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