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>
173 #include <openssl/modes.h>
175 #include <openssl/bn.h>
178 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
192 #define BUFSIZE (1024*8+1)
193 #define MAX_MISALIGNMENT 63
195 static volatile int run = 0;
198 static int usertime = 1;
200 static double Time_F(int s);
201 static void print_message(const char *s, long num, int length);
202 static void pkey_print_message(const char *str, const char *str2,
203 long num, int bits, int sec);
204 static void print_result(int alg, int run_no, int count, double time_used);
206 static int do_multi(int multi);
216 #define MAX_ECDH_SIZE 256
219 static const char *names[ALGOR_NUM] = {
220 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
221 "des cbc", "des ede3", "idea cbc", "seed cbc",
222 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
223 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
224 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
225 "evp", "sha256", "sha512", "whirlpool",
226 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
229 static double results[ALGOR_NUM][SIZE_NUM];
230 static int lengths[SIZE_NUM] = {
231 16, 64, 256, 1024, 8 * 1024
234 #ifndef OPENSSL_NO_RSA
235 static double rsa_results[RSA_NUM][2];
237 #ifndef OPENSSL_NO_DSA
238 static double dsa_results[DSA_NUM][2];
240 #ifndef OPENSSL_NO_EC
241 static double ecdsa_results[EC_NUM][2];
242 static double ecdh_results[EC_NUM][1];
245 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
246 static const char rnd_seed[] =
247 "string to make the random number generator think it has entropy";
248 static int rnd_fake = 0;
252 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
253 # define SIGRETTYPE void
255 # define SIGRETTYPE int
258 static SIGRETTYPE sig_done(int sig);
259 static SIGRETTYPE sig_done(int sig)
261 signal(SIGALRM, sig_done);
271 # if !defined(SIGALRM)
274 static unsigned int lapse, schlock;
275 static void alarm_win32(unsigned int secs)
280 # define alarm alarm_win32
282 static DWORD WINAPI sleepy(VOID * arg)
290 static double Time_F(int s)
297 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
299 DWORD err = GetLastError();
300 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
304 Sleep(0); /* scheduler spinlock */
305 ret = app_tminterval(s, usertime);
307 ret = app_tminterval(s, usertime);
309 TerminateThread(thr, 0);
317 static double Time_F(int s)
319 double ret = app_tminterval(s, usertime);
326 #ifndef OPENSSL_NO_EC
327 static const int KDF1_SHA1_len = 20;
328 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
331 if (*outlen < SHA_DIGEST_LENGTH)
333 *outlen = SHA_DIGEST_LENGTH;
334 return SHA1(in, inlen, out);
336 #endif /* OPENSSL_NO_EC */
338 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
340 static int found(const char *name, const OPT_PAIR * pairs, int *result)
342 for (; pairs->name; pairs++)
343 if (strcmp(name, pairs->name) == 0) {
344 *result = pairs->retval;
350 typedef enum OPTION_choice {
351 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
352 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
353 OPT_MR, OPT_MB, OPT_MISALIGN
356 OPTIONS speed_options[] = {
357 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
358 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
359 {"help", OPT_HELP, '-', "Display this summary"},
360 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
361 {"decrypt", OPT_DECRYPT, '-',
362 "Time decryption instead of encryption (only EVP)"},
363 {"mr", OPT_MR, '-', "Produce machine readable output"},
365 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
366 {"elapsed", OPT_ELAPSED, '-',
367 "Measure time in real time instead of CPU user time"},
369 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
371 #ifndef OPENSSL_NO_ENGINE
372 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
387 #define D_CBC_IDEA 10
388 #define D_CBC_SEED 11
392 #define D_CBC_CAST 15
393 #define D_CBC_128_AES 16
394 #define D_CBC_192_AES 17
395 #define D_CBC_256_AES 18
396 #define D_CBC_128_CML 19
397 #define D_CBC_192_CML 20
398 #define D_CBC_256_CML 21
402 #define D_WHIRLPOOL 25
403 #define D_IGE_128_AES 26
404 #define D_IGE_192_AES 27
405 #define D_IGE_256_AES 28
407 static OPT_PAIR doit_choices[] = {
408 #ifndef OPENSSL_NO_MD2
411 #ifndef OPENSSL_NO_MDC2
414 #ifndef OPENSSL_NO_MD4
417 #ifndef OPENSSL_NO_MD5
420 #ifndef OPENSSL_NO_MD5
424 {"sha256", D_SHA256},
425 {"sha512", D_SHA512},
426 #ifndef OPENSSL_NO_WHIRLPOOL
427 {"whirlpool", D_WHIRLPOOL},
429 #ifndef OPENSSL_NO_RMD160
430 {"ripemd", D_RMD160},
431 {"rmd160", D_RMD160},
432 {"ripemd160", D_RMD160},
434 #ifndef OPENSSL_NO_RC4
437 #ifndef OPENSSL_NO_DES
438 {"des-cbc", D_CBC_DES},
439 {"des-ede3", D_EDE3_DES},
441 #ifndef OPENSSL_NO_AES
442 {"aes-128-cbc", D_CBC_128_AES},
443 {"aes-192-cbc", D_CBC_192_AES},
444 {"aes-256-cbc", D_CBC_256_AES},
445 {"aes-128-ige", D_IGE_128_AES},
446 {"aes-192-ige", D_IGE_192_AES},
447 {"aes-256-ige", D_IGE_256_AES},
449 #ifndef OPENSSL_NO_RC2
450 {"rc2-cbc", D_CBC_RC2},
453 #ifndef OPENSSL_NO_RC5
454 {"rc5-cbc", D_CBC_RC5},
457 #ifndef OPENSSL_NO_IDEA
458 {"idea-cbc", D_CBC_IDEA},
459 {"idea", D_CBC_IDEA},
461 #ifndef OPENSSL_NO_SEED
462 {"seed-cbc", D_CBC_SEED},
463 {"seed", D_CBC_SEED},
465 #ifndef OPENSSL_NO_BF
466 {"bf-cbc", D_CBC_BF},
467 {"blowfish", D_CBC_BF},
470 #ifndef OPENSSL_NO_CAST
471 {"cast-cbc", D_CBC_CAST},
472 {"cast", D_CBC_CAST},
473 {"cast5", D_CBC_CAST},
482 static OPT_PAIR dsa_choices[] = {
483 {"dsa512", R_DSA_512},
484 {"dsa1024", R_DSA_1024},
485 {"dsa2048", R_DSA_2048},
495 #define R_RSA_15360 6
496 static OPT_PAIR rsa_choices[] = {
497 {"rsa512", R_RSA_512},
498 {"rsa1024", R_RSA_1024},
499 {"rsa2048", R_RSA_2048},
500 {"rsa3072", R_RSA_3072},
501 {"rsa4096", R_RSA_4096},
502 {"rsa7680", R_RSA_7680},
503 {"rsa15360", R_RSA_15360},
523 #ifndef OPENSSL_NO_EC
524 static OPT_PAIR ecdsa_choices[] = {
525 {"ecdsap160", R_EC_P160},
526 {"ecdsap192", R_EC_P192},
527 {"ecdsap224", R_EC_P224},
528 {"ecdsap256", R_EC_P256},
529 {"ecdsap384", R_EC_P384},
530 {"ecdsap521", R_EC_P521},
531 {"ecdsak163", R_EC_K163},
532 {"ecdsak233", R_EC_K233},
533 {"ecdsak283", R_EC_K283},
534 {"ecdsak409", R_EC_K409},
535 {"ecdsak571", R_EC_K571},
536 {"ecdsab163", R_EC_B163},
537 {"ecdsab233", R_EC_B233},
538 {"ecdsab283", R_EC_B283},
539 {"ecdsab409", R_EC_B409},
540 {"ecdsab571", R_EC_B571},
543 static OPT_PAIR ecdh_choices[] = {
544 {"ecdhp160", R_EC_P160},
545 {"ecdhp192", R_EC_P192},
546 {"ecdhp224", R_EC_P224},
547 {"ecdhp256", R_EC_P256},
548 {"ecdhp384", R_EC_P384},
549 {"ecdhp521", R_EC_P521},
550 {"ecdhk163", R_EC_K163},
551 {"ecdhk233", R_EC_K233},
552 {"ecdhk283", R_EC_K283},
553 {"ecdhk409", R_EC_K409},
554 {"ecdhk571", R_EC_K571},
555 {"ecdhb163", R_EC_B163},
556 {"ecdhb233", R_EC_B233},
557 {"ecdhb283", R_EC_B283},
558 {"ecdhb409", R_EC_B409},
559 {"ecdhb571", R_EC_B571},
564 int speed_main(int argc, char **argv)
567 const EVP_CIPHER *evp_cipher = NULL;
568 const EVP_MD *evp_md = NULL;
571 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
572 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
573 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
574 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
575 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
576 unsigned char *buf = NULL, *buf2 = NULL;
577 unsigned char md[EVP_MAX_MD_SIZE];
581 /* What follows are the buffers and key material. */
582 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
585 #ifndef OPENSSL_NO_MD2
586 unsigned char md2[MD2_DIGEST_LENGTH];
588 #ifndef OPENSSL_NO_MDC2
589 unsigned char mdc2[MDC2_DIGEST_LENGTH];
591 #ifndef OPENSSL_NO_MD4
592 unsigned char md4[MD4_DIGEST_LENGTH];
594 #ifndef OPENSSL_NO_MD5
595 unsigned char md5[MD5_DIGEST_LENGTH];
596 unsigned char hmac[MD5_DIGEST_LENGTH];
598 unsigned char sha[SHA_DIGEST_LENGTH];
599 unsigned char sha256[SHA256_DIGEST_LENGTH];
600 unsigned char sha512[SHA512_DIGEST_LENGTH];
601 #ifndef OPENSSL_NO_WHIRLPOOL
602 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
604 #ifndef OPENSSL_NO_RMD160
605 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
607 #ifndef OPENSSL_NO_RC4
610 #ifndef OPENSSL_NO_RC5
613 #ifndef OPENSSL_NO_RC2
616 #ifndef OPENSSL_NO_IDEA
617 IDEA_KEY_SCHEDULE idea_ks;
619 #ifndef OPENSSL_NO_SEED
620 SEED_KEY_SCHEDULE seed_ks;
622 #ifndef OPENSSL_NO_BF
625 #ifndef OPENSSL_NO_CAST
628 static const unsigned char key16[16] = {
629 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
630 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
632 #ifndef OPENSSL_NO_AES
633 static const unsigned char key24[24] = {
634 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
635 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
636 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
638 static const unsigned char key32[32] = {
639 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
640 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
641 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
642 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
645 #ifndef OPENSSL_NO_CAMELLIA
646 static const unsigned char ckey24[24] = {
647 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
648 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
649 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
651 static const unsigned char ckey32[32] = {
652 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
653 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
654 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
655 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
657 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
659 #ifndef OPENSSL_NO_AES
660 # define MAX_BLOCK_SIZE 128
662 # define MAX_BLOCK_SIZE 64
664 unsigned char DES_iv[8];
665 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
666 #ifndef OPENSSL_NO_DES
667 static DES_cblock key = {
668 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
670 static DES_cblock key2 = {
671 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
673 static DES_cblock key3 = {
674 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
676 DES_key_schedule sch;
677 DES_key_schedule sch2;
678 DES_key_schedule sch3;
680 #ifndef OPENSSL_NO_AES
681 AES_KEY aes_ks1, aes_ks2, aes_ks3;
683 #ifndef OPENSSL_NO_RSA
685 RSA *rsa_key[RSA_NUM];
686 long rsa_c[RSA_NUM][2];
687 static unsigned int rsa_bits[RSA_NUM] = {
688 512, 1024, 2048, 3072, 4096, 7680, 15360
690 static unsigned char *rsa_data[RSA_NUM] = {
691 test512, test1024, test2048, test3072, test4096, test7680, test15360
693 static int rsa_data_length[RSA_NUM] = {
694 sizeof(test512), sizeof(test1024),
695 sizeof(test2048), sizeof(test3072),
696 sizeof(test4096), sizeof(test7680),
700 #ifndef OPENSSL_NO_DSA
701 DSA *dsa_key[DSA_NUM];
702 long dsa_c[DSA_NUM][2];
703 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
705 #ifndef OPENSSL_NO_EC
707 * We only test over the following curves as they are representative, To
708 * add tests over more curves, simply add the curve NID and curve name to
709 * the following arrays and increase the EC_NUM value accordingly.
711 static unsigned int test_curves[EC_NUM] = {
713 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
714 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
716 NID_sect163k1, NID_sect233k1, NID_sect283k1,
717 NID_sect409k1, NID_sect571k1, NID_sect163r2,
718 NID_sect233r1, NID_sect283r1, NID_sect409r1,
721 static const char *test_curves_names[EC_NUM] = {
723 "secp160r1", "nistp192", "nistp224",
724 "nistp256", "nistp384", "nistp521",
726 "nistk163", "nistk233", "nistk283",
727 "nistk409", "nistk571", "nistb163",
728 "nistb233", "nistb283", "nistb409",
731 static int test_curves_bits[EC_NUM] = {
740 #ifndef OPENSSL_NO_EC
741 unsigned char ecdsasig[256];
742 unsigned int ecdsasiglen;
743 EC_KEY *ecdsa[EC_NUM];
744 long ecdsa_c[EC_NUM][2];
745 int ecdsa_doit[EC_NUM];
746 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
747 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
748 int secret_size_a, secret_size_b;
751 long ecdh_c[EC_NUM][2];
752 int ecdh_doit[EC_NUM];
755 memset(results, 0, sizeof(results));
756 #ifndef OPENSSL_NO_DSA
757 memset(dsa_key, 0, sizeof(dsa_key));
759 #ifndef OPENSSL_NO_EC
760 for (i = 0; i < EC_NUM; i++)
762 for (i = 0; i < EC_NUM; i++)
763 ecdh_a[i] = ecdh_b[i] = NULL;
765 #ifndef OPENSSL_NO_RSA
766 memset(rsa_key, 0, sizeof(rsa_key));
767 for (i = 0; i < RSA_NUM; i++)
771 memset(c, 0, sizeof(c));
772 memset(DES_iv, 0, sizeof(DES_iv));
773 memset(iv, 0, sizeof(iv));
775 for (i = 0; i < ALGOR_NUM; i++)
777 for (i = 0; i < RSA_NUM; i++)
779 for (i = 0; i < DSA_NUM; i++)
781 #ifndef OPENSSL_NO_EC
782 for (i = 0; i < EC_NUM; i++)
784 for (i = 0; i < EC_NUM; i++)
788 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
789 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
792 prog = opt_init(argc, argv, speed_options);
793 while ((o = opt_next()) != OPT_EOF) {
798 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
801 opt_help(speed_options);
808 evp_cipher = EVP_get_cipherbyname(opt_arg());
809 if (evp_cipher == NULL)
810 evp_md = EVP_get_digestbyname(opt_arg());
811 if (evp_cipher == NULL && evp_md == NULL) {
813 "%s: %s an unknown cipher or digest\n",
823 (void)setup_engine(opt_arg(), 0);
827 multi = atoi(opt_arg());
831 if (!opt_int(opt_arg(), &misalign))
833 if (misalign > MISALIGN) {
835 "%s: Maximum offset is %d\n", prog, MISALIGN);
838 buf = buf_malloc + misalign;
839 buf2 = buf2_malloc + misalign;
849 argc = opt_num_rest();
852 /* Remaining arguments are algorithms. */
853 for ( ; *argv; argv++) {
854 if (found(*argv, doit_choices, &i)) {
858 #ifndef OPENSSL_NO_DES
859 if (strcmp(*argv, "des") == 0) {
860 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
864 if (strcmp(*argv, "sha") == 0) {
865 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
868 #ifndef OPENSSL_NO_RSA
870 if (strcmp(*argv, "openssl") == 0) {
871 RSA_set_default_method(RSA_PKCS1_OpenSSL());
875 if (strcmp(*argv, "rsa") == 0) {
876 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
877 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
878 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
879 rsa_doit[R_RSA_15360] = 1;
882 if (found(*argv, rsa_choices, &i)) {
887 #ifndef OPENSSL_NO_DSA
888 if (strcmp(*argv, "dsa") == 0) {
889 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
890 dsa_doit[R_DSA_2048] = 1;
893 if (found(*argv, dsa_choices, &i)) {
898 #ifndef OPENSSL_NO_AES
899 if (strcmp(*argv, "aes") == 0) {
900 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
901 doit[D_CBC_256_AES] = 1;
905 #ifndef OPENSSL_NO_CAMELLIA
906 if (strcmp(*argv, "camellia") == 0) {
907 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
908 doit[D_CBC_256_CML] = 1;
912 #ifndef OPENSSL_NO_EC
913 if (strcmp(*argv, "ecdsa") == 0) {
914 for (i = 0; i < EC_NUM; i++)
918 if (found(*argv, ecdsa_choices, &i)) {
922 if (strcmp(*argv, "ecdh") == 0) {
923 for (i = 0; i < EC_NUM; i++)
927 if (found(*argv, ecdh_choices, &i)) {
932 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
937 if (multi && do_multi(multi))
941 /* No parameters; turn on everything. */
942 if ((argc == 0) && !doit[D_EVP]) {
943 for (i = 0; i < ALGOR_NUM; i++)
946 for (i = 0; i < RSA_NUM; i++)
948 for (i = 0; i < DSA_NUM; i++)
950 #ifndef OPENSSL_NO_EC
951 for (i = 0; i < EC_NUM; i++)
953 for (i = 0; i < EC_NUM; i++)
957 for (i = 0; i < ALGOR_NUM; i++)
961 if (usertime == 0 && !mr)
963 "You have chosen to measure elapsed time "
964 "instead of user CPU time.\n");
966 #ifndef OPENSSL_NO_RSA
967 for (i = 0; i < RSA_NUM; i++) {
968 const unsigned char *p;
971 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
972 if (rsa_key[i] == NULL) {
973 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
980 #ifndef OPENSSL_NO_DSA
981 dsa_key[0] = get_dsa512();
982 dsa_key[1] = get_dsa1024();
983 dsa_key[2] = get_dsa2048();
986 #ifndef OPENSSL_NO_DES
987 DES_set_key_unchecked(&key, &sch);
988 DES_set_key_unchecked(&key2, &sch2);
989 DES_set_key_unchecked(&key3, &sch3);
991 #ifndef OPENSSL_NO_AES
992 AES_set_encrypt_key(key16, 128, &aes_ks1);
993 AES_set_encrypt_key(key24, 192, &aes_ks2);
994 AES_set_encrypt_key(key32, 256, &aes_ks3);
996 #ifndef OPENSSL_NO_CAMELLIA
997 Camellia_set_key(key16, 128, &camellia_ks1);
998 Camellia_set_key(ckey24, 192, &camellia_ks2);
999 Camellia_set_key(ckey32, 256, &camellia_ks3);
1001 #ifndef OPENSSL_NO_IDEA
1002 idea_set_encrypt_key(key16, &idea_ks);
1004 #ifndef OPENSSL_NO_SEED
1005 SEED_set_key(key16, &seed_ks);
1007 #ifndef OPENSSL_NO_RC4
1008 RC4_set_key(&rc4_ks, 16, key16);
1010 #ifndef OPENSSL_NO_RC2
1011 RC2_set_key(&rc2_ks, 16, key16, 128);
1013 #ifndef OPENSSL_NO_RC5
1014 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1016 #ifndef OPENSSL_NO_BF
1017 BF_set_key(&bf_ks, 16, key16);
1019 #ifndef OPENSSL_NO_CAST
1020 CAST_set_key(&cast_ks, 16, key16);
1022 #ifndef OPENSSL_NO_RSA
1023 memset(rsa_c, 0, sizeof(rsa_c));
1026 # ifndef OPENSSL_NO_DES
1027 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1033 for (it = count; it; it--)
1034 DES_ecb_encrypt((DES_cblock *)buf,
1035 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1039 c[D_MD2][0] = count / 10;
1040 c[D_MDC2][0] = count / 10;
1041 c[D_MD4][0] = count;
1042 c[D_MD5][0] = count;
1043 c[D_HMAC][0] = count;
1044 c[D_SHA1][0] = count;
1045 c[D_RMD160][0] = count;
1046 c[D_RC4][0] = count * 5;
1047 c[D_CBC_DES][0] = count;
1048 c[D_EDE3_DES][0] = count / 3;
1049 c[D_CBC_IDEA][0] = count;
1050 c[D_CBC_SEED][0] = count;
1051 c[D_CBC_RC2][0] = count;
1052 c[D_CBC_RC5][0] = count;
1053 c[D_CBC_BF][0] = count;
1054 c[D_CBC_CAST][0] = count;
1055 c[D_CBC_128_AES][0] = count;
1056 c[D_CBC_192_AES][0] = count;
1057 c[D_CBC_256_AES][0] = count;
1058 c[D_CBC_128_CML][0] = count;
1059 c[D_CBC_192_CML][0] = count;
1060 c[D_CBC_256_CML][0] = count;
1061 c[D_SHA256][0] = count;
1062 c[D_SHA512][0] = count;
1063 c[D_WHIRLPOOL][0] = count;
1064 c[D_IGE_128_AES][0] = count;
1065 c[D_IGE_192_AES][0] = count;
1066 c[D_IGE_256_AES][0] = count;
1067 c[D_GHASH][0] = count;
1069 for (i = 1; i < SIZE_NUM; i++) {
1072 l0 = (long)lengths[0];
1073 l1 = (long)lengths[i];
1075 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1076 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1077 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1078 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1079 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1080 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1081 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1082 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1083 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1084 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1086 l0 = (long)lengths[i - 1];
1088 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1089 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1090 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1091 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1092 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1093 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1094 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1095 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1096 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1097 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1098 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1099 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1100 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1101 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1102 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1103 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1104 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1105 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1108 # ifndef OPENSSL_NO_RSA
1109 rsa_c[R_RSA_512][0] = count / 2000;
1110 rsa_c[R_RSA_512][1] = count / 400;
1111 for (i = 1; i < RSA_NUM; i++) {
1112 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1113 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1114 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1117 if (rsa_c[i][0] == 0) {
1125 # ifndef OPENSSL_NO_DSA
1126 dsa_c[R_DSA_512][0] = count / 1000;
1127 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1128 for (i = 1; i < DSA_NUM; i++) {
1129 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1130 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1131 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1134 if (dsa_c[i] == 0) {
1142 # ifndef OPENSSL_NO_EC
1143 ecdsa_c[R_EC_P160][0] = count / 1000;
1144 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1145 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1146 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1147 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1148 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1151 if (ecdsa_c[i] == 0) {
1157 ecdsa_c[R_EC_K163][0] = count / 1000;
1158 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1159 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1160 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1161 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1162 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1165 if (ecdsa_c[i] == 0) {
1171 ecdsa_c[R_EC_B163][0] = count / 1000;
1172 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1173 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1174 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1175 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1176 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1179 if (ecdsa_c[i] == 0) {
1186 ecdh_c[R_EC_P160][0] = count / 1000;
1187 ecdh_c[R_EC_P160][1] = count / 1000;
1188 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1189 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1190 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1191 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1194 if (ecdh_c[i] == 0) {
1200 ecdh_c[R_EC_K163][0] = count / 1000;
1201 ecdh_c[R_EC_K163][1] = count / 1000;
1202 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1203 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1204 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1205 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1208 if (ecdh_c[i] == 0) {
1214 ecdh_c[R_EC_B163][0] = count / 1000;
1215 ecdh_c[R_EC_B163][1] = count / 1000;
1216 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1217 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1218 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1219 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1222 if (ecdh_c[i] == 0) {
1230 # define COND(d) (count < (d))
1231 # define COUNT(d) (d)
1233 /* not worth fixing */
1234 # error "You cannot disable DES on systems without SIGALRM."
1235 # endif /* OPENSSL_NO_DES */
1237 # define COND(c) (run && count<0x7fffffff)
1238 # define COUNT(d) (count)
1240 signal(SIGALRM, sig_done);
1242 #endif /* SIGALRM */
1244 #ifndef OPENSSL_NO_MD2
1246 for (j = 0; j < SIZE_NUM; j++) {
1247 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1249 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1250 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1253 print_result(D_MD2, j, count, d);
1257 #ifndef OPENSSL_NO_MDC2
1259 for (j = 0; j < SIZE_NUM; j++) {
1260 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1262 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1263 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1266 print_result(D_MDC2, j, count, d);
1271 #ifndef OPENSSL_NO_MD4
1273 for (j = 0; j < SIZE_NUM; j++) {
1274 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1276 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1277 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1278 NULL, EVP_md4(), NULL);
1280 print_result(D_MD4, j, count, d);
1285 #ifndef OPENSSL_NO_MD5
1287 for (j = 0; j < SIZE_NUM; j++) {
1288 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1290 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1291 MD5(buf, lengths[j], md5);
1293 print_result(D_MD5, j, count, d);
1298 #if !defined(OPENSSL_NO_MD5)
1300 HMAC_CTX *hctx = NULL;
1302 hctx = HMAC_CTX_new();
1304 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1307 HMAC_Init_ex(hctx, (unsigned char *)"This is a key...",
1308 16, EVP_md5(), NULL);
1310 for (j = 0; j < SIZE_NUM; j++) {
1311 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1313 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1314 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
1315 HMAC_Update(hctx, buf, lengths[j]);
1316 HMAC_Final(hctx, &(hmac[0]), NULL);
1319 print_result(D_HMAC, j, count, d);
1321 HMAC_CTX_free(hctx);
1325 for (j = 0; j < SIZE_NUM; j++) {
1326 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1328 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1329 SHA1(buf, lengths[j], sha);
1331 print_result(D_SHA1, j, count, d);
1334 if (doit[D_SHA256]) {
1335 for (j = 0; j < SIZE_NUM; j++) {
1336 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1338 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1339 SHA256(buf, lengths[j], sha256);
1341 print_result(D_SHA256, j, count, d);
1344 if (doit[D_SHA512]) {
1345 for (j = 0; j < SIZE_NUM; j++) {
1346 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1348 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1349 SHA512(buf, lengths[j], sha512);
1351 print_result(D_SHA512, j, count, d);
1355 #ifndef OPENSSL_NO_WHIRLPOOL
1356 if (doit[D_WHIRLPOOL]) {
1357 for (j = 0; j < SIZE_NUM; j++) {
1358 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1360 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1361 WHIRLPOOL(buf, lengths[j], whirlpool);
1363 print_result(D_WHIRLPOOL, j, count, d);
1368 #ifndef OPENSSL_NO_RMD160
1369 if (doit[D_RMD160]) {
1370 for (j = 0; j < SIZE_NUM; j++) {
1371 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1373 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1374 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1375 EVP_ripemd160(), NULL);
1377 print_result(D_RMD160, j, count, d);
1381 #ifndef OPENSSL_NO_RC4
1383 for (j = 0; j < SIZE_NUM; j++) {
1384 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1386 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1387 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1389 print_result(D_RC4, j, count, d);
1393 #ifndef OPENSSL_NO_DES
1394 if (doit[D_CBC_DES]) {
1395 for (j = 0; j < SIZE_NUM; j++) {
1396 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1398 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1399 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1400 &DES_iv, DES_ENCRYPT);
1402 print_result(D_CBC_DES, j, count, d);
1406 if (doit[D_EDE3_DES]) {
1407 for (j = 0; j < SIZE_NUM; j++) {
1408 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1410 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1411 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1413 &DES_iv, DES_ENCRYPT);
1415 print_result(D_EDE3_DES, j, count, d);
1419 #ifndef OPENSSL_NO_AES
1420 if (doit[D_CBC_128_AES]) {
1421 for (j = 0; j < SIZE_NUM; j++) {
1422 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1425 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1426 AES_cbc_encrypt(buf, buf,
1427 (unsigned long)lengths[j], &aes_ks1,
1430 print_result(D_CBC_128_AES, j, count, d);
1433 if (doit[D_CBC_192_AES]) {
1434 for (j = 0; j < SIZE_NUM; j++) {
1435 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1438 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1439 AES_cbc_encrypt(buf, buf,
1440 (unsigned long)lengths[j], &aes_ks2,
1443 print_result(D_CBC_192_AES, j, count, d);
1446 if (doit[D_CBC_256_AES]) {
1447 for (j = 0; j < SIZE_NUM; j++) {
1448 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1451 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1452 AES_cbc_encrypt(buf, buf,
1453 (unsigned long)lengths[j], &aes_ks3,
1456 print_result(D_CBC_256_AES, j, count, d);
1460 if (doit[D_IGE_128_AES]) {
1461 for (j = 0; j < SIZE_NUM; j++) {
1462 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1465 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1466 AES_ige_encrypt(buf, buf2,
1467 (unsigned long)lengths[j], &aes_ks1,
1470 print_result(D_IGE_128_AES, j, count, d);
1473 if (doit[D_IGE_192_AES]) {
1474 for (j = 0; j < SIZE_NUM; j++) {
1475 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1478 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1479 AES_ige_encrypt(buf, buf2,
1480 (unsigned long)lengths[j], &aes_ks2,
1483 print_result(D_IGE_192_AES, j, count, d);
1486 if (doit[D_IGE_256_AES]) {
1487 for (j = 0; j < SIZE_NUM; j++) {
1488 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1491 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1492 AES_ige_encrypt(buf, buf2,
1493 (unsigned long)lengths[j], &aes_ks3,
1496 print_result(D_IGE_256_AES, j, count, d);
1499 if (doit[D_GHASH]) {
1500 GCM128_CONTEXT *ctx =
1501 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1502 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1504 for (j = 0; j < SIZE_NUM; j++) {
1505 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1507 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1508 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1510 print_result(D_GHASH, j, count, d);
1512 CRYPTO_gcm128_release(ctx);
1515 #ifndef OPENSSL_NO_CAMELLIA
1516 if (doit[D_CBC_128_CML]) {
1517 for (j = 0; j < SIZE_NUM; j++) {
1518 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1521 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1522 Camellia_cbc_encrypt(buf, buf,
1523 (unsigned long)lengths[j], &camellia_ks1,
1524 iv, CAMELLIA_ENCRYPT);
1526 print_result(D_CBC_128_CML, j, count, d);
1529 if (doit[D_CBC_192_CML]) {
1530 for (j = 0; j < SIZE_NUM; j++) {
1531 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1534 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1535 Camellia_cbc_encrypt(buf, buf,
1536 (unsigned long)lengths[j], &camellia_ks2,
1537 iv, CAMELLIA_ENCRYPT);
1539 print_result(D_CBC_192_CML, j, count, d);
1542 if (doit[D_CBC_256_CML]) {
1543 for (j = 0; j < SIZE_NUM; j++) {
1544 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1547 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1548 Camellia_cbc_encrypt(buf, buf,
1549 (unsigned long)lengths[j], &camellia_ks3,
1550 iv, CAMELLIA_ENCRYPT);
1552 print_result(D_CBC_256_CML, j, count, d);
1556 #ifndef OPENSSL_NO_IDEA
1557 if (doit[D_CBC_IDEA]) {
1558 for (j = 0; j < SIZE_NUM; j++) {
1559 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1561 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1562 idea_cbc_encrypt(buf, buf,
1563 (unsigned long)lengths[j], &idea_ks,
1566 print_result(D_CBC_IDEA, j, count, d);
1570 #ifndef OPENSSL_NO_SEED
1571 if (doit[D_CBC_SEED]) {
1572 for (j = 0; j < SIZE_NUM; j++) {
1573 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1575 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1576 SEED_cbc_encrypt(buf, buf,
1577 (unsigned long)lengths[j], &seed_ks, iv, 1);
1579 print_result(D_CBC_SEED, j, count, d);
1583 #ifndef OPENSSL_NO_RC2
1584 if (doit[D_CBC_RC2]) {
1585 for (j = 0; j < SIZE_NUM; j++) {
1586 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1588 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1589 RC2_cbc_encrypt(buf, buf,
1590 (unsigned long)lengths[j], &rc2_ks,
1593 print_result(D_CBC_RC2, j, count, d);
1597 #ifndef OPENSSL_NO_RC5
1598 if (doit[D_CBC_RC5]) {
1599 for (j = 0; j < SIZE_NUM; j++) {
1600 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1602 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1603 RC5_32_cbc_encrypt(buf, buf,
1604 (unsigned long)lengths[j], &rc5_ks,
1607 print_result(D_CBC_RC5, j, count, d);
1611 #ifndef OPENSSL_NO_BF
1612 if (doit[D_CBC_BF]) {
1613 for (j = 0; j < SIZE_NUM; j++) {
1614 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1616 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1617 BF_cbc_encrypt(buf, buf,
1618 (unsigned long)lengths[j], &bf_ks,
1621 print_result(D_CBC_BF, j, count, d);
1625 #ifndef OPENSSL_NO_CAST
1626 if (doit[D_CBC_CAST]) {
1627 for (j = 0; j < SIZE_NUM; j++) {
1628 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1630 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1631 CAST_cbc_encrypt(buf, buf,
1632 (unsigned long)lengths[j], &cast_ks,
1635 print_result(D_CBC_CAST, j, count, d);
1641 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1642 if (multiblock && evp_cipher) {
1644 (EVP_CIPHER_flags(evp_cipher) &
1645 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1646 BIO_printf(bio_err, "%s is not multi-block capable\n",
1647 OBJ_nid2ln(evp_cipher->nid));
1650 multiblock_speed(evp_cipher);
1655 for (j = 0; j < SIZE_NUM; j++) {
1660 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1662 * -O3 -fschedule-insns messes up an optimization here!
1663 * names[D_EVP] somehow becomes NULL
1665 print_message(names[D_EVP], save_count, lengths[j]);
1667 EVP_CIPHER_CTX_init(&ctx);
1669 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1671 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1672 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1676 for (count = 0, run = 1;
1677 COND(save_count * 4 * lengths[0] / lengths[j]);
1679 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1681 for (count = 0, run = 1;
1682 COND(save_count * 4 * lengths[0] / lengths[j]);
1684 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1686 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1688 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1690 EVP_CIPHER_CTX_cleanup(&ctx);
1693 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
1694 print_message(names[D_EVP], save_count, lengths[j]);
1697 for (count = 0, run = 1;
1698 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1699 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1703 print_result(D_EVP, j, count, d);
1707 RAND_bytes(buf, 36);
1708 #ifndef OPENSSL_NO_RSA
1709 for (j = 0; j < RSA_NUM; j++) {
1713 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1716 "RSA sign failure. No RSA sign will be done.\n");
1717 ERR_print_errors(bio_err);
1720 pkey_print_message("private", "rsa",
1721 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1722 /* RSA_blinding_on(rsa_key[j],NULL); */
1724 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1725 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1726 &rsa_num, rsa_key[j]);
1728 BIO_printf(bio_err, "RSA sign failure\n");
1729 ERR_print_errors(bio_err);
1736 mr ? "+R1:%ld:%d:%.2f\n"
1737 : "%ld %d bit private RSA's in %.2fs\n",
1738 count, rsa_bits[j], d);
1739 rsa_results[j][0] = d / (double)count;
1743 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1746 "RSA verify failure. No RSA verify will be done.\n");
1747 ERR_print_errors(bio_err);
1750 pkey_print_message("public", "rsa",
1751 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1753 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1754 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1755 rsa_num, rsa_key[j]);
1757 BIO_printf(bio_err, "RSA verify failure\n");
1758 ERR_print_errors(bio_err);
1765 mr ? "+R2:%ld:%d:%.2f\n"
1766 : "%ld %d bit public RSA's in %.2fs\n",
1767 count, rsa_bits[j], d);
1768 rsa_results[j][1] = d / (double)count;
1771 if (rsa_count <= 1) {
1772 /* if longer than 10s, don't do any more */
1773 for (j++; j < RSA_NUM; j++)
1779 RAND_bytes(buf, 20);
1780 #ifndef OPENSSL_NO_DSA
1781 if (RAND_status() != 1) {
1782 RAND_seed(rnd_seed, sizeof rnd_seed);
1785 for (j = 0; j < DSA_NUM; j++) {
1792 /* DSA_generate_key(dsa_key[j]); */
1793 /* DSA_sign_setup(dsa_key[j],NULL); */
1794 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1797 "DSA sign failure. No DSA sign will be done.\n");
1798 ERR_print_errors(bio_err);
1801 pkey_print_message("sign", "dsa",
1802 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1804 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1805 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1807 BIO_printf(bio_err, "DSA sign failure\n");
1808 ERR_print_errors(bio_err);
1815 mr ? "+R3:%ld:%d:%.2f\n"
1816 : "%ld %d bit DSA signs in %.2fs\n",
1817 count, dsa_bits[j], d);
1818 dsa_results[j][0] = d / (double)count;
1822 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1825 "DSA verify failure. No DSA verify will be done.\n");
1826 ERR_print_errors(bio_err);
1829 pkey_print_message("verify", "dsa",
1830 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1832 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1833 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1835 BIO_printf(bio_err, "DSA verify failure\n");
1836 ERR_print_errors(bio_err);
1843 mr ? "+R4:%ld:%d:%.2f\n"
1844 : "%ld %d bit DSA verify in %.2fs\n",
1845 count, dsa_bits[j], d);
1846 dsa_results[j][1] = d / (double)count;
1849 if (rsa_count <= 1) {
1850 /* if longer than 10s, don't do any more */
1851 for (j++; j < DSA_NUM; j++)
1859 #ifndef OPENSSL_NO_EC
1860 if (RAND_status() != 1) {
1861 RAND_seed(rnd_seed, sizeof rnd_seed);
1864 for (j = 0; j < EC_NUM; j++) {
1868 continue; /* Ignore Curve */
1869 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1870 if (ecdsa[j] == NULL) {
1871 BIO_printf(bio_err, "ECDSA failure.\n");
1872 ERR_print_errors(bio_err);
1875 EC_KEY_precompute_mult(ecdsa[j], NULL);
1876 /* Perform ECDSA signature test */
1877 EC_KEY_generate_key(ecdsa[j]);
1878 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1881 "ECDSA sign failure. No ECDSA sign will be done.\n");
1882 ERR_print_errors(bio_err);
1885 pkey_print_message("sign", "ecdsa",
1887 test_curves_bits[j], ECDSA_SECONDS);
1890 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1891 st = ECDSA_sign(0, buf, 20,
1892 ecdsasig, &ecdsasiglen, ecdsa[j]);
1894 BIO_printf(bio_err, "ECDSA sign failure\n");
1895 ERR_print_errors(bio_err);
1903 mr ? "+R5:%ld:%d:%.2f\n" :
1904 "%ld %d bit ECDSA signs in %.2fs \n",
1905 count, test_curves_bits[j], d);
1906 ecdsa_results[j][0] = d / (double)count;
1910 /* Perform ECDSA verification test */
1911 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1914 "ECDSA verify failure. No ECDSA verify will be done.\n");
1915 ERR_print_errors(bio_err);
1918 pkey_print_message("verify", "ecdsa",
1920 test_curves_bits[j], ECDSA_SECONDS);
1922 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1923 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1926 BIO_printf(bio_err, "ECDSA verify failure\n");
1927 ERR_print_errors(bio_err);
1934 mr ? "+R6:%ld:%d:%.2f\n"
1935 : "%ld %d bit ECDSA verify in %.2fs\n",
1936 count, test_curves_bits[j], d);
1937 ecdsa_results[j][1] = d / (double)count;
1940 if (rsa_count <= 1) {
1941 /* if longer than 10s, don't do any more */
1942 for (j++; j < EC_NUM; j++)
1951 #ifndef OPENSSL_NO_EC
1952 if (RAND_status() != 1) {
1953 RAND_seed(rnd_seed, sizeof rnd_seed);
1956 for (j = 0; j < EC_NUM; j++) {
1959 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1960 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1961 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1962 BIO_printf(bio_err, "ECDH failure.\n");
1963 ERR_print_errors(bio_err);
1966 /* generate two ECDH key pairs */
1967 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1968 !EC_KEY_generate_key(ecdh_b[j])) {
1969 BIO_printf(bio_err, "ECDH key generation failure.\n");
1970 ERR_print_errors(bio_err);
1974 * If field size is not more than 24 octets, then use SHA-1
1975 * hash of result; otherwise, use result (see section 4.8 of
1976 * draft-ietf-tls-ecc-03.txt).
1978 int field_size, outlen;
1979 void *(*kdf) (const void *in, size_t inlen, void *out,
1982 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1983 if (field_size <= 24 * 8) {
1984 outlen = KDF1_SHA1_len;
1987 outlen = (field_size + 7) / 8;
1991 ECDH_compute_key(secret_a, outlen,
1992 EC_KEY_get0_public_key(ecdh_b[j]),
1995 ECDH_compute_key(secret_b, outlen,
1996 EC_KEY_get0_public_key(ecdh_a[j]),
1998 if (secret_size_a != secret_size_b)
2003 for (secret_idx = 0; (secret_idx < secret_size_a)
2004 && (ecdh_checks == 1); secret_idx++) {
2005 if (secret_a[secret_idx] != secret_b[secret_idx])
2009 if (ecdh_checks == 0) {
2010 BIO_printf(bio_err, "ECDH computations don't match.\n");
2011 ERR_print_errors(bio_err);
2015 pkey_print_message("", "ecdh",
2017 test_curves_bits[j], ECDH_SECONDS);
2019 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2020 ECDH_compute_key(secret_a, outlen,
2021 EC_KEY_get0_public_key(ecdh_b[j]),
2026 mr ? "+R7:%ld:%d:%.2f\n" :
2027 "%ld %d-bit ECDH ops in %.2fs\n", count,
2028 test_curves_bits[j], d);
2029 ecdh_results[j][0] = d / (double)count;
2034 if (rsa_count <= 1) {
2035 /* if longer than 10s, don't do any more */
2036 for (j++; j < EC_NUM; j++)
2047 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2048 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2050 printf("%s ", BN_options());
2051 #ifndef OPENSSL_NO_MD2
2052 printf("%s ", MD2_options());
2054 #ifndef OPENSSL_NO_RC4
2055 printf("%s ", RC4_options());
2057 #ifndef OPENSSL_NO_DES
2058 printf("%s ", DES_options());
2060 #ifndef OPENSSL_NO_AES
2061 printf("%s ", AES_options());
2063 #ifndef OPENSSL_NO_IDEA
2064 printf("%s ", idea_options());
2066 #ifndef OPENSSL_NO_BF
2067 printf("%s ", BF_options());
2069 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2077 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2080 for (j = 0; j < SIZE_NUM; j++)
2081 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2085 for (k = 0; k < ALGOR_NUM; k++) {
2089 printf("+F:%d:%s", k, names[k]);
2091 printf("%-13s", names[k]);
2092 for (j = 0; j < SIZE_NUM; j++) {
2093 if (results[k][j] > 10000 && !mr)
2094 printf(" %11.2fk", results[k][j] / 1e3);
2096 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2100 #ifndef OPENSSL_NO_RSA
2102 for (k = 0; k < RSA_NUM; k++) {
2106 printf("%18ssign verify sign/s verify/s\n", " ");
2110 printf("+F2:%u:%u:%f:%f\n",
2111 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2113 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2114 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2115 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2118 #ifndef OPENSSL_NO_DSA
2120 for (k = 0; k < DSA_NUM; k++) {
2124 printf("%18ssign verify sign/s verify/s\n", " ");
2128 printf("+F3:%u:%u:%f:%f\n",
2129 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2131 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2132 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2133 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2136 #ifndef OPENSSL_NO_EC
2138 for (k = 0; k < EC_NUM; k++) {
2142 printf("%30ssign verify sign/s verify/s\n", " ");
2147 printf("+F4:%u:%u:%f:%f\n",
2148 k, test_curves_bits[k],
2149 ecdsa_results[k][0], ecdsa_results[k][1]);
2151 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2152 test_curves_bits[k],
2153 test_curves_names[k],
2154 ecdsa_results[k][0], ecdsa_results[k][1],
2155 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2159 #ifndef OPENSSL_NO_EC
2161 for (k = 0; k < EC_NUM; k++) {
2165 printf("%30sop op/s\n", " ");
2169 printf("+F5:%u:%u:%f:%f\n",
2170 k, test_curves_bits[k],
2171 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2174 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2175 test_curves_bits[k],
2176 test_curves_names[k],
2177 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2184 ERR_print_errors(bio_err);
2185 OPENSSL_free(buf_malloc);
2186 OPENSSL_free(buf2_malloc);
2187 #ifndef OPENSSL_NO_RSA
2188 for (i = 0; i < RSA_NUM; i++)
2189 RSA_free(rsa_key[i]);
2191 #ifndef OPENSSL_NO_DSA
2192 for (i = 0; i < DSA_NUM; i++)
2193 DSA_free(dsa_key[i]);
2196 #ifndef OPENSSL_NO_EC
2197 for (i = 0; i < EC_NUM; i++) {
2198 EC_KEY_free(ecdsa[i]);
2199 EC_KEY_free(ecdh_a[i]);
2200 EC_KEY_free(ecdh_b[i]);
2206 static void print_message(const char *s, long num, int length)
2210 mr ? "+DT:%s:%d:%d\n"
2211 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2212 (void)BIO_flush(bio_err);
2216 mr ? "+DN:%s:%ld:%d\n"
2217 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2218 (void)BIO_flush(bio_err);
2222 static void pkey_print_message(const char *str, const char *str2, long num,
2227 mr ? "+DTP:%d:%s:%s:%d\n"
2228 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2229 (void)BIO_flush(bio_err);
2233 mr ? "+DNP:%ld:%d:%s:%s\n"
2234 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2235 (void)BIO_flush(bio_err);
2239 static void print_result(int alg, int run_no, int count, double time_used)
2242 mr ? "+R:%d:%s:%f\n"
2243 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2244 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2248 static char *sstrsep(char **string, const char *delim)
2251 char *token = *string;
2256 memset(isdelim, 0, sizeof isdelim);
2260 isdelim[(unsigned char)(*delim)] = 1;
2264 while (!isdelim[(unsigned char)(**string)]) {
2276 static int do_multi(int multi)
2281 static char sep[] = ":";
2283 fds = malloc(sizeof(*fds) * multi);
2284 for (n = 0; n < multi; ++n) {
2285 if (pipe(fd) == -1) {
2286 BIO_printf(bio_err, "pipe failure\n");
2290 (void)BIO_flush(bio_err);
2297 if (dup(fd[1]) == -1) {
2298 BIO_printf(bio_err, "dup failed\n");
2307 printf("Forked child %d\n", n);
2310 /* for now, assume the pipe is long enough to take all the output */
2311 for (n = 0; n < multi; ++n) {
2316 f = fdopen(fds[n], "r");
2317 while (fgets(buf, sizeof buf, f)) {
2318 p = strchr(buf, '\n');
2321 if (buf[0] != '+') {
2322 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2326 printf("Got: %s from %d\n", buf, n);
2327 if (strncmp(buf, "+F:", 3) == 0) {
2332 alg = atoi(sstrsep(&p, sep));
2334 for (j = 0; j < SIZE_NUM; ++j)
2335 results[alg][j] += atof(sstrsep(&p, sep));
2336 } else if (strncmp(buf, "+F2:", 4) == 0) {
2341 k = atoi(sstrsep(&p, sep));
2344 d = atof(sstrsep(&p, sep));
2346 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2348 rsa_results[k][0] = d;
2350 d = atof(sstrsep(&p, sep));
2352 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2354 rsa_results[k][1] = d;
2356 # ifndef OPENSSL_NO_DSA
2357 else if (strncmp(buf, "+F3:", 4) == 0) {
2362 k = atoi(sstrsep(&p, sep));
2365 d = atof(sstrsep(&p, sep));
2367 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2369 dsa_results[k][0] = d;
2371 d = atof(sstrsep(&p, sep));
2373 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2375 dsa_results[k][1] = d;
2378 # ifndef OPENSSL_NO_EC
2379 else if (strncmp(buf, "+F4:", 4) == 0) {
2384 k = atoi(sstrsep(&p, sep));
2387 d = atof(sstrsep(&p, sep));
2389 ecdsa_results[k][0] =
2390 1 / (1 / ecdsa_results[k][0] + 1 / d);
2392 ecdsa_results[k][0] = d;
2394 d = atof(sstrsep(&p, sep));
2396 ecdsa_results[k][1] =
2397 1 / (1 / ecdsa_results[k][1] + 1 / d);
2399 ecdsa_results[k][1] = d;
2403 # ifndef OPENSSL_NO_EC
2404 else if (strncmp(buf, "+F5:", 4) == 0) {
2409 k = atoi(sstrsep(&p, sep));
2412 d = atof(sstrsep(&p, sep));
2414 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2416 ecdh_results[k][0] = d;
2421 else if (strncmp(buf, "+H:", 3) == 0) {
2424 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2434 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2436 static int mblengths[] =
2437 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2438 int j, count, num = OSSL_NELEM(lengths);
2439 const char *alg_name;
2440 unsigned char *inp, *out, no_key[32], no_iv[16];
2444 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2445 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2446 EVP_CIPHER_CTX_init(&ctx);
2447 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2448 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2450 alg_name = OBJ_nid2ln(evp_cipher->nid);
2452 for (j = 0; j < num; j++) {
2453 print_message(alg_name, 0, mblengths[j]);
2455 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2456 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2457 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2458 size_t len = mblengths[j];
2461 memset(aad, 0, 8); /* avoid uninitialized values */
2462 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2463 aad[9] = 3; /* version */
2465 aad[11] = 0; /* length */
2467 mb_param.out = NULL;
2470 mb_param.interleave = 8;
2472 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2473 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2474 sizeof(mb_param), &mb_param);
2480 EVP_CIPHER_CTX_ctrl(&ctx,
2481 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2482 sizeof(mb_param), &mb_param);
2486 RAND_bytes(out, 16);
2490 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2491 EVP_CTRL_AEAD_TLS1_AAD,
2492 EVP_AEAD_TLS1_AAD_LEN, aad);
2493 EVP_Cipher(&ctx, out, inp, len + pad);
2497 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2498 : "%d %s's in %.2fs\n", count, "evp", d);
2499 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2503 fprintf(stdout, "+H");
2504 for (j = 0; j < num; j++)
2505 fprintf(stdout, ":%d", mblengths[j]);
2506 fprintf(stdout, "\n");
2507 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2508 for (j = 0; j < num; j++)
2509 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2510 fprintf(stdout, "\n");
2513 "The 'numbers' are in 1000s of bytes per second processed.\n");
2514 fprintf(stdout, "type ");
2515 for (j = 0; j < num; j++)
2516 fprintf(stdout, "%7d bytes", mblengths[j]);
2517 fprintf(stdout, "\n");
2518 fprintf(stdout, "%-24s", alg_name);
2520 for (j = 0; j < num; j++) {
2521 if (results[D_EVP][j] > 10000)
2522 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2524 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2526 fprintf(stdout, "\n");