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 #if defined(TIMES) || defined(USE_TOD)
362 {"elapsed", OPT_ELAPSED, '-',
363 "Measure time in real time instead of CPU user time"},
365 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
366 {"decrypt", OPT_DECRYPT, '-',
367 "Time decryption instead of encryption (only EVP)"},
369 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
371 {"mr", OPT_MR, '-', "Produce machine readable output"},
373 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
374 #ifndef OPENSSL_NO_ENGINE
375 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
390 #define D_CBC_IDEA 10
391 #define D_CBC_SEED 11
395 #define D_CBC_CAST 15
396 #define D_CBC_128_AES 16
397 #define D_CBC_192_AES 17
398 #define D_CBC_256_AES 18
399 #define D_CBC_128_CML 19
400 #define D_CBC_192_CML 20
401 #define D_CBC_256_CML 21
405 #define D_WHIRLPOOL 25
406 #define D_IGE_128_AES 26
407 #define D_IGE_192_AES 27
408 #define D_IGE_256_AES 28
410 OPT_PAIR doit_choices[] = {
411 #ifndef OPENSSL_NO_MD2
414 #ifndef OPENSSL_NO_MDC2
417 #ifndef OPENSSL_NO_MD4
420 #ifndef OPENSSL_NO_MD5
423 #ifndef OPENSSL_NO_MD5
427 {"sha256", D_SHA256},
428 {"sha512", D_SHA512},
429 #ifndef OPENSSL_NO_WHIRLPOOL
430 {"whirlpool", D_WHIRLPOOL},
432 #ifndef OPENSSL_NO_RIPEMD
433 {"ripemd", D_RMD160},
434 {"rmd160", D_RMD160},
435 {"ripemd160", D_RMD160},
437 #ifndef OPENSSL_NO_RC4
440 #ifndef OPENSSL_NO_DES
441 {"des-cbc", D_CBC_DES},
442 {"des-ede3", D_EDE3_DES},
444 #ifndef OPENSSL_NO_AES
445 {"aes-128-cbc", D_CBC_128_AES},
446 {"aes-192-cbc", D_CBC_192_AES},
447 {"aes-256-cbc", D_CBC_256_AES},
448 {"aes-128-ige", D_IGE_128_AES},
449 {"aes-192-ige", D_IGE_192_AES},
450 {"aes-256-ige", D_IGE_256_AES},
452 #ifndef OPENSSL_NO_RC2
453 {"rc2-cbc", D_CBC_RC2},
456 #ifndef OPENSSL_NO_RC5
457 {"rc5-cbc", D_CBC_RC5},
460 #ifndef OPENSSL_NO_IDEA
461 {"idea-cbc", D_CBC_IDEA},
462 {"idea", D_CBC_IDEA},
464 #ifndef OPENSSL_NO_SEED
465 {"seed-cbc", D_CBC_SEED},
466 {"seed", D_CBC_SEED},
468 #ifndef OPENSSL_NO_BF
469 {"bf-cbc", D_CBC_BF},
470 {"blowfish", D_CBC_BF},
473 #ifndef OPENSSL_NO_CAST
474 {"cast-cbc", D_CBC_CAST},
475 {"cast", D_CBC_CAST},
476 {"cast5", D_CBC_CAST},
485 static OPT_PAIR dsa_choices[] = {
486 {"dsa512", R_DSA_512},
487 {"dsa1024", R_DSA_1024},
488 {"dsa2048", R_DSA_2048},
498 #define R_RSA_15360 6
499 static OPT_PAIR rsa_choices[] = {
500 {"rsa512", R_RSA_512},
501 {"rsa1024", R_RSA_1024},
502 {"rsa2048", R_RSA_2048},
503 {"rsa3072", R_RSA_3072},
504 {"rsa4096", R_RSA_4096},
505 {"rsa7680", R_RSA_7680},
506 {"rsa15360", R_RSA_15360},
526 #ifndef OPENSSL_NO_ECA
527 static OPT_PAIR ecdsa_choices[] = {
528 {"ecdsap160", R_EC_P160},
529 {"ecdsap192", R_EC_P192},
530 {"ecdsap224", R_EC_P224},
531 {"ecdsap256", R_EC_P256},
532 {"ecdsap384", R_EC_P384},
533 {"ecdsap521", R_EC_P521},
534 {"ecdsak163", R_EC_K163},
535 {"ecdsak233", R_EC_K233},
536 {"ecdsak283", R_EC_K283},
537 {"ecdsak409", R_EC_K409},
538 {"ecdsak571", R_EC_K571},
539 {"ecdsab163", R_EC_B163},
540 {"ecdsab233", R_EC_B233},
541 {"ecdsab283", R_EC_B283},
542 {"ecdsab409", R_EC_B409},
543 {"ecdsab571", R_EC_B571},
546 static OPT_PAIR ecdh_choices[] = {
547 {"ecdhp160", R_EC_P160},
548 {"ecdhp192", R_EC_P192},
549 {"ecdhp224", R_EC_P224},
550 {"ecdhp256", R_EC_P256},
551 {"ecdhp384", R_EC_P384},
552 {"ecdhp521", R_EC_P521},
553 {"ecdhk163", R_EC_K163},
554 {"ecdhk233", R_EC_K233},
555 {"ecdhk283", R_EC_K283},
556 {"ecdhk409", R_EC_K409},
557 {"ecdhk571", R_EC_K571},
558 {"ecdhb163", R_EC_B163},
559 {"ecdhb233", R_EC_B233},
560 {"ecdhb283", R_EC_B283},
561 {"ecdhb409", R_EC_B409},
562 {"ecdhb571", R_EC_B571},
567 int speed_main(int argc, char **argv)
570 const EVP_CIPHER *evp_cipher = NULL;
571 const EVP_MD *evp_md = NULL;
574 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
575 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
576 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
577 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
578 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
579 unsigned char *buf = NULL, *buf2 = NULL;
580 unsigned char *save_buf = NULL, *save_buf2 = NULL;
581 unsigned char md[EVP_MAX_MD_SIZE];
585 /* What follows are the buffers and key material. */
586 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
589 #ifndef OPENSSL_NO_MD2
590 unsigned char md2[MD2_DIGEST_LENGTH];
592 #ifndef OPENSSL_NO_MDC2
593 unsigned char mdc2[MDC2_DIGEST_LENGTH];
595 #ifndef OPENSSL_NO_MD4
596 unsigned char md4[MD4_DIGEST_LENGTH];
598 #ifndef OPENSSL_NO_MD5
599 unsigned char md5[MD5_DIGEST_LENGTH];
600 unsigned char hmac[MD5_DIGEST_LENGTH];
602 unsigned char sha[SHA_DIGEST_LENGTH];
603 unsigned char sha256[SHA256_DIGEST_LENGTH];
604 unsigned char sha512[SHA512_DIGEST_LENGTH];
605 #ifndef OPENSSL_NO_WHIRLPOOL
606 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
608 #ifndef OPENSSL_NO_RIPEMD
609 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
611 #ifndef OPENSSL_NO_RC4
614 #ifndef OPENSSL_NO_RC5
617 #ifndef OPENSSL_NO_RC2
620 #ifndef OPENSSL_NO_IDEA
621 IDEA_KEY_SCHEDULE idea_ks;
623 #ifndef OPENSSL_NO_SEED
624 SEED_KEY_SCHEDULE seed_ks;
626 #ifndef OPENSSL_NO_BF
629 #ifndef OPENSSL_NO_CAST
632 static const unsigned char key16[16] = {
633 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
634 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
636 #ifndef OPENSSL_NO_AES
637 static const unsigned char key24[24] = {
638 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
639 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
640 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
642 static const unsigned char key32[32] = {
643 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
644 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
645 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
646 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
649 #ifndef OPENSSL_NO_CAMELLIA
650 static const unsigned char ckey24[24] = {
651 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
652 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
653 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
655 static const unsigned char ckey32[32] = {
656 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
657 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
658 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
659 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
661 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
663 #ifndef OPENSSL_NO_AES
664 # define MAX_BLOCK_SIZE 128
666 # define MAX_BLOCK_SIZE 64
668 unsigned char DES_iv[8];
669 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
670 #ifndef OPENSSL_NO_DES
671 static DES_cblock key = {
672 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
674 static DES_cblock key2 = {
675 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
677 static DES_cblock key3 = {
678 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
680 DES_key_schedule sch;
681 DES_key_schedule sch2;
682 DES_key_schedule sch3;
684 #ifndef OPENSSL_NO_AES
685 AES_KEY aes_ks1, aes_ks2, aes_ks3;
687 #ifndef OPENSSL_NO_RSA
689 RSA *rsa_key[RSA_NUM];
690 long rsa_c[RSA_NUM][2];
691 static unsigned int rsa_bits[RSA_NUM] = {
692 512, 1024, 2048, 3072, 4096, 7680, 15360
694 static unsigned char *rsa_data[RSA_NUM] = {
695 test512, test1024, test2048, test3072, test4096, test7680, test15360
697 static int rsa_data_length[RSA_NUM] = {
698 sizeof(test512), sizeof(test1024),
699 sizeof(test2048), sizeof(test3072),
700 sizeof(test4096), sizeof(test7680),
704 #ifndef OPENSSL_NO_DSA
705 DSA *dsa_key[DSA_NUM];
706 long dsa_c[DSA_NUM][2];
707 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
709 #ifndef OPENSSL_NO_EC
711 * We only test over the following curves as they are representative, To
712 * add tests over more curves, simply add the curve NID and curve name to
713 * the following arrays and increase the EC_NUM value accordingly.
715 static unsigned int test_curves[EC_NUM] = {
717 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
718 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
720 NID_sect163k1, NID_sect233k1, NID_sect283k1,
721 NID_sect409k1, NID_sect571k1, NID_sect163r2,
722 NID_sect233r1, NID_sect283r1, NID_sect409r1,
725 static const char *test_curves_names[EC_NUM] = {
727 "secp160r1", "nistp192", "nistp224",
728 "nistp256", "nistp384", "nistp521",
730 "nistk163", "nistk233", "nistk283",
731 "nistk409", "nistk571", "nistb163",
732 "nistb233", "nistb283", "nistb409",
735 static int test_curves_bits[EC_NUM] = {
744 #ifndef OPENSSL_NO_EC
745 unsigned char ecdsasig[256];
746 unsigned int ecdsasiglen;
747 EC_KEY *ecdsa[EC_NUM];
748 long ecdsa_c[EC_NUM][2];
749 int ecdsa_doit[EC_NUM];
750 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
751 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
752 int secret_size_a, secret_size_b;
755 long ecdh_c[EC_NUM][2];
756 int ecdh_doit[EC_NUM];
762 memset(results, 0, sizeof(results));
763 #ifndef OPENSSL_NO_DSA
764 memset(dsa_key, 0, sizeof(dsa_key));
766 #ifndef OPENSSL_NO_EC
767 for (i = 0; i < EC_NUM; i++)
769 for (i = 0; i < EC_NUM; i++)
770 ecdh_a[i] = ecdh_b[i] = NULL;
772 #ifndef OPENSSL_NO_RSA
773 memset(rsa_key, 0, sizeof(rsa_key));
774 for (i = 0; i < RSA_NUM; i++)
778 memset(c, 0, sizeof(c));
779 memset(DES_iv, 0, sizeof(DES_iv));
780 memset(iv, 0, sizeof(iv));
782 for (i = 0; i < ALGOR_NUM; i++)
784 for (i = 0; i < RSA_NUM; i++)
786 for (i = 0; i < DSA_NUM; i++)
788 #ifndef OPENSSL_NO_EC
789 for (i = 0; i < EC_NUM; i++)
791 for (i = 0; i < EC_NUM; i++)
795 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
796 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
799 prog = opt_init(argc, argv, speed_options);
800 while ((o = opt_next()) != OPT_EOF) {
805 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
808 opt_help(speed_options);
815 evp_cipher = EVP_get_cipherbyname(opt_arg());
816 if (evp_cipher == NULL)
817 evp_md = EVP_get_digestbyname(opt_arg());
818 if (evp_cipher == NULL && evp_md == NULL) {
820 "%s: %s an unknown cipher or digest\n",
830 (void)setup_engine(opt_arg(), 0);
834 multi = atoi(opt_arg());
838 if (!opt_int(opt_arg(), &misalign))
840 if (misalign > MISALIGN) {
842 "%s: Maximum offset is %d\n", prog, MISALIGN);
845 buf = buf_malloc + misalign;
846 buf2 = buf2_malloc + misalign;
856 argc = opt_num_rest();
859 /* Remaining arguments are algorithms. */
860 for ( ; *argv; argv++) {
861 if (found(*argv, doit_choices, &i)) {
865 #ifndef OPENSSL_NO_DES
866 if (strcmp(*argv, "des") == 0) {
867 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
871 if (strcmp(*argv, "sha") == 0) {
872 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
875 #ifndef OPENSSL_NO_RSA
877 if (strcmp(*argv, "openssl") == 0) {
878 RSA_set_default_method(RSA_PKCS1_SSLeay());
882 if (strcmp(*argv, "rsa") == 0) {
883 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
884 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
885 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
886 rsa_doit[R_RSA_15360] = 1;
889 if (found(*argv, rsa_choices, &i)) {
894 #ifndef OPENSSL_NO_DSA
895 if (strcmp(*argv, "dsa") == 0) {
896 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
897 dsa_doit[R_DSA_2048] = 1;
900 if (found(*argv, dsa_choices, &i)) {
905 #ifndef OPENSSL_NO_AES
906 if (strcmp(*argv, "aes") == 0) {
907 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
908 doit[D_CBC_256_AES] = 1;
912 #ifndef OPENSSL_NO_CAMELLIA
913 if (strcmp(*argv, "camellia") == 0) {
914 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
915 doit[D_CBC_256_CML] = 1;
919 #ifndef OPENSSL_NO_EC
920 if (strcmp(*argv, "ecdsa") == 0) {
921 for (i = 0; i < EC_NUM; i++)
925 if (found(*argv, ecdsa_choices, &i)) {
929 if (strcmp(*argv, "ecdh") == 0) {
930 for (i = 0; i < EC_NUM; i++)
934 if (found(*argv, ecdh_choices, &i)) {
939 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
944 if (multi && do_multi(multi))
948 /* No parameters; turn on everything. */
950 for (i = 0; i < ALGOR_NUM; i++)
953 for (i = 0; i < RSA_NUM; i++)
955 for (i = 0; i < DSA_NUM; i++)
957 #ifndef OPENSSL_NO_EC
958 for (i = 0; i < EC_NUM; i++)
960 for (i = 0; i < EC_NUM; i++)
964 for (i = 0; i < ALGOR_NUM; i++)
968 if (usertime == 0 && !mr)
970 "You have chosen to measure elapsed time "
971 "instead of user CPU time.\n");
973 #ifndef OPENSSL_NO_RSA
974 for (i = 0; i < RSA_NUM; i++) {
975 const unsigned char *p;
978 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
979 if (rsa_key[i] == NULL) {
980 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
987 #ifndef OPENSSL_NO_DSA
988 dsa_key[0] = get_dsa512();
989 dsa_key[1] = get_dsa1024();
990 dsa_key[2] = get_dsa2048();
993 #ifndef OPENSSL_NO_DES
994 DES_set_key_unchecked(&key, &sch);
995 DES_set_key_unchecked(&key2, &sch2);
996 DES_set_key_unchecked(&key3, &sch3);
998 #ifndef OPENSSL_NO_AES
999 AES_set_encrypt_key(key16, 128, &aes_ks1);
1000 AES_set_encrypt_key(key24, 192, &aes_ks2);
1001 AES_set_encrypt_key(key32, 256, &aes_ks3);
1003 #ifndef OPENSSL_NO_CAMELLIA
1004 Camellia_set_key(key16, 128, &camellia_ks1);
1005 Camellia_set_key(ckey24, 192, &camellia_ks2);
1006 Camellia_set_key(ckey32, 256, &camellia_ks3);
1008 #ifndef OPENSSL_NO_IDEA
1009 idea_set_encrypt_key(key16, &idea_ks);
1011 #ifndef OPENSSL_NO_SEED
1012 SEED_set_key(key16, &seed_ks);
1014 #ifndef OPENSSL_NO_RC4
1015 RC4_set_key(&rc4_ks, 16, key16);
1017 #ifndef OPENSSL_NO_RC2
1018 RC2_set_key(&rc2_ks, 16, key16, 128);
1020 #ifndef OPENSSL_NO_RC5
1021 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1023 #ifndef OPENSSL_NO_BF
1024 BF_set_key(&bf_ks, 16, key16);
1026 #ifndef OPENSSL_NO_CAST
1027 CAST_set_key(&cast_ks, 16, key16);
1029 #ifndef OPENSSL_NO_RSA
1030 memset(rsa_c, 0, sizeof(rsa_c));
1033 # ifndef OPENSSL_NO_DES
1034 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1040 for (it = count; it; it--)
1041 DES_ecb_encrypt((DES_cblock *)buf,
1042 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1046 c[D_MD2][0] = count / 10;
1047 c[D_MDC2][0] = count / 10;
1048 c[D_MD4][0] = count;
1049 c[D_MD5][0] = count;
1050 c[D_HMAC][0] = count;
1051 c[D_SHA1][0] = count;
1052 c[D_RMD160][0] = count;
1053 c[D_RC4][0] = count * 5;
1054 c[D_CBC_DES][0] = count;
1055 c[D_EDE3_DES][0] = count / 3;
1056 c[D_CBC_IDEA][0] = count;
1057 c[D_CBC_SEED][0] = count;
1058 c[D_CBC_RC2][0] = count;
1059 c[D_CBC_RC5][0] = count;
1060 c[D_CBC_BF][0] = count;
1061 c[D_CBC_CAST][0] = count;
1062 c[D_CBC_128_AES][0] = count;
1063 c[D_CBC_192_AES][0] = count;
1064 c[D_CBC_256_AES][0] = count;
1065 c[D_CBC_128_CML][0] = count;
1066 c[D_CBC_192_CML][0] = count;
1067 c[D_CBC_256_CML][0] = count;
1068 c[D_SHA256][0] = count;
1069 c[D_SHA512][0] = count;
1070 c[D_WHIRLPOOL][0] = count;
1071 c[D_IGE_128_AES][0] = count;
1072 c[D_IGE_192_AES][0] = count;
1073 c[D_IGE_256_AES][0] = count;
1074 c[D_GHASH][0] = count;
1076 for (i = 1; i < SIZE_NUM; i++) {
1079 l0 = (long)lengths[0];
1080 l1 = (long)lengths[i];
1082 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1083 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1084 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1085 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1086 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1087 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1088 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1089 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1090 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1091 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1093 l0 = (long)lengths[i - 1];
1095 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1096 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1097 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1098 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1099 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1100 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1101 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1102 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1103 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1104 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1105 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1106 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1107 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1108 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1109 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1110 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1111 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1112 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1115 # ifndef OPENSSL_NO_RSA
1116 rsa_c[R_RSA_512][0] = count / 2000;
1117 rsa_c[R_RSA_512][1] = count / 400;
1118 for (i = 1; i < RSA_NUM; i++) {
1119 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1120 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1121 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1124 if (rsa_c[i][0] == 0) {
1132 # ifndef OPENSSL_NO_DSA
1133 dsa_c[R_DSA_512][0] = count / 1000;
1134 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1135 for (i = 1; i < DSA_NUM; i++) {
1136 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1137 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1138 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1141 if (dsa_c[i] == 0) {
1149 # ifndef OPENSSL_NO_EC
1150 ecdsa_c[R_EC_P160][0] = count / 1000;
1151 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1152 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1153 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1154 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1155 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1158 if (ecdsa_c[i] == 0) {
1164 ecdsa_c[R_EC_K163][0] = count / 1000;
1165 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1166 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1167 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1168 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1169 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1172 if (ecdsa_c[i] == 0) {
1178 ecdsa_c[R_EC_B163][0] = count / 1000;
1179 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1180 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1181 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1182 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1183 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1186 if (ecdsa_c[i] == 0) {
1193 ecdh_c[R_EC_P160][0] = count / 1000;
1194 ecdh_c[R_EC_P160][1] = count / 1000;
1195 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1196 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1197 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1198 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1201 if (ecdh_c[i] == 0) {
1207 ecdh_c[R_EC_K163][0] = count / 1000;
1208 ecdh_c[R_EC_K163][1] = count / 1000;
1209 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1210 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1211 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1212 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1215 if (ecdh_c[i] == 0) {
1221 ecdh_c[R_EC_B163][0] = count / 1000;
1222 ecdh_c[R_EC_B163][1] = count / 1000;
1223 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1224 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1225 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1226 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1229 if (ecdh_c[i] == 0) {
1237 # define COND(d) (count < (d))
1238 # define COUNT(d) (d)
1240 /* not worth fixing */
1241 # error "You cannot disable DES on systems without SIGALRM."
1242 # endif /* OPENSSL_NO_DES */
1244 # define COND(c) (run && count<0x7fffffff)
1245 # define COUNT(d) (count)
1247 signal(SIGALRM, sig_done);
1249 #endif /* SIGALRM */
1251 #ifndef OPENSSL_NO_MD2
1253 for (j = 0; j < SIZE_NUM; j++) {
1254 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1256 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1257 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1260 print_result(D_MD2, j, count, d);
1264 #ifndef OPENSSL_NO_MDC2
1266 for (j = 0; j < SIZE_NUM; j++) {
1267 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1269 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1270 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1273 print_result(D_MDC2, j, count, d);
1278 #ifndef OPENSSL_NO_MD4
1280 for (j = 0; j < SIZE_NUM; j++) {
1281 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1283 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1284 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1285 NULL, EVP_md4(), NULL);
1287 print_result(D_MD4, j, count, d);
1292 #ifndef OPENSSL_NO_MD5
1294 for (j = 0; j < SIZE_NUM; j++) {
1295 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1297 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1298 MD5(buf, lengths[j], md5);
1300 print_result(D_MD5, j, count, d);
1305 #if !defined(OPENSSL_NO_MD5)
1309 HMAC_CTX_init(&hctx);
1310 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1311 16, EVP_md5(), NULL);
1313 for (j = 0; j < SIZE_NUM; j++) {
1314 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1316 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1317 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1318 HMAC_Update(&hctx, buf, lengths[j]);
1319 HMAC_Final(&hctx, &(hmac[0]), NULL);
1322 print_result(D_HMAC, j, count, d);
1324 HMAC_CTX_cleanup(&hctx);
1328 for (j = 0; j < SIZE_NUM; j++) {
1329 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1331 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1332 SHA1(buf, lengths[j], sha);
1334 print_result(D_SHA1, j, count, d);
1337 if (doit[D_SHA256]) {
1338 for (j = 0; j < SIZE_NUM; j++) {
1339 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1341 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1342 SHA256(buf, lengths[j], sha256);
1344 print_result(D_SHA256, j, count, d);
1347 if (doit[D_SHA512]) {
1348 for (j = 0; j < SIZE_NUM; j++) {
1349 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1351 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1352 SHA512(buf, lengths[j], sha512);
1354 print_result(D_SHA512, j, count, d);
1358 #ifndef OPENSSL_NO_WHIRLPOOL
1359 if (doit[D_WHIRLPOOL]) {
1360 for (j = 0; j < SIZE_NUM; j++) {
1361 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1363 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1364 WHIRLPOOL(buf, lengths[j], whirlpool);
1366 print_result(D_WHIRLPOOL, j, count, d);
1371 #ifndef OPENSSL_NO_RMD160
1372 if (doit[D_RMD160]) {
1373 for (j = 0; j < SIZE_NUM; j++) {
1374 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1376 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1377 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1378 EVP_ripemd160(), NULL);
1380 print_result(D_RMD160, j, count, d);
1384 #ifndef OPENSSL_NO_RC4
1386 for (j = 0; j < SIZE_NUM; j++) {
1387 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1389 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1390 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1392 print_result(D_RC4, j, count, d);
1396 #ifndef OPENSSL_NO_DES
1397 if (doit[D_CBC_DES]) {
1398 for (j = 0; j < SIZE_NUM; j++) {
1399 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1401 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1402 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1403 &DES_iv, DES_ENCRYPT);
1405 print_result(D_CBC_DES, j, count, d);
1409 if (doit[D_EDE3_DES]) {
1410 for (j = 0; j < SIZE_NUM; j++) {
1411 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1413 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1414 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1416 &DES_iv, DES_ENCRYPT);
1418 print_result(D_EDE3_DES, j, count, d);
1422 #ifndef OPENSSL_NO_AES
1423 if (doit[D_CBC_128_AES]) {
1424 for (j = 0; j < SIZE_NUM; j++) {
1425 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1428 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1429 AES_cbc_encrypt(buf, buf,
1430 (unsigned long)lengths[j], &aes_ks1,
1433 print_result(D_CBC_128_AES, j, count, d);
1436 if (doit[D_CBC_192_AES]) {
1437 for (j = 0; j < SIZE_NUM; j++) {
1438 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1441 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1442 AES_cbc_encrypt(buf, buf,
1443 (unsigned long)lengths[j], &aes_ks2,
1446 print_result(D_CBC_192_AES, j, count, d);
1449 if (doit[D_CBC_256_AES]) {
1450 for (j = 0; j < SIZE_NUM; j++) {
1451 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1454 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1455 AES_cbc_encrypt(buf, buf,
1456 (unsigned long)lengths[j], &aes_ks3,
1459 print_result(D_CBC_256_AES, j, count, d);
1463 if (doit[D_IGE_128_AES]) {
1464 for (j = 0; j < SIZE_NUM; j++) {
1465 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1468 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1469 AES_ige_encrypt(buf, buf2,
1470 (unsigned long)lengths[j], &aes_ks1,
1473 print_result(D_IGE_128_AES, j, count, d);
1476 if (doit[D_IGE_192_AES]) {
1477 for (j = 0; j < SIZE_NUM; j++) {
1478 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1481 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1482 AES_ige_encrypt(buf, buf2,
1483 (unsigned long)lengths[j], &aes_ks2,
1486 print_result(D_IGE_192_AES, j, count, d);
1489 if (doit[D_IGE_256_AES]) {
1490 for (j = 0; j < SIZE_NUM; j++) {
1491 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1494 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1495 AES_ige_encrypt(buf, buf2,
1496 (unsigned long)lengths[j], &aes_ks3,
1499 print_result(D_IGE_256_AES, j, count, d);
1502 if (doit[D_GHASH]) {
1503 GCM128_CONTEXT *ctx =
1504 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1505 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1507 for (j = 0; j < SIZE_NUM; j++) {
1508 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1510 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1511 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1513 print_result(D_GHASH, j, count, d);
1515 CRYPTO_gcm128_release(ctx);
1518 #ifndef OPENSSL_NO_CAMELLIA
1519 if (doit[D_CBC_128_CML]) {
1520 for (j = 0; j < SIZE_NUM; j++) {
1521 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1524 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1525 Camellia_cbc_encrypt(buf, buf,
1526 (unsigned long)lengths[j], &camellia_ks1,
1527 iv, CAMELLIA_ENCRYPT);
1529 print_result(D_CBC_128_CML, j, count, d);
1532 if (doit[D_CBC_192_CML]) {
1533 for (j = 0; j < SIZE_NUM; j++) {
1534 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1537 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1538 Camellia_cbc_encrypt(buf, buf,
1539 (unsigned long)lengths[j], &camellia_ks2,
1540 iv, CAMELLIA_ENCRYPT);
1542 print_result(D_CBC_192_CML, j, count, d);
1545 if (doit[D_CBC_256_CML]) {
1546 for (j = 0; j < SIZE_NUM; j++) {
1547 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1550 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1551 Camellia_cbc_encrypt(buf, buf,
1552 (unsigned long)lengths[j], &camellia_ks3,
1553 iv, CAMELLIA_ENCRYPT);
1555 print_result(D_CBC_256_CML, j, count, d);
1559 #ifndef OPENSSL_NO_IDEA
1560 if (doit[D_CBC_IDEA]) {
1561 for (j = 0; j < SIZE_NUM; j++) {
1562 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1564 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1565 idea_cbc_encrypt(buf, buf,
1566 (unsigned long)lengths[j], &idea_ks,
1569 print_result(D_CBC_IDEA, j, count, d);
1573 #ifndef OPENSSL_NO_SEED
1574 if (doit[D_CBC_SEED]) {
1575 for (j = 0; j < SIZE_NUM; j++) {
1576 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1578 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1579 SEED_cbc_encrypt(buf, buf,
1580 (unsigned long)lengths[j], &seed_ks, iv, 1);
1582 print_result(D_CBC_SEED, j, count, d);
1586 #ifndef OPENSSL_NO_RC2
1587 if (doit[D_CBC_RC2]) {
1588 for (j = 0; j < SIZE_NUM; j++) {
1589 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1591 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1592 RC2_cbc_encrypt(buf, buf,
1593 (unsigned long)lengths[j], &rc2_ks,
1596 print_result(D_CBC_RC2, j, count, d);
1600 #ifndef OPENSSL_NO_RC5
1601 if (doit[D_CBC_RC5]) {
1602 for (j = 0; j < SIZE_NUM; j++) {
1603 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1605 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1606 RC5_32_cbc_encrypt(buf, buf,
1607 (unsigned long)lengths[j], &rc5_ks,
1610 print_result(D_CBC_RC5, j, count, d);
1614 #ifndef OPENSSL_NO_BF
1615 if (doit[D_CBC_BF]) {
1616 for (j = 0; j < SIZE_NUM; j++) {
1617 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1619 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1620 BF_cbc_encrypt(buf, buf,
1621 (unsigned long)lengths[j], &bf_ks,
1624 print_result(D_CBC_BF, j, count, d);
1628 #ifndef OPENSSL_NO_CAST
1629 if (doit[D_CBC_CAST]) {
1630 for (j = 0; j < SIZE_NUM; j++) {
1631 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1633 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1634 CAST_cbc_encrypt(buf, buf,
1635 (unsigned long)lengths[j], &cast_ks,
1638 print_result(D_CBC_CAST, j, count, d);
1644 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1645 if (multiblock && evp_cipher) {
1647 (EVP_CIPHER_flags(evp_cipher) &
1648 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1649 fprintf(stderr, "%s is not multi-block capable\n",
1650 OBJ_nid2ln(evp_cipher->nid));
1653 multiblock_speed(evp_cipher);
1658 for (j = 0; j < SIZE_NUM; j++) {
1663 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1665 * -O3 -fschedule-insns messes up an optimization here!
1666 * names[D_EVP] somehow becomes NULL
1668 print_message(names[D_EVP], save_count, lengths[j]);
1670 EVP_CIPHER_CTX_init(&ctx);
1672 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1674 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1675 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1679 for (count = 0, run = 1;
1680 COND(save_count * 4 * lengths[0] / lengths[j]);
1682 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1684 for (count = 0, run = 1;
1685 COND(save_count * 4 * lengths[0] / lengths[j]);
1687 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1689 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1691 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1693 EVP_CIPHER_CTX_cleanup(&ctx);
1696 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1697 print_message(names[D_EVP], save_count, lengths[j]);
1700 for (count = 0, run = 1;
1701 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1702 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1706 print_result(D_EVP, j, count, d);
1710 RAND_bytes(buf, 36);
1711 #ifndef OPENSSL_NO_RSA
1712 for (j = 0; j < RSA_NUM; j++) {
1716 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1719 "RSA sign failure. No RSA sign will be done.\n");
1720 ERR_print_errors(bio_err);
1723 pkey_print_message("private", "rsa",
1724 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1725 /* RSA_blinding_on(rsa_key[j],NULL); */
1727 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1728 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1729 &rsa_num, rsa_key[j]);
1731 BIO_printf(bio_err, "RSA sign failure\n");
1732 ERR_print_errors(bio_err);
1739 mr ? "+R1:%ld:%d:%.2f\n"
1740 : "%ld %d bit private RSA's in %.2fs\n",
1741 count, rsa_bits[j], d);
1742 rsa_results[j][0] = d / (double)count;
1746 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1749 "RSA verify failure. No RSA verify will be done.\n");
1750 ERR_print_errors(bio_err);
1753 pkey_print_message("public", "rsa",
1754 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1756 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1757 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1758 rsa_num, rsa_key[j]);
1760 BIO_printf(bio_err, "RSA verify failure\n");
1761 ERR_print_errors(bio_err);
1768 mr ? "+R2:%ld:%d:%.2f\n"
1769 : "%ld %d bit public RSA's in %.2fs\n",
1770 count, rsa_bits[j], d);
1771 rsa_results[j][1] = d / (double)count;
1774 if (rsa_count <= 1) {
1775 /* if longer than 10s, don't do any more */
1776 for (j++; j < RSA_NUM; j++)
1782 RAND_bytes(buf, 20);
1783 #ifndef OPENSSL_NO_DSA
1784 if (RAND_status() != 1) {
1785 RAND_seed(rnd_seed, sizeof rnd_seed);
1788 for (j = 0; j < DSA_NUM; j++) {
1795 /* DSA_generate_key(dsa_key[j]); */
1796 /* DSA_sign_setup(dsa_key[j],NULL); */
1797 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1800 "DSA sign failure. No DSA sign will be done.\n");
1801 ERR_print_errors(bio_err);
1804 pkey_print_message("sign", "dsa",
1805 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1807 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1808 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1810 BIO_printf(bio_err, "DSA sign failure\n");
1811 ERR_print_errors(bio_err);
1818 mr ? "+R3:%ld:%d:%.2f\n"
1819 : "%ld %d bit DSA signs in %.2fs\n",
1820 count, dsa_bits[j], d);
1821 dsa_results[j][0] = d / (double)count;
1825 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1828 "DSA verify failure. No DSA verify will be done.\n");
1829 ERR_print_errors(bio_err);
1832 pkey_print_message("verify", "dsa",
1833 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1835 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1836 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1838 BIO_printf(bio_err, "DSA verify failure\n");
1839 ERR_print_errors(bio_err);
1846 mr ? "+R4:%ld:%d:%.2f\n"
1847 : "%ld %d bit DSA verify in %.2fs\n",
1848 count, dsa_bits[j], d);
1849 dsa_results[j][1] = d / (double)count;
1852 if (rsa_count <= 1) {
1853 /* if longer than 10s, don't do any more */
1854 for (j++; j < DSA_NUM; j++)
1862 #ifndef OPENSSL_NO_EC
1863 if (RAND_status() != 1) {
1864 RAND_seed(rnd_seed, sizeof rnd_seed);
1867 for (j = 0; j < EC_NUM; j++) {
1871 continue; /* Ignore Curve */
1872 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1873 if (ecdsa[j] == NULL) {
1874 BIO_printf(bio_err, "ECDSA failure.\n");
1875 ERR_print_errors(bio_err);
1878 EC_KEY_precompute_mult(ecdsa[j], NULL);
1879 /* Perform ECDSA signature test */
1880 EC_KEY_generate_key(ecdsa[j]);
1881 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1884 "ECDSA sign failure. No ECDSA sign will be done.\n");
1885 ERR_print_errors(bio_err);
1888 pkey_print_message("sign", "ecdsa",
1890 test_curves_bits[j], ECDSA_SECONDS);
1893 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1894 st = ECDSA_sign(0, buf, 20,
1895 ecdsasig, &ecdsasiglen, ecdsa[j]);
1897 BIO_printf(bio_err, "ECDSA sign failure\n");
1898 ERR_print_errors(bio_err);
1906 mr ? "+R5:%ld:%d:%.2f\n" :
1907 "%ld %d bit ECDSA signs in %.2fs \n",
1908 count, test_curves_bits[j], d);
1909 ecdsa_results[j][0] = d / (double)count;
1913 /* Perform ECDSA verification test */
1914 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1917 "ECDSA verify failure. No ECDSA verify will be done.\n");
1918 ERR_print_errors(bio_err);
1921 pkey_print_message("verify", "ecdsa",
1923 test_curves_bits[j], ECDSA_SECONDS);
1925 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1926 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1929 BIO_printf(bio_err, "ECDSA verify failure\n");
1930 ERR_print_errors(bio_err);
1937 mr ? "+R6:%ld:%d:%.2f\n"
1938 : "%ld %d bit ECDSA verify in %.2fs\n",
1939 count, test_curves_bits[j], d);
1940 ecdsa_results[j][1] = d / (double)count;
1943 if (rsa_count <= 1) {
1944 /* if longer than 10s, don't do any more */
1945 for (j++; j < EC_NUM; j++)
1954 #ifndef OPENSSL_NO_EC
1955 if (RAND_status() != 1) {
1956 RAND_seed(rnd_seed, sizeof rnd_seed);
1959 for (j = 0; j < EC_NUM; j++) {
1962 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1963 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1964 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1965 BIO_printf(bio_err, "ECDH failure.\n");
1966 ERR_print_errors(bio_err);
1969 /* generate two ECDH key pairs */
1970 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1971 !EC_KEY_generate_key(ecdh_b[j])) {
1972 BIO_printf(bio_err, "ECDH key generation failure.\n");
1973 ERR_print_errors(bio_err);
1977 * If field size is not more than 24 octets, then use SHA-1
1978 * hash of result; otherwise, use result (see section 4.8 of
1979 * draft-ietf-tls-ecc-03.txt).
1981 int field_size, outlen;
1982 void *(*kdf) (const void *in, size_t inlen, void *out,
1985 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1986 if (field_size <= 24 * 8) {
1987 outlen = KDF1_SHA1_len;
1990 outlen = (field_size + 7) / 8;
1994 ECDH_compute_key(secret_a, outlen,
1995 EC_KEY_get0_public_key(ecdh_b[j]),
1998 ECDH_compute_key(secret_b, outlen,
1999 EC_KEY_get0_public_key(ecdh_a[j]),
2001 if (secret_size_a != secret_size_b)
2006 for (secret_idx = 0; (secret_idx < secret_size_a)
2007 && (ecdh_checks == 1); secret_idx++) {
2008 if (secret_a[secret_idx] != secret_b[secret_idx])
2012 if (ecdh_checks == 0) {
2013 BIO_printf(bio_err, "ECDH computations don't match.\n");
2014 ERR_print_errors(bio_err);
2018 pkey_print_message("", "ecdh",
2020 test_curves_bits[j], ECDH_SECONDS);
2022 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2023 ECDH_compute_key(secret_a, outlen,
2024 EC_KEY_get0_public_key(ecdh_b[j]),
2029 mr ? "+R7:%ld:%d:%.2f\n" :
2030 "%ld %d-bit ECDH ops in %.2fs\n", count,
2031 test_curves_bits[j], d);
2032 ecdh_results[j][0] = d / (double)count;
2037 if (rsa_count <= 1) {
2038 /* if longer than 10s, don't do any more */
2039 for (j++; j < EC_NUM; j++)
2050 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2051 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2053 printf("%s ", BN_options());
2054 #ifndef OPENSSL_NO_MD2
2055 printf("%s ", MD2_options());
2057 #ifndef OPENSSL_NO_RC4
2058 printf("%s ", RC4_options());
2060 #ifndef OPENSSL_NO_DES
2061 printf("%s ", DES_options());
2063 #ifndef OPENSSL_NO_AES
2064 printf("%s ", AES_options());
2066 #ifndef OPENSSL_NO_IDEA
2067 printf("%s ", idea_options());
2069 #ifndef OPENSSL_NO_BF
2070 printf("%s ", BF_options());
2072 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2080 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2083 for (j = 0; j < SIZE_NUM; j++)
2084 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2088 for (k = 0; k < ALGOR_NUM; k++) {
2092 printf("+F:%d:%s", k, names[k]);
2094 printf("%-13s", names[k]);
2095 for (j = 0; j < SIZE_NUM; j++) {
2096 if (results[k][j] > 10000 && !mr)
2097 printf(" %11.2fk", results[k][j] / 1e3);
2099 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2103 #ifndef OPENSSL_NO_RSA
2105 for (k = 0; k < RSA_NUM; k++) {
2109 printf("%18ssign verify sign/s verify/s\n", " ");
2113 printf("+F2:%u:%u:%f:%f\n",
2114 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2116 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2117 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2118 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2121 #ifndef OPENSSL_NO_DSA
2123 for (k = 0; k < DSA_NUM; k++) {
2127 printf("%18ssign verify sign/s verify/s\n", " ");
2131 printf("+F3:%u:%u:%f:%f\n",
2132 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2134 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2135 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2136 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2139 #ifndef OPENSSL_NO_EC
2141 for (k = 0; k < EC_NUM; k++) {
2145 printf("%30ssign verify sign/s verify/s\n", " ");
2150 printf("+F4:%u:%u:%f:%f\n",
2151 k, test_curves_bits[k],
2152 ecdsa_results[k][0], ecdsa_results[k][1]);
2154 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2155 test_curves_bits[k],
2156 test_curves_names[k],
2157 ecdsa_results[k][0], ecdsa_results[k][1],
2158 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2162 #ifndef OPENSSL_NO_EC
2164 for (k = 0; k < EC_NUM; k++) {
2168 printf("%30sop op/s\n", " ");
2172 printf("+F5:%u:%u:%f:%f\n",
2173 k, test_curves_bits[k],
2174 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2177 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2178 test_curves_bits[k],
2179 test_curves_names[k],
2180 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2187 ERR_print_errors(bio_err);
2188 OPENSSL_free(save_buf);
2189 OPENSSL_free(save_buf2);
2190 #ifndef OPENSSL_NO_RSA
2191 for (i = 0; i < RSA_NUM; i++)
2192 RSA_free(rsa_key[i]);
2194 #ifndef OPENSSL_NO_DSA
2195 for (i = 0; i < DSA_NUM; i++)
2196 DSA_free(dsa_key[i]);
2199 #ifndef OPENSSL_NO_EC
2200 for (i = 0; i < EC_NUM; i++) {
2201 EC_KEY_free(ecdsa[i]);
2202 EC_KEY_free(ecdh_a[i]);
2203 EC_KEY_free(ecdh_b[i]);
2210 static void print_message(const char *s, long num, int length)
2214 mr ? "+DT:%s:%d:%d\n"
2215 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2216 (void)BIO_flush(bio_err);
2220 mr ? "+DN:%s:%ld:%d\n"
2221 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2222 (void)BIO_flush(bio_err);
2226 static void pkey_print_message(const char *str, const char *str2, long num,
2231 mr ? "+DTP:%d:%s:%s:%d\n"
2232 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2233 (void)BIO_flush(bio_err);
2237 mr ? "+DNP:%ld:%d:%s:%s\n"
2238 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2239 (void)BIO_flush(bio_err);
2243 static void print_result(int alg, int run_no, int count, double time_used)
2246 mr ? "+R:%d:%s:%f\n"
2247 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2248 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2252 static char *sstrsep(char **string, const char *delim)
2255 char *token = *string;
2260 memset(isdelim, 0, sizeof isdelim);
2264 isdelim[(unsigned char)(*delim)] = 1;
2268 while (!isdelim[(unsigned char)(**string)]) {
2280 static int do_multi(int multi)
2285 static char sep[] = ":";
2287 fds = malloc(sizeof(*fds) * multi);
2288 for (n = 0; n < multi; ++n) {
2289 if (pipe(fd) == -1) {
2290 fprintf(stderr, "pipe failure\n");
2301 if (dup(fd[1]) == -1) {
2302 fprintf(stderr, "dup failed\n");
2311 printf("Forked child %d\n", n);
2314 /* for now, assume the pipe is long enough to take all the output */
2315 for (n = 0; n < multi; ++n) {
2320 f = fdopen(fds[n], "r");
2321 while (fgets(buf, sizeof buf, f)) {
2322 p = strchr(buf, '\n');
2325 if (buf[0] != '+') {
2326 fprintf(stderr, "Don't understand line '%s' from child %d\n",
2330 printf("Got: %s from %d\n", buf, n);
2331 if (strncmp(buf, "+F:", 3) == 0) {
2336 alg = atoi(sstrsep(&p, sep));
2338 for (j = 0; j < SIZE_NUM; ++j)
2339 results[alg][j] += atof(sstrsep(&p, sep));
2340 } else if (strncmp(buf, "+F2:", 4) == 0) {
2345 k = atoi(sstrsep(&p, sep));
2348 d = atof(sstrsep(&p, sep));
2350 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2352 rsa_results[k][0] = d;
2354 d = atof(sstrsep(&p, sep));
2356 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2358 rsa_results[k][1] = d;
2360 # ifndef OPENSSL_NO_DSA
2361 else if (strncmp(buf, "+F3:", 4) == 0) {
2366 k = atoi(sstrsep(&p, sep));
2369 d = atof(sstrsep(&p, sep));
2371 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2373 dsa_results[k][0] = d;
2375 d = atof(sstrsep(&p, sep));
2377 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2379 dsa_results[k][1] = d;
2382 # ifndef OPENSSL_NO_EC
2383 else if (strncmp(buf, "+F4:", 4) == 0) {
2388 k = atoi(sstrsep(&p, sep));
2391 d = atof(sstrsep(&p, sep));
2393 ecdsa_results[k][0] =
2394 1 / (1 / ecdsa_results[k][0] + 1 / d);
2396 ecdsa_results[k][0] = d;
2398 d = atof(sstrsep(&p, sep));
2400 ecdsa_results[k][1] =
2401 1 / (1 / ecdsa_results[k][1] + 1 / d);
2403 ecdsa_results[k][1] = d;
2407 # ifndef OPENSSL_NO_EC
2408 else if (strncmp(buf, "+F5:", 4) == 0) {
2413 k = atoi(sstrsep(&p, sep));
2416 d = atof(sstrsep(&p, sep));
2418 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2420 ecdh_results[k][0] = d;
2425 else if (strncmp(buf, "+H:", 3) == 0) {
2428 fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n);
2438 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2440 static int mblengths[] =
2441 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2442 int j, count, num = OSSL_NELEM(lengths);
2443 const char *alg_name;
2444 unsigned char *inp, *out, no_key[32], no_iv[16];
2448 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2449 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2450 EVP_CIPHER_CTX_init(&ctx);
2451 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2452 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2454 alg_name = OBJ_nid2ln(evp_cipher->nid);
2456 for (j = 0; j < num; j++) {
2457 print_message(alg_name, 0, mblengths[j]);
2459 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2460 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2461 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2462 size_t len = mblengths[j];
2465 memset(aad, 0, 8); /* avoid uninitialized values */
2466 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2467 aad[9] = 3; /* version */
2469 aad[11] = 0; /* length */
2471 mb_param.out = NULL;
2474 mb_param.interleave = 8;
2476 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2477 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2478 sizeof(mb_param), &mb_param);
2484 EVP_CIPHER_CTX_ctrl(&ctx,
2485 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2486 sizeof(mb_param), &mb_param);
2490 RAND_bytes(out, 16);
2494 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2495 EVP_CTRL_AEAD_TLS1_AAD,
2496 EVP_AEAD_TLS1_AAD_LEN, aad);
2497 EVP_Cipher(&ctx, out, inp, len + pad);
2501 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2502 : "%d %s's in %.2fs\n", count, "evp", d);
2503 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2507 fprintf(stdout, "+H");
2508 for (j = 0; j < num; j++)
2509 fprintf(stdout, ":%d", mblengths[j]);
2510 fprintf(stdout, "\n");
2511 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2512 for (j = 0; j < num; j++)
2513 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2514 fprintf(stdout, "\n");
2517 "The 'numbers' are in 1000s of bytes per second processed.\n");
2518 fprintf(stdout, "type ");
2519 for (j = 0; j < num; j++)
2520 fprintf(stdout, "%7d bytes", mblengths[j]);
2521 fprintf(stdout, "\n");
2522 fprintf(stdout, "%-24s", alg_name);
2524 for (j = 0; j < num; j++) {
2525 if (results[D_EVP][j] > 10000)
2526 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2528 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2530 fprintf(stdout, "\n");