/*
- * Copyright 2015-2020 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2015-2021 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* https://www.openssl.org/source/license.html
*/
+#define OPENSSL_SUPPRESS_DEPRECATED /* EVP_PKEY_new_CMAC_key */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
-#include "../e_os.h" /* strcasecmp */
+#include "internal/e_os.h" /* strcasecmp and strncasecmp */
#include <openssl/evp.h>
#include <openssl/pem.h>
#include <openssl/err.h>
return EVP_DigestUpdate(ctx, buf, buflen);
}
+static int test_duplicate_md_ctx(EVP_TEST *t, EVP_MD_CTX *mctx)
+{
+ char dont[] = "touch";
+
+ if (!TEST_ptr(mctx))
+ return 0;
+ if (!EVP_DigestFinalXOF(mctx, (unsigned char *)dont, 0)) {
+ EVP_MD_CTX_free(mctx);
+ t->err = "DIGESTFINALXOF_ERROR";
+ return 0;
+ }
+ if (!TEST_str_eq(dont, "touch")) {
+ EVP_MD_CTX_free(mctx);
+ t->err = "DIGESTFINALXOF_ERROR";
+ return 0;
+ }
+ EVP_MD_CTX_free(mctx);
+ return 1;
+}
+
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];
+ printf("test %s (%d %d)\n", t->name, t->s.start, t->s.curr);
t->err = "TEST_FAILURE";
if (!TEST_ptr(mctx = EVP_MD_CTX_new()))
goto err;
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";
if (!TEST_ptr(mctx_cpy = EVP_MD_CTX_new())) {
goto err;
}
- if (!EVP_MD_CTX_copy(mctx_cpy, mctx)) {
+ if (!TEST_true(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";
+ } else if (!test_duplicate_md_ctx(t, mctx_cpy)) {
goto err;
}
- if (!TEST_str_eq(dont, "touch")) {
- EVP_MD_CTX_free(mctx_cpy);
- t->err = "DIGESTFINALXOF_ERROR";
+
+ if (!test_duplicate_md_ctx(t, EVP_MD_CTX_dup(mctx)))
goto err;
- }
- EVP_MD_CTX_free(mctx_cpy);
got_len = expected->output_len;
if (!EVP_DigestFinalXOF(mctx, got, got_len)) {
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();
+
+ if (!TEST_ptr(cdat = OPENSSL_zalloc(sizeof(*cdat))))
return 0;
- 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) {
size_t in_len, out_len, donelen = 0;
int ok = 0, tmplen, chunklen, tmpflen, i;
EVP_CIPHER_CTX *ctx_base = NULL;
- EVP_CIPHER_CTX *ctx = NULL;
+ EVP_CIPHER_CTX *ctx = NULL, *duped;
t->err = "TEST_FAILURE";
if (!TEST_ptr(ctx_base = EVP_CIPHER_CTX_new()))
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
if (expected->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_iv_state(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))) {
+ if (!TEST_true(EVP_CIPHER_CTX_get_updated_iv(ctx_base, iv, sizeof(iv)))
+ || ((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;
}
+ /* Likewise for dup */
+ duped = EVP_CIPHER_CTX_dup(ctx);
+ if (duped != NULL) {
+ EVP_CIPHER_CTX_free(ctx);
+ ctx = duped;
+ }
+ 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)
return 0;
}
- mdat = OPENSSL_zalloc(sizeof(*mdat));
+ if (!TEST_ptr(mdat = OPENSSL_zalloc(sizeof(*mdat))))
+ return 0;
+
mdat->type = type;
- mdat->mac_name = OPENSSL_strdup(alg);
+ if (!TEST_ptr(mdat->mac_name = OPENSSL_strdup(alg))) {
+ OPENSSL_free(mdat);
+ return 0;
+ }
+
mdat->mac = mac;
- mdat->controls = sk_OPENSSL_STRING_new_null();
+ if (!TEST_ptr(mdat->controls = sk_OPENSSL_STRING_new_null())) {
+ OPENSSL_free(mdat->mac_name);
+ OPENSSL_free(mdat);
+ return 0;
+ }
+
+ 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
OBJ_nid2sn(expected->type), expected->alg);
if (expected->type == EVP_PKEY_CMAC) {
+#ifdef OPENSSL_NO_DEPRECATED_3_0
+ TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
+ t->skip = 1;
+ t->err = NULL;
+ goto err;
+#else
+ OSSL_LIB_CTX *tmpctx;
+
if (expected->alg != NULL && is_cipher_disabled(expected->alg)) {
TEST_info("skipping, PKEY CMAC '%s' is disabled", expected->alg);
t->skip = 1;
t->err = "MAC_KEY_CREATE_ERROR";
goto err;
}
- key = EVP_PKEY_new_CMAC_key_ex(expected->key, expected->key_len,
- EVP_CIPHER_name(cipher), libctx, NULL);
+ tmpctx = OSSL_LIB_CTX_set0_default(libctx);
+ key = EVP_PKEY_new_CMAC_key(NULL, expected->key, expected->key_len,
+ cipher);
+ OSSL_LIB_CTX_set0_default(tmpctx);
+#endif
} else {
key = EVP_PKEY_new_raw_private_key_ex(libctx,
OBJ_nid2sn(expected->type), NULL,
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);
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,
goto err;
}
- if (!EVP_MAC_CTX_set_params(ctx, params)) {
- t->err = "MAC_BAD_PARAMS";
- goto err;
- }
- if (!EVP_MAC_init(ctx)) {
+ if (!EVP_MAC_init(ctx, expected->key, expected->key_len, params)) {
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;
}
return parse_bin(value, &kdata->output, &kdata->output_len);
if (strcmp(keyword, "Ctrl") == 0)
return pkey_test_ctrl(t, kdata->ctx, value);
+ if (strcmp(keyword, "KDFType") == 0) {
+ OSSL_PARAM params[2];
+
+ params[0] = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_TYPE,
+ (char *)value, 0);
+ params[1] = OSSL_PARAM_construct_end();
+ if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
+ return -1;
+ return 1;
+ }
+ if (strcmp(keyword, "KDFDigest") == 0) {
+ OSSL_PARAM params[2];
+
+ params[0] = OSSL_PARAM_construct_utf8_string(OSSL_EXCHANGE_PARAM_KDF_DIGEST,
+ (char *)value, 0);
+ params[1] = OSSL_PARAM_construct_end();
+ if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
+ return -1;
+ return 1;
+ }
+ if (strcmp(keyword, "CEKAlg") == 0) {
+ OSSL_PARAM params[2];
+
+ params[0] = OSSL_PARAM_construct_utf8_string(OSSL_KDF_PARAM_CEK_ALG,
+ (char *)value, 0);
+ params[1] = OSSL_PARAM_construct_end();
+ if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
+ return -1;
+ return 1;
+ }
+ if (strcmp(keyword, "KDFOutlen") == 0) {
+ OSSL_PARAM params[2];
+ char *endptr;
+ size_t outlen = (size_t)strtoul(value, &endptr, 0);
+
+ if (endptr[0] != '\0')
+ return -1;
+
+ params[0] = OSSL_PARAM_construct_size_t(OSSL_EXCHANGE_PARAM_KDF_OUTLEN,
+ &outlen);
+ params[1] = OSSL_PARAM_construct_end();
+ if (EVP_PKEY_CTX_set_params(kdata->ctx, params) == 0)
+ return -1;
+ return 1;
+ }
return 0;
}
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
+ || !TEST_size_t_ne(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);
if (n > rdata->n)
rdata->n = n;
item = rdata->data + n;
- if (strncmp(keyword, "Entropy.", sizeof("Entropy")) == 0)
+ if (HAS_PREFIX(keyword, "Entropy."))
return parse_bin(value, &item->entropy, &item->entropy_len);
- if (strncmp(keyword, "ReseedEntropy.", sizeof("ReseedEntropy")) == 0)
+ if (HAS_PREFIX(keyword, "ReseedEntropy."))
return parse_bin(value, &item->reseed_entropy,
&item->reseed_entropy_len);
- if (strncmp(keyword, "Nonce.", sizeof("Nonce")) == 0)
+ if (HAS_PREFIX(keyword, "Nonce."))
return parse_bin(value, &item->nonce, &item->nonce_len);
- if (strncmp(keyword, "PersonalisationString.",
- sizeof("PersonalisationString")) == 0)
+ if (HAS_PREFIX(keyword, "PersonalisationString."))
return parse_bin(value, &item->pers, &item->pers_len);
- if (strncmp(keyword, "ReseedAdditionalInput.",
- sizeof("ReseedAdditionalInput")) == 0)
+ if (HAS_PREFIX(keyword, "ReseedAdditionalInput."))
return parse_bin(value, &item->reseed_addin,
&item->reseed_addin_len);
- if (strncmp(keyword, "AdditionalInputA.",
- sizeof("AdditionalInputA")) == 0)
+ if (HAS_PREFIX(keyword, "AdditionalInputA."))
return parse_bin(value, &item->addinA, &item->addinA_len);
- if (strncmp(keyword, "AdditionalInputB.",
- sizeof("AdditionalInputB")) == 0)
+ if (HAS_PREFIX(keyword, "AdditionalInputB."))
return parse_bin(value, &item->addinB, &item->addinB_len);
- if (strncmp(keyword, "EntropyPredictionResistanceA.",
- sizeof("EntropyPredictionResistanceA")) == 0)
+ if (HAS_PREFIX(keyword, "EntropyPredictionResistanceA."))
return parse_bin(value, &item->pr_entropyA, &item->pr_entropyA_len);
- if (strncmp(keyword, "EntropyPredictionResistanceB.",
- sizeof("EntropyPredictionResistanceB")) == 0)
+ if (HAS_PREFIX(keyword, "EntropyPredictionResistanceB."))
return parse_bin(value, &item->pr_entropyB, &item->pr_entropyB_len);
- if (strncmp(keyword, "Output.", sizeof("Output")) == 0)
+ if (HAS_PREFIX(keyword, "Output."))
return parse_bin(value, &item->output, &item->output_len);
} else {
if (strcmp(keyword, "Cipher") == 0)
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;
*p++ = OSSL_PARAM_construct_octet_string(OSSL_RAND_PARAM_TEST_NONCE,
z, item->nonce_len);
*p = OSSL_PARAM_construct_end();
- if (!TEST_true(EVP_RAND_set_ctx_params(expected->parent, params))
- || !TEST_true(EVP_RAND_instantiate(expected->parent, strength,
- 0, NULL, 0)))
+ if (!TEST_true(EVP_RAND_instantiate(expected->parent, strength,
+ 0, NULL, 0, params)))
goto err;
z = item->pers != NULL ? item->pers : (unsigned char *)"";
if (!TEST_true(EVP_RAND_instantiate
(expected->ctx, strength,
expected->prediction_resistance, z,
- item->pers_len)))
+ item->pers_len, NULL)))
goto err;
if (item->reseed_entropy != NULL) {
(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)))
- return 0;
+ if (!TEST_true(EVP_RAND_CTX_set_params(expected->parent, params)))
+ goto err;
}
if (!TEST_true(EVP_RAND_generate
(expected->ctx, got, got_len,
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;
}
if (p != NULL)
*p++ = '\0';
+ if (strcmp(name, "r") == 0
+ && OSSL_PARAM_locate_const(defs, name) == NULL) {
+ TEST_info("skipping, setting 'r' is unsupported");
+ t->skip = 1;
+ goto end;
+ }
+
rv = OSSL_PARAM_allocate_from_text(kdata->p, defs, name, p,
p != NULL ? strlen(p) : 0, NULL);
*++kdata->p = OSSL_PARAM_construct_end();
TEST_info("skipping, '%s' is disabled", p);
t->skip = 1;
}
+ goto end;
}
if (p != NULL
&& (strcmp(name, "cipher") == 0
&& is_cipher_disabled(p)) {
TEST_info("skipping, '%s' is disabled", p);
t->skip = 1;
+ goto end;
+ }
+ if (p != NULL
+ && (strcmp(name, "mac") == 0)
+ && is_mac_disabled(p)) {
+ TEST_info("skipping, '%s' is disabled", p);
+ t->skip = 1;
}
+ end:
OPENSSL_free(name);
return 1;
}
if (strcmp(keyword, "Output") == 0)
return parse_bin(value, &kdata->output, &kdata->output_len);
- if (strncmp(keyword, "Ctrl", 4) == 0)
+ if (HAS_PREFIX(keyword, "Ctrl"))
return kdf_test_ctrl(t, kdata->ctx, value);
return 0;
}
KDF_DATA *expected = t->data;
unsigned char *got = NULL;
size_t got_len = expected->output_len;
+ EVP_KDF_CTX *ctx;
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))) {
+ if (!TEST_ptr(got = OPENSSL_malloc(got_len == 0 ? 1 : got_len))) {
t->err = "INTERNAL_ERROR";
goto err;
}
- if (EVP_KDF_derive(expected->ctx, got, got_len) <= 0) {
+ if ((ctx = EVP_KDF_CTX_dup(expected->ctx)) != NULL) {
+ EVP_KDF_CTX_free(expected->ctx);
+ expected->ctx = ctx;
+ }
+ if (EVP_KDF_derive(expected->ctx, got, got_len, NULL) <= 0) {
t->err = "KDF_DERIVE_ERROR";
goto err;
}
if (strcmp(keyword, "Output") == 0)
return parse_bin(value, &kdata->output, &kdata->output_len);
- if (strncmp(keyword, "Ctrl", 4) == 0)
+ if (HAS_PREFIX(keyword, "Ctrl"))
return pkey_test_ctrl(t, kdata->ctx, value);
return 0;
}
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;
OSSL_LIB_CTX_free(libctx);
}
-#define STR_STARTS_WITH(str, pre) strncasecmp(pre, str, strlen(pre)) == 0
-#define STR_ENDS_WITH(str, pre) \
-strlen(str) < strlen(pre) ? 0 : (strcasecmp(pre, str + strlen(str) - strlen(pre)) == 0)
-
static int is_digest_disabled(const char *name)
{
#ifdef OPENSSL_NO_BLAKE2
- if (STR_STARTS_WITH(name, "BLAKE"))
+ if (HAS_CASE_PREFIX(name, "BLAKE"))
return 1;
#endif
#ifdef OPENSSL_NO_MD2
static int is_pkey_disabled(const char *name)
{
#ifdef OPENSSL_NO_EC
- if (STR_STARTS_WITH(name, "EC"))
+ if (HAS_CASE_PREFIX(name, "EC"))
return 1;
#endif
#ifdef OPENSSL_NO_DH
- if (STR_STARTS_WITH(name, "DH"))
+ if (HAS_CASE_PREFIX(name, "DH"))
return 1;
#endif
#ifdef OPENSSL_NO_DSA
- if (STR_STARTS_WITH(name, "DSA"))
+ if (HAS_CASE_PREFIX(name, "DSA"))
return 1;
#endif
return 0;
static int is_mac_disabled(const char *name)
{
#ifdef OPENSSL_NO_BLAKE2
- if (STR_STARTS_WITH(name, "BLAKE2BMAC")
- || STR_STARTS_WITH(name, "BLAKE2SMAC"))
+ if (HAS_CASE_PREFIX(name, "BLAKE2BMAC")
+ || HAS_CASE_PREFIX(name, "BLAKE2SMAC"))
return 1;
#endif
#ifdef OPENSSL_NO_CMAC
- if (STR_STARTS_WITH(name, "CMAC"))
+ if (HAS_CASE_PREFIX(name, "CMAC"))
return 1;
#endif
#ifdef OPENSSL_NO_POLY1305
- if (STR_STARTS_WITH(name, "Poly1305"))
+ if (HAS_CASE_PREFIX(name, "Poly1305"))
return 1;
#endif
#ifdef OPENSSL_NO_SIPHASH
- if (STR_STARTS_WITH(name, "SipHash"))
+ if (HAS_CASE_PREFIX(name, "SipHash"))
return 1;
#endif
return 0;
static int is_kdf_disabled(const char *name)
{
#ifdef OPENSSL_NO_SCRYPT
- if (STR_ENDS_WITH(name, "SCRYPT"))
+ if (HAS_CASE_SUFFIX(name, "SCRYPT"))
return 1;
#endif
return 0;
static int is_cipher_disabled(const char *name)
{
#ifdef OPENSSL_NO_ARIA
- if (STR_STARTS_WITH(name, "ARIA"))
+ if (HAS_CASE_PREFIX(name, "ARIA"))
return 1;
#endif
#ifdef OPENSSL_NO_BF
- if (STR_STARTS_WITH(name, "BF"))
+ if (HAS_CASE_PREFIX(name, "BF"))
return 1;
#endif
#ifdef OPENSSL_NO_CAMELLIA
- if (STR_STARTS_WITH(name, "CAMELLIA"))
+ if (HAS_CASE_PREFIX(name, "CAMELLIA"))
return 1;
#endif
#ifdef OPENSSL_NO_CAST
- if (STR_STARTS_WITH(name, "CAST"))
+ if (HAS_CASE_PREFIX(name, "CAST"))
return 1;
#endif
#ifdef OPENSSL_NO_CHACHA
- if (STR_STARTS_WITH(name, "CHACHA"))
+ if (HAS_CASE_PREFIX(name, "CHACHA"))
return 1;
#endif
#ifdef OPENSSL_NO_POLY1305
- if (STR_ENDS_WITH(name, "Poly1305"))
+ if (HAS_CASE_SUFFIX(name, "Poly1305"))
return 1;
#endif
#ifdef OPENSSL_NO_DES
- if (STR_STARTS_WITH(name, "DES"))
+ if (HAS_CASE_PREFIX(name, "DES"))
return 1;
- if (STR_ENDS_WITH(name, "3DESwrap"))
+ if (HAS_CASE_SUFFIX(name, "3DESwrap"))
return 1;
#endif
#ifdef OPENSSL_NO_OCB
- if (STR_ENDS_WITH(name, "OCB"))
+ if (HAS_CASE_SUFFIX(name, "OCB"))
return 1;
#endif
#ifdef OPENSSL_NO_IDEA
- if (STR_STARTS_WITH(name, "IDEA"))
+ if (HAS_CASE_PREFIX(name, "IDEA"))
return 1;
#endif
#ifdef OPENSSL_NO_RC2
- if (STR_STARTS_WITH(name, "RC2"))
+ if (HAS_CASE_PREFIX(name, "RC2"))
return 1;
#endif
#ifdef OPENSSL_NO_RC4
- if (STR_STARTS_WITH(name, "RC4"))
+ if (HAS_CASE_PREFIX(name, "RC4"))
return 1;
#endif
#ifdef OPENSSL_NO_RC5
- if (STR_STARTS_WITH(name, "RC5"))
+ if (HAS_CASE_PREFIX(name, "RC5"))
return 1;
#endif
#ifdef OPENSSL_NO_SEED
- if (STR_STARTS_WITH(name, "SEED"))
+ if (HAS_CASE_PREFIX(name, "SEED"))
return 1;
#endif
#ifdef OPENSSL_NO_SIV
- if (STR_ENDS_WITH(name, "SIV"))
+ if (HAS_CASE_SUFFIX(name, "SIV"))
return 1;
#endif
#ifdef OPENSSL_NO_SM4
- if (STR_STARTS_WITH(name, "SM4"))
+ if (HAS_CASE_PREFIX(name, "SM4"))
return 1;
#endif
return 0;
projects / openssl.git / blobdiff