static int digest_test_run(EVP_TEST *t)
{
DIGEST_DATA *expected = t->data;
+ EVP_TEST_BUFFER *inbuf;
EVP_MD_CTX *mctx;
unsigned char *got = NULL;
unsigned int got_len;
+ size_t size = 0;
+ int xof = 0;
OSSL_PARAM params[2];
t->err = "TEST_FAILURE";
goto err;
}
- if (EVP_MD_flags(expected->digest) & EVP_MD_FLAG_XOF) {
+ xof = (EVP_MD_get_flags(expected->digest) & EVP_MD_FLAG_XOF) != 0;
+ if (xof) {
EVP_MD_CTX *mctx_cpy;
char dont[] = "touch";
t->err = NULL;
+ /* Test the EVP_Q_digest interface as well */
+ if (sk_EVP_TEST_BUFFER_num(expected->input) == 1
+ && !xof
+ /* This should never fail but we need the returned pointer now */
+ && !TEST_ptr(inbuf = sk_EVP_TEST_BUFFER_value(expected->input, 0))
+ && !inbuf->count_set) {
+ OPENSSL_cleanse(got, got_len);
+ if (!TEST_true(EVP_Q_digest(libctx,
+ EVP_MD_get0_name(expected->fetched_digest),
+ NULL, inbuf->buf, inbuf->buflen,
+ got, &size))
+ || !TEST_mem_eq(got, size,
+ expected->output, expected->output_len)) {
+ t->err = "EVP_Q_digest failed";
+ goto err;
+ }
+ }
+
err:
OPENSSL_free(got);
EVP_MD_CTX_free(mctx);
size_t key_len;
size_t key_bits; /* Used by RC2 */
unsigned char *iv;
+ unsigned char *next_iv; /* Expected IV state after operation */
unsigned int rounds;
size_t iv_len;
unsigned char *plaintext;
size_t plaintext_len;
unsigned char *ciphertext;
size_t ciphertext_len;
- /* GCM, CCM, OCB and SIV only */
+ /* AEAD ciphers only */
unsigned char *aad[AAD_NUM];
size_t aad_len[AAD_NUM];
+ int tls_aad;
+ int tls_version;
unsigned char *tag;
const char *cts_mode;
size_t tag_len;
int tag_late;
+ unsigned char *mac_key;
+ size_t mac_key_len;
} CIPHER_DATA;
static int cipher_test_init(EVP_TEST *t, const char *alg)
return 1;
}
+ ERR_set_mark();
if ((cipher = fetched_cipher = EVP_CIPHER_fetch(libctx, alg, NULL)) == NULL
- && (cipher = EVP_get_cipherbyname(alg)) == NULL)
+ && (cipher = EVP_get_cipherbyname(alg)) == NULL) {
+ /* a stitched cipher might not be available */
+ if (strstr(alg, "HMAC") != NULL) {
+ ERR_pop_to_mark();
+ t->skip = 1;
+ TEST_info("skipping, '%s' is not available", alg);
+ return 1;
+ }
+ ERR_clear_last_mark();
return 0;
+ }
+ ERR_clear_last_mark();
cdat = OPENSSL_zalloc(sizeof(*cdat));
cdat->cipher = cipher;
cdat->fetched_cipher = fetched_cipher;
cdat->enc = -1;
- m = EVP_CIPHER_mode(cipher);
- if (m == EVP_CIPH_GCM_MODE
- || m == EVP_CIPH_OCB_MODE
- || m == EVP_CIPH_SIV_MODE
- || m == EVP_CIPH_CCM_MODE)
- cdat->aead = m;
- else if (EVP_CIPHER_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
- cdat->aead = -1;
+ m = EVP_CIPHER_get_mode(cipher);
+ if (EVP_CIPHER_get_flags(cipher) & EVP_CIPH_FLAG_AEAD_CIPHER)
+ cdat->aead = m != 0 ? m : -1;
else
cdat->aead = 0;
OPENSSL_free(cdat->key);
OPENSSL_free(cdat->iv);
+ OPENSSL_free(cdat->next_iv);
OPENSSL_free(cdat->ciphertext);
OPENSSL_free(cdat->plaintext);
for (i = 0; i < AAD_NUM; i++)
OPENSSL_free(cdat->aad[i]);
OPENSSL_free(cdat->tag);
+ OPENSSL_free(cdat->mac_key);
EVP_CIPHER_free(cdat->fetched_cipher);
}
}
if (strcmp(keyword, "IV") == 0)
return parse_bin(value, &cdat->iv, &cdat->iv_len);
+ if (strcmp(keyword, "NextIV") == 0)
+ return parse_bin(value, &cdat->next_iv, &cdat->iv_len);
if (strcmp(keyword, "Plaintext") == 0)
return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
if (strcmp(keyword, "Ciphertext") == 0)
return 1;
}
if (cdat->aead) {
- if (strcmp(keyword, "AAD") == 0) {
+ int tls_aad = 0;
+
+ if (strcmp(keyword, "TLSAAD") == 0)
+ cdat->tls_aad = tls_aad = 1;
+ if (strcmp(keyword, "AAD") == 0 || tls_aad) {
for (i = 0; i < AAD_NUM; i++) {
if (cdat->aad[i] == NULL)
return parse_bin(value, &cdat->aad[i], &cdat->aad_len[i]);
return -1;
return 1;
}
+ if (strcmp(keyword, "MACKey") == 0)
+ return parse_bin(value, &cdat->mac_key, &cdat->mac_key_len);
+ if (strcmp(keyword, "TLSVersion") == 0) {
+ char *endptr;
+
+ cdat->tls_version = (int)strtol(value, &endptr, 0);
+ return value[0] != '\0' && endptr[0] == '\0';
+ }
}
if (strcmp(keyword, "Operation") == 0) {
t->err = "INVALID_IV_LENGTH";
goto err;
}
- } else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_iv_length(ctx_base)) {
+ } else if (expected->iv_len != (size_t)EVP_CIPHER_CTX_get_iv_length(ctx_base)) {
t->err = "INVALID_IV_LENGTH";
goto err;
}
}
- if (expected->aead) {
+ if (expected->aead && !expected->tls_aad) {
unsigned char *tag;
/*
* If encrypting or OCB just set tag length initially, otherwise
/* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
unsigned char iv[128];
if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx_base, iv, sizeof(iv)))
- || ((EVP_CIPHER_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
- && !TEST_mem_eq(expected->iv, expected->iv_len, iv,
- expected->iv_len))) {
+ || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
+ && !TEST_mem_eq(expected->iv, expected->iv_len, iv,
+ expected->iv_len))) {
t->err = "INVALID_IV";
goto err;
}
}
/* Test that the cipher dup functions correctly if it is supported */
+ ERR_set_mark();
if (EVP_CIPHER_CTX_copy(ctx, ctx_base)) {
EVP_CIPHER_CTX_free(ctx_base);
ctx_base = NULL;
EVP_CIPHER_CTX_free(ctx);
ctx = ctx_base;
}
+ ERR_pop_to_mark();
+
+ if (expected->mac_key != NULL
+ && !EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_MAC_KEY,
+ (int)expected->mac_key_len,
+ (void *)expected->mac_key)) {
+ t->err = "SET_MAC_KEY_ERROR";
+ goto err;
+ }
+
+ if (expected->tls_version) {
+ OSSL_PARAM params[2];
+
+ params[0] = OSSL_PARAM_construct_int(OSSL_CIPHER_PARAM_TLS_VERSION,
+ &expected->tls_version);
+ params[1] = OSSL_PARAM_construct_end();
+ if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
+ t->err = "SET_TLS_VERSION_ERROR";
+ goto err;
+ }
+ }
if (expected->aead == EVP_CIPH_CCM_MODE) {
if (!EVP_CipherUpdate(ctx, NULL, &tmplen, NULL, out_len)) {
goto err;
}
}
- if (expected->aad[0] != NULL) {
+ if (expected->aad[0] != NULL && !expected->tls_aad) {
t->err = "AAD_SET_ERROR";
if (!frag) {
for (i = 0; expected->aad[i] != NULL; i++) {
}
}
- if (!enc && (expected->aead == EVP_CIPH_OCB_MODE || expected->tag_late)) {
+ if (expected->tls_aad) {
+ OSSL_PARAM params[2];
+ char *tls_aad;
+
+ /* duplicate the aad as the implementation might modify it */
+ if ((tls_aad = OPENSSL_memdup(expected->aad[0],
+ expected->aad_len[0])) == NULL)
+ goto err;
+ params[0] = OSSL_PARAM_construct_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD,
+ tls_aad,
+ expected->aad_len[0]);
+ params[1] = OSSL_PARAM_construct_end();
+ if (!EVP_CIPHER_CTX_set_params(ctx, params)) {
+ OPENSSL_free(tls_aad);
+ t->err = "TLS1_AAD_ERROR";
+ goto err;
+ }
+ OPENSSL_free(tls_aad);
+ } else if (!enc && (expected->aead == EVP_CIPH_OCB_MODE
+ || expected->tag_late)) {
if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
expected->tag_len, expected->tag)) {
t->err = "TAG_SET_ERROR";
in += in_len - 1;
in_len = 1;
}
- if (in_len > 0 ) {
+ if (in_len > 0) {
if (!EVP_CipherUpdate(ctx, tmp + out_misalign + tmplen, &chunklen,
in, 1))
goto err;
t->err = "CIPHERFINAL_ERROR";
goto err;
}
+ if (!enc && expected->tls_aad) {
+ if (expected->tls_version >= TLS1_1_VERSION
+ && (EVP_CIPHER_is_a(expected->cipher, "AES-128-CBC-HMAC-SHA1")
+ || EVP_CIPHER_is_a(expected->cipher, "AES-256-CBC-HMAC-SHA1"))) {
+ tmplen -= expected->iv_len;
+ expected_out += expected->iv_len;
+ out_misalign += expected->iv_len;
+ }
+ if ((int)out_len > tmplen + tmpflen)
+ out_len = tmplen + tmpflen;
+ }
if (!memory_err_compare(t, "VALUE_MISMATCH", expected_out, out_len,
tmp + out_misalign, tmplen + tmpflen))
goto err;
- if (enc && expected->aead) {
+ if (enc && expected->aead && !expected->tls_aad) {
unsigned char rtag[16];
if (!TEST_size_t_le(expected->tag_len, sizeof(rtag))) {
rtag, expected->tag_len))
goto err;
}
+ /* Check the updated IV */
+ if (expected->next_iv != NULL) {
+ /* Some (e.g., GCM) tests use IVs longer than EVP_MAX_IV_LENGTH. */
+ unsigned char iv[128];
+ if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx, iv, sizeof(iv)))
+ || ((EVP_CIPHER_get_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
+ && !TEST_mem_eq(expected->next_iv, expected->iv_len, iv,
+ expected->iv_len))) {
+ t->err = "INVALID_NEXT_IV";
+ goto err;
+ }
+ }
+
t->err = NULL;
ok = 1;
err:
t->err = "NO_KEY";
return 0;
}
- if (!cdat->iv && EVP_CIPHER_iv_length(cdat->cipher)) {
+ if (!cdat->iv && EVP_CIPHER_get_iv_length(cdat->cipher)) {
/* IV is optional and usually omitted in wrap mode */
- if (EVP_CIPHER_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
+ if (EVP_CIPHER_get_mode(cdat->cipher) != EVP_CIPH_WRAP_MODE) {
t->err = "NO_IV";
return 0;
}
}
- if (cdat->aead && !cdat->tag) {
+ if (cdat->aead && cdat->tag == NULL && !cdat->tls_aad) {
t->err = "NO_TAG";
return 0;
}
if (out_misalign == 1 && frag == 0) {
/*
- * XTS, SIV, CCM and Wrap modes have special requirements about input
- * lengths so we don't fragment for those
+ * XTS, SIV, CCM, stitched ciphers and Wrap modes have special
+ * requirements about input lengths so we don't fragment for those
*/
if (cdat->aead == EVP_CIPH_CCM_MODE
- || ((EVP_CIPHER_flags(cdat->cipher) & EVP_CIPH_FLAG_CTS) != 0)
- || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_SIV_MODE
- || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_XTS_MODE
- || EVP_CIPHER_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE)
+ || cdat->aead == EVP_CIPH_CBC_MODE
+ || (cdat->aead == -1
+ && EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_STREAM_CIPHER)
+ || ((EVP_CIPHER_get_flags(cdat->cipher) & EVP_CIPH_FLAG_CTS) != 0)
+ || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_SIV_MODE
+ || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_XTS_MODE
+ || EVP_CIPHER_get_mode(cdat->cipher) == EVP_CIPH_WRAP_MODE)
break;
out_misalign = 0;
frag++;
/* MAC salt (blake2) */
unsigned char *salt;
size_t salt_len;
+ /* XOF mode? */
+ int xof;
/* Collection of controls */
STACK_OF(OPENSSL_STRING) *controls;
+ /* Output size */
+ int output_size;
+ /* Block size */
+ int block_size;
} MAC_DATA;
static int mac_test_init(EVP_TEST *t, const char *alg)
mdat->mac_name = OPENSSL_strdup(alg);
mdat->mac = mac;
mdat->controls = sk_OPENSSL_STRING_new_null();
+ mdat->output_size = mdat->block_size = -1;
t->data = mdat;
return 1;
}
return parse_bin(value, &mdata->input, &mdata->input_len);
if (strcmp(keyword, "Output") == 0)
return parse_bin(value, &mdata->output, &mdata->output_len);
+ if (strcmp(keyword, "XOF") == 0)
+ return mdata->xof = 1;
if (strcmp(keyword, "Ctrl") == 0)
return sk_OPENSSL_STRING_push(mdata->controls,
OPENSSL_strdup(value)) != 0;
+ if (strcmp(keyword, "OutputSize") == 0) {
+ mdata->output_size = atoi(value);
+ if (mdata->output_size < 0)
+ return -1;
+ return 1;
+ }
+ if (strcmp(keyword, "BlockSize") == 0) {
+ mdata->block_size = atoi(value);
+ if (mdata->block_size < 0)
+ return -1;
+ return 1;
+ }
return 0;
}
static int mac_test_ctrl_pkey(EVP_TEST *t, EVP_PKEY_CTX *pctx,
const char *value)
{
- int rv;
+ int rv = 0;
char *p, *tmpval;
if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
return 0;
p = strchr(tmpval, ':');
- if (p != NULL)
+ if (p != NULL) {
*p++ = '\0';
- rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
+ rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
+ }
if (rv == -2)
t->err = "PKEY_CTRL_INVALID";
else if (rv <= 0)
size_t got_len;
int i;
+ /* We don't do XOF mode via PKEY */
+ if (expected->xof)
+ return 1;
+
if (expected->alg == NULL)
TEST_info("Trying the EVP_PKEY %s test", OBJ_nid2sn(expected->type));
else
t->err = "INTERNAL_ERROR";
goto err;
}
- if (!EVP_DigestSignInit_ex(mctx, &pctx, mdname, libctx, NULL, key)) {
+ if (!EVP_DigestSignInit_ex(mctx, &pctx, mdname, libctx, NULL, key, NULL)) {
t->err = "DIGESTSIGNINIT_ERROR";
goto err;
}
MAC_DATA *expected = t->data;
EVP_MAC_CTX *ctx = NULL;
unsigned char *got = NULL;
- size_t got_len;
- int i;
- OSSL_PARAM params[21];
+ size_t got_len = 0, size = 0;
+ int i, block_size = -1, output_size = -1;
+ OSSL_PARAM params[21], sizes[3], *psizes = sizes;
size_t params_n = 0;
size_t params_n_allocstart = 0;
const OSSL_PARAM *defined_params =
EVP_MAC_settable_ctx_params(expected->mac);
+ int xof;
if (expected->alg == NULL)
TEST_info("Trying the EVP_MAC %s test", expected->mac_name);
t->err = "MAC_INIT_ERROR";
goto err;
}
+ if (expected->output_size >= 0)
+ *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_SIZE,
+ &output_size);
+ if (expected->block_size >= 0)
+ *psizes++ = OSSL_PARAM_construct_int(OSSL_MAC_PARAM_BLOCK_SIZE,
+ &block_size);
+ if (psizes != sizes) {
+ *psizes = OSSL_PARAM_construct_end();
+ if (!TEST_true(EVP_MAC_CTX_get_params(ctx, sizes))) {
+ t->err = "INTERNAL_ERROR";
+ goto err;
+ }
+ if (expected->output_size >= 0
+ && !TEST_int_eq(output_size, expected->output_size)) {
+ t->err = "TEST_FAILURE";
+ goto err;
+ }
+ if (expected->block_size >= 0
+ && !TEST_int_eq(block_size, expected->block_size)) {
+ t->err = "TEST_FAILURE";
+ goto err;
+ }
+ }
if (!EVP_MAC_update(ctx, expected->input, expected->input_len)) {
t->err = "MAC_UPDATE_ERROR";
goto err;
}
- if (!EVP_MAC_final(ctx, NULL, &got_len, 0)) {
- t->err = "MAC_FINAL_LENGTH_ERROR";
- goto err;
- }
- if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
- t->err = "TEST_FAILURE";
- goto err;
- }
- if (!EVP_MAC_final(ctx, got, &got_len, got_len)
- || !memory_err_compare(t, "TEST_MAC_ERR",
- expected->output, expected->output_len,
- got, got_len)) {
- t->err = "TEST_MAC_ERR";
- goto err;
+ xof = expected->xof;
+ if (xof) {
+ if (!TEST_ptr(got = OPENSSL_malloc(expected->output_len))) {
+ t->err = "TEST_FAILURE";
+ goto err;
+ }
+ if (!EVP_MAC_finalXOF(ctx, got, expected->output_len)
+ || !memory_err_compare(t, "TEST_MAC_ERR",
+ expected->output, expected->output_len,
+ got, expected->output_len)) {
+ t->err = "MAC_FINAL_ERROR";
+ goto err;
+ }
+ } else {
+ if (!EVP_MAC_final(ctx, NULL, &got_len, 0)) {
+ t->err = "MAC_FINAL_LENGTH_ERROR";
+ goto err;
+ }
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
+ t->err = "TEST_FAILURE";
+ goto err;
+ }
+ if (!EVP_MAC_final(ctx, got, &got_len, got_len)
+ || !memory_err_compare(t, "TEST_MAC_ERR",
+ expected->output, expected->output_len,
+ got, got_len)) {
+ t->err = "TEST_MAC_ERR";
+ goto err;
+ }
}
t->err = NULL;
+
+ /* Test the EVP_Q_mac interface as well */
+ if (!xof) {
+ OPENSSL_cleanse(got, got_len);
+ if (!TEST_true(EVP_Q_mac(libctx, expected->mac_name, NULL,
+ expected->alg, params,
+ expected->key, expected->key_len,
+ expected->input, expected->input_len,
+ got, got_len, &size))
+ || !TEST_mem_eq(got, size,
+ expected->output, expected->output_len)) {
+ t->err = "EVP_Q_mac failed";
+ goto err;
+ }
+ }
err:
while (params_n-- > params_n_allocstart) {
OPENSSL_free(params[params_n].data);
static int pkey_test_ctrl(EVP_TEST *t, EVP_PKEY_CTX *pctx,
const char *value)
{
- int rv;
+ int rv = 0;
char *p, *tmpval;
if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
return 0;
p = strchr(tmpval, ':');
- if (p != NULL)
+ if (p != NULL) {
*p++ = '\0';
- rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
+ rv = EVP_PKEY_CTX_ctrl_str(pctx, tmpval, p);
+ }
if (rv == -2) {
t->err = "PKEY_CTRL_INVALID";
rv = 1;
const char *keyword, const char *value)
{
PKEY_DATA *kdata = t->data;
+ int validate = 0;
+
+ if (strcmp(keyword, "PeerKeyValidate") == 0)
+ validate = 1;
- if (strcmp(keyword, "PeerKey") == 0) {
+ if (validate || strcmp(keyword, "PeerKey") == 0) {
EVP_PKEY *peer;
if (find_key(&peer, value, public_keys) == 0)
return -1;
- if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0) {
+ if (EVP_PKEY_derive_set_peer_ex(kdata->ctx, peer, validate) <= 0) {
t->err = "DERIVE_SET_PEER_ERROR";
return 1;
}
static int pderive_test_run(EVP_TEST *t)
{
+ EVP_PKEY_CTX *dctx = NULL;
PKEY_DATA *expected = t->data;
unsigned char *got = NULL;
size_t got_len;
- if (EVP_PKEY_derive(expected->ctx, NULL, &got_len) <= 0) {
+ if (!TEST_ptr(dctx = EVP_PKEY_CTX_dup(expected->ctx))) {
+ t->err = "DERIVE_ERROR";
+ goto err;
+ }
+
+ if (EVP_PKEY_derive(dctx, NULL, &got_len) <= 0) {
t->err = "DERIVE_ERROR";
goto err;
}
t->err = "DERIVE_ERROR";
goto err;
}
- if (EVP_PKEY_derive(expected->ctx, got, &got_len) <= 0) {
+ if (EVP_PKEY_derive(dctx, got, &got_len) <= 0) {
t->err = "DERIVE_ERROR";
goto err;
}
t->err = NULL;
err:
OPENSSL_free(got);
+ EVP_PKEY_CTX_free(dctx);
return 1;
}
pbe_type = PBE_TYPE_PKCS12;
} else {
TEST_error("Unknown pbe algorithm %s", alg);
+ return 0;
}
- pdat = OPENSSL_zalloc(sizeof(*pdat));
+ if (!TEST_ptr(pdat = OPENSSL_zalloc(sizeof(*pdat))))
+ return 0;
pdat->pbe_type = pbe_type;
t->data = pdat;
return 1;
}
#endif
} else if (expected->pbe_type == PBE_TYPE_PKCS12) {
- fetched_digest = EVP_MD_fetch(libctx, EVP_MD_name(expected->md), NULL);
+ fetched_digest = EVP_MD_fetch(libctx, EVP_MD_get0_name(expected->md),
+ NULL);
if (fetched_digest == NULL) {
t->err = "PKCS12_ERROR";
goto err;
goto err;
*params = OSSL_PARAM_construct_uint(OSSL_RAND_PARAM_STRENGTH, &strength);
- if (!EVP_RAND_set_ctx_params(rdata->parent, params))
+ if (!EVP_RAND_CTX_set_params(rdata->parent, params))
goto err;
rand = EVP_RAND_fetch(libctx, name, NULL);
expected->digest, 0);
*p++ = OSSL_PARAM_construct_utf8_string(OSSL_DRBG_PARAM_MAC, "HMAC", 0);
*p = OSSL_PARAM_construct_end();
- if (!TEST_true(EVP_RAND_set_ctx_params(expected->ctx, params)))
+ if (!TEST_true(EVP_RAND_CTX_set_params(expected->ctx, params)))
goto err;
- strength = EVP_RAND_strength(expected->ctx);
+ strength = EVP_RAND_get_strength(expected->ctx);
for (i = 0; i <= expected->n; i++) {
item = expected->data + i;
(OSSL_RAND_PARAM_TEST_ENTROPY, item->reseed_entropy,
item->reseed_entropy_len);
params[1] = OSSL_PARAM_construct_end();
- if (!TEST_true(EVP_RAND_set_ctx_params(expected->parent, params)))
+ if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
goto err;
if (!TEST_true(EVP_RAND_reseed
(OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyA,
item->pr_entropyA_len);
params[1] = OSSL_PARAM_construct_end();
- if (!TEST_true(EVP_RAND_set_ctx_params(expected->parent, params)))
+ if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
goto err;
}
if (!TEST_true(EVP_RAND_generate
(OSSL_RAND_PARAM_TEST_ENTROPY, item->pr_entropyB,
item->pr_entropyB_len);
params[1] = OSSL_PARAM_construct_end();
- if (!TEST_true(EVP_RAND_set_ctx_params(expected->parent, params)))
+ if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
return 0;
}
if (!TEST_true(EVP_RAND_generate
if (!TEST_true(EVP_RAND_uninstantiate(expected->ctx))
|| !TEST_true(EVP_RAND_uninstantiate(expected->parent))
|| !TEST_true(EVP_RAND_verify_zeroization(expected->ctx))
- || !TEST_int_eq(EVP_RAND_state(expected->ctx),
+ || !TEST_int_eq(EVP_RAND_get_state(expected->ctx),
EVP_RAND_STATE_UNINITIALISED))
goto err;
}
t->err = "KDF_CTRL_ERROR";
return 1;
}
- if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
t->err = "INTERNAL_ERROR";
goto err;
}
unsigned char *got = NULL;
size_t got_len = expected->output_len;
- if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
t->err = "INTERNAL_ERROR";
goto err;
}
goto end;
}
- if ((rv = EVP_PKEY_eq(pair->privk, pair->pubk)) != 1 ) {
- if ( 0 == rv ) {
+ if ((rv = EVP_PKEY_eq(pair->privk, pair->pubk)) != 1) {
+ if (0 == rv) {
t->err = "KEYPAIR_MISMATCH";
- } else if ( -1 == rv ) {
+ } else if (-1 == rv) {
t->err = "KEYPAIR_TYPE_MISMATCH";
- } else if ( -2 == rv ) {
+ } else if (-2 == rv) {
t->err = "UNSUPPORTED_KEY_COMPARISON";
} else {
TEST_error("Unexpected error in key comparison");
if (strcmp(keyword, "Key") == 0) {
EVP_PKEY *pkey = NULL;
int rv = 0;
- const char *name = mdata->md == NULL ? NULL : EVP_MD_name(mdata->md);
+ const char *name = mdata->md == NULL ? NULL : EVP_MD_get0_name(mdata->md);
if (mdata->is_verify)
rv = find_key(&pkey, value, public_keys);
}
if (mdata->is_verify) {
if (!EVP_DigestVerifyInit_ex(mdata->ctx, &mdata->pctx, name, libctx,
- NULL, pkey))
+ NULL, pkey, NULL))
t->err = "DIGESTVERIFYINIT_ERROR";
return 1;
}
if (!EVP_DigestSignInit_ex(mdata->ctx, &mdata->pctx, name, libctx, NULL,
- pkey))
+ pkey, NULL))
t->err = "DIGESTSIGNINIT_ERROR";
return 1;
}
static int key_unsupported(void)
{
long err = ERR_peek_last_error();
+ int lib = ERR_GET_LIB(err);
+ long reason = ERR_GET_REASON(err);
- if (ERR_GET_LIB(err) == ERR_LIB_EVP
- && (ERR_GET_REASON(err) == EVP_R_UNSUPPORTED_ALGORITHM)) {
+ if ((lib == ERR_LIB_EVP && reason == EVP_R_UNSUPPORTED_ALGORITHM)
+ || (lib == ERR_LIB_EVP && reason == EVP_R_DECODE_ERROR)
+ || reason == ERR_R_UNSUPPORTED) {
ERR_clear_error();
return 1;
}
* hint to an unsupported algorithm/curve (e.g. if binary EC support is
* disabled).
*/
- if (ERR_GET_LIB(err) == ERR_LIB_EC
- && (ERR_GET_REASON(err) == EC_R_UNKNOWN_GROUP
- || ERR_GET_REASON(err) == EC_R_INVALID_CURVE)) {
+ if (lib == ERR_LIB_EC
+ && (reason == EC_R_UNKNOWN_GROUP
+ || reason == EC_R_INVALID_CURVE)) {
ERR_clear_error();
return 1;
}
}
klist = &public_keys;
} else if (strcmp(pp->key, "PrivateKeyRaw") == 0
- || strcmp(pp->key, "PublicKeyRaw") == 0 ) {
+ || strcmp(pp->key, "PublicKeyRaw") == 0) {
char *strnid = NULL, *keydata = NULL;
unsigned char *keybin;
size_t keylen;
OPT_TEST_OPTIONS_WITH_EXTRA_USAGE("[file...]\n"),
{ "config", OPT_CONFIG_FILE, '<',
"The configuration file to use for the libctx" },
- { OPT_HELP_STR, 1, '-',
- "file\tFile to run tests on.\n" },
+ { OPT_HELP_STR, 1, '-', "file\tFile to run tests on.\n" },
{ NULL }
};
return test_options;
/*
* Load the provider via configuration into the created library context.
* Load the 'null' provider into the default library context to ensure that
- * the the tests do not fallback to using the default provider.
+ * the tests do not fallback to using the default provider.
*/
if (!test_get_libctx(&libctx, &prov_null, config_file, NULL, NULL))
return 0;
projects / thirdparty / openssl.git / blobdiff