projects / BearSSL / blob
? search:


458d76540c3468021796a4621cc4cdf19c42e2fd
[BearSSL] / 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_prime_i15(void)
696 {
697 test_speed_ec_inner("EC prime_i15 P-256",
698 &br_ec_prime_i15, &br_secp256r1);
699 test_speed_ec_inner("EC prime_i15 P-384",
700 &br_ec_prime_i15, &br_secp384r1);
701 test_speed_ec_inner("EC prime_i15 P-521",
702 &br_ec_prime_i15, &br_secp521r1);
703 }
704
705 static void
706 test_speed_ec_prime_i31(void)
707 {
708 test_speed_ec_inner("EC prime_i31 P-256",
709 &br_ec_prime_i31, &br_secp256r1);
710 test_speed_ec_inner("EC prime_i31 P-384",
711 &br_ec_prime_i31, &br_secp384r1);
712 test_speed_ec_inner("EC prime_i31 P-521",
713 &br_ec_prime_i31, &br_secp521r1);
714 }
715
716 static void
717 test_speed_ec_c25519_i15(void)
718 {
719 test_speed_ec_inner("EC c25519_i15",
720 &br_ec_c25519_i15, &br_curve25519);
721 }
722
723 static void
724 test_speed_ec_c25519_i31(void)
725 {
726 test_speed_ec_inner("EC c25519_i31",
727 &br_ec_c25519_i31, &br_curve25519);
728 }
729
730 static void
731 test_speed_ec_c25519_m15(void)
732 {
733 test_speed_ec_inner("EC c25519_m15",
734 &br_ec_c25519_m15, &br_curve25519);
735 }
736
737 static void
738 test_speed_ec_c25519_m31(void)
739 {
740 test_speed_ec_inner("EC c25519_m31",
741 &br_ec_c25519_m31, &br_curve25519);
742 }
743
744 static void
745 test_speed_ecdsa_inner(const char *name,
746 const br_ec_impl *impl, const br_ec_curve_def *cd,
747 br_ecdsa_sign sign, br_ecdsa_vrfy vrfy)
748 {
749 unsigned char bx[80], U[160], hv[32], sig[160];
750 uint32_t x[22], n[22];
751 size_t nlen, ulen, sig_len;
752 int i;
753 long num;
754 br_ec_private_key sk;
755 br_ec_public_key pk;
756
757 nlen = cd->order_len;
758 br_i31_decode(n, cd->order, nlen);
759 memset(bx, 'T', sizeof bx);
760 br_i31_decode_reduce(x, bx, sizeof bx, n);
761 br_i31_encode(bx, nlen, x);
762 ulen = cd->generator_len;
763 memcpy(U, cd->generator, ulen);
764 impl->mul(U, ulen, bx, nlen, cd->curve);
765 sk.curve = cd->curve;
766 sk.x = bx;
767 sk.xlen = nlen;
768 pk.curve = cd->curve;
769 pk.q = U;
770 pk.qlen = ulen;
771
772 memset(hv, 'H', sizeof hv);
773 sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
774 if (vrfy(impl, hv, sizeof hv, &pk, sig, sig_len) != 1) {
775 fprintf(stderr, "self-test sign/verify failed\n");
776 exit(EXIT_FAILURE);
777 }
778
779 for (i = 0; i < 10; i ++) {
780 hv[1] ++;
781 sign(impl, &br_sha256_vtable, hv, &sk, sig);
782 vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
783 }
784
785 num = 10;
786 for (;;) {
787 clock_t begin, end;
788 double tt;
789 long k;
790
791 begin = clock();
792 for (k = num; k > 0; k --) {
793 hv[1] ++;
794 sig_len = sign(impl, &br_sha256_vtable, hv, &sk, sig);
795 }
796 end = clock();
797 tt = (double)(end - begin) / CLOCKS_PER_SEC;
798 if (tt >= 2.0) {
799 printf("%-30s %8.2f sign/s\n", name,
800 (double)num / tt);
801 fflush(stdout);
802 break;
803 }
804 num <<= 1;
805 }
806
807 num = 10;
808 for (;;) {
809 clock_t begin, end;
810 double tt;
811 long k;
812
813 begin = clock();
814 for (k = num; k > 0; k --) {
815 vrfy(impl, hv, sizeof hv, &pk, sig, sig_len);
816 }
817 end = clock();
818 tt = (double)(end - begin) / CLOCKS_PER_SEC;
819 if (tt >= 2.0) {
820 printf("%-30s %8.2f verify/s\n", name,
821 (double)num / tt);
822 fflush(stdout);
823 break;
824 }
825 num <<= 1;
826 }
827 }
828
829 static void
830 test_speed_ecdsa_p256_m15(void)
831 {
832 test_speed_ecdsa_inner("ECDSA m15 P-256",
833 &br_ec_p256_m15, &br_secp256r1,
834 &br_ecdsa_i15_sign_asn1,
835 &br_ecdsa_i15_vrfy_asn1);
836 }
837
838 static void
839 test_speed_ecdsa_i15(void)
840 {
841 test_speed_ecdsa_inner("ECDSA i15 P-256",
842 &br_ec_prime_i15, &br_secp256r1,
843 &br_ecdsa_i15_sign_asn1,
844 &br_ecdsa_i15_vrfy_asn1);
845 test_speed_ecdsa_inner("ECDSA i15 P-384",
846 &br_ec_prime_i15, &br_secp384r1,
847 &br_ecdsa_i15_sign_asn1,
848 &br_ecdsa_i15_vrfy_asn1);
849 test_speed_ecdsa_inner("ECDSA i15 P-521",
850 &br_ec_prime_i15, &br_secp521r1,
851 &br_ecdsa_i15_sign_asn1,
852 &br_ecdsa_i15_vrfy_asn1);
853 }
854
855 static void
856 test_speed_ecdsa_i31(void)
857 {
858 test_speed_ecdsa_inner("ECDSA i31 P-256",
859 &br_ec_prime_i31, &br_secp256r1,
860 &br_ecdsa_i31_sign_asn1,
861 &br_ecdsa_i31_vrfy_asn1);
862 test_speed_ecdsa_inner("ECDSA i31 P-384",
863 &br_ec_prime_i31, &br_secp384r1,
864 &br_ecdsa_i31_sign_asn1,
865 &br_ecdsa_i31_vrfy_asn1);
866 test_speed_ecdsa_inner("ECDSA i31 P-521",
867 &br_ec_prime_i31, &br_secp521r1,
868 &br_ecdsa_i31_sign_asn1,
869 &br_ecdsa_i31_vrfy_asn1);
870 }
871
872 #if 0
873 /* obsolete */
874 static void
875 test_speed_ec_prime_i31_inner(const char *name,
876 const unsigned char *bg, const br_ec_prime_i31_curve *cc)
877 {
878 unsigned char bx[80], point[160];
879 uint32_t x[BR_EC_I31_LEN];
880 br_ec_prime_i31_jacobian P;
881 uint32_t xbl;
882 size_t plen;
883 int i;
884 long num;
885
886 xbl = cc->p[0];
887 xbl -= (xbl >> 5);
888 plen = (xbl + 7) >> 3;
889 memset(bx, 'T', sizeof bx);
890 br_i31_decode_reduce(x, bx, sizeof bx, cc->p);
891 br_i31_encode(bx, plen, x);
892 br_ec_prime_i31_decode(&P, bg, 1 + (plen << 1), cc);
893 for (i = 0; i < 10; i ++) {
894 br_ec_prime_i31_mul(&P, bx, plen, cc);
895 br_ec_prime_i31_encode(point, &P, cc);
896 }
897 num = 10;
898 for (;;) {
899 clock_t begin, end;
900 double tt;
901 long k;
902
903 begin = clock();
904 for (k = num; k > 0; k --) {
905 br_ec_prime_i31_mul(&P, bx, plen, cc);
906 br_ec_prime_i31_encode(point, &P, cc);
907 }
908 end = clock();
909 tt = (double)(end - begin) / CLOCKS_PER_SEC;
910 if (tt >= 2.0) {
911 printf("%-30s %8.2f mul/s\n", name,
912 (double)num / tt);
913 fflush(stdout);
914 break;
915 }
916 num <<= 1;
917 }
918 }
919
920 static void
921 test_speed_ec_prime_i31(void)
922 {
923 test_speed_ec_prime_i31_inner("EC i31 P-256",
924 br_g_secp256r1, &br_ec_prime_i31_secp256r1);
925 test_speed_ec_prime_i31_inner("EC i31 P-384",
926 br_g_secp384r1, &br_ec_prime_i31_secp384r1);
927 test_speed_ec_prime_i31_inner("EC i31 P-521",
928 br_g_secp521r1, &br_ec_prime_i31_secp521r1);
929 }
930
931 static void
932 test_speed_ec_prime_i32_inner(const char *name,
933 const unsigned char *bg, const br_ec_prime_i32_curve *cc)
934 {
935 unsigned char bx[80], point[160];
936 uint32_t x[BR_EC_I32_LEN];
937 br_ec_prime_i32_jacobian P;
938 size_t plen;
939 int i;
940 long num;
941
942 plen = (cc->p[0] + 7) >> 3;
943 memset(bx, 'T', sizeof bx);
944 br_i32_decode_reduce(x, bx, sizeof bx, cc->p);
945 br_i32_encode(bx, plen, x);
946 br_ec_prime_i32_decode(&P, bg, 1 + (plen << 1), cc);
947 for (i = 0; i < 10; i ++) {
948 br_ec_prime_i32_mul(&P, bx, plen, cc);
949 br_ec_prime_i32_encode(point, &P, cc);
950 }
951 num = 10;
952 for (;;) {
953 clock_t begin, end;
954 double tt;
955 long k;
956
957 begin = clock();
958 for (k = num; k > 0; k --) {
959 br_ec_prime_i32_mul(&P, bx, plen, cc);
960 br_ec_prime_i32_encode(point, &P, cc);
961 }
962 end = clock();
963 tt = (double)(end - begin) / CLOCKS_PER_SEC;
964 if (tt >= 2.0) {
965 printf("%-30s %8.2f mul/s\n", name,
966 (double)num / tt);
967 fflush(stdout);
968 break;
969 }
970 num <<= 1;
971 }
972 }
973
974 static void
975 test_speed_ec_prime_i32(void)
976 {
977 test_speed_ec_prime_i32_inner("EC i32 P-256",
978 br_g_secp256r1, &br_ec_prime_i32_secp256r1);
979 test_speed_ec_prime_i32_inner("EC i32 P-384",
980 br_g_secp384r1, &br_ec_prime_i32_secp384r1);
981 test_speed_ec_prime_i32_inner("EC i32 P-521",
982 br_g_secp521r1, &br_ec_prime_i32_secp521r1);
983 }
984 #endif
985
986 static void
987 test_speed_i31(void)
988 {
989 static const unsigned char bp[] = {
990 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
991 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
992 0xBC, 0xE6, 0xFA, 0xAD, 0xA7, 0x17, 0x9E, 0x84,
993 0xF3, 0xB9, 0xCA, 0xC2, 0xFC, 0x63, 0x25, 0x51
994 };
995
996 unsigned char tmp[60 + sizeof bp];
997 uint32_t p[10], x[10], y[10], z[10], p0i;
998 int i;
999 long num;
1000
1001 br_i31_decode(p, bp, sizeof bp);
1002 p0i = br_i31_ninv31(p[1]);
1003 memset(tmp, 'T', sizeof tmp);
1004 br_i31_decode_reduce(x, tmp, sizeof tmp, p);
1005 memset(tmp, 'U', sizeof tmp);
1006 br_i31_decode_reduce(y, tmp, sizeof tmp, p);
1007
1008 for (i = 0; i < 10; i ++) {
1009 br_i31_to_monty(x, p);
1010 }
1011 num = 10;
1012 for (;;) {
1013 clock_t begin, end;
1014 double tt;
1015 long k;
1016
1017 begin = clock();
1018 for (k = num; k > 0; k --) {
1019 br_i31_to_monty(x, p);
1020 }
1021 end = clock();
1022 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1023 if (tt >= 2.0) {
1024 printf("%-30s %8.2f ops/s\n", "i31 to_monty",
1025 (double)num / tt);
1026 fflush(stdout);
1027 break;
1028 }
1029 num <<= 1;
1030 }
1031
1032 for (i = 0; i < 10; i ++) {
1033 br_i31_from_monty(x, p, p0i);
1034 }
1035 num = 10;
1036 for (;;) {
1037 clock_t begin, end;
1038 double tt;
1039 long k;
1040
1041 begin = clock();
1042 for (k = num; k > 0; k --) {
1043 br_i31_from_monty(x, p, p0i);
1044 }
1045 end = clock();
1046 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1047 if (tt >= 2.0) {
1048 printf("%-30s %8.2f ops/s\n", "i31 from_monty",
1049 (double)num / tt);
1050 fflush(stdout);
1051 break;
1052 }
1053 num <<= 1;
1054 }
1055
1056 for (i = 0; i < 10; i ++) {
1057 br_i31_montymul(z, x, y, p, p0i);
1058 }
1059 num = 10;
1060 for (;;) {
1061 clock_t begin, end;
1062 double tt;
1063 long k;
1064
1065 begin = clock();
1066 for (k = num; k > 0; k --) {
1067 br_i31_montymul(z, x, y, p, p0i);
1068 }
1069 end = clock();
1070 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1071 if (tt >= 2.0) {
1072 printf("%-30s %8.2f ops/s\n", "i31 montymul",
1073 (double)num / tt);
1074 fflush(stdout);
1075 break;
1076 }
1077 num <<= 1;
1078 }
1079 }
1080
1081 #if 0
1082
1083 static unsigned char P2048[] = {
1084 0xFD, 0xB6, 0xE0, 0x3E, 0x00, 0x49, 0x4C, 0xF0, 0x69, 0x3A, 0xDD, 0x7D,
1085 0xF8, 0xA2, 0x41, 0xB0, 0x6C, 0x67, 0xC5, 0xBA, 0xB8, 0x46, 0x80, 0xF5,
1086 0xBF, 0xAB, 0x98, 0xFC, 0x84, 0x73, 0xA5, 0x63, 0xC9, 0x52, 0x12, 0xDA,
1087 0x4C, 0xC1, 0x5B, 0x9D, 0x8D, 0xDF, 0xCD, 0xFE, 0xC5, 0xAD, 0x5A, 0x6F,
1088 0xDD, 0x02, 0xD9, 0xEC, 0x71, 0xEF, 0xEB, 0xB6, 0x95, 0xED, 0x94, 0x25,
1089 0x0E, 0x63, 0xDD, 0x6A, 0x52, 0xC7, 0x93, 0xAF, 0x85, 0x9D, 0x2C, 0xBE,
1090 0x5C, 0xBE, 0x35, 0xD8, 0xDD, 0x39, 0xEF, 0x1B, 0xB1, 0x49, 0x67, 0xB2,
1091 0x33, 0xC9, 0x7C, 0xE1, 0x51, 0x79, 0x51, 0x59, 0xCA, 0x6E, 0x2A, 0xDF,
1092 0x0D, 0x76, 0x1C, 0xE7, 0xA5, 0xC0, 0x1E, 0x6C, 0x56, 0x3A, 0x32, 0xE5,
1093 0xB5, 0xC5, 0xD4, 0xDB, 0xFE, 0xFF, 0xF8, 0xF2, 0x96, 0xA9, 0xC9, 0x65,
1094 0x59, 0x9E, 0x01, 0x79, 0x9D, 0x38, 0x68, 0x0F, 0xAD, 0x43, 0x3A, 0xD6,
1095 0x84, 0x0A, 0xE2, 0xEF, 0x96, 0xC1, 0x6D, 0x89, 0x74, 0x19, 0x63, 0x82,
1096 0x3B, 0xA0, 0x9C, 0xBA, 0x78, 0xDE, 0xDC, 0xC2, 0xE7, 0xD4, 0xFA, 0xD6,
1097 0x19, 0x21, 0x29, 0xAE, 0x5E, 0xF4, 0x38, 0x81, 0xC6, 0x9E, 0x0E, 0x3C,
1098 0xCD, 0xC0, 0xDC, 0x93, 0x5D, 0xFD, 0x9A, 0x5C, 0xAB, 0x54, 0x1F, 0xFF,
1099 0x9C, 0x12, 0x1B, 0x4C, 0xDF, 0x2D, 0x9C, 0x85, 0xF9, 0x68, 0x15, 0x89,
1100 0x42, 0x9B, 0x6C, 0x45, 0x89, 0x3A, 0xBC, 0xE9, 0x19, 0x91, 0xBE, 0x0C,
1101 0xEF, 0x90, 0xCC, 0xF6, 0xD6, 0xF0, 0x3D, 0x5C, 0xF5, 0xE5, 0x0F, 0x2F,
1102 0x02, 0x8A, 0x83, 0x4B, 0x93, 0x2F, 0x14, 0x12, 0x1F, 0x56, 0x9A, 0x12,
1103 0x58, 0x88, 0xAE, 0x60, 0xB8, 0x5A, 0xE4, 0xA1, 0xBF, 0x4A, 0x81, 0x84,
1104 0xAB, 0xBB, 0xE4, 0xD0, 0x1D, 0x41, 0xD9, 0x0A, 0xAB, 0x1E, 0x47, 0x5B,
1105 0x31, 0xAC, 0x2B, 0x73
1106 };
1107
1108 static unsigned char G2048[] = {
1109 0x02
1110 };
1111
1112 static void
1113 test_speed_modpow(void)
1114 {
1115 uint32_t mx[65], mp[65], me[65], t1[65], t2[65], len;
1116 unsigned char e[64];
1117 int i;
1118 long num;
1119
1120 len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1121 P2048, sizeof P2048);
1122 if (len != 65) {
1123 abort();
1124 }
1125 memset(e, 'P', sizeof e);
1126 if (!br_int_decode(me, sizeof me / sizeof me[0], e, sizeof e)) {
1127 abort();
1128 }
1129 if (!br_modint_decode(mx, mp, G2048, sizeof G2048)) {
1130 abort();
1131 }
1132 for (i = 0; i < 10; i ++) {
1133 br_modint_to_monty(mx, mp);
1134 br_modint_montypow(mx, me, mp, t1, t2);
1135 br_modint_from_monty(mx, mp);
1136 }
1137 num = 10;
1138 for (;;) {
1139 clock_t begin, end;
1140 double tt;
1141 long k;
1142
1143 begin = clock();
1144 for (k = num; k > 0; k --) {
1145 br_modint_to_monty(mx, mp);
1146 br_modint_montypow(mx, me, mp, t1, t2);
1147 br_modint_from_monty(mx, mp);
1148 }
1149 end = clock();
1150 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1151 if (tt >= 2.0) {
1152 printf("%-30s %8.2f exp/s\n", "pow[2048:256]",
1153 (double)num / tt);
1154 fflush(stdout);
1155 return;
1156 }
1157 num <<= 1;
1158 }
1159 }
1160
1161 static void
1162 test_speed_moddiv(void)
1163 {
1164 uint32_t mx[65], my[65], mp[65], t1[65], t2[65], t3[65], len;
1165 unsigned char x[255], y[255];
1166 int i;
1167 long num;
1168
1169 len = br_int_decode(mp, sizeof mp / sizeof mp[0],
1170 P2048, sizeof P2048);
1171 if (len != 65) {
1172 abort();
1173 }
1174 memset(x, 'T', sizeof x);
1175 memset(y, 'P', sizeof y);
1176 if (!br_modint_decode(mx, mp, x, sizeof x)) {
1177 abort();
1178 }
1179 if (!br_modint_decode(my, mp, y, sizeof y)) {
1180 abort();
1181 }
1182 for (i = 0; i < 10; i ++) {
1183 br_modint_div(mx, my, mp, t1, t2, t3);
1184 }
1185 num = 10;
1186 for (;;) {
1187 clock_t begin, end;
1188 double tt;
1189 long k;
1190
1191 begin = clock();
1192 for (k = num; k > 0; k --) {
1193 br_modint_div(mx, my, mp, t1, t2, t3);
1194 }
1195 end = clock();
1196 tt = (double)(end - begin) / CLOCKS_PER_SEC;
1197 if (tt >= 2.0) {
1198 printf("%-30s %8.2f div/s\n", "div[2048]",
1199 (double)num / tt);
1200 fflush(stdout);
1201 return;
1202 }
1203 num <<= 1;
1204 }
1205 }
1206 #endif
1207
1208 #define STU(x) { test_speed_ ## x, #x }
1209
1210 static const struct {
1211 void (*fn)(void);
1212 char *name;
1213 } tfns[] = {
1214 STU(md5),
1215 STU(sha1),
1216 STU(sha256),
1217 STU(sha512),
1218
1219 STU(aes128_big_cbcenc),
1220 STU(aes128_big_cbcdec),
1221 STU(aes192_big_cbcenc),
1222 STU(aes192_big_cbcdec),
1223 STU(aes256_big_cbcenc),
1224 STU(aes256_big_cbcdec),
1225 STU(aes128_big_ctr),
1226 STU(aes192_big_ctr),
1227 STU(aes256_big_ctr),
1228
1229 STU(aes128_small_cbcenc),
1230 STU(aes128_small_cbcdec),
1231 STU(aes192_small_cbcenc),
1232 STU(aes192_small_cbcdec),
1233 STU(aes256_small_cbcenc),
1234 STU(aes256_small_cbcdec),
1235 STU(aes128_small_ctr),
1236 STU(aes192_small_ctr),
1237 STU(aes256_small_ctr),
1238
1239 STU(aes128_ct_cbcenc),
1240 STU(aes128_ct_cbcdec),
1241 STU(aes192_ct_cbcenc),
1242 STU(aes192_ct_cbcdec),
1243 STU(aes256_ct_cbcenc),
1244 STU(aes256_ct_cbcdec),
1245 STU(aes128_ct_ctr),
1246 STU(aes192_ct_ctr),
1247 STU(aes256_ct_ctr),
1248
1249 STU(aes128_ct64_cbcenc),
1250 STU(aes128_ct64_cbcdec),
1251 STU(aes192_ct64_cbcenc),
1252 STU(aes192_ct64_cbcdec),
1253 STU(aes256_ct64_cbcenc),
1254 STU(aes256_ct64_cbcdec),
1255 STU(aes128_ct64_ctr),
1256 STU(aes192_ct64_ctr),
1257 STU(aes256_ct64_ctr),
1258
1259 STU(des_tab_cbcenc),
1260 STU(des_tab_cbcdec),
1261 STU(3des_tab_cbcenc),
1262 STU(3des_tab_cbcdec),
1263
1264 STU(des_ct_cbcenc),
1265 STU(des_ct_cbcdec),
1266 STU(3des_ct_cbcenc),
1267 STU(3des_ct_cbcdec),
1268
1269 STU(chacha20_ct),
1270
1271 STU(ghash_ctmul),
1272 STU(ghash_ctmul32),
1273 STU(ghash_ctmul64),
1274
1275 STU(poly1305_ctmul),
1276 STU(poly1305_ctmul32),
1277 STU(poly1305_i15),
1278
1279 STU(rsa_i15),
1280 STU(rsa_i31),
1281 STU(rsa_i32),
1282 STU(ec_prime_i15),
1283 STU(ec_prime_i31),
1284 STU(ec_p256_m15),
1285 STU(ec_c25519_i15),
1286 STU(ec_c25519_i31),
1287 STU(ec_c25519_m15),
1288 STU(ec_c25519_m31),
1289 STU(ecdsa_p256_m15),
1290 STU(ecdsa_i15),
1291 STU(ecdsa_i31),
1292
1293 STU(i31)
1294 };
1295
1296 static int
1297 eq_name(const char *s1, const char *s2)
1298 {
1299 for (;;) {
1300 int c1, c2;
1301
1302 for (;;) {
1303 c1 = *s1 ++;
1304 if (c1 >= 'A' && c1 <= 'Z') {
1305 c1 += 'a' - 'A';
1306 } else {
1307 switch (c1) {
1308 case '-': case '_': case '.': case ' ':
1309 continue;
1310 }
1311 }
1312 break;
1313 }
1314 for (;;) {
1315 c2 = *s2 ++;
1316 if (c2 >= 'A' && c2 <= 'Z') {
1317 c2 += 'a' - 'A';
1318 } else {
1319 switch (c2) {
1320 case '-': case '_': case '.': case ' ':
1321 continue;
1322 }
1323 }
1324 break;
1325 }
1326 if (c1 != c2) {
1327 return 0;
1328 }
1329 if (c1 == 0) {
1330 return 1;
1331 }
1332 }
1333 }
1334
1335 int
1336 main(int argc, char *argv[])
1337 {
1338 size_t u;
1339
1340 if (argc <= 1) {
1341 printf("usage: testspeed all | name...\n");
1342 printf("individual test names:\n");
1343 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1344 printf(" %s\n", tfns[u].name);
1345 }
1346 } else {
1347 for (u = 0; u < (sizeof tfns) / (sizeof tfns[0]); u ++) {
1348 int i;
1349
1350 for (i = 1; i < argc; i ++) {
1351 if (eq_name(argv[i], tfns[u].name)
1352 || eq_name(argv[i], "all"))
1353 {
1354 tfns[u].fn();
1355 break;
1356 }
1357 }
1358 }
1359 }
1360 return 0;
1361 }
The BearSSL library and tools.