#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/err.h>
+#include <openssl/provider.h>
#include <openssl/x509v3.h>
#include <openssl/pkcs12.h>
#include <openssl/kdf.h>
+#include <openssl/params.h>
+#include <openssl/core_names.h>
#include "internal/numbers.h"
+#include "internal/nelem.h"
#include "testutil.h"
#include "evp_test.h"
const EVP_TEST_METHOD *meth; /* method for this test */
const char *err, *aux_err; /* Error string for test */
char *expected_err; /* Expected error value of test */
- char *func; /* Expected error function string */
char *reason; /* Expected error reason string */
void *data; /* test specific data */
} EVP_TEST;
typedef struct digest_data_st {
/* Digest this test is for */
const EVP_MD *digest;
+ EVP_MD *fetched_digest;
/* Input to digest */
STACK_OF(EVP_TEST_BUFFER) *input;
/* Expected output */
{
DIGEST_DATA *mdat;
const EVP_MD *digest;
+ EVP_MD *fetched_digest;
- if ((digest = EVP_get_digestbyname(alg)) == NULL) {
+ if ((digest = fetched_digest = EVP_MD_fetch(NULL, alg, NULL)) == NULL
+ && (digest = EVP_get_digestbyname(alg)) == NULL) {
/* If alg has an OID assume disabled algorithm */
if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
t->skip = 1;
return 0;
t->data = mdat;
mdat->digest = digest;
+ mdat->fetched_digest = fetched_digest;
+ if (fetched_digest != NULL)
+ TEST_info("%s is fetched", alg);
return 1;
}
sk_EVP_TEST_BUFFER_pop_free(mdat->input, evp_test_buffer_free);
OPENSSL_free(mdat->output);
+ EVP_MD_meth_free(mdat->fetched_digest);
}
static int digest_test_parse(EVP_TEST *t,
}
if (EVP_MD_flags(expected->digest) & EVP_MD_FLAG_XOF) {
+ EVP_MD_CTX *mctx_cpy;
+ char dont[] = "touch";
+
+ if (!TEST_ptr(mctx_cpy = EVP_MD_CTX_new())) {
+ goto err;
+ }
+ if (!EVP_MD_CTX_copy(mctx_cpy, mctx)) {
+ EVP_MD_CTX_free(mctx_cpy);
+ goto err;
+ }
+ if (!EVP_DigestFinalXOF(mctx_cpy, (unsigned char *)dont, 0)) {
+ EVP_MD_CTX_free(mctx_cpy);
+ t->err = "DIGESTFINALXOF_ERROR";
+ goto err;
+ }
+ if (!TEST_str_eq(dont, "touch")) {
+ EVP_MD_CTX_free(mctx_cpy);
+ t->err = "DIGESTFINALXOF_ERROR";
+ goto err;
+ }
+ EVP_MD_CTX_free(mctx_cpy);
+
got_len = expected->output_len;
if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
t->err = "DIGESTFINALXOF_ERROR";
typedef struct cipher_data_st {
const EVP_CIPHER *cipher;
+ EVP_CIPHER *fetched_cipher;
int enc;
/* EVP_CIPH_GCM_MODE, EVP_CIPH_CCM_MODE or EVP_CIPH_OCB_MODE if AEAD */
int aead;
unsigned char *key;
size_t key_len;
+ size_t key_bits; /* Used by RC2 */
unsigned char *iv;
+ unsigned int rounds;
size_t iv_len;
unsigned char *plaintext;
size_t plaintext_len;
size_t aad_len[AAD_NUM];
unsigned char *tag;
size_t tag_len;
+ int tag_late;
} CIPHER_DATA;
static int cipher_test_init(EVP_TEST *t, const char *alg)
{
const EVP_CIPHER *cipher;
+ EVP_CIPHER *fetched_cipher;
CIPHER_DATA *cdat;
int m;
- if ((cipher = EVP_get_cipherbyname(alg)) == NULL) {
+ if ((cipher = fetched_cipher = EVP_CIPHER_fetch(NULL, alg, NULL)) == NULL
+ && (cipher = EVP_get_cipherbyname(alg)) == NULL) {
/* If alg has an OID assume disabled algorithm */
if (OBJ_sn2nid(alg) != NID_undef || OBJ_ln2nid(alg) != NID_undef) {
t->skip = 1;
}
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
cdat->aead = 0;
t->data = cdat;
+ if (fetched_cipher != NULL)
+ TEST_info("%s is fetched", alg);
return 1;
}
for (i = 0; i < AAD_NUM; i++)
OPENSSL_free(cdat->aad[i]);
OPENSSL_free(cdat->tag);
+ EVP_CIPHER_meth_free(cdat->fetched_cipher);
}
static int cipher_test_parse(EVP_TEST *t, const char *keyword,
if (strcmp(keyword, "Key") == 0)
return parse_bin(value, &cdat->key, &cdat->key_len);
+ if (strcmp(keyword, "Rounds") == 0) {
+ i = atoi(value);
+ if (i < 0)
+ return -1;
+ cdat->rounds = (unsigned int)i;
+ return 1;
+ }
if (strcmp(keyword, "IV") == 0)
return parse_bin(value, &cdat->iv, &cdat->iv_len);
if (strcmp(keyword, "Plaintext") == 0)
return parse_bin(value, &cdat->plaintext, &cdat->plaintext_len);
if (strcmp(keyword, "Ciphertext") == 0)
return parse_bin(value, &cdat->ciphertext, &cdat->ciphertext_len);
+ if (strcmp(keyword, "KeyBits") == 0) {
+ i = atoi(value);
+ if (i < 0)
+ return -1;
+ cdat->key_bits = (size_t)i;
+ return 1;
+ }
if (cdat->aead) {
if (strcmp(keyword, "AAD") == 0) {
for (i = 0; i < AAD_NUM; i++) {
if (cdat->aad[i] == NULL)
return parse_bin(value, &cdat->aad[i], &cdat->aad_len[i]);
}
- return 0;
+ return -1;
}
if (strcmp(keyword, "Tag") == 0)
return parse_bin(value, &cdat->tag, &cdat->tag_len);
+ if (strcmp(keyword, "SetTagLate") == 0) {
+ if (strcmp(value, "TRUE") == 0)
+ cdat->tag_late = 1;
+ else if (strcmp(value, "FALSE") == 0)
+ cdat->tag_late = 0;
+ else
+ return -1;
+ return 1;
+ }
}
if (strcmp(keyword, "Operation") == 0) {
else if (strcmp(value, "DECRYPT") == 0)
cdat->enc = 0;
else
- return 0;
+ return -1;
return 1;
}
return 0;
* If encrypting or OCB just set tag length initially, otherwise
* set tag length and value.
*/
- if (enc || expected->aead == EVP_CIPH_OCB_MODE) {
+ if (enc || expected->aead == EVP_CIPH_OCB_MODE || expected->tag_late) {
t->err = "TAG_LENGTH_SET_ERROR";
tag = NULL;
} else {
}
}
+ if (expected->rounds > 0) {
+ int rounds = (int)expected->rounds;
+
+ if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_SET_RC5_ROUNDS, rounds, NULL)) {
+ t->err = "INVALID_ROUNDS";
+ goto err;
+ }
+ }
+
if (!EVP_CIPHER_CTX_set_key_length(ctx, expected->key_len)) {
t->err = "INVALID_KEY_LENGTH";
goto err;
}
+ if (expected->key_bits > 0) {
+ int bits = (int)expected->key_bits;
+
+ if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_SET_RC2_KEY_BITS, bits, NULL)) {
+ t->err = "INVALID KEY BITS";
+ goto err;
+ }
+ }
if (!EVP_CipherInit_ex(ctx, NULL, NULL, expected->key, expected->iv, -1)) {
t->err = "KEY_SET_ERROR";
goto err;
}
- if (!enc && expected->aead == EVP_CIPH_OCB_MODE) {
- if (!EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_AEAD_SET_TAG,
- expected->tag_len, expected->tag)) {
- t->err = "TAG_SET_ERROR";
- goto err;
- }
+ /* Check that we get the same IV back */
+ if (expected->iv != NULL
+ && (EVP_CIPHER_flags(expected->cipher) & EVP_CIPH_CUSTOM_IV) == 0
+ && !TEST_mem_eq(expected->iv, expected->iv_len,
+ EVP_CIPHER_CTX_iv(ctx), expected->iv_len)) {
+ t->err = "INVALID_IV";
+ goto err;
}
if (expected->aead == EVP_CIPH_CCM_MODE) {
}
}
}
+
+ 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";
+ goto err;
+ }
+ }
+
EVP_CIPHER_CTX_set_padding(ctx, 0);
t->err = "CIPHERUPDATE_ERROR";
tmplen = 0;
typedef struct mac_data_st {
/* MAC type in one form or another */
- const EVP_MAC *mac; /* for mac_test_run_mac */
+ char *mac_name;
+ EVP_MAC *mac; /* for mac_test_run_mac */
int type; /* for mac_test_run_pkey */
/* Algorithm string for this MAC */
char *alg;
static int mac_test_init(EVP_TEST *t, const char *alg)
{
- const EVP_MAC *mac = NULL;
+ EVP_MAC *mac = NULL;
int type = NID_undef;
MAC_DATA *mdat;
- if ((mac = EVP_get_macbyname(alg)) == NULL) {
+ if ((mac = EVP_MAC_fetch(NULL, alg, NULL)) == NULL) {
/*
* Since we didn't find an EVP_MAC, we check for known EVP_PKEY methods
* For debugging purposes, we allow 'NNNN by EVP_PKEY' to force running
mdat = OPENSSL_zalloc(sizeof(*mdat));
mdat->type = type;
+ mdat->mac_name = OPENSSL_strdup(alg);
mdat->mac = mac;
mdat->controls = sk_OPENSSL_STRING_new_null();
t->data = mdat;
{
MAC_DATA *mdat = t->data;
+ EVP_MAC_free(mdat->mac);
+ OPENSSL_free(mdat->mac_name);
sk_OPENSSL_STRING_pop_free(mdat->controls, openssl_free);
OPENSSL_free(mdat->alg);
OPENSSL_free(mdat->key);
if (strcmp(keyword, "Algorithm") == 0) {
mdata->alg = OPENSSL_strdup(value);
if (!mdata->alg)
- return 0;
+ return -1;
return 1;
}
if (strcmp(keyword, "Input") == 0)
{
MAC_DATA *expected = t->data;
EVP_MAC_CTX *ctx = NULL;
- const void *algo = NULL;
- int algo_ctrl = 0;
unsigned char *got = NULL;
size_t got_len;
- int rv, i;
+ int i;
+ OSSL_PARAM params[21];
+ size_t params_n = 0;
+ size_t params_n_allocstart = 0;
+ const OSSL_PARAM *defined_params =
+ EVP_MAC_settable_ctx_params(expected->mac);
if (expected->alg == NULL)
- TEST_info("Trying the EVP_MAC %s test", EVP_MAC_name(expected->mac));
+ TEST_info("Trying the EVP_MAC %s test", expected->mac_name);
else
TEST_info("Trying the EVP_MAC %s test with %s",
- EVP_MAC_name(expected->mac), expected->alg);
+ expected->mac_name, expected->alg);
#ifdef OPENSSL_NO_DES
if (expected->alg != NULL && strstr(expected->alg, "DES") != NULL) {
}
#endif
- if ((ctx = EVP_MAC_CTX_new(expected->mac)) == NULL) {
- t->err = "MAC_CREATE_ERROR";
- goto err;
- }
-
- if (expected->alg != NULL
- && ((algo_ctrl = EVP_MAC_CTRL_SET_CIPHER,
- algo = EVP_get_cipherbyname(expected->alg)) == NULL
- && (algo_ctrl = EVP_MAC_CTRL_SET_MD,
- algo = EVP_get_digestbyname(expected->alg)) == NULL)) {
- t->err = "MAC_BAD_ALGORITHM";
- goto err;
- }
-
-
- if (algo_ctrl != 0) {
- rv = EVP_MAC_ctrl(ctx, algo_ctrl, algo);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
+ if (expected->alg != NULL) {
+ /*
+ * The underlying algorithm may be a cipher or a digest.
+ * We don't know which it is, but we can ask the MAC what it
+ * should be and bet on that.
+ */
+ if (OSSL_PARAM_locate_const(defined_params,
+ OSSL_MAC_PARAM_CIPHER) != NULL) {
+ params[params_n++] =
+ OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_CIPHER,
+ expected->alg, 0);
+ } else if (OSSL_PARAM_locate_const(defined_params,
+ OSSL_MAC_PARAM_DIGEST) != NULL) {
+ params[params_n++] =
+ OSSL_PARAM_construct_utf8_string(OSSL_MAC_PARAM_DIGEST,
+ expected->alg, 0);
+ } else {
+ t->err = "MAC_BAD_PARAMS";
goto err;
}
}
+ if (expected->key != NULL)
+ params[params_n++] =
+ OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_KEY,
+ expected->key,
+ expected->key_len);
+ if (expected->custom != NULL)
+ params[params_n++] =
+ OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_CUSTOM,
+ expected->custom,
+ expected->custom_len);
+ if (expected->salt != NULL)
+ params[params_n++] =
+ OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_SALT,
+ expected->salt,
+ expected->salt_len);
+ if (expected->iv != NULL)
+ params[params_n++] =
+ OSSL_PARAM_construct_octet_string(OSSL_MAC_PARAM_IV,
+ expected->iv,
+ expected->iv_len);
- rv = EVP_MAC_ctrl(ctx, EVP_MAC_CTRL_SET_KEY,
- expected->key, expected->key_len);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
+ /*
+ * Unknown controls. They must match parameters that the MAC recognises
+ */
+ if (params_n + sk_OPENSSL_STRING_num(expected->controls)
+ >= OSSL_NELEM(params)) {
+ t->err = "MAC_TOO_MANY_PARAMETERS";
goto err;
}
- if (expected->custom != NULL) {
- rv = EVP_MAC_ctrl(ctx, EVP_MAC_CTRL_SET_CUSTOM,
- expected->custom, expected->custom_len);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
- goto err;
- }
- }
+ params_n_allocstart = params_n;
+ for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++) {
+ char *tmpkey, *tmpval;
+ char *value = sk_OPENSSL_STRING_value(expected->controls, i);
- if (expected->salt != NULL) {
- rv = EVP_MAC_ctrl(ctx, EVP_MAC_CTRL_SET_SALT,
- expected->salt, expected->salt_len);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
+ if (!TEST_ptr(tmpkey = OPENSSL_strdup(value))) {
+ t->err = "MAC_PARAM_ERROR";
goto err;
}
- }
-
- if (expected->iv != NULL) {
- rv = EVP_MAC_ctrl(ctx, EVP_MAC_CTRL_SET_IV,
- expected->iv, expected->iv_len);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
+ tmpval = strchr(tmpkey, ':');
+ if (tmpval != NULL)
+ *tmpval++ = '\0';
+
+ if (tmpval == NULL
+ || !OSSL_PARAM_allocate_from_text(¶ms[params_n],
+ defined_params,
+ tmpkey, tmpval,
+ strlen(tmpval))) {
+ OPENSSL_free(tmpkey);
+ t->err = "MAC_PARAM_ERROR";
goto err;
}
+ params_n++;
+
+ OPENSSL_free(tmpkey);
}
+ params[params_n] = OSSL_PARAM_construct_end();
- for (i = 0; i < sk_OPENSSL_STRING_num(expected->controls); i++) {
- char *p, *tmpval;
- char *value = sk_OPENSSL_STRING_value(expected->controls, i);
+ if ((ctx = EVP_MAC_CTX_new(expected->mac)) == NULL) {
+ t->err = "MAC_CREATE_ERROR";
+ goto err;
+ }
- if (!TEST_ptr(tmpval = OPENSSL_strdup(value))) {
- t->err = "MAC_CTRL_ERROR";
- goto err;
- }
- p = strchr(tmpval, ':');
- if (p != NULL)
- *p++ = '\0';
- rv = EVP_MAC_ctrl_str(ctx, tmpval, p);
- OPENSSL_free(tmpval);
- if (rv == -2) {
- t->err = "MAC_CTRL_INVALID";
- goto err;
- } else if (rv <= 0) {
- t->err = "MAC_CTRL_ERROR";
- goto err;
- }
+ if (!EVP_MAC_CTX_set_params(ctx, params)) {
+ t->err = "MAC_BAD_PARAMS";
+ goto err;
}
if (!EVP_MAC_init(ctx)) {
t->err = "MAC_INIT_ERROR";
t->err = "MAC_UPDATE_ERROR";
goto err;
}
- if (!EVP_MAC_final(ctx, NULL, &got_len)) {
+ if (!EVP_MAC_final(ctx, NULL, &got_len, 0)) {
t->err = "MAC_FINAL_LENGTH_ERROR";
goto err;
}
t->err = "TEST_FAILURE";
goto err;
}
- if (!EVP_MAC_final(ctx, got, &got_len)
+ 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 = NULL;
err:
+ while (params_n-- > params_n_allocstart) {
+ OPENSSL_free(params[params_n].data);
+ }
EVP_MAC_CTX_free(ctx);
OPENSSL_free(got);
return 1;
if (strcmp(keyword, "PeerKey") == 0) {
EVP_PKEY *peer;
if (find_key(&peer, value, public_keys) == 0)
- return 0;
+ return -1;
if (EVP_PKEY_derive_set_peer(kdata->ctx, peer) <= 0)
- return 0;
+ return -1;
return 1;
}
if (strcmp(keyword, "SharedSecret") == 0)
/* Expected output */
unsigned char *output;
size_t output_len;
+ OSSL_PARAM params[20];
+ OSSL_PARAM *p;
} KDF_DATA;
/*
static int kdf_test_init(EVP_TEST *t, const char *name)
{
KDF_DATA *kdata;
- const EVP_KDF *kdf;
+ EVP_KDF *kdf;
#ifdef OPENSSL_NO_SCRYPT
- if (strcmp(name, "scrypt") == 0) {
+ /* TODO(3.0) Replace with "scrypt" once aliases are supported */
+ if (strcmp(name, "id-scrypt") == 0) {
t->skip = 1;
return 1;
}
-#endif
+#endif /* OPENSSL_NO_SCRYPT */
- kdf = EVP_get_kdfbyname(name);
- if (kdf == NULL)
- return 0;
+#ifdef OPENSSL_NO_CMS
+ if (strcmp(name, "X942KDF") == 0) {
+ t->skip = 1;
+ return 1;
+ }
+#endif /* OPENSSL_NO_CMS */
if (!TEST_ptr(kdata = OPENSSL_zalloc(sizeof(*kdata))))
return 0;
+ kdata->p = kdata->params;
+ *kdata->p = OSSL_PARAM_construct_end();
+
+ kdf = EVP_KDF_fetch(NULL, name, NULL);
+ if (kdf == NULL) {
+ OPENSSL_free(kdata);
+ return 0;
+ }
kdata->ctx = EVP_KDF_CTX_new(kdf);
+ EVP_KDF_free(kdf);
if (kdata->ctx == NULL) {
OPENSSL_free(kdata);
return 0;
static void kdf_test_cleanup(EVP_TEST *t)
{
KDF_DATA *kdata = t->data;
+ OSSL_PARAM *p;
+
+ for (p = kdata->params; p->key != NULL; p++)
+ OPENSSL_free(p->data);
OPENSSL_free(kdata->output);
EVP_KDF_CTX_free(kdata->ctx);
}
static int kdf_test_ctrl(EVP_TEST *t, EVP_KDF_CTX *kctx,
const char *value)
{
+ KDF_DATA *kdata = t->data;
int rv;
- char *p, *tmpval;
+ char *p, *name;
+ const OSSL_PARAM *defs = EVP_KDF_settable_ctx_params(EVP_KDF_CTX_kdf(kctx));
- if (!TEST_ptr(tmpval = OPENSSL_strdup(value)))
+ if (!TEST_ptr(name = OPENSSL_strdup(value)))
return 0;
- p = strchr(tmpval, ':');
+ p = strchr(name, ':');
if (p != NULL)
*p++ = '\0';
- rv = EVP_KDF_ctrl_str(kctx, tmpval, p);
- if (rv == -2) {
- t->err = "KDF_CTRL_INVALID";
- rv = 1;
- } else if (p != NULL && rv <= 0) {
+
+ rv = OSSL_PARAM_allocate_from_text(kdata->p, defs, name, p,
+ p != NULL ? strlen(p) : 0);
+ *++kdata->p = OSSL_PARAM_construct_end();
+ if (!rv) {
+ t->err = "KDF_PARAM_ERROR";
+ OPENSSL_free(name);
+ return 0;
+ }
+ if (p != NULL && strcmp(name, "digest") == 0) {
/* If p has an OID and lookup fails assume disabled algorithm */
int nid = OBJ_sn2nid(p);
if (nid == NID_undef)
nid = OBJ_ln2nid(p);
- if (nid != NID_undef
- && EVP_get_digestbynid(nid) == NULL
- && EVP_get_cipherbynid(nid) == NULL) {
+ if (nid != NID_undef && EVP_get_digestbynid(nid) == NULL)
t->skip = 1;
- rv = 1;
- } else {
- t->err = "KDF_CTRL_ERROR";
- rv = 1;
- }
}
- OPENSSL_free(tmpval);
- return rv > 0;
+ if (p != NULL && strcmp(name, "cipher") == 0) {
+ /* If p has an OID and lookup fails assume disabled algorithm */
+ int nid = OBJ_sn2nid(p);
+
+ if (nid == NID_undef)
+ nid = OBJ_ln2nid(p);
+ if (nid != NID_undef && EVP_get_cipherbynid(nid) == NULL)
+ t->skip = 1;
+ }
+ OPENSSL_free(name);
+ return 1;
}
static int kdf_test_parse(EVP_TEST *t,
unsigned char *got = NULL;
size_t got_len = expected->output_len;
+ if (!EVP_KDF_CTX_set_params(expected->ctx, expected->params)) {
+ t->err = "KDF_CTRL_ERROR";
+ return 1;
+ }
if (!TEST_ptr(got = OPENSSL_malloc(got_len))) {
t->err = "INTERNAL_ERROR";
goto err;
t->skip = 1;
return 1;
}
-#endif
+#endif /* OPENSSL_NO_SCRYPT */
+
+#ifdef OPENSSL_NO_CMS
+ if (strcmp(name, "X942KDF") == 0) {
+ t->skip = 1;
+ return 1;
+ }
+#endif /* OPENSSL_NO_CMS */
if (kdf_nid == NID_undef)
kdf_nid = OBJ_ln2nid(name);
static void pkey_kdf_test_cleanup(EVP_TEST *t)
{
PKEY_KDF_DATA *kdata = t->data;
+
OPENSSL_free(kdata->output);
EVP_PKEY_CTX_free(kdata->ctx);
}
}
if (strcmp(keyword, "Ctrl") == 0) {
if (mdata->pctx == NULL)
- return 0;
+ return -1;
return pkey_test_ctrl(t, mdata->pctx, value);
}
return 0;
}
OPENSSL_free(t->expected_err);
t->expected_err = NULL;
- OPENSSL_free(t->func);
- t->func = NULL;
OPENSSL_free(t->reason);
t->reason = NULL;
static int check_test_error(EVP_TEST *t)
{
unsigned long err;
- const char *func;
const char *reason;
if (t->err == NULL && t->expected_err == NULL)
return 0;
}
- if (t->func == NULL && t->reason == NULL)
+ if (t->reason == NULL)
return 1;
- if (t->func == NULL || t->reason == NULL) {
+ if (t->reason == NULL) {
TEST_info("%s:%d: Test is missing function or reason code",
t->s.test_file, t->s.start);
return 0;
err = ERR_peek_error();
if (err == 0) {
- TEST_info("%s:%d: Expected error \"%s:%s\" not set",
- t->s.test_file, t->s.start, t->func, t->reason);
+ TEST_info("%s:%d: Expected error \"%s\" not set",
+ t->s.test_file, t->s.start, t->reason);
return 0;
}
- func = ERR_func_error_string(err);
reason = ERR_reason_error_string(err);
- if (func == NULL && reason == NULL) {
- TEST_info("%s:%d: Expected error \"%s:%s\", no strings available."
+ if (reason == NULL) {
+ TEST_info("%s:%d: Expected error \"%s\", no strings available."
" Assuming ok.",
- t->s.test_file, t->s.start, t->func, t->reason);
+ t->s.test_file, t->s.start, t->reason);
return 1;
}
- if (strcmp(func, t->func) == 0 && strcmp(reason, t->reason) == 0)
+ if (strcmp(reason, t->reason) == 0)
return 1;
- TEST_info("%s:%d: Expected error \"%s:%s\", got \"%s:%s\"",
- t->s.test_file, t->s.start, t->func, t->reason, func, reason);
+ TEST_info("%s:%d: Expected error \"%s\", got \"%s\"",
+ t->s.test_file, t->s.start, t->reason, reason);
return 0;
}
return p;
}
+/*
+ * Return 1 if one of the providers named in the string is available.
+ * The provider names are separated with whitespace.
+ * NOTE: destructive function, it inserts '\0' after each provider name.
+ */
+static int prov_available(char *providers)
+{
+ char *p;
+ int more = 1;
+
+ while (more) {
+ for (; isspace(*providers); providers++)
+ continue;
+ if (*providers == '\0')
+ break; /* End of the road */
+ for (p = providers; *p != '\0' && !isspace(*p); p++)
+ continue;
+ if (*p == '\0')
+ more = 0;
+ else
+ *p = '\0';
+ if (OSSL_PROVIDER_available(NULL, providers))
+ return 1; /* Found one */
+ }
+ return 0;
+}
+
/*
* Read and parse one test. Return 0 if failure, 1 if okay.
*/
}
for (pp++, i = 1; i < t->s.numpairs; pp++, i++) {
- if (strcmp(pp->key, "Result") == 0) {
+ if (strcmp(pp->key, "Availablein") == 0) {
+ if (!prov_available(pp->value)) {
+ TEST_info("skipping, providers not available: %s:%d",
+ t->s.test_file, t->s.start);
+ t->skip = 1;
+ return 0;
+ }
+ } else if (strcmp(pp->key, "Result") == 0) {
if (t->expected_err != NULL) {
TEST_info("Line %d: multiple result lines", t->s.curr);
return 0;
}
t->expected_err = take_value(pp);
} else if (strcmp(pp->key, "Function") == 0) {
- if (t->func != NULL) {
- TEST_info("Line %d: multiple function lines\n", t->s.curr);
- return 0;
- }
- t->func = take_value(pp);
+ /* Ignore old line. */
} else if (strcmp(pp->key, "Reason") == 0) {
if (t->reason != NULL) {
TEST_info("Line %d: multiple reason lines", t->s.curr);
while (!BIO_eof(t->s.fp)) {
c = parse(t);
- if (t->skip)
+ if (t->skip) {
+ t->s.numskip++;
continue;
+ }
if (c == 0 || !run_test(t)) {
t->s.errors++;
break;
projects / openssl.git / blobdiff