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


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