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++)
795 (unsigned char *)OPENSSL_malloc((int)BUFSIZE + misalign)) == NULL) {
796 BIO_printf(bio_err, "out of memory\n");
800 (unsigned char *)OPENSSL_malloc((int)BUFSIZE + misalign)) == NULL) {
801 BIO_printf(bio_err, "out of memory\n");
808 prog = opt_init(argc, argv, speed_options);
809 while ((o = opt_next()) != OPT_EOF) {
814 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
817 opt_help(speed_options);
824 evp_cipher = EVP_get_cipherbyname(opt_arg());
825 if (evp_cipher == NULL)
826 evp_md = EVP_get_digestbyname(opt_arg());
827 if (evp_cipher == NULL && evp_md == NULL) {
829 "%s: %s an unknown cipher or digest\n",
838 #ifndef OPENSSL_NO_ENGINE
840 setup_engine(opt_arg(), 0);
845 multi = atoi(opt_arg());
849 if (!opt_int(opt_arg(), &misalign))
851 if (misalign > MISALIGN) {
853 "%s: Maximum offset is %d\n", prog, MISALIGN);
856 buf = buf_malloc + misalign;
857 buf2 = buf2_malloc + misalign;
867 argc = opt_num_rest();
870 /* Remaining arguments are algorithms. */
871 for ( ; *argv; argv++) {
872 if (found(*argv, doit_choices, &i)) {
876 #ifndef OPENSSL_NO_DES
877 if (strcmp(*argv, "des") == 0) {
878 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
882 if (strcmp(*argv, "sha") == 0) {
883 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
886 #ifndef OPENSSL_NO_RSA
888 if (strcmp(*argv, "openssl") == 0) {
889 RSA_set_default_method(RSA_PKCS1_SSLeay());
893 if (strcmp(*argv, "rsa") == 0) {
894 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
895 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
896 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
897 rsa_doit[R_RSA_15360] = 1;
900 if (found(*argv, rsa_choices, &i)) {
905 #ifndef OPENSSL_NO_DSA
906 if (strcmp(*argv, "dsa") == 0) {
907 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
908 dsa_doit[R_DSA_2048] = 1;
911 if (found(*argv, dsa_choices, &i)) {
916 #ifndef OPENSSL_NO_AES
917 if (strcmp(*argv, "aes") == 0) {
918 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
919 doit[D_CBC_256_AES] = 1;
923 #ifndef OPENSSL_NO_CAMELLIA
924 if (strcmp(*argv, "camellia") == 0) {
925 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
926 doit[D_CBC_256_CML] = 1;
930 #ifndef OPENSSL_NO_EC
931 if (strcmp(*argv, "ecdsa") == 0) {
932 for (i = 0; i < EC_NUM; i++)
936 if (found(*argv, ecdsa_choices, &i)) {
940 if (strcmp(*argv, "ecdh") == 0) {
941 for (i = 0; i < EC_NUM; i++)
945 if (found(*argv, ecdh_choices, &i)) {
950 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
955 if (multi && do_multi(multi))
959 /* No parameters; turn on everything. */
961 for (i = 0; i < ALGOR_NUM; i++)
964 for (i = 0; i < RSA_NUM; i++)
966 for (i = 0; i < DSA_NUM; i++)
968 #ifndef OPENSSL_NO_EC
969 for (i = 0; i < EC_NUM; i++)
971 for (i = 0; i < EC_NUM; i++)
975 for (i = 0; i < ALGOR_NUM; i++)
979 if (usertime == 0 && !mr)
981 "You have chosen to measure elapsed time "
982 "instead of user CPU time.\n");
984 #ifndef OPENSSL_NO_RSA
985 for (i = 0; i < RSA_NUM; i++) {
986 const unsigned char *p;
989 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
990 if (rsa_key[i] == NULL) {
991 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
998 #ifndef OPENSSL_NO_DSA
999 dsa_key[0] = get_dsa512();
1000 dsa_key[1] = get_dsa1024();
1001 dsa_key[2] = get_dsa2048();
1004 #ifndef OPENSSL_NO_DES
1005 DES_set_key_unchecked(&key, &sch);
1006 DES_set_key_unchecked(&key2, &sch2);
1007 DES_set_key_unchecked(&key3, &sch3);
1009 #ifndef OPENSSL_NO_AES
1010 AES_set_encrypt_key(key16, 128, &aes_ks1);
1011 AES_set_encrypt_key(key24, 192, &aes_ks2);
1012 AES_set_encrypt_key(key32, 256, &aes_ks3);
1014 #ifndef OPENSSL_NO_CAMELLIA
1015 Camellia_set_key(key16, 128, &camellia_ks1);
1016 Camellia_set_key(ckey24, 192, &camellia_ks2);
1017 Camellia_set_key(ckey32, 256, &camellia_ks3);
1019 #ifndef OPENSSL_NO_IDEA
1020 idea_set_encrypt_key(key16, &idea_ks);
1022 #ifndef OPENSSL_NO_SEED
1023 SEED_set_key(key16, &seed_ks);
1025 #ifndef OPENSSL_NO_RC4
1026 RC4_set_key(&rc4_ks, 16, key16);
1028 #ifndef OPENSSL_NO_RC2
1029 RC2_set_key(&rc2_ks, 16, key16, 128);
1031 #ifndef OPENSSL_NO_RC5
1032 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1034 #ifndef OPENSSL_NO_BF
1035 BF_set_key(&bf_ks, 16, key16);
1037 #ifndef OPENSSL_NO_CAST
1038 CAST_set_key(&cast_ks, 16, key16);
1040 #ifndef OPENSSL_NO_RSA
1041 memset(rsa_c, 0, sizeof(rsa_c));
1044 # ifndef OPENSSL_NO_DES
1045 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1051 for (it = count; it; it--)
1052 DES_ecb_encrypt((DES_cblock *)buf,
1053 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1057 c[D_MD2][0] = count / 10;
1058 c[D_MDC2][0] = count / 10;
1059 c[D_MD4][0] = count;
1060 c[D_MD5][0] = count;
1061 c[D_HMAC][0] = count;
1062 c[D_SHA1][0] = count;
1063 c[D_RMD160][0] = count;
1064 c[D_RC4][0] = count * 5;
1065 c[D_CBC_DES][0] = count;
1066 c[D_EDE3_DES][0] = count / 3;
1067 c[D_CBC_IDEA][0] = count;
1068 c[D_CBC_SEED][0] = count;
1069 c[D_CBC_RC2][0] = count;
1070 c[D_CBC_RC5][0] = count;
1071 c[D_CBC_BF][0] = count;
1072 c[D_CBC_CAST][0] = count;
1073 c[D_CBC_128_AES][0] = count;
1074 c[D_CBC_192_AES][0] = count;
1075 c[D_CBC_256_AES][0] = count;
1076 c[D_CBC_128_CML][0] = count;
1077 c[D_CBC_192_CML][0] = count;
1078 c[D_CBC_256_CML][0] = count;
1079 c[D_SHA256][0] = count;
1080 c[D_SHA512][0] = count;
1081 c[D_WHIRLPOOL][0] = count;
1082 c[D_IGE_128_AES][0] = count;
1083 c[D_IGE_192_AES][0] = count;
1084 c[D_IGE_256_AES][0] = count;
1085 c[D_GHASH][0] = count;
1087 for (i = 1; i < SIZE_NUM; i++) {
1090 l0 = (long)lengths[0];
1091 l1 = (long)lengths[i];
1093 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1094 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1095 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1096 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1097 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1098 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1099 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1100 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1101 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1102 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1104 l0 = (long)lengths[i - 1];
1106 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1107 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1108 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1109 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1110 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1111 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1112 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1113 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1114 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1115 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1116 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1117 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1118 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1119 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1120 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1121 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1122 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1123 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1126 # ifndef OPENSSL_NO_RSA
1127 rsa_c[R_RSA_512][0] = count / 2000;
1128 rsa_c[R_RSA_512][1] = count / 400;
1129 for (i = 1; i < RSA_NUM; i++) {
1130 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1131 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1132 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1135 if (rsa_c[i][0] == 0) {
1143 # ifndef OPENSSL_NO_DSA
1144 dsa_c[R_DSA_512][0] = count / 1000;
1145 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1146 for (i = 1; i < DSA_NUM; i++) {
1147 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1148 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1149 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1152 if (dsa_c[i] == 0) {
1160 # ifndef OPENSSL_NO_EC
1161 ecdsa_c[R_EC_P160][0] = count / 1000;
1162 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1163 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1164 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1165 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1166 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1169 if (ecdsa_c[i] == 0) {
1175 ecdsa_c[R_EC_K163][0] = count / 1000;
1176 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1177 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1178 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1179 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1180 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1183 if (ecdsa_c[i] == 0) {
1189 ecdsa_c[R_EC_B163][0] = count / 1000;
1190 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1191 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1192 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1193 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1194 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1197 if (ecdsa_c[i] == 0) {
1204 ecdh_c[R_EC_P160][0] = count / 1000;
1205 ecdh_c[R_EC_P160][1] = count / 1000;
1206 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1207 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1208 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1209 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1212 if (ecdh_c[i] == 0) {
1218 ecdh_c[R_EC_K163][0] = count / 1000;
1219 ecdh_c[R_EC_K163][1] = count / 1000;
1220 for (i = R_EC_K233; i <= R_EC_K571; i++) {
1221 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1222 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1223 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1226 if (ecdh_c[i] == 0) {
1232 ecdh_c[R_EC_B163][0] = count / 1000;
1233 ecdh_c[R_EC_B163][1] = count / 1000;
1234 for (i = R_EC_B233; i <= R_EC_B571; i++) {
1235 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1236 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1237 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1240 if (ecdh_c[i] == 0) {
1248 # define COND(d) (count < (d))
1249 # define COUNT(d) (d)
1251 /* not worth fixing */
1252 # error "You cannot disable DES on systems without SIGALRM."
1253 # endif /* OPENSSL_NO_DES */
1255 # define COND(c) (run && count<0x7fffffff)
1256 # define COUNT(d) (count)
1258 signal(SIGALRM, sig_done);
1260 #endif /* SIGALRM */
1262 #ifndef OPENSSL_NO_MD2
1264 for (j = 0; j < SIZE_NUM; j++) {
1265 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1267 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1268 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1271 print_result(D_MD2, j, count, d);
1275 #ifndef OPENSSL_NO_MDC2
1277 for (j = 0; j < SIZE_NUM; j++) {
1278 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1280 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1281 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1284 print_result(D_MDC2, j, count, d);
1289 #ifndef OPENSSL_NO_MD4
1291 for (j = 0; j < SIZE_NUM; j++) {
1292 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1294 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1295 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1296 NULL, EVP_md4(), NULL);
1298 print_result(D_MD4, j, count, d);
1303 #ifndef OPENSSL_NO_MD5
1305 for (j = 0; j < SIZE_NUM; j++) {
1306 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1308 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1309 MD5(buf, lengths[j], md5);
1311 print_result(D_MD5, j, count, d);
1316 #if !defined(OPENSSL_NO_MD5)
1320 HMAC_CTX_init(&hctx);
1321 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1322 16, EVP_md5(), NULL);
1324 for (j = 0; j < SIZE_NUM; j++) {
1325 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1327 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1328 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1329 HMAC_Update(&hctx, buf, lengths[j]);
1330 HMAC_Final(&hctx, &(hmac[0]), NULL);
1333 print_result(D_HMAC, j, count, d);
1335 HMAC_CTX_cleanup(&hctx);
1339 for (j = 0; j < SIZE_NUM; j++) {
1340 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1342 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1343 SHA1(buf, lengths[j], sha);
1345 print_result(D_SHA1, j, count, d);
1348 if (doit[D_SHA256]) {
1349 for (j = 0; j < SIZE_NUM; j++) {
1350 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1352 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1353 SHA256(buf, lengths[j], sha256);
1355 print_result(D_SHA256, j, count, d);
1358 if (doit[D_SHA512]) {
1359 for (j = 0; j < SIZE_NUM; j++) {
1360 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1362 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1363 SHA512(buf, lengths[j], sha512);
1365 print_result(D_SHA512, j, count, d);
1369 #ifndef OPENSSL_NO_WHIRLPOOL
1370 if (doit[D_WHIRLPOOL]) {
1371 for (j = 0; j < SIZE_NUM; j++) {
1372 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1374 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1375 WHIRLPOOL(buf, lengths[j], whirlpool);
1377 print_result(D_WHIRLPOOL, j, count, d);
1382 #ifndef OPENSSL_NO_RMD160
1383 if (doit[D_RMD160]) {
1384 for (j = 0; j < SIZE_NUM; j++) {
1385 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1387 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1388 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1389 EVP_ripemd160(), NULL);
1391 print_result(D_RMD160, j, count, d);
1395 #ifndef OPENSSL_NO_RC4
1397 for (j = 0; j < SIZE_NUM; j++) {
1398 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1400 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1401 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1403 print_result(D_RC4, j, count, d);
1407 #ifndef OPENSSL_NO_DES
1408 if (doit[D_CBC_DES]) {
1409 for (j = 0; j < SIZE_NUM; j++) {
1410 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1412 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1413 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1414 &DES_iv, DES_ENCRYPT);
1416 print_result(D_CBC_DES, j, count, d);
1420 if (doit[D_EDE3_DES]) {
1421 for (j = 0; j < SIZE_NUM; j++) {
1422 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1424 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1425 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1427 &DES_iv, DES_ENCRYPT);
1429 print_result(D_EDE3_DES, j, count, d);
1433 #ifndef OPENSSL_NO_AES
1434 if (doit[D_CBC_128_AES]) {
1435 for (j = 0; j < SIZE_NUM; j++) {
1436 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1439 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1440 AES_cbc_encrypt(buf, buf,
1441 (unsigned long)lengths[j], &aes_ks1,
1444 print_result(D_CBC_128_AES, j, count, d);
1447 if (doit[D_CBC_192_AES]) {
1448 for (j = 0; j < SIZE_NUM; j++) {
1449 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1452 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1453 AES_cbc_encrypt(buf, buf,
1454 (unsigned long)lengths[j], &aes_ks2,
1457 print_result(D_CBC_192_AES, j, count, d);
1460 if (doit[D_CBC_256_AES]) {
1461 for (j = 0; j < SIZE_NUM; j++) {
1462 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1465 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1466 AES_cbc_encrypt(buf, buf,
1467 (unsigned long)lengths[j], &aes_ks3,
1470 print_result(D_CBC_256_AES, j, count, d);
1474 if (doit[D_IGE_128_AES]) {
1475 for (j = 0; j < SIZE_NUM; j++) {
1476 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1479 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1480 AES_ige_encrypt(buf, buf2,
1481 (unsigned long)lengths[j], &aes_ks1,
1484 print_result(D_IGE_128_AES, j, count, d);
1487 if (doit[D_IGE_192_AES]) {
1488 for (j = 0; j < SIZE_NUM; j++) {
1489 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1492 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1493 AES_ige_encrypt(buf, buf2,
1494 (unsigned long)lengths[j], &aes_ks2,
1497 print_result(D_IGE_192_AES, j, count, d);
1500 if (doit[D_IGE_256_AES]) {
1501 for (j = 0; j < SIZE_NUM; j++) {
1502 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1505 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1506 AES_ige_encrypt(buf, buf2,
1507 (unsigned long)lengths[j], &aes_ks3,
1510 print_result(D_IGE_256_AES, j, count, d);
1513 if (doit[D_GHASH]) {
1514 GCM128_CONTEXT *ctx =
1515 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1516 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1518 for (j = 0; j < SIZE_NUM; j++) {
1519 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1521 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1522 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1524 print_result(D_GHASH, j, count, d);
1526 CRYPTO_gcm128_release(ctx);
1529 #ifndef OPENSSL_NO_CAMELLIA
1530 if (doit[D_CBC_128_CML]) {
1531 for (j = 0; j < SIZE_NUM; j++) {
1532 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1535 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1536 Camellia_cbc_encrypt(buf, buf,
1537 (unsigned long)lengths[j], &camellia_ks1,
1538 iv, CAMELLIA_ENCRYPT);
1540 print_result(D_CBC_128_CML, j, count, d);
1543 if (doit[D_CBC_192_CML]) {
1544 for (j = 0; j < SIZE_NUM; j++) {
1545 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1548 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1549 Camellia_cbc_encrypt(buf, buf,
1550 (unsigned long)lengths[j], &camellia_ks2,
1551 iv, CAMELLIA_ENCRYPT);
1553 print_result(D_CBC_192_CML, j, count, d);
1556 if (doit[D_CBC_256_CML]) {
1557 for (j = 0; j < SIZE_NUM; j++) {
1558 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1561 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1562 Camellia_cbc_encrypt(buf, buf,
1563 (unsigned long)lengths[j], &camellia_ks3,
1564 iv, CAMELLIA_ENCRYPT);
1566 print_result(D_CBC_256_CML, j, count, d);
1570 #ifndef OPENSSL_NO_IDEA
1571 if (doit[D_CBC_IDEA]) {
1572 for (j = 0; j < SIZE_NUM; j++) {
1573 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1575 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1576 idea_cbc_encrypt(buf, buf,
1577 (unsigned long)lengths[j], &idea_ks,
1580 print_result(D_CBC_IDEA, j, count, d);
1584 #ifndef OPENSSL_NO_SEED
1585 if (doit[D_CBC_SEED]) {
1586 for (j = 0; j < SIZE_NUM; j++) {
1587 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1589 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1590 SEED_cbc_encrypt(buf, buf,
1591 (unsigned long)lengths[j], &seed_ks, iv, 1);
1593 print_result(D_CBC_SEED, j, count, d);
1597 #ifndef OPENSSL_NO_RC2
1598 if (doit[D_CBC_RC2]) {
1599 for (j = 0; j < SIZE_NUM; j++) {
1600 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1602 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1603 RC2_cbc_encrypt(buf, buf,
1604 (unsigned long)lengths[j], &rc2_ks,
1607 print_result(D_CBC_RC2, j, count, d);
1611 #ifndef OPENSSL_NO_RC5
1612 if (doit[D_CBC_RC5]) {
1613 for (j = 0; j < SIZE_NUM; j++) {
1614 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1616 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1617 RC5_32_cbc_encrypt(buf, buf,
1618 (unsigned long)lengths[j], &rc5_ks,
1621 print_result(D_CBC_RC5, j, count, d);
1625 #ifndef OPENSSL_NO_BF
1626 if (doit[D_CBC_BF]) {
1627 for (j = 0; j < SIZE_NUM; j++) {
1628 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1630 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1631 BF_cbc_encrypt(buf, buf,
1632 (unsigned long)lengths[j], &bf_ks,
1635 print_result(D_CBC_BF, j, count, d);
1639 #ifndef OPENSSL_NO_CAST
1640 if (doit[D_CBC_CAST]) {
1641 for (j = 0; j < SIZE_NUM; j++) {
1642 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1644 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1645 CAST_cbc_encrypt(buf, buf,
1646 (unsigned long)lengths[j], &cast_ks,
1649 print_result(D_CBC_CAST, j, count, d);
1655 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1656 if (multiblock && evp_cipher) {
1658 (EVP_CIPHER_flags(evp_cipher) &
1659 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1660 fprintf(stderr, "%s is not multi-block capable\n",
1661 OBJ_nid2ln(evp_cipher->nid));
1664 multiblock_speed(evp_cipher);
1669 for (j = 0; j < SIZE_NUM; j++) {
1674 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1676 * -O3 -fschedule-insns messes up an optimization here!
1677 * names[D_EVP] somehow becomes NULL
1679 print_message(names[D_EVP], save_count, lengths[j]);
1681 EVP_CIPHER_CTX_init(&ctx);
1683 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1685 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1686 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1690 for (count = 0, run = 1;
1691 COND(save_count * 4 * lengths[0] / lengths[j]);
1693 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1695 for (count = 0, run = 1;
1696 COND(save_count * 4 * lengths[0] / lengths[j]);
1698 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1700 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1702 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1704 EVP_CIPHER_CTX_cleanup(&ctx);
1707 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1708 print_message(names[D_EVP], save_count, lengths[j]);
1711 for (count = 0, run = 1;
1712 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1713 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1717 print_result(D_EVP, j, count, d);
1721 RAND_bytes(buf, 36);
1722 #ifndef OPENSSL_NO_RSA
1723 for (j = 0; j < RSA_NUM; j++) {
1727 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1730 "RSA sign failure. No RSA sign will be done.\n");
1731 ERR_print_errors(bio_err);
1734 pkey_print_message("private", "rsa",
1735 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1736 /* RSA_blinding_on(rsa_key[j],NULL); */
1738 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1739 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1740 &rsa_num, rsa_key[j]);
1742 BIO_printf(bio_err, "RSA sign failure\n");
1743 ERR_print_errors(bio_err);
1750 mr ? "+R1:%ld:%d:%.2f\n"
1751 : "%ld %d bit private RSA's in %.2fs\n",
1752 count, rsa_bits[j], d);
1753 rsa_results[j][0] = d / (double)count;
1757 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1760 "RSA verify failure. No RSA verify will be done.\n");
1761 ERR_print_errors(bio_err);
1764 pkey_print_message("public", "rsa",
1765 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1767 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1768 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1769 rsa_num, rsa_key[j]);
1771 BIO_printf(bio_err, "RSA verify failure\n");
1772 ERR_print_errors(bio_err);
1779 mr ? "+R2:%ld:%d:%.2f\n"
1780 : "%ld %d bit public RSA's in %.2fs\n",
1781 count, rsa_bits[j], d);
1782 rsa_results[j][1] = d / (double)count;
1785 if (rsa_count <= 1) {
1786 /* if longer than 10s, don't do any more */
1787 for (j++; j < RSA_NUM; j++)
1793 RAND_bytes(buf, 20);
1794 #ifndef OPENSSL_NO_DSA
1795 if (RAND_status() != 1) {
1796 RAND_seed(rnd_seed, sizeof rnd_seed);
1799 for (j = 0; j < DSA_NUM; j++) {
1806 /* DSA_generate_key(dsa_key[j]); */
1807 /* DSA_sign_setup(dsa_key[j],NULL); */
1808 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1811 "DSA sign failure. No DSA sign will be done.\n");
1812 ERR_print_errors(bio_err);
1815 pkey_print_message("sign", "dsa",
1816 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1818 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1819 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1821 BIO_printf(bio_err, "DSA sign failure\n");
1822 ERR_print_errors(bio_err);
1829 mr ? "+R3:%ld:%d:%.2f\n"
1830 : "%ld %d bit DSA signs in %.2fs\n",
1831 count, dsa_bits[j], d);
1832 dsa_results[j][0] = d / (double)count;
1836 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1839 "DSA verify failure. No DSA verify will be done.\n");
1840 ERR_print_errors(bio_err);
1843 pkey_print_message("verify", "dsa",
1844 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1846 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1847 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1849 BIO_printf(bio_err, "DSA verify failure\n");
1850 ERR_print_errors(bio_err);
1857 mr ? "+R4:%ld:%d:%.2f\n"
1858 : "%ld %d bit DSA verify in %.2fs\n",
1859 count, dsa_bits[j], d);
1860 dsa_results[j][1] = d / (double)count;
1863 if (rsa_count <= 1) {
1864 /* if longer than 10s, don't do any more */
1865 for (j++; j < DSA_NUM; j++)
1873 #ifndef OPENSSL_NO_EC
1874 if (RAND_status() != 1) {
1875 RAND_seed(rnd_seed, sizeof rnd_seed);
1878 for (j = 0; j < EC_NUM; j++) {
1882 continue; /* Ignore Curve */
1883 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1884 if (ecdsa[j] == NULL) {
1885 BIO_printf(bio_err, "ECDSA failure.\n");
1886 ERR_print_errors(bio_err);
1889 EC_KEY_precompute_mult(ecdsa[j], NULL);
1890 /* Perform ECDSA signature test */
1891 EC_KEY_generate_key(ecdsa[j]);
1892 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1895 "ECDSA sign failure. No ECDSA sign will be done.\n");
1896 ERR_print_errors(bio_err);
1899 pkey_print_message("sign", "ecdsa",
1901 test_curves_bits[j], ECDSA_SECONDS);
1904 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1905 st = ECDSA_sign(0, buf, 20,
1906 ecdsasig, &ecdsasiglen, ecdsa[j]);
1908 BIO_printf(bio_err, "ECDSA sign failure\n");
1909 ERR_print_errors(bio_err);
1917 mr ? "+R5:%ld:%d:%.2f\n" :
1918 "%ld %d bit ECDSA signs in %.2fs \n",
1919 count, test_curves_bits[j], d);
1920 ecdsa_results[j][0] = d / (double)count;
1924 /* Perform ECDSA verification test */
1925 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1928 "ECDSA verify failure. No ECDSA verify will be done.\n");
1929 ERR_print_errors(bio_err);
1932 pkey_print_message("verify", "ecdsa",
1934 test_curves_bits[j], ECDSA_SECONDS);
1936 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1937 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1940 BIO_printf(bio_err, "ECDSA verify failure\n");
1941 ERR_print_errors(bio_err);
1948 mr ? "+R6:%ld:%d:%.2f\n"
1949 : "%ld %d bit ECDSA verify in %.2fs\n",
1950 count, test_curves_bits[j], d);
1951 ecdsa_results[j][1] = d / (double)count;
1954 if (rsa_count <= 1) {
1955 /* if longer than 10s, don't do any more */
1956 for (j++; j < EC_NUM; j++)
1965 #ifndef OPENSSL_NO_EC
1966 if (RAND_status() != 1) {
1967 RAND_seed(rnd_seed, sizeof rnd_seed);
1970 for (j = 0; j < EC_NUM; j++) {
1973 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1974 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1975 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1976 BIO_printf(bio_err, "ECDH failure.\n");
1977 ERR_print_errors(bio_err);
1980 /* generate two ECDH key pairs */
1981 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1982 !EC_KEY_generate_key(ecdh_b[j])) {
1983 BIO_printf(bio_err, "ECDH key generation failure.\n");
1984 ERR_print_errors(bio_err);
1988 * If field size is not more than 24 octets, then use SHA-1
1989 * hash of result; otherwise, use result (see section 4.8 of
1990 * draft-ietf-tls-ecc-03.txt).
1992 int field_size, outlen;
1993 void *(*kdf) (const void *in, size_t inlen, void *out,
1996 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1997 if (field_size <= 24 * 8) {
1998 outlen = KDF1_SHA1_len;
2001 outlen = (field_size + 7) / 8;
2005 ECDH_compute_key(secret_a, outlen,
2006 EC_KEY_get0_public_key(ecdh_b[j]),
2009 ECDH_compute_key(secret_b, outlen,
2010 EC_KEY_get0_public_key(ecdh_a[j]),
2012 if (secret_size_a != secret_size_b)
2017 for (secret_idx = 0; (secret_idx < secret_size_a)
2018 && (ecdh_checks == 1); secret_idx++) {
2019 if (secret_a[secret_idx] != secret_b[secret_idx])
2023 if (ecdh_checks == 0) {
2024 BIO_printf(bio_err, "ECDH computations don't match.\n");
2025 ERR_print_errors(bio_err);
2029 pkey_print_message("", "ecdh",
2031 test_curves_bits[j], ECDH_SECONDS);
2033 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2034 ECDH_compute_key(secret_a, outlen,
2035 EC_KEY_get0_public_key(ecdh_b[j]),
2040 mr ? "+R7:%ld:%d:%.2f\n" :
2041 "%ld %d-bit ECDH ops in %.2fs\n", count,
2042 test_curves_bits[j], d);
2043 ecdh_results[j][0] = d / (double)count;
2048 if (rsa_count <= 1) {
2049 /* if longer than 10s, don't do any more */
2050 for (j++; j < EC_NUM; j++)
2061 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2062 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2064 printf("%s ", BN_options());
2065 #ifndef OPENSSL_NO_MD2
2066 printf("%s ", MD2_options());
2068 #ifndef OPENSSL_NO_RC4
2069 printf("%s ", RC4_options());
2071 #ifndef OPENSSL_NO_DES
2072 printf("%s ", DES_options());
2074 #ifndef OPENSSL_NO_AES
2075 printf("%s ", AES_options());
2077 #ifndef OPENSSL_NO_IDEA
2078 printf("%s ", idea_options());
2080 #ifndef OPENSSL_NO_BF
2081 printf("%s ", BF_options());
2083 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2091 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2094 for (j = 0; j < SIZE_NUM; j++)
2095 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2099 for (k = 0; k < ALGOR_NUM; k++) {
2103 printf("+F:%d:%s", k, names[k]);
2105 printf("%-13s", names[k]);
2106 for (j = 0; j < SIZE_NUM; j++) {
2107 if (results[k][j] > 10000 && !mr)
2108 printf(" %11.2fk", results[k][j] / 1e3);
2110 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2114 #ifndef OPENSSL_NO_RSA
2116 for (k = 0; k < RSA_NUM; k++) {
2120 printf("%18ssign verify sign/s verify/s\n", " ");
2124 printf("+F2:%u:%u:%f:%f\n",
2125 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2127 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2128 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2129 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2132 #ifndef OPENSSL_NO_DSA
2134 for (k = 0; k < DSA_NUM; k++) {
2138 printf("%18ssign verify sign/s verify/s\n", " ");
2142 printf("+F3:%u:%u:%f:%f\n",
2143 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2145 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2146 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2147 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2150 #ifndef OPENSSL_NO_EC
2152 for (k = 0; k < EC_NUM; k++) {
2156 printf("%30ssign verify sign/s verify/s\n", " ");
2161 printf("+F4:%u:%u:%f:%f\n",
2162 k, test_curves_bits[k],
2163 ecdsa_results[k][0], ecdsa_results[k][1]);
2165 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2166 test_curves_bits[k],
2167 test_curves_names[k],
2168 ecdsa_results[k][0], ecdsa_results[k][1],
2169 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2173 #ifndef OPENSSL_NO_EC
2175 for (k = 0; k < EC_NUM; k++) {
2179 printf("%30sop op/s\n", " ");
2183 printf("+F5:%u:%u:%f:%f\n",
2184 k, test_curves_bits[k],
2185 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2188 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2189 test_curves_bits[k],
2190 test_curves_names[k],
2191 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2198 ERR_print_errors(bio_err);
2199 OPENSSL_free(save_buf);
2200 OPENSSL_free(save_buf2);
2201 #ifndef OPENSSL_NO_RSA
2202 for (i = 0; i < RSA_NUM; i++)
2203 RSA_free(rsa_key[i]);
2205 #ifndef OPENSSL_NO_DSA
2206 for (i = 0; i < DSA_NUM; i++)
2207 DSA_free(dsa_key[i]);
2210 #ifndef OPENSSL_NO_EC
2211 for (i = 0; i < EC_NUM; i++) {
2212 EC_KEY_free(ecdsa[i]);
2213 EC_KEY_free(ecdh_a[i]);
2214 EC_KEY_free(ecdh_b[i]);
2221 static void print_message(const char *s, long num, int length)
2225 mr ? "+DT:%s:%d:%d\n"
2226 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2227 (void)BIO_flush(bio_err);
2231 mr ? "+DN:%s:%ld:%d\n"
2232 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2233 (void)BIO_flush(bio_err);
2237 static void pkey_print_message(const char *str, const char *str2, long num,
2242 mr ? "+DTP:%d:%s:%s:%d\n"
2243 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2244 (void)BIO_flush(bio_err);
2248 mr ? "+DNP:%ld:%d:%s:%s\n"
2249 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2250 (void)BIO_flush(bio_err);
2254 static void print_result(int alg, int run_no, int count, double time_used)
2257 mr ? "+R:%d:%s:%f\n"
2258 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2259 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2263 static char *sstrsep(char **string, const char *delim)
2266 char *token = *string;
2271 memset(isdelim, 0, sizeof isdelim);
2275 isdelim[(unsigned char)(*delim)] = 1;
2279 while (!isdelim[(unsigned char)(**string)]) {
2291 static int do_multi(int multi)
2296 static char sep[] = ":";
2298 fds = malloc(multi * sizeof *fds);
2299 for (n = 0; n < multi; ++n) {
2300 if (pipe(fd) == -1) {
2301 fprintf(stderr, "pipe failure\n");
2312 if (dup(fd[1]) == -1) {
2313 fprintf(stderr, "dup failed\n");
2322 printf("Forked child %d\n", n);
2325 /* for now, assume the pipe is long enough to take all the output */
2326 for (n = 0; n < multi; ++n) {
2331 f = fdopen(fds[n], "r");
2332 while (fgets(buf, sizeof buf, f)) {
2333 p = strchr(buf, '\n');
2336 if (buf[0] != '+') {
2337 fprintf(stderr, "Don't understand line '%s' from child %d\n",
2341 printf("Got: %s from %d\n", buf, n);
2342 if (!strncmp(buf, "+F:", 3)) {
2347 alg = atoi(sstrsep(&p, sep));
2349 for (j = 0; j < SIZE_NUM; ++j)
2350 results[alg][j] += atof(sstrsep(&p, sep));
2351 } else if (!strncmp(buf, "+F2:", 4)) {
2356 k = atoi(sstrsep(&p, sep));
2359 d = atof(sstrsep(&p, sep));
2361 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2363 rsa_results[k][0] = d;
2365 d = atof(sstrsep(&p, sep));
2367 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2369 rsa_results[k][1] = d;
2371 # ifndef OPENSSL_NO_DSA
2372 else if (!strncmp(buf, "+F3:", 4)) {
2377 k = atoi(sstrsep(&p, sep));
2380 d = atof(sstrsep(&p, sep));
2382 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2384 dsa_results[k][0] = d;
2386 d = atof(sstrsep(&p, sep));
2388 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2390 dsa_results[k][1] = d;
2393 # ifndef OPENSSL_NO_EC
2394 else if (!strncmp(buf, "+F4:", 4)) {
2399 k = atoi(sstrsep(&p, sep));
2402 d = atof(sstrsep(&p, sep));
2404 ecdsa_results[k][0] =
2405 1 / (1 / ecdsa_results[k][0] + 1 / d);
2407 ecdsa_results[k][0] = d;
2409 d = atof(sstrsep(&p, sep));
2411 ecdsa_results[k][1] =
2412 1 / (1 / ecdsa_results[k][1] + 1 / d);
2414 ecdsa_results[k][1] = d;
2418 # ifndef OPENSSL_NO_EC
2419 else if (!strncmp(buf, "+F5:", 4)) {
2424 k = atoi(sstrsep(&p, sep));
2427 d = atof(sstrsep(&p, sep));
2429 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2431 ecdh_results[k][0] = d;
2436 else if (!strncmp(buf, "+H:", 3)) {
2439 fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n);
2449 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2451 static int mblengths[] =
2452 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2453 int j, count, num = sizeof(lengths) / sizeof(lengths[0]);
2454 const char *alg_name;
2455 unsigned char *inp, *out, no_key[32], no_iv[16];
2459 inp = OPENSSL_malloc(mblengths[num - 1]);
2460 out = OPENSSL_malloc(mblengths[num - 1] + 1024);
2462 BIO_printf(bio_err, "Out of memory\n");
2466 EVP_CIPHER_CTX_init(&ctx);
2467 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2468 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2470 alg_name = OBJ_nid2ln(evp_cipher->nid);
2472 for (j = 0; j < num; j++) {
2473 print_message(alg_name, 0, mblengths[j]);
2475 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2476 unsigned char aad[13];
2477 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2478 size_t len = mblengths[j];
2481 memset(aad, 0, 8); /* avoid uninitialized values */
2482 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2483 aad[9] = 3; /* version */
2485 aad[11] = 0; /* length */
2487 mb_param.out = NULL;
2490 mb_param.interleave = 8;
2492 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2493 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2494 sizeof(mb_param), &mb_param);
2500 EVP_CIPHER_CTX_ctrl(&ctx,
2501 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2502 sizeof(mb_param), &mb_param);
2506 RAND_bytes(out, 16);
2510 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2511 EVP_CTRL_AEAD_TLS1_AAD, 13, aad);
2512 EVP_Cipher(&ctx, out, inp, len + pad);
2516 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2517 : "%d %s's in %.2fs\n", count, "evp", d);
2518 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2522 fprintf(stdout, "+H");
2523 for (j = 0; j < num; j++)
2524 fprintf(stdout, ":%d", mblengths[j]);
2525 fprintf(stdout, "\n");
2526 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2527 for (j = 0; j < num; j++)
2528 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2529 fprintf(stdout, "\n");
2532 "The 'numbers' are in 1000s of bytes per second processed.\n");
2533 fprintf(stdout, "type ");
2534 for (j = 0; j < num; j++)
2535 fprintf(stdout, "%7d bytes", mblengths[j]);
2536 fprintf(stdout, "\n");
2537 fprintf(stdout, "%-24s", alg_name);
2539 for (j = 0; j < num; j++) {
2540 if (results[D_EVP][j] > 10000)
2541 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2543 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2545 fprintf(stdout, "\n");