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