1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
57 /* ====================================================================
58 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60 * Portions of the attached software ("Contribution") are developed by
61 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
63 * The Contribution is licensed pursuant to the OpenSSL open source
64 * license provided above.
66 * The ECDH and ECDSA speed test software is originally written by
67 * Sumit Gupta of Sun Microsystems Laboratories.
73 #define PRIME_SECONDS 10
74 #define RSA_SECONDS 10
75 #define DSA_SECONDS 10
76 #define ECDSA_SECONDS 10
77 #define ECDH_SECONDS 10
84 #include <openssl/crypto.h>
85 #include <openssl/rand.h>
86 #include <openssl/err.h>
87 #include <openssl/evp.h>
88 #include <openssl/objects.h>
89 #if !defined(OPENSSL_SYS_MSDOS)
90 # include OPENSSL_UNISTD
93 #ifndef OPENSSL_SYS_NETWARE
97 #if defined(_WIN32) || defined(__CYGWIN__)
99 # if defined(__CYGWIN__) && !defined(_WIN32)
101 * <windows.h> should define _WIN32, which normally is mutually exclusive
102 * with __CYGWIN__, but if it didn't...
105 /* this is done because Cygwin alarm() fails sometimes. */
109 #include <openssl/bn.h>
110 #ifndef OPENSSL_NO_DES
111 # include <openssl/des.h>
113 #ifndef OPENSSL_NO_AES
114 # include <openssl/aes.h>
116 #ifndef OPENSSL_NO_CAMELLIA
117 # include <openssl/camellia.h>
119 #ifndef OPENSSL_NO_MD2
120 # include <openssl/md2.h>
122 #ifndef OPENSSL_NO_MDC2
123 # include <openssl/mdc2.h>
125 #ifndef OPENSSL_NO_MD4
126 # include <openssl/md4.h>
128 #ifndef OPENSSL_NO_MD5
129 # include <openssl/md5.h>
131 #include <openssl/hmac.h>
132 #include <openssl/evp.h>
133 #include <openssl/sha.h>
134 #ifndef OPENSSL_NO_RMD160
135 # include <openssl/ripemd.h>
137 #ifndef OPENSSL_NO_WHIRLPOOL
138 # include <openssl/whrlpool.h>
140 #ifndef OPENSSL_NO_RC4
141 # include <openssl/rc4.h>
143 #ifndef OPENSSL_NO_RC5
144 # include <openssl/rc5.h>
146 #ifndef OPENSSL_NO_RC2
147 # include <openssl/rc2.h>
149 #ifndef OPENSSL_NO_IDEA
150 # include <openssl/idea.h>
152 #ifndef OPENSSL_NO_SEED
153 # include <openssl/seed.h>
155 #ifndef OPENSSL_NO_BF
156 # include <openssl/blowfish.h>
158 #ifndef OPENSSL_NO_CAST
159 # include <openssl/cast.h>
161 #ifndef OPENSSL_NO_RSA
162 # include <openssl/rsa.h>
163 # include "./testrsa.h"
165 #include <openssl/x509.h>
166 #ifndef OPENSSL_NO_DSA
167 # include <openssl/dsa.h>
168 # include "./testdsa.h"
170 #ifndef OPENSSL_NO_EC
171 # include <openssl/ecdsa.h>
172 # include <openssl/ecdh.h>
174 #include <openssl/modes.h>
176 #include <openssl/bn.h>
179 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
193 #define BUFSIZE (1024*8+1)
194 #define MAX_MISALIGNMENT 63
196 static volatile int run = 0;
199 static int usertime = 1;
201 static double Time_F(int s);
202 static void print_message(const char *s, long num, int length);
203 static void pkey_print_message(const char *str, const char *str2,
204 long num, int bits, int sec);
205 static void print_result(int alg, int run_no, int count, double time_used);
207 static int do_multi(int multi);
217 #define MAX_ECDH_SIZE 256
220 static const char *names[ALGOR_NUM] = {
221 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
222 "des cbc", "des ede3", "idea cbc", "seed cbc",
223 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
224 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
225 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
226 "evp", "sha256", "sha512", "whirlpool",
227 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
230 static double results[ALGOR_NUM][SIZE_NUM];
231 static int lengths[SIZE_NUM] = {
232 16, 64, 256, 1024, 8 * 1024
235 #ifndef OPENSSL_NO_RSA
236 static double rsa_results[RSA_NUM][2];
238 #ifndef OPENSSL_NO_DSA
239 static double dsa_results[DSA_NUM][2];
241 #ifndef OPENSSL_NO_EC
242 static double ecdsa_results[EC_NUM][2];
243 static double ecdh_results[EC_NUM][1];
246 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
247 static const char rnd_seed[] =
248 "string to make the random number generator think it has entropy";
249 static int rnd_fake = 0;
253 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
254 # define SIGRETTYPE void
256 # define SIGRETTYPE int
259 static SIGRETTYPE sig_done(int sig);
260 static SIGRETTYPE sig_done(int sig)
262 signal(SIGALRM, sig_done);
272 # if !defined(SIGALRM)
275 static unsigned int lapse, schlock;
276 static void alarm_win32(unsigned int secs)
281 # define alarm alarm_win32
283 static DWORD WINAPI sleepy(VOID * arg)
291 static double Time_F(int s)
298 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
300 DWORD ret = GetLastError();
301 BIO_printf(bio_err, "unable to CreateThread (%d)", ret);
305 Sleep(0); /* scheduler spinlock */
306 ret = app_tminterval(s, usertime);
308 ret = app_tminterval(s, usertime);
310 TerminateThread(thr, 0);
318 static double Time_F(int s)
320 double ret = app_tminterval(s, usertime);
327 #ifndef OPENSSL_NO_EC
328 static const int KDF1_SHA1_len = 20;
329 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
332 if (*outlen < SHA_DIGEST_LENGTH)
334 *outlen = SHA_DIGEST_LENGTH;
335 return SHA1(in, inlen, out);
337 #endif /* OPENSSL_NO_EC */
339 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
341 static int found(const char *name, const OPT_PAIR * pairs, int *result)
343 for (; pairs->name; pairs++)
344 if (strcmp(name, pairs->name) == 0) {
345 *result = pairs->retval;
351 typedef enum OPTION_choice {
352 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
353 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
354 OPT_MR, OPT_MB, OPT_MISALIGN
357 OPTIONS speed_options[] = {
358 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
359 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
360 {"help", OPT_HELP, '-', "Display this summary"},
361 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
362 {"decrypt", OPT_DECRYPT, '-',
363 "Time decryption instead of encryption (only EVP)"},
364 {"mr", OPT_MR, '-', "Produce machine readable output"},
366 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
367 {"elapsed", OPT_ELAPSED, '-',
368 "Measure time in real time instead of CPU user time"},
370 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
372 #ifndef OPENSSL_NO_ENGINE
373 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
388 #define D_CBC_IDEA 10
389 #define D_CBC_SEED 11
393 #define D_CBC_CAST 15
394 #define D_CBC_128_AES 16
395 #define D_CBC_192_AES 17
396 #define D_CBC_256_AES 18
397 #define D_CBC_128_CML 19
398 #define D_CBC_192_CML 20
399 #define D_CBC_256_CML 21
403 #define D_WHIRLPOOL 25
404 #define D_IGE_128_AES 26
405 #define D_IGE_192_AES 27
406 #define D_IGE_256_AES 28
408 OPT_PAIR doit_choices[] = {
409 #ifndef OPENSSL_NO_MD2
412 #ifndef OPENSSL_NO_MDC2
415 #ifndef OPENSSL_NO_MD4
418 #ifndef OPENSSL_NO_MD5
421 #ifndef OPENSSL_NO_MD5
425 {"sha256", D_SHA256},
426 {"sha512", D_SHA512},
427 #ifndef OPENSSL_NO_WHIRLPOOL
428 {"whirlpool", D_WHIRLPOOL},
430 #ifndef OPENSSL_NO_RMD160
431 {"ripemd", D_RMD160},
432 {"rmd160", D_RMD160},
433 {"ripemd160", D_RMD160},
435 #ifndef OPENSSL_NO_RC4
438 #ifndef OPENSSL_NO_DES
439 {"des-cbc", D_CBC_DES},
440 {"des-ede3", D_EDE3_DES},
442 #ifndef OPENSSL_NO_AES
443 {"aes-128-cbc", D_CBC_128_AES},
444 {"aes-192-cbc", D_CBC_192_AES},
445 {"aes-256-cbc", D_CBC_256_AES},
446 {"aes-128-ige", D_IGE_128_AES},
447 {"aes-192-ige", D_IGE_192_AES},
448 {"aes-256-ige", D_IGE_256_AES},
450 #ifndef OPENSSL_NO_RC2
451 {"rc2-cbc", D_CBC_RC2},
454 #ifndef OPENSSL_NO_RC5
455 {"rc5-cbc", D_CBC_RC5},
458 #ifndef OPENSSL_NO_IDEA
459 {"idea-cbc", D_CBC_IDEA},
460 {"idea", D_CBC_IDEA},
462 #ifndef OPENSSL_NO_SEED
463 {"seed-cbc", D_CBC_SEED},
464 {"seed", D_CBC_SEED},
466 #ifndef OPENSSL_NO_BF
467 {"bf-cbc", D_CBC_BF},
468 {"blowfish", D_CBC_BF},
471 #ifndef OPENSSL_NO_CAST
472 {"cast-cbc", D_CBC_CAST},
473 {"cast", D_CBC_CAST},
474 {"cast5", D_CBC_CAST},
483 static OPT_PAIR dsa_choices[] = {
484 {"dsa512", R_DSA_512},
485 {"dsa1024", R_DSA_1024},
486 {"dsa2048", R_DSA_2048},
496 #define R_RSA_15360 6
497 static OPT_PAIR rsa_choices[] = {
498 {"rsa512", R_RSA_512},
499 {"rsa1024", R_RSA_1024},
500 {"rsa2048", R_RSA_2048},
501 {"rsa3072", R_RSA_3072},
502 {"rsa4096", R_RSA_4096},
503 {"rsa7680", R_RSA_7680},
504 {"rsa15360", R_RSA_15360},
524 #ifndef OPENSSL_NO_ECA
525 static OPT_PAIR ecdsa_choices[] = {
526 {"ecdsap160", R_EC_P160},
527 {"ecdsap192", R_EC_P192},
528 {"ecdsap224", R_EC_P224},
529 {"ecdsap256", R_EC_P256},
530 {"ecdsap384", R_EC_P384},
531 {"ecdsap521", R_EC_P521},
532 {"ecdsak163", R_EC_K163},
533 {"ecdsak233", R_EC_K233},
534 {"ecdsak283", R_EC_K283},
535 {"ecdsak409", R_EC_K409},
536 {"ecdsak571", R_EC_K571},
537 {"ecdsab163", R_EC_B163},
538 {"ecdsab233", R_EC_B233},
539 {"ecdsab283", R_EC_B283},
540 {"ecdsab409", R_EC_B409},
541 {"ecdsab571", R_EC_B571},
544 static OPT_PAIR ecdh_choices[] = {
545 {"ecdhp160", R_EC_P160},
546 {"ecdhp192", R_EC_P192},
547 {"ecdhp224", R_EC_P224},
548 {"ecdhp256", R_EC_P256},
549 {"ecdhp384", R_EC_P384},
550 {"ecdhp521", R_EC_P521},
551 {"ecdhk163", R_EC_K163},
552 {"ecdhk233", R_EC_K233},
553 {"ecdhk283", R_EC_K283},
554 {"ecdhk409", R_EC_K409},
555 {"ecdhk571", R_EC_K571},
556 {"ecdhb163", R_EC_B163},
557 {"ecdhb233", R_EC_B233},
558 {"ecdhb283", R_EC_B283},
559 {"ecdhb409", R_EC_B409},
560 {"ecdhb571", R_EC_B571},
565 int speed_main(int argc, char **argv)
568 const EVP_CIPHER *evp_cipher = NULL;
569 const EVP_MD *evp_md = NULL;
572 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
573 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
574 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
575 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
576 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
577 unsigned char *buf = NULL, *buf2 = NULL;
578 unsigned char *save_buf = NULL, *save_buf2 = NULL;
579 unsigned char md[EVP_MAX_MD_SIZE];
583 /* What follows are the buffers and key material. */
584 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
587 #ifndef OPENSSL_NO_MD2
588 unsigned char md2[MD2_DIGEST_LENGTH];
590 #ifndef OPENSSL_NO_MDC2
591 unsigned char mdc2[MDC2_DIGEST_LENGTH];
593 #ifndef OPENSSL_NO_MD4
594 unsigned char md4[MD4_DIGEST_LENGTH];
596 #ifndef OPENSSL_NO_MD5
597 unsigned char md5[MD5_DIGEST_LENGTH];
598 unsigned char hmac[MD5_DIGEST_LENGTH];
600 unsigned char sha[SHA_DIGEST_LENGTH];
601 unsigned char sha256[SHA256_DIGEST_LENGTH];
602 unsigned char sha512[SHA512_DIGEST_LENGTH];
603 #ifndef OPENSSL_NO_WHIRLPOOL
604 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
606 #ifndef OPENSSL_NO_RMD160
607 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
609 #ifndef OPENSSL_NO_RC4
612 #ifndef OPENSSL_NO_RC5
615 #ifndef OPENSSL_NO_RC2
618 #ifndef OPENSSL_NO_IDEA
619 IDEA_KEY_SCHEDULE idea_ks;
621 #ifndef OPENSSL_NO_SEED
622 SEED_KEY_SCHEDULE seed_ks;
624 #ifndef OPENSSL_NO_BF
627 #ifndef OPENSSL_NO_CAST
630 static const unsigned char key16[16] = {
631 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
632 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
634 #ifndef OPENSSL_NO_AES
635 static const unsigned char key24[24] = {
636 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
637 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
638 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
640 static const unsigned char key32[32] = {
641 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
642 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
643 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
644 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
647 #ifndef OPENSSL_NO_CAMELLIA
648 static const unsigned char ckey24[24] = {
649 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
650 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
651 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
653 static const unsigned char ckey32[32] = {
654 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
655 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
656 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
657 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
659 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
661 #ifndef OPENSSL_NO_AES
662 # define MAX_BLOCK_SIZE 128
664 # define MAX_BLOCK_SIZE 64
666 unsigned char DES_iv[8];
667 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
668 #ifndef OPENSSL_NO_DES
669 static DES_cblock key = {
670 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
672 static DES_cblock key2 = {
673 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
675 static DES_cblock key3 = {
676 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
678 DES_key_schedule sch;
679 DES_key_schedule sch2;
680 DES_key_schedule sch3;
682 #ifndef OPENSSL_NO_AES
683 AES_KEY aes_ks1, aes_ks2, aes_ks3;
685 #ifndef OPENSSL_NO_RSA
687 RSA *rsa_key[RSA_NUM];
688 long rsa_c[RSA_NUM][2];
689 static unsigned int rsa_bits[RSA_NUM] = {
690 512, 1024, 2048, 3072, 4096, 7680, 15360
692 static unsigned char *rsa_data[RSA_NUM] = {
693 test512, test1024, test2048, test3072, test4096, test7680, test15360
695 static int rsa_data_length[RSA_NUM] = {
696 sizeof(test512), sizeof(test1024),
697 sizeof(test2048), sizeof(test3072),
698 sizeof(test4096), sizeof(test7680),
702 #ifndef OPENSSL_NO_DSA
703 DSA *dsa_key[DSA_NUM];
704 long dsa_c[DSA_NUM][2];
705 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
707 #ifndef OPENSSL_NO_EC
709 * We only test over the following curves as they are representative, To
710 * add tests over more curves, simply add the curve NID and curve name to
711 * the following arrays and increase the EC_NUM value accordingly.
713 static unsigned int test_curves[EC_NUM] = {
715 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
716 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
718 NID_sect163k1, NID_sect233k1, NID_sect283k1,
719 NID_sect409k1, NID_sect571k1, NID_sect163r2,
720 NID_sect233r1, NID_sect283r1, NID_sect409r1,
723 static const char *test_curves_names[EC_NUM] = {
725 "secp160r1", "nistp192", "nistp224",
726 "nistp256", "nistp384", "nistp521",
728 "nistk163", "nistk233", "nistk283",
729 "nistk409", "nistk571", "nistb163",
730 "nistb233", "nistb283", "nistb409",
733 static int test_curves_bits[EC_NUM] = {
742 #ifndef OPENSSL_NO_EC
743 unsigned char ecdsasig[256];
744 unsigned int ecdsasiglen;
745 EC_KEY *ecdsa[EC_NUM];
746 long ecdsa_c[EC_NUM][2];
747 int ecdsa_doit[EC_NUM];
748 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
749 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
750 int secret_size_a, secret_size_b;
753 long ecdh_c[EC_NUM][2];
754 int ecdh_doit[EC_NUM];
757 memset(results, 0, sizeof(results));
758 #ifndef OPENSSL_NO_DSA
759 memset(dsa_key, 0, sizeof(dsa_key));
761 #ifndef OPENSSL_NO_EC
762 for (i = 0; i < EC_NUM; i++)
764 for (i = 0; i < EC_NUM; i++)
765 ecdh_a[i] = ecdh_b[i] = NULL;
767 #ifndef OPENSSL_NO_RSA
768 memset(rsa_key, 0, sizeof(rsa_key));
769 for (i = 0; i < RSA_NUM; i++)
773 memset(c, 0, sizeof(c));
774 memset(DES_iv, 0, sizeof(DES_iv));
775 memset(iv, 0, sizeof(iv));
777 for (i = 0; i < ALGOR_NUM; i++)
779 for (i = 0; i < RSA_NUM; i++)
781 for (i = 0; i < DSA_NUM; i++)
783 #ifndef OPENSSL_NO_EC
784 for (i = 0; i < EC_NUM; i++)
786 for (i = 0; i < EC_NUM; i++)
790 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
791 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
794 prog = opt_init(argc, argv, speed_options);
795 while ((o = opt_next()) != OPT_EOF) {
800 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
803 opt_help(speed_options);
810 evp_cipher = EVP_get_cipherbyname(opt_arg());
811 if (evp_cipher == NULL)
812 evp_md = EVP_get_digestbyname(opt_arg());
813 if (evp_cipher == NULL && evp_md == NULL) {
815 "%s: %s an unknown cipher or digest\n",
825 (void)setup_engine(opt_arg(), 0);
829 multi = atoi(opt_arg());
833 if (!opt_int(opt_arg(), &misalign))
835 if (misalign > MISALIGN) {
837 "%s: Maximum offset is %d\n", prog, MISALIGN);
840 buf = buf_malloc + misalign;
841 buf2 = buf2_malloc + misalign;
851 argc = opt_num_rest();
854 if (!app_load_modules(NULL))
857 /* Remaining arguments are algorithms. */
858 for ( ; *argv; argv++) {
859 if (found(*argv, doit_choices, &i)) {
863 #ifndef OPENSSL_NO_DES
864 if (strcmp(*argv, "des") == 0) {
865 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
869 if (strcmp(*argv, "sha") == 0) {
870 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
873 #ifndef OPENSSL_NO_RSA
875 if (strcmp(*argv, "openssl") == 0) {
876 RSA_set_default_method(RSA_PKCS1_SSLeay());
880 if (strcmp(*argv, "rsa") == 0) {
881 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
882 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
883 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
884 rsa_doit[R_RSA_15360] = 1;
887 if (found(*argv, rsa_choices, &i)) {
892 #ifndef OPENSSL_NO_DSA
893 if (strcmp(*argv, "dsa") == 0) {
894 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
895 dsa_doit[R_DSA_2048] = 1;
898 if (found(*argv, dsa_choices, &i)) {
903 #ifndef OPENSSL_NO_AES
904 if (strcmp(*argv, "aes") == 0) {
905 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
906 doit[D_CBC_256_AES] = 1;
910 #ifndef OPENSSL_NO_CAMELLIA
911 if (strcmp(*argv, "camellia") == 0) {
912 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
913 doit[D_CBC_256_CML] = 1;
917 #ifndef OPENSSL_NO_EC
918 if (strcmp(*argv, "ecdsa") == 0) {
919 for (i = 0; i < EC_NUM; i++)
923 if (found(*argv, ecdsa_choices, &i)) {
927 if (strcmp(*argv, "ecdh") == 0) {
928 for (i = 0; i < EC_NUM; i++)
932 if (found(*argv, ecdh_choices, &i)) {
937 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
942 if (multi && do_multi(multi))
946 /* No parameters; turn on everything. */
947 if ((argc == 0) && !doit[D_EVP]) {
948 for (i = 0; i < ALGOR_NUM; i++)
951 for (i = 0; i < RSA_NUM; i++)
953 for (i = 0; i < DSA_NUM; i++)
955 #ifndef OPENSSL_NO_EC
956 for (i = 0; i < EC_NUM; i++)
958 for (i = 0; i < EC_NUM; i++)
962 for (i = 0; i < ALGOR_NUM; i++)
966 if (usertime == 0 && !mr)
968 "You have chosen to measure elapsed time "
969 "instead of user CPU time.\n");
971 #ifndef OPENSSL_NO_RSA
972 for (i = 0; i < RSA_NUM; i++) {
973 const unsigned char *p;
976 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
977 if (rsa_key[i] == NULL) {
978 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
985 #ifndef OPENSSL_NO_DSA
986 dsa_key[0] = get_dsa512();
987 dsa_key[1] = get_dsa1024();
988 dsa_key[2] = get_dsa2048();
991 #ifndef OPENSSL_NO_DES
992 DES_set_key_unchecked(&key, &sch);
993 DES_set_key_unchecked(&key2, &sch2);
994 DES_set_key_unchecked(&key3, &sch3);
996 #ifndef OPENSSL_NO_AES
997 AES_set_encrypt_key(key16, 128, &aes_ks1);
998 AES_set_encrypt_key(key24, 192, &aes_ks2);
999 AES_set_encrypt_key(key32, 256, &aes_ks3);
1001 #ifndef OPENSSL_NO_CAMELLIA
1002 Camellia_set_key(key16, 128, &camellia_ks1);
1003 Camellia_set_key(ckey24, 192, &camellia_ks2);
1004 Camellia_set_key(ckey32, 256, &camellia_ks3);
1006 #ifndef OPENSSL_NO_IDEA
1007 idea_set_encrypt_key(key16, &idea_ks);
1009 #ifndef OPENSSL_NO_SEED
1010 SEED_set_key(key16, &seed_ks);
1012 #ifndef OPENSSL_NO_RC4
1013 RC4_set_key(&rc4_ks, 16, key16);
1015 #ifndef OPENSSL_NO_RC2
1016 RC2_set_key(&rc2_ks, 16, key16, 128);
1018 #ifndef OPENSSL_NO_RC5
1019 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1021 #ifndef OPENSSL_NO_BF
1022 BF_set_key(&bf_ks, 16, key16);
1024 #ifndef OPENSSL_NO_CAST
1025 CAST_set_key(&cast_ks, 16, key16);
1027 #ifndef OPENSSL_NO_RSA
1028 memset(rsa_c, 0, sizeof(rsa_c));
1031 # ifndef OPENSSL_NO_DES
1032 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1038 for (it = count; it; it--)
1039 DES_ecb_encrypt((DES_cblock *)buf,
1040 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1044 c[D_MD2][0] = count / 10;
1045 c[D_MDC2][0] = count / 10;
1046 c[D_MD4][0] = count;
1047 c[D_MD5][0] = count;
1048 c[D_HMAC][0] = count;
1049 c[D_SHA1][0] = count;
1050 c[D_RMD160][0] = count;
1051 c[D_RC4][0] = count * 5;
1052 c[D_CBC_DES][0] = count;
1053 c[D_EDE3_DES][0] = count / 3;
1054 c[D_CBC_IDEA][0] = count;
1055 c[D_CBC_SEED][0] = count;
1056 c[D_CBC_RC2][0] = count;
1057 c[D_CBC_RC5][0] = count;
1058 c[D_CBC_BF][0] = count;
1059 c[D_CBC_CAST][0] = count;
1060 c[D_CBC_128_AES][0] = count;
1061 c[D_CBC_192_AES][0] = count;
1062 c[D_CBC_256_AES][0] = count;
1063 c[D_CBC_128_CML][0] = count;
1064 c[D_CBC_192_CML][0] = count;
1065 c[D_CBC_256_CML][0] = count;
1066 c[D_SHA256][0] = count;
1067 c[D_SHA512][0] = count;
1068 c[D_WHIRLPOOL][0] = count;
1069 c[D_IGE_128_AES][0] = count;
1070 c[D_IGE_192_AES][0] = count;
1071 c[D_IGE_256_AES][0] = count;
1072 c[D_GHASH][0] = count;
1074 for (i = 1; i < SIZE_NUM; i++) {
1077 l0 = (long)lengths[0];
1078 l1 = (long)lengths[i];
1080 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1081 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1082 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1083 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1084 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1085 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1086 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1087 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1088 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1089 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1091 l0 = (long)lengths[i - 1];
1093 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1094 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1095 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1096 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1097 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1098 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1099 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1100 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1101 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1102 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1103 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1104 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1105 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1106 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1107 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1108 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1109 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1110 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1113 # ifndef OPENSSL_NO_RSA
1114 rsa_c[R_RSA_512][0] = count / 2000;
1115 rsa_c[R_RSA_512][1] = count / 400;
1116 for (i = 1; i < RSA_NUM; i++) {
1117 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1118 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1119 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1122 if (rsa_c[i][0] == 0) {
1130 # ifndef OPENSSL_NO_DSA
1131 dsa_c[R_DSA_512][0] = count / 1000;
1132 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1133 for (i = 1; i < DSA_NUM; i++) {
1134 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1135 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1136 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1139 if (dsa_c[i] == 0) {
1147 # ifndef OPENSSL_NO_EC
1148 ecdsa_c[R_EC_P160][0] = count / 1000;
1149 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1150 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1151 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1152 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1153 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1156 if (ecdsa_c[i] == 0) {
1162 ecdsa_c[R_EC_K163][0] = count / 1000;
1163 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1164 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1165 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1166 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1167 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1170 if (ecdsa_c[i] == 0) {
1176 ecdsa_c[R_EC_B163][0] = count / 1000;
1177 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1178 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1179 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1180 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1181 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1184 if (ecdsa_c[i] == 0) {
1191 ecdh_c[R_EC_P160][0] = count / 1000;
1192 ecdh_c[R_EC_P160][1] = count / 1000;
1193 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1194 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1195 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1196 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1199 if (ecdh_c[i] == 0) {
1205 ecdh_c[R_EC_K163][0] = count / 1000;
1206 ecdh_c[R_EC_K163][1] = count / 1000;
1207 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1208 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1209 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1210 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1213 if (ecdh_c[i] == 0) {
1219 ecdh_c[R_EC_B163][0] = count / 1000;
1220 ecdh_c[R_EC_B163][1] = count / 1000;
1221 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1222 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1223 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1224 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1227 if (ecdh_c[i] == 0) {
1235 # define COND(d) (count < (d))
1236 # define COUNT(d) (d)
1238 /* not worth fixing */
1239 # error "You cannot disable DES on systems without SIGALRM."
1240 # endif /* OPENSSL_NO_DES */
1242 # define COND(c) (run && count<0x7fffffff)
1243 # define COUNT(d) (count)
1245 signal(SIGALRM, sig_done);
1247 #endif /* SIGALRM */
1249 #ifndef OPENSSL_NO_MD2
1251 for (j = 0; j < SIZE_NUM; j++) {
1252 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1254 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1255 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1258 print_result(D_MD2, j, count, d);
1262 #ifndef OPENSSL_NO_MDC2
1264 for (j = 0; j < SIZE_NUM; j++) {
1265 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1267 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1268 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1271 print_result(D_MDC2, j, count, d);
1276 #ifndef OPENSSL_NO_MD4
1278 for (j = 0; j < SIZE_NUM; j++) {
1279 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1281 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1282 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1283 NULL, EVP_md4(), NULL);
1285 print_result(D_MD4, j, count, d);
1290 #ifndef OPENSSL_NO_MD5
1292 for (j = 0; j < SIZE_NUM; j++) {
1293 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1295 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1296 MD5(buf, lengths[j], md5);
1298 print_result(D_MD5, j, count, d);
1303 #if !defined(OPENSSL_NO_MD5)
1307 HMAC_CTX_init(&hctx);
1308 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1309 16, EVP_md5(), NULL);
1311 for (j = 0; j < SIZE_NUM; j++) {
1312 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1314 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1315 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1316 HMAC_Update(&hctx, buf, lengths[j]);
1317 HMAC_Final(&hctx, &(hmac[0]), NULL);
1320 print_result(D_HMAC, j, count, d);
1322 HMAC_CTX_cleanup(&hctx);
1326 for (j = 0; j < SIZE_NUM; j++) {
1327 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1329 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1330 SHA1(buf, lengths[j], sha);
1332 print_result(D_SHA1, j, count, d);
1335 if (doit[D_SHA256]) {
1336 for (j = 0; j < SIZE_NUM; j++) {
1337 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1339 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1340 SHA256(buf, lengths[j], sha256);
1342 print_result(D_SHA256, j, count, d);
1345 if (doit[D_SHA512]) {
1346 for (j = 0; j < SIZE_NUM; j++) {
1347 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1349 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1350 SHA512(buf, lengths[j], sha512);
1352 print_result(D_SHA512, j, count, d);
1356 #ifndef OPENSSL_NO_WHIRLPOOL
1357 if (doit[D_WHIRLPOOL]) {
1358 for (j = 0; j < SIZE_NUM; j++) {
1359 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1361 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1362 WHIRLPOOL(buf, lengths[j], whirlpool);
1364 print_result(D_WHIRLPOOL, j, count, d);
1369 #ifndef OPENSSL_NO_RMD160
1370 if (doit[D_RMD160]) {
1371 for (j = 0; j < SIZE_NUM; j++) {
1372 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1374 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1375 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1376 EVP_ripemd160(), NULL);
1378 print_result(D_RMD160, j, count, d);
1382 #ifndef OPENSSL_NO_RC4
1384 for (j = 0; j < SIZE_NUM; j++) {
1385 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1387 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1388 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1390 print_result(D_RC4, j, count, d);
1394 #ifndef OPENSSL_NO_DES
1395 if (doit[D_CBC_DES]) {
1396 for (j = 0; j < SIZE_NUM; j++) {
1397 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1399 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1400 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1401 &DES_iv, DES_ENCRYPT);
1403 print_result(D_CBC_DES, j, count, d);
1407 if (doit[D_EDE3_DES]) {
1408 for (j = 0; j < SIZE_NUM; j++) {
1409 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1411 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1412 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1414 &DES_iv, DES_ENCRYPT);
1416 print_result(D_EDE3_DES, j, count, d);
1420 #ifndef OPENSSL_NO_AES
1421 if (doit[D_CBC_128_AES]) {
1422 for (j = 0; j < SIZE_NUM; j++) {
1423 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1426 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1427 AES_cbc_encrypt(buf, buf,
1428 (unsigned long)lengths[j], &aes_ks1,
1431 print_result(D_CBC_128_AES, j, count, d);
1434 if (doit[D_CBC_192_AES]) {
1435 for (j = 0; j < SIZE_NUM; j++) {
1436 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1439 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1440 AES_cbc_encrypt(buf, buf,
1441 (unsigned long)lengths[j], &aes_ks2,
1444 print_result(D_CBC_192_AES, j, count, d);
1447 if (doit[D_CBC_256_AES]) {
1448 for (j = 0; j < SIZE_NUM; j++) {
1449 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1452 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1453 AES_cbc_encrypt(buf, buf,
1454 (unsigned long)lengths[j], &aes_ks3,
1457 print_result(D_CBC_256_AES, j, count, d);
1461 if (doit[D_IGE_128_AES]) {
1462 for (j = 0; j < SIZE_NUM; j++) {
1463 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1466 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1467 AES_ige_encrypt(buf, buf2,
1468 (unsigned long)lengths[j], &aes_ks1,
1471 print_result(D_IGE_128_AES, j, count, d);
1474 if (doit[D_IGE_192_AES]) {
1475 for (j = 0; j < SIZE_NUM; j++) {
1476 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1479 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1480 AES_ige_encrypt(buf, buf2,
1481 (unsigned long)lengths[j], &aes_ks2,
1484 print_result(D_IGE_192_AES, j, count, d);
1487 if (doit[D_IGE_256_AES]) {
1488 for (j = 0; j < SIZE_NUM; j++) {
1489 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1492 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1493 AES_ige_encrypt(buf, buf2,
1494 (unsigned long)lengths[j], &aes_ks3,
1497 print_result(D_IGE_256_AES, j, count, d);
1500 if (doit[D_GHASH]) {
1501 GCM128_CONTEXT *ctx =
1502 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1503 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1505 for (j = 0; j < SIZE_NUM; j++) {
1506 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1508 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1509 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1511 print_result(D_GHASH, j, count, d);
1513 CRYPTO_gcm128_release(ctx);
1516 #ifndef OPENSSL_NO_CAMELLIA
1517 if (doit[D_CBC_128_CML]) {
1518 for (j = 0; j < SIZE_NUM; j++) {
1519 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1522 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1523 Camellia_cbc_encrypt(buf, buf,
1524 (unsigned long)lengths[j], &camellia_ks1,
1525 iv, CAMELLIA_ENCRYPT);
1527 print_result(D_CBC_128_CML, j, count, d);
1530 if (doit[D_CBC_192_CML]) {
1531 for (j = 0; j < SIZE_NUM; j++) {
1532 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1535 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1536 Camellia_cbc_encrypt(buf, buf,
1537 (unsigned long)lengths[j], &camellia_ks2,
1538 iv, CAMELLIA_ENCRYPT);
1540 print_result(D_CBC_192_CML, j, count, d);
1543 if (doit[D_CBC_256_CML]) {
1544 for (j = 0; j < SIZE_NUM; j++) {
1545 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1548 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1549 Camellia_cbc_encrypt(buf, buf,
1550 (unsigned long)lengths[j], &camellia_ks3,
1551 iv, CAMELLIA_ENCRYPT);
1553 print_result(D_CBC_256_CML, j, count, d);
1557 #ifndef OPENSSL_NO_IDEA
1558 if (doit[D_CBC_IDEA]) {
1559 for (j = 0; j < SIZE_NUM; j++) {
1560 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1562 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1563 idea_cbc_encrypt(buf, buf,
1564 (unsigned long)lengths[j], &idea_ks,
1567 print_result(D_CBC_IDEA, j, count, d);
1571 #ifndef OPENSSL_NO_SEED
1572 if (doit[D_CBC_SEED]) {
1573 for (j = 0; j < SIZE_NUM; j++) {
1574 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1576 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1577 SEED_cbc_encrypt(buf, buf,
1578 (unsigned long)lengths[j], &seed_ks, iv, 1);
1580 print_result(D_CBC_SEED, j, count, d);
1584 #ifndef OPENSSL_NO_RC2
1585 if (doit[D_CBC_RC2]) {
1586 for (j = 0; j < SIZE_NUM; j++) {
1587 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1589 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1590 RC2_cbc_encrypt(buf, buf,
1591 (unsigned long)lengths[j], &rc2_ks,
1594 print_result(D_CBC_RC2, j, count, d);
1598 #ifndef OPENSSL_NO_RC5
1599 if (doit[D_CBC_RC5]) {
1600 for (j = 0; j < SIZE_NUM; j++) {
1601 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1603 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1604 RC5_32_cbc_encrypt(buf, buf,
1605 (unsigned long)lengths[j], &rc5_ks,
1608 print_result(D_CBC_RC5, j, count, d);
1612 #ifndef OPENSSL_NO_BF
1613 if (doit[D_CBC_BF]) {
1614 for (j = 0; j < SIZE_NUM; j++) {
1615 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1617 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1618 BF_cbc_encrypt(buf, buf,
1619 (unsigned long)lengths[j], &bf_ks,
1622 print_result(D_CBC_BF, j, count, d);
1626 #ifndef OPENSSL_NO_CAST
1627 if (doit[D_CBC_CAST]) {
1628 for (j = 0; j < SIZE_NUM; j++) {
1629 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1631 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1632 CAST_cbc_encrypt(buf, buf,
1633 (unsigned long)lengths[j], &cast_ks,
1636 print_result(D_CBC_CAST, j, count, d);
1642 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1643 if (multiblock && evp_cipher) {
1645 (EVP_CIPHER_flags(evp_cipher) &
1646 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1647 BIO_printf(bio_err, "%s is not multi-block capable\n",
1648 OBJ_nid2ln(evp_cipher->nid));
1651 multiblock_speed(evp_cipher);
1656 for (j = 0; j < SIZE_NUM; j++) {
1661 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1663 * -O3 -fschedule-insns messes up an optimization here!
1664 * names[D_EVP] somehow becomes NULL
1666 print_message(names[D_EVP], save_count, lengths[j]);
1668 EVP_CIPHER_CTX_init(&ctx);
1670 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1672 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1673 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1677 for (count = 0, run = 1;
1678 COND(save_count * 4 * lengths[0] / lengths[j]);
1680 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1682 for (count = 0, run = 1;
1683 COND(save_count * 4 * lengths[0] / lengths[j]);
1685 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1687 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1689 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1691 EVP_CIPHER_CTX_cleanup(&ctx);
1694 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1695 print_message(names[D_EVP], save_count, lengths[j]);
1698 for (count = 0, run = 1;
1699 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1700 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1704 print_result(D_EVP, j, count, d);
1708 RAND_bytes(buf, 36);
1709 #ifndef OPENSSL_NO_RSA
1710 for (j = 0; j < RSA_NUM; j++) {
1714 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1717 "RSA sign failure. No RSA sign will be done.\n");
1718 ERR_print_errors(bio_err);
1721 pkey_print_message("private", "rsa",
1722 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1723 /* RSA_blinding_on(rsa_key[j],NULL); */
1725 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1726 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1727 &rsa_num, rsa_key[j]);
1729 BIO_printf(bio_err, "RSA sign failure\n");
1730 ERR_print_errors(bio_err);
1737 mr ? "+R1:%ld:%d:%.2f\n"
1738 : "%ld %d bit private RSA's in %.2fs\n",
1739 count, rsa_bits[j], d);
1740 rsa_results[j][0] = d / (double)count;
1744 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1747 "RSA verify failure. No RSA verify will be done.\n");
1748 ERR_print_errors(bio_err);
1751 pkey_print_message("public", "rsa",
1752 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1754 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1755 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1756 rsa_num, rsa_key[j]);
1758 BIO_printf(bio_err, "RSA verify failure\n");
1759 ERR_print_errors(bio_err);
1766 mr ? "+R2:%ld:%d:%.2f\n"
1767 : "%ld %d bit public RSA's in %.2fs\n",
1768 count, rsa_bits[j], d);
1769 rsa_results[j][1] = d / (double)count;
1772 if (rsa_count <= 1) {
1773 /* if longer than 10s, don't do any more */
1774 for (j++; j < RSA_NUM; j++)
1780 RAND_bytes(buf, 20);
1781 #ifndef OPENSSL_NO_DSA
1782 if (RAND_status() != 1) {
1783 RAND_seed(rnd_seed, sizeof rnd_seed);
1786 for (j = 0; j < DSA_NUM; j++) {
1793 /* DSA_generate_key(dsa_key[j]); */
1794 /* DSA_sign_setup(dsa_key[j],NULL); */
1795 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1798 "DSA sign failure. No DSA sign will be done.\n");
1799 ERR_print_errors(bio_err);
1802 pkey_print_message("sign", "dsa",
1803 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1805 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1806 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1808 BIO_printf(bio_err, "DSA sign failure\n");
1809 ERR_print_errors(bio_err);
1816 mr ? "+R3:%ld:%d:%.2f\n"
1817 : "%ld %d bit DSA signs in %.2fs\n",
1818 count, dsa_bits[j], d);
1819 dsa_results[j][0] = d / (double)count;
1823 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1826 "DSA verify failure. No DSA verify will be done.\n");
1827 ERR_print_errors(bio_err);
1830 pkey_print_message("verify", "dsa",
1831 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1833 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1834 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1836 BIO_printf(bio_err, "DSA verify failure\n");
1837 ERR_print_errors(bio_err);
1844 mr ? "+R4:%ld:%d:%.2f\n"
1845 : "%ld %d bit DSA verify in %.2fs\n",
1846 count, dsa_bits[j], d);
1847 dsa_results[j][1] = d / (double)count;
1850 if (rsa_count <= 1) {
1851 /* if longer than 10s, don't do any more */
1852 for (j++; j < DSA_NUM; j++)
1860 #ifndef OPENSSL_NO_EC
1861 if (RAND_status() != 1) {
1862 RAND_seed(rnd_seed, sizeof rnd_seed);
1865 for (j = 0; j < EC_NUM; j++) {
1869 continue; /* Ignore Curve */
1870 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1871 if (ecdsa[j] == NULL) {
1872 BIO_printf(bio_err, "ECDSA failure.\n");
1873 ERR_print_errors(bio_err);
1876 EC_KEY_precompute_mult(ecdsa[j], NULL);
1877 /* Perform ECDSA signature test */
1878 EC_KEY_generate_key(ecdsa[j]);
1879 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1882 "ECDSA sign failure. No ECDSA sign will be done.\n");
1883 ERR_print_errors(bio_err);
1886 pkey_print_message("sign", "ecdsa",
1888 test_curves_bits[j], ECDSA_SECONDS);
1891 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1892 st = ECDSA_sign(0, buf, 20,
1893 ecdsasig, &ecdsasiglen, ecdsa[j]);
1895 BIO_printf(bio_err, "ECDSA sign failure\n");
1896 ERR_print_errors(bio_err);
1904 mr ? "+R5:%ld:%d:%.2f\n" :
1905 "%ld %d bit ECDSA signs in %.2fs \n",
1906 count, test_curves_bits[j], d);
1907 ecdsa_results[j][0] = d / (double)count;
1911 /* Perform ECDSA verification test */
1912 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1915 "ECDSA verify failure. No ECDSA verify will be done.\n");
1916 ERR_print_errors(bio_err);
1919 pkey_print_message("verify", "ecdsa",
1921 test_curves_bits[j], ECDSA_SECONDS);
1923 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1924 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1927 BIO_printf(bio_err, "ECDSA verify failure\n");
1928 ERR_print_errors(bio_err);
1935 mr ? "+R6:%ld:%d:%.2f\n"
1936 : "%ld %d bit ECDSA verify in %.2fs\n",
1937 count, test_curves_bits[j], d);
1938 ecdsa_results[j][1] = d / (double)count;
1941 if (rsa_count <= 1) {
1942 /* if longer than 10s, don't do any more */
1943 for (j++; j < EC_NUM; j++)
1952 #ifndef OPENSSL_NO_EC
1953 if (RAND_status() != 1) {
1954 RAND_seed(rnd_seed, sizeof rnd_seed);
1957 for (j = 0; j < EC_NUM; j++) {
1960 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1961 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1962 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1963 BIO_printf(bio_err, "ECDH failure.\n");
1964 ERR_print_errors(bio_err);
1967 /* generate two ECDH key pairs */
1968 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1969 !EC_KEY_generate_key(ecdh_b[j])) {
1970 BIO_printf(bio_err, "ECDH key generation failure.\n");
1971 ERR_print_errors(bio_err);
1975 * If field size is not more than 24 octets, then use SHA-1
1976 * hash of result; otherwise, use result (see section 4.8 of
1977 * draft-ietf-tls-ecc-03.txt).
1979 int field_size, outlen;
1980 void *(*kdf) (const void *in, size_t inlen, void *out,
1983 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1984 if (field_size <= 24 * 8) {
1985 outlen = KDF1_SHA1_len;
1988 outlen = (field_size + 7) / 8;
1992 ECDH_compute_key(secret_a, outlen,
1993 EC_KEY_get0_public_key(ecdh_b[j]),
1996 ECDH_compute_key(secret_b, outlen,
1997 EC_KEY_get0_public_key(ecdh_a[j]),
1999 if (secret_size_a != secret_size_b)
2004 for (secret_idx = 0; (secret_idx < secret_size_a)
2005 && (ecdh_checks == 1); secret_idx++) {
2006 if (secret_a[secret_idx] != secret_b[secret_idx])
2010 if (ecdh_checks == 0) {
2011 BIO_printf(bio_err, "ECDH computations don't match.\n");
2012 ERR_print_errors(bio_err);
2016 pkey_print_message("", "ecdh",
2018 test_curves_bits[j], ECDH_SECONDS);
2020 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2021 ECDH_compute_key(secret_a, outlen,
2022 EC_KEY_get0_public_key(ecdh_b[j]),
2027 mr ? "+R7:%ld:%d:%.2f\n" :
2028 "%ld %d-bit ECDH ops in %.2fs\n", count,
2029 test_curves_bits[j], d);
2030 ecdh_results[j][0] = d / (double)count;
2035 if (rsa_count <= 1) {
2036 /* if longer than 10s, don't do any more */
2037 for (j++; j < EC_NUM; j++)
2048 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2049 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2051 printf("%s ", BN_options());
2052 #ifndef OPENSSL_NO_MD2
2053 printf("%s ", MD2_options());
2055 #ifndef OPENSSL_NO_RC4
2056 printf("%s ", RC4_options());
2058 #ifndef OPENSSL_NO_DES
2059 printf("%s ", DES_options());
2061 #ifndef OPENSSL_NO_AES
2062 printf("%s ", AES_options());
2064 #ifndef OPENSSL_NO_IDEA
2065 printf("%s ", idea_options());
2067 #ifndef OPENSSL_NO_BF
2068 printf("%s ", BF_options());
2070 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2078 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2081 for (j = 0; j < SIZE_NUM; j++)
2082 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2086 for (k = 0; k < ALGOR_NUM; k++) {
2090 printf("+F:%d:%s", k, names[k]);
2092 printf("%-13s", names[k]);
2093 for (j = 0; j < SIZE_NUM; j++) {
2094 if (results[k][j] > 10000 && !mr)
2095 printf(" %11.2fk", results[k][j] / 1e3);
2097 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2101 #ifndef OPENSSL_NO_RSA
2103 for (k = 0; k < RSA_NUM; k++) {
2107 printf("%18ssign verify sign/s verify/s\n", " ");
2111 printf("+F2:%u:%u:%f:%f\n",
2112 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2114 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2115 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2116 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2119 #ifndef OPENSSL_NO_DSA
2121 for (k = 0; k < DSA_NUM; k++) {
2125 printf("%18ssign verify sign/s verify/s\n", " ");
2129 printf("+F3:%u:%u:%f:%f\n",
2130 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2132 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2133 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2134 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2137 #ifndef OPENSSL_NO_EC
2139 for (k = 0; k < EC_NUM; k++) {
2143 printf("%30ssign verify sign/s verify/s\n", " ");
2148 printf("+F4:%u:%u:%f:%f\n",
2149 k, test_curves_bits[k],
2150 ecdsa_results[k][0], ecdsa_results[k][1]);
2152 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2153 test_curves_bits[k],
2154 test_curves_names[k],
2155 ecdsa_results[k][0], ecdsa_results[k][1],
2156 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2160 #ifndef OPENSSL_NO_EC
2162 for (k = 0; k < EC_NUM; k++) {
2166 printf("%30sop op/s\n", " ");
2170 printf("+F5:%u:%u:%f:%f\n",
2171 k, test_curves_bits[k],
2172 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2175 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2176 test_curves_bits[k],
2177 test_curves_names[k],
2178 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2185 ERR_print_errors(bio_err);
2186 OPENSSL_free(save_buf);
2187 OPENSSL_free(save_buf2);
2188 #ifndef OPENSSL_NO_RSA
2189 for (i = 0; i < RSA_NUM; i++)
2190 RSA_free(rsa_key[i]);
2192 #ifndef OPENSSL_NO_DSA
2193 for (i = 0; i < DSA_NUM; i++)
2194 DSA_free(dsa_key[i]);
2197 #ifndef OPENSSL_NO_EC
2198 for (i = 0; i < EC_NUM; i++) {
2199 EC_KEY_free(ecdsa[i]);
2200 EC_KEY_free(ecdh_a[i]);
2201 EC_KEY_free(ecdh_b[i]);
2208 static void print_message(const char *s, long num, int length)
2212 mr ? "+DT:%s:%d:%d\n"
2213 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2214 (void)BIO_flush(bio_err);
2218 mr ? "+DN:%s:%ld:%d\n"
2219 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2220 (void)BIO_flush(bio_err);
2224 static void pkey_print_message(const char *str, const char *str2, long num,
2229 mr ? "+DTP:%d:%s:%s:%d\n"
2230 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2231 (void)BIO_flush(bio_err);
2235 mr ? "+DNP:%ld:%d:%s:%s\n"
2236 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2237 (void)BIO_flush(bio_err);
2241 static void print_result(int alg, int run_no, int count, double time_used)
2244 mr ? "+R:%d:%s:%f\n"
2245 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2246 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2250 static char *sstrsep(char **string, const char *delim)
2253 char *token = *string;
2258 memset(isdelim, 0, sizeof isdelim);
2262 isdelim[(unsigned char)(*delim)] = 1;
2266 while (!isdelim[(unsigned char)(**string)]) {
2278 static int do_multi(int multi)
2283 static char sep[] = ":";
2285 fds = malloc(sizeof(*fds) * multi);
2286 for (n = 0; n < multi; ++n) {
2287 if (pipe(fd) == -1) {
2288 BIO_printf(bio_err, "pipe failure\n");
2292 (void)BIO_flush(bio_err);
2299 if (dup(fd[1]) == -1) {
2300 BIO_printf(bio_err, "dup failed\n");
2309 printf("Forked child %d\n", n);
2312 /* for now, assume the pipe is long enough to take all the output */
2313 for (n = 0; n < multi; ++n) {
2318 f = fdopen(fds[n], "r");
2319 while (fgets(buf, sizeof buf, f)) {
2320 p = strchr(buf, '\n');
2323 if (buf[0] != '+') {
2324 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2328 printf("Got: %s from %d\n", buf, n);
2329 if (strncmp(buf, "+F:", 3) == 0) {
2334 alg = atoi(sstrsep(&p, sep));
2336 for (j = 0; j < SIZE_NUM; ++j)
2337 results[alg][j] += atof(sstrsep(&p, sep));
2338 } else if (strncmp(buf, "+F2:", 4) == 0) {
2343 k = atoi(sstrsep(&p, sep));
2346 d = atof(sstrsep(&p, sep));
2348 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2350 rsa_results[k][0] = d;
2352 d = atof(sstrsep(&p, sep));
2354 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2356 rsa_results[k][1] = d;
2358 # ifndef OPENSSL_NO_DSA
2359 else if (strncmp(buf, "+F3:", 4) == 0) {
2364 k = atoi(sstrsep(&p, sep));
2367 d = atof(sstrsep(&p, sep));
2369 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2371 dsa_results[k][0] = d;
2373 d = atof(sstrsep(&p, sep));
2375 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2377 dsa_results[k][1] = d;
2380 # ifndef OPENSSL_NO_EC
2381 else if (strncmp(buf, "+F4:", 4) == 0) {
2386 k = atoi(sstrsep(&p, sep));
2389 d = atof(sstrsep(&p, sep));
2391 ecdsa_results[k][0] =
2392 1 / (1 / ecdsa_results[k][0] + 1 / d);
2394 ecdsa_results[k][0] = d;
2396 d = atof(sstrsep(&p, sep));
2398 ecdsa_results[k][1] =
2399 1 / (1 / ecdsa_results[k][1] + 1 / d);
2401 ecdsa_results[k][1] = d;
2405 # ifndef OPENSSL_NO_EC
2406 else if (strncmp(buf, "+F5:", 4) == 0) {
2411 k = atoi(sstrsep(&p, sep));
2414 d = atof(sstrsep(&p, sep));
2416 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2418 ecdh_results[k][0] = d;
2423 else if (strncmp(buf, "+H:", 3) == 0) {
2426 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2436 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2438 static int mblengths[] =
2439 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2440 int j, count, num = OSSL_NELEM(lengths);
2441 const char *alg_name;
2442 unsigned char *inp, *out, no_key[32], no_iv[16];
2446 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2447 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2448 EVP_CIPHER_CTX_init(&ctx);
2449 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2450 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2452 alg_name = OBJ_nid2ln(evp_cipher->nid);
2454 for (j = 0; j < num; j++) {
2455 print_message(alg_name, 0, mblengths[j]);
2457 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2458 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2459 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2460 size_t len = mblengths[j];
2463 memset(aad, 0, 8); /* avoid uninitialized values */
2464 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2465 aad[9] = 3; /* version */
2467 aad[11] = 0; /* length */
2469 mb_param.out = NULL;
2472 mb_param.interleave = 8;
2474 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2475 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2476 sizeof(mb_param), &mb_param);
2482 EVP_CIPHER_CTX_ctrl(&ctx,
2483 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2484 sizeof(mb_param), &mb_param);
2488 RAND_bytes(out, 16);
2492 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2493 EVP_CTRL_AEAD_TLS1_AAD,
2494 EVP_AEAD_TLS1_AAD_LEN, aad);
2495 EVP_Cipher(&ctx, out, inp, len + pad);
2499 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2500 : "%d %s's in %.2fs\n", count, "evp", d);
2501 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2505 fprintf(stdout, "+H");
2506 for (j = 0; j < num; j++)
2507 fprintf(stdout, ":%d", mblengths[j]);
2508 fprintf(stdout, "\n");
2509 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2510 for (j = 0; j < num; j++)
2511 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2512 fprintf(stdout, "\n");
2515 "The 'numbers' are in 1000s of bytes per second processed.\n");
2516 fprintf(stdout, "type ");
2517 for (j = 0; j < num; j++)
2518 fprintf(stdout, "%7d bytes", mblengths[j]);
2519 fprintf(stdout, "\n");
2520 fprintf(stdout, "%-24s", alg_name);
2522 for (j = 0; j < num; j++) {
2523 if (results[D_EVP][j] > 10000)
2524 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2526 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2528 fprintf(stdout, "\n");