1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
57 /* ====================================================================
58 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60 * Portions of the attached software ("Contribution") are developed by
61 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
63 * The Contribution is licensed pursuant to the OpenSSL open source
64 * license provided above.
66 * The ECDH and ECDSA speed test software is originally written by
67 * Sumit Gupta of Sun Microsystems Laboratories.
73 #define PRIME_SECONDS 10
74 #define RSA_SECONDS 10
75 #define DSA_SECONDS 10
76 #define ECDSA_SECONDS 10
77 #define ECDH_SECONDS 10
84 #include <openssl/crypto.h>
85 #include <openssl/rand.h>
86 #include <openssl/err.h>
87 #include <openssl/evp.h>
88 #include <openssl/objects.h>
89 #if !defined(OPENSSL_SYS_MSDOS)
90 # include OPENSSL_UNISTD
93 #ifndef OPENSSL_SYS_NETWARE
97 #if defined(_WIN32) || defined(__CYGWIN__)
99 # if defined(__CYGWIN__) && !defined(_WIN32)
101 * <windows.h> should define _WIN32, which normally is mutually exclusive
102 * with __CYGWIN__, but if it didn't...
105 /* this is done because Cygwin alarm() fails sometimes. */
109 #include <openssl/bn.h>
110 #ifndef OPENSSL_NO_DES
111 # include <openssl/des.h>
113 #ifndef OPENSSL_NO_AES
114 # include <openssl/aes.h>
116 #ifndef OPENSSL_NO_CAMELLIA
117 # include <openssl/camellia.h>
119 #ifndef OPENSSL_NO_MD2
120 # include <openssl/md2.h>
122 #ifndef OPENSSL_NO_MDC2
123 # include <openssl/mdc2.h>
125 #ifndef OPENSSL_NO_MD4
126 # include <openssl/md4.h>
128 #ifndef OPENSSL_NO_MD5
129 # include <openssl/md5.h>
131 #include <openssl/hmac.h>
132 #include <openssl/evp.h>
133 #include <openssl/sha.h>
134 #ifndef OPENSSL_NO_RMD160
135 # include <openssl/ripemd.h>
137 #ifndef OPENSSL_NO_WHIRLPOOL
138 # include <openssl/whrlpool.h>
140 #ifndef OPENSSL_NO_RC4
141 # include <openssl/rc4.h>
143 #ifndef OPENSSL_NO_RC5
144 # include <openssl/rc5.h>
146 #ifndef OPENSSL_NO_RC2
147 # include <openssl/rc2.h>
149 #ifndef OPENSSL_NO_IDEA
150 # include <openssl/idea.h>
152 #ifndef OPENSSL_NO_SEED
153 # include <openssl/seed.h>
155 #ifndef OPENSSL_NO_BF
156 # include <openssl/blowfish.h>
158 #ifndef OPENSSL_NO_CAST
159 # include <openssl/cast.h>
161 #ifndef OPENSSL_NO_RSA
162 # include <openssl/rsa.h>
163 # include "./testrsa.h"
165 #include <openssl/x509.h>
166 #ifndef OPENSSL_NO_DSA
167 # include <openssl/dsa.h>
168 # include "./testdsa.h"
170 #ifndef OPENSSL_NO_EC
171 # include <openssl/ecdsa.h>
172 # include <openssl/ecdh.h>
174 #include <openssl/modes.h>
176 #include <openssl/bn.h>
179 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
193 #define BUFSIZE (1024*8+1)
194 #define MAX_MISALIGNMENT 63
196 static volatile int run = 0;
199 static int usertime = 1;
201 static double Time_F(int s);
202 static void print_message(const char *s, long num, int length);
203 static void pkey_print_message(const char *str, const char *str2,
204 long num, int bits, int sec);
205 static void print_result(int alg, int run_no, int count, double time_used);
207 static int do_multi(int multi);
217 #define MAX_ECDH_SIZE 256
220 static const char *names[ALGOR_NUM] = {
221 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
222 "des cbc", "des ede3", "idea cbc", "seed cbc",
223 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
224 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
225 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
226 "evp", "sha256", "sha512", "whirlpool",
227 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
230 static double results[ALGOR_NUM][SIZE_NUM];
231 static int lengths[SIZE_NUM] = {
232 16, 64, 256, 1024, 8 * 1024
235 #ifndef OPENSSL_NO_RSA
236 static double rsa_results[RSA_NUM][2];
238 #ifndef OPENSSL_NO_DSA
239 static double dsa_results[DSA_NUM][2];
241 #ifndef OPENSSL_NO_EC
242 static double ecdsa_results[EC_NUM][2];
243 static double ecdh_results[EC_NUM][1];
246 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
247 static const char rnd_seed[] =
248 "string to make the random number generator think it has entropy";
249 static int rnd_fake = 0;
253 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
254 # define SIGRETTYPE void
256 # define SIGRETTYPE int
259 static SIGRETTYPE sig_done(int sig);
260 static SIGRETTYPE sig_done(int sig)
262 signal(SIGALRM, sig_done);
272 # if !defined(SIGALRM)
275 static unsigned int lapse, schlock;
276 static void alarm_win32(unsigned int secs)
281 # define alarm alarm_win32
283 static DWORD WINAPI sleepy(VOID * arg)
291 static double Time_F(int s)
298 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
300 DWORD ret = GetLastError();
301 BIO_printf(bio_err, "unable to CreateThread (%d)", ret);
305 Sleep(0); /* scheduler spinlock */
306 ret = app_tminterval(s, usertime);
308 ret = app_tminterval(s, usertime);
310 TerminateThread(thr, 0);
318 static double Time_F(int s)
320 double ret = app_tminterval(s, usertime);
327 #ifndef OPENSSL_NO_EC
328 static const int KDF1_SHA1_len = 20;
329 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
332 if (*outlen < SHA_DIGEST_LENGTH)
334 *outlen = SHA_DIGEST_LENGTH;
335 return SHA1(in, inlen, out);
337 #endif /* OPENSSL_NO_EC */
339 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
341 static int found(const char *name, const OPT_PAIR * pairs, int *result)
343 for (; pairs->name; pairs++)
344 if (strcmp(name, pairs->name) == 0) {
345 *result = pairs->retval;
351 typedef enum OPTION_choice {
352 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
353 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
354 OPT_MR, OPT_MB, OPT_MISALIGN
357 OPTIONS speed_options[] = {
358 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
359 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
360 {"help", OPT_HELP, '-', "Display this summary"},
361 #if defined(TIMES) || defined(USE_TOD)
362 {"elapsed", OPT_ELAPSED, '-',
363 "Measure time in real time instead of CPU user time"},
365 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
366 {"decrypt", OPT_DECRYPT, '-',
367 "Time decryption instead of encryption (only EVP)"},
369 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
371 {"mr", OPT_MR, '-', "Produce machine readable output"},
373 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
374 #ifndef OPENSSL_NO_ENGINE
375 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
389 #define D_CBC_IDEA 10
390 #define D_CBC_SEED 11
394 #define D_CBC_CAST 15
395 #define D_CBC_128_AES 16
396 #define D_CBC_192_AES 17
397 #define D_CBC_256_AES 18
398 #define D_CBC_128_CML 19
399 #define D_CBC_192_CML 20
400 #define D_CBC_256_CML 21
404 #define D_WHIRLPOOL 25
405 #define D_IGE_128_AES 26
406 #define D_IGE_192_AES 27
407 #define D_IGE_256_AES 28
409 OPT_PAIR doit_choices[] = {
410 #ifndef OPENSSL_NO_MD2
413 #ifndef OPENSSL_NO_MDC2
416 #ifndef OPENSSL_NO_MD4
419 #ifndef OPENSSL_NO_MD5
422 #ifndef OPENSSL_NO_MD5
426 {"sha256", D_SHA256},
427 {"sha512", D_SHA512},
428 #ifndef OPENSSL_NO_WHIRLPOOL
429 {"whirlpool", D_WHIRLPOOL},
431 #ifndef OPENSSL_NO_RIPEMD
432 {"ripemd", D_RMD160},
433 {"rmd160", D_RMD160},
434 {"ripemd160", D_RMD160},
436 #ifndef OPENSSL_NO_RC4
439 #ifndef OPENSSL_NO_DES
440 {"des-cbc", D_CBC_DES},
441 {"des-ede3", D_EDE3_DES},
443 #ifndef OPENSSL_NO_AES
444 {"aes-128-cbc", D_CBC_128_AES},
445 {"aes-192-cbc", D_CBC_192_AES},
446 {"aes-256-cbc", D_CBC_256_AES},
447 {"aes-128-ige", D_IGE_128_AES},
448 {"aes-192-ige", D_IGE_192_AES},
449 {"aes-256-ige", D_IGE_256_AES},
451 #ifndef OPENSSL_NO_RC2
452 {"rc2-cbc", D_CBC_RC2},
455 #ifndef OPENSSL_NO_RC5
456 {"rc5-cbc", D_CBC_RC5},
459 #ifndef OPENSSL_NO_IDEA
460 {"idea-cbc", D_CBC_IDEA},
461 {"idea", D_CBC_IDEA},
463 #ifndef OPENSSL_NO_SEED
464 {"seed-cbc", D_CBC_SEED},
465 {"seed", D_CBC_SEED},
467 #ifndef OPENSSL_NO_BF
468 {"bf-cbc", D_CBC_BF},
469 {"blowfish", D_CBC_BF},
472 #ifndef OPENSSL_NO_CAST
473 {"cast-cbc", D_CBC_CAST},
474 {"cast", D_CBC_CAST},
475 {"cast5", D_CBC_CAST},
484 static OPT_PAIR dsa_choices[] = {
485 {"dsa512", R_DSA_512},
486 {"dsa1024", R_DSA_1024},
487 {"dsa2048", R_DSA_2048},
497 #define R_RSA_15360 6
498 static OPT_PAIR rsa_choices[] = {
499 {"rsa512", R_RSA_512},
500 {"rsa1024", R_RSA_1024},
501 {"rsa2048", R_RSA_2048},
502 {"rsa3072", R_RSA_3072},
503 {"rsa4096", R_RSA_4096},
504 {"rsa7680", R_RSA_7680},
505 {"rsa15360", R_RSA_15360},
525 #ifndef OPENSSL_NO_ECA
526 static OPT_PAIR ecdsa_choices[] = {
527 {"ecdsap160", R_EC_P160},
528 {"ecdsap192", R_EC_P192},
529 {"ecdsap224", R_EC_P224},
530 {"ecdsap256", R_EC_P256},
531 {"ecdsap384", R_EC_P384},
532 {"ecdsap521", R_EC_P521},
533 {"ecdsak163", R_EC_K163},
534 {"ecdsak233", R_EC_K233},
535 {"ecdsak283", R_EC_K283},
536 {"ecdsak409", R_EC_K409},
537 {"ecdsak571", R_EC_K571},
538 {"ecdsab163", R_EC_B163},
539 {"ecdsab233", R_EC_B233},
540 {"ecdsab283", R_EC_B283},
541 {"ecdsab409", R_EC_B409},
542 {"ecdsab571", R_EC_B571},
545 static OPT_PAIR ecdh_choices[] = {
546 {"ecdhp160", R_EC_P160},
547 {"ecdhp192", R_EC_P192},
548 {"ecdhp224", R_EC_P224},
549 {"ecdhp256", R_EC_P256},
550 {"ecdhp384", R_EC_P384},
551 {"ecdhp521", R_EC_P521},
552 {"ecdhk163", R_EC_K163},
553 {"ecdhk233", R_EC_K233},
554 {"ecdhk283", R_EC_K283},
555 {"ecdhk409", R_EC_K409},
556 {"ecdhk571", R_EC_K571},
557 {"ecdhb163", R_EC_B163},
558 {"ecdhb233", R_EC_B233},
559 {"ecdhb283", R_EC_B283},
560 {"ecdhb409", R_EC_B409},
561 {"ecdhb571", R_EC_B571},
566 int speed_main(int argc, char **argv)
569 const EVP_CIPHER *evp_cipher = NULL;
570 const EVP_MD *evp_md = NULL;
573 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
574 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
575 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
576 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
577 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
578 unsigned char *buf = NULL, *buf2 = NULL;
579 unsigned char *save_buf = NULL, *save_buf2 = NULL;
580 unsigned char md[EVP_MAX_MD_SIZE];
584 /* What follows are the buffers and key material. */
585 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
588 #ifndef OPENSSL_NO_MD2
589 unsigned char md2[MD2_DIGEST_LENGTH];
591 #ifndef OPENSSL_NO_MDC2
592 unsigned char mdc2[MDC2_DIGEST_LENGTH];
594 #ifndef OPENSSL_NO_MD4
595 unsigned char md4[MD4_DIGEST_LENGTH];
597 #ifndef OPENSSL_NO_MD5
598 unsigned char md5[MD5_DIGEST_LENGTH];
599 unsigned char hmac[MD5_DIGEST_LENGTH];
601 unsigned char sha[SHA_DIGEST_LENGTH];
602 unsigned char sha256[SHA256_DIGEST_LENGTH];
603 unsigned char sha512[SHA512_DIGEST_LENGTH];
604 #ifndef OPENSSL_NO_WHIRLPOOL
605 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
607 #ifndef OPENSSL_NO_RIPEMD
608 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
610 #ifndef OPENSSL_NO_RC4
613 #ifndef OPENSSL_NO_RC5
616 #ifndef OPENSSL_NO_RC2
619 #ifndef OPENSSL_NO_IDEA
620 IDEA_KEY_SCHEDULE idea_ks;
622 #ifndef OPENSSL_NO_SEED
623 SEED_KEY_SCHEDULE seed_ks;
625 #ifndef OPENSSL_NO_BF
628 #ifndef OPENSSL_NO_CAST
631 static const unsigned char key16[16] = {
632 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
633 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
635 #ifndef OPENSSL_NO_AES
636 static const unsigned char key24[24] = {
637 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
638 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
639 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
641 static const unsigned char key32[32] = {
642 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
643 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
644 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
645 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
648 #ifndef OPENSSL_NO_CAMELLIA
649 static const unsigned char ckey24[24] = {
650 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
651 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
652 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
654 static const unsigned char ckey32[32] = {
655 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
656 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
657 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
658 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
660 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
662 #ifndef OPENSSL_NO_AES
663 # define MAX_BLOCK_SIZE 128
665 # define MAX_BLOCK_SIZE 64
667 unsigned char DES_iv[8];
668 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
669 #ifndef OPENSSL_NO_DES
670 static DES_cblock key = {
671 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
673 static DES_cblock key2 = {
674 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
676 static DES_cblock key3 = {
677 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
679 DES_key_schedule sch;
680 DES_key_schedule sch2;
681 DES_key_schedule sch3;
683 #ifndef OPENSSL_NO_AES
684 AES_KEY aes_ks1, aes_ks2, aes_ks3;
686 #ifndef OPENSSL_NO_RSA
688 RSA *rsa_key[RSA_NUM];
689 long rsa_c[RSA_NUM][2];
690 static unsigned int rsa_bits[RSA_NUM] = {
691 512, 1024, 2048, 3072, 4096, 7680, 15360
693 static unsigned char *rsa_data[RSA_NUM] = {
694 test512, test1024, test2048, test3072, test4096, test7680, test15360
696 static int rsa_data_length[RSA_NUM] = {
697 sizeof(test512), sizeof(test1024),
698 sizeof(test2048), sizeof(test3072),
699 sizeof(test4096), sizeof(test7680),
703 #ifndef OPENSSL_NO_DSA
704 DSA *dsa_key[DSA_NUM];
705 long dsa_c[DSA_NUM][2];
706 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
708 #ifndef OPENSSL_NO_EC
710 * We only test over the following curves as they are representative, To
711 * add tests over more curves, simply add the curve NID and curve name to
712 * the following arrays and increase the EC_NUM value accordingly.
714 static unsigned int test_curves[EC_NUM] = {
716 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
717 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
719 NID_sect163k1, NID_sect233k1, NID_sect283k1,
720 NID_sect409k1, NID_sect571k1, NID_sect163r2,
721 NID_sect233r1, NID_sect283r1, NID_sect409r1,
724 static const char *test_curves_names[EC_NUM] = {
726 "secp160r1", "nistp192", "nistp224",
727 "nistp256", "nistp384", "nistp521",
729 "nistk163", "nistk233", "nistk283",
730 "nistk409", "nistk571", "nistb163",
731 "nistb233", "nistb283", "nistb409",
734 static int test_curves_bits[EC_NUM] = {
743 #ifndef OPENSSL_NO_EC
744 unsigned char ecdsasig[256];
745 unsigned int ecdsasiglen;
746 EC_KEY *ecdsa[EC_NUM];
747 long ecdsa_c[EC_NUM][2];
748 int ecdsa_doit[EC_NUM];
749 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
750 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
751 int secret_size_a, secret_size_b;
754 long ecdh_c[EC_NUM][2];
755 int ecdh_doit[EC_NUM];
761 memset(results, 0, sizeof(results));
762 #ifndef OPENSSL_NO_DSA
763 memset(dsa_key, 0, sizeof(dsa_key));
765 #ifndef OPENSSL_NO_EC
766 for (i = 0; i < EC_NUM; i++)
768 for (i = 0; i < EC_NUM; i++)
769 ecdh_a[i] = ecdh_b[i] = NULL;
771 #ifndef OPENSSL_NO_RSA
772 memset(rsa_key, 0, sizeof(rsa_key));
773 for (i = 0; i < RSA_NUM; i++)
777 memset(c, 0, sizeof(c));
778 memset(DES_iv, 0, sizeof(DES_iv));
779 memset(iv, 0, sizeof(iv));
781 for (i = 0; i < ALGOR_NUM; i++)
783 for (i = 0; i < RSA_NUM; i++)
785 for (i = 0; i < DSA_NUM; i++)
787 #ifndef OPENSSL_NO_EC
788 for (i = 0; i < EC_NUM; i++)
790 for (i = 0; i < EC_NUM; i++)
794 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
795 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
798 prog = opt_init(argc, argv, speed_options);
799 while ((o = opt_next()) != OPT_EOF) {
804 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
807 opt_help(speed_options);
814 evp_cipher = EVP_get_cipherbyname(opt_arg());
815 if (evp_cipher == NULL)
816 evp_md = EVP_get_digestbyname(opt_arg());
817 if (evp_cipher == NULL && evp_md == NULL) {
819 "%s: %s an unknown cipher or digest\n",
829 (void)setup_engine(opt_arg(), 0);
833 multi = atoi(opt_arg());
837 if (!opt_int(opt_arg(), &misalign))
839 if (misalign > MISALIGN) {
841 "%s: Maximum offset is %d\n", prog, MISALIGN);
844 buf = buf_malloc + misalign;
845 buf2 = buf2_malloc + misalign;
855 argc = opt_num_rest();
858 /* Remaining arguments are algorithms. */
859 for ( ; *argv; argv++) {
860 if (found(*argv, doit_choices, &i)) {
864 #ifndef OPENSSL_NO_DES
865 if (strcmp(*argv, "des") == 0) {
866 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
870 if (strcmp(*argv, "sha") == 0) {
871 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
874 #ifndef OPENSSL_NO_RSA
876 if (strcmp(*argv, "openssl") == 0) {
877 RSA_set_default_method(RSA_PKCS1_SSLeay());
881 if (strcmp(*argv, "rsa") == 0) {
882 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
883 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
884 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
885 rsa_doit[R_RSA_15360] = 1;
888 if (found(*argv, rsa_choices, &i)) {
893 #ifndef OPENSSL_NO_DSA
894 if (strcmp(*argv, "dsa") == 0) {
895 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
896 dsa_doit[R_DSA_2048] = 1;
899 if (found(*argv, dsa_choices, &i)) {
904 #ifndef OPENSSL_NO_AES
905 if (strcmp(*argv, "aes") == 0) {
906 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
907 doit[D_CBC_256_AES] = 1;
911 #ifndef OPENSSL_NO_CAMELLIA
912 if (strcmp(*argv, "camellia") == 0) {
913 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
914 doit[D_CBC_256_CML] = 1;
918 #ifndef OPENSSL_NO_EC
919 if (strcmp(*argv, "ecdsa") == 0) {
920 for (i = 0; i < EC_NUM; i++)
924 if (found(*argv, ecdsa_choices, &i)) {
928 if (strcmp(*argv, "ecdh") == 0) {
929 for (i = 0; i < EC_NUM; i++)
933 if (found(*argv, ecdh_choices, &i)) {
938 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
943 if (multi && do_multi(multi))
947 /* No parameters; turn on everything. */
949 for (i = 0; i < ALGOR_NUM; i++)
952 for (i = 0; i < RSA_NUM; i++)
954 for (i = 0; i < DSA_NUM; i++)
956 #ifndef OPENSSL_NO_EC
957 for (i = 0; i < EC_NUM; i++)
959 for (i = 0; i < EC_NUM; i++)
963 for (i = 0; i < ALGOR_NUM; i++)
967 if (usertime == 0 && !mr)
969 "You have chosen to measure elapsed time "
970 "instead of user CPU time.\n");
972 #ifndef OPENSSL_NO_RSA
973 for (i = 0; i < RSA_NUM; i++) {
974 const unsigned char *p;
977 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
978 if (rsa_key[i] == NULL) {
979 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
986 #ifndef OPENSSL_NO_DSA
987 dsa_key[0] = get_dsa512();
988 dsa_key[1] = get_dsa1024();
989 dsa_key[2] = get_dsa2048();
992 #ifndef OPENSSL_NO_DES
993 DES_set_key_unchecked(&key, &sch);
994 DES_set_key_unchecked(&key2, &sch2);
995 DES_set_key_unchecked(&key3, &sch3);
997 #ifndef OPENSSL_NO_AES
998 AES_set_encrypt_key(key16, 128, &aes_ks1);
999 AES_set_encrypt_key(key24, 192, &aes_ks2);
1000 AES_set_encrypt_key(key32, 256, &aes_ks3);
1002 #ifndef OPENSSL_NO_CAMELLIA
1003 Camellia_set_key(key16, 128, &camellia_ks1);
1004 Camellia_set_key(ckey24, 192, &camellia_ks2);
1005 Camellia_set_key(ckey32, 256, &camellia_ks3);
1007 #ifndef OPENSSL_NO_IDEA
1008 idea_set_encrypt_key(key16, &idea_ks);
1010 #ifndef OPENSSL_NO_SEED
1011 SEED_set_key(key16, &seed_ks);
1013 #ifndef OPENSSL_NO_RC4
1014 RC4_set_key(&rc4_ks, 16, key16);
1016 #ifndef OPENSSL_NO_RC2
1017 RC2_set_key(&rc2_ks, 16, key16, 128);
1019 #ifndef OPENSSL_NO_RC5
1020 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1022 #ifndef OPENSSL_NO_BF
1023 BF_set_key(&bf_ks, 16, key16);
1025 #ifndef OPENSSL_NO_CAST
1026 CAST_set_key(&cast_ks, 16, key16);
1028 #ifndef OPENSSL_NO_RSA
1029 memset(rsa_c, 0, sizeof(rsa_c));
1032 # ifndef OPENSSL_NO_DES
1033 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1039 for (it = count; it; it--)
1040 DES_ecb_encrypt((DES_cblock *)buf,
1041 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1045 c[D_MD2][0] = count / 10;
1046 c[D_MDC2][0] = count / 10;
1047 c[D_MD4][0] = count;
1048 c[D_MD5][0] = count;
1049 c[D_HMAC][0] = count;
1050 c[D_SHA1][0] = count;
1051 c[D_RMD160][0] = count;
1052 c[D_RC4][0] = count * 5;
1053 c[D_CBC_DES][0] = count;
1054 c[D_EDE3_DES][0] = count / 3;
1055 c[D_CBC_IDEA][0] = count;
1056 c[D_CBC_SEED][0] = count;
1057 c[D_CBC_RC2][0] = count;
1058 c[D_CBC_RC5][0] = count;
1059 c[D_CBC_BF][0] = count;
1060 c[D_CBC_CAST][0] = count;
1061 c[D_CBC_128_AES][0] = count;
1062 c[D_CBC_192_AES][0] = count;
1063 c[D_CBC_256_AES][0] = count;
1064 c[D_CBC_128_CML][0] = count;
1065 c[D_CBC_192_CML][0] = count;
1066 c[D_CBC_256_CML][0] = count;
1067 c[D_SHA256][0] = count;
1068 c[D_SHA512][0] = count;
1069 c[D_WHIRLPOOL][0] = count;
1070 c[D_IGE_128_AES][0] = count;
1071 c[D_IGE_192_AES][0] = count;
1072 c[D_IGE_256_AES][0] = count;
1073 c[D_GHASH][0] = count;
1075 for (i = 1; i < SIZE_NUM; i++) {
1078 l0 = (long)lengths[0];
1079 l1 = (long)lengths[i];
1081 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1082 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1083 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1084 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1085 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1086 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1087 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1088 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1089 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1090 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1092 l0 = (long)lengths[i - 1];
1094 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1095 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1096 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1097 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1098 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1099 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1100 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1101 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1102 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1103 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1104 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1105 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1106 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1107 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1108 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1109 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1110 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1111 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1114 # ifndef OPENSSL_NO_RSA
1115 rsa_c[R_RSA_512][0] = count / 2000;
1116 rsa_c[R_RSA_512][1] = count / 400;
1117 for (i = 1; i < RSA_NUM; i++) {
1118 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1119 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1120 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1123 if (rsa_c[i][0] == 0) {
1131 # ifndef OPENSSL_NO_DSA
1132 dsa_c[R_DSA_512][0] = count / 1000;
1133 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1134 for (i = 1; i < DSA_NUM; i++) {
1135 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1136 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1137 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1140 if (dsa_c[i] == 0) {
1148 # ifndef OPENSSL_NO_EC
1149 ecdsa_c[R_EC_P160][0] = count / 1000;
1150 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1151 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1152 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1153 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1154 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1157 if (ecdsa_c[i] == 0) {
1163 ecdsa_c[R_EC_K163][0] = count / 1000;
1164 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1165 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1166 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1167 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1168 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1171 if (ecdsa_c[i] == 0) {
1177 ecdsa_c[R_EC_B163][0] = count / 1000;
1178 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1179 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1180 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1181 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1182 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1185 if (ecdsa_c[i] == 0) {
1192 ecdh_c[R_EC_P160][0] = count / 1000;
1193 ecdh_c[R_EC_P160][1] = count / 1000;
1194 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1195 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1196 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1197 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1200 if (ecdh_c[i] == 0) {
1206 ecdh_c[R_EC_K163][0] = count / 1000;
1207 ecdh_c[R_EC_K163][1] = count / 1000;
1208 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1209 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1210 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1211 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1214 if (ecdh_c[i] == 0) {
1220 ecdh_c[R_EC_B163][0] = count / 1000;
1221 ecdh_c[R_EC_B163][1] = count / 1000;
1222 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1223 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1224 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1225 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1228 if (ecdh_c[i] == 0) {
1236 # define COND(d) (count < (d))
1237 # define COUNT(d) (d)
1239 /* not worth fixing */
1240 # error "You cannot disable DES on systems without SIGALRM."
1241 # endif /* OPENSSL_NO_DES */
1243 # define COND(c) (run && count<0x7fffffff)
1244 # define COUNT(d) (count)
1246 signal(SIGALRM, sig_done);
1248 #endif /* SIGALRM */
1250 #ifndef OPENSSL_NO_MD2
1252 for (j = 0; j < SIZE_NUM; j++) {
1253 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1255 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1256 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1259 print_result(D_MD2, j, count, d);
1263 #ifndef OPENSSL_NO_MDC2
1265 for (j = 0; j < SIZE_NUM; j++) {
1266 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1268 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1269 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1272 print_result(D_MDC2, j, count, d);
1277 #ifndef OPENSSL_NO_MD4
1279 for (j = 0; j < SIZE_NUM; j++) {
1280 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1282 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1283 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1284 NULL, EVP_md4(), NULL);
1286 print_result(D_MD4, j, count, d);
1291 #ifndef OPENSSL_NO_MD5
1293 for (j = 0; j < SIZE_NUM; j++) {
1294 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1296 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1297 MD5(buf, lengths[j], md5);
1299 print_result(D_MD5, j, count, d);
1304 #if !defined(OPENSSL_NO_MD5)
1308 HMAC_CTX_init(&hctx);
1309 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1310 16, EVP_md5(), NULL);
1312 for (j = 0; j < SIZE_NUM; j++) {
1313 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1315 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1316 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1317 HMAC_Update(&hctx, buf, lengths[j]);
1318 HMAC_Final(&hctx, &(hmac[0]), NULL);
1321 print_result(D_HMAC, j, count, d);
1323 HMAC_CTX_cleanup(&hctx);
1327 for (j = 0; j < SIZE_NUM; j++) {
1328 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1330 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1331 SHA1(buf, lengths[j], sha);
1333 print_result(D_SHA1, j, count, d);
1336 if (doit[D_SHA256]) {
1337 for (j = 0; j < SIZE_NUM; j++) {
1338 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1340 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1341 SHA256(buf, lengths[j], sha256);
1343 print_result(D_SHA256, j, count, d);
1346 if (doit[D_SHA512]) {
1347 for (j = 0; j < SIZE_NUM; j++) {
1348 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1350 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1351 SHA512(buf, lengths[j], sha512);
1353 print_result(D_SHA512, j, count, d);
1357 #ifndef OPENSSL_NO_WHIRLPOOL
1358 if (doit[D_WHIRLPOOL]) {
1359 for (j = 0; j < SIZE_NUM; j++) {
1360 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1362 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1363 WHIRLPOOL(buf, lengths[j], whirlpool);
1365 print_result(D_WHIRLPOOL, j, count, d);
1370 #ifndef OPENSSL_NO_RMD160
1371 if (doit[D_RMD160]) {
1372 for (j = 0; j < SIZE_NUM; j++) {
1373 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1375 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1376 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1377 EVP_ripemd160(), NULL);
1379 print_result(D_RMD160, j, count, d);
1383 #ifndef OPENSSL_NO_RC4
1385 for (j = 0; j < SIZE_NUM; j++) {
1386 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1388 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1389 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1391 print_result(D_RC4, j, count, d);
1395 #ifndef OPENSSL_NO_DES
1396 if (doit[D_CBC_DES]) {
1397 for (j = 0; j < SIZE_NUM; j++) {
1398 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1400 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1401 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1402 &DES_iv, DES_ENCRYPT);
1404 print_result(D_CBC_DES, j, count, d);
1408 if (doit[D_EDE3_DES]) {
1409 for (j = 0; j < SIZE_NUM; j++) {
1410 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1412 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1413 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1415 &DES_iv, DES_ENCRYPT);
1417 print_result(D_EDE3_DES, j, count, d);
1421 #ifndef OPENSSL_NO_AES
1422 if (doit[D_CBC_128_AES]) {
1423 for (j = 0; j < SIZE_NUM; j++) {
1424 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1427 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1428 AES_cbc_encrypt(buf, buf,
1429 (unsigned long)lengths[j], &aes_ks1,
1432 print_result(D_CBC_128_AES, j, count, d);
1435 if (doit[D_CBC_192_AES]) {
1436 for (j = 0; j < SIZE_NUM; j++) {
1437 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1440 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1441 AES_cbc_encrypt(buf, buf,
1442 (unsigned long)lengths[j], &aes_ks2,
1445 print_result(D_CBC_192_AES, j, count, d);
1448 if (doit[D_CBC_256_AES]) {
1449 for (j = 0; j < SIZE_NUM; j++) {
1450 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1453 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1454 AES_cbc_encrypt(buf, buf,
1455 (unsigned long)lengths[j], &aes_ks3,
1458 print_result(D_CBC_256_AES, j, count, d);
1462 if (doit[D_IGE_128_AES]) {
1463 for (j = 0; j < SIZE_NUM; j++) {
1464 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1467 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1468 AES_ige_encrypt(buf, buf2,
1469 (unsigned long)lengths[j], &aes_ks1,
1472 print_result(D_IGE_128_AES, j, count, d);
1475 if (doit[D_IGE_192_AES]) {
1476 for (j = 0; j < SIZE_NUM; j++) {
1477 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1480 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1481 AES_ige_encrypt(buf, buf2,
1482 (unsigned long)lengths[j], &aes_ks2,
1485 print_result(D_IGE_192_AES, j, count, d);
1488 if (doit[D_IGE_256_AES]) {
1489 for (j = 0; j < SIZE_NUM; j++) {
1490 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1493 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1494 AES_ige_encrypt(buf, buf2,
1495 (unsigned long)lengths[j], &aes_ks3,
1498 print_result(D_IGE_256_AES, j, count, d);
1501 if (doit[D_GHASH]) {
1502 GCM128_CONTEXT *ctx =
1503 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1504 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1506 for (j = 0; j < SIZE_NUM; j++) {
1507 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1509 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1510 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1512 print_result(D_GHASH, j, count, d);
1514 CRYPTO_gcm128_release(ctx);
1517 #ifndef OPENSSL_NO_CAMELLIA
1518 if (doit[D_CBC_128_CML]) {
1519 for (j = 0; j < SIZE_NUM; j++) {
1520 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1523 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1524 Camellia_cbc_encrypt(buf, buf,
1525 (unsigned long)lengths[j], &camellia_ks1,
1526 iv, CAMELLIA_ENCRYPT);
1528 print_result(D_CBC_128_CML, j, count, d);
1531 if (doit[D_CBC_192_CML]) {
1532 for (j = 0; j < SIZE_NUM; j++) {
1533 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1536 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1537 Camellia_cbc_encrypt(buf, buf,
1538 (unsigned long)lengths[j], &camellia_ks2,
1539 iv, CAMELLIA_ENCRYPT);
1541 print_result(D_CBC_192_CML, j, count, d);
1544 if (doit[D_CBC_256_CML]) {
1545 for (j = 0; j < SIZE_NUM; j++) {
1546 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1549 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1550 Camellia_cbc_encrypt(buf, buf,
1551 (unsigned long)lengths[j], &camellia_ks3,
1552 iv, CAMELLIA_ENCRYPT);
1554 print_result(D_CBC_256_CML, j, count, d);
1558 #ifndef OPENSSL_NO_IDEA
1559 if (doit[D_CBC_IDEA]) {
1560 for (j = 0; j < SIZE_NUM; j++) {
1561 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1563 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1564 idea_cbc_encrypt(buf, buf,
1565 (unsigned long)lengths[j], &idea_ks,
1568 print_result(D_CBC_IDEA, j, count, d);
1572 #ifndef OPENSSL_NO_SEED
1573 if (doit[D_CBC_SEED]) {
1574 for (j = 0; j < SIZE_NUM; j++) {
1575 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1577 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1578 SEED_cbc_encrypt(buf, buf,
1579 (unsigned long)lengths[j], &seed_ks, iv, 1);
1581 print_result(D_CBC_SEED, j, count, d);
1585 #ifndef OPENSSL_NO_RC2
1586 if (doit[D_CBC_RC2]) {
1587 for (j = 0; j < SIZE_NUM; j++) {
1588 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1590 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1591 RC2_cbc_encrypt(buf, buf,
1592 (unsigned long)lengths[j], &rc2_ks,
1595 print_result(D_CBC_RC2, j, count, d);
1599 #ifndef OPENSSL_NO_RC5
1600 if (doit[D_CBC_RC5]) {
1601 for (j = 0; j < SIZE_NUM; j++) {
1602 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1604 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1605 RC5_32_cbc_encrypt(buf, buf,
1606 (unsigned long)lengths[j], &rc5_ks,
1609 print_result(D_CBC_RC5, j, count, d);
1613 #ifndef OPENSSL_NO_BF
1614 if (doit[D_CBC_BF]) {
1615 for (j = 0; j < SIZE_NUM; j++) {
1616 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1618 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1619 BF_cbc_encrypt(buf, buf,
1620 (unsigned long)lengths[j], &bf_ks,
1623 print_result(D_CBC_BF, j, count, d);
1627 #ifndef OPENSSL_NO_CAST
1628 if (doit[D_CBC_CAST]) {
1629 for (j = 0; j < SIZE_NUM; j++) {
1630 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1632 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1633 CAST_cbc_encrypt(buf, buf,
1634 (unsigned long)lengths[j], &cast_ks,
1637 print_result(D_CBC_CAST, j, count, d);
1643 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1644 if (multiblock && evp_cipher) {
1646 (EVP_CIPHER_flags(evp_cipher) &
1647 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1648 fprintf(stderr, "%s is not multi-block capable\n",
1649 OBJ_nid2ln(evp_cipher->nid));
1652 multiblock_speed(evp_cipher);
1657 for (j = 0; j < SIZE_NUM; j++) {
1662 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1664 * -O3 -fschedule-insns messes up an optimization here!
1665 * names[D_EVP] somehow becomes NULL
1667 print_message(names[D_EVP], save_count, lengths[j]);
1669 EVP_CIPHER_CTX_init(&ctx);
1671 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1673 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1674 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1678 for (count = 0, run = 1;
1679 COND(save_count * 4 * lengths[0] / lengths[j]);
1681 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1683 for (count = 0, run = 1;
1684 COND(save_count * 4 * lengths[0] / lengths[j]);
1686 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1688 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1690 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1692 EVP_CIPHER_CTX_cleanup(&ctx);
1695 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1696 print_message(names[D_EVP], save_count, lengths[j]);
1699 for (count = 0, run = 1;
1700 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1701 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1705 print_result(D_EVP, j, count, d);
1709 RAND_bytes(buf, 36);
1710 #ifndef OPENSSL_NO_RSA
1711 for (j = 0; j < RSA_NUM; j++) {
1715 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1718 "RSA sign failure. No RSA sign will be done.\n");
1719 ERR_print_errors(bio_err);
1722 pkey_print_message("private", "rsa",
1723 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1724 /* RSA_blinding_on(rsa_key[j],NULL); */
1726 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1727 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1728 &rsa_num, rsa_key[j]);
1730 BIO_printf(bio_err, "RSA sign failure\n");
1731 ERR_print_errors(bio_err);
1738 mr ? "+R1:%ld:%d:%.2f\n"
1739 : "%ld %d bit private RSA's in %.2fs\n",
1740 count, rsa_bits[j], d);
1741 rsa_results[j][0] = d / (double)count;
1745 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1748 "RSA verify failure. No RSA verify will be done.\n");
1749 ERR_print_errors(bio_err);
1752 pkey_print_message("public", "rsa",
1753 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1755 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1756 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1757 rsa_num, rsa_key[j]);
1759 BIO_printf(bio_err, "RSA verify failure\n");
1760 ERR_print_errors(bio_err);
1767 mr ? "+R2:%ld:%d:%.2f\n"
1768 : "%ld %d bit public RSA's in %.2fs\n",
1769 count, rsa_bits[j], d);
1770 rsa_results[j][1] = d / (double)count;
1773 if (rsa_count <= 1) {
1774 /* if longer than 10s, don't do any more */
1775 for (j++; j < RSA_NUM; j++)
1781 RAND_bytes(buf, 20);
1782 #ifndef OPENSSL_NO_DSA
1783 if (RAND_status() != 1) {
1784 RAND_seed(rnd_seed, sizeof rnd_seed);
1787 for (j = 0; j < DSA_NUM; j++) {
1794 /* DSA_generate_key(dsa_key[j]); */
1795 /* DSA_sign_setup(dsa_key[j],NULL); */
1796 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1799 "DSA sign failure. No DSA sign will be done.\n");
1800 ERR_print_errors(bio_err);
1803 pkey_print_message("sign", "dsa",
1804 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1806 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1807 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1809 BIO_printf(bio_err, "DSA sign failure\n");
1810 ERR_print_errors(bio_err);
1817 mr ? "+R3:%ld:%d:%.2f\n"
1818 : "%ld %d bit DSA signs in %.2fs\n",
1819 count, dsa_bits[j], d);
1820 dsa_results[j][0] = d / (double)count;
1824 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1827 "DSA verify failure. No DSA verify will be done.\n");
1828 ERR_print_errors(bio_err);
1831 pkey_print_message("verify", "dsa",
1832 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1834 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1835 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1837 BIO_printf(bio_err, "DSA verify failure\n");
1838 ERR_print_errors(bio_err);
1845 mr ? "+R4:%ld:%d:%.2f\n"
1846 : "%ld %d bit DSA verify in %.2fs\n",
1847 count, dsa_bits[j], d);
1848 dsa_results[j][1] = d / (double)count;
1851 if (rsa_count <= 1) {
1852 /* if longer than 10s, don't do any more */
1853 for (j++; j < DSA_NUM; j++)
1861 #ifndef OPENSSL_NO_EC
1862 if (RAND_status() != 1) {
1863 RAND_seed(rnd_seed, sizeof rnd_seed);
1866 for (j = 0; j < EC_NUM; j++) {
1870 continue; /* Ignore Curve */
1871 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1872 if (ecdsa[j] == NULL) {
1873 BIO_printf(bio_err, "ECDSA failure.\n");
1874 ERR_print_errors(bio_err);
1877 EC_KEY_precompute_mult(ecdsa[j], NULL);
1878 /* Perform ECDSA signature test */
1879 EC_KEY_generate_key(ecdsa[j]);
1880 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1883 "ECDSA sign failure. No ECDSA sign will be done.\n");
1884 ERR_print_errors(bio_err);
1887 pkey_print_message("sign", "ecdsa",
1889 test_curves_bits[j], ECDSA_SECONDS);
1892 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1893 st = ECDSA_sign(0, buf, 20,
1894 ecdsasig, &ecdsasiglen, ecdsa[j]);
1896 BIO_printf(bio_err, "ECDSA sign failure\n");
1897 ERR_print_errors(bio_err);
1905 mr ? "+R5:%ld:%d:%.2f\n" :
1906 "%ld %d bit ECDSA signs in %.2fs \n",
1907 count, test_curves_bits[j], d);
1908 ecdsa_results[j][0] = d / (double)count;
1912 /* Perform ECDSA verification test */
1913 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1916 "ECDSA verify failure. No ECDSA verify will be done.\n");
1917 ERR_print_errors(bio_err);
1920 pkey_print_message("verify", "ecdsa",
1922 test_curves_bits[j], ECDSA_SECONDS);
1924 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1925 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1928 BIO_printf(bio_err, "ECDSA verify failure\n");
1929 ERR_print_errors(bio_err);
1936 mr ? "+R6:%ld:%d:%.2f\n"
1937 : "%ld %d bit ECDSA verify in %.2fs\n",
1938 count, test_curves_bits[j], d);
1939 ecdsa_results[j][1] = d / (double)count;
1942 if (rsa_count <= 1) {
1943 /* if longer than 10s, don't do any more */
1944 for (j++; j < EC_NUM; j++)
1953 #ifndef OPENSSL_NO_EC
1954 if (RAND_status() != 1) {
1955 RAND_seed(rnd_seed, sizeof rnd_seed);
1958 for (j = 0; j < EC_NUM; j++) {
1961 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1962 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1963 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1964 BIO_printf(bio_err, "ECDH failure.\n");
1965 ERR_print_errors(bio_err);
1968 /* generate two ECDH key pairs */
1969 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1970 !EC_KEY_generate_key(ecdh_b[j])) {
1971 BIO_printf(bio_err, "ECDH key generation failure.\n");
1972 ERR_print_errors(bio_err);
1976 * If field size is not more than 24 octets, then use SHA-1
1977 * hash of result; otherwise, use result (see section 4.8 of
1978 * draft-ietf-tls-ecc-03.txt).
1980 int field_size, outlen;
1981 void *(*kdf) (const void *in, size_t inlen, void *out,
1984 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1985 if (field_size <= 24 * 8) {
1986 outlen = KDF1_SHA1_len;
1989 outlen = (field_size + 7) / 8;
1993 ECDH_compute_key(secret_a, outlen,
1994 EC_KEY_get0_public_key(ecdh_b[j]),
1997 ECDH_compute_key(secret_b, outlen,
1998 EC_KEY_get0_public_key(ecdh_a[j]),
2000 if (secret_size_a != secret_size_b)
2005 for (secret_idx = 0; (secret_idx < secret_size_a)
2006 && (ecdh_checks == 1); secret_idx++) {
2007 if (secret_a[secret_idx] != secret_b[secret_idx])
2011 if (ecdh_checks == 0) {
2012 BIO_printf(bio_err, "ECDH computations don't match.\n");
2013 ERR_print_errors(bio_err);
2017 pkey_print_message("", "ecdh",
2019 test_curves_bits[j], ECDH_SECONDS);
2021 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2022 ECDH_compute_key(secret_a, outlen,
2023 EC_KEY_get0_public_key(ecdh_b[j]),
2028 mr ? "+R7:%ld:%d:%.2f\n" :
2029 "%ld %d-bit ECDH ops in %.2fs\n", count,
2030 test_curves_bits[j], d);
2031 ecdh_results[j][0] = d / (double)count;
2036 if (rsa_count <= 1) {
2037 /* if longer than 10s, don't do any more */
2038 for (j++; j < EC_NUM; j++)
2049 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2050 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2052 printf("%s ", BN_options());
2053 #ifndef OPENSSL_NO_MD2
2054 printf("%s ", MD2_options());
2056 #ifndef OPENSSL_NO_RC4
2057 printf("%s ", RC4_options());
2059 #ifndef OPENSSL_NO_DES
2060 printf("%s ", DES_options());
2062 #ifndef OPENSSL_NO_AES
2063 printf("%s ", AES_options());
2065 #ifndef OPENSSL_NO_IDEA
2066 printf("%s ", idea_options());
2068 #ifndef OPENSSL_NO_BF
2069 printf("%s ", BF_options());
2071 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2079 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2082 for (j = 0; j < SIZE_NUM; j++)
2083 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2087 for (k = 0; k < ALGOR_NUM; k++) {
2091 printf("+F:%d:%s", k, names[k]);
2093 printf("%-13s", names[k]);
2094 for (j = 0; j < SIZE_NUM; j++) {
2095 if (results[k][j] > 10000 && !mr)
2096 printf(" %11.2fk", results[k][j] / 1e3);
2098 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2102 #ifndef OPENSSL_NO_RSA
2104 for (k = 0; k < RSA_NUM; k++) {
2108 printf("%18ssign verify sign/s verify/s\n", " ");
2112 printf("+F2:%u:%u:%f:%f\n",
2113 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2115 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2116 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2117 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2120 #ifndef OPENSSL_NO_DSA
2122 for (k = 0; k < DSA_NUM; k++) {
2126 printf("%18ssign verify sign/s verify/s\n", " ");
2130 printf("+F3:%u:%u:%f:%f\n",
2131 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2133 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2134 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2135 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2138 #ifndef OPENSSL_NO_EC
2140 for (k = 0; k < EC_NUM; k++) {
2144 printf("%30ssign verify sign/s verify/s\n", " ");
2149 printf("+F4:%u:%u:%f:%f\n",
2150 k, test_curves_bits[k],
2151 ecdsa_results[k][0], ecdsa_results[k][1]);
2153 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2154 test_curves_bits[k],
2155 test_curves_names[k],
2156 ecdsa_results[k][0], ecdsa_results[k][1],
2157 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2161 #ifndef OPENSSL_NO_EC
2163 for (k = 0; k < EC_NUM; k++) {
2167 printf("%30sop op/s\n", " ");
2171 printf("+F5:%u:%u:%f:%f\n",
2172 k, test_curves_bits[k],
2173 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2176 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2177 test_curves_bits[k],
2178 test_curves_names[k],
2179 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2186 ERR_print_errors(bio_err);
2187 OPENSSL_free(save_buf);
2188 OPENSSL_free(save_buf2);
2189 #ifndef OPENSSL_NO_RSA
2190 for (i = 0; i < RSA_NUM; i++)
2191 RSA_free(rsa_key[i]);
2193 #ifndef OPENSSL_NO_DSA
2194 for (i = 0; i < DSA_NUM; i++)
2195 DSA_free(dsa_key[i]);
2198 #ifndef OPENSSL_NO_EC
2199 for (i = 0; i < EC_NUM; i++) {
2200 EC_KEY_free(ecdsa[i]);
2201 EC_KEY_free(ecdh_a[i]);
2202 EC_KEY_free(ecdh_b[i]);
2209 static void print_message(const char *s, long num, int length)
2213 mr ? "+DT:%s:%d:%d\n"
2214 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2215 (void)BIO_flush(bio_err);
2219 mr ? "+DN:%s:%ld:%d\n"
2220 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2221 (void)BIO_flush(bio_err);
2225 static void pkey_print_message(const char *str, const char *str2, long num,
2230 mr ? "+DTP:%d:%s:%s:%d\n"
2231 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2232 (void)BIO_flush(bio_err);
2236 mr ? "+DNP:%ld:%d:%s:%s\n"
2237 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2238 (void)BIO_flush(bio_err);
2242 static void print_result(int alg, int run_no, int count, double time_used)
2245 mr ? "+R:%d:%s:%f\n"
2246 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2247 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2251 static char *sstrsep(char **string, const char *delim)
2254 char *token = *string;
2259 memset(isdelim, 0, sizeof isdelim);
2263 isdelim[(unsigned char)(*delim)] = 1;
2267 while (!isdelim[(unsigned char)(**string)]) {
2279 static int do_multi(int multi)
2284 static char sep[] = ":";
2286 fds = malloc(sizeof(*fds) * multi);
2287 for (n = 0; n < multi; ++n) {
2288 if (pipe(fd) == -1) {
2289 fprintf(stderr, "pipe failure\n");
2300 if (dup(fd[1]) == -1) {
2301 fprintf(stderr, "dup failed\n");
2310 printf("Forked child %d\n", n);
2313 /* for now, assume the pipe is long enough to take all the output */
2314 for (n = 0; n < multi; ++n) {
2319 f = fdopen(fds[n], "r");
2320 while (fgets(buf, sizeof buf, f)) {
2321 p = strchr(buf, '\n');
2324 if (buf[0] != '+') {
2325 fprintf(stderr, "Don't understand line '%s' from child %d\n",
2329 printf("Got: %s from %d\n", buf, n);
2330 if (!strncmp(buf, "+F:", 3)) {
2335 alg = atoi(sstrsep(&p, sep));
2337 for (j = 0; j < SIZE_NUM; ++j)
2338 results[alg][j] += atof(sstrsep(&p, sep));
2339 } else if (!strncmp(buf, "+F2:", 4)) {
2344 k = atoi(sstrsep(&p, sep));
2347 d = atof(sstrsep(&p, sep));
2349 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2351 rsa_results[k][0] = d;
2353 d = atof(sstrsep(&p, sep));
2355 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2357 rsa_results[k][1] = d;
2359 # ifndef OPENSSL_NO_DSA
2360 else if (!strncmp(buf, "+F3:", 4)) {
2365 k = atoi(sstrsep(&p, sep));
2368 d = atof(sstrsep(&p, sep));
2370 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2372 dsa_results[k][0] = d;
2374 d = atof(sstrsep(&p, sep));
2376 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2378 dsa_results[k][1] = d;
2381 # ifndef OPENSSL_NO_EC
2382 else if (!strncmp(buf, "+F4:", 4)) {
2387 k = atoi(sstrsep(&p, sep));
2390 d = atof(sstrsep(&p, sep));
2392 ecdsa_results[k][0] =
2393 1 / (1 / ecdsa_results[k][0] + 1 / d);
2395 ecdsa_results[k][0] = d;
2397 d = atof(sstrsep(&p, sep));
2399 ecdsa_results[k][1] =
2400 1 / (1 / ecdsa_results[k][1] + 1 / d);
2402 ecdsa_results[k][1] = d;
2406 # ifndef OPENSSL_NO_EC
2407 else if (!strncmp(buf, "+F5:", 4)) {
2412 k = atoi(sstrsep(&p, sep));
2415 d = atof(sstrsep(&p, sep));
2417 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2419 ecdh_results[k][0] = d;
2424 else if (!strncmp(buf, "+H:", 3)) {
2427 fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n);
2437 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2439 static int mblengths[] =
2440 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2441 int j, count, num = OSSL_NELEM(lengths);
2442 const char *alg_name;
2443 unsigned char *inp, *out, no_key[32], no_iv[16];
2447 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2448 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2449 EVP_CIPHER_CTX_init(&ctx);
2450 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2451 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2453 alg_name = OBJ_nid2ln(evp_cipher->nid);
2455 for (j = 0; j < num; j++) {
2456 print_message(alg_name, 0, mblengths[j]);
2458 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2459 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2460 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2461 size_t len = mblengths[j];
2464 memset(aad, 0, 8); /* avoid uninitialized values */
2465 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2466 aad[9] = 3; /* version */
2468 aad[11] = 0; /* length */
2470 mb_param.out = NULL;
2473 mb_param.interleave = 8;
2475 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2476 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2477 sizeof(mb_param), &mb_param);
2483 EVP_CIPHER_CTX_ctrl(&ctx,
2484 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2485 sizeof(mb_param), &mb_param);
2489 RAND_bytes(out, 16);
2493 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2494 EVP_CTRL_AEAD_TLS1_AAD,
2495 EVP_AEAD_TLS1_AAD_LEN, aad);
2496 EVP_Cipher(&ctx, out, inp, len + pad);
2500 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2501 : "%d %s's in %.2fs\n", count, "evp", d);
2502 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2506 fprintf(stdout, "+H");
2507 for (j = 0; j < num; j++)
2508 fprintf(stdout, ":%d", mblengths[j]);
2509 fprintf(stdout, "\n");
2510 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2511 for (j = 0; j < num; j++)
2512 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2513 fprintf(stdout, "\n");
2516 "The 'numbers' are in 1000s of bytes per second processed.\n");
2517 fprintf(stdout, "type ");
2518 for (j = 0; j < num; j++)
2519 fprintf(stdout, "%7d bytes", mblengths[j]);
2520 fprintf(stdout, "\n");
2521 fprintf(stdout, "%-24s", alg_name);
2523 for (j = 0; j < num; j++) {
2524 if (results[D_EVP][j] > 10000)
2525 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2527 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2529 fprintf(stdout, "\n");