source: EcnlProtoTool/trunk/openssl-1.1.0e/apps/speed.c@ 331

Last change on this file since 331 was 331, checked in by coas-nagasima, 6 years ago

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