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