rendclient.c
上传用户:awang829
上传日期:2019-07-14
资源大小:2356k
文件大小:37k
源码类别:

网络

开发平台:

Unix_Linux

  1. /* Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  2.  * Copyright (c) 2007-2009, 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. /** Called when we've established a circuit to an introduction point:
  10.  * send the introduction request. */
  11. void
  12. rend_client_introcirc_has_opened(origin_circuit_t *circ)
  13. {
  14.   tor_assert(circ->_base.purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
  15.   tor_assert(circ->cpath);
  16.   log_info(LD_REND,"introcirc is open");
  17.   connection_ap_attach_pending();
  18. }
  19. /** Send the establish-rendezvous cell along a rendezvous circuit. if
  20.  * it fails, mark the circ for close and return -1. else return 0.
  21.  */
  22. static int
  23. rend_client_send_establish_rendezvous(origin_circuit_t *circ)
  24. {
  25.   tor_assert(circ->_base.purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND);
  26.   tor_assert(circ->rend_data);
  27.   log_info(LD_REND, "Sending an ESTABLISH_RENDEZVOUS cell");
  28.   if (crypto_rand(circ->rend_data->rend_cookie, REND_COOKIE_LEN) < 0) {
  29.     log_warn(LD_BUG, "Internal error: Couldn't produce random cookie.");
  30.     circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  31.     return -1;
  32.   }
  33.   if (relay_send_command_from_edge(0, TO_CIRCUIT(circ),
  34.                                    RELAY_COMMAND_ESTABLISH_RENDEZVOUS,
  35.                                    circ->rend_data->rend_cookie,
  36.                                    REND_COOKIE_LEN,
  37.                                    circ->cpath->prev)<0) {
  38.     /* circ is already marked for close */
  39.     log_warn(LD_GENERAL, "Couldn't send ESTABLISH_RENDEZVOUS cell");
  40.     return -1;
  41.   }
  42.   return 0;
  43. }
  44. /** Called when we're trying to connect an ap conn; sends an INTRODUCE1 cell
  45.  * down introcirc if possible.
  46.  */
  47. int
  48. rend_client_send_introduction(origin_circuit_t *introcirc,
  49.                               origin_circuit_t *rendcirc)
  50. {
  51.   size_t payload_len;
  52.   int r, v3_shift = 0;
  53.   char payload[RELAY_PAYLOAD_SIZE];
  54.   char tmp[RELAY_PAYLOAD_SIZE];
  55.   rend_cache_entry_t *entry;
  56.   crypt_path_t *cpath;
  57.   off_t dh_offset;
  58.   crypto_pk_env_t *intro_key; /* either Bob's public key or an intro key. */
  59.   tor_assert(introcirc->_base.purpose == CIRCUIT_PURPOSE_C_INTRODUCING);
  60.   tor_assert(rendcirc->_base.purpose == CIRCUIT_PURPOSE_C_REND_READY);
  61.   tor_assert(introcirc->rend_data);
  62.   tor_assert(rendcirc->rend_data);
  63.   tor_assert(!rend_cmp_service_ids(introcirc->rend_data->onion_address,
  64.                                    rendcirc->rend_data->onion_address));
  65.   if (rend_cache_lookup_entry(introcirc->rend_data->onion_address, -1,
  66.                               &entry) < 1) {
  67.     log_warn(LD_REND,
  68.              "query %s didn't have valid rend desc in cache. Failing.",
  69.              escaped_safe_str(introcirc->rend_data->onion_address));
  70.     goto err;
  71.   }
  72.   /* first 20 bytes of payload are the hash of Bob's pk */
  73.   if (entry->parsed->version == 0) { /* un-versioned descriptor */
  74.     intro_key = entry->parsed->pk;
  75.   } else { /* versioned descriptor */
  76.     intro_key = NULL;
  77.     SMARTLIST_FOREACH(entry->parsed->intro_nodes, rend_intro_point_t *,
  78.                       intro, {
  79.       if (!memcmp(introcirc->build_state->chosen_exit->identity_digest,
  80.                   intro->extend_info->identity_digest, DIGEST_LEN)) {
  81.         intro_key = intro->intro_key;
  82.         break;
  83.       }
  84.     });
  85.     if (!intro_key) {
  86.       /** XXX This case probably means that the intro point vanished while
  87.        * we were building a circuit to it. In the future, we should find
  88.        * out how that happened and whether we should kill the circuits to
  89.        * removed intro points immediately. See task 1073. */
  90.       int num_intro_points = smartlist_len(entry->parsed->intro_nodes);
  91.       if (rend_cache_lookup_entry(introcirc->rend_data->onion_address,
  92.           0, &entry) > 0) {
  93.         log_info(LD_REND, "We have both a v0 and a v2 rend desc for this "
  94.                  "service. The v2 desc doesn't contain the introduction "
  95.                  "point (and key) to send an INTRODUCE1/2 cell to this "
  96.                  "introduction point. Assuming the introduction point "
  97.                  "is for v0 rend clients and using the service key "
  98.                  "from the v0 desc instead. (This is probably a bug, "
  99.                  "because we shouldn't even have both a v0 and a v2 "
  100.                  "descriptor for the same service.)");
  101.         /* See flyspray task 1024. */
  102.         intro_key = entry->parsed->pk;
  103.       } else {
  104.         log_info(LD_REND, "Internal error: could not find intro key; we "
  105.                  "only have a v2 rend desc with %d intro points.",
  106.                  num_intro_points);
  107.         goto err;
  108.       }
  109.     }
  110.   }
  111.   if (crypto_pk_get_digest(intro_key, payload)<0) {
  112.     log_warn(LD_BUG, "Internal error: couldn't hash public key.");
  113.     goto err;
  114.   }
  115.   /* Initialize the pending_final_cpath and start the DH handshake. */
  116.   cpath = rendcirc->build_state->pending_final_cpath;
  117.   if (!cpath) {
  118.     cpath = rendcirc->build_state->pending_final_cpath =
  119.       tor_malloc_zero(sizeof(crypt_path_t));
  120.     cpath->magic = CRYPT_PATH_MAGIC;
  121.     if (!(cpath->dh_handshake_state = crypto_dh_new())) {
  122.       log_warn(LD_BUG, "Internal error: couldn't allocate DH.");
  123.       goto err;
  124.     }
  125.     if (crypto_dh_generate_public(cpath->dh_handshake_state)<0) {
  126.       log_warn(LD_BUG, "Internal error: couldn't generate g^x.");
  127.       goto err;
  128.     }
  129.   }
  130.   /* If version is 3, write (optional) auth data and timestamp. */
  131.   if (entry->parsed->protocols & (1<<3)) {
  132.     tmp[0] = 3; /* version 3 of the cell format */
  133.     tmp[1] = (uint8_t)introcirc->rend_data->auth_type; /* auth type, if any */
  134.     v3_shift = 1;
  135.     if (introcirc->rend_data->auth_type != REND_NO_AUTH) {
  136.       set_uint16(tmp+2, htons(REND_DESC_COOKIE_LEN));
  137.       memcpy(tmp+4, introcirc->rend_data->descriptor_cookie,
  138.              REND_DESC_COOKIE_LEN);
  139.       v3_shift += 2+REND_DESC_COOKIE_LEN;
  140.     }
  141.     set_uint32(tmp+v3_shift+1, htonl((uint32_t)time(NULL)));
  142.     v3_shift += 4;
  143.   } /* if version 2 only write version number */
  144.   else if (entry->parsed->protocols & (1<<2)) {
  145.     tmp[0] = 2; /* version 2 of the cell format */
  146.   }
  147.   /* write the remaining items into tmp */
  148.   if (entry->parsed->protocols & (1<<3) || entry->parsed->protocols & (1<<2)) {
  149.     /* version 2 format */
  150.     extend_info_t *extend_info = rendcirc->build_state->chosen_exit;
  151.     int klen;
  152.     /* nul pads */
  153.     set_uint32(tmp+v3_shift+1, tor_addr_to_ipv4h(&extend_info->addr));
  154.     set_uint16(tmp+v3_shift+5, htons(extend_info->port));
  155.     memcpy(tmp+v3_shift+7, extend_info->identity_digest, DIGEST_LEN);
  156.     klen = crypto_pk_asn1_encode(extend_info->onion_key,
  157.                                  tmp+v3_shift+7+DIGEST_LEN+2,
  158.                                  sizeof(tmp)-(v3_shift+7+DIGEST_LEN+2));
  159.     set_uint16(tmp+v3_shift+7+DIGEST_LEN, htons(klen));
  160.     memcpy(tmp+v3_shift+7+DIGEST_LEN+2+klen, rendcirc->rend_data->rend_cookie,
  161.            REND_COOKIE_LEN);
  162.     dh_offset = v3_shift+7+DIGEST_LEN+2+klen+REND_COOKIE_LEN;
  163.   } else {
  164.     /* Version 0. */
  165.     strncpy(tmp, rendcirc->build_state->chosen_exit->nickname,
  166.             (MAX_NICKNAME_LEN+1)); /* nul pads */
  167.     memcpy(tmp+MAX_NICKNAME_LEN+1, rendcirc->rend_data->rend_cookie,
  168.            REND_COOKIE_LEN);
  169.     dh_offset = MAX_NICKNAME_LEN+1+REND_COOKIE_LEN;
  170.   }
  171.   if (crypto_dh_get_public(cpath->dh_handshake_state, tmp+dh_offset,
  172.                            DH_KEY_LEN)<0) {
  173.     log_warn(LD_BUG, "Internal error: couldn't extract g^x.");
  174.     goto err;
  175.   }
  176.   note_crypto_pk_op(REND_CLIENT);
  177.   /*XXX maybe give crypto_pk_public_hybrid_encrypt a max_len arg,
  178.    * to avoid buffer overflows? */
  179.   r = crypto_pk_public_hybrid_encrypt(intro_key, payload+DIGEST_LEN,
  180.                                       tmp,
  181.                                       (int)(dh_offset+DH_KEY_LEN),
  182.                                       PK_PKCS1_OAEP_PADDING, 0);
  183.   if (r<0) {
  184.     log_warn(LD_BUG,"Internal error: hybrid pk encrypt failed.");
  185.     goto err;
  186.   }
  187.   payload_len = DIGEST_LEN + r;
  188.   tor_assert(payload_len <= RELAY_PAYLOAD_SIZE); /* we overran something */
  189.   log_info(LD_REND, "Sending an INTRODUCE1 cell");
  190.   if (relay_send_command_from_edge(0, TO_CIRCUIT(introcirc),
  191.                                    RELAY_COMMAND_INTRODUCE1,
  192.                                    payload, payload_len,
  193.                                    introcirc->cpath->prev)<0) {
  194.     /* introcirc is already marked for close. leave rendcirc alone. */
  195.     log_warn(LD_BUG, "Couldn't send INTRODUCE1 cell");
  196.     return -1;
  197.   }
  198.   /* Now, we wait for an ACK or NAK on this circuit. */
  199.   introcirc->_base.purpose = CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT;
  200.   return 0;
  201. err:
  202.   circuit_mark_for_close(TO_CIRCUIT(introcirc), END_CIRC_REASON_INTERNAL);
  203.   circuit_mark_for_close(TO_CIRCUIT(rendcirc), END_CIRC_REASON_INTERNAL);
  204.   return -1;
  205. }
  206. /** Called when a rendezvous circuit is open; sends a establish
  207.  * rendezvous circuit as appropriate. */
  208. void
  209. rend_client_rendcirc_has_opened(origin_circuit_t *circ)
  210. {
  211.   tor_assert(circ->_base.purpose == CIRCUIT_PURPOSE_C_ESTABLISH_REND);
  212.   log_info(LD_REND,"rendcirc is open");
  213.   /* generate a rendezvous cookie, store it in circ */
  214.   if (rend_client_send_establish_rendezvous(circ) < 0) {
  215.     return;
  216.   }
  217. }
  218. /** Called when get an ACK or a NAK for a REND_INTRODUCE1 cell.
  219.  */
  220. int
  221. rend_client_introduction_acked(origin_circuit_t *circ,
  222.                                const char *request, size_t request_len)
  223. {
  224.   origin_circuit_t *rendcirc;
  225.   (void) request; // XXXX Use this.
  226.   if (circ->_base.purpose != CIRCUIT_PURPOSE_C_INTRODUCE_ACK_WAIT) {
  227.     log_warn(LD_PROTOCOL,
  228.              "Received REND_INTRODUCE_ACK on unexpected circuit %d.",
  229.              circ->_base.n_circ_id);
  230.     circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  231.     return -1;
  232.   }
  233.   tor_assert(circ->build_state->chosen_exit);
  234.   tor_assert(circ->rend_data);
  235.   if (request_len == 0) {
  236.     /* It's an ACK; the introduction point relayed our introduction request. */
  237.     /* Locate the rend circ which is waiting to hear about this ack,
  238.      * and tell it.
  239.      */
  240.     log_info(LD_REND,"Received ack. Telling rend circ...");
  241.     rendcirc = circuit_get_by_rend_query_and_purpose(
  242.                circ->rend_data->onion_address, CIRCUIT_PURPOSE_C_REND_READY);
  243.     if (rendcirc) { /* remember the ack */
  244.       rendcirc->_base.purpose = CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED;
  245.     } else {
  246.       log_info(LD_REND,"...Found no rend circ. Dropping on the floor.");
  247.     }
  248.     /* close the circuit: we won't need it anymore. */
  249.     circ->_base.purpose = CIRCUIT_PURPOSE_C_INTRODUCE_ACKED;
  250.     circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_FINISHED);
  251.   } else {
  252.     /* It's a NAK; the introduction point didn't relay our request. */
  253.     circ->_base.purpose = CIRCUIT_PURPOSE_C_INTRODUCING;
  254.     /* Remove this intro point from the set of viable introduction
  255.      * points. If any remain, extend to a new one and try again.
  256.      * If none remain, refetch the service descriptor.
  257.      */
  258.     if (rend_client_remove_intro_point(circ->build_state->chosen_exit,
  259.                                        circ->rend_data) > 0) {
  260.       /* There are introduction points left. Re-extend the circuit to
  261.        * another intro point and try again. */
  262.       extend_info_t *extend_info;
  263.       int result;
  264.       extend_info = rend_client_get_random_intro(circ->rend_data);
  265.       if (!extend_info) {
  266.         log_warn(LD_REND, "No introduction points left for %s. Closing.",
  267.                  escaped_safe_str(circ->rend_data->onion_address));
  268.         circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_INTERNAL);
  269.         return -1;
  270.       }
  271.       if (circ->remaining_relay_early_cells) {
  272.         log_info(LD_REND,
  273.                  "Got nack for %s from %s. Re-extending circ %d, "
  274.                  "this time to %s.",
  275.                  escaped_safe_str(circ->rend_data->onion_address),
  276.                  circ->build_state->chosen_exit->nickname,
  277.                  circ->_base.n_circ_id, extend_info->nickname);
  278.         result = circuit_extend_to_new_exit(circ, extend_info);
  279.       } else {
  280.         log_info(LD_REND,
  281.                  "Got nack for %s from %s. Building a new introduction "
  282.                  "circuit, this time to %s.",
  283.                  escaped_safe_str(circ->rend_data->onion_address),
  284.                  circ->build_state->chosen_exit->nickname,
  285.                  extend_info->nickname);
  286.         circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_FINISHED);
  287.         if (!circuit_launch_by_extend_info(CIRCUIT_PURPOSE_C_INTRODUCING,
  288.                                            extend_info,
  289.                                            CIRCLAUNCH_IS_INTERNAL)) {
  290.           log_warn(LD_REND, "Building introduction circuit failed.");
  291.           result = -1;
  292.         } else {
  293.           result = 0;
  294.         }
  295.       }
  296.       extend_info_free(extend_info);
  297.       return result;
  298.     }
  299.   }
  300.   return 0;
  301. }
  302. /** The period for which a hidden service directory cannot be queried for
  303.  * the same descriptor ID again. */
  304. #define REND_HID_SERV_DIR_REQUERY_PERIOD (15 * 60)
  305. /** Contains the last request times to hidden service directories for
  306.  * certain queries; keys are strings consisting of base32-encoded
  307.  * hidden service directory identities and base32-encoded descriptor IDs;
  308.  * values are pointers to timestamps of the last requests. */
  309. static strmap_t *last_hid_serv_requests = NULL;
  310. /** Look up the last request time to hidden service directory <b>hs_dir</b>
  311.  * for descriptor ID <b>desc_id_base32</b>. If <b>set</b> is non-zero,
  312.  * assign the current time <b>now</b> and return that. Otherwise, return
  313.  * the most recent request time, or 0 if no such request has been sent
  314.  * before. */
  315. static time_t
  316. lookup_last_hid_serv_request(routerstatus_t *hs_dir,
  317.                              const char *desc_id_base32, time_t now, int set)
  318. {
  319.   char hsdir_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  320.   char hsdir_desc_comb_id[2 * REND_DESC_ID_V2_LEN_BASE32 + 1];
  321.   time_t *last_request_ptr;
  322.   base32_encode(hsdir_id_base32, sizeof(hsdir_id_base32),
  323.                 hs_dir->identity_digest, DIGEST_LEN);
  324.   tor_snprintf(hsdir_desc_comb_id, sizeof(hsdir_desc_comb_id), "%s%s",
  325.                hsdir_id_base32, desc_id_base32);
  326.   if (set) {
  327.     last_request_ptr = tor_malloc_zero(sizeof(time_t *));
  328.     *last_request_ptr = now;
  329.     strmap_set(last_hid_serv_requests, hsdir_desc_comb_id, last_request_ptr);
  330.   } else
  331.     last_request_ptr = strmap_get_lc(last_hid_serv_requests,
  332.                                      hsdir_desc_comb_id);
  333.   return (last_request_ptr) ? *last_request_ptr : 0;
  334. }
  335. /** Clean the history of request times to hidden service directories, so that
  336.  * it does not contain requests older than REND_HID_SERV_DIR_REQUERY_PERIOD
  337.  * seconds any more. */
  338. static void
  339. directory_clean_last_hid_serv_requests(void)
  340. {
  341.   strmap_iter_t *iter;
  342.   time_t cutoff = time(NULL) - REND_HID_SERV_DIR_REQUERY_PERIOD;
  343.   if (!last_hid_serv_requests)
  344.     last_hid_serv_requests = strmap_new();
  345.   for (iter = strmap_iter_init(last_hid_serv_requests);
  346.        !strmap_iter_done(iter); ) {
  347.     const char *key;
  348.     void *val;
  349.     time_t *ent;
  350.     strmap_iter_get(iter, &key, &val);
  351.     ent = (time_t *) val;
  352.     if (*ent < cutoff) {
  353.       iter = strmap_iter_next_rmv(last_hid_serv_requests, iter);
  354.       tor_free(ent);
  355.     } else {
  356.       iter = strmap_iter_next(last_hid_serv_requests, iter);
  357.     }
  358.   }
  359. }
  360. /** Determine the responsible hidden service directories for <b>desc_id</b>
  361.  * and fetch the descriptor belonging to that ID from one of them. Only
  362.  * send a request to hidden service directories that we did not try within
  363.  * the last REND_HID_SERV_DIR_REQUERY_PERIOD seconds; on success, return 1,
  364.  * in the case that no hidden service directory is left to ask for the
  365.  * descriptor, return 0, and in case of a failure -1. <b>query</b> is only
  366.  * passed for pretty log statements. */
  367. static int
  368. directory_get_from_hs_dir(const char *desc_id, const rend_data_t *rend_query)
  369. {
  370.   smartlist_t *responsible_dirs = smartlist_create();
  371.   routerstatus_t *hs_dir;
  372.   char desc_id_base32[REND_DESC_ID_V2_LEN_BASE32 + 1];
  373.   time_t now = time(NULL);
  374.   char descriptor_cookie_base64[3*REND_DESC_COOKIE_LEN_BASE64];
  375.   tor_assert(desc_id);
  376.   tor_assert(rend_query);
  377.   /* Determine responsible dirs. Even if we can't get all we want,
  378.    * work with the ones we have. If it's empty, we'll notice below. */
  379.   (int) hid_serv_get_responsible_directories(responsible_dirs, desc_id);
  380.   base32_encode(desc_id_base32, sizeof(desc_id_base32),
  381.                 desc_id, DIGEST_LEN);
  382.   /* Only select those hidden service directories to which we did not send
  383.    * a request recently and for which we have a router descriptor here. */
  384.   directory_clean_last_hid_serv_requests(); /* Clean request history first. */
  385.   SMARTLIST_FOREACH(responsible_dirs, routerstatus_t *, dir, {
  386.     if (lookup_last_hid_serv_request(dir, desc_id_base32, 0, 0) +
  387.             REND_HID_SERV_DIR_REQUERY_PERIOD >= now ||
  388.         !router_get_by_digest(dir->identity_digest))
  389.       SMARTLIST_DEL_CURRENT(responsible_dirs, dir);
  390.   });
  391.   hs_dir = smartlist_choose(responsible_dirs);
  392.   smartlist_free(responsible_dirs);
  393.   if (!hs_dir) {
  394.     log_info(LD_REND, "Could not pick one of the responsible hidden "
  395.                       "service directories, because we requested them all "
  396.                       "recently without success.");
  397.     return 0;
  398.   }
  399.   /* Remember, that we are requesting a descriptor from this hidden service
  400.    * directory now. */
  401.   lookup_last_hid_serv_request(hs_dir, desc_id_base32, now, 1);
  402.   /* Encode descriptor cookie for logging purposes. */
  403.   if (rend_query->auth_type != REND_NO_AUTH) {
  404.     if (base64_encode(descriptor_cookie_base64,
  405.                       sizeof(descriptor_cookie_base64),
  406.                       rend_query->descriptor_cookie, REND_DESC_COOKIE_LEN)<0) {
  407.       log_warn(LD_BUG, "Could not base64-encode descriptor cookie.");
  408.       return 0;
  409.     }
  410.     /* Remove == signs and newline. */
  411.     descriptor_cookie_base64[strlen(descriptor_cookie_base64)-3] = '';
  412.   } else {
  413.     strlcpy(descriptor_cookie_base64, "(none)",
  414.             sizeof(descriptor_cookie_base64));
  415.   }
  416.   /* Send fetch request. (Pass query and possibly descriptor cookie so that
  417.    * they can be written to the directory connection and be referred to when
  418.    * the response arrives. */
  419.   directory_initiate_command_routerstatus_rend(hs_dir,
  420.                                           DIR_PURPOSE_FETCH_RENDDESC_V2,
  421.                                           ROUTER_PURPOSE_GENERAL,
  422.                                           1, desc_id_base32, NULL, 0, 0,
  423.                                           rend_query);
  424.   log_info(LD_REND, "Sending fetch request for v2 descriptor for "
  425.                     "service '%s' with descriptor ID '%s', auth type %d, "
  426.                     "and descriptor cookie '%s' to hidden service "
  427.                     "directory '%s' on port %d.",
  428.            rend_query->onion_address, desc_id_base32,
  429.            rend_query->auth_type,
  430.            (rend_query->auth_type == REND_NO_AUTH ? "[none]" :
  431.            escaped_safe_str(descriptor_cookie_base64)),
  432.            hs_dir->nickname, hs_dir->dir_port);
  433.   return 1;
  434. }
  435. /** If we are not currently fetching a rendezvous service descriptor
  436.  * for the service ID <b>query</b>, start a directory connection to fetch a
  437.  * new one.
  438.  */
  439. void
  440. rend_client_refetch_renddesc(const char *query)
  441. {
  442.   if (!get_options()->FetchHidServDescriptors)
  443.     return;
  444.   log_info(LD_REND, "Fetching rendezvous descriptor for service %s",
  445.            escaped_safe_str(query));
  446.   if (connection_get_by_type_state_rendquery(CONN_TYPE_DIR, 0, query, 0)) {
  447.     log_info(LD_REND,"Would fetch a new renddesc here (for %s), but one is "
  448.              "already in progress.", escaped_safe_str(query));
  449.   } else {
  450.     /* not one already; initiate a dir rend desc lookup */
  451.     directory_get_from_dirserver(DIR_PURPOSE_FETCH_RENDDESC,
  452.                                  ROUTER_PURPOSE_GENERAL, query,
  453.                                  PDS_RETRY_IF_NO_SERVERS);
  454.   }
  455. }
  456. /** Start a connection to a hidden service directory to fetch a v2
  457.  * rendezvous service descriptor for the base32-encoded service ID
  458.  * <b>query</b>.
  459.  */
  460. void
  461. rend_client_refetch_v2_renddesc(const rend_data_t *rend_query)
  462. {
  463.   char descriptor_id[DIGEST_LEN];
  464.   int replicas_left_to_try[REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS];
  465.   int i, tries_left, r;
  466.   rend_cache_entry_t *e = NULL;
  467.   time_t now = time(NULL);
  468.   tor_assert(rend_query);
  469.   /* Are we configured to fetch descriptors? */
  470.   if (!get_options()->FetchHidServDescriptors) {
  471.     log_warn(LD_REND, "We received an onion address for a v2 rendezvous "
  472.         "service descriptor, but are not fetching service descriptors.");
  473.     return;
  474.   }
  475.   /* Before fetching, check if we already have the descriptor here. */
  476.   r = rend_cache_lookup_entry(rend_query->onion_address, -1, &e);
  477.   if (r > 0 && now - e->received < NUM_SECONDS_BEFORE_HS_REFETCH) {
  478.     log_info(LD_REND, "We would fetch a v2 rendezvous descriptor, but we "
  479.                       "already have a fresh copy of that descriptor here. "
  480.                       "Not fetching.");
  481.     return;
  482.   }
  483.   log_debug(LD_REND, "Fetching v2 rendezvous descriptor for service %s",
  484.             safe_str(rend_query->onion_address));
  485.   /* Randomly iterate over the replicas until a descriptor can be fetched
  486.    * from one of the consecutive nodes, or no options are left. */
  487.   tries_left = REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS;
  488.   for (i = 0; i < REND_NUMBER_OF_NON_CONSECUTIVE_REPLICAS; i++)
  489.     replicas_left_to_try[i] = i;
  490.   while (tries_left > 0) {
  491.     int rand = crypto_rand_int(tries_left);
  492.     int chosen_replica = replicas_left_to_try[rand];
  493.     replicas_left_to_try[rand] = replicas_left_to_try[--tries_left];
  494.     if (rend_compute_v2_desc_id(descriptor_id, rend_query->onion_address,
  495.                                 rend_query->auth_type == REND_STEALTH_AUTH ?
  496.                                     rend_query->descriptor_cookie : NULL,
  497.                                 time(NULL), chosen_replica) < 0) {
  498.       log_warn(LD_REND, "Internal error: Computing v2 rendezvous "
  499.                         "descriptor ID did not succeed.");
  500.       return;
  501.     }
  502.     if (directory_get_from_hs_dir(descriptor_id, rend_query) != 0)
  503.       return; /* either success or failure, but we're done */
  504.   }
  505.   /* If we come here, there are no hidden service directories left. */
  506.   log_info(LD_REND, "Could not pick one of the responsible hidden "
  507.                     "service directories to fetch descriptors, because "
  508.                     "we already tried them all unsuccessfully.");
  509.   /* Close pending connections (unless a v0 request is still going on). */
  510.   rend_client_desc_trynow(rend_query->onion_address, 2);
  511.   return;
  512. }
  513. /** Remove failed_intro from ent. If ent now has no intro points, or
  514.  * service is unrecognized, then launch a new renddesc fetch.
  515.  *
  516.  * Return -1 if error, 0 if no intro points remain or service
  517.  * unrecognized, 1 if recognized and some intro points remain.
  518.  */
  519. int
  520. rend_client_remove_intro_point(extend_info_t *failed_intro,
  521.                                const rend_data_t *rend_query)
  522. {
  523.   int i, r;
  524.   rend_cache_entry_t *ent;
  525.   connection_t *conn;
  526.   r = rend_cache_lookup_entry(rend_query->onion_address, -1, &ent);
  527.   if (r<0) {
  528.     log_warn(LD_BUG, "Malformed service ID %s.",
  529.              escaped_safe_str(rend_query->onion_address));
  530.     return -1;
  531.   }
  532.   if (r==0) {
  533.     log_info(LD_REND, "Unknown service %s. Re-fetching descriptor.",
  534.              escaped_safe_str(rend_query->onion_address));
  535.     /* Fetch both, v0 and v2 rend descriptors in parallel. Use whichever
  536.      * arrives first. Exception: When using client authorization, only
  537.      * fetch v2 descriptors.*/
  538.     rend_client_refetch_v2_renddesc(rend_query);
  539.     if (rend_query->auth_type == REND_NO_AUTH)
  540.       rend_client_refetch_renddesc(rend_query->onion_address);
  541.     return 0;
  542.   }
  543.   for (i = 0; i < smartlist_len(ent->parsed->intro_nodes); i++) {
  544.     rend_intro_point_t *intro = smartlist_get(ent->parsed->intro_nodes, i);
  545.     if (!memcmp(failed_intro->identity_digest,
  546.                 intro->extend_info->identity_digest, DIGEST_LEN)) {
  547.       rend_intro_point_free(intro);
  548.       smartlist_del(ent->parsed->intro_nodes, i);
  549.       break;
  550.     }
  551.   }
  552.   if (smartlist_len(ent->parsed->intro_nodes) == 0) {
  553.     log_info(LD_REND,
  554.              "No more intro points remain for %s. Re-fetching descriptor.",
  555.              escaped_safe_str(rend_query->onion_address));
  556.     /* Fetch both, v0 and v2 rend descriptors in parallel. Use whichever
  557.      * arrives first. Exception: When using client authorization, only
  558.      * fetch v2 descriptors.*/
  559.     rend_client_refetch_v2_renddesc(rend_query);
  560.     if (rend_query->auth_type == REND_NO_AUTH)
  561.       rend_client_refetch_renddesc(rend_query->onion_address);
  562.     /* move all pending streams back to renddesc_wait */
  563.     while ((conn = connection_get_by_type_state_rendquery(CONN_TYPE_AP,
  564.                                    AP_CONN_STATE_CIRCUIT_WAIT,
  565.                                    rend_query->onion_address, -1))) {
  566.       conn->state = AP_CONN_STATE_RENDDESC_WAIT;
  567.     }
  568.     return 0;
  569.   }
  570.   log_info(LD_REND,"%d options left for %s.",
  571.            smartlist_len(ent->parsed->intro_nodes),
  572.            escaped_safe_str(rend_query->onion_address));
  573.   return 1;
  574. }
  575. /** Called when we receive a RENDEZVOUS_ESTABLISHED cell; changes the state of
  576.  * the circuit to C_REND_READY.
  577.  */
  578. int
  579. rend_client_rendezvous_acked(origin_circuit_t *circ, const char *request,
  580.                              size_t request_len)
  581. {
  582.   (void) request;
  583.   (void) request_len;
  584.   /* we just got an ack for our establish-rendezvous. switch purposes. */
  585.   if (circ->_base.purpose != CIRCUIT_PURPOSE_C_ESTABLISH_REND) {
  586.     log_warn(LD_PROTOCOL,"Got a rendezvous ack when we weren't expecting one. "
  587.              "Closing circ.");
  588.     circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  589.     return -1;
  590.   }
  591.   log_info(LD_REND,"Got rendezvous ack. This circuit is now ready for "
  592.            "rendezvous.");
  593.   circ->_base.purpose = CIRCUIT_PURPOSE_C_REND_READY;
  594.   /* XXXX022 This is a pretty brute-force approach. It'd be better to
  595.    * attach only the connections that are waiting on this circuit, rather
  596.    * than trying to attach them all. See comments bug 743. */
  597.   /* If we already have the introduction circuit built, make sure we send
  598.    * the INTRODUCE cell _now_ */
  599.   connection_ap_attach_pending();
  600.   return 0;
  601. }
  602. /** Bob sent us a rendezvous cell; join the circuits. */
  603. int
  604. rend_client_receive_rendezvous(origin_circuit_t *circ, const char *request,
  605.                                size_t request_len)
  606. {
  607.   crypt_path_t *hop;
  608.   char keys[DIGEST_LEN+CPATH_KEY_MATERIAL_LEN];
  609.   if ((circ->_base.purpose != CIRCUIT_PURPOSE_C_REND_READY &&
  610.        circ->_base.purpose != CIRCUIT_PURPOSE_C_REND_READY_INTRO_ACKED)
  611.       || !circ->build_state->pending_final_cpath) {
  612.     log_warn(LD_PROTOCOL,"Got rendezvous2 cell from hidden service, but not "
  613.              "expecting it. Closing.");
  614.     circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  615.     return -1;
  616.   }
  617.   if (request_len != DH_KEY_LEN+DIGEST_LEN) {
  618.     log_warn(LD_PROTOCOL,"Incorrect length (%d) on RENDEZVOUS2 cell.",
  619.              (int)request_len);
  620.     goto err;
  621.   }
  622.   log_info(LD_REND,"Got RENDEZVOUS2 cell from hidden service.");
  623.   /* first DH_KEY_LEN bytes are g^y from bob. Finish the dh handshake...*/
  624.   tor_assert(circ->build_state);
  625.   tor_assert(circ->build_state->pending_final_cpath);
  626.   hop = circ->build_state->pending_final_cpath;
  627.   tor_assert(hop->dh_handshake_state);
  628.   if (crypto_dh_compute_secret(hop->dh_handshake_state, request, DH_KEY_LEN,
  629.                                keys, DIGEST_LEN+CPATH_KEY_MATERIAL_LEN)<0) {
  630.     log_warn(LD_GENERAL, "Couldn't complete DH handshake.");
  631.     goto err;
  632.   }
  633.   /* ... and set up cpath. */
  634.   if (circuit_init_cpath_crypto(hop, keys+DIGEST_LEN, 0)<0)
  635.     goto err;
  636.   /* Check whether the digest is right... */
  637.   if (memcmp(keys, request+DH_KEY_LEN, DIGEST_LEN)) {
  638.     log_warn(LD_PROTOCOL, "Incorrect digest of key material.");
  639.     goto err;
  640.   }
  641.   crypto_dh_free(hop->dh_handshake_state);
  642.   hop->dh_handshake_state = NULL;
  643.   /* All is well. Extend the circuit. */
  644.   circ->_base.purpose = CIRCUIT_PURPOSE_C_REND_JOINED;
  645.   hop->state = CPATH_STATE_OPEN;
  646.   /* set the windows to default. these are the windows
  647.    * that alice thinks bob has.
  648.    */
  649.   hop->package_window = circuit_initial_package_window();
  650.   hop->deliver_window = CIRCWINDOW_START;
  651.   onion_append_to_cpath(&circ->cpath, hop);
  652.   circ->build_state->pending_final_cpath = NULL; /* prevent double-free */
  653.   /* XXXX022 This is a pretty brute-force approach. It'd be better to
  654.    * attach only the connections that are waiting on this circuit, rather
  655.    * than trying to attach them all. See comments bug 743. */
  656.   connection_ap_attach_pending();
  657.   return 0;
  658.  err:
  659.   circuit_mark_for_close(TO_CIRCUIT(circ), END_CIRC_REASON_TORPROTOCOL);
  660.   return -1;
  661. }
  662. /** Find all the apconns in state AP_CONN_STATE_RENDDESC_WAIT that
  663.  * are waiting on query. If there's a working cache entry here
  664.  * with at least one intro point, move them to the next state. If
  665.  * <b>rend_version</b> is non-negative, fail connections that have
  666.  * requested <b>query</b> unless there are still descriptor fetch
  667.  * requests in progress for other descriptor versions than
  668.  * <b>rend_version</b>.
  669.  */
  670. void
  671. rend_client_desc_trynow(const char *query, int rend_version)
  672. {
  673.   edge_connection_t *conn;
  674.   rend_cache_entry_t *entry;
  675.   time_t now = time(NULL);
  676.   smartlist_t *conns = get_connection_array();
  677.   SMARTLIST_FOREACH(conns, connection_t *, _conn,
  678.   {
  679.     if (_conn->type != CONN_TYPE_AP ||
  680.         _conn->state != AP_CONN_STATE_RENDDESC_WAIT ||
  681.         _conn->marked_for_close)
  682.       continue;
  683.     conn = TO_EDGE_CONN(_conn);
  684.     if (!conn->rend_data)
  685.       continue;
  686.     if (rend_cmp_service_ids(query, conn->rend_data->onion_address))
  687.       continue;
  688.     assert_connection_ok(TO_CONN(conn), now);
  689.     if (rend_cache_lookup_entry(conn->rend_data->onion_address, -1,
  690.                                 &entry) == 1 &&
  691.         smartlist_len(entry->parsed->intro_nodes) > 0) {
  692.       /* either this fetch worked, or it failed but there was a
  693.        * valid entry from before which we should reuse */
  694.       log_info(LD_REND,"Rend desc is usable. Launching circuits.");
  695.       conn->_base.state = AP_CONN_STATE_CIRCUIT_WAIT;
  696.       /* restart their timeout values, so they get a fair shake at
  697.        * connecting to the hidden service. */
  698.       conn->_base.timestamp_created = now;
  699.       conn->_base.timestamp_lastread = now;
  700.       conn->_base.timestamp_lastwritten = now;
  701.       if (connection_ap_handshake_attach_circuit(conn) < 0) {
  702.         /* it will never work */
  703.         log_warn(LD_REND,"Rendezvous attempt failed. Closing.");
  704.         if (!conn->_base.marked_for_close)
  705.           connection_mark_unattached_ap(conn, END_STREAM_REASON_CANT_ATTACH);
  706.       }
  707.     } else { /* 404, or fetch didn't get that far */
  708.       /* Unless there are requests for another descriptor version pending,
  709.        * close the connection. */
  710.       if (rend_version >= 0 &&
  711.           !connection_get_by_type_state_rendquery(CONN_TYPE_DIR, 0, query,
  712.                                                   rend_version == 0 ? 2 : 0)) {
  713.         log_notice(LD_REND,"Closing stream for '%s.onion': hidden service is "
  714.                    "unavailable (try again later).", safe_str(query));
  715.         connection_mark_unattached_ap(conn, END_STREAM_REASON_RESOLVEFAILED);
  716.       }
  717.     }
  718.   });
  719. }
  720. /** Return a newly allocated extend_info_t* for a randomly chosen introduction
  721.  * point for the named hidden service.  Return NULL if all introduction points
  722.  * have been tried and failed.
  723.  */
  724. extend_info_t *
  725. rend_client_get_random_intro(const rend_data_t *rend_query)
  726. {
  727.   int i;
  728.   rend_cache_entry_t *entry;
  729.   rend_intro_point_t *intro;
  730.   routerinfo_t *router;
  731.   if (rend_cache_lookup_entry(rend_query->onion_address, -1, &entry) < 1) {
  732.     log_warn(LD_REND,
  733.              "Query '%s' didn't have valid rend desc in cache. Failing.",
  734.              safe_str(rend_query->onion_address));
  735.     return NULL;
  736.   }
  737.  again:
  738.   if (smartlist_len(entry->parsed->intro_nodes) == 0)
  739.     return NULL;
  740.   i = crypto_rand_int(smartlist_len(entry->parsed->intro_nodes));
  741.   intro = smartlist_get(entry->parsed->intro_nodes, i);
  742.   /* Do we need to look up the router or is the extend info complete? */
  743.   if (!intro->extend_info->onion_key) {
  744.     router = router_get_by_nickname(intro->extend_info->nickname, 0);
  745.     if (!router) {
  746.       log_info(LD_REND, "Unknown router with nickname '%s'; trying another.",
  747.                intro->extend_info->nickname);
  748.       rend_intro_point_free(intro);
  749.       smartlist_del(entry->parsed->intro_nodes, i);
  750.       goto again;
  751.     }
  752.     extend_info_free(intro->extend_info);
  753.     intro->extend_info = extend_info_from_router(router);
  754.   }
  755.   return extend_info_dup(intro->extend_info);
  756. }
  757. /** Client-side authorizations for hidden services; map of onion address to
  758.  * rend_service_authorization_t*. */
  759. static strmap_t *auth_hid_servs = NULL;
  760. /** Look up the client-side authorization for the hidden service with
  761.  * <b>onion_address</b>. Return NULL if no authorization is available for
  762.  * that address. */
  763. rend_service_authorization_t*
  764. rend_client_lookup_service_authorization(const char *onion_address)
  765. {
  766.   tor_assert(onion_address);
  767.   if (!auth_hid_servs) return NULL;
  768.   return strmap_get(auth_hid_servs, onion_address);
  769. }
  770. /** Helper: Free storage held by rend_service_authorization_t. */
  771. static void
  772. rend_service_authorization_free(rend_service_authorization_t *auth)
  773. {
  774.   tor_free(auth);
  775. }
  776. /** Helper for strmap_free. */
  777. static void
  778. rend_service_authorization_strmap_item_free(void *service_auth)
  779. {
  780.   rend_service_authorization_free(service_auth);
  781. }
  782. /** Release all the storage held in auth_hid_servs.
  783.  */
  784. void
  785. rend_service_authorization_free_all(void)
  786. {
  787.   if (!auth_hid_servs) {
  788.     return;
  789.   }
  790.   strmap_free(auth_hid_servs, rend_service_authorization_strmap_item_free);
  791.   auth_hid_servs = NULL;
  792. }
  793. /** Parse <b>config_line</b> as a client-side authorization for a hidden
  794.  * service and add it to the local map of hidden service authorizations.
  795.  * Return 0 for success and -1 for failure. */
  796. int
  797. rend_parse_service_authorization(or_options_t *options, int validate_only)
  798. {
  799.   config_line_t *line;
  800.   int res = -1;
  801.   strmap_t *parsed = strmap_new();
  802.   smartlist_t *sl = smartlist_create();
  803.   rend_service_authorization_t *auth = NULL;
  804.   for (line = options->HidServAuth; line; line = line->next) {
  805.     char *onion_address, *descriptor_cookie;
  806.     char descriptor_cookie_tmp[REND_DESC_COOKIE_LEN+2];
  807.     char descriptor_cookie_base64ext[REND_DESC_COOKIE_LEN_BASE64+2+1];
  808.     int auth_type_val = 0;
  809.     auth = NULL;
  810.     SMARTLIST_FOREACH(sl, char *, c, tor_free(c););
  811.     smartlist_clear(sl);
  812.     smartlist_split_string(sl, line->value, " ",
  813.                            SPLIT_SKIP_SPACE|SPLIT_IGNORE_BLANK, 3);
  814.     if (smartlist_len(sl) < 2) {
  815.       log_warn(LD_CONFIG, "Configuration line does not consist of "
  816.                ""onion-address authorization-cookie [service-name]": "
  817.                "'%s'", line->value);
  818.       goto err;
  819.     }
  820.     auth = tor_malloc_zero(sizeof(rend_service_authorization_t));
  821.     /* Parse onion address. */
  822.     onion_address = smartlist_get(sl, 0);
  823.     if (strlen(onion_address) != REND_SERVICE_ADDRESS_LEN ||
  824.         strcmpend(onion_address, ".onion")) {
  825.       log_warn(LD_CONFIG, "Onion address has wrong format: '%s'",
  826.                onion_address);
  827.       goto err;
  828.     }
  829.     strlcpy(auth->onion_address, onion_address, REND_SERVICE_ID_LEN_BASE32+1);
  830.     if (!rend_valid_service_id(auth->onion_address)) {
  831.       log_warn(LD_CONFIG, "Onion address has wrong format: '%s'",
  832.                onion_address);
  833.       goto err;
  834.     }
  835.     /* Parse descriptor cookie. */
  836.     descriptor_cookie = smartlist_get(sl, 1);
  837.     if (strlen(descriptor_cookie) != REND_DESC_COOKIE_LEN_BASE64) {
  838.       log_warn(LD_CONFIG, "Authorization cookie has wrong length: '%s'",
  839.                descriptor_cookie);
  840.       goto err;
  841.     }
  842.     /* Add trailing zero bytes (AA) to make base64-decoding happy. */
  843.     tor_snprintf(descriptor_cookie_base64ext,
  844.                  REND_DESC_COOKIE_LEN_BASE64+2+1,
  845.                  "%sAA", descriptor_cookie);
  846.     if (base64_decode(descriptor_cookie_tmp, sizeof(descriptor_cookie_tmp),
  847.                       descriptor_cookie_base64ext,
  848.                       strlen(descriptor_cookie_base64ext)) < 0) {
  849.       log_warn(LD_CONFIG, "Decoding authorization cookie failed: '%s'",
  850.                descriptor_cookie);
  851.       goto err;
  852.     }
  853.     auth_type_val = (descriptor_cookie_tmp[16] >> 4) + 1;
  854.     if (auth_type_val < 1 || auth_type_val > 2) {
  855.       log_warn(LD_CONFIG, "Authorization cookie has unknown authorization "
  856.                           "type encoded.");
  857.       goto err;
  858.     }
  859.     auth->auth_type = auth_type_val == 1 ? REND_BASIC_AUTH : REND_STEALTH_AUTH;
  860.     memcpy(auth->descriptor_cookie, descriptor_cookie_tmp,
  861.            REND_DESC_COOKIE_LEN);
  862.     if (strmap_get(parsed, auth->onion_address)) {
  863.       log_warn(LD_CONFIG, "Duplicate authorization for the same hidden "
  864.                           "service.");
  865.       goto err;
  866.     }
  867.     strmap_set(parsed, auth->onion_address, auth);
  868.     auth = NULL;
  869.   }
  870.   res = 0;
  871.   goto done;
  872.  err:
  873.   res = -1;
  874.  done:
  875.   if (auth)
  876.     rend_service_authorization_free(auth);
  877.   SMARTLIST_FOREACH(sl, char *, c, tor_free(c););
  878.   smartlist_free(sl);
  879.   if (!validate_only && res == 0) {
  880.     rend_service_authorization_free_all();
  881.     auth_hid_servs = parsed;
  882.   } else {
  883.     strmap_free(parsed, rend_service_authorization_strmap_item_free);
  884.   }
  885.   return res;
  886. }