release/src/router/dropbear/libtomcrypt/testprof/x86_prof.c

   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 $ */