]> 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
Copyright update of more files that have changed this year
[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 <openssl/crypto.h>
24 #include <openssl/rand.h>
25 #include <openssl/err.h>
26 #include <openssl/evp.h>
27 #include <openssl/objects.h>
28 #include <openssl/async.h>
29 #if !defined(OPENSSL_SYS_MSDOS)
30 # include OPENSSL_UNISTD
31 #endif
32
33 #if defined(_WIN32)
34 # include <windows.h>
35 #endif
36
37 #include <openssl/bn.h>
38 #ifndef OPENSSL_NO_DES
39 # include <openssl/des.h>
40 #endif
41 #include <openssl/aes.h>
42 #ifndef OPENSSL_NO_CAMELLIA
43 # include <openssl/camellia.h>
44 #endif
45 #ifndef OPENSSL_NO_MD2
46 # include <openssl/md2.h>
47 #endif
48 #ifndef OPENSSL_NO_MDC2
49 # include <openssl/mdc2.h>
50 #endif
51 #ifndef OPENSSL_NO_MD4
52 # include <openssl/md4.h>
53 #endif
54 #ifndef OPENSSL_NO_MD5
55 # include <openssl/md5.h>
56 #endif
57 #include <openssl/hmac.h>
58 #include <openssl/sha.h>
59 #ifndef OPENSSL_NO_RMD160
60 # include <openssl/ripemd.h>
61 #endif
62 #ifndef OPENSSL_NO_WHIRLPOOL
63 # include <openssl/whrlpool.h>
64 #endif
65 #ifndef OPENSSL_NO_RC4
66 # include <openssl/rc4.h>
67 #endif
68 #ifndef OPENSSL_NO_RC5
69 # include <openssl/rc5.h>
70 #endif
71 #ifndef OPENSSL_NO_RC2
72 # include <openssl/rc2.h>
73 #endif
74 #ifndef OPENSSL_NO_IDEA
75 # include <openssl/idea.h>
76 #endif
77 #ifndef OPENSSL_NO_SEED
78 # include <openssl/seed.h>
79 #endif
80 #ifndef OPENSSL_NO_BF
81 # include <openssl/blowfish.h>
82 #endif
83 #ifndef OPENSSL_NO_CAST
84 # include <openssl/cast.h>
85 #endif
86 #ifndef OPENSSL_NO_RSA
87 # include <openssl/rsa.h>
88 # include "./testrsa.h"
89 #endif
90 #include <openssl/x509.h>
91 #ifndef OPENSSL_NO_DSA
92 # include <openssl/dsa.h>
93 # include "./testdsa.h"
94 #endif
95 #ifndef OPENSSL_NO_EC
96 # include <openssl/ec.h>
97 #endif
98 #include <openssl/modes.h>
99
100 #ifndef HAVE_FORK
101 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS)
102 # define HAVE_FORK 0
103 # else
104 # define HAVE_FORK 1
105 # endif
106 #endif
107
108 #if HAVE_FORK
109 # undef NO_FORK
110 #else
111 # define NO_FORK
112 #endif
113
114 #define MAX_MISALIGNMENT 63
115
116 #define ALGOR_NUM 31
117 #define RSA_NUM 7
118 #define DSA_NUM 3
119
120 #define EC_NUM 17
121 #define MAX_ECDH_SIZE 256
122 #define MISALIGN 64
123
124 typedef struct openssl_speed_sec_st {
125 int sym;
126 int rsa;
127 int dsa;
128 int ecdsa;
129 int ecdh;
130 } openssl_speed_sec_t;
131
132 static volatile int run = 0;
133
134 static int mr = 0;
135 static int usertime = 1;
136
137 typedef struct loopargs_st {
138 ASYNC_JOB *inprogress_job;
139 ASYNC_WAIT_CTX *wait_ctx;
140 unsigned char *buf;
141 unsigned char *buf2;
142 unsigned char *buf_malloc;
143 unsigned char *buf2_malloc;
144 unsigned char *key;
145 unsigned int siglen;
146 #ifndef OPENSSL_NO_RSA
147 RSA *rsa_key[RSA_NUM];
148 #endif
149 #ifndef OPENSSL_NO_DSA
150 DSA *dsa_key[DSA_NUM];
151 #endif
152 #ifndef OPENSSL_NO_EC
153 EC_KEY *ecdsa[EC_NUM];
154 EVP_PKEY_CTX *ecdh_ctx[EC_NUM];
155 unsigned char *secret_a;
156 unsigned char *secret_b;
157 size_t outlen[EC_NUM];
158 #endif
159 EVP_CIPHER_CTX *ctx;
160 HMAC_CTX *hctx;
161 GCM128_CONTEXT *gcm_ctx;
162 } loopargs_t;
163
164 #ifndef OPENSSL_NO_MD2
165 static int EVP_Digest_MD2_loop(void *args);
166 #endif
167
168 #ifndef OPENSSL_NO_MDC2
169 static int EVP_Digest_MDC2_loop(void *args);
170 #endif
171 #ifndef OPENSSL_NO_MD4
172 static int EVP_Digest_MD4_loop(void *args);
173 #endif
174 #ifndef OPENSSL_NO_MD5
175 static int MD5_loop(void *args);
176 static int HMAC_loop(void *args);
177 #endif
178 static int SHA1_loop(void *args);
179 static int SHA256_loop(void *args);
180 static int SHA512_loop(void *args);
181 #ifndef OPENSSL_NO_WHIRLPOOL
182 static int WHIRLPOOL_loop(void *args);
183 #endif
184 #ifndef OPENSSL_NO_RMD160
185 static int EVP_Digest_RMD160_loop(void *args);
186 #endif
187 #ifndef OPENSSL_NO_RC4
188 static int RC4_loop(void *args);
189 #endif
190 #ifndef OPENSSL_NO_DES
191 static int DES_ncbc_encrypt_loop(void *args);
192 static int DES_ede3_cbc_encrypt_loop(void *args);
193 #endif
194 static int AES_cbc_128_encrypt_loop(void *args);
195 static int AES_cbc_192_encrypt_loop(void *args);
196 static int AES_ige_128_encrypt_loop(void *args);
197 static int AES_cbc_256_encrypt_loop(void *args);
198 static int AES_ige_192_encrypt_loop(void *args);
199 static int AES_ige_256_encrypt_loop(void *args);
200 static int CRYPTO_gcm128_aad_loop(void *args);
201 static int RAND_bytes_loop(void *args);
202 static int EVP_Update_loop(void *args);
203 static int EVP_Update_loop_ccm(void *args);
204 static int EVP_Digest_loop(void *args);
205 #ifndef OPENSSL_NO_RSA
206 static int RSA_sign_loop(void *args);
207 static int RSA_verify_loop(void *args);
208 #endif
209 #ifndef OPENSSL_NO_DSA
210 static int DSA_sign_loop(void *args);
211 static int DSA_verify_loop(void *args);
212 #endif
213 #ifndef OPENSSL_NO_EC
214 static int ECDSA_sign_loop(void *args);
215 static int ECDSA_verify_loop(void *args);
216 #endif
217 static int run_benchmark(int async_jobs, int (*loop_function) (void *),
218 loopargs_t * loopargs);
219
220 static double Time_F(int s);
221 static void print_message(const char *s, long num, int length, int tm);
222 static void pkey_print_message(const char *str, const char *str2,
223 long num, int bits, int sec);
224 static void print_result(int alg, int run_no, int count, double time_used);
225 #ifndef NO_FORK
226 static int do_multi(int multi, int size_num);
227 #endif
228
229 static const int lengths_list[] = {
230 16, 64, 256, 1024, 8 * 1024, 16 * 1024
231 };
232 static int lengths_single = 0;
233
234 static const int *lengths = lengths_list;
235
236 static const char *names[ALGOR_NUM] = {
237 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
238 "des cbc", "des ede3", "idea cbc", "seed cbc",
239 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
240 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
241 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
242 "evp", "sha256", "sha512", "whirlpool",
243 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",
244 "rand"
245 };
246
247 static double results[ALGOR_NUM][OSSL_NELEM(lengths_list)];
248
249 #ifndef OPENSSL_NO_RSA
250 static double rsa_results[RSA_NUM][2];
251 #endif
252 #ifndef OPENSSL_NO_DSA
253 static double dsa_results[DSA_NUM][2];
254 #endif
255 #ifndef OPENSSL_NO_EC
256 static double ecdsa_results[EC_NUM][2];
257 static double ecdh_results[EC_NUM][1];
258 #endif
259
260 #ifdef SIGALRM
261 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
262 # define SIGRETTYPE void
263 # else
264 # define SIGRETTYPE int
265 # endif
266
267 static SIGRETTYPE sig_done(int sig);
268 static SIGRETTYPE sig_done(int sig)
269 {
270 signal(SIGALRM, sig_done);
271 run = 0;
272 }
273 #endif
274
275 #define START 0
276 #define STOP 1
277
278 #if defined(_WIN32)
279
280 # if !defined(SIGALRM)
281 # define SIGALRM
282 # endif
283 static unsigned int lapse;
284 static volatile unsigned int schlock;
285 static void alarm_win32(unsigned int secs)
286 {
287 lapse = secs * 1000;
288 }
289
290 # define alarm alarm_win32
291
292 static DWORD WINAPI sleepy(VOID * arg)
293 {
294 schlock = 1;
295 Sleep(lapse);
296 run = 0;
297 return 0;
298 }
299
300 static double Time_F(int s)
301 {
302 double ret;
303 static HANDLE thr;
304
305 if (s == START) {
306 schlock = 0;
307 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
308 if (thr == NULL) {
309 DWORD err = GetLastError();
310 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
311 ExitProcess(err);
312 }
313 while (!schlock)
314 Sleep(0); /* scheduler spinlock */
315 ret = app_tminterval(s, usertime);
316 } else {
317 ret = app_tminterval(s, usertime);
318 if (run)
319 TerminateThread(thr, 0);
320 CloseHandle(thr);
321 }
322
323 return ret;
324 }
325 #else
326
327 static double Time_F(int s)
328 {
329 double ret = app_tminterval(s, usertime);
330 if (s == STOP)
331 alarm(0);
332 return ret;
333 }
334 #endif
335
336 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
337 const openssl_speed_sec_t *seconds);
338
339 static int found(const char *name, const OPT_PAIR *pairs, int *result)
340 {
341 for (; pairs->name; pairs++)
342 if (strcmp(name, pairs->name) == 0) {
343 *result = pairs->retval;
344 return 1;
345 }
346 return 0;
347 }
348
349 typedef enum OPTION_choice {
350 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
351 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
352 OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,
353 OPT_PRIMES, OPT_SECONDS, OPT_BYTES
354 } OPTION_CHOICE;
355
356 const OPTIONS speed_options[] = {
357 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
358 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
359 {"help", OPT_HELP, '-', "Display this summary"},
360 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
361 {"decrypt", OPT_DECRYPT, '-',
362 "Time decryption instead of encryption (only EVP)"},
363 {"mr", OPT_MR, '-', "Produce machine readable output"},
364 {"mb", OPT_MB, '-',
365 "Enable (tls1.1) multi-block mode on evp_cipher requested with -evp"},
366 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
367 {"elapsed", OPT_ELAPSED, '-',
368 "Measure time in real time instead of CPU user time"},
369 #ifndef NO_FORK
370 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
371 #endif
372 #ifndef OPENSSL_NO_ASYNC
373 {"async_jobs", OPT_ASYNCJOBS, 'p',
374 "Enable async mode and start pnum jobs"},
375 #endif
376 OPT_R_OPTIONS,
377 #ifndef OPENSSL_NO_ENGINE
378 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
379 #endif
380 {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},
381 {"seconds", OPT_SECONDS, 'p',
382 "Run benchmarks for pnum seconds"},
383 {"bytes", OPT_BYTES, 'p',
384 "Run cipher, digest and rand benchmarks on pnum bytes"},
385 {NULL},
386 };
387
388 #define D_MD2 0
389 #define D_MDC2 1
390 #define D_MD4 2
391 #define D_MD5 3
392 #define D_HMAC 4
393 #define D_SHA1 5
394 #define D_RMD160 6
395 #define D_RC4 7
396 #define D_CBC_DES 8
397 #define D_EDE3_DES 9
398 #define D_CBC_IDEA 10
399 #define D_CBC_SEED 11
400 #define D_CBC_RC2 12
401 #define D_CBC_RC5 13
402 #define D_CBC_BF 14
403 #define D_CBC_CAST 15
404 #define D_CBC_128_AES 16
405 #define D_CBC_192_AES 17
406 #define D_CBC_256_AES 18
407 #define D_CBC_128_CML 19
408 #define D_CBC_192_CML 20
409 #define D_CBC_256_CML 21
410 #define D_EVP 22
411 #define D_SHA256 23
412 #define D_SHA512 24
413 #define D_WHIRLPOOL 25
414 #define D_IGE_128_AES 26
415 #define D_IGE_192_AES 27
416 #define D_IGE_256_AES 28
417 #define D_GHASH 29
418 #define D_RAND 30
419 static OPT_PAIR doit_choices[] = {
420 #ifndef OPENSSL_NO_MD2
421 {"md2", D_MD2},
422 #endif
423 #ifndef OPENSSL_NO_MDC2
424 {"mdc2", D_MDC2},
425 #endif
426 #ifndef OPENSSL_NO_MD4
427 {"md4", D_MD4},
428 #endif
429 #ifndef OPENSSL_NO_MD5
430 {"md5", D_MD5},
431 {"hmac", D_HMAC},
432 #endif
433 {"sha1", D_SHA1},
434 {"sha256", D_SHA256},
435 {"sha512", D_SHA512},
436 #ifndef OPENSSL_NO_WHIRLPOOL
437 {"whirlpool", D_WHIRLPOOL},
438 #endif
439 #ifndef OPENSSL_NO_RMD160
440 {"ripemd", D_RMD160},
441 {"rmd160", D_RMD160},
442 {"ripemd160", D_RMD160},
443 #endif
444 #ifndef OPENSSL_NO_RC4
445 {"rc4", D_RC4},
446 #endif
447 #ifndef OPENSSL_NO_DES
448 {"des-cbc", D_CBC_DES},
449 {"des-ede3", D_EDE3_DES},
450 #endif
451 {"aes-128-cbc", D_CBC_128_AES},
452 {"aes-192-cbc", D_CBC_192_AES},
453 {"aes-256-cbc", D_CBC_256_AES},
454 {"aes-128-ige", D_IGE_128_AES},
455 {"aes-192-ige", D_IGE_192_AES},
456 {"aes-256-ige", D_IGE_256_AES},
457 #ifndef OPENSSL_NO_RC2
458 {"rc2-cbc", D_CBC_RC2},
459 {"rc2", D_CBC_RC2},
460 #endif
461 #ifndef OPENSSL_NO_RC5
462 {"rc5-cbc", D_CBC_RC5},
463 {"rc5", D_CBC_RC5},
464 #endif
465 #ifndef OPENSSL_NO_IDEA
466 {"idea-cbc", D_CBC_IDEA},
467 {"idea", D_CBC_IDEA},
468 #endif
469 #ifndef OPENSSL_NO_SEED
470 {"seed-cbc", D_CBC_SEED},
471 {"seed", D_CBC_SEED},
472 #endif
473 #ifndef OPENSSL_NO_BF
474 {"bf-cbc", D_CBC_BF},
475 {"blowfish", D_CBC_BF},
476 {"bf", D_CBC_BF},
477 #endif
478 #ifndef OPENSSL_NO_CAST
479 {"cast-cbc", D_CBC_CAST},
480 {"cast", D_CBC_CAST},
481 {"cast5", D_CBC_CAST},
482 #endif
483 {"ghash", D_GHASH},
484 {"rand", D_RAND},
485 {NULL}
486 };
487
488 #ifndef OPENSSL_NO_DSA
489 # define R_DSA_512 0
490 # define R_DSA_1024 1
491 # define R_DSA_2048 2
492 static OPT_PAIR dsa_choices[] = {
493 {"dsa512", R_DSA_512},
494 {"dsa1024", R_DSA_1024},
495 {"dsa2048", R_DSA_2048},
496 {NULL},
497 };
498 #endif
499
500 #define R_RSA_512 0
501 #define R_RSA_1024 1
502 #define R_RSA_2048 2
503 #define R_RSA_3072 3
504 #define R_RSA_4096 4
505 #define R_RSA_7680 5
506 #define R_RSA_15360 6
507 static OPT_PAIR rsa_choices[] = {
508 {"rsa512", R_RSA_512},
509 {"rsa1024", R_RSA_1024},
510 {"rsa2048", R_RSA_2048},
511 {"rsa3072", R_RSA_3072},
512 {"rsa4096", R_RSA_4096},
513 {"rsa7680", R_RSA_7680},
514 {"rsa15360", R_RSA_15360},
515 {NULL}
516 };
517
518 #define R_EC_P160 0
519 #define R_EC_P192 1
520 #define R_EC_P224 2
521 #define R_EC_P256 3
522 #define R_EC_P384 4
523 #define R_EC_P521 5
524 #define R_EC_K163 6
525 #define R_EC_K233 7
526 #define R_EC_K283 8
527 #define R_EC_K409 9
528 #define R_EC_K571 10
529 #define R_EC_B163 11
530 #define R_EC_B233 12
531 #define R_EC_B283 13
532 #define R_EC_B409 14
533 #define R_EC_B571 15
534 #define R_EC_X25519 16
535 #ifndef OPENSSL_NO_EC
536 static OPT_PAIR ecdsa_choices[] = {
537 {"ecdsap160", R_EC_P160},
538 {"ecdsap192", R_EC_P192},
539 {"ecdsap224", R_EC_P224},
540 {"ecdsap256", R_EC_P256},
541 {"ecdsap384", R_EC_P384},
542 {"ecdsap521", R_EC_P521},
543 {"ecdsak163", R_EC_K163},
544 {"ecdsak233", R_EC_K233},
545 {"ecdsak283", R_EC_K283},
546 {"ecdsak409", R_EC_K409},
547 {"ecdsak571", R_EC_K571},
548 {"ecdsab163", R_EC_B163},
549 {"ecdsab233", R_EC_B233},
550 {"ecdsab283", R_EC_B283},
551 {"ecdsab409", R_EC_B409},
552 {"ecdsab571", R_EC_B571},
553 {NULL}
554 };
555
556 static OPT_PAIR ecdh_choices[] = {
557 {"ecdhp160", R_EC_P160},
558 {"ecdhp192", R_EC_P192},
559 {"ecdhp224", R_EC_P224},
560 {"ecdhp256", R_EC_P256},
561 {"ecdhp384", R_EC_P384},
562 {"ecdhp521", R_EC_P521},
563 {"ecdhk163", R_EC_K163},
564 {"ecdhk233", R_EC_K233},
565 {"ecdhk283", R_EC_K283},
566 {"ecdhk409", R_EC_K409},
567 {"ecdhk571", R_EC_K571},
568 {"ecdhb163", R_EC_B163},
569 {"ecdhb233", R_EC_B233},
570 {"ecdhb283", R_EC_B283},
571 {"ecdhb409", R_EC_B409},
572 {"ecdhb571", R_EC_B571},
573 {"ecdhx25519", R_EC_X25519},
574 {NULL}
575 };
576 #endif
577
578 #ifndef SIGALRM
579 # define COND(d) (count < (d))
580 # define COUNT(d) (d)
581 #else
582 # define COND(unused_cond) (run && count<0x7fffffff)
583 # define COUNT(d) (count)
584 #endif /* SIGALRM */
585
586 static int testnum;
587
588 /* Nb of iterations to do per algorithm and key-size */
589 static long c[ALGOR_NUM][OSSL_NELEM(lengths_list)];
590
591 #ifndef OPENSSL_NO_MD2
592 static int EVP_Digest_MD2_loop(void *args)
593 {
594 loopargs_t *tempargs = *(loopargs_t **) args;
595 unsigned char *buf = tempargs->buf;
596 unsigned char md2[MD2_DIGEST_LENGTH];
597 int count;
598
599 for (count = 0; COND(c[D_MD2][testnum]); count++) {
600 if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
601 NULL))
602 return -1;
603 }
604 return count;
605 }
606 #endif
607
608 #ifndef OPENSSL_NO_MDC2
609 static int EVP_Digest_MDC2_loop(void *args)
610 {
611 loopargs_t *tempargs = *(loopargs_t **) args;
612 unsigned char *buf = tempargs->buf;
613 unsigned char mdc2[MDC2_DIGEST_LENGTH];
614 int count;
615
616 for (count = 0; COND(c[D_MDC2][testnum]); count++) {
617 if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
618 NULL))
619 return -1;
620 }
621 return count;
622 }
623 #endif
624
625 #ifndef OPENSSL_NO_MD4
626 static int EVP_Digest_MD4_loop(void *args)
627 {
628 loopargs_t *tempargs = *(loopargs_t **) args;
629 unsigned char *buf = tempargs->buf;
630 unsigned char md4[MD4_DIGEST_LENGTH];
631 int count;
632
633 for (count = 0; COND(c[D_MD4][testnum]); count++) {
634 if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
635 NULL))
636 return -1;
637 }
638 return count;
639 }
640 #endif
641
642 #ifndef OPENSSL_NO_MD5
643 static int MD5_loop(void *args)
644 {
645 loopargs_t *tempargs = *(loopargs_t **) args;
646 unsigned char *buf = tempargs->buf;
647 unsigned char md5[MD5_DIGEST_LENGTH];
648 int count;
649 for (count = 0; COND(c[D_MD5][testnum]); count++)
650 MD5(buf, lengths[testnum], md5);
651 return count;
652 }
653
654 static int HMAC_loop(void *args)
655 {
656 loopargs_t *tempargs = *(loopargs_t **) args;
657 unsigned char *buf = tempargs->buf;
658 HMAC_CTX *hctx = tempargs->hctx;
659 unsigned char hmac[MD5_DIGEST_LENGTH];
660 int count;
661
662 for (count = 0; COND(c[D_HMAC][testnum]); count++) {
663 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
664 HMAC_Update(hctx, buf, lengths[testnum]);
665 HMAC_Final(hctx, hmac, NULL);
666 }
667 return count;
668 }
669 #endif
670
671 static int SHA1_loop(void *args)
672 {
673 loopargs_t *tempargs = *(loopargs_t **) args;
674 unsigned char *buf = tempargs->buf;
675 unsigned char sha[SHA_DIGEST_LENGTH];
676 int count;
677 for (count = 0; COND(c[D_SHA1][testnum]); count++)
678 SHA1(buf, lengths[testnum], sha);
679 return count;
680 }
681
682 static int SHA256_loop(void *args)
683 {
684 loopargs_t *tempargs = *(loopargs_t **) args;
685 unsigned char *buf = tempargs->buf;
686 unsigned char sha256[SHA256_DIGEST_LENGTH];
687 int count;
688 for (count = 0; COND(c[D_SHA256][testnum]); count++)
689 SHA256(buf, lengths[testnum], sha256);
690 return count;
691 }
692
693 static int SHA512_loop(void *args)
694 {
695 loopargs_t *tempargs = *(loopargs_t **) args;
696 unsigned char *buf = tempargs->buf;
697 unsigned char sha512[SHA512_DIGEST_LENGTH];
698 int count;
699 for (count = 0; COND(c[D_SHA512][testnum]); count++)
700 SHA512(buf, lengths[testnum], sha512);
701 return count;
702 }
703
704 #ifndef OPENSSL_NO_WHIRLPOOL
705 static int WHIRLPOOL_loop(void *args)
706 {
707 loopargs_t *tempargs = *(loopargs_t **) args;
708 unsigned char *buf = tempargs->buf;
709 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
710 int count;
711 for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)
712 WHIRLPOOL(buf, lengths[testnum], whirlpool);
713 return count;
714 }
715 #endif
716
717 #ifndef OPENSSL_NO_RMD160
718 static int EVP_Digest_RMD160_loop(void *args)
719 {
720 loopargs_t *tempargs = *(loopargs_t **) args;
721 unsigned char *buf = tempargs->buf;
722 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
723 int count;
724 for (count = 0; COND(c[D_RMD160][testnum]); count++) {
725 if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
726 NULL, EVP_ripemd160(), NULL))
727 return -1;
728 }
729 return count;
730 }
731 #endif
732
733 #ifndef OPENSSL_NO_RC4
734 static RC4_KEY rc4_ks;
735 static int RC4_loop(void *args)
736 {
737 loopargs_t *tempargs = *(loopargs_t **) args;
738 unsigned char *buf = tempargs->buf;
739 int count;
740 for (count = 0; COND(c[D_RC4][testnum]); count++)
741 RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
742 return count;
743 }
744 #endif
745
746 #ifndef OPENSSL_NO_DES
747 static unsigned char DES_iv[8];
748 static DES_key_schedule sch;
749 static DES_key_schedule sch2;
750 static DES_key_schedule sch3;
751 static int DES_ncbc_encrypt_loop(void *args)
752 {
753 loopargs_t *tempargs = *(loopargs_t **) args;
754 unsigned char *buf = tempargs->buf;
755 int count;
756 for (count = 0; COND(c[D_CBC_DES][testnum]); count++)
757 DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,
758 &DES_iv, DES_ENCRYPT);
759 return count;
760 }
761
762 static int DES_ede3_cbc_encrypt_loop(void *args)
763 {
764 loopargs_t *tempargs = *(loopargs_t **) args;
765 unsigned char *buf = tempargs->buf;
766 int count;
767 for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)
768 DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],
769 &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);
770 return count;
771 }
772 #endif
773
774 #define MAX_BLOCK_SIZE 128
775
776 static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
777 static AES_KEY aes_ks1, aes_ks2, aes_ks3;
778 static int AES_cbc_128_encrypt_loop(void *args)
779 {
780 loopargs_t *tempargs = *(loopargs_t **) args;
781 unsigned char *buf = tempargs->buf;
782 int count;
783 for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
784 AES_cbc_encrypt(buf, buf,
785 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
786 return count;
787 }
788
789 static int AES_cbc_192_encrypt_loop(void *args)
790 {
791 loopargs_t *tempargs = *(loopargs_t **) args;
792 unsigned char *buf = tempargs->buf;
793 int count;
794 for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
795 AES_cbc_encrypt(buf, buf,
796 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
797 return count;
798 }
799
800 static int AES_cbc_256_encrypt_loop(void *args)
801 {
802 loopargs_t *tempargs = *(loopargs_t **) args;
803 unsigned char *buf = tempargs->buf;
804 int count;
805 for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
806 AES_cbc_encrypt(buf, buf,
807 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
808 return count;
809 }
810
811 static int AES_ige_128_encrypt_loop(void *args)
812 {
813 loopargs_t *tempargs = *(loopargs_t **) args;
814 unsigned char *buf = tempargs->buf;
815 unsigned char *buf2 = tempargs->buf2;
816 int count;
817 for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
818 AES_ige_encrypt(buf, buf2,
819 (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);
820 return count;
821 }
822
823 static int AES_ige_192_encrypt_loop(void *args)
824 {
825 loopargs_t *tempargs = *(loopargs_t **) args;
826 unsigned char *buf = tempargs->buf;
827 unsigned char *buf2 = tempargs->buf2;
828 int count;
829 for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
830 AES_ige_encrypt(buf, buf2,
831 (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);
832 return count;
833 }
834
835 static int AES_ige_256_encrypt_loop(void *args)
836 {
837 loopargs_t *tempargs = *(loopargs_t **) args;
838 unsigned char *buf = tempargs->buf;
839 unsigned char *buf2 = tempargs->buf2;
840 int count;
841 for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
842 AES_ige_encrypt(buf, buf2,
843 (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);
844 return count;
845 }
846
847 static int CRYPTO_gcm128_aad_loop(void *args)
848 {
849 loopargs_t *tempargs = *(loopargs_t **) args;
850 unsigned char *buf = tempargs->buf;
851 GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;
852 int count;
853 for (count = 0; COND(c[D_GHASH][testnum]); count++)
854 CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);
855 return count;
856 }
857
858 static int RAND_bytes_loop(void *args)
859 {
860 loopargs_t *tempargs = *(loopargs_t **) args;
861 unsigned char *buf = tempargs->buf;
862 int count;
863
864 for (count = 0; COND(c[D_RAND][testnum]); count++)
865 RAND_bytes(buf, lengths[testnum]);
866 return count;
867 }
868
869 static long save_count = 0;
870 static int decrypt = 0;
871 static int EVP_Update_loop(void *args)
872 {
873 loopargs_t *tempargs = *(loopargs_t **) args;
874 unsigned char *buf = tempargs->buf;
875 EVP_CIPHER_CTX *ctx = tempargs->ctx;
876 int outl, count, rc;
877 #ifndef SIGALRM
878 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
879 #endif
880 if (decrypt) {
881 for (count = 0; COND(nb_iter); count++) {
882 rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
883 if (rc != 1)
884 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
885 }
886 } else {
887 for (count = 0; COND(nb_iter); count++) {
888 rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
889 if (rc != 1)
890 EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);
891 }
892 }
893 if (decrypt)
894 EVP_DecryptFinal_ex(ctx, buf, &outl);
895 else
896 EVP_EncryptFinal_ex(ctx, buf, &outl);
897 return count;
898 }
899 /*
900 * CCM does not support streaming. For the purpose of performance measurement,
901 * each message is encrypted using the same (key,iv)-pair. Do not use this
902 * code in your application.
903 */
904 static int EVP_Update_loop_ccm(void *args)
905 {
906 loopargs_t *tempargs = *(loopargs_t **) args;
907 unsigned char *buf = tempargs->buf;
908 EVP_CIPHER_CTX *ctx = tempargs->ctx;
909 int outl, count;
910 unsigned char tag[12];
911 #ifndef SIGALRM
912 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
913 #endif
914 if (decrypt) {
915 for (count = 0; COND(nb_iter); count++) {
916 EVP_DecryptInit_ex(ctx, NULL, NULL, NULL, iv);
917 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG, sizeof(tag), tag);
918 EVP_DecryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
919 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
920 EVP_DecryptFinal_ex(ctx, buf, &outl);
921 }
922 } else {
923 for (count = 0; COND(nb_iter); count++) {
924 EVP_EncryptInit_ex(ctx, NULL, NULL, NULL, iv);
925 EVP_EncryptUpdate(ctx, NULL, &outl, NULL, lengths[testnum]);
926 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);
927 EVP_EncryptFinal_ex(ctx, buf, &outl);
928 }
929 }
930 return count;
931 }
932
933 static const EVP_MD *evp_md = NULL;
934 static int EVP_Digest_loop(void *args)
935 {
936 loopargs_t *tempargs = *(loopargs_t **) args;
937 unsigned char *buf = tempargs->buf;
938 unsigned char md[EVP_MAX_MD_SIZE];
939 int count;
940 #ifndef SIGALRM
941 int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];
942 #endif
943
944 for (count = 0; COND(nb_iter); count++) {
945 if (!EVP_Digest(buf, lengths[testnum], md, NULL, evp_md, NULL))
946 return -1;
947 }
948 return count;
949 }
950
951 #ifndef OPENSSL_NO_RSA
952 static long rsa_c[RSA_NUM][2]; /* # RSA iteration test */
953
954 static int RSA_sign_loop(void *args)
955 {
956 loopargs_t *tempargs = *(loopargs_t **) args;
957 unsigned char *buf = tempargs->buf;
958 unsigned char *buf2 = tempargs->buf2;
959 unsigned int *rsa_num = &tempargs->siglen;
960 RSA **rsa_key = tempargs->rsa_key;
961 int ret, count;
962 for (count = 0; COND(rsa_c[testnum][0]); count++) {
963 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
964 if (ret == 0) {
965 BIO_printf(bio_err, "RSA sign failure\n");
966 ERR_print_errors(bio_err);
967 count = -1;
968 break;
969 }
970 }
971 return count;
972 }
973
974 static int RSA_verify_loop(void *args)
975 {
976 loopargs_t *tempargs = *(loopargs_t **) args;
977 unsigned char *buf = tempargs->buf;
978 unsigned char *buf2 = tempargs->buf2;
979 unsigned int rsa_num = tempargs->siglen;
980 RSA **rsa_key = tempargs->rsa_key;
981 int ret, count;
982 for (count = 0; COND(rsa_c[testnum][1]); count++) {
983 ret =
984 RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[testnum]);
985 if (ret <= 0) {
986 BIO_printf(bio_err, "RSA verify failure\n");
987 ERR_print_errors(bio_err);
988 count = -1;
989 break;
990 }
991 }
992 return count;
993 }
994 #endif
995
996 #ifndef OPENSSL_NO_DSA
997 static long dsa_c[DSA_NUM][2];
998 static int DSA_sign_loop(void *args)
999 {
1000 loopargs_t *tempargs = *(loopargs_t **) args;
1001 unsigned char *buf = tempargs->buf;
1002 unsigned char *buf2 = tempargs->buf2;
1003 DSA **dsa_key = tempargs->dsa_key;
1004 unsigned int *siglen = &tempargs->siglen;
1005 int ret, count;
1006 for (count = 0; COND(dsa_c[testnum][0]); count++) {
1007 ret = DSA_sign(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1008 if (ret == 0) {
1009 BIO_printf(bio_err, "DSA sign failure\n");
1010 ERR_print_errors(bio_err);
1011 count = -1;
1012 break;
1013 }
1014 }
1015 return count;
1016 }
1017
1018 static int DSA_verify_loop(void *args)
1019 {
1020 loopargs_t *tempargs = *(loopargs_t **) args;
1021 unsigned char *buf = tempargs->buf;
1022 unsigned char *buf2 = tempargs->buf2;
1023 DSA **dsa_key = tempargs->dsa_key;
1024 unsigned int siglen = tempargs->siglen;
1025 int ret, count;
1026 for (count = 0; COND(dsa_c[testnum][1]); count++) {
1027 ret = DSA_verify(0, buf, 20, buf2, siglen, dsa_key[testnum]);
1028 if (ret <= 0) {
1029 BIO_printf(bio_err, "DSA verify failure\n");
1030 ERR_print_errors(bio_err);
1031 count = -1;
1032 break;
1033 }
1034 }
1035 return count;
1036 }
1037 #endif
1038
1039 #ifndef OPENSSL_NO_EC
1040 static long ecdsa_c[EC_NUM][2];
1041 static int ECDSA_sign_loop(void *args)
1042 {
1043 loopargs_t *tempargs = *(loopargs_t **) args;
1044 unsigned char *buf = tempargs->buf;
1045 EC_KEY **ecdsa = tempargs->ecdsa;
1046 unsigned char *ecdsasig = tempargs->buf2;
1047 unsigned int *ecdsasiglen = &tempargs->siglen;
1048 int ret, count;
1049 for (count = 0; COND(ecdsa_c[testnum][0]); count++) {
1050 ret = ECDSA_sign(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1051 if (ret == 0) {
1052 BIO_printf(bio_err, "ECDSA sign failure\n");
1053 ERR_print_errors(bio_err);
1054 count = -1;
1055 break;
1056 }
1057 }
1058 return count;
1059 }
1060
1061 static int ECDSA_verify_loop(void *args)
1062 {
1063 loopargs_t *tempargs = *(loopargs_t **) args;
1064 unsigned char *buf = tempargs->buf;
1065 EC_KEY **ecdsa = tempargs->ecdsa;
1066 unsigned char *ecdsasig = tempargs->buf2;
1067 unsigned int ecdsasiglen = tempargs->siglen;
1068 int ret, count;
1069 for (count = 0; COND(ecdsa_c[testnum][1]); count++) {
1070 ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[testnum]);
1071 if (ret != 1) {
1072 BIO_printf(bio_err, "ECDSA verify failure\n");
1073 ERR_print_errors(bio_err);
1074 count = -1;
1075 break;
1076 }
1077 }
1078 return count;
1079 }
1080
1081 /* ******************************************************************** */
1082 static long ecdh_c[EC_NUM][1];
1083
1084 static int ECDH_EVP_derive_key_loop(void *args)
1085 {
1086 loopargs_t *tempargs = *(loopargs_t **) args;
1087 EVP_PKEY_CTX *ctx = tempargs->ecdh_ctx[testnum];
1088 unsigned char *derived_secret = tempargs->secret_a;
1089 int count;
1090 size_t *outlen = &(tempargs->outlen[testnum]);
1091
1092 for (count = 0; COND(ecdh_c[testnum][0]); count++)
1093 EVP_PKEY_derive(ctx, derived_secret, outlen);
1094
1095 return count;
1096 }
1097
1098 #endif /* OPENSSL_NO_EC */
1099
1100 static int run_benchmark(int async_jobs,
1101 int (*loop_function) (void *), loopargs_t * loopargs)
1102 {
1103 int job_op_count = 0;
1104 int total_op_count = 0;
1105 int num_inprogress = 0;
1106 int error = 0, i = 0, ret = 0;
1107 OSSL_ASYNC_FD job_fd = 0;
1108 size_t num_job_fds = 0;
1109
1110 run = 1;
1111
1112 if (async_jobs == 0) {
1113 return loop_function((void *)&loopargs);
1114 }
1115
1116 for (i = 0; i < async_jobs && !error; i++) {
1117 loopargs_t *looparg_item = loopargs + i;
1118
1119 /* Copy pointer content (looparg_t item address) into async context */
1120 ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1121 &job_op_count, loop_function,
1122 (void *)&looparg_item, sizeof(looparg_item));
1123 switch (ret) {
1124 case ASYNC_PAUSE:
1125 ++num_inprogress;
1126 break;
1127 case ASYNC_FINISH:
1128 if (job_op_count == -1) {
1129 error = 1;
1130 } else {
1131 total_op_count += job_op_count;
1132 }
1133 break;
1134 case ASYNC_NO_JOBS:
1135 case ASYNC_ERR:
1136 BIO_printf(bio_err, "Failure in the job\n");
1137 ERR_print_errors(bio_err);
1138 error = 1;
1139 break;
1140 }
1141 }
1142
1143 while (num_inprogress > 0) {
1144 #if defined(OPENSSL_SYS_WINDOWS)
1145 DWORD avail = 0;
1146 #elif defined(OPENSSL_SYS_UNIX)
1147 int select_result = 0;
1148 OSSL_ASYNC_FD max_fd = 0;
1149 fd_set waitfdset;
1150
1151 FD_ZERO(&waitfdset);
1152
1153 for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1154 if (loopargs[i].inprogress_job == NULL)
1155 continue;
1156
1157 if (!ASYNC_WAIT_CTX_get_all_fds
1158 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1159 || num_job_fds > 1) {
1160 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1161 ERR_print_errors(bio_err);
1162 error = 1;
1163 break;
1164 }
1165 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1166 &num_job_fds);
1167 FD_SET(job_fd, &waitfdset);
1168 if (job_fd > max_fd)
1169 max_fd = job_fd;
1170 }
1171
1172 if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1173 BIO_printf(bio_err,
1174 "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1175 "Decrease the value of async_jobs\n",
1176 max_fd, FD_SETSIZE);
1177 ERR_print_errors(bio_err);
1178 error = 1;
1179 break;
1180 }
1181
1182 select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1183 if (select_result == -1 && errno == EINTR)
1184 continue;
1185
1186 if (select_result == -1) {
1187 BIO_printf(bio_err, "Failure in the select\n");
1188 ERR_print_errors(bio_err);
1189 error = 1;
1190 break;
1191 }
1192
1193 if (select_result == 0)
1194 continue;
1195 #endif
1196
1197 for (i = 0; i < async_jobs; i++) {
1198 if (loopargs[i].inprogress_job == NULL)
1199 continue;
1200
1201 if (!ASYNC_WAIT_CTX_get_all_fds
1202 (loopargs[i].wait_ctx, NULL, &num_job_fds)
1203 || num_job_fds > 1) {
1204 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1205 ERR_print_errors(bio_err);
1206 error = 1;
1207 break;
1208 }
1209 ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd,
1210 &num_job_fds);
1211
1212 #if defined(OPENSSL_SYS_UNIX)
1213 if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1214 continue;
1215 #elif defined(OPENSSL_SYS_WINDOWS)
1216 if (num_job_fds == 1
1217 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1218 && avail > 0)
1219 continue;
1220 #endif
1221
1222 ret = ASYNC_start_job(&loopargs[i].inprogress_job,
1223 loopargs[i].wait_ctx, &job_op_count,
1224 loop_function, (void *)(loopargs + i),
1225 sizeof(loopargs_t));
1226 switch (ret) {
1227 case ASYNC_PAUSE:
1228 break;
1229 case ASYNC_FINISH:
1230 if (job_op_count == -1) {
1231 error = 1;
1232 } else {
1233 total_op_count += job_op_count;
1234 }
1235 --num_inprogress;
1236 loopargs[i].inprogress_job = NULL;
1237 break;
1238 case ASYNC_NO_JOBS:
1239 case ASYNC_ERR:
1240 --num_inprogress;
1241 loopargs[i].inprogress_job = NULL;
1242 BIO_printf(bio_err, "Failure in the job\n");
1243 ERR_print_errors(bio_err);
1244 error = 1;
1245 break;
1246 }
1247 }
1248 }
1249
1250 return error ? -1 : total_op_count;
1251 }
1252
1253 int speed_main(int argc, char **argv)
1254 {
1255 ENGINE *e = NULL;
1256 int (*loopfunc)(void *args);
1257 loopargs_t *loopargs = NULL;
1258 int async_init = 0;
1259 int loopargs_len = 0;
1260 char *prog;
1261 const char *engine_id = NULL;
1262 const EVP_CIPHER *evp_cipher = NULL;
1263 double d = 0.0;
1264 OPTION_CHOICE o;
1265 int multiblock = 0, pr_header = 0;
1266 int doit[ALGOR_NUM] = { 0 };
1267 int ret = 1, i, k, misalign = 0;
1268 long count = 0;
1269 int size_num = OSSL_NELEM(lengths_list);
1270 int keylen;
1271 int buflen;
1272 #ifndef NO_FORK
1273 int multi = 0;
1274 #endif
1275 unsigned int async_jobs = 0;
1276 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1277 || !defined(OPENSSL_NO_EC)
1278 long rsa_count = 1;
1279 #endif
1280
1281 /* What follows are the buffers and key material. */
1282 #ifndef OPENSSL_NO_RC5
1283 RC5_32_KEY rc5_ks;
1284 #endif
1285 #ifndef OPENSSL_NO_RC2
1286 RC2_KEY rc2_ks;
1287 #endif
1288 #ifndef OPENSSL_NO_IDEA
1289 IDEA_KEY_SCHEDULE idea_ks;
1290 #endif
1291 #ifndef OPENSSL_NO_SEED
1292 SEED_KEY_SCHEDULE seed_ks;
1293 #endif
1294 #ifndef OPENSSL_NO_BF
1295 BF_KEY bf_ks;
1296 #endif
1297 #ifndef OPENSSL_NO_CAST
1298 CAST_KEY cast_ks;
1299 #endif
1300 static const unsigned char key16[16] = {
1301 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1302 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1303 };
1304 static const unsigned char key24[24] = {
1305 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1306 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1307 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1308 };
1309 static const unsigned char key32[32] = {
1310 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1311 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1312 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1313 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1314 };
1315 #ifndef OPENSSL_NO_CAMELLIA
1316 static const unsigned char ckey24[24] = {
1317 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1318 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1319 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1320 };
1321 static const unsigned char ckey32[32] = {
1322 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1323 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1324 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1325 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1326 };
1327 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1328 #endif
1329 #ifndef OPENSSL_NO_DES
1330 static DES_cblock key = {
1331 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1332 };
1333 static DES_cblock key2 = {
1334 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1335 };
1336 static DES_cblock key3 = {
1337 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1338 };
1339 #endif
1340 #ifndef OPENSSL_NO_RSA
1341 static const unsigned int rsa_bits[RSA_NUM] = {
1342 512, 1024, 2048, 3072, 4096, 7680, 15360
1343 };
1344 static const unsigned char *rsa_data[RSA_NUM] = {
1345 test512, test1024, test2048, test3072, test4096, test7680, test15360
1346 };
1347 static const int rsa_data_length[RSA_NUM] = {
1348 sizeof(test512), sizeof(test1024),
1349 sizeof(test2048), sizeof(test3072),
1350 sizeof(test4096), sizeof(test7680),
1351 sizeof(test15360)
1352 };
1353 int rsa_doit[RSA_NUM] = { 0 };
1354 int primes = RSA_DEFAULT_PRIME_NUM;
1355 #endif
1356 #ifndef OPENSSL_NO_DSA
1357 static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1358 int dsa_doit[DSA_NUM] = { 0 };
1359 #endif
1360 #ifndef OPENSSL_NO_EC
1361 /*
1362 * We only test over the following curves as they are representative, To
1363 * add tests over more curves, simply add the curve NID and curve name to
1364 * the following arrays and increase the EC_NUM value accordingly.
1365 */
1366 static const unsigned int test_curves[EC_NUM] = {
1367 /* Prime Curves */
1368 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1369 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1370 /* Binary Curves */
1371 NID_sect163k1, NID_sect233k1, NID_sect283k1,
1372 NID_sect409k1, NID_sect571k1, NID_sect163r2,
1373 NID_sect233r1, NID_sect283r1, NID_sect409r1,
1374 NID_sect571r1,
1375 /* Other */
1376 NID_X25519
1377 };
1378 static const char *test_curves_names[EC_NUM] = {
1379 /* Prime Curves */
1380 "secp160r1", "nistp192", "nistp224",
1381 "nistp256", "nistp384", "nistp521",
1382 /* Binary Curves */
1383 "nistk163", "nistk233", "nistk283",
1384 "nistk409", "nistk571", "nistb163",
1385 "nistb233", "nistb283", "nistb409",
1386 "nistb571",
1387 /* Other */
1388 "X25519"
1389 };
1390 static const int test_curves_bits[EC_NUM] = {
1391 160, 192, 224,
1392 256, 384, 521,
1393 163, 233, 283,
1394 409, 571, 163,
1395 233, 283, 409,
1396 571, 253 /* X25519 */
1397 };
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 (i = 0; i < EC_NUM; i++)
1565 ecdsa_doit[i] = 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 (i = 0; i < EC_NUM; i++)
1574 ecdh_doit[i] = 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 (i = 0; i < EC_NUM; i++)
1647 ecdsa_doit[i] = 1;
1648 for (i = 0; i < EC_NUM; i++)
1649 ecdh_doit[i] = 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 %d bit 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 %d bit 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:%d:%.2f\n"
2579 : "%ld %d bit 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:%d:%.2f\n"
2605 : "%ld %d bit 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 for (testnum = 0; testnum < EC_NUM; testnum++) {
2620 int st = 1;
2621
2622 if (!ecdsa_doit[testnum])
2623 continue; /* Ignore Curve */
2624 for (i = 0; i < loopargs_len; i++) {
2625 loopargs[i].ecdsa[testnum] =
2626 EC_KEY_new_by_curve_name(test_curves[testnum]);
2627 if (loopargs[i].ecdsa[testnum] == NULL) {
2628 st = 0;
2629 break;
2630 }
2631 }
2632 if (st == 0) {
2633 BIO_printf(bio_err, "ECDSA failure.\n");
2634 ERR_print_errors(bio_err);
2635 rsa_count = 1;
2636 } else {
2637 for (i = 0; i < loopargs_len; i++) {
2638 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2639 /* Perform ECDSA signature test */
2640 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2641 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2642 &loopargs[i].siglen,
2643 loopargs[i].ecdsa[testnum]);
2644 if (st == 0)
2645 break;
2646 }
2647 if (st == 0) {
2648 BIO_printf(bio_err,
2649 "ECDSA sign failure. No ECDSA sign will be done.\n");
2650 ERR_print_errors(bio_err);
2651 rsa_count = 1;
2652 } else {
2653 pkey_print_message("sign", "ecdsa",
2654 ecdsa_c[testnum][0],
2655 test_curves_bits[testnum],
2656 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:%d:%.2f\n" :
2663 "%ld %d bit ECDSA signs in %.2fs \n",
2664 count, test_curves_bits[testnum], 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_bits[testnum],
2686 seconds.ecdsa);
2687 Time_F(START);
2688 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2689 d = Time_F(STOP);
2690 BIO_printf(bio_err,
2691 mr ? "+R6:%ld:%d:%.2f\n"
2692 : "%ld %d bit ECDSA verify in %.2fs\n",
2693 count, test_curves_bits[testnum], d);
2694 ecdsa_results[testnum][1] = (double)count / d;
2695 }
2696
2697 if (rsa_count <= 1) {
2698 /* if longer than 10s, don't do any more */
2699 for (testnum++; testnum < EC_NUM; testnum++)
2700 ecdsa_doit[testnum] = 0;
2701 }
2702 }
2703 }
2704
2705 for (testnum = 0; testnum < EC_NUM; testnum++) {
2706 int ecdh_checks = 1;
2707
2708 if (!ecdh_doit[testnum])
2709 continue;
2710
2711 for (i = 0; i < loopargs_len; i++) {
2712 EVP_PKEY_CTX *kctx = NULL;
2713 EVP_PKEY_CTX *test_ctx = NULL;
2714 EVP_PKEY_CTX *ctx = NULL;
2715 EVP_PKEY *key_A = NULL;
2716 EVP_PKEY *key_B = NULL;
2717 size_t outlen;
2718 size_t test_outlen;
2719
2720 /* Ensure that the error queue is empty */
2721 if (ERR_peek_error()) {
2722 BIO_printf(bio_err,
2723 "WARNING: the error queue contains previous unhandled errors.\n");
2724 ERR_print_errors(bio_err);
2725 }
2726
2727 /* Let's try to create a ctx directly from the NID: this works for
2728 * curves like Curve25519 that are not implemented through the low
2729 * level EC interface.
2730 * If this fails we try creating a EVP_PKEY_EC generic param ctx,
2731 * then we set the curve by NID before deriving the actual keygen
2732 * ctx for that specific curve. */
2733 kctx = EVP_PKEY_CTX_new_id(test_curves[testnum], NULL); /* keygen ctx from NID */
2734 if (!kctx) {
2735 EVP_PKEY_CTX *pctx = NULL;
2736 EVP_PKEY *params = NULL;
2737
2738 /* If we reach this code EVP_PKEY_CTX_new_id() failed and a
2739 * "int_ctx_new:unsupported algorithm" error was added to the
2740 * error queue.
2741 * We remove it from the error queue as we are handling it. */
2742 unsigned long error = ERR_peek_error(); /* peek the latest error in the queue */
2743 if (error == ERR_peek_last_error() && /* oldest and latest errors match */
2744 /* check that the error origin matches */
2745 ERR_GET_LIB(error) == ERR_LIB_EVP &&
2746 ERR_GET_FUNC(error) == EVP_F_INT_CTX_NEW &&
2747 ERR_GET_REASON(error) == EVP_R_UNSUPPORTED_ALGORITHM)
2748 ERR_get_error(); /* pop error from queue */
2749 if (ERR_peek_error()) {
2750 BIO_printf(bio_err,
2751 "Unhandled error in the error queue during ECDH init.\n");
2752 ERR_print_errors(bio_err);
2753 rsa_count = 1;
2754 break;
2755 }
2756
2757 if ( /* Create the context for parameter generation */
2758 !(pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL)) ||
2759 /* Initialise the parameter generation */
2760 !EVP_PKEY_paramgen_init(pctx) ||
2761 /* Set the curve by NID */
2762 !EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
2763 test_curves
2764 [testnum]) ||
2765 /* Create the parameter object params */
2766 !EVP_PKEY_paramgen(pctx, &params)) {
2767 ecdh_checks = 0;
2768 BIO_printf(bio_err, "ECDH EC params init failure.\n");
2769 ERR_print_errors(bio_err);
2770 rsa_count = 1;
2771 break;
2772 }
2773 /* Create the context for the key generation */
2774 kctx = EVP_PKEY_CTX_new(params, NULL);
2775
2776 EVP_PKEY_free(params);
2777 params = NULL;
2778 EVP_PKEY_CTX_free(pctx);
2779 pctx = NULL;
2780 }
2781 if (kctx == NULL || /* keygen ctx is not null */
2782 !EVP_PKEY_keygen_init(kctx) /* init keygen ctx */ ) {
2783 ecdh_checks = 0;
2784 BIO_printf(bio_err, "ECDH keygen failure.\n");
2785 ERR_print_errors(bio_err);
2786 rsa_count = 1;
2787 break;
2788 }
2789
2790 if (!EVP_PKEY_keygen(kctx, &key_A) || /* generate secret key A */
2791 !EVP_PKEY_keygen(kctx, &key_B) || /* generate secret key B */
2792 !(ctx = EVP_PKEY_CTX_new(key_A, NULL)) || /* derivation ctx from skeyA */
2793 !EVP_PKEY_derive_init(ctx) || /* init derivation ctx */
2794 !EVP_PKEY_derive_set_peer(ctx, key_B) || /* set peer pubkey in ctx */
2795 !EVP_PKEY_derive(ctx, NULL, &outlen) || /* determine max length */
2796 outlen == 0 || /* ensure outlen is a valid size */
2797 outlen > MAX_ECDH_SIZE /* avoid buffer overflow */ ) {
2798 ecdh_checks = 0;
2799 BIO_printf(bio_err, "ECDH key generation failure.\n");
2800 ERR_print_errors(bio_err);
2801 rsa_count = 1;
2802 break;
2803 }
2804
2805 /* Here we perform a test run, comparing the output of a*B and b*A;
2806 * we try this here and assume that further EVP_PKEY_derive calls
2807 * never fail, so we can skip checks in the actually benchmarked
2808 * code, for maximum performance. */
2809 if (!(test_ctx = EVP_PKEY_CTX_new(key_B, NULL)) || /* test ctx from skeyB */
2810 !EVP_PKEY_derive_init(test_ctx) || /* init derivation test_ctx */
2811 !EVP_PKEY_derive_set_peer(test_ctx, key_A) || /* set peer pubkey in test_ctx */
2812 !EVP_PKEY_derive(test_ctx, NULL, &test_outlen) || /* determine max length */
2813 !EVP_PKEY_derive(ctx, loopargs[i].secret_a, &outlen) || /* compute a*B */
2814 !EVP_PKEY_derive(test_ctx, loopargs[i].secret_b, &test_outlen) || /* compute b*A */
2815 test_outlen != outlen /* compare output length */ ) {
2816 ecdh_checks = 0;
2817 BIO_printf(bio_err, "ECDH computation failure.\n");
2818 ERR_print_errors(bio_err);
2819 rsa_count = 1;
2820 break;
2821 }
2822
2823 /* Compare the computation results: CRYPTO_memcmp() returns 0 if equal */
2824 if (CRYPTO_memcmp(loopargs[i].secret_a,
2825 loopargs[i].secret_b, outlen)) {
2826 ecdh_checks = 0;
2827 BIO_printf(bio_err, "ECDH computations don't match.\n");
2828 ERR_print_errors(bio_err);
2829 rsa_count = 1;
2830 break;
2831 }
2832
2833 loopargs[i].ecdh_ctx[testnum] = ctx;
2834 loopargs[i].outlen[testnum] = outlen;
2835
2836 EVP_PKEY_free(key_A);
2837 EVP_PKEY_free(key_B);
2838 EVP_PKEY_CTX_free(kctx);
2839 kctx = NULL;
2840 EVP_PKEY_CTX_free(test_ctx);
2841 test_ctx = NULL;
2842 }
2843 if (ecdh_checks != 0) {
2844 pkey_print_message("", "ecdh",
2845 ecdh_c[testnum][0],
2846 test_curves_bits[testnum],
2847 seconds.ecdh);
2848 Time_F(START);
2849 count =
2850 run_benchmark(async_jobs, ECDH_EVP_derive_key_loop, loopargs);
2851 d = Time_F(STOP);
2852 BIO_printf(bio_err,
2853 mr ? "+R7:%ld:%d:%.2f\n" :
2854 "%ld %d-bit ECDH ops in %.2fs\n", count,
2855 test_curves_bits[testnum], d);
2856 ecdh_results[testnum][0] = (double)count / d;
2857 rsa_count = count;
2858 }
2859
2860 if (rsa_count <= 1) {
2861 /* if longer than 10s, don't do any more */
2862 for (testnum++; testnum < EC_NUM; testnum++)
2863 ecdh_doit[testnum] = 0;
2864 }
2865 }
2866 #endif /* OPENSSL_NO_EC */
2867 #ifndef NO_FORK
2868 show_res:
2869 #endif
2870 if (!mr) {
2871 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2872 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2873 printf("options:");
2874 printf("%s ", BN_options());
2875 #ifndef OPENSSL_NO_MD2
2876 printf("%s ", MD2_options());
2877 #endif
2878 #ifndef OPENSSL_NO_RC4
2879 printf("%s ", RC4_options());
2880 #endif
2881 #ifndef OPENSSL_NO_DES
2882 printf("%s ", DES_options());
2883 #endif
2884 printf("%s ", AES_options());
2885 #ifndef OPENSSL_NO_IDEA
2886 printf("%s ", IDEA_options());
2887 #endif
2888 #ifndef OPENSSL_NO_BF
2889 printf("%s ", BF_options());
2890 #endif
2891 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2892 }
2893
2894 if (pr_header) {
2895 if (mr)
2896 printf("+H");
2897 else {
2898 printf
2899 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2900 printf("type ");
2901 }
2902 for (testnum = 0; testnum < size_num; testnum++)
2903 printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2904 printf("\n");
2905 }
2906
2907 for (k = 0; k < ALGOR_NUM; k++) {
2908 if (!doit[k])
2909 continue;
2910 if (mr)
2911 printf("+F:%d:%s", k, names[k]);
2912 else
2913 printf("%-13s", names[k]);
2914 for (testnum = 0; testnum < size_num; testnum++) {
2915 if (results[k][testnum] > 10000 && !mr)
2916 printf(" %11.2fk", results[k][testnum] / 1e3);
2917 else
2918 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2919 }
2920 printf("\n");
2921 }
2922 #ifndef OPENSSL_NO_RSA
2923 testnum = 1;
2924 for (k = 0; k < RSA_NUM; k++) {
2925 if (!rsa_doit[k])
2926 continue;
2927 if (testnum && !mr) {
2928 printf("%18ssign verify sign/s verify/s\n", " ");
2929 testnum = 0;
2930 }
2931 if (mr)
2932 printf("+F2:%u:%u:%f:%f\n",
2933 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2934 else
2935 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2936 rsa_bits[k], 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1],
2937 rsa_results[k][0], rsa_results[k][1]);
2938 }
2939 #endif
2940 #ifndef OPENSSL_NO_DSA
2941 testnum = 1;
2942 for (k = 0; k < DSA_NUM; k++) {
2943 if (!dsa_doit[k])
2944 continue;
2945 if (testnum && !mr) {
2946 printf("%18ssign verify sign/s verify/s\n", " ");
2947 testnum = 0;
2948 }
2949 if (mr)
2950 printf("+F3:%u:%u:%f:%f\n",
2951 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2952 else
2953 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2954 dsa_bits[k], 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1],
2955 dsa_results[k][0], dsa_results[k][1]);
2956 }
2957 #endif
2958 #ifndef OPENSSL_NO_EC
2959 testnum = 1;
2960 for (k = 0; k < EC_NUM; k++) {
2961 if (!ecdsa_doit[k])
2962 continue;
2963 if (testnum && !mr) {
2964 printf("%30ssign verify sign/s verify/s\n", " ");
2965 testnum = 0;
2966 }
2967
2968 if (mr)
2969 printf("+F4:%u:%u:%f:%f\n",
2970 k, test_curves_bits[k],
2971 ecdsa_results[k][0], ecdsa_results[k][1]);
2972 else
2973 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2974 test_curves_bits[k],
2975 test_curves_names[k],
2976 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1],
2977 ecdsa_results[k][0], ecdsa_results[k][1]);
2978 }
2979
2980 testnum = 1;
2981 for (k = 0; k < EC_NUM; k++) {
2982 if (!ecdh_doit[k])
2983 continue;
2984 if (testnum && !mr) {
2985 printf("%30sop op/s\n", " ");
2986 testnum = 0;
2987 }
2988 if (mr)
2989 printf("+F5:%u:%u:%f:%f\n",
2990 k, test_curves_bits[k],
2991 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2992
2993 else
2994 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2995 test_curves_bits[k],
2996 test_curves_names[k],
2997 1.0 / ecdh_results[k][0], ecdh_results[k][0]);
2998 }
2999 #endif
3000
3001 ret = 0;
3002
3003 end:
3004 ERR_print_errors(bio_err);
3005 for (i = 0; i < loopargs_len; i++) {
3006 OPENSSL_free(loopargs[i].buf_malloc);
3007 OPENSSL_free(loopargs[i].buf2_malloc);
3008
3009 #ifndef OPENSSL_NO_RSA
3010 for (k = 0; k < RSA_NUM; k++)
3011 RSA_free(loopargs[i].rsa_key[k]);
3012 #endif
3013 #ifndef OPENSSL_NO_DSA
3014 for (k = 0; k < DSA_NUM; k++)
3015 DSA_free(loopargs[i].dsa_key[k]);
3016 #endif
3017 #ifndef OPENSSL_NO_EC
3018 for (k = 0; k < EC_NUM; k++) {
3019 EC_KEY_free(loopargs[i].ecdsa[k]);
3020 EVP_PKEY_CTX_free(loopargs[i].ecdh_ctx[k]);
3021 }
3022 OPENSSL_free(loopargs[i].secret_a);
3023 OPENSSL_free(loopargs[i].secret_b);
3024 #endif
3025 }
3026
3027 if (async_jobs > 0) {
3028 for (i = 0; i < loopargs_len; i++)
3029 ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
3030 }
3031
3032 if (async_init) {
3033 ASYNC_cleanup_thread();
3034 }
3035 OPENSSL_free(loopargs);
3036 release_engine(e);
3037 return ret;
3038 }
3039
3040 static void print_message(const char *s, long num, int length, int tm)
3041 {
3042 #ifdef SIGALRM
3043 BIO_printf(bio_err,
3044 mr ? "+DT:%s:%d:%d\n"
3045 : "Doing %s for %ds on %d size blocks: ", s, tm, length);
3046 (void)BIO_flush(bio_err);
3047 alarm(tm);
3048 #else
3049 BIO_printf(bio_err,
3050 mr ? "+DN:%s:%ld:%d\n"
3051 : "Doing %s %ld times on %d size blocks: ", s, num, length);
3052 (void)BIO_flush(bio_err);
3053 #endif
3054 }
3055
3056 static void pkey_print_message(const char *str, const char *str2, long num,
3057 int bits, int tm)
3058 {
3059 #ifdef SIGALRM
3060 BIO_printf(bio_err,
3061 mr ? "+DTP:%d:%s:%s:%d\n"
3062 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
3063 (void)BIO_flush(bio_err);
3064 alarm(tm);
3065 #else
3066 BIO_printf(bio_err,
3067 mr ? "+DNP:%ld:%d:%s:%s\n"
3068 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
3069 (void)BIO_flush(bio_err);
3070 #endif
3071 }
3072
3073 static void print_result(int alg, int run_no, int count, double time_used)
3074 {
3075 if (count == -1) {
3076 BIO_puts(bio_err, "EVP error!\n");
3077 exit(1);
3078 }
3079 BIO_printf(bio_err,
3080 mr ? "+R:%d:%s:%f\n"
3081 : "%d %s's in %.2fs\n", count, names[alg], time_used);
3082 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
3083 }
3084
3085 #ifndef NO_FORK
3086 static char *sstrsep(char **string, const char *delim)
3087 {
3088 char isdelim[256];
3089 char *token = *string;
3090
3091 if (**string == 0)
3092 return NULL;
3093
3094 memset(isdelim, 0, sizeof(isdelim));
3095 isdelim[0] = 1;
3096
3097 while (*delim) {
3098 isdelim[(unsigned char)(*delim)] = 1;
3099 delim++;
3100 }
3101
3102 while (!isdelim[(unsigned char)(**string)]) {
3103 (*string)++;
3104 }
3105
3106 if (**string) {
3107 **string = 0;
3108 (*string)++;
3109 }
3110
3111 return token;
3112 }
3113
3114 static int do_multi(int multi, int size_num)
3115 {
3116 int n;
3117 int fd[2];
3118 int *fds;
3119 static char sep[] = ":";
3120
3121 fds = malloc(sizeof(*fds) * multi);
3122 for (n = 0; n < multi; ++n) {
3123 if (pipe(fd) == -1) {
3124 BIO_printf(bio_err, "pipe failure\n");
3125 exit(1);
3126 }
3127 fflush(stdout);
3128 (void)BIO_flush(bio_err);
3129 if (fork()) {
3130 close(fd[1]);
3131 fds[n] = fd[0];
3132 } else {
3133 close(fd[0]);
3134 close(1);
3135 if (dup(fd[1]) == -1) {
3136 BIO_printf(bio_err, "dup failed\n");
3137 exit(1);
3138 }
3139 close(fd[1]);
3140 mr = 1;
3141 usertime = 0;
3142 free(fds);
3143 return 0;
3144 }
3145 printf("Forked child %d\n", n);
3146 }
3147
3148 /* for now, assume the pipe is long enough to take all the output */
3149 for (n = 0; n < multi; ++n) {
3150 FILE *f;
3151 char buf[1024];
3152 char *p;
3153
3154 f = fdopen(fds[n], "r");
3155 while (fgets(buf, sizeof(buf), f)) {
3156 p = strchr(buf, '\n');
3157 if (p)
3158 *p = '\0';
3159 if (buf[0] != '+') {
3160 BIO_printf(bio_err,
3161 "Don't understand line '%s' from child %d\n", buf,
3162 n);
3163 continue;
3164 }
3165 printf("Got: %s from %d\n", buf, n);
3166 if (strncmp(buf, "+F:", 3) == 0) {
3167 int alg;
3168 int j;
3169
3170 p = buf + 3;
3171 alg = atoi(sstrsep(&p, sep));
3172 sstrsep(&p, sep);
3173 for (j = 0; j < size_num; ++j)
3174 results[alg][j] += atof(sstrsep(&p, sep));
3175 } else if (strncmp(buf, "+F2:", 4) == 0) {
3176 int k;
3177 double d;
3178
3179 p = buf + 4;
3180 k = atoi(sstrsep(&p, sep));
3181 sstrsep(&p, sep);
3182
3183 d = atof(sstrsep(&p, sep));
3184 rsa_results[k][0] += d;
3185
3186 d = atof(sstrsep(&p, sep));
3187 rsa_results[k][1] += d;
3188 }
3189 # ifndef OPENSSL_NO_DSA
3190 else if (strncmp(buf, "+F3:", 4) == 0) {
3191 int k;
3192 double d;
3193
3194 p = buf + 4;
3195 k = atoi(sstrsep(&p, sep));
3196 sstrsep(&p, sep);
3197
3198 d = atof(sstrsep(&p, sep));
3199 dsa_results[k][0] += d;
3200
3201 d = atof(sstrsep(&p, sep));
3202 dsa_results[k][1] += d;
3203 }
3204 # endif
3205 # ifndef OPENSSL_NO_EC
3206 else if (strncmp(buf, "+F4:", 4) == 0) {
3207 int k;
3208 double d;
3209
3210 p = buf + 4;
3211 k = atoi(sstrsep(&p, sep));
3212 sstrsep(&p, sep);
3213
3214 d = atof(sstrsep(&p, sep));
3215 ecdsa_results[k][0] += d;
3216
3217 d = atof(sstrsep(&p, sep));
3218 ecdsa_results[k][1] += d;
3219 } else if (strncmp(buf, "+F5:", 4) == 0) {
3220 int k;
3221 double d;
3222
3223 p = buf + 4;
3224 k = atoi(sstrsep(&p, sep));
3225 sstrsep(&p, sep);
3226
3227 d = atof(sstrsep(&p, sep));
3228 ecdh_results[k][0] += d;
3229 }
3230 # endif
3231
3232 else if (strncmp(buf, "+H:", 3) == 0) {
3233 ;
3234 } else
3235 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf,
3236 n);
3237 }
3238
3239 fclose(f);
3240 }
3241 free(fds);
3242 return 1;
3243 }
3244 #endif
3245
3246 static void multiblock_speed(const EVP_CIPHER *evp_cipher,
3247 const openssl_speed_sec_t *seconds)
3248 {
3249 static const int mblengths_list[] =
3250 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3251 const int *mblengths = mblengths_list;
3252 int j, count, keylen, num = OSSL_NELEM(mblengths_list);
3253 const char *alg_name;
3254 unsigned char *inp, *out, *key, no_key[32], no_iv[16];
3255 EVP_CIPHER_CTX *ctx;
3256 double d = 0.0;
3257
3258 if (lengths_single) {
3259 mblengths = &lengths_single;
3260 num = 1;
3261 }
3262
3263 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3264 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3265 ctx = EVP_CIPHER_CTX_new();
3266 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, NULL, no_iv);
3267
3268 keylen = EVP_CIPHER_CTX_key_length(ctx);
3269 key = app_malloc(keylen, "evp_cipher key");
3270 EVP_CIPHER_CTX_rand_key(ctx, key);
3271 EVP_EncryptInit_ex(ctx, NULL, NULL, key, NULL);
3272 OPENSSL_clear_free(key, keylen);
3273
3274 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key), no_key);
3275 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3276
3277 for (j = 0; j < num; j++) {
3278 print_message(alg_name, 0, mblengths[j], seconds->sym);
3279 Time_F(START);
3280 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3281 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3282 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3283 size_t len = mblengths[j];
3284 int packlen;
3285
3286 memset(aad, 0, 8); /* avoid uninitialized values */
3287 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
3288 aad[9] = 3; /* version */
3289 aad[10] = 2;
3290 aad[11] = 0; /* length */
3291 aad[12] = 0;
3292 mb_param.out = NULL;
3293 mb_param.inp = aad;
3294 mb_param.len = len;
3295 mb_param.interleave = 8;
3296
3297 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3298 sizeof(mb_param), &mb_param);
3299
3300 if (packlen > 0) {
3301 mb_param.out = out;
3302 mb_param.inp = inp;
3303 mb_param.len = len;
3304 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3305 sizeof(mb_param), &mb_param);
3306 } else {
3307 int pad;
3308
3309 RAND_bytes(out, 16);
3310 len += 16;
3311 aad[11] = (unsigned char)(len >> 8);
3312 aad[12] = (unsigned char)(len);
3313 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3314 EVP_AEAD_TLS1_AAD_LEN, aad);
3315 EVP_Cipher(ctx, out, inp, len + pad);
3316 }
3317 }
3318 d = Time_F(STOP);
3319 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3320 : "%d %s's in %.2fs\n", count, "evp", d);
3321 results[D_EVP][j] = ((double)count) / d * mblengths[j];
3322 }
3323
3324 if (mr) {
3325 fprintf(stdout, "+H");
3326 for (j = 0; j < num; j++)
3327 fprintf(stdout, ":%d", mblengths[j]);
3328 fprintf(stdout, "\n");
3329 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3330 for (j = 0; j < num; j++)
3331 fprintf(stdout, ":%.2f", results[D_EVP][j]);
3332 fprintf(stdout, "\n");
3333 } else {
3334 fprintf(stdout,
3335 "The 'numbers' are in 1000s of bytes per second processed.\n");
3336 fprintf(stdout, "type ");
3337 for (j = 0; j < num; j++)
3338 fprintf(stdout, "%7d bytes", mblengths[j]);
3339 fprintf(stdout, "\n");
3340 fprintf(stdout, "%-24s", alg_name);
3341
3342 for (j = 0; j < num; j++) {
3343 if (results[D_EVP][j] > 10000)
3344 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3345 else
3346 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3347 }
3348 fprintf(stdout, "\n");
3349 }
3350
3351 OPENSSL_free(inp);
3352 OPENSSL_free(out);
3353 EVP_CIPHER_CTX_free(ctx);
3354 }
A mirror of the official openssl repository