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