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
101 #include <openssl/bn.h>
102 #ifndef OPENSSL_NO_DES
103 # include <openssl/des.h>
105 #ifndef OPENSSL_NO_AES
106 # include <openssl/aes.h>
108 #ifndef OPENSSL_NO_CAMELLIA
109 # include <openssl/camellia.h>
111 #ifndef OPENSSL_NO_MD2
112 # include <openssl/md2.h>
114 #ifndef OPENSSL_NO_MDC2
115 # include <openssl/mdc2.h>
117 #ifndef OPENSSL_NO_MD4
118 # include <openssl/md4.h>
120 #ifndef OPENSSL_NO_MD5
121 # include <openssl/md5.h>
123 #include <openssl/hmac.h>
124 #include <openssl/sha.h>
125 #ifndef OPENSSL_NO_RMD160
126 # include <openssl/ripemd.h>
128 #ifndef OPENSSL_NO_WHIRLPOOL
129 # include <openssl/whrlpool.h>
131 #ifndef OPENSSL_NO_RC4
132 # include <openssl/rc4.h>
134 #ifndef OPENSSL_NO_RC5
135 # include <openssl/rc5.h>
137 #ifndef OPENSSL_NO_RC2
138 # include <openssl/rc2.h>
140 #ifndef OPENSSL_NO_IDEA
141 # include <openssl/idea.h>
143 #ifndef OPENSSL_NO_SEED
144 # include <openssl/seed.h>
146 #ifndef OPENSSL_NO_BF
147 # include <openssl/blowfish.h>
149 #ifndef OPENSSL_NO_CAST
150 # include <openssl/cast.h>
152 #ifndef OPENSSL_NO_RSA
153 # include <openssl/rsa.h>
154 # include "./testrsa.h"
156 #include <openssl/x509.h>
157 #ifndef OPENSSL_NO_DSA
158 # include <openssl/dsa.h>
159 # include "./testdsa.h"
161 #ifndef OPENSSL_NO_EC
162 # include <openssl/ec.h>
164 #include <openssl/modes.h>
167 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
181 #define BUFSIZE (1024*8+1)
182 #define MAX_MISALIGNMENT 63
184 static volatile int run = 0;
187 static int usertime = 1;
189 static double Time_F(int s);
190 static void print_message(const char *s, long num, int length);
191 static void pkey_print_message(const char *str, const char *str2,
192 long num, int bits, int sec);
193 static void print_result(int alg, int run_no, int count, double time_used);
195 static int do_multi(int multi);
205 #define MAX_ECDH_SIZE 256
208 static const char *names[ALGOR_NUM] = {
209 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
210 "des cbc", "des ede3", "idea cbc", "seed cbc",
211 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
212 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
213 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
214 "evp", "sha256", "sha512", "whirlpool",
215 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
218 static double results[ALGOR_NUM][SIZE_NUM];
219 static int lengths[SIZE_NUM] = {
220 16, 64, 256, 1024, 8 * 1024
223 #ifndef OPENSSL_NO_RSA
224 static double rsa_results[RSA_NUM][2];
226 #ifndef OPENSSL_NO_DSA
227 static double dsa_results[DSA_NUM][2];
229 #ifndef OPENSSL_NO_EC
230 static double ecdsa_results[EC_NUM][2];
231 static double ecdh_results[EC_NUM][1];
234 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
235 static const char rnd_seed[] =
236 "string to make the random number generator think it has entropy";
237 static int rnd_fake = 0;
241 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
242 # define SIGRETTYPE void
244 # define SIGRETTYPE int
247 static SIGRETTYPE sig_done(int sig);
248 static SIGRETTYPE sig_done(int sig)
250 signal(SIGALRM, sig_done);
260 # if !defined(SIGALRM)
263 static unsigned int lapse, schlock;
264 static void alarm_win32(unsigned int secs)
269 # define alarm alarm_win32
271 static DWORD WINAPI sleepy(VOID * arg)
279 static double Time_F(int s)
286 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
288 DWORD err = GetLastError();
289 BIO_printf(bio_err, "unable to CreateThread (%lu)", err);
293 Sleep(0); /* scheduler spinlock */
294 ret = app_tminterval(s, usertime);
296 ret = app_tminterval(s, usertime);
298 TerminateThread(thr, 0);
306 static double Time_F(int s)
308 double ret = app_tminterval(s, usertime);
315 #ifndef OPENSSL_NO_EC
316 static const int KDF1_SHA1_len = 20;
317 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
320 if (*outlen < SHA_DIGEST_LENGTH)
322 *outlen = SHA_DIGEST_LENGTH;
323 return SHA1(in, inlen, out);
325 #endif /* OPENSSL_NO_EC */
327 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
329 static int found(const char *name, const OPT_PAIR * pairs, int *result)
331 for (; pairs->name; pairs++)
332 if (strcmp(name, pairs->name) == 0) {
333 *result = pairs->retval;
339 typedef enum OPTION_choice {
340 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
341 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
342 OPT_MR, OPT_MB, OPT_MISALIGN
345 OPTIONS speed_options[] = {
346 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
347 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
348 {"help", OPT_HELP, '-', "Display this summary"},
349 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
350 {"decrypt", OPT_DECRYPT, '-',
351 "Time decryption instead of encryption (only EVP)"},
352 {"mr", OPT_MR, '-', "Produce machine readable output"},
354 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
355 {"elapsed", OPT_ELAPSED, '-',
356 "Measure time in real time instead of CPU user time"},
358 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
360 #ifndef OPENSSL_NO_ENGINE
361 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
376 #define D_CBC_IDEA 10
377 #define D_CBC_SEED 11
381 #define D_CBC_CAST 15
382 #define D_CBC_128_AES 16
383 #define D_CBC_192_AES 17
384 #define D_CBC_256_AES 18
385 #define D_CBC_128_CML 19
386 #define D_CBC_192_CML 20
387 #define D_CBC_256_CML 21
391 #define D_WHIRLPOOL 25
392 #define D_IGE_128_AES 26
393 #define D_IGE_192_AES 27
394 #define D_IGE_256_AES 28
396 static OPT_PAIR doit_choices[] = {
397 #ifndef OPENSSL_NO_MD2
400 #ifndef OPENSSL_NO_MDC2
403 #ifndef OPENSSL_NO_MD4
406 #ifndef OPENSSL_NO_MD5
409 #ifndef OPENSSL_NO_MD5
413 {"sha256", D_SHA256},
414 {"sha512", D_SHA512},
415 #ifndef OPENSSL_NO_WHIRLPOOL
416 {"whirlpool", D_WHIRLPOOL},
418 #ifndef OPENSSL_NO_RMD160
419 {"ripemd", D_RMD160},
420 {"rmd160", D_RMD160},
421 {"ripemd160", D_RMD160},
423 #ifndef OPENSSL_NO_RC4
426 #ifndef OPENSSL_NO_DES
427 {"des-cbc", D_CBC_DES},
428 {"des-ede3", D_EDE3_DES},
430 #ifndef OPENSSL_NO_AES
431 {"aes-128-cbc", D_CBC_128_AES},
432 {"aes-192-cbc", D_CBC_192_AES},
433 {"aes-256-cbc", D_CBC_256_AES},
434 {"aes-128-ige", D_IGE_128_AES},
435 {"aes-192-ige", D_IGE_192_AES},
436 {"aes-256-ige", D_IGE_256_AES},
438 #ifndef OPENSSL_NO_RC2
439 {"rc2-cbc", D_CBC_RC2},
442 #ifndef OPENSSL_NO_RC5
443 {"rc5-cbc", D_CBC_RC5},
446 #ifndef OPENSSL_NO_IDEA
447 {"idea-cbc", D_CBC_IDEA},
448 {"idea", D_CBC_IDEA},
450 #ifndef OPENSSL_NO_SEED
451 {"seed-cbc", D_CBC_SEED},
452 {"seed", D_CBC_SEED},
454 #ifndef OPENSSL_NO_BF
455 {"bf-cbc", D_CBC_BF},
456 {"blowfish", D_CBC_BF},
459 #ifndef OPENSSL_NO_CAST
460 {"cast-cbc", D_CBC_CAST},
461 {"cast", D_CBC_CAST},
462 {"cast5", D_CBC_CAST},
471 static OPT_PAIR dsa_choices[] = {
472 {"dsa512", R_DSA_512},
473 {"dsa1024", R_DSA_1024},
474 {"dsa2048", R_DSA_2048},
484 #define R_RSA_15360 6
485 static OPT_PAIR rsa_choices[] = {
486 {"rsa512", R_RSA_512},
487 {"rsa1024", R_RSA_1024},
488 {"rsa2048", R_RSA_2048},
489 {"rsa3072", R_RSA_3072},
490 {"rsa4096", R_RSA_4096},
491 {"rsa7680", R_RSA_7680},
492 {"rsa15360", R_RSA_15360},
512 #define R_EC_X25519 16
513 #ifndef OPENSSL_NO_EC
514 static OPT_PAIR ecdsa_choices[] = {
515 {"ecdsap160", R_EC_P160},
516 {"ecdsap192", R_EC_P192},
517 {"ecdsap224", R_EC_P224},
518 {"ecdsap256", R_EC_P256},
519 {"ecdsap384", R_EC_P384},
520 {"ecdsap521", R_EC_P521},
521 {"ecdsak163", R_EC_K163},
522 {"ecdsak233", R_EC_K233},
523 {"ecdsak283", R_EC_K283},
524 {"ecdsak409", R_EC_K409},
525 {"ecdsak571", R_EC_K571},
526 {"ecdsab163", R_EC_B163},
527 {"ecdsab233", R_EC_B233},
528 {"ecdsab283", R_EC_B283},
529 {"ecdsab409", R_EC_B409},
530 {"ecdsab571", R_EC_B571},
533 static OPT_PAIR ecdh_choices[] = {
534 {"ecdhp160", R_EC_P160},
535 {"ecdhp192", R_EC_P192},
536 {"ecdhp224", R_EC_P224},
537 {"ecdhp256", R_EC_P256},
538 {"ecdhp384", R_EC_P384},
539 {"ecdhp521", R_EC_P521},
540 {"ecdhk163", R_EC_K163},
541 {"ecdhk233", R_EC_K233},
542 {"ecdhk283", R_EC_K283},
543 {"ecdhk409", R_EC_K409},
544 {"ecdhk571", R_EC_K571},
545 {"ecdhb163", R_EC_B163},
546 {"ecdhb233", R_EC_B233},
547 {"ecdhb283", R_EC_B283},
548 {"ecdhb409", R_EC_B409},
549 {"ecdhb571", R_EC_B571},
550 {"ecdhx25519", R_EC_X25519},
555 int speed_main(int argc, char **argv)
558 const EVP_CIPHER *evp_cipher = NULL;
559 const EVP_MD *evp_md = NULL;
562 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
563 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
564 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
565 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
566 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
567 unsigned char *buf = NULL, *buf2 = NULL;
568 unsigned char md[EVP_MAX_MD_SIZE];
572 /* What follows are the buffers and key material. */
573 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
576 #ifndef OPENSSL_NO_MD2
577 unsigned char md2[MD2_DIGEST_LENGTH];
579 #ifndef OPENSSL_NO_MDC2
580 unsigned char mdc2[MDC2_DIGEST_LENGTH];
582 #ifndef OPENSSL_NO_MD4
583 unsigned char md4[MD4_DIGEST_LENGTH];
585 #ifndef OPENSSL_NO_MD5
586 unsigned char md5[MD5_DIGEST_LENGTH];
587 unsigned char hmac[MD5_DIGEST_LENGTH];
589 unsigned char sha[SHA_DIGEST_LENGTH];
590 unsigned char sha256[SHA256_DIGEST_LENGTH];
591 unsigned char sha512[SHA512_DIGEST_LENGTH];
592 #ifndef OPENSSL_NO_WHIRLPOOL
593 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
595 #ifndef OPENSSL_NO_RMD160
596 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
598 #ifndef OPENSSL_NO_RC4
601 #ifndef OPENSSL_NO_RC5
604 #ifndef OPENSSL_NO_RC2
607 #ifndef OPENSSL_NO_IDEA
608 IDEA_KEY_SCHEDULE idea_ks;
610 #ifndef OPENSSL_NO_SEED
611 SEED_KEY_SCHEDULE seed_ks;
613 #ifndef OPENSSL_NO_BF
616 #ifndef OPENSSL_NO_CAST
619 static const unsigned char key16[16] = {
620 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
621 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
623 #ifndef OPENSSL_NO_AES
624 static const unsigned char key24[24] = {
625 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
626 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
627 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
629 static const unsigned char key32[32] = {
630 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
631 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
632 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
633 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
636 #ifndef OPENSSL_NO_CAMELLIA
637 static const unsigned char ckey24[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 ckey32[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
648 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
650 #ifndef OPENSSL_NO_AES
651 # define MAX_BLOCK_SIZE 128
653 # define MAX_BLOCK_SIZE 64
655 unsigned char DES_iv[8];
656 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
657 #ifndef OPENSSL_NO_DES
658 static DES_cblock key = {
659 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
661 static DES_cblock key2 = {
662 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
664 static DES_cblock key3 = {
665 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
667 DES_key_schedule sch;
668 DES_key_schedule sch2;
669 DES_key_schedule sch3;
671 #ifndef OPENSSL_NO_AES
672 AES_KEY aes_ks1, aes_ks2, aes_ks3;
674 #ifndef OPENSSL_NO_RSA
676 RSA *rsa_key[RSA_NUM];
677 long rsa_c[RSA_NUM][2];
678 static unsigned int rsa_bits[RSA_NUM] = {
679 512, 1024, 2048, 3072, 4096, 7680, 15360
681 static unsigned char *rsa_data[RSA_NUM] = {
682 test512, test1024, test2048, test3072, test4096, test7680, test15360
684 static int rsa_data_length[RSA_NUM] = {
685 sizeof(test512), sizeof(test1024),
686 sizeof(test2048), sizeof(test3072),
687 sizeof(test4096), sizeof(test7680),
691 #ifndef OPENSSL_NO_DSA
692 DSA *dsa_key[DSA_NUM];
693 long dsa_c[DSA_NUM][2];
694 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
696 #ifndef OPENSSL_NO_EC
698 * We only test over the following curves as they are representative, To
699 * add tests over more curves, simply add the curve NID and curve name to
700 * the following arrays and increase the EC_NUM value accordingly.
702 static unsigned int test_curves[EC_NUM] = {
704 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
705 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
707 NID_sect163k1, NID_sect233k1, NID_sect283k1,
708 NID_sect409k1, NID_sect571k1, NID_sect163r2,
709 NID_sect233r1, NID_sect283r1, NID_sect409r1,
714 static const char *test_curves_names[EC_NUM] = {
716 "secp160r1", "nistp192", "nistp224",
717 "nistp256", "nistp384", "nistp521",
719 "nistk163", "nistk233", "nistk283",
720 "nistk409", "nistk571", "nistb163",
721 "nistb233", "nistb283", "nistb409",
726 static int test_curves_bits[EC_NUM] = {
732 571, 253 /* X25519 */
735 #ifndef OPENSSL_NO_EC
736 unsigned char ecdsasig[256];
737 unsigned int ecdsasiglen;
738 EC_KEY *ecdsa[EC_NUM];
739 long ecdsa_c[EC_NUM][2];
740 int ecdsa_doit[EC_NUM];
741 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
742 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
743 int secret_size_a, secret_size_b;
746 long ecdh_c[EC_NUM][2];
747 int ecdh_doit[EC_NUM];
750 memset(results, 0, sizeof(results));
751 #ifndef OPENSSL_NO_DSA
752 memset(dsa_key, 0, sizeof(dsa_key));
754 #ifndef OPENSSL_NO_EC
755 for (i = 0; i < EC_NUM; i++)
757 for (i = 0; i < EC_NUM; i++)
758 ecdh_a[i] = ecdh_b[i] = NULL;
760 #ifndef OPENSSL_NO_RSA
761 memset(rsa_key, 0, sizeof(rsa_key));
762 for (i = 0; i < RSA_NUM; i++)
766 memset(c, 0, sizeof(c));
767 memset(DES_iv, 0, sizeof(DES_iv));
768 memset(iv, 0, sizeof(iv));
770 for (i = 0; i < ALGOR_NUM; i++)
772 for (i = 0; i < RSA_NUM; i++)
774 for (i = 0; i < DSA_NUM; i++)
776 #ifndef OPENSSL_NO_EC
777 for (i = 0; i < EC_NUM; i++)
779 for (i = 0; i < EC_NUM; i++)
783 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
784 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
787 prog = opt_init(argc, argv, speed_options);
788 while ((o = opt_next()) != OPT_EOF) {
793 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
796 opt_help(speed_options);
803 evp_cipher = EVP_get_cipherbyname(opt_arg());
804 if (evp_cipher == NULL)
805 evp_md = EVP_get_digestbyname(opt_arg());
806 if (evp_cipher == NULL && evp_md == NULL) {
808 "%s: %s an unknown cipher or digest\n",
818 (void)setup_engine(opt_arg(), 0);
822 multi = atoi(opt_arg());
826 if (!opt_int(opt_arg(), &misalign))
828 if (misalign > MISALIGN) {
830 "%s: Maximum offset is %d\n", prog, MISALIGN);
833 buf = buf_malloc + misalign;
834 buf2 = buf2_malloc + misalign;
844 argc = opt_num_rest();
847 /* Remaining arguments are algorithms. */
848 for ( ; *argv; argv++) {
849 if (found(*argv, doit_choices, &i)) {
853 #ifndef OPENSSL_NO_DES
854 if (strcmp(*argv, "des") == 0) {
855 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
859 if (strcmp(*argv, "sha") == 0) {
860 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
863 #ifndef OPENSSL_NO_RSA
865 if (strcmp(*argv, "openssl") == 0) {
866 RSA_set_default_method(RSA_PKCS1_OpenSSL());
870 if (strcmp(*argv, "rsa") == 0) {
871 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
872 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
873 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
874 rsa_doit[R_RSA_15360] = 1;
877 if (found(*argv, rsa_choices, &i)) {
882 #ifndef OPENSSL_NO_DSA
883 if (strcmp(*argv, "dsa") == 0) {
884 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
885 dsa_doit[R_DSA_2048] = 1;
888 if (found(*argv, dsa_choices, &i)) {
893 #ifndef OPENSSL_NO_AES
894 if (strcmp(*argv, "aes") == 0) {
895 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
896 doit[D_CBC_256_AES] = 1;
900 #ifndef OPENSSL_NO_CAMELLIA
901 if (strcmp(*argv, "camellia") == 0) {
902 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
903 doit[D_CBC_256_CML] = 1;
907 #ifndef OPENSSL_NO_EC
908 if (strcmp(*argv, "ecdsa") == 0) {
909 for (i = 0; i < EC_NUM; i++)
913 if (found(*argv, ecdsa_choices, &i)) {
917 if (strcmp(*argv, "ecdh") == 0) {
918 for (i = 0; i < EC_NUM; i++)
922 if (found(*argv, ecdh_choices, &i)) {
927 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
932 if (multi && do_multi(multi))
936 /* No parameters; turn on everything. */
937 if ((argc == 0) && !doit[D_EVP]) {
938 for (i = 0; i < ALGOR_NUM; i++)
941 for (i = 0; i < RSA_NUM; i++)
943 for (i = 0; i < DSA_NUM; i++)
945 #ifndef OPENSSL_NO_EC
946 for (i = 0; i < EC_NUM; i++)
948 for (i = 0; i < EC_NUM; i++)
952 for (i = 0; i < ALGOR_NUM; i++)
956 if (usertime == 0 && !mr)
958 "You have chosen to measure elapsed time "
959 "instead of user CPU time.\n");
961 #ifndef OPENSSL_NO_RSA
962 for (i = 0; i < RSA_NUM; i++) {
963 const unsigned char *p;
966 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
967 if (rsa_key[i] == NULL) {
968 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
975 #ifndef OPENSSL_NO_DSA
976 dsa_key[0] = get_dsa512();
977 dsa_key[1] = get_dsa1024();
978 dsa_key[2] = get_dsa2048();
981 #ifndef OPENSSL_NO_DES
982 DES_set_key_unchecked(&key, &sch);
983 DES_set_key_unchecked(&key2, &sch2);
984 DES_set_key_unchecked(&key3, &sch3);
986 #ifndef OPENSSL_NO_AES
987 AES_set_encrypt_key(key16, 128, &aes_ks1);
988 AES_set_encrypt_key(key24, 192, &aes_ks2);
989 AES_set_encrypt_key(key32, 256, &aes_ks3);
991 #ifndef OPENSSL_NO_CAMELLIA
992 Camellia_set_key(key16, 128, &camellia_ks1);
993 Camellia_set_key(ckey24, 192, &camellia_ks2);
994 Camellia_set_key(ckey32, 256, &camellia_ks3);
996 #ifndef OPENSSL_NO_IDEA
997 idea_set_encrypt_key(key16, &idea_ks);
999 #ifndef OPENSSL_NO_SEED
1000 SEED_set_key(key16, &seed_ks);
1002 #ifndef OPENSSL_NO_RC4
1003 RC4_set_key(&rc4_ks, 16, key16);
1005 #ifndef OPENSSL_NO_RC2
1006 RC2_set_key(&rc2_ks, 16, key16, 128);
1008 #ifndef OPENSSL_NO_RC5
1009 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1011 #ifndef OPENSSL_NO_BF
1012 BF_set_key(&bf_ks, 16, key16);
1014 #ifndef OPENSSL_NO_CAST
1015 CAST_set_key(&cast_ks, 16, key16);
1017 #ifndef OPENSSL_NO_RSA
1018 memset(rsa_c, 0, sizeof(rsa_c));
1021 # ifndef OPENSSL_NO_DES
1022 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1028 for (it = count; it; it--)
1029 DES_ecb_encrypt((DES_cblock *)buf,
1030 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1034 c[D_MD2][0] = count / 10;
1035 c[D_MDC2][0] = count / 10;
1036 c[D_MD4][0] = count;
1037 c[D_MD5][0] = count;
1038 c[D_HMAC][0] = count;
1039 c[D_SHA1][0] = count;
1040 c[D_RMD160][0] = count;
1041 c[D_RC4][0] = count * 5;
1042 c[D_CBC_DES][0] = count;
1043 c[D_EDE3_DES][0] = count / 3;
1044 c[D_CBC_IDEA][0] = count;
1045 c[D_CBC_SEED][0] = count;
1046 c[D_CBC_RC2][0] = count;
1047 c[D_CBC_RC5][0] = count;
1048 c[D_CBC_BF][0] = count;
1049 c[D_CBC_CAST][0] = count;
1050 c[D_CBC_128_AES][0] = count;
1051 c[D_CBC_192_AES][0] = count;
1052 c[D_CBC_256_AES][0] = count;
1053 c[D_CBC_128_CML][0] = count;
1054 c[D_CBC_192_CML][0] = count;
1055 c[D_CBC_256_CML][0] = count;
1056 c[D_SHA256][0] = count;
1057 c[D_SHA512][0] = count;
1058 c[D_WHIRLPOOL][0] = count;
1059 c[D_IGE_128_AES][0] = count;
1060 c[D_IGE_192_AES][0] = count;
1061 c[D_IGE_256_AES][0] = count;
1062 c[D_GHASH][0] = count;
1064 for (i = 1; i < SIZE_NUM; i++) {
1067 l0 = (long)lengths[0];
1068 l1 = (long)lengths[i];
1070 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1071 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1072 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1073 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1074 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1075 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1076 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1077 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1078 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1079 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1080 c[D_GHASH][i] = c[D_GHASH][0] * 4 * l0 / l1;
1082 l0 = (long)lengths[i - 1];
1084 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1085 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1086 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1087 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1088 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1089 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1090 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1091 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1092 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1093 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1094 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1095 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1096 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1097 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1098 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1099 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1100 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1101 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1104 # ifndef OPENSSL_NO_RSA
1105 rsa_c[R_RSA_512][0] = count / 2000;
1106 rsa_c[R_RSA_512][1] = count / 400;
1107 for (i = 1; i < RSA_NUM; i++) {
1108 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1109 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1110 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1113 if (rsa_c[i][0] == 0) {
1121 # ifndef OPENSSL_NO_DSA
1122 dsa_c[R_DSA_512][0] = count / 1000;
1123 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1124 for (i = 1; i < DSA_NUM; i++) {
1125 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1126 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1127 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1130 if (dsa_c[i] == 0) {
1138 # ifndef OPENSSL_NO_EC
1139 ecdsa_c[R_EC_P160][0] = count / 1000;
1140 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1141 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1142 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1143 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1144 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1147 if (ecdsa_c[i] == 0) {
1153 ecdsa_c[R_EC_K163][0] = count / 1000;
1154 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1155 for (i = R_EC_K233; i <= R_EC_K571; 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_B163][0] = count / 1000;
1168 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1169 for (i = R_EC_B233; i <= R_EC_B571; 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) {
1182 ecdh_c[R_EC_P160][0] = count / 1000;
1183 ecdh_c[R_EC_P160][1] = count / 1000;
1184 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1185 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1186 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1187 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1190 if (ecdh_c[i] == 0) {
1196 ecdh_c[R_EC_K163][0] = count / 1000;
1197 ecdh_c[R_EC_K163][1] = count / 1000;
1198 for (i = R_EC_K233; i <= R_EC_K571; 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_B163][0] = count / 1000;
1211 ecdh_c[R_EC_B163][1] = count / 1000;
1212 for (i = R_EC_B233; i <= R_EC_B571; 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) {
1226 # define COND(d) (count < (d))
1227 # define COUNT(d) (d)
1229 /* not worth fixing */
1230 # error "You cannot disable DES on systems without SIGALRM."
1231 # endif /* OPENSSL_NO_DES */
1233 # define COND(c) (run && count<0x7fffffff)
1234 # define COUNT(d) (count)
1236 signal(SIGALRM, sig_done);
1238 #endif /* SIGALRM */
1240 #ifndef OPENSSL_NO_MD2
1242 for (j = 0; j < SIZE_NUM; j++) {
1243 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1245 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1246 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1249 print_result(D_MD2, j, count, d);
1253 #ifndef OPENSSL_NO_MDC2
1255 for (j = 0; j < SIZE_NUM; j++) {
1256 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1258 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1259 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1262 print_result(D_MDC2, j, count, d);
1267 #ifndef OPENSSL_NO_MD4
1269 for (j = 0; j < SIZE_NUM; j++) {
1270 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1272 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1273 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1274 NULL, EVP_md4(), NULL);
1276 print_result(D_MD4, j, count, d);
1281 #ifndef OPENSSL_NO_MD5
1283 for (j = 0; j < SIZE_NUM; j++) {
1284 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1286 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1287 MD5(buf, lengths[j], md5);
1289 print_result(D_MD5, j, count, d);
1294 #if !defined(OPENSSL_NO_MD5)
1296 HMAC_CTX *hctx = NULL;
1298 hctx = HMAC_CTX_new();
1300 BIO_printf(bio_err, "HMAC malloc failure, exiting...");
1303 HMAC_Init_ex(hctx, (unsigned char *)"This is a key...",
1304 16, EVP_md5(), NULL);
1306 for (j = 0; j < SIZE_NUM; j++) {
1307 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1309 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1310 HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
1311 HMAC_Update(hctx, buf, lengths[j]);
1312 HMAC_Final(hctx, &(hmac[0]), NULL);
1315 print_result(D_HMAC, j, count, d);
1317 HMAC_CTX_free(hctx);
1321 for (j = 0; j < SIZE_NUM; j++) {
1322 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1324 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1325 SHA1(buf, lengths[j], sha);
1327 print_result(D_SHA1, j, count, d);
1330 if (doit[D_SHA256]) {
1331 for (j = 0; j < SIZE_NUM; j++) {
1332 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1334 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1335 SHA256(buf, lengths[j], sha256);
1337 print_result(D_SHA256, j, count, d);
1340 if (doit[D_SHA512]) {
1341 for (j = 0; j < SIZE_NUM; j++) {
1342 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1344 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1345 SHA512(buf, lengths[j], sha512);
1347 print_result(D_SHA512, j, count, d);
1351 #ifndef OPENSSL_NO_WHIRLPOOL
1352 if (doit[D_WHIRLPOOL]) {
1353 for (j = 0; j < SIZE_NUM; j++) {
1354 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1356 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1357 WHIRLPOOL(buf, lengths[j], whirlpool);
1359 print_result(D_WHIRLPOOL, j, count, d);
1364 #ifndef OPENSSL_NO_RMD160
1365 if (doit[D_RMD160]) {
1366 for (j = 0; j < SIZE_NUM; j++) {
1367 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1369 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1370 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1371 EVP_ripemd160(), NULL);
1373 print_result(D_RMD160, j, count, d);
1377 #ifndef OPENSSL_NO_RC4
1379 for (j = 0; j < SIZE_NUM; j++) {
1380 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1382 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1383 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1385 print_result(D_RC4, j, count, d);
1389 #ifndef OPENSSL_NO_DES
1390 if (doit[D_CBC_DES]) {
1391 for (j = 0; j < SIZE_NUM; j++) {
1392 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1394 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1395 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1396 &DES_iv, DES_ENCRYPT);
1398 print_result(D_CBC_DES, j, count, d);
1402 if (doit[D_EDE3_DES]) {
1403 for (j = 0; j < SIZE_NUM; j++) {
1404 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1406 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1407 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1409 &DES_iv, DES_ENCRYPT);
1411 print_result(D_EDE3_DES, j, count, d);
1415 #ifndef OPENSSL_NO_AES
1416 if (doit[D_CBC_128_AES]) {
1417 for (j = 0; j < SIZE_NUM; j++) {
1418 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1421 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1422 AES_cbc_encrypt(buf, buf,
1423 (unsigned long)lengths[j], &aes_ks1,
1426 print_result(D_CBC_128_AES, j, count, d);
1429 if (doit[D_CBC_192_AES]) {
1430 for (j = 0; j < SIZE_NUM; j++) {
1431 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1434 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1435 AES_cbc_encrypt(buf, buf,
1436 (unsigned long)lengths[j], &aes_ks2,
1439 print_result(D_CBC_192_AES, j, count, d);
1442 if (doit[D_CBC_256_AES]) {
1443 for (j = 0; j < SIZE_NUM; j++) {
1444 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1447 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1448 AES_cbc_encrypt(buf, buf,
1449 (unsigned long)lengths[j], &aes_ks3,
1452 print_result(D_CBC_256_AES, j, count, d);
1456 if (doit[D_IGE_128_AES]) {
1457 for (j = 0; j < SIZE_NUM; j++) {
1458 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1461 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1462 AES_ige_encrypt(buf, buf2,
1463 (unsigned long)lengths[j], &aes_ks1,
1466 print_result(D_IGE_128_AES, j, count, d);
1469 if (doit[D_IGE_192_AES]) {
1470 for (j = 0; j < SIZE_NUM; j++) {
1471 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1474 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1475 AES_ige_encrypt(buf, buf2,
1476 (unsigned long)lengths[j], &aes_ks2,
1479 print_result(D_IGE_192_AES, j, count, d);
1482 if (doit[D_IGE_256_AES]) {
1483 for (j = 0; j < SIZE_NUM; j++) {
1484 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1487 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1488 AES_ige_encrypt(buf, buf2,
1489 (unsigned long)lengths[j], &aes_ks3,
1492 print_result(D_IGE_256_AES, j, count, d);
1495 if (doit[D_GHASH]) {
1496 GCM128_CONTEXT *ctx =
1497 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1498 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1500 for (j = 0; j < SIZE_NUM; j++) {
1501 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1503 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1504 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1506 print_result(D_GHASH, j, count, d);
1508 CRYPTO_gcm128_release(ctx);
1511 #ifndef OPENSSL_NO_CAMELLIA
1512 if (doit[D_CBC_128_CML]) {
1513 for (j = 0; j < SIZE_NUM; j++) {
1514 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1517 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1518 Camellia_cbc_encrypt(buf, buf,
1519 (unsigned long)lengths[j], &camellia_ks1,
1520 iv, CAMELLIA_ENCRYPT);
1522 print_result(D_CBC_128_CML, j, count, d);
1525 if (doit[D_CBC_192_CML]) {
1526 for (j = 0; j < SIZE_NUM; j++) {
1527 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1530 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1531 Camellia_cbc_encrypt(buf, buf,
1532 (unsigned long)lengths[j], &camellia_ks2,
1533 iv, CAMELLIA_ENCRYPT);
1535 print_result(D_CBC_192_CML, j, count, d);
1538 if (doit[D_CBC_256_CML]) {
1539 for (j = 0; j < SIZE_NUM; j++) {
1540 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1543 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1544 Camellia_cbc_encrypt(buf, buf,
1545 (unsigned long)lengths[j], &camellia_ks3,
1546 iv, CAMELLIA_ENCRYPT);
1548 print_result(D_CBC_256_CML, j, count, d);
1552 #ifndef OPENSSL_NO_IDEA
1553 if (doit[D_CBC_IDEA]) {
1554 for (j = 0; j < SIZE_NUM; j++) {
1555 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1557 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1558 idea_cbc_encrypt(buf, buf,
1559 (unsigned long)lengths[j], &idea_ks,
1562 print_result(D_CBC_IDEA, j, count, d);
1566 #ifndef OPENSSL_NO_SEED
1567 if (doit[D_CBC_SEED]) {
1568 for (j = 0; j < SIZE_NUM; j++) {
1569 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1571 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1572 SEED_cbc_encrypt(buf, buf,
1573 (unsigned long)lengths[j], &seed_ks, iv, 1);
1575 print_result(D_CBC_SEED, j, count, d);
1579 #ifndef OPENSSL_NO_RC2
1580 if (doit[D_CBC_RC2]) {
1581 for (j = 0; j < SIZE_NUM; j++) {
1582 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1584 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1585 RC2_cbc_encrypt(buf, buf,
1586 (unsigned long)lengths[j], &rc2_ks,
1589 print_result(D_CBC_RC2, j, count, d);
1593 #ifndef OPENSSL_NO_RC5
1594 if (doit[D_CBC_RC5]) {
1595 for (j = 0; j < SIZE_NUM; j++) {
1596 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1598 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1599 RC5_32_cbc_encrypt(buf, buf,
1600 (unsigned long)lengths[j], &rc5_ks,
1603 print_result(D_CBC_RC5, j, count, d);
1607 #ifndef OPENSSL_NO_BF
1608 if (doit[D_CBC_BF]) {
1609 for (j = 0; j < SIZE_NUM; j++) {
1610 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1612 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1613 BF_cbc_encrypt(buf, buf,
1614 (unsigned long)lengths[j], &bf_ks,
1617 print_result(D_CBC_BF, j, count, d);
1621 #ifndef OPENSSL_NO_CAST
1622 if (doit[D_CBC_CAST]) {
1623 for (j = 0; j < SIZE_NUM; j++) {
1624 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1626 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1627 CAST_cbc_encrypt(buf, buf,
1628 (unsigned long)lengths[j], &cast_ks,
1631 print_result(D_CBC_CAST, j, count, d);
1637 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1638 if (multiblock && evp_cipher) {
1640 (EVP_CIPHER_flags(evp_cipher) &
1641 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1642 BIO_printf(bio_err, "%s is not multi-block capable\n",
1643 OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher)));
1646 multiblock_speed(evp_cipher);
1651 for (j = 0; j < SIZE_NUM; j++) {
1653 EVP_CIPHER_CTX *ctx;
1656 names[D_EVP] = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
1658 * -O3 -fschedule-insns messes up an optimization here!
1659 * names[D_EVP] somehow becomes NULL
1661 print_message(names[D_EVP], save_count, lengths[j]);
1663 ctx = EVP_CIPHER_CTX_new();
1665 EVP_DecryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1667 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, key16, iv);
1668 EVP_CIPHER_CTX_set_padding(ctx, 0);
1672 for (count = 0, run = 1;
1673 COND(save_count * 4 * lengths[0] / lengths[j]);
1675 EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1677 for (count = 0, run = 1;
1678 COND(save_count * 4 * lengths[0] / lengths[j]);
1680 EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[j]);
1682 EVP_DecryptFinal_ex(ctx, buf, &outl);
1684 EVP_EncryptFinal_ex(ctx, buf, &outl);
1686 EVP_CIPHER_CTX_free(ctx);
1689 names[D_EVP] = OBJ_nid2ln(EVP_MD_type(evp_md));
1690 print_message(names[D_EVP], save_count, lengths[j]);
1693 for (count = 0, run = 1;
1694 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1695 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1699 print_result(D_EVP, j, count, d);
1703 RAND_bytes(buf, 36);
1704 #ifndef OPENSSL_NO_RSA
1705 for (j = 0; j < RSA_NUM; j++) {
1709 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1712 "RSA sign failure. No RSA sign will be done.\n");
1713 ERR_print_errors(bio_err);
1716 pkey_print_message("private", "rsa",
1717 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1718 /* RSA_blinding_on(rsa_key[j],NULL); */
1720 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1721 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1722 &rsa_num, rsa_key[j]);
1724 BIO_printf(bio_err, "RSA sign failure\n");
1725 ERR_print_errors(bio_err);
1732 mr ? "+R1:%ld:%d:%.2f\n"
1733 : "%ld %d bit private RSA's in %.2fs\n",
1734 count, rsa_bits[j], d);
1735 rsa_results[j][0] = d / (double)count;
1739 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1742 "RSA verify failure. No RSA verify will be done.\n");
1743 ERR_print_errors(bio_err);
1746 pkey_print_message("public", "rsa",
1747 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1749 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1750 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1751 rsa_num, rsa_key[j]);
1753 BIO_printf(bio_err, "RSA verify failure\n");
1754 ERR_print_errors(bio_err);
1761 mr ? "+R2:%ld:%d:%.2f\n"
1762 : "%ld %d bit public RSA's in %.2fs\n",
1763 count, rsa_bits[j], d);
1764 rsa_results[j][1] = d / (double)count;
1767 if (rsa_count <= 1) {
1768 /* if longer than 10s, don't do any more */
1769 for (j++; j < RSA_NUM; j++)
1775 RAND_bytes(buf, 20);
1776 #ifndef OPENSSL_NO_DSA
1777 if (RAND_status() != 1) {
1778 RAND_seed(rnd_seed, sizeof rnd_seed);
1781 for (j = 0; j < DSA_NUM; j++) {
1788 /* DSA_generate_key(dsa_key[j]); */
1789 /* DSA_sign_setup(dsa_key[j],NULL); */
1790 st = DSA_sign(0, buf, 20, buf2, &kk, dsa_key[j]);
1793 "DSA sign failure. No DSA sign will be done.\n");
1794 ERR_print_errors(bio_err);
1797 pkey_print_message("sign", "dsa",
1798 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1800 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1801 st = DSA_sign(0, buf, 20, buf2, &kk, dsa_key[j]);
1803 BIO_printf(bio_err, "DSA sign failure\n");
1804 ERR_print_errors(bio_err);
1811 mr ? "+R3:%ld:%d:%.2f\n"
1812 : "%ld %d bit DSA signs in %.2fs\n",
1813 count, dsa_bits[j], d);
1814 dsa_results[j][0] = d / (double)count;
1818 st = DSA_verify(0, buf, 20, buf2, kk, dsa_key[j]);
1821 "DSA verify failure. No DSA verify will be done.\n");
1822 ERR_print_errors(bio_err);
1825 pkey_print_message("verify", "dsa",
1826 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1828 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1829 st = DSA_verify(0, buf, 20, buf2, kk, dsa_key[j]);
1831 BIO_printf(bio_err, "DSA verify failure\n");
1832 ERR_print_errors(bio_err);
1839 mr ? "+R4:%ld:%d:%.2f\n"
1840 : "%ld %d bit DSA verify in %.2fs\n",
1841 count, dsa_bits[j], d);
1842 dsa_results[j][1] = d / (double)count;
1845 if (rsa_count <= 1) {
1846 /* if longer than 10s, don't do any more */
1847 for (j++; j < DSA_NUM; j++)
1855 #ifndef OPENSSL_NO_EC
1856 if (RAND_status() != 1) {
1857 RAND_seed(rnd_seed, sizeof rnd_seed);
1860 for (j = 0; j < EC_NUM; j++) {
1864 continue; /* Ignore Curve */
1865 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1866 if (ecdsa[j] == NULL) {
1867 BIO_printf(bio_err, "ECDSA failure.\n");
1868 ERR_print_errors(bio_err);
1871 EC_KEY_precompute_mult(ecdsa[j], NULL);
1872 /* Perform ECDSA signature test */
1873 EC_KEY_generate_key(ecdsa[j]);
1874 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1877 "ECDSA sign failure. No ECDSA sign will be done.\n");
1878 ERR_print_errors(bio_err);
1881 pkey_print_message("sign", "ecdsa",
1883 test_curves_bits[j], ECDSA_SECONDS);
1886 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1887 st = ECDSA_sign(0, buf, 20,
1888 ecdsasig, &ecdsasiglen, ecdsa[j]);
1890 BIO_printf(bio_err, "ECDSA sign failure\n");
1891 ERR_print_errors(bio_err);
1899 mr ? "+R5:%ld:%d:%.2f\n" :
1900 "%ld %d bit ECDSA signs in %.2fs \n",
1901 count, test_curves_bits[j], d);
1902 ecdsa_results[j][0] = d / (double)count;
1906 /* Perform ECDSA verification test */
1907 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1910 "ECDSA verify failure. No ECDSA verify will be done.\n");
1911 ERR_print_errors(bio_err);
1914 pkey_print_message("verify", "ecdsa",
1916 test_curves_bits[j], ECDSA_SECONDS);
1918 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1919 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1922 BIO_printf(bio_err, "ECDSA verify failure\n");
1923 ERR_print_errors(bio_err);
1930 mr ? "+R6:%ld:%d:%.2f\n"
1931 : "%ld %d bit ECDSA verify in %.2fs\n",
1932 count, test_curves_bits[j], d);
1933 ecdsa_results[j][1] = d / (double)count;
1936 if (rsa_count <= 1) {
1937 /* if longer than 10s, don't do any more */
1938 for (j++; j < EC_NUM; j++)
1947 #ifndef OPENSSL_NO_EC
1948 if (RAND_status() != 1) {
1949 RAND_seed(rnd_seed, sizeof rnd_seed);
1952 for (j = 0; j < EC_NUM; j++) {
1955 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1956 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1957 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1958 BIO_printf(bio_err, "ECDH failure.\n");
1959 ERR_print_errors(bio_err);
1962 /* generate two ECDH key pairs */
1963 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1964 !EC_KEY_generate_key(ecdh_b[j])) {
1965 BIO_printf(bio_err, "ECDH key generation failure.\n");
1966 ERR_print_errors(bio_err);
1970 * If field size is not more than 24 octets, then use SHA-1
1971 * hash of result; otherwise, use result (see section 4.8 of
1972 * draft-ietf-tls-ecc-03.txt).
1974 int field_size, outlen;
1975 void *(*kdf) (const void *in, size_t inlen, void *out,
1978 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1979 if (field_size <= 24 * 8) {
1980 outlen = KDF1_SHA1_len;
1983 outlen = (field_size + 7) / 8;
1987 ECDH_compute_key(secret_a, outlen,
1988 EC_KEY_get0_public_key(ecdh_b[j]),
1991 ECDH_compute_key(secret_b, outlen,
1992 EC_KEY_get0_public_key(ecdh_a[j]),
1994 if (secret_size_a != secret_size_b)
1999 for (secret_idx = 0; (secret_idx < secret_size_a)
2000 && (ecdh_checks == 1); secret_idx++) {
2001 if (secret_a[secret_idx] != secret_b[secret_idx])
2005 if (ecdh_checks == 0) {
2006 BIO_printf(bio_err, "ECDH computations don't match.\n");
2007 ERR_print_errors(bio_err);
2011 pkey_print_message("", "ecdh",
2013 test_curves_bits[j], ECDH_SECONDS);
2015 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2016 ECDH_compute_key(secret_a, outlen,
2017 EC_KEY_get0_public_key(ecdh_b[j]),
2022 mr ? "+R7:%ld:%d:%.2f\n" :
2023 "%ld %d-bit ECDH ops in %.2fs\n", count,
2024 test_curves_bits[j], d);
2025 ecdh_results[j][0] = d / (double)count;
2030 if (rsa_count <= 1) {
2031 /* if longer than 10s, don't do any more */
2032 for (j++; j < EC_NUM; j++)
2043 printf("%s\n", OpenSSL_version(OPENSSL_VERSION));
2044 printf("%s\n", OpenSSL_version(OPENSSL_BUILT_ON));
2046 printf("%s ", BN_options());
2047 #ifndef OPENSSL_NO_MD2
2048 printf("%s ", MD2_options());
2050 #ifndef OPENSSL_NO_RC4
2051 printf("%s ", RC4_options());
2053 #ifndef OPENSSL_NO_DES
2054 printf("%s ", DES_options());
2056 #ifndef OPENSSL_NO_AES
2057 printf("%s ", AES_options());
2059 #ifndef OPENSSL_NO_IDEA
2060 printf("%s ", idea_options());
2062 #ifndef OPENSSL_NO_BF
2063 printf("%s ", BF_options());
2065 printf("\n%s\n", OpenSSL_version(OPENSSL_CFLAGS));
2073 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2076 for (j = 0; j < SIZE_NUM; j++)
2077 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2081 for (k = 0; k < ALGOR_NUM; k++) {
2085 printf("+F:%d:%s", k, names[k]);
2087 printf("%-13s", names[k]);
2088 for (j = 0; j < SIZE_NUM; j++) {
2089 if (results[k][j] > 10000 && !mr)
2090 printf(" %11.2fk", results[k][j] / 1e3);
2092 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2096 #ifndef OPENSSL_NO_RSA
2098 for (k = 0; k < RSA_NUM; k++) {
2102 printf("%18ssign verify sign/s verify/s\n", " ");
2106 printf("+F2:%u:%u:%f:%f\n",
2107 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2109 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2110 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2111 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2114 #ifndef OPENSSL_NO_DSA
2116 for (k = 0; k < DSA_NUM; k++) {
2120 printf("%18ssign verify sign/s verify/s\n", " ");
2124 printf("+F3:%u:%u:%f:%f\n",
2125 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2127 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2128 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2129 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2132 #ifndef OPENSSL_NO_EC
2134 for (k = 0; k < EC_NUM; k++) {
2138 printf("%30ssign verify sign/s verify/s\n", " ");
2143 printf("+F4:%u:%u:%f:%f\n",
2144 k, test_curves_bits[k],
2145 ecdsa_results[k][0], ecdsa_results[k][1]);
2147 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2148 test_curves_bits[k],
2149 test_curves_names[k],
2150 ecdsa_results[k][0], ecdsa_results[k][1],
2151 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2155 #ifndef OPENSSL_NO_EC
2157 for (k = 0; k < EC_NUM; k++) {
2161 printf("%30sop op/s\n", " ");
2165 printf("+F5:%u:%u:%f:%f\n",
2166 k, test_curves_bits[k],
2167 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2170 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2171 test_curves_bits[k],
2172 test_curves_names[k],
2173 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2180 ERR_print_errors(bio_err);
2181 OPENSSL_free(buf_malloc);
2182 OPENSSL_free(buf2_malloc);
2183 #ifndef OPENSSL_NO_RSA
2184 for (i = 0; i < RSA_NUM; i++)
2185 RSA_free(rsa_key[i]);
2187 #ifndef OPENSSL_NO_DSA
2188 for (i = 0; i < DSA_NUM; i++)
2189 DSA_free(dsa_key[i]);
2192 #ifndef OPENSSL_NO_EC
2193 for (i = 0; i < EC_NUM; i++) {
2194 EC_KEY_free(ecdsa[i]);
2195 EC_KEY_free(ecdh_a[i]);
2196 EC_KEY_free(ecdh_b[i]);
2202 static void print_message(const char *s, long num, int length)
2206 mr ? "+DT:%s:%d:%d\n"
2207 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2208 (void)BIO_flush(bio_err);
2212 mr ? "+DN:%s:%ld:%d\n"
2213 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2214 (void)BIO_flush(bio_err);
2218 static void pkey_print_message(const char *str, const char *str2, long num,
2223 mr ? "+DTP:%d:%s:%s:%d\n"
2224 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2225 (void)BIO_flush(bio_err);
2229 mr ? "+DNP:%ld:%d:%s:%s\n"
2230 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2231 (void)BIO_flush(bio_err);
2235 static void print_result(int alg, int run_no, int count, double time_used)
2238 mr ? "+R:%d:%s:%f\n"
2239 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2240 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2244 static char *sstrsep(char **string, const char *delim)
2247 char *token = *string;
2252 memset(isdelim, 0, sizeof isdelim);
2256 isdelim[(unsigned char)(*delim)] = 1;
2260 while (!isdelim[(unsigned char)(**string)]) {
2272 static int do_multi(int multi)
2277 static char sep[] = ":";
2279 fds = malloc(sizeof(*fds) * multi);
2280 for (n = 0; n < multi; ++n) {
2281 if (pipe(fd) == -1) {
2282 BIO_printf(bio_err, "pipe failure\n");
2286 (void)BIO_flush(bio_err);
2293 if (dup(fd[1]) == -1) {
2294 BIO_printf(bio_err, "dup failed\n");
2303 printf("Forked child %d\n", n);
2306 /* for now, assume the pipe is long enough to take all the output */
2307 for (n = 0; n < multi; ++n) {
2312 f = fdopen(fds[n], "r");
2313 while (fgets(buf, sizeof buf, f)) {
2314 p = strchr(buf, '\n');
2317 if (buf[0] != '+') {
2318 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2322 printf("Got: %s from %d\n", buf, n);
2323 if (strncmp(buf, "+F:", 3) == 0) {
2328 alg = atoi(sstrsep(&p, sep));
2330 for (j = 0; j < SIZE_NUM; ++j)
2331 results[alg][j] += atof(sstrsep(&p, sep));
2332 } else if (strncmp(buf, "+F2:", 4) == 0) {
2337 k = atoi(sstrsep(&p, sep));
2340 d = atof(sstrsep(&p, sep));
2342 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2344 rsa_results[k][0] = d;
2346 d = atof(sstrsep(&p, sep));
2348 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2350 rsa_results[k][1] = d;
2352 # ifndef OPENSSL_NO_DSA
2353 else if (strncmp(buf, "+F3:", 4) == 0) {
2358 k = atoi(sstrsep(&p, sep));
2361 d = atof(sstrsep(&p, sep));
2363 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2365 dsa_results[k][0] = d;
2367 d = atof(sstrsep(&p, sep));
2369 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2371 dsa_results[k][1] = d;
2374 # ifndef OPENSSL_NO_EC
2375 else if (strncmp(buf, "+F4:", 4) == 0) {
2380 k = atoi(sstrsep(&p, sep));
2383 d = atof(sstrsep(&p, sep));
2385 ecdsa_results[k][0] =
2386 1 / (1 / ecdsa_results[k][0] + 1 / d);
2388 ecdsa_results[k][0] = d;
2390 d = atof(sstrsep(&p, sep));
2392 ecdsa_results[k][1] =
2393 1 / (1 / ecdsa_results[k][1] + 1 / d);
2395 ecdsa_results[k][1] = d;
2399 # ifndef OPENSSL_NO_EC
2400 else if (strncmp(buf, "+F5:", 4) == 0) {
2405 k = atoi(sstrsep(&p, sep));
2408 d = atof(sstrsep(&p, sep));
2410 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2412 ecdh_results[k][0] = d;
2417 else if (strncmp(buf, "+H:", 3) == 0) {
2420 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2430 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2432 static int mblengths[] =
2433 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2434 int j, count, num = OSSL_NELEM(lengths);
2435 const char *alg_name;
2436 unsigned char *inp, *out, no_key[32], no_iv[16];
2437 EVP_CIPHER_CTX *ctx;
2440 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2441 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2442 ctx = EVP_CIPHER_CTX_new();
2443 EVP_EncryptInit_ex(ctx, evp_cipher, NULL, no_key, no_iv);
2444 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2446 alg_name = OBJ_nid2ln(EVP_CIPHER_nid(evp_cipher));
2448 for (j = 0; j < num; j++) {
2449 print_message(alg_name, 0, mblengths[j]);
2451 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2452 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2453 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2454 size_t len = mblengths[j];
2457 memset(aad, 0, 8); /* avoid uninitialized values */
2458 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2459 aad[9] = 3; /* version */
2461 aad[11] = 0; /* length */
2463 mb_param.out = NULL;
2466 mb_param.interleave = 8;
2468 packlen = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2469 sizeof(mb_param), &mb_param);
2475 EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2476 sizeof(mb_param), &mb_param);
2480 RAND_bytes(out, 16);
2484 pad = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_TLS1_AAD,
2485 EVP_AEAD_TLS1_AAD_LEN, aad);
2486 EVP_Cipher(ctx, out, inp, len + pad);
2490 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2491 : "%d %s's in %.2fs\n", count, "evp", d);
2492 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2496 fprintf(stdout, "+H");
2497 for (j = 0; j < num; j++)
2498 fprintf(stdout, ":%d", mblengths[j]);
2499 fprintf(stdout, "\n");
2500 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2501 for (j = 0; j < num; j++)
2502 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2503 fprintf(stdout, "\n");
2506 "The 'numbers' are in 1000s of bytes per second processed.\n");
2507 fprintf(stdout, "type ");
2508 for (j = 0; j < num; j++)
2509 fprintf(stdout, "%7d bytes", mblengths[j]);
2510 fprintf(stdout, "\n");
2511 fprintf(stdout, "%-24s", alg_name);
2513 for (j = 0; j < num; j++) {
2514 if (results[D_EVP][j] > 10000)
2515 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2517 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2519 fprintf(stdout, "\n");
2524 EVP_CIPHER_CTX_free(ctx);