test_hs_common.c 66 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822
  1. /* Copyright (c) 2017, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. /**
  4. * \file test_hs_common.c
  5. * \brief Test hidden service common functionalities.
  6. */
  7. #define HS_COMMON_PRIVATE
  8. #define HS_CLIENT_PRIVATE
  9. #define HS_SERVICE_PRIVATE
  10. #define NODELIST_PRIVATE
  11. #include "test.h"
  12. #include "test_helpers.h"
  13. #include "log_test_helpers.h"
  14. #include "hs_test_helpers.h"
  15. #include "connection_edge.h"
  16. #include "hs_common.h"
  17. #include "hs_client.h"
  18. #include "hs_service.h"
  19. #include "config.h"
  20. #include "networkstatus.h"
  21. #include "directory.h"
  22. #include "dirvote.h"
  23. #include "nodelist.h"
  24. #include "routerlist.h"
  25. #include "statefile.h"
  26. #include "circuitlist.h"
  27. #include "shared_random.h"
  28. #include "util.h"
  29. /** Test the validation of HS v3 addresses */
  30. static void
  31. test_validate_address(void *arg)
  32. {
  33. int ret;
  34. (void) arg;
  35. /* Address too short and too long. */
  36. setup_full_capture_of_logs(LOG_WARN);
  37. ret = hs_address_is_valid("blah");
  38. tt_int_op(ret, OP_EQ, 0);
  39. expect_log_msg_containing("has an invalid length");
  40. teardown_capture_of_logs();
  41. setup_full_capture_of_logs(LOG_WARN);
  42. ret = hs_address_is_valid(
  43. "p3xnclpu4mu22dwaurjtsybyqk4xfjmcfz6z62yl24uwmhjatiwnlnadb");
  44. tt_int_op(ret, OP_EQ, 0);
  45. expect_log_msg_containing("has an invalid length");
  46. teardown_capture_of_logs();
  47. /* Invalid checksum (taken from prop224) */
  48. setup_full_capture_of_logs(LOG_WARN);
  49. ret = hs_address_is_valid(
  50. "l5satjgud6gucryazcyvyvhuxhr74u6ygigiuyixe3a6ysis67ororad");
  51. tt_int_op(ret, OP_EQ, 0);
  52. expect_log_msg_containing("invalid checksum");
  53. teardown_capture_of_logs();
  54. setup_full_capture_of_logs(LOG_WARN);
  55. ret = hs_address_is_valid(
  56. "btojiu7nu5y5iwut64eufevogqdw4wmqzugnoluw232r4t3ecsfv37ad");
  57. tt_int_op(ret, OP_EQ, 0);
  58. expect_log_msg_containing("invalid checksum");
  59. teardown_capture_of_logs();
  60. /* Non base32 decodable string. */
  61. setup_full_capture_of_logs(LOG_WARN);
  62. ret = hs_address_is_valid(
  63. "????????????????????????????????????????????????????????");
  64. tt_int_op(ret, OP_EQ, 0);
  65. expect_log_msg_containing("can't be decoded");
  66. teardown_capture_of_logs();
  67. /* Valid address. */
  68. ret = hs_address_is_valid(
  69. "25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid");
  70. tt_int_op(ret, OP_EQ, 1);
  71. done:
  72. ;
  73. }
  74. static int
  75. mock_write_str_to_file(const char *path, const char *str, int bin)
  76. {
  77. (void)bin;
  78. tt_str_op(path, OP_EQ, "/double/five"PATH_SEPARATOR"squared");
  79. tt_str_op(str, OP_EQ,
  80. "25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid.onion\n");
  81. done:
  82. return 0;
  83. }
  84. /** Test building HS v3 onion addresses. Uses test vectors from the
  85. * ./hs_build_address.py script. */
  86. static void
  87. test_build_address(void *arg)
  88. {
  89. int ret;
  90. char onion_addr[HS_SERVICE_ADDR_LEN_BASE32 + 1];
  91. ed25519_public_key_t pubkey;
  92. /* hex-encoded ed25519 pubkey used in hs_build_address.py */
  93. char pubkey_hex[] =
  94. "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a";
  95. hs_service_t *service = NULL;
  96. (void) arg;
  97. MOCK(write_str_to_file, mock_write_str_to_file);
  98. /* The following has been created with hs_build_address.py script that
  99. * follows proposal 224 specification to build an onion address. */
  100. static const char *test_addr =
  101. "25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid";
  102. /* Let's try to build the same onion address as the script */
  103. base16_decode((char*)pubkey.pubkey, sizeof(pubkey.pubkey),
  104. pubkey_hex, strlen(pubkey_hex));
  105. hs_build_address(&pubkey, HS_VERSION_THREE, onion_addr);
  106. tt_str_op(test_addr, OP_EQ, onion_addr);
  107. /* Validate that address. */
  108. ret = hs_address_is_valid(onion_addr);
  109. tt_int_op(ret, OP_EQ, 1);
  110. service = tor_malloc_zero(sizeof(hs_service_t));
  111. memcpy(service->onion_address, onion_addr, sizeof(service->onion_address));
  112. tor_asprintf(&service->config.directory_path, "/double/five");
  113. ret = write_address_to_file(service, "squared");
  114. tt_int_op(ret, OP_EQ, 0);
  115. done:
  116. hs_service_free(service);
  117. }
  118. /** Test that our HS time period calculation functions work properly */
  119. static void
  120. test_time_period(void *arg)
  121. {
  122. (void) arg;
  123. uint64_t tn;
  124. int retval;
  125. time_t fake_time, correct_time, start_time;
  126. /* Let's do the example in prop224 section [TIME-PERIODS] */
  127. retval = parse_rfc1123_time("Wed, 13 Apr 2016 11:00:00 UTC",
  128. &fake_time);
  129. tt_int_op(retval, OP_EQ, 0);
  130. /* Check that the time period number is right */
  131. tn = hs_get_time_period_num(fake_time);
  132. tt_u64_op(tn, OP_EQ, 16903);
  133. /* Increase current time to 11:59:59 UTC and check that the time period
  134. number is still the same */
  135. fake_time += 3599;
  136. tn = hs_get_time_period_num(fake_time);
  137. tt_u64_op(tn, OP_EQ, 16903);
  138. { /* Check start time of next time period */
  139. retval = parse_rfc1123_time("Wed, 13 Apr 2016 12:00:00 UTC",
  140. &correct_time);
  141. tt_int_op(retval, OP_EQ, 0);
  142. start_time = hs_get_start_time_of_next_time_period(fake_time);
  143. tt_int_op(start_time, OP_EQ, correct_time);
  144. }
  145. /* Now take time to 12:00:00 UTC and check that the time period rotated */
  146. fake_time += 1;
  147. tn = hs_get_time_period_num(fake_time);
  148. tt_u64_op(tn, OP_EQ, 16904);
  149. /* Now also check our hs_get_next_time_period_num() function */
  150. tn = hs_get_next_time_period_num(fake_time);
  151. tt_u64_op(tn, OP_EQ, 16905);
  152. { /* Check start time of next time period again */
  153. retval = parse_rfc1123_time("Wed, 14 Apr 2016 12:00:00 UTC",
  154. &correct_time);
  155. tt_int_op(retval, OP_EQ, 0);
  156. start_time = hs_get_start_time_of_next_time_period(fake_time);
  157. tt_int_op(start_time, OP_EQ, correct_time);
  158. }
  159. /* Now do another sanity check: The time period number at the start of the
  160. * next time period, must be the same time period number as the one returned
  161. * from hs_get_next_time_period_num() */
  162. {
  163. time_t next_tp_start = hs_get_start_time_of_next_time_period(fake_time);
  164. tt_u64_op(hs_get_time_period_num(next_tp_start), OP_EQ,
  165. hs_get_next_time_period_num(fake_time));
  166. }
  167. done:
  168. ;
  169. }
  170. /** Test that we can correctly find the start time of the next time period */
  171. static void
  172. test_start_time_of_next_time_period(void *arg)
  173. {
  174. (void) arg;
  175. int retval;
  176. time_t fake_time;
  177. char tbuf[ISO_TIME_LEN + 1];
  178. time_t next_tp_start_time;
  179. /* Do some basic tests */
  180. retval = parse_rfc1123_time("Wed, 13 Apr 2016 11:00:00 UTC",
  181. &fake_time);
  182. tt_int_op(retval, OP_EQ, 0);
  183. next_tp_start_time = hs_get_start_time_of_next_time_period(fake_time);
  184. /* Compare it with the correct result */
  185. format_iso_time(tbuf, next_tp_start_time);
  186. tt_str_op("2016-04-13 12:00:00", OP_EQ, tbuf);
  187. /* Another test with an edge-case time (start of TP) */
  188. retval = parse_rfc1123_time("Wed, 13 Apr 2016 12:00:00 UTC",
  189. &fake_time);
  190. tt_int_op(retval, OP_EQ, 0);
  191. next_tp_start_time = hs_get_start_time_of_next_time_period(fake_time);
  192. format_iso_time(tbuf, next_tp_start_time);
  193. tt_str_op("2016-04-14 12:00:00", OP_EQ, tbuf);
  194. {
  195. /* Now pretend we are on a testing network and alter the voting schedule to
  196. be every 10 seconds. This means that a time period has length 10*24
  197. seconds (4 minutes). It also means that we apply a rotational offset of
  198. 120 seconds to the time period, so that it starts at 00:02:00 instead of
  199. 00:00:00. */
  200. or_options_t *options = get_options_mutable();
  201. options->TestingTorNetwork = 1;
  202. options->V3AuthVotingInterval = 10;
  203. options->TestingV3AuthInitialVotingInterval = 10;
  204. retval = parse_rfc1123_time("Wed, 13 Apr 2016 00:00:00 UTC",
  205. &fake_time);
  206. tt_int_op(retval, OP_EQ, 0);
  207. next_tp_start_time = hs_get_start_time_of_next_time_period(fake_time);
  208. /* Compare it with the correct result */
  209. format_iso_time(tbuf, next_tp_start_time);
  210. tt_str_op("2016-04-13 00:02:00", OP_EQ, tbuf);
  211. retval = parse_rfc1123_time("Wed, 13 Apr 2016 00:02:00 UTC",
  212. &fake_time);
  213. tt_int_op(retval, OP_EQ, 0);
  214. next_tp_start_time = hs_get_start_time_of_next_time_period(fake_time);
  215. /* Compare it with the correct result */
  216. format_iso_time(tbuf, next_tp_start_time);
  217. tt_str_op("2016-04-13 00:06:00", OP_EQ, tbuf);
  218. }
  219. done:
  220. ;
  221. }
  222. /* Cleanup the global nodelist. It also frees the "md" in the node_t because
  223. * we allocate the memory in helper_add_hsdir_to_networkstatus(). */
  224. static void
  225. cleanup_nodelist(void)
  226. {
  227. smartlist_t *nodelist = nodelist_get_list();
  228. SMARTLIST_FOREACH_BEGIN(nodelist, node_t *, node) {
  229. tor_free(node->md);
  230. node->md = NULL;
  231. } SMARTLIST_FOREACH_END(node);
  232. nodelist_free_all();
  233. }
  234. static void
  235. helper_add_hsdir_to_networkstatus(networkstatus_t *ns,
  236. int identity_idx,
  237. const char *nickname,
  238. int is_hsdir)
  239. {
  240. routerstatus_t *rs = tor_malloc_zero(sizeof(routerstatus_t));
  241. routerinfo_t *ri = tor_malloc_zero(sizeof(routerinfo_t));
  242. uint8_t identity[DIGEST_LEN];
  243. tor_addr_t ipv4_addr;
  244. memset(identity, identity_idx, sizeof(identity));
  245. memcpy(rs->identity_digest, identity, DIGEST_LEN);
  246. rs->is_hs_dir = is_hsdir;
  247. rs->supports_v3_hsdir = 1;
  248. strlcpy(rs->nickname, nickname, sizeof(rs->nickname));
  249. tor_addr_parse(&ipv4_addr, "1.2.3.4");
  250. ri->addr = tor_addr_to_ipv4h(&ipv4_addr);
  251. rs->addr = tor_addr_to_ipv4h(&ipv4_addr);
  252. ri->nickname = tor_strdup(nickname);
  253. ri->protocol_list = tor_strdup("HSDir=1-2 LinkAuth=3");
  254. memcpy(ri->cache_info.identity_digest, identity, DIGEST_LEN);
  255. ri->cache_info.signing_key_cert = tor_malloc_zero(sizeof(tor_cert_t));
  256. /* Needed for the HSDir index computation. */
  257. memset(&ri->cache_info.signing_key_cert->signing_key,
  258. identity_idx, ED25519_PUBKEY_LEN);
  259. tt_assert(nodelist_set_routerinfo(ri, NULL));
  260. node_t *node = node_get_mutable_by_id(ri->cache_info.identity_digest);
  261. tt_assert(node);
  262. node->rs = rs;
  263. /* We need this to exist for node_has_descriptor() to return true. */
  264. node->md = tor_malloc_zero(sizeof(microdesc_t));
  265. /* Do this now the nodelist_set_routerinfo() function needs a "rs" to set
  266. * the indexes which it doesn't have when it is called. */
  267. node_set_hsdir_index(node, ns);
  268. node->ri = NULL;
  269. smartlist_add(ns->routerstatus_list, rs);
  270. done:
  271. routerinfo_free(ri);
  272. }
  273. static networkstatus_t *mock_ns = NULL;
  274. static networkstatus_t *
  275. mock_networkstatus_get_latest_consensus(void)
  276. {
  277. time_t now = approx_time();
  278. /* If initialized, return it */
  279. if (mock_ns) {
  280. return mock_ns;
  281. }
  282. /* Initialize fake consensus */
  283. mock_ns = tor_malloc_zero(sizeof(networkstatus_t));
  284. /* This consensus is live */
  285. mock_ns->valid_after = now-1;
  286. mock_ns->fresh_until = now+1;
  287. mock_ns->valid_until = now+2;
  288. /* Create routerstatus list */
  289. mock_ns->routerstatus_list = smartlist_new();
  290. mock_ns->type = NS_TYPE_CONSENSUS;
  291. return mock_ns;
  292. }
  293. static networkstatus_t *
  294. mock_networkstatus_get_live_consensus(time_t now)
  295. {
  296. (void) now;
  297. tt_assert(mock_ns);
  298. done:
  299. return mock_ns;
  300. }
  301. /** Test the responsible HSDirs calculation function */
  302. static void
  303. test_responsible_hsdirs(void *arg)
  304. {
  305. time_t now = approx_time();
  306. smartlist_t *responsible_dirs = smartlist_new();
  307. networkstatus_t *ns = NULL;
  308. int retval;
  309. (void) arg;
  310. hs_init();
  311. MOCK(networkstatus_get_latest_consensus,
  312. mock_networkstatus_get_latest_consensus);
  313. ns = networkstatus_get_latest_consensus();
  314. { /* First router: HSdir */
  315. helper_add_hsdir_to_networkstatus(ns, 1, "igor", 1);
  316. }
  317. { /* Second HSDir */
  318. helper_add_hsdir_to_networkstatus(ns, 2, "victor", 1);
  319. }
  320. { /* Third relay but not HSDir */
  321. helper_add_hsdir_to_networkstatus(ns, 3, "spyro", 0);
  322. }
  323. ed25519_keypair_t kp;
  324. retval = ed25519_keypair_generate(&kp, 0);
  325. tt_int_op(retval, OP_EQ , 0);
  326. uint64_t time_period_num = hs_get_time_period_num(now);
  327. hs_get_responsible_hsdirs(&kp.pubkey, time_period_num,
  328. 0, 0, responsible_dirs);
  329. /* Make sure that we only found 2 responsible HSDirs.
  330. * The third relay was not an hsdir! */
  331. tt_int_op(smartlist_len(responsible_dirs), OP_EQ, 2);
  332. /** TODO: Build a bigger network and do more tests here */
  333. done:
  334. SMARTLIST_FOREACH(ns->routerstatus_list,
  335. routerstatus_t *, rs, routerstatus_free(rs));
  336. smartlist_free(responsible_dirs);
  337. smartlist_clear(ns->routerstatus_list);
  338. networkstatus_vote_free(mock_ns);
  339. cleanup_nodelist();
  340. }
  341. static void
  342. mock_directory_initiate_request(directory_request_t *req)
  343. {
  344. (void)req;
  345. return;
  346. }
  347. static int
  348. mock_hs_desc_encode_descriptor(const hs_descriptor_t *desc,
  349. const ed25519_keypair_t *signing_kp,
  350. char **encoded_out)
  351. {
  352. (void)desc;
  353. (void)signing_kp;
  354. tor_asprintf(encoded_out, "lulu");
  355. return 0;
  356. }
  357. static or_state_t dummy_state;
  358. /* Mock function to get fake or state (used for rev counters) */
  359. static or_state_t *
  360. get_or_state_replacement(void)
  361. {
  362. return &dummy_state;
  363. }
  364. static int
  365. mock_router_have_minimum_dir_info(void)
  366. {
  367. return 1;
  368. }
  369. /** Test that we correctly detect when the HSDir hash ring changes so that we
  370. * reupload our descriptor. */
  371. static void
  372. test_desc_reupload_logic(void *arg)
  373. {
  374. networkstatus_t *ns = NULL;
  375. (void) arg;
  376. hs_init();
  377. MOCK(router_have_minimum_dir_info,
  378. mock_router_have_minimum_dir_info);
  379. MOCK(get_or_state,
  380. get_or_state_replacement);
  381. MOCK(networkstatus_get_latest_consensus,
  382. mock_networkstatus_get_latest_consensus);
  383. MOCK(directory_initiate_request,
  384. mock_directory_initiate_request);
  385. MOCK(hs_desc_encode_descriptor,
  386. mock_hs_desc_encode_descriptor);
  387. ns = networkstatus_get_latest_consensus();
  388. /** Test logic:
  389. * 1) Upload descriptor to HSDirs
  390. * CHECK that previous_hsdirs list was populated.
  391. * 2) Then call router_dir_info_changed() without an HSDir set change.
  392. * CHECK that no reuplod occurs.
  393. * 3) Now change the HSDir set, and call dir_info_changed() again.
  394. * CHECK that reupload occurs.
  395. * 4) Finally call service_desc_schedule_upload().
  396. * CHECK that previous_hsdirs list was cleared.
  397. **/
  398. /* Let's start by building our descriptor and service */
  399. hs_service_descriptor_t *desc = service_descriptor_new();
  400. hs_service_t *service = NULL;
  401. /* hex-encoded ed25519 pubkey used in hs_build_address.py */
  402. char pubkey_hex[] =
  403. "d75a980182b10ab7d54bfed3c964073a0ee172f3daa62325af021a68f707511a";
  404. char onion_addr[HS_SERVICE_ADDR_LEN_BASE32 + 1];
  405. ed25519_public_key_t pubkey;
  406. base16_decode((char*)pubkey.pubkey, sizeof(pubkey.pubkey),
  407. pubkey_hex, strlen(pubkey_hex));
  408. hs_build_address(&pubkey, HS_VERSION_THREE, onion_addr);
  409. service = tor_malloc_zero(sizeof(hs_service_t));
  410. memcpy(service->onion_address, onion_addr, sizeof(service->onion_address));
  411. ed25519_secret_key_generate(&service->keys.identity_sk, 0);
  412. ed25519_public_key_generate(&service->keys.identity_pk,
  413. &service->keys.identity_sk);
  414. service->desc_current = desc;
  415. /* Also add service to service map */
  416. hs_service_ht *service_map = get_hs_service_map();
  417. tt_assert(service_map);
  418. tt_int_op(hs_service_get_num_services(), OP_EQ, 0);
  419. register_service(service_map, service);
  420. tt_int_op(hs_service_get_num_services(), OP_EQ, 1);
  421. /* Now let's create our hash ring: */
  422. {
  423. helper_add_hsdir_to_networkstatus(ns, 1, "dingus", 1);
  424. helper_add_hsdir_to_networkstatus(ns, 2, "clive", 1);
  425. helper_add_hsdir_to_networkstatus(ns, 3, "aaron", 1);
  426. helper_add_hsdir_to_networkstatus(ns, 4, "lizzie", 1);
  427. helper_add_hsdir_to_networkstatus(ns, 5, "daewon", 1);
  428. helper_add_hsdir_to_networkstatus(ns, 6, "clarke", 1);
  429. }
  430. /* Now let's upload our desc to all hsdirs */
  431. upload_descriptor_to_all(service, desc);
  432. /* Check that previous hsdirs were populated */
  433. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 6);
  434. /* Poison next upload time so that we can see if it was changed by
  435. * router_dir_info_changed(). No changes in hash ring so far, so the upload
  436. * time should stay as is. */
  437. desc->next_upload_time = 42;
  438. router_dir_info_changed();
  439. tt_int_op(desc->next_upload_time, OP_EQ, 42);
  440. /* Now change the HSDir hash ring by swapping nora for aaron.
  441. * Start by clearing the hash ring */
  442. {
  443. SMARTLIST_FOREACH(ns->routerstatus_list,
  444. routerstatus_t *, rs, routerstatus_free(rs));
  445. smartlist_clear(ns->routerstatus_list);
  446. cleanup_nodelist();
  447. routerlist_free_all();
  448. }
  449. { /* Now add back all the nodes */
  450. helper_add_hsdir_to_networkstatus(ns, 1, "dingus", 1);
  451. helper_add_hsdir_to_networkstatus(ns, 2, "clive", 1);
  452. helper_add_hsdir_to_networkstatus(ns, 4, "lizzie", 1);
  453. helper_add_hsdir_to_networkstatus(ns, 5, "daewon", 1);
  454. helper_add_hsdir_to_networkstatus(ns, 6, "clarke", 1);
  455. helper_add_hsdir_to_networkstatus(ns, 7, "nora", 1);
  456. }
  457. /* Now call service_desc_hsdirs_changed() and see that it detected the hash
  458. ring change */
  459. time_t now = approx_time();
  460. tt_assert(now);
  461. tt_int_op(service_desc_hsdirs_changed(service, desc), OP_EQ, 1);
  462. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 6);
  463. /* Now order another upload and see that we keep having 6 prev hsdirs */
  464. upload_descriptor_to_all(service, desc);
  465. /* Check that previous hsdirs were populated */
  466. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 6);
  467. /* Now restore the HSDir hash ring to its original state by swapping back
  468. aaron for nora */
  469. /* First clear up the hash ring */
  470. {
  471. SMARTLIST_FOREACH(ns->routerstatus_list,
  472. routerstatus_t *, rs, routerstatus_free(rs));
  473. smartlist_clear(ns->routerstatus_list);
  474. cleanup_nodelist();
  475. routerlist_free_all();
  476. }
  477. { /* Now populate the hash ring again */
  478. helper_add_hsdir_to_networkstatus(ns, 1, "dingus", 1);
  479. helper_add_hsdir_to_networkstatus(ns, 2, "clive", 1);
  480. helper_add_hsdir_to_networkstatus(ns, 3, "aaron", 1);
  481. helper_add_hsdir_to_networkstatus(ns, 4, "lizzie", 1);
  482. helper_add_hsdir_to_networkstatus(ns, 5, "daewon", 1);
  483. helper_add_hsdir_to_networkstatus(ns, 6, "clarke", 1);
  484. }
  485. /* Check that our algorithm catches this change of hsdirs */
  486. tt_int_op(service_desc_hsdirs_changed(service, desc), OP_EQ, 1);
  487. /* Now pretend that the descriptor changed, and order a reupload to all
  488. HSDirs. Make sure that the set of previous HSDirs was cleared. */
  489. service_desc_schedule_upload(desc, now, 1);
  490. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 0);
  491. /* Now reupload again: see that the prev hsdir set got populated again. */
  492. upload_descriptor_to_all(service, desc);
  493. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 6);
  494. done:
  495. SMARTLIST_FOREACH(ns->routerstatus_list,
  496. routerstatus_t *, rs, routerstatus_free(rs));
  497. smartlist_clear(ns->routerstatus_list);
  498. networkstatus_vote_free(ns);
  499. cleanup_nodelist();
  500. hs_free_all();
  501. }
  502. /** Test disaster SRV computation and caching */
  503. static void
  504. test_disaster_srv(void *arg)
  505. {
  506. uint8_t *cached_disaster_srv_one = NULL;
  507. uint8_t *cached_disaster_srv_two = NULL;
  508. uint8_t srv_one[DIGEST256_LEN] = {0};
  509. uint8_t srv_two[DIGEST256_LEN] = {0};
  510. uint8_t srv_three[DIGEST256_LEN] = {0};
  511. uint8_t srv_four[DIGEST256_LEN] = {0};
  512. uint8_t srv_five[DIGEST256_LEN] = {0};
  513. (void) arg;
  514. /* Get the cached SRVs: we gonna use them later for verification */
  515. cached_disaster_srv_one = get_first_cached_disaster_srv();
  516. cached_disaster_srv_two = get_second_cached_disaster_srv();
  517. /* Compute some srvs */
  518. get_disaster_srv(1, srv_one);
  519. get_disaster_srv(2, srv_two);
  520. /* Check that the cached ones where updated */
  521. tt_mem_op(cached_disaster_srv_one, OP_EQ, srv_one, DIGEST256_LEN);
  522. tt_mem_op(cached_disaster_srv_two, OP_EQ, srv_two, DIGEST256_LEN);
  523. /* Ask for an SRV that has already been computed */
  524. get_disaster_srv(2, srv_two);
  525. /* and check that the cache entries have not changed */
  526. tt_mem_op(cached_disaster_srv_one, OP_EQ, srv_one, DIGEST256_LEN);
  527. tt_mem_op(cached_disaster_srv_two, OP_EQ, srv_two, DIGEST256_LEN);
  528. /* Ask for a new SRV */
  529. get_disaster_srv(3, srv_three);
  530. tt_mem_op(cached_disaster_srv_one, OP_EQ, srv_three, DIGEST256_LEN);
  531. tt_mem_op(cached_disaster_srv_two, OP_EQ, srv_two, DIGEST256_LEN);
  532. /* Ask for another SRV: none of the original SRVs should now be cached */
  533. get_disaster_srv(4, srv_four);
  534. tt_mem_op(cached_disaster_srv_one, OP_EQ, srv_three, DIGEST256_LEN);
  535. tt_mem_op(cached_disaster_srv_two, OP_EQ, srv_four, DIGEST256_LEN);
  536. /* Ask for yet another SRV */
  537. get_disaster_srv(5, srv_five);
  538. tt_mem_op(cached_disaster_srv_one, OP_EQ, srv_five, DIGEST256_LEN);
  539. tt_mem_op(cached_disaster_srv_two, OP_EQ, srv_four, DIGEST256_LEN);
  540. done:
  541. ;
  542. }
  543. /** Test our HS descriptor request tracker by making various requests and
  544. * checking whether they get tracked properly. */
  545. static void
  546. test_hid_serv_request_tracker(void *arg)
  547. {
  548. (void) arg;
  549. time_t retval;
  550. routerstatus_t *hsdir = NULL, *hsdir2 = NULL, *hsdir3 = NULL;
  551. time_t now = approx_time();
  552. const char *req_key_str_first =
  553. "vd4zb6zesaubtrjvdqcr2w7x7lhw2up4Xnw4526ThUNbL5o1go+EdUuEqlKxHkNbnK41pRzizzs";
  554. const char *req_key_str_second =
  555. "g53o7iavcd62oihswhr24u6czmqws5kpXnw4526ThUNbL5o1go+EdUuEqlKxHkNbnK41pRzizzs";
  556. const char *req_key_str_small = "ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ";
  557. /*************************** basic test *******************************/
  558. /* Get request tracker and make sure it's empty */
  559. strmap_t *request_tracker = get_last_hid_serv_requests();
  560. tt_int_op(strmap_size(request_tracker),OP_EQ, 0);
  561. /* Let's register a hid serv request */
  562. hsdir = tor_malloc_zero(sizeof(routerstatus_t));
  563. memset(hsdir->identity_digest, 'Z', DIGEST_LEN);
  564. retval = hs_lookup_last_hid_serv_request(hsdir, req_key_str_first,
  565. now, 1);
  566. tt_int_op(retval, OP_EQ, now);
  567. tt_int_op(strmap_size(request_tracker),OP_EQ, 1);
  568. /* Let's lookup a non-existent hidserv request */
  569. retval = hs_lookup_last_hid_serv_request(hsdir, req_key_str_second,
  570. now+1, 0);
  571. tt_int_op(retval, OP_EQ, 0);
  572. tt_int_op(strmap_size(request_tracker),OP_EQ, 1);
  573. /* Let's lookup a real hidserv request */
  574. retval = hs_lookup_last_hid_serv_request(hsdir, req_key_str_first,
  575. now+2, 0);
  576. tt_int_op(retval, OP_EQ, now); /* we got it */
  577. tt_int_op(strmap_size(request_tracker),OP_EQ, 1);
  578. /**********************************************************************/
  579. /* Let's add another request for the same HS but on a different HSDir. */
  580. hsdir2 = tor_malloc_zero(sizeof(routerstatus_t));
  581. memset(hsdir2->identity_digest, 2, DIGEST_LEN);
  582. retval = hs_lookup_last_hid_serv_request(hsdir2, req_key_str_first,
  583. now+3, 1);
  584. tt_int_op(retval, OP_EQ, now+3);
  585. tt_int_op(strmap_size(request_tracker),OP_EQ, 2);
  586. /* Check that we can clean the first request based on time */
  587. hs_clean_last_hid_serv_requests(now+3+REND_HID_SERV_DIR_REQUERY_PERIOD);
  588. tt_int_op(strmap_size(request_tracker),OP_EQ, 1);
  589. /* Check that it doesn't exist anymore */
  590. retval = hs_lookup_last_hid_serv_request(hsdir, req_key_str_first,
  591. now+2, 0);
  592. tt_int_op(retval, OP_EQ, 0);
  593. /* Now let's add a smaller req key str */
  594. hsdir3 = tor_malloc_zero(sizeof(routerstatus_t));
  595. memset(hsdir3->identity_digest, 3, DIGEST_LEN);
  596. retval = hs_lookup_last_hid_serv_request(hsdir3, req_key_str_small,
  597. now+4, 1);
  598. tt_int_op(retval, OP_EQ, now+4);
  599. tt_int_op(strmap_size(request_tracker),OP_EQ, 2);
  600. /*************************** deleting entries **************************/
  601. /* Add another request with very short key */
  602. retval = hs_lookup_last_hid_serv_request(hsdir, "l", now, 1);
  603. tt_int_op(retval, OP_EQ, now);
  604. tt_int_op(strmap_size(request_tracker),OP_EQ, 3);
  605. /* Try deleting entries with a dummy key. Check that our previous requests
  606. * are still there */
  607. tor_capture_bugs_(1);
  608. hs_purge_hid_serv_from_last_hid_serv_requests("a");
  609. tt_int_op(strmap_size(request_tracker),OP_EQ, 3);
  610. tor_end_capture_bugs_();
  611. /* Try another dummy key. Check that requests are still there */
  612. {
  613. char dummy[2000];
  614. memset(dummy, 'Z', 2000);
  615. dummy[1999] = '\x00';
  616. hs_purge_hid_serv_from_last_hid_serv_requests(dummy);
  617. tt_int_op(strmap_size(request_tracker),OP_EQ, 3);
  618. }
  619. /* Another dummy key! */
  620. hs_purge_hid_serv_from_last_hid_serv_requests(req_key_str_second);
  621. tt_int_op(strmap_size(request_tracker),OP_EQ, 3);
  622. /* Now actually delete a request! */
  623. hs_purge_hid_serv_from_last_hid_serv_requests(req_key_str_first);
  624. tt_int_op(strmap_size(request_tracker),OP_EQ, 2);
  625. /* Purge it all! */
  626. hs_purge_last_hid_serv_requests();
  627. request_tracker = get_last_hid_serv_requests();
  628. tt_int_op(strmap_size(request_tracker),OP_EQ, 0);
  629. done:
  630. tor_free(hsdir);
  631. tor_free(hsdir2);
  632. tor_free(hsdir3);
  633. }
  634. static void
  635. test_parse_extended_hostname(void *arg)
  636. {
  637. (void) arg;
  638. char address1[] = "fooaddress.onion";
  639. char address2[] = "aaaaaaaaaaaaaaaa.onion";
  640. char address3[] = "fooaddress.exit";
  641. char address4[] = "www.torproject.org";
  642. char address5[] = "foo.abcdefghijklmnop.onion";
  643. char address6[] = "foo.bar.abcdefghijklmnop.onion";
  644. char address7[] = ".abcdefghijklmnop.onion";
  645. char address8[] =
  646. "www.25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid.onion";
  647. tt_assert(BAD_HOSTNAME == parse_extended_hostname(address1));
  648. tt_assert(ONION_V2_HOSTNAME == parse_extended_hostname(address2));
  649. tt_str_op(address2,OP_EQ, "aaaaaaaaaaaaaaaa");
  650. tt_assert(EXIT_HOSTNAME == parse_extended_hostname(address3));
  651. tt_assert(NORMAL_HOSTNAME == parse_extended_hostname(address4));
  652. tt_assert(ONION_V2_HOSTNAME == parse_extended_hostname(address5));
  653. tt_str_op(address5,OP_EQ, "abcdefghijklmnop");
  654. tt_assert(ONION_V2_HOSTNAME == parse_extended_hostname(address6));
  655. tt_str_op(address6,OP_EQ, "abcdefghijklmnop");
  656. tt_assert(BAD_HOSTNAME == parse_extended_hostname(address7));
  657. tt_assert(ONION_V3_HOSTNAME == parse_extended_hostname(address8));
  658. tt_str_op(address8, OP_EQ,
  659. "25njqamcweflpvkl73j4szahhihoc4xt3ktcgjnpaingr5yhkenl5sid");
  660. done: ;
  661. }
  662. static void
  663. test_time_between_tp_and_srv(void *arg)
  664. {
  665. int ret;
  666. networkstatus_t ns;
  667. (void) arg;
  668. /* This function should be returning true where "^" are:
  669. *
  670. * +------------------------------------------------------------------+
  671. * | |
  672. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  673. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  674. * | |
  675. * | $==========|-----------$===========|-----------$===========| |
  676. * | ^^^^^^^^^^^^ ^^^^^^^^^^^^ |
  677. * | |
  678. * +------------------------------------------------------------------+
  679. */
  680. ret = parse_rfc1123_time("Sat, 26 Oct 1985 00:00:00 UTC", &ns.valid_after);
  681. tt_int_op(ret, OP_EQ, 0);
  682. ret = parse_rfc1123_time("Sat, 26 Oct 1985 01:00:00 UTC", &ns.fresh_until);
  683. tt_int_op(ret, OP_EQ, 0);
  684. dirvote_recalculate_timing(get_options(), ns.valid_after);
  685. ret = hs_in_period_between_tp_and_srv(&ns, 0);
  686. tt_int_op(ret, OP_EQ, 0);
  687. ret = parse_rfc1123_time("Sat, 26 Oct 1985 11:00:00 UTC", &ns.valid_after);
  688. tt_int_op(ret, OP_EQ, 0);
  689. ret = parse_rfc1123_time("Sat, 26 Oct 1985 12:00:00 UTC", &ns.fresh_until);
  690. tt_int_op(ret, OP_EQ, 0);
  691. dirvote_recalculate_timing(get_options(), ns.valid_after);
  692. ret = hs_in_period_between_tp_and_srv(&ns, 0);
  693. tt_int_op(ret, OP_EQ, 0);
  694. ret = parse_rfc1123_time("Sat, 26 Oct 1985 12:00:00 UTC", &ns.valid_after);
  695. tt_int_op(ret, OP_EQ, 0);
  696. ret = parse_rfc1123_time("Sat, 26 Oct 1985 13:00:00 UTC", &ns.fresh_until);
  697. tt_int_op(ret, OP_EQ, 0);
  698. dirvote_recalculate_timing(get_options(), ns.valid_after);
  699. ret = hs_in_period_between_tp_and_srv(&ns, 0);
  700. tt_int_op(ret, OP_EQ, 1);
  701. ret = parse_rfc1123_time("Sat, 26 Oct 1985 23:00:00 UTC", &ns.valid_after);
  702. tt_int_op(ret, OP_EQ, 0);
  703. ret = parse_rfc1123_time("Sat, 27 Oct 1985 00:00:00 UTC", &ns.fresh_until);
  704. tt_int_op(ret, OP_EQ, 0);
  705. dirvote_recalculate_timing(get_options(), ns.valid_after);
  706. ret = hs_in_period_between_tp_and_srv(&ns, 0);
  707. tt_int_op(ret, OP_EQ, 1);
  708. ret = parse_rfc1123_time("Sat, 27 Oct 1985 00:00:00 UTC", &ns.valid_after);
  709. tt_int_op(ret, OP_EQ, 0);
  710. ret = parse_rfc1123_time("Sat, 27 Oct 1985 01:00:00 UTC", &ns.fresh_until);
  711. tt_int_op(ret, OP_EQ, 0);
  712. dirvote_recalculate_timing(get_options(), ns.valid_after);
  713. ret = hs_in_period_between_tp_and_srv(&ns, 0);
  714. tt_int_op(ret, OP_EQ, 0);
  715. done:
  716. ;
  717. }
  718. /************ Reachability Test (it is huge) ****************/
  719. /* Simulate different consensus for client and service. Used by the
  720. * reachability test. The SRV and responsible HSDir list are used by all
  721. * reachability tests so make them common to simplify setup and teardown. */
  722. static networkstatus_t *mock_service_ns = NULL;
  723. static networkstatus_t *mock_client_ns = NULL;
  724. static sr_srv_t current_srv, previous_srv;
  725. static smartlist_t *service_responsible_hsdirs = NULL;
  726. static smartlist_t *client_responsible_hsdirs = NULL;
  727. static networkstatus_t *
  728. mock_networkstatus_get_live_consensus_service(time_t now)
  729. {
  730. (void) now;
  731. if (mock_service_ns) {
  732. return mock_service_ns;
  733. }
  734. mock_service_ns = tor_malloc_zero(sizeof(networkstatus_t));
  735. mock_service_ns->routerstatus_list = smartlist_new();
  736. mock_service_ns->type = NS_TYPE_CONSENSUS;
  737. return mock_service_ns;
  738. }
  739. static networkstatus_t *
  740. mock_networkstatus_get_latest_consensus_service(void)
  741. {
  742. return mock_networkstatus_get_live_consensus_service(0);
  743. }
  744. static networkstatus_t *
  745. mock_networkstatus_get_live_consensus_client(time_t now)
  746. {
  747. (void) now;
  748. if (mock_client_ns) {
  749. return mock_client_ns;
  750. }
  751. mock_client_ns = tor_malloc_zero(sizeof(networkstatus_t));
  752. mock_client_ns->routerstatus_list = smartlist_new();
  753. mock_client_ns->type = NS_TYPE_CONSENSUS;
  754. return mock_client_ns;
  755. }
  756. static networkstatus_t *
  757. mock_networkstatus_get_latest_consensus_client(void)
  758. {
  759. return mock_networkstatus_get_live_consensus_client(0);
  760. }
  761. /* Mock function because we are not trying to test the close circuit that does
  762. * an awful lot of checks on the circuit object. */
  763. static void
  764. mock_circuit_mark_for_close(circuit_t *circ, int reason, int line,
  765. const char *file)
  766. {
  767. (void) circ;
  768. (void) reason;
  769. (void) line;
  770. (void) file;
  771. return;
  772. }
  773. /* Initialize a big HSDir V3 hash ring. */
  774. static void
  775. helper_initialize_big_hash_ring(networkstatus_t *ns)
  776. {
  777. int ret;
  778. /* Generate 250 hsdirs! :) */
  779. for (int counter = 1 ; counter < 251 ; counter++) {
  780. /* Let's generate random nickname for each hsdir... */
  781. char nickname_binary[8];
  782. char nickname_str[13] = {0};
  783. crypto_rand(nickname_binary, sizeof(nickname_binary));
  784. ret = base64_encode(nickname_str, sizeof(nickname_str),
  785. nickname_binary, sizeof(nickname_binary), 0);
  786. tt_int_op(ret, OP_EQ, 12);
  787. helper_add_hsdir_to_networkstatus(ns, counter, nickname_str, 1);
  788. }
  789. /* Make sure we have 200 hsdirs in our list */
  790. tt_int_op(smartlist_len(ns->routerstatus_list), OP_EQ, 250);
  791. done:
  792. ;
  793. }
  794. /** Initialize service and publish its descriptor as needed. Return the newly
  795. * allocated service object to the caller. */
  796. static hs_service_t *
  797. helper_init_service(time_t now)
  798. {
  799. int retval;
  800. hs_service_t *service = hs_service_new(get_options());
  801. tt_assert(service);
  802. service->config.version = HS_VERSION_THREE;
  803. ed25519_secret_key_generate(&service->keys.identity_sk, 0);
  804. ed25519_public_key_generate(&service->keys.identity_pk,
  805. &service->keys.identity_sk);
  806. /* Register service to global map. */
  807. retval = register_service(get_hs_service_map(), service);
  808. tt_int_op(retval, OP_EQ, 0);
  809. /* Initialize service descriptor */
  810. build_all_descriptors(now);
  811. tt_assert(service->desc_current);
  812. tt_assert(service->desc_next);
  813. done:
  814. return service;
  815. }
  816. /* Helper function to set the RFC 1123 time string into t. */
  817. static void
  818. set_consensus_times(const char *time, time_t *t)
  819. {
  820. tt_assert(time);
  821. tt_assert(t);
  822. int ret = parse_rfc1123_time(time, t);
  823. tt_int_op(ret, OP_EQ, 0);
  824. done:
  825. return;
  826. }
  827. /* Helper function to cleanup the mock consensus (client and service) */
  828. static void
  829. cleanup_mock_ns(void)
  830. {
  831. if (mock_service_ns) {
  832. SMARTLIST_FOREACH(mock_service_ns->routerstatus_list,
  833. routerstatus_t *, rs, routerstatus_free(rs));
  834. smartlist_clear(mock_service_ns->routerstatus_list);
  835. mock_service_ns->sr_info.current_srv = NULL;
  836. mock_service_ns->sr_info.previous_srv = NULL;
  837. networkstatus_vote_free(mock_service_ns);
  838. mock_service_ns = NULL;
  839. }
  840. if (mock_client_ns) {
  841. SMARTLIST_FOREACH(mock_client_ns->routerstatus_list,
  842. routerstatus_t *, rs, routerstatus_free(rs));
  843. smartlist_clear(mock_client_ns->routerstatus_list);
  844. mock_client_ns->sr_info.current_srv = NULL;
  845. mock_client_ns->sr_info.previous_srv = NULL;
  846. networkstatus_vote_free(mock_client_ns);
  847. mock_client_ns = NULL;
  848. }
  849. }
  850. /* Helper function to setup a reachability test. Once called, the
  851. * cleanup_reachability_test MUST be called at the end. */
  852. static void
  853. setup_reachability_test(void)
  854. {
  855. MOCK(circuit_mark_for_close_, mock_circuit_mark_for_close);
  856. MOCK(get_or_state, get_or_state_replacement);
  857. hs_init();
  858. /* Baseline to start with. */
  859. memset(&current_srv, 0, sizeof(current_srv));
  860. memset(&previous_srv, 1, sizeof(previous_srv));
  861. /* Initialize the consensuses. */
  862. mock_networkstatus_get_latest_consensus_service();
  863. mock_networkstatus_get_latest_consensus_client();
  864. service_responsible_hsdirs = smartlist_new();
  865. client_responsible_hsdirs = smartlist_new();
  866. }
  867. /* Helper function to cleanup a reachability test initial setup. */
  868. static void
  869. cleanup_reachability_test(void)
  870. {
  871. smartlist_free(service_responsible_hsdirs);
  872. service_responsible_hsdirs = NULL;
  873. smartlist_free(client_responsible_hsdirs);
  874. client_responsible_hsdirs = NULL;
  875. hs_free_all();
  876. cleanup_mock_ns();
  877. UNMOCK(get_or_state);
  878. UNMOCK(circuit_mark_for_close_);
  879. }
  880. /* A reachability test always check if the resulting service and client
  881. * responsible HSDir for the given parameters are equal.
  882. *
  883. * Return true iff the same exact nodes are in both list. */
  884. static int
  885. are_responsible_hsdirs_equal(void)
  886. {
  887. int count = 0;
  888. tt_int_op(smartlist_len(client_responsible_hsdirs), OP_EQ, 6);
  889. tt_int_op(smartlist_len(service_responsible_hsdirs), OP_EQ, 6);
  890. SMARTLIST_FOREACH_BEGIN(client_responsible_hsdirs,
  891. const routerstatus_t *, c_rs) {
  892. SMARTLIST_FOREACH_BEGIN(service_responsible_hsdirs,
  893. const routerstatus_t *, s_rs) {
  894. if (tor_memeq(c_rs->identity_digest, s_rs->identity_digest,
  895. DIGEST_LEN)) {
  896. count++;
  897. break;
  898. }
  899. } SMARTLIST_FOREACH_END(s_rs);
  900. } SMARTLIST_FOREACH_END(c_rs);
  901. done:
  902. return (count == 6);
  903. }
  904. /* Tor doesn't use such a function to get the previous HSDir, it is only used
  905. * in node_set_hsdir_index(). We need it here so we can test the reachability
  906. * scenario 6 that requires the previous time period to compute the list of
  907. * responsible HSDir because of the client state timing. */
  908. static uint64_t
  909. get_previous_time_period(time_t now)
  910. {
  911. return hs_get_time_period_num(now) - 1;
  912. }
  913. /* Configuration of a reachability test scenario. */
  914. typedef struct reachability_cfg_t {
  915. /* Consensus timings to be set. They have to be compliant with
  916. * RFC 1123 time format. */
  917. const char *service_valid_after;
  918. const char *service_valid_until;
  919. const char *client_valid_after;
  920. const char *client_valid_until;
  921. /* SRVs that the service and client should use. */
  922. sr_srv_t *service_current_srv;
  923. sr_srv_t *service_previous_srv;
  924. sr_srv_t *client_current_srv;
  925. sr_srv_t *client_previous_srv;
  926. /* A time period function for the service to use for this scenario. For a
  927. * successful reachability test, the client always use the current time
  928. * period thus why no client function. */
  929. uint64_t (*service_time_period_fn)(time_t);
  930. /* Is the client and service expected to be in a new time period. After
  931. * setting the consensus time, the reachability test checks
  932. * hs_in_period_between_tp_and_srv() and test the returned value against
  933. * this. */
  934. unsigned int service_in_new_tp;
  935. unsigned int client_in_new_tp;
  936. /* Some scenario requires a hint that the client, because of its consensus
  937. * time, will request the "next" service descriptor so this indicates if it
  938. * is the case or not. */
  939. unsigned int client_fetch_next_desc;
  940. } reachability_cfg_t;
  941. /* Some defines to help with semantic while reading a configuration below. */
  942. #define NOT_IN_NEW_TP 0
  943. #define IN_NEW_TP 1
  944. #define DONT_NEED_NEXT_DESC 0
  945. #define NEED_NEXT_DESC 1
  946. static reachability_cfg_t reachability_scenarios[] = {
  947. /* Scenario 1
  948. *
  949. * +------------------------------------------------------------------+
  950. * | |
  951. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  952. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  953. * | |
  954. * | $==========|-----------$===========|-----------$===========| |
  955. * | ^ ^ |
  956. * | S C |
  957. * +------------------------------------------------------------------+
  958. *
  959. * S: Service, C: Client
  960. *
  961. * Service consensus valid_after time is set to 13:00 and client to 15:00,
  962. * both are after TP#1 thus have access to SRV#1. Service and client should
  963. * be using TP#1.
  964. */
  965. { "Sat, 26 Oct 1985 13:00:00 UTC", /* Service valid_after */
  966. "Sat, 26 Oct 1985 14:00:00 UTC", /* Service valid_until */
  967. "Sat, 26 Oct 1985 15:00:00 UTC", /* Client valid_after */
  968. "Sat, 26 Oct 1985 16:00:00 UTC", /* Client valid_until. */
  969. &current_srv, NULL, /* Service current and previous SRV */
  970. &current_srv, NULL, /* Client current and previous SRV */
  971. hs_get_time_period_num, /* Service time period function. */
  972. IN_NEW_TP, /* Is service in new TP? */
  973. IN_NEW_TP, /* Is client in new TP? */
  974. NEED_NEXT_DESC },
  975. /* Scenario 2
  976. *
  977. * +------------------------------------------------------------------+
  978. * | |
  979. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  980. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  981. * | |
  982. * | $==========|-----------$===========|-----------$===========| |
  983. * | ^ ^ |
  984. * | S C |
  985. * +------------------------------------------------------------------+
  986. *
  987. * S: Service, C: Client
  988. *
  989. * Service consensus valid_after time is set to 23:00 and client to 01:00,
  990. * which makes the client after the SRV#2 and the service just before. The
  991. * service should only be using TP#1. The client should be using TP#1.
  992. */
  993. { "Sat, 26 Oct 1985 23:00:00 UTC", /* Service valid_after */
  994. "Sat, 27 Oct 1985 00:00:00 UTC", /* Service valid_until */
  995. "Sat, 27 Oct 1985 01:00:00 UTC", /* Client valid_after */
  996. "Sat, 27 Oct 1985 02:00:00 UTC", /* Client valid_until. */
  997. &previous_srv, NULL, /* Service current and previous SRV */
  998. &current_srv, &previous_srv, /* Client current and previous SRV */
  999. hs_get_time_period_num, /* Service time period function. */
  1000. IN_NEW_TP, /* Is service in new TP? */
  1001. NOT_IN_NEW_TP, /* Is client in new TP? */
  1002. NEED_NEXT_DESC },
  1003. /* Scenario 3
  1004. *
  1005. * +------------------------------------------------------------------+
  1006. * | |
  1007. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1008. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1009. * | |
  1010. * | $==========|-----------$===========|----------$===========| |
  1011. * | ^ ^ |
  1012. * | S C |
  1013. * +------------------------------------------------------------------+
  1014. *
  1015. * S: Service, C: Client
  1016. *
  1017. * Service consensus valid_after time is set to 03:00 and client to 05:00,
  1018. * which makes both after SRV#2. The service should be using TP#1 as its
  1019. * current time period. The client should be using TP#1.
  1020. */
  1021. { "Sat, 27 Oct 1985 03:00:00 UTC", /* Service valid_after */
  1022. "Sat, 27 Oct 1985 04:00:00 UTC", /* Service valid_until */
  1023. "Sat, 27 Oct 1985 05:00:00 UTC", /* Client valid_after */
  1024. "Sat, 27 Oct 1985 06:00:00 UTC", /* Client valid_until. */
  1025. &current_srv, &previous_srv, /* Service current and previous SRV */
  1026. &current_srv, &previous_srv, /* Client current and previous SRV */
  1027. hs_get_time_period_num, /* Service time period function. */
  1028. NOT_IN_NEW_TP, /* Is service in new TP? */
  1029. NOT_IN_NEW_TP, /* Is client in new TP? */
  1030. DONT_NEED_NEXT_DESC },
  1031. /* Scenario 4
  1032. *
  1033. * +------------------------------------------------------------------+
  1034. * | |
  1035. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1036. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1037. * | |
  1038. * | $==========|-----------$===========|-----------$===========| |
  1039. * | ^ ^ |
  1040. * | S C |
  1041. * +------------------------------------------------------------------+
  1042. *
  1043. * S: Service, C: Client
  1044. *
  1045. * Service consensus valid_after time is set to 11:00 and client to 13:00,
  1046. * which makes the service before TP#2 and the client just after. The
  1047. * service should be using TP#1 as its current time period and TP#2 as the
  1048. * next. The client should be using TP#2 time period.
  1049. */
  1050. { "Sat, 27 Oct 1985 11:00:00 UTC", /* Service valid_after */
  1051. "Sat, 27 Oct 1985 12:00:00 UTC", /* Service valid_until */
  1052. "Sat, 27 Oct 1985 13:00:00 UTC", /* Client valid_after */
  1053. "Sat, 27 Oct 1985 14:00:00 UTC", /* Client valid_until. */
  1054. &current_srv, &previous_srv, /* Service current and previous SRV */
  1055. &current_srv, &previous_srv, /* Client current and previous SRV */
  1056. hs_get_next_time_period_num, /* Service time period function. */
  1057. NOT_IN_NEW_TP, /* Is service in new TP? */
  1058. IN_NEW_TP, /* Is client in new TP? */
  1059. NEED_NEXT_DESC },
  1060. /* Scenario 5
  1061. *
  1062. * +------------------------------------------------------------------+
  1063. * | |
  1064. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1065. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1066. * | |
  1067. * | $==========|-----------$===========|-----------$===========| |
  1068. * | ^ ^ |
  1069. * | C S |
  1070. * +------------------------------------------------------------------+
  1071. *
  1072. * S: Service, C: Client
  1073. *
  1074. * Service consensus valid_after time is set to 01:00 and client to 23:00,
  1075. * which makes the service after SRV#2 and the client just before. The
  1076. * service should be using TP#1 as its current time period and TP#2 as the
  1077. * next. The client should be using TP#1 time period.
  1078. */
  1079. { "Sat, 27 Oct 1985 01:00:00 UTC", /* Service valid_after */
  1080. "Sat, 27 Oct 1985 02:00:00 UTC", /* Service valid_until */
  1081. "Sat, 26 Oct 1985 23:00:00 UTC", /* Client valid_after */
  1082. "Sat, 27 Oct 1985 00:00:00 UTC", /* Client valid_until. */
  1083. &current_srv, &previous_srv, /* Service current and previous SRV */
  1084. &previous_srv, NULL, /* Client current and previous SRV */
  1085. hs_get_time_period_num, /* Service time period function. */
  1086. NOT_IN_NEW_TP, /* Is service in new TP? */
  1087. IN_NEW_TP, /* Is client in new TP? */
  1088. DONT_NEED_NEXT_DESC },
  1089. /* Scenario 6
  1090. *
  1091. * +------------------------------------------------------------------+
  1092. * | |
  1093. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1094. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1095. * | |
  1096. * | $==========|-----------$===========|-----------$===========| |
  1097. * | ^ ^ |
  1098. * | C S |
  1099. * +------------------------------------------------------------------+
  1100. *
  1101. * S: Service, C: Client
  1102. *
  1103. * Service consensus valid_after time is set to 13:00 and client to 11:00,
  1104. * which makes the service outside after TP#2 and the client just before.
  1105. * The service should be using TP#1 as its current time period and TP#2 as
  1106. * its next. The client should be using TP#1 time period.
  1107. */
  1108. { "Sat, 27 Oct 1985 13:00:00 UTC", /* Service valid_after */
  1109. "Sat, 27 Oct 1985 14:00:00 UTC", /* Service valid_until */
  1110. "Sat, 27 Oct 1985 11:00:00 UTC", /* Client valid_after */
  1111. "Sat, 27 Oct 1985 12:00:00 UTC", /* Client valid_until. */
  1112. &current_srv, &previous_srv, /* Service current and previous SRV */
  1113. &current_srv, &previous_srv, /* Client current and previous SRV */
  1114. get_previous_time_period, /* Service time period function. */
  1115. IN_NEW_TP, /* Is service in new TP? */
  1116. NOT_IN_NEW_TP, /* Is client in new TP? */
  1117. DONT_NEED_NEXT_DESC },
  1118. /* End marker. */
  1119. { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0, 0, 0}
  1120. };
  1121. /* Run a single reachability scenario. num_scenario is the corresponding
  1122. * scenario number from the documentation. It is used to log it in case of
  1123. * failure so we know which scenario fails. */
  1124. static int
  1125. run_reachability_scenario(const reachability_cfg_t *cfg, int num_scenario)
  1126. {
  1127. int ret = -1;
  1128. hs_service_t *service;
  1129. uint64_t service_tp, client_tp;
  1130. ed25519_public_key_t service_blinded_pk, client_blinded_pk;
  1131. setup_reachability_test();
  1132. tt_assert(cfg);
  1133. /* Set service consensus time. */
  1134. set_consensus_times(cfg->service_valid_after,
  1135. &mock_service_ns->valid_after);
  1136. set_consensus_times(cfg->service_valid_until,
  1137. &mock_service_ns->valid_until);
  1138. set_consensus_times(cfg->service_valid_until,
  1139. &mock_service_ns->fresh_until);
  1140. dirvote_recalculate_timing(get_options(), mock_service_ns->valid_after);
  1141. /* Set client consensus time. */
  1142. set_consensus_times(cfg->client_valid_after,
  1143. &mock_client_ns->valid_after);
  1144. set_consensus_times(cfg->client_valid_until,
  1145. &mock_client_ns->valid_until);
  1146. set_consensus_times(cfg->client_valid_until,
  1147. &mock_client_ns->fresh_until);
  1148. dirvote_recalculate_timing(get_options(), mock_client_ns->valid_after);
  1149. /* New time period checks for this scenario. */
  1150. tt_int_op(hs_in_period_between_tp_and_srv(mock_service_ns, 0), OP_EQ,
  1151. cfg->service_in_new_tp);
  1152. tt_int_op(hs_in_period_between_tp_and_srv(mock_client_ns, 0), OP_EQ,
  1153. cfg->client_in_new_tp);
  1154. /* Set the SRVs for this scenario. */
  1155. mock_client_ns->sr_info.current_srv = cfg->client_current_srv;
  1156. mock_client_ns->sr_info.previous_srv = cfg->client_previous_srv;
  1157. mock_service_ns->sr_info.current_srv = cfg->service_current_srv;
  1158. mock_service_ns->sr_info.previous_srv = cfg->service_previous_srv;
  1159. /* Initialize a service to get keys. */
  1160. service = helper_init_service(time(NULL));
  1161. /*
  1162. * === Client setup ===
  1163. */
  1164. MOCK(networkstatus_get_live_consensus,
  1165. mock_networkstatus_get_live_consensus_client);
  1166. MOCK(networkstatus_get_latest_consensus,
  1167. mock_networkstatus_get_latest_consensus_client);
  1168. /* Make networkstatus_is_live() happy. */
  1169. update_approx_time(mock_client_ns->valid_after);
  1170. /* Initialize a big hashring for this consensus with the hsdir index set. */
  1171. helper_initialize_big_hash_ring(mock_client_ns);
  1172. /* Client ONLY use the current time period. This is the whole point of these
  1173. * reachability test that is to make sure the client can always reach the
  1174. * service using only its current time period. */
  1175. client_tp = hs_get_time_period_num(0);
  1176. hs_build_blinded_pubkey(&service->keys.identity_pk, NULL, 0,
  1177. client_tp, &client_blinded_pk);
  1178. hs_get_responsible_hsdirs(&client_blinded_pk, client_tp, 0, 1,
  1179. client_responsible_hsdirs);
  1180. /* Cleanup the nodelist so we can let the service computes its own set of
  1181. * node with its own hashring. */
  1182. cleanup_nodelist();
  1183. tt_int_op(smartlist_len(client_responsible_hsdirs), OP_EQ, 6);
  1184. UNMOCK(networkstatus_get_latest_consensus);
  1185. UNMOCK(networkstatus_get_live_consensus);
  1186. /*
  1187. * === Service setup ===
  1188. */
  1189. MOCK(networkstatus_get_live_consensus,
  1190. mock_networkstatus_get_live_consensus_service);
  1191. MOCK(networkstatus_get_latest_consensus,
  1192. mock_networkstatus_get_latest_consensus_service);
  1193. /* Make networkstatus_is_live() happy. */
  1194. update_approx_time(mock_service_ns->valid_after);
  1195. /* Initialize a big hashring for this consensus with the hsdir index set. */
  1196. helper_initialize_big_hash_ring(mock_service_ns);
  1197. service_tp = cfg->service_time_period_fn(0);
  1198. hs_build_blinded_pubkey(&service->keys.identity_pk, NULL, 0,
  1199. service_tp, &service_blinded_pk);
  1200. /* A service builds two lists of responsible HSDir, for the current and the
  1201. * next descriptor. Depending on the scenario, the client timing indicate if
  1202. * it is fetching the current or the next descriptor so we use the
  1203. * "client_fetch_next_desc" to know which one the client is trying to get to
  1204. * confirm that the service computes the same hashring for the same blinded
  1205. * key and service time period function. */
  1206. hs_get_responsible_hsdirs(&service_blinded_pk, service_tp,
  1207. cfg->client_fetch_next_desc, 0,
  1208. service_responsible_hsdirs);
  1209. cleanup_nodelist();
  1210. tt_int_op(smartlist_len(service_responsible_hsdirs), OP_EQ, 6);
  1211. UNMOCK(networkstatus_get_latest_consensus);
  1212. UNMOCK(networkstatus_get_live_consensus);
  1213. /* Some testing of the values we just got from the client and service. */
  1214. tt_mem_op(&client_blinded_pk, OP_EQ, &service_blinded_pk,
  1215. ED25519_PUBKEY_LEN);
  1216. tt_int_op(are_responsible_hsdirs_equal(), OP_EQ, 1);
  1217. /* Everything went well. */
  1218. ret = 0;
  1219. done:
  1220. cleanup_reachability_test();
  1221. if (ret == -1) {
  1222. /* Do this so we can know which scenario failed. */
  1223. char msg[32];
  1224. tor_snprintf(msg, sizeof(msg), "Scenario %d failed", num_scenario);
  1225. tt_fail_msg(msg);
  1226. }
  1227. return ret;
  1228. }
  1229. static void
  1230. test_reachability(void *arg)
  1231. {
  1232. (void) arg;
  1233. /* NOTE: An important axiom to understand here is that SRV#N must only be
  1234. * used with TP#N value. For example, SRV#2 with TP#1 should NEVER be used
  1235. * together. The HSDir index computation is based on this axiom.*/
  1236. for (int i = 0; reachability_scenarios[i].service_valid_after; ++i) {
  1237. int ret = run_reachability_scenario(&reachability_scenarios[i], i + 1);
  1238. if (ret < 0) {
  1239. return;
  1240. }
  1241. }
  1242. }
  1243. /** Pick an HSDir for service with <b>onion_identity_pk</b> as a client. Put
  1244. * its identity digest in <b>hsdir_digest_out</b>. */
  1245. static void
  1246. helper_client_pick_hsdir(const ed25519_public_key_t *onion_identity_pk,
  1247. char *hsdir_digest_out)
  1248. {
  1249. tt_assert(onion_identity_pk);
  1250. routerstatus_t *client_hsdir = pick_hsdir_v3(onion_identity_pk);
  1251. tt_assert(client_hsdir);
  1252. digest_to_base64(hsdir_digest_out, client_hsdir->identity_digest);
  1253. done:
  1254. ;
  1255. }
  1256. static void
  1257. test_hs_indexes(void *arg)
  1258. {
  1259. int ret;
  1260. uint64_t period_num = 42;
  1261. ed25519_public_key_t pubkey;
  1262. (void) arg;
  1263. /* Build the hs_index */
  1264. {
  1265. uint8_t hs_index[DIGEST256_LEN];
  1266. const char *b32_test_vector =
  1267. "37e5cbbd56a22823714f18f1623ece5983a0d64c78495a8cfab854245e5f9a8a";
  1268. char test_vector[DIGEST256_LEN];
  1269. ret = base16_decode(test_vector, sizeof(test_vector), b32_test_vector,
  1270. strlen(b32_test_vector));
  1271. tt_int_op(ret, OP_EQ, sizeof(test_vector));
  1272. /* Our test vector uses a public key set to 32 bytes of \x42. */
  1273. memset(&pubkey, '\x42', sizeof(pubkey));
  1274. hs_build_hs_index(1, &pubkey, period_num, hs_index);
  1275. tt_mem_op(hs_index, OP_EQ, test_vector, sizeof(hs_index));
  1276. }
  1277. /* Build the hsdir_index */
  1278. {
  1279. uint8_t srv[DIGEST256_LEN];
  1280. uint8_t hsdir_index[DIGEST256_LEN];
  1281. const char *b32_test_vector =
  1282. "db475361014a09965e7e5e4d4a25b8f8d4b8f16cb1d8a7e95eed50249cc1a2d5";
  1283. char test_vector[DIGEST256_LEN];
  1284. ret = base16_decode(test_vector, sizeof(test_vector), b32_test_vector,
  1285. strlen(b32_test_vector));
  1286. tt_int_op(ret, OP_EQ, sizeof(test_vector));
  1287. /* Our test vector uses a public key set to 32 bytes of \x42. */
  1288. memset(&pubkey, '\x42', sizeof(pubkey));
  1289. memset(srv, '\x43', sizeof(srv));
  1290. hs_build_hsdir_index(&pubkey, srv, period_num, hsdir_index);
  1291. tt_mem_op(hsdir_index, OP_EQ, test_vector, sizeof(hsdir_index));
  1292. }
  1293. done:
  1294. ;
  1295. }
  1296. #define EARLY_IN_SRV_TO_TP 0
  1297. #define LATE_IN_SRV_TO_TP 1
  1298. #define EARLY_IN_TP_TO_SRV 2
  1299. #define LATE_IN_TP_TO_SRV 3
  1300. /** Set the consensus and system time based on <b>position</b>. See the
  1301. * following diagram for details:
  1302. *
  1303. * +------------------------------------------------------------------+
  1304. * | |
  1305. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1306. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1307. * | |
  1308. * | $==========|-----------$===========|----------$===========| |
  1309. * | |
  1310. * | |
  1311. * +------------------------------------------------------------------+
  1312. */
  1313. static time_t
  1314. helper_set_consensus_and_system_time(networkstatus_t *ns, int position)
  1315. {
  1316. time_t real_time = 0;
  1317. /* The period between SRV#N and TP#N is from 00:00 to 12:00 UTC. Consensus
  1318. * valid_after is what matters here, the rest is just to specify the voting
  1319. * period correctly. */
  1320. if (position == LATE_IN_SRV_TO_TP) {
  1321. parse_rfc1123_time("Wed, 13 Apr 2016 11:00:00 UTC", &ns->valid_after);
  1322. parse_rfc1123_time("Wed, 13 Apr 2016 12:00:00 UTC", &ns->fresh_until);
  1323. parse_rfc1123_time("Wed, 13 Apr 2016 14:00:00 UTC", &ns->valid_until);
  1324. } else if (position == EARLY_IN_TP_TO_SRV) {
  1325. parse_rfc1123_time("Wed, 13 Apr 2016 13:00:00 UTC", &ns->valid_after);
  1326. parse_rfc1123_time("Wed, 13 Apr 2016 14:00:00 UTC", &ns->fresh_until);
  1327. parse_rfc1123_time("Wed, 13 Apr 2016 16:00:00 UTC", &ns->valid_until);
  1328. } else if (position == LATE_IN_TP_TO_SRV) {
  1329. parse_rfc1123_time("Wed, 13 Apr 2016 23:00:00 UTC", &ns->valid_after);
  1330. parse_rfc1123_time("Wed, 14 Apr 2016 00:00:00 UTC", &ns->fresh_until);
  1331. parse_rfc1123_time("Wed, 14 Apr 2016 02:00:00 UTC", &ns->valid_until);
  1332. } else if (position == EARLY_IN_SRV_TO_TP) {
  1333. parse_rfc1123_time("Wed, 14 Apr 2016 01:00:00 UTC", &ns->valid_after);
  1334. parse_rfc1123_time("Wed, 14 Apr 2016 02:00:00 UTC", &ns->fresh_until);
  1335. parse_rfc1123_time("Wed, 14 Apr 2016 04:00:00 UTC", &ns->valid_until);
  1336. } else {
  1337. tt_assert(0);
  1338. }
  1339. dirvote_recalculate_timing(get_options(), ns->valid_after);
  1340. /* Set system time: pretend to be just 2 minutes before consensus expiry */
  1341. real_time = ns->valid_until - 120;
  1342. update_approx_time(real_time);
  1343. done:
  1344. return real_time;
  1345. }
  1346. /** Helper function that carries out the actual test for
  1347. * test_client_service_sync() */
  1348. static void
  1349. helper_test_hsdir_sync(networkstatus_t *ns,
  1350. int service_position, int client_position,
  1351. int client_fetches_next_desc)
  1352. {
  1353. hs_service_descriptor_t *desc;
  1354. int retval;
  1355. /** Test logic:
  1356. * 1) Initialize service time: consensus and system time.
  1357. * 1.1) Initialize service hash ring
  1358. * 2) Initialize service and publish descriptors.
  1359. * 3) Initialize client time: consensus and system time.
  1360. * 3.1) Initialize client hash ring
  1361. * 4) Try to fetch descriptor as client, and CHECK that the HSDir picked by
  1362. * the client was also picked by service.
  1363. */
  1364. /* 1) Initialize service time: consensus and real time */
  1365. time_t now = helper_set_consensus_and_system_time(ns, service_position);
  1366. helper_initialize_big_hash_ring(ns);
  1367. /* 2) Initialize service */
  1368. hs_service_t *service = helper_init_service(now);
  1369. desc = client_fetches_next_desc ? service->desc_next : service->desc_current;
  1370. /* Now let's upload our desc to all hsdirs */
  1371. upload_descriptor_to_all(service, desc);
  1372. /* Cleanup right now so we don't memleak on error. */
  1373. cleanup_nodelist();
  1374. /* Check that previous hsdirs were populated */
  1375. tt_int_op(smartlist_len(desc->previous_hsdirs), OP_EQ, 6);
  1376. /* 3) Initialize client time */
  1377. helper_set_consensus_and_system_time(ns, client_position);
  1378. cleanup_nodelist();
  1379. SMARTLIST_FOREACH(ns->routerstatus_list,
  1380. routerstatus_t *, rs, routerstatus_free(rs));
  1381. smartlist_clear(ns->routerstatus_list);
  1382. helper_initialize_big_hash_ring(ns);
  1383. /* 4) Pick 6 HSDirs as a client and check that they were also chosen by the
  1384. service. */
  1385. for (int y = 0 ; y < 6 ; y++) {
  1386. char client_hsdir_b64_digest[BASE64_DIGEST_LEN+1] = {0};
  1387. helper_client_pick_hsdir(&service->keys.identity_pk,
  1388. client_hsdir_b64_digest);
  1389. /* CHECK: Go through the hsdirs chosen by the service and make sure that it
  1390. * contains the one picked by the client! */
  1391. retval = smartlist_contains_string(desc->previous_hsdirs,
  1392. client_hsdir_b64_digest);
  1393. tt_int_op(retval, OP_EQ, 1);
  1394. }
  1395. /* Finally, try to pick a 7th hsdir and see that NULL is returned since we
  1396. * exhausted all of them: */
  1397. tt_assert(!pick_hsdir_v3(&service->keys.identity_pk));
  1398. done:
  1399. /* At the end: free all services and initialize the subsystem again, we will
  1400. * need it for next scenario. */
  1401. cleanup_nodelist();
  1402. hs_service_free_all();
  1403. hs_service_init();
  1404. SMARTLIST_FOREACH(ns->routerstatus_list,
  1405. routerstatus_t *, rs, routerstatus_free(rs));
  1406. smartlist_clear(ns->routerstatus_list);
  1407. }
  1408. /** This test ensures that client and service will pick the same HSDirs, under
  1409. * various timing scenarios:
  1410. * a) Scenario where both client and service are in the time segment between
  1411. * SRV#N and TP#N:
  1412. * b) Scenario where both client and service are in the time segment between
  1413. * TP#N and SRV#N+1.
  1414. * c) Scenario where service is between SRV#N and TP#N, but client is between
  1415. * TP#N and SRV#N+1.
  1416. * d) Scenario where service is between TP#N and SRV#N+1, but client is
  1417. * between SRV#N and TP#N.
  1418. *
  1419. * This test is important because it tests that upload_descriptor_to_all() is
  1420. * in synch with pick_hsdir_v3(). That's not the case for the
  1421. * test_reachability() test which only compares the responsible hsdir sets.
  1422. */
  1423. static void
  1424. test_client_service_hsdir_set_sync(void *arg)
  1425. {
  1426. networkstatus_t *ns = NULL;
  1427. (void) arg;
  1428. MOCK(networkstatus_get_latest_consensus,
  1429. mock_networkstatus_get_latest_consensus);
  1430. MOCK(networkstatus_get_live_consensus,
  1431. mock_networkstatus_get_live_consensus);
  1432. MOCK(get_or_state,
  1433. get_or_state_replacement);
  1434. MOCK(hs_desc_encode_descriptor,
  1435. mock_hs_desc_encode_descriptor);
  1436. MOCK(directory_initiate_request,
  1437. mock_directory_initiate_request);
  1438. hs_init();
  1439. /* Initialize a big hash ring: we want it to be big so that client and
  1440. * service cannot accidentally select the same HSDirs */
  1441. ns = networkstatus_get_latest_consensus();
  1442. tt_assert(ns);
  1443. /** Now test the various synch scenarios. See the helper function for more
  1444. details: */
  1445. /* a) Scenario where both client and service are in the time segment between
  1446. * SRV#N and TP#N. At this time the client fetches the first HS desc:
  1447. *
  1448. * +------------------------------------------------------------------+
  1449. * | |
  1450. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1451. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1452. * | |
  1453. * | $==========|-----------$===========|----------$===========| |
  1454. * | ^ ^ |
  1455. * | S C |
  1456. * +------------------------------------------------------------------+
  1457. */
  1458. helper_test_hsdir_sync(ns, LATE_IN_SRV_TO_TP, LATE_IN_SRV_TO_TP, 0);
  1459. /* b) Scenario where both client and service are in the time segment between
  1460. * TP#N and SRV#N+1. At this time the client fetches the second HS
  1461. * desc:
  1462. *
  1463. * +------------------------------------------------------------------+
  1464. * | |
  1465. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1466. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1467. * | |
  1468. * | $==========|-----------$===========|-----------$===========| |
  1469. * | ^ ^ |
  1470. * | S C |
  1471. * +------------------------------------------------------------------+
  1472. */
  1473. helper_test_hsdir_sync(ns, LATE_IN_TP_TO_SRV, LATE_IN_TP_TO_SRV, 1);
  1474. /* c) Scenario where service is between SRV#N and TP#N, but client is
  1475. * between TP#N and SRV#N+1. Client is forward in time so it fetches the
  1476. * second HS desc.
  1477. *
  1478. * +------------------------------------------------------------------+
  1479. * | |
  1480. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1481. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1482. * | |
  1483. * | $==========|-----------$===========|-----------$===========| |
  1484. * | ^ ^ |
  1485. * | S C |
  1486. * +------------------------------------------------------------------+
  1487. */
  1488. helper_test_hsdir_sync(ns, LATE_IN_SRV_TO_TP, EARLY_IN_TP_TO_SRV, 1);
  1489. /* d) Scenario where service is between TP#N and SRV#N+1, but client is
  1490. * between SRV#N and TP#N. Client is backwards in time so it fetches the
  1491. * first HS desc.
  1492. *
  1493. * +------------------------------------------------------------------+
  1494. * | |
  1495. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1496. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1497. * | |
  1498. * | $==========|-----------$===========|-----------$===========| |
  1499. * | ^ ^ |
  1500. * | C S |
  1501. * +------------------------------------------------------------------+
  1502. */
  1503. helper_test_hsdir_sync(ns, EARLY_IN_TP_TO_SRV, LATE_IN_SRV_TO_TP, 0);
  1504. /* e) Scenario where service is between SRV#N and TP#N, but client is
  1505. * between TP#N-1 and SRV#3. Client is backwards in time so it fetches
  1506. * the first HS desc.
  1507. *
  1508. * +------------------------------------------------------------------+
  1509. * | |
  1510. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1511. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1512. * | |
  1513. * | $==========|-----------$===========|-----------$===========| |
  1514. * | ^ ^ |
  1515. * | C S |
  1516. * +------------------------------------------------------------------+
  1517. */
  1518. helper_test_hsdir_sync(ns, EARLY_IN_SRV_TO_TP, LATE_IN_TP_TO_SRV, 0);
  1519. /* f) Scenario where service is between TP#N and SRV#N+1, but client is
  1520. * between SRV#N+1 and TP#N+1. Client is forward in time so it fetches
  1521. * the second HS desc.
  1522. *
  1523. * +------------------------------------------------------------------+
  1524. * | |
  1525. * | 00:00 12:00 00:00 12:00 00:00 12:00 |
  1526. * | SRV#1 TP#1 SRV#2 TP#2 SRV#3 TP#3 |
  1527. * | |
  1528. * | $==========|-----------$===========|-----------$===========| |
  1529. * | ^ ^ |
  1530. * | S C |
  1531. * +------------------------------------------------------------------+
  1532. */
  1533. helper_test_hsdir_sync(ns, LATE_IN_TP_TO_SRV, EARLY_IN_SRV_TO_TP, 1);
  1534. done:
  1535. networkstatus_vote_free(ns);
  1536. nodelist_free_all();
  1537. hs_free_all();
  1538. }
  1539. struct testcase_t hs_common_tests[] = {
  1540. { "build_address", test_build_address, TT_FORK,
  1541. NULL, NULL },
  1542. { "validate_address", test_validate_address, TT_FORK,
  1543. NULL, NULL },
  1544. { "time_period", test_time_period, TT_FORK,
  1545. NULL, NULL },
  1546. { "start_time_of_next_time_period", test_start_time_of_next_time_period,
  1547. TT_FORK, NULL, NULL },
  1548. { "responsible_hsdirs", test_responsible_hsdirs, TT_FORK,
  1549. NULL, NULL },
  1550. { "desc_reupload_logic", test_desc_reupload_logic, TT_FORK,
  1551. NULL, NULL },
  1552. { "disaster_srv", test_disaster_srv, TT_FORK,
  1553. NULL, NULL },
  1554. { "hid_serv_request_tracker", test_hid_serv_request_tracker, TT_FORK,
  1555. NULL, NULL },
  1556. { "parse_extended_hostname", test_parse_extended_hostname, TT_FORK,
  1557. NULL, NULL },
  1558. { "time_between_tp_and_srv", test_time_between_tp_and_srv, TT_FORK,
  1559. NULL, NULL },
  1560. { "reachability", test_reachability, TT_FORK,
  1561. NULL, NULL },
  1562. { "client_service_hsdir_set_sync", test_client_service_hsdir_set_sync,
  1563. TT_FORK, NULL, NULL },
  1564. { "hs_indexes", test_hs_indexes, TT_FORK,
  1565. NULL, NULL },
  1566. END_OF_TESTCASES
  1567. };