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