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