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