test.c 44 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249
  1. /* Copyright (c) 2001-2004, Roger Dingledine.
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2017, 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 <stdio.h>
  11. #ifdef HAVE_FCNTL_H
  12. #include <fcntl.h>
  13. #endif
  14. #ifdef _WIN32
  15. /* For mkdir() */
  16. #include <direct.h>
  17. #else
  18. #include <dirent.h>
  19. #endif /* defined(_WIN32) */
  20. /* These macros pull in declarations for some functions and structures that
  21. * are typically file-private. */
  22. #define GEOIP_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.h"
  36. #include "backtrace.h"
  37. #include "buffers.h"
  38. #include "circuitlist.h"
  39. #include "circuitstats.h"
  40. #include "compress.h"
  41. #include "config.h"
  42. #include "connection_edge.h"
  43. #include "geoip.h"
  44. #include "rendcommon.h"
  45. #include "rendcache.h"
  46. #include "test.h"
  47. #include "main.h"
  48. #include "memarea.h"
  49. #include "onion.h"
  50. #include "onion_ntor.h"
  51. #include "onion_fast.h"
  52. #include "onion_tap.h"
  53. #include "policies.h"
  54. #include "rephist.h"
  55. #include "routerparse.h"
  56. #include "statefile.h"
  57. #include "crypto_curve25519.h"
  58. #include "onion_ntor.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, DH_KEY_LEN, PK_PKCS1_OAEP_PADDING, 1);
  130. tt_int_op(-1, OP_EQ,
  131. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  132. s_buf, s_keys, 40));
  133. /* Server: Case 2: the encrypted data is not long enough. */
  134. memset(junk_buf, 0, sizeof(junk_buf));
  135. memset(junk_buf2, 0, sizeof(junk_buf2));
  136. crypto_pk_public_encrypt(pk, junk_buf2, sizeof(junk_buf2),
  137. junk_buf, 48, PK_PKCS1_OAEP_PADDING);
  138. tt_int_op(-1, OP_EQ,
  139. onion_skin_TAP_server_handshake(junk_buf2, pk, NULL,
  140. s_buf, s_keys, 40));
  141. /* client handshake 1: do it straight. */
  142. memset(c_buf, 0, TAP_ONIONSKIN_CHALLENGE_LEN);
  143. tt_assert(! onion_skin_TAP_create(pk, &c_dh, c_buf));
  144. /* Server: Case 3: we just don't have the right key. */
  145. tt_int_op(-1, OP_EQ,
  146. onion_skin_TAP_server_handshake(c_buf, pk2, NULL,
  147. s_buf, s_keys, 40));
  148. /* Server: Case 4: The RSA-encrypted portion is corrupt. */
  149. c_buf[64] ^= 33;
  150. tt_int_op(-1, OP_EQ,
  151. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  152. s_buf, s_keys, 40));
  153. c_buf[64] ^= 33;
  154. /* (Let the server procede) */
  155. tt_int_op(0, OP_EQ,
  156. onion_skin_TAP_server_handshake(c_buf, pk, NULL,
  157. s_buf, s_keys, 40));
  158. /* Client: Case 1: The server sent back junk. */
  159. const char *msg = NULL;
  160. s_buf[64] ^= 33;
  161. tt_int_op(-1, OP_EQ,
  162. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  163. s_buf[64] ^= 33;
  164. tt_str_op(msg, OP_EQ, "Digest DOES NOT MATCH on onion handshake. "
  165. "Bug or attack.");
  166. /* Let the client finish; make sure it can. */
  167. msg = NULL;
  168. tt_int_op(0, OP_EQ,
  169. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  170. tt_mem_op(s_keys,OP_EQ, c_keys, 40);
  171. tt_ptr_op(msg, OP_EQ, NULL);
  172. /* Client: Case 2: The server sent back a degenerate DH. */
  173. memset(s_buf, 0, sizeof(s_buf));
  174. tt_int_op(-1, OP_EQ,
  175. onion_skin_TAP_client_handshake(c_dh, s_buf, c_keys, 40, &msg));
  176. tt_str_op(msg, OP_EQ, "DH computation failed.");
  177. done:
  178. crypto_dh_free(c_dh);
  179. crypto_pk_free(pk);
  180. crypto_pk_free(pk2);
  181. }
  182. static void
  183. test_ntor_handshake(void *arg)
  184. {
  185. /* client-side */
  186. ntor_handshake_state_t *c_state = NULL;
  187. uint8_t c_buf[NTOR_ONIONSKIN_LEN];
  188. uint8_t c_keys[400];
  189. /* server-side */
  190. di_digest256_map_t *s_keymap=NULL;
  191. curve25519_keypair_t s_keypair;
  192. uint8_t s_buf[NTOR_REPLY_LEN];
  193. uint8_t s_keys[400];
  194. /* shared */
  195. const curve25519_public_key_t *server_pubkey;
  196. uint8_t node_id[20] = "abcdefghijklmnopqrst";
  197. (void) arg;
  198. /* Make the server some keys */
  199. curve25519_secret_key_generate(&s_keypair.seckey, 0);
  200. curve25519_public_key_generate(&s_keypair.pubkey, &s_keypair.seckey);
  201. dimap_add_entry(&s_keymap, s_keypair.pubkey.public_key, &s_keypair);
  202. server_pubkey = &s_keypair.pubkey;
  203. /* client handshake 1. */
  204. memset(c_buf, 0, NTOR_ONIONSKIN_LEN);
  205. tt_int_op(0, OP_EQ, onion_skin_ntor_create(node_id, server_pubkey,
  206. &c_state, c_buf));
  207. /* server handshake */
  208. memset(s_buf, 0, NTOR_REPLY_LEN);
  209. memset(s_keys, 0, 40);
  210. tt_int_op(0, OP_EQ, onion_skin_ntor_server_handshake(c_buf, s_keymap, NULL,
  211. node_id,
  212. s_buf, s_keys, 400));
  213. /* client handshake 2 */
  214. memset(c_keys, 0, 40);
  215. tt_int_op(0, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,
  216. c_keys, 400, NULL));
  217. tt_mem_op(c_keys,OP_EQ, s_keys, 400);
  218. memset(s_buf, 0, 40);
  219. tt_mem_op(c_keys,OP_NE, s_buf, 40);
  220. /* Now try with a bogus server response. Zero input should trigger
  221. * All The Problems. */
  222. memset(c_keys, 0, 400);
  223. memset(s_buf, 0, NTOR_REPLY_LEN);
  224. const char *msg = NULL;
  225. tt_int_op(-1, OP_EQ, onion_skin_ntor_client_handshake(c_state, s_buf,
  226. c_keys, 400, &msg));
  227. tt_str_op(msg, OP_EQ, "Zero output from curve25519 handshake");
  228. done:
  229. ntor_handshake_state_free(c_state);
  230. dimap_free(s_keymap, NULL);
  231. }
  232. static void
  233. test_fast_handshake(void *arg)
  234. {
  235. /* tests for the obsolete "CREATE_FAST" handshake. */
  236. (void) arg;
  237. fast_handshake_state_t *state = NULL;
  238. uint8_t client_handshake[CREATE_FAST_LEN];
  239. uint8_t server_handshake[CREATED_FAST_LEN];
  240. uint8_t s_keys[100], c_keys[100];
  241. /* First, test an entire handshake. */
  242. memset(client_handshake, 0, sizeof(client_handshake));
  243. tt_int_op(0, OP_EQ, fast_onionskin_create(&state, client_handshake));
  244. tt_assert(! tor_mem_is_zero((char*)client_handshake,
  245. sizeof(client_handshake)));
  246. tt_int_op(0, OP_EQ,
  247. fast_server_handshake(client_handshake, server_handshake,
  248. s_keys, 100));
  249. const char *msg = NULL;
  250. tt_int_op(0, OP_EQ,
  251. fast_client_handshake(state, server_handshake, c_keys, 100, &msg));
  252. tt_ptr_op(msg, OP_EQ, NULL);
  253. tt_mem_op(s_keys, OP_EQ, c_keys, 100);
  254. /* Now test a failing handshake. */
  255. server_handshake[0] ^= 3;
  256. tt_int_op(-1, OP_EQ,
  257. fast_client_handshake(state, server_handshake, c_keys, 100, &msg));
  258. tt_str_op(msg, OP_EQ, "Digest DOES NOT MATCH on fast handshake. "
  259. "Bug or attack.");
  260. done:
  261. fast_handshake_state_free(state);
  262. }
  263. /** Run unit tests for the onion queues. */
  264. static void
  265. test_onion_queues(void *arg)
  266. {
  267. uint8_t buf1[TAP_ONIONSKIN_CHALLENGE_LEN] = {0};
  268. uint8_t buf2[NTOR_ONIONSKIN_LEN] = {0};
  269. or_circuit_t *circ1 = or_circuit_new(0, NULL);
  270. or_circuit_t *circ2 = or_circuit_new(0, NULL);
  271. create_cell_t *onionskin = NULL, *create2_ptr;
  272. create_cell_t *create1 = tor_malloc_zero(sizeof(create_cell_t));
  273. create_cell_t *create2 = tor_malloc_zero(sizeof(create_cell_t));
  274. (void)arg;
  275. create2_ptr = create2; /* remember, but do not free */
  276. create_cell_init(create1, CELL_CREATE, ONION_HANDSHAKE_TYPE_TAP,
  277. TAP_ONIONSKIN_CHALLENGE_LEN, buf1);
  278. create_cell_init(create2, CELL_CREATE, ONION_HANDSHAKE_TYPE_NTOR,
  279. NTOR_ONIONSKIN_LEN, buf2);
  280. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  281. tt_int_op(0,OP_EQ, onion_pending_add(circ1, create1));
  282. create1 = NULL;
  283. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  284. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  285. tt_int_op(0,OP_EQ, onion_pending_add(circ2, create2));
  286. create2 = NULL;
  287. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  288. tt_ptr_op(circ2,OP_EQ, onion_next_task(&onionskin));
  289. tt_int_op(1,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  290. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  291. tt_ptr_op(onionskin, OP_EQ, create2_ptr);
  292. clear_pending_onions();
  293. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_TAP));
  294. tt_int_op(0,OP_EQ, onion_num_pending(ONION_HANDSHAKE_TYPE_NTOR));
  295. done:
  296. circuit_free_(TO_CIRCUIT(circ1));
  297. circuit_free_(TO_CIRCUIT(circ2));
  298. tor_free(create1);
  299. tor_free(create2);
  300. tor_free(onionskin);
  301. }
  302. static void
  303. test_circuit_timeout(void *arg)
  304. {
  305. /* Plan:
  306. * 1. Generate 1000 samples
  307. * 2. Estimate parameters
  308. * 3. If difference, repeat
  309. * 4. Save state
  310. * 5. load state
  311. * 6. Estimate parameters
  312. * 7. compare differences
  313. */
  314. circuit_build_times_t initial;
  315. circuit_build_times_t estimate;
  316. circuit_build_times_t final;
  317. double timeout1, timeout2;
  318. or_state_t *state=NULL;
  319. int i, runs;
  320. double close_ms;
  321. (void)arg;
  322. initialize_periodic_events();
  323. circuit_build_times_init(&initial);
  324. circuit_build_times_init(&estimate);
  325. circuit_build_times_init(&final);
  326. state = or_state_new();
  327. circuitbuild_running_unit_tests();
  328. #define timeout0 (build_time_t)(30*1000.0)
  329. initial.Xm = 3000;
  330. circuit_build_times_initial_alpha(&initial,
  331. CBT_DEFAULT_QUANTILE_CUTOFF/100.0,
  332. timeout0);
  333. close_ms = MAX(circuit_build_times_calculate_timeout(&initial,
  334. CBT_DEFAULT_CLOSE_QUANTILE/100.0),
  335. CBT_DEFAULT_TIMEOUT_INITIAL_VALUE);
  336. do {
  337. for (i=0; i < CBT_DEFAULT_MIN_CIRCUITS_TO_OBSERVE; i++) {
  338. build_time_t sample = circuit_build_times_generate_sample(&initial,0,1);
  339. if (sample > close_ms) {
  340. circuit_build_times_add_time(&estimate, CBT_BUILD_ABANDONED);
  341. } else {
  342. circuit_build_times_add_time(&estimate, sample);
  343. }
  344. }
  345. circuit_build_times_update_alpha(&estimate);
  346. timeout1 = circuit_build_times_calculate_timeout(&estimate,
  347. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  348. circuit_build_times_set_timeout(&estimate);
  349. log_notice(LD_CIRC, "Timeout1 is %f, Xm is %d", timeout1, estimate.Xm);
  350. /* 2% error */
  351. } while (fabs(circuit_build_times_cdf(&initial, timeout0) -
  352. circuit_build_times_cdf(&initial, timeout1)) > 0.02);
  353. tt_int_op(estimate.total_build_times, OP_LE, CBT_NCIRCUITS_TO_OBSERVE);
  354. circuit_build_times_update_state(&estimate, state);
  355. circuit_build_times_free_timeouts(&final);
  356. tt_int_op(circuit_build_times_parse_state(&final, state), OP_EQ, 0);
  357. circuit_build_times_update_alpha(&final);
  358. timeout2 = circuit_build_times_calculate_timeout(&final,
  359. CBT_DEFAULT_QUANTILE_CUTOFF/100.0);
  360. circuit_build_times_set_timeout(&final);
  361. log_notice(LD_CIRC, "Timeout2 is %f, Xm is %d", timeout2, final.Xm);
  362. /* 5% here because some accuracy is lost due to histogram conversion */
  363. tt_assert(fabs(circuit_build_times_cdf(&initial, timeout0) -
  364. circuit_build_times_cdf(&initial, timeout2)) < 0.05);
  365. for (runs = 0; runs < 50; runs++) {
  366. int build_times_idx = 0;
  367. int total_build_times = 0;
  368. final.close_ms = final.timeout_ms = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  369. estimate.close_ms = estimate.timeout_ms
  370. = CBT_DEFAULT_TIMEOUT_INITIAL_VALUE;
  371. for (i = 0; i < CBT_DEFAULT_RECENT_CIRCUITS*2; i++) {
  372. circuit_build_times_network_circ_success(&estimate);
  373. circuit_build_times_add_time(&estimate,
  374. circuit_build_times_generate_sample(&estimate, 0,
  375. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  376. circuit_build_times_network_circ_success(&estimate);
  377. circuit_build_times_add_time(&final,
  378. circuit_build_times_generate_sample(&final, 0,
  379. CBT_DEFAULT_QUANTILE_CUTOFF/100.0));
  380. }
  381. tt_assert(!circuit_build_times_network_check_changed(&estimate));
  382. tt_assert(!circuit_build_times_network_check_changed(&final));
  383. /* Reset liveness to be non-live */
  384. final.liveness.network_last_live = 0;
  385. estimate.liveness.network_last_live = 0;
  386. build_times_idx = estimate.build_times_idx;
  387. total_build_times = estimate.total_build_times;
  388. tt_assert(circuit_build_times_network_check_live(&estimate));
  389. tt_assert(circuit_build_times_network_check_live(&final));
  390. circuit_build_times_count_close(&estimate, 0,
  391. (time_t)(approx_time()-estimate.close_ms/1000.0-1));
  392. circuit_build_times_count_close(&final, 0,
  393. (time_t)(approx_time()-final.close_ms/1000.0-1));
  394. tt_assert(!circuit_build_times_network_check_live(&estimate));
  395. tt_assert(!circuit_build_times_network_check_live(&final));
  396. log_info(LD_CIRC, "idx: %d %d, tot: %d %d",
  397. build_times_idx, estimate.build_times_idx,
  398. total_build_times, estimate.total_build_times);
  399. /* Check rollback index. Should match top of loop. */
  400. tt_assert(build_times_idx == estimate.build_times_idx);
  401. // This can fail if estimate.total_build_times == 1000, because
  402. // in that case, rewind actually causes us to lose timeouts
  403. if (total_build_times != CBT_NCIRCUITS_TO_OBSERVE)
  404. tt_assert(total_build_times == estimate.total_build_times);
  405. /* Now simulate that the network has become live and we need
  406. * a change */
  407. circuit_build_times_network_is_live(&estimate);
  408. circuit_build_times_network_is_live(&final);
  409. for (i = 0; i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT; i++) {
  410. circuit_build_times_count_timeout(&estimate, 1);
  411. if (i < CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1) {
  412. circuit_build_times_count_timeout(&final, 1);
  413. }
  414. }
  415. tt_int_op(estimate.liveness.after_firsthop_idx, OP_EQ, 0);
  416. tt_assert(final.liveness.after_firsthop_idx ==
  417. CBT_DEFAULT_MAX_RECENT_TIMEOUT_COUNT-1);
  418. tt_assert(circuit_build_times_network_check_live(&estimate));
  419. tt_assert(circuit_build_times_network_check_live(&final));
  420. circuit_build_times_count_timeout(&final, 1);
  421. /* Ensure return value for degenerate cases are clamped correctly */
  422. initial.alpha = INT32_MAX;
  423. tt_assert(circuit_build_times_calculate_timeout(&initial, .99999999) <=
  424. INT32_MAX);
  425. initial.alpha = 0;
  426. tt_assert(circuit_build_times_calculate_timeout(&initial, .5) <=
  427. INT32_MAX);
  428. }
  429. done:
  430. circuit_build_times_free_timeouts(&initial);
  431. circuit_build_times_free_timeouts(&estimate);
  432. circuit_build_times_free_timeouts(&final);
  433. or_state_free(state);
  434. teardown_periodic_events();
  435. }
  436. /** Test encoding and parsing of rendezvous service descriptors. */
  437. static void
  438. test_rend_fns(void *arg)
  439. {
  440. rend_service_descriptor_t *generated = NULL, *parsed = NULL;
  441. char service_id[DIGEST_LEN];
  442. char service_id_base32[REND_SERVICE_ID_LEN_BASE32+1];
  443. const char *next_desc;
  444. smartlist_t *descs = smartlist_new();
  445. char computed_desc_id[DIGEST_LEN];
  446. char parsed_desc_id[DIGEST_LEN];
  447. crypto_pk_t *pk1 = NULL, *pk2 = NULL;
  448. time_t now;
  449. char *intro_points_encrypted = NULL;
  450. size_t intro_points_size;
  451. size_t encoded_size;
  452. int i;
  453. (void)arg;
  454. /* Initialize the service cache. */
  455. rend_cache_init();
  456. pk1 = pk_generate(0);
  457. pk2 = pk_generate(1);
  458. generated = tor_malloc_zero(sizeof(rend_service_descriptor_t));
  459. generated->pk = crypto_pk_dup_key(pk1);
  460. crypto_pk_get_digest(generated->pk, service_id);
  461. base32_encode(service_id_base32, REND_SERVICE_ID_LEN_BASE32+1,
  462. service_id, REND_SERVICE_ID_LEN);
  463. now = time(NULL);
  464. generated->timestamp = now;
  465. generated->version = 2;
  466. generated->protocols = 42;
  467. generated->intro_nodes = smartlist_new();
  468. for (i = 0; i < 3; i++) {
  469. rend_intro_point_t *intro = tor_malloc_zero(sizeof(rend_intro_point_t));
  470. crypto_pk_t *okey = pk_generate(2 + i);
  471. intro->extend_info = tor_malloc_zero(sizeof(extend_info_t));
  472. intro->extend_info->onion_key = okey;
  473. crypto_pk_get_digest(intro->extend_info->onion_key,
  474. intro->extend_info->identity_digest);
  475. //crypto_rand(info->identity_digest, DIGEST_LEN); /* Would this work? */
  476. intro->extend_info->nickname[0] = '$';
  477. base16_encode(intro->extend_info->nickname + 1,
  478. sizeof(intro->extend_info->nickname) - 1,
  479. intro->extend_info->identity_digest, DIGEST_LEN);
  480. /* Does not cover all IP addresses. */
  481. tor_addr_from_ipv4h(&intro->extend_info->addr, crypto_rand_int(65536));
  482. intro->extend_info->port = 1 + crypto_rand_int(65535);
  483. intro->intro_key = crypto_pk_dup_key(pk2);
  484. smartlist_add(generated->intro_nodes, intro);
  485. }
  486. int rv = rend_encode_v2_descriptors(descs, generated, now, 0,
  487. REND_NO_AUTH, NULL, NULL);
  488. tt_int_op(rv, OP_GT, 0);
  489. rv = rend_compute_v2_desc_id(computed_desc_id, service_id_base32, NULL,
  490. now, 0);
  491. tt_int_op(rv, OP_EQ, 0);
  492. tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
  493. smartlist_get(descs, 0))->desc_id, OP_EQ,
  494. computed_desc_id, DIGEST_LEN);
  495. rv = rend_parse_v2_service_descriptor(&parsed, parsed_desc_id,
  496. &intro_points_encrypted, &intro_points_size, &encoded_size,
  497. &next_desc,
  498. ((rend_encoded_v2_service_descriptor_t *)smartlist_get(descs, 0))
  499. ->desc_str, 1);
  500. tt_int_op(rv, OP_EQ, 0);
  501. tt_assert(parsed);
  502. tt_mem_op(((rend_encoded_v2_service_descriptor_t *)
  503. smartlist_get(descs, 0))->desc_id,OP_EQ, parsed_desc_id, DIGEST_LEN);
  504. tt_int_op(rend_parse_introduction_points(parsed, intro_points_encrypted,
  505. intro_points_size),OP_EQ, 3);
  506. tt_assert(!crypto_pk_cmp_keys(generated->pk, parsed->pk));
  507. tt_int_op(parsed->timestamp,OP_EQ, now);
  508. tt_int_op(parsed->version,OP_EQ, 2);
  509. tt_int_op(parsed->protocols,OP_EQ, 42);
  510. tt_int_op(smartlist_len(parsed->intro_nodes),OP_EQ, 3);
  511. for (i = 0; i < smartlist_len(parsed->intro_nodes); i++) {
  512. rend_intro_point_t *par_intro = smartlist_get(parsed->intro_nodes, i),
  513. *gen_intro = smartlist_get(generated->intro_nodes, i);
  514. extend_info_t *par_info = par_intro->extend_info;
  515. extend_info_t *gen_info = gen_intro->extend_info;
  516. tt_assert(!crypto_pk_cmp_keys(gen_info->onion_key, par_info->onion_key));
  517. tt_mem_op(gen_info->identity_digest,OP_EQ, par_info->identity_digest,
  518. DIGEST_LEN);
  519. tt_str_op(gen_info->nickname,OP_EQ, par_info->nickname);
  520. tt_assert(tor_addr_eq(&gen_info->addr, &par_info->addr));
  521. tt_int_op(gen_info->port,OP_EQ, par_info->port);
  522. }
  523. rend_service_descriptor_free(parsed);
  524. rend_service_descriptor_free(generated);
  525. parsed = generated = NULL;
  526. done:
  527. if (descs) {
  528. for (i = 0; i < smartlist_len(descs); i++)
  529. rend_encoded_v2_service_descriptor_free_(smartlist_get(descs, i));
  530. smartlist_free(descs);
  531. }
  532. if (parsed)
  533. rend_service_descriptor_free(parsed);
  534. if (generated)
  535. rend_service_descriptor_free(generated);
  536. if (pk1)
  537. crypto_pk_free(pk1);
  538. if (pk2)
  539. crypto_pk_free(pk2);
  540. tor_free(intro_points_encrypted);
  541. }
  542. /* Record odd numbered fake-IPs using ipv6, even numbered fake-IPs
  543. * using ipv4. Since our fake geoip database is the same between
  544. * ipv4 and ipv6, we should get the same result no matter which
  545. * address family we pick for each IP. */
  546. #define SET_TEST_ADDRESS(i) do { \
  547. if ((i) & 1) { \
  548. SET_TEST_IPV6(i); \
  549. tor_addr_from_in6(&addr, &in6); \
  550. } else { \
  551. tor_addr_from_ipv4h(&addr, (uint32_t) i); \
  552. } \
  553. } while (0)
  554. /* Make sure that country ID actually works. */
  555. #define SET_TEST_IPV6(i) \
  556. do { \
  557. set_uint32(in6.s6_addr + 12, htonl((uint32_t) (i))); \
  558. } while (0)
  559. #define CHECK_COUNTRY(country, val) do { \
  560. /* test ipv4 country lookup */ \
  561. tt_str_op(country, OP_EQ, \
  562. geoip_get_country_name(geoip_get_country_by_ipv4(val))); \
  563. /* test ipv6 country lookup */ \
  564. SET_TEST_IPV6(val); \
  565. tt_str_op(country, OP_EQ, \
  566. geoip_get_country_name(geoip_get_country_by_ipv6(&in6))); \
  567. } while (0)
  568. /** Run unit tests for GeoIP code. */
  569. static void
  570. test_geoip(void *arg)
  571. {
  572. int i, j;
  573. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  574. char *s = NULL, *v = NULL;
  575. const char *bridge_stats_1 =
  576. "bridge-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  577. "bridge-ips zz=24,xy=8\n"
  578. "bridge-ip-versions v4=16,v6=16\n"
  579. "bridge-ip-transports <OR>=24\n",
  580. *dirreq_stats_1 =
  581. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  582. "dirreq-v3-ips ab=8\n"
  583. "dirreq-v3-reqs ab=8\n"
  584. "dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,"
  585. "not-modified=0,busy=0\n"
  586. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  587. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  588. *dirreq_stats_2 =
  589. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  590. "dirreq-v3-ips \n"
  591. "dirreq-v3-reqs \n"
  592. "dirreq-v3-resp ok=0,not-enough-sigs=0,unavailable=0,not-found=0,"
  593. "not-modified=0,busy=0\n"
  594. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  595. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  596. *dirreq_stats_3 =
  597. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  598. "dirreq-v3-ips \n"
  599. "dirreq-v3-reqs \n"
  600. "dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,"
  601. "not-modified=0,busy=0\n"
  602. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  603. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=0\n",
  604. *dirreq_stats_4 =
  605. "dirreq-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  606. "dirreq-v3-ips \n"
  607. "dirreq-v3-reqs \n"
  608. "dirreq-v3-resp ok=8,not-enough-sigs=0,unavailable=0,not-found=0,"
  609. "not-modified=0,busy=0\n"
  610. "dirreq-v3-direct-dl complete=0,timeout=0,running=0\n"
  611. "dirreq-v3-tunneled-dl complete=0,timeout=0,running=4\n",
  612. *entry_stats_1 =
  613. "entry-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  614. "entry-ips ab=8\n",
  615. *entry_stats_2 =
  616. "entry-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  617. "entry-ips \n";
  618. tor_addr_t addr;
  619. struct in6_addr in6;
  620. /* Populate the DB a bit. Add these in order, since we can't do the final
  621. * 'sort' step. These aren't very good IP addresses, but they're perfectly
  622. * fine uint32_t values. */
  623. (void)arg;
  624. tt_int_op(0,OP_EQ, geoip_parse_entry("10,50,AB", AF_INET));
  625. tt_int_op(0,OP_EQ, geoip_parse_entry("52,90,XY", AF_INET));
  626. tt_int_op(0,OP_EQ, geoip_parse_entry("95,100,AB", AF_INET));
  627. tt_int_op(0,OP_EQ, geoip_parse_entry("\"105\",\"140\",\"ZZ\"", AF_INET));
  628. tt_int_op(0,OP_EQ, geoip_parse_entry("\"150\",\"190\",\"XY\"", AF_INET));
  629. tt_int_op(0,OP_EQ, geoip_parse_entry("\"200\",\"250\",\"AB\"", AF_INET));
  630. /* Populate the IPv6 DB equivalently with fake IPs in the same range */
  631. tt_int_op(0,OP_EQ, geoip_parse_entry("::a,::32,AB", AF_INET6));
  632. tt_int_op(0,OP_EQ, geoip_parse_entry("::34,::5a,XY", AF_INET6));
  633. tt_int_op(0,OP_EQ, geoip_parse_entry("::5f,::64,AB", AF_INET6));
  634. tt_int_op(0,OP_EQ, geoip_parse_entry("::69,::8c,ZZ", AF_INET6));
  635. tt_int_op(0,OP_EQ, geoip_parse_entry("::96,::be,XY", AF_INET6));
  636. tt_int_op(0,OP_EQ, geoip_parse_entry("::c8,::fa,AB", AF_INET6));
  637. /* We should have 4 countries: ??, ab, xy, zz. */
  638. tt_int_op(4,OP_EQ, geoip_get_n_countries());
  639. memset(&in6, 0, sizeof(in6));
  640. CHECK_COUNTRY("??", 3);
  641. CHECK_COUNTRY("ab", 32);
  642. CHECK_COUNTRY("??", 5);
  643. CHECK_COUNTRY("??", 51);
  644. CHECK_COUNTRY("xy", 150);
  645. CHECK_COUNTRY("xy", 190);
  646. CHECK_COUNTRY("??", 2000);
  647. tt_int_op(0,OP_EQ, geoip_get_country_by_ipv4(3));
  648. SET_TEST_IPV6(3);
  649. tt_int_op(0,OP_EQ, geoip_get_country_by_ipv6(&in6));
  650. get_options_mutable()->BridgeRelay = 1;
  651. get_options_mutable()->BridgeRecordUsageByCountry = 1;
  652. /* Put 9 observations in AB... */
  653. for (i=32; i < 40; ++i) {
  654. SET_TEST_ADDRESS(i);
  655. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  656. }
  657. SET_TEST_ADDRESS(225);
  658. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  659. /* and 3 observations in XY, several times. */
  660. for (j=0; j < 10; ++j)
  661. for (i=52; i < 55; ++i) {
  662. SET_TEST_ADDRESS(i);
  663. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-3600);
  664. }
  665. /* and 17 observations in ZZ... */
  666. for (i=110; i < 127; ++i) {
  667. SET_TEST_ADDRESS(i);
  668. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  669. }
  670. geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
  671. tt_assert(s);
  672. tt_assert(v);
  673. tt_str_op("zz=24,ab=16,xy=8",OP_EQ, s);
  674. tt_str_op("v4=16,v6=16",OP_EQ, v);
  675. tor_free(s);
  676. tor_free(v);
  677. /* Now clear out all the AB observations. */
  678. geoip_remove_old_clients(now-6000);
  679. geoip_get_client_history(GEOIP_CLIENT_CONNECT, &s, &v);
  680. tt_assert(s);
  681. tt_assert(v);
  682. tt_str_op("zz=24,xy=8",OP_EQ, s);
  683. tt_str_op("v4=16,v6=16",OP_EQ, v);
  684. tor_free(s);
  685. tor_free(v);
  686. /* Start testing bridge statistics by making sure that we don't output
  687. * bridge stats without initializing them. */
  688. s = geoip_format_bridge_stats(now + 86400);
  689. tt_ptr_op(s, OP_EQ, NULL);
  690. /* Initialize stats and generate the bridge-stats history string out of
  691. * the connecting clients added above. */
  692. geoip_bridge_stats_init(now);
  693. s = geoip_format_bridge_stats(now + 86400);
  694. tt_assert(s);
  695. tt_str_op(bridge_stats_1,OP_EQ, s);
  696. tor_free(s);
  697. /* Stop collecting bridge stats and make sure we don't write a history
  698. * string anymore. */
  699. geoip_bridge_stats_term();
  700. s = geoip_format_bridge_stats(now + 86400);
  701. tt_ptr_op(s, OP_EQ, NULL);
  702. /* Stop being a bridge and start being a directory mirror that gathers
  703. * directory request statistics. */
  704. geoip_bridge_stats_term();
  705. get_options_mutable()->BridgeRelay = 0;
  706. get_options_mutable()->BridgeRecordUsageByCountry = 0;
  707. get_options_mutable()->DirReqStatistics = 1;
  708. /* Start testing dirreq statistics by making sure that we don't collect
  709. * dirreq stats without initializing them. */
  710. SET_TEST_ADDRESS(100);
  711. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  712. s = geoip_format_dirreq_stats(now + 86400);
  713. tt_ptr_op(s, OP_EQ, NULL);
  714. /* Initialize stats, note one connecting client, and generate the
  715. * dirreq-stats history string. */
  716. geoip_dirreq_stats_init(now);
  717. SET_TEST_ADDRESS(100);
  718. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  719. s = geoip_format_dirreq_stats(now + 86400);
  720. tt_str_op(dirreq_stats_1,OP_EQ, s);
  721. tor_free(s);
  722. /* Stop collecting stats, add another connecting client, and ensure we
  723. * don't generate a history string. */
  724. geoip_dirreq_stats_term();
  725. SET_TEST_ADDRESS(101);
  726. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  727. s = geoip_format_dirreq_stats(now + 86400);
  728. tt_ptr_op(s, OP_EQ, NULL);
  729. /* Re-start stats, add a connecting client, reset stats, and make sure
  730. * that we get an all empty history string. */
  731. geoip_dirreq_stats_init(now);
  732. SET_TEST_ADDRESS(100);
  733. geoip_note_client_seen(GEOIP_CLIENT_NETWORKSTATUS, &addr, NULL, now);
  734. geoip_reset_dirreq_stats(now);
  735. s = geoip_format_dirreq_stats(now + 86400);
  736. tt_str_op(dirreq_stats_2,OP_EQ, s);
  737. tor_free(s);
  738. /* Note a successful network status response and make sure that it
  739. * appears in the history string. */
  740. geoip_note_ns_response(GEOIP_SUCCESS);
  741. s = geoip_format_dirreq_stats(now + 86400);
  742. tt_str_op(dirreq_stats_3,OP_EQ, s);
  743. tor_free(s);
  744. /* Start a tunneled directory request. */
  745. geoip_start_dirreq((uint64_t) 1, 1024, DIRREQ_TUNNELED);
  746. s = geoip_format_dirreq_stats(now + 86400);
  747. tt_str_op(dirreq_stats_4,OP_EQ, s);
  748. tor_free(s);
  749. /* Stop collecting directory request statistics and start gathering
  750. * entry stats. */
  751. geoip_dirreq_stats_term();
  752. get_options_mutable()->DirReqStatistics = 0;
  753. get_options_mutable()->EntryStatistics = 1;
  754. /* Start testing entry statistics by making sure that we don't collect
  755. * anything without initializing entry stats. */
  756. SET_TEST_ADDRESS(100);
  757. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  758. s = geoip_format_entry_stats(now + 86400);
  759. tt_ptr_op(s, OP_EQ, NULL);
  760. /* Initialize stats, note one connecting client, and generate the
  761. * entry-stats history string. */
  762. geoip_entry_stats_init(now);
  763. SET_TEST_ADDRESS(100);
  764. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  765. s = geoip_format_entry_stats(now + 86400);
  766. tt_str_op(entry_stats_1,OP_EQ, s);
  767. tor_free(s);
  768. /* Stop collecting stats, add another connecting client, and ensure we
  769. * don't generate a history string. */
  770. geoip_entry_stats_term();
  771. SET_TEST_ADDRESS(101);
  772. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  773. s = geoip_format_entry_stats(now + 86400);
  774. tt_ptr_op(s, OP_EQ, NULL);
  775. /* Re-start stats, add a connecting client, reset stats, and make sure
  776. * that we get an all empty history string. */
  777. geoip_entry_stats_init(now);
  778. SET_TEST_ADDRESS(100);
  779. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now);
  780. geoip_reset_entry_stats(now);
  781. s = geoip_format_entry_stats(now + 86400);
  782. tt_str_op(entry_stats_2,OP_EQ, s);
  783. tor_free(s);
  784. /* Stop collecting entry statistics. */
  785. geoip_entry_stats_term();
  786. get_options_mutable()->EntryStatistics = 0;
  787. done:
  788. tor_free(s);
  789. tor_free(v);
  790. }
  791. static void
  792. test_geoip_with_pt(void *arg)
  793. {
  794. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  795. char *s = NULL;
  796. int i;
  797. tor_addr_t addr;
  798. struct in6_addr in6;
  799. (void)arg;
  800. get_options_mutable()->BridgeRelay = 1;
  801. get_options_mutable()->BridgeRecordUsageByCountry = 1;
  802. memset(&in6, 0, sizeof(in6));
  803. /* No clients seen yet. */
  804. s = geoip_get_transport_history();
  805. tor_assert(!s);
  806. /* 4 connections without a pluggable transport */
  807. for (i=0; i < 4; ++i) {
  808. SET_TEST_ADDRESS(i);
  809. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, NULL, now-7200);
  810. }
  811. /* 9 connections with "alpha" */
  812. for (i=4; i < 13; ++i) {
  813. SET_TEST_ADDRESS(i);
  814. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "alpha", now-7200);
  815. }
  816. /* one connection with "beta" */
  817. SET_TEST_ADDRESS(13);
  818. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "beta", now-7200);
  819. /* 14 connections with "charlie" */
  820. for (i=14; i < 28; ++i) {
  821. SET_TEST_ADDRESS(i);
  822. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "charlie", now-7200);
  823. }
  824. /* 131 connections with "ddr" */
  825. for (i=28; i < 159; ++i) {
  826. SET_TEST_ADDRESS(i);
  827. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "ddr", now-7200);
  828. }
  829. /* 8 connections with "entropy" */
  830. for (i=159; i < 167; ++i) {
  831. SET_TEST_ADDRESS(i);
  832. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "entropy", now-7200);
  833. }
  834. /* 2 connections from the same IP with two different transports. */
  835. SET_TEST_ADDRESS(++i);
  836. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "fire", now-7200);
  837. geoip_note_client_seen(GEOIP_CLIENT_CONNECT, &addr, "google", now-7200);
  838. /* Test the transport history string. */
  839. s = geoip_get_transport_history();
  840. tor_assert(s);
  841. tt_str_op(s,OP_EQ, "<OR>=8,alpha=16,beta=8,charlie=16,ddr=136,"
  842. "entropy=8,fire=8,google=8");
  843. /* Stop collecting entry statistics. */
  844. geoip_entry_stats_term();
  845. get_options_mutable()->EntryStatistics = 0;
  846. done:
  847. tor_free(s);
  848. }
  849. #undef SET_TEST_ADDRESS
  850. #undef SET_TEST_IPV6
  851. #undef CHECK_COUNTRY
  852. /** Run unit tests for stats code. */
  853. static void
  854. test_stats(void *arg)
  855. {
  856. time_t now = 1281533250; /* 2010-08-11 13:27:30 UTC */
  857. char *s = NULL;
  858. int i;
  859. /* Start with testing exit port statistics; we shouldn't collect exit
  860. * stats without initializing them. */
  861. (void)arg;
  862. rep_hist_note_exit_stream_opened(80);
  863. rep_hist_note_exit_bytes(80, 100, 10000);
  864. s = rep_hist_format_exit_stats(now + 86400);
  865. tt_ptr_op(s, OP_EQ, NULL);
  866. /* Initialize stats, note some streams and bytes, and generate history
  867. * string. */
  868. rep_hist_exit_stats_init(now);
  869. rep_hist_note_exit_stream_opened(80);
  870. rep_hist_note_exit_bytes(80, 100, 10000);
  871. rep_hist_note_exit_stream_opened(443);
  872. rep_hist_note_exit_bytes(443, 100, 10000);
  873. rep_hist_note_exit_bytes(443, 100, 10000);
  874. s = rep_hist_format_exit_stats(now + 86400);
  875. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  876. "exit-kibibytes-written 80=1,443=1,other=0\n"
  877. "exit-kibibytes-read 80=10,443=20,other=0\n"
  878. "exit-streams-opened 80=4,443=4,other=0\n",OP_EQ, s);
  879. tor_free(s);
  880. /* Add a few bytes on 10 more ports and ensure that only the top 10
  881. * ports are contained in the history string. */
  882. for (i = 50; i < 60; i++) {
  883. rep_hist_note_exit_bytes(i, i, i);
  884. rep_hist_note_exit_stream_opened(i);
  885. }
  886. s = rep_hist_format_exit_stats(now + 86400);
  887. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  888. "exit-kibibytes-written 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  889. "59=1,80=1,443=1,other=1\n"
  890. "exit-kibibytes-read 52=1,53=1,54=1,55=1,56=1,57=1,58=1,"
  891. "59=1,80=10,443=20,other=1\n"
  892. "exit-streams-opened 52=4,53=4,54=4,55=4,56=4,57=4,58=4,"
  893. "59=4,80=4,443=4,other=4\n",OP_EQ, s);
  894. tor_free(s);
  895. /* Stop collecting stats, add some bytes, and ensure we don't generate
  896. * a history string. */
  897. rep_hist_exit_stats_term();
  898. rep_hist_note_exit_bytes(80, 100, 10000);
  899. s = rep_hist_format_exit_stats(now + 86400);
  900. tt_ptr_op(s, OP_EQ, NULL);
  901. /* Re-start stats, add some bytes, reset stats, and see what history we
  902. * get when observing no streams or bytes at all. */
  903. rep_hist_exit_stats_init(now);
  904. rep_hist_note_exit_stream_opened(80);
  905. rep_hist_note_exit_bytes(80, 100, 10000);
  906. rep_hist_reset_exit_stats(now);
  907. s = rep_hist_format_exit_stats(now + 86400);
  908. tt_str_op("exit-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  909. "exit-kibibytes-written other=0\n"
  910. "exit-kibibytes-read other=0\n"
  911. "exit-streams-opened other=0\n",OP_EQ, s);
  912. tor_free(s);
  913. /* Continue with testing connection statistics; we shouldn't collect
  914. * conn stats without initializing them. */
  915. rep_hist_note_or_conn_bytes(1, 20, 400, now);
  916. s = rep_hist_format_conn_stats(now + 86400);
  917. tt_ptr_op(s, OP_EQ, NULL);
  918. /* Initialize stats, note bytes, and generate history string. */
  919. rep_hist_conn_stats_init(now);
  920. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  921. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  922. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  923. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  924. s = rep_hist_format_conn_stats(now + 86400);
  925. tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,1,0\n",OP_EQ, s);
  926. tor_free(s);
  927. /* Stop collecting stats, add some bytes, and ensure we don't generate
  928. * a history string. */
  929. rep_hist_conn_stats_term();
  930. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  931. s = rep_hist_format_conn_stats(now + 86400);
  932. tt_ptr_op(s, OP_EQ, NULL);
  933. /* Re-start stats, add some bytes, reset stats, and see what history we
  934. * get when observing no bytes at all. */
  935. rep_hist_conn_stats_init(now);
  936. rep_hist_note_or_conn_bytes(1, 30000, 400000, now);
  937. rep_hist_note_or_conn_bytes(1, 30000, 400000, now + 5);
  938. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 10);
  939. rep_hist_note_or_conn_bytes(2, 400000, 30000, now + 15);
  940. rep_hist_reset_conn_stats(now);
  941. s = rep_hist_format_conn_stats(now + 86400);
  942. tt_str_op("conn-bi-direct 2010-08-12 13:27:30 (86400 s) 0,0,0,0\n",OP_EQ, s);
  943. tor_free(s);
  944. /* Continue with testing buffer statistics; we shouldn't collect buffer
  945. * stats without initializing them. */
  946. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  947. s = rep_hist_format_buffer_stats(now + 86400);
  948. tt_ptr_op(s, OP_EQ, NULL);
  949. /* Initialize stats, add statistics for a single circuit, and generate
  950. * the history string. */
  951. rep_hist_buffer_stats_init(now);
  952. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  953. s = rep_hist_format_buffer_stats(now + 86400);
  954. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  955. "cell-processed-cells 20,0,0,0,0,0,0,0,0,0\n"
  956. "cell-queued-cells 2.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  957. "0.00,0.00\n"
  958. "cell-time-in-queue 2,0,0,0,0,0,0,0,0,0\n"
  959. "cell-circuits-per-decile 1\n",OP_EQ, s);
  960. tor_free(s);
  961. /* Add nineteen more circuit statistics to the one that's already in the
  962. * history to see that the math works correctly. */
  963. for (i = 21; i < 30; i++)
  964. rep_hist_add_buffer_stats(2.0, 2.0, i);
  965. for (i = 20; i < 30; i++)
  966. rep_hist_add_buffer_stats(3.5, 3.5, i);
  967. s = rep_hist_format_buffer_stats(now + 86400);
  968. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  969. "cell-processed-cells 29,28,27,26,25,24,23,22,21,20\n"
  970. "cell-queued-cells 2.75,2.75,2.75,2.75,2.75,2.75,2.75,2.75,"
  971. "2.75,2.75\n"
  972. "cell-time-in-queue 3,3,3,3,3,3,3,3,3,3\n"
  973. "cell-circuits-per-decile 2\n",OP_EQ, s);
  974. tor_free(s);
  975. /* Stop collecting stats, add statistics for one circuit, and ensure we
  976. * don't generate a history string. */
  977. rep_hist_buffer_stats_term();
  978. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  979. s = rep_hist_format_buffer_stats(now + 86400);
  980. tt_ptr_op(s, OP_EQ, NULL);
  981. /* Re-start stats, add statistics for one circuit, reset stats, and make
  982. * sure that the history has all zeros. */
  983. rep_hist_buffer_stats_init(now);
  984. rep_hist_add_buffer_stats(2.0, 2.0, 20);
  985. rep_hist_reset_buffer_stats(now);
  986. s = rep_hist_format_buffer_stats(now + 86400);
  987. tt_str_op("cell-stats-end 2010-08-12 13:27:30 (86400 s)\n"
  988. "cell-processed-cells 0,0,0,0,0,0,0,0,0,0\n"
  989. "cell-queued-cells 0.00,0.00,0.00,0.00,0.00,0.00,0.00,0.00,"
  990. "0.00,0.00\n"
  991. "cell-time-in-queue 0,0,0,0,0,0,0,0,0,0\n"
  992. "cell-circuits-per-decile 0\n",OP_EQ, s);
  993. done:
  994. tor_free(s);
  995. }
  996. #define ENT(name) \
  997. { #name, test_ ## name , 0, NULL, NULL }
  998. #define FORK(name) \
  999. { #name, test_ ## name , TT_FORK, NULL, NULL }
  1000. static struct testcase_t test_array[] = {
  1001. ENT(onion_handshake),
  1002. { "bad_onion_handshake", test_bad_onion_handshake, 0, NULL, NULL },
  1003. ENT(onion_queues),
  1004. { "ntor_handshake", test_ntor_handshake, 0, NULL, NULL },
  1005. { "fast_handshake", test_fast_handshake, 0, NULL, NULL },
  1006. FORK(circuit_timeout),
  1007. FORK(rend_fns),
  1008. ENT(geoip),
  1009. FORK(geoip_with_pt),
  1010. FORK(stats),
  1011. END_OF_TESTCASES
  1012. };
  1013. struct testgroup_t testgroups[] = {
  1014. { "", test_array },
  1015. { "accounting/", accounting_tests },
  1016. { "addr/", addr_tests },
  1017. { "address/", address_tests },
  1018. { "buffer/", buffer_tests },
  1019. { "cellfmt/", cell_format_tests },
  1020. { "cellqueue/", cell_queue_tests },
  1021. { "channel/", channel_tests },
  1022. { "channelpadding/", channelpadding_tests },
  1023. { "channeltls/", channeltls_tests },
  1024. { "checkdir/", checkdir_tests },
  1025. { "circuitbuild/", circuitbuild_tests },
  1026. { "circuitlist/", circuitlist_tests },
  1027. { "circuitmux/", circuitmux_tests },
  1028. { "circuituse/", circuituse_tests },
  1029. { "circuitstats/", circuitstats_tests },
  1030. { "compat/libevent/", compat_libevent_tests },
  1031. { "config/", config_tests },
  1032. { "connection/", connection_tests },
  1033. { "conscache/", conscache_tests },
  1034. { "consdiff/", consdiff_tests },
  1035. { "consdiffmgr/", consdiffmgr_tests },
  1036. { "container/", container_tests },
  1037. { "control/", controller_tests },
  1038. { "control/event/", controller_event_tests },
  1039. { "crypto/", crypto_tests },
  1040. { "crypto/openssl/", crypto_openssl_tests },
  1041. { "dir/", dir_tests },
  1042. { "dir_handle_get/", dir_handle_get_tests },
  1043. { "dir/md/", microdesc_tests },
  1044. { "dos/", dos_tests },
  1045. { "entryconn/", entryconn_tests },
  1046. { "entrynodes/", entrynodes_tests },
  1047. { "guardfraction/", guardfraction_tests },
  1048. { "extorport/", extorport_tests },
  1049. { "legacy_hs/", hs_tests },
  1050. { "hs_cache/", hs_cache },
  1051. { "hs_cell/", hs_cell_tests },
  1052. { "hs_common/", hs_common_tests },
  1053. { "hs_config/", hs_config_tests },
  1054. { "hs_control/", hs_control_tests },
  1055. { "hs_descriptor/", hs_descriptor },
  1056. { "hs_ntor/", hs_ntor_tests },
  1057. { "hs_service/", hs_service_tests },
  1058. { "hs_client/", hs_client_tests },
  1059. { "hs_intropoint/", hs_intropoint_tests },
  1060. { "introduce/", introduce_tests },
  1061. { "keypin/", keypin_tests },
  1062. { "link-handshake/", link_handshake_tests },
  1063. { "nodelist/", nodelist_tests },
  1064. { "oom/", oom_tests },
  1065. { "oos/", oos_tests },
  1066. { "options/", options_tests },
  1067. { "policy/" , policy_tests },
  1068. { "procmon/", procmon_tests },
  1069. { "proto/http/", proto_http_tests },
  1070. { "proto/misc/", proto_misc_tests },
  1071. { "protover/", protover_tests },
  1072. { "pt/", pt_tests },
  1073. { "relay/" , relay_tests },
  1074. { "relaycell/", relaycell_tests },
  1075. { "rend_cache/", rend_cache_tests },
  1076. { "replaycache/", replaycache_tests },
  1077. { "router/", router_tests },
  1078. { "routerkeys/", routerkeys_tests },
  1079. { "routerlist/", routerlist_tests },
  1080. { "routerset/" , routerset_tests },
  1081. { "scheduler/", scheduler_tests },
  1082. { "socks/", socks_tests },
  1083. { "shared-random/", sr_tests },
  1084. { "status/" , status_tests },
  1085. { "storagedir/", storagedir_tests },
  1086. { "tortls/", tortls_tests },
  1087. { "util/", util_tests },
  1088. { "util/format/", util_format_tests },
  1089. { "util/logging/", logging_tests },
  1090. { "util/process/", util_process_tests },
  1091. { "util/pubsub/", pubsub_tests },
  1092. { "util/thread/", thread_tests },
  1093. { "util/handle/", handle_tests },
  1094. { "dns/", dns_tests },
  1095. END_OF_GROUPS
  1096. };