1 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
4 * This package is an SSL implementation written
5 * by Eric Young (eay@cryptsoft.com).
6 * The implementation was written so as to conform with Netscapes SSL.
8 * This library is free for commercial and non-commercial use as long as
9 * the following conditions are aheared to. The following conditions
10 * apply to all code found in this distribution, be it the RC4, RSA,
11 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
12 * included with this distribution is covered by the same copyright terms
13 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15 * Copyright remains Eric Young's, and as such any Copyright notices in
16 * the code are not to be removed.
17 * If this package is used in a product, Eric Young should be given attribution
18 * as the author of the parts of the library used.
19 * This can be in the form of a textual message at program startup or
20 * in documentation (online or textual) provided with the package.
22 * Redistribution and use in source and binary forms, with or without
23 * modification, are permitted provided that the following conditions
25 * 1. Redistributions of source code must retain the copyright
26 * notice, this list of conditions and the following disclaimer.
27 * 2. Redistributions in binary form must reproduce the above copyright
28 * notice, this list of conditions and the following disclaimer in the
29 * documentation and/or other materials provided with the distribution.
30 * 3. All advertising materials mentioning features or use of this software
31 * must display the following acknowledgement:
32 * "This product includes cryptographic software written by
33 * Eric Young (eay@cryptsoft.com)"
34 * The word 'cryptographic' can be left out if the rouines from the library
35 * being used are not cryptographic related :-).
36 * 4. If you include any Windows specific code (or a derivative thereof) from
37 * the apps directory (application code) you must include an acknowledgement:
38 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
41 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
43 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
44 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
45 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
46 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
47 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52 * The licence and distribution terms for any publically available version or
53 * derivative of this code cannot be changed. i.e. this code cannot simply be
54 * copied and put under another distribution licence
55 * [including the GNU Public Licence.]
57 /* ====================================================================
58 * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60 * Portions of the attached software ("Contribution") are developed by
61 * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
63 * The Contribution is licensed pursuant to the OpenSSL open source
64 * license provided above.
66 * The ECDH and ECDSA speed test software is originally written by
67 * Sumit Gupta of Sun Microsystems Laboratories.
73 #define PRIME_SECONDS 10
74 #define RSA_SECONDS 10
75 #define DSA_SECONDS 10
76 #define ECDSA_SECONDS 10
77 #define ECDH_SECONDS 10
84 #include <openssl/crypto.h>
85 #include <openssl/rand.h>
86 #include <openssl/err.h>
87 #include <openssl/evp.h>
88 #include <openssl/objects.h>
89 #if !defined(OPENSSL_SYS_MSDOS)
90 # include OPENSSL_UNISTD
93 #ifndef OPENSSL_SYS_NETWARE
97 #if defined(_WIN32) || defined(__CYGWIN__)
99 # if defined(__CYGWIN__) && !defined(_WIN32)
101 * <windows.h> should define _WIN32, which normally is mutually exclusive
102 * with __CYGWIN__, but if it didn't...
105 /* this is done because Cygwin alarm() fails sometimes. */
109 #include <openssl/bn.h>
110 #ifndef OPENSSL_NO_DES
111 # include <openssl/des.h>
113 #ifndef OPENSSL_NO_AES
114 # include <openssl/aes.h>
116 #ifndef OPENSSL_NO_CAMELLIA
117 # include <openssl/camellia.h>
119 #ifndef OPENSSL_NO_MD2
120 # include <openssl/md2.h>
122 #ifndef OPENSSL_NO_MDC2
123 # include <openssl/mdc2.h>
125 #ifndef OPENSSL_NO_MD4
126 # include <openssl/md4.h>
128 #ifndef OPENSSL_NO_MD5
129 # include <openssl/md5.h>
131 #include <openssl/hmac.h>
132 #include <openssl/evp.h>
133 #include <openssl/sha.h>
134 #ifndef OPENSSL_NO_RMD160
135 # include <openssl/ripemd.h>
137 #ifndef OPENSSL_NO_WHIRLPOOL
138 # include <openssl/whrlpool.h>
140 #ifndef OPENSSL_NO_RC4
141 # include <openssl/rc4.h>
143 #ifndef OPENSSL_NO_RC5
144 # include <openssl/rc5.h>
146 #ifndef OPENSSL_NO_RC2
147 # include <openssl/rc2.h>
149 #ifndef OPENSSL_NO_IDEA
150 # include <openssl/idea.h>
152 #ifndef OPENSSL_NO_SEED
153 # include <openssl/seed.h>
155 #ifndef OPENSSL_NO_BF
156 # include <openssl/blowfish.h>
158 #ifndef OPENSSL_NO_CAST
159 # include <openssl/cast.h>
161 #ifndef OPENSSL_NO_RSA
162 # include <openssl/rsa.h>
163 # include "./testrsa.h"
165 #include <openssl/x509.h>
166 #ifndef OPENSSL_NO_DSA
167 # include <openssl/dsa.h>
168 # include "./testdsa.h"
170 #ifndef OPENSSL_NO_EC
171 # include <openssl/ecdsa.h>
172 # include <openssl/ecdh.h>
174 #include <openssl/modes.h>
176 #include <openssl/bn.h>
179 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
193 #define BUFSIZE (1024*8+1)
194 #define MAX_MISALIGNMENT 63
196 static volatile int run = 0;
199 static int usertime = 1;
201 static double Time_F(int s);
202 static void print_message(const char *s, long num, int length);
203 static void pkey_print_message(const char *str, const char *str2,
204 long num, int bits, int sec);
205 static void print_result(int alg, int run_no, int count, double time_used);
207 static int do_multi(int multi);
217 #define MAX_ECDH_SIZE 256
220 static const char *names[ALGOR_NUM] = {
221 "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
222 "des cbc", "des ede3", "idea cbc", "seed cbc",
223 "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
224 "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
225 "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
226 "evp", "sha256", "sha512", "whirlpool",
227 "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
230 static double results[ALGOR_NUM][SIZE_NUM];
231 static int lengths[SIZE_NUM] = {
232 16, 64, 256, 1024, 8 * 1024
235 #ifndef OPENSSL_NO_RSA
236 static double rsa_results[RSA_NUM][2];
238 #ifndef OPENSSL_NO_DSA
239 static double dsa_results[DSA_NUM][2];
241 #ifndef OPENSSL_NO_EC
242 static double ecdsa_results[EC_NUM][2];
243 static double ecdh_results[EC_NUM][1];
246 #if defined(OPENSSL_NO_DSA) && !defined(OPENSSL_NO_EC)
247 static const char rnd_seed[] =
248 "string to make the random number generator think it has entropy";
249 static int rnd_fake = 0;
253 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
254 # define SIGRETTYPE void
256 # define SIGRETTYPE int
259 static SIGRETTYPE sig_done(int sig);
260 static SIGRETTYPE sig_done(int sig)
262 signal(SIGALRM, sig_done);
272 # if !defined(SIGALRM)
275 static unsigned int lapse, schlock;
276 static void alarm_win32(unsigned int secs)
281 # define alarm alarm_win32
283 static DWORD WINAPI sleepy(VOID * arg)
291 static double Time_F(int s)
298 thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
300 DWORD ret = GetLastError();
301 BIO_printf(bio_err, "unable to CreateThread (%d)", ret);
305 Sleep(0); /* scheduler spinlock */
306 ret = app_tminterval(s, usertime);
308 ret = app_tminterval(s, usertime);
310 TerminateThread(thr, 0);
318 static double Time_F(int s)
320 double ret = app_tminterval(s, usertime);
327 #ifndef OPENSSL_NO_EC
328 static const int KDF1_SHA1_len = 20;
329 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
332 if (*outlen < SHA_DIGEST_LENGTH)
334 *outlen = SHA_DIGEST_LENGTH;
335 return SHA1(in, inlen, out);
337 #endif /* OPENSSL_NO_EC */
339 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
341 static int found(const char *name, const OPT_PAIR * pairs, int *result)
343 for (; pairs->name; pairs++)
344 if (strcmp(name, pairs->name) == 0) {
345 *result = pairs->retval;
351 typedef enum OPTION_choice {
352 OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,
353 OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,
354 OPT_MR, OPT_MB, OPT_MISALIGN
357 OPTIONS speed_options[] = {
358 {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},
359 {OPT_HELP_STR, 1, '-', "Valid options are:\n"},
360 {"help", OPT_HELP, '-', "Display this summary"},
361 {"evp", OPT_EVP, 's', "Use specified EVP cipher"},
362 {"decrypt", OPT_DECRYPT, '-',
363 "Time decryption instead of encryption (only EVP)"},
364 {"mr", OPT_MR, '-', "Produce machine readable output"},
366 {"misalign", OPT_MISALIGN, 'n', "Amount to mis-align buffers"},
367 {"elapsed", OPT_ELAPSED, '-',
368 "Measure time in real time instead of CPU user time"},
370 {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},
372 #ifndef OPENSSL_NO_ENGINE
373 {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},
388 #define D_CBC_IDEA 10
389 #define D_CBC_SEED 11
393 #define D_CBC_CAST 15
394 #define D_CBC_128_AES 16
395 #define D_CBC_192_AES 17
396 #define D_CBC_256_AES 18
397 #define D_CBC_128_CML 19
398 #define D_CBC_192_CML 20
399 #define D_CBC_256_CML 21
403 #define D_WHIRLPOOL 25
404 #define D_IGE_128_AES 26
405 #define D_IGE_192_AES 27
406 #define D_IGE_256_AES 28
408 static OPT_PAIR doit_choices[] = {
409 #ifndef OPENSSL_NO_MD2
412 #ifndef OPENSSL_NO_MDC2
415 #ifndef OPENSSL_NO_MD4
418 #ifndef OPENSSL_NO_MD5
421 #ifndef OPENSSL_NO_MD5
425 {"sha256", D_SHA256},
426 {"sha512", D_SHA512},
427 #ifndef OPENSSL_NO_WHIRLPOOL
428 {"whirlpool", D_WHIRLPOOL},
430 #ifndef OPENSSL_NO_RMD160
431 {"ripemd", D_RMD160},
432 {"rmd160", D_RMD160},
433 {"ripemd160", D_RMD160},
435 #ifndef OPENSSL_NO_RC4
438 #ifndef OPENSSL_NO_DES
439 {"des-cbc", D_CBC_DES},
440 {"des-ede3", D_EDE3_DES},
442 #ifndef OPENSSL_NO_AES
443 {"aes-128-cbc", D_CBC_128_AES},
444 {"aes-192-cbc", D_CBC_192_AES},
445 {"aes-256-cbc", D_CBC_256_AES},
446 {"aes-128-ige", D_IGE_128_AES},
447 {"aes-192-ige", D_IGE_192_AES},
448 {"aes-256-ige", D_IGE_256_AES},
450 #ifndef OPENSSL_NO_RC2
451 {"rc2-cbc", D_CBC_RC2},
454 #ifndef OPENSSL_NO_RC5
455 {"rc5-cbc", D_CBC_RC5},
458 #ifndef OPENSSL_NO_IDEA
459 {"idea-cbc", D_CBC_IDEA},
460 {"idea", D_CBC_IDEA},
462 #ifndef OPENSSL_NO_SEED
463 {"seed-cbc", D_CBC_SEED},
464 {"seed", D_CBC_SEED},
466 #ifndef OPENSSL_NO_BF
467 {"bf-cbc", D_CBC_BF},
468 {"blowfish", D_CBC_BF},
471 #ifndef OPENSSL_NO_CAST
472 {"cast-cbc", D_CBC_CAST},
473 {"cast", D_CBC_CAST},
474 {"cast5", D_CBC_CAST},
483 static OPT_PAIR dsa_choices[] = {
484 {"dsa512", R_DSA_512},
485 {"dsa1024", R_DSA_1024},
486 {"dsa2048", R_DSA_2048},
496 #define R_RSA_15360 6
497 static OPT_PAIR rsa_choices[] = {
498 {"rsa512", R_RSA_512},
499 {"rsa1024", R_RSA_1024},
500 {"rsa2048", R_RSA_2048},
501 {"rsa3072", R_RSA_3072},
502 {"rsa4096", R_RSA_4096},
503 {"rsa7680", R_RSA_7680},
504 {"rsa15360", R_RSA_15360},
524 #ifndef OPENSSL_NO_EC
525 static OPT_PAIR ecdsa_choices[] = {
526 {"ecdsap160", R_EC_P160},
527 {"ecdsap192", R_EC_P192},
528 {"ecdsap224", R_EC_P224},
529 {"ecdsap256", R_EC_P256},
530 {"ecdsap384", R_EC_P384},
531 {"ecdsap521", R_EC_P521},
532 {"ecdsak163", R_EC_K163},
533 {"ecdsak233", R_EC_K233},
534 {"ecdsak283", R_EC_K283},
535 {"ecdsak409", R_EC_K409},
536 {"ecdsak571", R_EC_K571},
537 {"ecdsab163", R_EC_B163},
538 {"ecdsab233", R_EC_B233},
539 {"ecdsab283", R_EC_B283},
540 {"ecdsab409", R_EC_B409},
541 {"ecdsab571", R_EC_B571},
544 static OPT_PAIR ecdh_choices[] = {
545 {"ecdhp160", R_EC_P160},
546 {"ecdhp192", R_EC_P192},
547 {"ecdhp224", R_EC_P224},
548 {"ecdhp256", R_EC_P256},
549 {"ecdhp384", R_EC_P384},
550 {"ecdhp521", R_EC_P521},
551 {"ecdhk163", R_EC_K163},
552 {"ecdhk233", R_EC_K233},
553 {"ecdhk283", R_EC_K283},
554 {"ecdhk409", R_EC_K409},
555 {"ecdhk571", R_EC_K571},
556 {"ecdhb163", R_EC_B163},
557 {"ecdhb233", R_EC_B233},
558 {"ecdhb283", R_EC_B283},
559 {"ecdhb409", R_EC_B409},
560 {"ecdhb571", R_EC_B571},
565 int speed_main(int argc, char **argv)
568 const EVP_CIPHER *evp_cipher = NULL;
569 const EVP_MD *evp_md = NULL;
572 int decrypt = 0, multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
573 int dsa_doit[DSA_NUM], rsa_doit[RSA_NUM];
574 int ret = 1, i, j, k, misalign = MAX_MISALIGNMENT + 1;
575 long c[ALGOR_NUM][SIZE_NUM], count = 0, save_count = 0;
576 unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
577 unsigned char *buf = NULL, *buf2 = NULL;
578 unsigned char md[EVP_MAX_MD_SIZE];
582 /* What follows are the buffers and key material. */
583 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
586 #ifndef OPENSSL_NO_MD2
587 unsigned char md2[MD2_DIGEST_LENGTH];
589 #ifndef OPENSSL_NO_MDC2
590 unsigned char mdc2[MDC2_DIGEST_LENGTH];
592 #ifndef OPENSSL_NO_MD4
593 unsigned char md4[MD4_DIGEST_LENGTH];
595 #ifndef OPENSSL_NO_MD5
596 unsigned char md5[MD5_DIGEST_LENGTH];
597 unsigned char hmac[MD5_DIGEST_LENGTH];
599 unsigned char sha[SHA_DIGEST_LENGTH];
600 unsigned char sha256[SHA256_DIGEST_LENGTH];
601 unsigned char sha512[SHA512_DIGEST_LENGTH];
602 #ifndef OPENSSL_NO_WHIRLPOOL
603 unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
605 #ifndef OPENSSL_NO_RMD160
606 unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
608 #ifndef OPENSSL_NO_RC4
611 #ifndef OPENSSL_NO_RC5
614 #ifndef OPENSSL_NO_RC2
617 #ifndef OPENSSL_NO_IDEA
618 IDEA_KEY_SCHEDULE idea_ks;
620 #ifndef OPENSSL_NO_SEED
621 SEED_KEY_SCHEDULE seed_ks;
623 #ifndef OPENSSL_NO_BF
626 #ifndef OPENSSL_NO_CAST
629 static const unsigned char key16[16] = {
630 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
631 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
633 #ifndef OPENSSL_NO_AES
634 static const unsigned char key24[24] = {
635 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
636 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
637 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
639 static const unsigned char key32[32] = {
640 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
641 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
642 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
643 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
646 #ifndef OPENSSL_NO_CAMELLIA
647 static const unsigned char ckey24[24] = {
648 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
649 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
650 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
652 static const unsigned char ckey32[32] = {
653 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
654 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
655 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
656 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
658 CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
660 #ifndef OPENSSL_NO_AES
661 # define MAX_BLOCK_SIZE 128
663 # define MAX_BLOCK_SIZE 64
665 unsigned char DES_iv[8];
666 unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
667 #ifndef OPENSSL_NO_DES
668 static DES_cblock key = {
669 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0
671 static DES_cblock key2 = {
672 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
674 static DES_cblock key3 = {
675 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
677 DES_key_schedule sch;
678 DES_key_schedule sch2;
679 DES_key_schedule sch3;
681 #ifndef OPENSSL_NO_AES
682 AES_KEY aes_ks1, aes_ks2, aes_ks3;
684 #ifndef OPENSSL_NO_RSA
686 RSA *rsa_key[RSA_NUM];
687 long rsa_c[RSA_NUM][2];
688 static unsigned int rsa_bits[RSA_NUM] = {
689 512, 1024, 2048, 3072, 4096, 7680, 15360
691 static unsigned char *rsa_data[RSA_NUM] = {
692 test512, test1024, test2048, test3072, test4096, test7680, test15360
694 static int rsa_data_length[RSA_NUM] = {
695 sizeof(test512), sizeof(test1024),
696 sizeof(test2048), sizeof(test3072),
697 sizeof(test4096), sizeof(test7680),
701 #ifndef OPENSSL_NO_DSA
702 DSA *dsa_key[DSA_NUM];
703 long dsa_c[DSA_NUM][2];
704 static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
706 #ifndef OPENSSL_NO_EC
708 * We only test over the following curves as they are representative, To
709 * add tests over more curves, simply add the curve NID and curve name to
710 * the following arrays and increase the EC_NUM value accordingly.
712 static unsigned int test_curves[EC_NUM] = {
714 NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
715 NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
717 NID_sect163k1, NID_sect233k1, NID_sect283k1,
718 NID_sect409k1, NID_sect571k1, NID_sect163r2,
719 NID_sect233r1, NID_sect283r1, NID_sect409r1,
722 static const char *test_curves_names[EC_NUM] = {
724 "secp160r1", "nistp192", "nistp224",
725 "nistp256", "nistp384", "nistp521",
727 "nistk163", "nistk233", "nistk283",
728 "nistk409", "nistk571", "nistb163",
729 "nistb233", "nistb283", "nistb409",
732 static int test_curves_bits[EC_NUM] = {
741 #ifndef OPENSSL_NO_EC
742 unsigned char ecdsasig[256];
743 unsigned int ecdsasiglen;
744 EC_KEY *ecdsa[EC_NUM];
745 long ecdsa_c[EC_NUM][2];
746 int ecdsa_doit[EC_NUM];
747 EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
748 unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
749 int secret_size_a, secret_size_b;
752 long ecdh_c[EC_NUM][2];
753 int ecdh_doit[EC_NUM];
756 memset(results, 0, sizeof(results));
757 #ifndef OPENSSL_NO_DSA
758 memset(dsa_key, 0, sizeof(dsa_key));
760 #ifndef OPENSSL_NO_EC
761 for (i = 0; i < EC_NUM; i++)
763 for (i = 0; i < EC_NUM; i++)
764 ecdh_a[i] = ecdh_b[i] = NULL;
766 #ifndef OPENSSL_NO_RSA
767 memset(rsa_key, 0, sizeof(rsa_key));
768 for (i = 0; i < RSA_NUM; i++)
772 memset(c, 0, sizeof(c));
773 memset(DES_iv, 0, sizeof(DES_iv));
774 memset(iv, 0, sizeof(iv));
776 for (i = 0; i < ALGOR_NUM; i++)
778 for (i = 0; i < RSA_NUM; i++)
780 for (i = 0; i < DSA_NUM; i++)
782 #ifndef OPENSSL_NO_EC
783 for (i = 0; i < EC_NUM; i++)
785 for (i = 0; i < EC_NUM; i++)
789 buf = buf_malloc = app_malloc((int)BUFSIZE + misalign, "input buffer");
790 buf2 = buf2_malloc = app_malloc((int)BUFSIZE + misalign, "output buffer");
793 prog = opt_init(argc, argv, speed_options);
794 while ((o = opt_next()) != OPT_EOF) {
799 BIO_printf(bio_err, "%s: Use -help for summary.\n", prog);
802 opt_help(speed_options);
809 evp_cipher = EVP_get_cipherbyname(opt_arg());
810 if (evp_cipher == NULL)
811 evp_md = EVP_get_digestbyname(opt_arg());
812 if (evp_cipher == NULL && evp_md == NULL) {
814 "%s: %s an unknown cipher or digest\n",
824 (void)setup_engine(opt_arg(), 0);
828 multi = atoi(opt_arg());
832 if (!opt_int(opt_arg(), &misalign))
834 if (misalign > MISALIGN) {
836 "%s: Maximum offset is %d\n", prog, MISALIGN);
839 buf = buf_malloc + misalign;
840 buf2 = buf2_malloc + misalign;
850 argc = opt_num_rest();
853 if (!app_load_modules(NULL))
856 /* Remaining arguments are algorithms. */
857 for ( ; *argv; argv++) {
858 if (found(*argv, doit_choices, &i)) {
862 #ifndef OPENSSL_NO_DES
863 if (strcmp(*argv, "des") == 0) {
864 doit[D_CBC_DES] = doit[D_EDE3_DES] = 1;
868 if (strcmp(*argv, "sha") == 0) {
869 doit[D_SHA1] = doit[D_SHA256] = doit[D_SHA512] = 1;
872 #ifndef OPENSSL_NO_RSA
874 if (strcmp(*argv, "openssl") == 0) {
875 RSA_set_default_method(RSA_PKCS1_SSLeay());
879 if (strcmp(*argv, "rsa") == 0) {
880 rsa_doit[R_RSA_512] = rsa_doit[R_RSA_1024] =
881 rsa_doit[R_RSA_2048] = rsa_doit[R_RSA_3072] =
882 rsa_doit[R_RSA_4096] = rsa_doit[R_RSA_7680] =
883 rsa_doit[R_RSA_15360] = 1;
886 if (found(*argv, rsa_choices, &i)) {
891 #ifndef OPENSSL_NO_DSA
892 if (strcmp(*argv, "dsa") == 0) {
893 dsa_doit[R_DSA_512] = dsa_doit[R_DSA_1024] =
894 dsa_doit[R_DSA_2048] = 1;
897 if (found(*argv, dsa_choices, &i)) {
902 #ifndef OPENSSL_NO_AES
903 if (strcmp(*argv, "aes") == 0) {
904 doit[D_CBC_128_AES] = doit[D_CBC_192_AES] =
905 doit[D_CBC_256_AES] = 1;
909 #ifndef OPENSSL_NO_CAMELLIA
910 if (strcmp(*argv, "camellia") == 0) {
911 doit[D_CBC_128_CML] = doit[D_CBC_192_CML] =
912 doit[D_CBC_256_CML] = 1;
916 #ifndef OPENSSL_NO_EC
917 if (strcmp(*argv, "ecdsa") == 0) {
918 for (i = 0; i < EC_NUM; i++)
922 if (found(*argv, ecdsa_choices, &i)) {
926 if (strcmp(*argv, "ecdh") == 0) {
927 for (i = 0; i < EC_NUM; i++)
931 if (found(*argv, ecdh_choices, &i)) {
936 BIO_printf(bio_err, "%s: Unknown algorithm %s\n", prog, *argv);
941 if (multi && do_multi(multi))
945 /* No parameters; turn on everything. */
946 if ((argc == 0) && !doit[D_EVP]) {
947 for (i = 0; i < ALGOR_NUM; i++)
950 for (i = 0; i < RSA_NUM; i++)
952 for (i = 0; i < DSA_NUM; i++)
954 #ifndef OPENSSL_NO_EC
955 for (i = 0; i < EC_NUM; i++)
957 for (i = 0; i < EC_NUM; i++)
961 for (i = 0; i < ALGOR_NUM; i++)
965 if (usertime == 0 && !mr)
967 "You have chosen to measure elapsed time "
968 "instead of user CPU time.\n");
970 #ifndef OPENSSL_NO_RSA
971 for (i = 0; i < RSA_NUM; i++) {
972 const unsigned char *p;
975 rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
976 if (rsa_key[i] == NULL) {
977 BIO_printf(bio_err, "internal error loading RSA key number %d\n",
984 #ifndef OPENSSL_NO_DSA
985 dsa_key[0] = get_dsa512();
986 dsa_key[1] = get_dsa1024();
987 dsa_key[2] = get_dsa2048();
990 #ifndef OPENSSL_NO_DES
991 DES_set_key_unchecked(&key, &sch);
992 DES_set_key_unchecked(&key2, &sch2);
993 DES_set_key_unchecked(&key3, &sch3);
995 #ifndef OPENSSL_NO_AES
996 AES_set_encrypt_key(key16, 128, &aes_ks1);
997 AES_set_encrypt_key(key24, 192, &aes_ks2);
998 AES_set_encrypt_key(key32, 256, &aes_ks3);
1000 #ifndef OPENSSL_NO_CAMELLIA
1001 Camellia_set_key(key16, 128, &camellia_ks1);
1002 Camellia_set_key(ckey24, 192, &camellia_ks2);
1003 Camellia_set_key(ckey32, 256, &camellia_ks3);
1005 #ifndef OPENSSL_NO_IDEA
1006 idea_set_encrypt_key(key16, &idea_ks);
1008 #ifndef OPENSSL_NO_SEED
1009 SEED_set_key(key16, &seed_ks);
1011 #ifndef OPENSSL_NO_RC4
1012 RC4_set_key(&rc4_ks, 16, key16);
1014 #ifndef OPENSSL_NO_RC2
1015 RC2_set_key(&rc2_ks, 16, key16, 128);
1017 #ifndef OPENSSL_NO_RC5
1018 RC5_32_set_key(&rc5_ks, 16, key16, 12);
1020 #ifndef OPENSSL_NO_BF
1021 BF_set_key(&bf_ks, 16, key16);
1023 #ifndef OPENSSL_NO_CAST
1024 CAST_set_key(&cast_ks, 16, key16);
1026 #ifndef OPENSSL_NO_RSA
1027 memset(rsa_c, 0, sizeof(rsa_c));
1030 # ifndef OPENSSL_NO_DES
1031 BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1037 for (it = count; it; it--)
1038 DES_ecb_encrypt((DES_cblock *)buf,
1039 (DES_cblock *)buf, &sch, DES_ENCRYPT);
1043 c[D_MD2][0] = count / 10;
1044 c[D_MDC2][0] = count / 10;
1045 c[D_MD4][0] = count;
1046 c[D_MD5][0] = count;
1047 c[D_HMAC][0] = count;
1048 c[D_SHA1][0] = count;
1049 c[D_RMD160][0] = count;
1050 c[D_RC4][0] = count * 5;
1051 c[D_CBC_DES][0] = count;
1052 c[D_EDE3_DES][0] = count / 3;
1053 c[D_CBC_IDEA][0] = count;
1054 c[D_CBC_SEED][0] = count;
1055 c[D_CBC_RC2][0] = count;
1056 c[D_CBC_RC5][0] = count;
1057 c[D_CBC_BF][0] = count;
1058 c[D_CBC_CAST][0] = count;
1059 c[D_CBC_128_AES][0] = count;
1060 c[D_CBC_192_AES][0] = count;
1061 c[D_CBC_256_AES][0] = count;
1062 c[D_CBC_128_CML][0] = count;
1063 c[D_CBC_192_CML][0] = count;
1064 c[D_CBC_256_CML][0] = count;
1065 c[D_SHA256][0] = count;
1066 c[D_SHA512][0] = count;
1067 c[D_WHIRLPOOL][0] = count;
1068 c[D_IGE_128_AES][0] = count;
1069 c[D_IGE_192_AES][0] = count;
1070 c[D_IGE_256_AES][0] = count;
1071 c[D_GHASH][0] = count;
1073 for (i = 1; i < SIZE_NUM; i++) {
1076 l0 = (long)lengths[0];
1077 l1 = (long)lengths[i];
1079 c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1080 c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1081 c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1082 c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1083 c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1084 c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1085 c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1086 c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1087 c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1088 c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1090 l0 = (long)lengths[i - 1];
1092 c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1093 c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1094 c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1095 c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1096 c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1097 c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1098 c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1099 c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1100 c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1101 c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1102 c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1103 c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1104 c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1105 c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1106 c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1107 c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1108 c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1109 c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1112 # ifndef OPENSSL_NO_RSA
1113 rsa_c[R_RSA_512][0] = count / 2000;
1114 rsa_c[R_RSA_512][1] = count / 400;
1115 for (i = 1; i < RSA_NUM; i++) {
1116 rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1117 rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1118 if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1121 if (rsa_c[i][0] == 0) {
1129 # ifndef OPENSSL_NO_DSA
1130 dsa_c[R_DSA_512][0] = count / 1000;
1131 dsa_c[R_DSA_512][1] = count / 1000 / 2;
1132 for (i = 1; i < DSA_NUM; i++) {
1133 dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1134 dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1135 if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1138 if (dsa_c[i] == 0) {
1146 # ifndef OPENSSL_NO_EC
1147 ecdsa_c[R_EC_P160][0] = count / 1000;
1148 ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1149 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1150 ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1151 ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1152 if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1155 if (ecdsa_c[i] == 0) {
1161 ecdsa_c[R_EC_K163][0] = count / 1000;
1162 ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1163 for (i = R_EC_K233; i <= R_EC_K571; 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_B163][0] = count / 1000;
1176 ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1177 for (i = R_EC_B233; i <= R_EC_B571; 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) {
1190 ecdh_c[R_EC_P160][0] = count / 1000;
1191 ecdh_c[R_EC_P160][1] = count / 1000;
1192 for (i = R_EC_P192; i <= R_EC_P521; i++) {
1193 ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1194 ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1195 if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1198 if (ecdh_c[i] == 0) {
1204 ecdh_c[R_EC_K163][0] = count / 1000;
1205 ecdh_c[R_EC_K163][1] = count / 1000;
1206 for (i = R_EC_K233; i <= R_EC_K571; 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_B163][0] = count / 1000;
1219 ecdh_c[R_EC_B163][1] = count / 1000;
1220 for (i = R_EC_B233; i <= R_EC_B571; 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) {
1234 # define COND(d) (count < (d))
1235 # define COUNT(d) (d)
1237 /* not worth fixing */
1238 # error "You cannot disable DES on systems without SIGALRM."
1239 # endif /* OPENSSL_NO_DES */
1241 # define COND(c) (run && count<0x7fffffff)
1242 # define COUNT(d) (count)
1244 signal(SIGALRM, sig_done);
1246 #endif /* SIGALRM */
1248 #ifndef OPENSSL_NO_MD2
1250 for (j = 0; j < SIZE_NUM; j++) {
1251 print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1253 for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1254 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1257 print_result(D_MD2, j, count, d);
1261 #ifndef OPENSSL_NO_MDC2
1263 for (j = 0; j < SIZE_NUM; j++) {
1264 print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1266 for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1267 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1270 print_result(D_MDC2, j, count, d);
1275 #ifndef OPENSSL_NO_MD4
1277 for (j = 0; j < SIZE_NUM; j++) {
1278 print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1280 for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1281 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1282 NULL, EVP_md4(), NULL);
1284 print_result(D_MD4, j, count, d);
1289 #ifndef OPENSSL_NO_MD5
1291 for (j = 0; j < SIZE_NUM; j++) {
1292 print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1294 for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1295 MD5(buf, lengths[j], md5);
1297 print_result(D_MD5, j, count, d);
1302 #if !defined(OPENSSL_NO_MD5)
1306 HMAC_CTX_init(&hctx);
1307 HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1308 16, EVP_md5(), NULL);
1310 for (j = 0; j < SIZE_NUM; j++) {
1311 print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1313 for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1314 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1315 HMAC_Update(&hctx, buf, lengths[j]);
1316 HMAC_Final(&hctx, &(hmac[0]), NULL);
1319 print_result(D_HMAC, j, count, d);
1321 HMAC_CTX_cleanup(&hctx);
1325 for (j = 0; j < SIZE_NUM; j++) {
1326 print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1328 for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1329 SHA1(buf, lengths[j], sha);
1331 print_result(D_SHA1, j, count, d);
1334 if (doit[D_SHA256]) {
1335 for (j = 0; j < SIZE_NUM; j++) {
1336 print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1338 for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1339 SHA256(buf, lengths[j], sha256);
1341 print_result(D_SHA256, j, count, d);
1344 if (doit[D_SHA512]) {
1345 for (j = 0; j < SIZE_NUM; j++) {
1346 print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1348 for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1349 SHA512(buf, lengths[j], sha512);
1351 print_result(D_SHA512, j, count, d);
1355 #ifndef OPENSSL_NO_WHIRLPOOL
1356 if (doit[D_WHIRLPOOL]) {
1357 for (j = 0; j < SIZE_NUM; j++) {
1358 print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1360 for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1361 WHIRLPOOL(buf, lengths[j], whirlpool);
1363 print_result(D_WHIRLPOOL, j, count, d);
1368 #ifndef OPENSSL_NO_RMD160
1369 if (doit[D_RMD160]) {
1370 for (j = 0; j < SIZE_NUM; j++) {
1371 print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1373 for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1374 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1375 EVP_ripemd160(), NULL);
1377 print_result(D_RMD160, j, count, d);
1381 #ifndef OPENSSL_NO_RC4
1383 for (j = 0; j < SIZE_NUM; j++) {
1384 print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1386 for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1387 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1389 print_result(D_RC4, j, count, d);
1393 #ifndef OPENSSL_NO_DES
1394 if (doit[D_CBC_DES]) {
1395 for (j = 0; j < SIZE_NUM; j++) {
1396 print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1398 for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1399 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1400 &DES_iv, DES_ENCRYPT);
1402 print_result(D_CBC_DES, j, count, d);
1406 if (doit[D_EDE3_DES]) {
1407 for (j = 0; j < SIZE_NUM; j++) {
1408 print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1410 for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1411 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1413 &DES_iv, DES_ENCRYPT);
1415 print_result(D_EDE3_DES, j, count, d);
1419 #ifndef OPENSSL_NO_AES
1420 if (doit[D_CBC_128_AES]) {
1421 for (j = 0; j < SIZE_NUM; j++) {
1422 print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1425 for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1426 AES_cbc_encrypt(buf, buf,
1427 (unsigned long)lengths[j], &aes_ks1,
1430 print_result(D_CBC_128_AES, j, count, d);
1433 if (doit[D_CBC_192_AES]) {
1434 for (j = 0; j < SIZE_NUM; j++) {
1435 print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1438 for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1439 AES_cbc_encrypt(buf, buf,
1440 (unsigned long)lengths[j], &aes_ks2,
1443 print_result(D_CBC_192_AES, j, count, d);
1446 if (doit[D_CBC_256_AES]) {
1447 for (j = 0; j < SIZE_NUM; j++) {
1448 print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1451 for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1452 AES_cbc_encrypt(buf, buf,
1453 (unsigned long)lengths[j], &aes_ks3,
1456 print_result(D_CBC_256_AES, j, count, d);
1460 if (doit[D_IGE_128_AES]) {
1461 for (j = 0; j < SIZE_NUM; j++) {
1462 print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1465 for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1466 AES_ige_encrypt(buf, buf2,
1467 (unsigned long)lengths[j], &aes_ks1,
1470 print_result(D_IGE_128_AES, j, count, d);
1473 if (doit[D_IGE_192_AES]) {
1474 for (j = 0; j < SIZE_NUM; j++) {
1475 print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1478 for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1479 AES_ige_encrypt(buf, buf2,
1480 (unsigned long)lengths[j], &aes_ks2,
1483 print_result(D_IGE_192_AES, j, count, d);
1486 if (doit[D_IGE_256_AES]) {
1487 for (j = 0; j < SIZE_NUM; j++) {
1488 print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1491 for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1492 AES_ige_encrypt(buf, buf2,
1493 (unsigned long)lengths[j], &aes_ks3,
1496 print_result(D_IGE_256_AES, j, count, d);
1499 if (doit[D_GHASH]) {
1500 GCM128_CONTEXT *ctx =
1501 CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1502 CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1504 for (j = 0; j < SIZE_NUM; j++) {
1505 print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1507 for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1508 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1510 print_result(D_GHASH, j, count, d);
1512 CRYPTO_gcm128_release(ctx);
1515 #ifndef OPENSSL_NO_CAMELLIA
1516 if (doit[D_CBC_128_CML]) {
1517 for (j = 0; j < SIZE_NUM; j++) {
1518 print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1521 for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1522 Camellia_cbc_encrypt(buf, buf,
1523 (unsigned long)lengths[j], &camellia_ks1,
1524 iv, CAMELLIA_ENCRYPT);
1526 print_result(D_CBC_128_CML, j, count, d);
1529 if (doit[D_CBC_192_CML]) {
1530 for (j = 0; j < SIZE_NUM; j++) {
1531 print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1534 for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1535 Camellia_cbc_encrypt(buf, buf,
1536 (unsigned long)lengths[j], &camellia_ks2,
1537 iv, CAMELLIA_ENCRYPT);
1539 print_result(D_CBC_192_CML, j, count, d);
1542 if (doit[D_CBC_256_CML]) {
1543 for (j = 0; j < SIZE_NUM; j++) {
1544 print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1547 for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1548 Camellia_cbc_encrypt(buf, buf,
1549 (unsigned long)lengths[j], &camellia_ks3,
1550 iv, CAMELLIA_ENCRYPT);
1552 print_result(D_CBC_256_CML, j, count, d);
1556 #ifndef OPENSSL_NO_IDEA
1557 if (doit[D_CBC_IDEA]) {
1558 for (j = 0; j < SIZE_NUM; j++) {
1559 print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1561 for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1562 idea_cbc_encrypt(buf, buf,
1563 (unsigned long)lengths[j], &idea_ks,
1566 print_result(D_CBC_IDEA, j, count, d);
1570 #ifndef OPENSSL_NO_SEED
1571 if (doit[D_CBC_SEED]) {
1572 for (j = 0; j < SIZE_NUM; j++) {
1573 print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1575 for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1576 SEED_cbc_encrypt(buf, buf,
1577 (unsigned long)lengths[j], &seed_ks, iv, 1);
1579 print_result(D_CBC_SEED, j, count, d);
1583 #ifndef OPENSSL_NO_RC2
1584 if (doit[D_CBC_RC2]) {
1585 for (j = 0; j < SIZE_NUM; j++) {
1586 print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1588 for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1589 RC2_cbc_encrypt(buf, buf,
1590 (unsigned long)lengths[j], &rc2_ks,
1593 print_result(D_CBC_RC2, j, count, d);
1597 #ifndef OPENSSL_NO_RC5
1598 if (doit[D_CBC_RC5]) {
1599 for (j = 0; j < SIZE_NUM; j++) {
1600 print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1602 for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1603 RC5_32_cbc_encrypt(buf, buf,
1604 (unsigned long)lengths[j], &rc5_ks,
1607 print_result(D_CBC_RC5, j, count, d);
1611 #ifndef OPENSSL_NO_BF
1612 if (doit[D_CBC_BF]) {
1613 for (j = 0; j < SIZE_NUM; j++) {
1614 print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1616 for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1617 BF_cbc_encrypt(buf, buf,
1618 (unsigned long)lengths[j], &bf_ks,
1621 print_result(D_CBC_BF, j, count, d);
1625 #ifndef OPENSSL_NO_CAST
1626 if (doit[D_CBC_CAST]) {
1627 for (j = 0; j < SIZE_NUM; j++) {
1628 print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1630 for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1631 CAST_cbc_encrypt(buf, buf,
1632 (unsigned long)lengths[j], &cast_ks,
1635 print_result(D_CBC_CAST, j, count, d);
1641 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1642 if (multiblock && evp_cipher) {
1644 (EVP_CIPHER_flags(evp_cipher) &
1645 EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1646 BIO_printf(bio_err, "%s is not multi-block capable\n",
1647 OBJ_nid2ln(evp_cipher->nid));
1650 multiblock_speed(evp_cipher);
1655 for (j = 0; j < SIZE_NUM; j++) {
1660 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1662 * -O3 -fschedule-insns messes up an optimization here!
1663 * names[D_EVP] somehow becomes NULL
1665 print_message(names[D_EVP], save_count, lengths[j]);
1667 EVP_CIPHER_CTX_init(&ctx);
1669 EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1671 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1672 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1676 for (count = 0, run = 1;
1677 COND(save_count * 4 * lengths[0] / lengths[j]);
1679 EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1681 for (count = 0, run = 1;
1682 COND(save_count * 4 * lengths[0] / lengths[j]);
1684 EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1686 EVP_DecryptFinal_ex(&ctx, buf, &outl);
1688 EVP_EncryptFinal_ex(&ctx, buf, &outl);
1690 EVP_CIPHER_CTX_cleanup(&ctx);
1693 names[D_EVP] = OBJ_nid2ln(evp_md->type);
1694 print_message(names[D_EVP], save_count, lengths[j]);
1697 for (count = 0, run = 1;
1698 COND(save_count * 4 * lengths[0] / lengths[j]); count++)
1699 EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
1703 print_result(D_EVP, j, count, d);
1707 RAND_bytes(buf, 36);
1708 #ifndef OPENSSL_NO_RSA
1709 for (j = 0; j < RSA_NUM; j++) {
1713 st = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
1716 "RSA sign failure. No RSA sign will be done.\n");
1717 ERR_print_errors(bio_err);
1720 pkey_print_message("private", "rsa",
1721 rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
1722 /* RSA_blinding_on(rsa_key[j],NULL); */
1724 for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
1725 st = RSA_sign(NID_md5_sha1, buf, 36, buf2,
1726 &rsa_num, rsa_key[j]);
1728 BIO_printf(bio_err, "RSA sign failure\n");
1729 ERR_print_errors(bio_err);
1736 mr ? "+R1:%ld:%d:%.2f\n"
1737 : "%ld %d bit private RSA's in %.2fs\n",
1738 count, rsa_bits[j], d);
1739 rsa_results[j][0] = d / (double)count;
1743 st = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
1746 "RSA verify failure. No RSA verify will be done.\n");
1747 ERR_print_errors(bio_err);
1750 pkey_print_message("public", "rsa",
1751 rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
1753 for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
1754 st = RSA_verify(NID_md5_sha1, buf, 36, buf2,
1755 rsa_num, rsa_key[j]);
1757 BIO_printf(bio_err, "RSA verify failure\n");
1758 ERR_print_errors(bio_err);
1765 mr ? "+R2:%ld:%d:%.2f\n"
1766 : "%ld %d bit public RSA's in %.2fs\n",
1767 count, rsa_bits[j], d);
1768 rsa_results[j][1] = d / (double)count;
1771 if (rsa_count <= 1) {
1772 /* if longer than 10s, don't do any more */
1773 for (j++; j < RSA_NUM; j++)
1779 RAND_bytes(buf, 20);
1780 #ifndef OPENSSL_NO_DSA
1781 if (RAND_status() != 1) {
1782 RAND_seed(rnd_seed, sizeof rnd_seed);
1785 for (j = 0; j < DSA_NUM; j++) {
1792 /* DSA_generate_key(dsa_key[j]); */
1793 /* DSA_sign_setup(dsa_key[j],NULL); */
1794 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1797 "DSA sign failure. No DSA sign will be done.\n");
1798 ERR_print_errors(bio_err);
1801 pkey_print_message("sign", "dsa",
1802 dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
1804 for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
1805 st = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
1807 BIO_printf(bio_err, "DSA sign failure\n");
1808 ERR_print_errors(bio_err);
1815 mr ? "+R3:%ld:%d:%.2f\n"
1816 : "%ld %d bit DSA signs in %.2fs\n",
1817 count, dsa_bits[j], d);
1818 dsa_results[j][0] = d / (double)count;
1822 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1825 "DSA verify failure. No DSA verify will be done.\n");
1826 ERR_print_errors(bio_err);
1829 pkey_print_message("verify", "dsa",
1830 dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
1832 for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
1833 st = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
1835 BIO_printf(bio_err, "DSA verify failure\n");
1836 ERR_print_errors(bio_err);
1843 mr ? "+R4:%ld:%d:%.2f\n"
1844 : "%ld %d bit DSA verify in %.2fs\n",
1845 count, dsa_bits[j], d);
1846 dsa_results[j][1] = d / (double)count;
1849 if (rsa_count <= 1) {
1850 /* if longer than 10s, don't do any more */
1851 for (j++; j < DSA_NUM; j++)
1859 #ifndef OPENSSL_NO_EC
1860 if (RAND_status() != 1) {
1861 RAND_seed(rnd_seed, sizeof rnd_seed);
1864 for (j = 0; j < EC_NUM; j++) {
1868 continue; /* Ignore Curve */
1869 ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1870 if (ecdsa[j] == NULL) {
1871 BIO_printf(bio_err, "ECDSA failure.\n");
1872 ERR_print_errors(bio_err);
1875 EC_KEY_precompute_mult(ecdsa[j], NULL);
1876 /* Perform ECDSA signature test */
1877 EC_KEY_generate_key(ecdsa[j]);
1878 st = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
1881 "ECDSA sign failure. No ECDSA sign will be done.\n");
1882 ERR_print_errors(bio_err);
1885 pkey_print_message("sign", "ecdsa",
1887 test_curves_bits[j], ECDSA_SECONDS);
1890 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
1891 st = ECDSA_sign(0, buf, 20,
1892 ecdsasig, &ecdsasiglen, ecdsa[j]);
1894 BIO_printf(bio_err, "ECDSA sign failure\n");
1895 ERR_print_errors(bio_err);
1903 mr ? "+R5:%ld:%d:%.2f\n" :
1904 "%ld %d bit ECDSA signs in %.2fs \n",
1905 count, test_curves_bits[j], d);
1906 ecdsa_results[j][0] = d / (double)count;
1910 /* Perform ECDSA verification test */
1911 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
1914 "ECDSA verify failure. No ECDSA verify will be done.\n");
1915 ERR_print_errors(bio_err);
1918 pkey_print_message("verify", "ecdsa",
1920 test_curves_bits[j], ECDSA_SECONDS);
1922 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
1923 st = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
1926 BIO_printf(bio_err, "ECDSA verify failure\n");
1927 ERR_print_errors(bio_err);
1934 mr ? "+R6:%ld:%d:%.2f\n"
1935 : "%ld %d bit ECDSA verify in %.2fs\n",
1936 count, test_curves_bits[j], d);
1937 ecdsa_results[j][1] = d / (double)count;
1940 if (rsa_count <= 1) {
1941 /* if longer than 10s, don't do any more */
1942 for (j++; j < EC_NUM; j++)
1951 #ifndef OPENSSL_NO_EC
1952 if (RAND_status() != 1) {
1953 RAND_seed(rnd_seed, sizeof rnd_seed);
1956 for (j = 0; j < EC_NUM; j++) {
1959 ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1960 ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
1961 if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
1962 BIO_printf(bio_err, "ECDH failure.\n");
1963 ERR_print_errors(bio_err);
1966 /* generate two ECDH key pairs */
1967 if (!EC_KEY_generate_key(ecdh_a[j]) ||
1968 !EC_KEY_generate_key(ecdh_b[j])) {
1969 BIO_printf(bio_err, "ECDH key generation failure.\n");
1970 ERR_print_errors(bio_err);
1974 * If field size is not more than 24 octets, then use SHA-1
1975 * hash of result; otherwise, use result (see section 4.8 of
1976 * draft-ietf-tls-ecc-03.txt).
1978 int field_size, outlen;
1979 void *(*kdf) (const void *in, size_t inlen, void *out,
1982 EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
1983 if (field_size <= 24 * 8) {
1984 outlen = KDF1_SHA1_len;
1987 outlen = (field_size + 7) / 8;
1991 ECDH_compute_key(secret_a, outlen,
1992 EC_KEY_get0_public_key(ecdh_b[j]),
1995 ECDH_compute_key(secret_b, outlen,
1996 EC_KEY_get0_public_key(ecdh_a[j]),
1998 if (secret_size_a != secret_size_b)
2003 for (secret_idx = 0; (secret_idx < secret_size_a)
2004 && (ecdh_checks == 1); secret_idx++) {
2005 if (secret_a[secret_idx] != secret_b[secret_idx])
2009 if (ecdh_checks == 0) {
2010 BIO_printf(bio_err, "ECDH computations don't match.\n");
2011 ERR_print_errors(bio_err);
2015 pkey_print_message("", "ecdh",
2017 test_curves_bits[j], ECDH_SECONDS);
2019 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2020 ECDH_compute_key(secret_a, outlen,
2021 EC_KEY_get0_public_key(ecdh_b[j]),
2026 mr ? "+R7:%ld:%d:%.2f\n" :
2027 "%ld %d-bit ECDH ops in %.2fs\n", count,
2028 test_curves_bits[j], d);
2029 ecdh_results[j][0] = d / (double)count;
2034 if (rsa_count <= 1) {
2035 /* if longer than 10s, don't do any more */
2036 for (j++; j < EC_NUM; j++)
2047 printf("%s\n", SSLeay_version(SSLEAY_VERSION));
2048 printf("%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2050 printf("%s ", BN_options());
2051 #ifndef OPENSSL_NO_MD2
2052 printf("%s ", MD2_options());
2054 #ifndef OPENSSL_NO_RC4
2055 printf("%s ", RC4_options());
2057 #ifndef OPENSSL_NO_DES
2058 printf("%s ", DES_options());
2060 #ifndef OPENSSL_NO_AES
2061 printf("%s ", AES_options());
2063 #ifndef OPENSSL_NO_IDEA
2064 printf("%s ", idea_options());
2066 #ifndef OPENSSL_NO_BF
2067 printf("%s ", BF_options());
2069 printf("\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2077 ("The 'numbers' are in 1000s of bytes per second processed.\n");
2080 for (j = 0; j < SIZE_NUM; j++)
2081 printf(mr ? ":%d" : "%7d bytes", lengths[j]);
2085 for (k = 0; k < ALGOR_NUM; k++) {
2089 printf("+F:%d:%s", k, names[k]);
2091 printf("%-13s", names[k]);
2092 for (j = 0; j < SIZE_NUM; j++) {
2093 if (results[k][j] > 10000 && !mr)
2094 printf(" %11.2fk", results[k][j] / 1e3);
2096 printf(mr ? ":%.2f" : " %11.2f ", results[k][j]);
2100 #ifndef OPENSSL_NO_RSA
2102 for (k = 0; k < RSA_NUM; k++) {
2106 printf("%18ssign verify sign/s verify/s\n", " ");
2110 printf("+F2:%u:%u:%f:%f\n",
2111 k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2113 printf("rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2114 rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2115 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2118 #ifndef OPENSSL_NO_DSA
2120 for (k = 0; k < DSA_NUM; k++) {
2124 printf("%18ssign verify sign/s verify/s\n", " ");
2128 printf("+F3:%u:%u:%f:%f\n",
2129 k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2131 printf("dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2132 dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2133 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2136 #ifndef OPENSSL_NO_EC
2138 for (k = 0; k < EC_NUM; k++) {
2142 printf("%30ssign verify sign/s verify/s\n", " ");
2147 printf("+F4:%u:%u:%f:%f\n",
2148 k, test_curves_bits[k],
2149 ecdsa_results[k][0], ecdsa_results[k][1]);
2151 printf("%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2152 test_curves_bits[k],
2153 test_curves_names[k],
2154 ecdsa_results[k][0], ecdsa_results[k][1],
2155 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2159 #ifndef OPENSSL_NO_EC
2161 for (k = 0; k < EC_NUM; k++) {
2165 printf("%30sop op/s\n", " ");
2169 printf("+F5:%u:%u:%f:%f\n",
2170 k, test_curves_bits[k],
2171 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2174 printf("%4u bit ecdh (%s) %8.4fs %8.1f\n",
2175 test_curves_bits[k],
2176 test_curves_names[k],
2177 ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2184 ERR_print_errors(bio_err);
2185 OPENSSL_free(buf_malloc);
2186 OPENSSL_free(buf2_malloc);
2187 #ifndef OPENSSL_NO_RSA
2188 for (i = 0; i < RSA_NUM; i++)
2189 RSA_free(rsa_key[i]);
2191 #ifndef OPENSSL_NO_DSA
2192 for (i = 0; i < DSA_NUM; i++)
2193 DSA_free(dsa_key[i]);
2196 #ifndef OPENSSL_NO_EC
2197 for (i = 0; i < EC_NUM; i++) {
2198 EC_KEY_free(ecdsa[i]);
2199 EC_KEY_free(ecdh_a[i]);
2200 EC_KEY_free(ecdh_b[i]);
2206 static void print_message(const char *s, long num, int length)
2210 mr ? "+DT:%s:%d:%d\n"
2211 : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2212 (void)BIO_flush(bio_err);
2216 mr ? "+DN:%s:%ld:%d\n"
2217 : "Doing %s %ld times on %d size blocks: ", s, num, length);
2218 (void)BIO_flush(bio_err);
2222 static void pkey_print_message(const char *str, const char *str2, long num,
2227 mr ? "+DTP:%d:%s:%s:%d\n"
2228 : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2229 (void)BIO_flush(bio_err);
2233 mr ? "+DNP:%ld:%d:%s:%s\n"
2234 : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2235 (void)BIO_flush(bio_err);
2239 static void print_result(int alg, int run_no, int count, double time_used)
2242 mr ? "+R:%d:%s:%f\n"
2243 : "%d %s's in %.2fs\n", count, names[alg], time_used);
2244 results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2248 static char *sstrsep(char **string, const char *delim)
2251 char *token = *string;
2256 memset(isdelim, 0, sizeof isdelim);
2260 isdelim[(unsigned char)(*delim)] = 1;
2264 while (!isdelim[(unsigned char)(**string)]) {
2276 static int do_multi(int multi)
2281 static char sep[] = ":";
2283 fds = malloc(sizeof(*fds) * multi);
2284 for (n = 0; n < multi; ++n) {
2285 if (pipe(fd) == -1) {
2286 BIO_printf(bio_err, "pipe failure\n");
2290 (void)BIO_flush(bio_err);
2297 if (dup(fd[1]) == -1) {
2298 BIO_printf(bio_err, "dup failed\n");
2307 printf("Forked child %d\n", n);
2310 /* for now, assume the pipe is long enough to take all the output */
2311 for (n = 0; n < multi; ++n) {
2316 f = fdopen(fds[n], "r");
2317 while (fgets(buf, sizeof buf, f)) {
2318 p = strchr(buf, '\n');
2321 if (buf[0] != '+') {
2322 BIO_printf(bio_err, "Don't understand line '%s' from child %d\n",
2326 printf("Got: %s from %d\n", buf, n);
2327 if (strncmp(buf, "+F:", 3) == 0) {
2332 alg = atoi(sstrsep(&p, sep));
2334 for (j = 0; j < SIZE_NUM; ++j)
2335 results[alg][j] += atof(sstrsep(&p, sep));
2336 } else if (strncmp(buf, "+F2:", 4) == 0) {
2341 k = atoi(sstrsep(&p, sep));
2344 d = atof(sstrsep(&p, sep));
2346 rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2348 rsa_results[k][0] = d;
2350 d = atof(sstrsep(&p, sep));
2352 rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2354 rsa_results[k][1] = d;
2356 # ifndef OPENSSL_NO_DSA
2357 else if (strncmp(buf, "+F3:", 4) == 0) {
2362 k = atoi(sstrsep(&p, sep));
2365 d = atof(sstrsep(&p, sep));
2367 dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2369 dsa_results[k][0] = d;
2371 d = atof(sstrsep(&p, sep));
2373 dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2375 dsa_results[k][1] = d;
2378 # ifndef OPENSSL_NO_EC
2379 else if (strncmp(buf, "+F4:", 4) == 0) {
2384 k = atoi(sstrsep(&p, sep));
2387 d = atof(sstrsep(&p, sep));
2389 ecdsa_results[k][0] =
2390 1 / (1 / ecdsa_results[k][0] + 1 / d);
2392 ecdsa_results[k][0] = d;
2394 d = atof(sstrsep(&p, sep));
2396 ecdsa_results[k][1] =
2397 1 / (1 / ecdsa_results[k][1] + 1 / d);
2399 ecdsa_results[k][1] = d;
2403 # ifndef OPENSSL_NO_EC
2404 else if (strncmp(buf, "+F5:", 4) == 0) {
2409 k = atoi(sstrsep(&p, sep));
2412 d = atof(sstrsep(&p, sep));
2414 ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2416 ecdh_results[k][0] = d;
2421 else if (strncmp(buf, "+H:", 3) == 0) {
2424 BIO_printf(bio_err, "Unknown type '%s' from child %d\n", buf, n);
2434 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2436 static int mblengths[] =
2437 { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2438 int j, count, num = OSSL_NELEM(lengths);
2439 const char *alg_name;
2440 unsigned char *inp, *out, no_key[32], no_iv[16];
2444 inp = app_malloc(mblengths[num - 1], "multiblock input buffer");
2445 out = app_malloc(mblengths[num - 1] + 1024, "multiblock output buffer");
2446 EVP_CIPHER_CTX_init(&ctx);
2447 EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2448 EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2450 alg_name = OBJ_nid2ln(evp_cipher->nid);
2452 for (j = 0; j < num; j++) {
2453 print_message(alg_name, 0, mblengths[j]);
2455 for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2456 unsigned char aad[EVP_AEAD_TLS1_AAD_LEN];
2457 EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2458 size_t len = mblengths[j];
2461 memset(aad, 0, 8); /* avoid uninitialized values */
2462 aad[8] = 23; /* SSL3_RT_APPLICATION_DATA */
2463 aad[9] = 3; /* version */
2465 aad[11] = 0; /* length */
2467 mb_param.out = NULL;
2470 mb_param.interleave = 8;
2472 packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2473 EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2474 sizeof(mb_param), &mb_param);
2480 EVP_CIPHER_CTX_ctrl(&ctx,
2481 EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2482 sizeof(mb_param), &mb_param);
2486 RAND_bytes(out, 16);
2490 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2491 EVP_CTRL_AEAD_TLS1_AAD,
2492 EVP_AEAD_TLS1_AAD_LEN, aad);
2493 EVP_Cipher(&ctx, out, inp, len + pad);
2497 BIO_printf(bio_err, mr ? "+R:%d:%s:%f\n"
2498 : "%d %s's in %.2fs\n", count, "evp", d);
2499 results[D_EVP][j] = ((double)count) / d * mblengths[j];
2503 fprintf(stdout, "+H");
2504 for (j = 0; j < num; j++)
2505 fprintf(stdout, ":%d", mblengths[j]);
2506 fprintf(stdout, "\n");
2507 fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2508 for (j = 0; j < num; j++)
2509 fprintf(stdout, ":%.2f", results[D_EVP][j]);
2510 fprintf(stdout, "\n");
2513 "The 'numbers' are in 1000s of bytes per second processed.\n");
2514 fprintf(stdout, "type ");
2515 for (j = 0; j < num; j++)
2516 fprintf(stdout, "%7d bytes", mblengths[j]);
2517 fprintf(stdout, "\n");
2518 fprintf(stdout, "%-24s", alg_name);
2520 for (j = 0; j < num; j++) {
2521 if (results[D_EVP][j] > 10000)
2522 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2524 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2526 fprintf(stdout, "\n");