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