Mercurial > dropbear

comparison libtomcrypt/testprof/x86_prof.c @ 285:1b9e69c058d2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
propagate from branch 'au.asn.ucc.matt.ltc.dropbear' (head 20dccfc09627970a312d77fb41dc2970b62689c3) to branch 'au.asn.ucc.matt.dropbear' (head fdf4a7a3b97ae5046139915de7e40399cceb2c01)
author Matt Johnston <matt@ucc.asn.au>
date Wed, 08 Mar 2006 13:23:58 +0000
parents
children 0cbe8f6dbf9e
comparison
equal deleted inserted replaced
281:997e6f7dc01e 285:1b9e69c058d2
1 #include <tomcrypt_test.h>
2
3 prng_state yarrow_prng;
4
5 struct list results[100];
6 int no_results;
7 int sorter(const void *a, const void *b)
8 {
9 const struct list *A, *B;
10 A = a;
11 B = b;
12 if (A->avg < B->avg) return -1;
13 if (A->avg > B->avg) return 1;
14 return 0;
15 }
16
17 void tally_results(int type)
18 {
19 int x;
20
21 // qsort the results
22 qsort(results, no_results, sizeof(struct list), &sorter);
23
24 fprintf(stderr, "\n");
25 if (type == 0) {
26 for (x = 0; x < no_results; x++) {
27 fprintf(stderr, "%-20s: Schedule at %6lu\n", cipher_descriptor[results[x].id].name, (unsigned long)results[x].spd1);
28 }
29 } else if (type == 1) {
30 for (x = 0; x < no_results; x++) {
31 printf
32 ("%-20s[%3d]: Encrypt at %5lu, Decrypt at %5lu\n", cipher_descriptor[results[x].id].name, cipher_descriptor[results[x].id].ID, results[x].spd1, results[x].spd2);
33 }
34 } else {
35 for (x = 0; x < no_results; x++) {
36 printf
37 ("%-20s: Process at %5lu\n", hash_descriptor[results[x].id].name, results[x].spd1 / 1000);
38 }
39 }
40 }
41
42 /* RDTSC from Scott Duplichan */
43 ulong64 rdtsc (void)
44 {
45 #if defined __GNUC__ && !defined(LTC_NO_ASM)
46 #ifdef INTEL_CC
47 ulong64 a;
48 asm ( " rdtsc ":"=A"(a));
49 return a;
50 #elif defined(__i386__) || defined(__x86_64__)
51 ulong64 a;
52 asm __volatile__ ("rdtsc\nmovl %%eax,(%0)\nmovl %%edx,4(%0)\n"::"r"(&a):"%eax","%edx");
53 return a;
54 #elif defined(__ia64__) /* gcc-IA64 version */
55 unsigned long result;
56 __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
57 while (__builtin_expect ((int) result == -1, 0))
58 __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
59 return result;
60 #else
61 return XCLOCK();
62 #endif
63
64 // Microsoft and Intel Windows compilers
65 #elif defined _M_IX86 && !defined(LTC_NO_ASM)
66 __asm rdtsc
67 #elif defined _M_AMD64 && !defined(LTC_NO_ASM)
68 return __rdtsc ();
69 #elif defined _M_IA64 && !defined(LTC_NO_ASM)
70 #if defined __INTEL_COMPILER
71 #include <ia64intrin.h>
72 #endif
73 return __getReg (3116);
74 #else
75 return XCLOCK();
76 #endif
77 }
78
79 static ulong64 timer, skew = 0;
80
81 void t_start(void)
82 {
83 timer = rdtsc();
84 }
85
86 ulong64 t_read(void)
87 {
88 return rdtsc() - timer;
89 }
90
91 void init_timer(void)
92 {
93 ulong64 c1, c2, t1, t2, t3;
94 unsigned long y1;
95
96 c1 = c2 = (ulong64)-1;
97 for (y1 = 0; y1 < TIMES*100; y1++) {
98 t_start();
99 t1 = t_read();
100 t3 = t_read();
101 t2 = (t_read() - t1)>>1;
102
103 c1 = (t1 > c1) ? t1 : c1;
104 c2 = (t2 > c2) ? t2 : c2;
105 }
106 skew = c2 - c1;
107 fprintf(stderr, "Clock Skew: %lu\n", (unsigned long)skew);
108 }
109
110 void reg_algs(void)
111 {
112 int err;
113 #ifdef RIJNDAEL
114 register_cipher (&aes_desc);
115 #endif
116 #ifdef BLOWFISH
117 register_cipher (&blowfish_desc);
118 #endif
119 #ifdef XTEA
120 register_cipher (&xtea_desc);
121 #endif
122 #ifdef RC5
123 register_cipher (&rc5_desc);
124 #endif
125 #ifdef RC6
126 register_cipher (&rc6_desc);
127 #endif
128 #ifdef SAFERP
129 register_cipher (&saferp_desc);
130 #endif
131 #ifdef TWOFISH
132 register_cipher (&twofish_desc);
133 #endif
134 #ifdef SAFER
135 register_cipher (&safer_k64_desc);
136 register_cipher (&safer_sk64_desc);
137 register_cipher (&safer_k128_desc);
138 register_cipher (&safer_sk128_desc);
139 #endif
140 #ifdef RC2
141 register_cipher (&rc2_desc);
142 #endif
143 #ifdef DES
144 register_cipher (&des_desc);
145 register_cipher (&des3_desc);
146 #endif
147 #ifdef CAST5
148 register_cipher (&cast5_desc);
149 #endif
150 #ifdef NOEKEON
151 register_cipher (&noekeon_desc);
152 #endif
153 #ifdef SKIPJACK
154 register_cipher (&skipjack_desc);
155 #endif
156 #ifdef KHAZAD
157 register_cipher (&khazad_desc);
158 #endif
159 #ifdef ANUBIS
160 register_cipher (&anubis_desc);
161 #endif
162
163 #ifdef TIGER
164 register_hash (&tiger_desc);
165 #endif
166 #ifdef MD2
167 register_hash (&md2_desc);
168 #endif
169 #ifdef MD4
170 register_hash (&md4_desc);
171 #endif
172 #ifdef MD5
173 register_hash (&md5_desc);
174 #endif
175 #ifdef SHA1
176 register_hash (&sha1_desc);
177 #endif
178 #ifdef SHA224
179 register_hash (&sha224_desc);
180 #endif
181 #ifdef SHA256
182 register_hash (&sha256_desc);
183 #endif
184 #ifdef SHA384
185 register_hash (&sha384_desc);
186 #endif
187 #ifdef SHA512
188 register_hash (&sha512_desc);
189 #endif
190 #ifdef RIPEMD128
191 register_hash (&rmd128_desc);
192 #endif
193 #ifdef RIPEMD160
194 register_hash (&rmd160_desc);
195 #endif
196 #ifdef WHIRLPOOL
197 register_hash (&whirlpool_desc);
198 #endif
199 #ifdef CHC_HASH
200 register_hash(&chc_desc);
201 if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) {
202 fprintf(stderr, "chc_register error: %s\n", error_to_string(err));
203 exit(EXIT_FAILURE);
204 }
205 #endif
206
207
208 #ifndef YARROW
209 #error This demo requires Yarrow.
210 #endif
211 register_prng(&yarrow_desc);
212 #ifdef FORTUNA
213 register_prng(&fortuna_desc);
214 #endif
215 #ifdef RC4
216 register_prng(&rc4_desc);
217 #endif
218 #ifdef SOBER128
219 register_prng(&sober128_desc);
220 #endif
221
222 rng_make_prng(128, find_prng("yarrow"), &yarrow_prng, NULL);
223 }
224
225 int time_keysched(void)
226 {
227 unsigned long x, y1;
228 ulong64 t1, c1;
229 symmetric_key skey;
230 int kl;
231 int (*func) (const unsigned char *, int , int , symmetric_key *);
232 unsigned char key[MAXBLOCKSIZE];
233
234 fprintf(stderr, "\n\nKey Schedule Time Trials for the Symmetric Ciphers:\n(Times are cycles per key)\n");
235 no_results = 0;
236 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
237 #define DO1(k) func(k, kl, 0, &skey);
238
239 func = cipher_descriptor[x].setup;
240 kl = cipher_descriptor[x].min_key_length;
241 c1 = (ulong64)-1;
242 for (y1 = 0; y1 < KTIMES; y1++) {
243 yarrow_read(key, kl, &yarrow_prng);
244 t_start();
245 DO1(key);
246 t1 = t_read();
247 c1 = (t1 > c1) ? c1 : t1;
248 }
249 t1 = c1 - skew;
250 results[no_results].spd1 = results[no_results].avg = t1;
251 results[no_results++].id = x;
252 fprintf(stderr, "."); fflush(stdout);
253
254 #undef DO1
255 }
256 tally_results(0);
257
258 return 0;
259 }
260
261 int time_cipher(void)
262 {
263 unsigned long x, y1;
264 ulong64 t1, t2, c1, c2, a1, a2;
265 symmetric_ECB ecb;
266 unsigned char key[MAXBLOCKSIZE], pt[4096];
267 int err;
268
269 fprintf(stderr, "\n\nECB Time Trials for the Symmetric Ciphers:\n");
270 no_results = 0;
271 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
272 ecb_start(x, key, cipher_descriptor[x].min_key_length, 0, &ecb);
273
274 /* sanity check on cipher */
275 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
276 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
277 exit(EXIT_FAILURE);
278 }
279
280 #define DO1 ecb_encrypt(pt, pt, sizeof(pt), &ecb);
281 #define DO2 DO1 DO1
282
283 c1 = c2 = (ulong64)-1;
284 for (y1 = 0; y1 < 100; y1++) {
285 t_start();
286 DO1;
287 t1 = t_read();
288 DO2;
289 t2 = t_read();
290 t2 -= t1;
291
292 c1 = (t1 > c1 ? c1 : t1);
293 c2 = (t2 > c2 ? c2 : t2);
294 }
295 a1 = c2 - c1 - skew;
296
297 #undef DO1
298 #undef DO2
299 #define DO1 ecb_decrypt(pt, pt, sizeof(pt), &ecb);
300 #define DO2 DO1 DO1
301
302 c1 = c2 = (ulong64)-1;
303 for (y1 = 0; y1 < 100; y1++) {
304 t_start();
305 DO1;
306 t1 = t_read();
307 DO2;
308 t2 = t_read();
309 t2 -= t1;
310
311 c1 = (t1 > c1 ? c1 : t1);
312 c2 = (t2 > c2 ? c2 : t2);
313 }
314 a2 = c2 - c1 - skew;
315
316 results[no_results].id = x;
317 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
318 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
319 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
320 ++no_results;
321 fprintf(stderr, "."); fflush(stdout);
322
323 #undef DO2
324 #undef DO1
325 }
326 tally_results(1);
327
328 return 0;
329 }
330
331 #ifdef CBC
332 int time_cipher2(void)
333 {
334 unsigned long x, y1;
335 ulong64 t1, t2, c1, c2, a1, a2;
336 symmetric_CBC cbc;
337 unsigned char key[MAXBLOCKSIZE], pt[4096];
338 int err;
339
340 fprintf(stderr, "\n\nCBC Time Trials for the Symmetric Ciphers:\n");
341 no_results = 0;
342 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
343 cbc_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, &cbc);
344
345 /* sanity check on cipher */
346 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
347 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
348 exit(EXIT_FAILURE);
349 }
350
351 #define DO1 cbc_encrypt(pt, pt, sizeof(pt), &cbc);
352 #define DO2 DO1 DO1
353
354 c1 = c2 = (ulong64)-1;
355 for (y1 = 0; y1 < 100; y1++) {
356 t_start();
357 DO1;
358 t1 = t_read();
359 DO2;
360 t2 = t_read();
361 t2 -= t1;
362
363 c1 = (t1 > c1 ? c1 : t1);
364 c2 = (t2 > c2 ? c2 : t2);
365 }
366 a1 = c2 - c1 - skew;
367
368 #undef DO1
369 #undef DO2
370 #define DO1 cbc_decrypt(pt, pt, sizeof(pt), &cbc);
371 #define DO2 DO1 DO1
372
373 c1 = c2 = (ulong64)-1;
374 for (y1 = 0; y1 < 100; y1++) {
375 t_start();
376 DO1;
377 t1 = t_read();
378 DO2;
379 t2 = t_read();
380 t2 -= t1;
381
382 c1 = (t1 > c1 ? c1 : t1);
383 c2 = (t2 > c2 ? c2 : t2);
384 }
385 a2 = c2 - c1 - skew;
386
387 results[no_results].id = x;
388 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
389 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
390 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
391 ++no_results;
392 fprintf(stderr, "."); fflush(stdout);
393
394 #undef DO2
395 #undef DO1
396 }
397 tally_results(1);
398
399 return 0;
400 }
401 #else
402 int time_cipher2(void) { fprintf(stderr, "NO CBC\n"); return 0; }
403 #endif
404
405 #ifdef CTR
406 int time_cipher3(void)
407 {
408 unsigned long x, y1;
409 ulong64 t1, t2, c1, c2, a1, a2;
410 symmetric_CTR ctr;
411 unsigned char key[MAXBLOCKSIZE], pt[4096];
412 int err;
413
414 fprintf(stderr, "\n\nCTR Time Trials for the Symmetric Ciphers:\n");
415 no_results = 0;
416 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
417 ctr_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, CTR_COUNTER_LITTLE_ENDIAN, &ctr);
418
419 /* sanity check on cipher */
420 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
421 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
422 exit(EXIT_FAILURE);
423 }
424
425 #define DO1 ctr_encrypt(pt, pt, sizeof(pt), &ctr);
426 #define DO2 DO1 DO1
427
428 c1 = c2 = (ulong64)-1;
429 for (y1 = 0; y1 < 100; y1++) {
430 t_start();
431 DO1;
432 t1 = t_read();
433 DO2;
434 t2 = t_read();
435 t2 -= t1;
436
437 c1 = (t1 > c1 ? c1 : t1);
438 c2 = (t2 > c2 ? c2 : t2);
439 }
440 a1 = c2 - c1 - skew;
441
442 #undef DO1
443 #undef DO2
444 #define DO1 ctr_decrypt(pt, pt, sizeof(pt), &ctr);
445 #define DO2 DO1 DO1
446
447 c1 = c2 = (ulong64)-1;
448 for (y1 = 0; y1 < 100; y1++) {
449 t_start();
450 DO1;
451 t1 = t_read();
452 DO2;
453 t2 = t_read();
454 t2 -= t1;
455
456 c1 = (t1 > c1 ? c1 : t1);
457 c2 = (t2 > c2 ? c2 : t2);
458 }
459 a2 = c2 - c1 - skew;
460
461 results[no_results].id = x;
462 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
463 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
464 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
465 ++no_results;
466 fprintf(stderr, "."); fflush(stdout);
467
468 #undef DO2
469 #undef DO1
470 }
471 tally_results(1);
472
473 return 0;
474 }
475 #else
476 int time_cipher3(void) { fprintf(stderr, "NO CTR\n"); return 0; }
477 #endif
478
479 int time_hash(void)
480 {
481 unsigned long x, y1, len;
482 ulong64 t1, t2, c1, c2;
483 hash_state md;
484 int (*func)(hash_state *, const unsigned char *, unsigned long), err;
485 unsigned char pt[MAXBLOCKSIZE];
486
487
488 fprintf(stderr, "\n\nHASH Time Trials for:\n");
489 no_results = 0;
490 for (x = 0; hash_descriptor[x].name != NULL; x++) {
491
492 /* sanity check on hash */
493 if ((err = hash_descriptor[x].test()) != CRYPT_OK) {
494 fprintf(stderr, "\n\nERROR: Hash %s failed self-test %s\n", hash_descriptor[x].name, error_to_string(err));
495 exit(EXIT_FAILURE);
496 }
497
498 hash_descriptor[x].init(&md);
499
500 #define DO1 func(&md,pt,len);
501 #define DO2 DO1 DO1
502
503 func = hash_descriptor[x].process;
504 len = hash_descriptor[x].blocksize;
505
506 c1 = c2 = (ulong64)-1;
507 for (y1 = 0; y1 < TIMES; y1++) {
508 t_start();
509 DO1;
510 t1 = t_read();
511 DO2;
512 t2 = t_read() - t1;
513 c1 = (t1 > c1) ? c1 : t1;
514 c2 = (t2 > c2) ? c2 : t2;
515 }
516 t1 = c2 - c1 - skew;
517 t1 = ((t1 * CONST64(1000))) / ((ulong64)hash_descriptor[x].blocksize);
518 results[no_results].id = x;
519 results[no_results].spd1 = results[no_results].avg = t1;
520 ++no_results;
521 fprintf(stderr, "."); fflush(stdout);
522 #undef DO2
523 #undef DO1
524 }
525 tally_results(2);
526
527 return 0;
528 }
529
530 #ifdef MPI
531 void time_mult(void)
532 {
533 ulong64 t1, t2;
534 unsigned long x, y;
535 mp_int a, b, c;
536
537 fprintf(stderr, "Timing Multiplying:\n");
538 mp_init_multi(&a,&b,&c,NULL);
539 for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
540 mp_rand(&a, x);
541 mp_rand(&b, x);
542
543 #define DO1 mp_mul(&a, &b, &c);
544 #define DO2 DO1; DO1;
545
546 t2 = -1;
547 for (y = 0; y < TIMES; y++) {
548 t_start();
549 t1 = t_read();
550 DO2;
551 t1 = (t_read() - t1)>>1;
552 if (t1 < t2) t2 = t1;
553 }
554 fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
555 }
556 mp_clear_multi(&a,&b,&c,NULL);
557
558 #undef DO1
559 #undef DO2
560 }
561
562 void time_sqr(void)
563 {
564 ulong64 t1, t2;
565 unsigned long x, y;
566 mp_int a, b;
567
568 fprintf(stderr, "Timing Squaring:\n");
569 mp_init_multi(&a,&b,NULL);
570 for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
571 mp_rand(&a, x);
572
573 #define DO1 mp_sqr(&a, &b);
574 #define DO2 DO1; DO1;
575
576 t2 = -1;
577 for (y = 0; y < TIMES; y++) {
578 t_start();
579 t1 = t_read();
580 DO2;
581 t1 = (t_read() - t1)>>1;
582 if (t1 < t2) t2 = t1;
583 }
584 fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
585 }
586 mp_clear_multi(&a,&b,NULL);
587
588 #undef DO1
589 #undef DO2
590 }
591 #else
592 void time_mult(void) { fprintf(stderr, "NO MULT\n"); }
593 void time_sqr(void) { fprintf(stderr, "NO SQR\n"); }
594 #endif
595
596 void time_prng(void)
597 {
598 ulong64 t1, t2;
599 unsigned char buf[4096];
600 prng_state tprng;
601 unsigned long x, y;
602 int err;
603
604 fprintf(stderr, "Timing PRNGs (cycles/byte output, cycles add_entropy (32 bytes) :\n");
605 for (x = 0; prng_descriptor[x].name != NULL; x++) {
606
607 /* sanity check on prng */
608 if ((err = prng_descriptor[x].test()) != CRYPT_OK) {
609 fprintf(stderr, "\n\nERROR: PRNG %s failed self-test %s\n", prng_descriptor[x].name, error_to_string(err));
610 exit(EXIT_FAILURE);
611 }
612
613 prng_descriptor[x].start(&tprng);
614 zeromem(buf, 256);
615 prng_descriptor[x].add_entropy(buf, 256, &tprng);
616 prng_descriptor[x].ready(&tprng);
617 t2 = -1;
618
619 #define DO1 if (prng_descriptor[x].read(buf, 4096, &tprng) != 4096) { fprintf(stderr, "\n\nERROR READ != 4096\n\n"); exit(EXIT_FAILURE); }
620 #define DO2 DO1 DO1
621 for (y = 0; y < 10000; y++) {
622 t_start();
623 t1 = t_read();
624 DO2;
625 t1 = (t_read() - t1)>>1;
626 if (t1 < t2) t2 = t1;
627 }
628 fprintf(stderr, "%20s: %5llu ", prng_descriptor[x].name, t2>>12);
629 #undef DO2
630 #undef DO1
631
632 #define DO1 prng_descriptor[x].start(&tprng); prng_descriptor[x].add_entropy(buf, 32, &tprng); prng_descriptor[x].ready(&tprng); prng_descriptor[x].done(&tprng);
633 #define DO2 DO1 DO1
634 for (y = 0; y < 10000; y++) {
635 t_start();
636 t1 = t_read();
637 DO2;
638 t1 = (t_read() - t1)>>1;
639 if (t1 < t2) t2 = t1;
640 }
641 fprintf(stderr, "%5llu\n", t2);
642 #undef DO2
643 #undef DO1
644
645 }
646 }
647
648 #ifdef MRSA
649 /* time various RSA operations */
650 void time_rsa(void)
651 {
652 rsa_key key;
653 ulong64 t1, t2;
654 unsigned char buf[2][4096];
655 unsigned long x, y, z, zzz;
656 int err, zz;
657
658 for (x = 1024; x <= 2048; x += 512) {
659 t2 = 0;
660 for (y = 0; y < 16; y++) {
661 t_start();
662 t1 = t_read();
663 if ((err = rsa_make_key(&yarrow_prng, find_prng("yarrow"), x/8, 65537, &key)) != CRYPT_OK) {
664 fprintf(stderr, "\n\nrsa_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
665 exit(EXIT_FAILURE);
666 }
667 t1 = t_read() - t1;
668 t2 += t1;
669
670 if (y < 15) {
671 rsa_free(&key);
672 }
673 }
674 t2 >>= 4;
675 fprintf(stderr, "RSA-%lu make_key took %15llu cycles\n", x, t2);
676
677 t2 = 0;
678 for (y = 0; y < 16; y++) {
679 t_start();
680 t1 = t_read();
681 z = sizeof(buf[1]);
682 if ((err = rsa_encrypt_key(buf[0], 32, buf[1], &z, "testprog", 8, &yarrow_prng,
683 find_prng("yarrow"), find_hash("sha1"),
684 &key)) != CRYPT_OK) {
685 fprintf(stderr, "\n\nrsa_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
686 exit(EXIT_FAILURE);
687 }
688 t1 = t_read() - t1;
689 t2 += t1;
690 }
691 t2 >>= 4;
692 fprintf(stderr, "RSA-%lu encrypt_key took %15llu cycles\n", x, t2);
693
694 t2 = 0;
695 for (y = 0; y < 16; y++) {
696 t_start();
697 t1 = t_read();
698 zzz = sizeof(buf[0]);
699 if ((err = rsa_decrypt_key(buf[1], z, buf[0], &zzz, "testprog", 8, find_hash("sha1"),
700 &zz, &key)) != CRYPT_OK) {
701 fprintf(stderr, "\n\nrsa_decrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
702 exit(EXIT_FAILURE);
703 }
704 t1 = t_read() - t1;
705 t2 += t1;
706 }
707 t2 >>= 4;
708 fprintf(stderr, "RSA-%lu decrypt_key took %15llu cycles\n", x, t2);
709
710
711 rsa_free(&key);
712 }
713 }
714 #else
715 void time_rsa(void) { fprintf(stderr, "NO RSA\n"); }
716 #endif
717
718 #ifdef MECC
719 /* time various ECC operations */
720 void time_ecc(void)
721 {
722 ecc_key key;
723 ulong64 t1, t2;
724 unsigned char buf[2][4096];
725 unsigned long i, x, y, z;
726 int err;
727 static unsigned long sizes[] = {192/8, 256/8, 384/8, 521/8, 100000};
728
729 for (x = sizes[i=0]; x < 100000; x = sizes[++i]) {
730 t2 = 0;
731 for (y = 0; y < 16; y++) {
732 t_start();
733 t1 = t_read();
734 if ((err = ecc_make_key(&yarrow_prng, find_prng("yarrow"), x, &key)) != CRYPT_OK) {
735 fprintf(stderr, "\n\necc_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
736 exit(EXIT_FAILURE);
737 }
738 t1 = t_read() - t1;
739 t2 += t1;
740
741 if (y < 15) {
742 ecc_free(&key);
743 }
744 }
745 t2 >>= 4;
746 fprintf(stderr, "ECC-%lu make_key took %15llu cycles\n", x*8, t2);
747
748 t2 = 0;
749 for (y = 0; y < 16; y++) {
750 t_start();
751 t1 = t_read();
752 z = sizeof(buf[1]);
753 if ((err = ecc_encrypt_key(buf[0], 20, buf[1], &z, &yarrow_prng, find_prng("yarrow"), find_hash("sha1"),
754 &key)) != CRYPT_OK) {
755 fprintf(stderr, "\n\necc_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
756 exit(EXIT_FAILURE);
757 }
758 t1 = t_read() - t1;
759 t2 += t1;
760 }
761 t2 >>= 4;
762 fprintf(stderr, "ECC-%lu encrypt_key took %15llu cycles\n", x*8, t2);
763 ecc_free(&key);
764 }
765 }
766 #else
767 void time_ecc(void) { fprintf(stderr, "NO ECC\n"); }
768 #endif
769
770 #ifdef MDH
771 /* time various DH operations */
772 void time_dh(void)
773 {
774 dh_key key;
775 ulong64 t1, t2;
776 unsigned char buf[2][4096];
777 unsigned long i, x, y, z;
778 int err;
779 static unsigned long sizes[] = {768/8, 1024/8, 1536/8, 2048/8, 3072/8, 4096/8, 100000};
780
781 for (x = sizes[i=0]; x < 100000; x = sizes[++i]) {
782 t2 = 0;
783 for (y = 0; y < 16; y++) {
784 t_start();
785 t1 = t_read();
786 if ((err = dh_make_key(&yarrow_prng, find_prng("yarrow"), x, &key)) != CRYPT_OK) {
787 fprintf(stderr, "\n\ndh_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
788 exit(EXIT_FAILURE);
789 }
790 t1 = t_read() - t1;
791 t2 += t1;
792
793 if (y < 15) {
794 dh_free(&key);
795 }
796 }
797 t2 >>= 4;
798 fprintf(stderr, "DH-%4lu make_key took %15llu cycles\n", x*8, t2);
799
800 t2 = 0;
801 for (y = 0; y < 16; y++) {
802 t_start();
803 t1 = t_read();
804 z = sizeof(buf[1]);
805 if ((err = dh_encrypt_key(buf[0], 20, buf[1], &z, &yarrow_prng, find_prng("yarrow"), find_hash("sha1"),
806 &key)) != CRYPT_OK) {
807 fprintf(stderr, "\n\ndh_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
808 exit(EXIT_FAILURE);
809 }
810 t1 = t_read() - t1;
811 t2 += t1;
812 }
813 t2 >>= 4;
814 fprintf(stderr, "DH-%4lu encrypt_key took %15llu cycles\n", x*8, t2);
815 dh_free(&key);
816 }
817 }
818 #else
819 void time_dh(void) { fprintf(stderr, "NO DH\n"); }
820 #endif
821
822 void time_macs_(unsigned long MAC_SIZE)
823 {
824 unsigned char *buf, key[16], tag[16];
825 ulong64 t1, t2;
826 unsigned long x, z;
827 int err, cipher_idx, hash_idx;
828
829 fprintf(stderr, "\nMAC Timings (cycles/byte on %luKB blocks):\n", MAC_SIZE);
830
831 buf = XMALLOC(MAC_SIZE*1024);
832 if (buf == NULL) {
833 fprintf(stderr, "\n\nout of heap yo\n\n");
834 exit(EXIT_FAILURE);
835 }
836
837 cipher_idx = find_cipher("aes");
838 hash_idx = find_hash("md5");
839
840 yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
841 yarrow_read(key, 16, &yarrow_prng);
842
843 #ifdef OMAC
844 t2 = -1;
845 for (x = 0; x < 10000; x++) {
846 t_start();
847 t1 = t_read();
848 z = 16;
849 if ((err = omac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
850 fprintf(stderr, "\n\nomac error... %s\n", error_to_string(err));
851 exit(EXIT_FAILURE);
852 }
853 t1 = t_read() - t1;
854 if (t1 < t2) t2 = t1;
855 }
856 fprintf(stderr, "OMAC-AES\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
857 #endif
858
859 #ifdef PMAC
860 t2 = -1;
861 for (x = 0; x < 10000; x++) {
862 t_start();
863 t1 = t_read();
864 z = 16;
865 if ((err = pmac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
866 fprintf(stderr, "\n\npmac error... %s\n", error_to_string(err));
867 exit(EXIT_FAILURE);
868 }
869 t1 = t_read() - t1;
870 if (t1 < t2) t2 = t1;
871 }
872 fprintf(stderr, "PMAC-AES\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
873 #endif
874
875 #ifdef PELICAN
876 t2 = -1;
877 for (x = 0; x < 10000; x++) {
878 t_start();
879 t1 = t_read();
880 z = 16;
881 if ((err = pelican_memory(key, 16, buf, MAC_SIZE*1024, tag)) != CRYPT_OK) {
882 fprintf(stderr, "\n\npelican error... %s\n", error_to_string(err));
883 exit(EXIT_FAILURE);
884 }
885 t1 = t_read() - t1;
886 if (t1 < t2) t2 = t1;
887 }
888 fprintf(stderr, "PELICAN \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
889 #endif
890
891 #ifdef HMAC
892 t2 = -1;
893 for (x = 0; x < 10000; x++) {
894 t_start();
895 t1 = t_read();
896 z = 16;
897 if ((err = hmac_memory(hash_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
898 fprintf(stderr, "\n\nhmac error... %s\n", error_to_string(err));
899 exit(EXIT_FAILURE);
900 }
901 t1 = t_read() - t1;
902 if (t1 < t2) t2 = t1;
903 }
904 fprintf(stderr, "HMAC-MD5\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
905 #endif
906
907 XFREE(buf);
908 }
909
910 void time_macs(void)
911 {
912 time_macs_(1);
913 time_macs_(4);
914 time_macs_(32);
915 }
916
917 void time_encmacs_(unsigned long MAC_SIZE)
918 {
919 unsigned char *buf, IV[16], key[16], tag[16];
920 ulong64 t1, t2;
921 unsigned long x, z;
922 int err, cipher_idx;
923
924 fprintf(stderr, "\nENC+MAC Timings (zero byte AAD, 16 byte IV, cycles/byte on %luKB blocks):\n", MAC_SIZE);
925
926 buf = XMALLOC(MAC_SIZE*1024);
927 if (buf == NULL) {
928 fprintf(stderr, "\n\nout of heap yo\n\n");
929 exit(EXIT_FAILURE);
930 }
931
932 cipher_idx = find_cipher("aes");
933
934 yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
935 yarrow_read(key, 16, &yarrow_prng);
936 yarrow_read(IV, 16, &yarrow_prng);
937
938 #ifdef EAX_MODE
939 t2 = -1;
940 for (x = 0; x < 10000; x++) {
941 t_start();
942 t1 = t_read();
943 z = 16;
944 if ((err = eax_encrypt_authenticate_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
945 fprintf(stderr, "\nEAX error... %s\n", error_to_string(err));
946 exit(EXIT_FAILURE);
947 }
948 t1 = t_read() - t1;
949 if (t1 < t2) t2 = t1;
950 }
951 fprintf(stderr, "EAX \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
952 #endif
953
954 #ifdef OCB_MODE
955 t2 = -1;
956 for (x = 0; x < 10000; x++) {
957 t_start();
958 t1 = t_read();
959 z = 16;
960 if ((err = ocb_encrypt_authenticate_memory(cipher_idx, key, 16, IV, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
961 fprintf(stderr, "\nOCB error... %s\n", error_to_string(err));
962 exit(EXIT_FAILURE);
963 }
964 t1 = t_read() - t1;
965 if (t1 < t2) t2 = t1;
966 }
967 fprintf(stderr, "OCB \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
968 #endif
969
970 #ifdef CCM_MODE
971 t2 = -1;
972 for (x = 0; x < 10000; x++) {
973 t_start();
974 t1 = t_read();
975 z = 16;
976 if ((err = ccm_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, CCM_ENCRYPT)) != CRYPT_OK) {
977 fprintf(stderr, "\nCCM error... %s\n", error_to_string(err));
978 exit(EXIT_FAILURE);
979 }
980 t1 = t_read() - t1;
981 if (t1 < t2) t2 = t1;
982 }
983 fprintf(stderr, "CCM \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
984 #endif
985
986 #ifdef GCM_MODE
987 t2 = -1;
988 for (x = 0; x < 100; x++) {
989 t_start();
990 t1 = t_read();
991 z = 16;
992 if ((err = gcm_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, GCM_ENCRYPT)) != CRYPT_OK) {
993 fprintf(stderr, "\nGCM error... %s\n", error_to_string(err));
994 exit(EXIT_FAILURE);
995 }
996 t1 = t_read() - t1;
997 if (t1 < t2) t2 = t1;
998 }
999 fprintf(stderr, "GCM (no-precomp)\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1000
1001 {
1002 gcm_state gcm;
1003
1004 if ((err = gcm_init(&gcm, cipher_idx, key, 16)) != CRYPT_OK) { fprintf(stderr, "gcm_init: %s\n", error_to_string(err)); exit(EXIT_FAILURE); }
1005 t2 = -1;
1006 for (x = 0; x < 10000; x++) {
1007 t_start();
1008 t1 = t_read();
1009 z = 16;
1010 if ((err = gcm_reset(&gcm)) != CRYPT_OK) {
1011 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1012 exit(EXIT_FAILURE);
1013 }
1014 if ((err = gcm_add_iv(&gcm, IV, 16)) != CRYPT_OK) {
1015 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1016 exit(EXIT_FAILURE);
1017 }
1018 if ((err = gcm_add_aad(&gcm, NULL, 0)) != CRYPT_OK) {
1019 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1020 exit(EXIT_FAILURE);
1021 }
1022 if ((err = gcm_process(&gcm, buf, MAC_SIZE*1024, buf, GCM_ENCRYPT)) != CRYPT_OK) {
1023 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1024 exit(EXIT_FAILURE);
1025 }
1026
1027 if ((err = gcm_done(&gcm, tag, &z)) != CRYPT_OK) {
1028 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1029 exit(EXIT_FAILURE);
1030 }
1031 t1 = t_read() - t1;
1032 if (t1 < t2) t2 = t1;
1033 }
1034 fprintf(stderr, "GCM (precomp)\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1035 }
1036
1037 #endif
1038
1039 }
1040
1041 void time_encmacs(void)
1042 {
1043 time_encmacs_(1);
1044 time_encmacs_(4);
1045 time_encmacs_(32);
1046 }
1047
1048 /* $Source: /cvs/libtom/libtomcrypt/testprof/x86_prof.c,v $ */
1049 /* $Revision: 1.16 $ */
1050 /* $Date: 2005/06/14 20:44:23 $ */