connection_or.c 81 KB

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