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