};
static double results[ALGOR_NUM][SIZE_NUM];
-static int lengths[SIZE_NUM] = {
+
+static const int lengths[SIZE_NUM] = {
16, 64, 256, 1024, 8 * 1024, 16 * 1024
};
}
#endif
-#ifndef OPENSSL_NO_EC
-static const int KDF1_SHA1_len = 20;
-static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
- size_t *outlen)
-{
- if (*outlen < SHA_DIGEST_LENGTH)
- return NULL;
- *outlen = SHA_DIGEST_LENGTH;
- return SHA1(in, inlen, out);
-}
-#endif /* OPENSSL_NO_EC */
-
static void multiblock_speed(const EVP_CIPHER *evp_cipher);
static int found(const char *name, const OPT_PAIR * pairs, int *result)
unsigned char *buf = tempargs->buf;
unsigned char md2[MD2_DIGEST_LENGTH];
int count;
+
for (count = 0; COND(c[D_MD2][testnum]); count++) {
- if (!EVP_Digest(buf, (unsigned long)lengths[testnum], &(md2[0]), NULL,
- EVP_md2(), NULL))
+ if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),
+ NULL))
return -1;
}
return count;
unsigned char *buf = tempargs->buf;
unsigned char mdc2[MDC2_DIGEST_LENGTH];
int count;
+
for (count = 0; COND(c[D_MDC2][testnum]); count++) {
- if (!EVP_Digest(buf, (unsigned long)lengths[testnum], &(mdc2[0]), NULL,
- EVP_mdc2(), NULL))
+ if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),
+ NULL))
return -1;
}
return count;
unsigned char *buf = tempargs->buf;
unsigned char md4[MD4_DIGEST_LENGTH];
int count;
+
for (count = 0; COND(c[D_MD4][testnum]); count++) {
- if (!EVP_Digest(&(buf[0]), (unsigned long)lengths[testnum], &(md4[0]),
- NULL, EVP_md4(), NULL))
+ if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),
+ NULL))
return -1;
}
return count;
HMAC_CTX *hctx = tempargs->hctx;
unsigned char hmac[MD5_DIGEST_LENGTH];
int count;
+
for (count = 0; COND(c[D_HMAC][testnum]); count++) {
HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);
HMAC_Update(hctx, buf, lengths[testnum]);
- HMAC_Final(hctx, &(hmac[0]), NULL);
+ HMAC_Final(hctx, hmac, NULL);
}
return count;
}
unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];
int count;
for (count = 0; COND(c[D_RMD160][testnum]); count++) {
- if (!EVP_Digest(buf, (unsigned long)lengths[testnum], &(rmd160[0]),
+ if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),
NULL, EVP_ripemd160(), NULL))
return -1;
}
unsigned char *buf = tempargs->buf;
int count;
for (count = 0; COND(c[D_RC4][testnum]); count++)
- RC4(&rc4_ks, (unsigned int)lengths[testnum], buf, buf);
+ RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);
return count;
}
#endif
int count;
for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)
AES_cbc_encrypt(buf, buf,
- (unsigned long)lengths[testnum], &aes_ks1,
+ (size_t)lengths[testnum], &aes_ks1,
iv, AES_ENCRYPT);
return count;
}
int count;
for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)
AES_cbc_encrypt(buf, buf,
- (unsigned long)lengths[testnum], &aes_ks2,
+ (size_t)lengths[testnum], &aes_ks2,
iv, AES_ENCRYPT);
return count;
}
int count;
for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)
AES_cbc_encrypt(buf, buf,
- (unsigned long)lengths[testnum], &aes_ks3,
+ (size_t)lengths[testnum], &aes_ks3,
iv, AES_ENCRYPT);
return count;
}
int count;
for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)
AES_ige_encrypt(buf, buf2,
- (unsigned long)lengths[testnum], &aes_ks1,
+ (size_t)lengths[testnum], &aes_ks1,
iv, AES_ENCRYPT);
return count;
}
int count;
for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)
AES_ige_encrypt(buf, buf2,
- (unsigned long)lengths[testnum], &aes_ks2,
+ (size_t)lengths[testnum], &aes_ks2,
iv, AES_ENCRYPT);
return count;
}
int count;
for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)
AES_ige_encrypt(buf, buf2,
- (unsigned long)lengths[testnum], &aes_ks3,
+ (size_t)lengths[testnum], &aes_ks3,
iv, AES_ENCRYPT);
return count;
}
}
return count;
}
+
+static const int KDF1_SHA1_len = 20;
+static void *KDF1_SHA1(const void *in, size_t inlen, void *out,
+ size_t *outlen)
+{
+ if (*outlen < SHA_DIGEST_LENGTH)
+ return NULL;
+ *outlen = SHA_DIGEST_LENGTH;
+ return SHA1(in, inlen, out);
+}
+
#endif /* ndef OPENSSL_NO_EC */
const EVP_CIPHER *evp_cipher = NULL;
double d = 0.0;
OPTION_CHOICE o;
- int multiblock = 0, doit[ALGOR_NUM], pr_header = 0;
-#ifndef OPENSSL_NO_DSA
- int dsa_doit[DSA_NUM];
-#endif
- int rsa_doit[RSA_NUM];
+ int multiblock = 0, pr_header = 0;
+ int doit[ALGOR_NUM] = { 0 };
int ret = 1, i, k, misalign = 0;
long count = 0;
#ifndef NO_FORK
int multi = 0;
#endif
int async_jobs = 0;
- /* What follows are the buffers and key material. */
-#if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA)
+#if !defined(OPENSSL_NO_RSA) || !defined(OPENSSL_NO_DSA) \
+ || !defined(OPENSSL_NO_EC)
long rsa_count = 1;
#endif
+
+ /* What follows are the buffers and key material. */
#ifndef OPENSSL_NO_RC5
RC5_32_KEY rc5_ks;
#endif
};
#endif
#ifndef OPENSSL_NO_RSA
- static unsigned int rsa_bits[RSA_NUM] = {
+ static const unsigned int rsa_bits[RSA_NUM] = {
512, 1024, 2048, 3072, 4096, 7680, 15360
};
- static unsigned char *rsa_data[RSA_NUM] = {
+ static const unsigned char *rsa_data[RSA_NUM] = {
test512, test1024, test2048, test3072, test4096, test7680, test15360
};
- static int rsa_data_length[RSA_NUM] = {
+ static const int rsa_data_length[RSA_NUM] = {
sizeof(test512), sizeof(test1024),
sizeof(test2048), sizeof(test3072),
sizeof(test4096), sizeof(test7680),
sizeof(test15360)
};
+ int rsa_doit[RSA_NUM] = { 0 };
#endif
#ifndef OPENSSL_NO_DSA
- static unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
+ static const unsigned int dsa_bits[DSA_NUM] = { 512, 1024, 2048 };
+ int dsa_doit[DSA_NUM] = { 0 };
#endif
#ifndef OPENSSL_NO_EC
/*
* add tests over more curves, simply add the curve NID and curve name to
* the following arrays and increase the EC_NUM value accordingly.
*/
- static unsigned int test_curves[EC_NUM] = {
+ static const unsigned int test_curves[EC_NUM] = {
/* Prime Curves */
NID_secp160r1, NID_X9_62_prime192v1, NID_secp224r1,
NID_X9_62_prime256v1, NID_secp384r1, NID_secp521r1,
/* Other */
"X25519"
};
- static int test_curves_bits[EC_NUM] = {
+ static const int test_curves_bits[EC_NUM] = {
160, 192, 224,
256, 384, 521,
163, 233, 283,
233, 283, 409,
571, 253 /* X25519 */
};
-#endif
-#ifndef OPENSSL_NO_EC
- int ecdsa_doit[EC_NUM];
- int secret_size_a, secret_size_b;
- int ecdh_checks = 1;
- int secret_idx = 0;
- int ecdh_doit[EC_NUM];
-#endif
-
- memset(results, 0, sizeof(results));
-
-#ifndef OPENSSL_NO_DES
- memset(DES_iv, 0, sizeof(DES_iv));
-#endif
- memset(iv, 0, sizeof(iv));
-
- for (i = 0; i < ALGOR_NUM; i++)
- doit[i] = 0;
- for (i = 0; i < RSA_NUM; i++)
- rsa_doit[i] = 0;
-#ifndef OPENSSL_NO_DSA
- for (i = 0; i < DSA_NUM; i++)
- dsa_doit[i] = 0;
-#endif
-#ifndef OPENSSL_NO_EC
- for (i = 0; i < EC_NUM; i++)
- ecdsa_doit[i] = 0;
- for (i = 0; i < EC_NUM; i++)
- ecdh_doit[i] = 0;
-#endif
- misalign = 0;
+ int ecdsa_doit[EC_NUM] = { 0 };
+ int ecdh_doit[EC_NUM] = { 0 };
+#endif /* ndef OPENSSL_NO_EC */
prog = opt_init(argc, argv, speed_options);
while ((o = opt_next()) != OPT_EOF) {
#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");
#ifndef OPENSSL_NO_MD5
if (doit[D_HMAC]) {
+ char hmac_key[] = "This is a key...";
+ int len = strlen(hmac_key);
+
for (i = 0; i < loopargs_len; i++) {
loopargs[i].hctx = HMAC_CTX_new();
if (loopargs[i].hctx == NULL) {
exit(1);
}
- HMAC_Init_ex(loopargs[i].hctx, (unsigned char *)"This is a key...",
- 16, EVP_md5(), NULL);
+ HMAC_Init_ex(loopargs[i].hctx, hmac_key, len, EVP_md5(), NULL);
}
for (testnum = 0; testnum < SIZE_NUM; testnum++) {
print_message(names[D_HMAC], c[D_HMAC][testnum], lengths[testnum]);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_128_CML][testnum]); count++)
Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &camellia_ks1,
+ (size_t)lengths[testnum], &camellia_ks1,
iv, CAMELLIA_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_128_CML, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_192_CML][testnum]); count++)
Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &camellia_ks2,
+ (size_t)lengths[testnum], &camellia_ks2,
iv, CAMELLIA_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_192_CML, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_256_CML][testnum]); count++)
Camellia_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &camellia_ks3,
+ (size_t)lengths[testnum], &camellia_ks3,
iv, CAMELLIA_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_256_CML, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_IDEA][testnum]); count++)
IDEA_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &idea_ks,
+ (size_t)lengths[testnum], &idea_ks,
iv, IDEA_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_IDEA, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_SEED][testnum]); count++)
SEED_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &seed_ks, iv, 1);
+ (size_t)lengths[testnum], &seed_ks, iv, 1);
d = Time_F(STOP);
print_result(D_CBC_SEED, testnum, count, d);
}
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_RC2][testnum]); count++)
RC2_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &rc2_ks,
+ (size_t)lengths[testnum], &rc2_ks,
iv, RC2_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_RC2, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_RC5][testnum]); count++)
RC5_32_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &rc5_ks,
+ (size_t)lengths[testnum], &rc5_ks,
iv, RC5_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_RC5, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_BF][testnum]); count++)
BF_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &bf_ks,
+ (size_t)lengths[testnum], &bf_ks,
iv, BF_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_BF, testnum, count, d);
Time_F(START);
for (count = 0, run = 1; COND(c[D_CBC_CAST][testnum]); count++)
CAST_cbc_encrypt(loopargs[0].buf, loopargs[0].buf,
- (unsigned long)lengths[testnum], &cast_ks,
+ (size_t)lengths[testnum], &cast_ks,
iv, CAST_ENCRYPT);
d = Time_F(STOP);
print_result(D_CBC_CAST, testnum, count, d);
}
}
}
-#endif
-#ifndef OPENSSL_NO_EC
if (RAND_status() != 1) {
RAND_seed(rnd_seed, sizeof rnd_seed);
}
for (testnum = 0; testnum < EC_NUM; testnum++) {
+ int ecdh_checks = 1;
+
if (!ecdh_doit[testnum])
continue;
for (i = 0; i < loopargs_len; i++) {
ecdh_checks = 0;
rsa_count = 1;
} else {
+ int secret_size_a, secret_size_b;
/*
* If field size is not more than 24 octets, then use SHA-1
* hash of result; otherwise, use result (see section 4.8 of
else
ecdh_checks = 1;
- for (secret_idx = 0; (secret_idx < secret_size_a)
- && (ecdh_checks == 1); secret_idx++) {
- if (loopargs[i].secret_a[secret_idx] != loopargs[i].secret_b[secret_idx])
+ for (k = 0; k < secret_size_a && ecdh_checks == 1; k++) {
+ if (loopargs[i].secret_a[k] != loopargs[i].secret_b[k])
ecdh_checks = 0;
}
ecdsa_results[k][0], ecdsa_results[k][1],
1.0 / ecdsa_results[k][0], 1.0 / ecdsa_results[k][1]);
}
-#endif
-#ifndef OPENSSL_NO_EC
testnum = 1;
for (k = 0; k < EC_NUM; k++) {
if (!ecdh_doit[k])
OPENSSL_free(loopargs[i].buf_malloc);
OPENSSL_free(loopargs[i].buf2_malloc);
OPENSSL_free(loopargs[i].siglen);
- }
+
#ifndef OPENSSL_NO_RSA
- for (i = 0; i < loopargs_len; i++) {
for (k = 0; k < RSA_NUM; k++)
RSA_free(loopargs[i].rsa_key[k]);
- }
#endif
#ifndef OPENSSL_NO_DSA
- for (i = 0; i < loopargs_len; i++) {
for (k = 0; k < DSA_NUM; k++)
DSA_free(loopargs[i].dsa_key[k]);
- }
#endif
-
#ifndef OPENSSL_NO_EC
- for (i = 0; i < loopargs_len; i++) {
for (k = 0; k < EC_NUM; k++) {
EC_KEY_free(loopargs[i].ecdsa[k]);
EC_KEY_free(loopargs[i].ecdh_a[k]);
}
OPENSSL_free(loopargs[i].secret_a);
OPENSSL_free(loopargs[i].secret_b);
- }
#endif
+ }
+
if (async_jobs > 0) {
for (i = 0; i < loopargs_len; i++)
ASYNC_WAIT_CTX_free(loopargs[i].wait_ctx);
projects / openssl.git / blobdiff