test.c 32 KB

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