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