test.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930
  1. /* Copyright (c) 2001-2004, Roger Dingledine.
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2018, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. /**
  6. * \file test.c
  7. * \brief Unit tests for many pieces of the lower level Tor modules.
  8. **/
  9. #include "orconfig.h"
  10. #include "lib/crypt_ops/crypto_dh.h"
  11. #include "lib/crypt_ops/crypto_rand.h"
  12. #include "app/config/or_state_st.h"
  13. #include <stdio.h>
  14. #ifdef HAVE_FCNTL_H
  15. #include <fcntl.h>
  16. #endif
  17. #ifdef _WIN32
  18. /* For mkdir() */
  19. #include <direct.h>
  20. #else
  21. #include <dirent.h>
  22. #endif /* defined(_WIN32) */
  23. #include <math.h>
  24. /* These macros pull in declarations for some functions and structures that
  25. * are typically file-private. */
  26. #define ROUTER_PRIVATE
  27. #define CIRCUITSTATS_PRIVATE
  28. #define CIRCUITLIST_PRIVATE
  29. #define MAINLOOP_PRIVATE
  30. #define STATEFILE_PRIVATE
  31. #include "core/or/or.h"
  32. #include "lib/err/backtrace.h"
  33. #include "lib/container/buffers.h"
  34. #include "core/or/circuitlist.h"
  35. #include "core/or/circuitstats.h"
  36. #include "lib/compress/compress.h"
  37. #include "app/config/config.h"
  38. #include "core/or/connection_edge.h"
  39. #include "feature/rend/rendcommon.h"
  40. #include "feature/rend/rendcache.h"
  41. #include "test/test.h"
  42. #include "core/mainloop/mainloop.h"
  43. #include "lib/memarea/memarea.h"
  44. #include "core/or/onion.h"
  45. #include "core/crypto/onion_ntor.h"
  46. #include "core/crypto/onion_fast.h"
  47. #include "core/crypto/onion_tap.h"
  48. #include "core/or/policies.h"
  49. #include "feature/stats/rephist.h"
  50. #include "feature/nodelist/routerparse.h"
  51. #include "app/config/statefile.h"
  52. #include "lib/crypt_ops/crypto_curve25519.h"
  53. #include "core/or/extend_info_st.h"
  54. #include "core/or/or_circuit_st.h"
  55. #include "feature/rend/rend_encoded_v2_service_descriptor_st.h"
  56. #include "feature/rend/rend_intro_point_st.h"
  57. #include "feature/rend/rend_service_descriptor_st.h"
  58. #include "feature/relay/onion_queue.h"
  59. /** Run unit tests for the onion handshake code. */
  60. static void
  61. test_onion_handshake(void *arg)
  62. {
  63. /* client-side */
  64. crypto_dh_t *c_dh = NULL;
  65. char c_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  66. char c_keys[40];
  67. /* server-side */
  68. char s_buf[TAP_ONIONSKIN_REPLY_LEN];
  69. char s_keys[40];
  70. int i;
  71. /* shared */
  72. crypto_pk_t *pk = NULL, *pk2 = NULL;
  73. (void)arg;
  74. pk = pk_generate(0);
  75. pk2 = pk_generate(1);
  76. /* client handshake 1. */
  77. memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
  78. tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
  79. for (i = 1; i <= 3; ++i) {
  80. crypto_pk_t *k1, *k2;
  81. if (i==1) {
  82. /* server handshake: only one key known. */
  83. k1 = pk; k2 = NULL;
  84. } else if (i==2) {
  85. /* server handshake: try the right key first. */
  86. k1 = pk; k2 = pk2;
  87. } else {
  88. /* server handshake: try the right key second. */
  89. k1 = pk2; k2 = pk;
  90. }
  91. memset(s_buf, 0, TAP_ONIONSKIN_REPLY_LEN);
  92. memset(s_keys, 0, 40);
  93. tt_assert(! onion_skin_TAP_server_handshake(c_buf, k1, k2,
  94. s_buf, s_keys, 40));
  95. /* client handshake 2 */
  96. memset(c_keys, 0, 40);
  97. tt_assert(! onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys,
  98. 40, NULL));
  99. tt_mem_op(c_keys,OP_EQ, s_keys, 40);
  100. memset(s_buf, 0, 40);
  101. tt_mem_op(c_keys,OP_NE, s_buf, 40);
  102. }
  103. done:
  104. crypto_dh_free(c_dh);
  105. crypto_pk_free(pk);
  106. crypto_pk_free(pk2);
  107. }
  108. static void
  109. test_bad_onion_handshake(void *arg)
  110. {
  111. char junk_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  112. char junk_buf2[TAP_ONIONSKIN_CHALLENGE_LEN];
  113. /* client-side */
  114. crypto_dh_t *c_dh = NULL;
  115. char c_buf[TAP_ONIONSKIN_CHALLENGE_LEN];
  116. char c_keys[40];
  117. /* server-side */
  118. char s_buf[TAP_ONIONSKIN_REPLY_LEN];
  119. char s_keys[40];
  120. /* shared */
  121. crypto_pk_t *pk = NULL, *pk2 = NULL;
  122. (void)arg;
  123. pk = pk_generate(0);
  124. pk2 = pk_generate(1);
  125. /* Server: Case 1: the encrypted data is degenerate. */
  126. memset(junk_buf, 0, sizeof(junk_buf));
  127. crypto_pk_obsolete_public_hybrid_encrypt(pk,
  128. junk_buf2, TAP_ONIONSKIN_CHALLENGE_LEN,
  129. junk_buf, DH1024_KEY_LEN,
  130. PK_PKCS1_OAEP_PADDING, 1);
  131. tt_int_op(-1, OP_EQ,
  132. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  133. s_buf, s_keys, 40));
  134. /* Server: Case 2: the encrypted data is not long enough. */
  135. memset(junk_buf, 0, sizeof(junk_buf));
  136. memset(junk_buf2, 0, sizeof(junk_buf2));
  137. crypto_pk_public_encrypt(pk, junk_buf2, sizeof(junk_buf2),
  138. junk_buf, 48, PK_PKCS1_OAEP_PADDING);
  139. tt_int_op(-1, OP_EQ,
  140. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  141. s_buf, s_keys, 40));
  142. /* client handshake 1: do it straight. */
  143. memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
  144. tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
  145. /* Server: Case 3: we just don't have the right key. */
  146. tt_int_op(-1, OP_EQ,
  147. onion_skin_TAP_server_handshake(c_buf, pk2, NULL,
  148. s_buf, s_keys, 40));
  149. /* Server: Case 4: The RSA-encrypted portion is corrupt. */
  150. c_buf[64] ^= 33;
  151. tt_int_op(-1, OP_EQ,
  152. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  153. s_buf, s_keys, 40));
  154. c_buf[64] ^= 33;
  155. /* (Let the server proceed) */
  156. tt_int_op(0, OP_EQ,
  157. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  158. s_buf, s_keys, 40));
  159. /* Client: Case 1: The server sent back junk. */
  160. const char *msg = NULL;
  161. s_buf[64] ^= 33;
  162. tt_int_op(-1, OP_EQ,
  163. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  164. s_buf[64] ^= 33;
  165. tt_str_op(msg, OP_EQ, "Digest DOES NOT MATCH on onion handshake. "
  166. "Bug or attack.");
  167. /* Let the client finish; make sure it can. */
  168. msg = NULL;
  169. tt_int_op(0, OP_EQ,
  170. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  171. tt_mem_op(s_keys,OP_EQ, c_keys, 40);
  172. tt_ptr_op(msg, OP_EQ, NULL);
  173. /* Client: Case 2: The server sent back a degenerate DH. */
  174. memset(s_buf, 0, sizeof(s_buf));
  175. tt_int_op(-1, OP_EQ,
  176. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  177. tt_str_op(msg, OP_EQ, "DH computation failed.");
  178. done:
  179. crypto_dh_free(c_dh);
  180. crypto_pk_free(pk);
  181. crypto_pk_free(pk2);
  182. }
  183. static void
  184. test_ntor_handshake(void *arg)
  185. {
  186. /* client-side */
  187. ntor_handshake_state_t *c_state = NULL;
  188. uint8_t c_buf[NTOR_ONIONSKIN_LEN];
  189. uint8_t c_keys[400];
  190. /* server-side */
  191. di_digest256_map_t *s_keymap=NULL;
  192. curve25519_keypair_t s_keypair;
  193. uint8_t s_buf[NTOR_REPLY_LEN];
  194. uint8_t s_keys[400];
  195. /* shared */
  196. const curve25519_public_key_t *server_pubkey;
  197. uint8_t node_id[20] = "abcdefghijklmnopqrst";
  198. (void) arg;
  199. /* Make the server some keys */
  200. curve25519_secret_key_generate(&s_keypair.seckey, 0);
  201. curve25519_public_key_generate(&s_keypair.pubkey, &s_keypair.seckey);
  202. dimap_add_entry(&s_keymap, s_keypair.pubkey.public_key, &s_keypair);
  203. server_pubkey = &s_keypair.pubkey;
  204. /* client handshake 1. */
  205. memset(c_buf, 0, NTOR_ONIONSKIN_LEN);
  206. tt_int_op(0, OP_EQ, onion_skin_ntor_create(node_id, server_pubkey,
  207. &c_state, c_buf));
  208. /* server handshake */
  209. memset(s_buf, 0, NTOR_REPLY_LEN);
  210. memset(s_keys, 0, 40);
  211. tt_int_op(0, OP_EQ, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,
  212. node_id,
  213. s_buf, s_keys, 400));
  214. /* client handshake 2 */
  215. memset(c_keys, 0, 40);
  216. tt_int_op(0, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,
  217. c_keys, 400, NULL));
  218. tt_mem_op(c_keys,OP_EQ, s_keys, 400);
  219. memset(s_buf, 0, 40);
  220. tt_mem_op(c_keys,OP_NE, s_buf, 40);
  221. /* Now try with a bogus server response. Zero input should trigger
  222. * All The Problems. */
  223. memset(c_keys, 0, 400);
  224. memset(s_buf, 0, NTOR_REPLY_LEN);
  225. const char *msg = NULL;
  226. tt_int_op(-1, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,
  227. c_keys, 400, &msg));
  228. tt_str_op(msg, OP_EQ, "Zero output from curve25519 handshake");
  229. done:
  230. ntor_handshake_state_free(c_state);
  231. dimap_free(s_keymap, NULL);
  232. }
  233. static void
  234. test_fast_handshake(void *arg)
  235. {
  236. /* tests for the obsolete "CREATE_FAST" handshake. */
  237. (void) arg;
  238. fast_handshake_state_t *state = NULL;
  239. uint8_t client_handshake[CREATE_FAST_LEN];
  240. uint8_t server_handshake[CREATED_FAST_LEN];
  241. uint8_t s_keys[100], c_keys[100];
  242. /* First, test an entire handshake. */
  243. memset(client_handshake, 0, sizeof(client_handshake));
  244. tt_int_op(0, OP_EQ, fast_onionskin_create(&state, client_handshake));
  245. tt_assert(! tor_mem_is_zero((char*)client_handshake,
  246. sizeof(client_handshake)));
  247. tt_int_op(0, OP_EQ,
  248. fast_server_handshake(client_handshake, server_handshake,
  249. s_keys, 100));
  250. const char *msg = NULL;
  251. tt_int_op(0, OP_EQ,
  252. fast_client_handshake(state, server_handshake, c_keys, 100, &msg));
  253. tt_ptr_op(msg, OP_EQ, NULL);
  254. tt_mem_op(s_keys, OP_EQ, c_keys, 100);
  255. /* Now test a failing handshake. */
  256. server_handshake[0] ^= 3;
  257. tt_int_op(-1, OP_EQ,
  258. fast_client_handshake(state, server_handshake, c_keys, 100, &msg));
  259. tt_str_op(msg, OP_EQ, "Digest DOES NOT MATCH on fast handshake. "
  260. "Bug or attack.");
  261. done:
  262. fast_handshake_state_free(state);
  263. }
  264. /** Run unit tests for the onion queues. */
  265. static void
  266. test_onion_queues(void *arg)
  267. {
  268. uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0};
  269. uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0};
  270. or_circuit_t *circ1 = or_circuit_new(0, NULL);
  271. or_circuit_t *circ2 = or_circuit_new(0, NULL);
  272. create_cell_t *onionskin = NULL, *create2_ptr;
  273. create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t));
  274. create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t));
  275. (void)arg;
  276. create2_ptr = create2; /* remember, but do not free */
  277. create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
  278. TAP_ONIONSKIN_CHALLENGE_LEN, buf1);
  279. create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR,
  280. NTOR_ONIONSKIN_LEN, buf2);
  281. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  282. tt_int_op(0,OP_EQ, onion_pending_add(circ1, create1));
  283. create1 = NULL;
  284. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  285. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  286. tt_int_op(0,OP_EQ, onion_pending_add(circ2, create2));
  287. create2 = NULL;
  288. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  289. tt_ptr_op(circ2,OP_EQ, onion_next_task(&onionskin));
  290. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  291. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  292. tt_ptr_op(onionskin, OP_EQ, create2_ptr);
  293. clear_pending_onions();
  294. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  295. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  296. done:
  297. circuit_free_(TO_CIRCUIT(circ1));
  298. circuit_free_(TO_CIRCUIT(circ2));
  299. tor_free(create1);
  300. tor_free(create2);
  301. tor_free(onionskin);
  302. }
  303. static crypto_cipher_t *crypto_rand_aes_cipher = NULL;
  304. // Mock replacement for crypto_rand: Generates bytes from a provided AES_CTR
  305. // cipher in <b>crypto_rand_aes_cipher</b>.
  306. static void
  307. crypto_rand_deterministic_aes(char *out, size_t n)
  308. {
  309. tor_assert(crypto_rand_aes_cipher);
  310. memset(out, 0, n);
  311. crypto_cipher_crypt_inplace(crypto_rand_aes_cipher, out, n);
  312. }
  313. static void
  314. test_circuit_timeout(void *arg)
  315. {
  316. /* Plan:
  317. * 1. Generate 1000 samples
  318. * 2. Estimate parameters
  319. * 3. If difference, repeat
  320. * 4. Save state
  321. * 5. load state
  322. * 6. Estimate parameters
  323. * 7. compare differences
  324. */
  325. circuit_build_times_t initial;
  326. circuit_build_times_t estimate;
  327. circuit_build_times_t final;
  328. double timeout1, timeout2;
  329. or_state_t *state=NULL;
  330. int i, runs;
  331. double close_ms;
  332. (void)arg;
  333. initialize_periodic_events();
  334. circuit_build_times_init(&initial);
  335. circuit_build_times_init(&estimate);
  336. circuit_build_times_init(&final);
  337. state = or_state_new();
  338. // Use a deterministic RNG here, or else we'll get nondeterministic
  339. // coverage in some of the circuitstats functions.
  340. MOCK(crypto_rand, crypto_rand_deterministic_aes);
  341. crypto_rand_aes_cipher = crypto_cipher_new("xyzzyplughplover");
  342. circuitbuild_running_unit_tests();
  343. #define timeout0 (build_time_t)(30*1000.0)
  344. initial.Xm = 3000;
  345. circuit_build_times_initial_alpha(&initial,
  346. CBT_DEFAULT_QUANTILE_CUTOFF/100.0,
  347. timeout0);
  348. close_ms = MAX(circuit_build_times_calculate_timeout(&initial,
  349. CBT_DEFAULT_CLOSE_QUANTILE/100.0),
  350. CBT_DEFAULT_TIMEOUT_INITIAL_VALUE);
  351. do {
  352. for (i=0; i < CBT_DEFAULT_MIN_CIRCUITS_TO_OBSERVE; i++) {
  353. build_time_t sample = circuit_build_times_generate_sample(&initial,0,1);
  354. if (sample > close_ms) {
  355. circuit_build_times_add_time(&estimate, CBT_BUILD_ABANDONED);
  356. } else {
  357. circuit_build_times_add_time(&estimate, sample);
  358. }
  359. }
  360. circuit_build_times_update_alpha(&estimate);
  361. timeout1 = circuit_build_times_calculate_timeout(&estimate,
  362. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  363. circuit_build_times_set_timeout(&estimate);
  364. log_notice(LD_CIRC, "Timeout1 is %f, Xm is %d", timeout1, estimate.Xm);
  365. /* 2% error */
  366. } while (fabs(circuit_build_times_cdf(&initial, timeout0) -
  367. circuit_build_times_cdf(&initial, timeout1)) > 0.02);
  368. tt_int_op(estimate.total_build_times, OP_LE, CBT_NCIRCUITS_TO_OBSERVE);
  369. circuit_build_times_update_state(&estimate, state);
  370. circuit_build_times_free_timeouts(&final);
  371. tt_int_op(circuit_build_times_parse_state(&final, state), OP_EQ, 0);
  372. circuit_build_times_update_alpha(&final);
  373. timeout2 = circuit_build_times_calculate_timeout(&final,
  374. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  375. circuit_build_times_set_timeout(&final);
  376. log_notice(LD_CIRC, "Timeout2 is %f, Xm is %d", timeout2, final.Xm);
  377. /* 5% here because some accuracy is lost due to histogram conversion */
  378. tt_assert(fabs(circuit_build_times_cdf(&initial, timeout0) -
  379. circuit_build_times_cdf(&initial, timeout2)) < 0.05);
  380. for (runs = 0; runs < 50; runs++) {
  381. int build_times_idx = 0;
  382. int total_build_times = 0;
  383. final.close_ms = final.timeout_ms = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  384. estimate.close_ms = estimate.timeout_ms
  385. = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  386. for (i = 0; i < CBT_DEFAULT_RECENT_CIRCUITS*2; i++) {
  387. circuit_build_times_network_circ_success(&estimate);
  388. circuit_build_times_add_time(&estimate,
  389. circuit_build_times_generate_sample(&estimate, 0,
  390. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  391. circuit_build_times_network_circ_success(&estimate);
  392. circuit_build_times_add_time(&final,
  393. circuit_build_times_generate_sample(&final, 0,
  394. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  395. }
  396. tt_assert(!circuit_build_times_network_check_changed(&estimate));
  397. tt_assert(!circuit_build_times_network_check_changed(&final));
  398. /* Reset liveness to be non-live */
  399. final.liveness.network_last_live = 0;
  400. estimate.liveness.network_last_live = 0;
  401. build_times_idx = estimate.build_times_idx;
  402. total_build_times = estimate.total_build_times;
  403. tt_assert(circuit_build_times_network_check_live(&estimate));
  404. tt_assert(circuit_build_times_network_check_live(&final));
  405. circuit_build_times_count_close(&estimate, 0,
  406. (time_t)(approx_time()-estimate.close_ms/1000.0-1));
  407. circuit_build_times_count_close(&final, 0,
  408. (time_t)(approx_time()-final.close_ms/1000.0-1));
  409. tt_assert(!circuit_build_times_network_check_live(&estimate));
  410. tt_assert(!circuit_build_times_network_check_live(&final));
  411. log_info(LD_CIRC, "idx: %d %d, tot: %d %d",
  412. build_times_idx, estimate.build_times_idx,
  413. total_build_times, estimate.total_build_times);
  414. /* Check rollback index. Should match top of loop. */
  415. tt_assert(build_times_idx == estimate.build_times_idx);
  416. // This can fail if estimate.total_build_times == 1000, because
  417. // in that case, rewind actually causes us to lose timeouts
  418. if (total_build_times != CBT_NCIRCUITS_TO_OBSERVE)
  419. tt_assert(total_build_times == estimate.total_build_times);
  420. /* Now simulate that the network has become live and we need
  421. * a change */
  422. circuit_build_times_network_is_live(&estimate);
  423. circuit_build_times_network_is_live(&final);
  424. for (i = 0; i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT; i++) {
  425. circuit_build_times_count_timeout(&estimate, 1);
  426. if (i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1) {
  427. circuit_build_times_count_timeout(&final, 1);
  428. }
  429. }
  430. tt_int_op(estimate.liveness.after_firsthop_idx, OP_EQ, 0);
  431. tt_assert(final.liveness.after_firsthop_idx ==
  432. CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1);
  433. tt_assert(circuit_build_times_network_check_live(&estimate));
  434. tt_assert(circuit_build_times_network_check_live(&final));
  435. circuit_build_times_count_timeout(&final, 1);
  436. /* Ensure return value for degenerate cases are clamped correctly */
  437. initial.alpha = INT32_MAX;
  438. tt_assert(circuit_build_times_calculate_timeout(&initial, .99999999) <=
  439. INT32_MAX);
  440. initial.alpha = 0;
  441. tt_assert(circuit_build_times_calculate_timeout(&initial, .5) <=
  442. INT32_MAX);
  443. }
  444. done:
  445. circuit_build_times_free_timeouts(&initial);
  446. circuit_build_times_free_timeouts(&estimate);
  447. circuit_build_times_free_timeouts(&final);
  448. or_state_free(state);
  449. teardown_periodic_events();
  450. UNMOCK(crypto_rand);
  451. crypto_cipher_free(crypto_rand_aes_cipher);
  452. }
  453. /** Test encoding and parsing of rendezvous service descriptors. */
  454. static void
  455. test_rend_fns(void *arg)
  456. {
  457. rend_service_descriptor_t *generated = NULL, *parsed = NULL;
  458. char service_id[DIGEST_LEN];
  459. char service_id_base32[REND_SERVICE_ID_LEN_BASE32+1];
  460. const char *next_desc;
  461. smartlist_t *descs = smartlist_new();
  462. char computed_desc_id[DIGEST_LEN];
  463. char parsed_desc_id[DIGEST_LEN];
  464. crypto_pk_t *pk1 = NULL, *pk2 = NULL;
  465. time_t now;
  466. char *intro_points_encrypted = NULL;
  467. size_t intro_points_size;
  468. size_t encoded_size;
  469. int i;
  470. (void)arg;
  471. /* Initialize the service cache. */
  472. rend_cache_init();
  473. pk1 = pk_generate(0);
  474. pk2 = pk_generate(1);
  475. generated = tor_malloc_zero(sizeof(rend_service_descriptor_t));
  476. generated->pk = crypto_pk_dup_key(pk1);
  477. crypto_pk_get_digest(generated->pk, service_id);
  478. base32_encode(service_id_base32, REND_SERVICE_ID_LEN_BASE32+1,
  479. service_id, REND_SERVICE_ID_LEN);
  480. now = time(NULL);
  481. generated->timestamp = now;
  482. generated->version = 2;
  483. generated->protocols = 42;
  484. generated->intro_nodes = smartlist_new();
  485. for (i = 0; i < 3; i++) {
  486. rend_intro_point_t *intro = tor_malloc_zero(sizeof(rend_intro_point_t));
  487. crypto_pk_t *okey = pk_generate(2 + i);
  488. intro->extend_info = tor_malloc_zero(sizeof(extend_info_t));
  489. intro->extend_info->onion_key = okey;
  490. crypto_pk_get_digest(intro->extend_info->onion_key,
  491. intro->extend_info->identity_digest);
  492. //crypto_rand(info->identity_digest, DIGEST_LEN); /* Would this work? */
  493. intro->extend_info->nickname[0] = '$';
  494. base16_encode(intro->extend_info->nickname + 1,
  495. sizeof(intro->extend_info->nickname) - 1,
  496. intro->extend_info->identity_digest, DIGEST_LEN);
  497. /* Does not cover all IP addresses. */
  498. tor_addr_from_ipv4h(&intro->extend_info->addr, crypto_rand_int(65536));
  499. intro->extend_info->port = 1 + crypto_rand_int(65535);
  500. intro->intro_key = crypto_pk_dup_key(pk2);
  501. smartlist_add(generated->intro_nodes, intro);
  502. }
  503. int rv = rend_encode_v2_descriptors(descs, generated, now, 0,
  504. REND_NO_AUTH, NULL, NULL);
  505. tt_int_op(rv, OP_GT, 0);
  506. rv = rend_compute_v2_desc_id(computed_desc_id, service_id_base32, NULL,
  507. now, 0);
  508. tt_int_op(rv, OP_EQ, 0);
  509. tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
  510. smartlist_get(descs, 0))->desc_id, OP_EQ,
  511. computed_desc_id, DIGEST_LEN);
  512. rv = rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
  513. &intro_points_encrypted, &intro_points_size, &encoded_size,
  514. &next_desc,
  515. ((rend_encoded_v2_service_descriptor_t *)smartlist_get(descs, 0))
  516. ->desc_str, 1);
  517. tt_int_op(rv, OP_EQ, 0);
  518. tt_assert(parsed);
  519. tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
  520. smartlist_get(descs, 0))->desc_id,OP_EQ, parsed_desc_id, DIGEST_LEN);
  521. tt_int_op(rend_parse_introduction_points(parsed, intro_points_encrypted,
  522. intro_points_size),OP_EQ, 3);
  523. tt_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk));
  524. tt_int_op(parsed->timestamp,OP_EQ, now);
  525. tt_int_op(parsed->version,OP_EQ, 2);
  526. tt_int_op(parsed->protocols,OP_EQ, 42);
  527. tt_int_op(smartlist_len(parsed->intro_nodes),OP_EQ, 3);
  528. for (i = 0; i < smartlist_len(parsed->intro_nodes); i++) {
  529. rend_intro_point_t *par_intro = smartlist_get(parsed->intro_nodes, i),
  530. *gen_intro = smartlist_get(generated->intro_nodes, i);
  531. extend_info_t *par_info = par_intro->extend_info;
  532. extend_info_t *gen_info = gen_intro->extend_info;
  533. tt_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key));
  534. tt_mem_op(gen_info->identity_digest,OP_EQ, par_info->identity_digest,
  535. DIGEST_LEN);
  536. tt_str_op(gen_info->nickname,OP_EQ, par_info->nickname);
  537. tt_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
  538. tt_int_op(gen_info->port,OP_EQ, par_info->port);
  539. }
  540. rend_service_descriptor_free(parsed);
  541. rend_service_descriptor_free(generated);
  542. parsed = generated = NULL;
  543. done:
  544. if (descs) {
  545. for (i = 0; i < smartlist_len(descs); i++)
  546. rend_encoded_v2_service_descriptor_free_(smartlist_get(descs, i));
  547. smartlist_free(descs);
  548. }
  549. if (parsed)
  550. rend_service_descriptor_free(parsed);
  551. if (generated)
  552. rend_service_descriptor_free(generated);
  553. if (pk1)
  554. crypto_pk_free(pk1);
  555. if (pk2)
  556. crypto_pk_free(pk2);
  557. tor_free(intro_points_encrypted);
  558. }
  559. /** Run unit tests for stats code. */
  560. static void
  561. test_stats(void *arg)
  562. {
  563. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  564. char *s = NULL;
  565. int i;
  566. /* Start with testing exit port statistics; we shouldn't collect exit
  567. * stats without initializing them. */
  568. (void)arg;
  569. rep_hist_note_exit_stream_opened(80);
  570. rep_hist_note_exit_bytes(80, 100, 10000);
  571. s = rep_hist_format_exit_stats(now + 86400);
  572. tt_ptr_op(s, OP_EQ, NULL);
  573. /* Initialize stats, note some streams and bytes, and generate history
  574. * string. */
  575. rep_hist_exit_stats_init(now);
  576. rep_hist_note_exit_stream_opened(80);
  577. rep_hist_note_exit_bytes(80, 100, 10000);
  578. rep_hist_note_exit_stream_opened(443);
  579. rep_hist_note_exit_bytes(443, 100, 10000);
  580. rep_hist_note_exit_bytes(443, 100, 10000);
  581. s = rep_hist_format_exit_stats(now + 86400);
  582. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  583. "exit-kibibytes-written 80=1,443=1,other=0\n"
  584. "exit-kibibytes-read 80=10,443=20,other=0\n"
  585. "exit-streams-opened 80=4,443=4,other=0\n",OP_EQ, s);
  586. tor_free(s);
  587. /* Add a few bytes on 10 more ports and ensure that only the top 10
  588. * ports are contained in the history string. */
  589. for (i = 50; i < 60; i++) {
  590. rep_hist_note_exit_bytes(i, i, i);
  591. rep_hist_note_exit_stream_opened(i);
  592. }
  593. s = rep_hist_format_exit_stats(now + 86400);
  594. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  595. "exit-kibibytes-written 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  596. "59=1,80=1,443=1,other=1\n"
  597. "exit-kibibytes-read 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  598. "59=1,80=10,443=20,other=1\n"
  599. "exit-streams-opened 52=4,53=4,54=4,55=4,56=4,57=4,58=4,"
  600. "59=4,80=4,443=4,other=4\n",OP_EQ, s);
  601. tor_free(s);
  602. /* Stop collecting stats, add some bytes, and ensure we don't generate
  603. * a history string. */
  604. rep_hist_exit_stats_term();
  605. rep_hist_note_exit_bytes(80, 100, 10000);
  606. s = rep_hist_format_exit_stats(now + 86400);
  607. tt_ptr_op(s, OP_EQ, NULL);
  608. /* Re-start stats, add some bytes, reset stats, and see what history we
  609. * get when observing no streams or bytes at all. */
  610. rep_hist_exit_stats_init(now);
  611. rep_hist_note_exit_stream_opened(80);
  612. rep_hist_note_exit_bytes(80, 100, 10000);
  613. rep_hist_reset_exit_stats(now);
  614. s = rep_hist_format_exit_stats(now + 86400);
  615. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  616. "exit-kibibytes-written other=0\n"
  617. "exit-kibibytes-read other=0\n"
  618. "exit-streams-opened other=0\n",OP_EQ, s);
  619. tor_free(s);
  620. /* Continue with testing connection statistics; we shouldn't collect
  621. * conn stats without initializing them. */
  622. rep_hist_note_or_conn_bytes(1, 20, 400, now);
  623. s = rep_hist_format_conn_stats(now + 86400);
  624. tt_ptr_op(s, OP_EQ, NULL);
  625. /* Initialize stats, note bytes, and generate history string. */
  626. rep_hist_conn_stats_init(now);
  627. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  628. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  629. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  630. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  631. s = rep_hist_format_conn_stats(now + 86400);
  632. tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n",OP_EQ, s);
  633. tor_free(s);
  634. /* Stop collecting stats, add some bytes, and ensure we don't generate
  635. * a history string. */
  636. rep_hist_conn_stats_term();
  637. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  638. s = rep_hist_format_conn_stats(now + 86400);
  639. tt_ptr_op(s, OP_EQ, NULL);
  640. /* Re-start stats, add some bytes, reset stats, and see what history we
  641. * get when observing no bytes at all. */
  642. rep_hist_conn_stats_init(now);
  643. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  644. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  645. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  646. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  647. rep_hist_reset_conn_stats(now);
  648. s = rep_hist_format_conn_stats(now + 86400);
  649. tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n",OP_EQ, s);
  650. tor_free(s);
  651. /* Continue with testing buffer statistics; we shouldn't collect buffer
  652. * stats without initializing them. */
  653. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  654. s = rep_hist_format_buffer_stats(now + 86400);
  655. tt_ptr_op(s, OP_EQ, NULL);
  656. /* Initialize stats, add statistics for a single circuit, and generate
  657. * the history string. */
  658. rep_hist_buffer_stats_init(now);
  659. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  660. s = rep_hist_format_buffer_stats(now + 86400);
  661. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  662. "cell-processed-cells 20,0,0,0,0,0,0,0,0,0\n"
  663. "cell-queued-cells 2.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  664. "0.00,0.00\n"
  665. "cell-time-in-queue 2,0,0,0,0,0,0,0,0,0\n"
  666. "cell-circuits-per-decile 1\n",OP_EQ, s);
  667. tor_free(s);
  668. /* Add nineteen more circuit statistics to the one that's already in the
  669. * history to see that the math works correctly. */
  670. for (i = 21; i < 30; i++)
  671. rep_hist_add_buffer_stats(2.0, 2.0, i);
  672. for (i = 20; i < 30; i++)
  673. rep_hist_add_buffer_stats(3.5, 3.5, i);
  674. s = rep_hist_format_buffer_stats(now + 86400);
  675. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  676. "cell-processed-cells 29,28,27,26,25,24,23,22,21,20\n"
  677. "cell-queued-cells 2.75,2.75,2.75,2.75,2.75,2.75,2.75,2.75,"
  678. "2.75,2.75\n"
  679. "cell-time-in-queue 3,3,3,3,3,3,3,3,3,3\n"
  680. "cell-circuits-per-decile 2\n",OP_EQ, s);
  681. tor_free(s);
  682. /* Stop collecting stats, add statistics for one circuit, and ensure we
  683. * don't generate a history string. */
  684. rep_hist_buffer_stats_term();
  685. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  686. s = rep_hist_format_buffer_stats(now + 86400);
  687. tt_ptr_op(s, OP_EQ, NULL);
  688. /* Re-start stats, add statistics for one circuit, reset stats, and make
  689. * sure that the history has all zeros. */
  690. rep_hist_buffer_stats_init(now);
  691. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  692. rep_hist_reset_buffer_stats(now);
  693. s = rep_hist_format_buffer_stats(now + 86400);
  694. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  695. "cell-processed-cells 0,0,0,0,0,0,0,0,0,0\n"
  696. "cell-queued-cells 0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  697. "0.00,0.00\n"
  698. "cell-time-in-queue 0,0,0,0,0,0,0,0,0,0\n"
  699. "cell-circuits-per-decile 0\n",OP_EQ, s);
  700. done:
  701. tor_free(s);
  702. }
  703. #define ENT(name) \
  704. { #name, test_ ## name , 0, NULL, NULL }
  705. #define FORK(name) \
  706. { #name, test_ ## name , TT_FORK, NULL, NULL }
  707. static struct testcase_t test_array[] = {
  708. ENT(onion_handshake),
  709. { "bad_onion_handshake", test_bad_onion_handshake, 0, NULL, NULL },
  710. ENT(onion_queues),
  711. { "ntor_handshake", test_ntor_handshake, 0, NULL, NULL },
  712. { "fast_handshake", test_fast_handshake, 0, NULL, NULL },
  713. FORK(circuit_timeout),
  714. FORK(rend_fns),
  715. FORK(stats),
  716. END_OF_TESTCASES
  717. };
  718. struct testgroup_t testgroups[] = {
  719. { "", test_array },
  720. { "accounting/", accounting_tests },
  721. { "addr/", addr_tests },
  722. { "address/", address_tests },
  723. { "address_set/", address_set_tests },
  724. { "bridges/", bridges_tests },
  725. { "buffer/", buffer_tests },
  726. { "bwmgt/", bwmgt_tests },
  727. { "cellfmt/", cell_format_tests },
  728. { "cellqueue/", cell_queue_tests },
  729. { "channel/", channel_tests },
  730. { "channelpadding/", channelpadding_tests },
  731. { "channeltls/", channeltls_tests },
  732. { "checkdir/", checkdir_tests },
  733. { "circuitbuild/", circuitbuild_tests },
  734. { "circuitlist/", circuitlist_tests },
  735. { "circuitmux/", circuitmux_tests },
  736. { "circuituse/", circuituse_tests },
  737. { "circuitstats/", circuitstats_tests },
  738. { "compat/libevent/", compat_libevent_tests },
  739. { "config/", config_tests },
  740. { "connection/", connection_tests },
  741. { "conscache/", conscache_tests },
  742. { "consdiff/", consdiff_tests },
  743. { "consdiffmgr/", consdiffmgr_tests },
  744. { "container/", container_tests },
  745. { "control/", controller_tests },
  746. { "control/event/", controller_event_tests },
  747. { "crypto/", crypto_tests },
  748. { "crypto/ope/", crypto_ope_tests },
  749. #ifdef ENABLE_OPENSSL
  750. { "crypto/openssl/", crypto_openssl_tests },
  751. #endif
  752. { "crypto/pem/", pem_tests },
  753. { "dir/", dir_tests },
  754. { "dir_handle_get/", dir_handle_get_tests },
  755. { "dir/md/", microdesc_tests },
  756. { "dir/voting-schedule/", voting_schedule_tests },
  757. { "dos/", dos_tests },
  758. { "entryconn/", entryconn_tests },
  759. { "entrynodes/", entrynodes_tests },
  760. { "guardfraction/", guardfraction_tests },
  761. { "extorport/", extorport_tests },
  762. { "geoip/", geoip_tests },
  763. { "legacy_hs/", hs_tests },
  764. { "hs_cache/", hs_cache },
  765. { "hs_cell/", hs_cell_tests },
  766. { "hs_common/", hs_common_tests },
  767. { "hs_config/", hs_config_tests },
  768. { "hs_control/", hs_control_tests },
  769. { "hs_descriptor/", hs_descriptor },
  770. { "hs_ntor/", hs_ntor_tests },
  771. { "hs_service/", hs_service_tests },
  772. { "hs_client/", hs_client_tests },
  773. { "hs_intropoint/", hs_intropoint_tests },
  774. { "introduce/", introduce_tests },
  775. { "keypin/", keypin_tests },
  776. { "link-handshake/", link_handshake_tests },
  777. { "mainloop/", mainloop_tests },
  778. { "nodelist/", nodelist_tests },
  779. { "oom/", oom_tests },
  780. { "oos/", oos_tests },
  781. { "options/", options_tests },
  782. { "periodic-event/" , periodic_event_tests },
  783. { "policy/" , policy_tests },
  784. { "procmon/", procmon_tests },
  785. { "proto/http/", proto_http_tests },
  786. { "proto/misc/", proto_misc_tests },
  787. { "protover/", protover_tests },
  788. { "pt/", pt_tests },
  789. { "relay/" , relay_tests },
  790. { "relaycell/", relaycell_tests },
  791. { "relaycrypt/", relaycrypt_tests },
  792. { "rend_cache/", rend_cache_tests },
  793. { "replaycache/", replaycache_tests },
  794. { "router/", router_tests },
  795. { "routerkeys/", routerkeys_tests },
  796. { "routerlist/", routerlist_tests },
  797. { "routerset/" , routerset_tests },
  798. { "scheduler/", scheduler_tests },
  799. { "socks/", socks_tests },
  800. { "shared-random/", sr_tests },
  801. { "status/" , status_tests },
  802. { "storagedir/", storagedir_tests },
  803. { "tortls/", tortls_tests },
  804. #ifndef ENABLE_NSS
  805. { "tortls/openssl/", tortls_openssl_tests },
  806. #endif
  807. { "tortls/x509/", x509_tests },
  808. { "util/", util_tests },
  809. { "util/format/", util_format_tests },
  810. { "util/logging/", logging_tests },
  811. { "util/process/", util_process_tests },
  812. { "util/thread/", thread_tests },
  813. { "util/handle/", handle_tests },
  814. { "dns/", dns_tests },
  815. END_OF_GROUPS
  816. };