Process incoming NewSessionTicket messages on the client side
[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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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] = d / (double)count;
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], rsa_results[k][0], rsa_results[k][1],
2793                    1.0 / rsa_results[k][0], 1.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], dsa_results[k][0], dsa_results[k][1],
2811                    1.0 / dsa_results[k][0], 1.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                 if (n)
3041                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
3042                 else
3043                     rsa_results[k][0] = d;
3044
3045                 d = atof(sstrsep(&p, sep));
3046                 if (n)
3047                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
3048                 else
3049                     rsa_results[k][1] = d;
3050             }
3051 # ifndef OPENSSL_NO_DSA
3052             else if (strncmp(buf, "+F3:", 4) == 0) {
3053                 int k;
3054                 double d;
3055
3056                 p = buf + 4;
3057                 k = atoi(sstrsep(&p, sep));
3058                 sstrsep(&p, sep);
3059
3060                 d = atof(sstrsep(&p, sep));
3061                 if (n)
3062                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
3063                 else
3064                     dsa_results[k][0] = d;
3065
3066                 d = atof(sstrsep(&p, sep));
3067                 if (n)
3068                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
3069                 else
3070                     dsa_results[k][1] = d;
3071             }
3072 # endif
3073 # ifndef OPENSSL_NO_EC
3074             else if (strncmp(buf, "+F4:", 4) == 0) {
3075                 int k;
3076                 double d;
3077
3078                 p = buf + 4;
3079                 k = atoi(sstrsep(&p, sep));
3080                 sstrsep(&p, sep);
3081
3082                 d = atof(sstrsep(&p, sep));
3083                 if (n)
3084                     ecdsa_results[k][0] = 1 / (1 / ecdsa_results[k][0] + 1 / d);
3085                 else
3086                     ecdsa_results[k][0] = d;
3087
3088                 d = atof(sstrsep(&p, sep));
3089                 if (n)
3090                     ecdsa_results[k][1] = 1 / (1 / ecdsa_results[k][1] + 1 / d);
3091                 else
3092                     ecdsa_results[k][1] = d;
3093             } else if (strncmp(buf, "+F5:", 4) == 0) {
3094                 int k;
3095                 double d;
3096
3097                 p = buf + 4;
3098                 k = atoi(sstrsep(&p, sep));
3099                 sstrsep(&p, sep);
3100
3101                 d = atof(sstrsep(&p, sep));
3102                 if (n)
3103                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3104                 else
3105                     ecdh_results[k][0] = d;
3106
3107             }
3108 # endif
3109
3110             else if (strncmp(buf, "+H:", 3) == 0) {
3111                 ;
3112             } else
3113                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3114                            n);
3115         }
3116
3117         fclose(f);
3118     }
3119     free(fds);
3120     return 1;
3121 }
3122 #endif
3123
3124 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3125 {
3126     static int mblengths[] =
3127         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3128     int j, count, num = OSSL_NELEM(mblengths);
3129     const char *alg_name;
3130     unsigned char *inp, *out, no_key[32], no_iv[16];
3131     EVP_CIPHER_CTX *ctx;
3132     double d = 0.0;
3133
3134     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3135     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3136     ctx = EVP_CIPHER_CTX_new();
3137     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3138     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3139     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3140
3141     for (j = 0; j < num; j++) {
3142         print_message(alg_name, 0, mblengths[j]);
3143         Time_F(START);
3144         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3145             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3146             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3147             size_t len = mblengths[j];
3148             int packlen;
3149
3150             memset(aad, 0, 8);  /* avoid uninitialized values */
3151             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3152             aad[9] = 3;         /* version */
3153             aad[10] = 2;
3154             aad[11] = 0;        /* length */
3155             aad[12] = 0;
3156             mb_param.out = NULL;
3157             mb_param.inp = aad;
3158             mb_param.len = len;
3159             mb_param.interleave = 8;
3160
3161             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3162                                           sizeof(mb_param), &mb_param);
3163
3164             if (packlen > 0) {
3165                 mb_param.out = out;
3166                 mb_param.inp = inp;
3167                 mb_param.len = len;
3168                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3169                                     sizeof(mb_param), &mb_param);
3170             } else {
3171                 int pad;
3172
3173                 RAND_bytes(out, 16);
3174                 len += 16;
3175                 aad[11] = len >> 8;
3176                 aad[12] = len;
3177                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3178                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3179                 EVP_Cipher(ctx, out, inp, len + pad);
3180             }
3181         }
3182         d = Time_F(STOP);
3183         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3184                    : "%d %s's in %.2fs\n", count, "evp", d);
3185         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3186     }
3187
3188     if (mr) {
3189         fprintf(stdout, "+H");
3190         for (j = 0; j < num; j++)
3191             fprintf(stdout, ":%d", mblengths[j]);
3192         fprintf(stdout, "\n");
3193         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3194         for (j = 0; j < num; j++)
3195             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3196         fprintf(stdout, "\n");
3197     } else {
3198         fprintf(stdout,
3199                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3200         fprintf(stdout, "type                    ");
3201         for (j = 0; j < num; j++)
3202             fprintf(stdout, "%7d bytes", mblengths[j]);
3203         fprintf(stdout, "\n");
3204         fprintf(stdout, "%-24s", alg_name);
3205
3206         for (j = 0; j < num; j++) {
3207             if (results[D_EVP][j] > 10000)
3208                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3209             else
3210                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3211         }
3212         fprintf(stdout, "\n");
3213     }
3214
3215     OPENSSL_free(inp);
3216     OPENSSL_free(out);
3217     EVP_CIPHER_CTX_free(ctx);
3218 }