speed.c@ 96441

Last change on this file since 96441 was 94404, checked in by vboxsync, 3 years ago
libs/openssl: Update to 3.0.2 and switch to it, bugref:10128
File size: 123.2 KB

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

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/libs/openssl-3.0.3/apps/speed.c@ 96441

Download in other formats: