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