+
+# ifndef OPENSSL_NO_IDEA
+ BIO_printf(bio_err, "idea ");
+# endif
+# ifndef OPENSSL_NO_SEED
+ BIO_printf(bio_err, "seed ");
+# endif
+# ifndef OPENSSL_NO_RC2
+ BIO_printf(bio_err, "rc2 ");
+# endif
+# ifndef OPENSSL_NO_DES
+ BIO_printf(bio_err, "des ");
+# endif
+# ifndef OPENSSL_NO_AES
+ BIO_printf(bio_err, "aes ");
+# endif
+# ifndef OPENSSL_NO_CAMELLIA
+ BIO_printf(bio_err, "camellia ");
+# endif
+# ifndef OPENSSL_NO_RSA
+ BIO_printf(bio_err, "rsa ");
+# endif
+# ifndef OPENSSL_NO_BF
+ BIO_printf(bio_err, "blowfish");
+# endif
+# if !defined(OPENSSL_NO_IDEA) || !defined(OPENSSL_NO_SEED) || \
+ !defined(OPENSSL_NO_RC2) || !defined(OPENSSL_NO_DES) || \
+ !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_BF) || \
+ !defined(OPENSSL_NO_AES) || !defined(OPENSSL_NO_CAMELLIA)
+ BIO_printf(bio_err, "\n");
+# endif
+
+ BIO_printf(bio_err, "\n");
+ BIO_printf(bio_err, "Available options:\n");
+# if defined(TIMES) || defined(USE_TOD)
+ BIO_printf(bio_err, "-elapsed "
+ "measure time in real time instead of CPU user time.\n");
+# endif
+# ifndef OPENSSL_NO_ENGINE
+ BIO_printf(bio_err,
+ "-engine e "
+ "use engine e, possibly a hardware device.\n");
+# endif
+ BIO_printf(bio_err, "-evp e " "use EVP e.\n");
+ BIO_printf(bio_err,
+ "-decrypt "
+ "time decryption instead of encryption (only EVP).\n");
+ BIO_printf(bio_err,
+ "-mr "
+ "produce machine readable output.\n");
+# ifndef NO_FORK
+ BIO_printf(bio_err,
+ "-multi n " "run n benchmarks in parallel.\n");
+# endif
+ goto end;
+ }
+ argc--;
+ argv++;
+ j++;
+ }
+
+# ifndef NO_FORK
+ if (multi && do_multi(multi))
+ goto show_res;
+# endif
+
+ if (j == 0) {
+ for (i = 0; i < ALGOR_NUM; i++) {
+ if (i != D_EVP)
+ doit[i] = 1;
+ }
+ for (i = 0; i < RSA_NUM; i++)
+ rsa_doit[i] = 1;
+ for (i = 0; i < DSA_NUM; i++)
+ dsa_doit[i] = 1;
+# ifndef OPENSSL_NO_ECDSA
+ for (i = 0; i < EC_NUM; i++)
+ ecdsa_doit[i] = 1;
+# endif
+# ifndef OPENSSL_NO_ECDH
+ for (i = 0; i < EC_NUM; i++)
+ ecdh_doit[i] = 1;
+# endif
+ }
+ for (i = 0; i < ALGOR_NUM; i++)
+ if (doit[i])
+ pr_header++;
+
+ if (usertime == 0 && !mr)
+ BIO_printf(bio_err,
+ "You have chosen to measure elapsed time "
+ "instead of user CPU time.\n");
+
+# ifndef OPENSSL_NO_RSA
+ for (i = 0; i < RSA_NUM; i++) {
+ const unsigned char *p;
+
+ p = rsa_data[i];
+ rsa_key[i] = d2i_RSAPrivateKey(NULL, &p, rsa_data_length[i]);
+ if (rsa_key[i] == NULL) {
+ BIO_printf(bio_err, "internal error loading RSA key number %d\n",
+ i);
+ goto end;
+ }
+# if 0
+ else {
+ BIO_printf(bio_err,
+ mr ? "+RK:%d:"
+ : "Loaded RSA key, %d bit modulus and e= 0x",
+ BN_num_bits(rsa_key[i]->n));
+ BN_print(bio_err, rsa_key[i]->e);
+ BIO_printf(bio_err, "\n");
+ }
+# endif
+ }
+# endif
+
+# ifndef OPENSSL_NO_DSA
+ dsa_key[0] = get_dsa512();
+ dsa_key[1] = get_dsa1024();
+ dsa_key[2] = get_dsa2048();
+# endif
+
+# ifndef OPENSSL_NO_DES
+ DES_set_key_unchecked(&key, &sch);
+ DES_set_key_unchecked(&key2, &sch2);
+ DES_set_key_unchecked(&key3, &sch3);
+# endif
+# ifndef OPENSSL_NO_AES
+ AES_set_encrypt_key(key16, 128, &aes_ks1);
+ AES_set_encrypt_key(key24, 192, &aes_ks2);
+ AES_set_encrypt_key(key32, 256, &aes_ks3);
+# endif
+# ifndef OPENSSL_NO_CAMELLIA
+ Camellia_set_key(key16, 128, &camellia_ks1);
+ Camellia_set_key(ckey24, 192, &camellia_ks2);
+ Camellia_set_key(ckey32, 256, &camellia_ks3);
+# endif
+# ifndef OPENSSL_NO_IDEA
+ idea_set_encrypt_key(key16, &idea_ks);
+# endif
+# ifndef OPENSSL_NO_SEED
+ SEED_set_key(key16, &seed_ks);
+# endif
+# ifndef OPENSSL_NO_RC4
+ RC4_set_key(&rc4_ks, 16, key16);
+# endif
+# ifndef OPENSSL_NO_RC2
+ RC2_set_key(&rc2_ks, 16, key16, 128);
+# endif
+# ifndef OPENSSL_NO_RC5
+ RC5_32_set_key(&rc5_ks, 16, key16, 12);
+# endif
+# ifndef OPENSSL_NO_BF
+ BF_set_key(&bf_ks, 16, key16);
+# endif
+# ifndef OPENSSL_NO_CAST
+ CAST_set_key(&cast_ks, 16, key16);
+# endif
+# ifndef OPENSSL_NO_RSA
+ memset(rsa_c, 0, sizeof(rsa_c));
+# endif
+# ifndef SIGALRM
+# ifndef OPENSSL_NO_DES
+ BIO_printf(bio_err, "First we calculate the approximate speed ...\n");
+ count = 10;
+ do {
+ long it;
+ count *= 2;
+ Time_F(START);
+ for (it = count; it; it--)
+ DES_ecb_encrypt((DES_cblock *)buf,
+ (DES_cblock *)buf, &sch, DES_ENCRYPT);
+ d = Time_F(STOP);
+ } while (d < 3);
+ save_count = count;
+ c[D_MD2][0] = count / 10;
+ c[D_MDC2][0] = count / 10;
+ c[D_MD4][0] = count;
+ c[D_MD5][0] = count;
+ c[D_HMAC][0] = count;
+ c[D_SHA1][0] = count;
+ c[D_RMD160][0] = count;
+ c[D_RC4][0] = count * 5;
+ c[D_CBC_DES][0] = count;
+ c[D_EDE3_DES][0] = count / 3;
+ c[D_CBC_IDEA][0] = count;
+ c[D_CBC_SEED][0] = count;
+ c[D_CBC_RC2][0] = count;
+ c[D_CBC_RC5][0] = count;
+ c[D_CBC_BF][0] = count;
+ c[D_CBC_CAST][0] = count;
+ c[D_CBC_128_AES][0] = count;
+ c[D_CBC_192_AES][0] = count;
+ c[D_CBC_256_AES][0] = count;
+ c[D_CBC_128_CML][0] = count;
+ c[D_CBC_192_CML][0] = count;
+ c[D_CBC_256_CML][0] = count;
+ c[D_SHA256][0] = count;
+ c[D_SHA512][0] = count;
+ c[D_WHIRLPOOL][0] = count;
+ c[D_IGE_128_AES][0] = count;
+ c[D_IGE_192_AES][0] = count;
+ c[D_IGE_256_AES][0] = count;
+ c[D_GHASH][0] = count;
+
+ for (i = 1; i < SIZE_NUM; i++) {
+ c[D_MD2][i] = c[D_MD2][0] * 4 * lengths[0] / lengths[i];
+ c[D_MDC2][i] = c[D_MDC2][0] * 4 * lengths[0] / lengths[i];
+ c[D_MD4][i] = c[D_MD4][0] * 4 * lengths[0] / lengths[i];
+ c[D_MD5][i] = c[D_MD5][0] * 4 * lengths[0] / lengths[i];
+ c[D_HMAC][i] = c[D_HMAC][0] * 4 * lengths[0] / lengths[i];
+ c[D_SHA1][i] = c[D_SHA1][0] * 4 * lengths[0] / lengths[i];
+ c[D_RMD160][i] = c[D_RMD160][0] * 4 * lengths[0] / lengths[i];
+ c[D_SHA256][i] = c[D_SHA256][0] * 4 * lengths[0] / lengths[i];
+ c[D_SHA512][i] = c[D_SHA512][0] * 4 * lengths[0] / lengths[i];
+ c[D_WHIRLPOOL][i] = c[D_WHIRLPOOL][0] * 4 * lengths[0] / lengths[i];
+ }
+ for (i = 1; i < SIZE_NUM; i++) {
+ long l0, l1;
+
+ l0 = (long)lengths[i - 1];
+ l1 = (long)lengths[i];
+ c[D_RC4][i] = c[D_RC4][i - 1] * l0 / l1;
+ c[D_CBC_DES][i] = c[D_CBC_DES][i - 1] * l0 / l1;
+ c[D_EDE3_DES][i] = c[D_EDE3_DES][i - 1] * l0 / l1;
+ c[D_CBC_IDEA][i] = c[D_CBC_IDEA][i - 1] * l0 / l1;
+ c[D_CBC_SEED][i] = c[D_CBC_SEED][i - 1] * l0 / l1;
+ c[D_CBC_RC2][i] = c[D_CBC_RC2][i - 1] * l0 / l1;
+ c[D_CBC_RC5][i] = c[D_CBC_RC5][i - 1] * l0 / l1;
+ c[D_CBC_BF][i] = c[D_CBC_BF][i - 1] * l0 / l1;
+ c[D_CBC_CAST][i] = c[D_CBC_CAST][i - 1] * l0 / l1;
+ c[D_CBC_128_AES][i] = c[D_CBC_128_AES][i - 1] * l0 / l1;
+ c[D_CBC_192_AES][i] = c[D_CBC_192_AES][i - 1] * l0 / l1;
+ c[D_CBC_256_AES][i] = c[D_CBC_256_AES][i - 1] * l0 / l1;
+ c[D_CBC_128_CML][i] = c[D_CBC_128_CML][i - 1] * l0 / l1;
+ c[D_CBC_192_CML][i] = c[D_CBC_192_CML][i - 1] * l0 / l1;
+ c[D_CBC_256_CML][i] = c[D_CBC_256_CML][i - 1] * l0 / l1;
+ c[D_IGE_128_AES][i] = c[D_IGE_128_AES][i - 1] * l0 / l1;
+ c[D_IGE_192_AES][i] = c[D_IGE_192_AES][i - 1] * l0 / l1;
+ c[D_IGE_256_AES][i] = c[D_IGE_256_AES][i - 1] * l0 / l1;
+ }
+# ifndef OPENSSL_NO_RSA
+ rsa_c[R_RSA_512][0] = count / 2000;
+ rsa_c[R_RSA_512][1] = count / 400;
+ for (i = 1; i < RSA_NUM; i++) {
+ rsa_c[i][0] = rsa_c[i - 1][0] / 8;
+ rsa_c[i][1] = rsa_c[i - 1][1] / 4;
+ if ((rsa_doit[i] <= 1) && (rsa_c[i][0] == 0))
+ rsa_doit[i] = 0;
+ else {
+ if (rsa_c[i][0] == 0) {
+ rsa_c[i][0] = 1;
+ rsa_c[i][1] = 20;
+ }
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_DSA
+ dsa_c[R_DSA_512][0] = count / 1000;
+ dsa_c[R_DSA_512][1] = count / 1000 / 2;
+ for (i = 1; i < DSA_NUM; i++) {
+ dsa_c[i][0] = dsa_c[i - 1][0] / 4;
+ dsa_c[i][1] = dsa_c[i - 1][1] / 4;
+ if ((dsa_doit[i] <= 1) && (dsa_c[i][0] == 0))
+ dsa_doit[i] = 0;
+ else {
+ if (dsa_c[i] == 0) {
+ dsa_c[i][0] = 1;
+ dsa_c[i][1] = 1;
+ }
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_ECDSA
+ ecdsa_c[R_EC_P160][0] = count / 1000;
+ ecdsa_c[R_EC_P160][1] = count / 1000 / 2;
+ for (i = R_EC_P192; i <= R_EC_P521; i++) {
+ ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
+ ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
+ if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
+ ecdsa_doit[i] = 0;
+ else {
+ if (ecdsa_c[i] == 0) {
+ ecdsa_c[i][0] = 1;
+ ecdsa_c[i][1] = 1;
+ }
+ }
+ }
+ ecdsa_c[R_EC_K163][0] = count / 1000;
+ ecdsa_c[R_EC_K163][1] = count / 1000 / 2;
+ for (i = R_EC_K233; i <= R_EC_K571; i++) {
+ ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
+ ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
+ if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
+ ecdsa_doit[i] = 0;
+ else {
+ if (ecdsa_c[i] == 0) {
+ ecdsa_c[i][0] = 1;
+ ecdsa_c[i][1] = 1;
+ }
+ }
+ }
+ ecdsa_c[R_EC_B163][0] = count / 1000;
+ ecdsa_c[R_EC_B163][1] = count / 1000 / 2;
+ for (i = R_EC_B233; i <= R_EC_B571; i++) {
+ ecdsa_c[i][0] = ecdsa_c[i - 1][0] / 2;
+ ecdsa_c[i][1] = ecdsa_c[i - 1][1] / 2;
+ if ((ecdsa_doit[i] <= 1) && (ecdsa_c[i][0] == 0))
+ ecdsa_doit[i] = 0;
+ else {
+ if (ecdsa_c[i] == 0) {
+ ecdsa_c[i][0] = 1;
+ ecdsa_c[i][1] = 1;
+ }
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_ECDH
+ ecdh_c[R_EC_P160][0] = count / 1000;
+ ecdh_c[R_EC_P160][1] = count / 1000;
+ for (i = R_EC_P192; i <= R_EC_P521; i++) {
+ ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
+ ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
+ if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
+ ecdh_doit[i] = 0;
+ else {
+ if (ecdh_c[i] == 0) {
+ ecdh_c[i][0] = 1;
+ ecdh_c[i][1] = 1;
+ }
+ }
+ }
+ ecdh_c[R_EC_K163][0] = count / 1000;
+ ecdh_c[R_EC_K163][1] = count / 1000;
+ for (i = R_EC_K233; i <= R_EC_K571; i++) {
+ ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
+ ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
+ if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
+ ecdh_doit[i] = 0;
+ else {
+ if (ecdh_c[i] == 0) {
+ ecdh_c[i][0] = 1;
+ ecdh_c[i][1] = 1;
+ }
+ }
+ }
+ ecdh_c[R_EC_B163][0] = count / 1000;
+ ecdh_c[R_EC_B163][1] = count / 1000;
+ for (i = R_EC_B233; i <= R_EC_B571; i++) {
+ ecdh_c[i][0] = ecdh_c[i - 1][0] / 2;
+ ecdh_c[i][1] = ecdh_c[i - 1][1] / 2;
+ if ((ecdh_doit[i] <= 1) && (ecdh_c[i][0] == 0))
+ ecdh_doit[i] = 0;
+ else {
+ if (ecdh_c[i] == 0) {
+ ecdh_c[i][0] = 1;
+ ecdh_c[i][1] = 1;
+ }
+ }
+ }
+# endif
+
+# define COND(d) (count < (d))
+# define COUNT(d) (d)
+# else
+/* not worth fixing */
+# error "You cannot disable DES on systems without SIGALRM."
+# endif /* OPENSSL_NO_DES */
+# else
+# define COND(c) (run && count<0x7fffffff)
+# define COUNT(d) (count)
+# ifndef _WIN32
+ signal(SIGALRM, sig_done);
+# endif
+# endif /* SIGALRM */
+
+# ifndef OPENSSL_NO_MD2
+ if (doit[D_MD2]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_MD2], c[D_MD2][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_MD2][j]); count++)
+ EVP_Digest(buf, (unsigned long)lengths[j], &(md2[0]), NULL,
+ EVP_md2(), NULL);
+ d = Time_F(STOP);
+ print_result(D_MD2, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_MDC2
+ if (doit[D_MDC2]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_MDC2], c[D_MDC2][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_MDC2][j]); count++)
+ EVP_Digest(buf, (unsigned long)lengths[j], &(mdc2[0]), NULL,
+ EVP_mdc2(), NULL);
+ d = Time_F(STOP);
+ print_result(D_MDC2, j, count, d);
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_MD4
+ if (doit[D_MD4]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_MD4], c[D_MD4][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_MD4][j]); count++)
+ EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md4[0]),
+ NULL, EVP_md4(), NULL);
+ d = Time_F(STOP);
+ print_result(D_MD4, j, count, d);
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_MD5
+ if (doit[D_MD5]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_MD5], c[D_MD5][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_MD5][j]); count++)
+ EVP_Digest(&(buf[0]), (unsigned long)lengths[j], &(md5[0]),
+ NULL, EVP_get_digestbyname("md5"), NULL);
+ d = Time_F(STOP);
+ print_result(D_MD5, j, count, d);
+ }
+ }
+# endif
+
+# if !defined(OPENSSL_NO_MD5) && !defined(OPENSSL_NO_HMAC)
+ if (doit[D_HMAC]) {
+ HMAC_CTX hctx;
+
+ HMAC_CTX_init(&hctx);
+ HMAC_Init_ex(&hctx, (unsigned char *)"This is a key...",
+ 16, EVP_md5(), NULL);
+
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_HMAC], c[D_HMAC][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_HMAC][j]); count++) {
+ HMAC_Init_ex(&hctx, NULL, 0, NULL, NULL);
+ HMAC_Update(&hctx, buf, lengths[j]);
+ HMAC_Final(&hctx, &(hmac[0]), NULL);
+ }
+ d = Time_F(STOP);
+ print_result(D_HMAC, j, count, d);
+ }
+ HMAC_CTX_cleanup(&hctx);
+ }
+# endif
+# ifndef OPENSSL_NO_SHA
+ if (doit[D_SHA1]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_SHA1], c[D_SHA1][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_SHA1][j]); count++)
+ EVP_Digest(buf, (unsigned long)lengths[j], &(sha[0]), NULL,
+ EVP_sha1(), NULL);
+ d = Time_F(STOP);
+ print_result(D_SHA1, j, count, d);
+ }
+ }
+# ifndef OPENSSL_NO_SHA256
+ if (doit[D_SHA256]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_SHA256], c[D_SHA256][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_SHA256][j]); count++)
+ SHA256(buf, lengths[j], sha256);
+ d = Time_F(STOP);
+ print_result(D_SHA256, j, count, d);
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_SHA512
+ if (doit[D_SHA512]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_SHA512], c[D_SHA512][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_SHA512][j]); count++)
+ SHA512(buf, lengths[j], sha512);
+ d = Time_F(STOP);
+ print_result(D_SHA512, j, count, d);
+ }
+ }
+# endif
+# endif
+
+# ifndef OPENSSL_NO_WHIRLPOOL
+ if (doit[D_WHIRLPOOL]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_WHIRLPOOL], c[D_WHIRLPOOL][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_WHIRLPOOL][j]); count++)
+ WHIRLPOOL(buf, lengths[j], whirlpool);
+ d = Time_F(STOP);
+ print_result(D_WHIRLPOOL, j, count, d);
+ }
+ }
+# endif
+
+# ifndef OPENSSL_NO_RIPEMD
+ if (doit[D_RMD160]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_RMD160], c[D_RMD160][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_RMD160][j]); count++)
+ EVP_Digest(buf, (unsigned long)lengths[j], &(rmd160[0]), NULL,
+ EVP_ripemd160(), NULL);
+ d = Time_F(STOP);
+ print_result(D_RMD160, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_RC4
+ if (doit[D_RC4]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_RC4], c[D_RC4][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_RC4][j]); count++)
+ RC4(&rc4_ks, (unsigned int)lengths[j], buf, buf);
+ d = Time_F(STOP);
+ print_result(D_RC4, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_DES
+ if (doit[D_CBC_DES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_DES], c[D_CBC_DES][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_DES][j]); count++)
+ DES_ncbc_encrypt(buf, buf, lengths[j], &sch,
+ &DES_iv, DES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_DES, j, count, d);
+ }
+ }
+
+ if (doit[D_EDE3_DES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_EDE3_DES], c[D_EDE3_DES][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_EDE3_DES][j]); count++)
+ DES_ede3_cbc_encrypt(buf, buf, lengths[j],
+ &sch, &sch2, &sch3,
+ &DES_iv, DES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_EDE3_DES, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_AES
+ if (doit[D_CBC_128_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_128_AES], c[D_CBC_128_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_128_AES][j]); count++)
+ AES_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &aes_ks1,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_128_AES, j, count, d);
+ }
+ }
+ if (doit[D_CBC_192_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_192_AES], c[D_CBC_192_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_192_AES][j]); count++)
+ AES_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &aes_ks2,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_192_AES, j, count, d);
+ }
+ }
+ if (doit[D_CBC_256_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_256_AES], c[D_CBC_256_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_256_AES][j]); count++)
+ AES_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &aes_ks3,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_256_AES, j, count, d);
+ }
+ }
+
+ if (doit[D_IGE_128_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_IGE_128_AES], c[D_IGE_128_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_IGE_128_AES][j]); count++)
+ AES_ige_encrypt(buf, buf2,
+ (unsigned long)lengths[j], &aes_ks1,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_IGE_128_AES, j, count, d);
+ }
+ }
+ if (doit[D_IGE_192_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_IGE_192_AES], c[D_IGE_192_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_IGE_192_AES][j]); count++)
+ AES_ige_encrypt(buf, buf2,
+ (unsigned long)lengths[j], &aes_ks2,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_IGE_192_AES, j, count, d);
+ }
+ }
+ if (doit[D_IGE_256_AES]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_IGE_256_AES], c[D_IGE_256_AES][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_IGE_256_AES][j]); count++)
+ AES_ige_encrypt(buf, buf2,
+ (unsigned long)lengths[j], &aes_ks3,
+ iv, AES_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_IGE_256_AES, j, count, d);
+ }
+ }
+ if (doit[D_GHASH]) {
+ GCM128_CONTEXT *ctx =
+ CRYPTO_gcm128_new(&aes_ks1, (block128_f) AES_encrypt);
+ CRYPTO_gcm128_setiv(ctx, (unsigned char *)"0123456789ab", 12);
+
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_GHASH], c[D_GHASH][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_GHASH][j]); count++)
+ CRYPTO_gcm128_aad(ctx, buf, lengths[j]);
+ d = Time_F(STOP);
+ print_result(D_GHASH, j, count, d);
+ }
+ CRYPTO_gcm128_release(ctx);
+ }
+# endif
+# ifndef OPENSSL_NO_CAMELLIA
+ if (doit[D_CBC_128_CML]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_128_CML], c[D_CBC_128_CML][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_128_CML][j]); count++)
+ Camellia_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &camellia_ks1,
+ iv, CAMELLIA_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_128_CML, j, count, d);
+ }
+ }
+ if (doit[D_CBC_192_CML]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_192_CML], c[D_CBC_192_CML][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_192_CML][j]); count++)
+ Camellia_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &camellia_ks2,
+ iv, CAMELLIA_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_192_CML, j, count, d);
+ }
+ }
+ if (doit[D_CBC_256_CML]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_256_CML], c[D_CBC_256_CML][j],
+ lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_256_CML][j]); count++)
+ Camellia_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &camellia_ks3,
+ iv, CAMELLIA_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_256_CML, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_IDEA
+ if (doit[D_CBC_IDEA]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_IDEA], c[D_CBC_IDEA][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_IDEA][j]); count++)
+ idea_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &idea_ks,
+ iv, IDEA_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_IDEA, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_SEED
+ if (doit[D_CBC_SEED]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_SEED], c[D_CBC_SEED][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_SEED][j]); count++)
+ SEED_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &seed_ks, iv, 1);
+ d = Time_F(STOP);
+ print_result(D_CBC_SEED, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_RC2
+ if (doit[D_CBC_RC2]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_RC2], c[D_CBC_RC2][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_RC2][j]); count++)
+ RC2_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &rc2_ks,
+ iv, RC2_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_RC2, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_RC5
+ if (doit[D_CBC_RC5]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_RC5], c[D_CBC_RC5][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_RC5][j]); count++)
+ RC5_32_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &rc5_ks,
+ iv, RC5_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_RC5, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_BF
+ if (doit[D_CBC_BF]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_BF], c[D_CBC_BF][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_BF][j]); count++)
+ BF_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &bf_ks,
+ iv, BF_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_BF, j, count, d);
+ }
+ }
+# endif
+# ifndef OPENSSL_NO_CAST
+ if (doit[D_CBC_CAST]) {
+ for (j = 0; j < SIZE_NUM; j++) {
+ print_message(names[D_CBC_CAST], c[D_CBC_CAST][j], lengths[j]);
+ Time_F(START);
+ for (count = 0, run = 1; COND(c[D_CBC_CAST][j]); count++)
+ CAST_cbc_encrypt(buf, buf,
+ (unsigned long)lengths[j], &cast_ks,
+ iv, CAST_ENCRYPT);
+ d = Time_F(STOP);
+ print_result(D_CBC_CAST, j, count, d);
+ }
+ }
+# endif
+
+ if (doit[D_EVP]) {
+# ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
+ if (multiblock && evp_cipher) {
+ if (!
+ (EVP_CIPHER_flags(evp_cipher) &
+ EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK)) {
+ fprintf(stderr, "%s is not multi-block capable\n",
+ OBJ_nid2ln(evp_cipher->nid));
+ goto end;
+ }
+ multiblock_speed(evp_cipher);
+ mret = 0;
+ goto end;
+ }
+# endif
+ for (j = 0; j < SIZE_NUM; j++) {
+ if (evp_cipher) {
+ EVP_CIPHER_CTX ctx;
+ int outl;
+
+ names[D_EVP] = OBJ_nid2ln(evp_cipher->nid);
+ /*
+ * -O3 -fschedule-insns messes up an optimization here!
+ * names[D_EVP] somehow becomes NULL
+ */
+ print_message(names[D_EVP], save_count, lengths[j]);
+
+ EVP_CIPHER_CTX_init(&ctx);
+ if (decrypt)
+ EVP_DecryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
+ else
+ EVP_EncryptInit_ex(&ctx, evp_cipher, NULL, key16, iv);
+ EVP_CIPHER_CTX_set_padding(&ctx, 0);
+
+ Time_F(START);
+ if (decrypt)
+ for (count = 0, run = 1;
+ COND(save_count * 4 * lengths[0] / lengths[j]);
+ count++)
+ EVP_DecryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
+ else
+ for (count = 0, run = 1;
+ COND(save_count * 4 * lengths[0] / lengths[j]);
+ count++)
+ EVP_EncryptUpdate(&ctx, buf, &outl, buf, lengths[j]);
+ if (decrypt)
+ EVP_DecryptFinal_ex(&ctx, buf, &outl);
+ else
+ EVP_EncryptFinal_ex(&ctx, buf, &outl);
+ d = Time_F(STOP);
+ EVP_CIPHER_CTX_cleanup(&ctx);
+ }
+ if (evp_md) {
+ names[D_EVP] = OBJ_nid2ln(evp_md->type);
+ print_message(names[D_EVP], save_count, lengths[j]);
+
+ Time_F(START);
+ for (count = 0, run = 1;
+ COND(save_count * 4 * lengths[0] / lengths[j]); count++)
+ EVP_Digest(buf, lengths[j], &(md[0]), NULL, evp_md, NULL);
+
+ d = Time_F(STOP);
+ }
+ print_result(D_EVP, j, count, d);
+ }
+ }
+
+ RAND_pseudo_bytes(buf, 36);
+# ifndef OPENSSL_NO_RSA
+ for (j = 0; j < RSA_NUM; j++) {
+ int ret;
+ if (!rsa_doit[j])
+ continue;
+ ret = RSA_sign(NID_md5_sha1, buf, 36, buf2, &rsa_num, rsa_key[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err,
+ "RSA sign failure. No RSA sign will be done.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+ pkey_print_message("private", "rsa",
+ rsa_c[j][0], rsa_bits[j], RSA_SECONDS);
+ /* RSA_blinding_on(rsa_key[j],NULL); */
+ Time_F(START);
+ for (count = 0, run = 1; COND(rsa_c[j][0]); count++) {
+ ret = RSA_sign(NID_md5_sha1, buf, 36, buf2,
+ &rsa_num, rsa_key[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err, "RSA sign failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R1:%ld:%d:%.2f\n"
+ : "%ld %d bit private RSA's in %.2fs\n",
+ count, rsa_bits[j], d);
+ rsa_results[j][0] = d / (double)count;
+ rsa_count = count;
+ }
+
+# if 1
+ ret = RSA_verify(NID_md5_sha1, buf, 36, buf2, rsa_num, rsa_key[j]);
+ if (ret <= 0) {
+ BIO_printf(bio_err,
+ "RSA verify failure. No RSA verify will be done.\n");
+ ERR_print_errors(bio_err);
+ rsa_doit[j] = 0;
+ } else {
+ pkey_print_message("public", "rsa",
+ rsa_c[j][1], rsa_bits[j], RSA_SECONDS);
+ Time_F(START);
+ for (count = 0, run = 1; COND(rsa_c[j][1]); count++) {
+ ret = RSA_verify(NID_md5_sha1, buf, 36, buf2,
+ rsa_num, rsa_key[j]);
+ if (ret <= 0) {
+ BIO_printf(bio_err, "RSA verify failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R2:%ld:%d:%.2f\n"
+ : "%ld %d bit public RSA's in %.2fs\n",
+ count, rsa_bits[j], d);
+ rsa_results[j][1] = d / (double)count;
+ }
+# endif
+
+ if (rsa_count <= 1) {
+ /* if longer than 10s, don't do any more */
+ for (j++; j < RSA_NUM; j++)
+ rsa_doit[j] = 0;
+ }
+ }
+# endif
+
+ RAND_pseudo_bytes(buf, 20);
+# ifndef OPENSSL_NO_DSA
+ if (RAND_status() != 1) {
+ RAND_seed(rnd_seed, sizeof rnd_seed);
+ rnd_fake = 1;
+ }
+ for (j = 0; j < DSA_NUM; j++) {
+ unsigned int kk;
+ int ret;
+
+ if (!dsa_doit[j])
+ continue;
+
+ /* DSA_generate_key(dsa_key[j]); */
+ /* DSA_sign_setup(dsa_key[j],NULL); */
+ ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err,
+ "DSA sign failure. No DSA sign will be done.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+ pkey_print_message("sign", "dsa",
+ dsa_c[j][0], dsa_bits[j], DSA_SECONDS);
+ Time_F(START);
+ for (count = 0, run = 1; COND(dsa_c[j][0]); count++) {
+ ret = DSA_sign(EVP_PKEY_DSA, buf, 20, buf2, &kk, dsa_key[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err, "DSA sign failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R3:%ld:%d:%.2f\n"
+ : "%ld %d bit DSA signs in %.2fs\n",
+ count, dsa_bits[j], d);
+ dsa_results[j][0] = d / (double)count;
+ rsa_count = count;
+ }
+
+ ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
+ if (ret <= 0) {
+ BIO_printf(bio_err,
+ "DSA verify failure. No DSA verify will be done.\n");
+ ERR_print_errors(bio_err);
+ dsa_doit[j] = 0;
+ } else {
+ pkey_print_message("verify", "dsa",
+ dsa_c[j][1], dsa_bits[j], DSA_SECONDS);
+ Time_F(START);
+ for (count = 0, run = 1; COND(dsa_c[j][1]); count++) {
+ ret = DSA_verify(EVP_PKEY_DSA, buf, 20, buf2, kk, dsa_key[j]);
+ if (ret <= 0) {
+ BIO_printf(bio_err, "DSA verify failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R4:%ld:%d:%.2f\n"
+ : "%ld %d bit DSA verify in %.2fs\n",
+ count, dsa_bits[j], d);
+ dsa_results[j][1] = d / (double)count;
+ }
+
+ if (rsa_count <= 1) {
+ /* if longer than 10s, don't do any more */
+ for (j++; j < DSA_NUM; j++)
+ dsa_doit[j] = 0;
+ }
+ }
+ if (rnd_fake)
+ RAND_cleanup();
+# endif
+
+# ifndef OPENSSL_NO_ECDSA
+ if (RAND_status() != 1) {
+ RAND_seed(rnd_seed, sizeof rnd_seed);
+ rnd_fake = 1;
+ }
+ for (j = 0; j < EC_NUM; j++) {
+ int ret;
+
+ if (!ecdsa_doit[j])
+ continue; /* Ignore Curve */
+ ecdsa[j] = EC_KEY_new_by_curve_name(test_curves[j]);
+ if (ecdsa[j] == NULL) {
+ BIO_printf(bio_err, "ECDSA failure.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+# if 1
+ EC_KEY_precompute_mult(ecdsa[j], NULL);
+# endif
+ /* Perform ECDSA signature test */
+ EC_KEY_generate_key(ecdsa[j]);
+ ret = ECDSA_sign(0, buf, 20, ecdsasig, &ecdsasiglen, ecdsa[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err,
+ "ECDSA sign failure. No ECDSA sign will be done.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+ pkey_print_message("sign", "ecdsa",
+ ecdsa_c[j][0],
+ test_curves_bits[j], ECDSA_SECONDS);
+
+ Time_F(START);
+ for (count = 0, run = 1; COND(ecdsa_c[j][0]); count++) {
+ ret = ECDSA_sign(0, buf, 20,
+ ecdsasig, &ecdsasiglen, ecdsa[j]);
+ if (ret == 0) {
+ BIO_printf(bio_err, "ECDSA sign failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+
+ BIO_printf(bio_err,
+ mr ? "+R5:%ld:%d:%.2f\n" :
+ "%ld %d bit ECDSA signs in %.2fs \n",
+ count, test_curves_bits[j], d);
+ ecdsa_results[j][0] = d / (double)count;
+ rsa_count = count;
+ }
+
+ /* Perform ECDSA verification test */
+ ret = ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen, ecdsa[j]);
+ if (ret != 1) {
+ BIO_printf(bio_err,
+ "ECDSA verify failure. No ECDSA verify will be done.\n");
+ ERR_print_errors(bio_err);
+ ecdsa_doit[j] = 0;
+ } else {
+ pkey_print_message("verify", "ecdsa",
+ ecdsa_c[j][1],
+ test_curves_bits[j], ECDSA_SECONDS);
+ Time_F(START);
+ for (count = 0, run = 1; COND(ecdsa_c[j][1]); count++) {
+ ret =
+ ECDSA_verify(0, buf, 20, ecdsasig, ecdsasiglen,
+ ecdsa[j]);
+ if (ret != 1) {
+ BIO_printf(bio_err, "ECDSA verify failure\n");
+ ERR_print_errors(bio_err);
+ count = 1;
+ break;
+ }
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R6:%ld:%d:%.2f\n"
+ : "%ld %d bit ECDSA verify in %.2fs\n",
+ count, test_curves_bits[j], d);
+ ecdsa_results[j][1] = d / (double)count;
+ }
+
+ if (rsa_count <= 1) {
+ /* if longer than 10s, don't do any more */
+ for (j++; j < EC_NUM; j++)
+ ecdsa_doit[j] = 0;
+ }
+ }
+ }
+ if (rnd_fake)
+ RAND_cleanup();
+# endif
+
+# ifndef OPENSSL_NO_ECDH
+ if (RAND_status() != 1) {
+ RAND_seed(rnd_seed, sizeof rnd_seed);
+ rnd_fake = 1;
+ }
+ for (j = 0; j < EC_NUM; j++) {
+ if (!ecdh_doit[j])
+ continue;
+ ecdh_a[j] = EC_KEY_new_by_curve_name(test_curves[j]);
+ ecdh_b[j] = EC_KEY_new_by_curve_name(test_curves[j]);
+ if ((ecdh_a[j] == NULL) || (ecdh_b[j] == NULL)) {
+ BIO_printf(bio_err, "ECDH failure.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+ /* generate two ECDH key pairs */
+ if (!EC_KEY_generate_key(ecdh_a[j]) ||
+ !EC_KEY_generate_key(ecdh_b[j])) {
+ BIO_printf(bio_err, "ECDH key generation failure.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ } else {
+ /*
+ * If field size is not more than 24 octets, then use SHA-1
+ * hash of result; otherwise, use result (see section 4.8 of
+ * draft-ietf-tls-ecc-03.txt).
+ */
+ int field_size, outlen;
+ void *(*kdf) (const void *in, size_t inlen, void *out,
+ size_t *xoutlen);
+ field_size =
+ EC_GROUP_get_degree(EC_KEY_get0_group(ecdh_a[j]));
+ if (field_size <= 24 * 8) {
+ outlen = KDF1_SHA1_len;
+ kdf = KDF1_SHA1;
+ } else {
+ outlen = (field_size + 7) / 8;
+ kdf = NULL;
+ }
+ secret_size_a =
+ ECDH_compute_key(secret_a, outlen,
+ EC_KEY_get0_public_key(ecdh_b[j]),
+ ecdh_a[j], kdf);
+ secret_size_b =
+ ECDH_compute_key(secret_b, outlen,
+ EC_KEY_get0_public_key(ecdh_a[j]),
+ ecdh_b[j], kdf);
+ if (secret_size_a != secret_size_b)
+ ecdh_checks = 0;
+ else
+ ecdh_checks = 1;
+
+ for (secret_idx = 0; (secret_idx < secret_size_a)
+ && (ecdh_checks == 1); secret_idx++) {
+ if (secret_a[secret_idx] != secret_b[secret_idx])
+ ecdh_checks = 0;
+ }
+
+ if (ecdh_checks == 0) {
+ BIO_printf(bio_err, "ECDH computations don't match.\n");
+ ERR_print_errors(bio_err);
+ rsa_count = 1;
+ }
+
+ pkey_print_message("", "ecdh",
+ ecdh_c[j][0],
+ test_curves_bits[j], ECDH_SECONDS);
+ Time_F(START);
+ for (count = 0, run = 1; COND(ecdh_c[j][0]); count++) {
+ ECDH_compute_key(secret_a, outlen,
+ EC_KEY_get0_public_key(ecdh_b[j]),
+ ecdh_a[j], kdf);
+ }
+ d = Time_F(STOP);
+ BIO_printf(bio_err,
+ mr ? "+R7:%ld:%d:%.2f\n" :
+ "%ld %d-bit ECDH ops in %.2fs\n", count,
+ test_curves_bits[j], d);
+ ecdh_results[j][0] = d / (double)count;
+ rsa_count = count;
+ }
+ }
+
+ if (rsa_count <= 1) {
+ /* if longer than 10s, don't do any more */
+ for (j++; j < EC_NUM; j++)
+ ecdh_doit[j] = 0;
+ }
+ }
+ if (rnd_fake)
+ RAND_cleanup();
+# endif
+# ifndef NO_FORK
+ show_res:
+# endif
+ if (!mr) {
+ fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_VERSION));
+ fprintf(stdout, "%s\n", SSLeay_version(SSLEAY_BUILT_ON));
+ printf("options:");
+ printf("%s ", BN_options());
+# ifndef OPENSSL_NO_MD2
+ printf("%s ", MD2_options());
+# endif
+# ifndef OPENSSL_NO_RC4
+ printf("%s ", RC4_options());
+# endif
+# ifndef OPENSSL_NO_DES
+ printf("%s ", DES_options());
+# endif
+# ifndef OPENSSL_NO_AES
+ printf("%s ", AES_options());
+# endif
+# ifndef OPENSSL_NO_IDEA
+ printf("%s ", idea_options());
+# endif
+# ifndef OPENSSL_NO_BF
+ printf("%s ", BF_options());
+# endif
+ fprintf(stdout, "\n%s\n", SSLeay_version(SSLEAY_CFLAGS));
+ }
+
+ if (pr_header) {
+ if (mr)
+ fprintf(stdout, "+H");
+ else {
+ fprintf(stdout,
+ "The 'numbers' are in 1000s of bytes per second processed.\n");
+ fprintf(stdout, "type ");
+ }
+ for (j = 0; j < SIZE_NUM; j++)
+ fprintf(stdout, mr ? ":%d" : "%7d bytes", lengths[j]);
+ fprintf(stdout, "\n");
+ }
+
+ for (k = 0; k < ALGOR_NUM; k++) {
+ if (!doit[k])
+ continue;
+ if (mr)
+ fprintf(stdout, "+F:%d:%s", k, names[k]);
+ else
+ fprintf(stdout, "%-13s", names[k]);
+ for (j = 0; j < SIZE_NUM; j++) {
+ if (results[k][j] > 10000 && !mr)
+ fprintf(stdout, " %11.2fk", results[k][j] / 1e3);
+ else
+ fprintf(stdout, mr ? ":%.2f" : " %11.2f ", results[k][j]);
+ }
+ fprintf(stdout, "\n");
+ }
+# ifndef OPENSSL_NO_RSA
+ j = 1;
+ for (k = 0; k < RSA_NUM; k++) {
+ if (!rsa_doit[k])
+ continue;
+ if (j && !mr) {
+ printf("%18ssign verify sign/s verify/s\n", " ");
+ j = 0;
+ }
+ if (mr)
+ fprintf(stdout, "+F2:%u:%u:%f:%f\n",
+ k, rsa_bits[k], rsa_results[k][0], rsa_results[k][1]);
+ else
+ fprintf(stdout, "rsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
+ rsa_bits[k], rsa_results[k][0], rsa_results[k][1],
+ 1.0 / rsa_results[k][0], 1.0 / rsa_results[k][1]);
+ }
+# endif
+# ifndef OPENSSL_NO_DSA
+ j = 1;
+ for (k = 0; k < DSA_NUM; k++) {
+ if (!dsa_doit[k])
+ continue;
+ if (j && !mr) {
+ printf("%18ssign verify sign/s verify/s\n", " ");
+ j = 0;
+ }
+ if (mr)
+ fprintf(stdout, "+F3:%u:%u:%f:%f\n",
+ k, dsa_bits[k], dsa_results[k][0], dsa_results[k][1]);
+ else
+ fprintf(stdout, "dsa %4u bits %8.6fs %8.6fs %8.1f %8.1f\n",
+ dsa_bits[k], dsa_results[k][0], dsa_results[k][1],
+ 1.0 / dsa_results[k][0], 1.0 / dsa_results[k][1]);
+ }
+# endif
+# ifndef OPENSSL_NO_ECDSA
+ j = 1;
+ for (k = 0; k < EC_NUM; k++) {
+ if (!ecdsa_doit[k])
+ continue;
+ if (j && !mr) {
+ printf("%30ssign verify sign/s verify/s\n", " ");
+ j = 0;
+ }
+
+ if (mr)
+ fprintf(stdout, "+F4:%u:%u:%f:%f\n",
+ k, test_curves_bits[k],
+ ecdsa_results[k][0], ecdsa_results[k][1]);
+ else
+ fprintf(stdout,
+ "%4u bit ecdsa (%s) %8.4fs %8.4fs %8.1f %8.1f\n",
+ test_curves_bits[k],
+ test_curves_names[k],
+ ecdsa_results[k][0], ecdsa_results[k][1],
+ 1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
+ }
+# endif
+
+# ifndef OPENSSL_NO_ECDH
+ j = 1;
+ for (k = 0; k < EC_NUM; k++) {
+ if (!ecdh_doit[k])
+ continue;
+ if (j && !mr) {
+ printf("%30sop op/s\n", " ");
+ j = 0;
+ }
+ if (mr)
+ fprintf(stdout, "+F5:%u:%u:%f:%f\n",
+ k, test_curves_bits[k],
+ ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
+
+ else
+ fprintf(stdout, "%4u bit ecdh (%s) %8.4fs %8.1f\n",
+ test_curves_bits[k],
+ test_curves_names[k],
+ ecdh_results[k][0], 1.0 / ecdh_results[k][0]);
+ }
+# endif
+
+ mret = 0;
+
+ end:
+ ERR_print_errors(bio_err);
+ if (buf != NULL)
+ OPENSSL_free(buf);
+ if (buf2 != NULL)
+ OPENSSL_free(buf2);
+# ifndef OPENSSL_NO_RSA
+ for (i = 0; i < RSA_NUM; i++)
+ if (rsa_key[i] != NULL)
+ RSA_free(rsa_key[i]);
+# endif
+# ifndef OPENSSL_NO_DSA
+ for (i = 0; i < DSA_NUM; i++)
+ if (dsa_key[i] != NULL)
+ DSA_free(dsa_key[i]);
+# endif
+
+# ifndef OPENSSL_NO_ECDSA
+ for (i = 0; i < EC_NUM; i++)
+ if (ecdsa[i] != NULL)
+ EC_KEY_free(ecdsa[i]);
+# endif
+# ifndef OPENSSL_NO_ECDH
+ for (i = 0; i < EC_NUM; i++) {
+ if (ecdh_a[i] != NULL)
+ EC_KEY_free(ecdh_a[i]);
+ if (ecdh_b[i] != NULL)
+ EC_KEY_free(ecdh_b[i]);
+ }
+# endif
+
+ apps_shutdown();
+ OPENSSL_EXIT(mret);
+}