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