test_hs_common.c 67 KB

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