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