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