test.c 44 KB

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