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 #if defined(TIMES) || defined(USE_TOD)
368 {"elapsed", OPT_ELAPSED, '-',
369 "Measure time in real time instead of CPU user time"},
372 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
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 if (!app_load_modules(NULL))
862 /* Remaining arguments are algorithms. */
863 for ( ; *argv; argv++) {
864 if (found(*argv, doit_choices, &i)) {
868 #ifndef OPENSSL_NO_DES
869 if (strcmp(*argv, "des") == 0) {
870 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
874 if (strcmp(*argv, "sha") == 0) {
875 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
878 #ifndef OPENSSL_NO_RSA
880 if (strcmp(*argv, "openssl") == 0) {
881 RSA_set_default_method(RSA_PKCS1_SSLeay());
885 if (strcmp(*argv, "rsa") == 0) {
886 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
887 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
888 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
889 rsa_doit[R_RSA_15360] = 1;
892 if (found(*argv, rsa_choices, &i)) {
897 #ifndef OPENSSL_NO_DSA
898 if (strcmp(*argv, "dsa") == 0) {
899 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
900 dsa_doit[R_DSA_2048] = 1;
903 if (found(*argv, dsa_choices, &i)) {
908 #ifndef OPENSSL_NO_AES
909 if (strcmp(*argv, "aes") == 0) {
910 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
911 doit[D_CBC_256_AES] = 1;
915 #ifndef OPENSSL_NO_CAMELLIA
916 if (strcmp(*argv, "camellia") == 0) {
917 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
918 doit[D_CBC_256_CML] = 1;
922 #ifndef OPENSSL_NO_EC
923 if (strcmp(*argv, "ecdsa") == 0) {
924 for (i = 0; i < EC_NUM; i++)
928 if (found(*argv, ecdsa_choices, &i)) {
932 if (strcmp(*argv, "ecdh") == 0) {
933 for (i = 0; i < EC_NUM; i++)
937 if (found(*argv, ecdh_choices, &i)) {
942 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
947 if (multi && do_multi(multi))
951 /* No parameters; turn on everything. */
953 for (i = 0; i < ALGOR_NUM; i++)
956 for (i = 0; i < RSA_NUM; i++)
958 for (i = 0; i < DSA_NUM; i++)
960 #ifndef OPENSSL_NO_EC
961 for (i = 0; i < EC_NUM; i++)
963 for (i = 0; i < EC_NUM; i++)
967 for (i = 0; i < ALGOR_NUM; i++)
971 if (usertime == 0 && !mr)
973 "You have chosen to measure elapsed time "
974 "instead of user CPU time.\n");
976 #ifndef OPENSSL_NO_RSA
977 for (i = 0; i < RSA_NUM; i++) {
978 const unsigned char *p;
981 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
982 if (rsa_key[i] == NULL) {
983 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
990 #ifndef OPENSSL_NO_DSA
991 dsa_key[0] = get_dsa512();
992 dsa_key[1] = get_dsa1024();
993 dsa_key[2] = get_dsa2048();
996 #ifndef OPENSSL_NO_DES
997 DES_set_key_unchecked(&key, &sch);
998 DES_set_key_unchecked(&key2, &sch2);
999 DES_set_key_unchecked(&key3, &sch3);
1001 #ifndef OPENSSL_NO_AES
1002 AES_set_encrypt_key(key16, 128, &aes_ks1);
1003 AES_set_encrypt_key(key24, 192, &aes_ks2);
1004 AES_set_encrypt_key(key32, 256, &aes_ks3);
1006 #ifndef OPENSSL_NO_CAMELLIA
1007 Camellia_set_key(key16, 128, &camellia_ks1);
1008 Camellia_set_key(ckey24, 192, &camellia_ks2);
1009 Camellia_set_key(ckey32, 256, &camellia_ks3);
1011 #ifndef OPENSSL_NO_IDEA
1012 idea_set_encrypt_key(key16, &idea_ks);
1014 #ifndef OPENSSL_NO_SEED
1015 SEED_set_key(key16, &seed_ks);
1017 #ifndef OPENSSL_NO_RC4
1018 RC4_set_key(&rc4_ks, 16, key16);
1020 #ifndef OPENSSL_NO_RC2
1021 RC2_set_key(&rc2_ks, 16, key16, 128);
1023 #ifndef OPENSSL_NO_RC5
1024 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1026 #ifndef OPENSSL_NO_BF
1027 BF_set_key(&bf_ks, 16, key16);
1029 #ifndef OPENSSL_NO_CAST
1030 CAST_set_key(&cast_ks, 16, key16);
1032 #ifndef OPENSSL_NO_RSA
1033 memset(rsa_c, 0, sizeof(rsa_c));
1036 # ifndef OPENSSL_NO_DES
1037 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1043 for (it = count; it; it--)
1044 DES_ecb_encrypt((DES_cblock *)buf,
1045 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1049 c[D_MD2][0] = count / 10;
1050 c[D_MDC2][0] = count / 10;
1051 c[D_MD4][0] = count;
1052 c[D_MD5][0] = count;
1053 c[D_HMAC][0] = count;
1054 c[D_SHA1][0] = count;
1055 c[D_RMD160][0] = count;
1056 c[D_RC4][0] = count * 5;
1057 c[D_CBC_DES][0] = count;
1058 c[D_EDE3_DES][0] = count / 3;
1059 c[D_CBC_IDEA][0] = count;
1060 c[D_CBC_SEED][0] = count;
1061 c[D_CBC_RC2][0] = count;
1062 c[D_CBC_RC5][0] = count;
1063 c[D_CBC_BF][0] = count;
1064 c[D_CBC_CAST][0] = count;
1065 c[D_CBC_128_AES][0] = count;
1066 c[D_CBC_192_AES][0] = count;
1067 c[D_CBC_256_AES][0] = count;
1068 c[D_CBC_128_CML][0] = count;
1069 c[D_CBC_192_CML][0] = count;
1070 c[D_CBC_256_CML][0] = count;
1071 c[D_SHA256][0] = count;
1072 c[D_SHA512][0] = count;
1073 c[D_WHIRLPOOL][0] = count;
1074 c[D_IGE_128_AES][0] = count;
1075 c[D_IGE_192_AES][0] = count;
1076 c[D_IGE_256_AES][0] = count;
1077 c[D_GHASH][0] = count;
1079 for (i = 1; i < SIZE_NUM; i++) {
1082 l0 = (long)lengths[0];
1083 l1 = (long)lengths[i];
1085 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1086 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1087 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1088 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1089 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1090 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1091 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1092 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1093 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1094 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1096 l0 = (long)lengths[i - 1];
1098 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1099 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1100 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1101 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1102 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1103 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1104 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1105 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1106 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1107 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1108 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1109 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1110 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1111 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1112 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1113 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1114 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1115 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1118 # ifndef OPENSSL_NO_RSA
1119 rsa_c[R_RSA_512][0] = count / 2000;
1120 rsa_c[R_RSA_512][1] = count / 400;
1121 for (i = 1; i < RSA_NUM; i++) {
1122 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1123 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1124 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1127 if (rsa_c[i][0] == 0) {
1135 # ifndef OPENSSL_NO_DSA
1136 dsa_c[R_DSA_512][0] = count / 1000;
1137 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1138 for (i = 1; i < DSA_NUM; i++) {
1139 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1140 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1141 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1144 if (dsa_c[i] == 0) {
1152 # ifndef OPENSSL_NO_EC
1153 ecdsa_c[R_EC_P160][0] = count / 1000;
1154 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1155 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1156 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1157 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1158 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1161 if (ecdsa_c[i] == 0) {
1167 ecdsa_c[R_EC_K163][0] = count / 1000;
1168 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1169 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1170 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1171 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1172 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1175 if (ecdsa_c[i] == 0) {
1181 ecdsa_c[R_EC_B163][0] = count / 1000;
1182 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1183 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1184 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1185 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1186 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1189 if (ecdsa_c[i] == 0) {
1196 ecdh_c[R_EC_P160][0] = count / 1000;
1197 ecdh_c[R_EC_P160][1] = count / 1000;
1198 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1199 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1200 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1201 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1204 if (ecdh_c[i] == 0) {
1210 ecdh_c[R_EC_K163][0] = count / 1000;
1211 ecdh_c[R_EC_K163][1] = count / 1000;
1212 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1213 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1214 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1215 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1218 if (ecdh_c[i] == 0) {
1224 ecdh_c[R_EC_B163][0] = count / 1000;
1225 ecdh_c[R_EC_B163][1] = count / 1000;
1226 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1227 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1228 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1229 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1232 if (ecdh_c[i] == 0) {
1240 # define COND(d) (count < (d))
1241 # define COUNT(d) (d)
1243 /* not worth fixing */
1244 # error "You cannot disable DES on systems without SIGALRM."
1245 # endif /* OPENSSL_NO_DES */
1247 # define COND(c) (run && count<0x7fffffff)
1248 # define COUNT(d) (count)
1250 signal(SIGALRM, sig_done);
1252 #endif /* SIGALRM */
1254 #ifndef OPENSSL_NO_MD2
1256 for (j = 0; j < SIZE_NUM; j++) {
1257 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1259 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1260 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1263 print_result(D_MD2, j, count, d);
1267 #ifndef OPENSSL_NO_MDC2
1269 for (j = 0; j < SIZE_NUM; j++) {
1270 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1272 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1273 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1276 print_result(D_MDC2, j, count, d);
1281 #ifndef OPENSSL_NO_MD4
1283 for (j = 0; j < SIZE_NUM; j++) {
1284 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1286 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1287 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1288 NULL, EVP_md4(), NULL);
1290 print_result(D_MD4, j, count, d);
1295 #ifndef OPENSSL_NO_MD5
1297 for (j = 0; j < SIZE_NUM; j++) {
1298 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1300 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1301 MD5(buf, lengths[j], md5);
1303 print_result(D_MD5, j, count, d);
1308 #if !defined(OPENSSL_NO_MD5)
1312 HMAC_CTX_init(&hctx);
1313 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1314 16, EVP_md5(), NULL);
1316 for (j = 0; j < SIZE_NUM; j++) {
1317 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1319 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1320 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1321 HMAC_Update(&hctx, buf, lengths[j]);
1322 HMAC_Final(&hctx, &(hmac[0]), NULL);
1325 print_result(D_HMAC, j, count, d);
1327 HMAC_CTX_cleanup(&hctx);
1331 for (j = 0; j < SIZE_NUM; j++) {
1332 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1334 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1335 SHA1(buf, lengths[j], sha);
1337 print_result(D_SHA1, j, count, d);
1340 if (doit[D_SHA256]) {
1341 for (j = 0; j < SIZE_NUM; j++) {
1342 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1344 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1345 SHA256(buf, lengths[j], sha256);
1347 print_result(D_SHA256, j, count, d);
1350 if (doit[D_SHA512]) {
1351 for (j = 0; j < SIZE_NUM; j++) {
1352 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1354 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1355 SHA512(buf, lengths[j], sha512);
1357 print_result(D_SHA512, j, count, d);
1361 #ifndef OPENSSL_NO_WHIRLPOOL
1362 if (doit[D_WHIRLPOOL]) {
1363 for (j = 0; j < SIZE_NUM; j++) {
1364 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1366 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1367 WHIRLPOOL(buf, lengths[j], whirlpool);
1369 print_result(D_WHIRLPOOL, j, count, d);
1374 #ifndef OPENSSL_NO_RMD160
1375 if (doit[D_RMD160]) {
1376 for (j = 0; j < SIZE_NUM; j++) {
1377 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1379 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1380 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1381 EVP_ripemd160(), NULL);
1383 print_result(D_RMD160, j, count, d);
1387 #ifndef OPENSSL_NO_RC4
1389 for (j = 0; j < SIZE_NUM; j++) {
1390 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1392 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1393 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1395 print_result(D_RC4, j, count, d);
1399 #ifndef OPENSSL_NO_DES
1400 if (doit[D_CBC_DES]) {
1401 for (j = 0; j < SIZE_NUM; j++) {
1402 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1404 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1405 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1406 &DES_iv, DES_ENCRYPT);
1408 print_result(D_CBC_DES, j, count, d);
1412 if (doit[D_EDE3_DES]) {
1413 for (j = 0; j < SIZE_NUM; j++) {
1414 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1416 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1417 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1419 &DES_iv, DES_ENCRYPT);
1421 print_result(D_EDE3_DES, j, count, d);
1425 #ifndef OPENSSL_NO_AES
1426 if (doit[D_CBC_128_AES]) {
1427 for (j = 0; j < SIZE_NUM; j++) {
1428 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1431 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1432 AES_cbc_encrypt(buf, buf,
1433 (unsigned long)lengths[j], &aes_ks1,
1436 print_result(D_CBC_128_AES, j, count, d);
1439 if (doit[D_CBC_192_AES]) {
1440 for (j = 0; j < SIZE_NUM; j++) {
1441 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1444 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1445 AES_cbc_encrypt(buf, buf,
1446 (unsigned long)lengths[j], &aes_ks2,
1449 print_result(D_CBC_192_AES, j, count, d);
1452 if (doit[D_CBC_256_AES]) {
1453 for (j = 0; j < SIZE_NUM; j++) {
1454 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1457 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1458 AES_cbc_encrypt(buf, buf,
1459 (unsigned long)lengths[j], &aes_ks3,
1462 print_result(D_CBC_256_AES, j, count, d);
1466 if (doit[D_IGE_128_AES]) {
1467 for (j = 0; j < SIZE_NUM; j++) {
1468 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1471 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1472 AES_ige_encrypt(buf, buf2,
1473 (unsigned long)lengths[j], &aes_ks1,
1476 print_result(D_IGE_128_AES, j, count, d);
1479 if (doit[D_IGE_192_AES]) {
1480 for (j = 0; j < SIZE_NUM; j++) {
1481 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1484 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1485 AES_ige_encrypt(buf, buf2,
1486 (unsigned long)lengths[j], &aes_ks2,
1489 print_result(D_IGE_192_AES, j, count, d);
1492 if (doit[D_IGE_256_AES]) {
1493 for (j = 0; j < SIZE_NUM; j++) {
1494 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1497 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1498 AES_ige_encrypt(buf, buf2,
1499 (unsigned long)lengths[j], &aes_ks3,
1502 print_result(D_IGE_256_AES, j, count, d);
1505 if (doit[D_GHASH]) {
1506 GCM128_CONTEXT *ctx =
1507 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1508 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1510 for (j = 0; j < SIZE_NUM; j++) {
1511 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1513 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1514 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1516 print_result(D_GHASH, j, count, d);
1518 CRYPTO_gcm128_release(ctx);
1521 #ifndef OPENSSL_NO_CAMELLIA
1522 if (doit[D_CBC_128_CML]) {
1523 for (j = 0; j < SIZE_NUM; j++) {
1524 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1527 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1528 Camellia_cbc_encrypt(buf, buf,
1529 (unsigned long)lengths[j], &camellia_ks1,
1530 iv, CAMELLIA_ENCRYPT);
1532 print_result(D_CBC_128_CML, j, count, d);
1535 if (doit[D_CBC_192_CML]) {
1536 for (j = 0; j < SIZE_NUM; j++) {
1537 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1540 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1541 Camellia_cbc_encrypt(buf, buf,
1542 (unsigned long)lengths[j], &camellia_ks2,
1543 iv, CAMELLIA_ENCRYPT);
1545 print_result(D_CBC_192_CML, j, count, d);
1548 if (doit[D_CBC_256_CML]) {
1549 for (j = 0; j < SIZE_NUM; j++) {
1550 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1553 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1554 Camellia_cbc_encrypt(buf, buf,
1555 (unsigned long)lengths[j], &camellia_ks3,
1556 iv, CAMELLIA_ENCRYPT);
1558 print_result(D_CBC_256_CML, j, count, d);
1562 #ifndef OPENSSL_NO_IDEA
1563 if (doit[D_CBC_IDEA]) {
1564 for (j = 0; j < SIZE_NUM; j++) {
1565 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1567 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1568 idea_cbc_encrypt(buf, buf,
1569 (unsigned long)lengths[j], &idea_ks,
1572 print_result(D_CBC_IDEA, j, count, d);
1576 #ifndef OPENSSL_NO_SEED
1577 if (doit[D_CBC_SEED]) {
1578 for (j = 0; j < SIZE_NUM; j++) {
1579 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1581 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1582 SEED_cbc_encrypt(buf, buf,
1583 (unsigned long)lengths[j], &seed_ks, iv, 1);
1585 print_result(D_CBC_SEED, j, count, d);
1589 #ifndef OPENSSL_NO_RC2
1590 if (doit[D_CBC_RC2]) {
1591 for (j = 0; j < SIZE_NUM; j++) {
1592 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1594 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1595 RC2_cbc_encrypt(buf, buf,
1596 (unsigned long)lengths[j], &rc2_ks,
1599 print_result(D_CBC_RC2, j, count, d);
1603 #ifndef OPENSSL_NO_RC5
1604 if (doit[D_CBC_RC5]) {
1605 for (j = 0; j < SIZE_NUM; j++) {
1606 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1608 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1609 RC5_32_cbc_encrypt(buf, buf,
1610 (unsigned long)lengths[j], &rc5_ks,
1613 print_result(D_CBC_RC5, j, count, d);
1617 #ifndef OPENSSL_NO_BF
1618 if (doit[D_CBC_BF]) {
1619 for (j = 0; j < SIZE_NUM; j++) {
1620 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1622 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1623 BF_cbc_encrypt(buf, buf,
1624 (unsigned long)lengths[j], &bf_ks,
1627 print_result(D_CBC_BF, j, count, d);
1631 #ifndef OPENSSL_NO_CAST
1632 if (doit[D_CBC_CAST]) {
1633 for (j = 0; j < SIZE_NUM; j++) {
1634 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1636 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1637 CAST_cbc_encrypt(buf, buf,
1638 (unsigned long)lengths[j], &cast_ks,
1641 print_result(D_CBC_CAST, j, count, d);
1647 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1648 if (multiblock && evp_cipher) {
1650 (EVP_CIPHER_flags(evp_cipher) &
1651 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1652 fprintf(stderr, "%s is not multi-block capable\n",
1653 OBJ_nid2ln(evp_cipher->nid));
1656 multiblock_speed(evp_cipher);
1661 for (j = 0; j < SIZE_NUM; j++) {
1666 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1668 * -O3 -fschedule-insns messes up an optimization here!
1669 * names[D_EVP] somehow becomes NULL
1671 print_message(names[D_EVP], save_count, lengths[j]);
1673 EVP_CIPHER_CTX_init(&ctx);
1675 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1677 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1678 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1682 for (count = 0, run = 1;
1683 COND(save_count * 4 * lengths[0] / lengths[j]);
1685 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1687 for (count = 0, run = 1;
1688 COND(save_count * 4 * lengths[0] / lengths[j]);
1690 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1692 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1694 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1696 EVP_CIPHER_CTX_cleanup(&ctx);
1699 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1700 print_message(names[D_EVP], save_count, lengths[j]);
1703 for (count = 0, run = 1;
1704 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1705 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1709 print_result(D_EVP, j, count, d);
1713 RAND_bytes(buf, 36);
1714 #ifndef OPENSSL_NO_RSA
1715 for (j = 0; j < RSA_NUM; j++) {
1719 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1722 "RSA sign failure. No RSA sign will be done.\n");
1723 ERR_print_errors(bio_err);
1726 pkey_print_message("private", "rsa",
1727 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1728 /* RSA_blinding_on(rsa_key[j],NULL); */
1730 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1731 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1732 &rsa_num, rsa_key[j]);
1734 BIO_printf(bio_err, "RSA sign failure\n");
1735 ERR_print_errors(bio_err);
1742 mr ? "+R1:%ld:%d:%.2f\n"
1743 : "%ld %d bit private RSA's in %.2fs\n",
1744 count, rsa_bits[j], d);
1745 rsa_results[j][0] = d / (double)count;
1749 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1752 "RSA verify failure. No RSA verify will be done.\n");
1753 ERR_print_errors(bio_err);
1756 pkey_print_message("public", "rsa",
1757 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1759 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1760 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1761 rsa_num, rsa_key[j]);
1763 BIO_printf(bio_err, "RSA verify failure\n");
1764 ERR_print_errors(bio_err);
1771 mr ? "+R2:%ld:%d:%.2f\n"
1772 : "%ld %d bit public RSA's in %.2fs\n",
1773 count, rsa_bits[j], d);
1774 rsa_results[j][1] = d / (double)count;
1777 if (rsa_count <= 1) {
1778 /* if longer than 10s, don't do any more */
1779 for (j++; j < RSA_NUM; j++)
1785 RAND_bytes(buf, 20);
1786 #ifndef OPENSSL_NO_DSA
1787 if (RAND_status() != 1) {
1788 RAND_seed(rnd_seed, sizeof rnd_seed);
1791 for (j = 0; j < DSA_NUM; j++) {
1798 /* DSA_generate_key(dsa_key[j]); */
1799 /* DSA_sign_setup(dsa_key[j],NULL); */
1800 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1803 "DSA sign failure. No DSA sign will be done.\n");
1804 ERR_print_errors(bio_err);
1807 pkey_print_message("sign", "dsa",
1808 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1810 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1811 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1813 BIO_printf(bio_err, "DSA sign failure\n");
1814 ERR_print_errors(bio_err);
1821 mr ? "+R3:%ld:%d:%.2f\n"
1822 : "%ld %d bit DSA signs in %.2fs\n",
1823 count, dsa_bits[j], d);
1824 dsa_results[j][0] = d / (double)count;
1828 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1831 "DSA verify failure. No DSA verify will be done.\n");
1832 ERR_print_errors(bio_err);
1835 pkey_print_message("verify", "dsa",
1836 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1838 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1839 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1841 BIO_printf(bio_err, "DSA verify failure\n");
1842 ERR_print_errors(bio_err);
1849 mr ? "+R4:%ld:%d:%.2f\n"
1850 : "%ld %d bit DSA verify in %.2fs\n",
1851 count, dsa_bits[j], d);
1852 dsa_results[j][1] = d / (double)count;
1855 if (rsa_count <= 1) {
1856 /* if longer than 10s, don't do any more */
1857 for (j++; j < DSA_NUM; j++)
1865 #ifndef OPENSSL_NO_EC
1866 if (RAND_status() != 1) {
1867 RAND_seed(rnd_seed, sizeof rnd_seed);
1870 for (j = 0; j < EC_NUM; j++) {
1874 continue; /* Ignore Curve */
1875 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1876 if (ecdsa[j] == NULL) {
1877 BIO_printf(bio_err, "ECDSA failure.\n");
1878 ERR_print_errors(bio_err);
1881 EC_KEY_precompute_mult(ecdsa[j], NULL);
1882 /* Perform ECDSA signature test */
1883 EC_KEY_generate_key(ecdsa[j]);
1884 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1887 "ECDSA sign failure. No ECDSA sign will be done.\n");
1888 ERR_print_errors(bio_err);
1891 pkey_print_message("sign", "ecdsa",
1893 test_curves_bits[j], ECDSA_SECONDS);
1896 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1897 st = ECDSA_sign(0, buf, 20,
1898 ecdsasig, &ecdsasiglen, ecdsa[j]);
1900 BIO_printf(bio_err, "ECDSA sign failure\n");
1901 ERR_print_errors(bio_err);
1909 mr ? "+R5:%ld:%d:%.2f\n" :
1910 "%ld %d bit ECDSA signs in %.2fs \n",
1911 count, test_curves_bits[j], d);
1912 ecdsa_results[j][0] = d / (double)count;
1916 /* Perform ECDSA verification test */
1917 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1920 "ECDSA verify failure. No ECDSA verify will be done.\n");
1921 ERR_print_errors(bio_err);
1924 pkey_print_message("verify", "ecdsa",
1926 test_curves_bits[j], ECDSA_SECONDS);
1928 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1929 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1932 BIO_printf(bio_err, "ECDSA verify failure\n");
1933 ERR_print_errors(bio_err);
1940 mr ? "+R6:%ld:%d:%.2f\n"
1941 : "%ld %d bit ECDSA verify in %.2fs\n",
1942 count, test_curves_bits[j], d);
1943 ecdsa_results[j][1] = d / (double)count;
1946 if (rsa_count <= 1) {
1947 /* if longer than 10s, don't do any more */
1948 for (j++; j < EC_NUM; j++)
1957 #ifndef OPENSSL_NO_EC
1958 if (RAND_status() != 1) {
1959 RAND_seed(rnd_seed, sizeof rnd_seed);
1962 for (j = 0; j < EC_NUM; j++) {
1965 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1966 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1967 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1968 BIO_printf(bio_err, "ECDH failure.\n");
1969 ERR_print_errors(bio_err);
1972 /* generate two ECDH key pairs */
1973 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1974 !EC_KEY_generate_key(ecdh_b[j])) {
1975 BIO_printf(bio_err, "ECDH key generation failure.\n");
1976 ERR_print_errors(bio_err);
1980 * If field size is not more than 24 octets, then use SHA-1
1981 * hash of result; otherwise, use result (see section 4.8 of
1982 * draft-ietf-tls-ecc-03.txt).
1984 int field_size, outlen;
1985 void *(*kdf) (const void *in, size_t inlen, void *out,
1988 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1989 if (field_size <= 24 * 8) {
1990 outlen = KDF1_SHA1_len;
1993 outlen = (field_size + 7) / 8;
1997 ECDH_compute_key(secret_a, outlen,
1998 EC_KEY_get0_public_key(ecdh_b[j]),
2001 ECDH_compute_key(secret_b, outlen,
2002 EC_KEY_get0_public_key(ecdh_a[j]),
2004 if (secret_size_a != secret_size_b)
2009 for (secret_idx = 0; (secret_idx < secret_size_a)
2010 && (ecdh_checks == 1); secret_idx++) {
2011 if (secret_a[secret_idx] != secret_b[secret_idx])
2015 if (ecdh_checks == 0) {
2016 BIO_printf(bio_err, "ECDH computations don't match.\n");
2017 ERR_print_errors(bio_err);
2021 pkey_print_message("", "ecdh",
2023 test_curves_bits[j], ECDH_SECONDS);
2025 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2026 ECDH_compute_key(secret_a, outlen,
2027 EC_KEY_get0_public_key(ecdh_b[j]),
2032 mr ? "+R7:%ld:%d:%.2f\n" :
2033 "%ld %d-bit ECDH ops in %.2fs\n", count,
2034 test_curves_bits[j], d);
2035 ecdh_results[j][0] = d / (double)count;
2040 if (rsa_count <= 1) {
2041 /* if longer than 10s, don't do any more */
2042 for (j++; j < EC_NUM; j++)
2053 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2054 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2056 printf("%s ", BN_options());
2057 #ifndef OPENSSL_NO_MD2
2058 printf("%s ", MD2_options());
2060 #ifndef OPENSSL_NO_RC4
2061 printf("%s ", RC4_options());
2063 #ifndef OPENSSL_NO_DES
2064 printf("%s ", DES_options());
2066 #ifndef OPENSSL_NO_AES
2067 printf("%s ", AES_options());
2069 #ifndef OPENSSL_NO_IDEA
2070 printf("%s ", idea_options());
2072 #ifndef OPENSSL_NO_BF
2073 printf("%s ", BF_options());
2075 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2083 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2086 for (j = 0; j < SIZE_NUM; j++)
2087 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2091 for (k = 0; k < ALGOR_NUM; k++) {
2095 printf("+F:%d:%s", k, names[k]);
2097 printf("%-13s", names[k]);
2098 for (j = 0; j < SIZE_NUM; j++) {
2099 if (results[k][j] > 10000 && !mr)
2100 printf(" %11.2fk", results[k][j] / 1e3);
2102 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2106 #ifndef OPENSSL_NO_RSA
2108 for (k = 0; k < RSA_NUM; k++) {
2112 printf("%18ssign verify sign/s verify/s\n", " ");
2116 printf("+F2:%u:%u:%f:%f\n",
2117 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2119 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2120 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2121 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2124 #ifndef OPENSSL_NO_DSA
2126 for (k = 0; k < DSA_NUM; k++) {
2130 printf("%18ssign verify sign/s verify/s\n", " ");
2134 printf("+F3:%u:%u:%f:%f\n",
2135 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2137 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2138 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2139 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2142 #ifndef OPENSSL_NO_EC
2144 for (k = 0; k < EC_NUM; k++) {
2148 printf("%30ssign verify sign/s verify/s\n", " ");
2153 printf("+F4:%u:%u:%f:%f\n",
2154 k, test_curves_bits[k],
2155 ecdsa_results[k][0], ecdsa_results[k][1]);
2157 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2158 test_curves_bits[k],
2159 test_curves_names[k],
2160 ecdsa_results[k][0], ecdsa_results[k][1],
2161 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2165 #ifndef OPENSSL_NO_EC
2167 for (k = 0; k < EC_NUM; k++) {
2171 printf("%30sop op/s\n", " ");
2175 printf("+F5:%u:%u:%f:%f\n",
2176 k, test_curves_bits[k],
2177 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2180 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2181 test_curves_bits[k],
2182 test_curves_names[k],
2183 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2190 ERR_print_errors(bio_err);
2191 OPENSSL_free(save_buf);
2192 OPENSSL_free(save_buf2);
2193 #ifndef OPENSSL_NO_RSA
2194 for (i = 0; i < RSA_NUM; i++)
2195 RSA_free(rsa_key[i]);
2197 #ifndef OPENSSL_NO_DSA
2198 for (i = 0; i < DSA_NUM; i++)
2199 DSA_free(dsa_key[i]);
2202 #ifndef OPENSSL_NO_EC
2203 for (i = 0; i < EC_NUM; i++) {
2204 EC_KEY_free(ecdsa[i]);
2205 EC_KEY_free(ecdh_a[i]);
2206 EC_KEY_free(ecdh_b[i]);
2213 static void print_message(const char *s, long num, int length)
2217 mr ? "+DT:%s:%d:%d\n"
2218 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2219 (void)BIO_flush(bio_err);
2223 mr ? "+DN:%s:%ld:%d\n"
2224 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2225 (void)BIO_flush(bio_err);
2229 static void pkey_print_message(const char *str, const char *str2, long num,
2234 mr ? "+DTP:%d:%s:%s:%d\n"
2235 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2236 (void)BIO_flush(bio_err);
2240 mr ? "+DNP:%ld:%d:%s:%s\n"
2241 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2242 (void)BIO_flush(bio_err);
2246 static void print_result(int alg, int run_no, int count, double time_used)
2249 mr ? "+R:%d:%s:%f\n"
2250 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2251 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2255 static char *sstrsep(char **string, const char *delim)
2258 char *token = *string;
2263 memset(isdelim, 0, sizeof isdelim);
2267 isdelim[(unsigned char)(*delim)] = 1;
2271 while (!isdelim[(unsigned char)(**string)]) {
2283 static int do_multi(int multi)
2288 static char sep[] = ":";
2290 fds = malloc(sizeof(*fds) * multi);
2291 for (n = 0; n < multi; ++n) {
2292 if (pipe(fd) == -1) {
2293 fprintf(stderr, "pipe failure\n");
2304 if (dup(fd[1]) == -1) {
2305 fprintf(stderr, "dup failed\n");
2314 printf("Forked child %d\n", n);
2317 /* for now, assume the pipe is long enough to take all the output */
2318 for (n = 0; n < multi; ++n) {
2323 f = fdopen(fds[n], "r");
2324 while (fgets(buf, sizeof buf, f)) {
2325 p = strchr(buf, '\n');
2328 if (buf[0] != '+') {
2329 fprintf(stderr, "Don't understand line '%s' from child %d\n",
2333 printf("Got: %s from %d\n", buf, n);
2334 if (strncmp(buf, "+F:", 3) == 0) {
2339 alg = atoi(sstrsep(&p, sep));
2341 for (j = 0; j < SIZE_NUM; ++j)
2342 results[alg][j] += atof(sstrsep(&p, sep));
2343 } else if (strncmp(buf, "+F2:", 4) == 0) {
2348 k = atoi(sstrsep(&p, sep));
2351 d = atof(sstrsep(&p, sep));
2353 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2355 rsa_results[k][0] = d;
2357 d = atof(sstrsep(&p, sep));
2359 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2361 rsa_results[k][1] = d;
2363 # ifndef OPENSSL_NO_DSA
2364 else if (strncmp(buf, "+F3:", 4) == 0) {
2369 k = atoi(sstrsep(&p, sep));
2372 d = atof(sstrsep(&p, sep));
2374 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2376 dsa_results[k][0] = d;
2378 d = atof(sstrsep(&p, sep));
2380 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2382 dsa_results[k][1] = d;
2385 # ifndef OPENSSL_NO_EC
2386 else if (strncmp(buf, "+F4:", 4) == 0) {
2391 k = atoi(sstrsep(&p, sep));
2394 d = atof(sstrsep(&p, sep));
2396 ecdsa_results[k][0] =
2397 1 / (1 / ecdsa_results[k][0] + 1 / d);
2399 ecdsa_results[k][0] = d;
2401 d = atof(sstrsep(&p, sep));
2403 ecdsa_results[k][1] =
2404 1 / (1 / ecdsa_results[k][1] + 1 / d);
2406 ecdsa_results[k][1] = d;
2410 # ifndef OPENSSL_NO_EC
2411 else if (strncmp(buf, "+F5:", 4) == 0) {
2416 k = atoi(sstrsep(&p, sep));
2419 d = atof(sstrsep(&p, sep));
2421 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2423 ecdh_results[k][0] = d;
2428 else if (strncmp(buf, "+H:", 3) == 0) {
2431 fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n);
2441 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2443 static int mblengths[] =
2444 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2445 int j, count, num = OSSL_NELEM(lengths);
2446 const char *alg_name;
2447 unsigned char *inp, *out, no_key[32], no_iv[16];
2451 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2452 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2453 EVP_CIPHER_CTX_init(&ctx);
2454 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2455 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2457 alg_name = OBJ_nid2ln(evp_cipher->nid);
2459 for (j = 0; j < num; j++) {
2460 print_message(alg_name, 0, mblengths[j]);
2462 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2463 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2464 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2465 size_t len = mblengths[j];
2468 memset(aad, 0, 8); /* avoid uninitialized values */
2469 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2470 aad[9] = 3; /* version */
2472 aad[11] = 0; /* length */
2474 mb_param.out = NULL;
2477 mb_param.interleave = 8;
2479 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2480 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2481 sizeof(mb_param), &mb_param);
2487 EVP_CIPHER_CTX_ctrl(&ctx,
2488 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2489 sizeof(mb_param), &mb_param);
2493 RAND_bytes(out, 16);
2497 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2498 EVP_CTRL_AEAD_TLS1_AAD,
2499 EVP_AEAD_TLS1_AAD_LEN, aad);
2500 EVP_Cipher(&ctx, out, inp, len + pad);
2504 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2505 : "%d %s's in %.2fs\n", count, "evp", d);
2506 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2510 fprintf(stdout, "+H");
2511 for (j = 0; j < num; j++)
2512 fprintf(stdout, ":%d", mblengths[j]);
2513 fprintf(stdout, "\n");
2514 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2515 for (j = 0; j < num; j++)
2516 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2517 fprintf(stdout, "\n");
2520 "The 'numbers' are in 1000s of bytes per second processed.\n");
2521 fprintf(stdout, "type ");
2522 for (j = 0; j < num; j++)
2523 fprintf(stdout, "%7d bytes", mblengths[j]);
2524 fprintf(stdout, "\n");
2525 fprintf(stdout, "%-24s", alg_name);
2527 for (j = 0; j < num; j++) {
2528 if (results[D_EVP][j] > 10000)
2529 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2531 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2533 fprintf(stdout, "\n");