connection_or.c 82 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442
  1. /* Copyright (c) 2001 Matej Pfajfar.
  2. * Copyright (c) 2001-2004, Roger Dingledine.
  3. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  4. * Copyright (c) 2007-2016, The Tor Project, Inc. */
  5. /* See LICENSE for licensing information */
  6. /**
  7. * \file connection_or.c
  8. * \brief Functions to handle OR connections, TLS handshaking, and
  9. * cells on the network.
  10. *
  11. * An or_connection_t is a subtype of connection_t (as implemented in
  12. * connection.c) that uses a TLS connection to send and receive cells on the
  13. * Tor network. (By sending and receiving cells connection_or.c, it cooperates
  14. * with channeltls.c to implement a the channel interface of channel.c.)
  15. *
  16. * Every OR connection has an underlying tortls_t object (as implemented in
  17. * tortls.c) which it uses as its TLS stream. It is responsible for
  18. * sending and receiving cells over that TLS.
  19. *
  20. * This module also implements the client side of the v3 Tor link handshake,
  21. **/
  22. #include "or.h"
  23. #include "buffers.h"
  24. /*
  25. * Define this so we get channel internal functions, since we're implementing
  26. * part of a subclass (channel_tls_t).
  27. */
  28. #define TOR_CHANNEL_INTERNAL_
  29. #include "channel.h"
  30. #include "channeltls.h"
  31. #include "circuitbuild.h"
  32. #include "circuitlist.h"
  33. #include "circuitstats.h"
  34. #include "command.h"
  35. #include "config.h"
  36. #include "connection.h"
  37. #include "connection_or.h"
  38. #include "control.h"
  39. #include "dirserv.h"
  40. #include "entrynodes.h"
  41. #include "geoip.h"
  42. #include "main.h"
  43. #include "link_handshake.h"
  44. #include "microdesc.h"
  45. #include "networkstatus.h"
  46. #include "nodelist.h"
  47. #include "reasons.h"
  48. #include "relay.h"
  49. #include "rephist.h"
  50. #include "router.h"
  51. #include "routerlist.h"
  52. #include "ext_orport.h"
  53. #include "scheduler.h"
  54. static int connection_tls_finish_handshake(or_connection_t *conn);
  55. static int connection_or_launch_v3_or_handshake(or_connection_t *conn);
  56. static int connection_or_process_cells_from_inbuf(or_connection_t *conn);
  57. static int connection_or_check_valid_tls_handshake(or_connection_t *conn,
  58. int started_here,
  59. char *digest_rcvd_out);
  60. static void connection_or_tls_renegotiated_cb(tor_tls_t *tls, void *_conn);
  61. static unsigned int
  62. connection_or_is_bad_for_new_circs(or_connection_t *or_conn);
  63. static void connection_or_mark_bad_for_new_circs(or_connection_t *or_conn);
  64. /*
  65. * Call this when changing connection state, so notifications to the owning
  66. * channel can be handled.
  67. */
  68. static void connection_or_change_state(or_connection_t *conn, uint8_t state);
  69. /**************************************************************/
  70. /** Map from identity digest of connected OR or desired OR to a connection_t
  71. * with that identity digest. If there is more than one such connection_t,
  72. * they form a linked list, with next_with_same_id as the next pointer. */
  73. static digestmap_t *orconn_identity_map = NULL;
  74. /** Global map between Extended ORPort identifiers and OR
  75. * connections. */
  76. static digestmap_t *orconn_ext_or_id_map = NULL;
  77. /** If conn is listed in orconn_identity_map, remove it, and clear
  78. * conn->identity_digest. Otherwise do nothing. */
  79. void
  80. connection_or_remove_from_identity_map(or_connection_t *conn)
  81. {
  82. or_connection_t *tmp;
  83. tor_assert(conn);
  84. if (!orconn_identity_map)
  85. return;
  86. tmp = digestmap_get(orconn_identity_map, conn->identity_digest);
  87. if (!tmp) {
  88. if (!tor_digest_is_zero(conn->identity_digest)) {
  89. log_warn(LD_BUG, "Didn't find connection '%s' on identity map when "
  90. "trying to remove it.",
  91. conn->nickname ? conn->nickname : "NULL");
  92. }
  93. return;
  94. }
  95. if (conn == tmp) {
  96. if (conn->next_with_same_id)
  97. digestmap_set(orconn_identity_map, conn->identity_digest,
  98. conn->next_with_same_id);
  99. else
  100. digestmap_remove(orconn_identity_map, conn->identity_digest);
  101. } else {
  102. while (tmp->next_with_same_id) {
  103. if (tmp->next_with_same_id == conn) {
  104. tmp->next_with_same_id = conn->next_with_same_id;
  105. break;
  106. }
  107. tmp = tmp->next_with_same_id;
  108. }
  109. }
  110. memset(conn->identity_digest, 0, DIGEST_LEN);
  111. conn->next_with_same_id = NULL;
  112. }
  113. /** Remove all entries from the identity-to-orconn map, and clear
  114. * all identities in OR conns.*/
  115. void
  116. connection_or_clear_identity_map(void)
  117. {
  118. smartlist_t *conns = get_connection_array();
  119. SMARTLIST_FOREACH(conns, connection_t *, conn,
  120. {
  121. if (conn->type == CONN_TYPE_OR) {
  122. or_connection_t *or_conn = TO_OR_CONN(conn);
  123. memset(or_conn->identity_digest, 0, DIGEST_LEN);
  124. or_conn->next_with_same_id = NULL;
  125. }
  126. });
  127. digestmap_free(orconn_identity_map, NULL);
  128. orconn_identity_map = NULL;
  129. }
  130. /** Change conn->identity_digest to digest, and add conn into
  131. * orconn_digest_map. */
  132. static void
  133. connection_or_set_identity_digest(or_connection_t *conn, const char *digest)
  134. {
  135. or_connection_t *tmp;
  136. tor_assert(conn);
  137. tor_assert(digest);
  138. if (!orconn_identity_map)
  139. orconn_identity_map = digestmap_new();
  140. if (tor_memeq(conn->identity_digest, digest, DIGEST_LEN))
  141. return;
  142. /* If the identity was set previously, remove the old mapping. */
  143. if (! tor_digest_is_zero(conn->identity_digest)) {
  144. connection_or_remove_from_identity_map(conn);
  145. if (conn->chan)
  146. channel_clear_identity_digest(TLS_CHAN_TO_BASE(conn->chan));
  147. }
  148. memcpy(conn->identity_digest, digest, DIGEST_LEN);
  149. /* If we're setting the ID to zero, don't add a mapping. */
  150. if (tor_digest_is_zero(digest))
  151. return;
  152. tmp = digestmap_set(orconn_identity_map, digest, conn);
  153. conn->next_with_same_id = tmp;
  154. /* Deal with channels */
  155. if (conn->chan)
  156. channel_set_identity_digest(TLS_CHAN_TO_BASE(conn->chan), digest);
  157. #if 1
  158. /* Testing code to check for bugs in representation. */
  159. for (; tmp; tmp = tmp->next_with_same_id) {
  160. tor_assert(tor_memeq(tmp->identity_digest, digest, DIGEST_LEN));
  161. tor_assert(tmp != conn);
  162. }
  163. #endif
  164. }
  165. /** Remove the Extended ORPort identifier of <b>conn</b> from the
  166. * global identifier list. Also, clear the identifier from the
  167. * connection itself. */
  168. void
  169. connection_or_remove_from_ext_or_id_map(or_connection_t *conn)
  170. {
  171. or_connection_t *tmp;
  172. if (!orconn_ext_or_id_map)
  173. return;
  174. if (!conn->ext_or_conn_id)
  175. return;
  176. tmp = digestmap_remove(orconn_ext_or_id_map, conn->ext_or_conn_id);
  177. if (!tor_digest_is_zero(conn->ext_or_conn_id))
  178. tor_assert(tmp == conn);
  179. memset(conn->ext_or_conn_id, 0, EXT_OR_CONN_ID_LEN);
  180. }
  181. /** Return the connection whose ext_or_id is <b>id</b>. Return NULL if no such
  182. * connection is found. */
  183. or_connection_t *
  184. connection_or_get_by_ext_or_id(const char *id)
  185. {
  186. if (!orconn_ext_or_id_map)
  187. return NULL;
  188. return digestmap_get(orconn_ext_or_id_map, id);
  189. }
  190. /** Deallocate the global Extended ORPort identifier list */
  191. void
  192. connection_or_clear_ext_or_id_map(void)
  193. {
  194. digestmap_free(orconn_ext_or_id_map, NULL);
  195. orconn_ext_or_id_map = NULL;
  196. }
  197. /** Creates an Extended ORPort identifier for <b>conn</b> and deposits
  198. * it into the global list of identifiers. */
  199. void
  200. connection_or_set_ext_or_identifier(or_connection_t *conn)
  201. {
  202. char random_id[EXT_OR_CONN_ID_LEN];
  203. or_connection_t *tmp;
  204. if (!orconn_ext_or_id_map)
  205. orconn_ext_or_id_map = digestmap_new();
  206. /* Remove any previous identifiers: */
  207. if (conn->ext_or_conn_id && !tor_digest_is_zero(conn->ext_or_conn_id))
  208. connection_or_remove_from_ext_or_id_map(conn);
  209. do {
  210. crypto_rand(random_id, sizeof(random_id));
  211. } while (digestmap_get(orconn_ext_or_id_map, random_id));
  212. if (!conn->ext_or_conn_id)
  213. conn->ext_or_conn_id = tor_malloc_zero(EXT_OR_CONN_ID_LEN);
  214. memcpy(conn->ext_or_conn_id, random_id, EXT_OR_CONN_ID_LEN);
  215. tmp = digestmap_set(orconn_ext_or_id_map, random_id, conn);
  216. tor_assert(!tmp);
  217. }
  218. /**************************************************************/
  219. /** Map from a string describing what a non-open OR connection was doing when
  220. * failed, to an intptr_t describing the count of connections that failed that
  221. * way. Note that the count is stored _as_ the pointer.
  222. */
  223. static strmap_t *broken_connection_counts;
  224. /** If true, do not record information in <b>broken_connection_counts</b>. */
  225. static int disable_broken_connection_counts = 0;
  226. /** Record that an OR connection failed in <b>state</b>. */
  227. static void
  228. note_broken_connection(const char *state)
  229. {
  230. void *ptr;
  231. intptr_t val;
  232. if (disable_broken_connection_counts)
  233. return;
  234. if (!broken_connection_counts)
  235. broken_connection_counts = strmap_new();
  236. ptr = strmap_get(broken_connection_counts, state);
  237. val = (intptr_t)ptr;
  238. val++;
  239. ptr = (void*)val;
  240. strmap_set(broken_connection_counts, state, ptr);
  241. }
  242. /** Forget all recorded states for failed connections. If
  243. * <b>stop_recording</b> is true, don't record any more. */
  244. void
  245. clear_broken_connection_map(int stop_recording)
  246. {
  247. if (broken_connection_counts)
  248. strmap_free(broken_connection_counts, NULL);
  249. broken_connection_counts = NULL;
  250. if (stop_recording)
  251. disable_broken_connection_counts = 1;
  252. }
  253. /** Write a detailed description the state of <b>orconn</b> into the
  254. * <b>buflen</b>-byte buffer at <b>buf</b>. This description includes not
  255. * only the OR-conn level state but also the TLS state. It's useful for
  256. * diagnosing broken handshakes. */
  257. static void
  258. connection_or_get_state_description(or_connection_t *orconn,
  259. char *buf, size_t buflen)
  260. {
  261. connection_t *conn = TO_CONN(orconn);
  262. const char *conn_state;
  263. char tls_state[256];
  264. tor_assert(conn->type == CONN_TYPE_OR || conn->type == CONN_TYPE_EXT_OR);
  265. conn_state = conn_state_to_string(conn->type, conn->state);
  266. tor_tls_get_state_description(orconn->tls, tls_state, sizeof(tls_state));
  267. tor_snprintf(buf, buflen, "%s with SSL state %s", conn_state, tls_state);
  268. }
  269. /** Record the current state of <b>orconn</b> as the state of a broken
  270. * connection. */
  271. static void
  272. connection_or_note_state_when_broken(or_connection_t *orconn)
  273. {
  274. char buf[256];
  275. if (disable_broken_connection_counts)
  276. return;
  277. connection_or_get_state_description(orconn, buf, sizeof(buf));
  278. log_info(LD_HANDSHAKE,"Connection died in state '%s'", buf);
  279. note_broken_connection(buf);
  280. }
  281. /** Helper type used to sort connection states and find the most frequent. */
  282. typedef struct broken_state_count_t {
  283. intptr_t count;
  284. const char *state;
  285. } broken_state_count_t;
  286. /** Helper function used to sort broken_state_count_t by frequency. */
  287. static int
  288. broken_state_count_compare(const void **a_ptr, const void **b_ptr)
  289. {
  290. const broken_state_count_t *a = *a_ptr, *b = *b_ptr;
  291. if (b->count < a->count)
  292. return -1;
  293. else if (b->count == a->count)
  294. return 0;
  295. else
  296. return 1;
  297. }
  298. /** Upper limit on the number of different states to report for connection
  299. * failure. */
  300. #define MAX_REASONS_TO_REPORT 10
  301. /** Report a list of the top states for failed OR connections at log level
  302. * <b>severity</b>, in log domain <b>domain</b>. */
  303. void
  304. connection_or_report_broken_states(int severity, int domain)
  305. {
  306. int total = 0;
  307. smartlist_t *items;
  308. if (!broken_connection_counts || disable_broken_connection_counts)
  309. return;
  310. items = smartlist_new();
  311. STRMAP_FOREACH(broken_connection_counts, state, void *, countptr) {
  312. broken_state_count_t *c = tor_malloc(sizeof(broken_state_count_t));
  313. c->count = (intptr_t)countptr;
  314. total += (int)c->count;
  315. c->state = state;
  316. smartlist_add(items, c);
  317. } STRMAP_FOREACH_END;
  318. smartlist_sort(items, broken_state_count_compare);
  319. tor_log(severity, domain, "%d connections have failed%s", total,
  320. smartlist_len(items) > MAX_REASONS_TO_REPORT ? ". Top reasons:" : ":");
  321. SMARTLIST_FOREACH_BEGIN(items, const broken_state_count_t *, c) {
  322. if (c_sl_idx > MAX_REASONS_TO_REPORT)
  323. break;
  324. tor_log(severity, domain,
  325. " %d connections died in state %s", (int)c->count, c->state);
  326. } SMARTLIST_FOREACH_END(c);
  327. SMARTLIST_FOREACH(items, broken_state_count_t *, c, tor_free(c));
  328. smartlist_free(items);
  329. }
  330. /** Call this to change or_connection_t states, so the owning channel_tls_t can
  331. * be notified.
  332. */
  333. static void
  334. connection_or_change_state(or_connection_t *conn, uint8_t state)
  335. {
  336. uint8_t old_state;
  337. tor_assert(conn);
  338. old_state = conn->base_.state;
  339. conn->base_.state = state;
  340. if (conn->chan)
  341. channel_tls_handle_state_change_on_orconn(conn->chan, conn,
  342. old_state, state);
  343. }
  344. /** Return the number of circuits using an or_connection_t; this used to
  345. * be an or_connection_t field, but it got moved to channel_t and we
  346. * shouldn't maintain two copies. */
  347. MOCK_IMPL(int,
  348. connection_or_get_num_circuits, (or_connection_t *conn))
  349. {
  350. tor_assert(conn);
  351. if (conn->chan) {
  352. return channel_num_circuits(TLS_CHAN_TO_BASE(conn->chan));
  353. } else return 0;
  354. }
  355. /**************************************************************/
  356. /** Pack the cell_t host-order structure <b>src</b> into network-order
  357. * in the buffer <b>dest</b>. See tor-spec.txt for details about the
  358. * wire format.
  359. *
  360. * Note that this function doesn't touch <b>dst</b>-\>next: the caller
  361. * should set it or clear it as appropriate.
  362. */
  363. void
  364. cell_pack(packed_cell_t *dst, const cell_t *src, int wide_circ_ids)
  365. {
  366. char *dest = dst->body;
  367. if (wide_circ_ids) {
  368. set_uint32(dest, htonl(src->circ_id));
  369. dest += 4;
  370. } else {
  371. set_uint16(dest, htons(src->circ_id));
  372. dest += 2;
  373. memset(dest+CELL_MAX_NETWORK_SIZE-2, 0, 2); /*make sure it's clear */
  374. }
  375. set_uint8(dest, src->command);
  376. memcpy(dest+1, src->payload, CELL_PAYLOAD_SIZE);
  377. }
  378. /** Unpack the network-order buffer <b>src</b> into a host-order
  379. * cell_t structure <b>dest</b>.
  380. */
  381. static void
  382. cell_unpack(cell_t *dest, const char *src, int wide_circ_ids)
  383. {
  384. if (wide_circ_ids) {
  385. dest->circ_id = ntohl(get_uint32(src));
  386. src += 4;
  387. } else {
  388. dest->circ_id = ntohs(get_uint16(src));
  389. src += 2;
  390. }
  391. dest->command = get_uint8(src);
  392. memcpy(dest->payload, src+1, CELL_PAYLOAD_SIZE);
  393. }
  394. /** Write the header of <b>cell</b> into the first VAR_CELL_MAX_HEADER_SIZE
  395. * bytes of <b>hdr_out</b>. Returns number of bytes used. */
  396. int
  397. var_cell_pack_header(const var_cell_t *cell, char *hdr_out, int wide_circ_ids)
  398. {
  399. int r;
  400. if (wide_circ_ids) {
  401. set_uint32(hdr_out, htonl(cell->circ_id));
  402. hdr_out += 4;
  403. r = VAR_CELL_MAX_HEADER_SIZE;
  404. } else {
  405. set_uint16(hdr_out, htons(cell->circ_id));
  406. hdr_out += 2;
  407. r = VAR_CELL_MAX_HEADER_SIZE - 2;
  408. }
  409. set_uint8(hdr_out, cell->command);
  410. set_uint16(hdr_out+1, htons(cell->payload_len));
  411. return r;
  412. }
  413. /** Allocate and return a new var_cell_t with <b>payload_len</b> bytes of
  414. * payload space. */
  415. var_cell_t *
  416. var_cell_new(uint16_t payload_len)
  417. {
  418. size_t size = STRUCT_OFFSET(var_cell_t, payload) + payload_len;
  419. var_cell_t *cell = tor_malloc_zero(size);
  420. cell->payload_len = payload_len;
  421. cell->command = 0;
  422. cell->circ_id = 0;
  423. return cell;
  424. }
  425. /**
  426. * Copy a var_cell_t
  427. */
  428. var_cell_t *
  429. var_cell_copy(const var_cell_t *src)
  430. {
  431. var_cell_t *copy = NULL;
  432. size_t size = 0;
  433. if (src != NULL) {
  434. size = STRUCT_OFFSET(var_cell_t, payload) + src->payload_len;
  435. copy = tor_malloc_zero(size);
  436. copy->payload_len = src->payload_len;
  437. copy->command = src->command;
  438. copy->circ_id = src->circ_id;
  439. memcpy(copy->payload, src->payload, copy->payload_len);
  440. }
  441. return copy;
  442. }
  443. /** Release all space held by <b>cell</b>. */
  444. void
  445. var_cell_free(var_cell_t *cell)
  446. {
  447. tor_free(cell);
  448. }
  449. /** We've received an EOF from <b>conn</b>. Mark it for close and return. */
  450. int
  451. connection_or_reached_eof(or_connection_t *conn)
  452. {
  453. tor_assert(conn);
  454. log_info(LD_OR,"OR connection reached EOF. Closing.");
  455. connection_or_close_normally(conn, 1);
  456. return 0;
  457. }
  458. /** Handle any new bytes that have come in on connection <b>conn</b>.
  459. * If conn is in 'open' state, hand it to
  460. * connection_or_process_cells_from_inbuf()
  461. * (else do nothing).
  462. */
  463. int
  464. connection_or_process_inbuf(or_connection_t *conn)
  465. {
  466. /** Don't let the inbuf of a nonopen OR connection grow beyond this many
  467. * bytes: it's either a broken client, a non-Tor client, or a DOS
  468. * attempt. */
  469. #define MAX_OR_INBUF_WHEN_NONOPEN 0
  470. int ret = 0;
  471. tor_assert(conn);
  472. switch (conn->base_.state) {
  473. case OR_CONN_STATE_PROXY_HANDSHAKING:
  474. ret = connection_read_proxy_handshake(TO_CONN(conn));
  475. /* start TLS after handshake completion, or deal with error */
  476. if (ret == 1) {
  477. tor_assert(TO_CONN(conn)->proxy_state == PROXY_CONNECTED);
  478. if (connection_tls_start_handshake(conn, 0) < 0)
  479. ret = -1;
  480. /* Touch the channel's active timestamp if there is one */
  481. if (conn->chan)
  482. channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
  483. }
  484. if (ret < 0) {
  485. connection_or_close_for_error(conn, 0);
  486. }
  487. return ret;
  488. case OR_CONN_STATE_TLS_SERVER_RENEGOTIATING:
  489. case OR_CONN_STATE_OPEN:
  490. case OR_CONN_STATE_OR_HANDSHAKING_V2:
  491. case OR_CONN_STATE_OR_HANDSHAKING_V3:
  492. return connection_or_process_cells_from_inbuf(conn);
  493. default:
  494. break; /* don't do anything */
  495. }
  496. /* This check was necessary with 0.2.2, when the TLS_SERVER_RENEGOTIATING
  497. * check would otherwise just let data accumulate. It serves no purpose
  498. * in 0.2.3.
  499. *
  500. * XXXX Remove this check once we verify that the above paragraph is
  501. * 100% true. */
  502. if (buf_datalen(conn->base_.inbuf) > MAX_OR_INBUF_WHEN_NONOPEN) {
  503. log_fn(LOG_PROTOCOL_WARN, LD_NET, "Accumulated too much data (%d bytes) "
  504. "on nonopen OR connection %s %s:%u in state %s; closing.",
  505. (int)buf_datalen(conn->base_.inbuf),
  506. connection_or_nonopen_was_started_here(conn) ? "to" : "from",
  507. conn->base_.address, conn->base_.port,
  508. conn_state_to_string(conn->base_.type, conn->base_.state));
  509. connection_or_close_for_error(conn, 0);
  510. ret = -1;
  511. }
  512. return ret;
  513. }
  514. /** Called whenever we have flushed some data on an or_conn: add more data
  515. * from active circuits. */
  516. int
  517. connection_or_flushed_some(or_connection_t *conn)
  518. {
  519. size_t datalen;
  520. /* The channel will want to update its estimated queue size */
  521. channel_update_xmit_queue_size(TLS_CHAN_TO_BASE(conn->chan));
  522. /* If we're under the low water mark, add cells until we're just over the
  523. * high water mark. */
  524. datalen = connection_get_outbuf_len(TO_CONN(conn));
  525. if (datalen < OR_CONN_LOWWATER) {
  526. /* Let the scheduler know */
  527. scheduler_channel_wants_writes(TLS_CHAN_TO_BASE(conn->chan));
  528. }
  529. return 0;
  530. }
  531. /** This is for channeltls.c to ask how many cells we could accept if
  532. * they were available. */
  533. ssize_t
  534. connection_or_num_cells_writeable(or_connection_t *conn)
  535. {
  536. size_t datalen, cell_network_size;
  537. ssize_t n = 0;
  538. tor_assert(conn);
  539. /*
  540. * If we're under the high water mark, we're potentially
  541. * writeable; note this is different from the calculation above
  542. * used to trigger when to start writing after we've stopped.
  543. */
  544. datalen = connection_get_outbuf_len(TO_CONN(conn));
  545. if (datalen < OR_CONN_HIGHWATER) {
  546. cell_network_size = get_cell_network_size(conn->wide_circ_ids);
  547. n = CEIL_DIV(OR_CONN_HIGHWATER - datalen, cell_network_size);
  548. }
  549. return n;
  550. }
  551. /** Connection <b>conn</b> has finished writing and has no bytes left on
  552. * its outbuf.
  553. *
  554. * Otherwise it's in state "open": stop writing and return.
  555. *
  556. * If <b>conn</b> is broken, mark it for close and return -1, else
  557. * return 0.
  558. */
  559. int
  560. connection_or_finished_flushing(or_connection_t *conn)
  561. {
  562. tor_assert(conn);
  563. assert_connection_ok(TO_CONN(conn),0);
  564. switch (conn->base_.state) {
  565. case OR_CONN_STATE_PROXY_HANDSHAKING:
  566. case OR_CONN_STATE_OPEN:
  567. case OR_CONN_STATE_OR_HANDSHAKING_V2:
  568. case OR_CONN_STATE_OR_HANDSHAKING_V3:
  569. break;
  570. default:
  571. log_err(LD_BUG,"Called in unexpected state %d.", conn->base_.state);
  572. tor_fragile_assert();
  573. return -1;
  574. }
  575. return 0;
  576. }
  577. /** Connected handler for OR connections: begin the TLS handshake.
  578. */
  579. int
  580. connection_or_finished_connecting(or_connection_t *or_conn)
  581. {
  582. const int proxy_type = or_conn->proxy_type;
  583. connection_t *conn;
  584. tor_assert(or_conn);
  585. conn = TO_CONN(or_conn);
  586. tor_assert(conn->state == OR_CONN_STATE_CONNECTING);
  587. log_debug(LD_HANDSHAKE,"OR connect() to router at %s:%u finished.",
  588. conn->address,conn->port);
  589. control_event_bootstrap(BOOTSTRAP_STATUS_HANDSHAKE, 0);
  590. if (proxy_type != PROXY_NONE) {
  591. /* start proxy handshake */
  592. if (connection_proxy_connect(conn, proxy_type) < 0) {
  593. connection_or_close_for_error(or_conn, 0);
  594. return -1;
  595. }
  596. connection_start_reading(conn);
  597. connection_or_change_state(or_conn, OR_CONN_STATE_PROXY_HANDSHAKING);
  598. return 0;
  599. }
  600. if (connection_tls_start_handshake(or_conn, 0) < 0) {
  601. /* TLS handshaking error of some kind. */
  602. connection_or_close_for_error(or_conn, 0);
  603. return -1;
  604. }
  605. return 0;
  606. }
  607. /** Called when we're about to finally unlink and free an OR connection:
  608. * perform necessary accounting and cleanup */
  609. void
  610. connection_or_about_to_close(or_connection_t *or_conn)
  611. {
  612. time_t now = time(NULL);
  613. connection_t *conn = TO_CONN(or_conn);
  614. /* Tell the controlling channel we're closed */
  615. if (or_conn->chan) {
  616. channel_closed(TLS_CHAN_TO_BASE(or_conn->chan));
  617. /*
  618. * NULL this out because the channel might hang around a little
  619. * longer before channel_run_cleanup() gets it.
  620. */
  621. or_conn->chan->conn = NULL;
  622. or_conn->chan = NULL;
  623. }
  624. /* Remember why we're closing this connection. */
  625. if (conn->state != OR_CONN_STATE_OPEN) {
  626. /* now mark things down as needed */
  627. if (connection_or_nonopen_was_started_here(or_conn)) {
  628. const or_options_t *options = get_options();
  629. connection_or_note_state_when_broken(or_conn);
  630. rep_hist_note_connect_failed(or_conn->identity_digest, now);
  631. entry_guard_register_connect_status(or_conn->identity_digest,0,
  632. !options->HTTPSProxy, now);
  633. if (conn->state >= OR_CONN_STATE_TLS_HANDSHAKING) {
  634. int reason = tls_error_to_orconn_end_reason(or_conn->tls_error);
  635. control_event_or_conn_status(or_conn, OR_CONN_EVENT_FAILED,
  636. reason);
  637. if (!authdir_mode_tests_reachability(options))
  638. control_event_bootstrap_problem(
  639. orconn_end_reason_to_control_string(reason),
  640. reason, or_conn);
  641. }
  642. }
  643. } else if (conn->hold_open_until_flushed) {
  644. /* We only set hold_open_until_flushed when we're intentionally
  645. * closing a connection. */
  646. rep_hist_note_disconnect(or_conn->identity_digest, now);
  647. control_event_or_conn_status(or_conn, OR_CONN_EVENT_CLOSED,
  648. tls_error_to_orconn_end_reason(or_conn->tls_error));
  649. } else if (!tor_digest_is_zero(or_conn->identity_digest)) {
  650. rep_hist_note_connection_died(or_conn->identity_digest, now);
  651. control_event_or_conn_status(or_conn, OR_CONN_EVENT_CLOSED,
  652. tls_error_to_orconn_end_reason(or_conn->tls_error));
  653. }
  654. }
  655. /** Return 1 if identity digest <b>id_digest</b> is known to be a
  656. * currently or recently running relay. Otherwise return 0. */
  657. int
  658. connection_or_digest_is_known_relay(const char *id_digest)
  659. {
  660. if (router_get_consensus_status_by_id(id_digest))
  661. return 1; /* It's in the consensus: "yes" */
  662. if (router_get_by_id_digest(id_digest))
  663. return 1; /* Not in the consensus, but we have a descriptor for
  664. * it. Probably it was in a recent consensus. "Yes". */
  665. return 0;
  666. }
  667. /** Set the per-conn read and write limits for <b>conn</b>. If it's a known
  668. * relay, we will rely on the global read and write buckets, so give it
  669. * per-conn limits that are big enough they'll never matter. But if it's
  670. * not a known relay, first check if we set PerConnBwRate/Burst, then
  671. * check if the consensus sets them, else default to 'big enough'.
  672. *
  673. * If <b>reset</b> is true, set the bucket to be full. Otherwise, just
  674. * clip the bucket if it happens to be <em>too</em> full.
  675. */
  676. static void
  677. connection_or_update_token_buckets_helper(or_connection_t *conn, int reset,
  678. const or_options_t *options)
  679. {
  680. int rate, burst; /* per-connection rate limiting params */
  681. if (connection_or_digest_is_known_relay(conn->identity_digest)) {
  682. /* It's in the consensus, or we have a descriptor for it meaning it
  683. * was probably in a recent consensus. It's a recognized relay:
  684. * give it full bandwidth. */
  685. rate = (int)options->BandwidthRate;
  686. burst = (int)options->BandwidthBurst;
  687. } else {
  688. /* Not a recognized relay. Squeeze it down based on the suggested
  689. * bandwidth parameters in the consensus, but allow local config
  690. * options to override. */
  691. rate = options->PerConnBWRate ? (int)options->PerConnBWRate :
  692. networkstatus_get_param(NULL, "perconnbwrate",
  693. (int)options->BandwidthRate, 1, INT32_MAX);
  694. burst = options->PerConnBWBurst ? (int)options->PerConnBWBurst :
  695. networkstatus_get_param(NULL, "perconnbwburst",
  696. (int)options->BandwidthBurst, 1, INT32_MAX);
  697. }
  698. conn->bandwidthrate = rate;
  699. conn->bandwidthburst = burst;
  700. if (reset) { /* set up the token buckets to be full */
  701. conn->read_bucket = conn->write_bucket = burst;
  702. return;
  703. }
  704. /* If the new token bucket is smaller, take out the extra tokens.
  705. * (If it's larger, don't -- the buckets can grow to reach the cap.) */
  706. if (conn->read_bucket > burst)
  707. conn->read_bucket = burst;
  708. if (conn->write_bucket > burst)
  709. conn->write_bucket = burst;
  710. }
  711. /** Either our set of relays or our per-conn rate limits have changed.
  712. * Go through all the OR connections and update their token buckets to make
  713. * sure they don't exceed their maximum values. */
  714. void
  715. connection_or_update_token_buckets(smartlist_t *conns,
  716. const or_options_t *options)
  717. {
  718. SMARTLIST_FOREACH(conns, connection_t *, conn,
  719. {
  720. if (connection_speaks_cells(conn))
  721. connection_or_update_token_buckets_helper(TO_OR_CONN(conn), 0, options);
  722. });
  723. }
  724. /** How long do we wait before killing non-canonical OR connections with no
  725. * circuits? In Tor versions up to 0.2.1.25 and 0.2.2.12-alpha, we waited 15
  726. * minutes before cancelling these connections, which caused fast relays to
  727. * accrue many many idle connections. Hopefully 3-4.5 minutes is low enough
  728. * that it kills most idle connections, without being so low that we cause
  729. * clients to bounce on and off.
  730. *
  731. * For canonical connections, the limit is higher, at 15-22.5 minutes.
  732. *
  733. * For each OR connection, we randomly add up to 50% extra to its idle_timeout
  734. * field, to avoid exposing when exactly the last circuit closed. Since we're
  735. * storing idle_timeout in a uint16_t, don't let these values get higher than
  736. * 12 hours or so without revising connection_or_set_canonical and/or expanding
  737. * idle_timeout.
  738. */
  739. #define IDLE_OR_CONN_TIMEOUT_NONCANONICAL 180
  740. #define IDLE_OR_CONN_TIMEOUT_CANONICAL 900
  741. /* Mark <b>or_conn</b> as canonical if <b>is_canonical</b> is set, and
  742. * non-canonical otherwise. Adjust idle_timeout accordingly.
  743. */
  744. void
  745. connection_or_set_canonical(or_connection_t *or_conn,
  746. int is_canonical)
  747. {
  748. const unsigned int timeout_base = is_canonical ?
  749. IDLE_OR_CONN_TIMEOUT_CANONICAL : IDLE_OR_CONN_TIMEOUT_NONCANONICAL;
  750. if (bool_eq(is_canonical, or_conn->is_canonical) &&
  751. or_conn->idle_timeout != 0) {
  752. /* Don't recalculate an existing idle_timeout unless the canonical
  753. * status changed. */
  754. return;
  755. }
  756. or_conn->is_canonical = !! is_canonical; /* force to a 1-bit boolean */
  757. or_conn->idle_timeout = timeout_base + crypto_rand_int(timeout_base / 2);
  758. }
  759. /** If we don't necessarily know the router we're connecting to, but we
  760. * have an addr/port/id_digest, then fill in as much as we can. Start
  761. * by checking to see if this describes a router we know.
  762. * <b>started_here</b> is 1 if we are the initiator of <b>conn</b> and
  763. * 0 if it's an incoming connection. */
  764. void
  765. connection_or_init_conn_from_address(or_connection_t *conn,
  766. const tor_addr_t *addr, uint16_t port,
  767. const char *id_digest,
  768. int started_here)
  769. {
  770. const node_t *r = node_get_by_id(id_digest);
  771. connection_or_set_identity_digest(conn, id_digest);
  772. connection_or_update_token_buckets_helper(conn, 1, get_options());
  773. conn->base_.port = port;
  774. tor_addr_copy(&conn->base_.addr, addr);
  775. tor_addr_copy(&conn->real_addr, addr);
  776. if (r) {
  777. tor_addr_port_t node_ap;
  778. node_get_pref_orport(r, &node_ap);
  779. /* XXXX proposal 186 is making this more complex. For now, a conn
  780. is canonical when it uses the _preferred_ address. */
  781. if (tor_addr_eq(&conn->base_.addr, &node_ap.addr))
  782. connection_or_set_canonical(conn, 1);
  783. if (!started_here) {
  784. /* Override the addr/port, so our log messages will make sense.
  785. * This is dangerous, since if we ever try looking up a conn by
  786. * its actual addr/port, we won't remember. Careful! */
  787. /* XXXX arma: this is stupid, and it's the reason we need real_addr
  788. * to track is_canonical properly. What requires it? */
  789. /* XXXX <arma> i believe the reason we did this, originally, is because
  790. * we wanted to log what OR a connection was to, and if we logged the
  791. * right IP address and port 56244, that wouldn't be as helpful. now we
  792. * log the "right" port too, so we know if it's moria1 or moria2.
  793. */
  794. tor_addr_copy(&conn->base_.addr, &node_ap.addr);
  795. conn->base_.port = node_ap.port;
  796. }
  797. conn->nickname = tor_strdup(node_get_nickname(r));
  798. tor_free(conn->base_.address);
  799. conn->base_.address = tor_addr_to_str_dup(&node_ap.addr);
  800. } else {
  801. conn->nickname = tor_malloc(HEX_DIGEST_LEN+2);
  802. conn->nickname[0] = '$';
  803. base16_encode(conn->nickname+1, HEX_DIGEST_LEN+1,
  804. conn->identity_digest, DIGEST_LEN);
  805. tor_free(conn->base_.address);
  806. conn->base_.address = tor_addr_to_str_dup(addr);
  807. }
  808. /*
  809. * We have to tell channeltls.c to update the channel marks (local, in
  810. * particular), since we may have changed the address.
  811. */
  812. if (conn->chan) {
  813. channel_tls_update_marks(conn);
  814. }
  815. }
  816. /** These just pass all the is_bad_for_new_circs manipulation on to
  817. * channel_t */
  818. static unsigned int
  819. connection_or_is_bad_for_new_circs(or_connection_t *or_conn)
  820. {
  821. tor_assert(or_conn);
  822. if (or_conn->chan)
  823. return channel_is_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan));
  824. else return 0;
  825. }
  826. static void
  827. connection_or_mark_bad_for_new_circs(or_connection_t *or_conn)
  828. {
  829. tor_assert(or_conn);
  830. if (or_conn->chan)
  831. channel_mark_bad_for_new_circs(TLS_CHAN_TO_BASE(or_conn->chan));
  832. }
  833. /** How old do we let a connection to an OR get before deciding it's
  834. * too old for new circuits? */
  835. #define TIME_BEFORE_OR_CONN_IS_TOO_OLD (60*60*24*7)
  836. /** Given the head of the linked list for all the or_connections with a given
  837. * identity, set elements of that list as is_bad_for_new_circs as
  838. * appropriate. Helper for connection_or_set_bad_connections().
  839. *
  840. * Specifically, we set the is_bad_for_new_circs flag on:
  841. * - all connections if <b>force</b> is true.
  842. * - all connections that are too old.
  843. * - all open non-canonical connections for which a canonical connection
  844. * exists to the same router.
  845. * - all open canonical connections for which a 'better' canonical
  846. * connection exists to the same router.
  847. * - all open non-canonical connections for which a 'better' non-canonical
  848. * connection exists to the same router at the same address.
  849. *
  850. * See channel_is_better() in channel.c for our idea of what makes one OR
  851. * connection better than another.
  852. */
  853. static void
  854. connection_or_group_set_badness(or_connection_t *head, int force)
  855. {
  856. or_connection_t *or_conn = NULL, *best = NULL;
  857. int n_old = 0, n_inprogress = 0, n_canonical = 0, n_other = 0;
  858. time_t now = time(NULL);
  859. /* Pass 1: expire everything that's old, and see what the status of
  860. * everything else is. */
  861. for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
  862. if (or_conn->base_.marked_for_close ||
  863. connection_or_is_bad_for_new_circs(or_conn))
  864. continue;
  865. if (force ||
  866. or_conn->base_.timestamp_created + TIME_BEFORE_OR_CONN_IS_TOO_OLD
  867. < now) {
  868. log_info(LD_OR,
  869. "Marking OR conn to %s:%d as too old for new circuits "
  870. "(fd "TOR_SOCKET_T_FORMAT", %d secs old).",
  871. or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
  872. (int)(now - or_conn->base_.timestamp_created));
  873. connection_or_mark_bad_for_new_circs(or_conn);
  874. }
  875. if (connection_or_is_bad_for_new_circs(or_conn)) {
  876. ++n_old;
  877. } else if (or_conn->base_.state != OR_CONN_STATE_OPEN) {
  878. ++n_inprogress;
  879. } else if (or_conn->is_canonical) {
  880. ++n_canonical;
  881. } else {
  882. ++n_other;
  883. }
  884. }
  885. /* Pass 2: We know how about how good the best connection is.
  886. * expire everything that's worse, and find the very best if we can. */
  887. for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
  888. if (or_conn->base_.marked_for_close ||
  889. connection_or_is_bad_for_new_circs(or_conn))
  890. continue; /* This one doesn't need to be marked bad. */
  891. if (or_conn->base_.state != OR_CONN_STATE_OPEN)
  892. continue; /* Don't mark anything bad until we have seen what happens
  893. * when the connection finishes. */
  894. if (n_canonical && !or_conn->is_canonical) {
  895. /* We have at least one open canonical connection to this router,
  896. * and this one is open but not canonical. Mark it bad. */
  897. log_info(LD_OR,
  898. "Marking OR conn to %s:%d as unsuitable for new circuits: "
  899. "(fd "TOR_SOCKET_T_FORMAT", %d secs old). It is not "
  900. "canonical, and we have another connection to that OR that is.",
  901. or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
  902. (int)(now - or_conn->base_.timestamp_created));
  903. connection_or_mark_bad_for_new_circs(or_conn);
  904. continue;
  905. }
  906. if (!best ||
  907. channel_is_better(now,
  908. TLS_CHAN_TO_BASE(or_conn->chan),
  909. TLS_CHAN_TO_BASE(best->chan),
  910. 0)) {
  911. best = or_conn;
  912. }
  913. }
  914. if (!best)
  915. return;
  916. /* Pass 3: One connection to OR is best. If it's canonical, mark as bad
  917. * every other open connection. If it's non-canonical, mark as bad
  918. * every other open connection to the same address.
  919. *
  920. * XXXX This isn't optimal; if we have connections to an OR at multiple
  921. * addresses, we'd like to pick the best _for each address_, and mark as
  922. * bad every open connection that isn't best for its address. But this
  923. * can only occur in cases where the other OR is old (so we have no
  924. * canonical connection to it), or where all the connections to the OR are
  925. * at noncanonical addresses and we have no good direct connection (which
  926. * means we aren't at risk of attaching circuits to it anyway). As
  927. * 0.1.2.x dies out, the first case will go away, and the second one is
  928. * "mostly harmless", so a fix can wait until somebody is bored.
  929. */
  930. for (or_conn = head; or_conn; or_conn = or_conn->next_with_same_id) {
  931. if (or_conn->base_.marked_for_close ||
  932. connection_or_is_bad_for_new_circs(or_conn) ||
  933. or_conn->base_.state != OR_CONN_STATE_OPEN)
  934. continue;
  935. if (or_conn != best &&
  936. channel_is_better(now,
  937. TLS_CHAN_TO_BASE(best->chan),
  938. TLS_CHAN_TO_BASE(or_conn->chan), 1)) {
  939. /* This isn't the best conn, _and_ the best conn is better than it,
  940. even when we're being forgiving. */
  941. if (best->is_canonical) {
  942. log_info(LD_OR,
  943. "Marking OR conn to %s:%d as unsuitable for new circuits: "
  944. "(fd "TOR_SOCKET_T_FORMAT", %d secs old). "
  945. "We have a better canonical one "
  946. "(fd "TOR_SOCKET_T_FORMAT"; %d secs old).",
  947. or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
  948. (int)(now - or_conn->base_.timestamp_created),
  949. best->base_.s, (int)(now - best->base_.timestamp_created));
  950. connection_or_mark_bad_for_new_circs(or_conn);
  951. } else if (!tor_addr_compare(&or_conn->real_addr,
  952. &best->real_addr, CMP_EXACT)) {
  953. log_info(LD_OR,
  954. "Marking OR conn to %s:%d as unsuitable for new circuits: "
  955. "(fd "TOR_SOCKET_T_FORMAT", %d secs old). We have a better "
  956. "one with the "
  957. "same address (fd "TOR_SOCKET_T_FORMAT"; %d secs old).",
  958. or_conn->base_.address, or_conn->base_.port, or_conn->base_.s,
  959. (int)(now - or_conn->base_.timestamp_created),
  960. best->base_.s, (int)(now - best->base_.timestamp_created));
  961. connection_or_mark_bad_for_new_circs(or_conn);
  962. }
  963. }
  964. }
  965. }
  966. /** Go through all the OR connections (or if <b>digest</b> is non-NULL, just
  967. * the OR connections with that digest), and set the is_bad_for_new_circs
  968. * flag based on the rules in connection_or_group_set_badness() (or just
  969. * always set it if <b>force</b> is true).
  970. */
  971. void
  972. connection_or_set_bad_connections(const char *digest, int force)
  973. {
  974. if (!orconn_identity_map)
  975. return;
  976. DIGESTMAP_FOREACH(orconn_identity_map, identity, or_connection_t *, conn) {
  977. if (!digest || tor_memeq(digest, conn->identity_digest, DIGEST_LEN))
  978. connection_or_group_set_badness(conn, force);
  979. } DIGESTMAP_FOREACH_END;
  980. }
  981. /** <b>conn</b> is in the 'connecting' state, and it failed to complete
  982. * a TCP connection. Send notifications appropriately.
  983. *
  984. * <b>reason</b> specifies the or_conn_end_reason for the failure;
  985. * <b>msg</b> specifies the strerror-style error message.
  986. */
  987. void
  988. connection_or_connect_failed(or_connection_t *conn,
  989. int reason, const char *msg)
  990. {
  991. control_event_or_conn_status(conn, OR_CONN_EVENT_FAILED, reason);
  992. if (!authdir_mode_tests_reachability(get_options()))
  993. control_event_bootstrap_problem(msg, reason, conn);
  994. }
  995. /** <b>conn</b> got an error in connection_handle_read_impl() or
  996. * connection_handle_write_impl() and is going to die soon.
  997. *
  998. * <b>reason</b> specifies the or_conn_end_reason for the failure;
  999. * <b>msg</b> specifies the strerror-style error message.
  1000. */
  1001. void
  1002. connection_or_notify_error(or_connection_t *conn,
  1003. int reason, const char *msg)
  1004. {
  1005. channel_t *chan;
  1006. tor_assert(conn);
  1007. /* If we're connecting, call connect_failed() too */
  1008. if (TO_CONN(conn)->state == OR_CONN_STATE_CONNECTING)
  1009. connection_or_connect_failed(conn, reason, msg);
  1010. /* Tell the controlling channel if we have one */
  1011. if (conn->chan) {
  1012. chan = TLS_CHAN_TO_BASE(conn->chan);
  1013. /* Don't transition if we're already in closing, closed or error */
  1014. if (!CHANNEL_CONDEMNED(chan)) {
  1015. channel_close_for_error(chan);
  1016. }
  1017. }
  1018. /* No need to mark for error because connection.c is about to do that */
  1019. }
  1020. /** Launch a new OR connection to <b>addr</b>:<b>port</b> and expect to
  1021. * handshake with an OR with identity digest <b>id_digest</b>. Optionally,
  1022. * pass in a pointer to a channel using this connection.
  1023. *
  1024. * If <b>id_digest</b> is me, do nothing. If we're already connected to it,
  1025. * return that connection. If the connect() is in progress, set the
  1026. * new conn's state to 'connecting' and return it. If connect() succeeds,
  1027. * call connection_tls_start_handshake() on it.
  1028. *
  1029. * This function is called from router_retry_connections(), for
  1030. * ORs connecting to ORs, and circuit_establish_circuit(), for
  1031. * OPs connecting to ORs.
  1032. *
  1033. * Return the launched conn, or NULL if it failed.
  1034. */
  1035. MOCK_IMPL(or_connection_t *,
  1036. connection_or_connect, (const tor_addr_t *_addr, uint16_t port,
  1037. const char *id_digest, channel_tls_t *chan))
  1038. {
  1039. or_connection_t *conn;
  1040. const or_options_t *options = get_options();
  1041. int socket_error = 0;
  1042. tor_addr_t addr;
  1043. int r;
  1044. tor_addr_t proxy_addr;
  1045. uint16_t proxy_port;
  1046. int proxy_type;
  1047. tor_assert(_addr);
  1048. tor_assert(id_digest);
  1049. tor_addr_copy(&addr, _addr);
  1050. if (server_mode(options) && router_digest_is_me(id_digest)) {
  1051. log_info(LD_PROTOCOL,"Client asked me to connect to myself. Refusing.");
  1052. return NULL;
  1053. }
  1054. conn = or_connection_new(CONN_TYPE_OR, tor_addr_family(&addr));
  1055. /*
  1056. * Set up conn so it's got all the data we need to remember for channels
  1057. *
  1058. * This stuff needs to happen before connection_or_init_conn_from_address()
  1059. * so connection_or_set_identity_digest() and such know where to look to
  1060. * keep the channel up to date.
  1061. */
  1062. conn->chan = chan;
  1063. chan->conn = conn;
  1064. connection_or_init_conn_from_address(conn, &addr, port, id_digest, 1);
  1065. connection_or_change_state(conn, OR_CONN_STATE_CONNECTING);
  1066. control_event_or_conn_status(conn, OR_CONN_EVENT_LAUNCHED, 0);
  1067. conn->is_outgoing = 1;
  1068. /* If we are using a proxy server, find it and use it. */
  1069. r = get_proxy_addrport(&proxy_addr, &proxy_port, &proxy_type, TO_CONN(conn));
  1070. if (r == 0) {
  1071. conn->proxy_type = proxy_type;
  1072. if (proxy_type != PROXY_NONE) {
  1073. tor_addr_copy(&addr, &proxy_addr);
  1074. port = proxy_port;
  1075. conn->base_.proxy_state = PROXY_INFANT;
  1076. }
  1077. } else {
  1078. /* get_proxy_addrport() might fail if we have a Bridge line that
  1079. references a transport, but no ClientTransportPlugin lines
  1080. defining its transport proxy. If this is the case, let's try to
  1081. output a useful log message to the user. */
  1082. const char *transport_name =
  1083. find_transport_name_by_bridge_addrport(&TO_CONN(conn)->addr,
  1084. TO_CONN(conn)->port);
  1085. if (transport_name) {
  1086. log_warn(LD_GENERAL, "We were supposed to connect to bridge '%s' "
  1087. "using pluggable transport '%s', but we can't find a pluggable "
  1088. "transport proxy supporting '%s'. This can happen if you "
  1089. "haven't provided a ClientTransportPlugin line, or if "
  1090. "your pluggable transport proxy stopped running.",
  1091. fmt_addrport(&TO_CONN(conn)->addr, TO_CONN(conn)->port),
  1092. transport_name, transport_name);
  1093. control_event_bootstrap_problem(
  1094. "Can't connect to bridge",
  1095. END_OR_CONN_REASON_PT_MISSING,
  1096. conn);
  1097. } else {
  1098. log_warn(LD_GENERAL, "Tried to connect to '%s' through a proxy, but "
  1099. "the proxy address could not be found.",
  1100. fmt_addrport(&TO_CONN(conn)->addr, TO_CONN(conn)->port));
  1101. }
  1102. connection_free(TO_CONN(conn));
  1103. return NULL;
  1104. }
  1105. switch (connection_connect(TO_CONN(conn), conn->base_.address,
  1106. &addr, port, &socket_error)) {
  1107. case -1:
  1108. /* We failed to establish a connection probably because of a local
  1109. * error. No need to blame the guard in this case. Notify the networking
  1110. * system of this failure. */
  1111. connection_or_connect_failed(conn,
  1112. errno_to_orconn_end_reason(socket_error),
  1113. tor_socket_strerror(socket_error));
  1114. connection_free(TO_CONN(conn));
  1115. return NULL;
  1116. case 0:
  1117. connection_watch_events(TO_CONN(conn), READ_EVENT | WRITE_EVENT);
  1118. /* writable indicates finish, readable indicates broken link,
  1119. error indicates broken link on windows */
  1120. return conn;
  1121. /* case 1: fall through */
  1122. }
  1123. if (connection_or_finished_connecting(conn) < 0) {
  1124. /* already marked for close */
  1125. return NULL;
  1126. }
  1127. return conn;
  1128. }
  1129. /** Mark orconn for close and transition the associated channel, if any, to
  1130. * the closing state.
  1131. *
  1132. * It's safe to call this and connection_or_close_for_error() any time, and
  1133. * channel layer will treat it as a connection closing for reasons outside
  1134. * its control, like the remote end closing it. It can also be a local
  1135. * reason that's specific to connection_t/or_connection_t rather than
  1136. * the channel mechanism, such as expiration of old connections in
  1137. * run_connection_housekeeping(). If you want to close a channel_t
  1138. * from somewhere that logically works in terms of generic channels
  1139. * rather than connections, use channel_mark_for_close(); see also
  1140. * the comment on that function in channel.c.
  1141. */
  1142. void
  1143. connection_or_close_normally(or_connection_t *orconn, int flush)
  1144. {
  1145. channel_t *chan = NULL;
  1146. tor_assert(orconn);
  1147. if (flush) connection_mark_and_flush_internal(TO_CONN(orconn));
  1148. else connection_mark_for_close_internal(TO_CONN(orconn));
  1149. if (orconn->chan) {
  1150. chan = TLS_CHAN_TO_BASE(orconn->chan);
  1151. /* Don't transition if we're already in closing, closed or error */
  1152. if (!CHANNEL_CONDEMNED(chan)) {
  1153. channel_close_from_lower_layer(chan);
  1154. }
  1155. }
  1156. }
  1157. /** Mark orconn for close and transition the associated channel, if any, to
  1158. * the error state.
  1159. */
  1160. MOCK_IMPL(void,
  1161. connection_or_close_for_error,(or_connection_t *orconn, int flush))
  1162. {
  1163. channel_t *chan = NULL;
  1164. tor_assert(orconn);
  1165. if (flush) connection_mark_and_flush_internal(TO_CONN(orconn));
  1166. else connection_mark_for_close_internal(TO_CONN(orconn));
  1167. if (orconn->chan) {
  1168. chan = TLS_CHAN_TO_BASE(orconn->chan);
  1169. /* Don't transition if we're already in closing, closed or error */
  1170. if (!CHANNEL_CONDEMNED(chan)) {
  1171. channel_close_for_error(chan);
  1172. }
  1173. }
  1174. }
  1175. /** Begin the tls handshake with <b>conn</b>. <b>receiving</b> is 0 if
  1176. * we initiated the connection, else it's 1.
  1177. *
  1178. * Assign a new tls object to conn->tls, begin reading on <b>conn</b>, and
  1179. * pass <b>conn</b> to connection_tls_continue_handshake().
  1180. *
  1181. * Return -1 if <b>conn</b> is broken, else return 0.
  1182. */
  1183. MOCK_IMPL(int,
  1184. connection_tls_start_handshake,(or_connection_t *conn, int receiving))
  1185. {
  1186. channel_listener_t *chan_listener;
  1187. channel_t *chan;
  1188. /* Incoming connections will need a new channel passed to the
  1189. * channel_tls_listener */
  1190. if (receiving) {
  1191. /* It shouldn't already be set */
  1192. tor_assert(!(conn->chan));
  1193. chan_listener = channel_tls_get_listener();
  1194. if (!chan_listener) {
  1195. chan_listener = channel_tls_start_listener();
  1196. command_setup_listener(chan_listener);
  1197. }
  1198. chan = channel_tls_handle_incoming(conn);
  1199. channel_listener_queue_incoming(chan_listener, chan);
  1200. }
  1201. connection_or_change_state(conn, OR_CONN_STATE_TLS_HANDSHAKING);
  1202. tor_assert(!conn->tls);
  1203. conn->tls = tor_tls_new(conn->base_.s, receiving);
  1204. if (!conn->tls) {
  1205. log_warn(LD_BUG,"tor_tls_new failed. Closing.");
  1206. return -1;
  1207. }
  1208. tor_tls_set_logged_address(conn->tls, // XXX client and relay?
  1209. escaped_safe_str(conn->base_.address));
  1210. connection_start_reading(TO_CONN(conn));
  1211. log_debug(LD_HANDSHAKE,"starting TLS handshake on fd "TOR_SOCKET_T_FORMAT,
  1212. conn->base_.s);
  1213. note_crypto_pk_op(receiving ? TLS_HANDSHAKE_S : TLS_HANDSHAKE_C);
  1214. if (connection_tls_continue_handshake(conn) < 0)
  1215. return -1;
  1216. return 0;
  1217. }
  1218. /** Block all future attempts to renegotiate on 'conn' */
  1219. void
  1220. connection_or_block_renegotiation(or_connection_t *conn)
  1221. {
  1222. tor_tls_t *tls = conn->tls;
  1223. if (!tls)
  1224. return;
  1225. tor_tls_set_renegotiate_callback(tls, NULL, NULL);
  1226. tor_tls_block_renegotiation(tls);
  1227. }
  1228. /** Invoked on the server side from inside tor_tls_read() when the server
  1229. * gets a successful TLS renegotiation from the client. */
  1230. static void
  1231. connection_or_tls_renegotiated_cb(tor_tls_t *tls, void *_conn)
  1232. {
  1233. or_connection_t *conn = _conn;
  1234. (void)tls;
  1235. /* Don't invoke this again. */
  1236. connection_or_block_renegotiation(conn);
  1237. if (connection_tls_finish_handshake(conn) < 0) {
  1238. /* XXXX_TLS double-check that it's ok to do this from inside read. */
  1239. /* XXXX_TLS double-check that this verifies certificates. */
  1240. connection_or_close_for_error(conn, 0);
  1241. }
  1242. }
  1243. /** Move forward with the tls handshake. If it finishes, hand
  1244. * <b>conn</b> to connection_tls_finish_handshake().
  1245. *
  1246. * Return -1 if <b>conn</b> is broken, else return 0.
  1247. */
  1248. int
  1249. connection_tls_continue_handshake(or_connection_t *conn)
  1250. {
  1251. int result;
  1252. check_no_tls_errors();
  1253. tor_assert(conn->base_.state == OR_CONN_STATE_TLS_HANDSHAKING);
  1254. // log_notice(LD_OR, "Continue handshake with %p", conn->tls);
  1255. result = tor_tls_handshake(conn->tls);
  1256. // log_notice(LD_OR, "Result: %d", result);
  1257. switch (result) {
  1258. CASE_TOR_TLS_ERROR_ANY:
  1259. log_info(LD_OR,"tls error [%s]. breaking connection.",
  1260. tor_tls_err_to_string(result));
  1261. return -1;
  1262. case TOR_TLS_DONE:
  1263. if (! tor_tls_used_v1_handshake(conn->tls)) {
  1264. if (!tor_tls_is_server(conn->tls)) {
  1265. tor_assert(conn->base_.state == OR_CONN_STATE_TLS_HANDSHAKING);
  1266. return connection_or_launch_v3_or_handshake(conn);
  1267. } else {
  1268. /* v2/v3 handshake, but we are not a client. */
  1269. log_debug(LD_OR, "Done with initial SSL handshake (server-side). "
  1270. "Expecting renegotiation or VERSIONS cell");
  1271. tor_tls_set_renegotiate_callback(conn->tls,
  1272. connection_or_tls_renegotiated_cb,
  1273. conn);
  1274. connection_or_change_state(conn,
  1275. OR_CONN_STATE_TLS_SERVER_RENEGOTIATING);
  1276. connection_stop_writing(TO_CONN(conn));
  1277. connection_start_reading(TO_CONN(conn));
  1278. return 0;
  1279. }
  1280. }
  1281. tor_assert(tor_tls_is_server(conn->tls));
  1282. return connection_tls_finish_handshake(conn);
  1283. case TOR_TLS_WANTWRITE:
  1284. connection_start_writing(TO_CONN(conn));
  1285. log_debug(LD_OR,"wanted write");
  1286. return 0;
  1287. case TOR_TLS_WANTREAD: /* handshaking conns are *always* reading */
  1288. log_debug(LD_OR,"wanted read");
  1289. return 0;
  1290. case TOR_TLS_CLOSE:
  1291. log_info(LD_OR,"tls closed. breaking connection.");
  1292. return -1;
  1293. }
  1294. return 0;
  1295. }
  1296. /** Return 1 if we initiated this connection, or 0 if it started
  1297. * out as an incoming connection.
  1298. */
  1299. int
  1300. connection_or_nonopen_was_started_here(or_connection_t *conn)
  1301. {
  1302. tor_assert(conn->base_.type == CONN_TYPE_OR ||
  1303. conn->base_.type == CONN_TYPE_EXT_OR);
  1304. if (!conn->tls)
  1305. return 1; /* it's still in proxy states or something */
  1306. if (conn->handshake_state)
  1307. return conn->handshake_state->started_here;
  1308. return !tor_tls_is_server(conn->tls);
  1309. }
  1310. /** <b>Conn</b> just completed its handshake. Return 0 if all is well, and
  1311. * return -1 if they are lying, broken, or otherwise something is wrong.
  1312. *
  1313. * If we initiated this connection (<b>started_here</b> is true), make sure
  1314. * the other side sent a correctly formed certificate. If I initiated the
  1315. * connection, make sure it's the right relay by checking the certificate.
  1316. *
  1317. * Otherwise (if we _didn't_ initiate this connection), it's okay for
  1318. * the certificate to be weird or absent.
  1319. *
  1320. * If we return 0, and the certificate is as expected, write a hash of the
  1321. * identity key into <b>digest_rcvd_out</b>, which must have DIGEST_LEN
  1322. * space in it.
  1323. * If the certificate is invalid or missing on an incoming connection,
  1324. * we return 0 and set <b>digest_rcvd_out</b> to DIGEST_LEN NUL bytes.
  1325. * (If we return -1, the contents of this buffer are undefined.)
  1326. *
  1327. * As side effects,
  1328. * 1) Set conn->circ_id_type according to tor-spec.txt.
  1329. * 2) If we're an authdirserver and we initiated the connection: drop all
  1330. * descriptors that claim to be on that IP/port but that aren't
  1331. * this relay; and note that this relay is reachable.
  1332. * 3) If this is a bridge and we didn't configure its identity
  1333. * fingerprint, remember the keyid we just learned.
  1334. */
  1335. static int
  1336. connection_or_check_valid_tls_handshake(or_connection_t *conn,
  1337. int started_here,
  1338. char *digest_rcvd_out)
  1339. {
  1340. crypto_pk_t *identity_rcvd=NULL;
  1341. const or_options_t *options = get_options();
  1342. int severity = server_mode(options) ? LOG_PROTOCOL_WARN : LOG_WARN;
  1343. const char *safe_address =
  1344. started_here ? conn->base_.address :
  1345. safe_str_client(conn->base_.address);
  1346. const char *conn_type = started_here ? "outgoing" : "incoming";
  1347. int has_cert = 0;
  1348. check_no_tls_errors();
  1349. has_cert = tor_tls_peer_has_cert(conn->tls);
  1350. if (started_here && !has_cert) {
  1351. log_info(LD_HANDSHAKE,"Tried connecting to router at %s:%d, but it didn't "
  1352. "send a cert! Closing.",
  1353. safe_address, conn->base_.port);
  1354. return -1;
  1355. } else if (!has_cert) {
  1356. log_debug(LD_HANDSHAKE,"Got incoming connection with no certificate. "
  1357. "That's ok.");
  1358. }
  1359. check_no_tls_errors();
  1360. if (has_cert) {
  1361. int v = tor_tls_verify(started_here?severity:LOG_INFO,
  1362. conn->tls, &identity_rcvd);
  1363. if (started_here && v<0) {
  1364. log_fn(severity,LD_HANDSHAKE,"Tried connecting to router at %s:%d: It"
  1365. " has a cert but it's invalid. Closing.",
  1366. safe_address, conn->base_.port);
  1367. return -1;
  1368. } else if (v<0) {
  1369. log_info(LD_HANDSHAKE,"Incoming connection gave us an invalid cert "
  1370. "chain; ignoring.");
  1371. } else {
  1372. log_debug(LD_HANDSHAKE,
  1373. "The certificate seems to be valid on %s connection "
  1374. "with %s:%d", conn_type, safe_address, conn->base_.port);
  1375. }
  1376. check_no_tls_errors();
  1377. }
  1378. if (identity_rcvd) {
  1379. crypto_pk_get_digest(identity_rcvd, digest_rcvd_out);
  1380. } else {
  1381. memset(digest_rcvd_out, 0, DIGEST_LEN);
  1382. }
  1383. tor_assert(conn->chan);
  1384. channel_set_circid_type(TLS_CHAN_TO_BASE(conn->chan), identity_rcvd, 1);
  1385. crypto_pk_free(identity_rcvd);
  1386. if (started_here)
  1387. return connection_or_client_learned_peer_id(conn,
  1388. (const uint8_t*)digest_rcvd_out);
  1389. return 0;
  1390. }
  1391. /** Called when we (as a connection initiator) have definitively,
  1392. * authenticatedly, learned that ID of the Tor instance on the other
  1393. * side of <b>conn</b> is <b>peer_id</b>. For v1 and v2 handshakes,
  1394. * this is right after we get a certificate chain in a TLS handshake
  1395. * or renegotiation. For v3 handshakes, this is right after we get a
  1396. * certificate chain in a CERTS cell.
  1397. *
  1398. * If we did not know the ID before, record the one we got.
  1399. *
  1400. * If we wanted an ID, but we didn't get the one we expected, log a message
  1401. * and return -1.
  1402. * On relays:
  1403. * - log a protocol warning whenever the fingerprints don't match;
  1404. * On clients:
  1405. * - if a relay's fingerprint doesn't match, log a warning;
  1406. * - if we don't have updated relay fingerprints from a recent consensus, and
  1407. * a fallback directory mirror's hard-coded fingerprint has changed, log an
  1408. * info explaining that we will try another fallback.
  1409. *
  1410. * If we're testing reachability, remember what we learned.
  1411. *
  1412. * Return 0 on success, -1 on failure.
  1413. */
  1414. int
  1415. connection_or_client_learned_peer_id(or_connection_t *conn,
  1416. const uint8_t *peer_id)
  1417. {
  1418. const or_options_t *options = get_options();
  1419. if (tor_digest_is_zero(conn->identity_digest)) {
  1420. connection_or_set_identity_digest(conn, (const char*)peer_id);
  1421. tor_free(conn->nickname);
  1422. conn->nickname = tor_malloc(HEX_DIGEST_LEN+2);
  1423. conn->nickname[0] = '$';
  1424. base16_encode(conn->nickname+1, HEX_DIGEST_LEN+1,
  1425. conn->identity_digest, DIGEST_LEN);
  1426. log_info(LD_HANDSHAKE, "Connected to router %s at %s:%d without knowing "
  1427. "its key. Hoping for the best.",
  1428. conn->nickname, conn->base_.address, conn->base_.port);
  1429. /* if it's a bridge and we didn't know its identity fingerprint, now
  1430. * we do -- remember it for future attempts. */
  1431. learned_router_identity(&conn->base_.addr, conn->base_.port,
  1432. (const char*)peer_id);
  1433. }
  1434. if (tor_memneq(peer_id, conn->identity_digest, DIGEST_LEN)) {
  1435. /* I was aiming for a particular digest. I didn't get it! */
  1436. char seen[HEX_DIGEST_LEN+1];
  1437. char expected[HEX_DIGEST_LEN+1];
  1438. base16_encode(seen, sizeof(seen), (const char*)peer_id, DIGEST_LEN);
  1439. base16_encode(expected, sizeof(expected), conn->identity_digest,
  1440. DIGEST_LEN);
  1441. const int using_hardcoded_fingerprints =
  1442. !networkstatus_get_reasonably_live_consensus(time(NULL),
  1443. usable_consensus_flavor());
  1444. const int is_fallback_fingerprint = router_digest_is_fallback_dir(
  1445. conn->identity_digest);
  1446. const int is_authority_fingerprint = router_digest_is_trusted_dir(
  1447. conn->identity_digest);
  1448. int severity;
  1449. const char *extra_log = "";
  1450. if (server_mode(options)) {
  1451. severity = LOG_PROTOCOL_WARN;
  1452. } else {
  1453. if (using_hardcoded_fingerprints) {
  1454. /* We need to do the checks in this order, because the list of
  1455. * fallbacks includes the list of authorities */
  1456. if (is_authority_fingerprint) {
  1457. severity = LOG_WARN;
  1458. } else if (is_fallback_fingerprint) {
  1459. /* we expect a small number of fallbacks to change from their
  1460. * hard-coded fingerprints over the life of a release */
  1461. severity = LOG_INFO;
  1462. extra_log = " Tor will try a different fallback.";
  1463. } else {
  1464. /* it's a bridge, it's either a misconfiguration, or unexpected */
  1465. severity = LOG_WARN;
  1466. }
  1467. } else {
  1468. /* a relay has changed its fingerprint from the one in the consensus */
  1469. severity = LOG_WARN;
  1470. }
  1471. }
  1472. log_fn(severity, LD_HANDSHAKE,
  1473. "Tried connecting to router at %s:%d, but identity key was not "
  1474. "as expected: wanted %s but got %s.%s",
  1475. conn->base_.address, conn->base_.port, expected, seen, extra_log);
  1476. entry_guard_register_connect_status(conn->identity_digest, 0, 1,
  1477. time(NULL));
  1478. control_event_or_conn_status(conn, OR_CONN_EVENT_FAILED,
  1479. END_OR_CONN_REASON_OR_IDENTITY);
  1480. if (!authdir_mode_tests_reachability(options))
  1481. control_event_bootstrap_problem(
  1482. "Unexpected identity in router certificate",
  1483. END_OR_CONN_REASON_OR_IDENTITY,
  1484. conn);
  1485. return -1;
  1486. }
  1487. if (authdir_mode_tests_reachability(options)) {
  1488. dirserv_orconn_tls_done(&conn->base_.addr, conn->base_.port,
  1489. (const char*)peer_id);
  1490. }
  1491. return 0;
  1492. }
  1493. /** Return when a client used this, for connection.c, since client_used
  1494. * is now one of the timestamps of channel_t */
  1495. time_t
  1496. connection_or_client_used(or_connection_t *conn)
  1497. {
  1498. tor_assert(conn);
  1499. if (conn->chan) {
  1500. return channel_when_last_client(TLS_CHAN_TO_BASE(conn->chan));
  1501. } else return 0;
  1502. }
  1503. /** The v1/v2 TLS handshake is finished.
  1504. *
  1505. * Make sure we are happy with the person we just handshaked with.
  1506. *
  1507. * If they initiated the connection, make sure they're not already connected,
  1508. * then initialize conn from the information in router.
  1509. *
  1510. * If all is successful, call circuit_n_conn_done() to handle events
  1511. * that have been pending on the <tls handshake completion. Also set the
  1512. * directory to be dirty (only matters if I'm an authdirserver).
  1513. *
  1514. * If this is a v2 TLS handshake, send a versions cell.
  1515. */
  1516. static int
  1517. connection_tls_finish_handshake(or_connection_t *conn)
  1518. {
  1519. char digest_rcvd[DIGEST_LEN];
  1520. int started_here = connection_or_nonopen_was_started_here(conn);
  1521. tor_assert(!started_here);
  1522. log_debug(LD_HANDSHAKE,"%s tls handshake on %p with %s done, using "
  1523. "ciphersuite %s. verifying.",
  1524. started_here?"outgoing":"incoming",
  1525. conn,
  1526. safe_str_client(conn->base_.address),
  1527. tor_tls_get_ciphersuite_name(conn->tls));
  1528. if (connection_or_check_valid_tls_handshake(conn, started_here,
  1529. digest_rcvd) < 0)
  1530. return -1;
  1531. circuit_build_times_network_is_live(get_circuit_build_times_mutable());
  1532. if (tor_tls_used_v1_handshake(conn->tls)) {
  1533. conn->link_proto = 1;
  1534. connection_or_init_conn_from_address(conn, &conn->base_.addr,
  1535. conn->base_.port, digest_rcvd, 0);
  1536. tor_tls_block_renegotiation(conn->tls);
  1537. rep_hist_note_negotiated_link_proto(1, started_here);
  1538. return connection_or_set_state_open(conn);
  1539. } else {
  1540. connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V2);
  1541. if (connection_init_or_handshake_state(conn, started_here) < 0)
  1542. return -1;
  1543. connection_or_init_conn_from_address(conn, &conn->base_.addr,
  1544. conn->base_.port, digest_rcvd, 0);
  1545. return connection_or_send_versions(conn, 0);
  1546. }
  1547. }
  1548. /**
  1549. * Called as client when initial TLS handshake is done, and we notice
  1550. * that we got a v3-handshake signalling certificate from the server.
  1551. * Set up structures, do bookkeeping, and send the versions cell.
  1552. * Return 0 on success and -1 on failure.
  1553. */
  1554. static int
  1555. connection_or_launch_v3_or_handshake(or_connection_t *conn)
  1556. {
  1557. tor_assert(connection_or_nonopen_was_started_here(conn));
  1558. circuit_build_times_network_is_live(get_circuit_build_times_mutable());
  1559. connection_or_change_state(conn, OR_CONN_STATE_OR_HANDSHAKING_V3);
  1560. if (connection_init_or_handshake_state(conn, 1) < 0)
  1561. return -1;
  1562. return connection_or_send_versions(conn, 1);
  1563. }
  1564. /** Allocate a new connection handshake state for the connection
  1565. * <b>conn</b>. Return 0 on success, -1 on failure. */
  1566. int
  1567. connection_init_or_handshake_state(or_connection_t *conn, int started_here)
  1568. {
  1569. or_handshake_state_t *s;
  1570. if (conn->handshake_state) {
  1571. log_warn(LD_BUG, "Duplicate call to connection_init_or_handshake_state!");
  1572. return 0;
  1573. }
  1574. s = conn->handshake_state = tor_malloc_zero(sizeof(or_handshake_state_t));
  1575. s->started_here = started_here ? 1 : 0;
  1576. s->digest_sent_data = 1;
  1577. s->digest_received_data = 1;
  1578. return 0;
  1579. }
  1580. /** Free all storage held by <b>state</b>. */
  1581. void
  1582. or_handshake_state_free(or_handshake_state_t *state)
  1583. {
  1584. if (!state)
  1585. return;
  1586. crypto_digest_free(state->digest_sent);
  1587. crypto_digest_free(state->digest_received);
  1588. tor_x509_cert_free(state->auth_cert);
  1589. tor_x509_cert_free(state->id_cert);
  1590. memwipe(state, 0xBE, sizeof(or_handshake_state_t));
  1591. tor_free(state);
  1592. }
  1593. /**
  1594. * Remember that <b>cell</b> has been transmitted (if <b>incoming</b> is
  1595. * false) or received (if <b>incoming</b> is true) during a V3 handshake using
  1596. * <b>state</b>.
  1597. *
  1598. * (We don't record the cell, but we keep a digest of everything sent or
  1599. * received during the v3 handshake, and the client signs it in an
  1600. * authenticate cell.)
  1601. */
  1602. void
  1603. or_handshake_state_record_cell(or_connection_t *conn,
  1604. or_handshake_state_t *state,
  1605. const cell_t *cell,
  1606. int incoming)
  1607. {
  1608. size_t cell_network_size = get_cell_network_size(conn->wide_circ_ids);
  1609. crypto_digest_t *d, **dptr;
  1610. packed_cell_t packed;
  1611. if (incoming) {
  1612. if (!state->digest_received_data)
  1613. return;
  1614. } else {
  1615. if (!state->digest_sent_data)
  1616. return;
  1617. }
  1618. if (!incoming) {
  1619. log_warn(LD_BUG, "We shouldn't be sending any non-variable-length cells "
  1620. "while making a handshake digest. But we think we are sending "
  1621. "one with type %d.", (int)cell->command);
  1622. }
  1623. dptr = incoming ? &state->digest_received : &state->digest_sent;
  1624. if (! *dptr)
  1625. *dptr = crypto_digest256_new(DIGEST_SHA256);
  1626. d = *dptr;
  1627. /* Re-packing like this is a little inefficient, but we don't have to do
  1628. this very often at all. */
  1629. cell_pack(&packed, cell, conn->wide_circ_ids);
  1630. crypto_digest_add_bytes(d, packed.body, cell_network_size);
  1631. memwipe(&packed, 0, sizeof(packed));
  1632. }
  1633. /** Remember that a variable-length <b>cell</b> has been transmitted (if
  1634. * <b>incoming</b> is false) or received (if <b>incoming</b> is true) during a
  1635. * V3 handshake using <b>state</b>.
  1636. *
  1637. * (We don't record the cell, but we keep a digest of everything sent or
  1638. * received during the v3 handshake, and the client signs it in an
  1639. * authenticate cell.)
  1640. */
  1641. void
  1642. or_handshake_state_record_var_cell(or_connection_t *conn,
  1643. or_handshake_state_t *state,
  1644. const var_cell_t *cell,
  1645. int incoming)
  1646. {
  1647. crypto_digest_t *d, **dptr;
  1648. int n;
  1649. char buf[VAR_CELL_MAX_HEADER_SIZE];
  1650. if (incoming) {
  1651. if (!state->digest_received_data)
  1652. return;
  1653. } else {
  1654. if (!state->digest_sent_data)
  1655. return;
  1656. }
  1657. dptr = incoming ? &state->digest_received : &state->digest_sent;
  1658. if (! *dptr)
  1659. *dptr = crypto_digest256_new(DIGEST_SHA256);
  1660. d = *dptr;
  1661. n = var_cell_pack_header(cell, buf, conn->wide_circ_ids);
  1662. crypto_digest_add_bytes(d, buf, n);
  1663. crypto_digest_add_bytes(d, (const char *)cell->payload, cell->payload_len);
  1664. memwipe(buf, 0, sizeof(buf));
  1665. }
  1666. /** Set <b>conn</b>'s state to OR_CONN_STATE_OPEN, and tell other subsystems
  1667. * as appropriate. Called when we are done with all TLS and OR handshaking.
  1668. */
  1669. int
  1670. connection_or_set_state_open(or_connection_t *conn)
  1671. {
  1672. connection_or_change_state(conn, OR_CONN_STATE_OPEN);
  1673. control_event_or_conn_status(conn, OR_CONN_EVENT_CONNECTED, 0);
  1674. or_handshake_state_free(conn->handshake_state);
  1675. conn->handshake_state = NULL;
  1676. connection_start_reading(TO_CONN(conn));
  1677. return 0;
  1678. }
  1679. /** Pack <b>cell</b> into wire-format, and write it onto <b>conn</b>'s outbuf.
  1680. * For cells that use or affect a circuit, this should only be called by
  1681. * connection_or_flush_from_first_active_circuit().
  1682. */
  1683. void
  1684. connection_or_write_cell_to_buf(const cell_t *cell, or_connection_t *conn)
  1685. {
  1686. packed_cell_t networkcell;
  1687. size_t cell_network_size = get_cell_network_size(conn->wide_circ_ids);
  1688. tor_assert(cell);
  1689. tor_assert(conn);
  1690. cell_pack(&networkcell, cell, conn->wide_circ_ids);
  1691. connection_write_to_buf(networkcell.body, cell_network_size, TO_CONN(conn));
  1692. /* Touch the channel's active timestamp if there is one */
  1693. if (conn->chan)
  1694. channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
  1695. if (conn->base_.state == OR_CONN_STATE_OR_HANDSHAKING_V3)
  1696. or_handshake_state_record_cell(conn, conn->handshake_state, cell, 0);
  1697. }
  1698. /** Pack a variable-length <b>cell</b> into wire-format, and write it onto
  1699. * <b>conn</b>'s outbuf. Right now, this <em>DOES NOT</em> support cells that
  1700. * affect a circuit.
  1701. */
  1702. MOCK_IMPL(void,
  1703. connection_or_write_var_cell_to_buf,(const var_cell_t *cell,
  1704. or_connection_t *conn))
  1705. {
  1706. int n;
  1707. char hdr[VAR_CELL_MAX_HEADER_SIZE];
  1708. tor_assert(cell);
  1709. tor_assert(conn);
  1710. n = var_cell_pack_header(cell, hdr, conn->wide_circ_ids);
  1711. connection_write_to_buf(hdr, n, TO_CONN(conn));
  1712. connection_write_to_buf((char*)cell->payload,
  1713. cell->payload_len, TO_CONN(conn));
  1714. if (conn->base_.state == OR_CONN_STATE_OR_HANDSHAKING_V3)
  1715. or_handshake_state_record_var_cell(conn, conn->handshake_state, cell, 0);
  1716. /* Touch the channel's active timestamp if there is one */
  1717. if (conn->chan)
  1718. channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
  1719. }
  1720. /** See whether there's a variable-length cell waiting on <b>or_conn</b>'s
  1721. * inbuf. Return values as for fetch_var_cell_from_buf(). */
  1722. static int
  1723. connection_fetch_var_cell_from_buf(or_connection_t *or_conn, var_cell_t **out)
  1724. {
  1725. connection_t *conn = TO_CONN(or_conn);
  1726. return fetch_var_cell_from_buf(conn->inbuf, out, or_conn->link_proto);
  1727. }
  1728. /** Process cells from <b>conn</b>'s inbuf.
  1729. *
  1730. * Loop: while inbuf contains a cell, pull it off the inbuf, unpack it,
  1731. * and hand it to command_process_cell().
  1732. *
  1733. * Always return 0.
  1734. */
  1735. static int
  1736. connection_or_process_cells_from_inbuf(or_connection_t *conn)
  1737. {
  1738. var_cell_t *var_cell;
  1739. /*
  1740. * Note on memory management for incoming cells: below the channel layer,
  1741. * we shouldn't need to consider its internal queueing/copying logic. It
  1742. * is safe to pass cells to it on the stack or on the heap, but in the
  1743. * latter case we must be sure we free them later.
  1744. *
  1745. * The incoming cell queue code in channel.c will (in the common case)
  1746. * decide it can pass them to the upper layer immediately, in which case
  1747. * those functions may run directly on the cell pointers we pass here, or
  1748. * it may decide to queue them, in which case it will allocate its own
  1749. * buffer and copy the cell.
  1750. */
  1751. while (1) {
  1752. log_debug(LD_OR,
  1753. TOR_SOCKET_T_FORMAT": starting, inbuf_datalen %d "
  1754. "(%d pending in tls object).",
  1755. conn->base_.s,(int)connection_get_inbuf_len(TO_CONN(conn)),
  1756. tor_tls_get_pending_bytes(conn->tls));
  1757. if (connection_fetch_var_cell_from_buf(conn, &var_cell)) {
  1758. if (!var_cell)
  1759. return 0; /* not yet. */
  1760. /* Touch the channel's active timestamp if there is one */
  1761. if (conn->chan)
  1762. channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
  1763. circuit_build_times_network_is_live(get_circuit_build_times_mutable());
  1764. channel_tls_handle_var_cell(var_cell, conn);
  1765. var_cell_free(var_cell);
  1766. } else {
  1767. const int wide_circ_ids = conn->wide_circ_ids;
  1768. size_t cell_network_size = get_cell_network_size(conn->wide_circ_ids);
  1769. char buf[CELL_MAX_NETWORK_SIZE];
  1770. cell_t cell;
  1771. if (connection_get_inbuf_len(TO_CONN(conn))
  1772. < cell_network_size) /* whole response available? */
  1773. return 0; /* not yet */
  1774. /* Touch the channel's active timestamp if there is one */
  1775. if (conn->chan)
  1776. channel_timestamp_active(TLS_CHAN_TO_BASE(conn->chan));
  1777. circuit_build_times_network_is_live(get_circuit_build_times_mutable());
  1778. connection_fetch_from_buf(buf, cell_network_size, TO_CONN(conn));
  1779. /* retrieve cell info from buf (create the host-order struct from the
  1780. * network-order string) */
  1781. cell_unpack(&cell, buf, wide_circ_ids);
  1782. channel_tls_handle_cell(&cell, conn);
  1783. }
  1784. }
  1785. }
  1786. /** Array of recognized link protocol versions. */
  1787. static const uint16_t or_protocol_versions[] = { 1, 2, 3, 4 };
  1788. /** Number of versions in <b>or_protocol_versions</b>. */
  1789. static const int n_or_protocol_versions =
  1790. (int)( sizeof(or_protocol_versions)/sizeof(uint16_t) );
  1791. /** Return true iff <b>v</b> is a link protocol version that this Tor
  1792. * implementation believes it can support. */
  1793. int
  1794. is_or_protocol_version_known(uint16_t v)
  1795. {
  1796. int i;
  1797. for (i = 0; i < n_or_protocol_versions; ++i) {
  1798. if (or_protocol_versions[i] == v)
  1799. return 1;
  1800. }
  1801. return 0;
  1802. }
  1803. /** Send a VERSIONS cell on <b>conn</b>, telling the other host about the
  1804. * link protocol versions that this Tor can support.
  1805. *
  1806. * If <b>v3_plus</b>, this is part of a V3 protocol handshake, so only
  1807. * allow protocol version v3 or later. If not <b>v3_plus</b>, this is
  1808. * not part of a v3 protocol handshake, so don't allow protocol v3 or
  1809. * later.
  1810. **/
  1811. int
  1812. connection_or_send_versions(or_connection_t *conn, int v3_plus)
  1813. {
  1814. var_cell_t *cell;
  1815. int i;
  1816. int n_versions = 0;
  1817. const int min_version = v3_plus ? 3 : 0;
  1818. const int max_version = v3_plus ? UINT16_MAX : 2;
  1819. tor_assert(conn->handshake_state &&
  1820. !conn->handshake_state->sent_versions_at);
  1821. cell = var_cell_new(n_or_protocol_versions * 2);
  1822. cell->command = CELL_VERSIONS;
  1823. for (i = 0; i < n_or_protocol_versions; ++i) {
  1824. uint16_t v = or_protocol_versions[i];
  1825. if (v < min_version || v > max_version)
  1826. continue;
  1827. set_uint16(cell->payload+(2*n_versions), htons(v));
  1828. ++n_versions;
  1829. }
  1830. cell->payload_len = n_versions * 2;
  1831. connection_or_write_var_cell_to_buf(cell, conn);
  1832. conn->handshake_state->sent_versions_at = time(NULL);
  1833. var_cell_free(cell);
  1834. return 0;
  1835. }
  1836. /** Send a NETINFO cell on <b>conn</b>, telling the other server what we know
  1837. * about their address, our address, and the current time. */
  1838. MOCK_IMPL(int,
  1839. connection_or_send_netinfo,(or_connection_t *conn))
  1840. {
  1841. cell_t cell;
  1842. time_t now = time(NULL);
  1843. const routerinfo_t *me;
  1844. int len;
  1845. uint8_t *out;
  1846. tor_assert(conn->handshake_state);
  1847. if (conn->handshake_state->sent_netinfo) {
  1848. log_warn(LD_BUG, "Attempted to send an extra netinfo cell on a connection "
  1849. "where we already sent one.");
  1850. return 0;
  1851. }
  1852. memset(&cell, 0, sizeof(cell_t));
  1853. cell.command = CELL_NETINFO;
  1854. /* Timestamp, if we're a relay. */
  1855. if (public_server_mode(get_options()) || ! conn->is_outgoing)
  1856. set_uint32(cell.payload, htonl((uint32_t)now));
  1857. /* Their address. */
  1858. out = cell.payload + 4;
  1859. /* We use &conn->real_addr below, unless it hasn't yet been set. If it
  1860. * hasn't yet been set, we know that base_.addr hasn't been tampered with
  1861. * yet either. */
  1862. len = append_address_to_payload(out, !tor_addr_is_null(&conn->real_addr)
  1863. ? &conn->real_addr : &conn->base_.addr);
  1864. if (len<0)
  1865. return -1;
  1866. out += len;
  1867. /* My address -- only include it if I'm a public relay, or if I'm a
  1868. * bridge and this is an incoming connection. If I'm a bridge and this
  1869. * is an outgoing connection, act like a normal client and omit it. */
  1870. if ((public_server_mode(get_options()) || !conn->is_outgoing) &&
  1871. (me = router_get_my_routerinfo())) {
  1872. tor_addr_t my_addr;
  1873. *out++ = 1 + !tor_addr_is_null(&me->ipv6_addr);
  1874. tor_addr_from_ipv4h(&my_addr, me->addr);
  1875. len = append_address_to_payload(out, &my_addr);
  1876. if (len < 0)
  1877. return -1;
  1878. out += len;
  1879. if (!tor_addr_is_null(&me->ipv6_addr)) {
  1880. len = append_address_to_payload(out, &me->ipv6_addr);
  1881. if (len < 0)
  1882. return -1;
  1883. }
  1884. } else {
  1885. *out = 0;
  1886. }
  1887. conn->handshake_state->digest_sent_data = 0;
  1888. conn->handshake_state->sent_netinfo = 1;
  1889. connection_or_write_cell_to_buf(&cell, conn);
  1890. return 0;
  1891. }
  1892. /** Send a CERTS cell on the connection <b>conn</b>. Return 0 on success, -1
  1893. * on failure. */
  1894. int
  1895. connection_or_send_certs_cell(or_connection_t *conn)
  1896. {
  1897. const tor_x509_cert_t *global_link_cert = NULL, *id_cert = NULL,
  1898. *using_link_cert = NULL;
  1899. tor_x509_cert_t *own_link_cert = NULL;
  1900. const uint8_t *link_encoded = NULL, *id_encoded = NULL;
  1901. size_t link_len, id_len;
  1902. var_cell_t *cell;
  1903. size_t cell_len;
  1904. ssize_t pos;
  1905. tor_assert(conn->base_.state == OR_CONN_STATE_OR_HANDSHAKING_V3);
  1906. if (! conn->handshake_state)
  1907. return -1;
  1908. const int conn_in_server_mode = ! conn->handshake_state->started_here;
  1909. if (tor_tls_get_my_certs(conn_in_server_mode,
  1910. &global_link_cert, &id_cert) < 0)
  1911. return -1;
  1912. if (conn_in_server_mode) {
  1913. using_link_cert = own_link_cert = tor_tls_get_own_cert(conn->tls);
  1914. } else {
  1915. using_link_cert = global_link_cert;
  1916. }
  1917. tor_x509_cert_get_der(using_link_cert, &link_encoded, &link_len);
  1918. tor_x509_cert_get_der(id_cert, &id_encoded, &id_len);
  1919. cell_len = 1 /* 1 byte: num certs in cell */ +
  1920. 2 * ( 1 + 2 ) /* For each cert: 1 byte for type, 2 for length */ +
  1921. link_len + id_len;
  1922. cell = var_cell_new(cell_len);
  1923. cell->command = CELL_CERTS;
  1924. cell->payload[0] = 2;
  1925. pos = 1;
  1926. if (conn_in_server_mode)
  1927. cell->payload[pos] = OR_CERT_TYPE_TLS_LINK; /* Link cert */
  1928. else
  1929. cell->payload[pos] = OR_CERT_TYPE_AUTH_1024; /* client authentication */
  1930. set_uint16(&cell->payload[pos+1], htons(link_len));
  1931. memcpy(&cell->payload[pos+3], link_encoded, link_len);
  1932. pos += 3 + link_len;
  1933. cell->payload[pos] = OR_CERT_TYPE_ID_1024; /* ID cert */
  1934. set_uint16(&cell->payload[pos+1], htons(id_len));
  1935. memcpy(&cell->payload[pos+3], id_encoded, id_len);
  1936. pos += 3 + id_len;
  1937. tor_assert(pos == (int)cell_len); /* Otherwise we just smashed the heap */
  1938. connection_or_write_var_cell_to_buf(cell, conn);
  1939. var_cell_free(cell);
  1940. tor_x509_cert_free(own_link_cert);
  1941. return 0;
  1942. }
  1943. /** Send an AUTH_CHALLENGE cell on the connection <b>conn</b>. Return 0
  1944. * on success, -1 on failure. */
  1945. int
  1946. connection_or_send_auth_challenge_cell(or_connection_t *conn)
  1947. {
  1948. var_cell_t *cell = NULL;
  1949. int r = -1;
  1950. tor_assert(conn->base_.state == OR_CONN_STATE_OR_HANDSHAKING_V3);
  1951. if (! conn->handshake_state)
  1952. return -1;
  1953. auth_challenge_cell_t *ac = auth_challenge_cell_new();
  1954. crypto_rand((char*)ac->challenge, sizeof(ac->challenge));
  1955. auth_challenge_cell_add_methods(ac, AUTHTYPE_RSA_SHA256_TLSSECRET);
  1956. auth_challenge_cell_set_n_methods(ac,
  1957. auth_challenge_cell_getlen_methods(ac));
  1958. cell = var_cell_new(auth_challenge_cell_encoded_len(ac));
  1959. ssize_t len = auth_challenge_cell_encode(cell->payload, cell->payload_len,
  1960. ac);
  1961. if (len != cell->payload_len)
  1962. goto done;
  1963. cell->command = CELL_AUTH_CHALLENGE;
  1964. connection_or_write_var_cell_to_buf(cell, conn);
  1965. r = 0;
  1966. done:
  1967. var_cell_free(cell);
  1968. auth_challenge_cell_free(ac);
  1969. return r;
  1970. }
  1971. /** Compute the main body of an AUTHENTICATE cell that a client can use
  1972. * to authenticate itself on a v3 handshake for <b>conn</b>. Write it to the
  1973. * <b>outlen</b>-byte buffer at <b>out</b>.
  1974. *
  1975. * If <b>server</b> is true, only calculate the first
  1976. * V3_AUTH_FIXED_PART_LEN bytes -- the part of the authenticator that's
  1977. * determined by the rest of the handshake, and which match the provided value
  1978. * exactly.
  1979. *
  1980. * If <b>server</b> is false and <b>signing_key</b> is NULL, calculate the
  1981. * first V3_AUTH_BODY_LEN bytes of the authenticator (that is, everything
  1982. * that should be signed), but don't actually sign it.
  1983. *
  1984. * If <b>server</b> is false and <b>signing_key</b> is provided, calculate the
  1985. * entire authenticator, signed with <b>signing_key</b>.
  1986. *
  1987. * Return the length of the cell body on success, and -1 on failure.
  1988. */
  1989. int
  1990. connection_or_compute_authenticate_cell_body(or_connection_t *conn,
  1991. uint8_t *out, size_t outlen,
  1992. crypto_pk_t *signing_key,
  1993. int server)
  1994. {
  1995. auth1_t *auth = NULL;
  1996. auth_ctx_t *ctx = auth_ctx_new();
  1997. int result;
  1998. /* assert state is reasonable XXXX */
  1999. ctx->is_ed = 0;
  2000. auth = auth1_new();
  2001. /* Type: 8 bytes. */
  2002. memcpy(auth1_getarray_type(auth), "AUTH0001", 8);
  2003. {
  2004. const tor_x509_cert_t *id_cert=NULL;
  2005. const common_digests_t *my_digests, *their_digests;
  2006. const uint8_t *my_id, *their_id, *client_id, *server_id;
  2007. if (tor_tls_get_my_certs(server, NULL, &id_cert))
  2008. goto err;
  2009. my_digests = tor_x509_cert_get_id_digests(id_cert);
  2010. their_digests =
  2011. tor_x509_cert_get_id_digests(conn->handshake_state->id_cert);
  2012. tor_assert(my_digests);
  2013. tor_assert(their_digests);
  2014. my_id = (uint8_t*)my_digests->d[DIGEST_SHA256];
  2015. their_id = (uint8_t*)their_digests->d[DIGEST_SHA256];
  2016. client_id = server ? their_id : my_id;
  2017. server_id = server ? my_id : their_id;
  2018. /* Client ID digest: 32 octets. */
  2019. memcpy(auth->cid, client_id, 32);
  2020. /* Server ID digest: 32 octets. */
  2021. memcpy(auth->sid, server_id, 32);
  2022. }
  2023. {
  2024. crypto_digest_t *server_d, *client_d;
  2025. if (server) {
  2026. server_d = conn->handshake_state->digest_sent;
  2027. client_d = conn->handshake_state->digest_received;
  2028. } else {
  2029. client_d = conn->handshake_state->digest_sent;
  2030. server_d = conn->handshake_state->digest_received;
  2031. }
  2032. /* Server log digest : 32 octets */
  2033. crypto_digest_get_digest(server_d, (char*)auth->slog, 32);
  2034. /* Client log digest : 32 octets */
  2035. crypto_digest_get_digest(client_d, (char*)auth->clog, 32);
  2036. }
  2037. {
  2038. /* Digest of cert used on TLS link : 32 octets. */
  2039. tor_x509_cert_t *cert = NULL;
  2040. if (server) {
  2041. cert = tor_tls_get_own_cert(conn->tls);
  2042. } else {
  2043. cert = tor_tls_get_peer_cert(conn->tls);
  2044. }
  2045. if (!cert) {
  2046. log_warn(LD_OR, "Unable to find cert when making AUTH1 data.");
  2047. goto err;
  2048. }
  2049. memcpy(auth->scert,
  2050. tor_x509_cert_get_cert_digests(cert)->d[DIGEST_SHA256], 32);
  2051. tor_x509_cert_free(cert);
  2052. }
  2053. /* HMAC of clientrandom and serverrandom using master key : 32 octets */
  2054. tor_tls_get_tlssecrets(conn->tls, auth->tlssecrets);
  2055. /* 8 octets were reserved for the current time, but we're trying to get out
  2056. * of the habit of sending time around willynilly. Fortunately, nothing
  2057. * checks it. That's followed by 16 bytes of nonce. */
  2058. crypto_rand((char*)auth->rand, 24);
  2059. ssize_t len;
  2060. if ((len = auth1_encode(out, outlen, auth, ctx)) < 0) {
  2061. log_warn(LD_OR, "Unable to encode signed part of AUTH1 data.");
  2062. goto err;
  2063. }
  2064. if (server) {
  2065. auth1_t *tmp = NULL;
  2066. ssize_t len2 = auth1_parse(&tmp, out, len, ctx);
  2067. if (!tmp) {
  2068. log_warn(LD_OR, "Unable to parse signed part of AUTH1 data.");
  2069. goto err;
  2070. }
  2071. result = (int) (tmp->end_of_fixed_part - out);
  2072. auth1_free(tmp);
  2073. if (len2 != len) {
  2074. log_warn(LD_OR, "Mismatched length when re-parsing AUTH1 data.");
  2075. goto err;
  2076. }
  2077. goto done;
  2078. }
  2079. if (signing_key) {
  2080. auth1_setlen_sig(auth, crypto_pk_keysize(signing_key));
  2081. char d[32];
  2082. crypto_digest256(d, (char*)out, len, DIGEST_SHA256);
  2083. int siglen = crypto_pk_private_sign(signing_key,
  2084. (char*)auth1_getarray_sig(auth),
  2085. auth1_getlen_sig(auth),
  2086. d, 32);
  2087. if (siglen < 0) {
  2088. log_warn(LD_OR, "Unable to sign AUTH1 data.");
  2089. goto err;
  2090. }
  2091. auth1_setlen_sig(auth, siglen);
  2092. len = auth1_encode(out, outlen, auth, ctx);
  2093. if (len < 0) {
  2094. log_warn(LD_OR, "Unable to encode signed AUTH1 data.");
  2095. goto err;
  2096. }
  2097. }
  2098. result = (int) len;
  2099. goto done;
  2100. err:
  2101. result = -1;
  2102. done:
  2103. auth1_free(auth);
  2104. auth_ctx_free(ctx);
  2105. return result;
  2106. }
  2107. /** Send an AUTHENTICATE cell on the connection <b>conn</b>. Return 0 on
  2108. * success, -1 on failure */
  2109. MOCK_IMPL(int,
  2110. connection_or_send_authenticate_cell,(or_connection_t *conn, int authtype))
  2111. {
  2112. var_cell_t *cell;
  2113. crypto_pk_t *pk = tor_tls_get_my_client_auth_key();
  2114. int authlen;
  2115. size_t cell_maxlen;
  2116. /* XXXX make sure we're actually supposed to send this! */
  2117. if (!pk) {
  2118. log_warn(LD_BUG, "Can't compute authenticate cell: no client auth key");
  2119. return -1;
  2120. }
  2121. if (authtype != AUTHTYPE_RSA_SHA256_TLSSECRET) {
  2122. log_warn(LD_BUG, "Tried to send authenticate cell with unknown "
  2123. "authentication type %d", authtype);
  2124. return -1;
  2125. }
  2126. cell_maxlen = 4 + /* overhead */
  2127. V3_AUTH_BODY_LEN + /* Authentication body */
  2128. crypto_pk_keysize(pk) + /* Max signature length */
  2129. 16 /* add a few extra bytes just in case. */;
  2130. cell = var_cell_new(cell_maxlen);
  2131. cell->command = CELL_AUTHENTICATE;
  2132. set_uint16(cell->payload, htons(AUTHTYPE_RSA_SHA256_TLSSECRET));
  2133. /* skip over length ; we don't know that yet. */
  2134. authlen = connection_or_compute_authenticate_cell_body(conn,
  2135. cell->payload+4,
  2136. cell_maxlen-4,
  2137. pk,
  2138. 0 /* not server */);
  2139. if (authlen < 0) {
  2140. log_warn(LD_BUG, "Unable to compute authenticate cell!");
  2141. var_cell_free(cell);
  2142. return -1;
  2143. }
  2144. tor_assert(authlen + 4 <= cell->payload_len);
  2145. set_uint16(cell->payload+2, htons(authlen));
  2146. cell->payload_len = authlen + 4;
  2147. connection_or_write_var_cell_to_buf(cell, conn);
  2148. var_cell_free(cell);
  2149. return 0;
  2150. }