]> git.ipfire.org Git - thirdparty/openssl.git/blob - apps/speed.c
projects / thirdparty / openssl.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
speed.c: simplify aggregation of dsa --multi results
[thirdparty/openssl.git] / apps / speed.c
1 /*
2 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the OpenSSL license (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 /* ====================================================================
11 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
12 *
13 * Portions of the attached software ("Contribution") are developed by
14 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
15 *
16 * The Contribution is licensed pursuant to the OpenSSL open source
17 * license provided above.
18 *
19 * The ECDH and ECDSA speed test software is originally written by
20 * Sumit Gupta of Sun Microsystems Laboratories.
21 *
22 */
23
24 #undef SECONDS
25 #define SECONDS 3
26 #define PRIME_SECONDS 10
27 #define RSA_SECONDS 10
28 #define DSA_SECONDS 10
29 #define ECDSA_SECONDS 10
30 #define ECDH_SECONDS 10
31
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <math.h>
36 #include "apps.h"
37 #include <openssl/crypto.h>
38 #include <openssl/rand.h>
39 #include <openssl/err.h>
40 #include <openssl/evp.h>
41 #include <openssl/objects.h>
42 #include <openssl/async.h>
43 #if !defined(OPENSSL_SYS_MSDOS)
44 # include OPENSSL_UNISTD
45 #endif
46
47 #if defined(_WIN32)
48 # include <windows.h>
49 #endif
50
51 #include <openssl/bn.h>
52 #ifndef OPENSSL_NO_DES
53 # include <openssl/des.h>
54 #endif
55 #include <openssl/aes.h>
56 #ifndef OPENSSL_NO_CAMELLIA
57 # include <openssl/camellia.h>
58 #endif
59 #ifndef OPENSSL_NO_MD2
60 # include <openssl/md2.h>
61 #endif
62 #ifndef OPENSSL_NO_MDC2
63 # include <openssl/mdc2.h>
64 #endif
65 #ifndef OPENSSL_NO_MD4
66 # include <openssl/md4.h>
67 #endif
68 #ifndef OPENSSL_NO_MD5
69 # include <openssl/md5.h>
70 #endif
71 #include <openssl/hmac.h>
72 #include <openssl/sha.h>
73 #ifndef OPENSSL_NO_RMD160
74 # include <openssl/ripemd.h>
75 #endif
76 #ifndef OPENSSL_NO_WHIRLPOOL
77 # include <openssl/whrlpool.h>
78 #endif
79 #ifndef OPENSSL_NO_RC4
80 # include <openssl/rc4.h>
81 #endif
82 #ifndef OPENSSL_NO_RC5
83 # include <openssl/rc5.h>
84 #endif
85 #ifndef OPENSSL_NO_RC2
86 # include <openssl/rc2.h>
87 #endif
88 #ifndef OPENSSL_NO_IDEA
89 # include <openssl/idea.h>
90 #endif
91 #ifndef OPENSSL_NO_SEED
92 # include <openssl/seed.h>
93 #endif
94 #ifndef OPENSSL_NO_BF
95 # include <openssl/blowfish.h>
96 #endif
97 #ifndef OPENSSL_NO_CAST
98 # include <openssl/cast.h>
99 #endif
100 #ifndef OPENSSL_NO_RSA
101 # include <openssl/rsa.h>
102 # include "./testrsa.h"
103 #endif
104 #include <openssl/x509.h>
105 #ifndef OPENSSL_NO_DSA
106 # include <openssl/dsa.h>
107 # include "./testdsa.h"
108 #endif
109 #ifndef OPENSSL_NO_EC
110 # include <openssl/ec.h>
111 #endif
112 #include <openssl/modes.h>
113
114 #ifndef HAVE_FORK
115 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
116 # define HAVE_FORK 0
117 # else
118 # define HAVE_FORK 1
119 # endif
120 #endif
121
122 #if HAVE_FORK
123 # undef NO_FORK
124 #else
125 # define NO_FORK
126 #endif
127
128 #undef BUFSIZE
129 #define BUFSIZE (1024*16+1)
130 #define MAX_MISALIGNMENT 63
131
132 #define ALGOR_NUM 30
133 #define SIZE_NUM 6
134 #define PRIME_NUM 3
135 #define RSA_NUM 7
136 #define DSA_NUM 3
137
138 #define EC_NUM 17
139 #define MAX_ECDH_SIZE 256
140 #define MISALIGN 64
141
142 static volatile int run = 0;
143
144 static int mr = 0;
145 static int usertime = 1;
146
147 typedef struct loopargs_st {
148 ASYNC_JOB *inprogress_job;
149 ASYNC_WAIT_CTX *wait_ctx;
150 unsigned char *buf;
151 unsigned char *buf2;
152 unsigned char *buf_malloc;
153 unsigned char *buf2_malloc;
154 unsigned int siglen;
155 #ifndef OPENSSL_NO_RSA
156 RSA *rsa_key[RSA_NUM];
157 #endif
158 #ifndef OPENSSL_NO_DSA
159 DSA *dsa_key[DSA_NUM];
160 #endif
161 #ifndef OPENSSL_NO_EC
162 EC_KEY *ecdsa[EC_NUM];
163 EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
164 unsigned char *secret_a;
165 unsigned char *secret_b;
166 size_t outlen[EC_NUM];
167 #endif
168 EVP_CIPHER_CTX *ctx;
169 HMAC_CTX *hctx;
170 GCM128_CONTEXT *gcm_ctx;
171 } loopargs_t;
172
173 #ifndef OPENSSL_NO_MD2
174 static int EVP_Digest_MD2_loop(void *args);
175 #endif
176
177 #ifndef OPENSSL_NO_MDC2
178 static int EVP_Digest_MDC2_loop(void *args);
179 #endif
180 #ifndef OPENSSL_NO_MD4
181 static int EVP_Digest_MD4_loop(void *args);
182 #endif
183 #ifndef OPENSSL_NO_MD5
184 static int MD5_loop(void *args);
185 static int HMAC_loop(void *args);
186 #endif
187 static int SHA1_loop(void *args);
188 static int SHA256_loop(void *args);
189 static int SHA512_loop(void *args);
190 #ifndef OPENSSL_NO_WHIRLPOOL
191 static int WHIRLPOOL_loop(void *args);
192 #endif
193 #ifndef OPENSSL_NO_RMD160
194 static int EVP_Digest_RMD160_loop(void *args);
195 #endif
196 #ifndef OPENSSL_NO_RC4
197 static int RC4_loop(void *args);
198 #endif
199 #ifndef OPENSSL_NO_DES
200 static int DES_ncbc_encrypt_loop(void *args);
201 static int DES_ede3_cbc_encrypt_loop(void *args);
202 #endif
203 static int AES_cbc_128_encrypt_loop(void *args);
204 static int AES_cbc_192_encrypt_loop(void *args);
205 static int AES_ige_128_encrypt_loop(void *args);
206 static int AES_cbc_256_encrypt_loop(void *args);
207 static int AES_ige_192_encrypt_loop(void *args);
208 static int AES_ige_256_encrypt_loop(void *args);
209 static int CRYPTO_gcm128_aad_loop(void *args);
210 static int EVP_Update_loop(void *args);
211 static int EVP_Digest_loop(void *args);
212 #ifndef OPENSSL_NO_RSA
213 static int RSA_sign_loop(void *args);
214 static int RSA_verify_loop(void *args);
215 #endif
216 #ifndef OPENSSL_NO_DSA
217 static int DSA_sign_loop(void *args);
218 static int DSA_verify_loop(void *args);
219 #endif
220 #ifndef OPENSSL_NO_EC
221 static int ECDSA_sign_loop(void *args);
222 static int ECDSA_verify_loop(void *args);
223 #endif
224 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
225 loopargs_t * loopargs);
226
227 static double Time_F(int s);
228 static void print_message(const char *s, long num, int length);
229 static void pkey_print_message(const char *str, const char *str2,
230 long num, int bits, int sec);
231 static void print_result(int alg, int run_no, int count, double time_used);
232 #ifndef NO_FORK
233 static int do_multi(int multi);
234 #endif
235
236 static const char *names[ALGOR_NUM] = {
237 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
238 "des cbc", "des ede3", "idea cbc", "seed cbc",
239 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
240 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
241 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
242 "evp", "sha256", "sha512", "whirlpool",
243 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
244 };
245
246 static double results[ALGOR_NUM][SIZE_NUM];
247
248 static const int lengths[SIZE_NUM] = {
249 16, 64, 256, 1024, 8 * 1024, 16 * 1024
250 };
251
252 #ifndef OPENSSL_NO_RSA
253 static double rsa_results[RSA_NUM][2];
254 #endif
255 #ifndef OPENSSL_NO_DSA
256 static double dsa_results[DSA_NUM][2];
257 #endif
258 #ifndef OPENSSL_NO_EC
259 static double ecdsa_results[EC_NUM][2];
260 static double ecdh_results[EC_NUM][1];
261 #endif
262
263 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_EC)
264 static const char rnd_seed[] =
265 "string to make the random number generator think it has entropy";
266 #endif
267
268 #ifdef SIGALRM
269 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
270 # define SIGRETTYPE void
271 # else
272 # define SIGRETTYPE int
273 # endif
274
275 static SIGRETTYPE sig_done(int sig);
276 static SIGRETTYPE sig_done(int sig)
277 {
278 signal(SIGALRM, sig_done);
279 run = 0;
280 }
281 #endif
282
283 #define START 0
284 #define STOP 1
285
286 #if defined(_WIN32)
287
288 # if !defined(SIGALRM)
289 # define SIGALRM
290 # endif
291 static unsigned int lapse, schlock;
292 static void alarm_win32(unsigned int secs)
293 {
294 lapse = secs * 1000;
295 }
296
297 # define alarm alarm_win32
298
299 static DWORD WINAPI sleepy(VOID * arg)
300 {
301 schlock = 1;
302 Sleep(lapse);
303 run = 0;
304 return 0;
305 }
306
307 static double Time_F(int s)
308 {
309 double ret;
310 static HANDLE thr;
311
312 if (s == START) {
313 schlock = 0;
314 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
315 if (thr == NULL) {
316 DWORD err = GetLastError();
317 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
318 ExitProcess(err);
319 }
320 while (!schlock)
321 Sleep(0); /* scheduler spinlock */
322 ret = app_tminterval(s, usertime);
323 } else {
324 ret = app_tminterval(s, usertime);
325 if (run)
326 TerminateThread(thr, 0);
327 CloseHandle(thr);
328 }
329
330 return ret;
331 }
332 #else
333
334 static double Time_F(int s)
335 {
336 double ret = app_tminterval(s, usertime);
337 if (s == STOP)
338 alarm(0);
339 return ret;
340 }
341 #endif
342
343 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
344
345 static int found(const char *name, const OPT_PAIR *pairs, int *result)
346 {
347 for (; pairs->name; pairs++)
348 if (strcmp(name, pairs->name) == 0) {
349 *result = pairs->retval;
350 return 1;
351 }
352 return 0;
353 }
354
355 typedef enum OPTION_choice {
356 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
357 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
358 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS
359 } OPTION_CHOICE;
360
361 const OPTIONS speed_options[] = {
362 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
363 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
364 {"help", OPT_HELP, '-', "Display this summary"},
365 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
366 {"decrypt", OPT_DECRYPT, '-',
367 "Time decryption instead of encryption (only EVP)"},
368 {"mr", OPT_MR, '-', "Produce machine readable output"},
369 {"mb", OPT_MB, '-',
370 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
371 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
372 {"elapsed", OPT_ELAPSED, '-',
373 "Measure time in real time instead of CPU user time"},
374 #ifndef NO_FORK
375 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
376 #endif
377 #ifndef OPENSSL_NO_ASYNC
378 {"async_jobs", OPT_ASYNCJOBS, 'p',
379 "Enable async mode and start pnum jobs"},
380 #endif
381 #ifndef OPENSSL_NO_ENGINE
382 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
383 #endif
384 {NULL},
385 };
386
387 #define D_MD2 0
388 #define D_MDC2 1
389 #define D_MD4 2
390 #define D_MD5 3
391 #define D_HMAC 4
392 #define D_SHA1 5
393 #define D_RMD160 6
394 #define D_RC4 7
395 #define D_CBC_DES 8
396 #define D_EDE3_DES 9
397 #define D_CBC_IDEA 10
398 #define D_CBC_SEED 11
399 #define D_CBC_RC2 12
400 #define D_CBC_RC5 13
401 #define D_CBC_BF 14
402 #define D_CBC_CAST 15
403 #define D_CBC_128_AES 16
404 #define D_CBC_192_AES 17
405 #define D_CBC_256_AES 18
406 #define D_CBC_128_CML 19
407 #define D_CBC_192_CML 20
408 #define D_CBC_256_CML 21
409 #define D_EVP 22
410 #define D_SHA256 23
411 #define D_SHA512 24
412 #define D_WHIRLPOOL 25
413 #define D_IGE_128_AES 26
414 #define D_IGE_192_AES 27
415 #define D_IGE_256_AES 28
416 #define D_GHASH 29
417 static OPT_PAIR doit_choices[] = {
418 #ifndef OPENSSL_NO_MD2
419 {"md2", D_MD2},
420 #endif
421 #ifndef OPENSSL_NO_MDC2
422 {"mdc2", D_MDC2},
423 #endif
424 #ifndef OPENSSL_NO_MD4
425 {"md4", D_MD4},
426 #endif
427 #ifndef OPENSSL_NO_MD5
428 {"md5", D_MD5},
429 {"hmac", D_HMAC},
430 #endif
431 {"sha1", D_SHA1},
432 {"sha256", D_SHA256},
433 {"sha512", D_SHA512},
434 #ifndef OPENSSL_NO_WHIRLPOOL
435 {"whirlpool", D_WHIRLPOOL},
436 #endif
437 #ifndef OPENSSL_NO_RMD160
438 {"ripemd", D_RMD160},
439 {"rmd160", D_RMD160},
440 {"ripemd160", D_RMD160},
441 #endif
442 #ifndef OPENSSL_NO_RC4
443 {"rc4", D_RC4},
444 #endif
445 #ifndef OPENSSL_NO_DES
446 {"des-cbc", D_CBC_DES},
447 {"des-ede3", D_EDE3_DES},
448 #endif
449 {"aes-128-cbc", D_CBC_128_AES},
450 {"aes-192-cbc", D_CBC_192_AES},
451 {"aes-256-cbc", D_CBC_256_AES},
452 {"aes-128-ige", D_IGE_128_AES},
453 {"aes-192-ige", D_IGE_192_AES},
454 {"aes-256-ige", D_IGE_256_AES},
455 #ifndef OPENSSL_NO_RC2
456 {"rc2-cbc", D_CBC_RC2},
457 {"rc2", D_CBC_RC2},
458 #endif
459 #ifndef OPENSSL_NO_RC5
460 {"rc5-cbc", D_CBC_RC5},
461 {"rc5", D_CBC_RC5},
462 #endif
463 #ifndef OPENSSL_NO_IDEA
464 {"idea-cbc", D_CBC_IDEA},
465 {"idea", D_CBC_IDEA},
466 #endif
467 #ifndef OPENSSL_NO_SEED
468 {"seed-cbc", D_CBC_SEED},
469 {"seed", D_CBC_SEED},
470 #endif
471 #ifndef OPENSSL_NO_BF
472 {"bf-cbc", D_CBC_BF},
473 {"blowfish", D_CBC_BF},
474 {"bf", D_CBC_BF},
475 #endif
476 #ifndef OPENSSL_NO_CAST
477 {"cast-cbc", D_CBC_CAST},
478 {"cast", D_CBC_CAST},
479 {"cast5", D_CBC_CAST},
480 #endif
481 {"ghash", D_GHASH},
482 {NULL}
483 };
484
485 #ifndef OPENSSL_NO_DSA
486 # define R_DSA_512 0
487 # define R_DSA_1024 1
488 # define R_DSA_2048 2
489 static OPT_PAIR dsa_choices[] = {
490 {"dsa512", R_DSA_512},
491 {"dsa1024", R_DSA_1024},
492 {"dsa2048", R_DSA_2048},
493 {NULL},
494 };
495 #endif
496
497 #define R_RSA_512 0
498 #define R_RSA_1024 1
499 #define R_RSA_2048 2
500 #define R_RSA_3072 3
501 #define R_RSA_4096 4
502 #define R_RSA_7680 5
503 #define R_RSA_15360 6
504 static OPT_PAIR rsa_choices[] = {
505 {"rsa512", R_RSA_512},
506 {"rsa1024", R_RSA_1024},
507 {"rsa2048", R_RSA_2048},
508 {"rsa3072", R_RSA_3072},
509 {"rsa4096", R_RSA_4096},
510 {"rsa7680", R_RSA_7680},
511 {"rsa15360", R_RSA_15360},
512 {NULL}
513 };
514
515 #define R_EC_P160 0
516 #define R_EC_P192 1
517 #define R_EC_P224 2
518 #define R_EC_P256 3
519 #define R_EC_P384 4
520 #define R_EC_P521 5
521 #define R_EC_K163 6
522 #define R_EC_K233 7
523 #define R_EC_K283 8
524 #define R_EC_K409 9
525 #define R_EC_K571 10
526 #define R_EC_B163 11
527 #define R_EC_B233 12
528 #define R_EC_B283 13
529 #define R_EC_B409 14
530 #define R_EC_B571 15
531 #define R_EC_X25519 16
532 #ifndef OPENSSL_NO_EC
533 static OPT_PAIR ecdsa_choices[] = {
534 {"ecdsap160", R_EC_P160},
535 {"ecdsap192", R_EC_P192},
536 {"ecdsap224", R_EC_P224},
537 {"ecdsap256", R_EC_P256},
538 {"ecdsap384", R_EC_P384},
539 {"ecdsap521", R_EC_P521},
540 {"ecdsak163", R_EC_K163},
541 {"ecdsak233", R_EC_K233},
542 {"ecdsak283", R_EC_K283},
543 {"ecdsak409", R_EC_K409},
544 {"ecdsak571", R_EC_K571},
545 {"ecdsab163", R_EC_B163},
546 {"ecdsab233", R_EC_B233},
547 {"ecdsab283", R_EC_B283},
548 {"ecdsab409", R_EC_B409},
549 {"ecdsab571", R_EC_B571},
550 {NULL}
551 };
552
553 static OPT_PAIR ecdh_choices[] = {
554 {"ecdhp160", R_EC_P160},
555 {"ecdhp192", R_EC_P192},
556 {"ecdhp224", R_EC_P224},
557 {"ecdhp256", R_EC_P256},
558 {"ecdhp384", R_EC_P384},
559 {"ecdhp521", R_EC_P521},
560 {"ecdhk163", R_EC_K163},
561 {"ecdhk233", R_EC_K233},
562 {"ecdhk283", R_EC_K283},
563 {"ecdhk409", R_EC_K409},
564 {"ecdhk571", R_EC_K571},
565 {"ecdhb163", R_EC_B163},
566 {"ecdhb233", R_EC_B233},
567 {"ecdhb283", R_EC_B283},
568 {"ecdhb409", R_EC_B409},
569 {"ecdhb571", R_EC_B571},
570 {"ecdhx25519", R_EC_X25519},
571 {NULL}
572 };
573 #endif
574
575 #ifndef SIGALRM
576 # define COND(d) (count < (d))
577 # define COUNT(d) (d)
578 #else
579 # define COND(unused_cond) (run && count<0x7fffffff)
580 # define COUNT(d) (count)
581 #endif /* SIGALRM */
582
583 static int testnum;
584
585 /* Nb of iterations to do per algorithm and key-size */
586 static long c[ALGOR_NUM][SIZE_NUM];
587
588 #ifndef OPENSSL_NO_MD2
589 static int EVP_Digest_MD2_loop(void *args)
590 {
591 loopargs_t *tempargs = *(loopargs_t **) args;
592 unsigned char *buf = tempargs->buf;
593 unsigned char md2[MD2_DIGEST_LENGTH];
594 int count;
595
596 for (count = 0; COND(c[D_MD2][testnum]); count++) {
597 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
598 NULL))
599 return -1;
600 }
601 return count;
602 }
603 #endif
604
605 #ifndef OPENSSL_NO_MDC2
606 static int EVP_Digest_MDC2_loop(void *args)
607 {
608 loopargs_t *tempargs = *(loopargs_t **) args;
609 unsigned char *buf = tempargs->buf;
610 unsigned char mdc2[MDC2_DIGEST_LENGTH];
611 int count;
612
613 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
614 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
615 NULL))
616 return -1;
617 }
618 return count;
619 }
620 #endif
621
622 #ifndef OPENSSL_NO_MD4
623 static int EVP_Digest_MD4_loop(void *args)
624 {
625 loopargs_t *tempargs = *(loopargs_t **) args;
626 unsigned char *buf = tempargs->buf;
627 unsigned char md4[MD4_DIGEST_LENGTH];
628 int count;
629
630 for (count = 0; COND(c[D_MD4][testnum]); count++) {
631 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
632 NULL))
633 return -1;
634 }
635 return count;
636 }
637 #endif
638
639 #ifndef OPENSSL_NO_MD5
640 static int MD5_loop(void *args)
641 {
642 loopargs_t *tempargs = *(loopargs_t **) args;
643 unsigned char *buf = tempargs->buf;
644 unsigned char md5[MD5_DIGEST_LENGTH];
645 int count;
646 for (count = 0; COND(c[D_MD5][testnum]); count++)
647 MD5(buf, lengths[testnum], md5);
648 return count;
649 }
650
651 static int HMAC_loop(void *args)
652 {
653 loopargs_t *tempargs = *(loopargs_t **) args;
654 unsigned char *buf = tempargs->buf;
655 HMAC_CTX *hctx = tempargs->hctx;
656 unsigned char hmac[MD5_DIGEST_LENGTH];
657 int count;
658
659 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
660 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
661 HMAC_Update(hctx, buf, lengths[testnum]);
662 HMAC_Final(hctx, hmac, NULL);
663 }
664 return count;
665 }
666 #endif
667
668 static int SHA1_loop(void *args)
669 {
670 loopargs_t *tempargs = *(loopargs_t **) args;
671 unsigned char *buf = tempargs->buf;
672 unsigned char sha[SHA_DIGEST_LENGTH];
673 int count;
674 for (count = 0; COND(c[D_SHA1][testnum]); count++)
675 SHA1(buf, lengths[testnum], sha);
676 return count;
677 }
678
679 static int SHA256_loop(void *args)
680 {
681 loopargs_t *tempargs = *(loopargs_t **) args;
682 unsigned char *buf = tempargs->buf;
683 unsigned char sha256[SHA256_DIGEST_LENGTH];
684 int count;
685 for (count = 0; COND(c[D_SHA256][testnum]); count++)
686 SHA256(buf, lengths[testnum], sha256);
687 return count;
688 }
689
690 static int SHA512_loop(void *args)
691 {
692 loopargs_t *tempargs = *(loopargs_t **) args;
693 unsigned char *buf = tempargs->buf;
694 unsigned char sha512[SHA512_DIGEST_LENGTH];
695 int count;
696 for (count = 0; COND(c[D_SHA512][testnum]); count++)
697 SHA512(buf, lengths[testnum], sha512);
698 return count;
699 }
700
701 #ifndef OPENSSL_NO_WHIRLPOOL
702 static int WHIRLPOOL_loop(void *args)
703 {
704 loopargs_t *tempargs = *(loopargs_t **) args;
705 unsigned char *buf = tempargs->buf;
706 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
707 int count;
708 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
709 WHIRLPOOL(buf, lengths[testnum], whirlpool);
710 return count;
711 }
712 #endif
713
714 #ifndef OPENSSL_NO_RMD160
715 static int EVP_Digest_RMD160_loop(void *args)
716 {
717 loopargs_t *tempargs = *(loopargs_t **) args;
718 unsigned char *buf = tempargs->buf;
719 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
720 int count;
721 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
722 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
723 NULL, EVP_ripemd160(), NULL))
724 return -1;
725 }
726 return count;
727 }
728 #endif
729
730 #ifndef OPENSSL_NO_RC4
731 static RC4_KEY rc4_ks;
732 static int RC4_loop(void *args)
733 {
734 loopargs_t *tempargs = *(loopargs_t **) args;
735 unsigned char *buf = tempargs->buf;
736 int count;
737 for (count = 0; COND(c[D_RC4][testnum]); count++)
738 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
739 return count;
740 }
741 #endif
742
743 #ifndef OPENSSL_NO_DES
744 static unsigned char DES_iv[8];
745 static DES_key_schedule sch;
746 static DES_key_schedule sch2;
747 static DES_key_schedule sch3;
748 static int DES_ncbc_encrypt_loop(void *args)
749 {
750 loopargs_t *tempargs = *(loopargs_t **) args;
751 unsigned char *buf = tempargs->buf;
752 int count;
753 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
754 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
755 &DES_iv, DES_ENCRYPT);
756 return count;
757 }
758
759 static int DES_ede3_cbc_encrypt_loop(void *args)
760 {
761 loopargs_t *tempargs = *(loopargs_t **) args;
762 unsigned char *buf = tempargs->buf;
763 int count;
764 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
765 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
766 &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
767 return count;
768 }
769 #endif
770
771 #define MAX_BLOCK_SIZE 128
772
773 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
774 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
775 static int AES_cbc_128_encrypt_loop(void *args)
776 {
777 loopargs_t *tempargs = *(loopargs_t **) args;
778 unsigned char *buf = tempargs->buf;
779 int count;
780 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
781 AES_cbc_encrypt(buf, buf,
782 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
783 return count;
784 }
785
786 static int AES_cbc_192_encrypt_loop(void *args)
787 {
788 loopargs_t *tempargs = *(loopargs_t **) args;
789 unsigned char *buf = tempargs->buf;
790 int count;
791 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
792 AES_cbc_encrypt(buf, buf,
793 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
794 return count;
795 }
796
797 static int AES_cbc_256_encrypt_loop(void *args)
798 {
799 loopargs_t *tempargs = *(loopargs_t **) args;
800 unsigned char *buf = tempargs->buf;
801 int count;
802 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
803 AES_cbc_encrypt(buf, buf,
804 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
805 return count;
806 }
807
808 static int AES_ige_128_encrypt_loop(void *args)
809 {
810 loopargs_t *tempargs = *(loopargs_t **) args;
811 unsigned char *buf = tempargs->buf;
812 unsigned char *buf2 = tempargs->buf2;
813 int count;
814 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
815 AES_ige_encrypt(buf, buf2,
816 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
817 return count;
818 }
819
820 static int AES_ige_192_encrypt_loop(void *args)
821 {
822 loopargs_t *tempargs = *(loopargs_t **) args;
823 unsigned char *buf = tempargs->buf;
824 unsigned char *buf2 = tempargs->buf2;
825 int count;
826 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
827 AES_ige_encrypt(buf, buf2,
828 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
829 return count;
830 }
831
832 static int AES_ige_256_encrypt_loop(void *args)
833 {
834 loopargs_t *tempargs = *(loopargs_t **) args;
835 unsigned char *buf = tempargs->buf;
836 unsigned char *buf2 = tempargs->buf2;
837 int count;
838 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
839 AES_ige_encrypt(buf, buf2,
840 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
841 return count;
842 }
843
844 static int CRYPTO_gcm128_aad_loop(void *args)
845 {
846 loopargs_t *tempargs = *(loopargs_t **) args;
847 unsigned char *buf = tempargs->buf;
848 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
849 int count;
850 for (count = 0; COND(c[D_GHASH][testnum]); count++)
851 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
852 return count;
853 }
854
855 static long save_count = 0;
856 static int decrypt = 0;
857 static int EVP_Update_loop(void *args)
858 {
859 loopargs_t *tempargs = *(loopargs_t **) args;
860 unsigned char *buf = tempargs->buf;
861 EVP_CIPHER_CTX *ctx = tempargs->ctx;
862 int outl, count;
863 #ifndef SIGALRM
864 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
865 #endif
866 if (decrypt)
867 for (count = 0; COND(nb_iter); count++)
868 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
869 else
870 for (count = 0; COND(nb_iter); count++)
871 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
872 if (decrypt)
873 EVP_DecryptFinal_ex(ctx, buf, &outl);
874 else
875 EVP_EncryptFinal_ex(ctx, buf, &outl);
876 return count;
877 }
878
879 static const EVP_MD *evp_md = NULL;
880 static int EVP_Digest_loop(void *args)
881 {
882 loopargs_t *tempargs = *(loopargs_t **) args;
883 unsigned char *buf = tempargs->buf;
884 unsigned char md[EVP_MAX_MD_SIZE];
885 int count;
886 #ifndef SIGALRM
887 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
888 #endif
889
890 for (count = 0; COND(nb_iter); count++) {
891 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
892 return -1;
893 }
894 return count;
895 }
896
897 #ifndef OPENSSL_NO_RSA
898 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
899
900 static int RSA_sign_loop(void *args)
901 {
902 loopargs_t *tempargs = *(loopargs_t **) args;
903 unsigned char *buf = tempargs->buf;
904 unsigned char *buf2 = tempargs->buf2;
905 unsigned int *rsa_num = &tempargs->siglen;
906 RSA **rsa_key = tempargs->rsa_key;
907 int ret, count;
908 for (count = 0; COND(rsa_c[testnum][0]); count++) {
909 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
910 if (ret == 0) {
911 BIO_printf(bio_err, "RSA sign failure\n");
912 ERR_print_errors(bio_err);
913 count = -1;
914 break;
915 }
916 }
917 return count;
918 }
919
920 static int RSA_verify_loop(void *args)
921 {
922 loopargs_t *tempargs = *(loopargs_t **) args;
923 unsigned char *buf = tempargs->buf;
924 unsigned char *buf2 = tempargs->buf2;
925 unsigned int rsa_num = tempargs->siglen;
926 RSA **rsa_key = tempargs->rsa_key;
927 int ret, count;
928 for (count = 0; COND(rsa_c[testnum][1]); count++) {
929 ret =
930 RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
931 if (ret <= 0) {
932 BIO_printf(bio_err, "RSA verify failure\n");
933 ERR_print_errors(bio_err);
934 count = -1;
935 break;
936 }
937 }
938 return count;
939 }
940 #endif
941
942 #ifndef OPENSSL_NO_DSA
943 static long dsa_c[DSA_NUM][2];
944 static int DSA_sign_loop(void *args)
945 {
946 loopargs_t *tempargs = *(loopargs_t **) args;
947 unsigned char *buf = tempargs->buf;
948 unsigned char *buf2 = tempargs->buf2;
949 DSA **dsa_key = tempargs->dsa_key;
950 unsigned int *siglen = &tempargs->siglen;
951 int ret, count;
952 for (count = 0; COND(dsa_c[testnum][0]); count++) {
953 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
954 if (ret == 0) {
955 BIO_printf(bio_err, "DSA sign failure\n");
956 ERR_print_errors(bio_err);
957 count = -1;
958 break;
959 }
960 }
961 return count;
962 }
963
964 static int DSA_verify_loop(void *args)
965 {
966 loopargs_t *tempargs = *(loopargs_t **) args;
967 unsigned char *buf = tempargs->buf;
968 unsigned char *buf2 = tempargs->buf2;
969 DSA **dsa_key = tempargs->dsa_key;
970 unsigned int siglen = tempargs->siglen;
971 int ret, count;
972 for (count = 0; COND(dsa_c[testnum][1]); count++) {
973 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
974 if (ret <= 0) {
975 BIO_printf(bio_err, "DSA verify failure\n");
976 ERR_print_errors(bio_err);
977 count = -1;
978 break;
979 }
980 }
981 return count;
982 }
983 #endif
984
985 #ifndef OPENSSL_NO_EC
986 static long ecdsa_c[EC_NUM][2];
987 static int ECDSA_sign_loop(void *args)
988 {
989 loopargs_t *tempargs = *(loopargs_t **) args;
990 unsigned char *buf = tempargs->buf;
991 EC_KEY **ecdsa = tempargs->ecdsa;
992 unsigned char *ecdsasig = tempargs->buf2;
993 unsigned int *ecdsasiglen = &tempargs->siglen;
994 int ret, count;
995 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
996 ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
997 if (ret == 0) {
998 BIO_printf(bio_err, "ECDSA sign failure\n");
999 ERR_print_errors(bio_err);
1000 count = -1;
1001 break;
1002 }
1003 }
1004 return count;
1005 }
1006
1007 static int ECDSA_verify_loop(void *args)
1008 {
1009 loopargs_t *tempargs = *(loopargs_t **) args;
1010 unsigned char *buf = tempargs->buf;
1011 EC_KEY **ecdsa = tempargs->ecdsa;
1012 unsigned char *ecdsasig = tempargs->buf2;
1013 unsigned int ecdsasiglen = tempargs->siglen;
1014 int ret, count;
1015 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1016 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1017 if (ret != 1) {
1018 BIO_printf(bio_err, "ECDSA verify failure\n");
1019 ERR_print_errors(bio_err);
1020 count = -1;
1021 break;
1022 }
1023 }
1024 return count;
1025 }
1026
1027 /* ******************************************************************** */
1028 static long ecdh_c[EC_NUM][1];
1029
1030 static int ECDH_EVP_derive_key_loop(void *args)
1031 {
1032 loopargs_t *tempargs = *(loopargs_t **) args;
1033 EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1034 unsigned char *derived_secret = tempargs->secret_a;
1035 int count;
1036 size_t *outlen = &(tempargs->outlen[testnum]);
1037
1038 for (count = 0; COND(ecdh_c[testnum][0]); count++)
1039 EVP_PKEY_derive(ctx, derived_secret, outlen);
1040
1041 return count;
1042 }
1043
1044 #endif /* OPENSSL_NO_EC */
1045
1046 static int run_benchmark(int async_jobs,
1047 int (*loop_function) (void *), loopargs_t * loopargs)
1048 {
1049 int job_op_count = 0;
1050 int total_op_count = 0;
1051 int num_inprogress = 0;
1052 int error = 0, i = 0, ret = 0;
1053 OSSL_ASYNC_FD job_fd = 0;
1054 size_t num_job_fds = 0;
1055
1056 run = 1;
1057
1058 if (async_jobs == 0) {
1059 return loop_function((void *)&loopargs);
1060 }
1061
1062 for (i = 0; i < async_jobs && !error; i++) {
1063 loopargs_t *looparg_item = loopargs + i;
1064
1065 /* Copy pointer content (looparg_t item address) into async context */
1066 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1067 &job_op_count, loop_function,
1068 (void *)&looparg_item, sizeof(looparg_item));
1069 switch (ret) {
1070 case ASYNC_PAUSE:
1071 ++num_inprogress;
1072 break;
1073 case ASYNC_FINISH:
1074 if (job_op_count == -1) {
1075 error = 1;
1076 } else {
1077 total_op_count += job_op_count;
1078 }
1079 break;
1080 case ASYNC_NO_JOBS:
1081 case ASYNC_ERR:
1082 BIO_printf(bio_err, "Failure in the job\n");
1083 ERR_print_errors(bio_err);
1084 error = 1;
1085 break;
1086 }
1087 }
1088
1089 while (num_inprogress > 0) {
1090 #if defined(OPENSSL_SYS_WINDOWS)
1091 DWORD avail = 0;
1092 #elif defined(OPENSSL_SYS_UNIX)
1093 int select_result = 0;
1094 OSSL_ASYNC_FD max_fd = 0;
1095 fd_set waitfdset;
1096
1097 FD_ZERO(&waitfdset);
1098
1099 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1100 if (loopargs[i].inprogress_job == NULL)
1101 continue;
1102
1103 if (!ASYNC_WAIT_CTX_get_all_fds
1104 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1105 || num_job_fds > 1) {
1106 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1107 ERR_print_errors(bio_err);
1108 error = 1;
1109 break;
1110 }
1111 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1112 &num_job_fds);
1113 FD_SET(job_fd, &waitfdset);
1114 if (job_fd > max_fd)
1115 max_fd = job_fd;
1116 }
1117
1118 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1119 BIO_printf(bio_err,
1120 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1121 "Decrease the value of async_jobs\n",
1122 max_fd, FD_SETSIZE);
1123 ERR_print_errors(bio_err);
1124 error = 1;
1125 break;
1126 }
1127
1128 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1129 if (select_result == -1 && errno == EINTR)
1130 continue;
1131
1132 if (select_result == -1) {
1133 BIO_printf(bio_err, "Failure in the select\n");
1134 ERR_print_errors(bio_err);
1135 error = 1;
1136 break;
1137 }
1138
1139 if (select_result == 0)
1140 continue;
1141 #endif
1142
1143 for (i = 0; i < async_jobs; i++) {
1144 if (loopargs[i].inprogress_job == NULL)
1145 continue;
1146
1147 if (!ASYNC_WAIT_CTX_get_all_fds
1148 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1149 || num_job_fds > 1) {
1150 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1151 ERR_print_errors(bio_err);
1152 error = 1;
1153 break;
1154 }
1155 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1156 &num_job_fds);
1157
1158 #if defined(OPENSSL_SYS_UNIX)
1159 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1160 continue;
1161 #elif defined(OPENSSL_SYS_WINDOWS)
1162 if (num_job_fds == 1
1163 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1164 && avail > 0)
1165 continue;
1166 #endif
1167
1168 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1169 loopargs[i].wait_ctx, &job_op_count,
1170 loop_function, (void *)(loopargs + i),
1171 sizeof(loopargs_t));
1172 switch (ret) {
1173 case ASYNC_PAUSE:
1174 break;
1175 case ASYNC_FINISH:
1176 if (job_op_count == -1) {
1177 error = 1;
1178 } else {
1179 total_op_count += job_op_count;
1180 }
1181 --num_inprogress;
1182 loopargs[i].inprogress_job = NULL;
1183 break;
1184 case ASYNC_NO_JOBS:
1185 case ASYNC_ERR:
1186 --num_inprogress;
1187 loopargs[i].inprogress_job = NULL;
1188 BIO_printf(bio_err, "Failure in the job\n");
1189 ERR_print_errors(bio_err);
1190 error = 1;
1191 break;
1192 }
1193 }
1194 }
1195
1196 return error ? -1 : total_op_count;
1197 }
1198
1199 int speed_main(int argc, char **argv)
1200 {
1201 ENGINE *e = NULL;
1202 loopargs_t *loopargs = NULL;
1203 int async_init = 0;
1204 int loopargs_len = 0;
1205 char *prog;
1206 const char *engine_id = NULL;
1207 const EVP_CIPHER *evp_cipher = NULL;
1208 double d = 0.0;
1209 OPTION_CHOICE o;
1210 int multiblock = 0, pr_header = 0;
1211 int doit[ALGOR_NUM] = { 0 };
1212 int ret = 1, i, k, misalign = 0;
1213 long count = 0;
1214 #ifndef NO_FORK
1215 int multi = 0;
1216 #endif
1217 int async_jobs = 0;
1218 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1219 || !defined(OPENSSL_NO_EC)
1220 long rsa_count = 1;
1221 #endif
1222
1223 /* What follows are the buffers and key material. */
1224 #ifndef OPENSSL_NO_RC5
1225 RC5_32_KEY rc5_ks;
1226 #endif
1227 #ifndef OPENSSL_NO_RC2
1228 RC2_KEY rc2_ks;
1229 #endif
1230 #ifndef OPENSSL_NO_IDEA
1231 IDEA_KEY_SCHEDULE idea_ks;
1232 #endif
1233 #ifndef OPENSSL_NO_SEED
1234 SEED_KEY_SCHEDULE seed_ks;
1235 #endif
1236 #ifndef OPENSSL_NO_BF
1237 BF_KEY bf_ks;
1238 #endif
1239 #ifndef OPENSSL_NO_CAST
1240 CAST_KEY cast_ks;
1241 #endif
1242 static const unsigned char key16[16] = {
1243 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1244 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1245 };
1246 static const unsigned char key24[24] = {
1247 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1248 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1249 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1250 };
1251 static const unsigned char key32[32] = {
1252 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1253 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1254 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1255 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1256 };
1257 #ifndef OPENSSL_NO_CAMELLIA
1258 static const unsigned char ckey24[24] = {
1259 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1260 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1261 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1262 };
1263 static const unsigned char ckey32[32] = {
1264 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1265 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1266 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1267 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1268 };
1269 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1270 #endif
1271 #ifndef OPENSSL_NO_DES
1272 static DES_cblock key = {
1273 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1274 };
1275 static DES_cblock key2 = {
1276 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1277 };
1278 static DES_cblock key3 = {
1279 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1280 };
1281 #endif
1282 #ifndef OPENSSL_NO_RSA
1283 static const unsigned int rsa_bits[RSA_NUM] = {
1284 512, 1024, 2048, 3072, 4096, 7680, 15360
1285 };
1286 static const unsigned char *rsa_data[RSA_NUM] = {
1287 test512, test1024, test2048, test3072, test4096, test7680, test15360
1288 };
1289 static const int rsa_data_length[RSA_NUM] = {
1290 sizeof(test512), sizeof(test1024),
1291 sizeof(test2048), sizeof(test3072),
1292 sizeof(test4096), sizeof(test7680),
1293 sizeof(test15360)
1294 };
1295 int rsa_doit[RSA_NUM] = { 0 };
1296 #endif
1297 #ifndef OPENSSL_NO_DSA
1298 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1299 int dsa_doit[DSA_NUM] = { 0 };
1300 #endif
1301 #ifndef OPENSSL_NO_EC
1302 /*
1303 * We only test over the following curves as they are representative, To
1304 * add tests over more curves, simply add the curve NID and curve name to
1305 * the following arrays and increase the EC_NUM value accordingly.
1306 */
1307 static const unsigned int test_curves[EC_NUM] = {
1308 /* Prime Curves */
1309 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1310 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1311 /* Binary Curves */
1312 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1313 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1314 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1315 NID_sect571r1,
1316 /* Other */
1317 NID_X25519
1318 };
1319 static const char *test_curves_names[EC_NUM] = {
1320 /* Prime Curves */
1321 "secp160r1", "nistp192", "nistp224",
1322 "nistp256", "nistp384", "nistp521",
1323 /* Binary Curves */
1324 "nistk163", "nistk233", "nistk283",
1325 "nistk409", "nistk571", "nistb163",
1326 "nistb233", "nistb283", "nistb409",
1327 "nistb571",
1328 /* Other */
1329 "X25519"
1330 };
1331 static const int test_curves_bits[EC_NUM] = {
1332 160, 192, 224,
1333 256, 384, 521,
1334 163, 233, 283,
1335 409, 571, 163,
1336 233, 283, 409,
1337 571, 253 /* X25519 */
1338 };
1339
1340 int ecdsa_doit[EC_NUM] = { 0 };
1341 int ecdh_doit[EC_NUM] = { 0 };
1342 #endif /* ndef OPENSSL_NO_EC */
1343
1344 prog = opt_init(argc, argv, speed_options);
1345 while ((o = opt_next()) != OPT_EOF) {
1346 switch (o) {
1347 case OPT_EOF:
1348 case OPT_ERR:
1349 opterr:
1350 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1351 goto end;
1352 case OPT_HELP:
1353 opt_help(speed_options);
1354 ret = 0;
1355 goto end;
1356 case OPT_ELAPSED:
1357 usertime = 0;
1358 break;
1359 case OPT_EVP:
1360 evp_cipher = EVP_get_cipherbyname(opt_arg());
1361 if (evp_cipher == NULL)
1362 evp_md = EVP_get_digestbyname(opt_arg());
1363 if (evp_cipher == NULL && evp_md == NULL) {
1364 BIO_printf(bio_err,
1365 "%s: %s is an unknown cipher or digest\n",
1366 prog, opt_arg());
1367 goto end;
1368 }
1369 doit[D_EVP] = 1;
1370 break;
1371 case OPT_DECRYPT:
1372 decrypt = 1;
1373 break;
1374 case OPT_ENGINE:
1375 /*
1376 * In a forked execution, an engine might need to be
1377 * initialised by each child process, not by the parent.
1378 * So store the name here and run setup_engine() later on.
1379 */
1380 engine_id = opt_arg();
1381 break;
1382 case OPT_MULTI:
1383 #ifndef NO_FORK
1384 multi = atoi(opt_arg());
1385 #endif
1386 break;
1387 case OPT_ASYNCJOBS:
1388 #ifndef OPENSSL_NO_ASYNC
1389 async_jobs = atoi(opt_arg());
1390 if (!ASYNC_is_capable()) {
1391 BIO_printf(bio_err,
1392 "%s: async_jobs specified but async not supported\n",
1393 prog);
1394 goto opterr;
1395 }
1396 #endif
1397 break;
1398 case OPT_MISALIGN:
1399 if (!opt_int(opt_arg(), &misalign))
1400 goto end;
1401 if (misalign > MISALIGN) {
1402 BIO_printf(bio_err,
1403 "%s: Maximum offset is %d\n", prog, MISALIGN);
1404 goto opterr;
1405 }
1406 break;
1407 case OPT_MR:
1408 mr = 1;
1409 break;
1410 case OPT_MB:
1411 multiblock = 1;
1412 #ifdef OPENSSL_NO_MULTIBLOCK
1413 BIO_printf(bio_err,
1414 "%s: -mb specified but multi-block support is disabled\n",
1415 prog);
1416 goto end;
1417 #endif
1418 break;
1419 }
1420 }
1421 argc = opt_num_rest();
1422 argv = opt_rest();
1423
1424 /* Remaining arguments are algorithms. */
1425 for (; *argv; argv++) {
1426 if (found(*argv, doit_choices, &i)) {
1427 doit[i] = 1;
1428 continue;
1429 }
1430 #ifndef OPENSSL_NO_DES
1431 if (strcmp(*argv, "des") == 0) {
1432 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1433 continue;
1434 }
1435 #endif
1436 if (strcmp(*argv, "sha") == 0) {
1437 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1438 continue;
1439 }
1440 #ifndef OPENSSL_NO_RSA
1441 # ifndef RSA_NULL
1442 if (strcmp(*argv, "openssl") == 0) {
1443 RSA_set_default_method(RSA_PKCS1_OpenSSL());
1444 continue;
1445 }
1446 # endif
1447 if (strcmp(*argv, "rsa") == 0) {
1448 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1449 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1450 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1451 rsa_doit[R_RSA_15360] = 1;
1452 continue;
1453 }
1454 if (found(*argv, rsa_choices, &i)) {
1455 rsa_doit[i] = 1;
1456 continue;
1457 }
1458 #endif
1459 #ifndef OPENSSL_NO_DSA
1460 if (strcmp(*argv, "dsa") == 0) {
1461 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1462 dsa_doit[R_DSA_2048] = 1;
1463 continue;
1464 }
1465 if (found(*argv, dsa_choices, &i)) {
1466 dsa_doit[i] = 2;
1467 continue;
1468 }
1469 #endif
1470 if (strcmp(*argv, "aes") == 0) {
1471 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] = doit[D_CBC_256_AES] = 1;
1472 continue;
1473 }
1474 #ifndef OPENSSL_NO_CAMELLIA
1475 if (strcmp(*argv, "camellia") == 0) {
1476 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] = doit[D_CBC_256_CML] = 1;
1477 continue;
1478 }
1479 #endif
1480 #ifndef OPENSSL_NO_EC
1481 if (strcmp(*argv, "ecdsa") == 0) {
1482 for (i = 0; i < EC_NUM; i++)
1483 ecdsa_doit[i] = 1;
1484 continue;
1485 }
1486 if (found(*argv, ecdsa_choices, &i)) {
1487 ecdsa_doit[i] = 2;
1488 continue;
1489 }
1490 if (strcmp(*argv, "ecdh") == 0) {
1491 for (i = 0; i < EC_NUM; i++)
1492 ecdh_doit[i] = 1;
1493 continue;
1494 }
1495 if (found(*argv, ecdh_choices, &i)) {
1496 ecdh_doit[i] = 2;
1497 continue;
1498 }
1499 #endif
1500 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1501 goto end;
1502 }
1503
1504 /* Initialize the job pool if async mode is enabled */
1505 if (async_jobs > 0) {
1506 async_init = ASYNC_init_thread(async_jobs, async_jobs);
1507 if (!async_init) {
1508 BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1509 goto end;
1510 }
1511 }
1512
1513 loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1514 loopargs =
1515 app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1516 memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1517
1518 for (i = 0; i < loopargs_len; i++) {
1519 if (async_jobs > 0) {
1520 loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1521 if (loopargs[i].wait_ctx == NULL) {
1522 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1523 goto end;
1524 }
1525 }
1526
1527 loopargs[i].buf_malloc =
1528 app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1529 loopargs[i].buf2_malloc =
1530 app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1531 /* Align the start of buffers on a 64 byte boundary */
1532 loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1533 loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1534 #ifndef OPENSSL_NO_EC
1535 loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1536 loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1537 #endif
1538 }
1539
1540 #ifndef NO_FORK
1541 if (multi && do_multi(multi))
1542 goto show_res;
1543 #endif
1544
1545 /* Initialize the engine after the fork */
1546 e = setup_engine(engine_id, 0);
1547
1548 /* No parameters; turn on everything. */
1549 if ((argc == 0) && !doit[D_EVP]) {
1550 for (i = 0; i < ALGOR_NUM; i++)
1551 if (i != D_EVP)
1552 doit[i] = 1;
1553 #ifndef OPENSSL_NO_RSA
1554 for (i = 0; i < RSA_NUM; i++)
1555 rsa_doit[i] = 1;
1556 #endif
1557 #ifndef OPENSSL_NO_DSA
1558 for (i = 0; i < DSA_NUM; i++)
1559 dsa_doit[i] = 1;
1560 #endif
1561 #ifndef OPENSSL_NO_EC
1562 for (i = 0; i < EC_NUM; i++)
1563 ecdsa_doit[i] = 1;
1564 for (i = 0; i < EC_NUM; i++)
1565 ecdh_doit[i] = 1;
1566 #endif
1567 }
1568 for (i = 0; i < ALGOR_NUM; i++)
1569 if (doit[i])
1570 pr_header++;
1571
1572 if (usertime == 0 && !mr)
1573 BIO_printf(bio_err,
1574 "You have chosen to measure elapsed time "
1575 "instead of user CPU time.\n");
1576
1577 #ifndef OPENSSL_NO_RSA
1578 for (i = 0; i < loopargs_len; i++) {
1579 for (k = 0; k < RSA_NUM; k++) {
1580 const unsigned char *p;
1581
1582 p = rsa_data[k];
1583 loopargs[i].rsa_key[k] =
1584 d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1585 if (loopargs[i].rsa_key[k] == NULL) {
1586 BIO_printf(bio_err,
1587 "internal error loading RSA key number %d\n", k);
1588 goto end;
1589 }
1590 }
1591 }
1592 #endif
1593 #ifndef OPENSSL_NO_DSA
1594 for (i = 0; i < loopargs_len; i++) {
1595 loopargs[i].dsa_key[0] = get_dsa512();
1596 loopargs[i].dsa_key[1] = get_dsa1024();
1597 loopargs[i].dsa_key[2] = get_dsa2048();
1598 }
1599 #endif
1600 #ifndef OPENSSL_NO_DES
1601 DES_set_key_unchecked(&key, &sch);
1602 DES_set_key_unchecked(&key2, &sch2);
1603 DES_set_key_unchecked(&key3, &sch3);
1604 #endif
1605 AES_set_encrypt_key(key16, 128, &aes_ks1);
1606 AES_set_encrypt_key(key24, 192, &aes_ks2);
1607 AES_set_encrypt_key(key32, 256, &aes_ks3);
1608 #ifndef OPENSSL_NO_CAMELLIA
1609 Camellia_set_key(key16, 128, &camellia_ks1);
1610 Camellia_set_key(ckey24, 192, &camellia_ks2);
1611 Camellia_set_key(ckey32, 256, &camellia_ks3);
1612 #endif
1613 #ifndef OPENSSL_NO_IDEA
1614 IDEA_set_encrypt_key(key16, &idea_ks);
1615 #endif
1616 #ifndef OPENSSL_NO_SEED
1617 SEED_set_key(key16, &seed_ks);
1618 #endif
1619 #ifndef OPENSSL_NO_RC4
1620 RC4_set_key(&rc4_ks, 16, key16);
1621 #endif
1622 #ifndef OPENSSL_NO_RC2
1623 RC2_set_key(&rc2_ks, 16, key16, 128);
1624 #endif
1625 #ifndef OPENSSL_NO_RC5
1626 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1627 #endif
1628 #ifndef OPENSSL_NO_BF
1629 BF_set_key(&bf_ks, 16, key16);
1630 #endif
1631 #ifndef OPENSSL_NO_CAST
1632 CAST_set_key(&cast_ks, 16, key16);
1633 #endif
1634 #ifndef SIGALRM
1635 # ifndef OPENSSL_NO_DES
1636 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1637 count = 10;
1638 do {
1639 long it;
1640 count *= 2;
1641 Time_F(START);
1642 for (it = count; it; it--)
1643 DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1644 (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1645 d = Time_F(STOP);
1646 } while (d < 3);
1647 save_count = count;
1648 c[D_MD2][0] = count / 10;
1649 c[D_MDC2][0] = count / 10;
1650 c[D_MD4][0] = count;
1651 c[D_MD5][0] = count;
1652 c[D_HMAC][0] = count;
1653 c[D_SHA1][0] = count;
1654 c[D_RMD160][0] = count;
1655 c[D_RC4][0] = count * 5;
1656 c[D_CBC_DES][0] = count;
1657 c[D_EDE3_DES][0] = count / 3;
1658 c[D_CBC_IDEA][0] = count;
1659 c[D_CBC_SEED][0] = count;
1660 c[D_CBC_RC2][0] = count;
1661 c[D_CBC_RC5][0] = count;
1662 c[D_CBC_BF][0] = count;
1663 c[D_CBC_CAST][0] = count;
1664 c[D_CBC_128_AES][0] = count;
1665 c[D_CBC_192_AES][0] = count;
1666 c[D_CBC_256_AES][0] = count;
1667 c[D_CBC_128_CML][0] = count;
1668 c[D_CBC_192_CML][0] = count;
1669 c[D_CBC_256_CML][0] = count;
1670 c[D_SHA256][0] = count;
1671 c[D_SHA512][0] = count;
1672 c[D_WHIRLPOOL][0] = count;
1673 c[D_IGE_128_AES][0] = count;
1674 c[D_IGE_192_AES][0] = count;
1675 c[D_IGE_256_AES][0] = count;
1676 c[D_GHASH][0] = count;
1677
1678 for (i = 1; i < SIZE_NUM; i++) {
1679 long l0, l1;
1680
1681 l0 = (long)lengths[0];
1682 l1 = (long)lengths[i];
1683
1684 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1685 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1686 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1687 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1688 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1689 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1690 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1691 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1692 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1693 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1694 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1695
1696 l0 = (long)lengths[i - 1];
1697
1698 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1699 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1700 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1701 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1702 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1703 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1704 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1705 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1706 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1707 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1708 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1709 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1710 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1711 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1712 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1713 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1714 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1715 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1716 }
1717
1718 # ifndef OPENSSL_NO_RSA
1719 rsa_c[R_RSA_512][0] = count / 2000;
1720 rsa_c[R_RSA_512][1] = count / 400;
1721 for (i = 1; i < RSA_NUM; i++) {
1722 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1723 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1724 if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1725 rsa_doit[i] = 0;
1726 else {
1727 if (rsa_c[i][0] == 0) {
1728 rsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1729 rsa_c[i][1] = 20;
1730 }
1731 }
1732 }
1733 # endif
1734
1735 # ifndef OPENSSL_NO_DSA
1736 dsa_c[R_DSA_512][0] = count / 1000;
1737 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1738 for (i = 1; i < DSA_NUM; i++) {
1739 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1740 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1741 if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1742 dsa_doit[i] = 0;
1743 else {
1744 if (dsa_c[i][0] == 0) {
1745 dsa_c[i][0] = 1; /* Set minimum iteration Nb to 1. */
1746 dsa_c[i][1] = 1;
1747 }
1748 }
1749 }
1750 # endif
1751
1752 # ifndef OPENSSL_NO_EC
1753 ecdsa_c[R_EC_P160][0] = count / 1000;
1754 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1755 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1756 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1757 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1758 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1759 ecdsa_doit[i] = 0;
1760 else {
1761 if (ecdsa_c[i][0] == 0) {
1762 ecdsa_c[i][0] = 1;
1763 ecdsa_c[i][1] = 1;
1764 }
1765 }
1766 }
1767 ecdsa_c[R_EC_K163][0] = count / 1000;
1768 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1769 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1770 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1771 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1772 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1773 ecdsa_doit[i] = 0;
1774 else {
1775 if (ecdsa_c[i][0] == 0) {
1776 ecdsa_c[i][0] = 1;
1777 ecdsa_c[i][1] = 1;
1778 }
1779 }
1780 }
1781 ecdsa_c[R_EC_B163][0] = count / 1000;
1782 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1783 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1784 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1785 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1786 if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1787 ecdsa_doit[i] = 0;
1788 else {
1789 if (ecdsa_c[i][0] == 0) {
1790 ecdsa_c[i][0] = 1;
1791 ecdsa_c[i][1] = 1;
1792 }
1793 }
1794 }
1795
1796 ecdh_c[R_EC_P160][0] = count / 1000;
1797 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1798 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1799 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1800 ecdh_doit[i] = 0;
1801 else {
1802 if (ecdh_c[i][0] == 0) {
1803 ecdh_c[i][0] = 1;
1804 }
1805 }
1806 }
1807 ecdh_c[R_EC_K163][0] = count / 1000;
1808 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1809 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1810 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1811 ecdh_doit[i] = 0;
1812 else {
1813 if (ecdh_c[i][0] == 0) {
1814 ecdh_c[i][0] = 1;
1815 }
1816 }
1817 }
1818 ecdh_c[R_EC_B163][0] = count / 1000;
1819 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1820 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1821 if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1822 ecdh_doit[i] = 0;
1823 else {
1824 if (ecdh_c[i][0] == 0) {
1825 ecdh_c[i][0] = 1;
1826 }
1827 }
1828 }
1829 # endif
1830
1831 # else
1832 /* not worth fixing */
1833 # error "You cannot disable DES on systems without SIGALRM."
1834 # endif /* OPENSSL_NO_DES */
1835 #else
1836 # ifndef _WIN32
1837 signal(SIGALRM, sig_done);
1838 # endif
1839 #endif /* SIGALRM */
1840
1841 #ifndef OPENSSL_NO_MD2
1842 if (doit[D_MD2]) {
1843 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1844 print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1845 Time_F(START);
1846 count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1847 d = Time_F(STOP);
1848 print_result(D_MD2, testnum, count, d);
1849 }
1850 }
1851 #endif
1852 #ifndef OPENSSL_NO_MDC2
1853 if (doit[D_MDC2]) {
1854 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1855 print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1856 Time_F(START);
1857 count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1858 d = Time_F(STOP);
1859 print_result(D_MDC2, testnum, count, d);
1860 }
1861 }
1862 #endif
1863
1864 #ifndef OPENSSL_NO_MD4
1865 if (doit[D_MD4]) {
1866 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1867 print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1868 Time_F(START);
1869 count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1870 d = Time_F(STOP);
1871 print_result(D_MD4, testnum, count, d);
1872 }
1873 }
1874 #endif
1875
1876 #ifndef OPENSSL_NO_MD5
1877 if (doit[D_MD5]) {
1878 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1879 print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1880 Time_F(START);
1881 count = run_benchmark(async_jobs, MD5_loop, loopargs);
1882 d = Time_F(STOP);
1883 print_result(D_MD5, testnum, count, d);
1884 }
1885 }
1886
1887 if (doit[D_HMAC]) {
1888 static const char hmac_key[] = "This is a key...";
1889 int len = strlen(hmac_key);
1890
1891 for (i = 0; i < loopargs_len; i++) {
1892 loopargs[i].hctx = HMAC_CTX_new();
1893 if (loopargs[i].hctx == NULL) {
1894 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1895 exit(1);
1896 }
1897
1898 HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1899 }
1900 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1901 print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1902 Time_F(START);
1903 count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1904 d = Time_F(STOP);
1905 print_result(D_HMAC, testnum, count, d);
1906 }
1907 for (i = 0; i < loopargs_len; i++) {
1908 HMAC_CTX_free(loopargs[i].hctx);
1909 }
1910 }
1911 #endif
1912 if (doit[D_SHA1]) {
1913 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1914 print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1915 Time_F(START);
1916 count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1917 d = Time_F(STOP);
1918 print_result(D_SHA1, testnum, count, d);
1919 }
1920 }
1921 if (doit[D_SHA256]) {
1922 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1923 print_message(names[D_SHA256], c[D_SHA256][testnum],
1924 lengths[testnum]);
1925 Time_F(START);
1926 count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1927 d = Time_F(STOP);
1928 print_result(D_SHA256, testnum, count, d);
1929 }
1930 }
1931 if (doit[D_SHA512]) {
1932 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1933 print_message(names[D_SHA512], c[D_SHA512][testnum],
1934 lengths[testnum]);
1935 Time_F(START);
1936 count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1937 d = Time_F(STOP);
1938 print_result(D_SHA512, testnum, count, d);
1939 }
1940 }
1941 #ifndef OPENSSL_NO_WHIRLPOOL
1942 if (doit[D_WHIRLPOOL]) {
1943 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1944 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum],
1945 lengths[testnum]);
1946 Time_F(START);
1947 count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1948 d = Time_F(STOP);
1949 print_result(D_WHIRLPOOL, testnum, count, d);
1950 }
1951 }
1952 #endif
1953
1954 #ifndef OPENSSL_NO_RMD160
1955 if (doit[D_RMD160]) {
1956 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1957 print_message(names[D_RMD160], c[D_RMD160][testnum],
1958 lengths[testnum]);
1959 Time_F(START);
1960 count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1961 d = Time_F(STOP);
1962 print_result(D_RMD160, testnum, count, d);
1963 }
1964 }
1965 #endif
1966 #ifndef OPENSSL_NO_RC4
1967 if (doit[D_RC4]) {
1968 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1969 print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1970 Time_F(START);
1971 count = run_benchmark(async_jobs, RC4_loop, loopargs);
1972 d = Time_F(STOP);
1973 print_result(D_RC4, testnum, count, d);
1974 }
1975 }
1976 #endif
1977 #ifndef OPENSSL_NO_DES
1978 if (doit[D_CBC_DES]) {
1979 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1980 print_message(names[D_CBC_DES], c[D_CBC_DES][testnum],
1981 lengths[testnum]);
1982 Time_F(START);
1983 count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
1984 d = Time_F(STOP);
1985 print_result(D_CBC_DES, testnum, count, d);
1986 }
1987 }
1988
1989 if (doit[D_EDE3_DES]) {
1990 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1991 print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum],
1992 lengths[testnum]);
1993 Time_F(START);
1994 count =
1995 run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
1996 d = Time_F(STOP);
1997 print_result(D_EDE3_DES, testnum, count, d);
1998 }
1999 }
2000 #endif
2001
2002 if (doit[D_CBC_128_AES]) {
2003 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2004 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2005 lengths[testnum]);
2006 Time_F(START);
2007 count =
2008 run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2009 d = Time_F(STOP);
2010 print_result(D_CBC_128_AES, testnum, count, d);
2011 }
2012 }
2013 if (doit[D_CBC_192_AES]) {
2014 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2015 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2016 lengths[testnum]);
2017 Time_F(START);
2018 count =
2019 run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2020 d = Time_F(STOP);
2021 print_result(D_CBC_192_AES, testnum, count, d);
2022 }
2023 }
2024 if (doit[D_CBC_256_AES]) {
2025 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2026 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2027 lengths[testnum]);
2028 Time_F(START);
2029 count =
2030 run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2031 d = Time_F(STOP);
2032 print_result(D_CBC_256_AES, testnum, count, d);
2033 }
2034 }
2035
2036 if (doit[D_IGE_128_AES]) {
2037 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2038 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2039 lengths[testnum]);
2040 Time_F(START);
2041 count =
2042 run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2043 d = Time_F(STOP);
2044 print_result(D_IGE_128_AES, testnum, count, d);
2045 }
2046 }
2047 if (doit[D_IGE_192_AES]) {
2048 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2049 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2050 lengths[testnum]);
2051 Time_F(START);
2052 count =
2053 run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2054 d = Time_F(STOP);
2055 print_result(D_IGE_192_AES, testnum, count, d);
2056 }
2057 }
2058 if (doit[D_IGE_256_AES]) {
2059 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2060 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2061 lengths[testnum]);
2062 Time_F(START);
2063 count =
2064 run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2065 d = Time_F(STOP);
2066 print_result(D_IGE_256_AES, testnum, count, d);
2067 }
2068 }
2069 if (doit[D_GHASH]) {
2070 for (i = 0; i < loopargs_len; i++) {
2071 loopargs[i].gcm_ctx =
2072 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2073 CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx,
2074 (unsigned char *)"0123456789ab", 12);
2075 }
2076
2077 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2078 print_message(names[D_GHASH], c[D_GHASH][testnum],
2079 lengths[testnum]);
2080 Time_F(START);
2081 count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2082 d = Time_F(STOP);
2083 print_result(D_GHASH, testnum, count, d);
2084 }
2085 for (i = 0; i < loopargs_len; i++)
2086 CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2087 }
2088 #ifndef OPENSSL_NO_CAMELLIA
2089 if (doit[D_CBC_128_CML]) {
2090 if (async_jobs > 0) {
2091 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2092 names[D_CBC_128_CML]);
2093 doit[D_CBC_128_CML] = 0;
2094 }
2095 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2096 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2097 lengths[testnum]);
2098 Time_F(START);
2099 for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2100 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2101 (size_t)lengths[testnum], &camellia_ks1,
2102 iv, CAMELLIA_ENCRYPT);
2103 d = Time_F(STOP);
2104 print_result(D_CBC_128_CML, testnum, count, d);
2105 }
2106 }
2107 if (doit[D_CBC_192_CML]) {
2108 if (async_jobs > 0) {
2109 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2110 names[D_CBC_192_CML]);
2111 doit[D_CBC_192_CML] = 0;
2112 }
2113 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2114 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2115 lengths[testnum]);
2116 if (async_jobs > 0) {
2117 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2118 exit(1);
2119 }
2120 Time_F(START);
2121 for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2122 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2123 (size_t)lengths[testnum], &camellia_ks2,
2124 iv, CAMELLIA_ENCRYPT);
2125 d = Time_F(STOP);
2126 print_result(D_CBC_192_CML, testnum, count, d);
2127 }
2128 }
2129 if (doit[D_CBC_256_CML]) {
2130 if (async_jobs > 0) {
2131 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2132 names[D_CBC_256_CML]);
2133 doit[D_CBC_256_CML] = 0;
2134 }
2135 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2136 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2137 lengths[testnum]);
2138 Time_F(START);
2139 for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2140 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2141 (size_t)lengths[testnum], &camellia_ks3,
2142 iv, CAMELLIA_ENCRYPT);
2143 d = Time_F(STOP);
2144 print_result(D_CBC_256_CML, testnum, count, d);
2145 }
2146 }
2147 #endif
2148 #ifndef OPENSSL_NO_IDEA
2149 if (doit[D_CBC_IDEA]) {
2150 if (async_jobs > 0) {
2151 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2152 names[D_CBC_IDEA]);
2153 doit[D_CBC_IDEA] = 0;
2154 }
2155 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2156 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum],
2157 lengths[testnum]);
2158 Time_F(START);
2159 for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2160 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2161 (size_t)lengths[testnum], &idea_ks,
2162 iv, IDEA_ENCRYPT);
2163 d = Time_F(STOP);
2164 print_result(D_CBC_IDEA, testnum, count, d);
2165 }
2166 }
2167 #endif
2168 #ifndef OPENSSL_NO_SEED
2169 if (doit[D_CBC_SEED]) {
2170 if (async_jobs > 0) {
2171 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2172 names[D_CBC_SEED]);
2173 doit[D_CBC_SEED] = 0;
2174 }
2175 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2176 print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum],
2177 lengths[testnum]);
2178 Time_F(START);
2179 for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2180 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2181 (size_t)lengths[testnum], &seed_ks, iv, 1);
2182 d = Time_F(STOP);
2183 print_result(D_CBC_SEED, testnum, count, d);
2184 }
2185 }
2186 #endif
2187 #ifndef OPENSSL_NO_RC2
2188 if (doit[D_CBC_RC2]) {
2189 if (async_jobs > 0) {
2190 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2191 names[D_CBC_RC2]);
2192 doit[D_CBC_RC2] = 0;
2193 }
2194 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2195 print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum],
2196 lengths[testnum]);
2197 if (async_jobs > 0) {
2198 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2199 exit(1);
2200 }
2201 Time_F(START);
2202 for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2203 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2204 (size_t)lengths[testnum], &rc2_ks,
2205 iv, RC2_ENCRYPT);
2206 d = Time_F(STOP);
2207 print_result(D_CBC_RC2, testnum, count, d);
2208 }
2209 }
2210 #endif
2211 #ifndef OPENSSL_NO_RC5
2212 if (doit[D_CBC_RC5]) {
2213 if (async_jobs > 0) {
2214 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2215 names[D_CBC_RC5]);
2216 doit[D_CBC_RC5] = 0;
2217 }
2218 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2219 print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum],
2220 lengths[testnum]);
2221 if (async_jobs > 0) {
2222 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2223 exit(1);
2224 }
2225 Time_F(START);
2226 for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2227 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2228 (size_t)lengths[testnum], &rc5_ks,
2229 iv, RC5_ENCRYPT);
2230 d = Time_F(STOP);
2231 print_result(D_CBC_RC5, testnum, count, d);
2232 }
2233 }
2234 #endif
2235 #ifndef OPENSSL_NO_BF
2236 if (doit[D_CBC_BF]) {
2237 if (async_jobs > 0) {
2238 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2239 names[D_CBC_BF]);
2240 doit[D_CBC_BF] = 0;
2241 }
2242 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2243 print_message(names[D_CBC_BF], c[D_CBC_BF][testnum],
2244 lengths[testnum]);
2245 Time_F(START);
2246 for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2247 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2248 (size_t)lengths[testnum], &bf_ks,
2249 iv, BF_ENCRYPT);
2250 d = Time_F(STOP);
2251 print_result(D_CBC_BF, testnum, count, d);
2252 }
2253 }
2254 #endif
2255 #ifndef OPENSSL_NO_CAST
2256 if (doit[D_CBC_CAST]) {
2257 if (async_jobs > 0) {
2258 BIO_printf(bio_err, "Async mode is not supported with %s\n",
2259 names[D_CBC_CAST]);
2260 doit[D_CBC_CAST] = 0;
2261 }
2262 for (testnum = 0; testnum < SIZE_NUM && async_init == 0; testnum++) {
2263 print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum],
2264 lengths[testnum]);
2265 Time_F(START);
2266 for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2267 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2268 (size_t)lengths[testnum], &cast_ks,
2269 iv, CAST_ENCRYPT);
2270 d = Time_F(STOP);
2271 print_result(D_CBC_CAST, testnum, count, d);
2272 }
2273 }
2274 #endif
2275
2276 if (doit[D_EVP]) {
2277 if (multiblock && evp_cipher) {
2278 if (!
2279 (EVP_CIPHER_flags(evp_cipher) &
2280 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2281 BIO_printf(bio_err, "%s is not multi-block capable\n",
2282 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2283 goto end;
2284 }
2285 if (async_jobs > 0) {
2286 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2287 exit(1);
2288 }
2289 multiblock_speed(evp_cipher);
2290 ret = 0;
2291 goto end;
2292 }
2293 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2294 if (evp_cipher) {
2295
2296 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2297 /*
2298 * -O3 -fschedule-insns messes up an optimization here!
2299 * names[D_EVP] somehow becomes NULL
2300 */
2301 print_message(names[D_EVP], save_count, lengths[testnum]);
2302
2303 for (k = 0; k < loopargs_len; k++) {
2304 loopargs[k].ctx = EVP_CIPHER_CTX_new();
2305 if (decrypt)
2306 EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL,
2307 key16, iv);
2308 else
2309 EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL,
2310 key16, iv);
2311 EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2312 }
2313
2314 Time_F(START);
2315 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2316 d = Time_F(STOP);
2317 for (k = 0; k < loopargs_len; k++) {
2318 EVP_CIPHER_CTX_free(loopargs[k].ctx);
2319 }
2320 }
2321 if (evp_md) {
2322 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2323 print_message(names[D_EVP], save_count, lengths[testnum]);
2324 Time_F(START);
2325 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2326 d = Time_F(STOP);
2327 }
2328 print_result(D_EVP, testnum, count, d);
2329 }
2330 }
2331
2332 for (i = 0; i < loopargs_len; i++)
2333 RAND_bytes(loopargs[i].buf, 36);
2334
2335 #ifndef OPENSSL_NO_RSA
2336 for (testnum = 0; testnum < RSA_NUM; testnum++) {
2337 int st = 0;
2338 if (!rsa_doit[testnum])
2339 continue;
2340 for (i = 0; i < loopargs_len; i++) {
2341 st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2342 &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2343 if (st == 0)
2344 break;
2345 }
2346 if (st == 0) {
2347 BIO_printf(bio_err,
2348 "RSA sign failure. No RSA sign will be done.\n");
2349 ERR_print_errors(bio_err);
2350 rsa_count = 1;
2351 } else {
2352 pkey_print_message("private", "rsa",
2353 rsa_c[testnum][0], rsa_bits[testnum],
2354 RSA_SECONDS);
2355 /* RSA_blinding_on(rsa_key[testnum],NULL); */
2356 Time_F(START);
2357 count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2358 d = Time_F(STOP);
2359 BIO_printf(bio_err,
2360 mr ? "+R1:%ld:%d:%.2f\n"
2361 : "%ld %d bit private RSA's in %.2fs\n",
2362 count, rsa_bits[testnum], d);
2363 rsa_results[testnum][0] = (double)count / d;
2364 rsa_count = count;
2365 }
2366
2367 for (i = 0; i < loopargs_len; i++) {
2368 st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2369 loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2370 if (st <= 0)
2371 break;
2372 }
2373 if (st <= 0) {
2374 BIO_printf(bio_err,
2375 "RSA verify failure. No RSA verify will be done.\n");
2376 ERR_print_errors(bio_err);
2377 rsa_doit[testnum] = 0;
2378 } else {
2379 pkey_print_message("public", "rsa",
2380 rsa_c[testnum][1], rsa_bits[testnum],
2381 RSA_SECONDS);
2382 Time_F(START);
2383 count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2384 d = Time_F(STOP);
2385 BIO_printf(bio_err,
2386 mr ? "+R2:%ld:%d:%.2f\n"
2387 : "%ld %d bit public RSA's in %.2fs\n",
2388 count, rsa_bits[testnum], d);
2389 rsa_results[testnum][1] = (double)count / d;
2390 }
2391
2392 if (rsa_count <= 1) {
2393 /* if longer than 10s, don't do any more */
2394 for (testnum++; testnum < RSA_NUM; testnum++)
2395 rsa_doit[testnum] = 0;
2396 }
2397 }
2398 #endif /* OPENSSL_NO_RSA */
2399
2400 for (i = 0; i < loopargs_len; i++)
2401 RAND_bytes(loopargs[i].buf, 36);
2402
2403 #ifndef OPENSSL_NO_DSA
2404 if (RAND_status() != 1) {
2405 RAND_seed(rnd_seed, sizeof rnd_seed);
2406 }
2407 for (testnum = 0; testnum < DSA_NUM; testnum++) {
2408 int st = 0;
2409 if (!dsa_doit[testnum])
2410 continue;
2411
2412 /* DSA_generate_key(dsa_key[testnum]); */
2413 /* DSA_sign_setup(dsa_key[testnum],NULL); */
2414 for (i = 0; i < loopargs_len; i++) {
2415 st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2416 &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2417 if (st == 0)
2418 break;
2419 }
2420 if (st == 0) {
2421 BIO_printf(bio_err,
2422 "DSA sign failure. No DSA sign will be done.\n");
2423 ERR_print_errors(bio_err);
2424 rsa_count = 1;
2425 } else {
2426 pkey_print_message("sign", "dsa",
2427 dsa_c[testnum][0], dsa_bits[testnum],
2428 DSA_SECONDS);
2429 Time_F(START);
2430 count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2431 d = Time_F(STOP);
2432 BIO_printf(bio_err,
2433 mr ? "+R3:%ld:%d:%.2f\n"
2434 : "%ld %d bit DSA signs in %.2fs\n",
2435 count, dsa_bits[testnum], d);
2436 dsa_results[testnum][0] = (double)count / d;
2437 rsa_count = count;
2438 }
2439
2440 for (i = 0; i < loopargs_len; i++) {
2441 st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2442 loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2443 if (st <= 0)
2444 break;
2445 }
2446 if (st <= 0) {
2447 BIO_printf(bio_err,
2448 "DSA verify failure. No DSA verify will be done.\n");
2449 ERR_print_errors(bio_err);
2450 dsa_doit[testnum] = 0;
2451 } else {
2452 pkey_print_message("verify", "dsa",
2453 dsa_c[testnum][1], dsa_bits[testnum],
2454 DSA_SECONDS);
2455 Time_F(START);
2456 count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2457 d = Time_F(STOP);
2458 BIO_printf(bio_err,
2459 mr ? "+R4:%ld:%d:%.2f\n"
2460 : "%ld %d bit DSA verify in %.2fs\n",
2461 count, dsa_bits[testnum], d);
2462 dsa_results[testnum][1] = (double)count / d;
2463 }
2464
2465 if (rsa_count <= 1) {
2466 /* if longer than 10s, don't do any more */
2467 for (testnum++; testnum < DSA_NUM; testnum++)
2468 dsa_doit[testnum] = 0;
2469 }
2470 }
2471 #endif /* OPENSSL_NO_DSA */
2472
2473 #ifndef OPENSSL_NO_EC
2474 if (RAND_status() != 1) {
2475 RAND_seed(rnd_seed, sizeof rnd_seed);
2476 }
2477 for (testnum = 0; testnum < EC_NUM; testnum++) {
2478 int st = 1;
2479
2480 if (!ecdsa_doit[testnum])
2481 continue; /* Ignore Curve */
2482 for (i = 0; i < loopargs_len; i++) {
2483 loopargs[i].ecdsa[testnum] =
2484 EC_KEY_new_by_curve_name(test_curves[testnum]);
2485 if (loopargs[i].ecdsa[testnum] == NULL) {
2486 st = 0;
2487 break;
2488 }
2489 }
2490 if (st == 0) {
2491 BIO_printf(bio_err, "ECDSA failure.\n");
2492 ERR_print_errors(bio_err);
2493 rsa_count = 1;
2494 } else {
2495 for (i = 0; i < loopargs_len; i++) {
2496 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2497 /* Perform ECDSA signature test */
2498 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2499 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2500 &loopargs[i].siglen,
2501 loopargs[i].ecdsa[testnum]);
2502 if (st == 0)
2503 break;
2504 }
2505 if (st == 0) {
2506 BIO_printf(bio_err,
2507 "ECDSA sign failure. No ECDSA sign will be done.\n");
2508 ERR_print_errors(bio_err);
2509 rsa_count = 1;
2510 } else {
2511 pkey_print_message("sign", "ecdsa",
2512 ecdsa_c[testnum][0],
2513 test_curves_bits[testnum], ECDSA_SECONDS);
2514 Time_F(START);
2515 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2516 d = Time_F(STOP);
2517
2518 BIO_printf(bio_err,
2519 mr ? "+R5:%ld:%d:%.2f\n" :
2520 "%ld %d bit ECDSA signs in %.2fs \n",
2521 count, test_curves_bits[testnum], d);
2522 ecdsa_results[testnum][0] = d / (double)count;
2523 rsa_count = count;
2524 }
2525
2526 /* Perform ECDSA verification test */
2527 for (i = 0; i < loopargs_len; i++) {
2528 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2529 loopargs[i].siglen,
2530 loopargs[i].ecdsa[testnum]);
2531 if (st != 1)
2532 break;
2533 }
2534 if (st != 1) {
2535 BIO_printf(bio_err,
2536 "ECDSA verify failure. No ECDSA verify will be done.\n");
2537 ERR_print_errors(bio_err);
2538 ecdsa_doit[testnum] = 0;
2539 } else {
2540 pkey_print_message("verify", "ecdsa",
2541 ecdsa_c[testnum][1],
2542 test_curves_bits[testnum], ECDSA_SECONDS);
2543 Time_F(START);
2544 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2545 d = Time_F(STOP);
2546 BIO_printf(bio_err,
2547 mr ? "+R6:%ld:%d:%.2f\n"
2548 : "%ld %d bit ECDSA verify in %.2fs\n",
2549 count, test_curves_bits[testnum], d);
2550 ecdsa_results[testnum][1] = d / (double)count;
2551 }
2552
2553 if (rsa_count <= 1) {
2554 /* if longer than 10s, don't do any more */
2555 for (testnum++; testnum < EC_NUM; testnum++)
2556 ecdsa_doit[testnum] = 0;
2557 }
2558 }
2559 }
2560
2561 if (RAND_status() != 1) {
2562 RAND_seed(rnd_seed, sizeof rnd_seed);
2563 }
2564 for (testnum = 0; testnum < EC_NUM; testnum++) {
2565 int ecdh_checks = 1;
2566
2567 if (!ecdh_doit[testnum])
2568 continue;
2569
2570 for (i = 0; i < loopargs_len; i++) {
2571 EVP_PKEY_CTX *kctx = NULL;
2572 EVP_PKEY_CTX *test_ctx = NULL;
2573 EVP_PKEY_CTX *ctx = NULL;
2574 EVP_PKEY *key_A = NULL;
2575 EVP_PKEY *key_B = NULL;
2576 size_t outlen;
2577 size_t test_outlen;
2578
2579 /* Ensure that the error queue is empty */
2580 if (ERR_peek_error()) {
2581 BIO_printf(bio_err,
2582 "WARNING: the error queue contains previous unhandled errors.\n");
2583 ERR_print_errors(bio_err);
2584 }
2585
2586 /* Let's try to create a ctx directly from the NID: this works for
2587 * curves like Curve25519 that are not implemented through the low
2588 * level EC interface.
2589 * If this fails we try creating a EVP_PKEY_EC generic param ctx,
2590 * then we set the curve by NID before deriving the actual keygen
2591 * ctx for that specific curve. */
2592 kctx = EVP_PKEY_CTX_new_id(test_curves[testnum], NULL); /* keygen ctx from NID */
2593 if (!kctx) {
2594 EVP_PKEY_CTX *pctx = NULL;
2595 EVP_PKEY *params = NULL;
2596
2597 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
2598 * "int_ctx_new:unsupported algorithm" error was added to the
2599 * error queue.
2600 * We remove it from the error queue as we are handling it. */
2601 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
2602 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
2603 /* check that the error origin matches */
2604 ERR_GET_LIB(error) == ERR_LIB_EVP &&
2605 ERR_GET_FUNC(error) == EVP_F_INT_CTX_NEW &&
2606 ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
2607 ERR_get_error(); /* pop error from queue */
2608 if (ERR_peek_error()) {
2609 BIO_printf(bio_err,
2610 "Unhandled error in the error queue during ECDH init.\n");
2611 ERR_print_errors(bio_err);
2612 rsa_count = 1;
2613 break;
2614 }
2615
2616 if ( /* Create the context for parameter generation */
2617 !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2618 /* Initialise the parameter generation */
2619 !EVP_PKEY_paramgen_init(pctx) ||
2620 /* Set the curve by NID */
2621 !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2622 test_curves
2623 [testnum]) ||
2624 /* Create the parameter object params */
2625 !EVP_PKEY_paramgen(pctx, &params)) {
2626 ecdh_checks = 0;
2627 BIO_printf(bio_err, "ECDH EC params init failure.\n");
2628 ERR_print_errors(bio_err);
2629 rsa_count = 1;
2630 break;
2631 }
2632 /* Create the context for the key generation */
2633 kctx = EVP_PKEY_CTX_new(params, NULL);
2634
2635 EVP_PKEY_free(params);
2636 params = NULL;
2637 EVP_PKEY_CTX_free(pctx);
2638 pctx = NULL;
2639 }
2640 if (!kctx || /* keygen ctx is not null */
2641 !EVP_PKEY_keygen_init(kctx) /* init keygen ctx */ ) {
2642 ecdh_checks = 0;
2643 BIO_printf(bio_err, "ECDH keygen failure.\n");
2644 ERR_print_errors(bio_err);
2645 rsa_count = 1;
2646 break;
2647 }
2648
2649 if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2650 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2651 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2652 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2653 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2654 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2655 outlen == 0 || /* ensure outlen is a valid size */
2656 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
2657 ecdh_checks = 0;
2658 BIO_printf(bio_err, "ECDH key generation failure.\n");
2659 ERR_print_errors(bio_err);
2660 rsa_count = 1;
2661 break;
2662 }
2663
2664 /* Here we perform a test run, comparing the output of a*B and b*A;
2665 * we try this here and assume that further EVP_PKEY_derive calls
2666 * never fail, so we can skip checks in the actually benchmarked
2667 * code, for maximum performance. */
2668 if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
2669 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
2670 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
2671 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
2672 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
2673 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
2674 test_outlen != outlen /* compare output length */ ) {
2675 ecdh_checks = 0;
2676 BIO_printf(bio_err, "ECDH computation failure.\n");
2677 ERR_print_errors(bio_err);
2678 rsa_count = 1;
2679 break;
2680 }
2681
2682 /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
2683 if (CRYPTO_memcmp(loopargs[i].secret_a,
2684 loopargs[i].secret_b, outlen)) {
2685 ecdh_checks = 0;
2686 BIO_printf(bio_err, "ECDH computations don't match.\n");
2687 ERR_print_errors(bio_err);
2688 rsa_count = 1;
2689 break;
2690 }
2691
2692 loopargs[i].ecdh_ctx[testnum] = ctx;
2693 loopargs[i].outlen[testnum] = outlen;
2694
2695 EVP_PKEY_CTX_free(kctx);
2696 kctx = NULL;
2697 EVP_PKEY_CTX_free(test_ctx);
2698 test_ctx = NULL;
2699 }
2700 if (ecdh_checks != 0) {
2701 pkey_print_message("", "ecdh",
2702 ecdh_c[testnum][0],
2703 test_curves_bits[testnum], ECDH_SECONDS);
2704 Time_F(START);
2705 count =
2706 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2707 d = Time_F(STOP);
2708 BIO_printf(bio_err,
2709 mr ? "+R7:%ld:%d:%.2f\n" :
2710 "%ld %d-bit ECDH ops in %.2fs\n", count,
2711 test_curves_bits[testnum], d);
2712 ecdh_results[testnum][0] = d / (double)count;
2713 rsa_count = count;
2714 }
2715
2716 if (rsa_count <= 1) {
2717 /* if longer than 10s, don't do any more */
2718 for (testnum++; testnum < EC_NUM; testnum++)
2719 ecdh_doit[testnum] = 0;
2720 }
2721 }
2722 #endif /* OPENSSL_NO_EC */
2723 #ifndef NO_FORK
2724 show_res:
2725 #endif
2726 if (!mr) {
2727 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2728 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2729 printf("options:");
2730 printf("%s ", BN_options());
2731 #ifndef OPENSSL_NO_MD2
2732 printf("%s ", MD2_options());
2733 #endif
2734 #ifndef OPENSSL_NO_RC4
2735 printf("%s ", RC4_options());
2736 #endif
2737 #ifndef OPENSSL_NO_DES
2738 printf("%s ", DES_options());
2739 #endif
2740 printf("%s ", AES_options());
2741 #ifndef OPENSSL_NO_IDEA
2742 printf("%s ", IDEA_options());
2743 #endif
2744 #ifndef OPENSSL_NO_BF
2745 printf("%s ", BF_options());
2746 #endif
2747 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2748 }
2749
2750 if (pr_header) {
2751 if (mr)
2752 printf("+H");
2753 else {
2754 printf
2755 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2756 printf("type ");
2757 }
2758 for (testnum = 0; testnum < SIZE_NUM; testnum++)
2759 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2760 printf("\n");
2761 }
2762
2763 for (k = 0; k < ALGOR_NUM; k++) {
2764 if (!doit[k])
2765 continue;
2766 if (mr)
2767 printf("+F:%d:%s", k, names[k]);
2768 else
2769 printf("%-13s", names[k]);
2770 for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2771 if (results[k][testnum] > 10000 && !mr)
2772 printf(" %11.2fk", results[k][testnum] / 1e3);
2773 else
2774 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2775 }
2776 printf("\n");
2777 }
2778 #ifndef OPENSSL_NO_RSA
2779 testnum = 1;
2780 for (k = 0; k < RSA_NUM; k++) {
2781 if (!rsa_doit[k])
2782 continue;
2783 if (testnum && !mr) {
2784 printf("%18ssign verify sign/s verify/s\n", " ");
2785 testnum = 0;
2786 }
2787 if (mr)
2788 printf("+F2:%u:%u:%f:%f\n",
2789 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2790 else
2791 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2792 rsa_bits[k], 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
2793 rsa_results[k][0], rsa_results[k][1]);
2794 }
2795 #endif
2796 #ifndef OPENSSL_NO_DSA
2797 testnum = 1;
2798 for (k = 0; k < DSA_NUM; k++) {
2799 if (!dsa_doit[k])
2800 continue;
2801 if (testnum && !mr) {
2802 printf("%18ssign verify sign/s verify/s\n", " ");
2803 testnum = 0;
2804 }
2805 if (mr)
2806 printf("+F3:%u:%u:%f:%f\n",
2807 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2808 else
2809 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2810 dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
2811 dsa_results[k][0], dsa_results[k][1]);
2812 }
2813 #endif
2814 #ifndef OPENSSL_NO_EC
2815 testnum = 1;
2816 for (k = 0; k < EC_NUM; k++) {
2817 if (!ecdsa_doit[k])
2818 continue;
2819 if (testnum && !mr) {
2820 printf("%30ssign verify sign/s verify/s\n", " ");
2821 testnum = 0;
2822 }
2823
2824 if (mr)
2825 printf("+F4:%u:%u:%f:%f\n",
2826 k, test_curves_bits[k],
2827 ecdsa_results[k][0], ecdsa_results[k][1]);
2828 else
2829 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2830 test_curves_bits[k],
2831 test_curves_names[k],
2832 ecdsa_results[k][0], ecdsa_results[k][1],
2833 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2834 }
2835
2836 testnum = 1;
2837 for (k = 0; k < EC_NUM; k++) {
2838 if (!ecdh_doit[k])
2839 continue;
2840 if (testnum && !mr) {
2841 printf("%30sop op/s\n", " ");
2842 testnum = 0;
2843 }
2844 if (mr)
2845 printf("+F5:%u:%u:%f:%f\n",
2846 k, test_curves_bits[k],
2847 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2848
2849 else
2850 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2851 test_curves_bits[k],
2852 test_curves_names[k],
2853 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2854 }
2855 #endif
2856
2857 ret = 0;
2858
2859 end:
2860 ERR_print_errors(bio_err);
2861 for (i = 0; i < loopargs_len; i++) {
2862 OPENSSL_free(loopargs[i].buf_malloc);
2863 OPENSSL_free(loopargs[i].buf2_malloc);
2864
2865 #ifndef OPENSSL_NO_RSA
2866 for (k = 0; k < RSA_NUM; k++)
2867 RSA_free(loopargs[i].rsa_key[k]);
2868 #endif
2869 #ifndef OPENSSL_NO_DSA
2870 for (k = 0; k < DSA_NUM; k++)
2871 DSA_free(loopargs[i].dsa_key[k]);
2872 #endif
2873 #ifndef OPENSSL_NO_EC
2874 for (k = 0; k < EC_NUM; k++) {
2875 EC_KEY_free(loopargs[i].ecdsa[k]);
2876 EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
2877 }
2878 OPENSSL_free(loopargs[i].secret_a);
2879 OPENSSL_free(loopargs[i].secret_b);
2880 #endif
2881 }
2882
2883 if (async_jobs > 0) {
2884 for (i = 0; i < loopargs_len; i++)
2885 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2886 }
2887
2888 if (async_init) {
2889 ASYNC_cleanup_thread();
2890 }
2891 OPENSSL_free(loopargs);
2892 release_engine(e);
2893 return (ret);
2894 }
2895
2896 static void print_message(const char *s, long num, int length)
2897 {
2898 #ifdef SIGALRM
2899 BIO_printf(bio_err,
2900 mr ? "+DT:%s:%d:%d\n"
2901 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2902 (void)BIO_flush(bio_err);
2903 alarm(SECONDS);
2904 #else
2905 BIO_printf(bio_err,
2906 mr ? "+DN:%s:%ld:%d\n"
2907 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2908 (void)BIO_flush(bio_err);
2909 #endif
2910 }
2911
2912 static void pkey_print_message(const char *str, const char *str2, long num,
2913 int bits, int tm)
2914 {
2915 #ifdef SIGALRM
2916 BIO_printf(bio_err,
2917 mr ? "+DTP:%d:%s:%s:%d\n"
2918 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2919 (void)BIO_flush(bio_err);
2920 alarm(tm);
2921 #else
2922 BIO_printf(bio_err,
2923 mr ? "+DNP:%ld:%d:%s:%s\n"
2924 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2925 (void)BIO_flush(bio_err);
2926 #endif
2927 }
2928
2929 static void print_result(int alg, int run_no, int count, double time_used)
2930 {
2931 if (count == -1) {
2932 BIO_puts(bio_err, "EVP error!\n");
2933 exit(1);
2934 }
2935 BIO_printf(bio_err,
2936 mr ? "+R:%d:%s:%f\n"
2937 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2938 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2939 }
2940
2941 #ifndef NO_FORK
2942 static char *sstrsep(char **string, const char *delim)
2943 {
2944 char isdelim[256];
2945 char *token = *string;
2946
2947 if (**string == 0)
2948 return NULL;
2949
2950 memset(isdelim, 0, sizeof isdelim);
2951 isdelim[0] = 1;
2952
2953 while (*delim) {
2954 isdelim[(unsigned char)(*delim)] = 1;
2955 delim++;
2956 }
2957
2958 while (!isdelim[(unsigned char)(**string)]) {
2959 (*string)++;
2960 }
2961
2962 if (**string) {
2963 **string = 0;
2964 (*string)++;
2965 }
2966
2967 return token;
2968 }
2969
2970 static int do_multi(int multi)
2971 {
2972 int n;
2973 int fd[2];
2974 int *fds;
2975 static char sep[] = ":";
2976
2977 fds = malloc(sizeof(*fds) * multi);
2978 for (n = 0; n < multi; ++n) {
2979 if (pipe(fd) == -1) {
2980 BIO_printf(bio_err, "pipe failure\n");
2981 exit(1);
2982 }
2983 fflush(stdout);
2984 (void)BIO_flush(bio_err);
2985 if (fork()) {
2986 close(fd[1]);
2987 fds[n] = fd[0];
2988 } else {
2989 close(fd[0]);
2990 close(1);
2991 if (dup(fd[1]) == -1) {
2992 BIO_printf(bio_err, "dup failed\n");
2993 exit(1);
2994 }
2995 close(fd[1]);
2996 mr = 1;
2997 usertime = 0;
2998 free(fds);
2999 return 0;
3000 }
3001 printf("Forked child %d\n", n);
3002 }
3003
3004 /* for now, assume the pipe is long enough to take all the output */
3005 for (n = 0; n < multi; ++n) {
3006 FILE *f;
3007 char buf[1024];
3008 char *p;
3009
3010 f = fdopen(fds[n], "r");
3011 while (fgets(buf, sizeof buf, f)) {
3012 p = strchr(buf, '\n');
3013 if (p)
3014 *p = '\0';
3015 if (buf[0] != '+') {
3016 BIO_printf(bio_err,
3017 "Don't understand line '%s' from child %d\n", buf,
3018 n);
3019 continue;
3020 }
3021 printf("Got: %s from %d\n", buf, n);
3022 if (strncmp(buf, "+F:", 3) == 0) {
3023 int alg;
3024 int j;
3025
3026 p = buf + 3;
3027 alg = atoi(sstrsep(&p, sep));
3028 sstrsep(&p, sep);
3029 for (j = 0; j < SIZE_NUM; ++j)
3030 results[alg][j] += atof(sstrsep(&p, sep));
3031 } else if (strncmp(buf, "+F2:", 4) == 0) {
3032 int k;
3033 double d;
3034
3035 p = buf + 4;
3036 k = atoi(sstrsep(&p, sep));
3037 sstrsep(&p, sep);
3038
3039 d = atof(sstrsep(&p, sep));
3040 rsa_results[k][0] += d;
3041
3042 d = atof(sstrsep(&p, sep));
3043 rsa_results[k][1] += d;
3044 }
3045 # ifndef OPENSSL_NO_DSA
3046 else if (strncmp(buf, "+F3:", 4) == 0) {
3047 int k;
3048 double d;
3049
3050 p = buf + 4;
3051 k = atoi(sstrsep(&p, sep));
3052 sstrsep(&p, sep);
3053
3054 d = atof(sstrsep(&p, sep));
3055 dsa_results[k][0] += d;
3056
3057 d = atof(sstrsep(&p, sep));
3058 dsa_results[k][1] += d;
3059 }
3060 # endif
3061 # ifndef OPENSSL_NO_EC
3062 else if (strncmp(buf, "+F4:", 4) == 0) {
3063 int k;
3064 double d;
3065
3066 p = buf + 4;
3067 k = atoi(sstrsep(&p, sep));
3068 sstrsep(&p, sep);
3069
3070 d = atof(sstrsep(&p, sep));
3071 if (n)
3072 ecdsa_results[k][0] = 1 / (1 / ecdsa_results[k][0] + 1 / d);
3073 else
3074 ecdsa_results[k][0] = d;
3075
3076 d = atof(sstrsep(&p, sep));
3077 if (n)
3078 ecdsa_results[k][1] = 1 / (1 / ecdsa_results[k][1] + 1 / d);
3079 else
3080 ecdsa_results[k][1] = d;
3081 } else if (strncmp(buf, "+F5:", 4) == 0) {
3082 int k;
3083 double d;
3084
3085 p = buf + 4;
3086 k = atoi(sstrsep(&p, sep));
3087 sstrsep(&p, sep);
3088
3089 d = atof(sstrsep(&p, sep));
3090 if (n)
3091 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3092 else
3093 ecdh_results[k][0] = d;
3094
3095 }
3096 # endif
3097
3098 else if (strncmp(buf, "+H:", 3) == 0) {
3099 ;
3100 } else
3101 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3102 n);
3103 }
3104
3105 fclose(f);
3106 }
3107 free(fds);
3108 return 1;
3109 }
3110 #endif
3111
3112 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3113 {
3114 static int mblengths[] =
3115 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3116 int j, count, num = OSSL_NELEM(mblengths);
3117 const char *alg_name;
3118 unsigned char *inp, *out, no_key[32], no_iv[16];
3119 EVP_CIPHER_CTX *ctx;
3120 double d = 0.0;
3121
3122 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3123 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3124 ctx = EVP_CIPHER_CTX_new();
3125 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3126 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3127 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3128
3129 for (j = 0; j < num; j++) {
3130 print_message(alg_name, 0, mblengths[j]);
3131 Time_F(START);
3132 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3133 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3134 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3135 size_t len = mblengths[j];
3136 int packlen;
3137
3138 memset(aad, 0, 8); /* avoid uninitialized values */
3139 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3140 aad[9] = 3; /* version */
3141 aad[10] = 2;
3142 aad[11] = 0; /* length */
3143 aad[12] = 0;
3144 mb_param.out = NULL;
3145 mb_param.inp = aad;
3146 mb_param.len = len;
3147 mb_param.interleave = 8;
3148
3149 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3150 sizeof(mb_param), &mb_param);
3151
3152 if (packlen > 0) {
3153 mb_param.out = out;
3154 mb_param.inp = inp;
3155 mb_param.len = len;
3156 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3157 sizeof(mb_param), &mb_param);
3158 } else {
3159 int pad;
3160
3161 RAND_bytes(out, 16);
3162 len += 16;
3163 aad[11] = len >> 8;
3164 aad[12] = len;
3165 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3166 EVP_AEAD_TLS1_AAD_LEN, aad);
3167 EVP_Cipher(ctx, out, inp, len + pad);
3168 }
3169 }
3170 d = Time_F(STOP);
3171 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3172 : "%d %s's in %.2fs\n", count, "evp", d);
3173 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3174 }
3175
3176 if (mr) {
3177 fprintf(stdout, "+H");
3178 for (j = 0; j < num; j++)
3179 fprintf(stdout, ":%d", mblengths[j]);
3180 fprintf(stdout, "\n");
3181 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3182 for (j = 0; j < num; j++)
3183 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3184 fprintf(stdout, "\n");
3185 } else {
3186 fprintf(stdout,
3187 "The 'numbers' are in 1000s of bytes per second processed.\n");
3188 fprintf(stdout, "type ");
3189 for (j = 0; j < num; j++)
3190 fprintf(stdout, "%7d bytes", mblengths[j]);
3191 fprintf(stdout, "\n");
3192 fprintf(stdout, "%-24s", alg_name);
3193
3194 for (j = 0; j < num; j++) {
3195 if (results[D_EVP][j] > 10000)
3196 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3197 else
3198 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3199 }
3200 fprintf(stdout, "\n");
3201 }
3202
3203 OPENSSL_free(inp);
3204 OPENSSL_free(out);
3205 EVP_CIPHER_CTX_free(ctx);
3206 }
A mirror of the official openssl repository