connection_or.c 84 KB

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