public/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
openssl/test/slh_dsa_test.c
Andrew Dinh ecc174065a Update slh_dsa_test.c 
Reviewed-by: Saša Nedvědický <sashan@openssl.org>
Reviewed-by: Neil Horman <nhorman@openssl.org>
Reviewed-by: Tim Hudson <tjh@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/26916)
2025-02-27 10:23:38 -05:00

667 lines
24 KiB
C
Raw Permalink Blame History

/*
* Copyright 2024-2025 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
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#include <openssl/core_names.h>
#include <openssl/evp.h>
#include <openssl/param_build.h>
#include <openssl/rand.h>
#include <openssl/pem.h>
#include "crypto/slh_dsa.h"
#include "internal/nelem.h"
#include "testutil.h"
#include "slh_dsa.inc"
typedef enum OPTION_choice {
OPT_ERR = -1,
OPT_EOF = 0,
OPT_CONFIG_FILE,
OPT_TEST_ENUM
} OPTION_CHOICE;
static OSSL_LIB_CTX *lib_ctx = NULL;
static OSSL_PROVIDER *null_prov = NULL;
static OSSL_PROVIDER *lib_prov = NULL;
static EVP_PKEY *slh_dsa_key_from_data(const char *alg,
const unsigned char *data, size_t datalen,
int public)
{
int ret;
EVP_PKEY_CTX *ctx = NULL;
EVP_PKEY *key = NULL;
OSSL_PARAM params[2];
const char *keytype = public ? OSSL_PKEY_PARAM_PUB_KEY : OSSL_PKEY_PARAM_PRIV_KEY;
int selection = public ? EVP_PKEY_PUBLIC_KEY : EVP_PKEY_KEYPAIR;
params[0] = OSSL_PARAM_construct_octet_string(keytype, (uint8_t *)data, datalen);
params[1] = OSSL_PARAM_construct_end();
ret = TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(lib_ctx, alg, NULL))
&& TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
&& (EVP_PKEY_fromdata(ctx, &key, selection, params) == 1);
if (ret == 0) {
EVP_PKEY_free(key);
key = NULL;
}
EVP_PKEY_CTX_free(ctx);
return key;
}
static int slh_dsa_create_keypair(EVP_PKEY **pkey, const char *name,
const uint8_t *priv, size_t priv_len,
const uint8_t *pub, size_t pub_len)
{
int ret = 0;
EVP_PKEY_CTX *ctx = NULL;
OSSL_PARAM_BLD *bld = NULL;
OSSL_PARAM *params = NULL;
const char *pub_name = OSSL_PKEY_PARAM_PUB_KEY;
if (!TEST_ptr(bld = OSSL_PARAM_BLD_new())
|| !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
OSSL_PKEY_PARAM_PRIV_KEY,
priv, priv_len) > 0)
|| !TEST_true(OSSL_PARAM_BLD_push_octet_string(bld,
pub_name,
pub, pub_len) > 0)
|| !TEST_ptr(params = OSSL_PARAM_BLD_to_param(bld))
|| !TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(lib_ctx, name, NULL))
|| !TEST_int_eq(EVP_PKEY_fromdata_init(ctx), 1)
|| !TEST_int_eq(EVP_PKEY_fromdata(ctx, pkey, EVP_PKEY_KEYPAIR,
params), 1))
goto err;
ret = 1;
err:
OSSL_PARAM_free(params);
OSSL_PARAM_BLD_free(bld);
EVP_PKEY_CTX_free(ctx);
return ret;
}
static int slh_dsa_bad_pub_len_test(void)
{
int ret = 0;
SLH_DSA_SIG_TEST_DATA *td = &slh_dsa_sig_testdata[0];
EVP_PKEY *pkey = NULL;
size_t pub_len = 0;
unsigned char pubdata[64 + 1];
if (!TEST_size_t_le(td->pub_len, sizeof(pubdata)))
goto end;
OPENSSL_cleanse(pubdata, sizeof(pubdata));
memcpy(pubdata, td->pub, td->pub_len);
if (!TEST_ptr_null(pkey = slh_dsa_key_from_data(td->alg, pubdata,
td->pub_len - 1, 1))
|| !TEST_ptr_null(pkey = slh_dsa_key_from_data(td->alg, pubdata,
td->pub_len + 1, 1)))
goto end;
ret = 1;
end:
if (ret == 0)
TEST_note("Incorrectly accepted public key of length %u (expected %u)",
(unsigned)pub_len, (unsigned)td->pub_len);
EVP_PKEY_free(pkey);
return ret == 1;
}
static int slh_dsa_key_eq_test(void)
{
int ret = 0;
size_t i;
EVP_PKEY *key[4] = { NULL, NULL, NULL, NULL };
SLH_DSA_SIG_TEST_DATA *td1 = &slh_dsa_sig_testdata[0];
SLH_DSA_SIG_TEST_DATA *td2 = &slh_dsa_sig_testdata[1];
#ifndef OPENSSL_NO_EC
EVP_PKEY *eckey = NULL;
#endif
if (!TEST_ptr(key[0] = slh_dsa_key_from_data(td1->alg, td1->pub, td1->pub_len, 1))
|| !TEST_ptr(key[1] = slh_dsa_key_from_data(td1->alg, td1->pub, td1->pub_len, 1))
|| !TEST_ptr(key[2] = slh_dsa_key_from_data(td2->alg, td2->pub, td2->pub_len, 1))
|| !TEST_ptr(key[3] = EVP_PKEY_dup(key[0])))
goto end;
if (!TEST_int_eq(EVP_PKEY_eq(key[0], key[1]), 1)
|| !TEST_int_ne(EVP_PKEY_eq(key[0], key[2]), 1)
|| !TEST_int_eq(EVP_PKEY_eq(key[0], key[3]), 1))
goto end;
#ifndef OPENSSL_NO_EC
if (!TEST_ptr(eckey = EVP_PKEY_Q_keygen(lib_ctx, NULL, "EC", "P-256")))
goto end;
ret = TEST_int_ne(EVP_PKEY_eq(key[0], eckey), 1);
EVP_PKEY_free(eckey);
#else
ret = 1;
#endif
end:
for (i = 0; i < OSSL_NELEM(key); ++i)
EVP_PKEY_free(key[i]);
return ret;
}
static int slh_dsa_key_validate_test(void)
{
int ret = 0;
SLH_DSA_SIG_TEST_DATA *td = &slh_dsa_sig_testdata[0];
EVP_PKEY_CTX *vctx = NULL;
EVP_PKEY *key = NULL;
if (!TEST_ptr(key = slh_dsa_key_from_data(td->alg, td->pub, td->pub_len, 1)))
return 0;
if (!TEST_ptr(vctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, key, NULL)))
goto end;
if (!TEST_int_eq(EVP_PKEY_public_check(vctx), 1))
goto end;
if (!TEST_int_eq(EVP_PKEY_private_check(vctx), 0))
goto end;
if (!TEST_int_eq(EVP_PKEY_pairwise_check(vctx), 0))
goto end;
ret = 1;
end:
EVP_PKEY_CTX_free(vctx);
EVP_PKEY_free(key);
return ret;
}
static int slh_dsa_key_validate_failure_test(void)
{
int ret = 0;
EVP_PKEY_CTX *vctx = NULL;
EVP_PKEY *key = NULL;
/*
* Loading 128s private key data into a 128f algorithm will have an incorrect
* public key.
*/
if (!TEST_ptr(key = slh_dsa_key_from_data("SLH-DSA-SHA2-128f",
slh_dsa_sha2_128s_0_keygen_priv,
sizeof(slh_dsa_sha2_128s_0_keygen_priv), 0)))
return 0;
if (!TEST_ptr(vctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, key, NULL)))
goto end;
if (!TEST_int_eq(EVP_PKEY_pairwise_check(vctx), 0))
goto end;
ret = 1;
end:
EVP_PKEY_CTX_free(vctx);
EVP_PKEY_free(key);
return ret;
}
/*
* Rather than having to store the full signature into a file, we just do a
* verify using the output of a sign. The sign test already does a Known answer
* test (KAT) using the digest of the signature, so this should be sufficient to
* run as a KAT for the verify.
*/
static int do_slh_dsa_verify(const SLH_DSA_SIG_TEST_DATA *td,
uint8_t *sig, size_t sig_len)
{
int ret = 0;
EVP_PKEY_CTX *vctx = NULL;
EVP_PKEY *key = NULL;
EVP_SIGNATURE *sig_alg = NULL;
OSSL_PARAM params[2], *p = params;
int encode = 0;
*p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, &encode);
*p = OSSL_PARAM_construct_end();
if (!TEST_ptr(key = slh_dsa_key_from_data(td->alg, td->pub, td->pub_len, 1)))
return 0;
if (!TEST_ptr(vctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, key, NULL)))
goto err;
if (!TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(lib_ctx, td->alg, NULL)))
goto err;
if (!TEST_int_eq(EVP_PKEY_verify_message_init(vctx, sig_alg, params), 1)
|| !TEST_int_eq(EVP_PKEY_verify(vctx, sig, sig_len,
td->msg, td->msg_len), 1))
goto err;
ret = 1;
err:
EVP_SIGNATURE_free(sig_alg);
EVP_PKEY_free(key);
EVP_PKEY_CTX_free(vctx);
return ret;
}
static int slh_dsa_sign_verify_test(int tst_id)
{
int ret = 0;
SLH_DSA_SIG_TEST_DATA *td = &slh_dsa_sig_testdata[tst_id];
EVP_PKEY_CTX *sctx = NULL;
EVP_PKEY *pkey = NULL;
EVP_SIGNATURE *sig_alg = NULL;
OSSL_PARAM params[4], *p = params;
uint8_t *psig = NULL;
size_t psig_len = 0, sig_len2 = 0;
uint8_t digest[32];
size_t digest_len = sizeof(digest);
int encode = 0, deterministic = 1;
*p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, &deterministic);
*p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, &encode);
if (td->add_random != NULL)
*p++ = OSSL_PARAM_construct_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY,
(char *)td->add_random,
td->add_random_len);
*p = OSSL_PARAM_construct_end();
/*
* This just uses from data here, but keygen also works.
* The keygen path is tested via slh_dsa_keygen_test
*/
if (!slh_dsa_create_keypair(&pkey, td->alg, td->priv, td->priv_len,
td->pub, td->pub_len))
goto err;
if (!TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, pkey, NULL)))
goto err;
if (!TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(lib_ctx, td->alg, NULL)))
goto err;
if (!TEST_int_eq(EVP_PKEY_sign_message_init(sctx, sig_alg, params), 1)
|| !TEST_int_eq(EVP_PKEY_sign(sctx, NULL, &psig_len,
td->msg, td->msg_len), 1)
|| !TEST_true(EVP_PKEY_get_size_t_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len2))
|| !TEST_int_eq(sig_len2, psig_len)
|| !TEST_ptr(psig = OPENSSL_zalloc(psig_len))
|| !TEST_int_eq(EVP_PKEY_sign(sctx, psig, &psig_len,
td->msg, td->msg_len), 1))
goto err;
if (!TEST_int_eq(EVP_Q_digest(lib_ctx, "SHA256", NULL, psig, psig_len,
digest, &digest_len), 1))
goto err;
if (!TEST_mem_eq(digest, digest_len, td->sig_digest, td->sig_digest_len))
goto err;
if (!do_slh_dsa_verify(td, psig, psig_len))
goto err;
ret = 1;
err:
EVP_SIGNATURE_free(sig_alg);
EVP_PKEY_free(pkey);
EVP_PKEY_CTX_free(sctx);
OPENSSL_free(psig);
return ret;
}
static EVP_PKEY *do_gen_key(const char *alg,
const uint8_t *seed, size_t seed_len)
{
EVP_PKEY *pkey = NULL;
EVP_PKEY_CTX *ctx = NULL;
OSSL_PARAM params[2], *p = params;
if (seed_len != 0)
*p++ = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED,
(char *)seed, seed_len);
*p = OSSL_PARAM_construct_end();
if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(lib_ctx, alg, NULL))
|| !TEST_int_eq(EVP_PKEY_keygen_init(ctx), 1)
|| !TEST_int_eq(EVP_PKEY_CTX_set_params(ctx, params), 1)
|| !TEST_int_eq(EVP_PKEY_generate(ctx, &pkey), 1))
pkey = NULL;
EVP_PKEY_CTX_free(ctx);
return pkey;
}
static int slh_dsa_keygen_test(int tst_id)
{
int ret = 0;
const SLH_DSA_KEYGEN_TEST_DATA *tst = &slh_dsa_keygen_testdata[tst_id];
EVP_PKEY *pkey = NULL;
uint8_t priv[64 * 2], pub[32 * 2];
size_t priv_len, pub_len;
size_t key_len = tst->priv_len;
size_t n = key_len / 4;
int bits = 0, sec_bits = 0, sig_len = 0;
if (!TEST_ptr(pkey = do_gen_key(tst->name, tst->priv, key_len - n)))
goto err;
if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey, OSSL_PKEY_PARAM_PRIV_KEY,
priv, sizeof(priv), &priv_len)))
goto err;
if (!TEST_true(EVP_PKEY_get_octet_string_param(pkey, OSSL_PKEY_PARAM_PUB_KEY,
pub, sizeof(pub), &pub_len)))
goto err;
if (!TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_BITS, &bits))
|| !TEST_int_eq(bits, 8 * 2 * n)
|| !TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_SECURITY_BITS,
&sec_bits))
|| !TEST_int_eq(sec_bits, 8 * n)
|| !TEST_true(EVP_PKEY_get_int_param(pkey, OSSL_PKEY_PARAM_MAX_SIZE,
&sig_len))
|| !TEST_int_ge(sig_len, 7856)
|| !TEST_int_le(sig_len, 49856))
goto err;
if (!TEST_size_t_eq(priv_len, key_len)
|| !TEST_size_t_eq(pub_len, key_len / 2))
goto err;
if (!TEST_mem_eq(pub, pub_len, tst->priv + 2 * n, 2 * n))
goto err;
ret = 1;
err:
EVP_PKEY_free(pkey);
return ret;
}
static int slh_dsa_usage_test(void)
{
int ret = 0;
EVP_CIPHER *cipher = NULL; /* Used to encrypt the private key */
char *pass = "Password";
BIO *pub_bio = NULL, *priv_bio = NULL;
EVP_PKEY_CTX *gctx = NULL, *sctx = NULL, *vctx = NULL;
EVP_PKEY *gkey = NULL, *pub = NULL, *priv = NULL;
EVP_SIGNATURE *sig_alg = NULL;
uint8_t *sig = NULL;
size_t sig_len = 0;
uint8_t msg[] = "Hello World";
size_t msg_len = sizeof(msg) - 1;
/* Generate a key */
if (!TEST_ptr(gctx = EVP_PKEY_CTX_new_from_name(lib_ctx, "SLH-DSA-SHA2-128s", NULL))
|| !TEST_int_eq(EVP_PKEY_keygen_init(gctx), 1)
|| !TEST_int_eq(EVP_PKEY_keygen(gctx, &gkey), 1))
goto err;
/* Save it to a BIO - it uses a mem bio for testing */
if (!TEST_ptr(pub_bio = BIO_new(BIO_s_mem()))
|| !TEST_ptr(priv_bio = BIO_new(BIO_s_mem()))
|| !TEST_ptr(cipher = EVP_CIPHER_fetch(lib_ctx, "AES-256-CBC", NULL))
|| !TEST_true(PEM_write_bio_PUBKEY_ex(pub_bio, gkey, lib_ctx, NULL))
|| !TEST_true(PEM_write_bio_PrivateKey_ex(priv_bio, gkey, cipher,
NULL, 0, NULL, (void *)pass,
lib_ctx, NULL)))
goto err;
/* Read the private key and add to a signing ctx */
if (!TEST_ptr(PEM_read_bio_PrivateKey_ex(priv_bio, &priv, NULL, pass, lib_ctx, NULL))
|| !TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, priv, NULL))
|| !TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(lib_ctx, "SLH-DSA-SHA2-128s", NULL))
|| !TEST_int_eq(EVP_PKEY_sign_message_init(sctx, sig_alg, NULL), 1))
goto err;
/* Determine the size of the signature & allocate space */
if (!TEST_int_eq(EVP_PKEY_sign(sctx, NULL, &sig_len, msg, msg_len), 1)
|| !TEST_ptr(sig = OPENSSL_malloc(sig_len))
|| !TEST_int_eq(EVP_PKEY_sign(sctx, sig, &sig_len, msg, msg_len), 1))
goto err;
if (!TEST_true(EVP_PKEY_pairwise_check(sctx))
|| !TEST_true(EVP_PKEY_public_check(sctx))
|| !TEST_true(EVP_PKEY_private_check(sctx)))
goto err;
/* Read the public key and add to a verify ctx */
if (!TEST_ptr(PEM_read_bio_PUBKEY_ex(pub_bio, &pub, NULL, NULL, lib_ctx, NULL))
|| !TEST_ptr(vctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, pub, NULL)))
goto err;
/* verify the signature */
if (!TEST_int_eq(EVP_PKEY_verify_message_init(vctx, sig_alg, NULL), 1)
|| !TEST_int_eq(EVP_PKEY_verify(vctx, sig, sig_len, msg, msg_len), 1))
goto err;
ret = 1;
err:
EVP_CIPHER_free(cipher);
EVP_SIGNATURE_free(sig_alg);
EVP_PKEY_free(gkey);
EVP_PKEY_free(pub);
EVP_PKEY_free(priv);
EVP_PKEY_CTX_free(gctx);
EVP_PKEY_CTX_free(sctx);
EVP_PKEY_CTX_free(vctx);
BIO_free(pub_bio);
BIO_free(priv_bio);
OPENSSL_free(sig);
return ret;
}
static int slh_dsa_deterministic_usage_test(void)
{
int ret = 0;
EVP_CIPHER *cipher = NULL; /* Used to encrypt the private key */
char *pass = "Password";
BIO *pub_bio = NULL, *priv_bio = NULL;
EVP_PKEY_CTX *gctx = NULL, *sctx = NULL, *vctx = NULL, *dupctx = NULL;
EVP_PKEY *gkey = NULL, *pub = NULL, *priv = NULL;
EVP_SIGNATURE *sig_alg = NULL;
uint8_t *sig = NULL;
size_t sig_len = 0, len = 0;
uint8_t msg[] = { 0x01, 0x02, 0x03, 0x04 };
size_t msg_len = sizeof(msg);
const SLH_DSA_KEYGEN_TEST_DATA *tst = &slh_dsa_keygen_testdata[0];
size_t key_len = tst->priv_len / 2;
size_t n = key_len / 2;
int deterministic = 1;
OSSL_PARAM params[2], *p = params;
/* Generate a key */
if (!TEST_ptr(gkey = do_gen_key(tst->name, tst->priv, key_len + n)))
goto err;
/* Save it to a BIO - it uses a mem bio for testing */
if (!TEST_ptr(pub_bio = BIO_new(BIO_s_mem()))
|| !TEST_ptr(priv_bio = BIO_new(BIO_s_mem()))
|| !TEST_ptr(cipher = EVP_CIPHER_fetch(lib_ctx, "AES-256-CBC", NULL))
|| !TEST_true(PEM_write_bio_PUBKEY_ex(pub_bio, gkey, lib_ctx, NULL))
|| !TEST_true(PEM_write_bio_PrivateKey_ex(priv_bio, gkey, cipher,
NULL, 0, NULL, (void *)pass,
lib_ctx, NULL)))
goto err;
*p++ = OSSL_PARAM_construct_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, &deterministic);
*p = OSSL_PARAM_construct_end();
/* Read the private key and add to a signing ctx */
if (!TEST_ptr(PEM_read_bio_PrivateKey_ex(priv_bio, &priv, NULL, pass, lib_ctx, NULL))
|| !TEST_ptr(sctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, priv, NULL))
/* Init the signature */
|| !TEST_ptr(sig_alg = EVP_SIGNATURE_fetch(lib_ctx, tst->name, NULL))
|| !TEST_int_eq(EVP_PKEY_sign_message_init(sctx, sig_alg, params), 1))
goto err;
if (!TEST_ptr(dupctx = EVP_PKEY_CTX_dup(sctx)))
goto err;
/* Determine the size of the signature & allocate space */
if (!TEST_int_eq(EVP_PKEY_sign(sctx, NULL, &sig_len, msg, msg_len), 1))
goto err;
len = sig_len;
if (!TEST_ptr(sig = OPENSSL_zalloc(sig_len * 2))
|| !TEST_int_eq(EVP_PKEY_sign(sctx, sig, &len, msg, msg_len), 1)
|| !TEST_size_t_eq(sig_len, len)
|| !TEST_int_eq(EVP_PKEY_sign(dupctx, sig + sig_len, &len,
msg, msg_len), 1)
|| !TEST_size_t_eq(sig_len, len))
goto err;
/* Read the public key and add to a verify ctx */
if (!TEST_ptr(PEM_read_bio_PUBKEY_ex(pub_bio, &pub, NULL, NULL, lib_ctx, NULL))
|| !TEST_ptr(vctx = EVP_PKEY_CTX_new_from_pkey(lib_ctx, pub, NULL)))
goto err;
EVP_PKEY_CTX_free(dupctx);
/* verify the signature */
if (!TEST_int_eq(EVP_PKEY_verify_message_init(vctx, sig_alg, NULL), 1)
|| !TEST_ptr(dupctx = EVP_PKEY_CTX_dup(vctx))
|| !TEST_int_eq(EVP_PKEY_verify(vctx, sig, sig_len, msg, msg_len), 1)
|| !TEST_int_eq(EVP_PKEY_verify(dupctx, sig + sig_len, sig_len,
msg, msg_len), 1))
goto err;
ret = 1;
err:
EVP_CIPHER_free(cipher);
EVP_SIGNATURE_free(sig_alg);
EVP_PKEY_free(gkey);
EVP_PKEY_free(pub);
EVP_PKEY_free(priv);
EVP_PKEY_CTX_free(gctx);
EVP_PKEY_CTX_free(sctx);
EVP_PKEY_CTX_free(vctx);
EVP_PKEY_CTX_free(dupctx);
BIO_free(pub_bio);
BIO_free(priv_bio);
OPENSSL_free(sig);
return ret;
}
static int slh_dsa_digest_sign_verify_test(void)
{
int ret = 0;
EVP_PKEY *key = NULL;
uint8_t *sig = NULL;
size_t sig_len = 0;
OSSL_PARAM params[3], *p = params;
const char *alg = "SLH-DSA-SHA2-128s";
EVP_MD_CTX *mctx = NULL;
static uint8_t context[] = "A context String";
static uint8_t msg[] = "Hello World";
size_t msg_len = sizeof(msg);
if (!TEST_ptr(key = do_gen_key(alg, NULL, 0)))
goto err;
*p++ = OSSL_PARAM_construct_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING,
context, sizeof(context));
*p++ = OSSL_PARAM_construct_end();
if (!TEST_ptr(mctx = EVP_MD_CTX_new())
|| !TEST_int_eq(EVP_DigestSignInit_ex(mctx, NULL, "SHA256",
lib_ctx, "?fips=true",
key, params), 0)
|| !TEST_int_eq(EVP_DigestSignInit_ex(mctx, NULL, NULL, lib_ctx,
"?fips=true", key, params), 1))
goto err;
if (!TEST_int_eq(EVP_DigestSign(mctx, NULL, &sig_len, msg, msg_len), 1)
|| !TEST_ptr(sig = OPENSSL_zalloc(sig_len)))
goto err;
sig_len--;
if (!TEST_int_eq(EVP_DigestSign(mctx, sig, &sig_len, msg, msg_len), 0))
goto err;
sig_len++;
if (!TEST_int_eq(EVP_DigestSignInit_ex(mctx, NULL, NULL, lib_ctx, "?fips=true",
key, params), 1)
|| !TEST_int_eq(EVP_DigestSign(mctx, sig, &sig_len, msg, msg_len), 1)
|| !TEST_int_eq(EVP_DigestVerifyInit_ex(mctx, NULL, "SHA256",
lib_ctx, "?fips=true",
key, params), 0)
|| !TEST_int_eq(EVP_DigestVerifyInit_ex(mctx, NULL, NULL,
lib_ctx, "?fips=true",
key, params), 1)
|| !TEST_int_eq(EVP_DigestVerify(mctx, sig, sig_len, msg, msg_len), 1))
goto err;
ret = 1;
err:
EVP_PKEY_free(key);
EVP_MD_CTX_free(mctx);
OPENSSL_free(sig);
return ret;
}
static int slh_dsa_keygen_invalid_test(void)
{
int ret = 0;
const SLH_DSA_KEYGEN_TEST_DATA *tst = &slh_dsa_keygen_testdata[0];
EVP_PKEY *pkey = NULL;
EVP_PKEY_CTX *ctx = NULL;
OSSL_PARAM params[2], *p = params;
size_t key_len = tst->priv_len;
size_t n = key_len / 4;
uint8_t seed[128] = {0};
if (!TEST_ptr(ctx = EVP_PKEY_CTX_new_from_name(lib_ctx, tst->name, NULL))
|| !TEST_int_eq(EVP_PKEY_keygen_init(ctx), 1))
goto err;
/* Test the set fails if the seed is larger than the internal buffer */
p[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED,
seed, 97);
p[1] = OSSL_PARAM_construct_end();
if (!TEST_int_eq(EVP_PKEY_CTX_set_params(ctx, params), 0))
goto err;
/* Test the generate fails if the seed is not the correct size */
p[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED,
seed, n * 3 - 1);
p[1] = OSSL_PARAM_construct_end();
if (!TEST_int_eq(EVP_PKEY_CTX_set_params(ctx, params), 1)
|| !TEST_int_eq(EVP_PKEY_generate(ctx, &pkey), 0))
goto err;
/* Test the generate fails if the seed is not the correct size */
p[0] = OSSL_PARAM_construct_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED,
seed, n * 3 + 1);
p[1] = OSSL_PARAM_construct_end();
if (!TEST_int_eq(EVP_PKEY_CTX_set_params(ctx, params), 1)
|| !TEST_int_eq(EVP_PKEY_generate(ctx, &pkey), 0))
goto err;
ret = 1;
err:
EVP_PKEY_free(pkey);
EVP_PKEY_CTX_free(ctx);
return ret;
}
const OPTIONS *test_get_options(void)
{
static const OPTIONS options[] = {
OPT_TEST_OPTIONS_DEFAULT_USAGE,
{ "config", OPT_CONFIG_FILE, '<',
"The configuration file to use for the libctx" },
{ NULL }
};
return options;
}
int setup_tests(void)
{
OPTION_CHOICE o;
char *config_file = NULL;
while ((o = opt_next()) != OPT_EOF) {
switch (o) {
case OPT_CONFIG_FILE:
config_file = opt_arg();
break;
case OPT_TEST_CASES:
break;
default:
case OPT_ERR:
return 0;
}
}
if (!test_get_libctx(&lib_ctx, &null_prov, config_file, &lib_prov, NULL))
return 0;
ADD_TEST(slh_dsa_bad_pub_len_test);
ADD_TEST(slh_dsa_key_validate_test);
ADD_TEST(slh_dsa_key_validate_failure_test);
ADD_TEST(slh_dsa_key_eq_test);
ADD_TEST(slh_dsa_usage_test);
ADD_TEST(slh_dsa_deterministic_usage_test);
ADD_ALL_TESTS(slh_dsa_sign_verify_test, OSSL_NELEM(slh_dsa_sig_testdata));
ADD_ALL_TESTS(slh_dsa_keygen_test, OSSL_NELEM(slh_dsa_keygen_testdata));
ADD_TEST(slh_dsa_digest_sign_verify_test);
ADD_TEST(slh_dsa_keygen_invalid_test);
return 1;
}
void cleanup_tests(void)
{
OSSL_PROVIDER_unload(null_prov);
OSSL_PROVIDER_unload(lib_prov);
OSSL_LIB_CTX_free(lib_ctx);
}
Reference in a new issue View git blame Copy permalink