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