bench.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713
  1. /* Copyright (c) 2001-2004, Roger Dingledine.
  2. * Copyright (c) 2004-2006, Roger Dingledine, Nick Mathewson.
  3. * Copyright (c) 2007-2016, The Tor Project, Inc. */
  4. /* See LICENSE for licensing information */
  5. extern const char tor_git_revision[];
  6. /* Ordinarily defined in tor_main.c; this bit is just here to provide one
  7. * since we're not linking to tor_main.c */
  8. const char tor_git_revision[] = "";
  9. /**
  10. * \file bench.c
  11. * \brief Benchmarks for lower level Tor modules.
  12. **/
  13. #include "orconfig.h"
  14. #include "or.h"
  15. #include "onion_tap.h"
  16. #include "relay.h"
  17. #include <openssl/opensslv.h>
  18. #include <openssl/evp.h>
  19. #include <openssl/ec.h>
  20. #include <openssl/ecdh.h>
  21. #include <openssl/obj_mac.h>
  22. #include "config.h"
  23. #include "crypto_curve25519.h"
  24. #include "onion_ntor.h"
  25. #include "crypto_ed25519.h"
  26. #if defined(HAVE_CLOCK_GETTIME) && defined(CLOCK_PROCESS_CPUTIME_ID)
  27. static uint64_t nanostart;
  28. static inline uint64_t
  29. timespec_to_nsec(const struct timespec *ts)
  30. {
  31. return ((uint64_t)ts->tv_sec)*1000000000 + ts->tv_nsec;
  32. }
  33. static void
  34. reset_perftime(void)
  35. {
  36. struct timespec ts;
  37. int r;
  38. r = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
  39. tor_assert(r == 0);
  40. nanostart = timespec_to_nsec(&ts);
  41. }
  42. static uint64_t
  43. perftime(void)
  44. {
  45. struct timespec ts;
  46. int r;
  47. r = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
  48. tor_assert(r == 0);
  49. return timespec_to_nsec(&ts) - nanostart;
  50. }
  51. #else
  52. static struct timeval tv_start = { 0, 0 };
  53. static void
  54. reset_perftime(void)
  55. {
  56. tor_gettimeofday(&tv_start);
  57. }
  58. static uint64_t
  59. perftime(void)
  60. {
  61. struct timeval now, out;
  62. tor_gettimeofday(&now);
  63. timersub(&now, &tv_start, &out);
  64. return ((uint64_t)out.tv_sec)*1000000000 + out.tv_usec*1000;
  65. }
  66. #endif
  67. #define NANOCOUNT(start,end,iters) \
  68. ( ((double)((end)-(start))) / (iters) )
  69. #define MICROCOUNT(start,end,iters) \
  70. ( NANOCOUNT((start), (end), (iters)) / 1000.0 )
  71. /** Run AES performance benchmarks. */
  72. static void
  73. bench_aes(void)
  74. {
  75. int len, i;
  76. char *b1, *b2;
  77. crypto_cipher_t *c;
  78. uint64_t start, end;
  79. const int bytes_per_iter = (1<<24);
  80. reset_perftime();
  81. c = crypto_cipher_new(NULL);
  82. for (len = 1; len <= 8192; len *= 2) {
  83. int iters = bytes_per_iter / len;
  84. b1 = tor_malloc_zero(len);
  85. b2 = tor_malloc_zero(len);
  86. start = perftime();
  87. for (i = 0; i < iters; ++i) {
  88. crypto_cipher_encrypt(c, b1, b2, len);
  89. }
  90. end = perftime();
  91. tor_free(b1);
  92. tor_free(b2);
  93. printf("%d bytes: %.2f nsec per byte\n", len,
  94. NANOCOUNT(start, end, iters*len));
  95. }
  96. crypto_cipher_free(c);
  97. }
  98. static void
  99. bench_onion_TAP(void)
  100. {
  101. const int iters = 1<<9;
  102. int i;
  103. crypto_pk_t *key, *key2;
  104. uint64_t start, end;
  105. char os[TAP_ONIONSKIN_CHALLENGE_LEN];
  106. char or[TAP_ONIONSKIN_REPLY_LEN];
  107. crypto_dh_t *dh_out;
  108. key = crypto_pk_new();
  109. key2 = crypto_pk_new();
  110. if (crypto_pk_generate_key_with_bits(key, 1024) < 0)
  111. goto done;
  112. if (crypto_pk_generate_key_with_bits(key2, 1024) < 0)
  113. goto done;
  114. reset_perftime();
  115. start = perftime();
  116. for (i = 0; i < iters; ++i) {
  117. onion_skin_TAP_create(key, &dh_out, os);
  118. crypto_dh_free(dh_out);
  119. }
  120. end = perftime();
  121. printf("Client-side, part 1: %f usec.\n", NANOCOUNT(start, end, iters)/1e3);
  122. onion_skin_TAP_create(key, &dh_out, os);
  123. start = perftime();
  124. for (i = 0; i < iters; ++i) {
  125. char key_out[CPATH_KEY_MATERIAL_LEN];
  126. onion_skin_TAP_server_handshake(os, key, NULL, or,
  127. key_out, sizeof(key_out));
  128. }
  129. end = perftime();
  130. printf("Server-side, key guessed right: %f usec\n",
  131. NANOCOUNT(start, end, iters)/1e3);
  132. start = perftime();
  133. for (i = 0; i < iters; ++i) {
  134. char key_out[CPATH_KEY_MATERIAL_LEN];
  135. onion_skin_TAP_server_handshake(os, key2, key, or,
  136. key_out, sizeof(key_out));
  137. }
  138. end = perftime();
  139. printf("Server-side, key guessed wrong: %f usec.\n",
  140. NANOCOUNT(start, end, iters)/1e3);
  141. start = perftime();
  142. for (i = 0; i < iters; ++i) {
  143. crypto_dh_t *dh;
  144. char key_out[CPATH_KEY_MATERIAL_LEN];
  145. int s;
  146. dh = crypto_dh_dup(dh_out);
  147. s = onion_skin_TAP_client_handshake(dh, or, key_out, sizeof(key_out),
  148. NULL);
  149. crypto_dh_free(dh);
  150. tor_assert(s == 0);
  151. }
  152. end = perftime();
  153. printf("Client-side, part 2: %f usec.\n",
  154. NANOCOUNT(start, end, iters)/1e3);
  155. done:
  156. crypto_pk_free(key);
  157. crypto_pk_free(key2);
  158. }
  159. static void
  160. bench_onion_ntor_impl(void)
  161. {
  162. const int iters = 1<<10;
  163. int i;
  164. curve25519_keypair_t keypair1, keypair2;
  165. uint64_t start, end;
  166. uint8_t os[NTOR_ONIONSKIN_LEN];
  167. uint8_t or[NTOR_REPLY_LEN];
  168. ntor_handshake_state_t *state = NULL;
  169. uint8_t nodeid[DIGEST_LEN];
  170. di_digest256_map_t *keymap = NULL;
  171. curve25519_secret_key_generate(&keypair1.seckey, 0);
  172. curve25519_public_key_generate(&keypair1.pubkey, &keypair1.seckey);
  173. curve25519_secret_key_generate(&keypair2.seckey, 0);
  174. curve25519_public_key_generate(&keypair2.pubkey, &keypair2.seckey);
  175. dimap_add_entry(&keymap, keypair1.pubkey.public_key, &keypair1);
  176. dimap_add_entry(&keymap, keypair2.pubkey.public_key, &keypair2);
  177. reset_perftime();
  178. start = perftime();
  179. for (i = 0; i < iters; ++i) {
  180. onion_skin_ntor_create(nodeid, &keypair1.pubkey, &state, os);
  181. ntor_handshake_state_free(state);
  182. state = NULL;
  183. }
  184. end = perftime();
  185. printf("Client-side, part 1: %f usec.\n", NANOCOUNT(start, end, iters)/1e3);
  186. state = NULL;
  187. onion_skin_ntor_create(nodeid, &keypair1.pubkey, &state, os);
  188. start = perftime();
  189. for (i = 0; i < iters; ++i) {
  190. uint8_t key_out[CPATH_KEY_MATERIAL_LEN];
  191. onion_skin_ntor_server_handshake(os, keymap, NULL, nodeid, or,
  192. key_out, sizeof(key_out));
  193. }
  194. end = perftime();
  195. printf("Server-side: %f usec\n",
  196. NANOCOUNT(start, end, iters)/1e3);
  197. start = perftime();
  198. for (i = 0; i < iters; ++i) {
  199. uint8_t key_out[CPATH_KEY_MATERIAL_LEN];
  200. int s;
  201. s = onion_skin_ntor_client_handshake(state, or, key_out, sizeof(key_out),
  202. NULL);
  203. tor_assert(s == 0);
  204. }
  205. end = perftime();
  206. printf("Client-side, part 2: %f usec.\n",
  207. NANOCOUNT(start, end, iters)/1e3);
  208. ntor_handshake_state_free(state);
  209. dimap_free(keymap, NULL);
  210. }
  211. static void
  212. bench_onion_ntor(void)
  213. {
  214. int ed;
  215. for (ed = 0; ed <= 1; ++ed) {
  216. printf("Ed25519-based basepoint multiply = %s.\n",
  217. (ed == 0) ? "disabled" : "enabled");
  218. curve25519_set_impl_params(ed);
  219. bench_onion_ntor_impl();
  220. }
  221. }
  222. static void
  223. bench_ed25519_impl(void)
  224. {
  225. uint64_t start, end;
  226. const int iters = 1<<12;
  227. int i;
  228. const uint8_t msg[] = "but leaving, could not tell what they had heard";
  229. ed25519_signature_t sig;
  230. ed25519_keypair_t kp;
  231. curve25519_keypair_t curve_kp;
  232. ed25519_public_key_t pubkey_tmp;
  233. ed25519_secret_key_generate(&kp.seckey, 0);
  234. start = perftime();
  235. for (i = 0; i < iters; ++i) {
  236. ed25519_public_key_generate(&kp.pubkey, &kp.seckey);
  237. }
  238. end = perftime();
  239. printf("Generate public key: %.2f usec\n",
  240. MICROCOUNT(start, end, iters));
  241. start = perftime();
  242. for (i = 0; i < iters; ++i) {
  243. ed25519_sign(&sig, msg, sizeof(msg), &kp);
  244. }
  245. end = perftime();
  246. printf("Sign a short message: %.2f usec\n",
  247. MICROCOUNT(start, end, iters));
  248. start = perftime();
  249. for (i = 0; i < iters; ++i) {
  250. ed25519_checksig(&sig, msg, sizeof(msg), &kp.pubkey);
  251. }
  252. end = perftime();
  253. printf("Verify signature: %.2f usec\n",
  254. MICROCOUNT(start, end, iters));
  255. curve25519_keypair_generate(&curve_kp, 0);
  256. start = perftime();
  257. for (i = 0; i < iters; ++i) {
  258. ed25519_public_key_from_curve25519_public_key(&pubkey_tmp,
  259. &curve_kp.pubkey, 1);
  260. }
  261. end = perftime();
  262. printf("Convert public point from curve25519: %.2f usec\n",
  263. MICROCOUNT(start, end, iters));
  264. curve25519_keypair_generate(&curve_kp, 0);
  265. start = perftime();
  266. for (i = 0; i < iters; ++i) {
  267. ed25519_public_blind(&pubkey_tmp, &kp.pubkey, msg);
  268. }
  269. end = perftime();
  270. printf("Blind a public key: %.2f usec\n",
  271. MICROCOUNT(start, end, iters));
  272. }
  273. static void
  274. bench_ed25519(void)
  275. {
  276. int donna;
  277. for (donna = 0; donna <= 1; ++donna) {
  278. printf("Ed25519-donna = %s.\n",
  279. (donna == 0) ? "disabled" : "enabled");
  280. ed25519_set_impl_params(donna);
  281. bench_ed25519_impl();
  282. }
  283. }
  284. static void
  285. bench_cell_aes(void)
  286. {
  287. uint64_t start, end;
  288. const int len = 509;
  289. const int iters = (1<<16);
  290. const int max_misalign = 15;
  291. char *b = tor_malloc(len+max_misalign);
  292. crypto_cipher_t *c;
  293. int i, misalign;
  294. c = crypto_cipher_new(NULL);
  295. reset_perftime();
  296. for (misalign = 0; misalign <= max_misalign; ++misalign) {
  297. start = perftime();
  298. for (i = 0; i < iters; ++i) {
  299. crypto_cipher_crypt_inplace(c, b+misalign, len);
  300. }
  301. end = perftime();
  302. printf("%d bytes, misaligned by %d: %.2f nsec per byte\n", len, misalign,
  303. NANOCOUNT(start, end, iters*len));
  304. }
  305. crypto_cipher_free(c);
  306. tor_free(b);
  307. }
  308. /** Run digestmap_t performance benchmarks. */
  309. static void
  310. bench_dmap(void)
  311. {
  312. smartlist_t *sl = smartlist_new();
  313. smartlist_t *sl2 = smartlist_new();
  314. uint64_t start, end, pt2, pt3, pt4;
  315. int iters = 8192;
  316. const int elts = 4000;
  317. const int fpostests = 100000;
  318. char d[20];
  319. int i,n=0, fp = 0;
  320. digestmap_t *dm = digestmap_new();
  321. digestset_t *ds = digestset_new(elts);
  322. for (i = 0; i < elts; ++i) {
  323. crypto_rand(d, 20);
  324. smartlist_add(sl, tor_memdup(d, 20));
  325. }
  326. for (i = 0; i < elts; ++i) {
  327. crypto_rand(d, 20);
  328. smartlist_add(sl2, tor_memdup(d, 20));
  329. }
  330. printf("nbits=%d\n", ds->mask+1);
  331. reset_perftime();
  332. start = perftime();
  333. for (i = 0; i < iters; ++i) {
  334. SMARTLIST_FOREACH(sl, const char *, cp, digestmap_set(dm, cp, (void*)1));
  335. }
  336. pt2 = perftime();
  337. printf("digestmap_set: %.2f ns per element\n",
  338. NANOCOUNT(start, pt2, iters*elts));
  339. for (i = 0; i < iters; ++i) {
  340. SMARTLIST_FOREACH(sl, const char *, cp, digestmap_get(dm, cp));
  341. SMARTLIST_FOREACH(sl2, const char *, cp, digestmap_get(dm, cp));
  342. }
  343. pt3 = perftime();
  344. printf("digestmap_get: %.2f ns per element\n",
  345. NANOCOUNT(pt2, pt3, iters*elts*2));
  346. for (i = 0; i < iters; ++i) {
  347. SMARTLIST_FOREACH(sl, const char *, cp, digestset_add(ds, cp));
  348. }
  349. pt4 = perftime();
  350. printf("digestset_add: %.2f ns per element\n",
  351. NANOCOUNT(pt3, pt4, iters*elts));
  352. for (i = 0; i < iters; ++i) {
  353. SMARTLIST_FOREACH(sl, const char *, cp, n += digestset_contains(ds, cp));
  354. SMARTLIST_FOREACH(sl2, const char *, cp, n += digestset_contains(ds, cp));
  355. }
  356. end = perftime();
  357. printf("digestset_contains: %.2f ns per element.\n",
  358. NANOCOUNT(pt4, end, iters*elts*2));
  359. /* We need to use this, or else the whole loop gets optimized out. */
  360. printf("Hits == %d\n", n);
  361. for (i = 0; i < fpostests; ++i) {
  362. crypto_rand(d, 20);
  363. if (digestset_contains(ds, d)) ++fp;
  364. }
  365. printf("False positive rate on digestset: %.2f%%\n",
  366. (fp/(double)fpostests)*100);
  367. digestmap_free(dm, NULL);
  368. digestset_free(ds);
  369. SMARTLIST_FOREACH(sl, char *, cp, tor_free(cp));
  370. SMARTLIST_FOREACH(sl2, char *, cp, tor_free(cp));
  371. smartlist_free(sl);
  372. smartlist_free(sl2);
  373. }
  374. static void
  375. bench_siphash(void)
  376. {
  377. char buf[128];
  378. int lens[] = { 7, 8, 15, 16, 20, 32, 111, 128, -1 };
  379. int i, j;
  380. uint64_t start, end;
  381. const int N = 300000;
  382. crypto_rand(buf, sizeof(buf));
  383. for (i = 0; lens[i] > 0; ++i) {
  384. reset_perftime();
  385. start = perftime();
  386. for (j = 0; j < N; ++j) {
  387. siphash24g(buf, lens[i]);
  388. }
  389. end = perftime();
  390. printf("siphash24g(%d): %.2f ns per call\n",
  391. lens[i], NANOCOUNT(start,end,N));
  392. }
  393. }
  394. static void
  395. bench_digest(void)
  396. {
  397. char buf[8192];
  398. char out[DIGEST512_LEN];
  399. const int lens[] = { 1, 16, 32, 64, 128, 512, 1024, 2048, -1 };
  400. const int N = 300000;
  401. uint64_t start, end;
  402. crypto_rand(buf, sizeof(buf));
  403. for (int alg = 0; alg < N_DIGEST_ALGORITHMS; alg++) {
  404. for (int i = 0; lens[i] > 0; ++i) {
  405. reset_perftime();
  406. start = perftime();
  407. for (int j = 0; j < N; ++j) {
  408. switch (alg) {
  409. case DIGEST_SHA1:
  410. crypto_digest(out, buf, lens[i]);
  411. break;
  412. case DIGEST_SHA256:
  413. case DIGEST_SHA3_256:
  414. crypto_digest256(out, buf, lens[i], alg);
  415. break;
  416. case DIGEST_SHA512:
  417. case DIGEST_SHA3_512:
  418. crypto_digest512(out, buf, lens[i], alg);
  419. break;
  420. default:
  421. tor_assert(0);
  422. }
  423. }
  424. end = perftime();
  425. printf("%s(%d): %.2f ns per call\n",
  426. crypto_digest_algorithm_get_name(alg),
  427. lens[i], NANOCOUNT(start,end,N));
  428. }
  429. }
  430. }
  431. static void
  432. bench_cell_ops(void)
  433. {
  434. const int iters = 1<<16;
  435. int i;
  436. /* benchmarks for cell ops at relay. */
  437. or_circuit_t *or_circ = tor_malloc_zero(sizeof(or_circuit_t));
  438. cell_t *cell = tor_malloc(sizeof(cell_t));
  439. int outbound;
  440. uint64_t start, end;
  441. crypto_rand((char*)cell->payload, sizeof(cell->payload));
  442. /* Mock-up or_circuit_t */
  443. or_circ->base_.magic = OR_CIRCUIT_MAGIC;
  444. or_circ->base_.purpose = CIRCUIT_PURPOSE_OR;
  445. /* Initialize crypto */
  446. or_circ->p_crypto = crypto_cipher_new(NULL);
  447. or_circ->n_crypto = crypto_cipher_new(NULL);
  448. or_circ->p_digest = crypto_digest_new();
  449. or_circ->n_digest = crypto_digest_new();
  450. reset_perftime();
  451. for (outbound = 0; outbound <= 1; ++outbound) {
  452. cell_direction_t d = outbound ? CELL_DIRECTION_OUT : CELL_DIRECTION_IN;
  453. start = perftime();
  454. for (i = 0; i < iters; ++i) {
  455. char recognized = 0;
  456. crypt_path_t *layer_hint = NULL;
  457. relay_crypt(TO_CIRCUIT(or_circ), cell, d, &layer_hint, &recognized);
  458. }
  459. end = perftime();
  460. printf("%sbound cells: %.2f ns per cell. (%.2f ns per byte of payload)\n",
  461. outbound?"Out":" In",
  462. NANOCOUNT(start,end,iters),
  463. NANOCOUNT(start,end,iters*CELL_PAYLOAD_SIZE));
  464. }
  465. crypto_digest_free(or_circ->p_digest);
  466. crypto_digest_free(or_circ->n_digest);
  467. crypto_cipher_free(or_circ->p_crypto);
  468. crypto_cipher_free(or_circ->n_crypto);
  469. tor_free(or_circ);
  470. tor_free(cell);
  471. }
  472. static void
  473. bench_dh(void)
  474. {
  475. const int iters = 1<<10;
  476. int i;
  477. uint64_t start, end;
  478. reset_perftime();
  479. start = perftime();
  480. for (i = 0; i < iters; ++i) {
  481. char dh_pubkey_a[DH_BYTES], dh_pubkey_b[DH_BYTES];
  482. char secret_a[DH_BYTES], secret_b[DH_BYTES];
  483. ssize_t slen_a, slen_b;
  484. crypto_dh_t *dh_a = crypto_dh_new(DH_TYPE_TLS);
  485. crypto_dh_t *dh_b = crypto_dh_new(DH_TYPE_TLS);
  486. crypto_dh_generate_public(dh_a);
  487. crypto_dh_generate_public(dh_b);
  488. crypto_dh_get_public(dh_a, dh_pubkey_a, sizeof(dh_pubkey_a));
  489. crypto_dh_get_public(dh_b, dh_pubkey_b, sizeof(dh_pubkey_b));
  490. slen_a = crypto_dh_compute_secret(LOG_NOTICE,
  491. dh_a, dh_pubkey_b, sizeof(dh_pubkey_b),
  492. secret_a, sizeof(secret_a));
  493. slen_b = crypto_dh_compute_secret(LOG_NOTICE,
  494. dh_b, dh_pubkey_a, sizeof(dh_pubkey_a),
  495. secret_b, sizeof(secret_b));
  496. tor_assert(slen_a == slen_b);
  497. tor_assert(!memcmp(secret_a, secret_b, slen_a));
  498. crypto_dh_free(dh_a);
  499. crypto_dh_free(dh_b);
  500. }
  501. end = perftime();
  502. printf("Complete DH handshakes (1024 bit, public and private ops):\n"
  503. " %f millisec each.\n", NANOCOUNT(start, end, iters)/1e6);
  504. }
  505. static void
  506. bench_ecdh_impl(int nid, const char *name)
  507. {
  508. const int iters = 1<<10;
  509. int i;
  510. uint64_t start, end;
  511. reset_perftime();
  512. start = perftime();
  513. for (i = 0; i < iters; ++i) {
  514. char secret_a[DH_BYTES], secret_b[DH_BYTES];
  515. ssize_t slen_a, slen_b;
  516. EC_KEY *dh_a = EC_KEY_new_by_curve_name(nid);
  517. EC_KEY *dh_b = EC_KEY_new_by_curve_name(nid);
  518. if (!dh_a || !dh_b) {
  519. puts("Skipping. (No implementation?)");
  520. return;
  521. }
  522. EC_KEY_generate_key(dh_a);
  523. EC_KEY_generate_key(dh_b);
  524. slen_a = ECDH_compute_key(secret_a, DH_BYTES,
  525. EC_KEY_get0_public_key(dh_b), dh_a,
  526. NULL);
  527. slen_b = ECDH_compute_key(secret_b, DH_BYTES,
  528. EC_KEY_get0_public_key(dh_a), dh_b,
  529. NULL);
  530. tor_assert(slen_a == slen_b);
  531. tor_assert(!memcmp(secret_a, secret_b, slen_a));
  532. EC_KEY_free(dh_a);
  533. EC_KEY_free(dh_b);
  534. }
  535. end = perftime();
  536. printf("Complete ECDH %s handshakes (2 public and 2 private ops):\n"
  537. " %f millisec each.\n", name, NANOCOUNT(start, end, iters)/1e6);
  538. }
  539. static void
  540. bench_ecdh_p256(void)
  541. {
  542. bench_ecdh_impl(NID_X9_62_prime256v1, "P-256");
  543. }
  544. static void
  545. bench_ecdh_p224(void)
  546. {
  547. bench_ecdh_impl(NID_secp224r1, "P-224");
  548. }
  549. typedef void (*bench_fn)(void);
  550. typedef struct benchmark_t {
  551. const char *name;
  552. bench_fn fn;
  553. int enabled;
  554. } benchmark_t;
  555. #define ENT(s) { #s , bench_##s, 0 }
  556. static struct benchmark_t benchmarks[] = {
  557. ENT(dmap),
  558. ENT(siphash),
  559. ENT(digest),
  560. ENT(aes),
  561. ENT(onion_TAP),
  562. ENT(onion_ntor),
  563. ENT(ed25519),
  564. ENT(cell_aes),
  565. ENT(cell_ops),
  566. ENT(dh),
  567. ENT(ecdh_p256),
  568. ENT(ecdh_p224),
  569. {NULL,NULL,0}
  570. };
  571. static benchmark_t *
  572. find_benchmark(const char *name)
  573. {
  574. benchmark_t *b;
  575. for (b = benchmarks; b->name; ++b) {
  576. if (!strcmp(name, b->name)) {
  577. return b;
  578. }
  579. }
  580. return NULL;
  581. }
  582. /** Main entry point for benchmark code: parse the command line, and run
  583. * some benchmarks. */
  584. int
  585. main(int argc, const char **argv)
  586. {
  587. int i;
  588. int list=0, n_enabled=0;
  589. benchmark_t *b;
  590. char *errmsg;
  591. or_options_t *options;
  592. tor_threads_init();
  593. for (i = 1; i < argc; ++i) {
  594. if (!strcmp(argv[i], "--list")) {
  595. list = 1;
  596. } else {
  597. benchmark_t *b = find_benchmark(argv[i]);
  598. ++n_enabled;
  599. if (b) {
  600. b->enabled = 1;
  601. } else {
  602. printf("No such benchmark as %s\n", argv[i]);
  603. }
  604. }
  605. }
  606. reset_perftime();
  607. if (crypto_seed_rng() < 0) {
  608. printf("Couldn't seed RNG; exiting.\n");
  609. return 1;
  610. }
  611. crypto_init_siphash_key();
  612. options = options_new();
  613. init_logging(1);
  614. options->command = CMD_RUN_UNITTESTS;
  615. options->DataDirectory = tor_strdup("");
  616. options_init(options);
  617. if (set_options(options, &errmsg) < 0) {
  618. printf("Failed to set initial options: %s\n", errmsg);
  619. tor_free(errmsg);
  620. return 1;
  621. }
  622. for (b = benchmarks; b->name; ++b) {
  623. if (b->enabled || n_enabled == 0) {
  624. printf("===== %s =====\n", b->name);
  625. if (!list)
  626. b->fn();
  627. }
  628. }
  629. return 0;
  630. }