test_routerlist.c 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801
  1. /* Copyright (c) 2014-2019, The Tor Project, Inc. */
  2. /* See LICENSE for licensing information */
  3. #include "orconfig.h"
  4. #include <math.h>
  5. #include <time.h>
  6. #define CONNECTION_PRIVATE
  7. #define DIRCLIENT_PRIVATE
  8. #define DIRVOTE_PRIVATE
  9. #define ENTRYNODES_PRIVATE
  10. #define HIBERNATE_PRIVATE
  11. #define NETWORKSTATUS_PRIVATE
  12. #define ROUTERLIST_PRIVATE
  13. #define NODE_SELECT_PRIVATE
  14. #define TOR_UNIT_TESTING
  15. #include "core/or/or.h"
  16. #include "app/config/config.h"
  17. #include "core/mainloop/connection.h"
  18. #include "feature/control/control.h"
  19. #include "lib/crypt_ops/crypto_rand.h"
  20. #include "feature/dircommon/directory.h"
  21. #include "feature/dirclient/dirclient.h"
  22. #include "feature/dirauth/dirvote.h"
  23. #include "feature/client/entrynodes.h"
  24. #include "feature/hibernate/hibernate.h"
  25. #include "feature/nodelist/microdesc.h"
  26. #include "feature/nodelist/networkstatus.h"
  27. #include "feature/nodelist/nodelist.h"
  28. #include "core/or/policies.h"
  29. #include "feature/relay/router.h"
  30. #include "feature/nodelist/authcert.h"
  31. #include "feature/nodelist/node_select.h"
  32. #include "feature/nodelist/routerlist.h"
  33. #include "feature/nodelist/routerset.h"
  34. #include "feature/dirparse/authcert_parse.h"
  35. #include "feature/dirparse/ns_parse.h"
  36. #include "feature/dirauth/shared_random.h"
  37. #include "app/config/statefile.h"
  38. #include "feature/nodelist/authority_cert_st.h"
  39. #include "feature/dircommon/dir_connection_st.h"
  40. #include "feature/nodelist/networkstatus_st.h"
  41. #include "feature/nodelist/node_st.h"
  42. #include "app/config/or_state_st.h"
  43. #include "feature/nodelist/routerstatus_st.h"
  44. #include "lib/encoding/confline.h"
  45. #include "lib/buf/buffers.h"
  46. #include "test/test.h"
  47. #include "test/test_dir_common.h"
  48. #include "test/log_test_helpers.h"
  49. void construct_consensus(char **consensus_text_md, time_t now);
  50. static authority_cert_t *mock_cert;
  51. static authority_cert_t *
  52. get_my_v3_authority_cert_m(void)
  53. {
  54. tor_assert(mock_cert);
  55. return mock_cert;
  56. }
  57. /* 4 digests + 3 sep + pre + post + NULL */
  58. static char output[4*BASE64_DIGEST256_LEN+3+2+2+1];
  59. static void
  60. mock_get_from_dirserver(uint8_t dir_purpose, uint8_t router_purpose,
  61. const char *resource, int pds_flags,
  62. download_want_authority_t want_authority)
  63. {
  64. (void)dir_purpose;
  65. (void)router_purpose;
  66. (void)pds_flags;
  67. (void)want_authority;
  68. tt_assert(resource);
  69. strlcpy(output, resource, sizeof(output));
  70. done:
  71. ;
  72. }
  73. static void
  74. test_routerlist_initiate_descriptor_downloads(void *arg)
  75. {
  76. const char *prose = "unhurried and wise, we perceive.";
  77. smartlist_t *digests = smartlist_new();
  78. (void)arg;
  79. for (int i = 0; i < 20; i++) {
  80. smartlist_add(digests, (char*)prose);
  81. }
  82. MOCK(directory_get_from_dirserver, mock_get_from_dirserver);
  83. initiate_descriptor_downloads(NULL, DIR_PURPOSE_FETCH_MICRODESC,
  84. digests, 3, 7, 0);
  85. UNMOCK(directory_get_from_dirserver);
  86. tt_str_op(output, OP_EQ, "d/"
  87. "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"
  88. "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"
  89. "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4-"
  90. "dW5odXJyaWVkIGFuZCB3aXNlLCB3ZSBwZXJjZWl2ZS4"
  91. ".z");
  92. done:
  93. smartlist_free(digests);
  94. }
  95. static int count = 0;
  96. static void
  97. mock_initiate_descriptor_downloads(const routerstatus_t *source,
  98. int purpose, smartlist_t *digests,
  99. int lo, int hi, int pds_flags)
  100. {
  101. (void)source;
  102. (void)purpose;
  103. (void)digests;
  104. (void)pds_flags;
  105. (void)hi;
  106. (void)lo;
  107. count += 1;
  108. }
  109. static void
  110. test_routerlist_launch_descriptor_downloads(void *arg)
  111. {
  112. smartlist_t *downloadable = smartlist_new();
  113. time_t now = time(NULL);
  114. char *cp;
  115. (void)arg;
  116. for (int i = 0; i < 100; i++) {
  117. cp = tor_malloc(DIGEST256_LEN);
  118. tt_assert(cp);
  119. crypto_rand(cp, DIGEST256_LEN);
  120. smartlist_add(downloadable, cp);
  121. }
  122. MOCK(initiate_descriptor_downloads, mock_initiate_descriptor_downloads);
  123. launch_descriptor_downloads(DIR_PURPOSE_FETCH_MICRODESC, downloadable,
  124. NULL, now);
  125. tt_int_op(3, OP_EQ, count);
  126. UNMOCK(initiate_descriptor_downloads);
  127. done:
  128. SMARTLIST_FOREACH(downloadable, char *, cp1, tor_free(cp1));
  129. smartlist_free(downloadable);
  130. }
  131. void
  132. construct_consensus(char **consensus_text_md, time_t now)
  133. {
  134. networkstatus_t *vote = NULL;
  135. networkstatus_t *v1 = NULL, *v2 = NULL, *v3 = NULL;
  136. networkstatus_voter_info_t *voter = NULL;
  137. authority_cert_t *cert1=NULL, *cert2=NULL, *cert3=NULL;
  138. crypto_pk_t *sign_skey_1=NULL, *sign_skey_2=NULL, *sign_skey_3=NULL;
  139. crypto_pk_t *sign_skey_leg=NULL;
  140. smartlist_t *votes = NULL;
  141. int n_vrs;
  142. tt_assert(!dir_common_authority_pk_init(&cert1, &cert2, &cert3,
  143. &sign_skey_1, &sign_skey_2,
  144. &sign_skey_3));
  145. sign_skey_leg = pk_generate(4);
  146. dir_common_construct_vote_1(&vote, cert1, sign_skey_1,
  147. &dir_common_gen_routerstatus_for_v3ns,
  148. &v1, &n_vrs, now, 1);
  149. networkstatus_vote_free(vote);
  150. tt_assert(v1);
  151. tt_int_op(n_vrs, OP_EQ, 4);
  152. tt_int_op(smartlist_len(v1->routerstatus_list), OP_EQ, 4);
  153. dir_common_construct_vote_2(&vote, cert2, sign_skey_2,
  154. &dir_common_gen_routerstatus_for_v3ns,
  155. &v2, &n_vrs, now, 1);
  156. networkstatus_vote_free(vote);
  157. tt_assert(v2);
  158. tt_int_op(n_vrs, OP_EQ, 4);
  159. tt_int_op(smartlist_len(v2->routerstatus_list), OP_EQ, 4);
  160. dir_common_construct_vote_3(&vote, cert3, sign_skey_3,
  161. &dir_common_gen_routerstatus_for_v3ns,
  162. &v3, &n_vrs, now, 1);
  163. tt_assert(v3);
  164. tt_int_op(n_vrs, OP_EQ, 4);
  165. tt_int_op(smartlist_len(v3->routerstatus_list), OP_EQ, 4);
  166. networkstatus_vote_free(vote);
  167. votes = smartlist_new();
  168. smartlist_add(votes, v1);
  169. smartlist_add(votes, v2);
  170. smartlist_add(votes, v3);
  171. *consensus_text_md = networkstatus_compute_consensus(votes, 3,
  172. cert1->identity_key,
  173. sign_skey_1,
  174. "AAAAAAAAAAAAAAAAAAAA",
  175. sign_skey_leg,
  176. FLAV_MICRODESC);
  177. tt_assert(*consensus_text_md);
  178. done:
  179. tor_free(voter);
  180. networkstatus_vote_free(v1);
  181. networkstatus_vote_free(v2);
  182. networkstatus_vote_free(v3);
  183. smartlist_free(votes);
  184. authority_cert_free(cert1);
  185. authority_cert_free(cert2);
  186. authority_cert_free(cert3);
  187. crypto_pk_free(sign_skey_1);
  188. crypto_pk_free(sign_skey_2);
  189. crypto_pk_free(sign_skey_3);
  190. crypto_pk_free(sign_skey_leg);
  191. }
  192. static int mock_usable_consensus_flavor_value = FLAV_NS;
  193. static int
  194. mock_usable_consensus_flavor(void)
  195. {
  196. return mock_usable_consensus_flavor_value;
  197. }
  198. static void
  199. test_router_pick_directory_server_impl(void *arg)
  200. {
  201. (void)arg;
  202. networkstatus_t *con_md = NULL;
  203. char *consensus_text_md = NULL;
  204. int flags = PDS_IGNORE_FASCISTFIREWALL|PDS_RETRY_IF_NO_SERVERS;
  205. or_options_t *options = get_options_mutable();
  206. const routerstatus_t *rs = NULL;
  207. options->UseMicrodescriptors = 1;
  208. char *router1_id = NULL, *router2_id = NULL, *router3_id = NULL;
  209. node_t *node_router1 = NULL, *node_router2 = NULL, *node_router3 = NULL;
  210. config_line_t *policy_line = NULL;
  211. time_t now = time(NULL);
  212. int tmp_dirport1, tmp_dirport3;
  213. (void)arg;
  214. MOCK(usable_consensus_flavor, mock_usable_consensus_flavor);
  215. /* With no consensus, we must be bootstrapping, regardless of time or flavor
  216. */
  217. mock_usable_consensus_flavor_value = FLAV_NS;
  218. tt_assert(networkstatus_consensus_is_bootstrapping(now));
  219. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2000));
  220. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2*24*60*60));
  221. tt_assert(networkstatus_consensus_is_bootstrapping(now - 2*24*60*60));
  222. mock_usable_consensus_flavor_value = FLAV_MICRODESC;
  223. tt_assert(networkstatus_consensus_is_bootstrapping(now));
  224. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2000));
  225. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2*24*60*60));
  226. tt_assert(networkstatus_consensus_is_bootstrapping(now - 2*24*60*60));
  227. /* Init SR subsystem. */
  228. MOCK(get_my_v3_authority_cert, get_my_v3_authority_cert_m);
  229. mock_cert = authority_cert_parse_from_string(AUTHORITY_CERT_1,
  230. strlen(AUTHORITY_CERT_1),
  231. NULL);
  232. sr_init(0);
  233. UNMOCK(get_my_v3_authority_cert);
  234. /* No consensus available, fail early */
  235. rs = router_pick_directory_server_impl(V3_DIRINFO, (const int) 0, NULL);
  236. tt_ptr_op(rs, OP_EQ, NULL);
  237. construct_consensus(&consensus_text_md, now);
  238. tt_assert(consensus_text_md);
  239. con_md = networkstatus_parse_vote_from_string(consensus_text_md,
  240. strlen(consensus_text_md),
  241. NULL,
  242. NS_TYPE_CONSENSUS);
  243. tt_assert(con_md);
  244. tt_int_op(con_md->flavor,OP_EQ, FLAV_MICRODESC);
  245. tt_assert(con_md->routerstatus_list);
  246. tt_int_op(smartlist_len(con_md->routerstatus_list), OP_EQ, 3);
  247. tt_assert(!networkstatus_set_current_consensus_from_ns(con_md,
  248. "microdesc"));
  249. /* If the consensus time or flavor doesn't match, we are still
  250. * bootstrapping */
  251. mock_usable_consensus_flavor_value = FLAV_NS;
  252. tt_assert(networkstatus_consensus_is_bootstrapping(now));
  253. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2000));
  254. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2*24*60*60));
  255. tt_assert(networkstatus_consensus_is_bootstrapping(now - 2*24*60*60));
  256. /* With a valid consensus for the current time and flavor, we stop
  257. * bootstrapping, even if we have no certificates */
  258. mock_usable_consensus_flavor_value = FLAV_MICRODESC;
  259. tt_assert(!networkstatus_consensus_is_bootstrapping(now + 2000));
  260. tt_assert(!networkstatus_consensus_is_bootstrapping(con_md->valid_after));
  261. tt_assert(!networkstatus_consensus_is_bootstrapping(con_md->valid_until));
  262. tt_assert(!networkstatus_consensus_is_bootstrapping(con_md->valid_until
  263. + 24*60*60));
  264. /* These times are outside the test validity period */
  265. tt_assert(networkstatus_consensus_is_bootstrapping(now + 2*24*60*60));
  266. tt_assert(networkstatus_consensus_is_bootstrapping(now - 2*24*60*60));
  267. nodelist_set_consensus(con_md);
  268. nodelist_assert_ok();
  269. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  270. /* We should not fail now we have a consensus and routerstatus_list
  271. * and nodelist are populated. */
  272. tt_ptr_op(rs, OP_NE, NULL);
  273. /* Manipulate the nodes so we get the dir server we expect */
  274. router1_id = tor_malloc(DIGEST_LEN);
  275. memset(router1_id, TEST_DIR_ROUTER_ID_1, DIGEST_LEN);
  276. router2_id = tor_malloc(DIGEST_LEN);
  277. memset(router2_id, TEST_DIR_ROUTER_ID_2, DIGEST_LEN);
  278. router3_id = tor_malloc(DIGEST_LEN);
  279. memset(router3_id, TEST_DIR_ROUTER_ID_3, DIGEST_LEN);
  280. node_router1 = node_get_mutable_by_id(router1_id);
  281. node_router2 = node_get_mutable_by_id(router2_id);
  282. node_router3 = node_get_mutable_by_id(router3_id);
  283. node_router1->is_possible_guard = 1;
  284. node_router1->is_running = 0;
  285. node_router3->is_running = 0;
  286. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  287. tt_ptr_op(rs, OP_NE, NULL);
  288. tt_assert(tor_memeq(rs->identity_digest, router2_id, DIGEST_LEN));
  289. rs = NULL;
  290. node_router1->is_running = 1;
  291. node_router3->is_running = 1;
  292. node_router1->rs->is_v2_dir = 0;
  293. node_router3->rs->is_v2_dir = 0;
  294. tmp_dirport1 = node_router1->rs->dir_port;
  295. tmp_dirport3 = node_router3->rs->dir_port;
  296. node_router1->rs->dir_port = 0;
  297. node_router3->rs->dir_port = 0;
  298. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  299. tt_ptr_op(rs, OP_NE, NULL);
  300. tt_assert(tor_memeq(rs->identity_digest, router2_id, DIGEST_LEN));
  301. rs = NULL;
  302. node_router1->rs->is_v2_dir = 1;
  303. node_router3->rs->is_v2_dir = 1;
  304. node_router1->rs->dir_port = tmp_dirport1;
  305. node_router3->rs->dir_port = tmp_dirport3;
  306. node_router1->is_valid = 0;
  307. node_router3->is_valid = 0;
  308. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  309. tt_ptr_op(rs, OP_NE, NULL);
  310. tt_assert(tor_memeq(rs->identity_digest, router2_id, DIGEST_LEN));
  311. rs = NULL;
  312. node_router1->is_valid = 1;
  313. node_router3->is_valid = 1;
  314. /* Manipulate overloaded */
  315. node_router2->rs->last_dir_503_at = now;
  316. node_router3->rs->last_dir_503_at = now;
  317. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  318. tt_ptr_op(rs, OP_NE, NULL);
  319. tt_assert(tor_memeq(rs->identity_digest, router1_id, DIGEST_LEN));
  320. node_router2->rs->last_dir_503_at = 0;
  321. node_router3->rs->last_dir_503_at = 0;
  322. /* Set a Fascist firewall */
  323. flags &= ~ PDS_IGNORE_FASCISTFIREWALL;
  324. policy_line = tor_malloc_zero(sizeof(config_line_t));
  325. policy_line->key = tor_strdup("ReachableORAddresses");
  326. policy_line->value = tor_strdup("accept *:442, reject *:*");
  327. options->ReachableORAddresses = policy_line;
  328. policies_parse_from_options(options);
  329. node_router1->rs->or_port = 444;
  330. node_router2->rs->or_port = 443;
  331. node_router3->rs->or_port = 442;
  332. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  333. tt_ptr_op(rs, OP_NE, NULL);
  334. tt_assert(tor_memeq(rs->identity_digest, router3_id, DIGEST_LEN));
  335. node_router1->rs->or_port = 442;
  336. node_router2->rs->or_port = 443;
  337. node_router3->rs->or_port = 444;
  338. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  339. tt_ptr_op(rs, OP_NE, NULL);
  340. tt_assert(tor_memeq(rs->identity_digest, router1_id, DIGEST_LEN));
  341. /* Fascist firewall and overloaded */
  342. node_router1->rs->or_port = 442;
  343. node_router2->rs->or_port = 443;
  344. node_router3->rs->or_port = 442;
  345. node_router3->rs->last_dir_503_at = now;
  346. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  347. tt_ptr_op(rs, OP_NE, NULL);
  348. tt_assert(tor_memeq(rs->identity_digest, router1_id, DIGEST_LEN));
  349. node_router3->rs->last_dir_503_at = 0;
  350. /* Fascists against OR and Dir */
  351. policy_line = tor_malloc_zero(sizeof(config_line_t));
  352. policy_line->key = tor_strdup("ReachableAddresses");
  353. policy_line->value = tor_strdup("accept *:80, reject *:*");
  354. options->ReachableDirAddresses = policy_line;
  355. policies_parse_from_options(options);
  356. node_router1->rs->or_port = 442;
  357. node_router2->rs->or_port = 441;
  358. node_router3->rs->or_port = 443;
  359. node_router1->rs->dir_port = 80;
  360. node_router2->rs->dir_port = 80;
  361. node_router3->rs->dir_port = 81;
  362. node_router1->rs->last_dir_503_at = now;
  363. rs = router_pick_directory_server_impl(V3_DIRINFO, flags, NULL);
  364. tt_ptr_op(rs, OP_NE, NULL);
  365. tt_assert(tor_memeq(rs->identity_digest, router1_id, DIGEST_LEN));
  366. node_router1->rs->last_dir_503_at = 0;
  367. done:
  368. UNMOCK(usable_consensus_flavor);
  369. if (router1_id)
  370. tor_free(router1_id);
  371. if (router2_id)
  372. tor_free(router2_id);
  373. if (router3_id)
  374. tor_free(router3_id);
  375. if (options->ReachableORAddresses ||
  376. options->ReachableDirAddresses)
  377. policies_free_all();
  378. tor_free(consensus_text_md);
  379. networkstatus_vote_free(con_md);
  380. }
  381. static or_state_t *dummy_state = NULL;
  382. static or_state_t *
  383. get_or_state_replacement(void)
  384. {
  385. return dummy_state;
  386. }
  387. static void
  388. mock_directory_initiate_request(directory_request_t *req)
  389. {
  390. (void)req;
  391. return;
  392. }
  393. static circuit_guard_state_t *
  394. mock_circuit_guard_state_new(entry_guard_t *guard, unsigned state,
  395. entry_guard_restriction_t *rst)
  396. {
  397. (void) guard;
  398. (void) state;
  399. (void) rst;
  400. return NULL;
  401. }
  402. /** Test that we will use our directory guards to fetch mds even if we don't
  403. * have any dirinfo (tests bug #23862). */
  404. static void
  405. test_directory_guard_fetch_with_no_dirinfo(void *arg)
  406. {
  407. int retval;
  408. char *consensus_text_md = NULL;
  409. or_options_t *options = get_options_mutable();
  410. time_t now = time(NULL);
  411. (void) arg;
  412. hibernate_set_state_for_testing_(HIBERNATE_STATE_LIVE);
  413. /* Initialize the SRV subsystem */
  414. MOCK(get_my_v3_authority_cert, get_my_v3_authority_cert_m);
  415. mock_cert = authority_cert_parse_from_string(AUTHORITY_CERT_1,
  416. strlen(AUTHORITY_CERT_1),
  417. NULL);
  418. sr_init(0);
  419. UNMOCK(get_my_v3_authority_cert);
  420. /* Initialize the entry node configuration from the ticket */
  421. options->UseEntryGuards = 1;
  422. options->StrictNodes = 1;
  423. get_options_mutable()->EntryNodes = routerset_new();
  424. routerset_parse(get_options_mutable()->EntryNodes,
  425. "2121212121212121212121212121212121212121", "foo");
  426. /* Mock some functions */
  427. dummy_state = tor_malloc_zero(sizeof(or_state_t));
  428. MOCK(get_or_state, get_or_state_replacement);
  429. MOCK(directory_initiate_request, mock_directory_initiate_request);
  430. /* we need to mock this one to avoid memleaks */
  431. MOCK(circuit_guard_state_new, mock_circuit_guard_state_new);
  432. /* Call guards_update_all() to simulate loading our state file (see
  433. * entry_guards_load_guards_from_state() and ticket #23989). */
  434. guards_update_all();
  435. /* Test logic: Simulate the arrival of a new consensus when we have no
  436. * dirinfo at all. Tor will need to fetch the mds from the consensus. Make
  437. * sure that Tor will use the specified entry guard instead of relying on the
  438. * fallback directories. */
  439. /* Fixup the dirconn that will deliver the consensus */
  440. dir_connection_t *conn = dir_connection_new(AF_INET);
  441. tor_addr_from_ipv4h(&conn->base_.addr, 0x7f000001);
  442. conn->base_.port = 8800;
  443. TO_CONN(conn)->address = tor_strdup("127.0.0.1");
  444. conn->base_.purpose = DIR_PURPOSE_FETCH_CONSENSUS;
  445. conn->requested_resource = tor_strdup("ns");
  446. /* Construct a consensus */
  447. construct_consensus(&consensus_text_md, now);
  448. tt_assert(consensus_text_md);
  449. /* Place the consensus in the dirconn */
  450. response_handler_args_t args;
  451. memset(&args, 0, sizeof(response_handler_args_t));
  452. args.status_code = 200;
  453. args.body = consensus_text_md;
  454. args.body_len = strlen(consensus_text_md);
  455. /* Update approx time so that the consensus is considered live */
  456. update_approx_time(now+1010);
  457. setup_capture_of_logs(LOG_DEBUG);
  458. /* Now handle the consensus */
  459. retval = handle_response_fetch_consensus(conn, &args);
  460. tt_int_op(retval, OP_EQ, 0);
  461. /* Make sure that our primary guard was chosen */
  462. expect_log_msg_containing("Selected primary guard router3");
  463. done:
  464. tor_free(consensus_text_md);
  465. tor_free(dummy_state);
  466. connection_free_minimal(TO_CONN(conn));
  467. entry_guards_free_all();
  468. teardown_capture_of_logs();
  469. }
  470. static connection_t *mocked_connection = NULL;
  471. /* Mock connection_get_by_type_addr_port_purpose by returning
  472. * mocked_connection. */
  473. static connection_t *
  474. mock_connection_get_by_type_addr_port_purpose(int type,
  475. const tor_addr_t *addr,
  476. uint16_t port, int purpose)
  477. {
  478. (void)type;
  479. (void)addr;
  480. (void)port;
  481. (void)purpose;
  482. return mocked_connection;
  483. }
  484. #define TEST_ADDR_STR "127.0.0.1"
  485. #define TEST_DIR_PORT 12345
  486. static void
  487. test_routerlist_router_is_already_dir_fetching(void *arg)
  488. {
  489. (void)arg;
  490. tor_addr_port_t test_ap, null_addr_ap, zero_port_ap;
  491. /* Setup */
  492. tor_addr_parse(&test_ap.addr, TEST_ADDR_STR);
  493. test_ap.port = TEST_DIR_PORT;
  494. tor_addr_make_null(&null_addr_ap.addr, AF_INET6);
  495. null_addr_ap.port = TEST_DIR_PORT;
  496. tor_addr_parse(&zero_port_ap.addr, TEST_ADDR_STR);
  497. zero_port_ap.port = 0;
  498. MOCK(connection_get_by_type_addr_port_purpose,
  499. mock_connection_get_by_type_addr_port_purpose);
  500. /* Test that we never get 1 from a NULL connection */
  501. mocked_connection = NULL;
  502. tt_int_op(router_is_already_dir_fetching(&test_ap, 1, 1), OP_EQ, 0);
  503. tt_int_op(router_is_already_dir_fetching(&test_ap, 1, 0), OP_EQ, 0);
  504. tt_int_op(router_is_already_dir_fetching(&test_ap, 0, 1), OP_EQ, 0);
  505. /* We always expect 0 in these cases */
  506. tt_int_op(router_is_already_dir_fetching(&test_ap, 0, 0), OP_EQ, 0);
  507. tt_int_op(router_is_already_dir_fetching(NULL, 1, 1), OP_EQ, 0);
  508. tt_int_op(router_is_already_dir_fetching(&null_addr_ap, 1, 1), OP_EQ, 0);
  509. tt_int_op(router_is_already_dir_fetching(&zero_port_ap, 1, 1), OP_EQ, 0);
  510. /* Test that we get 1 with a connection in the appropriate circumstances */
  511. mocked_connection = connection_new(CONN_TYPE_DIR, AF_INET);
  512. tt_int_op(router_is_already_dir_fetching(&test_ap, 1, 1), OP_EQ, 1);
  513. tt_int_op(router_is_already_dir_fetching(&test_ap, 1, 0), OP_EQ, 1);
  514. tt_int_op(router_is_already_dir_fetching(&test_ap, 0, 1), OP_EQ, 1);
  515. /* Test that we get 0 even with a connection in the appropriate
  516. * circumstances */
  517. tt_int_op(router_is_already_dir_fetching(&test_ap, 0, 0), OP_EQ, 0);
  518. tt_int_op(router_is_already_dir_fetching(NULL, 1, 1), OP_EQ, 0);
  519. tt_int_op(router_is_already_dir_fetching(&null_addr_ap, 1, 1), OP_EQ, 0);
  520. tt_int_op(router_is_already_dir_fetching(&zero_port_ap, 1, 1), OP_EQ, 0);
  521. done:
  522. /* If a connection is never set up, connection_free chokes on it. */
  523. if (mocked_connection) {
  524. buf_free(mocked_connection->inbuf);
  525. buf_free(mocked_connection->outbuf);
  526. }
  527. tor_free(mocked_connection);
  528. UNMOCK(connection_get_by_type_addr_port_purpose);
  529. }
  530. #undef TEST_ADDR_STR
  531. #undef TEST_DIR_PORT
  532. static long mock_apparent_skew = 0;
  533. /** Store apparent_skew and assert that the other arguments are as
  534. * expected. */
  535. static void
  536. mock_clock_skew_warning(const connection_t *conn, long apparent_skew,
  537. int trusted, log_domain_mask_t domain,
  538. const char *received, const char *source)
  539. {
  540. (void)conn;
  541. mock_apparent_skew = apparent_skew;
  542. tt_int_op(trusted, OP_EQ, 1);
  543. tt_int_op(domain, OP_EQ, LD_GENERAL);
  544. tt_str_op(received, OP_EQ, "microdesc flavor consensus");
  545. tt_str_op(source, OP_EQ, "CONSENSUS");
  546. done:
  547. ;
  548. }
  549. /** Do common setup for test_timely_consensus() and
  550. * test_early_consensus(). Call networkstatus_set_current_consensus()
  551. * on a constructed consensus and with an appropriately-modified
  552. * approx_time. Callers expect presence or absence of appropriate log
  553. * messages and control events. */
  554. static int
  555. test_skew_common(void *arg, time_t now, unsigned long *offset)
  556. {
  557. char *consensus = NULL;
  558. int retval = 0;
  559. *offset = strtoul(arg, NULL, 10);
  560. /* Initialize the SRV subsystem */
  561. MOCK(get_my_v3_authority_cert, get_my_v3_authority_cert_m);
  562. mock_cert = authority_cert_parse_from_string(AUTHORITY_CERT_1,
  563. strlen(AUTHORITY_CERT_1),
  564. NULL);
  565. sr_init(0);
  566. UNMOCK(get_my_v3_authority_cert);
  567. construct_consensus(&consensus, now);
  568. tt_assert(consensus);
  569. update_approx_time(now + *offset);
  570. mock_apparent_skew = 0;
  571. /* Caller will call UNMOCK() */
  572. MOCK(clock_skew_warning, mock_clock_skew_warning);
  573. /* Caller will call teardown_capture_of_logs() */
  574. setup_capture_of_logs(LOG_WARN);
  575. retval = networkstatus_set_current_consensus(consensus, strlen(consensus),
  576. "microdesc", 0,
  577. NULL);
  578. done:
  579. tor_free(consensus);
  580. return retval;
  581. }
  582. /** Test non-early consensus */
  583. static void
  584. test_timely_consensus(void *arg)
  585. {
  586. time_t now = time(NULL);
  587. unsigned long offset = 0;
  588. int retval = 0;
  589. retval = test_skew_common(arg, now, &offset);
  590. (void)offset;
  591. expect_no_log_msg_containing("behind the time published in the consensus");
  592. tt_int_op(retval, OP_EQ, 0);
  593. tt_int_op(mock_apparent_skew, OP_EQ, 0);
  594. done:
  595. teardown_capture_of_logs();
  596. UNMOCK(clock_skew_warning);
  597. }
  598. /** Test early consensus */
  599. static void
  600. test_early_consensus(void *arg)
  601. {
  602. time_t now = time(NULL);
  603. unsigned long offset = 0;
  604. int retval = 0;
  605. retval = test_skew_common(arg, now, &offset);
  606. /* Can't use expect_single_log_msg() because of unrecognized authorities */
  607. expect_log_msg_containing("behind the time published in the consensus");
  608. tt_int_op(retval, OP_EQ, 0);
  609. /* This depends on construct_consensus() setting valid_after=now+1000 */
  610. tt_int_op(mock_apparent_skew, OP_EQ, offset - 1000);
  611. done:
  612. teardown_capture_of_logs();
  613. UNMOCK(clock_skew_warning);
  614. }
  615. /** Test warn_early_consensus(), expecting no warning */
  616. static void
  617. test_warn_early_consensus_no(const networkstatus_t *c, time_t now,
  618. long offset)
  619. {
  620. mock_apparent_skew = 0;
  621. setup_capture_of_logs(LOG_WARN);
  622. warn_early_consensus(c, "microdesc", now + offset);
  623. expect_no_log_msg_containing("behind the time published in the consensus");
  624. tt_int_op(mock_apparent_skew, OP_EQ, 0);
  625. done:
  626. teardown_capture_of_logs();
  627. }
  628. /** Test warn_early_consensus(), expecting a warning */
  629. static void
  630. test_warn_early_consensus_yes(const networkstatus_t *c, time_t now,
  631. long offset)
  632. {
  633. mock_apparent_skew = 0;
  634. setup_capture_of_logs(LOG_WARN);
  635. warn_early_consensus(c, "microdesc", now + offset);
  636. /* Can't use expect_single_log_msg() because of unrecognized authorities */
  637. expect_log_msg_containing("behind the time published in the consensus");
  638. tt_int_op(mock_apparent_skew, OP_EQ, offset);
  639. done:
  640. teardown_capture_of_logs();
  641. }
  642. /**
  643. * Test warn_early_consensus() directly, checking both the non-warning
  644. * case (consensus is not early) and the warning case (consensus is
  645. * early). Depends on EARLY_CONSENSUS_NOTICE_SKEW=60.
  646. */
  647. static void
  648. test_warn_early_consensus(void *arg)
  649. {
  650. networkstatus_t *c = NULL;
  651. time_t now = time(NULL);
  652. (void)arg;
  653. c = tor_malloc_zero(sizeof *c);
  654. c->valid_after = now;
  655. c->dist_seconds = 300;
  656. mock_apparent_skew = 0;
  657. MOCK(clock_skew_warning, mock_clock_skew_warning);
  658. test_warn_early_consensus_no(c, now, 60);
  659. test_warn_early_consensus_no(c, now, 0);
  660. test_warn_early_consensus_no(c, now, -60);
  661. test_warn_early_consensus_no(c, now, -360);
  662. test_warn_early_consensus_yes(c, now, -361);
  663. test_warn_early_consensus_yes(c, now, -600);
  664. UNMOCK(clock_skew_warning);
  665. tor_free(c);
  666. }
  667. #define NODE(name, flags) \
  668. { #name, test_routerlist_##name, (flags), NULL, NULL }
  669. #define ROUTER(name,flags) \
  670. { #name, test_router_##name, (flags), NULL, NULL }
  671. #define TIMELY(name, arg) \
  672. { name, test_timely_consensus, TT_FORK, &passthrough_setup, \
  673. (char *)(arg) }
  674. #define EARLY(name, arg) \
  675. { name, test_early_consensus, TT_FORK, &passthrough_setup, \
  676. (char *)(arg) }
  677. struct testcase_t routerlist_tests[] = {
  678. NODE(initiate_descriptor_downloads, 0),
  679. NODE(launch_descriptor_downloads, 0),
  680. NODE(router_is_already_dir_fetching, TT_FORK),
  681. ROUTER(pick_directory_server_impl, TT_FORK),
  682. { "directory_guard_fetch_with_no_dirinfo",
  683. test_directory_guard_fetch_with_no_dirinfo, TT_FORK, NULL, NULL },
  684. /* These depend on construct_consensus() setting
  685. * valid_after=now+1000 and dist_seconds=250 */
  686. TIMELY("timely_consensus1", "1010"),
  687. TIMELY("timely_consensus2", "1000"),
  688. TIMELY("timely_consensus3", "690"),
  689. EARLY("early_consensus1", "689"),
  690. { "warn_early_consensus", test_warn_early_consensus, 0, NULL, NULL },
  691. END_OF_TESTCASES
  692. };