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