rendclient.c 57 KB

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