key = OPENSSL_malloc(sizeof(*key));
if (!key)
return 0;
- key->name = BUF_strdup(value);
+ key->name = OPENSSL_strdup(value);
key->key = pk;
key->next = *lst;
*lst = key;
fprintf(stderr, "Line %d: multiple result lines\n", t->line);
return 0;
}
- t->expected_err = BUF_strdup(value);
+ t->expected_err = OPENSSL_strdup(value);
if (!t->expected_err)
return 0;
} else {
}
/* The result printing code expects a non-NULL buffer. */
- t->out_expected = BUF_memdup(expected, expected_len ? expected_len : 1);
+ t->out_expected = OPENSSL_memdup(expected, expected_len ? expected_len : 1);
t->out_expected_len = expected_len;
- t->out_received = BUF_memdup(received, received_len ? received_len : 1);
+ t->out_received = OPENSSL_memdup(received, received_len ? received_len : 1);
t->out_received_len = received_len;
if (t->out_expected == NULL || t->out_received == NULL) {
fprintf(stderr, "Memory allocation error!\n");
CRYPTO_cleanup_all_ex_data();
ERR_remove_thread_state(NULL);
ERR_free_strings();
+#ifdef CRYPTO_MDEBUG
CRYPTO_mem_leaks_fp(stderr);
+#endif
if (t.errors)
return 1;
return 0;
static int digest_test_init(struct evp_test *t, const char *alg)
{
const EVP_MD *digest;
- struct digest_data *mdat = t->data;
+ struct digest_data *mdat;
digest = EVP_get_digestbyname(alg);
if (!digest) {
/* If alg has an OID assume disabled algorithm */
EVP_MD_CTX *mctx;
unsigned char md[EVP_MAX_MD_SIZE];
unsigned int md_len;
- mctx = EVP_MD_CTX_create();
+ mctx = EVP_MD_CTX_new();
if (!mctx)
goto err;
err = "DIGESTINIT_ERROR";
goto err;
err = NULL;
err:
- if (mctx)
- EVP_MD_CTX_destroy(mctx);
+ EVP_MD_CTX_free(mctx);
t->err = err;
return 1;
}
|| EVP_CIPHER_mode(cipher) == EVP_CIPH_OCB_MODE
|| EVP_CIPHER_mode(cipher) == EVP_CIPH_CCM_MODE)
cdat->aead = EVP_CIPHER_mode(cipher);
+ else if (EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
+ cdat->aead = -1;
else
cdat->aead = 0;
if (strcmp(keyword, "Key") == 0)
return test_bin(value, &mdata->key, &mdata->key_len);
if (strcmp(keyword, "Algorithm") == 0) {
- mdata->alg = BUF_strdup(value);
+ mdata->alg = OPENSSL_strdup(value);
if (!mdata->alg)
return 0;
return 1;
if (!md)
goto err;
}
- mctx = EVP_MD_CTX_create();
+ mctx = EVP_MD_CTX_new();
if (!mctx)
goto err;
err = "DIGESTSIGNINIT_ERROR";
goto err;
err = NULL;
err:
- if (mctx)
- EVP_MD_CTX_destroy(mctx);
+ EVP_MD_CTX_free(mctx);
OPENSSL_free(mac);
EVP_PKEY_CTX_free(genctx);
EVP_PKEY_free(key);
edata->encoding = BASE64_VALID_ENCODING;
} else if (strcmp(encoding, "invalid") == 0) {
edata->encoding = BASE64_INVALID_ENCODING;
- t->expected_err = BUF_strdup("DECODE_ERROR");
+ t->expected_err = OPENSSL_strdup("DECODE_ERROR");
if (t->expected_err == NULL)
return 0;
} else {
unsigned char *encode_out = NULL, *decode_out = NULL;
int output_len, chunk_len;
const char *err = "INTERNAL_ERROR";
- EVP_ENCODE_CTX decode_ctx;
+ EVP_ENCODE_CTX *decode_ctx = EVP_ENCODE_CTX_new();
+
+ if (decode_ctx == NULL)
+ goto err;
if (edata->encoding == BASE64_CANONICAL_ENCODING) {
- EVP_ENCODE_CTX encode_ctx;
+ EVP_ENCODE_CTX *encode_ctx = EVP_ENCODE_CTX_new();
+ if (encode_ctx == NULL)
+ goto err;
encode_out = OPENSSL_malloc(EVP_ENCODE_LENGTH(edata->input_len));
if (encode_out == NULL)
goto err;
- EVP_EncodeInit(&encode_ctx);
- EVP_EncodeUpdate(&encode_ctx, encode_out, &chunk_len,
+ EVP_EncodeInit(encode_ctx);
+ EVP_EncodeUpdate(encode_ctx, encode_out, &chunk_len,
edata->input, edata->input_len);
output_len = chunk_len;
- EVP_EncodeFinal(&encode_ctx, encode_out + chunk_len, &chunk_len);
+ EVP_EncodeFinal(encode_ctx, encode_out + chunk_len, &chunk_len);
output_len += chunk_len;
+ EVP_ENCODE_CTX_free(encode_ctx);
+
if (check_var_length_output(t, edata->output, edata->output_len,
encode_out, output_len)) {
err = "BAD_ENCODING";
if (decode_out == NULL)
goto err;
- EVP_DecodeInit(&decode_ctx);
- if (EVP_DecodeUpdate(&decode_ctx, decode_out, &chunk_len, edata->output,
+ EVP_DecodeInit(decode_ctx);
+ if (EVP_DecodeUpdate(decode_ctx, decode_out, &chunk_len, edata->output,
edata->output_len) < 0) {
err = "DECODE_ERROR";
goto err;
}
output_len = chunk_len;
- if (EVP_DecodeFinal(&decode_ctx, decode_out + chunk_len, &chunk_len) != 1) {
+ if (EVP_DecodeFinal(decode_ctx, decode_out + chunk_len, &chunk_len) != 1) {
err = "DECODE_ERROR";
goto err;
}
t->err = err;
OPENSSL_free(encode_out);
OPENSSL_free(decode_out);
+ EVP_ENCODE_CTX_free(decode_ctx);
return 1;
}