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