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