]> git.ipfire.org Git - thirdparty/openssl.git/blob - apps/speed.c
projects / thirdparty / openssl.git / blob
? search:


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