_ Git - BearSSL/blob - test/test_speed.c

   1 /*
   2  * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining
   5  * a copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sublicense, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be
  13  * included in all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  16  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  18  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  19  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  20  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <time.h>
  29 #include "inner.h"
  30
  31 #define HASH_SIZE(cname)   br_ ## cname ## _SIZE
  32
  33 #define SPEED_HASH(Name, cname) \
  34 static void \
  35 test_speed_ ## cname(void) \
  36 { \
  37         unsigned char buf[8192]; \
  38         unsigned char tmp[HASH_SIZE(cname)]; \
  39         br_ ## cname ## _context mc; \
  40         int i; \
  41         long num; \
  42  \
  43         memset(buf, 'T', sizeof buf); \
  44         for (i = 0; i < 10; i ++) { \
  45                 br_ ## cname ## _init(&mc); \
  46                 br_ ## cname ## _update(&mc, buf, sizeof buf); \
  47                 br_ ## cname ## _out(&mc, tmp); \
  48         } \
  49         num = 10; \
  50         for (;;) { \
  51                 clock_t begin, end; \
  52                 double tt; \
  53                 long k; \
  54  \
  55                 br_ ## cname ## _init(&mc); \
  56                 begin = clock(); \
  57                 for (k = num; k > 0; k --) { \
  58                         br_ ## cname ## _update(&mc, buf, sizeof buf); \
  59                 } \
  60                 end = clock(); \
  61                 br_ ## cname ## _out(&mc, tmp); \
  62                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
  63                 if (tt >= 2.0) { \
  64                         printf("%-30s %8.2f MB/s\n", #Name, \
  65                                 ((double)sizeof buf) * (double)num \
  66                                 / (tt * 1000000.0)); \
  67                         fflush(stdout); \
  68                         return; \
  69                 } \
  70                 num <<= 1; \
  71         } \
  72 }
  73
  74 #define BLOCK_SIZE(cname)   br_ ## cname ## _BLOCK_SIZE
  75
  76 #define SPEED_BLOCKCIPHER_CBC(Name, fname, cname, klen, dir) \
  77 static void \
  78 test_speed_ ## fname(void) \
  79 { \
  80         unsigned char key[klen]; \
  81         unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
  82         unsigned char iv[BLOCK_SIZE(cname)]; \
  83         const br_block_cbc ## dir ## _class *vt; \
  84         br_ ## cname ## _cbc ## dir ## _keys ec; \
  85         int i; \
  86         long num; \
  87  \
  88         memset(key, 'T', sizeof key); \
  89         memset(buf, 'P', sizeof buf); \
  90         memset(iv, 'X', sizeof iv); \
  91         vt = &br_ ## cname ## _cbc ## dir ## _vtable; \
  92         for (i = 0; i < 10; i ++) { \
  93                 vt->init(&ec.vtable, key, sizeof key); \
  94                 vt->run(&ec.vtable, iv, buf, sizeof buf); \
  95         } \
  96         num = 10; \
  97         for (;;) { \
  98                 clock_t begin, end; \
  99                 double tt; \
 100                 long k; \
 101  \
 102                 vt->init(&ec.vtable, key, sizeof key); \
 103                 begin = clock(); \
 104                 for (k = num; k > 0; k --) { \
 105                         vt->run(&ec.vtable, iv, buf, sizeof buf); \
 106                 } \
 107                 end = clock(); \
 108                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 109                 if (tt >= 2.0) { \
 110                         printf("%-30s %8.2f MB/s\n", #Name, \
 111                                 ((double)sizeof buf) * (double)num \
 112                                 / (tt * 1000000.0)); \
 113                         fflush(stdout); \
 114                         return; \
 115                 } \
 116                 num <<= 1; \
 117         } \
 118 }
 119
 120 #define SPEED_BLOCKCIPHER_CTR(Name, fname, cname, klen) \
 121 static void \
 122 test_speed_ ## fname(void) \
 123 { \
 124         unsigned char key[klen]; \
 125         unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
 126         unsigned char iv[BLOCK_SIZE(cname) - 4]; \
 127         const br_block_ctr_class *vt; \
 128         br_ ## cname ## _ctr_keys ec; \
 129         int i; \
 130         long num; \
 131  \
 132         memset(key, 'T', sizeof key); \
 133         memset(buf, 'P', sizeof buf); \
 134         memset(iv, 'X', sizeof iv); \
 135         vt = &br_ ## cname ## _ctr_vtable; \
 136         for (i = 0; i < 10; i ++) { \
 137                 vt->init(&ec.vtable, key, sizeof key); \
 138                 vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 139         } \
 140         num = 10; \
 141         for (;;) { \
 142                 clock_t begin, end; \
 143                 double tt; \
 144                 long k; \
 145  \
 146                 vt->init(&ec.vtable, key, sizeof key); \
 147                 begin = clock(); \
 148                 for (k = num; k > 0; k --) { \
 149                         vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
 150                 } \
 151                 end = clock(); \
 152                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 153                 if (tt >= 2.0) { \
 154                         printf("%-30s %8.2f MB/s\n", #Name, \
 155                                 ((double)sizeof buf) * (double)num \
 156                                 / (tt * 1000000.0)); \
 157                         fflush(stdout); \
 158                         return; \
 159                 } \
 160                 num <<= 1; \
 161         } \
 162 }
 163
 164 #define SPEED_CHACHA20(Name, fname) \
 165 static void \
 166 test_speed_ ## fname(void) \
 167 { \
 168         unsigned char key[32]; \
 169         unsigned char buf[8192]; \
 170         unsigned char iv[12]; \
 171         int i; \
 172         long num; \
 173  \
 174         memset(key, 'T', sizeof key); \
 175         memset(buf, 'P', sizeof buf); \
 176         memset(iv, 'X', sizeof iv); \
 177         for (i = 0; i < 10; i ++) { \
 178                 br_ ## fname ## _run(key, iv, i, buf, sizeof buf); \
 179         } \
 180         num = 10; \
 181         for (;;) { \
 182                 clock_t begin, end; \
 183                 double tt; \
 184                 long k; \
 185  \
 186                 begin = clock(); \
 187                 for (k = num; k > 0; k --) { \
 188                         br_ ## fname ## _run(key, iv, \
 189                                 (uint32_t)k, buf, sizeof buf); \
 190                 } \
 191                 end = clock(); \
 192                 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
 193                 if (tt >= 2.0) { \
 194                         printf("%-30s %8.2f MB/s\n", #Name, \
 195                                 ((double)sizeof buf) * (double)num \
 196                                 / (tt * 1000000.0)); \
 197                         fflush(stdout); \
 198                         return; \
 199                 } \
 200                 num <<= 1; \
 201         } \
 202 }
 203
 204 SPEED_HASH(MD5, md5)
 205 SPEED_HASH(SHA-1, sha1)
 206 SPEED_HASH(SHA-256, sha256)
 207 SPEED_HASH(SHA-512, sha512)
 208
 209 #define SPEED_AES(iname) \
 210 SPEED_BLOCKCIPHER_CBC(AES-128 CBC encrypt (iname), aes128_ ## iname ## _cbcenc, aes_ ## iname, 16, enc) \
 211 SPEED_BLOCKCIPHER_CBC(AES-128 CBC decrypt (iname), aes128_ ## iname ## _cbcdec, aes_ ## iname, 16, dec) \
 212 SPEED_BLOCKCIPHER_CBC(AES-192 CBC encrypt (iname), aes192_ ## iname ## _cbcenc, aes_ ## iname, 24, enc) \
 213 SPEED_BLOCKCIPHER_CBC(AES-192 CBC decrypt (iname), aes192_ ## iname ## _cbcdec, aes_ ## iname, 24, dec) \
 214 SPEED_BLOCKCIPHER_CBC(AES-256 CBC encrypt (iname), aes256_ ## iname ## _cbcenc, aes_ ## iname, 32, enc) \
 215 SPEED_BLOCKCIPHER_CBC(AES-256 CBC decrypt (iname), aes256_ ## iname ## _cbcdec, aes_ ## iname, 32, dec) \
 216 SPEED_BLOCKCIPHER_CTR(AES-128 CTR (iname), aes128_ ## iname ## _ctr, aes_ ## iname, 16) \
 217 SPEED_BLOCKCIPHER_CTR(AES-192 CTR (iname), aes192_ ## iname ## _ctr, aes_ ## iname, 24) \
 218 SPEED_BLOCKCIPHER_CTR(AES-256 CTR (iname), aes256_ ## iname ## _ctr, aes_ ## iname, 32)
 219
 220 SPEED_AES(big)
 221 SPEED_AES(small)
 222 SPEED_AES(ct)
 223 SPEED_AES(ct64)
 224
 225 #define SPEED_DES(iname) \
 226 SPEED_BLOCKCIPHER_CBC(DES CBC encrypt (iname), des_ ## iname ## _cbcenc, des_ ## iname, 8, enc) \
 227 SPEED_BLOCKCIPHER_CBC(DES CBC decrypt (iname), des_ ## iname ## _cbcdec, des_ ## iname, 8, dec) \
 228 SPEED_BLOCKCIPHER_CBC(3DES CBC encrypt (iname), 3des_ ## iname ## _cbcenc, des_ ## iname, 24, enc) \
 229 SPEED_BLOCKCIPHER_CBC(3DES CBC decrypt (iname), 3des_ ## iname ## _cbcdec, des_ ## iname, 24, dec)
 230
 231 SPEED_DES(tab)
 232 SPEED_DES(ct)
 233
 234 SPEED_CHACHA20(ChaCha20, chacha20_ct)
 235
 236 static void
 237 test_speed_ghash_inner(char *name, br_ghash gh)
 238 {
 239         unsigned char buf[8192], h[16], y[16];
 240         int i;
 241         long num;
 242
 243         memset(buf, 'T', sizeof buf);
 244         memset(h, 'P', sizeof h);
 245         memset(y, 0, sizeof y);
 246         for (i = 0; i < 10; i ++) {
 247                 gh(y, h, buf, sizeof buf);
 248         }
 249         num = 10;
 250         for (;;) {
 251                 clock_t begin, end;
 252                 double tt;
 253                 long k;
 254
 255                 begin = clock();
 256                 for (k = num; k > 0; k --) {
 257                         gh(y, h, buf, sizeof buf);
 258                 }
 259                 end = clock();
 260                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 261                 if (tt >= 2.0) {
 262                         printf("%-30s %8.2f MB/s\n", name,
 263                                 ((double)sizeof buf) * (double)num
 264                                 / (tt * 1000000.0));
 265                         fflush(stdout);
 266                         return;
 267                 }
 268                 num <<= 1;
 269         }
 270 }
 271
 272 static void
 273 test_speed_ghash_ctmul(void)
 274 {
 275         test_speed_ghash_inner("GHASH (ctmul)", &br_ghash_ctmul);
 276 }
 277
 278 static void
 279 test_speed_ghash_ctmul32(void)
 280 {
 281         test_speed_ghash_inner("GHASH (ctmul32)", &br_ghash_ctmul32);
 282 }
 283
 284 static void
 285 test_speed_ghash_ctmul64(void)
 286 {
 287         test_speed_ghash_inner("GHASH (ctmul64)", &br_ghash_ctmul64);
 288 }
 289
 290 static uint32_t
 291 fake_chacha20(const void *key, const void *iv,
 292         uint32_t cc, void *data, size_t len)
 293 {
 294         (void)key;
 295         (void)iv;
 296         (void)data;
 297         (void)len;
 298         return cc + (uint32_t)((len + 63) >> 6);
 299 }
 300
 301 /*
 302  * To speed-test Poly1305, we run it with a do-nothing stub instead of
 303  * ChaCha20.
 304  */
 305 static void
 306 test_speed_poly1305_inner(char *name, br_poly1305_run pl)
 307 {
 308         unsigned char buf[8192], key[32], iv[12], aad[13], tag[16];
 309         int i;
 310         long num;
 311
 312         memset(key, 'K', sizeof key);
 313         memset(iv, 'I', sizeof iv);
 314         memset(aad, 'A', sizeof aad);
 315         memset(buf, 'T', sizeof buf);
 316         for (i = 0; i < 10; i ++) {
 317                 pl(key, iv, buf, sizeof buf,
 318                         aad, sizeof aad, tag, &fake_chacha20, 0);
 319         }
 320         num = 10;
 321         for (;;) {
 322                 clock_t begin, end;
 323                 double tt;
 324                 long k;
 325
 326                 begin = clock();
 327                 for (k = num; k > 0; k --) {
 328                         pl(key, iv, buf, sizeof buf,
 329                                 aad, sizeof aad, tag, &fake_chacha20, 0);
 330                 }
 331                 end = clock();
 332                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 333                 if (tt >= 2.0) {
 334                         printf("%-30s %8.2f MB/s\n", name,
 335                                 ((double)sizeof buf) * (double)num
 336                                 / (tt * 1000000.0));
 337                         fflush(stdout);
 338                         return;
 339                 }
 340                 num <<= 1;
 341         }
 342 }
 343
 344 static void
 345 test_speed_poly1305_ctmul(void)
 346 {
 347         test_speed_poly1305_inner("Poly1305 (ctmul)", &br_poly1305_ctmul_run);
 348 }
 349
 350 static void
 351 test_speed_poly1305_ctmul32(void)
 352 {
 353         test_speed_poly1305_inner("Poly1305 (ctmul32)",
 354                 &br_poly1305_ctmul32_run);
 355 }
 356
 357 static void
 358 test_speed_poly1305_i15(void)
 359 {
 360         test_speed_poly1305_inner("Poly1305 (i15)", &br_poly1305_i15_run);
 361 }
 362
 363 static const unsigned char RSA_N[] = {
 364         0xE9, 0xF2, 0x4A, 0x2F, 0x96, 0xDF, 0x0A, 0x23,
 365         0x01, 0x85, 0xF1, 0x2C, 0xB2, 0xA8, 0xEF, 0x23,
 366         0xCE, 0x2E, 0xB0, 0x4E, 0x18, 0x31, 0x95, 0x5B,
 367         0x98, 0x2D, 0x9B, 0x8C, 0xE3, 0x1A, 0x2B, 0x96,
 368         0xB5, 0xC7, 0xEE, 0xED, 0x72, 0x43, 0x2D, 0xFE,
 369         0x7F, 0x61, 0x33, 0xEA, 0x14, 0xFC, 0xDE, 0x80,
 370         0x17, 0x42, 0xF0, 0xF3, 0xC3, 0xC7, 0x89, 0x47,
 371         0x76, 0x5B, 0xFA, 0x33, 0xC4, 0x8C, 0x94, 0xDE,
 372         0x6A, 0x75, 0xD8, 0x1A, 0xF4, 0x49, 0xBC, 0xF3,
 373         0xB7, 0x9E, 0x2C, 0x8D, 0xEC, 0x5A, 0xEE, 0xBF,
 374         0x4B, 0x5A, 0x7F, 0xEF, 0x21, 0x39, 0xDB, 0x1D,
 375         0x83, 0x5E, 0x7E, 0x2F, 0xAA, 0x5E, 0xBA, 0x28,
 376         0xC3, 0xA2, 0x53, 0x19, 0xFB, 0x2F, 0x78, 0x6B,
 377         0x14, 0x60, 0x49, 0x3C, 0xCC, 0x1B, 0xE9, 0x1E,
 378         0x3D, 0x10, 0xA4, 0xEB, 0x7F, 0x66, 0x98, 0xF6,
 379         0xC3, 0xAC, 0x35, 0xF5, 0x01, 0x84, 0xFF, 0x7D,
 380         0x1F, 0x72, 0xBE, 0xB4, 0xD1, 0x89, 0xC8, 0xDD,
 381         0x44, 0xE7, 0xB5, 0x2E, 0x2C, 0xE1, 0x85, 0xF5,
 382         0x15, 0x50, 0xA9, 0x08, 0xC7, 0x67, 0xD9, 0x2B,
 383         0x6C, 0x11, 0xB3, 0xEB, 0x28, 0x8D, 0xF4, 0xCC,
 384         0xE3, 0xC3, 0xC5, 0x04, 0x0E, 0x7C, 0x8D, 0xDB,
 385         0x39, 0x06, 0x6A, 0x74, 0x75, 0xDF, 0xA8, 0x0F,
 386         0xDA, 0x67, 0x5A, 0x73, 0x1E, 0xFD, 0x8E, 0x4C,
 387         0xEE, 0x17, 0xEE, 0x1E, 0x67, 0xDB, 0x98, 0x70,
 388         0x60, 0xF7, 0xB9, 0xB5, 0x1F, 0x19, 0x93, 0xD6,
 389         0x3F, 0x2F, 0x1F, 0xB6, 0x5B, 0x59, 0xAA, 0x85,
 390         0xBB, 0x25, 0xE4, 0x13, 0xEF, 0xE7, 0xB9, 0x87,
 391         0x9C, 0x3F, 0x5E, 0xE4, 0x08, 0xA3, 0x51, 0xCF,
 392         0x8B, 0xAD, 0xF4, 0xE6, 0x1A, 0x5F, 0x51, 0xDD,
 393         0xA8, 0xBE, 0xE8, 0xD1, 0x20, 0x19, 0x61, 0x6C,
 394         0x18, 0xAB, 0xCA, 0x0A, 0xD9, 0x82, 0xA6, 0x94,
 395         0xD5, 0x69, 0x2A, 0xF6, 0x43, 0x66, 0x31, 0x09
 396 };
 397
 398 static const unsigned char RSA_E[] = {
 399         0x01, 0x00, 0x01
 400 };
 401
 402 static const unsigned char RSA_P[] = {
 403         0xFD, 0x39, 0x40, 0x56, 0x20, 0x80, 0xC5, 0x81,
 404         0x4C, 0x5F, 0x0C, 0x1A, 0x52, 0x84, 0x03, 0x2F,
 405         0xCE, 0x82, 0xB0, 0xD8, 0x30, 0x23, 0x7F, 0x77,
 406         0x45, 0xC2, 0x01, 0xC4, 0x68, 0x96, 0x0D, 0xA7,
 407         0x22, 0xA9, 0x6C, 0xA9, 0x1A, 0x33, 0xE5, 0x2F,
 408         0xB5, 0x07, 0x9A, 0xF9, 0xEA, 0x33, 0xA5, 0xC8,
 409         0x96, 0x60, 0x6A, 0xCA, 0xEB, 0xE5, 0x6E, 0x09,
 410         0x46, 0x7E, 0x2D, 0xEF, 0x93, 0x7D, 0x56, 0xED,
 411         0x75, 0x70, 0x3B, 0x96, 0xC4, 0xD5, 0xDB, 0x0B,
 412         0x3F, 0x69, 0xDF, 0x06, 0x18, 0x76, 0xF4, 0xCF,
 413         0xF8, 0x84, 0x22, 0xDF, 0xBD, 0x71, 0x62, 0x7B,
 414         0x67, 0x99, 0xBC, 0x09, 0x95, 0x54, 0xA4, 0x98,
 415         0x83, 0xF5, 0xA9, 0xCF, 0x09, 0xA5, 0x1F, 0x61,
 416         0x25, 0xB4, 0x70, 0x6C, 0x91, 0xB8, 0xB3, 0xD0,
 417         0xCE, 0x9C, 0x45, 0x65, 0x9B, 0xEF, 0xD4, 0x70,
 418         0xBE, 0x86, 0xD2, 0x98, 0x5D, 0xEB, 0xE3, 0xFF
 419 };
 420
 421 static const unsigned char RSA_Q[] = {
 422         0xEC, 0x82, 0xEE, 0x63, 0x5F, 0x40, 0x52, 0xDB,
 423         0x38, 0x7A, 0x37, 0x6A, 0x54, 0x5B, 0xD9, 0xA0,
 424         0x73, 0xB4, 0xBB, 0x52, 0xB2, 0x84, 0x07, 0xD0,
 425         0xCC, 0x82, 0x0D, 0x20, 0xB3, 0xFA, 0xD5, 0xB6,
 426         0x25, 0x92, 0x35, 0x4D, 0xB4, 0xC7, 0x36, 0x48,
 427         0xCE, 0x5E, 0x21, 0x4A, 0xA6, 0x74, 0x65, 0xF4,
 428         0x7D, 0x1D, 0xBC, 0x3B, 0xE2, 0xF4, 0x3E, 0x11,
 429         0x58, 0x10, 0x6C, 0x04, 0x46, 0x9E, 0x8D, 0x57,
 430         0xE0, 0x04, 0xE2, 0xEC, 0x47, 0xCF, 0xB3, 0x2A,
 431         0xFD, 0x4C, 0x55, 0x18, 0xDB, 0xDE, 0x3B, 0xDC,
 432         0xF4, 0x5B, 0xDA, 0xF3, 0x1A, 0xC8, 0x41, 0x6F,
 433         0x73, 0x3B, 0xFE, 0x3C, 0xA0, 0xDB, 0xBA, 0x6E,
 434         0x65, 0xA5, 0xE8, 0x02, 0xA5, 0x6C, 0xEA, 0x03,
 435         0xF6, 0x99, 0xF7, 0xCB, 0x4B, 0xB7, 0x11, 0x51,
 436         0x93, 0x88, 0x3F, 0xF9, 0x06, 0x85, 0xA9, 0x1E,
 437         0xCA, 0x64, 0xF8, 0x11, 0xA5, 0x1A, 0xCA, 0xF7
 438 };
 439
 440 static const unsigned char RSA_DP[] = {
 441         0x77, 0x95, 0xE0, 0x02, 0x4C, 0x9B, 0x43, 0xAA,
 442         0xCA, 0x4C, 0x60, 0xC4, 0xD5, 0x8F, 0x2E, 0x8A,
 443         0x17, 0x36, 0xB5, 0x19, 0x83, 0xB2, 0x5F, 0xF2,
 444         0x0D, 0xE9, 0x8F, 0x38, 0x18, 0x44, 0x34, 0xF2,
 445         0x67, 0x76, 0x27, 0xB0, 0xBC, 0x85, 0x21, 0x89,
 446         0x24, 0x2F, 0x11, 0x4B, 0x51, 0x05, 0x4F, 0x17,
 447         0xA9, 0x9C, 0xA3, 0x12, 0x6D, 0xD1, 0x0D, 0xE4,
 448         0x27, 0x7C, 0x53, 0x69, 0x3E, 0xF8, 0x04, 0x63,
 449         0x64, 0x00, 0xBA, 0xC3, 0x7A, 0xF5, 0x9B, 0xDA,
 450         0x75, 0xFA, 0x23, 0xAF, 0x17, 0x42, 0xA6, 0x5E,
 451         0xC8, 0xF8, 0x6E, 0x17, 0xC7, 0xB9, 0x92, 0x4E,
 452         0xC1, 0x20, 0x63, 0x23, 0x0B, 0x78, 0xCB, 0xBA,
 453         0x93, 0x27, 0x23, 0x28, 0x79, 0x5F, 0x97, 0xB0,
 454         0x23, 0x44, 0x51, 0x8B, 0x94, 0x4D, 0xEB, 0xED,
 455         0x82, 0x85, 0x5E, 0x68, 0x9B, 0xF9, 0xE9, 0x13,
 456         0xCD, 0x86, 0x92, 0x52, 0x0E, 0x98, 0xE6, 0x35
 457 };
 458
 459 static const unsigned char RSA_DQ[] = {
 460         0xD8, 0xDD, 0x71, 0xB3, 0x62, 0xBA, 0xBB, 0x7E,
 461         0xD1, 0xF9, 0x96, 0xE8, 0x83, 0xB3, 0xB9, 0x08,
 462         0x9C, 0x30, 0x03, 0x77, 0xDF, 0xC2, 0x9A, 0xDC,
 463         0x05, 0x39, 0xD6, 0xC9, 0xBE, 0xDE, 0x68, 0xA9,
 464         0xDD, 0x27, 0x84, 0x82, 0xDD, 0x19, 0xB1, 0x97,
 465         0xEE, 0xCA, 0x77, 0x22, 0x59, 0x20, 0xEF, 0xFF,
 466         0xCF, 0xDD, 0xBD, 0x24, 0xF8, 0x84, 0xD6, 0x88,
 467         0xD6, 0xC4, 0x30, 0x17, 0x77, 0x9D, 0x98, 0xA3,
 468         0x14, 0x01, 0xC7, 0x05, 0xBB, 0x0F, 0x23, 0x0D,
 469         0x6F, 0x37, 0x57, 0xEC, 0x34, 0x67, 0x41, 0x62,
 470         0xE8, 0x19, 0x75, 0xD9, 0x66, 0x1C, 0x6B, 0x8B,
 471         0xC3, 0x11, 0x26, 0x9C, 0xF7, 0x2E, 0xA3, 0x72,
 472         0xE8, 0xF7, 0xC8, 0x96, 0xEC, 0x92, 0xC2, 0xBD,
 473         0xA1, 0x98, 0x2A, 0x93, 0x99, 0xB8, 0xA2, 0x43,
 474         0xB7, 0xD0, 0xBE, 0x40, 0x1C, 0x8F, 0xE0, 0xB4,
 475         0x20, 0x07, 0x97, 0x43, 0xAE, 0xAD, 0xB3, 0x9F
 476 };
 477
 478 static const unsigned char RSA_IQ[] = {
 479         0xB7, 0xE2, 0x60, 0xA9, 0x62, 0xEC, 0xEC, 0x0B,
 480         0x57, 0x02, 0x96, 0xF9, 0x36, 0x35, 0x2C, 0x37,
 481         0xAF, 0xC2, 0xEE, 0x71, 0x49, 0x26, 0x8E, 0x0F,
 482         0x27, 0xB1, 0xFA, 0x0F, 0xEA, 0xDC, 0xF0, 0x8B,
 483         0x53, 0x6C, 0xB2, 0x46, 0x27, 0xCD, 0x29, 0xA2,
 484         0x35, 0x0F, 0x5D, 0x8A, 0x3F, 0x20, 0x8C, 0x13,
 485         0x3D, 0xA1, 0xFF, 0x85, 0x91, 0x99, 0xE8, 0x50,
 486         0xED, 0xF1, 0x29, 0x00, 0xEE, 0x24, 0x90, 0xB5,
 487         0x5F, 0x3A, 0x74, 0x26, 0xD7, 0xA2, 0x24, 0x8D,
 488         0x89, 0x88, 0xD8, 0x35, 0x22, 0x22, 0x8A, 0x66,
 489         0x5D, 0x5C, 0xDE, 0x83, 0x8C, 0xFA, 0x27, 0xE6,
 490         0xB9, 0xEB, 0x72, 0x08, 0xCD, 0x53, 0x4B, 0x93,
 491         0x0F, 0xAD, 0xC3, 0xF8, 0x7C, 0xFE, 0x84, 0xD7,
 492         0x08, 0xF3, 0xBE, 0x3D, 0x60, 0x1E, 0x95, 0x8D,
 493         0x44, 0x5B, 0x65, 0x7E, 0xC1, 0x30, 0xC3, 0x84,
 494         0xC0, 0xB0, 0xFE, 0xBF, 0x28, 0x54, 0x1E, 0xC4
 495 };
 496
 497 static const br_rsa_public_key RSA_PK = {
 498         (void *)RSA_N, sizeof RSA_N,
 499         (void *)RSA_E, sizeof RSA_E
 500 };
 501
 502 static const br_rsa_private_key RSA_SK = {
 503         2048,
 504         (void *)RSA_P, sizeof RSA_P,
 505         (void *)RSA_Q, sizeof RSA_Q,
 506         (void *)RSA_DP, sizeof RSA_DP,
 507         (void *)RSA_DQ, sizeof RSA_DQ,
 508         (void *)RSA_IQ, sizeof RSA_IQ
 509 };
 510
 511 static void
 512 test_speed_rsa_inner(char *name,
 513         br_rsa_public fpub, br_rsa_private fpriv)
 514 {
 515         unsigned char tmp[sizeof RSA_N];
 516         int i;
 517         long num;
 518
 519         memset(tmp, 'R', sizeof tmp);
 520         tmp[0] = 0;
 521         for (i = 0; i < 10; i ++) {
 522                 if (!fpriv(tmp, &RSA_SK)) {
 523                         abort();
 524                 }
 525         }
 526         num = 10;
 527         for (;;) {
 528                 clock_t begin, end;
 529                 double tt;
 530                 long k;
 531
 532                 begin = clock();
 533                 for (k = num; k > 0; k --) {
 534                         fpriv(tmp, &RSA_SK);
 535                 }
 536                 end = clock();
 537                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 538                 if (tt >= 2.0) {
 539                         printf("%-30s %8.2f priv/s\n", name,
 540                                 (double)num / tt);
 541                         fflush(stdout);
 542                         break;
 543                 }
 544                 num <<= 1;
 545         }
 546         for (i = 0; i < 10; i ++) {
 547                 if (!fpub(tmp, sizeof tmp, &RSA_PK)) {
 548                         abort();
 549                 }
 550         }
 551         num = 10;
 552         for (;;) {
 553                 clock_t begin, end;
 554                 double tt;
 555                 long k;
 556
 557                 begin = clock();
 558                 for (k = num; k > 0; k --) {
 559                         fpub(tmp, sizeof tmp, &RSA_PK);
 560                 }
 561                 end = clock();
 562                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 563                 if (tt >= 2.0) {
 564                         printf("%-30s %8.2f pub/s\n", name,
 565                                 (double)num / tt);
 566                         fflush(stdout);
 567                         break;
 568                 }
 569                 num <<= 1;
 570         }
 571 }
 572
 573 static void
 574 test_speed_rsa_i15(void)
 575 {
 576         test_speed_rsa_inner("RSA i15",
 577                 &br_rsa_i15_public, &br_rsa_i15_private);
 578 }
 579
 580 static void
 581 test_speed_rsa_i31(void)
 582 {
 583         test_speed_rsa_inner("RSA i31",
 584                 &br_rsa_i31_public, &br_rsa_i31_private);
 585 }
 586
 587 static void
 588 test_speed_rsa_i32(void)
 589 {
 590         test_speed_rsa_inner("RSA i32",
 591                 &br_rsa_i32_public, &br_rsa_i32_private);
 592 }
 593
 594 static void
 595 test_speed_ec_inner_1(const char *name,
 596         const br_ec_impl *impl, const br_ec_curve_def *cd)
 597 {
 598         unsigned char bx[80], U[160];
 599         uint32_t x[22], n[22];
 600         size_t nlen, ulen;
 601         int i;
 602         long num;
 603
 604         nlen = cd->order_len;
 605         br_i31_decode(n, cd->order, nlen);
 606         memset(bx, 'T', sizeof bx);
 607         br_i31_decode_reduce(x, bx, sizeof bx, n);
 608         br_i31_encode(bx, nlen, x);
 609         ulen = cd->generator_len;
 610         memcpy(U, cd->generator, ulen);
 611         for (i = 0; i < 10; i ++) {
 612                 impl->mul(U, ulen, bx, nlen, cd->curve);
 613         }
 614         num = 10;
 615         for (;;) {
 616                 clock_t begin, end;
 617                 double tt;
 618                 long k;
 619
 620                 begin = clock();
 621                 for (k = num; k > 0; k --) {
 622                         impl->mul(U, ulen, bx, nlen, cd->curve);
 623                 }
 624                 end = clock();
 625                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 626                 if (tt >= 2.0) {
 627                         printf("%-30s %8.2f mul/s\n", name,
 628                                 (double)num / tt);
 629                         fflush(stdout);
 630                         break;
 631                 }
 632                 num <<= 1;
 633         }
 634 }
 635
 636 static void
 637 test_speed_ec_inner_2(const char *name,
 638         const br_ec_impl *impl, const br_ec_curve_def *cd)
 639 {
 640         unsigned char bx[80], U[160];
 641         uint32_t x[22], n[22];
 642         size_t nlen;
 643         int i;
 644         long num;
 645
 646         nlen = cd->order_len;
 647         br_i31_decode(n, cd->order, nlen);
 648         memset(bx, 'T', sizeof bx);
 649         br_i31_decode_reduce(x, bx, sizeof bx, n);
 650         br_i31_encode(bx, nlen, x);
 651         for (i = 0; i < 10; i ++) {
 652                 impl->mulgen(U, bx, nlen, cd->curve);
 653         }
 654         num = 10;
 655         for (;;) {
 656                 clock_t begin, end;
 657                 double tt;
 658                 long k;
 659
 660                 begin = clock();
 661                 for (k = num; k > 0; k --) {
 662                         impl->mulgen(U, bx, nlen, cd->curve);
 663                 }
 664                 end = clock();
 665                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 666                 if (tt >= 2.0) {
 667                         printf("%-30s %8.2f mul/s\n", name,
 668                                 (double)num / tt);
 669                         fflush(stdout);
 670                         break;
 671                 }
 672                 num <<= 1;
 673         }
 674 }
 675
 676 static void
 677 test_speed_ec_inner(const char *name,
 678         const br_ec_impl *impl, const br_ec_curve_def *cd)
 679 {
 680         char tmp[50];
 681
 682         test_speed_ec_inner_1(name, impl, cd);
 683         sprintf(tmp, "%s (FP)", name);
 684         test_speed_ec_inner_2(tmp, impl, cd);
 685 }
 686
 687 static void
 688 test_speed_ec_p256_m15(void)
 689 {
 690         test_speed_ec_inner("EC p256_m15",
 691                 &br_ec_p256_m15, &br_secp256r1);
 692 }
 693
 694 static void
 695 test_speed_ec_p256_m31(void)
 696 {
 697         test_speed_ec_inner("EC p256_m31",
 698                 &br_ec_p256_m31, &br_secp256r1);
 699 }
 700
 701 static void
 702 test_speed_ec_prime_i15(void)
 703 {
 704         test_speed_ec_inner("EC prime_i15 P-256",
 705                 &br_ec_prime_i15, &br_secp256r1);
 706         test_speed_ec_inner("EC prime_i15 P-384",
 707                 &br_ec_prime_i15, &br_secp384r1);
 708         test_speed_ec_inner("EC prime_i15 P-521",
 709                 &br_ec_prime_i15, &br_secp521r1);
 710 }
 711
 712 static void
 713 test_speed_ec_prime_i31(void)
 714 {
 715         test_speed_ec_inner("EC prime_i31 P-256",
 716                 &br_ec_prime_i31, &br_secp256r1);
 717         test_speed_ec_inner("EC prime_i31 P-384",
 718                 &br_ec_prime_i31, &br_secp384r1);
 719         test_speed_ec_inner("EC prime_i31 P-521",
 720                 &br_ec_prime_i31, &br_secp521r1);
 721 }
 722
 723 static void
 724 test_speed_ec_c25519_i15(void)
 725 {
 726         test_speed_ec_inner("EC c25519_i15",
 727                 &br_ec_c25519_i15, &br_curve25519);
 728 }
 729
 730 static void
 731 test_speed_ec_c25519_i31(void)
 732 {
 733         test_speed_ec_inner("EC c25519_i31",
 734                 &br_ec_c25519_i31, &br_curve25519);
 735 }
 736
 737 static void
 738 test_speed_ec_c25519_m15(void)
 739 {
 740         test_speed_ec_inner("EC c25519_m15",
 741                 &br_ec_c25519_m15, &br_curve25519);
 742 }
 743
 744 static void
 745 test_speed_ec_c25519_m31(void)
 746 {
 747         test_speed_ec_inner("EC c25519_m31",
 748                 &br_ec_c25519_m31, &br_curve25519);
 749 }
 750
 751 static void
 752 test_speed_ecdsa_inner(const char *name,
 753         const br_ec_impl *impl, const br_ec_curve_def *cd,
 754         br_ecdsa_sign sign, br_ecdsa_vrfy vrfy)
 755 {
 756         unsigned char bx[80], U[160], hv[32], sig[160];
 757         uint32_t x[22], n[22];
 758         size_t nlen, ulen, sig_len;
 759         int i;
 760         long num;
 761         br_ec_private_key sk;
 762         br_ec_public_key pk;
 763
 764         nlen = cd->order_len;
 765         br_i31_decode(n, cd->order, nlen);
 766         memset(bx, 'T', sizeof bx);
 767         br_i31_decode_reduce(x, bx, sizeof bx, n);
 768         br_i31_encode(bx, nlen, x);
 769         ulen = cd->generator_len;
 770         memcpy(U, cd->generator, ulen);
 771         impl->mul(U, ulen, bx, nlen, cd->curve);
 772         sk.curve = cd->curve;
 773         sk.x = bx;
 774         sk.xlen = nlen;
 775         pk.curve = cd->curve;
 776         pk.q = U;
 777         pk.qlen = ulen;
 778
 779         memset(hv, 'H', sizeof hv);
 780         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
 781         if (vrfy(impl, hv, sizeof hv, &pk, sig, sig_len) != 1) {
 782                 fprintf(stderr, "self-test sign/verify failed\n");
 783                 exit(EXIT_FAILURE);
 784         }
 785
 786         for (i = 0; i < 10; i ++) {
 787                 hv[1] ++;
 788                 sign(impl, &br_sha256_vtable, hv, &sk, sig);
 789                 vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
 790         }
 791
 792         num = 10;
 793         for (;;) {
 794                 clock_t begin, end;
 795                 double tt;
 796                 long k;
 797
 798                 begin = clock();
 799                 for (k = num; k > 0; k --) {
 800                         hv[1] ++;
 801                         sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
 802                 }
 803                 end = clock();
 804                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 805                 if (tt >= 2.0) {
 806                         printf("%-30s %8.2f sign/s\n", name,
 807                                 (double)num / tt);
 808                         fflush(stdout);
 809                         break;
 810                 }
 811                 num <<= 1;
 812         }
 813
 814         num = 10;
 815         for (;;) {
 816                 clock_t begin, end;
 817                 double tt;
 818                 long k;
 819
 820                 begin = clock();
 821                 for (k = num; k > 0; k --) {
 822                         vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
 823                 }
 824                 end = clock();
 825                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 826                 if (tt >= 2.0) {
 827                         printf("%-30s %8.2f verify/s\n", name,
 828                                 (double)num / tt);
 829                         fflush(stdout);
 830                         break;
 831                 }
 832                 num <<= 1;
 833         }
 834 }
 835
 836 static void
 837 test_speed_ecdsa_p256_m15(void)
 838 {
 839         test_speed_ecdsa_inner("ECDSA m15 P-256",
 840                 &br_ec_p256_m15, &br_secp256r1,
 841                 &br_ecdsa_i15_sign_asn1,
 842                 &br_ecdsa_i15_vrfy_asn1);
 843 }
 844
 845 static void
 846 test_speed_ecdsa_p256_m31(void)
 847 {
 848         test_speed_ecdsa_inner("ECDSA m31 P-256",
 849                 &br_ec_p256_m31, &br_secp256r1,
 850                 &br_ecdsa_i31_sign_asn1,
 851                 &br_ecdsa_i31_vrfy_asn1);
 852 }
 853
 854 static void
 855 test_speed_ecdsa_i15(void)
 856 {
 857         test_speed_ecdsa_inner("ECDSA i15 P-256",
 858                 &br_ec_prime_i15, &br_secp256r1,
 859                 &br_ecdsa_i15_sign_asn1,
 860                 &br_ecdsa_i15_vrfy_asn1);
 861         test_speed_ecdsa_inner("ECDSA i15 P-384",
 862                 &br_ec_prime_i15, &br_secp384r1,
 863                 &br_ecdsa_i15_sign_asn1,
 864                 &br_ecdsa_i15_vrfy_asn1);
 865         test_speed_ecdsa_inner("ECDSA i15 P-521",
 866                 &br_ec_prime_i15, &br_secp521r1,
 867                 &br_ecdsa_i15_sign_asn1,
 868                 &br_ecdsa_i15_vrfy_asn1);
 869 }
 870
 871 static void
 872 test_speed_ecdsa_i31(void)
 873 {
 874         test_speed_ecdsa_inner("ECDSA i31 P-256",
 875                 &br_ec_prime_i31, &br_secp256r1,
 876                 &br_ecdsa_i31_sign_asn1,
 877                 &br_ecdsa_i31_vrfy_asn1);
 878         test_speed_ecdsa_inner("ECDSA i31 P-384",
 879                 &br_ec_prime_i31, &br_secp384r1,
 880                 &br_ecdsa_i31_sign_asn1,
 881                 &br_ecdsa_i31_vrfy_asn1);
 882         test_speed_ecdsa_inner("ECDSA i31 P-521",
 883                 &br_ec_prime_i31, &br_secp521r1,
 884                 &br_ecdsa_i31_sign_asn1,
 885                 &br_ecdsa_i31_vrfy_asn1);
 886 }
 887
 888 static void
 889 test_speed_i31(void)
 890 {
 891         static const unsigned char bp[] = {
 892                 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
 893                 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 894                 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
 895                 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
 896         };
 897
 898         unsigned char tmp[60 + sizeof bp];
 899         uint32_t p[10], x[10], y[10], z[10], p0i;
 900         int i;
 901         long num;
 902
 903         br_i31_decode(p, bp, sizeof bp);
 904         p0i = br_i31_ninv31(p[1]);
 905         memset(tmp, 'T', sizeof tmp);
 906         br_i31_decode_reduce(x, tmp, sizeof tmp, p);
 907         memset(tmp, 'U', sizeof tmp);
 908         br_i31_decode_reduce(y, tmp, sizeof tmp, p);
 909
 910         for (i = 0; i < 10; i ++) {
 911                 br_i31_to_monty(x, p);
 912         }
 913         num = 10;
 914         for (;;) {
 915                 clock_t begin, end;
 916                 double tt;
 917                 long k;
 918
 919                 begin = clock();
 920                 for (k = num; k > 0; k --) {
 921                         br_i31_to_monty(x, p);
 922                 }
 923                 end = clock();
 924                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 925                 if (tt >= 2.0) {
 926                         printf("%-30s %8.2f ops/s\n", "i31 to_monty",
 927                                 (double)num / tt);
 928                         fflush(stdout);
 929                         break;
 930                 }
 931                 num <<= 1;
 932         }
 933
 934         for (i = 0; i < 10; i ++) {
 935                 br_i31_from_monty(x, p, p0i);
 936         }
 937         num = 10;
 938         for (;;) {
 939                 clock_t begin, end;
 940                 double tt;
 941                 long k;
 942
 943                 begin = clock();
 944                 for (k = num; k > 0; k --) {
 945                         br_i31_from_monty(x, p, p0i);
 946                 }
 947                 end = clock();
 948                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 949                 if (tt >= 2.0) {
 950                         printf("%-30s %8.2f ops/s\n", "i31 from_monty",
 951                                 (double)num / tt);
 952                         fflush(stdout);
 953                         break;
 954                 }
 955                 num <<= 1;
 956         }
 957
 958         for (i = 0; i < 10; i ++) {
 959                 br_i31_montymul(z, x, y, p, p0i);
 960         }
 961         num = 10;
 962         for (;;) {
 963                 clock_t begin, end;
 964                 double tt;
 965                 long k;
 966
 967                 begin = clock();
 968                 for (k = num; k > 0; k --) {
 969                         br_i31_montymul(z, x, y, p, p0i);
 970                 }
 971                 end = clock();
 972                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
 973                 if (tt >= 2.0) {
 974                         printf("%-30s %8.2f ops/s\n", "i31 montymul",
 975                                 (double)num / tt);
 976                         fflush(stdout);
 977                         break;
 978                 }
 979                 num <<= 1;
 980         }
 981 }
 982
 983 #if 0
 984
 985 static unsigned char P2048[] = {
 986         0xFD, 0xB6, 0xE0, 0x3E, 0x00, 0x49, 0x4C, 0xF0, 0x69, 0x3A, 0xDD, 0x7D,
 987         0xF8, 0xA2, 0x41, 0xB0, 0x6C, 0x67, 0xC5, 0xBA, 0xB8, 0x46, 0x80, 0xF5,
 988         0xBF, 0xAB, 0x98, 0xFC, 0x84, 0x73, 0xA5, 0x63, 0xC9, 0x52, 0x12, 0xDA,
 989         0x4C, 0xC1, 0x5B, 0x9D, 0x8D, 0xDF, 0xCD, 0xFE, 0xC5, 0xAD, 0x5A, 0x6F,
 990         0xDD, 0x02, 0xD9, 0xEC, 0x71, 0xEF, 0xEB, 0xB6, 0x95, 0xED, 0x94, 0x25,
 991         0x0E, 0x63, 0xDD, 0x6A, 0x52, 0xC7, 0x93, 0xAF, 0x85, 0x9D, 0x2C, 0xBE,
 992         0x5C, 0xBE, 0x35, 0xD8, 0xDD, 0x39, 0xEF, 0x1B, 0xB1, 0x49, 0x67, 0xB2,
 993         0x33, 0xC9, 0x7C, 0xE1, 0x51, 0x79, 0x51, 0x59, 0xCA, 0x6E, 0x2A, 0xDF,
 994         0x0D, 0x76, 0x1C, 0xE7, 0xA5, 0xC0, 0x1E, 0x6C, 0x56, 0x3A, 0x32, 0xE5,
 995         0xB5, 0xC5, 0xD4, 0xDB, 0xFE, 0xFF, 0xF8, 0xF2, 0x96, 0xA9, 0xC9, 0x65,
 996         0x59, 0x9E, 0x01, 0x79, 0x9D, 0x38, 0x68, 0x0F, 0xAD, 0x43, 0x3A, 0xD6,
 997         0x84, 0x0A, 0xE2, 0xEF, 0x96, 0xC1, 0x6D, 0x89, 0x74, 0x19, 0x63, 0x82,
 998         0x3B, 0xA0, 0x9C, 0xBA, 0x78, 0xDE, 0xDC, 0xC2, 0xE7, 0xD4, 0xFA, 0xD6,
 999         0x19, 0x21, 0x29, 0xAE, 0x5E, 0xF4, 0x38, 0x81, 0xC6, 0x9E, 0x0E, 0x3C,
1000         0xCD, 0xC0, 0xDC, 0x93, 0x5D, 0xFD, 0x9A, 0x5C, 0xAB, 0x54, 0x1F, 0xFF,
1001         0x9C, 0x12, 0x1B, 0x4C, 0xDF, 0x2D, 0x9C, 0x85, 0xF9, 0x68, 0x15, 0x89,
1002         0x42, 0x9B, 0x6C, 0x45, 0x89, 0x3A, 0xBC, 0xE9, 0x19, 0x91, 0xBE, 0x0C,
1003         0xEF, 0x90, 0xCC, 0xF6, 0xD6, 0xF0, 0x3D, 0x5C, 0xF5, 0xE5, 0x0F, 0x2F,
1004         0x02, 0x8A, 0x83, 0x4B, 0x93, 0x2F, 0x14, 0x12, 0x1F, 0x56, 0x9A, 0x12,
1005         0x58, 0x88, 0xAE, 0x60, 0xB8, 0x5A, 0xE4, 0xA1, 0xBF, 0x4A, 0x81, 0x84,
1006         0xAB, 0xBB, 0xE4, 0xD0, 0x1D, 0x41, 0xD9, 0x0A, 0xAB, 0x1E, 0x47, 0x5B,
1007         0x31, 0xAC, 0x2B, 0x73
1008 };
1009
1010 static unsigned char G2048[] = {
1011         0x02
1012 };
1013
1014 static void
1015 test_speed_modpow(void)
1016 {
1017         uint32_t mx[65], mp[65], me[65], t1[65], t2[65], len;
1018         unsigned char e[64];
1019         int i;
1020         long num;
1021
1022         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1023                 P2048, sizeof P2048);
1024         if (len != 65) {
1025                 abort();
1026         }
1027         memset(e, 'P', sizeof e);
1028         if (!br_int_decode(me, sizeof me / sizeof me[0], e, sizeof e)) {
1029                 abort();
1030         }
1031         if (!br_modint_decode(mx, mp, G2048, sizeof G2048)) {
1032                 abort();
1033         }
1034         for (i = 0; i < 10; i ++) {
1035                 br_modint_to_monty(mx, mp);
1036                 br_modint_montypow(mx, me, mp, t1, t2);
1037                 br_modint_from_monty(mx, mp);
1038         }
1039         num = 10;
1040         for (;;) {
1041                 clock_t begin, end;
1042                 double tt;
1043                 long k;
1044
1045                 begin = clock();
1046                 for (k = num; k > 0; k --) {
1047                         br_modint_to_monty(mx, mp);
1048                         br_modint_montypow(mx, me, mp, t1, t2);
1049                         br_modint_from_monty(mx, mp);
1050                 }
1051                 end = clock();
1052                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1053                 if (tt >= 2.0) {
1054                         printf("%-30s %8.2f exp/s\n", "pow[2048:256]",
1055                                 (double)num / tt);
1056                         fflush(stdout);
1057                         return;
1058                 }
1059                 num <<= 1;
1060         }
1061 }
1062
1063 static void
1064 test_speed_moddiv(void)
1065 {
1066         uint32_t mx[65], my[65], mp[65], t1[65], t2[65], t3[65], len;
1067         unsigned char x[255], y[255];
1068         int i;
1069         long num;
1070
1071         len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1072                 P2048, sizeof P2048);
1073         if (len != 65) {
1074                 abort();
1075         }
1076         memset(x, 'T', sizeof x);
1077         memset(y, 'P', sizeof y);
1078         if (!br_modint_decode(mx, mp, x, sizeof x)) {
1079                 abort();
1080         }
1081         if (!br_modint_decode(my, mp, y, sizeof y)) {
1082                 abort();
1083         }
1084         for (i = 0; i < 10; i ++) {
1085                 br_modint_div(mx, my, mp, t1, t2, t3);
1086         }
1087         num = 10;
1088         for (;;) {
1089                 clock_t begin, end;
1090                 double tt;
1091                 long k;
1092
1093                 begin = clock();
1094                 for (k = num; k > 0; k --) {
1095                         br_modint_div(mx, my, mp, t1, t2, t3);
1096                 }
1097                 end = clock();
1098                 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1099                 if (tt >= 2.0) {
1100                         printf("%-30s %8.2f div/s\n", "div[2048]",
1101                                 (double)num / tt);
1102                         fflush(stdout);
1103                         return;
1104                 }
1105                 num <<= 1;
1106         }
1107 }
1108 #endif
1109
1110 #define STU(x)   { test_speed_ ## x, #x }
1111
1112 static const struct {
1113         void (*fn)(void);
1114         char *name;
1115 } tfns[] = {
1116         STU(md5),
1117         STU(sha1),
1118         STU(sha256),
1119         STU(sha512),
1120
1121         STU(aes128_big_cbcenc),
1122         STU(aes128_big_cbcdec),
1123         STU(aes192_big_cbcenc),
1124         STU(aes192_big_cbcdec),
1125         STU(aes256_big_cbcenc),
1126         STU(aes256_big_cbcdec),
1127         STU(aes128_big_ctr),
1128         STU(aes192_big_ctr),
1129         STU(aes256_big_ctr),
1130
1131         STU(aes128_small_cbcenc),
1132         STU(aes128_small_cbcdec),
1133         STU(aes192_small_cbcenc),
1134         STU(aes192_small_cbcdec),
1135         STU(aes256_small_cbcenc),
1136         STU(aes256_small_cbcdec),
1137         STU(aes128_small_ctr),
1138         STU(aes192_small_ctr),
1139         STU(aes256_small_ctr),
1140
1141         STU(aes128_ct_cbcenc),
1142         STU(aes128_ct_cbcdec),
1143         STU(aes192_ct_cbcenc),
1144         STU(aes192_ct_cbcdec),
1145         STU(aes256_ct_cbcenc),
1146         STU(aes256_ct_cbcdec),
1147         STU(aes128_ct_ctr),
1148         STU(aes192_ct_ctr),
1149         STU(aes256_ct_ctr),
1150
1151         STU(aes128_ct64_cbcenc),
1152         STU(aes128_ct64_cbcdec),
1153         STU(aes192_ct64_cbcenc),
1154         STU(aes192_ct64_cbcdec),
1155         STU(aes256_ct64_cbcenc),
1156         STU(aes256_ct64_cbcdec),
1157         STU(aes128_ct64_ctr),
1158         STU(aes192_ct64_ctr),
1159         STU(aes256_ct64_ctr),
1160
1161         STU(des_tab_cbcenc),
1162         STU(des_tab_cbcdec),
1163         STU(3des_tab_cbcenc),
1164         STU(3des_tab_cbcdec),
1165
1166         STU(des_ct_cbcenc),
1167         STU(des_ct_cbcdec),
1168         STU(3des_ct_cbcenc),
1169         STU(3des_ct_cbcdec),
1170
1171         STU(chacha20_ct),
1172
1173         STU(ghash_ctmul),
1174         STU(ghash_ctmul32),
1175         STU(ghash_ctmul64),
1176
1177         STU(poly1305_ctmul),
1178         STU(poly1305_ctmul32),
1179         STU(poly1305_i15),
1180
1181         STU(rsa_i15),
1182         STU(rsa_i31),
1183         STU(rsa_i32),
1184         STU(ec_prime_i15),
1185         STU(ec_prime_i31),
1186         STU(ec_p256_m15),
1187         STU(ec_p256_m31),
1188         STU(ec_c25519_i15),
1189         STU(ec_c25519_i31),
1190         STU(ec_c25519_m15),
1191         STU(ec_c25519_m31),
1192         STU(ecdsa_p256_m15),
1193         STU(ecdsa_p256_m31),
1194         STU(ecdsa_i15),
1195         STU(ecdsa_i31),
1196
1197         STU(i31)
1198 };
1199
1200 static int
1201 eq_name(const char *s1, const char *s2)
1202 {
1203         for (;;) {
1204                 int c1, c2;
1205
1206                 for (;;) {
1207                         c1 = *s1 ++;
1208                         if (c1 >= 'A' && c1 <= 'Z') {
1209                                 c1 += 'a' - 'A';
1210                         } else {
1211                                 switch (c1) {
1212                                 case '-': case '_': case '.': case ' ':
1213                                         continue;
1214                                 }
1215                         }
1216                         break;
1217                 }
1218                 for (;;) {
1219                         c2 = *s2 ++;
1220                         if (c2 >= 'A' && c2 <= 'Z') {
1221                                 c2 += 'a' - 'A';
1222                         } else {
1223                                 switch (c2) {
1224                                 case '-': case '_': case '.': case ' ':
1225                                         continue;
1226                                 }
1227                         }
1228                         break;
1229                 }
1230                 if (c1 != c2) {
1231                         return 0;
1232                 }
1233                 if (c1 == 0) {
1234                         return 1;
1235                 }
1236         }
1237 }
1238
1239 int
1240 main(int argc, char *argv[])
1241 {
1242         size_t u;
1243
1244         if (argc <= 1) {
1245                 printf("usage: testspeed all | name...\n");
1246                 printf("individual test names:\n");
1247                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1248                         printf("   %s\n", tfns[u].name);
1249                 }
1250         } else {
1251                 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1252                         int i;
1253
1254                         for (i = 1; i < argc; i ++) {
1255                                 if (eq_name(argv[i], tfns[u].name)
1256                                         || eq_name(argv[i], "all"))
1257                                 {
1258                                         tfns[u].fn();
1259                                         break;
1260                                 }
1261                         }
1262                 }
1263         }
1264         return 0;
1265 }