2 * Copyright (c) 2016 Thomas Pornin <pornin@bolet.org>
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:
12 * The above copyright notice and this permission notice shall be
13 * included in all copies or substantial portions of the Software.
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
31 #define HASH_SIZE(cname) br_ ## cname ## _SIZE
33 #define SPEED_HASH(Name, cname) \
35 test_speed_ ## cname(void) \
37 unsigned char buf[8192]; \
38 unsigned char tmp[HASH_SIZE(cname)]; \
39 br_ ## cname ## _context mc; \
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); \
55 br_ ## cname ## _init(&mc); \
57 for (k = num; k > 0; k --) { \
58 br_ ## cname ## _update(&mc, buf, sizeof buf); \
61 br_ ## cname ## _out(&mc, tmp); \
62 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
64 printf("%-30s %8.2f MB/s\n", #Name, \
65 ((double)sizeof buf) * (double)num \
66 / (tt * 1000000.0)); \
74 #define BLOCK_SIZE(cname) br_ ## cname ## _BLOCK_SIZE
76 #define SPEED_BLOCKCIPHER_CBC(Name, fname, cname, klen, dir) \
78 test_speed_ ## fname(void) \
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; \
88 memset(key, 'T', sizeof key); \
89 memset(buf, 'P', sizeof buf); \
90 memset(iv, 'X', sizeof iv); \
91 vt = br_ ## cname ## _cbc ## dir ## _get_vtable(); \
93 printf("%-30s UNAVAILABLE\n", #Name); \
97 for (i = 0; i < 10; i ++) { \
98 vt->init(&ec.vtable, key, sizeof key); \
99 vt->run(&ec.vtable, iv, buf, sizeof buf); \
103 clock_t begin, end; \
107 vt->init(&ec.vtable, key, sizeof key); \
109 for (k = num; k > 0; k --) { \
110 vt->run(&ec.vtable, iv, buf, sizeof buf); \
113 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
115 printf("%-30s %8.2f MB/s\n", #Name, \
116 ((double)sizeof buf) * (double)num \
117 / (tt * 1000000.0)); \
125 #define SPEED_BLOCKCIPHER_CTR(Name, fname, cname, klen) \
127 test_speed_ ## fname(void) \
129 unsigned char key[klen]; \
130 unsigned char buf[8192 - (8192 % BLOCK_SIZE(cname))]; \
131 unsigned char iv[BLOCK_SIZE(cname) - 4]; \
132 const br_block_ctr_class *vt; \
133 br_ ## cname ## _ctr_keys ec; \
137 memset(key, 'T', sizeof key); \
138 memset(buf, 'P', sizeof buf); \
139 memset(iv, 'X', sizeof iv); \
140 vt = br_ ## cname ## _ctr_get_vtable(); \
142 printf("%-30s UNAVAILABLE\n", #Name); \
146 for (i = 0; i < 10; i ++) { \
147 vt->init(&ec.vtable, key, sizeof key); \
148 vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
152 clock_t begin, end; \
156 vt->init(&ec.vtable, key, sizeof key); \
158 for (k = num; k > 0; k --) { \
159 vt->run(&ec.vtable, iv, 1, buf, sizeof buf); \
162 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
164 printf("%-30s %8.2f MB/s\n", #Name, \
165 ((double)sizeof buf) * (double)num \
166 / (tt * 1000000.0)); \
174 #define SPEED_CHACHA20(Name, fname) \
176 test_speed_ ## fname(void) \
178 unsigned char key[32]; \
179 unsigned char buf[8192]; \
180 unsigned char iv[12]; \
184 memset(key, 'T', sizeof key); \
185 memset(buf, 'P', sizeof buf); \
186 memset(iv, 'X', sizeof iv); \
187 for (i = 0; i < 10; i ++) { \
188 br_ ## fname ## _run(key, iv, i, buf, sizeof buf); \
192 clock_t begin, end; \
197 for (k = num; k > 0; k --) { \
198 br_ ## fname ## _run(key, iv, \
199 (uint32_t)k, buf, sizeof buf); \
202 tt = (double)(end - begin) / CLOCKS_PER_SEC; \
204 printf("%-30s %8.2f MB/s\n", #Name, \
205 ((double)sizeof buf) * (double)num \
206 / (tt * 1000000.0)); \
215 SPEED_HASH(SHA
-1, sha1
)
216 SPEED_HASH(SHA
-256, sha256
)
217 SPEED_HASH(SHA
-512, sha512
)
220 * There are no vtable selection functions for the portable implementations,
221 * so we define some custom macros.
223 #define br_aes_big_cbcenc_get_vtable() (&br_aes_big_cbcenc_vtable)
224 #define br_aes_big_cbcdec_get_vtable() (&br_aes_big_cbcdec_vtable)
225 #define br_aes_big_ctr_get_vtable() (&br_aes_big_ctr_vtable)
226 #define br_aes_small_cbcenc_get_vtable() (&br_aes_small_cbcenc_vtable)
227 #define br_aes_small_cbcdec_get_vtable() (&br_aes_small_cbcdec_vtable)
228 #define br_aes_small_ctr_get_vtable() (&br_aes_small_ctr_vtable)
229 #define br_aes_ct_cbcenc_get_vtable() (&br_aes_ct_cbcenc_vtable)
230 #define br_aes_ct_cbcdec_get_vtable() (&br_aes_ct_cbcdec_vtable)
231 #define br_aes_ct_ctr_get_vtable() (&br_aes_ct_ctr_vtable)
232 #define br_aes_ct64_cbcenc_get_vtable() (&br_aes_ct64_cbcenc_vtable)
233 #define br_aes_ct64_cbcdec_get_vtable() (&br_aes_ct64_cbcdec_vtable)
234 #define br_aes_ct64_ctr_get_vtable() (&br_aes_ct64_ctr_vtable)
236 #define SPEED_AES(iname) \
237 SPEED_BLOCKCIPHER_CBC(AES-128 CBC encrypt (iname), aes128_ ## iname ## _cbcenc, aes_ ## iname, 16, enc) \
238 SPEED_BLOCKCIPHER_CBC(AES-128 CBC decrypt (iname), aes128_ ## iname ## _cbcdec, aes_ ## iname, 16, dec) \
239 SPEED_BLOCKCIPHER_CBC(AES-192 CBC encrypt (iname), aes192_ ## iname ## _cbcenc, aes_ ## iname, 24, enc) \
240 SPEED_BLOCKCIPHER_CBC(AES-192 CBC decrypt (iname), aes192_ ## iname ## _cbcdec, aes_ ## iname, 24, dec) \
241 SPEED_BLOCKCIPHER_CBC(AES-256 CBC encrypt (iname), aes256_ ## iname ## _cbcenc, aes_ ## iname, 32, enc) \
242 SPEED_BLOCKCIPHER_CBC(AES-256 CBC decrypt (iname), aes256_ ## iname ## _cbcdec, aes_ ## iname, 32, dec) \
243 SPEED_BLOCKCIPHER_CTR(AES-128 CTR (iname), aes128_ ## iname ## _ctr, aes_ ## iname, 16) \
244 SPEED_BLOCKCIPHER_CTR(AES-192 CTR (iname), aes192_ ## iname ## _ctr, aes_ ## iname, 24) \
245 SPEED_BLOCKCIPHER_CTR(AES-256 CTR (iname), aes256_ ## iname ## _ctr, aes_ ## iname, 32)
254 #define br_des_tab_cbcenc_get_vtable() (&br_des_tab_cbcenc_vtable)
255 #define br_des_tab_cbcdec_get_vtable() (&br_des_tab_cbcdec_vtable)
256 #define br_des_ct_cbcenc_get_vtable() (&br_des_ct_cbcenc_vtable)
257 #define br_des_ct_cbcdec_get_vtable() (&br_des_ct_cbcdec_vtable)
259 #define SPEED_DES(iname) \
260 SPEED_BLOCKCIPHER_CBC(DES CBC encrypt (iname), des_ ## iname ## _cbcenc, des_ ## iname, 8, enc) \
261 SPEED_BLOCKCIPHER_CBC(DES CBC decrypt (iname), des_ ## iname ## _cbcdec, des_ ## iname, 8, dec) \
262 SPEED_BLOCKCIPHER_CBC(3DES CBC encrypt (iname), 3des_ ## iname ## _cbcenc, des_ ## iname, 24, enc) \
263 SPEED_BLOCKCIPHER_CBC(3DES CBC decrypt (iname), 3des_ ## iname ## _cbcdec, des_ ## iname, 24, dec)
268 SPEED_CHACHA20(ChaCha20
, chacha20_ct
)
271 test_speed_ghash_inner(char *name
, br_ghash gh
)
273 unsigned char buf
[8192], h
[16], y
[16];
277 memset(buf
, 'T', sizeof buf
);
278 memset(h
, 'P', sizeof h
);
279 memset(y
, 0, sizeof y
);
280 for (i
= 0; i
< 10; i
++) {
281 gh(y
, h
, buf
, sizeof buf
);
290 for (k
= num
; k
> 0; k
--) {
291 gh(y
, h
, buf
, sizeof buf
);
294 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
296 printf("%-30s %8.2f MB/s\n", name
,
297 ((double)sizeof buf
) * (double)num
307 test_speed_ghash_ctmul(void)
309 test_speed_ghash_inner("GHASH (ctmul)", &br_ghash_ctmul
);
313 test_speed_ghash_ctmul32(void)
315 test_speed_ghash_inner("GHASH (ctmul32)", &br_ghash_ctmul32
);
319 test_speed_ghash_ctmul64(void)
321 test_speed_ghash_inner("GHASH (ctmul64)", &br_ghash_ctmul64
);
325 test_speed_ghash_pclmul(void)
329 gh
= br_ghash_pclmul_get();
331 printf("%-30s UNAVAILABLE\n", "GHASH (pclmul)");
334 test_speed_ghash_inner("GHASH (pclmul)", gh
);
339 test_speed_ghash_pwr8(void)
343 gh
= br_ghash_pwr8_get();
345 printf("%-30s UNAVAILABLE\n", "GHASH (pwr8)");
348 test_speed_ghash_inner("GHASH (pwr8)", gh
);
353 fake_chacha20(const void *key
, const void *iv
,
354 uint32_t cc
, void *data
, size_t len
)
360 return cc
+ (uint32_t)((len
+ 63) >> 6);
364 * To speed-test Poly1305, we run it with a do-nothing stub instead of
368 test_speed_poly1305_inner(char *name
, br_poly1305_run pl
)
370 unsigned char buf
[8192], key
[32], iv
[12], aad
[13], tag
[16];
374 memset(key
, 'K', sizeof key
);
375 memset(iv
, 'I', sizeof iv
);
376 memset(aad
, 'A', sizeof aad
);
377 memset(buf
, 'T', sizeof buf
);
378 for (i
= 0; i
< 10; i
++) {
379 pl(key
, iv
, buf
, sizeof buf
,
380 aad
, sizeof aad
, tag
, &fake_chacha20
, 0);
389 for (k
= num
; k
> 0; k
--) {
390 pl(key
, iv
, buf
, sizeof buf
,
391 aad
, sizeof aad
, tag
, &fake_chacha20
, 0);
394 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
396 printf("%-30s %8.2f MB/s\n", name
,
397 ((double)sizeof buf
) * (double)num
407 test_speed_poly1305_ctmul(void)
409 test_speed_poly1305_inner("Poly1305 (ctmul)", &br_poly1305_ctmul_run
);
413 test_speed_poly1305_ctmul32(void)
415 test_speed_poly1305_inner("Poly1305 (ctmul32)",
416 &br_poly1305_ctmul32_run
);
420 test_speed_poly1305_i15(void)
422 test_speed_poly1305_inner("Poly1305 (i15)", &br_poly1305_i15_run
);
425 static const unsigned char RSA_N
[] = {
426 0xE9, 0xF2, 0x4A, 0x2F, 0x96, 0xDF, 0x0A, 0x23,
427 0x01, 0x85, 0xF1, 0x2C, 0xB2, 0xA8, 0xEF, 0x23,
428 0xCE, 0x2E, 0xB0, 0x4E, 0x18, 0x31, 0x95, 0x5B,
429 0x98, 0x2D, 0x9B, 0x8C, 0xE3, 0x1A, 0x2B, 0x96,
430 0xB5, 0xC7, 0xEE, 0xED, 0x72, 0x43, 0x2D, 0xFE,
431 0x7F, 0x61, 0x33, 0xEA, 0x14, 0xFC, 0xDE, 0x80,
432 0x17, 0x42, 0xF0, 0xF3, 0xC3, 0xC7, 0x89, 0x47,
433 0x76, 0x5B, 0xFA, 0x33, 0xC4, 0x8C, 0x94, 0xDE,
434 0x6A, 0x75, 0xD8, 0x1A, 0xF4, 0x49, 0xBC, 0xF3,
435 0xB7, 0x9E, 0x2C, 0x8D, 0xEC, 0x5A, 0xEE, 0xBF,
436 0x4B, 0x5A, 0x7F, 0xEF, 0x21, 0x39, 0xDB, 0x1D,
437 0x83, 0x5E, 0x7E, 0x2F, 0xAA, 0x5E, 0xBA, 0x28,
438 0xC3, 0xA2, 0x53, 0x19, 0xFB, 0x2F, 0x78, 0x6B,
439 0x14, 0x60, 0x49, 0x3C, 0xCC, 0x1B, 0xE9, 0x1E,
440 0x3D, 0x10, 0xA4, 0xEB, 0x7F, 0x66, 0x98, 0xF6,
441 0xC3, 0xAC, 0x35, 0xF5, 0x01, 0x84, 0xFF, 0x7D,
442 0x1F, 0x72, 0xBE, 0xB4, 0xD1, 0x89, 0xC8, 0xDD,
443 0x44, 0xE7, 0xB5, 0x2E, 0x2C, 0xE1, 0x85, 0xF5,
444 0x15, 0x50, 0xA9, 0x08, 0xC7, 0x67, 0xD9, 0x2B,
445 0x6C, 0x11, 0xB3, 0xEB, 0x28, 0x8D, 0xF4, 0xCC,
446 0xE3, 0xC3, 0xC5, 0x04, 0x0E, 0x7C, 0x8D, 0xDB,
447 0x39, 0x06, 0x6A, 0x74, 0x75, 0xDF, 0xA8, 0x0F,
448 0xDA, 0x67, 0x5A, 0x73, 0x1E, 0xFD, 0x8E, 0x4C,
449 0xEE, 0x17, 0xEE, 0x1E, 0x67, 0xDB, 0x98, 0x70,
450 0x60, 0xF7, 0xB9, 0xB5, 0x1F, 0x19, 0x93, 0xD6,
451 0x3F, 0x2F, 0x1F, 0xB6, 0x5B, 0x59, 0xAA, 0x85,
452 0xBB, 0x25, 0xE4, 0x13, 0xEF, 0xE7, 0xB9, 0x87,
453 0x9C, 0x3F, 0x5E, 0xE4, 0x08, 0xA3, 0x51, 0xCF,
454 0x8B, 0xAD, 0xF4, 0xE6, 0x1A, 0x5F, 0x51, 0xDD,
455 0xA8, 0xBE, 0xE8, 0xD1, 0x20, 0x19, 0x61, 0x6C,
456 0x18, 0xAB, 0xCA, 0x0A, 0xD9, 0x82, 0xA6, 0x94,
457 0xD5, 0x69, 0x2A, 0xF6, 0x43, 0x66, 0x31, 0x09
460 static const unsigned char RSA_E
[] = {
464 static const unsigned char RSA_P
[] = {
465 0xFD, 0x39, 0x40, 0x56, 0x20, 0x80, 0xC5, 0x81,
466 0x4C, 0x5F, 0x0C, 0x1A, 0x52, 0x84, 0x03, 0x2F,
467 0xCE, 0x82, 0xB0, 0xD8, 0x30, 0x23, 0x7F, 0x77,
468 0x45, 0xC2, 0x01, 0xC4, 0x68, 0x96, 0x0D, 0xA7,
469 0x22, 0xA9, 0x6C, 0xA9, 0x1A, 0x33, 0xE5, 0x2F,
470 0xB5, 0x07, 0x9A, 0xF9, 0xEA, 0x33, 0xA5, 0xC8,
471 0x96, 0x60, 0x6A, 0xCA, 0xEB, 0xE5, 0x6E, 0x09,
472 0x46, 0x7E, 0x2D, 0xEF, 0x93, 0x7D, 0x56, 0xED,
473 0x75, 0x70, 0x3B, 0x96, 0xC4, 0xD5, 0xDB, 0x0B,
474 0x3F, 0x69, 0xDF, 0x06, 0x18, 0x76, 0xF4, 0xCF,
475 0xF8, 0x84, 0x22, 0xDF, 0xBD, 0x71, 0x62, 0x7B,
476 0x67, 0x99, 0xBC, 0x09, 0x95, 0x54, 0xA4, 0x98,
477 0x83, 0xF5, 0xA9, 0xCF, 0x09, 0xA5, 0x1F, 0x61,
478 0x25, 0xB4, 0x70, 0x6C, 0x91, 0xB8, 0xB3, 0xD0,
479 0xCE, 0x9C, 0x45, 0x65, 0x9B, 0xEF, 0xD4, 0x70,
480 0xBE, 0x86, 0xD2, 0x98, 0x5D, 0xEB, 0xE3, 0xFF
483 static const unsigned char RSA_Q
[] = {
484 0xEC, 0x82, 0xEE, 0x63, 0x5F, 0x40, 0x52, 0xDB,
485 0x38, 0x7A, 0x37, 0x6A, 0x54, 0x5B, 0xD9, 0xA0,
486 0x73, 0xB4, 0xBB, 0x52, 0xB2, 0x84, 0x07, 0xD0,
487 0xCC, 0x82, 0x0D, 0x20, 0xB3, 0xFA, 0xD5, 0xB6,
488 0x25, 0x92, 0x35, 0x4D, 0xB4, 0xC7, 0x36, 0x48,
489 0xCE, 0x5E, 0x21, 0x4A, 0xA6, 0x74, 0x65, 0xF4,
490 0x7D, 0x1D, 0xBC, 0x3B, 0xE2, 0xF4, 0x3E, 0x11,
491 0x58, 0x10, 0x6C, 0x04, 0x46, 0x9E, 0x8D, 0x57,
492 0xE0, 0x04, 0xE2, 0xEC, 0x47, 0xCF, 0xB3, 0x2A,
493 0xFD, 0x4C, 0x55, 0x18, 0xDB, 0xDE, 0x3B, 0xDC,
494 0xF4, 0x5B, 0xDA, 0xF3, 0x1A, 0xC8, 0x41, 0x6F,
495 0x73, 0x3B, 0xFE, 0x3C, 0xA0, 0xDB, 0xBA, 0x6E,
496 0x65, 0xA5, 0xE8, 0x02, 0xA5, 0x6C, 0xEA, 0x03,
497 0xF6, 0x99, 0xF7, 0xCB, 0x4B, 0xB7, 0x11, 0x51,
498 0x93, 0x88, 0x3F, 0xF9, 0x06, 0x85, 0xA9, 0x1E,
499 0xCA, 0x64, 0xF8, 0x11, 0xA5, 0x1A, 0xCA, 0xF7
502 static const unsigned char RSA_DP
[] = {
503 0x77, 0x95, 0xE0, 0x02, 0x4C, 0x9B, 0x43, 0xAA,
504 0xCA, 0x4C, 0x60, 0xC4, 0xD5, 0x8F, 0x2E, 0x8A,
505 0x17, 0x36, 0xB5, 0x19, 0x83, 0xB2, 0x5F, 0xF2,
506 0x0D, 0xE9, 0x8F, 0x38, 0x18, 0x44, 0x34, 0xF2,
507 0x67, 0x76, 0x27, 0xB0, 0xBC, 0x85, 0x21, 0x89,
508 0x24, 0x2F, 0x11, 0x4B, 0x51, 0x05, 0x4F, 0x17,
509 0xA9, 0x9C, 0xA3, 0x12, 0x6D, 0xD1, 0x0D, 0xE4,
510 0x27, 0x7C, 0x53, 0x69, 0x3E, 0xF8, 0x04, 0x63,
511 0x64, 0x00, 0xBA, 0xC3, 0x7A, 0xF5, 0x9B, 0xDA,
512 0x75, 0xFA, 0x23, 0xAF, 0x17, 0x42, 0xA6, 0x5E,
513 0xC8, 0xF8, 0x6E, 0x17, 0xC7, 0xB9, 0x92, 0x4E,
514 0xC1, 0x20, 0x63, 0x23, 0x0B, 0x78, 0xCB, 0xBA,
515 0x93, 0x27, 0x23, 0x28, 0x79, 0x5F, 0x97, 0xB0,
516 0x23, 0x44, 0x51, 0x8B, 0x94, 0x4D, 0xEB, 0xED,
517 0x82, 0x85, 0x5E, 0x68, 0x9B, 0xF9, 0xE9, 0x13,
518 0xCD, 0x86, 0x92, 0x52, 0x0E, 0x98, 0xE6, 0x35
521 static const unsigned char RSA_DQ
[] = {
522 0xD8, 0xDD, 0x71, 0xB3, 0x62, 0xBA, 0xBB, 0x7E,
523 0xD1, 0xF9, 0x96, 0xE8, 0x83, 0xB3, 0xB9, 0x08,
524 0x9C, 0x30, 0x03, 0x77, 0xDF, 0xC2, 0x9A, 0xDC,
525 0x05, 0x39, 0xD6, 0xC9, 0xBE, 0xDE, 0x68, 0xA9,
526 0xDD, 0x27, 0x84, 0x82, 0xDD, 0x19, 0xB1, 0x97,
527 0xEE, 0xCA, 0x77, 0x22, 0x59, 0x20, 0xEF, 0xFF,
528 0xCF, 0xDD, 0xBD, 0x24, 0xF8, 0x84, 0xD6, 0x88,
529 0xD6, 0xC4, 0x30, 0x17, 0x77, 0x9D, 0x98, 0xA3,
530 0x14, 0x01, 0xC7, 0x05, 0xBB, 0x0F, 0x23, 0x0D,
531 0x6F, 0x37, 0x57, 0xEC, 0x34, 0x67, 0x41, 0x62,
532 0xE8, 0x19, 0x75, 0xD9, 0x66, 0x1C, 0x6B, 0x8B,
533 0xC3, 0x11, 0x26, 0x9C, 0xF7, 0x2E, 0xA3, 0x72,
534 0xE8, 0xF7, 0xC8, 0x96, 0xEC, 0x92, 0xC2, 0xBD,
535 0xA1, 0x98, 0x2A, 0x93, 0x99, 0xB8, 0xA2, 0x43,
536 0xB7, 0xD0, 0xBE, 0x40, 0x1C, 0x8F, 0xE0, 0xB4,
537 0x20, 0x07, 0x97, 0x43, 0xAE, 0xAD, 0xB3, 0x9F
540 static const unsigned char RSA_IQ
[] = {
541 0xB7, 0xE2, 0x60, 0xA9, 0x62, 0xEC, 0xEC, 0x0B,
542 0x57, 0x02, 0x96, 0xF9, 0x36, 0x35, 0x2C, 0x37,
543 0xAF, 0xC2, 0xEE, 0x71, 0x49, 0x26, 0x8E, 0x0F,
544 0x27, 0xB1, 0xFA, 0x0F, 0xEA, 0xDC, 0xF0, 0x8B,
545 0x53, 0x6C, 0xB2, 0x46, 0x27, 0xCD, 0x29, 0xA2,
546 0x35, 0x0F, 0x5D, 0x8A, 0x3F, 0x20, 0x8C, 0x13,
547 0x3D, 0xA1, 0xFF, 0x85, 0x91, 0x99, 0xE8, 0x50,
548 0xED, 0xF1, 0x29, 0x00, 0xEE, 0x24, 0x90, 0xB5,
549 0x5F, 0x3A, 0x74, 0x26, 0xD7, 0xA2, 0x24, 0x8D,
550 0x89, 0x88, 0xD8, 0x35, 0x22, 0x22, 0x8A, 0x66,
551 0x5D, 0x5C, 0xDE, 0x83, 0x8C, 0xFA, 0x27, 0xE6,
552 0xB9, 0xEB, 0x72, 0x08, 0xCD, 0x53, 0x4B, 0x93,
553 0x0F, 0xAD, 0xC3, 0xF8, 0x7C, 0xFE, 0x84, 0xD7,
554 0x08, 0xF3, 0xBE, 0x3D, 0x60, 0x1E, 0x95, 0x8D,
555 0x44, 0x5B, 0x65, 0x7E, 0xC1, 0x30, 0xC3, 0x84,
556 0xC0, 0xB0, 0xFE, 0xBF, 0x28, 0x54, 0x1E, 0xC4
559 static const br_rsa_public_key RSA_PK
= {
560 (void *)RSA_N
, sizeof RSA_N
,
561 (void *)RSA_E
, sizeof RSA_E
564 static const br_rsa_private_key RSA_SK
= {
566 (void *)RSA_P
, sizeof RSA_P
,
567 (void *)RSA_Q
, sizeof RSA_Q
,
568 (void *)RSA_DP
, sizeof RSA_DP
,
569 (void *)RSA_DQ
, sizeof RSA_DQ
,
570 (void *)RSA_IQ
, sizeof RSA_IQ
574 test_speed_rsa_inner(char *name
,
575 br_rsa_public fpub
, br_rsa_private fpriv
)
577 unsigned char tmp
[sizeof RSA_N
];
581 memset(tmp
, 'R', sizeof tmp
);
583 for (i
= 0; i
< 10; i
++) {
584 if (!fpriv(tmp
, &RSA_SK
)) {
595 for (k
= num
; k
> 0; k
--) {
599 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
601 printf("%-30s %8.2f priv/s\n", name
,
608 for (i
= 0; i
< 10; i
++) {
609 if (!fpub(tmp
, sizeof tmp
, &RSA_PK
)) {
620 for (k
= num
; k
> 0; k
--) {
621 fpub(tmp
, sizeof tmp
, &RSA_PK
);
624 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
626 printf("%-30s %8.2f pub/s\n", name
,
636 test_speed_rsa_i15(void)
638 test_speed_rsa_inner("RSA i15",
639 &br_rsa_i15_public
, &br_rsa_i15_private
);
643 test_speed_rsa_i31(void)
645 test_speed_rsa_inner("RSA i31",
646 &br_rsa_i31_public
, &br_rsa_i31_private
);
650 test_speed_rsa_i32(void)
652 test_speed_rsa_inner("RSA i32",
653 &br_rsa_i32_public
, &br_rsa_i32_private
);
657 test_speed_ec_inner_1(const char *name
,
658 const br_ec_impl
*impl
, const br_ec_curve_def
*cd
)
660 unsigned char bx
[80], U
[160];
661 uint32_t x
[22], n
[22];
666 nlen
= cd
->order_len
;
667 br_i31_decode(n
, cd
->order
, nlen
);
668 memset(bx
, 'T', sizeof bx
);
669 br_i31_decode_reduce(x
, bx
, sizeof bx
, n
);
670 br_i31_encode(bx
, nlen
, x
);
671 ulen
= cd
->generator_len
;
672 memcpy(U
, cd
->generator
, ulen
);
673 for (i
= 0; i
< 10; i
++) {
674 impl
->mul(U
, ulen
, bx
, nlen
, cd
->curve
);
683 for (k
= num
; k
> 0; k
--) {
684 impl
->mul(U
, ulen
, bx
, nlen
, cd
->curve
);
687 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
689 printf("%-30s %8.2f mul/s\n", name
,
699 test_speed_ec_inner_2(const char *name
,
700 const br_ec_impl
*impl
, const br_ec_curve_def
*cd
)
702 unsigned char bx
[80], U
[160];
703 uint32_t x
[22], n
[22];
708 nlen
= cd
->order_len
;
709 br_i31_decode(n
, cd
->order
, nlen
);
710 memset(bx
, 'T', sizeof bx
);
711 br_i31_decode_reduce(x
, bx
, sizeof bx
, n
);
712 br_i31_encode(bx
, nlen
, x
);
713 for (i
= 0; i
< 10; i
++) {
714 impl
->mulgen(U
, bx
, nlen
, cd
->curve
);
723 for (k
= num
; k
> 0; k
--) {
724 impl
->mulgen(U
, bx
, nlen
, cd
->curve
);
727 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
729 printf("%-30s %8.2f mul/s\n", name
,
739 test_speed_ec_inner(const char *name
,
740 const br_ec_impl
*impl
, const br_ec_curve_def
*cd
)
744 test_speed_ec_inner_1(name
, impl
, cd
);
745 sprintf(tmp
, "%s (FP)", name
);
746 test_speed_ec_inner_2(tmp
, impl
, cd
);
750 test_speed_ec_p256_m15(void)
752 test_speed_ec_inner("EC p256_m15",
753 &br_ec_p256_m15
, &br_secp256r1
);
757 test_speed_ec_p256_m31(void)
759 test_speed_ec_inner("EC p256_m31",
760 &br_ec_p256_m31
, &br_secp256r1
);
764 test_speed_ec_prime_i15(void)
766 test_speed_ec_inner("EC prime_i15 P-256",
767 &br_ec_prime_i15
, &br_secp256r1
);
768 test_speed_ec_inner("EC prime_i15 P-384",
769 &br_ec_prime_i15
, &br_secp384r1
);
770 test_speed_ec_inner("EC prime_i15 P-521",
771 &br_ec_prime_i15
, &br_secp521r1
);
775 test_speed_ec_prime_i31(void)
777 test_speed_ec_inner("EC prime_i31 P-256",
778 &br_ec_prime_i31
, &br_secp256r1
);
779 test_speed_ec_inner("EC prime_i31 P-384",
780 &br_ec_prime_i31
, &br_secp384r1
);
781 test_speed_ec_inner("EC prime_i31 P-521",
782 &br_ec_prime_i31
, &br_secp521r1
);
786 test_speed_ec_c25519_i15(void)
788 test_speed_ec_inner("EC c25519_i15",
789 &br_ec_c25519_i15
, &br_curve25519
);
793 test_speed_ec_c25519_i31(void)
795 test_speed_ec_inner("EC c25519_i31",
796 &br_ec_c25519_i31
, &br_curve25519
);
800 test_speed_ec_c25519_m15(void)
802 test_speed_ec_inner("EC c25519_m15",
803 &br_ec_c25519_m15
, &br_curve25519
);
807 test_speed_ec_c25519_m31(void)
809 test_speed_ec_inner("EC c25519_m31",
810 &br_ec_c25519_m31
, &br_curve25519
);
814 test_speed_ecdsa_inner(const char *name
,
815 const br_ec_impl
*impl
, const br_ec_curve_def
*cd
,
816 br_ecdsa_sign sign
, br_ecdsa_vrfy vrfy
)
818 unsigned char bx
[80], U
[160], hv
[32], sig
[160];
819 uint32_t x
[22], n
[22];
820 size_t nlen
, ulen
, sig_len
;
823 br_ec_private_key sk
;
826 nlen
= cd
->order_len
;
827 br_i31_decode(n
, cd
->order
, nlen
);
828 memset(bx
, 'T', sizeof bx
);
829 br_i31_decode_reduce(x
, bx
, sizeof bx
, n
);
830 br_i31_encode(bx
, nlen
, x
);
831 ulen
= cd
->generator_len
;
832 memcpy(U
, cd
->generator
, ulen
);
833 impl
->mul(U
, ulen
, bx
, nlen
, cd
->curve
);
834 sk
.curve
= cd
->curve
;
837 pk
.curve
= cd
->curve
;
841 memset(hv
, 'H', sizeof hv
);
842 sig_len
= sign(impl
, &br_sha256_vtable
, hv
, &sk
, sig
);
843 if (vrfy(impl
, hv
, sizeof hv
, &pk
, sig
, sig_len
) != 1) {
844 fprintf(stderr
, "self-test sign/verify failed\n");
848 for (i
= 0; i
< 10; i
++) {
850 sign(impl
, &br_sha256_vtable
, hv
, &sk
, sig
);
851 vrfy(impl
, hv
, sizeof hv
, &pk
, sig
, sig_len
);
861 for (k
= num
; k
> 0; k
--) {
863 sig_len
= sign(impl
, &br_sha256_vtable
, hv
, &sk
, sig
);
866 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
868 printf("%-30s %8.2f sign/s\n", name
,
883 for (k
= num
; k
> 0; k
--) {
884 vrfy(impl
, hv
, sizeof hv
, &pk
, sig
, sig_len
);
887 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
889 printf("%-30s %8.2f verify/s\n", name
,
899 test_speed_ecdsa_p256_m15(void)
901 test_speed_ecdsa_inner("ECDSA m15 P-256",
902 &br_ec_p256_m15
, &br_secp256r1
,
903 &br_ecdsa_i15_sign_asn1
,
904 &br_ecdsa_i15_vrfy_asn1
);
908 test_speed_ecdsa_p256_m31(void)
910 test_speed_ecdsa_inner("ECDSA m31 P-256",
911 &br_ec_p256_m31
, &br_secp256r1
,
912 &br_ecdsa_i31_sign_asn1
,
913 &br_ecdsa_i31_vrfy_asn1
);
917 test_speed_ecdsa_i15(void)
919 test_speed_ecdsa_inner("ECDSA i15 P-256",
920 &br_ec_prime_i15
, &br_secp256r1
,
921 &br_ecdsa_i15_sign_asn1
,
922 &br_ecdsa_i15_vrfy_asn1
);
923 test_speed_ecdsa_inner("ECDSA i15 P-384",
924 &br_ec_prime_i15
, &br_secp384r1
,
925 &br_ecdsa_i15_sign_asn1
,
926 &br_ecdsa_i15_vrfy_asn1
);
927 test_speed_ecdsa_inner("ECDSA i15 P-521",
928 &br_ec_prime_i15
, &br_secp521r1
,
929 &br_ecdsa_i15_sign_asn1
,
930 &br_ecdsa_i15_vrfy_asn1
);
934 test_speed_ecdsa_i31(void)
936 test_speed_ecdsa_inner("ECDSA i31 P-256",
937 &br_ec_prime_i31
, &br_secp256r1
,
938 &br_ecdsa_i31_sign_asn1
,
939 &br_ecdsa_i31_vrfy_asn1
);
940 test_speed_ecdsa_inner("ECDSA i31 P-384",
941 &br_ec_prime_i31
, &br_secp384r1
,
942 &br_ecdsa_i31_sign_asn1
,
943 &br_ecdsa_i31_vrfy_asn1
);
944 test_speed_ecdsa_inner("ECDSA i31 P-521",
945 &br_ec_prime_i31
, &br_secp521r1
,
946 &br_ecdsa_i31_sign_asn1
,
947 &br_ecdsa_i31_vrfy_asn1
);
953 static const unsigned char bp
[] = {
954 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
955 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
956 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
957 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
960 unsigned char tmp
[60 + sizeof bp
];
961 uint32_t p
[10], x
[10], y
[10], z
[10], p0i
;
965 br_i31_decode(p
, bp
, sizeof bp
);
966 p0i
= br_i31_ninv31(p
[1]);
967 memset(tmp
, 'T', sizeof tmp
);
968 br_i31_decode_reduce(x
, tmp
, sizeof tmp
, p
);
969 memset(tmp
, 'U', sizeof tmp
);
970 br_i31_decode_reduce(y
, tmp
, sizeof tmp
, p
);
972 for (i
= 0; i
< 10; i
++) {
973 br_i31_to_monty(x
, p
);
982 for (k
= num
; k
> 0; k
--) {
983 br_i31_to_monty(x
, p
);
986 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
988 printf("%-30s %8.2f ops/s\n", "i31 to_monty",
996 for (i
= 0; i
< 10; i
++) {
997 br_i31_from_monty(x
, p
, p0i
);
1006 for (k
= num
; k
> 0; k
--) {
1007 br_i31_from_monty(x
, p
, p0i
);
1010 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
1012 printf("%-30s %8.2f ops/s\n", "i31 from_monty",
1020 for (i
= 0; i
< 10; i
++) {
1021 br_i31_montymul(z
, x
, y
, p
, p0i
);
1030 for (k
= num
; k
> 0; k
--) {
1031 br_i31_montymul(z
, x
, y
, p
, p0i
);
1034 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
1036 printf("%-30s %8.2f ops/s\n", "i31 montymul",
1047 static unsigned char P2048
[] = {
1048 0xFD, 0xB6, 0xE0, 0x3E, 0x00, 0x49, 0x4C, 0xF0, 0x69, 0x3A, 0xDD, 0x7D,
1049 0xF8, 0xA2, 0x41, 0xB0, 0x6C, 0x67, 0xC5, 0xBA, 0xB8, 0x46, 0x80, 0xF5,
1050 0xBF, 0xAB, 0x98, 0xFC, 0x84, 0x73, 0xA5, 0x63, 0xC9, 0x52, 0x12, 0xDA,
1051 0x4C, 0xC1, 0x5B, 0x9D, 0x8D, 0xDF, 0xCD, 0xFE, 0xC5, 0xAD, 0x5A, 0x6F,
1052 0xDD, 0x02, 0xD9, 0xEC, 0x71, 0xEF, 0xEB, 0xB6, 0x95, 0xED, 0x94, 0x25,
1053 0x0E, 0x63, 0xDD, 0x6A, 0x52, 0xC7, 0x93, 0xAF, 0x85, 0x9D, 0x2C, 0xBE,
1054 0x5C, 0xBE, 0x35, 0xD8, 0xDD, 0x39, 0xEF, 0x1B, 0xB1, 0x49, 0x67, 0xB2,
1055 0x33, 0xC9, 0x7C, 0xE1, 0x51, 0x79, 0x51, 0x59, 0xCA, 0x6E, 0x2A, 0xDF,
1056 0x0D, 0x76, 0x1C, 0xE7, 0xA5, 0xC0, 0x1E, 0x6C, 0x56, 0x3A, 0x32, 0xE5,
1057 0xB5, 0xC5, 0xD4, 0xDB, 0xFE, 0xFF, 0xF8, 0xF2, 0x96, 0xA9, 0xC9, 0x65,
1058 0x59, 0x9E, 0x01, 0x79, 0x9D, 0x38, 0x68, 0x0F, 0xAD, 0x43, 0x3A, 0xD6,
1059 0x84, 0x0A, 0xE2, 0xEF, 0x96, 0xC1, 0x6D, 0x89, 0x74, 0x19, 0x63, 0x82,
1060 0x3B, 0xA0, 0x9C, 0xBA, 0x78, 0xDE, 0xDC, 0xC2, 0xE7, 0xD4, 0xFA, 0xD6,
1061 0x19, 0x21, 0x29, 0xAE, 0x5E, 0xF4, 0x38, 0x81, 0xC6, 0x9E, 0x0E, 0x3C,
1062 0xCD, 0xC0, 0xDC, 0x93, 0x5D, 0xFD, 0x9A, 0x5C, 0xAB, 0x54, 0x1F, 0xFF,
1063 0x9C, 0x12, 0x1B, 0x4C, 0xDF, 0x2D, 0x9C, 0x85, 0xF9, 0x68, 0x15, 0x89,
1064 0x42, 0x9B, 0x6C, 0x45, 0x89, 0x3A, 0xBC, 0xE9, 0x19, 0x91, 0xBE, 0x0C,
1065 0xEF, 0x90, 0xCC, 0xF6, 0xD6, 0xF0, 0x3D, 0x5C, 0xF5, 0xE5, 0x0F, 0x2F,
1066 0x02, 0x8A, 0x83, 0x4B, 0x93, 0x2F, 0x14, 0x12, 0x1F, 0x56, 0x9A, 0x12,
1067 0x58, 0x88, 0xAE, 0x60, 0xB8, 0x5A, 0xE4, 0xA1, 0xBF, 0x4A, 0x81, 0x84,
1068 0xAB, 0xBB, 0xE4, 0xD0, 0x1D, 0x41, 0xD9, 0x0A, 0xAB, 0x1E, 0x47, 0x5B,
1069 0x31, 0xAC, 0x2B, 0x73
1072 static unsigned char G2048
[] = {
1077 test_speed_modpow(void)
1079 uint32_t mx
[65], mp
[65], me
[65], t1
[65], t2
[65], len
;
1080 unsigned char e
[64];
1084 len
= br_int_decode(mp
, sizeof mp
/ sizeof mp
[0],
1085 P2048
, sizeof P2048
);
1089 memset(e
, 'P', sizeof e
);
1090 if (!br_int_decode(me
, sizeof me
/ sizeof me
[0], e
, sizeof e
)) {
1093 if (!br_modint_decode(mx
, mp
, G2048
, sizeof G2048
)) {
1096 for (i
= 0; i
< 10; i
++) {
1097 br_modint_to_monty(mx
, mp
);
1098 br_modint_montypow(mx
, me
, mp
, t1
, t2
);
1099 br_modint_from_monty(mx
, mp
);
1108 for (k
= num
; k
> 0; k
--) {
1109 br_modint_to_monty(mx
, mp
);
1110 br_modint_montypow(mx
, me
, mp
, t1
, t2
);
1111 br_modint_from_monty(mx
, mp
);
1114 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
1116 printf("%-30s %8.2f exp/s\n", "pow[2048:256]",
1126 test_speed_moddiv(void)
1128 uint32_t mx
[65], my
[65], mp
[65], t1
[65], t2
[65], t3
[65], len
;
1129 unsigned char x
[255], y
[255];
1133 len
= br_int_decode(mp
, sizeof mp
/ sizeof mp
[0],
1134 P2048
, sizeof P2048
);
1138 memset(x
, 'T', sizeof x
);
1139 memset(y
, 'P', sizeof y
);
1140 if (!br_modint_decode(mx
, mp
, x
, sizeof x
)) {
1143 if (!br_modint_decode(my
, mp
, y
, sizeof y
)) {
1146 for (i
= 0; i
< 10; i
++) {
1147 br_modint_div(mx
, my
, mp
, t1
, t2
, t3
);
1156 for (k
= num
; k
> 0; k
--) {
1157 br_modint_div(mx
, my
, mp
, t1
, t2
, t3
);
1160 tt
= (double)(end
- begin
) / CLOCKS_PER_SEC
;
1162 printf("%-30s %8.2f div/s\n", "div[2048]",
1172 #define STU(x) { test_speed_ ## x, #x }
1174 static const struct {
1183 STU(aes128_big_cbcenc
),
1184 STU(aes128_big_cbcdec
),
1185 STU(aes192_big_cbcenc
),
1186 STU(aes192_big_cbcdec
),
1187 STU(aes256_big_cbcenc
),
1188 STU(aes256_big_cbcdec
),
1189 STU(aes128_big_ctr
),
1190 STU(aes192_big_ctr
),
1191 STU(aes256_big_ctr
),
1193 STU(aes128_small_cbcenc
),
1194 STU(aes128_small_cbcdec
),
1195 STU(aes192_small_cbcenc
),
1196 STU(aes192_small_cbcdec
),
1197 STU(aes256_small_cbcenc
),
1198 STU(aes256_small_cbcdec
),
1199 STU(aes128_small_ctr
),
1200 STU(aes192_small_ctr
),
1201 STU(aes256_small_ctr
),
1203 STU(aes128_ct_cbcenc
),
1204 STU(aes128_ct_cbcdec
),
1205 STU(aes192_ct_cbcenc
),
1206 STU(aes192_ct_cbcdec
),
1207 STU(aes256_ct_cbcenc
),
1208 STU(aes256_ct_cbcdec
),
1213 STU(aes128_ct64_cbcenc
),
1214 STU(aes128_ct64_cbcdec
),
1215 STU(aes192_ct64_cbcenc
),
1216 STU(aes192_ct64_cbcdec
),
1217 STU(aes256_ct64_cbcenc
),
1218 STU(aes256_ct64_cbcdec
),
1219 STU(aes128_ct64_ctr
),
1220 STU(aes192_ct64_ctr
),
1221 STU(aes256_ct64_ctr
),
1223 STU(aes128_x86ni_cbcenc
),
1224 STU(aes128_x86ni_cbcdec
),
1225 STU(aes192_x86ni_cbcenc
),
1226 STU(aes192_x86ni_cbcdec
),
1227 STU(aes256_x86ni_cbcenc
),
1228 STU(aes256_x86ni_cbcdec
),
1229 STU(aes128_x86ni_ctr
),
1230 STU(aes192_x86ni_ctr
),
1231 STU(aes256_x86ni_ctr
),
1233 STU(aes128_pwr8_cbcenc
),
1234 STU(aes128_pwr8_cbcdec
),
1235 STU(aes192_pwr8_cbcenc
),
1236 STU(aes192_pwr8_cbcdec
),
1237 STU(aes256_pwr8_cbcenc
),
1238 STU(aes256_pwr8_cbcdec
),
1239 STU(aes128_pwr8_ctr
),
1240 STU(aes192_pwr8_ctr
),
1241 STU(aes256_pwr8_ctr
),
1243 STU(des_tab_cbcenc
),
1244 STU(des_tab_cbcdec
),
1245 STU(3des_tab_cbcenc
),
1246 STU(3des_tab_cbcdec
),
1250 STU(3des_ct_cbcenc
),
1251 STU(3des_ct_cbcdec
),
1261 STU(poly1305_ctmul
),
1262 STU(poly1305_ctmul32
),
1276 STU(ecdsa_p256_m15
),
1277 STU(ecdsa_p256_m31
),
1285 eq_name(const char *s1
, const char *s2
)
1292 if (c1
>= 'A' && c1
<= 'Z') {
1296 case '-': case '_': case '.': case ' ':
1304 if (c2
>= 'A' && c2
<= 'Z') {
1308 case '-': case '_': case '.': case ' ':
1324 main(int argc
, char *argv
[])
1329 printf("usage: testspeed all | name...\n");
1330 printf("individual test names:\n");
1331 for (u
= 0; u
< (sizeof tfns
) / (sizeof tfns
[0]); u
++) {
1332 printf(" %s\n", tfns
[u
].name
);
1335 for (u
= 0; u
< (sizeof tfns
) / (sizeof tfns
[0]); u
++) {
1338 for (i
= 1; i
< argc
; i
++) {
1339 if (eq_name(argv
[i
], tfns
[u
].name
)
1340 || eq_name(argv
[i
], "all"))