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