rendclient.c 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518
  1. /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  2. * Copyright (c) 2007-2015, The Tor Project, Inc. */
  3. /* See LICENSE for licensing information */
  4. /**
  5. * \file rendclient.c
  6. * \brief Client code to access location-hidden services.
  7. **/
  8. #include "or.h"
  9. #include "circpathbias.h"
  10. #include "circuitbuild.h"
  11. #include "circuitlist.h"
  12. #include "circuituse.h"
  13. #include "config.h"
  14. #include "connection.h"
  15. #include "connection_edge.h"
  16. #include "directory.h"
  17. #include "main.h"
  18. #include "networkstatus.h"
  19. #include "nodelist.h"
  20. #include "relay.h"
  21. #include "rendclient.h"
  22. #include "rendcommon.h"
  23. #include "rephist.h"
  24. #include "router.h"
  25. #include "routerlist.h"
  26. #include "routerset.h"
  27. #include "control.h"
  28. static extend_info_t *rend_client_get_random_intro_impl(
  29. const rend_cache_entry_t *rend_query,
  30. const int strict, const int warnings);
  31. /** Purge all potentially remotely-detectable state held in the hidden
  32. * service client code. Called on SIGNAL NEWNYM. */
  33. void
  34. rend_client_purge_state(void)
  35. {
  36. rend_cache_purge();
  37. rend_client_cancel_descriptor_fetches();
  38. rend_client_purge_last_hid_serv_requests();
  39. }
  40. /** Called when we've established a circuit to an introduction point:
  41. * send the introduction request. */
  42. void
  43. rend_client_introcirc_has_opened(origin_circuit_t *circ)
  44. {
  45. tor_assert(circ->base_.purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
  46. tor_assert(circ->cpath);
  47. log_info(LD_REND,"introcirc is open");
  48. connection_ap_attach_pending();
  49. }
  50. /** Send the establish-rendezvous cell along a rendezvous circuit. if
  51. * it fails, mark the circ for close and return -1. else return 0.
  52. */
  53. static int
  54. rend_client_send_establish_rendezvous(origin_circuit_t *circ)
  55. {
  56. tor_assert(circ->base_.purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND);
  57. tor_assert(circ->rend_data);
  58. log_info(LD_REND, "Sending an ESTABLISH_RENDEZVOUS cell");
  59. if (crypto_rand(circ->rend_data->rend_cookie, REND_COOKIE_LEN) < 0) {
  60. log_warn(LD_BUG, "Internal error: Couldn't produce random cookie.");
  61. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  62. return -1;
  63. }
  64. /* Set timestamp_dirty, because circuit_expire_building expects it,
  65. * and the rend cookie also means we've used the circ. */
  66. circ->base_.timestamp_dirty = time(NULL);
  67. /* We've attempted to use this circuit. Probe it if we fail */
  68. pathbias_count_use_attempt(circ);
  69. if (relay_send_command_from_edge(0, TO_CIRCUIT(circ),
  70. RELAY_COMMAND_ESTABLISH_RENDEZVOUS,
  71. circ->rend_data->rend_cookie,
  72. REND_COOKIE_LEN,
  73. circ->cpath->prev)<0) {
  74. /* circ is already marked for close */
  75. log_warn(LD_GENERAL, "Couldn't send ESTABLISH_RENDEZVOUS cell");
  76. return -1;
  77. }
  78. return 0;
  79. }
  80. /** Extend the introduction circuit <b>circ</b> to another valid
  81. * introduction point for the hidden service it is trying to connect
  82. * to, or mark it and launch a new circuit if we can't extend it.
  83. * Return 0 on success or possible success. Return -1 and mark the
  84. * introduction circuit for close on permanent failure.
  85. *
  86. * On failure, the caller is responsible for marking the associated
  87. * rendezvous circuit for close. */
  88. static int
  89. rend_client_reextend_intro_circuit(origin_circuit_t *circ)
  90. {
  91. extend_info_t *extend_info;
  92. int result;
  93. extend_info = rend_client_get_random_intro(circ->rend_data);
  94. if (!extend_info) {
  95. log_warn(LD_REND,
  96. "No usable introduction points left for %s. Closing.",
  97. safe_str_client(circ->rend_data->onion_address));
  98. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  99. return -1;
  100. }
  101. // XXX: should we not re-extend if hs_circ_has_timed_out?
  102. if (circ->remaining_relay_early_cells) {
  103. log_info(LD_REND,
  104. "Re-extending circ %u, this time to %s.",
  105. (unsigned)circ->base_.n_circ_id,
  106. safe_str_client(extend_info_describe(extend_info)));
  107. result = circuit_extend_to_new_exit(circ, extend_info);
  108. } else {
  109. log_info(LD_REND,
  110. "Closing intro circ %u (out of RELAY_EARLY cells).",
  111. (unsigned)circ->base_.n_circ_id);
  112. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_FINISHED);
  113. /* connection_ap_handshake_attach_circuit will launch a new intro circ. */
  114. result = 0;
  115. }
  116. extend_info_free(extend_info);
  117. return result;
  118. }
  119. /** Called when we're trying to connect an ap conn; sends an INTRODUCE1 cell
  120. * down introcirc if possible.
  121. */
  122. int
  123. rend_client_send_introduction(origin_circuit_t *introcirc,
  124. origin_circuit_t *rendcirc)
  125. {
  126. size_t payload_len;
  127. int r, v3_shift = 0;
  128. char payload[RELAY_PAYLOAD_SIZE];
  129. char tmp[RELAY_PAYLOAD_SIZE];
  130. rend_cache_entry_t *entry = NULL;
  131. crypt_path_t *cpath;
  132. off_t dh_offset;
  133. crypto_pk_t *intro_key = NULL;
  134. int status = 0;
  135. tor_assert(introcirc->base_.purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
  136. tor_assert(rendcirc->base_.purpose == CIRCUIT_PURPOSE_C_REND_READY);
  137. tor_assert(introcirc->rend_data);
  138. tor_assert(rendcirc->rend_data);
  139. tor_assert(!rend_cmp_service_ids(introcirc->rend_data->onion_address,
  140. rendcirc->rend_data->onion_address));
  141. #ifndef NON_ANONYMOUS_MODE_ENABLED
  142. tor_assert(!(introcirc->build_state->onehop_tunnel));
  143. tor_assert(!(rendcirc->build_state->onehop_tunnel));
  144. #endif
  145. r = rend_cache_lookup_entry(introcirc->rend_data->onion_address, -1,
  146. &entry);
  147. /* An invalid onion address is not possible else we have a big issue. */
  148. tor_assert(r != -EINVAL);
  149. if (r < 0 || !rend_client_any_intro_points_usable(entry)) {
  150. /* If the descriptor is not found or the intro points are not usable
  151. * anymore, trigger a fetch. */
  152. log_info(LD_REND,
  153. "query %s didn't have valid rend desc in cache. "
  154. "Refetching descriptor.",
  155. safe_str_client(introcirc->rend_data->onion_address));
  156. rend_client_refetch_v2_renddesc(introcirc->rend_data);
  157. {
  158. connection_t *conn;
  159. while ((conn = connection_get_by_type_state_rendquery(CONN_TYPE_AP,
  160. AP_CONN_STATE_CIRCUIT_WAIT,
  161. introcirc->rend_data->onion_address))) {
  162. conn->state = AP_CONN_STATE_RENDDESC_WAIT;
  163. }
  164. }
  165. status = -1;
  166. goto cleanup;
  167. }
  168. /* first 20 bytes of payload are the hash of Bob's pk */
  169. intro_key = NULL;
  170. SMARTLIST_FOREACH(entry->parsed->intro_nodes, rend_intro_point_t *,
  171. intro, {
  172. if (tor_memeq(introcirc->build_state->chosen_exit->identity_digest,
  173. intro->extend_info->identity_digest, DIGEST_LEN)) {
  174. intro_key = intro->intro_key;
  175. break;
  176. }
  177. });
  178. if (!intro_key) {
  179. log_info(LD_REND, "Could not find intro key for %s at %s; we "
  180. "have a v2 rend desc with %d intro points. "
  181. "Trying a different intro point...",
  182. safe_str_client(introcirc->rend_data->onion_address),
  183. safe_str_client(extend_info_describe(
  184. introcirc->build_state->chosen_exit)),
  185. smartlist_len(entry->parsed->intro_nodes));
  186. if (rend_client_reextend_intro_circuit(introcirc)) {
  187. status = -2;
  188. goto perm_err;
  189. } else {
  190. status = -1;
  191. goto cleanup;
  192. }
  193. }
  194. if (crypto_pk_get_digest(intro_key, payload)<0) {
  195. log_warn(LD_BUG, "Internal error: couldn't hash public key.");
  196. status = -2;
  197. goto perm_err;
  198. }
  199. /* Initialize the pending_final_cpath and start the DH handshake. */
  200. cpath = rendcirc->build_state->pending_final_cpath;
  201. if (!cpath) {
  202. cpath = rendcirc->build_state->pending_final_cpath =
  203. tor_malloc_zero(sizeof(crypt_path_t));
  204. cpath->magic = CRYPT_PATH_MAGIC;
  205. if (!(cpath->rend_dh_handshake_state = crypto_dh_new(DH_TYPE_REND))) {
  206. log_warn(LD_BUG, "Internal error: couldn't allocate DH.");
  207. status = -2;
  208. goto perm_err;
  209. }
  210. if (crypto_dh_generate_public(cpath->rend_dh_handshake_state)<0) {
  211. log_warn(LD_BUG, "Internal error: couldn't generate g^x.");
  212. status = -2;
  213. goto perm_err;
  214. }
  215. }
  216. /* If version is 3, write (optional) auth data and timestamp. */
  217. if (entry->parsed->protocols & (1<<3)) {
  218. tmp[0] = 3; /* version 3 of the cell format */
  219. tmp[1] = (uint8_t)introcirc->rend_data->auth_type; /* auth type, if any */
  220. v3_shift = 1;
  221. if (introcirc->rend_data->auth_type != REND_NO_AUTH) {
  222. set_uint16(tmp+2, htons(REND_DESC_COOKIE_LEN));
  223. memcpy(tmp+4, introcirc->rend_data->descriptor_cookie,
  224. REND_DESC_COOKIE_LEN);
  225. v3_shift += 2+REND_DESC_COOKIE_LEN;
  226. }
  227. /* Once this held a timestamp. */
  228. set_uint32(tmp+v3_shift+1, 0);
  229. v3_shift += 4;
  230. } /* if version 2 only write version number */
  231. else if (entry->parsed->protocols & (1<<2)) {
  232. tmp[0] = 2; /* version 2 of the cell format */
  233. }
  234. /* write the remaining items into tmp */
  235. if (entry->parsed->protocols & (1<<3) || entry->parsed->protocols & (1<<2)) {
  236. /* version 2 format */
  237. extend_info_t *extend_info = rendcirc->build_state->chosen_exit;
  238. int klen;
  239. /* nul pads */
  240. set_uint32(tmp+v3_shift+1, tor_addr_to_ipv4n(&extend_info->addr));
  241. set_uint16(tmp+v3_shift+5, htons(extend_info->port));
  242. memcpy(tmp+v3_shift+7, extend_info->identity_digest, DIGEST_LEN);
  243. klen = crypto_pk_asn1_encode(extend_info->onion_key,
  244. tmp+v3_shift+7+DIGEST_LEN+2,
  245. sizeof(tmp)-(v3_shift+7+DIGEST_LEN+2));
  246. set_uint16(tmp+v3_shift+7+DIGEST_LEN, htons(klen));
  247. memcpy(tmp+v3_shift+7+DIGEST_LEN+2+klen, rendcirc->rend_data->rend_cookie,
  248. REND_COOKIE_LEN);
  249. dh_offset = v3_shift+7+DIGEST_LEN+2+klen+REND_COOKIE_LEN;
  250. } else {
  251. /* Version 0. */
  252. strncpy(tmp, rendcirc->build_state->chosen_exit->nickname,
  253. (MAX_NICKNAME_LEN+1)); /* nul pads */
  254. memcpy(tmp+MAX_NICKNAME_LEN+1, rendcirc->rend_data->rend_cookie,
  255. REND_COOKIE_LEN);
  256. dh_offset = MAX_NICKNAME_LEN+1+REND_COOKIE_LEN;
  257. }
  258. if (crypto_dh_get_public(cpath->rend_dh_handshake_state, tmp+dh_offset,
  259. DH_KEY_LEN)<0) {
  260. log_warn(LD_BUG, "Internal error: couldn't extract g^x.");
  261. status = -2;
  262. goto perm_err;
  263. }
  264. note_crypto_pk_op(REND_CLIENT);
  265. /*XXX maybe give crypto_pk_public_hybrid_encrypt a max_len arg,
  266. * to avoid buffer overflows? */
  267. r = crypto_pk_public_hybrid_encrypt(intro_key, payload+DIGEST_LEN,
  268. sizeof(payload)-DIGEST_LEN,
  269. tmp,
  270. (int)(dh_offset+DH_KEY_LEN),
  271. PK_PKCS1_OAEP_PADDING, 0);
  272. if (r<0) {
  273. log_warn(LD_BUG,"Internal error: hybrid pk encrypt failed.");
  274. status = -2;
  275. goto perm_err;
  276. }
  277. payload_len = DIGEST_LEN + r;
  278. tor_assert(payload_len <= RELAY_PAYLOAD_SIZE); /* we overran something */
  279. /* Copy the rendezvous cookie from rendcirc to introcirc, so that
  280. * when introcirc gets an ack, we can change the state of the right
  281. * rendezvous circuit. */
  282. memcpy(introcirc->rend_data->rend_cookie, rendcirc->rend_data->rend_cookie,
  283. REND_COOKIE_LEN);
  284. log_info(LD_REND, "Sending an INTRODUCE1 cell");
  285. if (relay_send_command_from_edge(0, TO_CIRCUIT(introcirc),
  286. RELAY_COMMAND_INTRODUCE1,
  287. payload, payload_len,
  288. introcirc->cpath->prev)<0) {
  289. /* introcirc is already marked for close. leave rendcirc alone. */
  290. log_warn(LD_BUG, "Couldn't send INTRODUCE1 cell");
  291. status = -2;
  292. goto cleanup;
  293. }
  294. /* Now, we wait for an ACK or NAK on this circuit. */
  295. circuit_change_purpose(TO_CIRCUIT(introcirc),
  296. CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT);
  297. /* Set timestamp_dirty, because circuit_expire_building expects it
  298. * to specify when a circuit entered the _C_INTRODUCE_ACK_WAIT
  299. * state. */
  300. introcirc->base_.timestamp_dirty = time(NULL);
  301. pathbias_count_use_attempt(introcirc);
  302. goto cleanup;
  303. perm_err:
  304. if (!introcirc->base_.marked_for_close)
  305. circuit_mark_for_close(TO_CIRCUIT(introcirc), END_CIRC_REASON_INTERNAL);
  306. circuit_mark_for_close(TO_CIRCUIT(rendcirc), END_CIRC_REASON_INTERNAL);
  307. cleanup:
  308. memwipe(payload, 0, sizeof(payload));
  309. memwipe(tmp, 0, sizeof(tmp));
  310. return status;
  311. }
  312. /** Called when a rendezvous circuit is open; sends a establish
  313. * rendezvous circuit as appropriate. */
  314. void
  315. rend_client_rendcirc_has_opened(origin_circuit_t *circ)
  316. {
  317. tor_assert(circ->base_.purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND);
  318. log_info(LD_REND,"rendcirc is open");
  319. /* generate a rendezvous cookie, store it in circ */
  320. if (rend_client_send_establish_rendezvous(circ) < 0) {
  321. return;
  322. }
  323. }
  324. /**
  325. * Called to close other intro circuits we launched in parallel.
  326. */
  327. static void
  328. rend_client_close_other_intros(const char *onion_address)
  329. {
  330. /* abort parallel intro circs, if any */
  331. SMARTLIST_FOREACH_BEGIN(circuit_get_global_list(), circuit_t *, c) {
  332. if ((c->purpose == CIRCUIT_PURPOSE_C_INTRODUCING ||
  333. c->purpose == CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) &&
  334. !c->marked_for_close && CIRCUIT_IS_ORIGIN(c)) {
  335. origin_circuit_t *oc = TO_ORIGIN_CIRCUIT(c);
  336. if (oc->rend_data &&
  337. !rend_cmp_service_ids(onion_address,
  338. oc->rend_data->onion_address)) {
  339. log_info(LD_REND|LD_CIRC, "Closing introduction circuit %d that we "
  340. "built in parallel (Purpose %d).", oc->global_identifier,
  341. c->purpose);
  342. circuit_mark_for_close(c, END_CIRC_REASON_IP_NOW_REDUNDANT);
  343. }
  344. }
  345. }
  346. SMARTLIST_FOREACH_END(c);
  347. }
  348. /** Called when get an ACK or a NAK for a REND_INTRODUCE1 cell.
  349. */
  350. int
  351. rend_client_introduction_acked(origin_circuit_t *circ,
  352. const uint8_t *request, size_t request_len)
  353. {
  354. origin_circuit_t *rendcirc;
  355. (void) request; // XXXX Use this.
  356. if (circ->base_.purpose != CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  357. log_warn(LD_PROTOCOL,
  358. "Received REND_INTRODUCE_ACK on unexpected circuit %u.",
  359. (unsigned)circ->base_.n_circ_id);
  360. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  361. return -1;
  362. }
  363. tor_assert(circ->build_state->chosen_exit);
  364. #ifndef NON_ANONYMOUS_MODE_ENABLED
  365. tor_assert(!(circ->build_state->onehop_tunnel));
  366. #endif
  367. tor_assert(circ->rend_data);
  368. /* For path bias: This circuit was used successfully. Valid
  369. * nacks and acks count. */
  370. pathbias_mark_use_success(circ);
  371. if (request_len == 0) {
  372. /* It's an ACK; the introduction point relayed our introduction request. */
  373. /* Locate the rend circ which is waiting to hear about this ack,
  374. * and tell it.
  375. */
  376. log_info(LD_REND,"Received ack. Telling rend circ...");
  377. rendcirc = circuit_get_ready_rend_circ_by_rend_data(circ->rend_data);
  378. if (rendcirc) { /* remember the ack */
  379. #ifndef NON_ANONYMOUS_MODE_ENABLED
  380. tor_assert(!(rendcirc->build_state->onehop_tunnel));
  381. #endif
  382. circuit_change_purpose(TO_CIRCUIT(rendcirc),
  383. CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED);
  384. /* Set timestamp_dirty, because circuit_expire_building expects
  385. * it to specify when a circuit entered the
  386. * _C_REND_READY_INTRO_ACKED state. */
  387. rendcirc->base_.timestamp_dirty = time(NULL);
  388. } else {
  389. log_info(LD_REND,"...Found no rend circ. Dropping on the floor.");
  390. }
  391. /* close the circuit: we won't need it anymore. */
  392. circuit_change_purpose(TO_CIRCUIT(circ),
  393. CIRCUIT_PURPOSE_C_INTRODUCE_ACKED);
  394. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_FINISHED);
  395. /* close any other intros launched in parallel */
  396. rend_client_close_other_intros(circ->rend_data->onion_address);
  397. } else {
  398. /* It's a NAK; the introduction point didn't relay our request. */
  399. circuit_change_purpose(TO_CIRCUIT(circ), CIRCUIT_PURPOSE_C_INTRODUCING);
  400. /* Remove this intro point from the set of viable introduction
  401. * points. If any remain, extend to a new one and try again.
  402. * If none remain, refetch the service descriptor.
  403. */
  404. log_info(LD_REND, "Got nack for %s from %s...",
  405. safe_str_client(circ->rend_data->onion_address),
  406. safe_str_client(extend_info_describe(circ->build_state->chosen_exit)));
  407. if (rend_client_report_intro_point_failure(circ->build_state->chosen_exit,
  408. circ->rend_data,
  409. INTRO_POINT_FAILURE_GENERIC)>0) {
  410. /* There are introduction points left. Re-extend the circuit to
  411. * another intro point and try again. */
  412. int result = rend_client_reextend_intro_circuit(circ);
  413. /* XXXX If that call failed, should we close the rend circuit,
  414. * too? */
  415. return result;
  416. } else {
  417. /* Close circuit because no more intro points are usable thus not
  418. * useful anymore. Change it's purpose before so we don't report an
  419. * intro point failure again triggering an extra descriptor fetch. */
  420. circuit_change_purpose(TO_CIRCUIT(circ),
  421. CIRCUIT_PURPOSE_C_INTRODUCE_ACKED);
  422. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_FINISHED);
  423. }
  424. }
  425. return 0;
  426. }
  427. /** The period for which a hidden service directory cannot be queried for
  428. * the same descriptor ID again. */
  429. #define REND_HID_SERV_DIR_REQUERY_PERIOD (15 * 60)
  430. /** Contains the last request times to hidden service directories for
  431. * certain queries; each key is a string consisting of the
  432. * concatenation of a base32-encoded HS directory identity digest, a
  433. * base32-encoded HS descriptor ID, and a hidden service address
  434. * (without the ".onion" part); each value is a pointer to a time_t
  435. * holding the time of the last request for that descriptor ID to that
  436. * HS directory. */
  437. static strmap_t *last_hid_serv_requests_ = NULL;
  438. /** Returns last_hid_serv_requests_, initializing it to a new strmap if
  439. * necessary. */
  440. static strmap_t *
  441. get_last_hid_serv_requests(void)
  442. {
  443. if (!last_hid_serv_requests_)
  444. last_hid_serv_requests_ = strmap_new();
  445. return last_hid_serv_requests_;
  446. }
  447. #define LAST_HID_SERV_REQUEST_KEY_LEN (REND_DESC_ID_V2_LEN_BASE32 + \
  448. REND_DESC_ID_V2_LEN_BASE32 + \
  449. REND_SERVICE_ID_LEN_BASE32)
  450. /** Look up the last request time to hidden service directory <b>hs_dir</b>
  451. * for descriptor ID <b>desc_id_base32</b> for the service specified in
  452. * <b>rend_query</b>. If <b>set</b> is non-zero,
  453. * assign the current time <b>now</b> and return that. Otherwise, return
  454. * the most recent request time, or 0 if no such request has been sent
  455. * before. */
  456. static time_t
  457. lookup_last_hid_serv_request(routerstatus_t *hs_dir,
  458. const char *desc_id_base32,
  459. time_t now, int set)
  460. {
  461. char hsdir_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  462. char hsdir_desc_comb_id[LAST_HID_SERV_REQUEST_KEY_LEN + 1];
  463. time_t *last_request_ptr;
  464. strmap_t *last_hid_serv_requests = get_last_hid_serv_requests();
  465. base32_encode(hsdir_id_base32, sizeof(hsdir_id_base32),
  466. hs_dir->identity_digest, DIGEST_LEN);
  467. tor_snprintf(hsdir_desc_comb_id, sizeof(hsdir_desc_comb_id), "%s%s",
  468. hsdir_id_base32,
  469. desc_id_base32);
  470. /* XXX023 tor_assert(strlen(hsdir_desc_comb_id) ==
  471. LAST_HID_SERV_REQUEST_KEY_LEN); */
  472. if (set) {
  473. time_t *oldptr;
  474. last_request_ptr = tor_malloc_zero(sizeof(time_t));
  475. *last_request_ptr = now;
  476. oldptr = strmap_set(last_hid_serv_requests, hsdir_desc_comb_id,
  477. last_request_ptr);
  478. tor_free(oldptr);
  479. } else
  480. last_request_ptr = strmap_get_lc(last_hid_serv_requests,
  481. hsdir_desc_comb_id);
  482. return (last_request_ptr) ? *last_request_ptr : 0;
  483. }
  484. /** Clean the history of request times to hidden service directories, so that
  485. * it does not contain requests older than REND_HID_SERV_DIR_REQUERY_PERIOD
  486. * seconds any more. */
  487. static void
  488. directory_clean_last_hid_serv_requests(time_t now)
  489. {
  490. strmap_iter_t *iter;
  491. time_t cutoff = now - REND_HID_SERV_DIR_REQUERY_PERIOD;
  492. strmap_t *last_hid_serv_requests = get_last_hid_serv_requests();
  493. for (iter = strmap_iter_init(last_hid_serv_requests);
  494. !strmap_iter_done(iter); ) {
  495. const char *key;
  496. void *val;
  497. time_t *ent;
  498. strmap_iter_get(iter, &key, &val);
  499. ent = (time_t *) val;
  500. if (*ent < cutoff) {
  501. iter = strmap_iter_next_rmv(last_hid_serv_requests, iter);
  502. tor_free(ent);
  503. } else {
  504. iter = strmap_iter_next(last_hid_serv_requests, iter);
  505. }
  506. }
  507. }
  508. /** Remove all requests related to the hidden service named
  509. * <b>onion_address</b> from the history of times of requests to
  510. * hidden service directories.
  511. *
  512. * This is called from rend_client_note_connection_attempt_ended(), which
  513. * must be idempotent, so any future changes to this function must leave
  514. * it idempotent too.
  515. */
  516. static void
  517. purge_hid_serv_from_last_hid_serv_requests(const char *onion_address)
  518. {
  519. strmap_iter_t *iter;
  520. strmap_t *last_hid_serv_requests = get_last_hid_serv_requests();
  521. /* XXX023 tor_assert(strlen(onion_address) == REND_SERVICE_ID_LEN_BASE32); */
  522. for (iter = strmap_iter_init(last_hid_serv_requests);
  523. !strmap_iter_done(iter); ) {
  524. const char *key;
  525. void *val;
  526. strmap_iter_get(iter, &key, &val);
  527. /* XXX023 tor_assert(strlen(key) == LAST_HID_SERV_REQUEST_KEY_LEN); */
  528. if (tor_memeq(key + LAST_HID_SERV_REQUEST_KEY_LEN -
  529. REND_SERVICE_ID_LEN_BASE32,
  530. onion_address,
  531. REND_SERVICE_ID_LEN_BASE32)) {
  532. iter = strmap_iter_next_rmv(last_hid_serv_requests, iter);
  533. tor_free(val);
  534. } else {
  535. iter = strmap_iter_next(last_hid_serv_requests, iter);
  536. }
  537. }
  538. }
  539. /** Purge the history of request times to hidden service directories,
  540. * so that future lookups of an HS descriptor will not fail because we
  541. * accessed all of the HSDir relays responsible for the descriptor
  542. * recently. */
  543. void
  544. rend_client_purge_last_hid_serv_requests(void)
  545. {
  546. /* Don't create the table if it doesn't exist yet (and it may very
  547. * well not exist if the user hasn't accessed any HSes)... */
  548. strmap_t *old_last_hid_serv_requests = last_hid_serv_requests_;
  549. /* ... and let get_last_hid_serv_requests re-create it for us if
  550. * necessary. */
  551. last_hid_serv_requests_ = NULL;
  552. if (old_last_hid_serv_requests != NULL) {
  553. log_info(LD_REND, "Purging client last-HS-desc-request-time table");
  554. strmap_free(old_last_hid_serv_requests, tor_free_);
  555. }
  556. }
  557. /** This returns a good valid hs dir that should be used for the given
  558. * descriptor id.
  559. *
  560. * Return NULL on error else the hsdir node pointer. */
  561. static routerstatus_t *
  562. pick_hsdir(const char *desc_id)
  563. {
  564. smartlist_t *responsible_dirs = smartlist_new();
  565. smartlist_t *usable_responsible_dirs = smartlist_new();
  566. const or_options_t *options = get_options();
  567. routerstatus_t *hs_dir;
  568. char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  569. time_t now = time(NULL);
  570. int excluded_some;
  571. tor_assert(desc_id);
  572. base32_encode(desc_id_base32, sizeof(desc_id_base32),
  573. desc_id, DIGEST_LEN);
  574. /* Determine responsible dirs. Even if we can't get all we want, work with
  575. * the ones we have. If it's empty, we'll notice below. */
  576. hid_serv_get_responsible_directories(responsible_dirs, desc_id);
  577. /* Clean request history first. */
  578. directory_clean_last_hid_serv_requests(now);
  579. /* Only select those hidden service directories to which we did not send a
  580. * request recently and for which we have a router descriptor here. */
  581. SMARTLIST_FOREACH_BEGIN(responsible_dirs, routerstatus_t *, dir) {
  582. time_t last = lookup_last_hid_serv_request(dir, desc_id_base32,
  583. 0, 0);
  584. const node_t *node = node_get_by_id(dir->identity_digest);
  585. if (last + REND_HID_SERV_DIR_REQUERY_PERIOD >= now ||
  586. !node || !node_has_descriptor(node)) {
  587. SMARTLIST_DEL_CURRENT(responsible_dirs, dir);
  588. continue;
  589. }
  590. if (!routerset_contains_node(options->ExcludeNodes, node)) {
  591. smartlist_add(usable_responsible_dirs, dir);
  592. }
  593. } SMARTLIST_FOREACH_END(dir);
  594. excluded_some =
  595. smartlist_len(usable_responsible_dirs) < smartlist_len(responsible_dirs);
  596. hs_dir = smartlist_choose(usable_responsible_dirs);
  597. if (!hs_dir && !options->StrictNodes) {
  598. hs_dir = smartlist_choose(responsible_dirs);
  599. }
  600. smartlist_free(responsible_dirs);
  601. smartlist_free(usable_responsible_dirs);
  602. if (!hs_dir) {
  603. log_info(LD_REND, "Could not pick one of the responsible hidden "
  604. "service directories, because we requested them all "
  605. "recently without success.");
  606. if (options->StrictNodes && excluded_some) {
  607. log_warn(LD_REND, "Could not pick a hidden service directory for the "
  608. "requested hidden service: they are all either down or "
  609. "excluded, and StrictNodes is set.");
  610. }
  611. } else {
  612. /* Remember that we are requesting a descriptor from this hidden service
  613. * directory now. */
  614. lookup_last_hid_serv_request(hs_dir, desc_id_base32, now, 1);
  615. }
  616. return hs_dir;
  617. }
  618. /** Determine the responsible hidden service directories for <b>desc_id</b>
  619. * and fetch the descriptor with that ID from one of them. Only
  620. * send a request to a hidden service directory that we have not yet tried
  621. * during this attempt to connect to this hidden service; on success, return 1,
  622. * in the case that no hidden service directory is left to ask for the
  623. * descriptor, return 0, and in case of a failure -1. */
  624. static int
  625. directory_get_from_hs_dir(const char *desc_id, const rend_data_t *rend_query,
  626. routerstatus_t *rs_hsdir)
  627. {
  628. routerstatus_t *hs_dir = rs_hsdir;
  629. char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  630. char descriptor_cookie_base64[3*REND_DESC_COOKIE_LEN_BASE64];
  631. #ifdef ENABLE_TOR2WEB_MODE
  632. const int tor2web_mode = get_options()->Tor2webMode;
  633. const int how_to_fetch = tor2web_mode ? DIRIND_ONEHOP : DIRIND_ANONYMOUS;
  634. #else
  635. const int how_to_fetch = DIRIND_ANONYMOUS;
  636. #endif
  637. tor_assert(desc_id);
  638. base32_encode(desc_id_base32, sizeof(desc_id_base32),
  639. desc_id, DIGEST_LEN);
  640. /* Automatically pick an hs dir if none given. */
  641. if (!rs_hsdir) {
  642. hs_dir = pick_hsdir(desc_id);
  643. if (!hs_dir) {
  644. /* No suitable hs dir can be found, stop right now. */
  645. return 0;
  646. }
  647. }
  648. /* Encode descriptor cookie for logging purposes. Also, if the cookie is
  649. * malformed, no fetch is triggered thus this needs to be done before the
  650. * fetch request. */
  651. if (rend_query->auth_type != REND_NO_AUTH) {
  652. if (base64_encode(descriptor_cookie_base64,
  653. sizeof(descriptor_cookie_base64),
  654. rend_query->descriptor_cookie, REND_DESC_COOKIE_LEN)<0) {
  655. log_warn(LD_BUG, "Could not base64-encode descriptor cookie.");
  656. return 0;
  657. }
  658. /* Remove == signs and newline. */
  659. descriptor_cookie_base64[strlen(descriptor_cookie_base64)-3] = '\0';
  660. } else {
  661. strlcpy(descriptor_cookie_base64, "(none)",
  662. sizeof(descriptor_cookie_base64));
  663. }
  664. /* Send fetch request. (Pass query and possibly descriptor cookie so that
  665. * they can be written to the directory connection and be referred to when
  666. * the response arrives. */
  667. directory_initiate_command_routerstatus_rend(hs_dir,
  668. DIR_PURPOSE_FETCH_RENDDESC_V2,
  669. ROUTER_PURPOSE_GENERAL,
  670. how_to_fetch,
  671. desc_id_base32,
  672. NULL, 0, 0,
  673. rend_query);
  674. log_info(LD_REND, "Sending fetch request for v2 descriptor for "
  675. "service '%s' with descriptor ID '%s', auth type %d, "
  676. "and descriptor cookie '%s' to hidden service "
  677. "directory %s",
  678. rend_query->onion_address, desc_id_base32,
  679. rend_query->auth_type,
  680. (rend_query->auth_type == REND_NO_AUTH ? "[none]" :
  681. escaped_safe_str_client(descriptor_cookie_base64)),
  682. routerstatus_describe(hs_dir));
  683. control_event_hs_descriptor_requested(rend_query,
  684. hs_dir->identity_digest,
  685. desc_id_base32);
  686. return 1;
  687. }
  688. /** Fetch a v2 descriptor using the given descriptor id. If any hsdir(s) are
  689. * given, they will be used instead.
  690. *
  691. * On success, 1 is returned. If no hidden service is left to ask, return 0.
  692. * On error, -1 is returned. */
  693. static int
  694. fetch_v2_desc_by_descid(const char *desc_id, const rend_data_t *rend_query,
  695. smartlist_t *hsdirs)
  696. {
  697. int ret;
  698. tor_assert(rend_query);
  699. if (!hsdirs) {
  700. ret = directory_get_from_hs_dir(desc_id, rend_query, NULL);
  701. goto end; /* either success or failure, but we're done */
  702. }
  703. /* Using the given hsdir list, trigger a fetch on each of them. */
  704. SMARTLIST_FOREACH_BEGIN(hsdirs, routerstatus_t *, hs_dir) {
  705. /* This should always be a success. */
  706. ret = directory_get_from_hs_dir(desc_id, rend_query, hs_dir);
  707. tor_assert(ret);
  708. } SMARTLIST_FOREACH_END(hs_dir);
  709. /* Everything went well. */
  710. ret = 0;
  711. end:
  712. return ret;
  713. }
  714. /** Fetch a v2 descriptor using the onion address in the given query object.
  715. * This will compute the descriptor id for each replicas and fetch it on the
  716. * given hsdir(s) if any or the responsible ones that are choosen
  717. * automatically.
  718. *
  719. * On success, 1 is returned. If no hidden service is left to ask, return 0.
  720. * On error, -1 is returned. */
  721. static int
  722. fetch_v2_desc_by_addr(const rend_data_t *query,
  723. smartlist_t *hsdirs)
  724. {
  725. char descriptor_id[DIGEST_LEN];
  726. int replicas_left_to_try[REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS];
  727. int i, tries_left, ret;
  728. tor_assert(query);
  729. /* Randomly iterate over the replicas until a descriptor can be fetched
  730. * from one of the consecutive nodes, or no options are left. */
  731. for (i = 0; i < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; i++) {
  732. replicas_left_to_try[i] = i;
  733. }
  734. tries_left = REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS;
  735. while (tries_left > 0) {
  736. int rand = crypto_rand_int(tries_left);
  737. int chosen_replica = replicas_left_to_try[rand];
  738. replicas_left_to_try[rand] = replicas_left_to_try[--tries_left];
  739. ret = rend_compute_v2_desc_id(descriptor_id, query->onion_address,
  740. query->auth_type == REND_STEALTH_AUTH ?
  741. query->descriptor_cookie : NULL,
  742. time(NULL), chosen_replica);
  743. if (ret < 0) {
  744. /* Normally, on failure the descriptor_id is untouched but let's be
  745. * safe in general in case the function changes at some point. */
  746. goto end;
  747. }
  748. /* Trigger the fetch with the computed descriptor ID. */
  749. ret = fetch_v2_desc_by_descid(descriptor_id, query, hsdirs);
  750. if (ret != 0) {
  751. /* Either on success or failure, as long as we tried a fetch we are
  752. * done here. */
  753. goto end;
  754. }
  755. }
  756. /* If we come here, there are no hidden service directories left. */
  757. log_info(LD_REND, "Could not pick one of the responsible hidden "
  758. "service directories to fetch descriptors, because "
  759. "we already tried them all unsuccessfully.");
  760. ret = 0;
  761. end:
  762. memwipe(descriptor_id, 0, sizeof(descriptor_id));
  763. return ret;
  764. }
  765. /** Fetch a v2 descriptor using the given query. If any hsdir are specified,
  766. * use them for the fetch.
  767. *
  768. * On success, 1 is returned. If no hidden service is left to ask, return 0.
  769. * On error, -1 is returned. */
  770. int
  771. rend_client_fetch_v2_desc(const rend_data_t *query,
  772. smartlist_t *hsdirs)
  773. {
  774. int ret;
  775. tor_assert(query);
  776. /* Depending on what's available in the rend data query object, we will
  777. * trigger a fetch by HS address or using a descriptor ID. */
  778. if (query->onion_address[0] != '\0') {
  779. ret = fetch_v2_desc_by_addr(query, hsdirs);
  780. } else if (query->descriptor_id[0] != '\0') {
  781. ret = fetch_v2_desc_by_descid(query->descriptor_id, query, hsdirs);
  782. } else {
  783. /* Query data is invalid. */
  784. ret = -1;
  785. goto error;
  786. }
  787. error:
  788. return ret;
  789. }
  790. /** Unless we already have a descriptor for <b>rend_query</b> with at least
  791. * one (possibly) working introduction point in it, start a connection to a
  792. * hidden service directory to fetch a v2 rendezvous service descriptor. */
  793. void
  794. rend_client_refetch_v2_renddesc(const rend_data_t *rend_query)
  795. {
  796. int ret;
  797. rend_cache_entry_t *e = NULL;
  798. tor_assert(rend_query);
  799. /* Are we configured to fetch descriptors? */
  800. if (!get_options()->FetchHidServDescriptors) {
  801. log_warn(LD_REND, "We received an onion address for a v2 rendezvous "
  802. "service descriptor, but are not fetching service descriptors.");
  803. return;
  804. }
  805. /* Before fetching, check if we already have a usable descriptor here. */
  806. if (rend_cache_lookup_entry(rend_query->onion_address, -1, &e) == 0 &&
  807. rend_client_any_intro_points_usable(e)) {
  808. log_info(LD_REND, "We would fetch a v2 rendezvous descriptor, but we "
  809. "already have a usable descriptor here. Not fetching.");
  810. return;
  811. }
  812. log_debug(LD_REND, "Fetching v2 rendezvous descriptor for service %s",
  813. safe_str_client(rend_query->onion_address));
  814. ret = rend_client_fetch_v2_desc(rend_query, NULL);
  815. if (ret <= 0) {
  816. /* Close pending connections on error or if no hsdir can be found. */
  817. rend_client_desc_trynow(rend_query->onion_address);
  818. }
  819. return;
  820. }
  821. /** Cancel all rendezvous descriptor fetches currently in progress.
  822. */
  823. void
  824. rend_client_cancel_descriptor_fetches(void)
  825. {
  826. smartlist_t *connection_array = get_connection_array();
  827. SMARTLIST_FOREACH_BEGIN(connection_array, connection_t *, conn) {
  828. if (conn->type == CONN_TYPE_DIR &&
  829. conn->purpose == DIR_PURPOSE_FETCH_RENDDESC_V2) {
  830. /* It's a rendezvous descriptor fetch in progress -- cancel it
  831. * by marking the connection for close.
  832. *
  833. * Even if this connection has already reached EOF, this is
  834. * enough to make sure that if the descriptor hasn't been
  835. * processed yet, it won't be. See the end of
  836. * connection_handle_read; connection_reached_eof (indirectly)
  837. * processes whatever response the connection received. */
  838. const rend_data_t *rd = (TO_DIR_CONN(conn))->rend_data;
  839. if (!rd) {
  840. log_warn(LD_BUG | LD_REND,
  841. "Marking for close dir conn fetching rendezvous "
  842. "descriptor for unknown service!");
  843. } else {
  844. log_debug(LD_REND, "Marking for close dir conn fetching "
  845. "rendezvous descriptor for service %s",
  846. safe_str(rd->onion_address));
  847. }
  848. connection_mark_for_close(conn);
  849. }
  850. } SMARTLIST_FOREACH_END(conn);
  851. }
  852. /** Mark <b>failed_intro</b> as a failed introduction point for the
  853. * hidden service specified by <b>rend_query</b>. If the HS now has no
  854. * usable intro points, or we do not have an HS descriptor for it,
  855. * then launch a new renddesc fetch.
  856. *
  857. * If <b>failure_type</b> is INTRO_POINT_FAILURE_GENERIC, remove the
  858. * intro point from (our parsed copy of) the HS descriptor.
  859. *
  860. * If <b>failure_type</b> is INTRO_POINT_FAILURE_TIMEOUT, mark the
  861. * intro point as 'timed out'; it will not be retried until the
  862. * current hidden service connection attempt has ended or it has
  863. * appeared in a newly fetched rendezvous descriptor.
  864. *
  865. * If <b>failure_type</b> is INTRO_POINT_FAILURE_UNREACHABLE,
  866. * increment the intro point's reachability-failure count; if it has
  867. * now failed MAX_INTRO_POINT_REACHABILITY_FAILURES or more times,
  868. * remove the intro point from (our parsed copy of) the HS descriptor.
  869. *
  870. * Return -1 if error, 0 if no usable intro points remain or service
  871. * unrecognized, 1 if recognized and some intro points remain.
  872. */
  873. int
  874. rend_client_report_intro_point_failure(extend_info_t *failed_intro,
  875. const rend_data_t *rend_query,
  876. unsigned int failure_type)
  877. {
  878. int i, r;
  879. rend_cache_entry_t *ent;
  880. connection_t *conn;
  881. r = rend_cache_lookup_entry(rend_query->onion_address, -1, &ent);
  882. if (r < 0) {
  883. /* Either invalid onion address or cache entry not found. */
  884. switch (-r) {
  885. case EINVAL:
  886. log_warn(LD_BUG, "Malformed service ID %s.",
  887. escaped_safe_str_client(rend_query->onion_address));
  888. return -1;
  889. case ENOENT:
  890. log_info(LD_REND, "Unknown service %s. Re-fetching descriptor.",
  891. escaped_safe_str_client(rend_query->onion_address));
  892. rend_client_refetch_v2_renddesc(rend_query);
  893. return 0;
  894. default:
  895. log_warn(LD_BUG, "Unknown cache lookup returned code: %d", r);
  896. return -1;
  897. }
  898. }
  899. /* The intro points are not checked here if they are usable or not because
  900. * this is called when an intro point circuit is closed thus there must be
  901. * at least one intro point that is usable and is about to be flagged. */
  902. for (i = 0; i < smartlist_len(ent->parsed->intro_nodes); i++) {
  903. rend_intro_point_t *intro = smartlist_get(ent->parsed->intro_nodes, i);
  904. if (tor_memeq(failed_intro->identity_digest,
  905. intro->extend_info->identity_digest, DIGEST_LEN)) {
  906. switch (failure_type) {
  907. default:
  908. log_warn(LD_BUG, "Unknown failure type %u. Removing intro point.",
  909. failure_type);
  910. tor_fragile_assert();
  911. /* fall through */
  912. case INTRO_POINT_FAILURE_GENERIC:
  913. rend_intro_point_free(intro);
  914. smartlist_del(ent->parsed->intro_nodes, i);
  915. break;
  916. case INTRO_POINT_FAILURE_TIMEOUT:
  917. intro->timed_out = 1;
  918. break;
  919. case INTRO_POINT_FAILURE_UNREACHABLE:
  920. ++(intro->unreachable_count);
  921. {
  922. int zap_intro_point =
  923. intro->unreachable_count >= MAX_INTRO_POINT_REACHABILITY_FAILURES;
  924. log_info(LD_REND, "Failed to reach this intro point %u times.%s",
  925. intro->unreachable_count,
  926. zap_intro_point ? " Removing from descriptor.": "");
  927. if (zap_intro_point) {
  928. rend_intro_point_free(intro);
  929. smartlist_del(ent->parsed->intro_nodes, i);
  930. }
  931. }
  932. break;
  933. }
  934. break;
  935. }
  936. }
  937. if (! rend_client_any_intro_points_usable(ent)) {
  938. log_info(LD_REND,
  939. "No more intro points remain for %s. Re-fetching descriptor.",
  940. escaped_safe_str_client(rend_query->onion_address));
  941. rend_client_refetch_v2_renddesc(rend_query);
  942. /* move all pending streams back to renddesc_wait */
  943. while ((conn = connection_get_by_type_state_rendquery(CONN_TYPE_AP,
  944. AP_CONN_STATE_CIRCUIT_WAIT,
  945. rend_query->onion_address))) {
  946. conn->state = AP_CONN_STATE_RENDDESC_WAIT;
  947. }
  948. return 0;
  949. }
  950. log_info(LD_REND,"%d options left for %s.",
  951. smartlist_len(ent->parsed->intro_nodes),
  952. escaped_safe_str_client(rend_query->onion_address));
  953. return 1;
  954. }
  955. /** Called when we receive a RENDEZVOUS_ESTABLISHED cell; changes the state of
  956. * the circuit to C_REND_READY.
  957. */
  958. int
  959. rend_client_rendezvous_acked(origin_circuit_t *circ, const uint8_t *request,
  960. size_t request_len)
  961. {
  962. (void) request;
  963. (void) request_len;
  964. /* we just got an ack for our establish-rendezvous. switch purposes. */
  965. if (circ->base_.purpose != CIRCUIT_PURPOSE_C_ESTABLISH_REND) {
  966. log_warn(LD_PROTOCOL,"Got a rendezvous ack when we weren't expecting one. "
  967. "Closing circ.");
  968. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  969. return -1;
  970. }
  971. log_info(LD_REND,"Got rendezvous ack. This circuit is now ready for "
  972. "rendezvous.");
  973. circuit_change_purpose(TO_CIRCUIT(circ), CIRCUIT_PURPOSE_C_REND_READY);
  974. /* Set timestamp_dirty, because circuit_expire_building expects it
  975. * to specify when a circuit entered the _C_REND_READY state. */
  976. circ->base_.timestamp_dirty = time(NULL);
  977. /* From a path bias point of view, this circuit is now successfully used.
  978. * Waiting any longer opens us up to attacks from Bob. He could induce
  979. * Alice to attempt to connect to his hidden service and never reply
  980. * to her rend requests */
  981. pathbias_mark_use_success(circ);
  982. /* XXXX This is a pretty brute-force approach. It'd be better to
  983. * attach only the connections that are waiting on this circuit, rather
  984. * than trying to attach them all. See comments bug 743. */
  985. /* If we already have the introduction circuit built, make sure we send
  986. * the INTRODUCE cell _now_ */
  987. connection_ap_attach_pending();
  988. return 0;
  989. }
  990. /** Bob sent us a rendezvous cell; join the circuits. */
  991. int
  992. rend_client_receive_rendezvous(origin_circuit_t *circ, const uint8_t *request,
  993. size_t request_len)
  994. {
  995. crypt_path_t *hop;
  996. char keys[DIGEST_LEN+CPATH_KEY_MATERIAL_LEN];
  997. if ((circ->base_.purpose != CIRCUIT_PURPOSE_C_REND_READY &&
  998. circ->base_.purpose != CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED)
  999. || !circ->build_state->pending_final_cpath) {
  1000. log_warn(LD_PROTOCOL,"Got rendezvous2 cell from hidden service, but not "
  1001. "expecting it. Closing.");
  1002. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  1003. return -1;
  1004. }
  1005. if (request_len != DH_KEY_LEN+DIGEST_LEN) {
  1006. log_warn(LD_PROTOCOL,"Incorrect length (%d) on RENDEZVOUS2 cell.",
  1007. (int)request_len);
  1008. goto err;
  1009. }
  1010. log_info(LD_REND,"Got RENDEZVOUS2 cell from hidden service.");
  1011. /* first DH_KEY_LEN bytes are g^y from bob. Finish the dh handshake...*/
  1012. tor_assert(circ->build_state);
  1013. tor_assert(circ->build_state->pending_final_cpath);
  1014. hop = circ->build_state->pending_final_cpath;
  1015. tor_assert(hop->rend_dh_handshake_state);
  1016. if (crypto_dh_compute_secret(LOG_PROTOCOL_WARN,
  1017. hop->rend_dh_handshake_state, (char*)request,
  1018. DH_KEY_LEN,
  1019. keys, DIGEST_LEN+CPATH_KEY_MATERIAL_LEN)<0) {
  1020. log_warn(LD_GENERAL, "Couldn't complete DH handshake.");
  1021. goto err;
  1022. }
  1023. /* ... and set up cpath. */
  1024. if (circuit_init_cpath_crypto(hop, keys+DIGEST_LEN, 0)<0)
  1025. goto err;
  1026. /* Check whether the digest is right... */
  1027. if (tor_memneq(keys, request+DH_KEY_LEN, DIGEST_LEN)) {
  1028. log_warn(LD_PROTOCOL, "Incorrect digest of key material.");
  1029. goto err;
  1030. }
  1031. crypto_dh_free(hop->rend_dh_handshake_state);
  1032. hop->rend_dh_handshake_state = NULL;
  1033. /* All is well. Extend the circuit. */
  1034. circuit_change_purpose(TO_CIRCUIT(circ), CIRCUIT_PURPOSE_C_REND_JOINED);
  1035. hop->state = CPATH_STATE_OPEN;
  1036. /* set the windows to default. these are the windows
  1037. * that alice thinks bob has.
  1038. */
  1039. hop->package_window = circuit_initial_package_window();
  1040. hop->deliver_window = CIRCWINDOW_START;
  1041. /* Now that this circuit has finished connecting to its destination,
  1042. * make sure circuit_get_open_circ_or_launch is willing to return it
  1043. * so we can actually use it. */
  1044. circ->hs_circ_has_timed_out = 0;
  1045. onion_append_to_cpath(&circ->cpath, hop);
  1046. circ->build_state->pending_final_cpath = NULL; /* prevent double-free */
  1047. circuit_try_attaching_streams(circ);
  1048. memwipe(keys, 0, sizeof(keys));
  1049. return 0;
  1050. err:
  1051. memwipe(keys, 0, sizeof(keys));
  1052. circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  1053. return -1;
  1054. }
  1055. /** Find all the apconns in state AP_CONN_STATE_RENDDESC_WAIT that are
  1056. * waiting on <b>query</b>. If there's a working cache entry here with at
  1057. * least one intro point, move them to the next state. */
  1058. void
  1059. rend_client_desc_trynow(const char *query)
  1060. {
  1061. entry_connection_t *conn;
  1062. rend_cache_entry_t *entry;
  1063. const rend_data_t *rend_data;
  1064. time_t now = time(NULL);
  1065. smartlist_t *conns = get_connection_array();
  1066. SMARTLIST_FOREACH_BEGIN(conns, connection_t *, base_conn) {
  1067. if (base_conn->type != CONN_TYPE_AP ||
  1068. base_conn->state != AP_CONN_STATE_RENDDESC_WAIT ||
  1069. base_conn->marked_for_close)
  1070. continue;
  1071. conn = TO_ENTRY_CONN(base_conn);
  1072. rend_data = ENTRY_TO_EDGE_CONN(conn)->rend_data;
  1073. if (!rend_data)
  1074. continue;
  1075. if (rend_cmp_service_ids(query, rend_data->onion_address))
  1076. continue;
  1077. assert_connection_ok(base_conn, now);
  1078. if (rend_cache_lookup_entry(rend_data->onion_address, -1,
  1079. &entry) == 0 &&
  1080. rend_client_any_intro_points_usable(entry)) {
  1081. /* either this fetch worked, or it failed but there was a
  1082. * valid entry from before which we should reuse */
  1083. log_info(LD_REND,"Rend desc is usable. Launching circuits.");
  1084. base_conn->state = AP_CONN_STATE_CIRCUIT_WAIT;
  1085. /* restart their timeout values, so they get a fair shake at
  1086. * connecting to the hidden service. */
  1087. base_conn->timestamp_created = now;
  1088. base_conn->timestamp_lastread = now;
  1089. base_conn->timestamp_lastwritten = now;
  1090. if (connection_ap_handshake_attach_circuit(conn) < 0) {
  1091. /* it will never work */
  1092. log_warn(LD_REND,"Rendezvous attempt failed. Closing.");
  1093. if (!base_conn->marked_for_close)
  1094. connection_mark_unattached_ap(conn, END_STREAM_REASON_CANT_ATTACH);
  1095. }
  1096. } else { /* 404, or fetch didn't get that far */
  1097. log_notice(LD_REND,"Closing stream for '%s.onion': hidden service is "
  1098. "unavailable (try again later).",
  1099. safe_str_client(query));
  1100. connection_mark_unattached_ap(conn, END_STREAM_REASON_RESOLVEFAILED);
  1101. rend_client_note_connection_attempt_ended(query);
  1102. }
  1103. } SMARTLIST_FOREACH_END(base_conn);
  1104. }
  1105. /** Clear temporary state used only during an attempt to connect to
  1106. * the hidden service named <b>onion_address</b>. Called when a
  1107. * connection attempt has ended; it is possible for this to be called
  1108. * multiple times while handling an ended connection attempt, and
  1109. * any future changes to this function must ensure it remains
  1110. * idempotent.
  1111. */
  1112. void
  1113. rend_client_note_connection_attempt_ended(const char *onion_address)
  1114. {
  1115. rend_cache_entry_t *cache_entry = NULL;
  1116. rend_cache_lookup_entry(onion_address, -1, &cache_entry);
  1117. log_info(LD_REND, "Connection attempt for %s has ended; "
  1118. "cleaning up temporary state.",
  1119. safe_str_client(onion_address));
  1120. /* Clear the timed_out flag on all remaining intro points for this HS. */
  1121. if (cache_entry != NULL) {
  1122. SMARTLIST_FOREACH(cache_entry->parsed->intro_nodes,
  1123. rend_intro_point_t *, ip,
  1124. ip->timed_out = 0; );
  1125. }
  1126. /* Remove the HS's entries in last_hid_serv_requests. */
  1127. purge_hid_serv_from_last_hid_serv_requests(onion_address);
  1128. }
  1129. /** Return a newly allocated extend_info_t* for a randomly chosen introduction
  1130. * point for the named hidden service. Return NULL if all introduction points
  1131. * have been tried and failed.
  1132. */
  1133. extend_info_t *
  1134. rend_client_get_random_intro(const rend_data_t *rend_query)
  1135. {
  1136. int ret;
  1137. extend_info_t *result;
  1138. rend_cache_entry_t *entry;
  1139. ret = rend_cache_lookup_entry(rend_query->onion_address, -1, &entry);
  1140. if (ret < 0 || !rend_client_any_intro_points_usable(entry)) {
  1141. log_warn(LD_REND,
  1142. "Query '%s' didn't have valid rend desc in cache. Failing.",
  1143. safe_str_client(rend_query->onion_address));
  1144. /* XXX: Should we refetch the descriptor here if the IPs are not usable
  1145. * anymore ?. */
  1146. return NULL;
  1147. }
  1148. /* See if we can get a node that complies with ExcludeNodes */
  1149. if ((result = rend_client_get_random_intro_impl(entry, 1, 1)))
  1150. return result;
  1151. /* If not, and StrictNodes is not set, see if we can return any old node
  1152. */
  1153. if (!get_options()->StrictNodes)
  1154. return rend_client_get_random_intro_impl(entry, 0, 1);
  1155. return NULL;
  1156. }
  1157. /** As rend_client_get_random_intro, except assume that StrictNodes is set
  1158. * iff <b>strict</b> is true. If <b>warnings</b> is false, don't complain
  1159. * to the user when we're out of nodes, even if StrictNodes is true.
  1160. */
  1161. static extend_info_t *
  1162. rend_client_get_random_intro_impl(const rend_cache_entry_t *entry,
  1163. const int strict,
  1164. const int warnings)
  1165. {
  1166. int i;
  1167. rend_intro_point_t *intro;
  1168. const or_options_t *options = get_options();
  1169. smartlist_t *usable_nodes;
  1170. int n_excluded = 0;
  1171. /* We'll keep a separate list of the usable nodes. If this becomes empty,
  1172. * no nodes are usable. */
  1173. usable_nodes = smartlist_new();
  1174. smartlist_add_all(usable_nodes, entry->parsed->intro_nodes);
  1175. /* Remove the intro points that have timed out during this HS
  1176. * connection attempt from our list of usable nodes. */
  1177. SMARTLIST_FOREACH(usable_nodes, rend_intro_point_t *, ip,
  1178. if (ip->timed_out) {
  1179. SMARTLIST_DEL_CURRENT(usable_nodes, ip);
  1180. });
  1181. again:
  1182. if (smartlist_len(usable_nodes) == 0) {
  1183. if (n_excluded && get_options()->StrictNodes && warnings) {
  1184. /* We only want to warn if StrictNodes is really set. Otherwise
  1185. * we're just about to retry anyways.
  1186. */
  1187. log_warn(LD_REND, "All introduction points for hidden service are "
  1188. "at excluded relays, and StrictNodes is set. Skipping.");
  1189. }
  1190. smartlist_free(usable_nodes);
  1191. return NULL;
  1192. }
  1193. i = crypto_rand_int(smartlist_len(usable_nodes));
  1194. intro = smartlist_get(usable_nodes, i);
  1195. /* Do we need to look up the router or is the extend info complete? */
  1196. if (!intro->extend_info->onion_key) {
  1197. const node_t *node;
  1198. extend_info_t *new_extend_info;
  1199. if (tor_digest_is_zero(intro->extend_info->identity_digest))
  1200. node = node_get_by_hex_id(intro->extend_info->nickname);
  1201. else
  1202. node = node_get_by_id(intro->extend_info->identity_digest);
  1203. if (!node) {
  1204. log_info(LD_REND, "Unknown router with nickname '%s'; trying another.",
  1205. intro->extend_info->nickname);
  1206. smartlist_del(usable_nodes, i);
  1207. goto again;
  1208. }
  1209. new_extend_info = extend_info_from_node(node, 0);
  1210. if (!new_extend_info) {
  1211. log_info(LD_REND, "We don't have a descriptor for the intro-point relay "
  1212. "'%s'; trying another.",
  1213. extend_info_describe(intro->extend_info));
  1214. smartlist_del(usable_nodes, i);
  1215. goto again;
  1216. } else {
  1217. extend_info_free(intro->extend_info);
  1218. intro->extend_info = new_extend_info;
  1219. }
  1220. tor_assert(intro->extend_info != NULL);
  1221. }
  1222. /* Check if we should refuse to talk to this router. */
  1223. if (strict &&
  1224. routerset_contains_extendinfo(options->ExcludeNodes,
  1225. intro->extend_info)) {
  1226. n_excluded++;
  1227. smartlist_del(usable_nodes, i);
  1228. goto again;
  1229. }
  1230. smartlist_free(usable_nodes);
  1231. return extend_info_dup(intro->extend_info);
  1232. }
  1233. /** Return true iff any introduction points still listed in <b>entry</b> are
  1234. * usable. */
  1235. int
  1236. rend_client_any_intro_points_usable(const rend_cache_entry_t *entry)
  1237. {
  1238. extend_info_t *extend_info =
  1239. rend_client_get_random_intro_impl(entry, get_options()->StrictNodes, 0);
  1240. int rv = (extend_info != NULL);
  1241. extend_info_free(extend_info);
  1242. return rv;
  1243. }
  1244. /** Client-side authorizations for hidden services; map of onion address to
  1245. * rend_service_authorization_t*. */
  1246. static strmap_t *auth_hid_servs = NULL;
  1247. /** Look up the client-side authorization for the hidden service with
  1248. * <b>onion_address</b>. Return NULL if no authorization is available for
  1249. * that address. */
  1250. rend_service_authorization_t*
  1251. rend_client_lookup_service_authorization(const char *onion_address)
  1252. {
  1253. tor_assert(onion_address);
  1254. if (!auth_hid_servs) return NULL;
  1255. return strmap_get(auth_hid_servs, onion_address);
  1256. }
  1257. /** Helper: Free storage held by rend_service_authorization_t. */
  1258. static void
  1259. rend_service_authorization_free(rend_service_authorization_t *auth)
  1260. {
  1261. tor_free(auth);
  1262. }
  1263. /** Helper for strmap_free. */
  1264. static void
  1265. rend_service_authorization_strmap_item_free(void *service_auth)
  1266. {
  1267. rend_service_authorization_free(service_auth);
  1268. }
  1269. /** Release all the storage held in auth_hid_servs.
  1270. */
  1271. void
  1272. rend_service_authorization_free_all(void)
  1273. {
  1274. if (!auth_hid_servs) {
  1275. return;
  1276. }
  1277. strmap_free(auth_hid_servs, rend_service_authorization_strmap_item_free);
  1278. auth_hid_servs = NULL;
  1279. }
  1280. /** Parse <b>config_line</b> as a client-side authorization for a hidden
  1281. * service and add it to the local map of hidden service authorizations.
  1282. * Return 0 for success and -1 for failure. */
  1283. int
  1284. rend_parse_service_authorization(const or_options_t *options,
  1285. int validate_only)
  1286. {
  1287. config_line_t *line;
  1288. int res = -1;
  1289. strmap_t *parsed = strmap_new();
  1290. smartlist_t *sl = smartlist_new();
  1291. rend_service_authorization_t *auth = NULL;
  1292. char descriptor_cookie_tmp[REND_DESC_COOKIE_LEN+2];
  1293. char descriptor_cookie_base64ext[REND_DESC_COOKIE_LEN_BASE64+2+1];
  1294. for (line = options->HidServAuth; line; line = line->next) {
  1295. char *onion_address, *descriptor_cookie;
  1296. int auth_type_val = 0;
  1297. auth = NULL;
  1298. SMARTLIST_FOREACH(sl, char *, c, tor_free(c););
  1299. smartlist_clear(sl);
  1300. smartlist_split_string(sl, line->value, " ",
  1301. SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 3);
  1302. if (smartlist_len(sl) < 2) {
  1303. log_warn(LD_CONFIG, "Configuration line does not consist of "
  1304. "\"onion-address authorization-cookie [service-name]\": "
  1305. "'%s'", line->value);
  1306. goto err;
  1307. }
  1308. auth = tor_malloc_zero(sizeof(rend_service_authorization_t));
  1309. /* Parse onion address. */
  1310. onion_address = smartlist_get(sl, 0);
  1311. if (strlen(onion_address) != REND_SERVICE_ADDRESS_LEN ||
  1312. strcmpend(onion_address, ".onion")) {
  1313. log_warn(LD_CONFIG, "Onion address has wrong format: '%s'",
  1314. onion_address);
  1315. goto err;
  1316. }
  1317. strlcpy(auth->onion_address, onion_address, REND_SERVICE_ID_LEN_BASE32+1);
  1318. if (!rend_valid_service_id(auth->onion_address)) {
  1319. log_warn(LD_CONFIG, "Onion address has wrong format: '%s'",
  1320. onion_address);
  1321. goto err;
  1322. }
  1323. /* Parse descriptor cookie. */
  1324. descriptor_cookie = smartlist_get(sl, 1);
  1325. if (strlen(descriptor_cookie) != REND_DESC_COOKIE_LEN_BASE64) {
  1326. log_warn(LD_CONFIG, "Authorization cookie has wrong length: '%s'",
  1327. descriptor_cookie);
  1328. goto err;
  1329. }
  1330. /* Add trailing zero bytes (AA) to make base64-decoding happy. */
  1331. tor_snprintf(descriptor_cookie_base64ext,
  1332. REND_DESC_COOKIE_LEN_BASE64+2+1,
  1333. "%sAA", descriptor_cookie);
  1334. if (base64_decode(descriptor_cookie_tmp, sizeof(descriptor_cookie_tmp),
  1335. descriptor_cookie_base64ext,
  1336. strlen(descriptor_cookie_base64ext)) < 0) {
  1337. log_warn(LD_CONFIG, "Decoding authorization cookie failed: '%s'",
  1338. descriptor_cookie);
  1339. goto err;
  1340. }
  1341. auth_type_val = (((uint8_t)descriptor_cookie_tmp[16]) >> 4) + 1;
  1342. if (auth_type_val < 1 || auth_type_val > 2) {
  1343. log_warn(LD_CONFIG, "Authorization cookie has unknown authorization "
  1344. "type encoded.");
  1345. goto err;
  1346. }
  1347. auth->auth_type = auth_type_val == 1 ? REND_BASIC_AUTH : REND_STEALTH_AUTH;
  1348. memcpy(auth->descriptor_cookie, descriptor_cookie_tmp,
  1349. REND_DESC_COOKIE_LEN);
  1350. if (strmap_get(parsed, auth->onion_address)) {
  1351. log_warn(LD_CONFIG, "Duplicate authorization for the same hidden "
  1352. "service.");
  1353. goto err;
  1354. }
  1355. strmap_set(parsed, auth->onion_address, auth);
  1356. auth = NULL;
  1357. }
  1358. res = 0;
  1359. goto done;
  1360. err:
  1361. res = -1;
  1362. done:
  1363. rend_service_authorization_free(auth);
  1364. SMARTLIST_FOREACH(sl, char *, c, tor_free(c););
  1365. smartlist_free(sl);
  1366. if (!validate_only && res == 0) {
  1367. rend_service_authorization_free_all();
  1368. auth_hid_servs = parsed;
  1369. } else {
  1370. strmap_free(parsed, rend_service_authorization_strmap_item_free);
  1371. }
  1372. memwipe(descriptor_cookie_tmp, 0, sizeof(descriptor_cookie_tmp));
  1373. memwipe(descriptor_cookie_base64ext, 0, sizeof(descriptor_cookie_base64ext));
  1374. return res;
  1375. }