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