1110007Smarkm/* apps/speed.c -*- mode:C; c-file-style: "eay" -*- */ 255714Skris/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 355714Skris * All rights reserved. 455714Skris * 555714Skris * This package is an SSL implementation written 655714Skris * by Eric Young (eay@cryptsoft.com). 755714Skris * The implementation was written so as to conform with Netscapes SSL. 8296341Sdelphij * 955714Skris * This library is free for commercial and non-commercial use as long as 1055714Skris * the following conditions are aheared to. The following conditions 1155714Skris * apply to all code found in this distribution, be it the RC4, RSA, 1255714Skris * lhash, DES, etc., code; not just the SSL code. The SSL documentation 1355714Skris * included with this distribution is covered by the same copyright terms 1455714Skris * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15296341Sdelphij * 1655714Skris * Copyright remains Eric Young's, and as such any Copyright notices in 1755714Skris * the code are not to be removed. 1855714Skris * If this package is used in a product, Eric Young should be given attribution 1955714Skris * as the author of the parts of the library used. 2055714Skris * This can be in the form of a textual message at program startup or 2155714Skris * in documentation (online or textual) provided with the package. 22296341Sdelphij * 2355714Skris * Redistribution and use in source and binary forms, with or without 2455714Skris * modification, are permitted provided that the following conditions 2555714Skris * are met: 2655714Skris * 1. Redistributions of source code must retain the copyright 2755714Skris * notice, this list of conditions and the following disclaimer. 2855714Skris * 2. Redistributions in binary form must reproduce the above copyright 2955714Skris * notice, this list of conditions and the following disclaimer in the 3055714Skris * documentation and/or other materials provided with the distribution. 3155714Skris * 3. All advertising materials mentioning features or use of this software 3255714Skris * must display the following acknowledgement: 3355714Skris * "This product includes cryptographic software written by 3455714Skris * Eric Young (eay@cryptsoft.com)" 3555714Skris * The word 'cryptographic' can be left out if the rouines from the library 3655714Skris * being used are not cryptographic related :-). 37296341Sdelphij * 4. If you include any Windows specific code (or a derivative thereof) from 3855714Skris * the apps directory (application code) you must include an acknowledgement: 3955714Skris * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40296341Sdelphij * 4155714Skris * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 4255714Skris * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 4355714Skris * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 4455714Skris * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 4555714Skris * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 4655714Skris * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 4755714Skris * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 4855714Skris * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 4955714Skris * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5055714Skris * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5155714Skris * SUCH DAMAGE. 52296341Sdelphij * 5355714Skris * The licence and distribution terms for any publically available version or 5455714Skris * derivative of this code cannot be changed. i.e. this code cannot simply be 5555714Skris * copied and put under another distribution licence 5655714Skris * [including the GNU Public Licence.] 5755714Skris */ 58160817Ssimon/* ==================================================================== 59160817Ssimon * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED. 60160817Ssimon * 61296341Sdelphij * Portions of the attached software ("Contribution") are developed by 62160817Ssimon * SUN MICROSYSTEMS, INC., and are contributed to the OpenSSL project. 63160817Ssimon * 64160817Ssimon * The Contribution is licensed pursuant to the OpenSSL open source 65160817Ssimon * license provided above. 66160817Ssimon * 67296341Sdelphij * The ECDH and ECDSA speed test software is originally written by 68160817Ssimon * Sumit Gupta of Sun Microsystems Laboratories. 69160817Ssimon * 70160817Ssimon */ 7155714Skris 7255714Skris/* most of this code has been pilfered from my libdes speed.c program */ 7355714Skris 74111150Snectar#ifndef OPENSSL_NO_SPEED 75111150Snectar 76296341Sdelphij# undef SECONDS 77296341Sdelphij# define SECONDS 3 78296341Sdelphij# define RSA_SECONDS 10 79296341Sdelphij# define DSA_SECONDS 10 80296341Sdelphij# define ECDSA_SECONDS 10 81296341Sdelphij# define ECDH_SECONDS 10 8255714Skris 8355714Skris/* 11-Sep-92 Andrew Daviel Support for Silicon Graphics IRIX added */ 8455714Skris/* 06-Apr-92 Luke Brennan Support for VMS and add extra signal calls */ 8555714Skris 86296341Sdelphij# undef PROG 87296341Sdelphij# define PROG speed_main 8855714Skris 89296341Sdelphij# include <stdio.h> 90296341Sdelphij# include <stdlib.h> 91160817Ssimon 92296341Sdelphij# include <string.h> 93296341Sdelphij# include <math.h> 94296341Sdelphij# include "apps.h" 95296341Sdelphij# ifdef OPENSSL_NO_STDIO 96296341Sdelphij# define APPS_WIN16 97296341Sdelphij# endif 98296341Sdelphij# include <openssl/crypto.h> 99296341Sdelphij# include <openssl/rand.h> 100296341Sdelphij# include <openssl/err.h> 101296341Sdelphij# include <openssl/evp.h> 102296341Sdelphij# include <openssl/objects.h> 103296341Sdelphij# if !defined(OPENSSL_SYS_MSDOS) 104296341Sdelphij# include OPENSSL_UNISTD 105296341Sdelphij# endif 10655714Skris 107296341Sdelphij# ifndef OPENSSL_SYS_NETWARE 108296341Sdelphij# include <signal.h> 109296341Sdelphij# endif 110160817Ssimon 111296341Sdelphij# if defined(_WIN32) || defined(__CYGWIN__) 112296341Sdelphij# include <windows.h> 113296341Sdelphij# if defined(__CYGWIN__) && !defined(_WIN32) 114296341Sdelphij /* 115296341Sdelphij * <windows.h> should define _WIN32, which normally is mutually exclusive 116296341Sdelphij * with __CYGWIN__, but if it didn't... 117296341Sdelphij */ 118296341Sdelphij# define _WIN32 119238405Sjkim /* this is done because Cygwin alarm() fails sometimes. */ 120296341Sdelphij# endif 121238405Sjkim# endif 12255714Skris 123296341Sdelphij# include <openssl/bn.h> 124296341Sdelphij# ifndef OPENSSL_NO_DES 125296341Sdelphij# include <openssl/des.h> 126296341Sdelphij# endif 127296341Sdelphij# ifndef OPENSSL_NO_AES 128296341Sdelphij# include <openssl/aes.h> 129296341Sdelphij# endif 130296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 131296341Sdelphij# include <openssl/camellia.h> 132296341Sdelphij# endif 133296341Sdelphij# ifndef OPENSSL_NO_MD2 134296341Sdelphij# include <openssl/md2.h> 135296341Sdelphij# endif 136296341Sdelphij# ifndef OPENSSL_NO_MDC2 137296341Sdelphij# include <openssl/mdc2.h> 138296341Sdelphij# endif 139296341Sdelphij# ifndef OPENSSL_NO_MD4 140296341Sdelphij# include <openssl/md4.h> 141296341Sdelphij# endif 142296341Sdelphij# ifndef OPENSSL_NO_MD5 143296341Sdelphij# include <openssl/md5.h> 144296341Sdelphij# endif 145296341Sdelphij# ifndef OPENSSL_NO_HMAC 146296341Sdelphij# include <openssl/hmac.h> 147296341Sdelphij# endif 148296341Sdelphij# include <openssl/evp.h> 149296341Sdelphij# ifndef OPENSSL_NO_SHA 150296341Sdelphij# include <openssl/sha.h> 151296341Sdelphij# endif 152296341Sdelphij# ifndef OPENSSL_NO_RIPEMD 153296341Sdelphij# include <openssl/ripemd.h> 154296341Sdelphij# endif 155296341Sdelphij# ifndef OPENSSL_NO_WHIRLPOOL 156296341Sdelphij# include <openssl/whrlpool.h> 157296341Sdelphij# endif 158296341Sdelphij# ifndef OPENSSL_NO_RC4 159296341Sdelphij# include <openssl/rc4.h> 160296341Sdelphij# endif 161296341Sdelphij# ifndef OPENSSL_NO_RC5 162296341Sdelphij# include <openssl/rc5.h> 163296341Sdelphij# endif 164296341Sdelphij# ifndef OPENSSL_NO_RC2 165296341Sdelphij# include <openssl/rc2.h> 166296341Sdelphij# endif 167296341Sdelphij# ifndef OPENSSL_NO_IDEA 168296341Sdelphij# include <openssl/idea.h> 169296341Sdelphij# endif 170296341Sdelphij# ifndef OPENSSL_NO_SEED 171296341Sdelphij# include <openssl/seed.h> 172296341Sdelphij# endif 173296341Sdelphij# ifndef OPENSSL_NO_BF 174296341Sdelphij# include <openssl/blowfish.h> 175296341Sdelphij# endif 176296341Sdelphij# ifndef OPENSSL_NO_CAST 177296341Sdelphij# include <openssl/cast.h> 178296341Sdelphij# endif 179296341Sdelphij# ifndef OPENSSL_NO_RSA 180296341Sdelphij# include <openssl/rsa.h> 181296341Sdelphij# include "./testrsa.h" 182296341Sdelphij# endif 183296341Sdelphij# include <openssl/x509.h> 184296341Sdelphij# ifndef OPENSSL_NO_DSA 185296341Sdelphij# include <openssl/dsa.h> 186296341Sdelphij# include "./testdsa.h" 187296341Sdelphij# endif 188296341Sdelphij# ifndef OPENSSL_NO_ECDSA 189296341Sdelphij# include <openssl/ecdsa.h> 190296341Sdelphij# endif 191296341Sdelphij# ifndef OPENSSL_NO_ECDH 192296341Sdelphij# include <openssl/ecdh.h> 193296341Sdelphij# endif 194296341Sdelphij# include <openssl/modes.h> 19555714Skris 196296341Sdelphij# ifdef OPENSSL_FIPS 197296341Sdelphij# ifdef OPENSSL_DOING_MAKEDEPEND 198296341Sdelphij# undef AES_set_encrypt_key 199296341Sdelphij# undef AES_set_decrypt_key 200296341Sdelphij# undef DES_set_key_unchecked 201296341Sdelphij# endif 202296341Sdelphij# define BF_set_key private_BF_set_key 203296341Sdelphij# define CAST_set_key private_CAST_set_key 204296341Sdelphij# define idea_set_encrypt_key private_idea_set_encrypt_key 205296341Sdelphij# define SEED_set_key private_SEED_set_key 206296341Sdelphij# define RC2_set_key private_RC2_set_key 207296341Sdelphij# define RC4_set_key private_RC4_set_key 208296341Sdelphij# define DES_set_key_unchecked private_DES_set_key_unchecked 209296341Sdelphij# define AES_set_encrypt_key private_AES_set_encrypt_key 210296341Sdelphij# define AES_set_decrypt_key private_AES_set_decrypt_key 211296341Sdelphij# define Camellia_set_key private_Camellia_set_key 212296341Sdelphij# endif 21355714Skris 214296341Sdelphij# ifndef HAVE_FORK 215296341Sdelphij# if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_MACINTOSH_CLASSIC) || defined(OPENSSL_SYS_OS2) || defined(OPENSSL_SYS_NETWARE) 216296341Sdelphij# define HAVE_FORK 0 217296341Sdelphij# else 218296341Sdelphij# define HAVE_FORK 1 219296341Sdelphij# endif 220296341Sdelphij# endif 221296341Sdelphij 222296341Sdelphij# if HAVE_FORK 223296341Sdelphij# undef NO_FORK 224206046Ssimon# else 225296341Sdelphij# define NO_FORK 226206046Ssimon# endif 227206046Ssimon 228296341Sdelphij# undef BUFSIZE 229296341Sdelphij# define BUFSIZE ((long)1024*8+1) 230296341Sdelphijstatic volatile int run = 0; 231110007Smarkm 232296341Sdelphijstatic int mr = 0; 233296341Sdelphijstatic int usertime = 1; 23455714Skris 235110007Smarkmstatic double Time_F(int s); 236296341Sdelphijstatic void print_message(const char *s, long num, int length); 237160817Ssimonstatic void pkey_print_message(const char *str, const char *str2, 238296341Sdelphij long num, int bits, int sec); 239296341Sdelphijstatic void print_result(int alg, int run_no, int count, double time_used); 240296341Sdelphij# ifndef NO_FORK 241110007Smarkmstatic int do_multi(int multi); 242296341Sdelphij# endif 243110007Smarkm 244296341Sdelphij# define ALGOR_NUM 30 245296341Sdelphij# define SIZE_NUM 5 246296341Sdelphij# define RSA_NUM 4 247296341Sdelphij# define DSA_NUM 3 248160817Ssimon 249296341Sdelphij# define EC_NUM 16 250296341Sdelphij# define MAX_ECDH_SIZE 256 251160817Ssimon 252296341Sdelphijstatic const char *names[ALGOR_NUM] = { 253296341Sdelphij "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4", 254296341Sdelphij "des cbc", "des ede3", "idea cbc", "seed cbc", 255296341Sdelphij "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc", 256296341Sdelphij "aes-128 cbc", "aes-192 cbc", "aes-256 cbc", 257296341Sdelphij "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc", 258296341Sdelphij "evp", "sha256", "sha512", "whirlpool", 259296341Sdelphij "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash" 260296341Sdelphij}; 261296341Sdelphij 262110007Smarkmstatic double results[ALGOR_NUM][SIZE_NUM]; 263296341Sdelphijstatic int lengths[SIZE_NUM] = { 16, 64, 256, 1024, 8 * 1024 }; 264296341Sdelphij 265296341Sdelphij# ifndef OPENSSL_NO_RSA 266110007Smarkmstatic double rsa_results[RSA_NUM][2]; 267296341Sdelphij# endif 268296341Sdelphij# ifndef OPENSSL_NO_DSA 269110007Smarkmstatic double dsa_results[DSA_NUM][2]; 270296341Sdelphij# endif 271296341Sdelphij# ifndef OPENSSL_NO_ECDSA 272160817Ssimonstatic double ecdsa_results[EC_NUM][2]; 273296341Sdelphij# endif 274296341Sdelphij# ifndef OPENSSL_NO_ECDH 275160817Ssimonstatic double ecdh_results[EC_NUM][1]; 276296341Sdelphij# endif 277110007Smarkm 278296341Sdelphij# if defined(OPENSSL_NO_DSA) && !(defined(OPENSSL_NO_ECDSA) && defined(OPENSSL_NO_ECDH)) 279296341Sdelphijstatic const char rnd_seed[] = 280296341Sdelphij "string to make the random number generator think it has entropy"; 281160817Ssimonstatic int rnd_fake = 0; 282296341Sdelphij# endif 283160817Ssimon 284296341Sdelphij# ifdef SIGALRM 285296341Sdelphij# if defined(__STDC__) || defined(sgi) || defined(_AIX) 286296341Sdelphij# define SIGRETTYPE void 287296341Sdelphij# else 288296341Sdelphij# define SIGRETTYPE int 289296341Sdelphij# endif 29055714Skris 29155714Skrisstatic SIGRETTYPE sig_done(int sig); 29255714Skrisstatic SIGRETTYPE sig_done(int sig) 293296341Sdelphij{ 294296341Sdelphij signal(SIGALRM, sig_done); 295296341Sdelphij run = 0; 296296341Sdelphij# ifdef LINT 297296341Sdelphij sig = sig; 298296341Sdelphij# endif 299296341Sdelphij} 300296341Sdelphij# endif 30155714Skris 302296341Sdelphij# define START 0 303296341Sdelphij# define STOP 1 30455714Skris 305296341Sdelphij# if defined(_WIN32) 306160817Ssimon 307296341Sdelphij# if !defined(SIGALRM) 308296341Sdelphij# define SIGALRM 309296341Sdelphij# endif 310296341Sdelphijstatic unsigned int lapse, schlock; 311296341Sdelphijstatic void alarm_win32(unsigned int secs) 312296341Sdelphij{ 313296341Sdelphij lapse = secs * 1000; 314296341Sdelphij} 315238405Sjkim 316296341Sdelphij# define alarm alarm_win32 31755714Skris 318296341Sdelphijstatic DWORD WINAPI sleepy(VOID * arg) 319296341Sdelphij{ 320296341Sdelphij schlock = 1; 321296341Sdelphij Sleep(lapse); 322296341Sdelphij run = 0; 323296341Sdelphij return 0; 324296341Sdelphij} 325296341Sdelphij 326160817Ssimonstatic double Time_F(int s) 327296341Sdelphij{ 328296341Sdelphij if (s == START) { 329296341Sdelphij HANDLE thr; 330296341Sdelphij schlock = 0; 331296341Sdelphij thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL); 332296341Sdelphij if (thr == NULL) { 333296341Sdelphij DWORD ret = GetLastError(); 334296341Sdelphij BIO_printf(bio_err, "unable to CreateThread (%d)", ret); 335296341Sdelphij ExitProcess(ret); 336296341Sdelphij } 337296341Sdelphij CloseHandle(thr); /* detach the thread */ 338296341Sdelphij while (!schlock) 339296341Sdelphij Sleep(0); /* scheduler spinlock */ 340296341Sdelphij } 34168654Skris 342296341Sdelphij return app_tminterval(s, usertime); 343296341Sdelphij} 344296341Sdelphij# else 34555714Skris 346238405Sjkimstatic double Time_F(int s) 347296341Sdelphij{ 348296341Sdelphij return app_tminterval(s, usertime); 349296341Sdelphij} 350296341Sdelphij# endif 35155714Skris 352296341Sdelphij# ifndef OPENSSL_NO_ECDH 353160817Ssimonstatic const int KDF1_SHA1_len = 20; 354296341Sdelphijstatic void *KDF1_SHA1(const void *in, size_t inlen, void *out, 355296341Sdelphij size_t *outlen) 356296341Sdelphij{ 357296341Sdelphij# ifndef OPENSSL_NO_SHA 358296341Sdelphij if (*outlen < SHA_DIGEST_LENGTH) 359296341Sdelphij return NULL; 360296341Sdelphij else 361296341Sdelphij *outlen = SHA_DIGEST_LENGTH; 362296341Sdelphij return SHA1(in, inlen, out); 363296341Sdelphij# else 364296341Sdelphij return NULL; 365296341Sdelphij# endif /* OPENSSL_NO_SHA */ 366296341Sdelphij} 367296341Sdelphij# endif /* OPENSSL_NO_ECDH */ 368160817Ssimon 36959194Skrisint MAIN(int, char **); 37059194Skris 37155714Skrisint MAIN(int argc, char **argv) 372296341Sdelphij{ 373296341Sdelphij unsigned char *buf = NULL, *buf2 = NULL; 374296341Sdelphij int mret = 1; 375296341Sdelphij long count = 0, save_count = 0; 376296341Sdelphij int i, j, k; 377296341Sdelphij# if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) 378296341Sdelphij long rsa_count; 379296341Sdelphij# endif 380296341Sdelphij# ifndef OPENSSL_NO_RSA 381296341Sdelphij unsigned rsa_num; 382296341Sdelphij# endif 383296341Sdelphij unsigned char md[EVP_MAX_MD_SIZE]; 384296341Sdelphij# ifndef OPENSSL_NO_MD2 385296341Sdelphij unsigned char md2[MD2_DIGEST_LENGTH]; 386296341Sdelphij# endif 387296341Sdelphij# ifndef OPENSSL_NO_MDC2 388296341Sdelphij unsigned char mdc2[MDC2_DIGEST_LENGTH]; 389296341Sdelphij# endif 390296341Sdelphij# ifndef OPENSSL_NO_MD4 391296341Sdelphij unsigned char md4[MD4_DIGEST_LENGTH]; 392296341Sdelphij# endif 393296341Sdelphij# ifndef OPENSSL_NO_MD5 394296341Sdelphij unsigned char md5[MD5_DIGEST_LENGTH]; 395296341Sdelphij unsigned char hmac[MD5_DIGEST_LENGTH]; 396296341Sdelphij# endif 397296341Sdelphij# ifndef OPENSSL_NO_SHA 398296341Sdelphij unsigned char sha[SHA_DIGEST_LENGTH]; 399296341Sdelphij# ifndef OPENSSL_NO_SHA256 400296341Sdelphij unsigned char sha256[SHA256_DIGEST_LENGTH]; 401296341Sdelphij# endif 402296341Sdelphij# ifndef OPENSSL_NO_SHA512 403296341Sdelphij unsigned char sha512[SHA512_DIGEST_LENGTH]; 404296341Sdelphij# endif 405296341Sdelphij# endif 406296341Sdelphij# ifndef OPENSSL_NO_WHIRLPOOL 407296341Sdelphij unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH]; 408296341Sdelphij# endif 409296341Sdelphij# ifndef OPENSSL_NO_RIPEMD 410296341Sdelphij unsigned char rmd160[RIPEMD160_DIGEST_LENGTH]; 411296341Sdelphij# endif 412296341Sdelphij# ifndef OPENSSL_NO_RC4 413296341Sdelphij RC4_KEY rc4_ks; 414296341Sdelphij# endif 415296341Sdelphij# ifndef OPENSSL_NO_RC5 416296341Sdelphij RC5_32_KEY rc5_ks; 417296341Sdelphij# endif 418296341Sdelphij# ifndef OPENSSL_NO_RC2 419296341Sdelphij RC2_KEY rc2_ks; 420296341Sdelphij# endif 421296341Sdelphij# ifndef OPENSSL_NO_IDEA 422296341Sdelphij IDEA_KEY_SCHEDULE idea_ks; 423296341Sdelphij# endif 424296341Sdelphij# ifndef OPENSSL_NO_SEED 425296341Sdelphij SEED_KEY_SCHEDULE seed_ks; 426296341Sdelphij# endif 427296341Sdelphij# ifndef OPENSSL_NO_BF 428296341Sdelphij BF_KEY bf_ks; 429296341Sdelphij# endif 430296341Sdelphij# ifndef OPENSSL_NO_CAST 431296341Sdelphij CAST_KEY cast_ks; 432296341Sdelphij# endif 433296341Sdelphij static const unsigned char key16[16] = { 434296341Sdelphij 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 435296341Sdelphij 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12 436296341Sdelphij }; 437296341Sdelphij# ifndef OPENSSL_NO_AES 438296341Sdelphij static const unsigned char key24[24] = { 439296341Sdelphij 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 440296341Sdelphij 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 441296341Sdelphij 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 442296341Sdelphij }; 443296341Sdelphij static const unsigned char key32[32] = { 444296341Sdelphij 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 445296341Sdelphij 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 446296341Sdelphij 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 447296341Sdelphij 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56 448296341Sdelphij }; 449296341Sdelphij# endif 450296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 451296341Sdelphij static const unsigned char ckey24[24] = { 452296341Sdelphij 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 453296341Sdelphij 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 454296341Sdelphij 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 455296341Sdelphij }; 456296341Sdelphij static const unsigned char ckey32[32] = { 457296341Sdelphij 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 458296341Sdelphij 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 459296341Sdelphij 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 460296341Sdelphij 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34, 0x56 461296341Sdelphij }; 462296341Sdelphij# endif 463296341Sdelphij# ifndef OPENSSL_NO_AES 464296341Sdelphij# define MAX_BLOCK_SIZE 128 465296341Sdelphij# else 466296341Sdelphij# define MAX_BLOCK_SIZE 64 467296341Sdelphij# endif 468296341Sdelphij unsigned char DES_iv[8]; 469296341Sdelphij unsigned char iv[2 * MAX_BLOCK_SIZE / 8]; 470296341Sdelphij# ifndef OPENSSL_NO_DES 471296341Sdelphij static DES_cblock key = 472296341Sdelphij { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 }; 473296341Sdelphij static DES_cblock key2 = 474296341Sdelphij { 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12 }; 475296341Sdelphij static DES_cblock key3 = 476296341Sdelphij { 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0, 0x12, 0x34 }; 477296341Sdelphij DES_key_schedule sch; 478296341Sdelphij DES_key_schedule sch2; 479296341Sdelphij DES_key_schedule sch3; 480296341Sdelphij# endif 481296341Sdelphij# ifndef OPENSSL_NO_AES 482296341Sdelphij AES_KEY aes_ks1, aes_ks2, aes_ks3; 483296341Sdelphij# endif 484296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 485296341Sdelphij CAMELLIA_KEY camellia_ks1, camellia_ks2, camellia_ks3; 486296341Sdelphij# endif 487296341Sdelphij# define D_MD2 0 488296341Sdelphij# define D_MDC2 1 489296341Sdelphij# define D_MD4 2 490296341Sdelphij# define D_MD5 3 491296341Sdelphij# define D_HMAC 4 492296341Sdelphij# define D_SHA1 5 493296341Sdelphij# define D_RMD160 6 494296341Sdelphij# define D_RC4 7 495296341Sdelphij# define D_CBC_DES 8 496296341Sdelphij# define D_EDE3_DES 9 497296341Sdelphij# define D_CBC_IDEA 10 498296341Sdelphij# define D_CBC_SEED 11 499296341Sdelphij# define D_CBC_RC2 12 500296341Sdelphij# define D_CBC_RC5 13 501296341Sdelphij# define D_CBC_BF 14 502296341Sdelphij# define D_CBC_CAST 15 503296341Sdelphij# define D_CBC_128_AES 16 504296341Sdelphij# define D_CBC_192_AES 17 505296341Sdelphij# define D_CBC_256_AES 18 506296341Sdelphij# define D_CBC_128_CML 19 507296341Sdelphij# define D_CBC_192_CML 20 508296341Sdelphij# define D_CBC_256_CML 21 509296341Sdelphij# define D_EVP 22 510296341Sdelphij# define D_SHA256 23 511296341Sdelphij# define D_SHA512 24 512296341Sdelphij# define D_WHIRLPOOL 25 513296341Sdelphij# define D_IGE_128_AES 26 514296341Sdelphij# define D_IGE_192_AES 27 515296341Sdelphij# define D_IGE_256_AES 28 516296341Sdelphij# define D_GHASH 29 517296341Sdelphij double d = 0.0; 518296341Sdelphij long c[ALGOR_NUM][SIZE_NUM]; 519296341Sdelphij# define R_DSA_512 0 520296341Sdelphij# define R_DSA_1024 1 521296341Sdelphij# define R_DSA_2048 2 522296341Sdelphij# define R_RSA_512 0 523296341Sdelphij# define R_RSA_1024 1 524296341Sdelphij# define R_RSA_2048 2 525296341Sdelphij# define R_RSA_4096 3 526160817Ssimon 527296341Sdelphij# define R_EC_P160 0 528296341Sdelphij# define R_EC_P192 1 529296341Sdelphij# define R_EC_P224 2 530296341Sdelphij# define R_EC_P256 3 531296341Sdelphij# define R_EC_P384 4 532296341Sdelphij# define R_EC_P521 5 533296341Sdelphij# define R_EC_K163 6 534296341Sdelphij# define R_EC_K233 7 535296341Sdelphij# define R_EC_K283 8 536296341Sdelphij# define R_EC_K409 9 537296341Sdelphij# define R_EC_K571 10 538296341Sdelphij# define R_EC_B163 11 539296341Sdelphij# define R_EC_B233 12 540296341Sdelphij# define R_EC_B283 13 541296341Sdelphij# define R_EC_B409 14 542296341Sdelphij# define R_EC_B571 15 543160817Ssimon 544296341Sdelphij# ifndef OPENSSL_NO_RSA 545296341Sdelphij RSA *rsa_key[RSA_NUM]; 546296341Sdelphij long rsa_c[RSA_NUM][2]; 547296341Sdelphij static unsigned int rsa_bits[RSA_NUM] = { 548296341Sdelphij 512, 1024, 2048, 4096 549296341Sdelphij }; 550296341Sdelphij static unsigned char *rsa_data[RSA_NUM] = { 551296341Sdelphij test512, test1024, test2048, test4096 552296341Sdelphij }; 553296341Sdelphij static int rsa_data_length[RSA_NUM] = { 554296341Sdelphij sizeof(test512), sizeof(test1024), 555296341Sdelphij sizeof(test2048), sizeof(test4096) 556296341Sdelphij }; 557296341Sdelphij# endif 558296341Sdelphij# ifndef OPENSSL_NO_DSA 559296341Sdelphij DSA *dsa_key[DSA_NUM]; 560296341Sdelphij long dsa_c[DSA_NUM][2]; 561296341Sdelphij static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 }; 562296341Sdelphij# endif 563296341Sdelphij# ifndef OPENSSL_NO_EC 564296341Sdelphij /* 565296341Sdelphij * We only test over the following curves as they are representative, To 566296341Sdelphij * add tests over more curves, simply add the curve NID and curve name to 567296341Sdelphij * the following arrays and increase the EC_NUM value accordingly. 568296341Sdelphij */ 569296341Sdelphij static unsigned int test_curves[EC_NUM] = { 570296341Sdelphij /* Prime Curves */ 571296341Sdelphij NID_secp160r1, 572296341Sdelphij NID_X9_62_prime192v1, 573296341Sdelphij NID_secp224r1, 574296341Sdelphij NID_X9_62_prime256v1, 575296341Sdelphij NID_secp384r1, 576296341Sdelphij NID_secp521r1, 577296341Sdelphij /* Binary Curves */ 578296341Sdelphij NID_sect163k1, 579296341Sdelphij NID_sect233k1, 580296341Sdelphij NID_sect283k1, 581296341Sdelphij NID_sect409k1, 582296341Sdelphij NID_sect571k1, 583296341Sdelphij NID_sect163r2, 584296341Sdelphij NID_sect233r1, 585296341Sdelphij NID_sect283r1, 586296341Sdelphij NID_sect409r1, 587296341Sdelphij NID_sect571r1 588296341Sdelphij }; 589296341Sdelphij static const char *test_curves_names[EC_NUM] = { 590296341Sdelphij /* Prime Curves */ 591296341Sdelphij "secp160r1", 592296341Sdelphij "nistp192", 593296341Sdelphij "nistp224", 594296341Sdelphij "nistp256", 595296341Sdelphij "nistp384", 596296341Sdelphij "nistp521", 597296341Sdelphij /* Binary Curves */ 598296341Sdelphij "nistk163", 599296341Sdelphij "nistk233", 600296341Sdelphij "nistk283", 601296341Sdelphij "nistk409", 602296341Sdelphij "nistk571", 603296341Sdelphij "nistb163", 604296341Sdelphij "nistb233", 605296341Sdelphij "nistb283", 606296341Sdelphij "nistb409", 607296341Sdelphij "nistb571" 608296341Sdelphij }; 609296341Sdelphij static int test_curves_bits[EC_NUM] = { 610160817Ssimon 160, 192, 224, 256, 384, 521, 611160817Ssimon 163, 233, 283, 409, 571, 612160817Ssimon 163, 233, 283, 409, 571 613296341Sdelphij }; 614160817Ssimon 615296341Sdelphij# endif 616160817Ssimon 617296341Sdelphij# ifndef OPENSSL_NO_ECDSA 618296341Sdelphij unsigned char ecdsasig[256]; 619296341Sdelphij unsigned int ecdsasiglen; 620296341Sdelphij EC_KEY *ecdsa[EC_NUM]; 621296341Sdelphij long ecdsa_c[EC_NUM][2]; 622296341Sdelphij# endif 623160817Ssimon 624296341Sdelphij# ifndef OPENSSL_NO_ECDH 625296341Sdelphij EC_KEY *ecdh_a[EC_NUM], *ecdh_b[EC_NUM]; 626296341Sdelphij unsigned char secret_a[MAX_ECDH_SIZE], secret_b[MAX_ECDH_SIZE]; 627296341Sdelphij int secret_size_a, secret_size_b; 628296341Sdelphij int ecdh_checks = 0; 629296341Sdelphij int secret_idx = 0; 630296341Sdelphij long ecdh_c[EC_NUM][2]; 631296341Sdelphij# endif 632160817Ssimon 633296341Sdelphij int rsa_doit[RSA_NUM]; 634296341Sdelphij int dsa_doit[DSA_NUM]; 635296341Sdelphij# ifndef OPENSSL_NO_ECDSA 636296341Sdelphij int ecdsa_doit[EC_NUM]; 637296341Sdelphij# endif 638296341Sdelphij# ifndef OPENSSL_NO_ECDH 639296341Sdelphij int ecdh_doit[EC_NUM]; 640296341Sdelphij# endif 641296341Sdelphij int doit[ALGOR_NUM]; 642296341Sdelphij int pr_header = 0; 643296341Sdelphij const EVP_CIPHER *evp_cipher = NULL; 644296341Sdelphij const EVP_MD *evp_md = NULL; 645296341Sdelphij int decrypt = 0; 646296341Sdelphij# ifndef NO_FORK 647296341Sdelphij int multi = 0; 648296341Sdelphij# endif 64955714Skris 650296341Sdelphij# ifndef TIMES 651296341Sdelphij usertime = -1; 652296341Sdelphij# endif 65368654Skris 654296341Sdelphij apps_startup(); 655296341Sdelphij memset(results, 0, sizeof(results)); 656296341Sdelphij# ifndef OPENSSL_NO_DSA 657296341Sdelphij memset(dsa_key, 0, sizeof(dsa_key)); 658296341Sdelphij# endif 659296341Sdelphij# ifndef OPENSSL_NO_ECDSA 660296341Sdelphij for (i = 0; i < EC_NUM; i++) 661296341Sdelphij ecdsa[i] = NULL; 662296341Sdelphij# endif 663296341Sdelphij# ifndef OPENSSL_NO_ECDH 664296341Sdelphij for (i = 0; i < EC_NUM; i++) { 665296341Sdelphij ecdh_a[i] = NULL; 666296341Sdelphij ecdh_b[i] = NULL; 667296341Sdelphij } 668296341Sdelphij# endif 66955714Skris 670296341Sdelphij if (bio_err == NULL) 671296341Sdelphij if ((bio_err = BIO_new(BIO_s_file())) != NULL) 672296341Sdelphij BIO_set_fp(bio_err, stderr, BIO_NOCLOSE | BIO_FP_TEXT); 673160817Ssimon 674296341Sdelphij if (!load_config(bio_err, NULL)) 675296341Sdelphij goto end; 67655714Skris 677296341Sdelphij# ifndef OPENSSL_NO_RSA 678296341Sdelphij memset(rsa_key, 0, sizeof(rsa_key)); 679296341Sdelphij for (i = 0; i < RSA_NUM; i++) 680296341Sdelphij rsa_key[i] = NULL; 681296341Sdelphij# endif 682110007Smarkm 683296341Sdelphij if ((buf = (unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL) { 684296341Sdelphij BIO_printf(bio_err, "out of memory\n"); 685296341Sdelphij goto end; 686296341Sdelphij } 687296341Sdelphij if ((buf2 = (unsigned char *)OPENSSL_malloc((int)BUFSIZE)) == NULL) { 688296341Sdelphij BIO_printf(bio_err, "out of memory\n"); 689296341Sdelphij goto end; 690296341Sdelphij } 69155714Skris 692296341Sdelphij memset(c, 0, sizeof(c)); 693296341Sdelphij memset(DES_iv, 0, sizeof(DES_iv)); 694296341Sdelphij memset(iv, 0, sizeof(iv)); 69555714Skris 696296341Sdelphij for (i = 0; i < ALGOR_NUM; i++) 697296341Sdelphij doit[i] = 0; 698296341Sdelphij for (i = 0; i < RSA_NUM; i++) 699296341Sdelphij rsa_doit[i] = 0; 700296341Sdelphij for (i = 0; i < DSA_NUM; i++) 701296341Sdelphij dsa_doit[i] = 0; 702296341Sdelphij# ifndef OPENSSL_NO_ECDSA 703296341Sdelphij for (i = 0; i < EC_NUM; i++) 704296341Sdelphij ecdsa_doit[i] = 0; 705296341Sdelphij# endif 706296341Sdelphij# ifndef OPENSSL_NO_ECDH 707296341Sdelphij for (i = 0; i < EC_NUM; i++) 708296341Sdelphij ecdh_doit[i] = 0; 709296341Sdelphij# endif 71055714Skris 711296341Sdelphij j = 0; 712296341Sdelphij argc--; 713296341Sdelphij argv++; 714296341Sdelphij while (argc) { 715296341Sdelphij if ((argc > 0) && (strcmp(*argv, "-elapsed") == 0)) { 716296341Sdelphij usertime = 0; 717296341Sdelphij j--; /* Otherwise, -elapsed gets confused with an 718296341Sdelphij * algorithm. */ 719296341Sdelphij } else if ((argc > 0) && (strcmp(*argv, "-evp") == 0)) { 720296341Sdelphij argc--; 721296341Sdelphij argv++; 722296341Sdelphij if (argc == 0) { 723296341Sdelphij BIO_printf(bio_err, "no EVP given\n"); 724296341Sdelphij goto end; 725296341Sdelphij } 726296341Sdelphij evp_cipher = EVP_get_cipherbyname(*argv); 727296341Sdelphij if (!evp_cipher) { 728296341Sdelphij evp_md = EVP_get_digestbyname(*argv); 729296341Sdelphij } 730296341Sdelphij if (!evp_cipher && !evp_md) { 731296341Sdelphij BIO_printf(bio_err, "%s is an unknown cipher or digest\n", 732296341Sdelphij *argv); 733296341Sdelphij goto end; 734296341Sdelphij } 735296341Sdelphij doit[D_EVP] = 1; 736296341Sdelphij } else if (argc > 0 && !strcmp(*argv, "-decrypt")) { 737296341Sdelphij decrypt = 1; 738296341Sdelphij j--; /* Otherwise, -elapsed gets confused with an 739296341Sdelphij * algorithm. */ 740296341Sdelphij } 741296341Sdelphij# ifndef OPENSSL_NO_ENGINE 742296341Sdelphij else if ((argc > 0) && (strcmp(*argv, "-engine") == 0)) { 743296341Sdelphij argc--; 744296341Sdelphij argv++; 745296341Sdelphij if (argc == 0) { 746296341Sdelphij BIO_printf(bio_err, "no engine given\n"); 747296341Sdelphij goto end; 748296341Sdelphij } 749296341Sdelphij setup_engine(bio_err, *argv, 0); 750296341Sdelphij /* 751296341Sdelphij * j will be increased again further down. We just don't want 752296341Sdelphij * speed to confuse an engine with an algorithm, especially when 753296341Sdelphij * none is given (which means all of them should be run) 754296341Sdelphij */ 755296341Sdelphij j--; 756296341Sdelphij } 757296341Sdelphij# endif 758296341Sdelphij# ifndef NO_FORK 759296341Sdelphij else if ((argc > 0) && (strcmp(*argv, "-multi") == 0)) { 760296341Sdelphij argc--; 761296341Sdelphij argv++; 762296341Sdelphij if (argc == 0) { 763296341Sdelphij BIO_printf(bio_err, "no multi count given\n"); 764296341Sdelphij goto end; 765296341Sdelphij } 766296341Sdelphij multi = atoi(argv[0]); 767296341Sdelphij if (multi <= 0) { 768296341Sdelphij BIO_printf(bio_err, "bad multi count\n"); 769296341Sdelphij goto end; 770296341Sdelphij } 771296341Sdelphij j--; /* Otherwise, -mr gets confused with an 772296341Sdelphij * algorithm. */ 773296341Sdelphij } 774296341Sdelphij# endif 775296341Sdelphij else if (argc > 0 && !strcmp(*argv, "-mr")) { 776296341Sdelphij mr = 1; 777296341Sdelphij j--; /* Otherwise, -mr gets confused with an 778296341Sdelphij * algorithm. */ 779296341Sdelphij } else 780296341Sdelphij# ifndef OPENSSL_NO_MD2 781296341Sdelphij if (strcmp(*argv, "md2") == 0) 782296341Sdelphij doit[D_MD2] = 1; 783296341Sdelphij else 784296341Sdelphij# endif 785296341Sdelphij# ifndef OPENSSL_NO_MDC2 786296341Sdelphij if (strcmp(*argv, "mdc2") == 0) 787296341Sdelphij doit[D_MDC2] = 1; 788296341Sdelphij else 789296341Sdelphij# endif 790296341Sdelphij# ifndef OPENSSL_NO_MD4 791296341Sdelphij if (strcmp(*argv, "md4") == 0) 792296341Sdelphij doit[D_MD4] = 1; 793296341Sdelphij else 794296341Sdelphij# endif 795296341Sdelphij# ifndef OPENSSL_NO_MD5 796296341Sdelphij if (strcmp(*argv, "md5") == 0) 797296341Sdelphij doit[D_MD5] = 1; 798296341Sdelphij else 799296341Sdelphij# endif 800296341Sdelphij# ifndef OPENSSL_NO_MD5 801296341Sdelphij if (strcmp(*argv, "hmac") == 0) 802296341Sdelphij doit[D_HMAC] = 1; 803296341Sdelphij else 804296341Sdelphij# endif 805296341Sdelphij# ifndef OPENSSL_NO_SHA 806296341Sdelphij if (strcmp(*argv, "sha1") == 0) 807296341Sdelphij doit[D_SHA1] = 1; 808296341Sdelphij else if (strcmp(*argv, "sha") == 0) 809296341Sdelphij doit[D_SHA1] = 1, doit[D_SHA256] = 1, doit[D_SHA512] = 1; 810296341Sdelphij else 811296341Sdelphij# ifndef OPENSSL_NO_SHA256 812296341Sdelphij if (strcmp(*argv, "sha256") == 0) 813296341Sdelphij doit[D_SHA256] = 1; 814296341Sdelphij else 815296341Sdelphij# endif 816296341Sdelphij# ifndef OPENSSL_NO_SHA512 817296341Sdelphij if (strcmp(*argv, "sha512") == 0) 818296341Sdelphij doit[D_SHA512] = 1; 819296341Sdelphij else 820296341Sdelphij# endif 821296341Sdelphij# endif 822296341Sdelphij# ifndef OPENSSL_NO_WHIRLPOOL 823296341Sdelphij if (strcmp(*argv, "whirlpool") == 0) 824296341Sdelphij doit[D_WHIRLPOOL] = 1; 825296341Sdelphij else 826296341Sdelphij# endif 827296341Sdelphij# ifndef OPENSSL_NO_RIPEMD 828296341Sdelphij if (strcmp(*argv, "ripemd") == 0) 829296341Sdelphij doit[D_RMD160] = 1; 830296341Sdelphij else if (strcmp(*argv, "rmd160") == 0) 831296341Sdelphij doit[D_RMD160] = 1; 832296341Sdelphij else if (strcmp(*argv, "ripemd160") == 0) 833296341Sdelphij doit[D_RMD160] = 1; 834296341Sdelphij else 835296341Sdelphij# endif 836296341Sdelphij# ifndef OPENSSL_NO_RC4 837296341Sdelphij if (strcmp(*argv, "rc4") == 0) 838296341Sdelphij doit[D_RC4] = 1; 839296341Sdelphij else 840296341Sdelphij# endif 841296341Sdelphij# ifndef OPENSSL_NO_DES 842296341Sdelphij if (strcmp(*argv, "des-cbc") == 0) 843296341Sdelphij doit[D_CBC_DES] = 1; 844296341Sdelphij else if (strcmp(*argv, "des-ede3") == 0) 845296341Sdelphij doit[D_EDE3_DES] = 1; 846296341Sdelphij else 847296341Sdelphij# endif 848296341Sdelphij# ifndef OPENSSL_NO_AES 849296341Sdelphij if (strcmp(*argv, "aes-128-cbc") == 0) 850296341Sdelphij doit[D_CBC_128_AES] = 1; 851296341Sdelphij else if (strcmp(*argv, "aes-192-cbc") == 0) 852296341Sdelphij doit[D_CBC_192_AES] = 1; 853296341Sdelphij else if (strcmp(*argv, "aes-256-cbc") == 0) 854296341Sdelphij doit[D_CBC_256_AES] = 1; 855296341Sdelphij else if (strcmp(*argv, "aes-128-ige") == 0) 856296341Sdelphij doit[D_IGE_128_AES] = 1; 857296341Sdelphij else if (strcmp(*argv, "aes-192-ige") == 0) 858296341Sdelphij doit[D_IGE_192_AES] = 1; 859296341Sdelphij else if (strcmp(*argv, "aes-256-ige") == 0) 860296341Sdelphij doit[D_IGE_256_AES] = 1; 861296341Sdelphij else 862296341Sdelphij# endif 863296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 864296341Sdelphij if (strcmp(*argv, "camellia-128-cbc") == 0) 865296341Sdelphij doit[D_CBC_128_CML] = 1; 866296341Sdelphij else if (strcmp(*argv, "camellia-192-cbc") == 0) 867296341Sdelphij doit[D_CBC_192_CML] = 1; 868296341Sdelphij else if (strcmp(*argv, "camellia-256-cbc") == 0) 869296341Sdelphij doit[D_CBC_256_CML] = 1; 870296341Sdelphij else 871296341Sdelphij# endif 872296341Sdelphij# ifndef OPENSSL_NO_RSA 873296341Sdelphij# if 0 /* was: #ifdef RSAref */ 874296341Sdelphij if (strcmp(*argv, "rsaref") == 0) { 875296341Sdelphij RSA_set_default_openssl_method(RSA_PKCS1_RSAref()); 876296341Sdelphij j--; 877296341Sdelphij } else 878296341Sdelphij# endif 879296341Sdelphij# ifndef RSA_NULL 880296341Sdelphij if (strcmp(*argv, "openssl") == 0) { 881296341Sdelphij RSA_set_default_method(RSA_PKCS1_SSLeay()); 882296341Sdelphij j--; 883296341Sdelphij } else 884296341Sdelphij# endif 885296341Sdelphij# endif /* !OPENSSL_NO_RSA */ 886296341Sdelphij if (strcmp(*argv, "dsa512") == 0) 887296341Sdelphij dsa_doit[R_DSA_512] = 2; 888296341Sdelphij else if (strcmp(*argv, "dsa1024") == 0) 889296341Sdelphij dsa_doit[R_DSA_1024] = 2; 890296341Sdelphij else if (strcmp(*argv, "dsa2048") == 0) 891296341Sdelphij dsa_doit[R_DSA_2048] = 2; 892296341Sdelphij else if (strcmp(*argv, "rsa512") == 0) 893296341Sdelphij rsa_doit[R_RSA_512] = 2; 894296341Sdelphij else if (strcmp(*argv, "rsa1024") == 0) 895296341Sdelphij rsa_doit[R_RSA_1024] = 2; 896296341Sdelphij else if (strcmp(*argv, "rsa2048") == 0) 897296341Sdelphij rsa_doit[R_RSA_2048] = 2; 898296341Sdelphij else if (strcmp(*argv, "rsa4096") == 0) 899296341Sdelphij rsa_doit[R_RSA_4096] = 2; 900296341Sdelphij else 901296341Sdelphij# ifndef OPENSSL_NO_RC2 902296341Sdelphij if (strcmp(*argv, "rc2-cbc") == 0) 903296341Sdelphij doit[D_CBC_RC2] = 1; 904296341Sdelphij else if (strcmp(*argv, "rc2") == 0) 905296341Sdelphij doit[D_CBC_RC2] = 1; 906296341Sdelphij else 907296341Sdelphij# endif 908296341Sdelphij# ifndef OPENSSL_NO_RC5 909296341Sdelphij if (strcmp(*argv, "rc5-cbc") == 0) 910296341Sdelphij doit[D_CBC_RC5] = 1; 911296341Sdelphij else if (strcmp(*argv, "rc5") == 0) 912296341Sdelphij doit[D_CBC_RC5] = 1; 913296341Sdelphij else 914296341Sdelphij# endif 915296341Sdelphij# ifndef OPENSSL_NO_IDEA 916296341Sdelphij if (strcmp(*argv, "idea-cbc") == 0) 917296341Sdelphij doit[D_CBC_IDEA] = 1; 918296341Sdelphij else if (strcmp(*argv, "idea") == 0) 919296341Sdelphij doit[D_CBC_IDEA] = 1; 920296341Sdelphij else 921296341Sdelphij# endif 922296341Sdelphij# ifndef OPENSSL_NO_SEED 923296341Sdelphij if (strcmp(*argv, "seed-cbc") == 0) 924296341Sdelphij doit[D_CBC_SEED] = 1; 925296341Sdelphij else if (strcmp(*argv, "seed") == 0) 926296341Sdelphij doit[D_CBC_SEED] = 1; 927296341Sdelphij else 928296341Sdelphij# endif 929296341Sdelphij# ifndef OPENSSL_NO_BF 930296341Sdelphij if (strcmp(*argv, "bf-cbc") == 0) 931296341Sdelphij doit[D_CBC_BF] = 1; 932296341Sdelphij else if (strcmp(*argv, "blowfish") == 0) 933296341Sdelphij doit[D_CBC_BF] = 1; 934296341Sdelphij else if (strcmp(*argv, "bf") == 0) 935296341Sdelphij doit[D_CBC_BF] = 1; 936296341Sdelphij else 937296341Sdelphij# endif 938296341Sdelphij# ifndef OPENSSL_NO_CAST 939296341Sdelphij if (strcmp(*argv, "cast-cbc") == 0) 940296341Sdelphij doit[D_CBC_CAST] = 1; 941296341Sdelphij else if (strcmp(*argv, "cast") == 0) 942296341Sdelphij doit[D_CBC_CAST] = 1; 943296341Sdelphij else if (strcmp(*argv, "cast5") == 0) 944296341Sdelphij doit[D_CBC_CAST] = 1; 945296341Sdelphij else 946296341Sdelphij# endif 947296341Sdelphij# ifndef OPENSSL_NO_DES 948296341Sdelphij if (strcmp(*argv, "des") == 0) { 949296341Sdelphij doit[D_CBC_DES] = 1; 950296341Sdelphij doit[D_EDE3_DES] = 1; 951296341Sdelphij } else 952296341Sdelphij# endif 953296341Sdelphij# ifndef OPENSSL_NO_AES 954296341Sdelphij if (strcmp(*argv, "aes") == 0) { 955296341Sdelphij doit[D_CBC_128_AES] = 1; 956296341Sdelphij doit[D_CBC_192_AES] = 1; 957296341Sdelphij doit[D_CBC_256_AES] = 1; 958296341Sdelphij } else if (strcmp(*argv, "ghash") == 0) { 959296341Sdelphij doit[D_GHASH] = 1; 960296341Sdelphij } else 961296341Sdelphij# endif 962296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 963296341Sdelphij if (strcmp(*argv, "camellia") == 0) { 964296341Sdelphij doit[D_CBC_128_CML] = 1; 965296341Sdelphij doit[D_CBC_192_CML] = 1; 966296341Sdelphij doit[D_CBC_256_CML] = 1; 967296341Sdelphij } else 968296341Sdelphij# endif 969296341Sdelphij# ifndef OPENSSL_NO_RSA 970296341Sdelphij if (strcmp(*argv, "rsa") == 0) { 971296341Sdelphij rsa_doit[R_RSA_512] = 1; 972296341Sdelphij rsa_doit[R_RSA_1024] = 1; 973296341Sdelphij rsa_doit[R_RSA_2048] = 1; 974296341Sdelphij rsa_doit[R_RSA_4096] = 1; 975296341Sdelphij } else 976296341Sdelphij# endif 977296341Sdelphij# ifndef OPENSSL_NO_DSA 978296341Sdelphij if (strcmp(*argv, "dsa") == 0) { 979296341Sdelphij dsa_doit[R_DSA_512] = 1; 980296341Sdelphij dsa_doit[R_DSA_1024] = 1; 981296341Sdelphij dsa_doit[R_DSA_2048] = 1; 982296341Sdelphij } else 983296341Sdelphij# endif 984296341Sdelphij# ifndef OPENSSL_NO_ECDSA 985296341Sdelphij if (strcmp(*argv, "ecdsap160") == 0) 986296341Sdelphij ecdsa_doit[R_EC_P160] = 2; 987296341Sdelphij else if (strcmp(*argv, "ecdsap192") == 0) 988296341Sdelphij ecdsa_doit[R_EC_P192] = 2; 989296341Sdelphij else if (strcmp(*argv, "ecdsap224") == 0) 990296341Sdelphij ecdsa_doit[R_EC_P224] = 2; 991296341Sdelphij else if (strcmp(*argv, "ecdsap256") == 0) 992296341Sdelphij ecdsa_doit[R_EC_P256] = 2; 993296341Sdelphij else if (strcmp(*argv, "ecdsap384") == 0) 994296341Sdelphij ecdsa_doit[R_EC_P384] = 2; 995296341Sdelphij else if (strcmp(*argv, "ecdsap521") == 0) 996296341Sdelphij ecdsa_doit[R_EC_P521] = 2; 997296341Sdelphij else if (strcmp(*argv, "ecdsak163") == 0) 998296341Sdelphij ecdsa_doit[R_EC_K163] = 2; 999296341Sdelphij else if (strcmp(*argv, "ecdsak233") == 0) 1000296341Sdelphij ecdsa_doit[R_EC_K233] = 2; 1001296341Sdelphij else if (strcmp(*argv, "ecdsak283") == 0) 1002296341Sdelphij ecdsa_doit[R_EC_K283] = 2; 1003296341Sdelphij else if (strcmp(*argv, "ecdsak409") == 0) 1004296341Sdelphij ecdsa_doit[R_EC_K409] = 2; 1005296341Sdelphij else if (strcmp(*argv, "ecdsak571") == 0) 1006296341Sdelphij ecdsa_doit[R_EC_K571] = 2; 1007296341Sdelphij else if (strcmp(*argv, "ecdsab163") == 0) 1008296341Sdelphij ecdsa_doit[R_EC_B163] = 2; 1009296341Sdelphij else if (strcmp(*argv, "ecdsab233") == 0) 1010296341Sdelphij ecdsa_doit[R_EC_B233] = 2; 1011296341Sdelphij else if (strcmp(*argv, "ecdsab283") == 0) 1012296341Sdelphij ecdsa_doit[R_EC_B283] = 2; 1013296341Sdelphij else if (strcmp(*argv, "ecdsab409") == 0) 1014296341Sdelphij ecdsa_doit[R_EC_B409] = 2; 1015296341Sdelphij else if (strcmp(*argv, "ecdsab571") == 0) 1016296341Sdelphij ecdsa_doit[R_EC_B571] = 2; 1017296341Sdelphij else if (strcmp(*argv, "ecdsa") == 0) { 1018296341Sdelphij for (i = 0; i < EC_NUM; i++) 1019296341Sdelphij ecdsa_doit[i] = 1; 1020296341Sdelphij } else 1021296341Sdelphij# endif 1022296341Sdelphij# ifndef OPENSSL_NO_ECDH 1023296341Sdelphij if (strcmp(*argv, "ecdhp160") == 0) 1024296341Sdelphij ecdh_doit[R_EC_P160] = 2; 1025296341Sdelphij else if (strcmp(*argv, "ecdhp192") == 0) 1026296341Sdelphij ecdh_doit[R_EC_P192] = 2; 1027296341Sdelphij else if (strcmp(*argv, "ecdhp224") == 0) 1028296341Sdelphij ecdh_doit[R_EC_P224] = 2; 1029296341Sdelphij else if (strcmp(*argv, "ecdhp256") == 0) 1030296341Sdelphij ecdh_doit[R_EC_P256] = 2; 1031296341Sdelphij else if (strcmp(*argv, "ecdhp384") == 0) 1032296341Sdelphij ecdh_doit[R_EC_P384] = 2; 1033296341Sdelphij else if (strcmp(*argv, "ecdhp521") == 0) 1034296341Sdelphij ecdh_doit[R_EC_P521] = 2; 1035296341Sdelphij else if (strcmp(*argv, "ecdhk163") == 0) 1036296341Sdelphij ecdh_doit[R_EC_K163] = 2; 1037296341Sdelphij else if (strcmp(*argv, "ecdhk233") == 0) 1038296341Sdelphij ecdh_doit[R_EC_K233] = 2; 1039296341Sdelphij else if (strcmp(*argv, "ecdhk283") == 0) 1040296341Sdelphij ecdh_doit[R_EC_K283] = 2; 1041296341Sdelphij else if (strcmp(*argv, "ecdhk409") == 0) 1042296341Sdelphij ecdh_doit[R_EC_K409] = 2; 1043296341Sdelphij else if (strcmp(*argv, "ecdhk571") == 0) 1044296341Sdelphij ecdh_doit[R_EC_K571] = 2; 1045296341Sdelphij else if (strcmp(*argv, "ecdhb163") == 0) 1046296341Sdelphij ecdh_doit[R_EC_B163] = 2; 1047296341Sdelphij else if (strcmp(*argv, "ecdhb233") == 0) 1048296341Sdelphij ecdh_doit[R_EC_B233] = 2; 1049296341Sdelphij else if (strcmp(*argv, "ecdhb283") == 0) 1050296341Sdelphij ecdh_doit[R_EC_B283] = 2; 1051296341Sdelphij else if (strcmp(*argv, "ecdhb409") == 0) 1052296341Sdelphij ecdh_doit[R_EC_B409] = 2; 1053296341Sdelphij else if (strcmp(*argv, "ecdhb571") == 0) 1054296341Sdelphij ecdh_doit[R_EC_B571] = 2; 1055296341Sdelphij else if (strcmp(*argv, "ecdh") == 0) { 1056296341Sdelphij for (i = 0; i < EC_NUM; i++) 1057296341Sdelphij ecdh_doit[i] = 1; 1058296341Sdelphij } else 1059296341Sdelphij# endif 1060296341Sdelphij { 1061296341Sdelphij BIO_printf(bio_err, "Error: bad option or value\n"); 1062296341Sdelphij BIO_printf(bio_err, "\n"); 1063296341Sdelphij BIO_printf(bio_err, "Available values:\n"); 1064296341Sdelphij# ifndef OPENSSL_NO_MD2 1065296341Sdelphij BIO_printf(bio_err, "md2 "); 1066296341Sdelphij# endif 1067296341Sdelphij# ifndef OPENSSL_NO_MDC2 1068296341Sdelphij BIO_printf(bio_err, "mdc2 "); 1069296341Sdelphij# endif 1070296341Sdelphij# ifndef OPENSSL_NO_MD4 1071296341Sdelphij BIO_printf(bio_err, "md4 "); 1072296341Sdelphij# endif 1073296341Sdelphij# ifndef OPENSSL_NO_MD5 1074296341Sdelphij BIO_printf(bio_err, "md5 "); 1075296341Sdelphij# ifndef OPENSSL_NO_HMAC 1076296341Sdelphij BIO_printf(bio_err, "hmac "); 1077296341Sdelphij# endif 1078296341Sdelphij# endif 1079296341Sdelphij# ifndef OPENSSL_NO_SHA1 1080296341Sdelphij BIO_printf(bio_err, "sha1 "); 1081296341Sdelphij# endif 1082296341Sdelphij# ifndef OPENSSL_NO_SHA256 1083296341Sdelphij BIO_printf(bio_err, "sha256 "); 1084296341Sdelphij# endif 1085296341Sdelphij# ifndef OPENSSL_NO_SHA512 1086296341Sdelphij BIO_printf(bio_err, "sha512 "); 1087296341Sdelphij# endif 1088296341Sdelphij# ifndef OPENSSL_NO_WHIRLPOOL 1089296341Sdelphij BIO_printf(bio_err, "whirlpool"); 1090296341Sdelphij# endif 1091296341Sdelphij# ifndef OPENSSL_NO_RIPEMD160 1092296341Sdelphij BIO_printf(bio_err, "rmd160"); 1093296341Sdelphij# endif 1094296341Sdelphij# if !defined(OPENSSL_NO_MD2) || !defined(OPENSSL_NO_MDC2) || \ 1095110007Smarkm !defined(OPENSSL_NO_MD4) || !defined(OPENSSL_NO_MD5) || \ 1096238405Sjkim !defined(OPENSSL_NO_SHA1) || !defined(OPENSSL_NO_RIPEMD160) || \ 1097238405Sjkim !defined(OPENSSL_NO_WHIRLPOOL) 1098296341Sdelphij BIO_printf(bio_err, "\n"); 1099296341Sdelphij# endif 110068654Skris 1101296341Sdelphij# ifndef OPENSSL_NO_IDEA 1102296341Sdelphij BIO_printf(bio_err, "idea-cbc "); 1103296341Sdelphij# endif 1104296341Sdelphij# ifndef OPENSSL_NO_SEED 1105296341Sdelphij BIO_printf(bio_err, "seed-cbc "); 1106296341Sdelphij# endif 1107296341Sdelphij# ifndef OPENSSL_NO_RC2 1108296341Sdelphij BIO_printf(bio_err, "rc2-cbc "); 1109296341Sdelphij# endif 1110296341Sdelphij# ifndef OPENSSL_NO_RC5 1111296341Sdelphij BIO_printf(bio_err, "rc5-cbc "); 1112296341Sdelphij# endif 1113296341Sdelphij# ifndef OPENSSL_NO_BF 1114296341Sdelphij BIO_printf(bio_err, "bf-cbc"); 1115296341Sdelphij# endif 1116296341Sdelphij# if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || !defined(OPENSSL_NO_RC2) || \ 1117110007Smarkm !defined(OPENSSL_NO_BF) || !defined(OPENSSL_NO_RC5) 1118296341Sdelphij BIO_printf(bio_err, "\n"); 1119296341Sdelphij# endif 1120296341Sdelphij# ifndef OPENSSL_NO_DES 1121296341Sdelphij BIO_printf(bio_err, "des-cbc des-ede3 "); 1122296341Sdelphij# endif 1123296341Sdelphij# ifndef OPENSSL_NO_AES 1124296341Sdelphij BIO_printf(bio_err, "aes-128-cbc aes-192-cbc aes-256-cbc "); 1125296341Sdelphij BIO_printf(bio_err, "aes-128-ige aes-192-ige aes-256-ige "); 1126296341Sdelphij# endif 1127296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 1128296341Sdelphij BIO_printf(bio_err, "\n"); 1129296341Sdelphij BIO_printf(bio_err, 1130296341Sdelphij "camellia-128-cbc camellia-192-cbc camellia-256-cbc "); 1131296341Sdelphij# endif 1132296341Sdelphij# ifndef OPENSSL_NO_RC4 1133296341Sdelphij BIO_printf(bio_err, "rc4"); 1134296341Sdelphij# endif 1135296341Sdelphij BIO_printf(bio_err, "\n"); 113668654Skris 1137296341Sdelphij# ifndef OPENSSL_NO_RSA 1138296341Sdelphij BIO_printf(bio_err, "rsa512 rsa1024 rsa2048 rsa4096\n"); 1139296341Sdelphij# endif 114068654Skris 1141296341Sdelphij# ifndef OPENSSL_NO_DSA 1142296341Sdelphij BIO_printf(bio_err, "dsa512 dsa1024 dsa2048\n"); 1143296341Sdelphij# endif 1144296341Sdelphij# ifndef OPENSSL_NO_ECDSA 1145296341Sdelphij BIO_printf(bio_err, "ecdsap160 ecdsap192 ecdsap224 " 1146296341Sdelphij "ecdsap256 ecdsap384 ecdsap521\n"); 1147296341Sdelphij BIO_printf(bio_err, 1148296341Sdelphij "ecdsak163 ecdsak233 ecdsak283 ecdsak409 ecdsak571\n"); 1149296341Sdelphij BIO_printf(bio_err, 1150296341Sdelphij "ecdsab163 ecdsab233 ecdsab283 ecdsab409 ecdsab571\n"); 1151296341Sdelphij BIO_printf(bio_err, "ecdsa\n"); 1152296341Sdelphij# endif 1153296341Sdelphij# ifndef OPENSSL_NO_ECDH 1154296341Sdelphij BIO_printf(bio_err, "ecdhp160 ecdhp192 ecdhp224 " 1155296341Sdelphij "ecdhp256 ecdhp384 ecdhp521\n"); 1156296341Sdelphij BIO_printf(bio_err, 1157296341Sdelphij "ecdhk163 ecdhk233 ecdhk283 ecdhk409 ecdhk571\n"); 1158296341Sdelphij BIO_printf(bio_err, 1159296341Sdelphij "ecdhb163 ecdhb233 ecdhb283 ecdhb409 ecdhb571\n"); 1160296341Sdelphij BIO_printf(bio_err, "ecdh\n"); 1161296341Sdelphij# endif 116268654Skris 1163296341Sdelphij# ifndef OPENSSL_NO_IDEA 1164296341Sdelphij BIO_printf(bio_err, "idea "); 1165296341Sdelphij# endif 1166296341Sdelphij# ifndef OPENSSL_NO_SEED 1167296341Sdelphij BIO_printf(bio_err, "seed "); 1168296341Sdelphij# endif 1169296341Sdelphij# ifndef OPENSSL_NO_RC2 1170296341Sdelphij BIO_printf(bio_err, "rc2 "); 1171296341Sdelphij# endif 1172296341Sdelphij# ifndef OPENSSL_NO_DES 1173296341Sdelphij BIO_printf(bio_err, "des "); 1174296341Sdelphij# endif 1175296341Sdelphij# ifndef OPENSSL_NO_AES 1176296341Sdelphij BIO_printf(bio_err, "aes "); 1177296341Sdelphij# endif 1178296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 1179296341Sdelphij BIO_printf(bio_err, "camellia "); 1180296341Sdelphij# endif 1181296341Sdelphij# ifndef OPENSSL_NO_RSA 1182296341Sdelphij BIO_printf(bio_err, "rsa "); 1183296341Sdelphij# endif 1184296341Sdelphij# ifndef OPENSSL_NO_BF 1185296341Sdelphij BIO_printf(bio_err, "blowfish"); 1186296341Sdelphij# endif 1187296341Sdelphij# if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || \ 1188194206Ssimon !defined(OPENSSL_NO_RC2) || !defined(OPENSSL_NO_DES) || \ 1189194206Ssimon !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_BF) || \ 1190194206Ssimon !defined(OPENSSL_NO_AES) || !defined(OPENSSL_NO_CAMELLIA) 1191296341Sdelphij BIO_printf(bio_err, "\n"); 1192296341Sdelphij# endif 119368654Skris 1194296341Sdelphij BIO_printf(bio_err, "\n"); 1195296341Sdelphij BIO_printf(bio_err, "Available options:\n"); 1196296341Sdelphij# if defined(TIMES) || defined(USE_TOD) 1197296341Sdelphij BIO_printf(bio_err, "-elapsed " 1198296341Sdelphij "measure time in real time instead of CPU user time.\n"); 1199296341Sdelphij# endif 1200296341Sdelphij# ifndef OPENSSL_NO_ENGINE 1201296341Sdelphij BIO_printf(bio_err, 1202296341Sdelphij "-engine e " 1203296341Sdelphij "use engine e, possibly a hardware device.\n"); 1204296341Sdelphij# endif 1205296341Sdelphij BIO_printf(bio_err, "-evp e " "use EVP e.\n"); 1206296341Sdelphij BIO_printf(bio_err, 1207296341Sdelphij "-decrypt " 1208296341Sdelphij "time decryption instead of encryption (only EVP).\n"); 1209296341Sdelphij BIO_printf(bio_err, 1210296341Sdelphij "-mr " 1211296341Sdelphij "produce machine readable output.\n"); 1212296341Sdelphij# ifndef NO_FORK 1213296341Sdelphij BIO_printf(bio_err, 1214296341Sdelphij "-multi n " "run n benchmarks in parallel.\n"); 1215296341Sdelphij# endif 1216296341Sdelphij goto end; 1217296341Sdelphij } 1218296341Sdelphij argc--; 1219296341Sdelphij argv++; 1220296341Sdelphij j++; 1221296341Sdelphij } 122255714Skris 1223296341Sdelphij# ifndef NO_FORK 1224296341Sdelphij if (multi && do_multi(multi)) 1225296341Sdelphij goto show_res; 1226296341Sdelphij# endif 1227110007Smarkm 1228296341Sdelphij if (j == 0) { 1229296341Sdelphij for (i = 0; i < ALGOR_NUM; i++) { 1230296341Sdelphij if (i != D_EVP) 1231296341Sdelphij doit[i] = 1; 1232296341Sdelphij } 1233296341Sdelphij for (i = 0; i < RSA_NUM; i++) 1234296341Sdelphij rsa_doit[i] = 1; 1235296341Sdelphij for (i = 0; i < DSA_NUM; i++) 1236296341Sdelphij dsa_doit[i] = 1; 1237296341Sdelphij# ifndef OPENSSL_NO_ECDSA 1238296341Sdelphij for (i = 0; i < EC_NUM; i++) 1239296341Sdelphij ecdsa_doit[i] = 1; 1240296341Sdelphij# endif 1241296341Sdelphij# ifndef OPENSSL_NO_ECDH 1242296341Sdelphij for (i = 0; i < EC_NUM; i++) 1243296341Sdelphij ecdh_doit[i] = 1; 1244296341Sdelphij# endif 1245296341Sdelphij } 1246296341Sdelphij for (i = 0; i < ALGOR_NUM; i++) 1247296341Sdelphij if (doit[i]) 1248296341Sdelphij pr_header++; 124955714Skris 1250296341Sdelphij if (usertime == 0 && !mr) 1251296341Sdelphij BIO_printf(bio_err, 1252296341Sdelphij "You have chosen to measure elapsed time " 1253296341Sdelphij "instead of user CPU time.\n"); 125455714Skris 1255296341Sdelphij# ifndef OPENSSL_NO_RSA 1256296341Sdelphij for (i = 0; i < RSA_NUM; i++) { 1257296341Sdelphij const unsigned char *p; 125855714Skris 1259296341Sdelphij p = rsa_data[i]; 1260296341Sdelphij rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]); 1261296341Sdelphij if (rsa_key[i] == NULL) { 1262296341Sdelphij BIO_printf(bio_err, "internal error loading RSA key number %d\n", 1263296341Sdelphij i); 1264296341Sdelphij goto end; 1265296341Sdelphij } 1266296341Sdelphij# if 0 1267296341Sdelphij else { 1268296341Sdelphij BIO_printf(bio_err, 1269296341Sdelphij mr ? "+RK:%d:" 1270296341Sdelphij : "Loaded RSA key, %d bit modulus and e= 0x", 1271296341Sdelphij BN_num_bits(rsa_key[i]->n)); 1272296341Sdelphij BN_print(bio_err, rsa_key[i]->e); 1273296341Sdelphij BIO_printf(bio_err, "\n"); 1274296341Sdelphij } 1275296341Sdelphij# endif 1276296341Sdelphij } 1277296341Sdelphij# endif 127855714Skris 1279296341Sdelphij# ifndef OPENSSL_NO_DSA 1280296341Sdelphij dsa_key[0] = get_dsa512(); 1281296341Sdelphij dsa_key[1] = get_dsa1024(); 1282296341Sdelphij dsa_key[2] = get_dsa2048(); 1283296341Sdelphij# endif 128455714Skris 1285296341Sdelphij# ifndef OPENSSL_NO_DES 1286296341Sdelphij DES_set_key_unchecked(&key, &sch); 1287296341Sdelphij DES_set_key_unchecked(&key2, &sch2); 1288296341Sdelphij DES_set_key_unchecked(&key3, &sch3); 1289296341Sdelphij# endif 1290296341Sdelphij# ifndef OPENSSL_NO_AES 1291296341Sdelphij AES_set_encrypt_key(key16, 128, &aes_ks1); 1292296341Sdelphij AES_set_encrypt_key(key24, 192, &aes_ks2); 1293296341Sdelphij AES_set_encrypt_key(key32, 256, &aes_ks3); 1294296341Sdelphij# endif 1295296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 1296296341Sdelphij Camellia_set_key(key16, 128, &camellia_ks1); 1297296341Sdelphij Camellia_set_key(ckey24, 192, &camellia_ks2); 1298296341Sdelphij Camellia_set_key(ckey32, 256, &camellia_ks3); 1299296341Sdelphij# endif 1300296341Sdelphij# ifndef OPENSSL_NO_IDEA 1301296341Sdelphij idea_set_encrypt_key(key16, &idea_ks); 1302296341Sdelphij# endif 1303296341Sdelphij# ifndef OPENSSL_NO_SEED 1304296341Sdelphij SEED_set_key(key16, &seed_ks); 1305296341Sdelphij# endif 1306296341Sdelphij# ifndef OPENSSL_NO_RC4 1307296341Sdelphij RC4_set_key(&rc4_ks, 16, key16); 1308296341Sdelphij# endif 1309296341Sdelphij# ifndef OPENSSL_NO_RC2 1310296341Sdelphij RC2_set_key(&rc2_ks, 16, key16, 128); 1311296341Sdelphij# endif 1312296341Sdelphij# ifndef OPENSSL_NO_RC5 1313296341Sdelphij RC5_32_set_key(&rc5_ks, 16, key16, 12); 1314296341Sdelphij# endif 1315296341Sdelphij# ifndef OPENSSL_NO_BF 1316296341Sdelphij BF_set_key(&bf_ks, 16, key16); 1317296341Sdelphij# endif 1318296341Sdelphij# ifndef OPENSSL_NO_CAST 1319296341Sdelphij CAST_set_key(&cast_ks, 16, key16); 1320296341Sdelphij# endif 1321296341Sdelphij# ifndef OPENSSL_NO_RSA 1322296341Sdelphij memset(rsa_c, 0, sizeof(rsa_c)); 1323296341Sdelphij# endif 1324296341Sdelphij# ifndef SIGALRM 1325296341Sdelphij# ifndef OPENSSL_NO_DES 1326296341Sdelphij BIO_printf(bio_err, "First we calculate the approximate speed ...\n"); 1327296341Sdelphij count = 10; 1328296341Sdelphij do { 1329296341Sdelphij long it; 1330296341Sdelphij count *= 2; 1331296341Sdelphij Time_F(START); 1332296341Sdelphij for (it = count; it; it--) 1333296341Sdelphij DES_ecb_encrypt((DES_cblock *)buf, 1334296341Sdelphij (DES_cblock *)buf, &sch, DES_ENCRYPT); 1335296341Sdelphij d = Time_F(STOP); 1336296341Sdelphij } while (d < 3); 1337296341Sdelphij save_count = count; 1338296341Sdelphij c[D_MD2][0] = count / 10; 1339296341Sdelphij c[D_MDC2][0] = count / 10; 1340296341Sdelphij c[D_MD4][0] = count; 1341296341Sdelphij c[D_MD5][0] = count; 1342296341Sdelphij c[D_HMAC][0] = count; 1343296341Sdelphij c[D_SHA1][0] = count; 1344296341Sdelphij c[D_RMD160][0] = count; 1345296341Sdelphij c[D_RC4][0] = count * 5; 1346296341Sdelphij c[D_CBC_DES][0] = count; 1347296341Sdelphij c[D_EDE3_DES][0] = count / 3; 1348296341Sdelphij c[D_CBC_IDEA][0] = count; 1349296341Sdelphij c[D_CBC_SEED][0] = count; 1350296341Sdelphij c[D_CBC_RC2][0] = count; 1351296341Sdelphij c[D_CBC_RC5][0] = count; 1352296341Sdelphij c[D_CBC_BF][0] = count; 1353296341Sdelphij c[D_CBC_CAST][0] = count; 1354296341Sdelphij c[D_CBC_128_AES][0] = count; 1355296341Sdelphij c[D_CBC_192_AES][0] = count; 1356296341Sdelphij c[D_CBC_256_AES][0] = count; 1357296341Sdelphij c[D_CBC_128_CML][0] = count; 1358296341Sdelphij c[D_CBC_192_CML][0] = count; 1359296341Sdelphij c[D_CBC_256_CML][0] = count; 1360296341Sdelphij c[D_SHA256][0] = count; 1361296341Sdelphij c[D_SHA512][0] = count; 1362296341Sdelphij c[D_WHIRLPOOL][0] = count; 1363296341Sdelphij c[D_IGE_128_AES][0] = count; 1364296341Sdelphij c[D_IGE_192_AES][0] = count; 1365296341Sdelphij c[D_IGE_256_AES][0] = count; 1366296341Sdelphij c[D_GHASH][0] = count; 136755714Skris 1368296341Sdelphij for (i = 1; i < SIZE_NUM; i++) { 1369296341Sdelphij c[D_MD2][i] = c[D_MD2][0] * 4 * lengths[0] / lengths[i]; 1370296341Sdelphij c[D_MDC2][i] = c[D_MDC2][0] * 4 * lengths[0] / lengths[i]; 1371296341Sdelphij c[D_MD4][i] = c[D_MD4][0] * 4 * lengths[0] / lengths[i]; 1372296341Sdelphij c[D_MD5][i] = c[D_MD5][0] * 4 * lengths[0] / lengths[i]; 1373296341Sdelphij c[D_HMAC][i] = c[D_HMAC][0] * 4 * lengths[0] / lengths[i]; 1374296341Sdelphij c[D_SHA1][i] = c[D_SHA1][0] * 4 * lengths[0] / lengths[i]; 1375296341Sdelphij c[D_RMD160][i] = c[D_RMD160][0] * 4 * lengths[0] / lengths[i]; 1376296341Sdelphij c[D_SHA256][i] = c[D_SHA256][0] * 4 * lengths[0] / lengths[i]; 1377296341Sdelphij c[D_SHA512][i] = c[D_SHA512][0] * 4 * lengths[0] / lengths[i]; 1378296341Sdelphij c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * lengths[0] / lengths[i]; 1379296341Sdelphij } 1380296341Sdelphij for (i = 1; i < SIZE_NUM; i++) { 1381296341Sdelphij long l0, l1; 138255714Skris 1383296341Sdelphij l0 = (long)lengths[i - 1]; 1384296341Sdelphij l1 = (long)lengths[i]; 1385296341Sdelphij c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1; 1386296341Sdelphij c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1; 1387296341Sdelphij c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1; 1388296341Sdelphij c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1; 1389296341Sdelphij c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1; 1390296341Sdelphij c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1; 1391296341Sdelphij c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1; 1392296341Sdelphij c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1; 1393296341Sdelphij c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1; 1394296341Sdelphij c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1; 1395296341Sdelphij c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1; 1396296341Sdelphij c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1; 1397296341Sdelphij c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1; 1398296341Sdelphij c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1; 1399296341Sdelphij c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1; 1400296341Sdelphij c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1; 1401296341Sdelphij c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1; 1402296341Sdelphij c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1; 1403296341Sdelphij } 1404296341Sdelphij# ifndef OPENSSL_NO_RSA 1405296341Sdelphij rsa_c[R_RSA_512][0] = count / 2000; 1406296341Sdelphij rsa_c[R_RSA_512][1] = count / 400; 1407296341Sdelphij for (i = 1; i < RSA_NUM; i++) { 1408296341Sdelphij rsa_c[i][0] = rsa_c[i - 1][0] / 8; 1409296341Sdelphij rsa_c[i][1] = rsa_c[i - 1][1] / 4; 1410296341Sdelphij if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0)) 1411296341Sdelphij rsa_doit[i] = 0; 1412296341Sdelphij else { 1413296341Sdelphij if (rsa_c[i][0] == 0) { 1414296341Sdelphij rsa_c[i][0] = 1; 1415296341Sdelphij rsa_c[i][1] = 20; 1416296341Sdelphij } 1417296341Sdelphij } 1418296341Sdelphij } 1419296341Sdelphij# endif 142055714Skris 1421296341Sdelphij# ifndef OPENSSL_NO_DSA 1422296341Sdelphij dsa_c[R_DSA_512][0] = count / 1000; 1423296341Sdelphij dsa_c[R_DSA_512][1] = count / 1000 / 2; 1424296341Sdelphij for (i = 1; i < DSA_NUM; i++) { 1425296341Sdelphij dsa_c[i][0] = dsa_c[i - 1][0] / 4; 1426296341Sdelphij dsa_c[i][1] = dsa_c[i - 1][1] / 4; 1427296341Sdelphij if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0)) 1428296341Sdelphij dsa_doit[i] = 0; 1429296341Sdelphij else { 1430296341Sdelphij if (dsa_c[i] == 0) { 1431296341Sdelphij dsa_c[i][0] = 1; 1432296341Sdelphij dsa_c[i][1] = 1; 1433296341Sdelphij } 1434296341Sdelphij } 1435296341Sdelphij } 1436296341Sdelphij# endif 143755714Skris 1438296341Sdelphij# ifndef OPENSSL_NO_ECDSA 1439296341Sdelphij ecdsa_c[R_EC_P160][0] = count / 1000; 1440296341Sdelphij ecdsa_c[R_EC_P160][1] = count / 1000 / 2; 1441296341Sdelphij for (i = R_EC_P192; i <= R_EC_P521; i++) { 1442296341Sdelphij ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2; 1443296341Sdelphij ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2; 1444296341Sdelphij if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0)) 1445296341Sdelphij ecdsa_doit[i] = 0; 1446296341Sdelphij else { 1447296341Sdelphij if (ecdsa_c[i] == 0) { 1448296341Sdelphij ecdsa_c[i][0] = 1; 1449296341Sdelphij ecdsa_c[i][1] = 1; 1450296341Sdelphij } 1451296341Sdelphij } 1452296341Sdelphij } 1453296341Sdelphij ecdsa_c[R_EC_K163][0] = count / 1000; 1454296341Sdelphij ecdsa_c[R_EC_K163][1] = count / 1000 / 2; 1455296341Sdelphij for (i = R_EC_K233; i <= R_EC_K571; i++) { 1456296341Sdelphij ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2; 1457296341Sdelphij ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2; 1458296341Sdelphij if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0)) 1459296341Sdelphij ecdsa_doit[i] = 0; 1460296341Sdelphij else { 1461296341Sdelphij if (ecdsa_c[i] == 0) { 1462296341Sdelphij ecdsa_c[i][0] = 1; 1463296341Sdelphij ecdsa_c[i][1] = 1; 1464296341Sdelphij } 1465296341Sdelphij } 1466296341Sdelphij } 1467296341Sdelphij ecdsa_c[R_EC_B163][0] = count / 1000; 1468296341Sdelphij ecdsa_c[R_EC_B163][1] = count / 1000 / 2; 1469296341Sdelphij for (i = R_EC_B233; i <= R_EC_B571; i++) { 1470296341Sdelphij ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2; 1471296341Sdelphij ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2; 1472296341Sdelphij if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0)) 1473296341Sdelphij ecdsa_doit[i] = 0; 1474296341Sdelphij else { 1475296341Sdelphij if (ecdsa_c[i] == 0) { 1476296341Sdelphij ecdsa_c[i][0] = 1; 1477296341Sdelphij ecdsa_c[i][1] = 1; 1478296341Sdelphij } 1479296341Sdelphij } 1480296341Sdelphij } 1481296341Sdelphij# endif 1482160817Ssimon 1483296341Sdelphij# ifndef OPENSSL_NO_ECDH 1484296341Sdelphij ecdh_c[R_EC_P160][0] = count / 1000; 1485296341Sdelphij ecdh_c[R_EC_P160][1] = count / 1000; 1486296341Sdelphij for (i = R_EC_P192; i <= R_EC_P521; i++) { 1487296341Sdelphij ecdh_c[i][0] = ecdh_c[i - 1][0] / 2; 1488296341Sdelphij ecdh_c[i][1] = ecdh_c[i - 1][1] / 2; 1489296341Sdelphij if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0)) 1490296341Sdelphij ecdh_doit[i] = 0; 1491296341Sdelphij else { 1492296341Sdelphij if (ecdh_c[i] == 0) { 1493296341Sdelphij ecdh_c[i][0] = 1; 1494296341Sdelphij ecdh_c[i][1] = 1; 1495296341Sdelphij } 1496296341Sdelphij } 1497296341Sdelphij } 1498296341Sdelphij ecdh_c[R_EC_K163][0] = count / 1000; 1499296341Sdelphij ecdh_c[R_EC_K163][1] = count / 1000; 1500296341Sdelphij for (i = R_EC_K233; i <= R_EC_K571; i++) { 1501296341Sdelphij ecdh_c[i][0] = ecdh_c[i - 1][0] / 2; 1502296341Sdelphij ecdh_c[i][1] = ecdh_c[i - 1][1] / 2; 1503296341Sdelphij if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0)) 1504296341Sdelphij ecdh_doit[i] = 0; 1505296341Sdelphij else { 1506296341Sdelphij if (ecdh_c[i] == 0) { 1507296341Sdelphij ecdh_c[i][0] = 1; 1508296341Sdelphij ecdh_c[i][1] = 1; 1509296341Sdelphij } 1510296341Sdelphij } 1511296341Sdelphij } 1512296341Sdelphij ecdh_c[R_EC_B163][0] = count / 1000; 1513296341Sdelphij ecdh_c[R_EC_B163][1] = count / 1000; 1514296341Sdelphij for (i = R_EC_B233; i <= R_EC_B571; i++) { 1515296341Sdelphij ecdh_c[i][0] = ecdh_c[i - 1][0] / 2; 1516296341Sdelphij ecdh_c[i][1] = ecdh_c[i - 1][1] / 2; 1517296341Sdelphij if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0)) 1518296341Sdelphij ecdh_doit[i] = 0; 1519296341Sdelphij else { 1520296341Sdelphij if (ecdh_c[i] == 0) { 1521296341Sdelphij ecdh_c[i][0] = 1; 1522296341Sdelphij ecdh_c[i][1] = 1; 1523296341Sdelphij } 1524296341Sdelphij } 1525296341Sdelphij } 1526296341Sdelphij# endif 1527160817Ssimon 1528296341Sdelphij# define COND(d) (count < (d)) 1529296341Sdelphij# define COUNT(d) (d) 1530296341Sdelphij# else 153159194Skris/* not worth fixing */ 1532296341Sdelphij# error "You cannot disable DES on systems without SIGALRM." 1533296341Sdelphij# endif /* OPENSSL_NO_DES */ 1534296341Sdelphij# else 1535296341Sdelphij# define COND(c) (run && count<0x7fffffff) 1536296341Sdelphij# define COUNT(d) (count) 1537296341Sdelphij# ifndef _WIN32 1538296341Sdelphij signal(SIGALRM, sig_done); 1539296341Sdelphij# endif 1540296341Sdelphij# endif /* SIGALRM */ 154155714Skris 1542296341Sdelphij# ifndef OPENSSL_NO_MD2 1543296341Sdelphij if (doit[D_MD2]) { 1544296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1545296341Sdelphij print_message(names[D_MD2], c[D_MD2][j], lengths[j]); 1546296341Sdelphij Time_F(START); 1547296341Sdelphij for (count = 0, run = 1; COND(c[D_MD2][j]); count++) 1548296341Sdelphij EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL, 1549296341Sdelphij EVP_md2(), NULL); 1550296341Sdelphij d = Time_F(STOP); 1551296341Sdelphij print_result(D_MD2, j, count, d); 1552296341Sdelphij } 1553296341Sdelphij } 1554296341Sdelphij# endif 1555296341Sdelphij# ifndef OPENSSL_NO_MDC2 1556296341Sdelphij if (doit[D_MDC2]) { 1557296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1558296341Sdelphij print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]); 1559296341Sdelphij Time_F(START); 1560296341Sdelphij for (count = 0, run = 1; COND(c[D_MDC2][j]); count++) 1561296341Sdelphij EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL, 1562296341Sdelphij EVP_mdc2(), NULL); 1563296341Sdelphij d = Time_F(STOP); 1564296341Sdelphij print_result(D_MDC2, j, count, d); 1565296341Sdelphij } 1566296341Sdelphij } 1567296341Sdelphij# endif 156855714Skris 1569296341Sdelphij# ifndef OPENSSL_NO_MD4 1570296341Sdelphij if (doit[D_MD4]) { 1571296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1572296341Sdelphij print_message(names[D_MD4], c[D_MD4][j], lengths[j]); 1573296341Sdelphij Time_F(START); 1574296341Sdelphij for (count = 0, run = 1; COND(c[D_MD4][j]); count++) 1575296341Sdelphij EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]), 1576296341Sdelphij NULL, EVP_md4(), NULL); 1577296341Sdelphij d = Time_F(STOP); 1578296341Sdelphij print_result(D_MD4, j, count, d); 1579296341Sdelphij } 1580296341Sdelphij } 1581296341Sdelphij# endif 158268654Skris 1583296341Sdelphij# ifndef OPENSSL_NO_MD5 1584296341Sdelphij if (doit[D_MD5]) { 1585296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1586296341Sdelphij print_message(names[D_MD5], c[D_MD5][j], lengths[j]); 1587296341Sdelphij Time_F(START); 1588296341Sdelphij for (count = 0, run = 1; COND(c[D_MD5][j]); count++) 1589296341Sdelphij EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md5[0]), 1590296341Sdelphij NULL, EVP_get_digestbyname("md5"), NULL); 1591296341Sdelphij d = Time_F(STOP); 1592296341Sdelphij print_result(D_MD5, j, count, d); 1593296341Sdelphij } 1594296341Sdelphij } 1595296341Sdelphij# endif 159655714Skris 1597296341Sdelphij# if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC) 1598296341Sdelphij if (doit[D_HMAC]) { 1599296341Sdelphij HMAC_CTX hctx; 160055714Skris 1601296341Sdelphij HMAC_CTX_init(&hctx); 1602296341Sdelphij HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...", 1603296341Sdelphij 16, EVP_md5(), NULL); 1604110007Smarkm 1605296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1606296341Sdelphij print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]); 1607296341Sdelphij Time_F(START); 1608296341Sdelphij for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) { 1609296341Sdelphij HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL); 1610296341Sdelphij HMAC_Update(&hctx, buf, lengths[j]); 1611296341Sdelphij HMAC_Final(&hctx, &(hmac[0]), NULL); 1612296341Sdelphij } 1613296341Sdelphij d = Time_F(STOP); 1614296341Sdelphij print_result(D_HMAC, j, count, d); 1615296341Sdelphij } 1616296341Sdelphij HMAC_CTX_cleanup(&hctx); 1617296341Sdelphij } 1618296341Sdelphij# endif 1619296341Sdelphij# ifndef OPENSSL_NO_SHA 1620296341Sdelphij if (doit[D_SHA1]) { 1621296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1622296341Sdelphij print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]); 1623296341Sdelphij Time_F(START); 1624296341Sdelphij for (count = 0, run = 1; COND(c[D_SHA1][j]); count++) 1625296341Sdelphij EVP_Digest(buf, (unsigned long)lengths[j], &(sha[0]), NULL, 1626296341Sdelphij EVP_sha1(), NULL); 1627296341Sdelphij d = Time_F(STOP); 1628296341Sdelphij print_result(D_SHA1, j, count, d); 1629296341Sdelphij } 1630296341Sdelphij } 1631296341Sdelphij# ifndef OPENSSL_NO_SHA256 1632296341Sdelphij if (doit[D_SHA256]) { 1633296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1634296341Sdelphij print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]); 1635296341Sdelphij Time_F(START); 1636296341Sdelphij for (count = 0, run = 1; COND(c[D_SHA256][j]); count++) 1637296341Sdelphij SHA256(buf, lengths[j], sha256); 1638296341Sdelphij d = Time_F(STOP); 1639296341Sdelphij print_result(D_SHA256, j, count, d); 1640296341Sdelphij } 1641296341Sdelphij } 1642296341Sdelphij# endif 1643160817Ssimon 1644296341Sdelphij# ifndef OPENSSL_NO_SHA512 1645296341Sdelphij if (doit[D_SHA512]) { 1646296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1647296341Sdelphij print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]); 1648296341Sdelphij Time_F(START); 1649296341Sdelphij for (count = 0, run = 1; COND(c[D_SHA512][j]); count++) 1650296341Sdelphij SHA512(buf, lengths[j], sha512); 1651296341Sdelphij d = Time_F(STOP); 1652296341Sdelphij print_result(D_SHA512, j, count, d); 1653296341Sdelphij } 1654296341Sdelphij } 1655296341Sdelphij# endif 1656296341Sdelphij# endif 1657160817Ssimon 1658296341Sdelphij# ifndef OPENSSL_NO_WHIRLPOOL 1659296341Sdelphij if (doit[D_WHIRLPOOL]) { 1660296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1661296341Sdelphij print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]); 1662296341Sdelphij Time_F(START); 1663296341Sdelphij for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++) 1664296341Sdelphij WHIRLPOOL(buf, lengths[j], whirlpool); 1665296341Sdelphij d = Time_F(STOP); 1666296341Sdelphij print_result(D_WHIRLPOOL, j, count, d); 1667296341Sdelphij } 1668296341Sdelphij } 1669296341Sdelphij# endif 1670160817Ssimon 1671296341Sdelphij# ifndef OPENSSL_NO_RIPEMD 1672296341Sdelphij if (doit[D_RMD160]) { 1673296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1674296341Sdelphij print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]); 1675296341Sdelphij Time_F(START); 1676296341Sdelphij for (count = 0, run = 1; COND(c[D_RMD160][j]); count++) 1677296341Sdelphij EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL, 1678296341Sdelphij EVP_ripemd160(), NULL); 1679296341Sdelphij d = Time_F(STOP); 1680296341Sdelphij print_result(D_RMD160, j, count, d); 1681296341Sdelphij } 1682296341Sdelphij } 1683296341Sdelphij# endif 1684296341Sdelphij# ifndef OPENSSL_NO_RC4 1685296341Sdelphij if (doit[D_RC4]) { 1686296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1687296341Sdelphij print_message(names[D_RC4], c[D_RC4][j], lengths[j]); 1688296341Sdelphij Time_F(START); 1689296341Sdelphij for (count = 0, run = 1; COND(c[D_RC4][j]); count++) 1690296341Sdelphij RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf); 1691296341Sdelphij d = Time_F(STOP); 1692296341Sdelphij print_result(D_RC4, j, count, d); 1693296341Sdelphij } 1694296341Sdelphij } 1695296341Sdelphij# endif 1696296341Sdelphij# ifndef OPENSSL_NO_DES 1697296341Sdelphij if (doit[D_CBC_DES]) { 1698296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1699296341Sdelphij print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]); 1700296341Sdelphij Time_F(START); 1701296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++) 1702296341Sdelphij DES_ncbc_encrypt(buf, buf, lengths[j], &sch, 1703296341Sdelphij &DES_iv, DES_ENCRYPT); 1704296341Sdelphij d = Time_F(STOP); 1705296341Sdelphij print_result(D_CBC_DES, j, count, d); 1706296341Sdelphij } 1707296341Sdelphij } 1708238405Sjkim 1709296341Sdelphij if (doit[D_EDE3_DES]) { 1710296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1711296341Sdelphij print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]); 1712296341Sdelphij Time_F(START); 1713296341Sdelphij for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++) 1714296341Sdelphij DES_ede3_cbc_encrypt(buf, buf, lengths[j], 1715296341Sdelphij &sch, &sch2, &sch3, 1716296341Sdelphij &DES_iv, DES_ENCRYPT); 1717296341Sdelphij d = Time_F(STOP); 1718296341Sdelphij print_result(D_EDE3_DES, j, count, d); 1719296341Sdelphij } 1720296341Sdelphij } 1721296341Sdelphij# endif 1722296341Sdelphij# ifndef OPENSSL_NO_AES 1723296341Sdelphij if (doit[D_CBC_128_AES]) { 1724296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1725296341Sdelphij print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j], 1726296341Sdelphij lengths[j]); 1727296341Sdelphij Time_F(START); 1728296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++) 1729296341Sdelphij AES_cbc_encrypt(buf, buf, 1730296341Sdelphij (unsigned long)lengths[j], &aes_ks1, 1731296341Sdelphij iv, AES_ENCRYPT); 1732296341Sdelphij d = Time_F(STOP); 1733296341Sdelphij print_result(D_CBC_128_AES, j, count, d); 1734296341Sdelphij } 1735296341Sdelphij } 1736296341Sdelphij if (doit[D_CBC_192_AES]) { 1737296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1738296341Sdelphij print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j], 1739296341Sdelphij lengths[j]); 1740296341Sdelphij Time_F(START); 1741296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++) 1742296341Sdelphij AES_cbc_encrypt(buf, buf, 1743296341Sdelphij (unsigned long)lengths[j], &aes_ks2, 1744296341Sdelphij iv, AES_ENCRYPT); 1745296341Sdelphij d = Time_F(STOP); 1746296341Sdelphij print_result(D_CBC_192_AES, j, count, d); 1747296341Sdelphij } 1748296341Sdelphij } 1749296341Sdelphij if (doit[D_CBC_256_AES]) { 1750296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1751296341Sdelphij print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j], 1752296341Sdelphij lengths[j]); 1753296341Sdelphij Time_F(START); 1754296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++) 1755296341Sdelphij AES_cbc_encrypt(buf, buf, 1756296341Sdelphij (unsigned long)lengths[j], &aes_ks3, 1757296341Sdelphij iv, AES_ENCRYPT); 1758296341Sdelphij d = Time_F(STOP); 1759296341Sdelphij print_result(D_CBC_256_AES, j, count, d); 1760296341Sdelphij } 1761296341Sdelphij } 176255714Skris 1763296341Sdelphij if (doit[D_IGE_128_AES]) { 1764296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1765296341Sdelphij print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j], 1766296341Sdelphij lengths[j]); 1767296341Sdelphij Time_F(START); 1768296341Sdelphij for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++) 1769296341Sdelphij AES_ige_encrypt(buf, buf2, 1770296341Sdelphij (unsigned long)lengths[j], &aes_ks1, 1771296341Sdelphij iv, AES_ENCRYPT); 1772296341Sdelphij d = Time_F(STOP); 1773296341Sdelphij print_result(D_IGE_128_AES, j, count, d); 1774296341Sdelphij } 1775296341Sdelphij } 1776296341Sdelphij if (doit[D_IGE_192_AES]) { 1777296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1778296341Sdelphij print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j], 1779296341Sdelphij lengths[j]); 1780296341Sdelphij Time_F(START); 1781296341Sdelphij for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++) 1782296341Sdelphij AES_ige_encrypt(buf, buf2, 1783296341Sdelphij (unsigned long)lengths[j], &aes_ks2, 1784296341Sdelphij iv, AES_ENCRYPT); 1785296341Sdelphij d = Time_F(STOP); 1786296341Sdelphij print_result(D_IGE_192_AES, j, count, d); 1787296341Sdelphij } 1788296341Sdelphij } 1789296341Sdelphij if (doit[D_IGE_256_AES]) { 1790296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1791296341Sdelphij print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j], 1792296341Sdelphij lengths[j]); 1793296341Sdelphij Time_F(START); 1794296341Sdelphij for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++) 1795296341Sdelphij AES_ige_encrypt(buf, buf2, 1796296341Sdelphij (unsigned long)lengths[j], &aes_ks3, 1797296341Sdelphij iv, AES_ENCRYPT); 1798296341Sdelphij d = Time_F(STOP); 1799296341Sdelphij print_result(D_IGE_256_AES, j, count, d); 1800296341Sdelphij } 1801296341Sdelphij } 1802296341Sdelphij if (doit[D_GHASH]) { 1803296341Sdelphij GCM128_CONTEXT *ctx = 1804296341Sdelphij CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt); 1805296341Sdelphij CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12); 1806110007Smarkm 1807296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1808296341Sdelphij print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]); 1809296341Sdelphij Time_F(START); 1810296341Sdelphij for (count = 0, run = 1; COND(c[D_GHASH][j]); count++) 1811296341Sdelphij CRYPTO_gcm128_aad(ctx, buf, lengths[j]); 1812296341Sdelphij d = Time_F(STOP); 1813296341Sdelphij print_result(D_GHASH, j, count, d); 1814296341Sdelphij } 1815296341Sdelphij CRYPTO_gcm128_release(ctx); 1816296341Sdelphij } 1817296341Sdelphij# endif 1818296341Sdelphij# ifndef OPENSSL_NO_CAMELLIA 1819296341Sdelphij if (doit[D_CBC_128_CML]) { 1820296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1821296341Sdelphij print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j], 1822296341Sdelphij lengths[j]); 1823296341Sdelphij Time_F(START); 1824296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++) 1825296341Sdelphij Camellia_cbc_encrypt(buf, buf, 1826296341Sdelphij (unsigned long)lengths[j], &camellia_ks1, 1827296341Sdelphij iv, CAMELLIA_ENCRYPT); 1828296341Sdelphij d = Time_F(STOP); 1829296341Sdelphij print_result(D_CBC_128_CML, j, count, d); 1830296341Sdelphij } 1831296341Sdelphij } 1832296341Sdelphij if (doit[D_CBC_192_CML]) { 1833296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1834296341Sdelphij print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j], 1835296341Sdelphij lengths[j]); 1836296341Sdelphij Time_F(START); 1837296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++) 1838296341Sdelphij Camellia_cbc_encrypt(buf, buf, 1839296341Sdelphij (unsigned long)lengths[j], &camellia_ks2, 1840296341Sdelphij iv, CAMELLIA_ENCRYPT); 1841296341Sdelphij d = Time_F(STOP); 1842296341Sdelphij print_result(D_CBC_192_CML, j, count, d); 1843296341Sdelphij } 1844296341Sdelphij } 1845296341Sdelphij if (doit[D_CBC_256_CML]) { 1846296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1847296341Sdelphij print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j], 1848296341Sdelphij lengths[j]); 1849296341Sdelphij Time_F(START); 1850296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++) 1851296341Sdelphij Camellia_cbc_encrypt(buf, buf, 1852296341Sdelphij (unsigned long)lengths[j], &camellia_ks3, 1853296341Sdelphij iv, CAMELLIA_ENCRYPT); 1854296341Sdelphij d = Time_F(STOP); 1855296341Sdelphij print_result(D_CBC_256_CML, j, count, d); 1856296341Sdelphij } 1857296341Sdelphij } 1858296341Sdelphij# endif 1859296341Sdelphij# ifndef OPENSSL_NO_IDEA 1860296341Sdelphij if (doit[D_CBC_IDEA]) { 1861296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1862296341Sdelphij print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]); 1863296341Sdelphij Time_F(START); 1864296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++) 1865296341Sdelphij idea_cbc_encrypt(buf, buf, 1866296341Sdelphij (unsigned long)lengths[j], &idea_ks, 1867296341Sdelphij iv, IDEA_ENCRYPT); 1868296341Sdelphij d = Time_F(STOP); 1869296341Sdelphij print_result(D_CBC_IDEA, j, count, d); 1870296341Sdelphij } 1871296341Sdelphij } 1872296341Sdelphij# endif 1873296341Sdelphij# ifndef OPENSSL_NO_SEED 1874296341Sdelphij if (doit[D_CBC_SEED]) { 1875296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1876296341Sdelphij print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]); 1877296341Sdelphij Time_F(START); 1878296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++) 1879296341Sdelphij SEED_cbc_encrypt(buf, buf, 1880296341Sdelphij (unsigned long)lengths[j], &seed_ks, iv, 1); 1881296341Sdelphij d = Time_F(STOP); 1882296341Sdelphij print_result(D_CBC_SEED, j, count, d); 1883296341Sdelphij } 1884296341Sdelphij } 1885296341Sdelphij# endif 1886296341Sdelphij# ifndef OPENSSL_NO_RC2 1887296341Sdelphij if (doit[D_CBC_RC2]) { 1888296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1889296341Sdelphij print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]); 1890296341Sdelphij Time_F(START); 1891296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++) 1892296341Sdelphij RC2_cbc_encrypt(buf, buf, 1893296341Sdelphij (unsigned long)lengths[j], &rc2_ks, 1894296341Sdelphij iv, RC2_ENCRYPT); 1895296341Sdelphij d = Time_F(STOP); 1896296341Sdelphij print_result(D_CBC_RC2, j, count, d); 1897296341Sdelphij } 1898296341Sdelphij } 1899296341Sdelphij# endif 1900296341Sdelphij# ifndef OPENSSL_NO_RC5 1901296341Sdelphij if (doit[D_CBC_RC5]) { 1902296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1903296341Sdelphij print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]); 1904296341Sdelphij Time_F(START); 1905296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++) 1906296341Sdelphij RC5_32_cbc_encrypt(buf, buf, 1907296341Sdelphij (unsigned long)lengths[j], &rc5_ks, 1908296341Sdelphij iv, RC5_ENCRYPT); 1909296341Sdelphij d = Time_F(STOP); 1910296341Sdelphij print_result(D_CBC_RC5, j, count, d); 1911296341Sdelphij } 1912296341Sdelphij } 1913296341Sdelphij# endif 1914296341Sdelphij# ifndef OPENSSL_NO_BF 1915296341Sdelphij if (doit[D_CBC_BF]) { 1916296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1917296341Sdelphij print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]); 1918296341Sdelphij Time_F(START); 1919296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++) 1920296341Sdelphij BF_cbc_encrypt(buf, buf, 1921296341Sdelphij (unsigned long)lengths[j], &bf_ks, 1922296341Sdelphij iv, BF_ENCRYPT); 1923296341Sdelphij d = Time_F(STOP); 1924296341Sdelphij print_result(D_CBC_BF, j, count, d); 1925296341Sdelphij } 1926296341Sdelphij } 1927296341Sdelphij# endif 1928296341Sdelphij# ifndef OPENSSL_NO_CAST 1929296341Sdelphij if (doit[D_CBC_CAST]) { 1930296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1931296341Sdelphij print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]); 1932296341Sdelphij Time_F(START); 1933296341Sdelphij for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++) 1934296341Sdelphij CAST_cbc_encrypt(buf, buf, 1935296341Sdelphij (unsigned long)lengths[j], &cast_ks, 1936296341Sdelphij iv, CAST_ENCRYPT); 1937296341Sdelphij d = Time_F(STOP); 1938296341Sdelphij print_result(D_CBC_CAST, j, count, d); 1939296341Sdelphij } 1940296341Sdelphij } 1941296341Sdelphij# endif 1942238405Sjkim 1943296341Sdelphij if (doit[D_EVP]) { 1944296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 1945296341Sdelphij if (evp_cipher) { 1946296341Sdelphij EVP_CIPHER_CTX ctx; 1947296341Sdelphij int outl; 1948238405Sjkim 1949296341Sdelphij names[D_EVP] = OBJ_nid2ln(evp_cipher->nid); 1950296341Sdelphij /* 1951296341Sdelphij * -O3 -fschedule-insns messes up an optimization here! 1952296341Sdelphij * names[D_EVP] somehow becomes NULL 1953296341Sdelphij */ 1954296341Sdelphij print_message(names[D_EVP], save_count, lengths[j]); 1955162914Ssimon 1956296341Sdelphij EVP_CIPHER_CTX_init(&ctx); 1957296341Sdelphij if (decrypt) 1958296341Sdelphij EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv); 1959296341Sdelphij else 1960296341Sdelphij EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv); 1961296341Sdelphij EVP_CIPHER_CTX_set_padding(&ctx, 0); 196255714Skris 1963296341Sdelphij Time_F(START); 1964296341Sdelphij if (decrypt) 1965296341Sdelphij for (count = 0, run = 1; 1966296341Sdelphij COND(save_count * 4 * lengths[0] / lengths[j]); 1967296341Sdelphij count++) 1968296341Sdelphij EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]); 1969296341Sdelphij else 1970296341Sdelphij for (count = 0, run = 1; 1971296341Sdelphij COND(save_count * 4 * lengths[0] / lengths[j]); 1972296341Sdelphij count++) 1973296341Sdelphij EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]); 1974296341Sdelphij if (decrypt) 1975296341Sdelphij EVP_DecryptFinal_ex(&ctx, buf, &outl); 1976296341Sdelphij else 1977296341Sdelphij EVP_EncryptFinal_ex(&ctx, buf, &outl); 1978296341Sdelphij d = Time_F(STOP); 1979296341Sdelphij EVP_CIPHER_CTX_cleanup(&ctx); 1980296341Sdelphij } 1981296341Sdelphij if (evp_md) { 1982296341Sdelphij names[D_EVP] = OBJ_nid2ln(evp_md->type); 1983296341Sdelphij print_message(names[D_EVP], save_count, lengths[j]); 1984110007Smarkm 1985296341Sdelphij Time_F(START); 1986296341Sdelphij for (count = 0, run = 1; 1987296341Sdelphij COND(save_count * 4 * lengths[0] / lengths[j]); count++) 1988296341Sdelphij EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL); 1989110007Smarkm 1990296341Sdelphij d = Time_F(STOP); 1991296341Sdelphij } 1992296341Sdelphij print_result(D_EVP, j, count, d); 1993296341Sdelphij } 1994296341Sdelphij } 1995110007Smarkm 1996296341Sdelphij RAND_pseudo_bytes(buf, 36); 1997296341Sdelphij# ifndef OPENSSL_NO_RSA 1998296341Sdelphij for (j = 0; j < RSA_NUM; j++) { 1999296341Sdelphij int ret; 2000296341Sdelphij if (!rsa_doit[j]) 2001296341Sdelphij continue; 2002296341Sdelphij ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]); 2003296341Sdelphij if (ret == 0) { 2004296341Sdelphij BIO_printf(bio_err, 2005296341Sdelphij "RSA sign failure. No RSA sign will be done.\n"); 2006296341Sdelphij ERR_print_errors(bio_err); 2007296341Sdelphij rsa_count = 1; 2008296341Sdelphij } else { 2009296341Sdelphij pkey_print_message("private", "rsa", 2010296341Sdelphij rsa_c[j][0], rsa_bits[j], RSA_SECONDS); 2011296341Sdelphij /* RSA_blinding_on(rsa_key[j],NULL); */ 2012296341Sdelphij Time_F(START); 2013296341Sdelphij for (count = 0, run = 1; COND(rsa_c[j][0]); count++) { 2014296341Sdelphij ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, 2015296341Sdelphij &rsa_num, rsa_key[j]); 2016296341Sdelphij if (ret == 0) { 2017296341Sdelphij BIO_printf(bio_err, "RSA sign failure\n"); 2018296341Sdelphij ERR_print_errors(bio_err); 2019296341Sdelphij count = 1; 2020296341Sdelphij break; 2021296341Sdelphij } 2022296341Sdelphij } 2023296341Sdelphij d = Time_F(STOP); 2024296341Sdelphij BIO_printf(bio_err, 2025296341Sdelphij mr ? "+R1:%ld:%d:%.2f\n" 2026296341Sdelphij : "%ld %d bit private RSA's in %.2fs\n", 2027296341Sdelphij count, rsa_bits[j], d); 2028296341Sdelphij rsa_results[j][0] = d / (double)count; 2029296341Sdelphij rsa_count = count; 2030296341Sdelphij } 2031110007Smarkm 2032296341Sdelphij# if 1 2033296341Sdelphij ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]); 2034296341Sdelphij if (ret <= 0) { 2035296341Sdelphij BIO_printf(bio_err, 2036296341Sdelphij "RSA verify failure. No RSA verify will be done.\n"); 2037296341Sdelphij ERR_print_errors(bio_err); 2038296341Sdelphij rsa_doit[j] = 0; 2039296341Sdelphij } else { 2040296341Sdelphij pkey_print_message("public", "rsa", 2041296341Sdelphij rsa_c[j][1], rsa_bits[j], RSA_SECONDS); 2042296341Sdelphij Time_F(START); 2043296341Sdelphij for (count = 0, run = 1; COND(rsa_c[j][1]); count++) { 2044296341Sdelphij ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, 2045296341Sdelphij rsa_num, rsa_key[j]); 2046296341Sdelphij if (ret <= 0) { 2047296341Sdelphij BIO_printf(bio_err, "RSA verify failure\n"); 2048296341Sdelphij ERR_print_errors(bio_err); 2049296341Sdelphij count = 1; 2050296341Sdelphij break; 2051296341Sdelphij } 2052296341Sdelphij } 2053296341Sdelphij d = Time_F(STOP); 2054296341Sdelphij BIO_printf(bio_err, 2055296341Sdelphij mr ? "+R2:%ld:%d:%.2f\n" 2056296341Sdelphij : "%ld %d bit public RSA's in %.2fs\n", 2057296341Sdelphij count, rsa_bits[j], d); 2058296341Sdelphij rsa_results[j][1] = d / (double)count; 2059296341Sdelphij } 2060296341Sdelphij# endif 2061110007Smarkm 2062296341Sdelphij if (rsa_count <= 1) { 2063296341Sdelphij /* if longer than 10s, don't do any more */ 2064296341Sdelphij for (j++; j < RSA_NUM; j++) 2065296341Sdelphij rsa_doit[j] = 0; 2066296341Sdelphij } 2067296341Sdelphij } 2068296341Sdelphij# endif 2069110007Smarkm 2070296341Sdelphij RAND_pseudo_bytes(buf, 20); 2071296341Sdelphij# ifndef OPENSSL_NO_DSA 2072296341Sdelphij if (RAND_status() != 1) { 2073296341Sdelphij RAND_seed(rnd_seed, sizeof rnd_seed); 2074296341Sdelphij rnd_fake = 1; 2075296341Sdelphij } 2076296341Sdelphij for (j = 0; j < DSA_NUM; j++) { 2077296341Sdelphij unsigned int kk; 2078296341Sdelphij int ret; 207955714Skris 2080296341Sdelphij if (!dsa_doit[j]) 2081296341Sdelphij continue; 208255714Skris 2083296341Sdelphij /* DSA_generate_key(dsa_key[j]); */ 2084296341Sdelphij /* DSA_sign_setup(dsa_key[j],NULL); */ 2085296341Sdelphij ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]); 2086296341Sdelphij if (ret == 0) { 2087296341Sdelphij BIO_printf(bio_err, 2088296341Sdelphij "DSA sign failure. No DSA sign will be done.\n"); 2089296341Sdelphij ERR_print_errors(bio_err); 2090296341Sdelphij rsa_count = 1; 2091296341Sdelphij } else { 2092296341Sdelphij pkey_print_message("sign", "dsa", 2093296341Sdelphij dsa_c[j][0], dsa_bits[j], DSA_SECONDS); 2094296341Sdelphij Time_F(START); 2095296341Sdelphij for (count = 0, run = 1; COND(dsa_c[j][0]); count++) { 2096296341Sdelphij ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]); 2097296341Sdelphij if (ret == 0) { 2098296341Sdelphij BIO_printf(bio_err, "DSA sign failure\n"); 2099296341Sdelphij ERR_print_errors(bio_err); 2100296341Sdelphij count = 1; 2101296341Sdelphij break; 2102296341Sdelphij } 2103296341Sdelphij } 2104296341Sdelphij d = Time_F(STOP); 2105296341Sdelphij BIO_printf(bio_err, 2106296341Sdelphij mr ? "+R3:%ld:%d:%.2f\n" 2107296341Sdelphij : "%ld %d bit DSA signs in %.2fs\n", 2108296341Sdelphij count, dsa_bits[j], d); 2109296341Sdelphij dsa_results[j][0] = d / (double)count; 2110296341Sdelphij rsa_count = count; 2111296341Sdelphij } 211255714Skris 2113296341Sdelphij ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]); 2114296341Sdelphij if (ret <= 0) { 2115296341Sdelphij BIO_printf(bio_err, 2116296341Sdelphij "DSA verify failure. No DSA verify will be done.\n"); 2117296341Sdelphij ERR_print_errors(bio_err); 2118296341Sdelphij dsa_doit[j] = 0; 2119296341Sdelphij } else { 2120296341Sdelphij pkey_print_message("verify", "dsa", 2121296341Sdelphij dsa_c[j][1], dsa_bits[j], DSA_SECONDS); 2122296341Sdelphij Time_F(START); 2123296341Sdelphij for (count = 0, run = 1; COND(dsa_c[j][1]); count++) { 2124296341Sdelphij ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]); 2125296341Sdelphij if (ret <= 0) { 2126296341Sdelphij BIO_printf(bio_err, "DSA verify failure\n"); 2127296341Sdelphij ERR_print_errors(bio_err); 2128296341Sdelphij count = 1; 2129296341Sdelphij break; 2130296341Sdelphij } 2131296341Sdelphij } 2132296341Sdelphij d = Time_F(STOP); 2133296341Sdelphij BIO_printf(bio_err, 2134296341Sdelphij mr ? "+R4:%ld:%d:%.2f\n" 2135296341Sdelphij : "%ld %d bit DSA verify in %.2fs\n", 2136296341Sdelphij count, dsa_bits[j], d); 2137296341Sdelphij dsa_results[j][1] = d / (double)count; 2138296341Sdelphij } 213955714Skris 2140296341Sdelphij if (rsa_count <= 1) { 2141296341Sdelphij /* if longer than 10s, don't do any more */ 2142296341Sdelphij for (j++; j < DSA_NUM; j++) 2143296341Sdelphij dsa_doit[j] = 0; 2144296341Sdelphij } 2145296341Sdelphij } 2146296341Sdelphij if (rnd_fake) 2147296341Sdelphij RAND_cleanup(); 2148296341Sdelphij# endif 214955714Skris 2150296341Sdelphij# ifndef OPENSSL_NO_ECDSA 2151296341Sdelphij if (RAND_status() != 1) { 2152296341Sdelphij RAND_seed(rnd_seed, sizeof rnd_seed); 2153296341Sdelphij rnd_fake = 1; 2154296341Sdelphij } 2155296341Sdelphij for (j = 0; j < EC_NUM; j++) { 2156296341Sdelphij int ret; 215755714Skris 2158296341Sdelphij if (!ecdsa_doit[j]) 2159296341Sdelphij continue; /* Ignore Curve */ 2160296341Sdelphij ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]); 2161296341Sdelphij if (ecdsa[j] == NULL) { 2162296341Sdelphij BIO_printf(bio_err, "ECDSA failure.\n"); 2163296341Sdelphij ERR_print_errors(bio_err); 2164296341Sdelphij rsa_count = 1; 2165296341Sdelphij } else { 2166296341Sdelphij# if 1 2167296341Sdelphij EC_KEY_precompute_mult(ecdsa[j], NULL); 2168296341Sdelphij# endif 2169296341Sdelphij /* Perform ECDSA signature test */ 2170296341Sdelphij EC_KEY_generate_key(ecdsa[j]); 2171296341Sdelphij ret = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]); 2172296341Sdelphij if (ret == 0) { 2173296341Sdelphij BIO_printf(bio_err, 2174296341Sdelphij "ECDSA sign failure. No ECDSA sign will be done.\n"); 2175296341Sdelphij ERR_print_errors(bio_err); 2176296341Sdelphij rsa_count = 1; 2177296341Sdelphij } else { 2178296341Sdelphij pkey_print_message("sign", "ecdsa", 2179296341Sdelphij ecdsa_c[j][0], 2180296341Sdelphij test_curves_bits[j], ECDSA_SECONDS); 2181160817Ssimon 2182296341Sdelphij Time_F(START); 2183296341Sdelphij for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) { 2184296341Sdelphij ret = ECDSA_sign(0, buf, 20, 2185296341Sdelphij ecdsasig, &ecdsasiglen, ecdsa[j]); 2186296341Sdelphij if (ret == 0) { 2187296341Sdelphij BIO_printf(bio_err, "ECDSA sign failure\n"); 2188296341Sdelphij ERR_print_errors(bio_err); 2189296341Sdelphij count = 1; 2190296341Sdelphij break; 2191296341Sdelphij } 2192296341Sdelphij } 2193296341Sdelphij d = Time_F(STOP); 2194160817Ssimon 2195296341Sdelphij BIO_printf(bio_err, 2196296341Sdelphij mr ? "+R5:%ld:%d:%.2f\n" : 2197296341Sdelphij "%ld %d bit ECDSA signs in %.2fs \n", 2198296341Sdelphij count, test_curves_bits[j], d); 2199296341Sdelphij ecdsa_results[j][0] = d / (double)count; 2200296341Sdelphij rsa_count = count; 2201296341Sdelphij } 2202160817Ssimon 2203296341Sdelphij /* Perform ECDSA verification test */ 2204296341Sdelphij ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]); 2205296341Sdelphij if (ret != 1) { 2206296341Sdelphij BIO_printf(bio_err, 2207296341Sdelphij "ECDSA verify failure. No ECDSA verify will be done.\n"); 2208296341Sdelphij ERR_print_errors(bio_err); 2209296341Sdelphij ecdsa_doit[j] = 0; 2210296341Sdelphij } else { 2211296341Sdelphij pkey_print_message("verify", "ecdsa", 2212296341Sdelphij ecdsa_c[j][1], 2213296341Sdelphij test_curves_bits[j], ECDSA_SECONDS); 2214296341Sdelphij Time_F(START); 2215296341Sdelphij for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) { 2216296341Sdelphij ret = 2217296341Sdelphij ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, 2218296341Sdelphij ecdsa[j]); 2219296341Sdelphij if (ret != 1) { 2220296341Sdelphij BIO_printf(bio_err, "ECDSA verify failure\n"); 2221296341Sdelphij ERR_print_errors(bio_err); 2222296341Sdelphij count = 1; 2223296341Sdelphij break; 2224296341Sdelphij } 2225296341Sdelphij } 2226296341Sdelphij d = Time_F(STOP); 2227296341Sdelphij BIO_printf(bio_err, 2228296341Sdelphij mr ? "+R6:%ld:%d:%.2f\n" 2229296341Sdelphij : "%ld %d bit ECDSA verify in %.2fs\n", 2230296341Sdelphij count, test_curves_bits[j], d); 2231296341Sdelphij ecdsa_results[j][1] = d / (double)count; 2232296341Sdelphij } 2233160817Ssimon 2234296341Sdelphij if (rsa_count <= 1) { 2235296341Sdelphij /* if longer than 10s, don't do any more */ 2236296341Sdelphij for (j++; j < EC_NUM; j++) 2237296341Sdelphij ecdsa_doit[j] = 0; 2238296341Sdelphij } 2239296341Sdelphij } 2240296341Sdelphij } 2241296341Sdelphij if (rnd_fake) 2242296341Sdelphij RAND_cleanup(); 2243296341Sdelphij# endif 2244160817Ssimon 2245296341Sdelphij# ifndef OPENSSL_NO_ECDH 2246296341Sdelphij if (RAND_status() != 1) { 2247296341Sdelphij RAND_seed(rnd_seed, sizeof rnd_seed); 2248296341Sdelphij rnd_fake = 1; 2249296341Sdelphij } 2250296341Sdelphij for (j = 0; j < EC_NUM; j++) { 2251296341Sdelphij if (!ecdh_doit[j]) 2252296341Sdelphij continue; 2253296341Sdelphij ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]); 2254296341Sdelphij ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]); 2255296341Sdelphij if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) { 2256296341Sdelphij BIO_printf(bio_err, "ECDH failure.\n"); 2257296341Sdelphij ERR_print_errors(bio_err); 2258296341Sdelphij rsa_count = 1; 2259296341Sdelphij } else { 2260296341Sdelphij /* generate two ECDH key pairs */ 2261296341Sdelphij if (!EC_KEY_generate_key(ecdh_a[j]) || 2262296341Sdelphij !EC_KEY_generate_key(ecdh_b[j])) { 2263296341Sdelphij BIO_printf(bio_err, "ECDH key generation failure.\n"); 2264296341Sdelphij ERR_print_errors(bio_err); 2265296341Sdelphij rsa_count = 1; 2266296341Sdelphij } else { 2267296341Sdelphij /* 2268296341Sdelphij * If field size is not more than 24 octets, then use SHA-1 2269296341Sdelphij * hash of result; otherwise, use result (see section 4.8 of 2270296341Sdelphij * draft-ietf-tls-ecc-03.txt). 2271296341Sdelphij */ 2272296341Sdelphij int field_size, outlen; 2273296341Sdelphij void *(*kdf) (const void *in, size_t inlen, void *out, 2274296341Sdelphij size_t *xoutlen); 2275296341Sdelphij field_size = 2276296341Sdelphij EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j])); 2277296341Sdelphij if (field_size <= 24 * 8) { 2278296341Sdelphij outlen = KDF1_SHA1_len; 2279296341Sdelphij kdf = KDF1_SHA1; 2280296341Sdelphij } else { 2281296341Sdelphij outlen = (field_size + 7) / 8; 2282296341Sdelphij kdf = NULL; 2283296341Sdelphij } 2284296341Sdelphij secret_size_a = 2285296341Sdelphij ECDH_compute_key(secret_a, outlen, 2286296341Sdelphij EC_KEY_get0_public_key(ecdh_b[j]), 2287296341Sdelphij ecdh_a[j], kdf); 2288296341Sdelphij secret_size_b = 2289296341Sdelphij ECDH_compute_key(secret_b, outlen, 2290296341Sdelphij EC_KEY_get0_public_key(ecdh_a[j]), 2291296341Sdelphij ecdh_b[j], kdf); 2292296341Sdelphij if (secret_size_a != secret_size_b) 2293296341Sdelphij ecdh_checks = 0; 2294296341Sdelphij else 2295296341Sdelphij ecdh_checks = 1; 2296160817Ssimon 2297296341Sdelphij for (secret_idx = 0; (secret_idx < secret_size_a) 2298296341Sdelphij && (ecdh_checks == 1); secret_idx++) { 2299296341Sdelphij if (secret_a[secret_idx] != secret_b[secret_idx]) 2300296341Sdelphij ecdh_checks = 0; 2301296341Sdelphij } 2302160817Ssimon 2303296341Sdelphij if (ecdh_checks == 0) { 2304296341Sdelphij BIO_printf(bio_err, "ECDH computations don't match.\n"); 2305296341Sdelphij ERR_print_errors(bio_err); 2306296341Sdelphij rsa_count = 1; 2307296341Sdelphij } 2308160817Ssimon 2309296341Sdelphij pkey_print_message("", "ecdh", 2310296341Sdelphij ecdh_c[j][0], 2311296341Sdelphij test_curves_bits[j], ECDH_SECONDS); 2312296341Sdelphij Time_F(START); 2313296341Sdelphij for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) { 2314296341Sdelphij ECDH_compute_key(secret_a, outlen, 2315296341Sdelphij EC_KEY_get0_public_key(ecdh_b[j]), 2316296341Sdelphij ecdh_a[j], kdf); 2317296341Sdelphij } 2318296341Sdelphij d = Time_F(STOP); 2319296341Sdelphij BIO_printf(bio_err, 2320296341Sdelphij mr ? "+R7:%ld:%d:%.2f\n" : 2321296341Sdelphij "%ld %d-bit ECDH ops in %.2fs\n", count, 2322296341Sdelphij test_curves_bits[j], d); 2323296341Sdelphij ecdh_results[j][0] = d / (double)count; 2324296341Sdelphij rsa_count = count; 2325296341Sdelphij } 2326296341Sdelphij } 2327160817Ssimon 2328296341Sdelphij if (rsa_count <= 1) { 2329296341Sdelphij /* if longer than 10s, don't do any more */ 2330296341Sdelphij for (j++; j < EC_NUM; j++) 2331296341Sdelphij ecdh_doit[j] = 0; 2332296341Sdelphij } 2333296341Sdelphij } 2334296341Sdelphij if (rnd_fake) 2335296341Sdelphij RAND_cleanup(); 2336296341Sdelphij# endif 2337296341Sdelphij# ifndef NO_FORK 2338296341Sdelphij show_res: 2339296341Sdelphij# endif 2340296341Sdelphij if (!mr) { 2341296341Sdelphij fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_VERSION)); 2342296341Sdelphij fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_BUILT_ON)); 2343296341Sdelphij printf("options:"); 2344296341Sdelphij printf("%s ", BN_options()); 2345296341Sdelphij# ifndef OPENSSL_NO_MD2 2346296341Sdelphij printf("%s ", MD2_options()); 2347296341Sdelphij# endif 2348296341Sdelphij# ifndef OPENSSL_NO_RC4 2349296341Sdelphij printf("%s ", RC4_options()); 2350296341Sdelphij# endif 2351296341Sdelphij# ifndef OPENSSL_NO_DES 2352296341Sdelphij printf("%s ", DES_options()); 2353296341Sdelphij# endif 2354296341Sdelphij# ifndef OPENSSL_NO_AES 2355296341Sdelphij printf("%s ", AES_options()); 2356296341Sdelphij# endif 2357296341Sdelphij# ifndef OPENSSL_NO_IDEA 2358296341Sdelphij printf("%s ", idea_options()); 2359296341Sdelphij# endif 2360296341Sdelphij# ifndef OPENSSL_NO_BF 2361296341Sdelphij printf("%s ", BF_options()); 2362296341Sdelphij# endif 2363296341Sdelphij fprintf(stdout, "\n%s\n", SSLeay_version(SSLEAY_CFLAGS)); 2364296341Sdelphij } 2365160817Ssimon 2366296341Sdelphij if (pr_header) { 2367296341Sdelphij if (mr) 2368296341Sdelphij fprintf(stdout, "+H"); 2369296341Sdelphij else { 2370296341Sdelphij fprintf(stdout, 2371296341Sdelphij "The 'numbers' are in 1000s of bytes per second processed.\n"); 2372296341Sdelphij fprintf(stdout, "type "); 2373296341Sdelphij } 2374296341Sdelphij for (j = 0; j < SIZE_NUM; j++) 2375296341Sdelphij fprintf(stdout, mr ? ":%d" : "%7d bytes", lengths[j]); 2376296341Sdelphij fprintf(stdout, "\n"); 2377296341Sdelphij } 2378160817Ssimon 2379296341Sdelphij for (k = 0; k < ALGOR_NUM; k++) { 2380296341Sdelphij if (!doit[k]) 2381296341Sdelphij continue; 2382296341Sdelphij if (mr) 2383296341Sdelphij fprintf(stdout, "+F:%d:%s", k, names[k]); 2384296341Sdelphij else 2385296341Sdelphij fprintf(stdout, "%-13s", names[k]); 2386296341Sdelphij for (j = 0; j < SIZE_NUM; j++) { 2387296341Sdelphij if (results[k][j] > 10000 && !mr) 2388296341Sdelphij fprintf(stdout, " %11.2fk", results[k][j] / 1e3); 2389296341Sdelphij else 2390296341Sdelphij fprintf(stdout, mr ? ":%.2f" : " %11.2f ", results[k][j]); 2391296341Sdelphij } 2392296341Sdelphij fprintf(stdout, "\n"); 2393296341Sdelphij } 2394296341Sdelphij# ifndef OPENSSL_NO_RSA 2395296341Sdelphij j = 1; 2396296341Sdelphij for (k = 0; k < RSA_NUM; k++) { 2397296341Sdelphij if (!rsa_doit[k]) 2398296341Sdelphij continue; 2399296341Sdelphij if (j && !mr) { 2400296341Sdelphij printf("%18ssign verify sign/s verify/s\n", " "); 2401296341Sdelphij j = 0; 2402296341Sdelphij } 2403296341Sdelphij if (mr) 2404296341Sdelphij fprintf(stdout, "+F2:%u:%u:%f:%f\n", 2405296341Sdelphij k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]); 2406296341Sdelphij else 2407296341Sdelphij fprintf(stdout, "rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 2408296341Sdelphij rsa_bits[k], rsa_results[k][0], rsa_results[k][1], 2409296341Sdelphij 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]); 2410296341Sdelphij } 2411296341Sdelphij# endif 2412296341Sdelphij# ifndef OPENSSL_NO_DSA 2413296341Sdelphij j = 1; 2414296341Sdelphij for (k = 0; k < DSA_NUM; k++) { 2415296341Sdelphij if (!dsa_doit[k]) 2416296341Sdelphij continue; 2417296341Sdelphij if (j && !mr) { 2418296341Sdelphij printf("%18ssign verify sign/s verify/s\n", " "); 2419296341Sdelphij j = 0; 2420296341Sdelphij } 2421296341Sdelphij if (mr) 2422296341Sdelphij fprintf(stdout, "+F3:%u:%u:%f:%f\n", 2423296341Sdelphij k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]); 2424296341Sdelphij else 2425296341Sdelphij fprintf(stdout, "dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n", 2426296341Sdelphij dsa_bits[k], dsa_results[k][0], dsa_results[k][1], 2427296341Sdelphij 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]); 2428296341Sdelphij } 2429296341Sdelphij# endif 2430296341Sdelphij# ifndef OPENSSL_NO_ECDSA 2431296341Sdelphij j = 1; 2432296341Sdelphij for (k = 0; k < EC_NUM; k++) { 2433296341Sdelphij if (!ecdsa_doit[k]) 2434296341Sdelphij continue; 2435296341Sdelphij if (j && !mr) { 2436296341Sdelphij printf("%30ssign verify sign/s verify/s\n", " "); 2437296341Sdelphij j = 0; 2438296341Sdelphij } 2439160817Ssimon 2440296341Sdelphij if (mr) 2441296341Sdelphij fprintf(stdout, "+F4:%u:%u:%f:%f\n", 2442296341Sdelphij k, test_curves_bits[k], 2443296341Sdelphij ecdsa_results[k][0], ecdsa_results[k][1]); 2444296341Sdelphij else 2445296341Sdelphij fprintf(stdout, 2446296341Sdelphij "%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n", 2447296341Sdelphij test_curves_bits[k], 2448296341Sdelphij test_curves_names[k], 2449296341Sdelphij ecdsa_results[k][0], ecdsa_results[k][1], 2450296341Sdelphij 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]); 2451296341Sdelphij } 2452296341Sdelphij# endif 245355714Skris 2454296341Sdelphij# ifndef OPENSSL_NO_ECDH 2455296341Sdelphij j = 1; 2456296341Sdelphij for (k = 0; k < EC_NUM; k++) { 2457296341Sdelphij if (!ecdh_doit[k]) 2458296341Sdelphij continue; 2459296341Sdelphij if (j && !mr) { 2460296341Sdelphij printf("%30sop op/s\n", " "); 2461296341Sdelphij j = 0; 2462296341Sdelphij } 2463296341Sdelphij if (mr) 2464296341Sdelphij fprintf(stdout, "+F5:%u:%u:%f:%f\n", 2465296341Sdelphij k, test_curves_bits[k], 2466296341Sdelphij ecdh_results[k][0], 1.0 / ecdh_results[k][0]); 246755714Skris 2468296341Sdelphij else 2469296341Sdelphij fprintf(stdout, "%4u bit ecdh (%s) %8.4fs %8.1f\n", 2470296341Sdelphij test_curves_bits[k], 2471296341Sdelphij test_curves_names[k], 2472296341Sdelphij ecdh_results[k][0], 1.0 / ecdh_results[k][0]); 2473296341Sdelphij } 2474296341Sdelphij# endif 2475160817Ssimon 2476296341Sdelphij mret = 0; 2477160817Ssimon 2478296341Sdelphij end: 2479296341Sdelphij ERR_print_errors(bio_err); 2480296341Sdelphij if (buf != NULL) 2481296341Sdelphij OPENSSL_free(buf); 2482296341Sdelphij if (buf2 != NULL) 2483296341Sdelphij OPENSSL_free(buf2); 2484296341Sdelphij# ifndef OPENSSL_NO_RSA 2485296341Sdelphij for (i = 0; i < RSA_NUM; i++) 2486296341Sdelphij if (rsa_key[i] != NULL) 2487296341Sdelphij RSA_free(rsa_key[i]); 2488296341Sdelphij# endif 2489296341Sdelphij# ifndef OPENSSL_NO_DSA 2490296341Sdelphij for (i = 0; i < DSA_NUM; i++) 2491296341Sdelphij if (dsa_key[i] != NULL) 2492296341Sdelphij DSA_free(dsa_key[i]); 2493296341Sdelphij# endif 2494160817Ssimon 2495296341Sdelphij# ifndef OPENSSL_NO_ECDSA 2496296341Sdelphij for (i = 0; i < EC_NUM; i++) 2497296341Sdelphij if (ecdsa[i] != NULL) 2498296341Sdelphij EC_KEY_free(ecdsa[i]); 2499296341Sdelphij# endif 2500296341Sdelphij# ifndef OPENSSL_NO_ECDH 2501296341Sdelphij for (i = 0; i < EC_NUM; i++) { 2502296341Sdelphij if (ecdh_a[i] != NULL) 2503296341Sdelphij EC_KEY_free(ecdh_a[i]); 2504296341Sdelphij if (ecdh_b[i] != NULL) 2505296341Sdelphij EC_KEY_free(ecdh_b[i]); 2506296341Sdelphij } 2507296341Sdelphij# endif 2508160817Ssimon 2509296341Sdelphij apps_shutdown(); 2510296341Sdelphij OPENSSL_EXIT(mret); 2511296341Sdelphij} 2512160817Ssimon 2513110007Smarkmstatic void print_message(const char *s, long num, int length) 2514296341Sdelphij{ 2515296341Sdelphij# ifdef SIGALRM 2516296341Sdelphij BIO_printf(bio_err, 2517296341Sdelphij mr ? "+DT:%s:%d:%d\n" 2518296341Sdelphij : "Doing %s for %ds on %d size blocks: ", s, SECONDS, length); 2519296341Sdelphij (void)BIO_flush(bio_err); 2520296341Sdelphij alarm(SECONDS); 2521296341Sdelphij# else 2522296341Sdelphij BIO_printf(bio_err, 2523296341Sdelphij mr ? "+DN:%s:%ld:%d\n" 2524296341Sdelphij : "Doing %s %ld times on %d size blocks: ", s, num, length); 2525296341Sdelphij (void)BIO_flush(bio_err); 2526296341Sdelphij# endif 2527296341Sdelphij# ifdef LINT 2528296341Sdelphij num = num; 2529296341Sdelphij# endif 2530296341Sdelphij} 253155714Skris 2532160817Ssimonstatic void pkey_print_message(const char *str, const char *str2, long num, 2533296341Sdelphij int bits, int tm) 2534296341Sdelphij{ 2535296341Sdelphij# ifdef SIGALRM 2536296341Sdelphij BIO_printf(bio_err, 2537296341Sdelphij mr ? "+DTP:%d:%s:%s:%d\n" 2538296341Sdelphij : "Doing %d bit %s %s's for %ds: ", bits, str, str2, tm); 2539296341Sdelphij (void)BIO_flush(bio_err); 2540296341Sdelphij alarm(tm); 2541296341Sdelphij# else 2542296341Sdelphij BIO_printf(bio_err, 2543296341Sdelphij mr ? "+DNP:%ld:%d:%s:%s\n" 2544296341Sdelphij : "Doing %ld %d bit %s %s's: ", num, bits, str, str2); 2545296341Sdelphij (void)BIO_flush(bio_err); 2546296341Sdelphij# endif 2547296341Sdelphij# ifdef LINT 2548296341Sdelphij num = num; 2549296341Sdelphij# endif 2550296341Sdelphij} 255155714Skris 2552296341Sdelphijstatic void print_result(int alg, int run_no, int count, double time_used) 2553296341Sdelphij{ 2554296341Sdelphij BIO_printf(bio_err, 2555296341Sdelphij mr ? "+R:%d:%s:%f\n" 2556296341Sdelphij : "%d %s's in %.2fs\n", count, names[alg], time_used); 2557296341Sdelphij results[alg][run_no] = ((double)count) / time_used * lengths[run_no]; 2558296341Sdelphij} 2559110007Smarkm 2560296341Sdelphij# ifndef NO_FORK 2561110007Smarkmstatic char *sstrsep(char **string, const char *delim) 2562296341Sdelphij{ 2563110007Smarkm char isdelim[256]; 2564110007Smarkm char *token = *string; 2565110007Smarkm 2566110007Smarkm if (**string == 0) 2567110007Smarkm return NULL; 2568110007Smarkm 2569110007Smarkm memset(isdelim, 0, sizeof isdelim); 2570110007Smarkm isdelim[0] = 1; 2571110007Smarkm 2572296341Sdelphij while (*delim) { 2573110007Smarkm isdelim[(unsigned char)(*delim)] = 1; 2574110007Smarkm delim++; 2575296341Sdelphij } 2576110007Smarkm 2577296341Sdelphij while (!isdelim[(unsigned char)(**string)]) { 2578110007Smarkm (*string)++; 2579296341Sdelphij } 2580110007Smarkm 2581296341Sdelphij if (**string) { 2582110007Smarkm **string = 0; 2583110007Smarkm (*string)++; 2584296341Sdelphij } 2585110007Smarkm 2586110007Smarkm return token; 2587296341Sdelphij} 2588110007Smarkm 2589110007Smarkmstatic int do_multi(int multi) 2590296341Sdelphij{ 2591296341Sdelphij int n; 2592296341Sdelphij int fd[2]; 2593296341Sdelphij int *fds; 2594296341Sdelphij static char sep[] = ":"; 2595110007Smarkm 2596296341Sdelphij fds = malloc(multi * sizeof *fds); 2597296341Sdelphij for (n = 0; n < multi; ++n) { 2598296341Sdelphij if (pipe(fd) == -1) { 2599296341Sdelphij fprintf(stderr, "pipe failure\n"); 2600296341Sdelphij exit(1); 2601296341Sdelphij } 2602296341Sdelphij fflush(stdout); 2603296341Sdelphij fflush(stderr); 2604296341Sdelphij if (fork()) { 2605296341Sdelphij close(fd[1]); 2606296341Sdelphij fds[n] = fd[0]; 2607296341Sdelphij } else { 2608296341Sdelphij close(fd[0]); 2609296341Sdelphij close(1); 2610296341Sdelphij if (dup(fd[1]) == -1) { 2611296341Sdelphij fprintf(stderr, "dup failed\n"); 2612296341Sdelphij exit(1); 2613296341Sdelphij } 2614296341Sdelphij close(fd[1]); 2615296341Sdelphij mr = 1; 2616296341Sdelphij usertime = 0; 2617296341Sdelphij free(fds); 2618296341Sdelphij return 0; 2619296341Sdelphij } 2620296341Sdelphij printf("Forked child %d\n", n); 2621296341Sdelphij } 2622110007Smarkm 2623296341Sdelphij /* for now, assume the pipe is long enough to take all the output */ 2624296341Sdelphij for (n = 0; n < multi; ++n) { 2625296341Sdelphij FILE *f; 2626296341Sdelphij char buf[1024]; 2627296341Sdelphij char *p; 2628110007Smarkm 2629296341Sdelphij f = fdopen(fds[n], "r"); 2630296341Sdelphij while (fgets(buf, sizeof buf, f)) { 2631296341Sdelphij p = strchr(buf, '\n'); 2632296341Sdelphij if (p) 2633296341Sdelphij *p = '\0'; 2634296341Sdelphij if (buf[0] != '+') { 2635296341Sdelphij fprintf(stderr, "Don't understand line '%s' from child %d\n", 2636296341Sdelphij buf, n); 2637296341Sdelphij continue; 2638296341Sdelphij } 2639296341Sdelphij printf("Got: %s from %d\n", buf, n); 2640296341Sdelphij if (!strncmp(buf, "+F:", 3)) { 2641296341Sdelphij int alg; 2642296341Sdelphij int j; 2643110007Smarkm 2644296341Sdelphij p = buf + 3; 2645296341Sdelphij alg = atoi(sstrsep(&p, sep)); 2646296341Sdelphij sstrsep(&p, sep); 2647296341Sdelphij for (j = 0; j < SIZE_NUM; ++j) 2648296341Sdelphij results[alg][j] += atof(sstrsep(&p, sep)); 2649296341Sdelphij } else if (!strncmp(buf, "+F2:", 4)) { 2650296341Sdelphij int k; 2651296341Sdelphij double d; 2652110007Smarkm 2653296341Sdelphij p = buf + 4; 2654296341Sdelphij k = atoi(sstrsep(&p, sep)); 2655296341Sdelphij sstrsep(&p, sep); 2656110007Smarkm 2657296341Sdelphij d = atof(sstrsep(&p, sep)); 2658296341Sdelphij if (n) 2659296341Sdelphij rsa_results[k][0] = 1 / (1 / rsa_results[k][0] + 1 / d); 2660296341Sdelphij else 2661296341Sdelphij rsa_results[k][0] = d; 2662110007Smarkm 2663296341Sdelphij d = atof(sstrsep(&p, sep)); 2664296341Sdelphij if (n) 2665296341Sdelphij rsa_results[k][1] = 1 / (1 / rsa_results[k][1] + 1 / d); 2666296341Sdelphij else 2667296341Sdelphij rsa_results[k][1] = d; 2668296341Sdelphij } 2669296341Sdelphij# ifndef OPENSSL_NO_DSA 2670296341Sdelphij else if (!strncmp(buf, "+F3:", 4)) { 2671296341Sdelphij int k; 2672296341Sdelphij double d; 2673110007Smarkm 2674296341Sdelphij p = buf + 4; 2675296341Sdelphij k = atoi(sstrsep(&p, sep)); 2676296341Sdelphij sstrsep(&p, sep); 2677160817Ssimon 2678296341Sdelphij d = atof(sstrsep(&p, sep)); 2679296341Sdelphij if (n) 2680296341Sdelphij dsa_results[k][0] = 1 / (1 / dsa_results[k][0] + 1 / d); 2681296341Sdelphij else 2682296341Sdelphij dsa_results[k][0] = d; 2683160817Ssimon 2684296341Sdelphij d = atof(sstrsep(&p, sep)); 2685296341Sdelphij if (n) 2686296341Sdelphij dsa_results[k][1] = 1 / (1 / dsa_results[k][1] + 1 / d); 2687296341Sdelphij else 2688296341Sdelphij dsa_results[k][1] = d; 2689296341Sdelphij } 2690296341Sdelphij# endif 2691296341Sdelphij# ifndef OPENSSL_NO_ECDSA 2692296341Sdelphij else if (!strncmp(buf, "+F4:", 4)) { 2693296341Sdelphij int k; 2694296341Sdelphij double d; 2695160817Ssimon 2696296341Sdelphij p = buf + 4; 2697296341Sdelphij k = atoi(sstrsep(&p, sep)); 2698296341Sdelphij sstrsep(&p, sep); 2699160817Ssimon 2700296341Sdelphij d = atof(sstrsep(&p, sep)); 2701296341Sdelphij if (n) 2702296341Sdelphij ecdsa_results[k][0] = 2703296341Sdelphij 1 / (1 / ecdsa_results[k][0] + 1 / d); 2704296341Sdelphij else 2705296341Sdelphij ecdsa_results[k][0] = d; 2706160817Ssimon 2707296341Sdelphij d = atof(sstrsep(&p, sep)); 2708296341Sdelphij if (n) 2709296341Sdelphij ecdsa_results[k][1] = 2710296341Sdelphij 1 / (1 / ecdsa_results[k][1] + 1 / d); 2711296341Sdelphij else 2712296341Sdelphij ecdsa_results[k][1] = d; 2713296341Sdelphij } 2714296341Sdelphij# endif 2715160817Ssimon 2716296341Sdelphij# ifndef OPENSSL_NO_ECDH 2717296341Sdelphij else if (!strncmp(buf, "+F5:", 4)) { 2718296341Sdelphij int k; 2719296341Sdelphij double d; 2720238405Sjkim 2721296341Sdelphij p = buf + 4; 2722296341Sdelphij k = atoi(sstrsep(&p, sep)); 2723296341Sdelphij sstrsep(&p, sep); 2724296341Sdelphij 2725296341Sdelphij d = atof(sstrsep(&p, sep)); 2726296341Sdelphij if (n) 2727296341Sdelphij ecdh_results[k][0] = 1 / (1 / ecdh_results[k][0] + 1 / d); 2728296341Sdelphij else 2729296341Sdelphij ecdh_results[k][0] = d; 2730296341Sdelphij 2731296341Sdelphij } 2732296341Sdelphij# endif 2733296341Sdelphij 2734296341Sdelphij else if (!strncmp(buf, "+H:", 3)) { 2735296341Sdelphij } else 2736296341Sdelphij fprintf(stderr, "Unknown type '%s' from child %d\n", buf, n); 2737296341Sdelphij } 2738296341Sdelphij 2739296341Sdelphij fclose(f); 2740296341Sdelphij } 2741296341Sdelphij free(fds); 2742296341Sdelphij return 1; 2743296341Sdelphij} 2744296341Sdelphij# endif 2745110007Smarkm#endif 2746