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