Small nits and cleanups
[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     size_t      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',
384      "Enable async mode and start pnum jobs"},
385 #endif
386 #ifndef OPENSSL_NO_ENGINE
387     {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
388 #endif
389     {NULL},
390 };
391
392 #define D_MD2           0
393 #define D_MDC2          1
394 #define D_MD4           2
395 #define D_MD5           3
396 #define D_HMAC          4
397 #define D_SHA1          5
398 #define D_RMD160        6
399 #define D_RC4           7
400 #define D_CBC_DES       8
401 #define D_EDE3_DES      9
402 #define D_CBC_IDEA      10
403 #define D_CBC_SEED      11
404 #define D_CBC_RC2       12
405 #define D_CBC_RC5       13
406 #define D_CBC_BF        14
407 #define D_CBC_CAST      15
408 #define D_CBC_128_AES   16
409 #define D_CBC_192_AES   17
410 #define D_CBC_256_AES   18
411 #define D_CBC_128_CML   19
412 #define D_CBC_192_CML   20
413 #define D_CBC_256_CML   21
414 #define D_EVP           22
415 #define D_SHA256        23
416 #define D_SHA512        24
417 #define D_WHIRLPOOL     25
418 #define D_IGE_128_AES   26
419 #define D_IGE_192_AES   27
420 #define D_IGE_256_AES   28
421 #define D_GHASH         29
422 static OPT_PAIR doit_choices[] = {
423 #ifndef OPENSSL_NO_MD2
424     {"md2", D_MD2},
425 #endif
426 #ifndef OPENSSL_NO_MDC2
427     {"mdc2", D_MDC2},
428 #endif
429 #ifndef OPENSSL_NO_MD4
430     {"md4", D_MD4},
431 #endif
432 #ifndef OPENSSL_NO_MD5
433     {"md5", D_MD5},
434     {"hmac", D_HMAC},
435 #endif
436     {"sha1", D_SHA1},
437     {"sha256", D_SHA256},
438     {"sha512", D_SHA512},
439 #ifndef OPENSSL_NO_WHIRLPOOL
440     {"whirlpool", D_WHIRLPOOL},
441 #endif
442 #ifndef OPENSSL_NO_RMD160
443     {"ripemd", D_RMD160},
444     {"rmd160", D_RMD160},
445     {"ripemd160", D_RMD160},
446 #endif
447 #ifndef OPENSSL_NO_RC4
448     {"rc4", D_RC4},
449 #endif
450 #ifndef OPENSSL_NO_DES
451     {"des-cbc", D_CBC_DES},
452     {"des-ede3", D_EDE3_DES},
453 #endif
454     {"aes-128-cbc", D_CBC_128_AES},
455     {"aes-192-cbc", D_CBC_192_AES},
456     {"aes-256-cbc", D_CBC_256_AES},
457     {"aes-128-ige", D_IGE_128_AES},
458     {"aes-192-ige", D_IGE_192_AES},
459     {"aes-256-ige", D_IGE_256_AES},
460 #ifndef OPENSSL_NO_RC2
461     {"rc2-cbc", D_CBC_RC2},
462     {"rc2", D_CBC_RC2},
463 #endif
464 #ifndef OPENSSL_NO_RC5
465     {"rc5-cbc", D_CBC_RC5},
466     {"rc5", D_CBC_RC5},
467 #endif
468 #ifndef OPENSSL_NO_IDEA
469     {"idea-cbc", D_CBC_IDEA},
470     {"idea", D_CBC_IDEA},
471 #endif
472 #ifndef OPENSSL_NO_SEED
473     {"seed-cbc", D_CBC_SEED},
474     {"seed", D_CBC_SEED},
475 #endif
476 #ifndef OPENSSL_NO_BF
477     {"bf-cbc", D_CBC_BF},
478     {"blowfish", D_CBC_BF},
479     {"bf", D_CBC_BF},
480 #endif
481 #ifndef OPENSSL_NO_CAST
482     {"cast-cbc", D_CBC_CAST},
483     {"cast", D_CBC_CAST},
484     {"cast5", D_CBC_CAST},
485 #endif
486     {"ghash", D_GHASH},
487     {NULL}
488 };
489
490 #ifndef OPENSSL_NO_DSA
491 # define R_DSA_512       0
492 # define R_DSA_1024      1
493 # define R_DSA_2048      2
494 static OPT_PAIR dsa_choices[] = {
495     {"dsa512", R_DSA_512},
496     {"dsa1024", R_DSA_1024},
497     {"dsa2048", R_DSA_2048},
498     {NULL},
499 };
500 #endif
501
502 #define R_RSA_512       0
503 #define R_RSA_1024      1
504 #define R_RSA_2048      2
505 #define R_RSA_3072      3
506 #define R_RSA_4096      4
507 #define R_RSA_7680      5
508 #define R_RSA_15360     6
509 static OPT_PAIR rsa_choices[] = {
510     {"rsa512", R_RSA_512},
511     {"rsa1024", R_RSA_1024},
512     {"rsa2048", R_RSA_2048},
513     {"rsa3072", R_RSA_3072},
514     {"rsa4096", R_RSA_4096},
515     {"rsa7680", R_RSA_7680},
516     {"rsa15360", R_RSA_15360},
517     {NULL}
518 };
519
520 #define R_EC_P160    0
521 #define R_EC_P192    1
522 #define R_EC_P224    2
523 #define R_EC_P256    3
524 #define R_EC_P384    4
525 #define R_EC_P521    5
526 #define R_EC_K163    6
527 #define R_EC_K233    7
528 #define R_EC_K283    8
529 #define R_EC_K409    9
530 #define R_EC_K571    10
531 #define R_EC_B163    11
532 #define R_EC_B233    12
533 #define R_EC_B283    13
534 #define R_EC_B409    14
535 #define R_EC_B571    15
536 #define R_EC_X25519  16
537 #ifndef OPENSSL_NO_EC
538 static OPT_PAIR ecdsa_choices[] = {
539     {"ecdsap160", R_EC_P160},
540     {"ecdsap192", R_EC_P192},
541     {"ecdsap224", R_EC_P224},
542     {"ecdsap256", R_EC_P256},
543     {"ecdsap384", R_EC_P384},
544     {"ecdsap521", R_EC_P521},
545     {"ecdsak163", R_EC_K163},
546     {"ecdsak233", R_EC_K233},
547     {"ecdsak283", R_EC_K283},
548     {"ecdsak409", R_EC_K409},
549     {"ecdsak571", R_EC_K571},
550     {"ecdsab163", R_EC_B163},
551     {"ecdsab233", R_EC_B233},
552     {"ecdsab283", R_EC_B283},
553     {"ecdsab409", R_EC_B409},
554     {"ecdsab571", R_EC_B571},
555     {NULL}
556 };
557
558 static OPT_PAIR ecdh_choices[] = {
559     {"ecdhp160", R_EC_P160},
560     {"ecdhp192", R_EC_P192},
561     {"ecdhp224", R_EC_P224},
562     {"ecdhp256", R_EC_P256},
563     {"ecdhp384", R_EC_P384},
564     {"ecdhp521", R_EC_P521},
565     {"ecdhk163", R_EC_K163},
566     {"ecdhk233", R_EC_K233},
567     {"ecdhk283", R_EC_K283},
568     {"ecdhk409", R_EC_K409},
569     {"ecdhk571", R_EC_K571},
570     {"ecdhb163", R_EC_B163},
571     {"ecdhb233", R_EC_B233},
572     {"ecdhb283", R_EC_B283},
573     {"ecdhb409", R_EC_B409},
574     {"ecdhb571", R_EC_B571},
575     {"ecdhx25519", R_EC_X25519},
576     {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;
1050     size_t outlen = tempargs->outlen;
1051     kdf_fn kdf = tempargs->kdf;
1052
1053     for (count = 0; COND(ecdh_c[testnum][0]); count++) {
1054         ECDH_compute_key(secret_a, outlen,
1055                 EC_KEY_get0_public_key(ecdh_b[testnum]),
1056                 ecdh_a[testnum], kdf);
1057     }
1058     return count;
1059 }
1060
1061 static const size_t KDF1_SHA1_len = 20;
1062 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
1063                        size_t *outlen)
1064 {
1065     if (*outlen < SHA_DIGEST_LENGTH)
1066         return NULL;
1067     *outlen = SHA_DIGEST_LENGTH;
1068     return SHA1(in, inlen, out);
1069 }
1070 #endif                          /* OPENSSL_NO_EC */
1071
1072 static int run_benchmark(int async_jobs,
1073                          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, i = 0, ret = 0;
1079     OSSL_ASYNC_FD job_fd = 0;
1080     size_t num_job_fds = 0;
1081
1082     run = 1;
1083
1084     if (async_jobs == 0) {
1085         return loop_function((void *)loopargs);
1086     }
1087
1088     for (i = 0; i < async_jobs && !error; i++) {
1089         ret = ASYNC_start_job(&loopargs[i].inprogress_job, loopargs[i].wait_ctx,
1090                               &job_op_count, loop_function,
1091                               (void *)(loopargs + i), sizeof(loopargs_t));
1092         switch (ret) {
1093         case ASYNC_PAUSE:
1094             ++num_inprogress;
1095             break;
1096         case ASYNC_FINISH:
1097             if (job_op_count == -1) {
1098                 error = 1;
1099             } else {
1100                 total_op_count += job_op_count;
1101             }
1102             break;
1103         case ASYNC_NO_JOBS:
1104         case ASYNC_ERR:
1105             BIO_printf(bio_err, "Failure in the job\n");
1106             ERR_print_errors(bio_err);
1107             error = 1;
1108             break;
1109         }
1110     }
1111
1112     while (num_inprogress > 0) {
1113 #if defined(OPENSSL_SYS_WINDOWS)
1114         DWORD avail = 0;
1115 #elif defined(OPENSSL_SYS_UNIX)
1116         int select_result = 0;
1117         OSSL_ASYNC_FD max_fd = 0;
1118         fd_set waitfdset;
1119
1120         FD_ZERO(&waitfdset);
1121
1122         for (i = 0; i < async_jobs && num_inprogress > 0; i++) {
1123             if (loopargs[i].inprogress_job == NULL)
1124                 continue;
1125
1126             if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1127                     || num_job_fds > 1) {
1128                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1129                 ERR_print_errors(bio_err);
1130                 error = 1;
1131                 break;
1132             }
1133             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1134             FD_SET(job_fd, &waitfdset);
1135             if (job_fd > max_fd)
1136                 max_fd = job_fd;
1137         }
1138
1139         if (max_fd >= (OSSL_ASYNC_FD)FD_SETSIZE) {
1140             BIO_printf(bio_err,
1141                     "Error: max_fd (%d) must be smaller than FD_SETSIZE (%d). "
1142                     "Decrease the value of async_jobs\n",
1143                     max_fd, FD_SETSIZE);
1144             ERR_print_errors(bio_err);
1145             error = 1;
1146             break;
1147         }
1148
1149         select_result = select(max_fd + 1, &waitfdset, NULL, NULL, NULL);
1150         if (select_result == -1 && errno == EINTR)
1151             continue;
1152
1153         if (select_result == -1) {
1154             BIO_printf(bio_err, "Failure in the select\n");
1155             ERR_print_errors(bio_err);
1156             error = 1;
1157             break;
1158         }
1159
1160         if (select_result == 0)
1161             continue;
1162 #endif
1163
1164         for (i = 0; i < async_jobs; i++) {
1165             if (loopargs[i].inprogress_job == NULL)
1166                 continue;
1167
1168             if (!ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, NULL, &num_job_fds)
1169                     || num_job_fds > 1) {
1170                 BIO_printf(bio_err, "Too many fds in ASYNC_WAIT_CTX\n");
1171                 ERR_print_errors(bio_err);
1172                 error = 1;
1173                 break;
1174             }
1175             ASYNC_WAIT_CTX_get_all_fds(loopargs[i].wait_ctx, &job_fd, &num_job_fds);
1176
1177 #if defined(OPENSSL_SYS_UNIX)
1178             if (num_job_fds == 1 && !FD_ISSET(job_fd, &waitfdset))
1179                 continue;
1180 #elif defined(OPENSSL_SYS_WINDOWS)
1181             if (num_job_fds == 1
1182                 && !PeekNamedPipe(job_fd, NULL, 0, NULL, &avail, NULL)
1183                 && avail > 0)
1184                 continue;
1185 #endif
1186
1187             ret = ASYNC_start_job(&loopargs[i].inprogress_job, 
1188                     loopargs[i].wait_ctx, &job_op_count, loop_function, 
1189                     (void *)(loopargs + i), sizeof(loopargs_t));
1190             switch (ret) {
1191             case ASYNC_PAUSE:
1192                 break;
1193             case ASYNC_FINISH:
1194                 if (job_op_count == -1) {
1195                     error = 1;
1196                 } else {
1197                     total_op_count += job_op_count;
1198                 }
1199                 --num_inprogress;
1200                 loopargs[i].inprogress_job = NULL;
1201                 break;
1202             case ASYNC_NO_JOBS:
1203             case ASYNC_ERR:
1204                 --num_inprogress;
1205                 loopargs[i].inprogress_job = NULL;
1206                 BIO_printf(bio_err, "Failure in the job\n");
1207                 ERR_print_errors(bio_err);
1208                 error = 1;
1209                 break;
1210             }
1211         }
1212     }
1213
1214     return error ? -1 : total_op_count;
1215 }
1216
1217 int speed_main(int argc, char **argv)
1218 {
1219     loopargs_t *loopargs = NULL;
1220     int async_init = 0;
1221     int loopargs_len = 0;
1222     char *prog;
1223 #ifndef OPENSSL_NO_ENGINE
1224     const char *engine_id = NULL;
1225 #endif
1226     const EVP_CIPHER *evp_cipher = NULL;
1227     double d = 0.0;
1228     OPTION_CHOICE o;
1229     int multiblock = 0, pr_header = 0;
1230     int doit[ALGOR_NUM] = { 0 };
1231     int ret = 1, i, k, misalign = 0;
1232     long count = 0;
1233 #ifndef NO_FORK
1234     int multi = 0;
1235 #endif
1236     int async_jobs = 0;
1237 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
1238     || !defined(OPENSSL_NO_EC)
1239     long rsa_count = 1;
1240 #endif
1241
1242     /* What follows are the buffers and key material. */
1243 #ifndef OPENSSL_NO_RC5
1244     RC5_32_KEY rc5_ks;
1245 #endif
1246 #ifndef OPENSSL_NO_RC2
1247     RC2_KEY rc2_ks;
1248 #endif
1249 #ifndef OPENSSL_NO_IDEA
1250     IDEA_KEY_SCHEDULE idea_ks;
1251 #endif
1252 #ifndef OPENSSL_NO_SEED
1253     SEED_KEY_SCHEDULE seed_ks;
1254 #endif
1255 #ifndef OPENSSL_NO_BF
1256     BF_KEY bf_ks;
1257 #endif
1258 #ifndef OPENSSL_NO_CAST
1259     CAST_KEY cast_ks;
1260 #endif
1261     static const unsigned char key16[16] = {
1262         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1263         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1264     };
1265     static const unsigned char key24[24] = {
1266         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1267         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1268         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1269     };
1270     static const unsigned char key32[32] = {
1271         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1272         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1273         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1274         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1275     };
1276 #ifndef OPENSSL_NO_CAMELLIA
1277     static const unsigned char ckey24[24] = {
1278         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1279         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1280         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1281     };
1282     static const unsigned char ckey32[32] = {
1283         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
1284         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
1285         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
1286         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
1287     };
1288     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
1289 #endif
1290 #ifndef OPENSSL_NO_DES
1291     static DES_cblock key = {
1292         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
1293     };
1294     static DES_cblock key2 = {
1295         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
1296     };
1297     static DES_cblock key3 = {
1298         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
1299     };
1300 #endif
1301 #ifndef OPENSSL_NO_RSA
1302     static const unsigned int rsa_bits[RSA_NUM] = {
1303         512, 1024, 2048, 3072, 4096, 7680, 15360
1304     };
1305     static const unsigned char *rsa_data[RSA_NUM] = {
1306         test512, test1024, test2048, test3072, test4096, test7680, test15360
1307     };
1308     static const int rsa_data_length[RSA_NUM] = {
1309         sizeof(test512), sizeof(test1024),
1310         sizeof(test2048), sizeof(test3072),
1311         sizeof(test4096), sizeof(test7680),
1312         sizeof(test15360)
1313     };
1314     int rsa_doit[RSA_NUM] = { 0 };
1315 #endif
1316 #ifndef OPENSSL_NO_DSA
1317     static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
1318     int dsa_doit[DSA_NUM] = { 0 };
1319 #endif
1320 #ifndef OPENSSL_NO_EC
1321     /*
1322      * We only test over the following curves as they are representative, To
1323      * add tests over more curves, simply add the curve NID and curve name to
1324      * the following arrays and increase the EC_NUM value accordingly.
1325      */
1326     static const unsigned int test_curves[EC_NUM] = {
1327         /* Prime Curves */
1328         NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
1329         NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
1330         /* Binary Curves */
1331         NID_sect163k1, NID_sect233k1, NID_sect283k1,
1332         NID_sect409k1, NID_sect571k1, NID_sect163r2,
1333         NID_sect233r1, NID_sect283r1, NID_sect409r1,
1334         NID_sect571r1,
1335         /* Other */
1336         NID_X25519
1337     };
1338     static const char *test_curves_names[EC_NUM] = {
1339         /* Prime Curves */
1340         "secp160r1", "nistp192", "nistp224",
1341         "nistp256", "nistp384", "nistp521",
1342         /* Binary Curves */
1343         "nistk163", "nistk233", "nistk283",
1344         "nistk409", "nistk571", "nistb163",
1345         "nistb233", "nistb283", "nistb409",
1346         "nistb571",
1347         /* Other */
1348         "X25519"
1349     };
1350     static const int test_curves_bits[EC_NUM] = {
1351         160, 192, 224,
1352         256, 384, 521,
1353         163, 233, 283,
1354         409, 571, 163,
1355         233, 283, 409,
1356         571, 253 /* X25519 */
1357     };
1358
1359     int ecdsa_doit[EC_NUM] = { 0 };
1360     int ecdh_doit[EC_NUM] = { 0 };
1361 #endif                          /* ndef OPENSSL_NO_EC */
1362
1363     prog = opt_init(argc, argv, speed_options);
1364     while ((o = opt_next()) != OPT_EOF) {
1365         switch (o) {
1366         case OPT_EOF:
1367         case OPT_ERR:
1368  opterr:
1369             BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
1370             goto end;
1371         case OPT_HELP:
1372             opt_help(speed_options);
1373             ret = 0;
1374             goto end;
1375         case OPT_ELAPSED:
1376             usertime = 0;
1377             break;
1378         case OPT_EVP:
1379             evp_cipher = EVP_get_cipherbyname(opt_arg());
1380             if (evp_cipher == NULL)
1381                 evp_md = EVP_get_digestbyname(opt_arg());
1382             if (evp_cipher == NULL && evp_md == NULL) {
1383                 BIO_printf(bio_err,
1384                            "%s: %s is an unknown cipher or digest\n",
1385                            prog, opt_arg());
1386                 goto end;
1387             }
1388             doit[D_EVP] = 1;
1389             break;
1390         case OPT_DECRYPT:
1391             decrypt = 1;
1392             break;
1393         case OPT_ENGINE:
1394             /*
1395              * In a forked execution, an engine might need to be
1396              * initialised by each child process, not by the parent.
1397              * So store the name here and run setup_engine() later on.
1398              */
1399 #ifndef OPENSSL_NO_ENGINE
1400             engine_id = opt_arg();
1401 #endif
1402             break;
1403         case OPT_MULTI:
1404 #ifndef NO_FORK
1405             multi = atoi(opt_arg());
1406 #endif
1407             break;
1408         case OPT_ASYNCJOBS:
1409 #ifndef OPENSSL_NO_ASYNC
1410             async_jobs = atoi(opt_arg());
1411             if (!ASYNC_is_capable()) {
1412                 BIO_printf(bio_err,
1413                            "%s: async_jobs specified but async not supported\n",
1414                            prog);
1415                 goto opterr;
1416             }
1417 #endif
1418             break;
1419         case OPT_MISALIGN:
1420             if (!opt_int(opt_arg(), &misalign))
1421                 goto end;
1422             if (misalign > MISALIGN) {
1423                 BIO_printf(bio_err,
1424                            "%s: Maximum offset is %d\n", prog, MISALIGN);
1425                 goto opterr;
1426             }
1427             break;
1428         case OPT_MR:
1429             mr = 1;
1430             break;
1431         case OPT_MB:
1432             multiblock = 1;
1433 #ifdef OPENSSL_NO_MULTIBLOCK
1434             BIO_printf(bio_err,
1435                        "%s: -mb specified but multi-block support is disabled\n",
1436                        prog);
1437             goto end;
1438 #endif
1439             break;
1440         }
1441     }
1442     argc = opt_num_rest();
1443     argv = opt_rest();
1444
1445     /* Remaining arguments are algorithms. */
1446     for ( ; *argv; argv++) {
1447         if (found(*argv, doit_choices, &i)) {
1448             doit[i] = 1;
1449             continue;
1450         }
1451 #ifndef OPENSSL_NO_DES
1452         if (strcmp(*argv, "des") == 0) {
1453             doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
1454             continue;
1455         }
1456 #endif
1457         if (strcmp(*argv, "sha") == 0) {
1458             doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
1459             continue;
1460         }
1461 #ifndef OPENSSL_NO_RSA
1462 # ifndef RSA_NULL
1463         if (strcmp(*argv, "openssl") == 0) {
1464             RSA_set_default_method(RSA_PKCS1_OpenSSL());
1465             continue;
1466         }
1467 # endif
1468         if (strcmp(*argv, "rsa") == 0) {
1469             rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
1470                 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
1471                 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
1472                 rsa_doit[R_RSA_15360] = 1;
1473             continue;
1474         }
1475         if (found(*argv, rsa_choices, &i)) {
1476             rsa_doit[i] = 1;
1477             continue;
1478         }
1479 #endif
1480 #ifndef OPENSSL_NO_DSA
1481         if (strcmp(*argv, "dsa") == 0) {
1482             dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
1483                 dsa_doit[R_DSA_2048] = 1;
1484             continue;
1485         }
1486         if (found(*argv, dsa_choices, &i)) {
1487             dsa_doit[i] = 2;
1488             continue;
1489         }
1490 #endif
1491         if (strcmp(*argv, "aes") == 0) {
1492             doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
1493                 doit[D_CBC_256_AES] = 1;
1494             continue;
1495         }
1496 #ifndef OPENSSL_NO_CAMELLIA
1497         if (strcmp(*argv, "camellia") == 0) {
1498             doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
1499                 doit[D_CBC_256_CML] = 1;
1500             continue;
1501         }
1502 #endif
1503 #ifndef OPENSSL_NO_EC
1504         if (strcmp(*argv, "ecdsa") == 0) {
1505             for (i = 0; i < EC_NUM; i++)
1506                 ecdsa_doit[i] = 1;
1507             continue;
1508         }
1509         if (found(*argv, ecdsa_choices, &i)) {
1510             ecdsa_doit[i] = 2;
1511             continue;
1512         }
1513         if (strcmp(*argv, "ecdh") == 0) {
1514             for (i = 0; i < EC_NUM; i++)
1515                 ecdh_doit[i] = 1;
1516             continue;
1517         }
1518         if (found(*argv, ecdh_choices, &i)) {
1519             ecdh_doit[i] = 2;
1520             continue;
1521         }
1522 #endif
1523         BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
1524         goto end;
1525     }
1526
1527     /* Initialize the job pool if async mode is enabled */
1528     if (async_jobs > 0) {
1529         async_init = ASYNC_init_thread(async_jobs, async_jobs);
1530         if (!async_init) {
1531             BIO_printf(bio_err, "Error creating the ASYNC job pool\n");
1532             goto end;
1533         }
1534     }
1535
1536     loopargs_len = (async_jobs == 0 ? 1 : async_jobs);
1537     loopargs = app_malloc(loopargs_len * sizeof(loopargs_t), "array of loopargs");
1538     memset(loopargs, 0, loopargs_len * sizeof(loopargs_t));
1539
1540     for (i = 0; i < loopargs_len; i++) {
1541         if (async_jobs > 0) {
1542             loopargs[i].wait_ctx = ASYNC_WAIT_CTX_new();
1543             if (loopargs[i].wait_ctx == NULL) {
1544                 BIO_printf(bio_err, "Error creating the ASYNC_WAIT_CTX\n");
1545                 goto end;
1546             }
1547         }
1548
1549         loopargs[i].buf_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1550         loopargs[i].buf2_malloc = app_malloc((int)BUFSIZE + MAX_MISALIGNMENT + 1, "input buffer");
1551         /* Align the start of buffers on a 64 byte boundary */
1552         loopargs[i].buf = loopargs[i].buf_malloc + misalign;
1553         loopargs[i].buf2 = loopargs[i].buf2_malloc + misalign;
1554 #ifndef OPENSSL_NO_EC
1555         loopargs[i].secret_a = app_malloc(MAX_ECDH_SIZE, "ECDH secret a");
1556         loopargs[i].secret_b = app_malloc(MAX_ECDH_SIZE, "ECDH secret b");
1557 #endif
1558     }
1559
1560 #ifndef NO_FORK
1561     if (multi && do_multi(multi))
1562         goto show_res;
1563 #endif
1564
1565     /* Initialize the engine after the fork */
1566     (void)setup_engine(engine_id, 0);
1567
1568     /* No parameters; turn on everything. */
1569     if ((argc == 0) && !doit[D_EVP]) {
1570         for (i = 0; i < ALGOR_NUM; i++)
1571             if (i != D_EVP)
1572                 doit[i] = 1;
1573 #ifndef OPENSSL_NO_RSA
1574         for (i = 0; i < RSA_NUM; i++)
1575             rsa_doit[i] = 1;
1576 #endif
1577 #ifndef OPENSSL_NO_DSA
1578         for (i = 0; i < DSA_NUM; i++)
1579             dsa_doit[i] = 1;
1580 #endif
1581 #ifndef OPENSSL_NO_EC
1582         for (i = 0; i < EC_NUM; i++)
1583             ecdsa_doit[i] = 1;
1584         for (i = 0; i < EC_NUM; i++)
1585             ecdh_doit[i] = 1;
1586 #endif
1587     }
1588     for (i = 0; i < ALGOR_NUM; i++)
1589         if (doit[i])
1590             pr_header++;
1591
1592     if (usertime == 0 && !mr)
1593         BIO_printf(bio_err,
1594                    "You have chosen to measure elapsed time "
1595                    "instead of user CPU time.\n");
1596
1597 #ifndef OPENSSL_NO_RSA
1598     for (i = 0; i < loopargs_len; i++) {
1599         for (k = 0; k < RSA_NUM; k++) {
1600             const unsigned char *p;
1601
1602             p = rsa_data[k];
1603             loopargs[i].rsa_key[k] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[k]);
1604             if (loopargs[i].rsa_key[k] == NULL) {
1605                 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1606                         k);
1607                 goto end;
1608             }
1609         }
1610     }
1611 #endif
1612 #ifndef OPENSSL_NO_DSA
1613     for (i = 0; i < loopargs_len; i++) {
1614         loopargs[i].dsa_key[0] = get_dsa512();
1615         loopargs[i].dsa_key[1] = get_dsa1024();
1616         loopargs[i].dsa_key[2] = get_dsa2048();
1617     }
1618 #endif
1619 #ifndef OPENSSL_NO_DES
1620     DES_set_key_unchecked(&key, &sch);
1621     DES_set_key_unchecked(&key2, &sch2);
1622     DES_set_key_unchecked(&key3, &sch3);
1623 #endif
1624     AES_set_encrypt_key(key16, 128, &aes_ks1);
1625     AES_set_encrypt_key(key24, 192, &aes_ks2);
1626     AES_set_encrypt_key(key32, 256, &aes_ks3);
1627 #ifndef OPENSSL_NO_CAMELLIA
1628     Camellia_set_key(key16, 128, &camellia_ks1);
1629     Camellia_set_key(ckey24, 192, &camellia_ks2);
1630     Camellia_set_key(ckey32, 256, &camellia_ks3);
1631 #endif
1632 #ifndef OPENSSL_NO_IDEA
1633     IDEA_set_encrypt_key(key16, &idea_ks);
1634 #endif
1635 #ifndef OPENSSL_NO_SEED
1636     SEED_set_key(key16, &seed_ks);
1637 #endif
1638 #ifndef OPENSSL_NO_RC4
1639     RC4_set_key(&rc4_ks, 16, key16);
1640 #endif
1641 #ifndef OPENSSL_NO_RC2
1642     RC2_set_key(&rc2_ks, 16, key16, 128);
1643 #endif
1644 #ifndef OPENSSL_NO_RC5
1645     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1646 #endif
1647 #ifndef OPENSSL_NO_BF
1648     BF_set_key(&bf_ks, 16, key16);
1649 #endif
1650 #ifndef OPENSSL_NO_CAST
1651     CAST_set_key(&cast_ks, 16, key16);
1652 #endif
1653 #ifndef SIGALRM
1654 # ifndef OPENSSL_NO_DES
1655     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1656     count = 10;
1657     do {
1658         long it;
1659         count *= 2;
1660         Time_F(START);
1661         for (it = count; it; it--)
1662             DES_ecb_encrypt((DES_cblock *)loopargs[0].buf,
1663                             (DES_cblock *)loopargs[0].buf, &sch, DES_ENCRYPT);
1664         d = Time_F(STOP);
1665     } while (d < 3);
1666     save_count = count;
1667     c[D_MD2][0] = count / 10;
1668     c[D_MDC2][0] = count / 10;
1669     c[D_MD4][0] = count;
1670     c[D_MD5][0] = count;
1671     c[D_HMAC][0] = count;
1672     c[D_SHA1][0] = count;
1673     c[D_RMD160][0] = count;
1674     c[D_RC4][0] = count * 5;
1675     c[D_CBC_DES][0] = count;
1676     c[D_EDE3_DES][0] = count / 3;
1677     c[D_CBC_IDEA][0] = count;
1678     c[D_CBC_SEED][0] = count;
1679     c[D_CBC_RC2][0] = count;
1680     c[D_CBC_RC5][0] = count;
1681     c[D_CBC_BF][0] = count;
1682     c[D_CBC_CAST][0] = count;
1683     c[D_CBC_128_AES][0] = count;
1684     c[D_CBC_192_AES][0] = count;
1685     c[D_CBC_256_AES][0] = count;
1686     c[D_CBC_128_CML][0] = count;
1687     c[D_CBC_192_CML][0] = count;
1688     c[D_CBC_256_CML][0] = count;
1689     c[D_SHA256][0] = count;
1690     c[D_SHA512][0] = count;
1691     c[D_WHIRLPOOL][0] = count;
1692     c[D_IGE_128_AES][0] = count;
1693     c[D_IGE_192_AES][0] = count;
1694     c[D_IGE_256_AES][0] = count;
1695     c[D_GHASH][0] = count;
1696
1697     for (i = 1; i < SIZE_NUM; i++) {
1698         long l0, l1;
1699
1700         l0 = (long)lengths[0];
1701         l1 = (long)lengths[i];
1702
1703         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1704         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1705         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1706         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1707         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1708         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1709         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1710         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1711         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1712         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1713         c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1714
1715         l0 = (long)lengths[i - 1];
1716
1717         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1718         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1719         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1720         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1721         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1722         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1723         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1724         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1725         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1726         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1727         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1728         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1729         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1730         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1731         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1732         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1733         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1734         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1735     }
1736
1737 #  ifndef OPENSSL_NO_RSA
1738     rsa_c[R_RSA_512][0] = count / 2000;
1739     rsa_c[R_RSA_512][1] = count / 400;
1740     for (i = 1; i < RSA_NUM; i++) {
1741         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1742         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1743         if (rsa_doit[i] <= 1 && rsa_c[i][0] == 0)
1744             rsa_doit[i] = 0;
1745         else {
1746             if (rsa_c[i][0] == 0) {
1747                 rsa_c[i][0] = 1;            /* Set minimum iteration Nb to 1. */
1748                 rsa_c[i][1] = 20;
1749             }
1750         }
1751     }
1752 #  endif
1753
1754 #  ifndef OPENSSL_NO_DSA
1755     dsa_c[R_DSA_512][0] = count / 1000;
1756     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1757     for (i = 1; i < DSA_NUM; i++) {
1758         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1759         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1760         if (dsa_doit[i] <= 1 && dsa_c[i][0] == 0)
1761             dsa_doit[i] = 0;
1762         else {
1763             if (dsa_c[i][0] == 0) {
1764                 dsa_c[i][0] = 1;            /* Set minimum iteration Nb to 1. */
1765                 dsa_c[i][1] = 1;
1766             }
1767         }
1768     }
1769 #  endif
1770
1771 #  ifndef OPENSSL_NO_EC
1772     ecdsa_c[R_EC_P160][0] = count / 1000;
1773     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1774     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1775         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1776         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1777         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1778             ecdsa_doit[i] = 0;
1779         else {
1780             if (ecdsa_c[i][0] == 0) {
1781                 ecdsa_c[i][0] = 1;
1782                 ecdsa_c[i][1] = 1;
1783             }
1784         }
1785     }
1786     ecdsa_c[R_EC_K163][0] = count / 1000;
1787     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1788     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1789         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1790         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1791         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1792             ecdsa_doit[i] = 0;
1793         else {
1794             if (ecdsa_c[i][0] == 0) {
1795                 ecdsa_c[i][0] = 1;
1796                 ecdsa_c[i][1] = 1;
1797             }
1798         }
1799     }
1800     ecdsa_c[R_EC_B163][0] = count / 1000;
1801     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1802     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1803         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1804         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1805         if (ecdsa_doit[i] <= 1 && ecdsa_c[i][0] == 0)
1806             ecdsa_doit[i] = 0;
1807         else {
1808             if (ecdsa_c[i][0] == 0) {
1809                 ecdsa_c[i][0] = 1;
1810                 ecdsa_c[i][1] = 1;
1811             }
1812         }
1813     }
1814
1815     ecdh_c[R_EC_P160][0] = count / 1000;
1816     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1817         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1818         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1819             ecdh_doit[i] = 0;
1820         else {
1821             if (ecdh_c[i][0] == 0) {
1822                 ecdh_c[i][0] = 1;
1823             }
1824         }
1825     }
1826     ecdh_c[R_EC_K163][0] = count / 1000;
1827     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1828         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1829         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1830             ecdh_doit[i] = 0;
1831         else {
1832             if (ecdh_c[i][0] == 0) {
1833                 ecdh_c[i][0] = 1;
1834             }
1835         }
1836     }
1837     ecdh_c[R_EC_B163][0] = count / 1000;
1838     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1839         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1840         if (ecdh_doit[i] <= 1 && ecdh_c[i][0] == 0)
1841             ecdh_doit[i] = 0;
1842         else {
1843             if (ecdh_c[i][0] == 0) {
1844                 ecdh_c[i][0] = 1;
1845             }
1846         }
1847     }
1848 #  endif
1849
1850 # else
1851 /* not worth fixing */
1852 #  error "You cannot disable DES on systems without SIGALRM."
1853 # endif                        /* OPENSSL_NO_DES */
1854 #else
1855 # ifndef _WIN32
1856     signal(SIGALRM, sig_done);
1857 # endif
1858 #endif                         /* SIGALRM */
1859
1860 #ifndef OPENSSL_NO_MD2
1861     if (doit[D_MD2]) {
1862         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1863             print_message(names[D_MD2], c[D_MD2][testnum], lengths[testnum]);
1864             Time_F(START);
1865             count = run_benchmark(async_jobs, EVP_Digest_MD2_loop, loopargs);
1866             d = Time_F(STOP);
1867             print_result(D_MD2, testnum, count, d);
1868         }
1869     }
1870 #endif
1871 #ifndef OPENSSL_NO_MDC2
1872     if (doit[D_MDC2]) {
1873         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1874             print_message(names[D_MDC2], c[D_MDC2][testnum], lengths[testnum]);
1875             Time_F(START);
1876             count = run_benchmark(async_jobs, EVP_Digest_MDC2_loop, loopargs);
1877             d = Time_F(STOP);
1878             print_result(D_MDC2, testnum, count, d);
1879         }
1880     }
1881 #endif
1882
1883 #ifndef OPENSSL_NO_MD4
1884     if (doit[D_MD4]) {
1885         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1886             print_message(names[D_MD4], c[D_MD4][testnum], lengths[testnum]);
1887             Time_F(START);
1888             count = run_benchmark(async_jobs, EVP_Digest_MD4_loop, loopargs);
1889             d = Time_F(STOP);
1890             print_result(D_MD4, testnum, count, d);
1891         }
1892     }
1893 #endif
1894
1895 #ifndef OPENSSL_NO_MD5
1896     if (doit[D_MD5]) {
1897         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1898             print_message(names[D_MD5], c[D_MD5][testnum], lengths[testnum]);
1899             Time_F(START);
1900             count = run_benchmark(async_jobs, MD5_loop, loopargs);
1901             d = Time_F(STOP);
1902             print_result(D_MD5, testnum, count, d);
1903         }
1904     }
1905
1906     if (doit[D_HMAC]) {
1907         static const char hmac_key[] = "This is a key...";
1908         int len = strlen(hmac_key);
1909
1910         for (i = 0; i < loopargs_len; i++) {
1911             loopargs[i].hctx = HMAC_CTX_new();
1912             if (loopargs[i].hctx == NULL) {
1913                 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1914                 exit(1);
1915             }
1916
1917             HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
1918         }
1919         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1920             print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
1921             Time_F(START);
1922             count = run_benchmark(async_jobs, HMAC_loop, loopargs);
1923             d = Time_F(STOP);
1924             print_result(D_HMAC, testnum, count, d);
1925         }
1926         for (i = 0; i < loopargs_len; i++) {
1927             HMAC_CTX_free(loopargs[i].hctx);
1928         }
1929     }
1930 #endif
1931     if (doit[D_SHA1]) {
1932         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1933             print_message(names[D_SHA1], c[D_SHA1][testnum], lengths[testnum]);
1934             Time_F(START);
1935             count = run_benchmark(async_jobs, SHA1_loop, loopargs);
1936             d = Time_F(STOP);
1937             print_result(D_SHA1, testnum, count, d);
1938         }
1939     }
1940     if (doit[D_SHA256]) {
1941         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1942             print_message(names[D_SHA256], c[D_SHA256][testnum], lengths[testnum]);
1943             Time_F(START);
1944             count = run_benchmark(async_jobs, SHA256_loop, loopargs);
1945             d = Time_F(STOP);
1946             print_result(D_SHA256, testnum, count, d);
1947         }
1948     }
1949     if (doit[D_SHA512]) {
1950         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1951             print_message(names[D_SHA512], c[D_SHA512][testnum], lengths[testnum]);
1952             Time_F(START);
1953             count = run_benchmark(async_jobs, SHA512_loop, loopargs);
1954             d = Time_F(STOP);
1955             print_result(D_SHA512, testnum, count, d);
1956         }
1957     }
1958
1959 #ifndef OPENSSL_NO_WHIRLPOOL
1960     if (doit[D_WHIRLPOOL]) {
1961         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1962             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][testnum], lengths[testnum]);
1963             Time_F(START);
1964             count = run_benchmark(async_jobs, WHIRLPOOL_loop, loopargs);
1965             d = Time_F(STOP);
1966             print_result(D_WHIRLPOOL, testnum, count, d);
1967         }
1968     }
1969 #endif
1970
1971 #ifndef OPENSSL_NO_RMD160
1972     if (doit[D_RMD160]) {
1973         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1974             print_message(names[D_RMD160], c[D_RMD160][testnum], lengths[testnum]);
1975             Time_F(START);
1976             count = run_benchmark(async_jobs, EVP_Digest_RMD160_loop, loopargs);
1977             d = Time_F(STOP);
1978             print_result(D_RMD160, testnum, count, d);
1979         }
1980     }
1981 #endif
1982 #ifndef OPENSSL_NO_RC4
1983     if (doit[D_RC4]) {
1984         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1985             print_message(names[D_RC4], c[D_RC4][testnum], lengths[testnum]);
1986             Time_F(START);
1987             count = run_benchmark(async_jobs, RC4_loop, loopargs);
1988             d = Time_F(STOP);
1989             print_result(D_RC4, testnum, count, d);
1990         }
1991     }
1992 #endif
1993 #ifndef OPENSSL_NO_DES
1994     if (doit[D_CBC_DES]) {
1995         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
1996             print_message(names[D_CBC_DES], c[D_CBC_DES][testnum], lengths[testnum]);
1997             Time_F(START);
1998             count = run_benchmark(async_jobs, DES_ncbc_encrypt_loop, loopargs);
1999             d = Time_F(STOP);
2000             print_result(D_CBC_DES, testnum, count, d);
2001         }
2002     }
2003
2004     if (doit[D_EDE3_DES]) {
2005         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2006             print_message(names[D_EDE3_DES], c[D_EDE3_DES][testnum], lengths[testnum]);
2007             Time_F(START);
2008             count = run_benchmark(async_jobs, DES_ede3_cbc_encrypt_loop, loopargs);
2009             d = Time_F(STOP);
2010             print_result(D_EDE3_DES, testnum, count, d);
2011         }
2012     }
2013 #endif
2014
2015     if (doit[D_CBC_128_AES]) {
2016         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2017             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][testnum],
2018                           lengths[testnum]);
2019             Time_F(START);
2020             count = run_benchmark(async_jobs, AES_cbc_128_encrypt_loop, loopargs);
2021             d = Time_F(STOP);
2022             print_result(D_CBC_128_AES, testnum, count, d);
2023         }
2024     }
2025     if (doit[D_CBC_192_AES]) {
2026         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2027             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][testnum],
2028                           lengths[testnum]);
2029             Time_F(START);
2030             count = run_benchmark(async_jobs, AES_cbc_192_encrypt_loop, loopargs);
2031             d = Time_F(STOP);
2032             print_result(D_CBC_192_AES, testnum, count, d);
2033         }
2034     }
2035     if (doit[D_CBC_256_AES]) {
2036         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2037             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][testnum],
2038                           lengths[testnum]);
2039             Time_F(START);
2040             count = run_benchmark(async_jobs, AES_cbc_256_encrypt_loop, loopargs);
2041             d = Time_F(STOP);
2042             print_result(D_CBC_256_AES, testnum, count, d);
2043         }
2044     }
2045
2046     if (doit[D_IGE_128_AES]) {
2047         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2048             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][testnum],
2049                           lengths[testnum]);
2050             Time_F(START);
2051             count = run_benchmark(async_jobs, AES_ige_128_encrypt_loop, loopargs);
2052             d = Time_F(STOP);
2053             print_result(D_IGE_128_AES, testnum, count, d);
2054         }
2055     }
2056     if (doit[D_IGE_192_AES]) {
2057         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2058             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][testnum],
2059                           lengths[testnum]);
2060             Time_F(START);
2061             count = run_benchmark(async_jobs, AES_ige_192_encrypt_loop, loopargs);
2062             d = Time_F(STOP);
2063             print_result(D_IGE_192_AES, testnum, count, d);
2064         }
2065     }
2066     if (doit[D_IGE_256_AES]) {
2067         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2068             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][testnum],
2069                           lengths[testnum]);
2070             Time_F(START);
2071             count = run_benchmark(async_jobs, AES_ige_256_encrypt_loop, loopargs);
2072             d = Time_F(STOP);
2073             print_result(D_IGE_256_AES, testnum, count, d);
2074         }
2075     }
2076     if (doit[D_GHASH]) {
2077         for (i = 0; i < loopargs_len; i++) {
2078             loopargs[i].gcm_ctx = CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
2079             CRYPTO_gcm128_setiv(loopargs[i].gcm_ctx, (unsigned char *)"0123456789ab", 12);
2080         }
2081
2082         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2083             print_message(names[D_GHASH], c[D_GHASH][testnum], lengths[testnum]);
2084             Time_F(START);
2085             count = run_benchmark(async_jobs, CRYPTO_gcm128_aad_loop, loopargs);
2086             d = Time_F(STOP);
2087             print_result(D_GHASH, testnum, count, d);
2088         }
2089         for (i = 0; i < loopargs_len; i++)
2090             CRYPTO_gcm128_release(loopargs[i].gcm_ctx);
2091     }
2092
2093 #ifndef OPENSSL_NO_CAMELLIA
2094     if (doit[D_CBC_128_CML]) {
2095         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2096             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][testnum],
2097                           lengths[testnum]);
2098             if (async_jobs > 0) {
2099                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2100                 exit(1);
2101             }
2102             Time_F(START);
2103             for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
2104                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2105                                      (size_t)lengths[testnum], &camellia_ks1,
2106                                      iv, CAMELLIA_ENCRYPT);
2107             d = Time_F(STOP);
2108             print_result(D_CBC_128_CML, testnum, count, d);
2109         }
2110     }
2111     if (doit[D_CBC_192_CML]) {
2112         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2113             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][testnum],
2114                           lengths[testnum]);
2115             if (async_jobs > 0) {
2116                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2117                 exit(1);
2118             }
2119             Time_F(START);
2120             for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
2121                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2122                                      (size_t)lengths[testnum], &camellia_ks2,
2123                                      iv, CAMELLIA_ENCRYPT);
2124             d = Time_F(STOP);
2125             print_result(D_CBC_192_CML, testnum, count, d);
2126         }
2127     }
2128     if (doit[D_CBC_256_CML]) {
2129         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2130             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][testnum],
2131                           lengths[testnum]);
2132             if (async_jobs > 0) {
2133                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2134                 exit(1);
2135             }
2136             Time_F(START);
2137             for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
2138                 Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2139                                      (size_t)lengths[testnum], &camellia_ks3,
2140                                      iv, CAMELLIA_ENCRYPT);
2141             d = Time_F(STOP);
2142             print_result(D_CBC_256_CML, testnum, count, d);
2143         }
2144     }
2145 #endif
2146 #ifndef OPENSSL_NO_IDEA
2147     if (doit[D_CBC_IDEA]) {
2148         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2149             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][testnum], lengths[testnum]);
2150             if (async_jobs > 0) {
2151                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2152                 exit(1);
2153             }
2154             Time_F(START);
2155             for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
2156                 IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2157                                  (size_t)lengths[testnum], &idea_ks,
2158                                  iv, IDEA_ENCRYPT);
2159             d = Time_F(STOP);
2160             print_result(D_CBC_IDEA, testnum, count, d);
2161         }
2162     }
2163 #endif
2164 #ifndef OPENSSL_NO_SEED
2165     if (doit[D_CBC_SEED]) {
2166         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2167             print_message(names[D_CBC_SEED], c[D_CBC_SEED][testnum], lengths[testnum]);
2168             if (async_jobs > 0) {
2169                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2170                 exit(1);
2171             }
2172             Time_F(START);
2173             for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
2174                 SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2175                                  (size_t)lengths[testnum], &seed_ks, iv, 1);
2176             d = Time_F(STOP);
2177             print_result(D_CBC_SEED, testnum, count, d);
2178         }
2179     }
2180 #endif
2181 #ifndef OPENSSL_NO_RC2
2182     if (doit[D_CBC_RC2]) {
2183         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2184             print_message(names[D_CBC_RC2], c[D_CBC_RC2][testnum], lengths[testnum]);
2185             if (async_jobs > 0) {
2186                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2187                 exit(1);
2188             }
2189             Time_F(START);
2190             for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
2191                 RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2192                                 (size_t)lengths[testnum], &rc2_ks,
2193                                 iv, RC2_ENCRYPT);
2194             d = Time_F(STOP);
2195             print_result(D_CBC_RC2, testnum, count, d);
2196         }
2197     }
2198 #endif
2199 #ifndef OPENSSL_NO_RC5
2200     if (doit[D_CBC_RC5]) {
2201         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2202             print_message(names[D_CBC_RC5], c[D_CBC_RC5][testnum], lengths[testnum]);
2203             if (async_jobs > 0) {
2204                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2205                 exit(1);
2206             }
2207             Time_F(START);
2208             for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
2209                 RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2210                                    (size_t)lengths[testnum], &rc5_ks,
2211                                    iv, RC5_ENCRYPT);
2212             d = Time_F(STOP);
2213             print_result(D_CBC_RC5, testnum, count, d);
2214         }
2215     }
2216 #endif
2217 #ifndef OPENSSL_NO_BF
2218     if (doit[D_CBC_BF]) {
2219         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2220             print_message(names[D_CBC_BF], c[D_CBC_BF][testnum], lengths[testnum]);
2221             if (async_jobs > 0) {
2222                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2223                 exit(1);
2224             }
2225             Time_F(START);
2226             for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
2227                 BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2228                                (size_t)lengths[testnum], &bf_ks,
2229                                iv, BF_ENCRYPT);
2230             d = Time_F(STOP);
2231             print_result(D_CBC_BF, testnum, count, d);
2232         }
2233     }
2234 #endif
2235 #ifndef OPENSSL_NO_CAST
2236     if (doit[D_CBC_CAST]) {
2237         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2238             print_message(names[D_CBC_CAST], c[D_CBC_CAST][testnum], lengths[testnum]);
2239             if (async_jobs > 0) {
2240                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2241                 exit(1);
2242             }
2243             Time_F(START);
2244             for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
2245                 CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
2246                                  (size_t)lengths[testnum], &cast_ks,
2247                                  iv, CAST_ENCRYPT);
2248             d = Time_F(STOP);
2249             print_result(D_CBC_CAST, testnum, count, d);
2250         }
2251     }
2252 #endif
2253
2254     if (doit[D_EVP]) {
2255 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
2256         if (multiblock && evp_cipher) {
2257             if (!
2258                 (EVP_CIPHER_flags(evp_cipher) &
2259                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
2260                 BIO_printf(bio_err, "%s is not multi-block capable\n",
2261                            OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
2262                 goto end;
2263             }
2264             if (async_jobs > 0) {
2265                 BIO_printf(bio_err, "Async mode is not supported, exiting...");
2266                 exit(1);
2267             }
2268             multiblock_speed(evp_cipher);
2269             ret = 0;
2270             goto end;
2271         }
2272 #endif
2273         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2274             if (evp_cipher) {
2275
2276                 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2277                 /*
2278                  * -O3 -fschedule-insns messes up an optimization here!
2279                  * names[D_EVP] somehow becomes NULL
2280                  */
2281                 print_message(names[D_EVP], save_count, lengths[testnum]);
2282
2283                 for (k = 0; k < loopargs_len; k++) {
2284                     loopargs[k].ctx = EVP_CIPHER_CTX_new();
2285                     if (decrypt)
2286                         EVP_DecryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2287                     else
2288                         EVP_EncryptInit_ex(loopargs[k].ctx, evp_cipher, NULL, key16, iv);
2289                     EVP_CIPHER_CTX_set_padding(loopargs[k].ctx, 0);
2290                 }
2291
2292                 Time_F(START);
2293                 count = run_benchmark(async_jobs, EVP_Update_loop, loopargs);
2294                 d = Time_F(STOP);
2295                 for (k = 0; k < loopargs_len; k++) {
2296                     EVP_CIPHER_CTX_free(loopargs[k].ctx);
2297                 }
2298             }
2299             if (evp_md) {
2300                 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
2301                 print_message(names[D_EVP], save_count, lengths[testnum]);
2302                 Time_F(START);
2303                 count = run_benchmark(async_jobs, EVP_Digest_loop, loopargs);
2304                 d = Time_F(STOP);
2305             }
2306             print_result(D_EVP, testnum, count, d);
2307         }
2308     }
2309
2310     for (i = 0; i < loopargs_len; i++)
2311         RAND_bytes(loopargs[i].buf, 36);
2312
2313 #ifndef OPENSSL_NO_RSA
2314     for (testnum = 0; testnum < RSA_NUM; testnum++) {
2315         int st = 0;
2316         if (!rsa_doit[testnum])
2317             continue;
2318         for (i = 0; i < loopargs_len; i++) {
2319             st = RSA_sign(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2320                           &loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2321             if (st == 0)
2322                 break;
2323         }
2324         if (st == 0) {
2325             BIO_printf(bio_err,
2326                        "RSA sign failure.  No RSA sign will be done.\n");
2327             ERR_print_errors(bio_err);
2328             rsa_count = 1;
2329         } else {
2330             pkey_print_message("private", "rsa",
2331                                rsa_c[testnum][0], rsa_bits[testnum], RSA_SECONDS);
2332             /* RSA_blinding_on(rsa_key[testnum],NULL); */
2333             Time_F(START);
2334             count = run_benchmark(async_jobs, RSA_sign_loop, loopargs);
2335             d = Time_F(STOP);
2336             BIO_printf(bio_err,
2337                        mr ? "+R1:%ld:%d:%.2f\n"
2338                        : "%ld %d bit private RSA's in %.2fs\n",
2339                        count, rsa_bits[testnum], d);
2340             rsa_results[testnum][0] = d / (double)count;
2341             rsa_count = count;
2342         }
2343
2344         for (i = 0; i < loopargs_len; i++) {
2345             st = RSA_verify(NID_md5_sha1, loopargs[i].buf, 36, loopargs[i].buf2,
2346                             loopargs[i].siglen, loopargs[i].rsa_key[testnum]);
2347             if (st <= 0)
2348                 break;
2349         }
2350         if (st <= 0) {
2351             BIO_printf(bio_err,
2352                        "RSA verify failure.  No RSA verify will be done.\n");
2353             ERR_print_errors(bio_err);
2354             rsa_doit[testnum] = 0;
2355         } else {
2356             pkey_print_message("public", "rsa",
2357                                rsa_c[testnum][1], rsa_bits[testnum], RSA_SECONDS);
2358             Time_F(START);
2359             count = run_benchmark(async_jobs, RSA_verify_loop, loopargs);
2360             d = Time_F(STOP);
2361             BIO_printf(bio_err,
2362                        mr ? "+R2:%ld:%d:%.2f\n"
2363                        : "%ld %d bit public RSA's in %.2fs\n",
2364                        count, rsa_bits[testnum], d);
2365             rsa_results[testnum][1] = d / (double)count;
2366         }
2367
2368         if (rsa_count <= 1) {
2369             /* if longer than 10s, don't do any more */
2370             for (testnum++; testnum < RSA_NUM; testnum++)
2371                 rsa_doit[testnum] = 0;
2372         }
2373     }
2374 #endif                          /* OPENSSL_NO_RSA */
2375
2376     for (i = 0; i < loopargs_len; i++)
2377         RAND_bytes(loopargs[i].buf, 36);
2378
2379 #ifndef OPENSSL_NO_DSA
2380     if (RAND_status() != 1) {
2381         RAND_seed(rnd_seed, sizeof rnd_seed);
2382     }
2383     for (testnum = 0; testnum < DSA_NUM; testnum++) {
2384         int st = 0;
2385         if (!dsa_doit[testnum])
2386             continue;
2387
2388         /* DSA_generate_key(dsa_key[testnum]); */
2389         /* DSA_sign_setup(dsa_key[testnum],NULL); */
2390         for (i = 0; i < loopargs_len; i++) {
2391             st = DSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2392                           &loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2393             if (st == 0)
2394                 break;
2395         }
2396         if (st == 0) {
2397             BIO_printf(bio_err,
2398                        "DSA sign failure.  No DSA sign will be done.\n");
2399             ERR_print_errors(bio_err);
2400             rsa_count = 1;
2401         } else {
2402             pkey_print_message("sign", "dsa",
2403                                dsa_c[testnum][0], dsa_bits[testnum], DSA_SECONDS);
2404             Time_F(START);
2405             count = run_benchmark(async_jobs, DSA_sign_loop, loopargs);
2406             d = Time_F(STOP);
2407             BIO_printf(bio_err,
2408                        mr ? "+R3:%ld:%d:%.2f\n"
2409                        : "%ld %d bit DSA signs in %.2fs\n",
2410                        count, dsa_bits[testnum], d);
2411             dsa_results[testnum][0] = d / (double)count;
2412             rsa_count = count;
2413         }
2414
2415         for (i = 0; i < loopargs_len; i++) {
2416             st = DSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2417                             loopargs[i].siglen, loopargs[i].dsa_key[testnum]);
2418             if (st <= 0)
2419                 break;
2420         }
2421         if (st <= 0) {
2422             BIO_printf(bio_err,
2423                        "DSA verify failure.  No DSA verify will be done.\n");
2424             ERR_print_errors(bio_err);
2425             dsa_doit[testnum] = 0;
2426         } else {
2427             pkey_print_message("verify", "dsa",
2428                                dsa_c[testnum][1], dsa_bits[testnum], DSA_SECONDS);
2429             Time_F(START);
2430             count = run_benchmark(async_jobs, DSA_verify_loop, loopargs);
2431             d = Time_F(STOP);
2432             BIO_printf(bio_err,
2433                        mr ? "+R4:%ld:%d:%.2f\n"
2434                        : "%ld %d bit DSA verify in %.2fs\n",
2435                        count, dsa_bits[testnum], d);
2436             dsa_results[testnum][1] = d / (double)count;
2437         }
2438
2439         if (rsa_count <= 1) {
2440             /* if longer than 10s, don't do any more */
2441             for (testnum++; testnum < DSA_NUM; testnum++)
2442                 dsa_doit[testnum] = 0;
2443         }
2444     }
2445 #endif                          /* OPENSSL_NO_DSA */
2446
2447 #ifndef OPENSSL_NO_EC
2448     if (RAND_status() != 1) {
2449         RAND_seed(rnd_seed, sizeof rnd_seed);
2450     }
2451     for (testnum = 0; testnum < EC_NUM; testnum++) {
2452         int st = 1;
2453
2454         if (!ecdsa_doit[testnum])
2455             continue;           /* Ignore Curve */
2456         for (i = 0; i < loopargs_len; i++) {
2457             loopargs[i].ecdsa[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2458             if (loopargs[i].ecdsa[testnum] == NULL) {
2459                 st = 0;
2460                 break;
2461             }
2462         }
2463         if (st == 0) {
2464             BIO_printf(bio_err, "ECDSA failure.\n");
2465             ERR_print_errors(bio_err);
2466             rsa_count = 1;
2467         } else {
2468             for (i = 0; i < loopargs_len; i++) {
2469                 EC_KEY_precompute_mult(loopargs[i].ecdsa[testnum], NULL);
2470                 /* Perform ECDSA signature test */
2471                 EC_KEY_generate_key(loopargs[i].ecdsa[testnum]);
2472                 st = ECDSA_sign(0, loopargs[i].buf, 20, loopargs[i].buf2,
2473                                 &loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2474                 if (st == 0)
2475                     break;
2476             }
2477             if (st == 0) {
2478                 BIO_printf(bio_err,
2479                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
2480                 ERR_print_errors(bio_err);
2481                 rsa_count = 1;
2482             } else {
2483                 pkey_print_message("sign", "ecdsa",
2484                                    ecdsa_c[testnum][0],
2485                                    test_curves_bits[testnum], ECDSA_SECONDS);
2486                 Time_F(START);
2487                 count = run_benchmark(async_jobs, ECDSA_sign_loop, loopargs);
2488                 d = Time_F(STOP);
2489
2490                 BIO_printf(bio_err,
2491                            mr ? "+R5:%ld:%d:%.2f\n" :
2492                            "%ld %d bit ECDSA signs in %.2fs \n",
2493                            count, test_curves_bits[testnum], d);
2494                 ecdsa_results[testnum][0] = d / (double)count;
2495                 rsa_count = count;
2496             }
2497
2498             /* Perform ECDSA verification test */
2499             for (i = 0; i < loopargs_len; i++) {
2500                 st = ECDSA_verify(0, loopargs[i].buf, 20, loopargs[i].buf2,
2501                                   loopargs[i].siglen, loopargs[i].ecdsa[testnum]);
2502                 if (st != 1)
2503                     break;
2504             }
2505             if (st != 1) {
2506                 BIO_printf(bio_err,
2507                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
2508                 ERR_print_errors(bio_err);
2509                 ecdsa_doit[testnum] = 0;
2510             } else {
2511                 pkey_print_message("verify", "ecdsa",
2512                                    ecdsa_c[testnum][1],
2513                                    test_curves_bits[testnum], ECDSA_SECONDS);
2514                 Time_F(START);
2515                 count = run_benchmark(async_jobs, ECDSA_verify_loop, loopargs);
2516                 d = Time_F(STOP);
2517                 BIO_printf(bio_err,
2518                            mr ? "+R6:%ld:%d:%.2f\n"
2519                            : "%ld %d bit ECDSA verify in %.2fs\n",
2520                            count, test_curves_bits[testnum], d);
2521                 ecdsa_results[testnum][1] = d / (double)count;
2522             }
2523
2524             if (rsa_count <= 1) {
2525                 /* if longer than 10s, don't do any more */
2526                 for (testnum++; testnum < EC_NUM; testnum++)
2527                     ecdsa_doit[testnum] = 0;
2528             }
2529         }
2530     }
2531
2532     if (RAND_status() != 1) {
2533         RAND_seed(rnd_seed, sizeof rnd_seed);
2534     }
2535     for (testnum = 0; testnum < EC_NUM; testnum++) {
2536         int ecdh_checks = 1;
2537
2538         if (!ecdh_doit[testnum])
2539             continue;
2540         for (i = 0; i < loopargs_len; i++) {
2541             loopargs[i].ecdh_a[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2542             loopargs[i].ecdh_b[testnum] = EC_KEY_new_by_curve_name(test_curves[testnum]);
2543             if (loopargs[i].ecdh_a[testnum] == NULL ||
2544                 loopargs[i].ecdh_b[testnum] == NULL) {
2545                 ecdh_checks = 0;
2546                 break;
2547             }
2548         }
2549         if (ecdh_checks == 0) {
2550             BIO_printf(bio_err, "ECDH failure.\n");
2551             ERR_print_errors(bio_err);
2552             rsa_count = 1;
2553         } else {
2554             for (i = 0; i < loopargs_len; i++) {
2555                 /* generate two ECDH key pairs */
2556                 if (!EC_KEY_generate_key(loopargs[i].ecdh_a[testnum]) ||
2557                         !EC_KEY_generate_key(loopargs[i].ecdh_b[testnum])) {
2558                     BIO_printf(bio_err, "ECDH key generation failure.\n");
2559                     ERR_print_errors(bio_err);
2560                     ecdh_checks = 0;
2561                     rsa_count = 1;
2562                 } else {
2563                     int secret_size_a, secret_size_b;
2564                     /*
2565                      * If field size is not more than 24 octets, then use SHA-1
2566                      * hash of result; otherwise, use result (see section 4.8 of
2567                      * draft-ietf-tls-ecc-03.txt).
2568                      */
2569                     int field_size = EC_GROUP_get_degree(
2570                             EC_KEY_get0_group(loopargs[i].ecdh_a[testnum]));
2571
2572                     if (field_size <= 24 * 8) {                 /* 192 bits */
2573                         loopargs[i].outlen = KDF1_SHA1_len;
2574                         loopargs[i].kdf = KDF1_SHA1;
2575                     } else {
2576                         loopargs[i].outlen = (field_size + 7) / 8;
2577                         loopargs[i].kdf = NULL;
2578                     }
2579                     secret_size_a =
2580                         ECDH_compute_key(loopargs[i].secret_a, loopargs[i].outlen,
2581                                 EC_KEY_get0_public_key(loopargs[i].ecdh_b[testnum]),
2582                                 loopargs[i].ecdh_a[testnum], loopargs[i].kdf);
2583                     secret_size_b =
2584                         ECDH_compute_key(loopargs[i].secret_b, loopargs[i].outlen,
2585                                 EC_KEY_get0_public_key(loopargs[i].ecdh_a[testnum]),
2586                                 loopargs[i].ecdh_b[testnum], loopargs[i].kdf);
2587                     if (secret_size_a != secret_size_b)
2588                         ecdh_checks = 0;
2589                     else
2590                         ecdh_checks = 1;
2591
2592                     for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
2593                         if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
2594                             ecdh_checks = 0;
2595                     }
2596
2597                     if (ecdh_checks == 0) {
2598                         BIO_printf(bio_err, "ECDH computations don't match.\n");
2599                         ERR_print_errors(bio_err);
2600                         rsa_count = 1;
2601                         break;
2602                     }
2603                 }
2604             }
2605             if (ecdh_checks != 0) {
2606                 pkey_print_message("", "ecdh",
2607                         ecdh_c[testnum][0],
2608                         test_curves_bits[testnum], ECDH_SECONDS);
2609                 Time_F(START);
2610                 count = run_benchmark(async_jobs, ECDH_compute_key_loop, loopargs);
2611                 d = Time_F(STOP);
2612                 BIO_printf(bio_err,
2613                         mr ? "+R7:%ld:%d:%.2f\n" :
2614                         "%ld %d-bit ECDH ops in %.2fs\n", count,
2615                         test_curves_bits[testnum], d);
2616                 ecdh_results[testnum][0] = d / (double)count;
2617                 rsa_count = count;
2618             }
2619         }
2620
2621         if (rsa_count <= 1) {
2622             /* if longer than 10s, don't do any more */
2623             for (testnum++; testnum < EC_NUM; testnum++)
2624                 ecdh_doit[testnum] = 0;
2625         }
2626     }
2627 #endif                          /* OPENSSL_NO_EC */
2628 #ifndef NO_FORK
2629  show_res:
2630 #endif
2631     if (!mr) {
2632         printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2633         printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2634         printf("options:");
2635         printf("%s ", BN_options());
2636 #ifndef OPENSSL_NO_MD2
2637         printf("%s ", MD2_options());
2638 #endif
2639 #ifndef OPENSSL_NO_RC4
2640         printf("%s ", RC4_options());
2641 #endif
2642 #ifndef OPENSSL_NO_DES
2643         printf("%s ", DES_options());
2644 #endif
2645         printf("%s ", AES_options());
2646 #ifndef OPENSSL_NO_IDEA
2647         printf("%s ", IDEA_options());
2648 #endif
2649 #ifndef OPENSSL_NO_BF
2650         printf("%s ", BF_options());
2651 #endif
2652         printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2653     }
2654
2655     if (pr_header) {
2656         if (mr)
2657             printf("+H");
2658         else {
2659             printf
2660                 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2661             printf("type        ");
2662         }
2663         for (testnum = 0; testnum < SIZE_NUM; testnum++)
2664             printf(mr ? ":%d" : "%7d bytes", lengths[testnum]);
2665         printf("\n");
2666     }
2667
2668     for (k = 0; k < ALGOR_NUM; k++) {
2669         if (!doit[k])
2670             continue;
2671         if (mr)
2672             printf("+F:%d:%s", k, names[k]);
2673         else
2674             printf("%-13s", names[k]);
2675         for (testnum = 0; testnum < SIZE_NUM; testnum++) {
2676             if (results[k][testnum] > 10000 && !mr)
2677                 printf(" %11.2fk", results[k][testnum] / 1e3);
2678             else
2679                 printf(mr ? ":%.2f" : " %11.2f ", results[k][testnum]);
2680         }
2681         printf("\n");
2682     }
2683 #ifndef OPENSSL_NO_RSA
2684     testnum = 1;
2685     for (k = 0; k < RSA_NUM; k++) {
2686         if (!rsa_doit[k])
2687             continue;
2688         if (testnum && !mr) {
2689             printf("%18ssign    verify    sign/s verify/s\n", " ");
2690             testnum = 0;
2691         }
2692         if (mr)
2693             printf("+F2:%u:%u:%f:%f\n",
2694                    k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2695         else
2696             printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2697                    rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2698                    1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2699     }
2700 #endif
2701 #ifndef OPENSSL_NO_DSA
2702     testnum = 1;
2703     for (k = 0; k < DSA_NUM; k++) {
2704         if (!dsa_doit[k])
2705             continue;
2706         if (testnum && !mr) {
2707             printf("%18ssign    verify    sign/s verify/s\n", " ");
2708             testnum = 0;
2709         }
2710         if (mr)
2711             printf("+F3:%u:%u:%f:%f\n",
2712                    k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2713         else
2714             printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2715                    dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2716                    1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2717     }
2718 #endif
2719 #ifndef OPENSSL_NO_EC
2720     testnum = 1;
2721     for (k = 0; k < EC_NUM; k++) {
2722         if (!ecdsa_doit[k])
2723             continue;
2724         if (testnum && !mr) {
2725             printf("%30ssign    verify    sign/s verify/s\n", " ");
2726             testnum = 0;
2727         }
2728
2729         if (mr)
2730             printf("+F4:%u:%u:%f:%f\n",
2731                    k, test_curves_bits[k],
2732                    ecdsa_results[k][0], ecdsa_results[k][1]);
2733         else
2734             printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2735                    test_curves_bits[k],
2736                    test_curves_names[k],
2737                    ecdsa_results[k][0], ecdsa_results[k][1],
2738                    1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2739     }
2740
2741     testnum = 1;
2742     for (k = 0; k < EC_NUM; k++) {
2743         if (!ecdh_doit[k])
2744             continue;
2745         if (testnum && !mr) {
2746             printf("%30sop      op/s\n", " ");
2747             testnum = 0;
2748         }
2749         if (mr)
2750             printf("+F5:%u:%u:%f:%f\n",
2751                    k, test_curves_bits[k],
2752                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2753
2754         else
2755             printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2756                    test_curves_bits[k],
2757                    test_curves_names[k],
2758                    ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2759     }
2760 #endif
2761
2762     ret = 0;
2763
2764  end:
2765     ERR_print_errors(bio_err);
2766     for (i = 0; i < loopargs_len; i++) {
2767         OPENSSL_free(loopargs[i].buf_malloc);
2768         OPENSSL_free(loopargs[i].buf2_malloc);
2769
2770 #ifndef OPENSSL_NO_RSA
2771         for (k = 0; k < RSA_NUM; k++)
2772             RSA_free(loopargs[i].rsa_key[k]);
2773 #endif
2774 #ifndef OPENSSL_NO_DSA
2775         for (k = 0; k < DSA_NUM; k++)
2776             DSA_free(loopargs[i].dsa_key[k]);
2777 #endif
2778 #ifndef OPENSSL_NO_EC
2779         for (k = 0; k < EC_NUM; k++) {
2780             EC_KEY_free(loopargs[i].ecdsa[k]);
2781             EC_KEY_free(loopargs[i].ecdh_a[k]);
2782             EC_KEY_free(loopargs[i].ecdh_b[k]);
2783         }
2784         OPENSSL_free(loopargs[i].secret_a);
2785         OPENSSL_free(loopargs[i].secret_b);
2786 #endif
2787     }
2788
2789     if (async_jobs > 0) {
2790         for (i = 0; i < loopargs_len; i++)
2791             ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
2792     }
2793
2794     if (async_init) {
2795         ASYNC_cleanup_thread();
2796     }
2797     OPENSSL_free(loopargs);
2798     return (ret);
2799 }
2800
2801 static void print_message(const char *s, long num, int length)
2802 {
2803 #ifdef SIGALRM
2804     BIO_printf(bio_err,
2805                mr ? "+DT:%s:%d:%d\n"
2806                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2807     (void)BIO_flush(bio_err);
2808     alarm(SECONDS);
2809 #else
2810     BIO_printf(bio_err,
2811                mr ? "+DN:%s:%ld:%d\n"
2812                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2813     (void)BIO_flush(bio_err);
2814 #endif
2815 }
2816
2817 static void pkey_print_message(const char *str, const char *str2, long num,
2818                                int bits, int tm)
2819 {
2820 #ifdef SIGALRM
2821     BIO_printf(bio_err,
2822                mr ? "+DTP:%d:%s:%s:%d\n"
2823                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2824     (void)BIO_flush(bio_err);
2825     alarm(tm);
2826 #else
2827     BIO_printf(bio_err,
2828                mr ? "+DNP:%ld:%d:%s:%s\n"
2829                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2830     (void)BIO_flush(bio_err);
2831 #endif
2832 }
2833
2834 static void print_result(int alg, int run_no, int count, double time_used)
2835 {
2836     if (count == -1) {
2837         BIO_puts(bio_err, "EVP error!\n");
2838         exit(1);
2839     }
2840     BIO_printf(bio_err,
2841                mr ? "+R:%d:%s:%f\n"
2842                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2843     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2844 }
2845
2846 #ifndef NO_FORK
2847 static char *sstrsep(char **string, const char *delim)
2848 {
2849     char isdelim[256];
2850     char *token = *string;
2851
2852     if (**string == 0)
2853         return NULL;
2854
2855     memset(isdelim, 0, sizeof isdelim);
2856     isdelim[0] = 1;
2857
2858     while (*delim) {
2859         isdelim[(unsigned char)(*delim)] = 1;
2860         delim++;
2861     }
2862
2863     while (!isdelim[(unsigned char)(**string)]) {
2864         (*string)++;
2865     }
2866
2867     if (**string) {
2868         **string = 0;
2869         (*string)++;
2870     }
2871
2872     return token;
2873 }
2874
2875 static int do_multi(int multi)
2876 {
2877     int n;
2878     int fd[2];
2879     int *fds;
2880     static char sep[] = ":";
2881
2882     fds = malloc(sizeof(*fds) * multi);
2883     for (n = 0; n < multi; ++n) {
2884         if (pipe(fd) == -1) {
2885             BIO_printf(bio_err, "pipe failure\n");
2886             exit(1);
2887         }
2888         fflush(stdout);
2889         (void)BIO_flush(bio_err);
2890         if (fork()) {
2891             close(fd[1]);
2892             fds[n] = fd[0];
2893         } else {
2894             close(fd[0]);
2895             close(1);
2896             if (dup(fd[1]) == -1) {
2897                 BIO_printf(bio_err, "dup failed\n");
2898                 exit(1);
2899             }
2900             close(fd[1]);
2901             mr = 1;
2902             usertime = 0;
2903             free(fds);
2904             return 0;
2905         }
2906         printf("Forked child %d\n", n);
2907     }
2908
2909     /* for now, assume the pipe is long enough to take all the output */
2910     for (n = 0; n < multi; ++n) {
2911         FILE *f;
2912         char buf[1024];
2913         char *p;
2914
2915         f = fdopen(fds[n], "r");
2916         while (fgets(buf, sizeof buf, f)) {
2917             p = strchr(buf, '\n');
2918             if (p)
2919                 *p = '\0';
2920             if (buf[0] != '+') {
2921                 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2922                         buf, n);
2923                 continue;
2924             }
2925             printf("Got: %s from %d\n", buf, n);
2926             if (strncmp(buf, "+F:", 3) == 0) {
2927                 int alg;
2928                 int j;
2929
2930                 p = buf + 3;
2931                 alg = atoi(sstrsep(&p, sep));
2932                 sstrsep(&p, sep);
2933                 for (j = 0; j < SIZE_NUM; ++j)
2934                     results[alg][j] += atof(sstrsep(&p, sep));
2935             } else if (strncmp(buf, "+F2:", 4) == 0) {
2936                 int k;
2937                 double d;
2938
2939                 p = buf + 4;
2940                 k = atoi(sstrsep(&p, sep));
2941                 sstrsep(&p, sep);
2942
2943                 d = atof(sstrsep(&p, sep));
2944                 if (n)
2945                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2946                 else
2947                     rsa_results[k][0] = d;
2948
2949                 d = atof(sstrsep(&p, sep));
2950                 if (n)
2951                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2952                 else
2953                     rsa_results[k][1] = d;
2954             }
2955 # ifndef OPENSSL_NO_DSA
2956             else if (strncmp(buf, "+F3:", 4) == 0) {
2957                 int k;
2958                 double d;
2959
2960                 p = buf + 4;
2961                 k = atoi(sstrsep(&p, sep));
2962                 sstrsep(&p, sep);
2963
2964                 d = atof(sstrsep(&p, sep));
2965                 if (n)
2966                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2967                 else
2968                     dsa_results[k][0] = d;
2969
2970                 d = atof(sstrsep(&p, sep));
2971                 if (n)
2972                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2973                 else
2974                     dsa_results[k][1] = d;
2975             }
2976 # endif
2977 # ifndef OPENSSL_NO_EC
2978             else if (strncmp(buf, "+F4:", 4) == 0) {
2979                 int k;
2980                 double d;
2981
2982                 p = buf + 4;
2983                 k = atoi(sstrsep(&p, sep));
2984                 sstrsep(&p, sep);
2985
2986                 d = atof(sstrsep(&p, sep));
2987                 if (n)
2988                     ecdsa_results[k][0] =
2989                         1 / (1 / ecdsa_results[k][0] + 1 / d);
2990                 else
2991                     ecdsa_results[k][0] = d;
2992
2993                 d = atof(sstrsep(&p, sep));
2994                 if (n)
2995                     ecdsa_results[k][1] =
2996                         1 / (1 / ecdsa_results[k][1] + 1 / d);
2997                 else
2998                     ecdsa_results[k][1] = d;
2999             } else if (strncmp(buf, "+F5:", 4) == 0) {
3000                 int k;
3001                 double d;
3002
3003                 p = buf + 4;
3004                 k = atoi(sstrsep(&p, sep));
3005                 sstrsep(&p, sep);
3006
3007                 d = atof(sstrsep(&p, sep));
3008                 if (n)
3009                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
3010                 else
3011                     ecdh_results[k][0] = d;
3012
3013             }
3014 # endif
3015
3016             else if (strncmp(buf, "+H:", 3) == 0) {
3017                 ;
3018             } else
3019                 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
3020         }
3021
3022         fclose(f);
3023     }
3024     free(fds);
3025     return 1;
3026 }
3027 #endif
3028
3029 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
3030 {
3031     static int mblengths[] =
3032         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
3033     int j, count, num = OSSL_NELEM(mblengths);
3034     const char *alg_name;
3035     unsigned char *inp, *out, no_key[32], no_iv[16];
3036     EVP_CIPHER_CTX *ctx;
3037     double d = 0.0;
3038
3039     inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
3040     out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
3041     ctx = EVP_CIPHER_CTX_new();
3042     EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
3043     EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
3044                         no_key);
3045     alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
3046
3047     for (j = 0; j < num; j++) {
3048         print_message(alg_name, 0, mblengths[j]);
3049         Time_F(START);
3050         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
3051             unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
3052             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
3053             size_t len = mblengths[j];
3054             int packlen;
3055
3056             memset(aad, 0, 8);  /* avoid uninitialized values */
3057             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
3058             aad[9] = 3;         /* version */
3059             aad[10] = 2;
3060             aad[11] = 0;        /* length */
3061             aad[12] = 0;
3062             mb_param.out = NULL;
3063             mb_param.inp = aad;
3064             mb_param.len = len;
3065             mb_param.interleave = 8;
3066
3067             packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
3068                                           sizeof(mb_param), &mb_param);
3069
3070             if (packlen > 0) {
3071                 mb_param.out = out;
3072                 mb_param.inp = inp;
3073                 mb_param.len = len;
3074                 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
3075                                     sizeof(mb_param), &mb_param);
3076             } else {
3077                 int pad;
3078
3079                 RAND_bytes(out, 16);
3080                 len += 16;
3081                 aad[11] = len >> 8;
3082                 aad[12] = len;
3083                 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
3084                                           EVP_AEAD_TLS1_AAD_LEN, aad);
3085                 EVP_Cipher(ctx, out, inp, len + pad);
3086             }
3087         }
3088         d = Time_F(STOP);
3089         BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
3090                    : "%d %s's in %.2fs\n", count, "evp", d);
3091         results[D_EVP][j] = ((double)count) / d * mblengths[j];
3092     }
3093
3094     if (mr) {
3095         fprintf(stdout, "+H");
3096         for (j = 0; j < num; j++)
3097             fprintf(stdout, ":%d", mblengths[j]);
3098         fprintf(stdout, "\n");
3099         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
3100         for (j = 0; j < num; j++)
3101             fprintf(stdout, ":%.2f", results[D_EVP][j]);
3102         fprintf(stdout, "\n");
3103     } else {
3104         fprintf(stdout,
3105                 "The 'numbers' are in 1000s of bytes per second processed.\n");
3106         fprintf(stdout, "type                    ");
3107         for (j = 0; j < num; j++)
3108             fprintf(stdout, "%7d bytes", mblengths[j]);
3109         fprintf(stdout, "\n");
3110         fprintf(stdout, "%-24s", alg_name);
3111
3112         for (j = 0; j < num; j++) {
3113             if (results[D_EVP][j] > 10000)
3114                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
3115             else
3116                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
3117         }
3118         fprintf(stdout, "\n");
3119     }
3120
3121     OPENSSL_free(inp);
3122     OPENSSL_free(out);
3123     EVP_CIPHER_CTX_free(ctx);
3124 }