Mercurial > dropbear

comparison libtomcrypt/testprof/x86_prof.c @ 389:5ff8218bcee9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
propagate from branch 'au.asn.ucc.matt.ltm.dropbear' (head 2af95f00ebd5bb7a28b3817db1218442c935388e) to branch 'au.asn.ucc.matt.dropbear' (head ecd779509ef23a8cdf64888904fc9b31d78aa933)
author Matt Johnston <matt@ucc.asn.au>
date Thu, 11 Jan 2007 03:14:55 +0000
parents 0cbe8f6dbf9e
children f849a5ca2efc
comparison
equal deleted inserted replaced
388:fb54020f78e1 389:5ff8218bcee9
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(LTC_PPC32) || defined(TFM_PPC32)
55 unsigned long a, b;
56 __asm__ __volatile__ ("mftbu %1 \nmftb %0\n":"=r"(a), "=r"(b));
57 return (((ulong64)b) << 32ULL) | ((ulong64)a);
58 #elif defined(__ia64__) /* gcc-IA64 version */
59 unsigned long result;
60 __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
61 while (__builtin_expect ((int) result == -1, 0))
62 __asm__ __volatile__("mov %0=ar.itc" : "=r"(result) :: "memory");
63 return result;
64 #elif defined(__sparc__)
65 #if defined(__arch64__)
66 ulong64 a;
67 asm volatile("rd %%tick,%0" : "=r" (a));
68 return a;
69 #else
70 register unsigned long x, y;
71 __asm__ __volatile__ ("rd %%tick, %0; clruw %0, %1; srlx %0, 32, %0" : "=r" (x), "=r" (y) : "0" (x), "1" (y));
72 return ((unsigned long long) x << 32) | y;
73 #endif
74 #else
75 return XCLOCK();
76 #endif
77
78 /* Microsoft and Intel Windows compilers */
79 #elif defined _M_IX86 && !defined(LTC_NO_ASM)
80 __asm rdtsc
81 #elif defined _M_AMD64 && !defined(LTC_NO_ASM)
82 return __rdtsc ();
83 #elif defined _M_IA64 && !defined(LTC_NO_ASM)
84 #if defined __INTEL_COMPILER
85 #include <ia64intrin.h>
86 #endif
87 return __getReg (3116);
88 #else
89 return XCLOCK();
90 #endif
91 }
92
93 static ulong64 timer, skew = 0;
94
95 void t_start(void)
96 {
97 timer = rdtsc();
98 }
99
100 ulong64 t_read(void)
101 {
102 return rdtsc() - timer;
103 }
104
105 void init_timer(void)
106 {
107 ulong64 c1, c2, t1, t2, t3;
108 unsigned long y1;
109
110 c1 = c2 = (ulong64)-1;
111 for (y1 = 0; y1 < TIMES*100; y1++) {
112 t_start();
113 t1 = t_read();
114 t3 = t_read();
115 t2 = (t_read() - t1)>>1;
116
117 c1 = (t1 > c1) ? t1 : c1;
118 c2 = (t2 > c2) ? t2 : c2;
119 }
120 skew = c2 - c1;
121 fprintf(stderr, "Clock Skew: %lu\n", (unsigned long)skew);
122 }
123
124 void reg_algs(void)
125 {
126 int err;
127 #ifdef RIJNDAEL
128 register_cipher (&aes_desc);
129 #endif
130 #ifdef BLOWFISH
131 register_cipher (&blowfish_desc);
132 #endif
133 #ifdef XTEA
134 register_cipher (&xtea_desc);
135 #endif
136 #ifdef RC5
137 register_cipher (&rc5_desc);
138 #endif
139 #ifdef RC6
140 register_cipher (&rc6_desc);
141 #endif
142 #ifdef SAFERP
143 register_cipher (&saferp_desc);
144 #endif
145 #ifdef TWOFISH
146 register_cipher (&twofish_desc);
147 #endif
148 #ifdef SAFER
149 register_cipher (&safer_k64_desc);
150 register_cipher (&safer_sk64_desc);
151 register_cipher (&safer_k128_desc);
152 register_cipher (&safer_sk128_desc);
153 #endif
154 #ifdef RC2
155 register_cipher (&rc2_desc);
156 #endif
157 #ifdef DES
158 register_cipher (&des_desc);
159 register_cipher (&des3_desc);
160 #endif
161 #ifdef CAST5
162 register_cipher (&cast5_desc);
163 #endif
164 #ifdef NOEKEON
165 register_cipher (&noekeon_desc);
166 #endif
167 #ifdef SKIPJACK
168 register_cipher (&skipjack_desc);
169 #endif
170 #ifdef KHAZAD
171 register_cipher (&khazad_desc);
172 #endif
173 #ifdef ANUBIS
174 register_cipher (&anubis_desc);
175 #endif
176 #ifdef KSEED
177 register_cipher (&kseed_desc);
178 #endif
179 #ifdef LTC_KASUMI
180 register_cipher (&kasumi_desc);
181 #endif
182
183 #ifdef TIGER
184 register_hash (&tiger_desc);
185 #endif
186 #ifdef MD2
187 register_hash (&md2_desc);
188 #endif
189 #ifdef MD4
190 register_hash (&md4_desc);
191 #endif
192 #ifdef MD5
193 register_hash (&md5_desc);
194 #endif
195 #ifdef SHA1
196 register_hash (&sha1_desc);
197 #endif
198 #ifdef SHA224
199 register_hash (&sha224_desc);
200 #endif
201 #ifdef SHA256
202 register_hash (&sha256_desc);
203 #endif
204 #ifdef SHA384
205 register_hash (&sha384_desc);
206 #endif
207 #ifdef SHA512
208 register_hash (&sha512_desc);
209 #endif
210 #ifdef RIPEMD128
211 register_hash (&rmd128_desc);
212 #endif
213 #ifdef RIPEMD160
214 register_hash (&rmd160_desc);
215 #endif
216 #ifdef RIPEMD256
217 register_hash (&rmd256_desc);
218 #endif
219 #ifdef RIPEMD320
220 register_hash (&rmd320_desc);
221 #endif
222 #ifdef WHIRLPOOL
223 register_hash (&whirlpool_desc);
224 #endif
225 #ifdef CHC_HASH
226 register_hash(&chc_desc);
227 if ((err = chc_register(register_cipher(&aes_desc))) != CRYPT_OK) {
228 fprintf(stderr, "chc_register error: %s\n", error_to_string(err));
229 exit(EXIT_FAILURE);
230 }
231 #endif
232
233
234 #ifndef YARROW
235 #error This demo requires Yarrow.
236 #endif
237 register_prng(&yarrow_desc);
238 #ifdef FORTUNA
239 register_prng(&fortuna_desc);
240 #endif
241 #ifdef RC4
242 register_prng(&rc4_desc);
243 #endif
244 #ifdef SOBER128
245 register_prng(&sober128_desc);
246 #endif
247
248 if ((err = rng_make_prng(128, find_prng("yarrow"), &yarrow_prng, NULL)) != CRYPT_OK) {
249 fprintf(stderr, "rng_make_prng failed: %s\n", error_to_string(err));
250 exit(EXIT_FAILURE);
251 }
252
253 }
254
255 int time_keysched(void)
256 {
257 unsigned long x, y1;
258 ulong64 t1, c1;
259 symmetric_key skey;
260 int kl;
261 int (*func) (const unsigned char *, int , int , symmetric_key *);
262 unsigned char key[MAXBLOCKSIZE];
263
264 fprintf(stderr, "\n\nKey Schedule Time Trials for the Symmetric Ciphers:\n(Times are cycles per key)\n");
265 no_results = 0;
266 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
267 #define DO1(k) func(k, kl, 0, &skey);
268
269 func = cipher_descriptor[x].setup;
270 kl = cipher_descriptor[x].min_key_length;
271 c1 = (ulong64)-1;
272 for (y1 = 0; y1 < KTIMES; y1++) {
273 yarrow_read(key, kl, &yarrow_prng);
274 t_start();
275 DO1(key);
276 t1 = t_read();
277 c1 = (t1 > c1) ? c1 : t1;
278 }
279 t1 = c1 - skew;
280 results[no_results].spd1 = results[no_results].avg = t1;
281 results[no_results++].id = x;
282 fprintf(stderr, "."); fflush(stdout);
283
284 #undef DO1
285 }
286 tally_results(0);
287
288 return 0;
289 }
290
291 int time_cipher(void)
292 {
293 unsigned long x, y1;
294 ulong64 t1, t2, c1, c2, a1, a2;
295 symmetric_ECB ecb;
296 unsigned char key[MAXBLOCKSIZE], pt[4096];
297 int err;
298
299 fprintf(stderr, "\n\nECB Time Trials for the Symmetric Ciphers:\n");
300 no_results = 0;
301 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
302 ecb_start(x, key, cipher_descriptor[x].min_key_length, 0, &ecb);
303
304 /* sanity check on cipher */
305 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
306 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
307 exit(EXIT_FAILURE);
308 }
309
310 #define DO1 ecb_encrypt(pt, pt, sizeof(pt), &ecb);
311 #define DO2 DO1 DO1
312
313 c1 = c2 = (ulong64)-1;
314 for (y1 = 0; y1 < 100; y1++) {
315 t_start();
316 DO1;
317 t1 = t_read();
318 DO2;
319 t2 = t_read();
320 t2 -= t1;
321
322 c1 = (t1 > c1 ? c1 : t1);
323 c2 = (t2 > c2 ? c2 : t2);
324 }
325 a1 = c2 - c1 - skew;
326
327 #undef DO1
328 #undef DO2
329 #define DO1 ecb_decrypt(pt, pt, sizeof(pt), &ecb);
330 #define DO2 DO1 DO1
331
332 c1 = c2 = (ulong64)-1;
333 for (y1 = 0; y1 < 100; y1++) {
334 t_start();
335 DO1;
336 t1 = t_read();
337 DO2;
338 t2 = t_read();
339 t2 -= t1;
340
341 c1 = (t1 > c1 ? c1 : t1);
342 c2 = (t2 > c2 ? c2 : t2);
343 }
344 a2 = c2 - c1 - skew;
345 ecb_done(&ecb);
346
347 results[no_results].id = x;
348 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
349 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
350 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
351 ++no_results;
352 fprintf(stderr, "."); fflush(stdout);
353
354 #undef DO2
355 #undef DO1
356 }
357 tally_results(1);
358
359 return 0;
360 }
361
362 #ifdef LTC_CBC_MODE
363 int time_cipher2(void)
364 {
365 unsigned long x, y1;
366 ulong64 t1, t2, c1, c2, a1, a2;
367 symmetric_CBC cbc;
368 unsigned char key[MAXBLOCKSIZE], pt[4096];
369 int err;
370
371 fprintf(stderr, "\n\nCBC Time Trials for the Symmetric Ciphers:\n");
372 no_results = 0;
373 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
374 cbc_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, &cbc);
375
376 /* sanity check on cipher */
377 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
378 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
379 exit(EXIT_FAILURE);
380 }
381
382 #define DO1 cbc_encrypt(pt, pt, sizeof(pt), &cbc);
383 #define DO2 DO1 DO1
384
385 c1 = c2 = (ulong64)-1;
386 for (y1 = 0; y1 < 100; y1++) {
387 t_start();
388 DO1;
389 t1 = t_read();
390 DO2;
391 t2 = t_read();
392 t2 -= t1;
393
394 c1 = (t1 > c1 ? c1 : t1);
395 c2 = (t2 > c2 ? c2 : t2);
396 }
397 a1 = c2 - c1 - skew;
398
399 #undef DO1
400 #undef DO2
401 #define DO1 cbc_decrypt(pt, pt, sizeof(pt), &cbc);
402 #define DO2 DO1 DO1
403
404 c1 = c2 = (ulong64)-1;
405 for (y1 = 0; y1 < 100; y1++) {
406 t_start();
407 DO1;
408 t1 = t_read();
409 DO2;
410 t2 = t_read();
411 t2 -= t1;
412
413 c1 = (t1 > c1 ? c1 : t1);
414 c2 = (t2 > c2 ? c2 : t2);
415 }
416 a2 = c2 - c1 - skew;
417 cbc_done(&cbc);
418
419 results[no_results].id = x;
420 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
421 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
422 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
423 ++no_results;
424 fprintf(stderr, "."); fflush(stdout);
425
426 #undef DO2
427 #undef DO1
428 }
429 tally_results(1);
430
431 return 0;
432 }
433 #else
434 int time_cipher2(void) { fprintf(stderr, "NO CBC\n"); return 0; }
435 #endif
436
437 #ifdef LTC_CTR_MODE
438 int time_cipher3(void)
439 {
440 unsigned long x, y1;
441 ulong64 t1, t2, c1, c2, a1, a2;
442 symmetric_CTR ctr;
443 unsigned char key[MAXBLOCKSIZE], pt[4096];
444 int err;
445
446 fprintf(stderr, "\n\nCTR Time Trials for the Symmetric Ciphers:\n");
447 no_results = 0;
448 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
449 ctr_start(x, pt, key, cipher_descriptor[x].min_key_length, 0, CTR_COUNTER_LITTLE_ENDIAN, &ctr);
450
451 /* sanity check on cipher */
452 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
453 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
454 exit(EXIT_FAILURE);
455 }
456
457 #define DO1 ctr_encrypt(pt, pt, sizeof(pt), &ctr);
458 #define DO2 DO1 DO1
459
460 c1 = c2 = (ulong64)-1;
461 for (y1 = 0; y1 < 100; y1++) {
462 t_start();
463 DO1;
464 t1 = t_read();
465 DO2;
466 t2 = t_read();
467 t2 -= t1;
468
469 c1 = (t1 > c1 ? c1 : t1);
470 c2 = (t2 > c2 ? c2 : t2);
471 }
472 a1 = c2 - c1 - skew;
473
474 #undef DO1
475 #undef DO2
476 #define DO1 ctr_decrypt(pt, pt, sizeof(pt), &ctr);
477 #define DO2 DO1 DO1
478
479 c1 = c2 = (ulong64)-1;
480 for (y1 = 0; y1 < 100; y1++) {
481 t_start();
482 DO1;
483 t1 = t_read();
484 DO2;
485 t2 = t_read();
486 t2 -= t1;
487
488 c1 = (t1 > c1 ? c1 : t1);
489 c2 = (t2 > c2 ? c2 : t2);
490 }
491 a2 = c2 - c1 - skew;
492 ctr_done(&ctr);
493
494 results[no_results].id = x;
495 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
496 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
497 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
498 ++no_results;
499 fprintf(stderr, "."); fflush(stdout);
500
501 #undef DO2
502 #undef DO1
503 }
504 tally_results(1);
505
506 return 0;
507 }
508 #else
509 int time_cipher3(void) { fprintf(stderr, "NO CTR\n"); return 0; }
510 #endif
511
512 #ifdef LTC_LRW_MODE
513 int time_cipher4(void)
514 {
515 unsigned long x, y1;
516 ulong64 t1, t2, c1, c2, a1, a2;
517 symmetric_LRW lrw;
518 unsigned char key[MAXBLOCKSIZE], pt[4096];
519 int err;
520
521 fprintf(stderr, "\n\nLRW Time Trials for the Symmetric Ciphers:\n");
522 no_results = 0;
523 for (x = 0; cipher_descriptor[x].name != NULL; x++) {
524 if (cipher_descriptor[x].block_length != 16) continue;
525 lrw_start(x, pt, key, cipher_descriptor[x].min_key_length, key, 0, &lrw);
526
527 /* sanity check on cipher */
528 if ((err = cipher_descriptor[x].test()) != CRYPT_OK) {
529 fprintf(stderr, "\n\nERROR: Cipher %s failed self-test %s\n", cipher_descriptor[x].name, error_to_string(err));
530 exit(EXIT_FAILURE);
531 }
532
533 #define DO1 lrw_encrypt(pt, pt, sizeof(pt), &lrw);
534 #define DO2 DO1 DO1
535
536 c1 = c2 = (ulong64)-1;
537 for (y1 = 0; y1 < 100; y1++) {
538 t_start();
539 DO1;
540 t1 = t_read();
541 DO2;
542 t2 = t_read();
543 t2 -= t1;
544
545 c1 = (t1 > c1 ? c1 : t1);
546 c2 = (t2 > c2 ? c2 : t2);
547 }
548 a1 = c2 - c1 - skew;
549
550 #undef DO1
551 #undef DO2
552 #define DO1 lrw_decrypt(pt, pt, sizeof(pt), &lrw);
553 #define DO2 DO1 DO1
554
555 c1 = c2 = (ulong64)-1;
556 for (y1 = 0; y1 < 100; y1++) {
557 t_start();
558 DO1;
559 t1 = t_read();
560 DO2;
561 t2 = t_read();
562 t2 -= t1;
563
564 c1 = (t1 > c1 ? c1 : t1);
565 c2 = (t2 > c2 ? c2 : t2);
566 }
567 a2 = c2 - c1 - skew;
568
569 lrw_done(&lrw);
570
571 results[no_results].id = x;
572 results[no_results].spd1 = a1/(sizeof(pt)/cipher_descriptor[x].block_length);
573 results[no_results].spd2 = a2/(sizeof(pt)/cipher_descriptor[x].block_length);
574 results[no_results].avg = (results[no_results].spd1 + results[no_results].spd2+1)/2;
575 ++no_results;
576 fprintf(stderr, "."); fflush(stdout);
577
578 #undef DO2
579 #undef DO1
580 }
581 tally_results(1);
582
583 return 0;
584 }
585 #else
586 int time_cipher4(void) { fprintf(stderr, "NO LRW\n"); return 0; }
587 #endif
588
589
590 int time_hash(void)
591 {
592 unsigned long x, y1, len;
593 ulong64 t1, t2, c1, c2;
594 hash_state md;
595 int (*func)(hash_state *, const unsigned char *, unsigned long), err;
596 unsigned char pt[MAXBLOCKSIZE];
597
598
599 fprintf(stderr, "\n\nHASH Time Trials for:\n");
600 no_results = 0;
601 for (x = 0; hash_descriptor[x].name != NULL; x++) {
602
603 /* sanity check on hash */
604 if ((err = hash_descriptor[x].test()) != CRYPT_OK) {
605 fprintf(stderr, "\n\nERROR: Hash %s failed self-test %s\n", hash_descriptor[x].name, error_to_string(err));
606 exit(EXIT_FAILURE);
607 }
608
609 hash_descriptor[x].init(&md);
610
611 #define DO1 func(&md,pt,len);
612 #define DO2 DO1 DO1
613
614 func = hash_descriptor[x].process;
615 len = hash_descriptor[x].blocksize;
616
617 c1 = c2 = (ulong64)-1;
618 for (y1 = 0; y1 < TIMES; y1++) {
619 t_start();
620 DO1;
621 t1 = t_read();
622 DO2;
623 t2 = t_read() - t1;
624 c1 = (t1 > c1) ? c1 : t1;
625 c2 = (t2 > c2) ? c2 : t2;
626 }
627 t1 = c2 - c1 - skew;
628 t1 = ((t1 * CONST64(1000))) / ((ulong64)hash_descriptor[x].blocksize);
629 results[no_results].id = x;
630 results[no_results].spd1 = results[no_results].avg = t1;
631 ++no_results;
632 fprintf(stderr, "."); fflush(stdout);
633 #undef DO2
634 #undef DO1
635 }
636 tally_results(2);
637
638 return 0;
639 }
640
641 #undef MPI
642 /*#warning you need an mp_rand!!!*/
643
644 #ifdef MPI
645 void time_mult(void)
646 {
647 ulong64 t1, t2;
648 unsigned long x, y;
649 void *a, *b, *c;
650
651 fprintf(stderr, "Timing Multiplying:\n");
652 mp_init_multi(&a,&b,&c,NULL);
653 for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
654 mp_rand(&a, x);
655 mp_rand(&b, x);
656
657 #define DO1 mp_mul(&a, &b, &c);
658 #define DO2 DO1; DO1;
659
660 t2 = -1;
661 for (y = 0; y < TIMES; y++) {
662 t_start();
663 t1 = t_read();
664 DO2;
665 t1 = (t_read() - t1)>>1;
666 if (t1 < t2) t2 = t1;
667 }
668 fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
669 }
670 mp_clear_multi(&a,&b,&c,NULL);
671
672 #undef DO1
673 #undef DO2
674 }
675
676 void time_sqr(void)
677 {
678 ulong64 t1, t2;
679 unsigned long x, y;
680 mp_int a, b;
681
682 fprintf(stderr, "Timing Squaring:\n");
683 mp_init_multi(&a,&b,NULL);
684 for (x = 128/DIGIT_BIT; x <= 1536/DIGIT_BIT; x += 128/DIGIT_BIT) {
685 mp_rand(&a, x);
686
687 #define DO1 mp_sqr(&a, &b);
688 #define DO2 DO1; DO1;
689
690 t2 = -1;
691 for (y = 0; y < TIMES; y++) {
692 t_start();
693 t1 = t_read();
694 DO2;
695 t1 = (t_read() - t1)>>1;
696 if (t1 < t2) t2 = t1;
697 }
698 fprintf(stderr, "%4lu bits: %9llu cycles\n", x*DIGIT_BIT, t2);
699 }
700 mp_clear_multi(&a,&b,NULL);
701
702 #undef DO1
703 #undef DO2
704 }
705 #else
706 void time_mult(void) { fprintf(stderr, "NO MULT\n"); }
707 void time_sqr(void) { fprintf(stderr, "NO SQR\n"); }
708 #endif
709
710 void time_prng(void)
711 {
712 ulong64 t1, t2;
713 unsigned char buf[4096];
714 prng_state tprng;
715 unsigned long x, y;
716 int err;
717
718 fprintf(stderr, "Timing PRNGs (cycles/byte output, cycles add_entropy (32 bytes) :\n");
719 for (x = 0; prng_descriptor[x].name != NULL; x++) {
720
721 /* sanity check on prng */
722 if ((err = prng_descriptor[x].test()) != CRYPT_OK) {
723 fprintf(stderr, "\n\nERROR: PRNG %s failed self-test %s\n", prng_descriptor[x].name, error_to_string(err));
724 exit(EXIT_FAILURE);
725 }
726
727 prng_descriptor[x].start(&tprng);
728 zeromem(buf, 256);
729 prng_descriptor[x].add_entropy(buf, 256, &tprng);
730 prng_descriptor[x].ready(&tprng);
731 t2 = -1;
732
733 #define DO1 if (prng_descriptor[x].read(buf, 4096, &tprng) != 4096) { fprintf(stderr, "\n\nERROR READ != 4096\n\n"); exit(EXIT_FAILURE); }
734 #define DO2 DO1 DO1
735 for (y = 0; y < 10000; y++) {
736 t_start();
737 t1 = t_read();
738 DO2;
739 t1 = (t_read() - t1)>>1;
740 if (t1 < t2) t2 = t1;
741 }
742 fprintf(stderr, "%20s: %5llu ", prng_descriptor[x].name, t2>>12);
743 #undef DO2
744 #undef DO1
745
746 #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);
747 #define DO2 DO1 DO1
748 for (y = 0; y < 10000; y++) {
749 t_start();
750 t1 = t_read();
751 DO2;
752 t1 = (t_read() - t1)>>1;
753 if (t1 < t2) t2 = t1;
754 }
755 fprintf(stderr, "%5llu\n", t2);
756 #undef DO2
757 #undef DO1
758
759 }
760 }
761
762 #ifdef MDSA
763 /* time various DSA operations */
764 void time_dsa(void)
765 {
766 dsa_key key;
767 ulong64 t1, t2;
768 unsigned long x, y;
769 int err;
770 static const struct {
771 int group, modulus;
772 } groups[] = {
773 { 20, 96 },
774 { 20, 128 },
775 { 24, 192 },
776 { 28, 256 },
777 { 32, 512 }
778 };
779
780 for (x = 0; x < (sizeof(groups)/sizeof(groups[0])); x++) {
781 t2 = 0;
782 for (y = 0; y < 4; y++) {
783 t_start();
784 t1 = t_read();
785 if ((err = dsa_make_key(&yarrow_prng, find_prng("yarrow"), groups[x].group, groups[x].modulus, &key)) != CRYPT_OK) {
786 fprintf(stderr, "\n\ndsa_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
787 exit(EXIT_FAILURE);
788 }
789 t1 = t_read() - t1;
790 t2 += t1;
791
792 #ifdef LTC_PROFILE
793 t2 <<= 2;
794 break;
795 #endif
796 if (y < 3) {
797 dsa_free(&key);
798 }
799 }
800 t2 >>= 2;
801 fprintf(stderr, "DSA-(%lu, %lu) make_key took %15llu cycles\n", (unsigned long)groups[x].group*8, (unsigned long)groups[x].modulus*8, t2);
802 }
803 }
804 #endif
805
806
807 #ifdef MRSA
808 /* time various RSA operations */
809 void time_rsa(void)
810 {
811 rsa_key key;
812 ulong64 t1, t2;
813 unsigned char buf[2][2048];
814 unsigned long x, y, z, zzz;
815 int err, zz, stat;
816
817 for (x = 1024; x <= 2048; x += 256) {
818 t2 = 0;
819 for (y = 0; y < 4; y++) {
820 t_start();
821 t1 = t_read();
822 if ((err = rsa_make_key(&yarrow_prng, find_prng("yarrow"), x/8, 65537, &key)) != CRYPT_OK) {
823 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));
824 exit(EXIT_FAILURE);
825 }
826 t1 = t_read() - t1;
827 t2 += t1;
828
829 #ifdef LTC_PROFILE
830 t2 <<= 2;
831 break;
832 #endif
833
834 if (y < 3) {
835 rsa_free(&key);
836 }
837 }
838 t2 >>= 2;
839 fprintf(stderr, "RSA-%lu make_key took %15llu cycles\n", x, t2);
840
841 t2 = 0;
842 for (y = 0; y < 16; y++) {
843 t_start();
844 t1 = t_read();
845 z = sizeof(buf[1]);
846 if ((err = rsa_encrypt_key(buf[0], 32, buf[1], &z, (const unsigned char *)"testprog", 8, &yarrow_prng,
847 find_prng("yarrow"), find_hash("sha1"),
848 &key)) != CRYPT_OK) {
849 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));
850 exit(EXIT_FAILURE);
851 }
852 t1 = t_read() - t1;
853 t2 += t1;
854 #ifdef LTC_PROFILE
855 t2 <<= 4;
856 break;
857 #endif
858 }
859 t2 >>= 4;
860 fprintf(stderr, "RSA-%lu encrypt_key took %15llu cycles\n", x, t2);
861
862 t2 = 0;
863 for (y = 0; y < 2048; y++) {
864 t_start();
865 t1 = t_read();
866 zzz = sizeof(buf[0]);
867 if ((err = rsa_decrypt_key(buf[1], z, buf[0], &zzz, (const unsigned char *)"testprog", 8, find_hash("sha1"),
868 &zz, &key)) != CRYPT_OK) {
869 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));
870 exit(EXIT_FAILURE);
871 }
872 t1 = t_read() - t1;
873 t2 += t1;
874 #ifdef LTC_PROFILE
875 t2 <<= 11;
876 break;
877 #endif
878 }
879 t2 >>= 11;
880 fprintf(stderr, "RSA-%lu decrypt_key took %15llu cycles\n", x, t2);
881
882 t2 = 0;
883 for (y = 0; y < 256; y++) {
884 t_start();
885 t1 = t_read();
886 z = sizeof(buf[1]);
887 if ((err = rsa_sign_hash(buf[0], 20, buf[1], &z, &yarrow_prng,
888 find_prng("yarrow"), find_hash("sha1"), 8, &key)) != CRYPT_OK) {
889 fprintf(stderr, "\n\nrsa_sign_hash says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
890 exit(EXIT_FAILURE);
891 }
892 t1 = t_read() - t1;
893 t2 += t1;
894 #ifdef LTC_PROFILE
895 t2 <<= 8;
896 break;
897 #endif
898 }
899 t2 >>= 8;
900 fprintf(stderr, "RSA-%lu sign_hash took %15llu cycles\n", x, t2);
901
902 t2 = 0;
903 for (y = 0; y < 2048; y++) {
904 t_start();
905 t1 = t_read();
906 if ((err = rsa_verify_hash(buf[1], z, buf[0], 20, find_hash("sha1"), 8, &stat, &key)) != CRYPT_OK) {
907 fprintf(stderr, "\n\nrsa_verify_hash says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
908 exit(EXIT_FAILURE);
909 }
910 if (stat == 0) {
911 fprintf(stderr, "\n\nrsa_verify_hash for RSA-%lu failed to verify signature(%lu)\n", x, y);
912 exit(EXIT_FAILURE);
913 }
914 t1 = t_read() - t1;
915 t2 += t1;
916 #ifdef LTC_PROFILE
917 t2 <<= 11;
918 break;
919 #endif
920 }
921 t2 >>= 11;
922 fprintf(stderr, "RSA-%lu verify_hash took %15llu cycles\n", x, t2);
923 fprintf(stderr, "\n\n");
924 rsa_free(&key);
925 }
926 }
927 #else
928 void time_rsa(void) { fprintf(stderr, "NO RSA\n"); }
929 #endif
930
931 #ifdef MKAT
932 /* time various KAT operations */
933 void time_katja(void)
934 {
935 katja_key key;
936 ulong64 t1, t2;
937 unsigned char buf[2][4096];
938 unsigned long x, y, z, zzz;
939 int err, zz;
940
941 for (x = 1024; x <= 2048; x += 256) {
942 t2 = 0;
943 for (y = 0; y < 4; y++) {
944 t_start();
945 t1 = t_read();
946 if ((err = katja_make_key(&yarrow_prng, find_prng("yarrow"), x/8, &key)) != CRYPT_OK) {
947 fprintf(stderr, "\n\nkatja_make_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
948 exit(EXIT_FAILURE);
949 }
950 t1 = t_read() - t1;
951 t2 += t1;
952
953 if (y < 3) {
954 katja_free(&key);
955 }
956 }
957 t2 >>= 2;
958 fprintf(stderr, "Katja-%lu make_key took %15llu cycles\n", x, t2);
959
960 t2 = 0;
961 for (y = 0; y < 16; y++) {
962 t_start();
963 t1 = t_read();
964 z = sizeof(buf[1]);
965 if ((err = katja_encrypt_key(buf[0], 32, buf[1], &z, "testprog", 8, &yarrow_prng,
966 find_prng("yarrow"), find_hash("sha1"),
967 &key)) != CRYPT_OK) {
968 fprintf(stderr, "\n\nkatja_encrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
969 exit(EXIT_FAILURE);
970 }
971 t1 = t_read() - t1;
972 t2 += t1;
973 }
974 t2 >>= 4;
975 fprintf(stderr, "Katja-%lu encrypt_key took %15llu cycles\n", x, t2);
976
977 t2 = 0;
978 for (y = 0; y < 2048; y++) {
979 t_start();
980 t1 = t_read();
981 zzz = sizeof(buf[0]);
982 if ((err = katja_decrypt_key(buf[1], z, buf[0], &zzz, "testprog", 8, find_hash("sha1"),
983 &zz, &key)) != CRYPT_OK) {
984 fprintf(stderr, "\n\nkatja_decrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
985 exit(EXIT_FAILURE);
986 }
987 t1 = t_read() - t1;
988 t2 += t1;
989 }
990 t2 >>= 11;
991 fprintf(stderr, "Katja-%lu decrypt_key took %15llu cycles\n", x, t2);
992
993
994 katja_free(&key);
995 }
996 }
997 #else
998 void time_katja(void) { fprintf(stderr, "NO Katja\n"); }
999 #endif
1000
1001 #ifdef MECC
1002 /* time various ECC operations */
1003 void time_ecc(void)
1004 {
1005 ecc_key key;
1006 ulong64 t1, t2;
1007 unsigned char buf[2][256];
1008 unsigned long i, w, x, y, z;
1009 int err, stat;
1010 static unsigned long sizes[] = {
1011 #ifdef ECC112
1012 112/8,
1013 #endif
1014 #ifdef ECC128
1015 128/8,
1016 #endif
1017 #ifdef ECC160
1018 160/8,
1019 #endif
1020 #ifdef ECC192
1021 192/8,
1022 #endif
1023 #ifdef ECC224
1024 224/8,
1025 #endif
1026 #ifdef ECC256
1027 256/8,
1028 #endif
1029 #ifdef ECC384
1030 384/8,
1031 #endif
1032 #ifdef ECC521
1033 521/8,
1034 #endif
1035 100000};
1036
1037 for (x = sizes[i=0]; x < 100000; x = sizes[++i]) {
1038 t2 = 0;
1039 for (y = 0; y < 256; y++) {
1040 t_start();
1041 t1 = t_read();
1042 if ((err = ecc_make_key(&yarrow_prng, find_prng("yarrow"), x, &key)) != CRYPT_OK) {
1043 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));
1044 exit(EXIT_FAILURE);
1045 }
1046 t1 = t_read() - t1;
1047 t2 += t1;
1048
1049 #ifdef LTC_PROFILE
1050 t2 <<= 8;
1051 break;
1052 #endif
1053
1054 if (y < 255) {
1055 ecc_free(&key);
1056 }
1057 }
1058 t2 >>= 8;
1059 fprintf(stderr, "ECC-%lu make_key took %15llu cycles\n", x*8, t2);
1060
1061 t2 = 0;
1062 for (y = 0; y < 256; y++) {
1063 t_start();
1064 t1 = t_read();
1065 z = sizeof(buf[1]);
1066 if ((err = ecc_encrypt_key(buf[0], 20, buf[1], &z, &yarrow_prng, find_prng("yarrow"), find_hash("sha1"),
1067 &key)) != CRYPT_OK) {
1068 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));
1069 exit(EXIT_FAILURE);
1070 }
1071 t1 = t_read() - t1;
1072 t2 += t1;
1073 #ifdef LTC_PROFILE
1074 t2 <<= 8;
1075 break;
1076 #endif
1077 }
1078 t2 >>= 8;
1079 fprintf(stderr, "ECC-%lu encrypt_key took %15llu cycles\n", x*8, t2);
1080
1081 t2 = 0;
1082 for (y = 0; y < 256; y++) {
1083 t_start();
1084 t1 = t_read();
1085 w = 20;
1086 if ((err = ecc_decrypt_key(buf[1], z, buf[0], &w, &key)) != CRYPT_OK) {
1087 fprintf(stderr, "\n\necc_decrypt_key says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
1088 exit(EXIT_FAILURE);
1089 }
1090 t1 = t_read() - t1;
1091 t2 += t1;
1092 #ifdef LTC_PROFILE
1093 t2 <<= 8;
1094 break;
1095 #endif
1096 }
1097 t2 >>= 8;
1098 fprintf(stderr, "ECC-%lu decrypt_key took %15llu cycles\n", x*8, t2);
1099
1100 t2 = 0;
1101 for (y = 0; y < 256; y++) {
1102 t_start();
1103 t1 = t_read();
1104 z = sizeof(buf[1]);
1105 if ((err = ecc_sign_hash(buf[0], 20, buf[1], &z, &yarrow_prng,
1106 find_prng("yarrow"), &key)) != CRYPT_OK) {
1107 fprintf(stderr, "\n\necc_sign_hash says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
1108 exit(EXIT_FAILURE);
1109 }
1110 t1 = t_read() - t1;
1111 t2 += t1;
1112 #ifdef LTC_PROFILE
1113 t2 <<= 8;
1114 break;
1115 #endif
1116 }
1117 t2 >>= 8;
1118 fprintf(stderr, "ECC-%lu sign_hash took %15llu cycles\n", x*8, t2);
1119
1120 t2 = 0;
1121 for (y = 0; y < 256; y++) {
1122 t_start();
1123 t1 = t_read();
1124 if ((err = ecc_verify_hash(buf[1], z, buf[0], 20, &stat, &key)) != CRYPT_OK) {
1125 fprintf(stderr, "\n\necc_verify_hash says %s, wait...no it should say %s...damn you!\n", error_to_string(err), error_to_string(CRYPT_OK));
1126 exit(EXIT_FAILURE);
1127 }
1128 if (stat == 0) {
1129 fprintf(stderr, "\n\necc_verify_hash for ECC-%lu failed to verify signature(%lu)\n", x*8, y);
1130 exit(EXIT_FAILURE);
1131 }
1132 t1 = t_read() - t1;
1133 t2 += t1;
1134 #ifdef LTC_PROFILE
1135 t2 <<= 8;
1136 break;
1137 #endif
1138 }
1139 t2 >>= 8;
1140 fprintf(stderr, "ECC-%lu verify_hash took %15llu cycles\n", x*8, t2);
1141
1142 fprintf(stderr, "\n\n");
1143 ecc_free(&key);
1144 }
1145 }
1146 #else
1147 void time_ecc(void) { fprintf(stderr, "NO ECC\n"); }
1148 #endif
1149
1150 void time_macs_(unsigned long MAC_SIZE)
1151 {
1152 unsigned char *buf, key[16], tag[16];
1153 ulong64 t1, t2;
1154 unsigned long x, z;
1155 int err, cipher_idx, hash_idx;
1156
1157 fprintf(stderr, "\nMAC Timings (cycles/byte on %luKB blocks):\n", MAC_SIZE);
1158
1159 buf = XMALLOC(MAC_SIZE*1024);
1160 if (buf == NULL) {
1161 fprintf(stderr, "\n\nout of heap yo\n\n");
1162 exit(EXIT_FAILURE);
1163 }
1164
1165 cipher_idx = find_cipher("aes");
1166 hash_idx = find_hash("sha1");
1167
1168 if (cipher_idx == -1 || hash_idx == -1) {
1169 fprintf(stderr, "Warning the MAC tests requires AES and SHA1 to operate... so sorry\n");
1170 return;
1171 }
1172
1173 yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
1174 yarrow_read(key, 16, &yarrow_prng);
1175
1176 #ifdef LTC_OMAC
1177 t2 = -1;
1178 for (x = 0; x < 10000; x++) {
1179 t_start();
1180 t1 = t_read();
1181 z = 16;
1182 if ((err = omac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
1183 fprintf(stderr, "\n\nomac error... %s\n", error_to_string(err));
1184 exit(EXIT_FAILURE);
1185 }
1186 t1 = t_read() - t1;
1187 if (t1 < t2) t2 = t1;
1188 }
1189 fprintf(stderr, "OMAC-%s\t\t%9llu\n", cipher_descriptor[cipher_idx].name, t2/(ulong64)(MAC_SIZE*1024));
1190 #endif
1191
1192 #ifdef LTC_XCBC
1193 t2 = -1;
1194 for (x = 0; x < 10000; x++) {
1195 t_start();
1196 t1 = t_read();
1197 z = 16;
1198 if ((err = xcbc_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
1199 fprintf(stderr, "\n\nxcbc error... %s\n", error_to_string(err));
1200 exit(EXIT_FAILURE);
1201 }
1202 t1 = t_read() - t1;
1203 if (t1 < t2) t2 = t1;
1204 }
1205 fprintf(stderr, "XCBC-%s\t\t%9llu\n", cipher_descriptor[cipher_idx].name, t2/(ulong64)(MAC_SIZE*1024));
1206 #endif
1207
1208 #ifdef LTC_F9_MODE
1209 t2 = -1;
1210 for (x = 0; x < 10000; x++) {
1211 t_start();
1212 t1 = t_read();
1213 z = 16;
1214 if ((err = f9_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
1215 fprintf(stderr, "\n\nF9 error... %s\n", error_to_string(err));
1216 exit(EXIT_FAILURE);
1217 }
1218 t1 = t_read() - t1;
1219 if (t1 < t2) t2 = t1;
1220 }
1221 fprintf(stderr, "F9-%s\t\t\t%9llu\n", cipher_descriptor[cipher_idx].name, t2/(ulong64)(MAC_SIZE*1024));
1222 #endif
1223
1224 #ifdef LTC_PMAC
1225 t2 = -1;
1226 for (x = 0; x < 10000; x++) {
1227 t_start();
1228 t1 = t_read();
1229 z = 16;
1230 if ((err = pmac_memory(cipher_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
1231 fprintf(stderr, "\n\npmac error... %s\n", error_to_string(err));
1232 exit(EXIT_FAILURE);
1233 }
1234 t1 = t_read() - t1;
1235 if (t1 < t2) t2 = t1;
1236 }
1237 fprintf(stderr, "PMAC-AES\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1238 #endif
1239
1240 #ifdef PELICAN
1241 t2 = -1;
1242 for (x = 0; x < 10000; x++) {
1243 t_start();
1244 t1 = t_read();
1245 z = 16;
1246 if ((err = pelican_memory(key, 16, buf, MAC_SIZE*1024, tag)) != CRYPT_OK) {
1247 fprintf(stderr, "\n\npelican error... %s\n", error_to_string(err));
1248 exit(EXIT_FAILURE);
1249 }
1250 t1 = t_read() - t1;
1251 if (t1 < t2) t2 = t1;
1252 }
1253 fprintf(stderr, "PELICAN \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1254 #endif
1255
1256 #ifdef LTC_HMAC
1257 t2 = -1;
1258 for (x = 0; x < 10000; x++) {
1259 t_start();
1260 t1 = t_read();
1261 z = 16;
1262 if ((err = hmac_memory(hash_idx, key, 16, buf, MAC_SIZE*1024, tag, &z)) != CRYPT_OK) {
1263 fprintf(stderr, "\n\nhmac error... %s\n", error_to_string(err));
1264 exit(EXIT_FAILURE);
1265 }
1266 t1 = t_read() - t1;
1267 if (t1 < t2) t2 = t1;
1268 }
1269 fprintf(stderr, "HMAC-%s\t\t%9llu\n", hash_descriptor[hash_idx].name, t2/(ulong64)(MAC_SIZE*1024));
1270 #endif
1271
1272 XFREE(buf);
1273 }
1274
1275 void time_macs(void)
1276 {
1277 time_macs_(1);
1278 time_macs_(4);
1279 time_macs_(32);
1280 }
1281
1282 void time_encmacs_(unsigned long MAC_SIZE)
1283 {
1284 unsigned char *buf, IV[16], key[16], tag[16];
1285 ulong64 t1, t2;
1286 unsigned long x, z;
1287 int err, cipher_idx;
1288 symmetric_key skey;
1289
1290 fprintf(stderr, "\nENC+MAC Timings (zero byte AAD, 16 byte IV, cycles/byte on %luKB blocks):\n", MAC_SIZE);
1291
1292 buf = XMALLOC(MAC_SIZE*1024);
1293 if (buf == NULL) {
1294 fprintf(stderr, "\n\nout of heap yo\n\n");
1295 exit(EXIT_FAILURE);
1296 }
1297
1298 cipher_idx = find_cipher("aes");
1299
1300 yarrow_read(buf, MAC_SIZE*1024, &yarrow_prng);
1301 yarrow_read(key, 16, &yarrow_prng);
1302 yarrow_read(IV, 16, &yarrow_prng);
1303
1304 #ifdef EAX_MODE
1305 t2 = -1;
1306 for (x = 0; x < 10000; x++) {
1307 t_start();
1308 t1 = t_read();
1309 z = 16;
1310 if ((err = eax_encrypt_authenticate_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
1311 fprintf(stderr, "\nEAX error... %s\n", error_to_string(err));
1312 exit(EXIT_FAILURE);
1313 }
1314 t1 = t_read() - t1;
1315 if (t1 < t2) t2 = t1;
1316 }
1317 fprintf(stderr, "EAX \t\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1318 #endif
1319
1320 #ifdef OCB_MODE
1321 t2 = -1;
1322 for (x = 0; x < 10000; x++) {
1323 t_start();
1324 t1 = t_read();
1325 z = 16;
1326 if ((err = ocb_encrypt_authenticate_memory(cipher_idx, key, 16, IV, buf, MAC_SIZE*1024, buf, tag, &z)) != CRYPT_OK) {
1327 fprintf(stderr, "\nOCB error... %s\n", error_to_string(err));
1328 exit(EXIT_FAILURE);
1329 }
1330 t1 = t_read() - t1;
1331 if (t1 < t2) t2 = t1;
1332 }
1333 fprintf(stderr, "OCB \t\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1334 #endif
1335
1336 #ifdef CCM_MODE
1337 t2 = -1;
1338 for (x = 0; x < 10000; x++) {
1339 t_start();
1340 t1 = t_read();
1341 z = 16;
1342 if ((err = ccm_memory(cipher_idx, key, 16, NULL, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, CCM_ENCRYPT)) != CRYPT_OK) {
1343 fprintf(stderr, "\nCCM error... %s\n", error_to_string(err));
1344 exit(EXIT_FAILURE);
1345 }
1346 t1 = t_read() - t1;
1347 if (t1 < t2) t2 = t1;
1348 }
1349 fprintf(stderr, "CCM (no-precomp) \t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1350
1351 cipher_descriptor[cipher_idx].setup(key, 16, 0, &skey);
1352 t2 = -1;
1353 for (x = 0; x < 10000; x++) {
1354 t_start();
1355 t1 = t_read();
1356 z = 16;
1357 if ((err = ccm_memory(cipher_idx, key, 16, &skey, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, CCM_ENCRYPT)) != CRYPT_OK) {
1358 fprintf(stderr, "\nCCM error... %s\n", error_to_string(err));
1359 exit(EXIT_FAILURE);
1360 }
1361 t1 = t_read() - t1;
1362 if (t1 < t2) t2 = t1;
1363 }
1364 fprintf(stderr, "CCM (precomp) \t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1365 cipher_descriptor[cipher_idx].done(&skey);
1366 #endif
1367
1368 #ifdef GCM_MODE
1369 t2 = -1;
1370 for (x = 0; x < 100; x++) {
1371 t_start();
1372 t1 = t_read();
1373 z = 16;
1374 if ((err = gcm_memory(cipher_idx, key, 16, IV, 16, NULL, 0, buf, MAC_SIZE*1024, buf, tag, &z, GCM_ENCRYPT)) != CRYPT_OK) {
1375 fprintf(stderr, "\nGCM error... %s\n", error_to_string(err));
1376 exit(EXIT_FAILURE);
1377 }
1378 t1 = t_read() - t1;
1379 if (t1 < t2) t2 = t1;
1380 }
1381 fprintf(stderr, "GCM (no-precomp)\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1382
1383 {
1384 gcm_state gcm
1385 #ifdef GCM_TABLES_SSE2
1386 __attribute__ ((aligned (16)))
1387 #endif
1388 ;
1389
1390 if ((err = gcm_init(&gcm, cipher_idx, key, 16)) != CRYPT_OK) { fprintf(stderr, "gcm_init: %s\n", error_to_string(err)); exit(EXIT_FAILURE); }
1391 t2 = -1;
1392 for (x = 0; x < 10000; x++) {
1393 t_start();
1394 t1 = t_read();
1395 z = 16;
1396 if ((err = gcm_reset(&gcm)) != CRYPT_OK) {
1397 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1398 exit(EXIT_FAILURE);
1399 }
1400 if ((err = gcm_add_iv(&gcm, IV, 16)) != CRYPT_OK) {
1401 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1402 exit(EXIT_FAILURE);
1403 }
1404 if ((err = gcm_add_aad(&gcm, NULL, 0)) != CRYPT_OK) {
1405 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1406 exit(EXIT_FAILURE);
1407 }
1408 if ((err = gcm_process(&gcm, buf, MAC_SIZE*1024, buf, GCM_ENCRYPT)) != CRYPT_OK) {
1409 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1410 exit(EXIT_FAILURE);
1411 }
1412
1413 if ((err = gcm_done(&gcm, tag, &z)) != CRYPT_OK) {
1414 fprintf(stderr, "\nGCM error[%d]... %s\n", __LINE__, error_to_string(err));
1415 exit(EXIT_FAILURE);
1416 }
1417 t1 = t_read() - t1;
1418 if (t1 < t2) t2 = t1;
1419 }
1420 fprintf(stderr, "GCM (precomp)\t\t%9llu\n", t2/(ulong64)(MAC_SIZE*1024));
1421 }
1422
1423 #endif
1424
1425 }
1426
1427 void time_encmacs(void)
1428 {
1429 time_encmacs_(1);
1430 time_encmacs_(4);
1431 time_encmacs_(32);
1432 }
1433
1434 /* $Source: /cvs/libtom/libtomcrypt/testprof/x86_prof.c,v $ */
1435 /* $Revision: 1.51 $ */
1436 /* $Date: 2006/11/21 00:10:18 $ */