419dced8078ccd4aadbeeb24d31d140fbdb3cff1
[openssl.git] / apps / speed.c
1 /* apps/speed.c -*- mode:C; c-file-style: "eay" -*- */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 /* ====================================================================
59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
60  *
61  * Portions of the attached software ("Contribution") are developed by
62  * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project.
63  *
64  * The Contribution is licensed pursuant to the OpenSSL open source
65  * license provided above.
66  *
67  * The ECDH and ECDSA speed test software is originally written by
68  * Sumit Gupta of Sun Microsystems Laboratories.
69  *
70  */
71
72 #undef SECONDS
73 #define SECONDS                 3
74 #define PRIME_SECONDS   10
75 #define RSA_SECONDS             10
76 #define DSA_SECONDS             10
77 #define ECDSA_SECONDS   10
78 #define ECDH_SECONDS    10
79
80 #undef PROG
81 #define PROG speed_main
82
83 #include <stdio.h>
84 #include <stdlib.h>
85
86 #include <string.h>
87 #include <math.h>
88 #include "apps.h"
89 #include <openssl/crypto.h>
90 #include <openssl/rand.h>
91 #include <openssl/err.h>
92 #include <openssl/evp.h>
93 #include <openssl/objects.h>
94 #if !defined(OPENSSL_SYS_MSDOS)
95 # include OPENSSL_UNISTD
96 #endif
97
98 #ifndef OPENSSL_SYS_NETWARE
99 # include <signal.h>
100 #endif
101
102 #if defined(_WIN32) || defined(__CYGWIN__)
103 # include <windows.h>
104 # if defined(__CYGWIN__) && !defined(_WIN32)
105   /*
106    * <windows.h> should define _WIN32, which normally is mutually exclusive
107    * with __CYGWIN__, but if it didn't...
108    */
109 #  define _WIN32
110   /* this is done because Cygwin alarm() fails sometimes. */
111 # endif
112 #endif
113
114 #include <openssl/bn.h>
115 #ifndef OPENSSL_NO_DES
116 # include <openssl/des.h>
117 #endif
118 #ifndef OPENSSL_NO_AES
119 # include <openssl/aes.h>
120 #endif
121 #ifndef OPENSSL_NO_CAMELLIA
122 # include <openssl/camellia.h>
123 #endif
124 #ifndef OPENSSL_NO_MD2
125 # include <openssl/md2.h>
126 #endif
127 #ifndef OPENSSL_NO_MDC2
128 # include <openssl/mdc2.h>
129 #endif
130 #ifndef OPENSSL_NO_MD4
131 # include <openssl/md4.h>
132 #endif
133 #ifndef OPENSSL_NO_MD5
134 # include <openssl/md5.h>
135 #endif
136 #ifndef OPENSSL_NO_HMAC
137 # include <openssl/hmac.h>
138 #endif
139 #include <openssl/evp.h>
140 # include <openssl/sha.h>
141 #ifndef OPENSSL_NO_RMD160
142 # include <openssl/ripemd.h>
143 #endif
144 #ifndef OPENSSL_NO_WHIRLPOOL
145 # include <openssl/whrlpool.h>
146 #endif
147 #ifndef OPENSSL_NO_RC4
148 # include <openssl/rc4.h>
149 #endif
150 #ifndef OPENSSL_NO_RC5
151 # include <openssl/rc5.h>
152 #endif
153 #ifndef OPENSSL_NO_RC2
154 # include <openssl/rc2.h>
155 #endif
156 #ifndef OPENSSL_NO_IDEA
157 # include <openssl/idea.h>
158 #endif
159 #ifndef OPENSSL_NO_SEED
160 # include <openssl/seed.h>
161 #endif
162 #ifndef OPENSSL_NO_BF
163 # include <openssl/blowfish.h>
164 #endif
165 #ifndef OPENSSL_NO_CAST
166 # include <openssl/cast.h>
167 #endif
168 #ifndef OPENSSL_NO_RSA
169 # include <openssl/rsa.h>
170 # include "./testrsa.h"
171 #endif
172 #include <openssl/x509.h>
173 #ifndef OPENSSL_NO_DSA
174 # include <openssl/dsa.h>
175 # include "./testdsa.h"
176 #endif
177 #ifndef OPENSSL_NO_ECDSA
178 # include <openssl/ecdsa.h>
179 #endif
180 #ifndef OPENSSL_NO_ECDH
181 # include <openssl/ecdh.h>
182 #endif
183 #include <openssl/modes.h>
184
185 #include <openssl/bn.h>
186
187 #ifndef HAVE_FORK
188 # if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE)
189 #  define HAVE_FORK 0
190 # else
191 #  define HAVE_FORK 1
192 # endif
193 #endif
194
195 #if HAVE_FORK
196 # undef NO_FORK
197 #else
198 # define NO_FORK
199 #endif
200
201 #undef BUFSIZE
202 #define BUFSIZE (1024*8+1)
203 #define MAX_MISALIGNMENT 63
204
205 static volatile int run = 0;
206
207 static int mr = 0;
208 static int usertime = 1;
209
210 static double Time_F(int s);
211 static void print_message(const char *s, long num, int length);
212 static void pkey_print_message(const char *str, const char *str2,
213                                long num, int bits, int sec);
214 static void print_result(int alg, int run_no, int count, double time_used);
215 #ifndef NO_FORK
216 static int do_multi(int multi);
217 #endif
218
219 #define ALGOR_NUM       30
220 #define SIZE_NUM        5
221 #define PRIME_NUM       3
222 #define RSA_NUM         7
223 #define DSA_NUM         3
224
225 #define EC_NUM       16
226 #define MAX_ECDH_SIZE 256
227
228 static const char *names[ALGOR_NUM] = {
229     "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",
230     "des cbc", "des ede3", "idea cbc", "seed cbc",
231     "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",
232     "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",
233     "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",
234     "evp", "sha256", "sha512", "whirlpool",
235     "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash"
236 };
237
238 static double results[ALGOR_NUM][SIZE_NUM];
239 static int lengths[SIZE_NUM] = { 16, 64, 256, 1024, 8 * 1024 };
240
241 #ifndef OPENSSL_NO_RSA
242 static double rsa_results[RSA_NUM][2];
243 #endif
244 #ifndef OPENSSL_NO_DSA
245 static double dsa_results[DSA_NUM][2];
246 #endif
247 #ifndef OPENSSL_NO_ECDSA
248 static double ecdsa_results[EC_NUM][2];
249 #endif
250 #ifndef OPENSSL_NO_ECDH
251 static double ecdh_results[EC_NUM][1];
252 #endif
253
254 #if defined(OPENSSL_NO_DSA) && !(defined(OPENSSL_NO_ECDSA) && defined(OPENSSL_NO_ECDH))
255 static const char rnd_seed[] =
256     "string to make the random number generator think it has entropy";
257 static int rnd_fake = 0;
258 #endif
259
260 #ifdef SIGALRM
261 # if defined(__STDC__) || defined(sgi) || defined(_AIX)
262 #  define SIGRETTYPE void
263 # else
264 #  define SIGRETTYPE int
265 # endif
266
267 static SIGRETTYPE sig_done(int sig);
268 static SIGRETTYPE sig_done(int sig)
269 {
270     signal(SIGALRM, sig_done);
271     run = 0;
272 }
273 #endif
274
275 #define START   0
276 #define STOP    1
277
278 #if defined(_WIN32)
279
280 # if !defined(SIGALRM)
281 #  define SIGALRM
282 # endif
283 static unsigned int lapse, schlock;
284 static void alarm_win32(unsigned int secs)
285 {
286     lapse = secs * 1000;
287 }
288
289 # define alarm alarm_win32
290
291 static DWORD WINAPI sleepy(VOID * arg)
292 {
293     schlock = 1;
294     Sleep(lapse);
295     run = 0;
296     return 0;
297 }
298
299 static double Time_F(int s)
300 {
301     double ret;
302     static HANDLE thr;
303
304     if (s == START) {
305         schlock = 0;
306         thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);
307         if (thr == NULL) {
308             DWORD ret = GetLastError();
309             BIO_printf(bio_err, "unable to CreateThread (%d)", ret);
310             ExitProcess(ret);
311         }
312         while (!schlock)
313             Sleep(0);           /* scheduler spinlock */
314         ret = app_tminterval(s, usertime);
315     } else {
316         ret = app_tminterval(s, usertime);
317         if (run)
318             TerminateThread(thr, 0);
319         CloseHandle(thr);
320     }
321
322     return ret;
323 }
324 #else
325
326 static double Time_F(int s)
327 {
328     double ret = app_tminterval(s, usertime);
329     if (s == STOP)
330         alarm(0);
331     return ret;
332 }
333 #endif
334
335 #ifndef OPENSSL_NO_ECDH
336 static const int KDF1_SHA1_len = 20;
337 static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
338                        size_t *outlen)
339 {
340     if (*outlen < SHA_DIGEST_LENGTH)
341         return NULL;
342     *outlen = SHA_DIGEST_LENGTH;
343     return SHA1(in, inlen, out);
344 }
345 #endif                         /* OPENSSL_NO_ECDH */
346
347 static void multiblock_speed(const EVP_CIPHER *evp_cipher);
348
349 int MAIN(int, char **);
350
351 int MAIN(int argc, char **argv)
352 {
353     unsigned char *buf_malloc = NULL, *buf2_malloc = NULL;
354     unsigned char *buf = NULL, *buf2 = NULL;
355     int mret = 1;
356     long count = 0, save_count = 0;
357     int i, j, k;
358 #if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
359     long rsa_count;
360 #endif
361 #ifndef OPENSSL_NO_RSA
362     unsigned rsa_num;
363 #endif
364     unsigned char md[EVP_MAX_MD_SIZE];
365 #ifndef OPENSSL_NO_MD2
366     unsigned char md2[MD2_DIGEST_LENGTH];
367 #endif
368 #ifndef OPENSSL_NO_MDC2
369     unsigned char mdc2[MDC2_DIGEST_LENGTH];
370 #endif
371 #ifndef OPENSSL_NO_MD4
372     unsigned char md4[MD4_DIGEST_LENGTH];
373 #endif
374 #ifndef OPENSSL_NO_MD5
375     unsigned char md5[MD5_DIGEST_LENGTH];
376     unsigned char hmac[MD5_DIGEST_LENGTH];
377 #endif
378     unsigned char sha[SHA_DIGEST_LENGTH];
379     unsigned char sha256[SHA256_DIGEST_LENGTH];
380     unsigned char sha512[SHA512_DIGEST_LENGTH];
381 #ifndef OPENSSL_NO_WHIRLPOOL
382     unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];
383 #endif
384 #ifndef OPENSSL_NO_RMD160
385     unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
386 #endif
387 #ifndef OPENSSL_NO_RC4
388     RC4_KEY rc4_ks;
389 #endif
390 #ifndef OPENSSL_NO_RC5
391     RC5_32_KEY rc5_ks;
392 #endif
393 #ifndef OPENSSL_NO_RC2
394     RC2_KEY rc2_ks;
395 #endif
396 #ifndef OPENSSL_NO_IDEA
397     IDEA_KEY_SCHEDULE idea_ks;
398 #endif
399 #ifndef OPENSSL_NO_SEED
400     SEED_KEY_SCHEDULE seed_ks;
401 #endif
402 #ifndef OPENSSL_NO_BF
403     BF_KEY bf_ks;
404 #endif
405 #ifndef OPENSSL_NO_CAST
406     CAST_KEY cast_ks;
407 #endif
408     static const unsigned char key16[16] = {
409         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
410         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12
411     };
412 #ifndef OPENSSL_NO_AES
413     static const unsigned char key24[24] = {
414         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
415         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
416         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
417     };
418     static const unsigned char key32[32] = {
419         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
420         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
421         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
422         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
423     };
424 #endif
425 #ifndef OPENSSL_NO_CAMELLIA
426     static const unsigned char ckey24[24] = {
427         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
428         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
429         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34
430     };
431     static const unsigned char ckey32[32] = {
432         0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
433         0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12,
434         0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34,
435         0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56
436     };
437 #endif
438 #ifndef OPENSSL_NO_AES
439 # define MAX_BLOCK_SIZE 128
440 #else
441 # define MAX_BLOCK_SIZE 64
442 #endif
443     unsigned char DES_iv[8];
444     unsigned char iv[2 * MAX_BLOCK_SIZE / 8];
445 #ifndef OPENSSL_NO_DES
446     static DES_cblock key =
447         { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 };
448     static DES_cblock key2 =
449         { 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12 };
450     static DES_cblock key3 =
451         { 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 };
452     DES_key_schedule sch;
453     DES_key_schedule sch2;
454     DES_key_schedule sch3;
455 #endif
456 #ifndef OPENSSL_NO_AES
457     AES_KEY aes_ks1, aes_ks2, aes_ks3;
458 #endif
459 #ifndef OPENSSL_NO_CAMELLIA
460     CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3;
461 #endif
462 #define D_MD2           0
463 #define D_MDC2          1
464 #define D_MD4           2
465 #define D_MD5           3
466 #define D_HMAC          4
467 #define D_SHA1          5
468 #define D_RMD160        6
469 #define D_RC4           7
470 #define D_CBC_DES       8
471 #define D_EDE3_DES      9
472 #define D_CBC_IDEA      10
473 #define D_CBC_SEED      11
474 #define D_CBC_RC2       12
475 #define D_CBC_RC5       13
476 #define D_CBC_BF        14
477 #define D_CBC_CAST      15
478 #define D_CBC_128_AES   16
479 #define D_CBC_192_AES   17
480 #define D_CBC_256_AES   18
481 #define D_CBC_128_CML   19
482 #define D_CBC_192_CML   20
483 #define D_CBC_256_CML   21
484 #define D_EVP           22
485 #define D_SHA256        23
486 #define D_SHA512        24
487 #define D_WHIRLPOOL     25
488 #define D_IGE_128_AES   26
489 #define D_IGE_192_AES   27
490 #define D_IGE_256_AES   28
491 #define D_GHASH         29
492     double d = 0.0;
493     long c[ALGOR_NUM][SIZE_NUM];
494
495 #ifndef OPENSSL_SYS_WIN32
496 #endif
497 #define R_DSA_512       0
498 #define R_DSA_1024      1
499 #define R_DSA_2048      2
500 #define R_RSA_512       0
501 #define R_RSA_1024      1
502 #define R_RSA_2048      2
503 #define R_RSA_3072      3
504 #define R_RSA_4096      4
505 #define R_RSA_7680      5
506 #define R_RSA_15360     6
507
508 #define R_EC_P160    0
509 #define R_EC_P192    1
510 #define R_EC_P224    2
511 #define R_EC_P256    3
512 #define R_EC_P384    4
513 #define R_EC_P521    5
514 #define R_EC_K163    6
515 #define R_EC_K233    7
516 #define R_EC_K283    8
517 #define R_EC_K409    9
518 #define R_EC_K571    10
519 #define R_EC_B163    11
520 #define R_EC_B233    12
521 #define R_EC_B283    13
522 #define R_EC_B409    14
523 #define R_EC_B571    15
524
525 #ifndef OPENSSL_NO_RSA
526     RSA *rsa_key[RSA_NUM];
527     long rsa_c[RSA_NUM][2];
528     static unsigned int rsa_bits[RSA_NUM] = {
529         512, 1024, 2048, 3072, 4096, 7680, 15360
530     };
531     static unsigned char *rsa_data[RSA_NUM] = {
532         test512, test1024, test2048, test3072, test4096, test7680, test15360
533     };
534     static int rsa_data_length[RSA_NUM] = {
535         sizeof(test512), sizeof(test1024),
536         sizeof(test2048), sizeof(test3072),
537         sizeof(test4096), sizeof(test7680),
538         sizeof(test15360)
539     };
540 #endif
541 #ifndef OPENSSL_NO_DSA
542     DSA *dsa_key[DSA_NUM];
543     long dsa_c[DSA_NUM][2];
544     static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
545 #endif
546 #ifndef OPENSSL_NO_EC
547     /*
548      * We only test over the following curves as they are representative, To
549      * add tests over more curves, simply add the curve NID and curve name to
550      * the following arrays and increase the EC_NUM value accordingly.
551      */
552     static unsigned int test_curves[EC_NUM] = {
553         /* Prime Curves */
554         NID_secp160r1,
555         NID_X9_62_prime192v1,
556         NID_secp224r1,
557         NID_X9_62_prime256v1,
558         NID_secp384r1,
559         NID_secp521r1,
560         /* Binary Curves */
561         NID_sect163k1,
562         NID_sect233k1,
563         NID_sect283k1,
564         NID_sect409k1,
565         NID_sect571k1,
566         NID_sect163r2,
567         NID_sect233r1,
568         NID_sect283r1,
569         NID_sect409r1,
570         NID_sect571r1
571     };
572     static const char *test_curves_names[EC_NUM] = {
573         /* Prime Curves */
574         "secp160r1",
575         "nistp192",
576         "nistp224",
577         "nistp256",
578         "nistp384",
579         "nistp521",
580         /* Binary Curves */
581         "nistk163",
582         "nistk233",
583         "nistk283",
584         "nistk409",
585         "nistk571",
586         "nistb163",
587         "nistb233",
588         "nistb283",
589         "nistb409",
590         "nistb571"
591     };
592     static int test_curves_bits[EC_NUM] = {
593         160, 192, 224, 256, 384, 521,
594         163, 233, 283, 409, 571,
595         163, 233, 283, 409, 571
596     };
597
598 #endif
599
600 #ifndef OPENSSL_NO_ECDSA
601     unsigned char ecdsasig[256];
602     unsigned int ecdsasiglen;
603     EC_KEY *ecdsa[EC_NUM];
604     long ecdsa_c[EC_NUM][2];
605 #endif
606
607 #ifndef OPENSSL_NO_ECDH
608     EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM];
609     unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE];
610     int secret_size_a, secret_size_b;
611     int ecdh_checks = 0;
612     int secret_idx = 0;
613     long ecdh_c[EC_NUM][2];
614 #endif
615
616     int rsa_doit[RSA_NUM];
617     int dsa_doit[DSA_NUM];
618 #ifndef OPENSSL_NO_ECDSA
619     int ecdsa_doit[EC_NUM];
620 #endif
621 #ifndef OPENSSL_NO_ECDH
622     int ecdh_doit[EC_NUM];
623 #endif
624     int doit[ALGOR_NUM];
625     int pr_header = 0;
626     const EVP_CIPHER *evp_cipher = NULL;
627     const EVP_MD *evp_md = NULL;
628     int decrypt = 0;
629 #ifndef NO_FORK
630     int multi = 0;
631 #endif
632     int multiblock = 0;
633     int misalign = MAX_MISALIGNMENT + 1;
634
635 #ifndef TIMES
636     usertime = -1;
637 #endif
638
639     apps_startup();
640     memset(results, 0, sizeof(results));
641 #ifndef OPENSSL_NO_DSA
642     memset(dsa_key, 0, sizeof(dsa_key));
643 #endif
644 #ifndef OPENSSL_NO_ECDSA
645     for (i = 0; i < EC_NUM; i++)
646         ecdsa[i] = NULL;
647 #endif
648 #ifndef OPENSSL_NO_ECDH
649     for (i = 0; i < EC_NUM; i++) {
650         ecdh_a[i] = NULL;
651         ecdh_b[i] = NULL;
652     }
653 #endif
654
655     if (bio_err == NULL)
656         if ((bio_err = BIO_new(BIO_s_file())) != NULL)
657             BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT);
658
659     if (!load_config(bio_err, NULL))
660         goto end;
661
662 #ifndef OPENSSL_NO_RSA
663     memset(rsa_key, 0, sizeof(rsa_key));
664     for (i = 0; i < RSA_NUM; i++)
665         rsa_key[i] = NULL;
666 #endif
667
668     if ((buf_malloc =
669          (unsigned char *)OPENSSL_malloc(BUFSIZE + misalign)) == NULL) {
670         BIO_printf(bio_err, "out of memory\n");
671         goto end;
672     }
673     if ((buf2_malloc =
674          (unsigned char *)OPENSSL_malloc(BUFSIZE + misalign)) == NULL) {
675         BIO_printf(bio_err, "out of memory\n");
676         goto end;
677     }
678
679     misalign = 0;               /* set later and buf/buf2 are adjusted
680                                  * accordingly */
681     buf = buf_malloc;
682     buf2 = buf2_malloc;
683
684     memset(c, 0, sizeof(c));
685     memset(DES_iv, 0, sizeof(DES_iv));
686     memset(iv, 0, sizeof(iv));
687
688     for (i = 0; i < ALGOR_NUM; i++)
689         doit[i] = 0;
690     for (i = 0; i < RSA_NUM; i++)
691         rsa_doit[i] = 0;
692     for (i = 0; i < DSA_NUM; i++)
693         dsa_doit[i] = 0;
694 #ifndef OPENSSL_NO_ECDSA
695     for (i = 0; i < EC_NUM; i++)
696         ecdsa_doit[i] = 0;
697 #endif
698 #ifndef OPENSSL_NO_ECDH
699     for (i = 0; i < EC_NUM; i++)
700         ecdh_doit[i] = 0;
701 #endif
702
703     j = 0;
704     argc--;
705     argv++;
706     while (argc) {
707         if ((argc > 0) && (strcmp(*argv, "-elapsed") == 0)) {
708             usertime = 0;
709             j--;                /* Otherwise, -elapsed gets confused with an
710                                  * algorithm. */
711         } else if ((argc > 0) && (strcmp(*argv, "-evp") == 0)) {
712             argc--;
713             argv++;
714             if (argc == 0) {
715                 BIO_printf(bio_err, "no EVP given\n");
716                 goto end;
717             }
718             evp_cipher = EVP_get_cipherbyname(*argv);
719             if (!evp_cipher) {
720                 evp_md = EVP_get_digestbyname(*argv);
721             }
722             if (!evp_cipher && !evp_md) {
723                 BIO_printf(bio_err, "%s is an unknown cipher or digest\n",
724                            *argv);
725                 goto end;
726             }
727             doit[D_EVP] = 1;
728         } else if (argc > 0 && !strcmp(*argv, "-decrypt")) {
729             decrypt = 1;
730             j--;                /* Otherwise, -elapsed gets confused with an
731                                  * algorithm. */
732         }
733 #ifndef OPENSSL_NO_ENGINE
734         else if ((argc > 0) && (strcmp(*argv, "-engine") == 0)) {
735             argc--;
736             argv++;
737             if (argc == 0) {
738                 BIO_printf(bio_err, "no engine given\n");
739                 goto end;
740             }
741             setup_engine(bio_err, *argv, 0);
742             /*
743              * j will be increased again further down.  We just don't want
744              * speed to confuse an engine with an algorithm, especially when
745              * none is given (which means all of them should be run)
746              */
747             j--;
748         }
749 #endif
750 #ifndef NO_FORK
751         else if ((argc > 0) && (strcmp(*argv, "-multi") == 0)) {
752             argc--;
753             argv++;
754             if (argc == 0) {
755                 BIO_printf(bio_err, "no multi count given\n");
756                 goto end;
757             }
758             multi = atoi(argv[0]);
759             if (multi <= 0) {
760                 BIO_printf(bio_err, "bad multi count\n");
761                 goto end;
762             }
763             j--;                /* Otherwise, -mr gets confused with an
764                                  * algorithm. */
765         }
766 #endif
767         else if (argc > 0 && !strcmp(*argv, "-mr")) {
768             mr = 1;
769             j--;                /* Otherwise, -mr gets confused with an
770                                  * algorithm. */
771         } else if (argc > 0 && !strcmp(*argv, "-mb")) {
772             multiblock = 1;
773             j--;
774         } else if (argc > 0 && !strcmp(*argv, "-misalign")) {
775             argc--;
776             argv++;
777             if (argc == 0) {
778                 BIO_printf(bio_err, "no misalignment given\n");
779                 goto end;
780             }
781             misalign = atoi(argv[0]);
782             if (misalign < 0 || misalign > MAX_MISALIGNMENT) {
783                 BIO_printf(bio_err,
784                            "misalignment is outsize permitted range 0-%d\n",
785                            MAX_MISALIGNMENT);
786                 goto end;
787             }
788             buf = buf_malloc + misalign;
789             buf2 = buf2_malloc + misalign;
790             j--;
791         } else
792 #ifndef OPENSSL_NO_MD2
793         if (strcmp(*argv, "md2") == 0)
794             doit[D_MD2] = 1;
795         else
796 #endif
797 #ifndef OPENSSL_NO_MDC2
798         if (strcmp(*argv, "mdc2") == 0)
799             doit[D_MDC2] = 1;
800         else
801 #endif
802 #ifndef OPENSSL_NO_MD4
803         if (strcmp(*argv, "md4") == 0)
804             doit[D_MD4] = 1;
805         else
806 #endif
807 #ifndef OPENSSL_NO_MD5
808         if (strcmp(*argv, "md5") == 0)
809             doit[D_MD5] = 1;
810         else
811 #endif
812 #ifndef OPENSSL_NO_MD5
813         if (strcmp(*argv, "hmac") == 0)
814             doit[D_HMAC] = 1;
815         else
816 #endif
817         if (strcmp(*argv, "sha1") == 0)
818             doit[D_SHA1] = 1;
819         else if (strcmp(*argv, "sha") == 0)
820             doit[D_SHA1] = 1, doit[D_SHA256] = 1, doit[D_SHA512] = 1;
821         else if (strcmp(*argv, "sha256") == 0)
822             doit[D_SHA256] = 1;
823         else if (strcmp(*argv, "sha512") == 0)
824             doit[D_SHA512] = 1;
825         else
826 #ifndef OPENSSL_NO_WHIRLPOOL
827         if (strcmp(*argv, "whirlpool") == 0)
828             doit[D_WHIRLPOOL] = 1;
829         else
830 #endif
831 #ifndef OPENSSL_NO_RMD160
832         if (strcmp(*argv, "ripemd") == 0)
833             doit[D_RMD160] = 1;
834         else if (strcmp(*argv, "rmd160") == 0)
835             doit[D_RMD160] = 1;
836         else if (strcmp(*argv, "ripemd160") == 0)
837             doit[D_RMD160] = 1;
838         else
839 #endif
840 #ifndef OPENSSL_NO_RC4
841         if (strcmp(*argv, "rc4") == 0)
842             doit[D_RC4] = 1;
843         else
844 #endif
845 #ifndef OPENSSL_NO_DES
846         if (strcmp(*argv, "des-cbc") == 0)
847             doit[D_CBC_DES] = 1;
848         else if (strcmp(*argv, "des-ede3") == 0)
849             doit[D_EDE3_DES] = 1;
850         else
851 #endif
852 #ifndef OPENSSL_NO_AES
853         if (strcmp(*argv, "aes-128-cbc") == 0)
854             doit[D_CBC_128_AES] = 1;
855         else if (strcmp(*argv, "aes-192-cbc") == 0)
856             doit[D_CBC_192_AES] = 1;
857         else if (strcmp(*argv, "aes-256-cbc") == 0)
858             doit[D_CBC_256_AES] = 1;
859         else if (strcmp(*argv, "aes-128-ige") == 0)
860             doit[D_IGE_128_AES] = 1;
861         else if (strcmp(*argv, "aes-192-ige") == 0)
862             doit[D_IGE_192_AES] = 1;
863         else if (strcmp(*argv, "aes-256-ige") == 0)
864             doit[D_IGE_256_AES] = 1;
865         else
866 #endif
867 #ifndef OPENSSL_NO_CAMELLIA
868         if (strcmp(*argv, "camellia-128-cbc") == 0)
869             doit[D_CBC_128_CML] = 1;
870         else if (strcmp(*argv, "camellia-192-cbc") == 0)
871             doit[D_CBC_192_CML] = 1;
872         else if (strcmp(*argv, "camellia-256-cbc") == 0)
873             doit[D_CBC_256_CML] = 1;
874         else
875 #endif
876 #ifndef OPENSSL_NO_RSA
877 # if 0                         /* was: #ifdef RSAref */
878         if (strcmp(*argv, "rsaref") == 0) {
879             RSA_set_default_openssl_method(RSA_PKCS1_RSAref());
880             j--;
881         } else
882 # endif
883 # ifndef RSA_NULL
884         if (strcmp(*argv, "openssl") == 0) {
885             RSA_set_default_method(RSA_PKCS1_SSLeay());
886             j--;
887         } else
888 # endif
889 #endif                         /* !OPENSSL_NO_RSA */
890         if (strcmp(*argv, "dsa512") == 0)
891             dsa_doit[R_DSA_512] = 2;
892         else if (strcmp(*argv, "dsa1024") == 0)
893             dsa_doit[R_DSA_1024] = 2;
894         else if (strcmp(*argv, "dsa2048") == 0)
895             dsa_doit[R_DSA_2048] = 2;
896         else if (strcmp(*argv, "rsa512") == 0)
897             rsa_doit[R_RSA_512] = 2;
898         else if (strcmp(*argv, "rsa1024") == 0)
899             rsa_doit[R_RSA_1024] = 2;
900         else if (strcmp(*argv, "rsa2048") == 0)
901             rsa_doit[R_RSA_2048] = 2;
902         else if (strcmp(*argv, "rsa3072") == 0)
903             rsa_doit[R_RSA_3072] = 2;
904         else if (strcmp(*argv, "rsa4096") == 0)
905             rsa_doit[R_RSA_4096] = 2;
906         else if (strcmp(*argv, "rsa7680") == 0)
907             rsa_doit[R_RSA_7680] = 2;
908         else if (strcmp(*argv, "rsa15360") == 0)
909             rsa_doit[R_RSA_15360] = 2;
910         else
911 #ifndef OPENSSL_NO_RC2
912         if (strcmp(*argv, "rc2-cbc") == 0)
913             doit[D_CBC_RC2] = 1;
914         else if (strcmp(*argv, "rc2") == 0)
915             doit[D_CBC_RC2] = 1;
916         else
917 #endif
918 #ifndef OPENSSL_NO_RC5
919         if (strcmp(*argv, "rc5-cbc") == 0)
920             doit[D_CBC_RC5] = 1;
921         else if (strcmp(*argv, "rc5") == 0)
922             doit[D_CBC_RC5] = 1;
923         else
924 #endif
925 #ifndef OPENSSL_NO_IDEA
926         if (strcmp(*argv, "idea-cbc") == 0)
927             doit[D_CBC_IDEA] = 1;
928         else if (strcmp(*argv, "idea") == 0)
929             doit[D_CBC_IDEA] = 1;
930         else
931 #endif
932 #ifndef OPENSSL_NO_SEED
933         if (strcmp(*argv, "seed-cbc") == 0)
934             doit[D_CBC_SEED] = 1;
935         else if (strcmp(*argv, "seed") == 0)
936             doit[D_CBC_SEED] = 1;
937         else
938 #endif
939 #ifndef OPENSSL_NO_BF
940         if (strcmp(*argv, "bf-cbc") == 0)
941             doit[D_CBC_BF] = 1;
942         else if (strcmp(*argv, "blowfish") == 0)
943             doit[D_CBC_BF] = 1;
944         else if (strcmp(*argv, "bf") == 0)
945             doit[D_CBC_BF] = 1;
946         else
947 #endif
948 #ifndef OPENSSL_NO_CAST
949         if (strcmp(*argv, "cast-cbc") == 0)
950             doit[D_CBC_CAST] = 1;
951         else if (strcmp(*argv, "cast") == 0)
952             doit[D_CBC_CAST] = 1;
953         else if (strcmp(*argv, "cast5") == 0)
954             doit[D_CBC_CAST] = 1;
955         else
956 #endif
957 #ifndef OPENSSL_NO_DES
958         if (strcmp(*argv, "des") == 0) {
959             doit[D_CBC_DES] = 1;
960             doit[D_EDE3_DES] = 1;
961         } else
962 #endif
963 #ifndef OPENSSL_NO_AES
964         if (strcmp(*argv, "aes") == 0) {
965             doit[D_CBC_128_AES] = 1;
966             doit[D_CBC_192_AES] = 1;
967             doit[D_CBC_256_AES] = 1;
968         } else if (strcmp(*argv, "ghash") == 0) {
969             doit[D_GHASH] = 1;
970         } else
971 #endif
972 #ifndef OPENSSL_NO_CAMELLIA
973         if (strcmp(*argv, "camellia") == 0) {
974             doit[D_CBC_128_CML] = 1;
975             doit[D_CBC_192_CML] = 1;
976             doit[D_CBC_256_CML] = 1;
977         } else
978 #endif
979 #ifndef OPENSSL_NO_RSA
980         if (strcmp(*argv, "rsa") == 0) {
981             rsa_doit[R_RSA_512] = 1;
982             rsa_doit[R_RSA_1024] = 1;
983             rsa_doit[R_RSA_2048] = 1;
984             rsa_doit[R_RSA_3072] = 1;
985             rsa_doit[R_RSA_4096] = 1;
986             rsa_doit[R_RSA_7680] = 1;
987             rsa_doit[R_RSA_15360] = 1;
988         } else
989 #endif
990 #ifndef OPENSSL_NO_DSA
991         if (strcmp(*argv, "dsa") == 0) {
992             dsa_doit[R_DSA_512] = 1;
993             dsa_doit[R_DSA_1024] = 1;
994             dsa_doit[R_DSA_2048] = 1;
995         } else
996 #endif
997 #ifndef OPENSSL_NO_ECDSA
998         if (strcmp(*argv, "ecdsap160") == 0)
999             ecdsa_doit[R_EC_P160] = 2;
1000         else if (strcmp(*argv, "ecdsap192") == 0)
1001             ecdsa_doit[R_EC_P192] = 2;
1002         else if (strcmp(*argv, "ecdsap224") == 0)
1003             ecdsa_doit[R_EC_P224] = 2;
1004         else if (strcmp(*argv, "ecdsap256") == 0)
1005             ecdsa_doit[R_EC_P256] = 2;
1006         else if (strcmp(*argv, "ecdsap384") == 0)
1007             ecdsa_doit[R_EC_P384] = 2;
1008         else if (strcmp(*argv, "ecdsap521") == 0)
1009             ecdsa_doit[R_EC_P521] = 2;
1010         else if (strcmp(*argv, "ecdsak163") == 0)
1011             ecdsa_doit[R_EC_K163] = 2;
1012         else if (strcmp(*argv, "ecdsak233") == 0)
1013             ecdsa_doit[R_EC_K233] = 2;
1014         else if (strcmp(*argv, "ecdsak283") == 0)
1015             ecdsa_doit[R_EC_K283] = 2;
1016         else if (strcmp(*argv, "ecdsak409") == 0)
1017             ecdsa_doit[R_EC_K409] = 2;
1018         else if (strcmp(*argv, "ecdsak571") == 0)
1019             ecdsa_doit[R_EC_K571] = 2;
1020         else if (strcmp(*argv, "ecdsab163") == 0)
1021             ecdsa_doit[R_EC_B163] = 2;
1022         else if (strcmp(*argv, "ecdsab233") == 0)
1023             ecdsa_doit[R_EC_B233] = 2;
1024         else if (strcmp(*argv, "ecdsab283") == 0)
1025             ecdsa_doit[R_EC_B283] = 2;
1026         else if (strcmp(*argv, "ecdsab409") == 0)
1027             ecdsa_doit[R_EC_B409] = 2;
1028         else if (strcmp(*argv, "ecdsab571") == 0)
1029             ecdsa_doit[R_EC_B571] = 2;
1030         else if (strcmp(*argv, "ecdsa") == 0) {
1031             for (i = 0; i < EC_NUM; i++)
1032                 ecdsa_doit[i] = 1;
1033         } else
1034 #endif
1035 #ifndef OPENSSL_NO_ECDH
1036         if (strcmp(*argv, "ecdhp160") == 0)
1037             ecdh_doit[R_EC_P160] = 2;
1038         else if (strcmp(*argv, "ecdhp192") == 0)
1039             ecdh_doit[R_EC_P192] = 2;
1040         else if (strcmp(*argv, "ecdhp224") == 0)
1041             ecdh_doit[R_EC_P224] = 2;
1042         else if (strcmp(*argv, "ecdhp256") == 0)
1043             ecdh_doit[R_EC_P256] = 2;
1044         else if (strcmp(*argv, "ecdhp384") == 0)
1045             ecdh_doit[R_EC_P384] = 2;
1046         else if (strcmp(*argv, "ecdhp521") == 0)
1047             ecdh_doit[R_EC_P521] = 2;
1048         else if (strcmp(*argv, "ecdhk163") == 0)
1049             ecdh_doit[R_EC_K163] = 2;
1050         else if (strcmp(*argv, "ecdhk233") == 0)
1051             ecdh_doit[R_EC_K233] = 2;
1052         else if (strcmp(*argv, "ecdhk283") == 0)
1053             ecdh_doit[R_EC_K283] = 2;
1054         else if (strcmp(*argv, "ecdhk409") == 0)
1055             ecdh_doit[R_EC_K409] = 2;
1056         else if (strcmp(*argv, "ecdhk571") == 0)
1057             ecdh_doit[R_EC_K571] = 2;
1058         else if (strcmp(*argv, "ecdhb163") == 0)
1059             ecdh_doit[R_EC_B163] = 2;
1060         else if (strcmp(*argv, "ecdhb233") == 0)
1061             ecdh_doit[R_EC_B233] = 2;
1062         else if (strcmp(*argv, "ecdhb283") == 0)
1063             ecdh_doit[R_EC_B283] = 2;
1064         else if (strcmp(*argv, "ecdhb409") == 0)
1065             ecdh_doit[R_EC_B409] = 2;
1066         else if (strcmp(*argv, "ecdhb571") == 0)
1067             ecdh_doit[R_EC_B571] = 2;
1068         else if (strcmp(*argv, "ecdh") == 0) {
1069             for (i = 0; i < EC_NUM; i++)
1070                 ecdh_doit[i] = 1;
1071         } else
1072 #endif
1073         {
1074             BIO_printf(bio_err, "Error: bad option or value\n");
1075             BIO_printf(bio_err, "\n");
1076             BIO_printf(bio_err, "Available values:\n");
1077 #ifndef OPENSSL_NO_MD2
1078             BIO_printf(bio_err, "md2      ");
1079 #endif
1080 #ifndef OPENSSL_NO_MDC2
1081             BIO_printf(bio_err, "mdc2     ");
1082 #endif
1083 #ifndef OPENSSL_NO_MD4
1084             BIO_printf(bio_err, "md4      ");
1085 #endif
1086 #ifndef OPENSSL_NO_MD5
1087             BIO_printf(bio_err, "md5      ");
1088 # ifndef OPENSSL_NO_HMAC
1089             BIO_printf(bio_err, "hmac     ");
1090 # endif
1091 #endif
1092             BIO_printf(bio_err, "sha1     ");
1093             BIO_printf(bio_err, "sha256   ");
1094             BIO_printf(bio_err, "sha512   ");
1095 #ifndef OPENSSL_NO_WHIRLPOOL
1096             BIO_printf(bio_err, "whirlpool");
1097 #endif
1098 #ifndef OPENSSL_NO_RMD160
1099             BIO_printf(bio_err, "rmd160");
1100 #endif
1101             BIO_printf(bio_err, "\n");
1102
1103 #ifndef OPENSSL_NO_IDEA
1104             BIO_printf(bio_err, "idea-cbc ");
1105 #endif
1106 #ifndef OPENSSL_NO_SEED
1107             BIO_printf(bio_err, "seed-cbc ");
1108 #endif
1109 #ifndef OPENSSL_NO_RC2
1110             BIO_printf(bio_err, "rc2-cbc  ");
1111 #endif
1112 #ifndef OPENSSL_NO_RC5
1113             BIO_printf(bio_err, "rc5-cbc  ");
1114 #endif
1115 #ifndef OPENSSL_NO_BF
1116             BIO_printf(bio_err, "bf-cbc");
1117 #endif
1118 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || !defined(OPENSSL_NO_RC2) || \
1119     !defined(OPENSSL_NO_BF) || !defined(OPENSSL_NO_RC5)
1120             BIO_printf(bio_err, "\n");
1121 #endif
1122 #ifndef OPENSSL_NO_DES
1123             BIO_printf(bio_err, "des-cbc  des-ede3 ");
1124 #endif
1125 #ifndef OPENSSL_NO_AES
1126             BIO_printf(bio_err, "aes-128-cbc aes-192-cbc aes-256-cbc ");
1127             BIO_printf(bio_err, "aes-128-ige aes-192-ige aes-256-ige ");
1128 #endif
1129 #ifndef OPENSSL_NO_CAMELLIA
1130             BIO_printf(bio_err, "\n");
1131             BIO_printf(bio_err,
1132                        "camellia-128-cbc camellia-192-cbc camellia-256-cbc ");
1133 #endif
1134 #ifndef OPENSSL_NO_RC4
1135             BIO_printf(bio_err, "rc4");
1136 #endif
1137             BIO_printf(bio_err, "\n");
1138
1139 #ifndef OPENSSL_NO_RSA
1140             BIO_printf(bio_err,
1141                        "rsa512   rsa1024  rsa2048  rsa3072  rsa4096\n");
1142             BIO_printf(bio_err, "rsa7680  rsa15360\n");
1143 #endif
1144
1145 #ifndef OPENSSL_NO_DSA
1146             BIO_printf(bio_err, "dsa512   dsa1024  dsa2048\n");
1147 #endif
1148 #ifndef OPENSSL_NO_ECDSA
1149             BIO_printf(bio_err, "ecdsap160 ecdsap192 ecdsap224 "
1150                        "ecdsap256 ecdsap384 ecdsap521\n");
1151             BIO_printf(bio_err,
1152                        "ecdsak163 ecdsak233 ecdsak283 ecdsak409 ecdsak571\n");
1153             BIO_printf(bio_err,
1154                        "ecdsab163 ecdsab233 ecdsab283 ecdsab409 ecdsab571\n");
1155             BIO_printf(bio_err, "ecdsa\n");
1156 #endif
1157 #ifndef OPENSSL_NO_ECDH
1158             BIO_printf(bio_err, "ecdhp160  ecdhp192  ecdhp224 "
1159                        "ecdhp256  ecdhp384  ecdhp521\n");
1160             BIO_printf(bio_err,
1161                        "ecdhk163  ecdhk233  ecdhk283  ecdhk409  ecdhk571\n");
1162             BIO_printf(bio_err,
1163                        "ecdhb163  ecdhb233  ecdhb283  ecdhb409  ecdhb571\n");
1164             BIO_printf(bio_err, "ecdh\n");
1165 #endif
1166
1167 #ifndef OPENSSL_NO_IDEA
1168             BIO_printf(bio_err, "idea     ");
1169 #endif
1170 #ifndef OPENSSL_NO_SEED
1171             BIO_printf(bio_err, "seed     ");
1172 #endif
1173 #ifndef OPENSSL_NO_RC2
1174             BIO_printf(bio_err, "rc2      ");
1175 #endif
1176 #ifndef OPENSSL_NO_DES
1177             BIO_printf(bio_err, "des      ");
1178 #endif
1179 #ifndef OPENSSL_NO_AES
1180             BIO_printf(bio_err, "aes      ");
1181 #endif
1182 #ifndef OPENSSL_NO_CAMELLIA
1183             BIO_printf(bio_err, "camellia ");
1184 #endif
1185 #ifndef OPENSSL_NO_RSA
1186             BIO_printf(bio_err, "rsa      ");
1187 #endif
1188 #ifndef OPENSSL_NO_BF
1189             BIO_printf(bio_err, "blowfish");
1190 #endif
1191 #if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || \
1192     !defined(OPENSSL_NO_RC2) || !defined(OPENSSL_NO_DES) || \
1193     !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_BF) || \
1194     !defined(OPENSSL_NO_AES) || !defined(OPENSSL_NO_CAMELLIA)
1195             BIO_printf(bio_err, "\n");
1196 #endif
1197
1198             BIO_printf(bio_err, "\n");
1199             BIO_printf(bio_err, "Available options:\n");
1200 #if defined(TIMES) || defined(USE_TOD)
1201             BIO_printf(bio_err, "-elapsed        "
1202                        "measure time in real time instead of CPU user time.\n");
1203 #endif
1204 #ifndef OPENSSL_NO_ENGINE
1205             BIO_printf(bio_err,
1206                        "-engine e       "
1207                        "use engine e, possibly a hardware device.\n");
1208 #endif
1209             BIO_printf(bio_err, "-evp e          " "use EVP e.\n");
1210             BIO_printf(bio_err,
1211                        "-decrypt        "
1212                        "time decryption instead of encryption (only EVP).\n");
1213             BIO_printf(bio_err,
1214                        "-mr             "
1215                        "produce machine readable output.\n");
1216             BIO_printf(bio_err,
1217                        "-mb             "
1218                        "perform multi-block benchmark (for specific ciphers)\n");
1219             BIO_printf(bio_err,
1220                        "-misalign n     "
1221                        "perform benchmark with misaligned data\n");
1222 #ifndef NO_FORK
1223             BIO_printf(bio_err,
1224                        "-multi n        " "run n benchmarks in parallel.\n");
1225 #endif
1226             goto end;
1227         }
1228         argc--;
1229         argv++;
1230         j++;
1231     }
1232
1233 #ifndef NO_FORK
1234     if (multi && do_multi(multi))
1235         goto show_res;
1236 #endif
1237
1238     if (j == 0) {
1239         for (i = 0; i < ALGOR_NUM; i++) {
1240             if (i != D_EVP)
1241                 doit[i] = 1;
1242         }
1243         for (i = 0; i < RSA_NUM; i++)
1244             rsa_doit[i] = 1;
1245         for (i = 0; i < DSA_NUM; i++)
1246             dsa_doit[i] = 1;
1247 #ifndef OPENSSL_NO_ECDSA
1248         for (i = 0; i < EC_NUM; i++)
1249             ecdsa_doit[i] = 1;
1250 #endif
1251 #ifndef OPENSSL_NO_ECDH
1252         for (i = 0; i < EC_NUM; i++)
1253             ecdh_doit[i] = 1;
1254 #endif
1255     }
1256     for (i = 0; i < ALGOR_NUM; i++)
1257         if (doit[i])
1258             pr_header++;
1259
1260     if (usertime == 0 && !mr)
1261         BIO_printf(bio_err,
1262                    "You have chosen to measure elapsed time "
1263                    "instead of user CPU time.\n");
1264
1265 #ifndef OPENSSL_NO_RSA
1266     for (i = 0; i < RSA_NUM; i++) {
1267         const unsigned char *p;
1268
1269         p = rsa_data[i];
1270         rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
1271         if (rsa_key[i] == NULL) {
1272             BIO_printf(bio_err, "internal error loading RSA key number %d\n",
1273                        i);
1274             goto end;
1275         }
1276 # if 0
1277         else {
1278             BIO_printf(bio_err,
1279                        mr ? "+RK:%d:"
1280                        : "Loaded RSA key, %d bit modulus and e= 0x",
1281                        BN_num_bits(rsa_key[i]->n));
1282             BN_print(bio_err, rsa_key[i]->e);
1283             BIO_printf(bio_err, "\n");
1284         }
1285 # endif
1286     }
1287 #endif
1288
1289 #ifndef OPENSSL_NO_DSA
1290     dsa_key[0] = get_dsa512();
1291     dsa_key[1] = get_dsa1024();
1292     dsa_key[2] = get_dsa2048();
1293 #endif
1294
1295 #ifndef OPENSSL_NO_DES
1296     DES_set_key_unchecked(&key, &sch);
1297     DES_set_key_unchecked(&key2, &sch2);
1298     DES_set_key_unchecked(&key3, &sch3);
1299 #endif
1300 #ifndef OPENSSL_NO_AES
1301     AES_set_encrypt_key(key16, 128, &aes_ks1);
1302     AES_set_encrypt_key(key24, 192, &aes_ks2);
1303     AES_set_encrypt_key(key32, 256, &aes_ks3);
1304 #endif
1305 #ifndef OPENSSL_NO_CAMELLIA
1306     Camellia_set_key(key16, 128, &camellia_ks1);
1307     Camellia_set_key(ckey24, 192, &camellia_ks2);
1308     Camellia_set_key(ckey32, 256, &camellia_ks3);
1309 #endif
1310 #ifndef OPENSSL_NO_IDEA
1311     idea_set_encrypt_key(key16, &idea_ks);
1312 #endif
1313 #ifndef OPENSSL_NO_SEED
1314     SEED_set_key(key16, &seed_ks);
1315 #endif
1316 #ifndef OPENSSL_NO_RC4
1317     RC4_set_key(&rc4_ks, 16, key16);
1318 #endif
1319 #ifndef OPENSSL_NO_RC2
1320     RC2_set_key(&rc2_ks, 16, key16, 128);
1321 #endif
1322 #ifndef OPENSSL_NO_RC5
1323     RC5_32_set_key(&rc5_ks, 16, key16, 12);
1324 #endif
1325 #ifndef OPENSSL_NO_BF
1326     BF_set_key(&bf_ks, 16, key16);
1327 #endif
1328 #ifndef OPENSSL_NO_CAST
1329     CAST_set_key(&cast_ks, 16, key16);
1330 #endif
1331 #ifndef OPENSSL_NO_RSA
1332     memset(rsa_c, 0, sizeof(rsa_c));
1333 #endif
1334 #ifndef SIGALRM
1335 # ifndef OPENSSL_NO_DES
1336     BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
1337     count = 10;
1338     do {
1339         long it;
1340         count *= 2;
1341         Time_F(START);
1342         for (it = count; it; it--)
1343             DES_ecb_encrypt((DES_cblock *)buf,
1344                             (DES_cblock *)buf, &sch, DES_ENCRYPT);
1345         d = Time_F(STOP);
1346     } while (d < 3);
1347     save_count = count;
1348     c[D_MD2][0] = count / 10;
1349     c[D_MDC2][0] = count / 10;
1350     c[D_MD4][0] = count;
1351     c[D_MD5][0] = count;
1352     c[D_HMAC][0] = count;
1353     c[D_SHA1][0] = count;
1354     c[D_RMD160][0] = count;
1355     c[D_RC4][0] = count * 5;
1356     c[D_CBC_DES][0] = count;
1357     c[D_EDE3_DES][0] = count / 3;
1358     c[D_CBC_IDEA][0] = count;
1359     c[D_CBC_SEED][0] = count;
1360     c[D_CBC_RC2][0] = count;
1361     c[D_CBC_RC5][0] = count;
1362     c[D_CBC_BF][0] = count;
1363     c[D_CBC_CAST][0] = count;
1364     c[D_CBC_128_AES][0] = count;
1365     c[D_CBC_192_AES][0] = count;
1366     c[D_CBC_256_AES][0] = count;
1367     c[D_CBC_128_CML][0] = count;
1368     c[D_CBC_192_CML][0] = count;
1369     c[D_CBC_256_CML][0] = count;
1370     c[D_SHA256][0] = count;
1371     c[D_SHA512][0] = count;
1372     c[D_WHIRLPOOL][0] = count;
1373     c[D_IGE_128_AES][0] = count;
1374     c[D_IGE_192_AES][0] = count;
1375     c[D_IGE_256_AES][0] = count;
1376     c[D_GHASH][0] = count;
1377
1378     for (i = 1; i < SIZE_NUM; i++) {
1379         long l0, l1;
1380
1381         l0 = (long)lengths[0];
1382         l1 = (long)lengths[i];
1383
1384         c[D_MD2][i] = c[D_MD2][0] * 4 * l0 / l1;
1385         c[D_MDC2][i] = c[D_MDC2][0] * 4 * l0 / l1;
1386         c[D_MD4][i] = c[D_MD4][0] * 4 * l0 / l1;
1387         c[D_MD5][i] = c[D_MD5][0] * 4 * l0 / l1;
1388         c[D_HMAC][i] = c[D_HMAC][0] * 4 * l0 / l1;
1389         c[D_SHA1][i] = c[D_SHA1][0] * 4 * l0 / l1;
1390         c[D_RMD160][i] = c[D_RMD160][0] * 4 * l0 / l1;
1391         c[D_SHA256][i] = c[D_SHA256][0] * 4 * l0 / l1;
1392         c[D_SHA512][i] = c[D_SHA512][0] * 4 * l0 / l1;
1393         c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * l0 / l1;
1394
1395         l0 = (long)lengths[i - 1];
1396
1397         c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
1398         c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
1399         c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
1400         c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
1401         c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
1402         c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
1403         c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
1404         c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
1405         c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
1406         c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
1407         c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
1408         c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
1409         c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
1410         c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
1411         c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
1412         c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
1413         c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
1414         c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
1415     }
1416
1417 #  ifndef OPENSSL_NO_RSA
1418     rsa_c[R_RSA_512][0] = count / 2000;
1419     rsa_c[R_RSA_512][1] = count / 400;
1420     for (i = 1; i < RSA_NUM; i++) {
1421         rsa_c[i][0] = rsa_c[i - 1][0] / 8;
1422         rsa_c[i][1] = rsa_c[i - 1][1] / 4;
1423         if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
1424             rsa_doit[i] = 0;
1425         else {
1426             if (rsa_c[i][0] == 0) {
1427                 rsa_c[i][0] = 1;
1428                 rsa_c[i][1] = 20;
1429             }
1430         }
1431     }
1432 #  endif
1433
1434 #  ifndef OPENSSL_NO_DSA
1435     dsa_c[R_DSA_512][0] = count / 1000;
1436     dsa_c[R_DSA_512][1] = count / 1000 / 2;
1437     for (i = 1; i < DSA_NUM; i++) {
1438         dsa_c[i][0] = dsa_c[i - 1][0] / 4;
1439         dsa_c[i][1] = dsa_c[i - 1][1] / 4;
1440         if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
1441             dsa_doit[i] = 0;
1442         else {
1443             if (dsa_c[i] == 0) {
1444                 dsa_c[i][0] = 1;
1445                 dsa_c[i][1] = 1;
1446             }
1447         }
1448     }
1449 #  endif
1450
1451 #  ifndef OPENSSL_NO_ECDSA
1452     ecdsa_c[R_EC_P160][0] = count / 1000;
1453     ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
1454     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1455         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1456         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1457         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1458             ecdsa_doit[i] = 0;
1459         else {
1460             if (ecdsa_c[i] == 0) {
1461                 ecdsa_c[i][0] = 1;
1462                 ecdsa_c[i][1] = 1;
1463             }
1464         }
1465     }
1466     ecdsa_c[R_EC_K163][0] = count / 1000;
1467     ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
1468     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1469         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1470         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1471         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1472             ecdsa_doit[i] = 0;
1473         else {
1474             if (ecdsa_c[i] == 0) {
1475                 ecdsa_c[i][0] = 1;
1476                 ecdsa_c[i][1] = 1;
1477             }
1478         }
1479     }
1480     ecdsa_c[R_EC_B163][0] = count / 1000;
1481     ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
1482     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1483         ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
1484         ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
1485         if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
1486             ecdsa_doit[i] = 0;
1487         else {
1488             if (ecdsa_c[i] == 0) {
1489                 ecdsa_c[i][0] = 1;
1490                 ecdsa_c[i][1] = 1;
1491             }
1492         }
1493     }
1494 #  endif
1495
1496 #  ifndef OPENSSL_NO_ECDH
1497     ecdh_c[R_EC_P160][0] = count / 1000;
1498     ecdh_c[R_EC_P160][1] = count / 1000;
1499     for (i = R_EC_P192; i <= R_EC_P521; i++) {
1500         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1501         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1502         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1503             ecdh_doit[i] = 0;
1504         else {
1505             if (ecdh_c[i] == 0) {
1506                 ecdh_c[i][0] = 1;
1507                 ecdh_c[i][1] = 1;
1508             }
1509         }
1510     }
1511     ecdh_c[R_EC_K163][0] = count / 1000;
1512     ecdh_c[R_EC_K163][1] = count / 1000;
1513     for (i = R_EC_K233; i <= R_EC_K571; i++) {
1514         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1515         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1516         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1517             ecdh_doit[i] = 0;
1518         else {
1519             if (ecdh_c[i] == 0) {
1520                 ecdh_c[i][0] = 1;
1521                 ecdh_c[i][1] = 1;
1522             }
1523         }
1524     }
1525     ecdh_c[R_EC_B163][0] = count / 1000;
1526     ecdh_c[R_EC_B163][1] = count / 1000;
1527     for (i = R_EC_B233; i <= R_EC_B571; i++) {
1528         ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
1529         ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
1530         if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
1531             ecdh_doit[i] = 0;
1532         else {
1533             if (ecdh_c[i] == 0) {
1534                 ecdh_c[i][0] = 1;
1535                 ecdh_c[i][1] = 1;
1536             }
1537         }
1538     }
1539 #  endif
1540
1541 #  define COND(d) (count < (d))
1542 #  define COUNT(d) (d)
1543 # else
1544 /* not worth fixing */
1545 #  error "You cannot disable DES on systems without SIGALRM."
1546 # endif                        /* OPENSSL_NO_DES */
1547 #else
1548 # define COND(c) (run && count<0x7fffffff)
1549 # define COUNT(d) (count)
1550 # ifndef _WIN32
1551     signal(SIGALRM, sig_done);
1552 # endif
1553 #endif                         /* SIGALRM */
1554
1555 #ifndef OPENSSL_NO_MD2
1556     if (doit[D_MD2]) {
1557         for (j = 0; j < SIZE_NUM; j++) {
1558             print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
1559             Time_F(START);
1560             for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
1561                 EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
1562                            EVP_md2(), NULL);
1563             d = Time_F(STOP);
1564             print_result(D_MD2, j, count, d);
1565         }
1566     }
1567 #endif
1568 #ifndef OPENSSL_NO_MDC2
1569     if (doit[D_MDC2]) {
1570         for (j = 0; j < SIZE_NUM; j++) {
1571             print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
1572             Time_F(START);
1573             for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
1574                 EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
1575                            EVP_mdc2(), NULL);
1576             d = Time_F(STOP);
1577             print_result(D_MDC2, j, count, d);
1578         }
1579     }
1580 #endif
1581
1582 #ifndef OPENSSL_NO_MD4
1583     if (doit[D_MD4]) {
1584         for (j = 0; j < SIZE_NUM; j++) {
1585             print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
1586             Time_F(START);
1587             for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
1588                 EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
1589                            NULL, EVP_md4(), NULL);
1590             d = Time_F(STOP);
1591             print_result(D_MD4, j, count, d);
1592         }
1593     }
1594 #endif
1595
1596 #ifndef OPENSSL_NO_MD5
1597     if (doit[D_MD5]) {
1598         for (j = 0; j < SIZE_NUM; j++) {
1599             print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
1600             Time_F(START);
1601             for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
1602                 MD5(buf, lengths[j], md5);
1603             d = Time_F(STOP);
1604             print_result(D_MD5, j, count, d);
1605         }
1606     }
1607 #endif
1608
1609 #if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC)
1610     if (doit[D_HMAC]) {
1611         HMAC_CTX hctx;
1612
1613         HMAC_CTX_init(&hctx);
1614         HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
1615                      16, EVP_md5(), NULL);
1616
1617         for (j = 0; j < SIZE_NUM; j++) {
1618             print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
1619             Time_F(START);
1620             for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
1621                 HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
1622                 HMAC_Update(&hctx, buf, lengths[j]);
1623                 HMAC_Final(&hctx, &(hmac[0]), NULL);
1624             }
1625             d = Time_F(STOP);
1626             print_result(D_HMAC, j, count, d);
1627         }
1628         HMAC_CTX_cleanup(&hctx);
1629     }
1630 #endif
1631     if (doit[D_SHA1]) {
1632         for (j = 0; j < SIZE_NUM; j++) {
1633             print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
1634             Time_F(START);
1635             for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
1636                 SHA1(buf, lengths[j], sha);
1637             d = Time_F(STOP);
1638             print_result(D_SHA1, j, count, d);
1639         }
1640     }
1641     if (doit[D_SHA256]) {
1642         for (j = 0; j < SIZE_NUM; j++) {
1643             print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
1644             Time_F(START);
1645             for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
1646                 SHA256(buf, lengths[j], sha256);
1647             d = Time_F(STOP);
1648             print_result(D_SHA256, j, count, d);
1649         }
1650     }
1651     if (doit[D_SHA512]) {
1652         for (j = 0; j < SIZE_NUM; j++) {
1653             print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
1654             Time_F(START);
1655             for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
1656                 SHA512(buf, lengths[j], sha512);
1657             d = Time_F(STOP);
1658             print_result(D_SHA512, j, count, d);
1659         }
1660     }
1661
1662 #ifndef OPENSSL_NO_WHIRLPOOL
1663     if (doit[D_WHIRLPOOL]) {
1664         for (j = 0; j < SIZE_NUM; j++) {
1665             print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
1666             Time_F(START);
1667             for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
1668                 WHIRLPOOL(buf, lengths[j], whirlpool);
1669             d = Time_F(STOP);
1670             print_result(D_WHIRLPOOL, j, count, d);
1671         }
1672     }
1673 #endif
1674
1675 #ifndef OPENSSL_NO_RMD160
1676     if (doit[D_RMD160]) {
1677         for (j = 0; j < SIZE_NUM; j++) {
1678             print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
1679             Time_F(START);
1680             for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
1681                 EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
1682                            EVP_ripemd160(), NULL);
1683             d = Time_F(STOP);
1684             print_result(D_RMD160, j, count, d);
1685         }
1686     }
1687 #endif
1688 #ifndef OPENSSL_NO_RC4
1689     if (doit[D_RC4]) {
1690         for (j = 0; j < SIZE_NUM; j++) {
1691             print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
1692             Time_F(START);
1693             for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
1694                 RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
1695             d = Time_F(STOP);
1696             print_result(D_RC4, j, count, d);
1697         }
1698     }
1699 #endif
1700 #ifndef OPENSSL_NO_DES
1701     if (doit[D_CBC_DES]) {
1702         for (j = 0; j < SIZE_NUM; j++) {
1703             print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
1704             Time_F(START);
1705             for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
1706                 DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
1707                                  &DES_iv, DES_ENCRYPT);
1708             d = Time_F(STOP);
1709             print_result(D_CBC_DES, j, count, d);
1710         }
1711     }
1712
1713     if (doit[D_EDE3_DES]) {
1714         for (j = 0; j < SIZE_NUM; j++) {
1715             print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
1716             Time_F(START);
1717             for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
1718                 DES_ede3_cbc_encrypt(buf, buf, lengths[j],
1719                                      &sch, &sch2, &sch3,
1720                                      &DES_iv, DES_ENCRYPT);
1721             d = Time_F(STOP);
1722             print_result(D_EDE3_DES, j, count, d);
1723         }
1724     }
1725 #endif
1726 #ifndef OPENSSL_NO_AES
1727     if (doit[D_CBC_128_AES]) {
1728         for (j = 0; j < SIZE_NUM; j++) {
1729             print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
1730                           lengths[j]);
1731             Time_F(START);
1732             for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
1733                 AES_cbc_encrypt(buf, buf,
1734                                 (unsigned long)lengths[j], &aes_ks1,
1735                                 iv, AES_ENCRYPT);
1736             d = Time_F(STOP);
1737             print_result(D_CBC_128_AES, j, count, d);
1738         }
1739     }
1740     if (doit[D_CBC_192_AES]) {
1741         for (j = 0; j < SIZE_NUM; j++) {
1742             print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
1743                           lengths[j]);
1744             Time_F(START);
1745             for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
1746                 AES_cbc_encrypt(buf, buf,
1747                                 (unsigned long)lengths[j], &aes_ks2,
1748                                 iv, AES_ENCRYPT);
1749             d = Time_F(STOP);
1750             print_result(D_CBC_192_AES, j, count, d);
1751         }
1752     }
1753     if (doit[D_CBC_256_AES]) {
1754         for (j = 0; j < SIZE_NUM; j++) {
1755             print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
1756                           lengths[j]);
1757             Time_F(START);
1758             for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
1759                 AES_cbc_encrypt(buf, buf,
1760                                 (unsigned long)lengths[j], &aes_ks3,
1761                                 iv, AES_ENCRYPT);
1762             d = Time_F(STOP);
1763             print_result(D_CBC_256_AES, j, count, d);
1764         }
1765     }
1766
1767     if (doit[D_IGE_128_AES]) {
1768         for (j = 0; j < SIZE_NUM; j++) {
1769             print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
1770                           lengths[j]);
1771             Time_F(START);
1772             for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
1773                 AES_ige_encrypt(buf, buf2,
1774                                 (unsigned long)lengths[j], &aes_ks1,
1775                                 iv, AES_ENCRYPT);
1776             d = Time_F(STOP);
1777             print_result(D_IGE_128_AES, j, count, d);
1778         }
1779     }
1780     if (doit[D_IGE_192_AES]) {
1781         for (j = 0; j < SIZE_NUM; j++) {
1782             print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
1783                           lengths[j]);
1784             Time_F(START);
1785             for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
1786                 AES_ige_encrypt(buf, buf2,
1787                                 (unsigned long)lengths[j], &aes_ks2,
1788                                 iv, AES_ENCRYPT);
1789             d = Time_F(STOP);
1790             print_result(D_IGE_192_AES, j, count, d);
1791         }
1792     }
1793     if (doit[D_IGE_256_AES]) {
1794         for (j = 0; j < SIZE_NUM; j++) {
1795             print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
1796                           lengths[j]);
1797             Time_F(START);
1798             for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
1799                 AES_ige_encrypt(buf, buf2,
1800                                 (unsigned long)lengths[j], &aes_ks3,
1801                                 iv, AES_ENCRYPT);
1802             d = Time_F(STOP);
1803             print_result(D_IGE_256_AES, j, count, d);
1804         }
1805     }
1806     if (doit[D_GHASH]) {
1807         GCM128_CONTEXT *ctx =
1808             CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
1809         CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
1810
1811         for (j = 0; j < SIZE_NUM; j++) {
1812             print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
1813             Time_F(START);
1814             for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
1815                 CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
1816             d = Time_F(STOP);
1817             print_result(D_GHASH, j, count, d);
1818         }
1819         CRYPTO_gcm128_release(ctx);
1820     }
1821 #endif
1822 #ifndef OPENSSL_NO_CAMELLIA
1823     if (doit[D_CBC_128_CML]) {
1824         for (j = 0; j < SIZE_NUM; j++) {
1825             print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
1826                           lengths[j]);
1827             Time_F(START);
1828             for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
1829                 Camellia_cbc_encrypt(buf, buf,
1830                                      (unsigned long)lengths[j], &camellia_ks1,
1831                                      iv, CAMELLIA_ENCRYPT);
1832             d = Time_F(STOP);
1833             print_result(D_CBC_128_CML, j, count, d);
1834         }
1835     }
1836     if (doit[D_CBC_192_CML]) {
1837         for (j = 0; j < SIZE_NUM; j++) {
1838             print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
1839                           lengths[j]);
1840             Time_F(START);
1841             for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
1842                 Camellia_cbc_encrypt(buf, buf,
1843                                      (unsigned long)lengths[j], &camellia_ks2,
1844                                      iv, CAMELLIA_ENCRYPT);
1845             d = Time_F(STOP);
1846             print_result(D_CBC_192_CML, j, count, d);
1847         }
1848     }
1849     if (doit[D_CBC_256_CML]) {
1850         for (j = 0; j < SIZE_NUM; j++) {
1851             print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
1852                           lengths[j]);
1853             Time_F(START);
1854             for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
1855                 Camellia_cbc_encrypt(buf, buf,
1856                                      (unsigned long)lengths[j], &camellia_ks3,
1857                                      iv, CAMELLIA_ENCRYPT);
1858             d = Time_F(STOP);
1859             print_result(D_CBC_256_CML, j, count, d);
1860         }
1861     }
1862 #endif
1863 #ifndef OPENSSL_NO_IDEA
1864     if (doit[D_CBC_IDEA]) {
1865         for (j = 0; j < SIZE_NUM; j++) {
1866             print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
1867             Time_F(START);
1868             for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
1869                 idea_cbc_encrypt(buf, buf,
1870                                  (unsigned long)lengths[j], &idea_ks,
1871                                  iv, IDEA_ENCRYPT);
1872             d = Time_F(STOP);
1873             print_result(D_CBC_IDEA, j, count, d);
1874         }
1875     }
1876 #endif
1877 #ifndef OPENSSL_NO_SEED
1878     if (doit[D_CBC_SEED]) {
1879         for (j = 0; j < SIZE_NUM; j++) {
1880             print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
1881             Time_F(START);
1882             for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
1883                 SEED_cbc_encrypt(buf, buf,
1884                                  (unsigned long)lengths[j], &seed_ks, iv, 1);
1885             d = Time_F(STOP);
1886             print_result(D_CBC_SEED, j, count, d);
1887         }
1888     }
1889 #endif
1890 #ifndef OPENSSL_NO_RC2
1891     if (doit[D_CBC_RC2]) {
1892         for (j = 0; j < SIZE_NUM; j++) {
1893             print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
1894             Time_F(START);
1895             for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
1896                 RC2_cbc_encrypt(buf, buf,
1897                                 (unsigned long)lengths[j], &rc2_ks,
1898                                 iv, RC2_ENCRYPT);
1899             d = Time_F(STOP);
1900             print_result(D_CBC_RC2, j, count, d);
1901         }
1902     }
1903 #endif
1904 #ifndef OPENSSL_NO_RC5
1905     if (doit[D_CBC_RC5]) {
1906         for (j = 0; j < SIZE_NUM; j++) {
1907             print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
1908             Time_F(START);
1909             for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
1910                 RC5_32_cbc_encrypt(buf, buf,
1911                                    (unsigned long)lengths[j], &rc5_ks,
1912                                    iv, RC5_ENCRYPT);
1913             d = Time_F(STOP);
1914             print_result(D_CBC_RC5, j, count, d);
1915         }
1916     }
1917 #endif
1918 #ifndef OPENSSL_NO_BF
1919     if (doit[D_CBC_BF]) {
1920         for (j = 0; j < SIZE_NUM; j++) {
1921             print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
1922             Time_F(START);
1923             for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
1924                 BF_cbc_encrypt(buf, buf,
1925                                (unsigned long)lengths[j], &bf_ks,
1926                                iv, BF_ENCRYPT);
1927             d = Time_F(STOP);
1928             print_result(D_CBC_BF, j, count, d);
1929         }
1930     }
1931 #endif
1932 #ifndef OPENSSL_NO_CAST
1933     if (doit[D_CBC_CAST]) {
1934         for (j = 0; j < SIZE_NUM; j++) {
1935             print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
1936             Time_F(START);
1937             for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
1938                 CAST_cbc_encrypt(buf, buf,
1939                                  (unsigned long)lengths[j], &cast_ks,
1940                                  iv, CAST_ENCRYPT);
1941             d = Time_F(STOP);
1942             print_result(D_CBC_CAST, j, count, d);
1943         }
1944     }
1945 #endif
1946
1947     if (doit[D_EVP]) {
1948 #ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
1949         if (multiblock && evp_cipher) {
1950             if (!
1951                 (EVP_CIPHER_flags(evp_cipher) &
1952                  EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
1953                 fprintf(stderr, "%s is not multi-block capable\n",
1954                         OBJ_nid2ln(evp_cipher->nid));
1955                 goto end;
1956             }
1957             multiblock_speed(evp_cipher);
1958             mret = 0;
1959             goto end;
1960         }
1961 #endif
1962         for (j = 0; j < SIZE_NUM; j++) {
1963             if (evp_cipher) {
1964                 EVP_CIPHER_CTX ctx;
1965                 int outl;
1966
1967                 names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
1968                 /*
1969                  * -O3 -fschedule-insns messes up an optimization here!
1970                  * names[D_EVP] somehow becomes NULL
1971                  */
1972                 print_message(names[D_EVP], save_count, lengths[j]);
1973
1974                 EVP_CIPHER_CTX_init(&ctx);
1975                 if (decrypt)
1976                     EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1977                 else
1978                     EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
1979                 EVP_CIPHER_CTX_set_padding(&ctx, 0);
1980
1981                 Time_F(START);
1982                 if (decrypt)
1983                     for (count = 0, run = 1;
1984                          COND(save_count * 4 * lengths[0] / lengths[j]);
1985                          count++)
1986                         EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1987                 else
1988                     for (count = 0, run = 1;
1989                          COND(save_count * 4 * lengths[0] / lengths[j]);
1990                          count++)
1991                         EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
1992                 if (decrypt)
1993                     EVP_DecryptFinal_ex(&ctx, buf, &outl);
1994                 else
1995                     EVP_EncryptFinal_ex(&ctx, buf, &outl);
1996                 d = Time_F(STOP);
1997                 EVP_CIPHER_CTX_cleanup(&ctx);
1998             }
1999             if (evp_md) {
2000                 names[D_EVP] = OBJ_nid2ln(evp_md->type);
2001                 print_message(names[D_EVP], save_count, lengths[j]);
2002
2003                 Time_F(START);
2004                 for (count = 0, run = 1;
2005                      COND(save_count * 4 * lengths[0] / lengths[j]); count++)
2006                     EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
2007
2008                 d = Time_F(STOP);
2009             }
2010             print_result(D_EVP, j, count, d);
2011         }
2012     }
2013 #ifndef OPENSSL_SYS_WIN32
2014 #endif
2015     RAND_pseudo_bytes(buf, 36);
2016 #ifndef OPENSSL_NO_RSA
2017     for (j = 0; j < RSA_NUM; j++) {
2018         int ret;
2019         if (!rsa_doit[j])
2020             continue;
2021         ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
2022         if (ret == 0) {
2023             BIO_printf(bio_err,
2024                        "RSA sign failure.  No RSA sign will be done.\n");
2025             ERR_print_errors(bio_err);
2026             rsa_count = 1;
2027         } else {
2028             pkey_print_message("private", "rsa",
2029                                rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
2030             /* RSA_blinding_on(rsa_key[j],NULL); */
2031             Time_F(START);
2032             for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
2033                 ret = RSA_sign(NID_md5_sha1, buf, 36, buf2,
2034                                &rsa_num, rsa_key[j]);
2035                 if (ret == 0) {
2036                     BIO_printf(bio_err, "RSA sign failure\n");
2037                     ERR_print_errors(bio_err);
2038                     count = 1;
2039                     break;
2040                 }
2041             }
2042             d = Time_F(STOP);
2043             BIO_printf(bio_err,
2044                        mr ? "+R1:%ld:%d:%.2f\n"
2045                        : "%ld %d bit private RSA's in %.2fs\n",
2046                        count, rsa_bits[j], d);
2047             rsa_results[j][0] = d / (double)count;
2048             rsa_count = count;
2049         }
2050
2051 # if 1
2052         ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
2053         if (ret <= 0) {
2054             BIO_printf(bio_err,
2055                        "RSA verify failure.  No RSA verify will be done.\n");
2056             ERR_print_errors(bio_err);
2057             rsa_doit[j] = 0;
2058         } else {
2059             pkey_print_message("public", "rsa",
2060                                rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
2061             Time_F(START);
2062             for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
2063                 ret = RSA_verify(NID_md5_sha1, buf, 36, buf2,
2064                                  rsa_num, rsa_key[j]);
2065                 if (ret <= 0) {
2066                     BIO_printf(bio_err, "RSA verify failure\n");
2067                     ERR_print_errors(bio_err);
2068                     count = 1;
2069                     break;
2070                 }
2071             }
2072             d = Time_F(STOP);
2073             BIO_printf(bio_err,
2074                        mr ? "+R2:%ld:%d:%.2f\n"
2075                        : "%ld %d bit public RSA's in %.2fs\n",
2076                        count, rsa_bits[j], d);
2077             rsa_results[j][1] = d / (double)count;
2078         }
2079 # endif
2080
2081         if (rsa_count <= 1) {
2082             /* if longer than 10s, don't do any more */
2083             for (j++; j < RSA_NUM; j++)
2084                 rsa_doit[j] = 0;
2085         }
2086     }
2087 #endif
2088
2089     RAND_pseudo_bytes(buf, 20);
2090 #ifndef OPENSSL_NO_DSA
2091     if (RAND_status() != 1) {
2092         RAND_seed(rnd_seed, sizeof rnd_seed);
2093         rnd_fake = 1;
2094     }
2095     for (j = 0; j < DSA_NUM; j++) {
2096         unsigned int kk;
2097         int ret;
2098
2099         if (!dsa_doit[j])
2100             continue;
2101
2102         /* DSA_generate_key(dsa_key[j]); */
2103         /* DSA_sign_setup(dsa_key[j],NULL); */
2104         ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
2105         if (ret == 0) {
2106             BIO_printf(bio_err,
2107                        "DSA sign failure.  No DSA sign will be done.\n");
2108             ERR_print_errors(bio_err);
2109             rsa_count = 1;
2110         } else {
2111             pkey_print_message("sign", "dsa",
2112                                dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
2113             Time_F(START);
2114             for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
2115                 ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
2116                 if (ret == 0) {
2117                     BIO_printf(bio_err, "DSA sign failure\n");
2118                     ERR_print_errors(bio_err);
2119                     count = 1;
2120                     break;
2121                 }
2122             }
2123             d = Time_F(STOP);
2124             BIO_printf(bio_err,
2125                        mr ? "+R3:%ld:%d:%.2f\n"
2126                        : "%ld %d bit DSA signs in %.2fs\n",
2127                        count, dsa_bits[j], d);
2128             dsa_results[j][0] = d / (double)count;
2129             rsa_count = count;
2130         }
2131
2132         ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
2133         if (ret <= 0) {
2134             BIO_printf(bio_err,
2135                        "DSA verify failure.  No DSA verify will be done.\n");
2136             ERR_print_errors(bio_err);
2137             dsa_doit[j] = 0;
2138         } else {
2139             pkey_print_message("verify", "dsa",
2140                                dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
2141             Time_F(START);
2142             for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
2143                 ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
2144                 if (ret <= 0) {
2145                     BIO_printf(bio_err, "DSA verify failure\n");
2146                     ERR_print_errors(bio_err);
2147                     count = 1;
2148                     break;
2149                 }
2150             }
2151             d = Time_F(STOP);
2152             BIO_printf(bio_err,
2153                        mr ? "+R4:%ld:%d:%.2f\n"
2154                        : "%ld %d bit DSA verify in %.2fs\n",
2155                        count, dsa_bits[j], d);
2156             dsa_results[j][1] = d / (double)count;
2157         }
2158
2159         if (rsa_count <= 1) {
2160             /* if longer than 10s, don't do any more */
2161             for (j++; j < DSA_NUM; j++)
2162                 dsa_doit[j] = 0;
2163         }
2164     }
2165     if (rnd_fake)
2166         RAND_cleanup();
2167 #endif
2168
2169 #ifndef OPENSSL_NO_ECDSA
2170     if (RAND_status() != 1) {
2171         RAND_seed(rnd_seed, sizeof rnd_seed);
2172         rnd_fake = 1;
2173     }
2174     for (j = 0; j < EC_NUM; j++) {
2175         int ret;
2176
2177         if (!ecdsa_doit[j])
2178             continue;           /* Ignore Curve */
2179         ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2180         if (ecdsa[j] == NULL) {
2181             BIO_printf(bio_err, "ECDSA failure.\n");
2182             ERR_print_errors(bio_err);
2183             rsa_count = 1;
2184         } else {
2185 # if 1
2186             EC_KEY_precompute_mult(ecdsa[j], NULL);
2187 # endif
2188             /* Perform ECDSA signature test */
2189             EC_KEY_generate_key(ecdsa[j]);
2190             ret = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
2191             if (ret == 0) {
2192                 BIO_printf(bio_err,
2193                            "ECDSA sign failure.  No ECDSA sign will be done.\n");
2194                 ERR_print_errors(bio_err);
2195                 rsa_count = 1;
2196             } else {
2197                 pkey_print_message("sign", "ecdsa",
2198                                    ecdsa_c[j][0],
2199                                    test_curves_bits[j], ECDSA_SECONDS);
2200
2201                 Time_F(START);
2202                 for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
2203                     ret = ECDSA_sign(0, buf, 20,
2204                                      ecdsasig, &ecdsasiglen, ecdsa[j]);
2205                     if (ret == 0) {
2206                         BIO_printf(bio_err, "ECDSA sign failure\n");
2207                         ERR_print_errors(bio_err);
2208                         count = 1;
2209                         break;
2210                     }
2211                 }
2212                 d = Time_F(STOP);
2213
2214                 BIO_printf(bio_err,
2215                            mr ? "+R5:%ld:%d:%.2f\n" :
2216                            "%ld %d bit ECDSA signs in %.2fs \n",
2217                            count, test_curves_bits[j], d);
2218                 ecdsa_results[j][0] = d / (double)count;
2219                 rsa_count = count;
2220             }
2221
2222             /* Perform ECDSA verification test */
2223             ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
2224             if (ret != 1) {
2225                 BIO_printf(bio_err,
2226                            "ECDSA verify failure.  No ECDSA verify will be done.\n");
2227                 ERR_print_errors(bio_err);
2228                 ecdsa_doit[j] = 0;
2229             } else {
2230                 pkey_print_message("verify", "ecdsa",
2231                                    ecdsa_c[j][1],
2232                                    test_curves_bits[j], ECDSA_SECONDS);
2233                 Time_F(START);
2234                 for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
2235                     ret =
2236                         ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
2237                                      ecdsa[j]);
2238                     if (ret != 1) {
2239                         BIO_printf(bio_err, "ECDSA verify failure\n");
2240                         ERR_print_errors(bio_err);
2241                         count = 1;
2242                         break;
2243                     }
2244                 }
2245                 d = Time_F(STOP);
2246                 BIO_printf(bio_err,
2247                            mr ? "+R6:%ld:%d:%.2f\n"
2248                            : "%ld %d bit ECDSA verify in %.2fs\n",
2249                            count, test_curves_bits[j], d);
2250                 ecdsa_results[j][1] = d / (double)count;
2251             }
2252
2253             if (rsa_count <= 1) {
2254                 /* if longer than 10s, don't do any more */
2255                 for (j++; j < EC_NUM; j++)
2256                     ecdsa_doit[j] = 0;
2257             }
2258         }
2259     }
2260     if (rnd_fake)
2261         RAND_cleanup();
2262 #endif
2263
2264 #ifndef OPENSSL_NO_ECDH
2265     if (RAND_status() != 1) {
2266         RAND_seed(rnd_seed, sizeof rnd_seed);
2267         rnd_fake = 1;
2268     }
2269     for (j = 0; j < EC_NUM; j++) {
2270         if (!ecdh_doit[j])
2271             continue;
2272         ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2273         ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
2274         if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
2275             BIO_printf(bio_err, "ECDH failure.\n");
2276             ERR_print_errors(bio_err);
2277             rsa_count = 1;
2278         } else {
2279             /* generate two ECDH key pairs */
2280             if (!EC_KEY_generate_key(ecdh_a[j]) ||
2281                 !EC_KEY_generate_key(ecdh_b[j])) {
2282                 BIO_printf(bio_err, "ECDH key generation failure.\n");
2283                 ERR_print_errors(bio_err);
2284                 rsa_count = 1;
2285             } else {
2286                 /*
2287                  * If field size is not more than 24 octets, then use SHA-1
2288                  * hash of result; otherwise, use result (see section 4.8 of
2289                  * draft-ietf-tls-ecc-03.txt).
2290                  */
2291                 int field_size, outlen;
2292                 void *(*kdf) (const void *in, size_t inlen, void *out,
2293                               size_t *xoutlen);
2294                 field_size =
2295                     EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
2296                 if (field_size <= 24 * 8) {
2297                     outlen = KDF1_SHA1_len;
2298                     kdf = KDF1_SHA1;
2299                 } else {
2300                     outlen = (field_size + 7) / 8;
2301                     kdf = NULL;
2302                 }
2303                 secret_size_a =
2304                     ECDH_compute_key(secret_a, outlen,
2305                                      EC_KEY_get0_public_key(ecdh_b[j]),
2306                                      ecdh_a[j], kdf);
2307                 secret_size_b =
2308                     ECDH_compute_key(secret_b, outlen,
2309                                      EC_KEY_get0_public_key(ecdh_a[j]),
2310                                      ecdh_b[j], kdf);
2311                 if (secret_size_a != secret_size_b)
2312                     ecdh_checks = 0;
2313                 else
2314                     ecdh_checks = 1;
2315
2316                 for (secret_idx = 0; (secret_idx < secret_size_a)
2317                      && (ecdh_checks == 1); secret_idx++) {
2318                     if (secret_a[secret_idx] != secret_b[secret_idx])
2319                         ecdh_checks = 0;
2320                 }
2321
2322                 if (ecdh_checks == 0) {
2323                     BIO_printf(bio_err, "ECDH computations don't match.\n");
2324                     ERR_print_errors(bio_err);
2325                     rsa_count = 1;
2326                 }
2327
2328                 pkey_print_message("", "ecdh",
2329                                    ecdh_c[j][0],
2330                                    test_curves_bits[j], ECDH_SECONDS);
2331                 Time_F(START);
2332                 for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
2333                     ECDH_compute_key(secret_a, outlen,
2334                                      EC_KEY_get0_public_key(ecdh_b[j]),
2335                                      ecdh_a[j], kdf);
2336                 }
2337                 d = Time_F(STOP);
2338                 BIO_printf(bio_err,
2339                            mr ? "+R7:%ld:%d:%.2f\n" :
2340                            "%ld %d-bit ECDH ops in %.2fs\n", count,
2341                            test_curves_bits[j], d);
2342                 ecdh_results[j][0] = d / (double)count;
2343                 rsa_count = count;
2344             }
2345         }
2346
2347         if (rsa_count <= 1) {
2348             /* if longer than 10s, don't do any more */
2349             for (j++; j < EC_NUM; j++)
2350                 ecdh_doit[j] = 0;
2351         }
2352     }
2353     if (rnd_fake)
2354         RAND_cleanup();
2355 #endif
2356 #ifndef NO_FORK
2357  show_res:
2358 #endif
2359     if (!mr) {
2360         fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_VERSION));
2361         fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_BUILT_ON));
2362         printf("options:");
2363         printf("%s ", BN_options());
2364 #ifndef OPENSSL_NO_MD2
2365         printf("%s ", MD2_options());
2366 #endif
2367 #ifndef OPENSSL_NO_RC4
2368         printf("%s ", RC4_options());
2369 #endif
2370 #ifndef OPENSSL_NO_DES
2371         printf("%s ", DES_options());
2372 #endif
2373 #ifndef OPENSSL_NO_AES
2374         printf("%s ", AES_options());
2375 #endif
2376 #ifndef OPENSSL_NO_IDEA
2377         printf("%s ", idea_options());
2378 #endif
2379 #ifndef OPENSSL_NO_BF
2380         printf("%s ", BF_options());
2381 #endif
2382         fprintf(stdout, "\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
2383     }
2384
2385     if (pr_header) {
2386         if (mr)
2387             fprintf(stdout, "+H");
2388         else {
2389             fprintf(stdout,
2390                     "The 'numbers' are in 1000s of bytes per second processed.\n");
2391             fprintf(stdout, "type        ");
2392         }
2393         for (j = 0; j < SIZE_NUM; j++)
2394             fprintf(stdout, mr ? ":%d" : "%7d bytes", lengths[j]);
2395         fprintf(stdout, "\n");
2396     }
2397
2398     for (k = 0; k < ALGOR_NUM; k++) {
2399         if (!doit[k])
2400             continue;
2401         if (mr)
2402             fprintf(stdout, "+F:%d:%s", k, names[k]);
2403         else
2404             fprintf(stdout, "%-13s", names[k]);
2405         for (j = 0; j < SIZE_NUM; j++) {
2406             if (results[k][j] > 10000 && !mr)
2407                 fprintf(stdout, " %11.2fk", results[k][j] / 1e3);
2408             else
2409                 fprintf(stdout, mr ? ":%.2f" : " %11.2f ", results[k][j]);
2410         }
2411         fprintf(stdout, "\n");
2412     }
2413 #ifndef OPENSSL_NO_RSA
2414     j = 1;
2415     for (k = 0; k < RSA_NUM; k++) {
2416         if (!rsa_doit[k])
2417             continue;
2418         if (j && !mr) {
2419             printf("%18ssign    verify    sign/s verify/s\n", " ");
2420             j = 0;
2421         }
2422         if (mr)
2423             fprintf(stdout, "+F2:%u:%u:%f:%f\n",
2424                     k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
2425         else
2426             fprintf(stdout, "rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2427                     rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
2428                     1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
2429     }
2430 #endif
2431 #ifndef OPENSSL_NO_DSA
2432     j = 1;
2433     for (k = 0; k < DSA_NUM; k++) {
2434         if (!dsa_doit[k])
2435             continue;
2436         if (j && !mr) {
2437             printf("%18ssign    verify    sign/s verify/s\n", " ");
2438             j = 0;
2439         }
2440         if (mr)
2441             fprintf(stdout, "+F3:%u:%u:%f:%f\n",
2442                     k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
2443         else
2444             fprintf(stdout, "dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
2445                     dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
2446                     1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
2447     }
2448 #endif
2449 #ifndef OPENSSL_NO_ECDSA
2450     j = 1;
2451     for (k = 0; k < EC_NUM; k++) {
2452         if (!ecdsa_doit[k])
2453             continue;
2454         if (j && !mr) {
2455             printf("%30ssign    verify    sign/s verify/s\n", " ");
2456             j = 0;
2457         }
2458
2459         if (mr)
2460             fprintf(stdout, "+F4:%u:%u:%f:%f\n",
2461                     k, test_curves_bits[k],
2462                     ecdsa_results[k][0], ecdsa_results[k][1]);
2463         else
2464             fprintf(stdout,
2465                     "%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
2466                     test_curves_bits[k],
2467                     test_curves_names[k],
2468                     ecdsa_results[k][0], ecdsa_results[k][1],
2469                     1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
2470     }
2471 #endif
2472
2473 #ifndef OPENSSL_NO_ECDH
2474     j = 1;
2475     for (k = 0; k < EC_NUM; k++) {
2476         if (!ecdh_doit[k])
2477             continue;
2478         if (j && !mr) {
2479             printf("%30sop      op/s\n", " ");
2480             j = 0;
2481         }
2482         if (mr)
2483             fprintf(stdout, "+F5:%u:%u:%f:%f\n",
2484                     k, test_curves_bits[k],
2485                     ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2486
2487         else
2488             fprintf(stdout, "%4u bit ecdh (%s) %8.4fs %8.1f\n",
2489                     test_curves_bits[k],
2490                     test_curves_names[k],
2491                     ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
2492     }
2493 #endif
2494
2495     mret = 0;
2496
2497  end:
2498     ERR_print_errors(bio_err);
2499     if (buf_malloc != NULL)
2500         OPENSSL_free(buf_malloc);
2501     if (buf2_malloc != NULL)
2502         OPENSSL_free(buf2_malloc);
2503 #ifndef OPENSSL_NO_RSA
2504     for (i = 0; i < RSA_NUM; i++)
2505         if (rsa_key[i] != NULL)
2506             RSA_free(rsa_key[i]);
2507 #endif
2508 #ifndef OPENSSL_NO_DSA
2509     for (i = 0; i < DSA_NUM; i++)
2510         if (dsa_key[i] != NULL)
2511             DSA_free(dsa_key[i]);
2512 #endif
2513
2514 #ifndef OPENSSL_NO_ECDSA
2515     for (i = 0; i < EC_NUM; i++)
2516         if (ecdsa[i] != NULL)
2517             EC_KEY_free(ecdsa[i]);
2518 #endif
2519 #ifndef OPENSSL_NO_ECDH
2520     for (i = 0; i < EC_NUM; i++) {
2521         if (ecdh_a[i] != NULL)
2522             EC_KEY_free(ecdh_a[i]);
2523         if (ecdh_b[i] != NULL)
2524             EC_KEY_free(ecdh_b[i]);
2525     }
2526 #endif
2527
2528     apps_shutdown();
2529     OPENSSL_EXIT(mret);
2530 }
2531
2532 static void print_message(const char *s, long num, int length)
2533 {
2534 #ifdef SIGALRM
2535     BIO_printf(bio_err,
2536                mr ? "+DT:%s:%d:%d\n"
2537                : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length);
2538     (void)BIO_flush(bio_err);
2539     alarm(SECONDS);
2540 #else
2541     BIO_printf(bio_err,
2542                mr ? "+DN:%s:%ld:%d\n"
2543                : "Doing %s %ld times on %d size blocks: ", s, num, length);
2544     (void)BIO_flush(bio_err);
2545 #endif
2546 }
2547
2548 static void pkey_print_message(const char *str, const char *str2, long num,
2549                                int bits, int tm)
2550 {
2551 #ifdef SIGALRM
2552     BIO_printf(bio_err,
2553                mr ? "+DTP:%d:%s:%s:%d\n"
2554                : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm);
2555     (void)BIO_flush(bio_err);
2556     alarm(tm);
2557 #else
2558     BIO_printf(bio_err,
2559                mr ? "+DNP:%ld:%d:%s:%s\n"
2560                : "Doing %ld %d bit %s %s's: ", num, bits, str, str2);
2561     (void)BIO_flush(bio_err);
2562 #endif
2563 }
2564
2565 static void print_result(int alg, int run_no, int count, double time_used)
2566 {
2567     BIO_printf(bio_err,
2568                mr ? "+R:%d:%s:%f\n"
2569                : "%d %s's in %.2fs\n", count, names[alg], time_used);
2570     results[alg][run_no] = ((double)count) / time_used * lengths[run_no];
2571 }
2572
2573 #ifndef NO_FORK
2574 static char *sstrsep(char **string, const char *delim)
2575 {
2576     char isdelim[256];
2577     char *token = *string;
2578
2579     if (**string == 0)
2580         return NULL;
2581
2582     memset(isdelim, 0, sizeof isdelim);
2583     isdelim[0] = 1;
2584
2585     while (*delim) {
2586         isdelim[(unsigned char)(*delim)] = 1;
2587         delim++;
2588     }
2589
2590     while (!isdelim[(unsigned char)(**string)]) {
2591         (*string)++;
2592     }
2593
2594     if (**string) {
2595         **string = 0;
2596         (*string)++;
2597     }
2598
2599     return token;
2600 }
2601
2602 static int do_multi(int multi)
2603 {
2604     int n;
2605     int fd[2];
2606     int *fds;
2607     static char sep[] = ":";
2608
2609     fds = malloc(multi * sizeof *fds);
2610     for (n = 0; n < multi; ++n) {
2611         if (pipe(fd) == -1) {
2612             fprintf(stderr, "pipe failure\n");
2613             exit(1);
2614         }
2615         fflush(stdout);
2616         fflush(stderr);
2617         if (fork()) {
2618             close(fd[1]);
2619             fds[n] = fd[0];
2620         } else {
2621             close(fd[0]);
2622             close(1);
2623             if (dup(fd[1]) == -1) {
2624                 fprintf(stderr, "dup failed\n");
2625                 exit(1);
2626             }
2627             close(fd[1]);
2628             mr = 1;
2629             usertime = 0;
2630             free(fds);
2631             return 0;
2632         }
2633         printf("Forked child %d\n", n);
2634     }
2635
2636     /* for now, assume the pipe is long enough to take all the output */
2637     for (n = 0; n < multi; ++n) {
2638         FILE *f;
2639         char buf[1024];
2640         char *p;
2641
2642         f = fdopen(fds[n], "r");
2643         while (fgets(buf, sizeof buf, f)) {
2644             p = strchr(buf, '\n');
2645             if (p)
2646                 *p = '\0';
2647             if (buf[0] != '+') {
2648                 fprintf(stderr, "Don't understand line '%s' from child %d\n",
2649                         buf, n);
2650                 continue;
2651             }
2652             printf("Got: %s from %d\n", buf, n);
2653             if (!strncmp(buf, "+F:", 3)) {
2654                 int alg;
2655                 int j;
2656
2657                 p = buf + 3;
2658                 alg = atoi(sstrsep(&p, sep));
2659                 sstrsep(&p, sep);
2660                 for (j = 0; j < SIZE_NUM; ++j)
2661                     results[alg][j] += atof(sstrsep(&p, sep));
2662             } else if (!strncmp(buf, "+F2:", 4)) {
2663                 int k;
2664                 double d;
2665
2666                 p = buf + 4;
2667                 k = atoi(sstrsep(&p, sep));
2668                 sstrsep(&p, sep);
2669
2670                 d = atof(sstrsep(&p, sep));
2671                 if (n)
2672                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2673                 else
2674                     rsa_results[k][0] = d;
2675
2676                 d = atof(sstrsep(&p, sep));
2677                 if (n)
2678                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2679                 else
2680                     rsa_results[k][1] = d;
2681             } else if (!strncmp(buf, "+F2:", 4)) {
2682                 int k;
2683                 double d;
2684
2685                 p = buf + 4;
2686                 k = atoi(sstrsep(&p, sep));
2687                 sstrsep(&p, sep);
2688
2689                 d = atof(sstrsep(&p, sep));
2690                 if (n)
2691                     rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d);
2692                 else
2693                     rsa_results[k][0] = d;
2694
2695                 d = atof(sstrsep(&p, sep));
2696                 if (n)
2697                     rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d);
2698                 else
2699                     rsa_results[k][1] = d;
2700             }
2701 # ifndef OPENSSL_NO_DSA
2702             else if (!strncmp(buf, "+F3:", 4)) {
2703                 int k;
2704                 double d;
2705
2706                 p = buf + 4;
2707                 k = atoi(sstrsep(&p, sep));
2708                 sstrsep(&p, sep);
2709
2710                 d = atof(sstrsep(&p, sep));
2711                 if (n)
2712                     dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d);
2713                 else
2714                     dsa_results[k][0] = d;
2715
2716                 d = atof(sstrsep(&p, sep));
2717                 if (n)
2718                     dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d);
2719                 else
2720                     dsa_results[k][1] = d;
2721             }
2722 # endif
2723 # ifndef OPENSSL_NO_ECDSA
2724             else if (!strncmp(buf, "+F4:", 4)) {
2725                 int k;
2726                 double d;
2727
2728                 p = buf + 4;
2729                 k = atoi(sstrsep(&p, sep));
2730                 sstrsep(&p, sep);
2731
2732                 d = atof(sstrsep(&p, sep));
2733                 if (n)
2734                     ecdsa_results[k][0] =
2735                         1 / (1 / ecdsa_results[k][0] + 1 / d);
2736                 else
2737                     ecdsa_results[k][0] = d;
2738
2739                 d = atof(sstrsep(&p, sep));
2740                 if (n)
2741                     ecdsa_results[k][1] =
2742                         1 / (1 / ecdsa_results[k][1] + 1 / d);
2743                 else
2744                     ecdsa_results[k][1] = d;
2745             }
2746 # endif
2747
2748 # ifndef OPENSSL_NO_ECDH
2749             else if (!strncmp(buf, "+F5:", 4)) {
2750                 int k;
2751                 double d;
2752
2753                 p = buf + 4;
2754                 k = atoi(sstrsep(&p, sep));
2755                 sstrsep(&p, sep);
2756
2757                 d = atof(sstrsep(&p, sep));
2758                 if (n)
2759                     ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d);
2760                 else
2761                     ecdh_results[k][0] = d;
2762
2763             }
2764 # endif
2765
2766             else if (!strncmp(buf, "+H:", 3)) {
2767             } else
2768                 fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n);
2769         }
2770
2771         fclose(f);
2772     }
2773     free(fds);
2774     return 1;
2775 }
2776 #endif
2777
2778 static void multiblock_speed(const EVP_CIPHER *evp_cipher)
2779 {
2780     static int mblengths[] =
2781         { 8 * 1024, 2 * 8 * 1024, 4 * 8 * 1024, 8 * 8 * 1024, 8 * 16 * 1024 };
2782     int j, count, num = sizeof(lengths) / sizeof(lengths[0]);
2783     const char *alg_name;
2784     unsigned char *inp, *out, no_key[32], no_iv[16];
2785     EVP_CIPHER_CTX ctx;
2786     double d = 0.0;
2787
2788     inp = OPENSSL_malloc(mblengths[num - 1]);
2789     out = OPENSSL_malloc(mblengths[num - 1] + 1024);
2790
2791     EVP_CIPHER_CTX_init(&ctx);
2792     EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, no_key, no_iv);
2793     EVP_CIPHER_CTX_ctrl(&ctx, EVP_CTRL_AEAD_SET_MAC_KEY, sizeof(no_key),
2794                         no_key);
2795     alg_name = OBJ_nid2ln(evp_cipher->nid);
2796
2797     for (j = 0; j < num; j++) {
2798         print_message(alg_name, 0, mblengths[j]);
2799         Time_F(START);
2800         for (count = 0, run = 1; run && count < 0x7fffffff; count++) {
2801             unsigned char aad[13];
2802             EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param;
2803             size_t len = mblengths[j];
2804             int packlen;
2805
2806             memset(aad, 0, 8);  /* avoid uninitialized values */
2807             aad[8] = 23;        /* SSL3_RT_APPLICATION_DATA */
2808             aad[9] = 3;         /* version */
2809             aad[10] = 2;
2810             aad[11] = 0;        /* length */
2811             aad[12] = 0;
2812             mb_param.out = NULL;
2813             mb_param.inp = aad;
2814             mb_param.len = len;
2815             mb_param.interleave = 8;
2816
2817             packlen = EVP_CIPHER_CTX_ctrl(&ctx,
2818                                           EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
2819                                           sizeof(mb_param), &mb_param);
2820
2821             if (packlen > 0) {
2822                 mb_param.out = out;
2823                 mb_param.inp = inp;
2824                 mb_param.len = len;
2825                 EVP_CIPHER_CTX_ctrl(&ctx,
2826                                     EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
2827                                     sizeof(mb_param), &mb_param);
2828             } else {
2829                 int pad;
2830
2831                 RAND_bytes(out, 16);
2832                 len += 16;
2833                 aad[11] = len >> 8;
2834                 aad[12] = len;
2835                 pad = EVP_CIPHER_CTX_ctrl(&ctx,
2836                                           EVP_CTRL_AEAD_TLS1_AAD, 13, aad);
2837                 EVP_Cipher(&ctx, out, inp, len + pad);
2838             }
2839         }
2840         d = Time_F(STOP);
2841         BIO_printf(bio_err,
2842                    mr ? "+R:%d:%s:%f\n"
2843                    : "%d %s's in %.2fs\n", count, "evp", d);
2844         results[D_EVP][j] = ((double)count) / d * mblengths[j];
2845     }
2846
2847     if (mr) {
2848         fprintf(stdout, "+H");
2849         for (j = 0; j < num; j++)
2850             fprintf(stdout, ":%d", mblengths[j]);
2851         fprintf(stdout, "\n");
2852         fprintf(stdout, "+F:%d:%s", D_EVP, alg_name);
2853         for (j = 0; j < num; j++)
2854             fprintf(stdout, ":%.2f", results[D_EVP][j]);
2855         fprintf(stdout, "\n");
2856     } else {
2857         fprintf(stdout,
2858                 "The 'numbers' are in 1000s of bytes per second processed.\n");
2859         fprintf(stdout, "type                    ");
2860         for (j = 0; j < num; j++)
2861             fprintf(stdout, "%7d bytes", mblengths[j]);
2862         fprintf(stdout, "\n");
2863         fprintf(stdout, "%-24s", alg_name);
2864
2865         for (j = 0; j < num; j++) {
2866             if (results[D_EVP][j] > 10000)
2867                 fprintf(stdout, " %11.2fk", results[D_EVP][j] / 1e3);
2868             else
2869                 fprintf(stdout, " %11.2f ", results[D_EVP][j]);
2870         }
2871         fprintf(stdout, "\n");
2872     }
2873
2874     OPENSSL_free(inp);
2875     OPENSSL_free(out);
2876 }