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


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