src/test/test_hs_control.c

   1 /* Copyright (c) 2017, The Tor Project, Inc. */
   2 /* See LICENSE for licensing information */
   3
   4 /**
   5  * \file test_hs_control.c
   6  * \brief Unit tests for hidden service control port event and command.
   7  **/
   8
   9 #define CONTROL_PRIVATE
  10 #define CIRCUITBUILD_PRIVATE
  11 #define RENDCOMMON_PRIVATE
  12 #define RENDSERVICE_PRIVATE
  13 #define HS_SERVICE_PRIVATE
  14
  15 #include "or.h"
  16 #include "test.h"
  17 #include "control.h"
  18 #include "config.h"
  19 #include "hs_common.h"
  20 #include "hs_control.h"
  21 #include "nodelist.h"
  22 //#include "rendcommon.h"
  23 //#include "rendservice.h"
  24 //#include "routerset.h"
  25 //#include "circuitbuild.h"
  26 #include "test_helpers.h"
  27
  28 /* mock ID digest and longname for node that's in nodelist */
  29 #define HSDIR_EXIST_ID \
  30   "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA" \
  31   "\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA\xAA"
  32 #define STR_HSDIR_EXIST_LONGNAME \
  33   "$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=TestDir"
  34 #define STR_HSDIR_NONE_EXIST_LONGNAME \
  35   "$BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB"
  36
  37 /* Helper global variable for hidden service descriptor event test.
  38  * It's used as a pointer to dynamically created message buffer in
  39  * send_control_event_string_replacement function, which mocks
  40  * send_control_event_string function.
  41  *
  42  * Always free it after use! */
  43 static char *received_msg = NULL;
  44
  45 /** Mock function for send_control_event_string
  46  */
  47 static void
  48 queue_control_event_string_replacement(uint16_t event, char *msg)
  49 {
  50   (void) event;
  51   tor_free(received_msg);
  52   received_msg = msg;
  53 }
  54
  55 /** Mock function for node_describe_longname_by_id, it returns either
  56  * STR_HSDIR_EXIST_LONGNAME or STR_HSDIR_NONE_EXIST_LONGNAME
  57  */
  58 static const char *
  59 node_describe_longname_by_id_replacement(const char *id_digest)
  60 {
  61   if (!strcmp(id_digest, HSDIR_EXIST_ID)) {
  62     return STR_HSDIR_EXIST_LONGNAME;
  63   } else {
  64     return STR_HSDIR_NONE_EXIST_LONGNAME;
  65   }
  66 }
  67
  68 /* HSDir fetch index is a series of 'D' */
  69 #define HSDIR_INDEX_FETCH_HEX \
  70   "4343434343434343434343434343434343434343434343434343434343434343"
  71 #define HSDIR_INDEX_STORE_HEX \
  72   "4444444444444444444444444444444444444444444444444444444444444444"
  73
  74 static const node_t *
  75 mock_node_get_by_id(const char *digest)
  76 {
  77   static node_t node;
  78   memcpy(node.identity, digest, DIGEST_LEN);
  79   node.hsdir_index = tor_malloc_zero(sizeof(hsdir_index_t));
  80   memset(node.hsdir_index->fetch, 'C', DIGEST256_LEN);
  81   memset(node.hsdir_index->store_first, 'D', DIGEST256_LEN);
  82   return &node;
  83 }
  84
  85 static void
  86 test_hs_desc_event(void *arg)
  87 {
  88   int ret;
  89   char *expected_msg = NULL;
  90   char onion_address[HS_SERVICE_ADDR_LEN_BASE32 + 1];
  91   ed25519_keypair_t identity_kp;
  92   ed25519_public_key_t blinded_pk;
  93   char base64_blinded_pk[ED25519_BASE64_LEN + 1];
  94   routerstatus_t hsdir_rs;
  95   hs_ident_dir_conn_t ident;
  96
  97   (void) arg;
  98   MOCK(queue_control_event_string,
  99        queue_control_event_string_replacement);
 100   MOCK(node_describe_longname_by_id,
 101        node_describe_longname_by_id_replacement);
 102   MOCK(node_get_by_id, mock_node_get_by_id);
 103
 104   /* Setup what we need for this test. */
 105   ed25519_keypair_generate(&identity_kp, 0);
 106   hs_build_address(&identity_kp.pubkey, HS_VERSION_THREE, onion_address);
 107   ret = hs_address_is_valid(onion_address);
 108   tt_int_op(ret, OP_EQ, 1);
 109   memset(&blinded_pk, 'B', sizeof(blinded_pk));
 110   memset(&hsdir_rs, 0, sizeof(hsdir_rs));
 111   memcpy(hsdir_rs.identity_digest, HSDIR_EXIST_ID, DIGEST_LEN);
 112   ret = ed25519_public_to_base64(base64_blinded_pk, &blinded_pk);
 113   tt_int_op(ret, OP_EQ, 0);
 114   memcpy(&ident.identity_pk, &identity_kp.pubkey,
 115          sizeof(ed25519_public_key_t));
 116   memcpy(&ident.blinded_pk, &blinded_pk, sizeof(blinded_pk));
 117
 118   /* HS_DESC REQUESTED ... */
 119   hs_control_desc_event_requested(&identity_kp.pubkey, base64_blinded_pk,
 120                                   &hsdir_rs);
 121   tor_asprintf(&expected_msg, "650 HS_DESC REQUESTED %s NO_AUTH "
 122                STR_HSDIR_EXIST_LONGNAME " %s HSDIR_INDEX="
 123                HSDIR_INDEX_FETCH_HEX "\r\n",
 124                onion_address, base64_blinded_pk);
 125   tt_assert(received_msg);
 126   tt_str_op(received_msg, OP_EQ, expected_msg);
 127   tor_free(received_msg);
 128   tor_free(expected_msg);
 129
 130   /* HS_DESC CREATED... */
 131   hs_control_desc_event_created(onion_address, &blinded_pk);
 132   tor_asprintf(&expected_msg, "650 HS_DESC CREATED %s UNKNOWN "
 133                               "UNKNOWN %s\r\n",
 134                onion_address, base64_blinded_pk);
 135   tt_assert(received_msg);
 136   tt_str_op(received_msg, OP_EQ, expected_msg);
 137   tor_free(received_msg);
 138   tor_free(expected_msg);
 139
 140   /* HS_DESC UPLOAD... */
 141   uint8_t hsdir_index_store[DIGEST256_LEN];
 142   memset(hsdir_index_store, 'D', sizeof(hsdir_index_store));
 143   hs_control_desc_event_upload(onion_address, HSDIR_EXIST_ID,
 144                                &blinded_pk, hsdir_index_store);
 145   tor_asprintf(&expected_msg, "650 HS_DESC UPLOAD %s UNKNOWN "
 146                               STR_HSDIR_EXIST_LONGNAME " %s "
 147                               "HSDIR_INDEX=" HSDIR_INDEX_STORE_HEX "\r\n",
 148                onion_address, base64_blinded_pk);
 149   tt_assert(received_msg);
 150   tt_str_op(received_msg, OP_EQ, expected_msg);
 151   tor_free(received_msg);
 152   tor_free(expected_msg);
 153
 154   /* HS_DESC FAILED... */
 155   hs_control_desc_event_failed(&ident, HSDIR_EXIST_ID, "BAD_DESC");
 156   tor_asprintf(&expected_msg, "650 HS_DESC FAILED %s NO_AUTH "
 157                               STR_HSDIR_EXIST_LONGNAME " %s "
 158                               "REASON=BAD_DESC\r\n",
 159                onion_address, base64_blinded_pk);
 160   tt_assert(received_msg);
 161   tt_str_op(received_msg, OP_EQ, expected_msg);
 162   tor_free(received_msg);
 163   tor_free(expected_msg);
 164
 165   /* HS_DESC RECEIVED... */
 166   hs_control_desc_event_received(&ident, HSDIR_EXIST_ID);
 167   tor_asprintf(&expected_msg, "650 HS_DESC RECEIVED %s NO_AUTH "
 168                               STR_HSDIR_EXIST_LONGNAME " %s\r\n",
 169                onion_address, base64_blinded_pk);
 170   tt_assert(received_msg);
 171   tt_str_op(received_msg, OP_EQ, expected_msg);
 172   tor_free(received_msg);
 173   tor_free(expected_msg);
 174
 175   /* HS_DESC UPLOADED... */
 176   hs_control_desc_event_uploaded(&ident, HSDIR_EXIST_ID);
 177   tor_asprintf(&expected_msg, "650 HS_DESC UPLOADED %s UNKNOWN "
 178                               STR_HSDIR_EXIST_LONGNAME "\r\n",
 179                onion_address);
 180   tt_assert(received_msg);
 181   tt_str_op(received_msg, OP_EQ, expected_msg);
 182   tor_free(received_msg);
 183   tor_free(expected_msg);
 184
 185  done:
 186   UNMOCK(queue_control_event_string);
 187   UNMOCK(node_describe_longname_by_id);
 188   UNMOCK(node_get_by_id);
 189   tor_free(received_msg);
 190   tor_free(expected_msg);
 191 }
 192
 193 struct testcase_t hs_control_tests[] = {
 194   { "hs_desc_event", test_hs_desc_event, TT_FORK,
 195     NULL, NULL },
 196
 197   END_OF_TESTCASES
 198 };
 199