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