connection_or.c 78 KB

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