/src/openssl/providers/implementations/signature/slh_dsa_sig.c

Source (jump to first uncovered line)
/*
 * 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/err.h>
#include <openssl/rand.h>
#include <openssl/proverr.h>
#include "prov/implementations.h"
#include "prov/providercommon.h"
#include "prov/provider_ctx.h"
#include "prov/der_slh_dsa.h"
#include "crypto/slh_dsa.h"
#include "internal/cryptlib.h"
#include "internal/sizes.h"

#define SLH_DSA_MAX_ADD_RANDOM_LEN 32

#define SLH_DSA_MESSAGE_ENCODE_RAW  0
#define SLH_DSA_MESSAGE_ENCODE_PURE 1

static OSSL_FUNC_signature_sign_message_init_fn slh_dsa_sign_msg_init;
static OSSL_FUNC_signature_sign_fn slh_dsa_sign;
static OSSL_FUNC_signature_verify_message_init_fn slh_dsa_verify_msg_init;
static OSSL_FUNC_signature_verify_fn slh_dsa_verify;
static OSSL_FUNC_signature_digest_sign_init_fn slh_dsa_digest_signverify_init;
static OSSL_FUNC_signature_digest_sign_fn slh_dsa_digest_sign;
static OSSL_FUNC_signature_digest_verify_fn slh_dsa_digest_verify;
static OSSL_FUNC_signature_freectx_fn slh_dsa_freectx;
static OSSL_FUNC_signature_dupctx_fn slh_dsa_dupctx;
static OSSL_FUNC_signature_set_ctx_params_fn slh_dsa_set_ctx_params;
static OSSL_FUNC_signature_settable_ctx_params_fn slh_dsa_settable_ctx_params;

/*
 * NOTE: Any changes to this structure may require updating slh_dsa_dupctx().
 */
typedef struct {
    SLH_DSA_KEY *key; /* Note that the key is not owned by this object */
    SLH_DSA_HASH_CTX *hash_ctx;
    uint8_t context_string[SLH_DSA_MAX_CONTEXT_STRING_LEN];
    size_t context_string_len;
    uint8_t add_random[SLH_DSA_MAX_ADD_RANDOM_LEN];
    size_t add_random_len;
    int msg_encode;
    int deterministic;
    OSSL_LIB_CTX *libctx;
    char *propq;
    const char *alg;
    /* The Algorithm Identifier of the signature algorithm */
    uint8_t aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE];
    size_t  aid_len;
} PROV_SLH_DSA_CTX;

static void slh_dsa_freectx(void *vctx)
{
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;

    ossl_slh_dsa_hash_ctx_free(ctx->hash_ctx);
    OPENSSL_free(ctx->propq);
    OPENSSL_cleanse(ctx->add_random, ctx->add_random_len);
    OPENSSL_free(ctx);
}

static void *slh_dsa_newctx(void *provctx, const char *alg, const char *propq)
{
    PROV_SLH_DSA_CTX *ctx;

    if (!ossl_prov_is_running())
        return NULL;

    ctx = OPENSSL_zalloc(sizeof(PROV_SLH_DSA_CTX));
    if (ctx == NULL)
        return NULL;

    ctx->libctx = PROV_LIBCTX_OF(provctx);
    if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)
        goto err;
    ctx->alg = alg;
    ctx->msg_encode = SLH_DSA_MESSAGE_ENCODE_PURE;
    return ctx;
 err:
    slh_dsa_freectx(ctx);
    return NULL;
}

static void *slh_dsa_dupctx(void *vctx)
{
    PROV_SLH_DSA_CTX *src = (PROV_SLH_DSA_CTX *)vctx;
    PROV_SLH_DSA_CTX *ret;

    if (!ossl_prov_is_running())
        return NULL;

    /*
     * Note that the SLH_DSA_KEY is ref counted via EVP_PKEY so we can just copy
     * the key here.
     */
    ret = OPENSSL_memdup(src, sizeof(*src));
    if (ret == NULL)
        return NULL;
    ret->propq = NULL;
    ret->hash_ctx = NULL;
    if (src->propq != NULL && (ret->propq = OPENSSL_strdup(src->propq)) == NULL)
        goto err;
    ret->hash_ctx = ossl_slh_dsa_hash_ctx_dup(src->hash_ctx);
    if (ret->hash_ctx == NULL)
        goto err;

    return ret;
 err:
    slh_dsa_freectx(ret);
    return NULL;
}

static int slh_dsa_set_alg_id_buffer(PROV_SLH_DSA_CTX *ctx)
{
    int ret;
    WPACKET pkt;
    uint8_t *aid = NULL;

    /*
     * We do not care about DER writing errors.
     * All it really means is that for some reason, there's no
     * AlgorithmIdentifier to be had, but the operation itself is
     * still valid, just as long as it's not used to construct
     * anything that needs an AlgorithmIdentifier.
     */
    ctx->aid_len = 0;
    ret = WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf));
    ret = ret && ossl_DER_w_algorithmIdentifier_SLH_DSA(&pkt, -1, ctx->key);
    if (ret && WPACKET_finish(&pkt)) {
        WPACKET_get_total_written(&pkt, &ctx->aid_len);
        aid = WPACKET_get_curr(&pkt);
    }
    WPACKET_cleanup(&pkt);
    if (aid != NULL && ctx->aid_len != 0)
        memmove(ctx->aid_buf, aid, ctx->aid_len);
    return 1;
}

static int slh_dsa_signverify_msg_init(void *vctx, void *vkey,
                                       const OSSL_PARAM params[], int operation,
                                       const char *desc)
{
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;
    SLH_DSA_KEY *key = vkey;

    if (!ossl_prov_is_running()
            || ctx == NULL)
        return 0;

    if (vkey == NULL && ctx->key == NULL) {
        ERR_raise(ERR_LIB_PROV, PROV_R_NO_KEY_SET);
        return 0;
    }

    if (key != NULL) {
        if (!ossl_slh_dsa_key_type_matches(key, ctx->alg))
            return 0;
        ctx->hash_ctx = ossl_slh_dsa_hash_ctx_new(key);
        if (ctx->hash_ctx == NULL)
            return 0;
        ctx->key = vkey;
    }

    slh_dsa_set_alg_id_buffer(ctx);
    if (!slh_dsa_set_ctx_params(ctx, params))
        return 0;
    return 1;
}

static int slh_dsa_sign_msg_init(void *vctx, void *vkey, const OSSL_PARAM params[])
{
    return slh_dsa_signverify_msg_init(vctx, vkey, params,
                                       EVP_PKEY_OP_SIGN, "SLH_DSA Sign Init");
}

static int slh_dsa_digest_signverify_init(void *vctx, const char *mdname,
                                          void *vkey, const OSSL_PARAM params[])
{
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;

    if (mdname != NULL && mdname[0] != '\0') {
        ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
                       "Explicit digest not supported for SLH-DSA operations");
        return 0;
    }

    if (vkey == NULL && ctx->key != NULL)
        return slh_dsa_set_ctx_params(ctx, params);

    return slh_dsa_signverify_msg_init(vctx, vkey, params,
                                       EVP_PKEY_OP_SIGN, "SLH_DSA Sign Init");
}

static int slh_dsa_sign(void *vctx, unsigned char *sig, size_t *siglen,
                        size_t sigsize, const unsigned char *msg, size_t msg_len)
{
    int ret = 0;
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;
    uint8_t add_rand[SLH_DSA_MAX_ADD_RANDOM_LEN], *opt_rand = NULL;
    size_t n = 0;

    if (!ossl_prov_is_running())
        return 0;

    if (sig != NULL) {
        if (ctx->add_random_len != 0) {
            opt_rand = ctx->add_random;
        } else if (ctx->deterministic == 0) {
            n = ossl_slh_dsa_key_get_n(ctx->key);
            if (RAND_priv_bytes_ex(ctx->libctx, add_rand, n, 0) <= 0)
                return 0;
            opt_rand = add_rand;
        }
    }
    ret = ossl_slh_dsa_sign(ctx->hash_ctx, msg, msg_len,
                            ctx->context_string, ctx->context_string_len,
                            opt_rand, ctx->msg_encode,
                            sig, siglen, sigsize);
    if (opt_rand != add_rand)
        OPENSSL_cleanse(opt_rand, n);
    return ret;
}

static int slh_dsa_digest_sign(void *vctx, uint8_t *sig, size_t *siglen, size_t sigsize,
                               const uint8_t *tbs, size_t tbslen)
{
    return slh_dsa_sign(vctx, sig, siglen, sigsize, tbs, tbslen);
}

static int slh_dsa_verify_msg_init(void *vctx, void *vkey, const OSSL_PARAM params[])
{
    return slh_dsa_signverify_msg_init(vctx, vkey, params, EVP_PKEY_OP_VERIFY,
                                       "SLH_DSA Verify Init");
}

static int slh_dsa_verify(void *vctx, const uint8_t *sig, size_t siglen,
                          const uint8_t *msg, size_t msg_len)
{
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;
    return ossl_slh_dsa_verify(ctx->hash_ctx, msg, msg_len,
                               ctx->context_string, ctx->context_string_len,
                               ctx->msg_encode, sig, siglen);
}
static int slh_dsa_digest_verify(void *vctx, const uint8_t *sig, size_t siglen,
                                 const uint8_t *tbs, size_t tbslen)
{
    return slh_dsa_verify(vctx, sig, siglen, tbs, tbslen);
}

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef slh_dsa_set_ctx_params_list
static const OSSL_PARAM slh_dsa_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef slh_dsa_set_ctx_params_st
struct slh_dsa_set_ctx_params_st {
    OSSL_PARAM *context;
    OSSL_PARAM *det;
    OSSL_PARAM *entropy;
    OSSL_PARAM *msgenc;
};
#endif

#ifndef slh_dsa_set_ctx_params_decoder
static int slh_dsa_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct slh_dsa_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'c':
                if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
                    /* SIGNATURE_PARAM_CONTEXT_STRING */
                    if (ossl_unlikely(r->context != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->context = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
                    /* SIGNATURE_PARAM_DETERMINISTIC */
                    if (ossl_unlikely(r->det != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->det = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("essage-encoding", s + 1) == 0)) {
                    /* SIGNATURE_PARAM_MESSAGE_ENCODING */
                    if (ossl_unlikely(r->msgenc != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->msgenc = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
                    /* SIGNATURE_PARAM_TEST_ENTROPY */
                    if (ossl_unlikely(r->entropy != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->entropy = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

static int slh_dsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_SLH_DSA_CTX *pctx = (PROV_SLH_DSA_CTX *)vctx;
    struct slh_dsa_set_ctx_params_st p;

    if (pctx == NULL || !slh_dsa_set_ctx_params_decoder(params, &p))
        return 0;

    if (p.context != NULL) {
        void *vp = pctx->context_string;

        if (!OSSL_PARAM_get_octet_string(p.context, &vp,
                                         sizeof(pctx->context_string),
                                         &(pctx->context_string_len))) {
            pctx->context_string_len = 0;
            return 0;
        }
    }

    if (p.entropy != NULL) {
        void *vp = pctx->add_random;
        size_t n = ossl_slh_dsa_key_get_n(pctx->key);

        if (!OSSL_PARAM_get_octet_string(p.entropy, &vp, n, &(pctx->add_random_len))
                || pctx->add_random_len != n) {
            pctx->add_random_len = 0;
            return 0;
        }
    }

    if (p.det != NULL && !OSSL_PARAM_get_int(p.det, &pctx->deterministic))
        return 0;

    if (p.msgenc != NULL && !OSSL_PARAM_get_int(p.msgenc, &pctx->msg_encode))
        return 0;
    return 1;
}

static const OSSL_PARAM *slh_dsa_settable_ctx_params(void *vctx,
                                                     ossl_unused void *provctx)
{
    return slh_dsa_set_ctx_params_list;
}

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef slh_dsa_get_ctx_params_list
static const OSSL_PARAM slh_dsa_get_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef slh_dsa_get_ctx_params_st
struct slh_dsa_get_ctx_params_st {
    OSSL_PARAM *algid;
};
#endif

#ifndef slh_dsa_get_ctx_params_decoder
static int slh_dsa_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct slh_dsa_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("algorithm-id", s + 0) == 0)) {
                /* SIGNATURE_PARAM_ALGORITHM_ID */
                if (ossl_unlikely(r->algid != NULL)) {
                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                   "param %s is repeated", s);
                    return 0;
                }
                r->algid = (OSSL_PARAM *)p;
            }
    return 1;
}
#endif
/* End of machine generated */

static const OSSL_PARAM *slh_dsa_gettable_ctx_params(ossl_unused void *vctx,
                                                     ossl_unused void *provctx)
{
    return slh_dsa_get_ctx_params_list;
}

static int slh_dsa_get_ctx_params(void *vctx, OSSL_PARAM *params)
{
    PROV_SLH_DSA_CTX *ctx = (PROV_SLH_DSA_CTX *)vctx;
    struct slh_dsa_get_ctx_params_st p;

    if (ctx == NULL || !slh_dsa_get_ctx_params_decoder(params, &p))
        return 0;

    if (p.algid != NULL
        && !OSSL_PARAM_set_octet_string(p.algid,
                                        ctx->aid_len == 0 ? NULL : ctx->aid_buf,
                                        ctx->aid_len))
        return 0;

    return 1;
}

#define MAKE_SIGNATURE_FUNCTIONS(alg, fn)                                      \
    static OSSL_FUNC_signature_newctx_fn slh_dsa_##fn##_newctx;                \
    static void *slh_dsa_##fn##_newctx(void *provctx, const char *propq)       \
    {                                                                          \
        return slh_dsa_newctx(provctx, alg, propq);                            \
    }                                                                          \
    const OSSL_DISPATCH ossl_slh_dsa_##fn##_signature_functions[] = {          \
        { OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))slh_dsa_##fn##_newctx }, \
        { OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_INIT,                               \
          (void (*)(void))slh_dsa_sign_msg_init },                             \
        { OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))slh_dsa_sign },            \
        { OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_INIT,                             \
          (void (*)(void))slh_dsa_verify_msg_init },                           \
        { OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))slh_dsa_verify },        \
        { OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT,                                \
          (void (*)(void))slh_dsa_digest_signverify_init },                    \
        { OSSL_FUNC_SIGNATURE_DIGEST_SIGN,                                     \
          (void (*)(void))slh_dsa_digest_sign },                               \
        { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT,                              \
          (void (*)(void))slh_dsa_digest_signverify_init },                    \
        { OSSL_FUNC_SIGNATURE_DIGEST_VERIFY,                                   \
          (void (*)(void))slh_dsa_digest_verify },                             \
        { OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))slh_dsa_freectx },      \
        { OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))slh_dsa_dupctx },        \
        { OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))slh_dsa_set_ctx_params },\
        { OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS,                             \
          (void (*)(void))slh_dsa_settable_ctx_params },                       \
        { OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS,                                  \
          (void (*)(void))slh_dsa_get_ctx_params },                            \
        { OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS,                             \
          (void (*)(void))slh_dsa_gettable_ctx_params },                       \
        OSSL_DISPATCH_END                                                      \
    }

MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-128s", sha2_128s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-128f", sha2_128f);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-192s", sha2_192s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-192f", sha2_192f);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-256s", sha2_256s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-256f", sha2_256f);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-128s", shake_128s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-128f", shake_128f);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-192s", shake_192s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-192f", shake_192f);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-256s", shake_256s);
MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-256f", shake_256f);

Coverage Report

Created: 2025-08-28 06:41

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2024-2025 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10
11		#include <openssl/core_names.h>
12		#include <openssl/err.h>
13		#include <openssl/rand.h>
14		#include <openssl/proverr.h>
15		#include "prov/implementations.h"
16		#include "prov/providercommon.h"
17		#include "prov/provider_ctx.h"
18		#include "prov/der_slh_dsa.h"
19		#include "crypto/slh_dsa.h"
20		#include "internal/cryptlib.h"
21		#include "internal/sizes.h"
22
23		#define SLH_DSA_MAX_ADD_RANDOM_LEN 32
24
25		#define SLH_DSA_MESSAGE_ENCODE_RAW 0
26	0	#define SLH_DSA_MESSAGE_ENCODE_PURE 1
27
28		static OSSL_FUNC_signature_sign_message_init_fn slh_dsa_sign_msg_init;
29		static OSSL_FUNC_signature_sign_fn slh_dsa_sign;
30		static OSSL_FUNC_signature_verify_message_init_fn slh_dsa_verify_msg_init;
31		static OSSL_FUNC_signature_verify_fn slh_dsa_verify;
32		static OSSL_FUNC_signature_digest_sign_init_fn slh_dsa_digest_signverify_init;
33		static OSSL_FUNC_signature_digest_sign_fn slh_dsa_digest_sign;
34		static OSSL_FUNC_signature_digest_verify_fn slh_dsa_digest_verify;
35		static OSSL_FUNC_signature_freectx_fn slh_dsa_freectx;
36		static OSSL_FUNC_signature_dupctx_fn slh_dsa_dupctx;
37		static OSSL_FUNC_signature_set_ctx_params_fn slh_dsa_set_ctx_params;
38		static OSSL_FUNC_signature_settable_ctx_params_fn slh_dsa_settable_ctx_params;
39
40		/*
41		* NOTE: Any changes to this structure may require updating slh_dsa_dupctx().
42		*/
43		typedef struct {
44		SLH_DSA_KEY key; / Note that the key is not owned by this object */
45		SLH_DSA_HASH_CTX *hash_ctx;
46		uint8_t context_string[SLH_DSA_MAX_CONTEXT_STRING_LEN];
47		size_t context_string_len;
48		uint8_t add_random[SLH_DSA_MAX_ADD_RANDOM_LEN];
49		size_t add_random_len;
50		int msg_encode;
51		int deterministic;
52		OSSL_LIB_CTX *libctx;
53		char *propq;
54		const char *alg;
55		/* The Algorithm Identifier of the signature algorithm */
56		uint8_t aid_buf[OSSL_MAX_ALGORITHM_ID_SIZE];
57		size_t aid_len;
58		} PROV_SLH_DSA_CTX;
59
60		static void slh_dsa_freectx(void *vctx)
61	0	{
62	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
63
64	0	ossl_slh_dsa_hash_ctx_free(ctx->hash_ctx);
65	0	OPENSSL_free(ctx->propq);
66	0	OPENSSL_cleanse(ctx->add_random, ctx->add_random_len);
67	0	OPENSSL_free(ctx);
68	0	}
69
70		static void slh_dsa_newctx(void provctx, const char alg, const char propq)
71	0	{
72	0	PROV_SLH_DSA_CTX *ctx;
73
74	0	if (!ossl_prov_is_running())
75	0	return NULL;
76
77	0	ctx = OPENSSL_zalloc(sizeof(PROV_SLH_DSA_CTX));
78	0	if (ctx == NULL)
79	0	return NULL;
80
81	0	ctx->libctx = PROV_LIBCTX_OF(provctx);
82	0	if (propq != NULL && (ctx->propq = OPENSSL_strdup(propq)) == NULL)
83	0	goto err;
84	0	ctx->alg = alg;
85	0	ctx->msg_encode = SLH_DSA_MESSAGE_ENCODE_PURE;
86	0	return ctx;
87	0	err:
88	0	slh_dsa_freectx(ctx);
89	0	return NULL;
90	0	}
91
92		static void slh_dsa_dupctx(void vctx)
93	0	{
94	0	PROV_SLH_DSA_CTX src = (PROV_SLH_DSA_CTX )vctx;
95	0	PROV_SLH_DSA_CTX *ret;
96
97	0	if (!ossl_prov_is_running())
98	0	return NULL;
99
100		/*
101		* Note that the SLH_DSA_KEY is ref counted via EVP_PKEY so we can just copy
102		* the key here.
103		*/
104	0	ret = OPENSSL_memdup(src, sizeof(*src));
105	0	if (ret == NULL)
106	0	return NULL;
107	0	ret->propq = NULL;
108	0	ret->hash_ctx = NULL;
109	0	if (src->propq != NULL && (ret->propq = OPENSSL_strdup(src->propq)) == NULL)
110	0	goto err;
111	0	ret->hash_ctx = ossl_slh_dsa_hash_ctx_dup(src->hash_ctx);
112	0	if (ret->hash_ctx == NULL)
113	0	goto err;
114
115	0	return ret;
116	0	err:
117	0	slh_dsa_freectx(ret);
118	0	return NULL;
119	0	}
120
121		static int slh_dsa_set_alg_id_buffer(PROV_SLH_DSA_CTX *ctx)
122	0	{
123	0	int ret;
124	0	WPACKET pkt;
125	0	uint8_t *aid = NULL;
126
127		/*
128		* We do not care about DER writing errors.
129		* All it really means is that for some reason, there's no
130		* AlgorithmIdentifier to be had, but the operation itself is
131		* still valid, just as long as it's not used to construct
132		* anything that needs an AlgorithmIdentifier.
133		*/
134	0	ctx->aid_len = 0;
135	0	ret = WPACKET_init_der(&pkt, ctx->aid_buf, sizeof(ctx->aid_buf));
136	0	ret = ret && ossl_DER_w_algorithmIdentifier_SLH_DSA(&pkt, -1, ctx->key);
137	0	if (ret && WPACKET_finish(&pkt)) {
138	0	WPACKET_get_total_written(&pkt, &ctx->aid_len);
139	0	aid = WPACKET_get_curr(&pkt);
140	0	}
141	0	WPACKET_cleanup(&pkt);
142	0	if (aid != NULL && ctx->aid_len != 0)
143	0	memmove(ctx->aid_buf, aid, ctx->aid_len);
144	0	return 1;
145	0	}
146
147		static int slh_dsa_signverify_msg_init(void vctx, void vkey,
148		const OSSL_PARAM params[], int operation,
149		const char *desc)
150	0	{
151	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
152	0	SLH_DSA_KEY *key = vkey;
153
154	0	if (!ossl_prov_is_running()
155	0	\|\| ctx == NULL)
156	0	return 0;
157
158	0	if (vkey == NULL && ctx->key == NULL) {
159	0	ERR_raise(ERR_LIB_PROV, PROV_R_NO_KEY_SET);
160	0	return 0;
161	0	}
162
163	0	if (key != NULL) {
164	0	if (!ossl_slh_dsa_key_type_matches(key, ctx->alg))
165	0	return 0;
166	0	ctx->hash_ctx = ossl_slh_dsa_hash_ctx_new(key);
167	0	if (ctx->hash_ctx == NULL)
168	0	return 0;
169	0	ctx->key = vkey;
170	0	}
171
172	0	slh_dsa_set_alg_id_buffer(ctx);
173	0	if (!slh_dsa_set_ctx_params(ctx, params))
174	0	return 0;
175	0	return 1;
176	0	}
177
178		static int slh_dsa_sign_msg_init(void vctx, void vkey, const OSSL_PARAM params[])
179	0	{
180	0	return slh_dsa_signverify_msg_init(vctx, vkey, params,
181	0	EVP_PKEY_OP_SIGN, "SLH_DSA Sign Init");
182	0	}
183
184		static int slh_dsa_digest_signverify_init(void vctx, const char mdname,
185		void *vkey, const OSSL_PARAM params[])
186	0	{
187	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
188
189	0	if (mdname != NULL && mdname[0] != '\0') {
190	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_DIGEST,
191	0	"Explicit digest not supported for SLH-DSA operations");
192	0	return 0;
193	0	}
194
195	0	if (vkey == NULL && ctx->key != NULL)
196	0	return slh_dsa_set_ctx_params(ctx, params);
197
198	0	return slh_dsa_signverify_msg_init(vctx, vkey, params,
199	0	EVP_PKEY_OP_SIGN, "SLH_DSA Sign Init");
200	0	}
201
202		static int slh_dsa_sign(void vctx, unsigned char sig, size_t *siglen,
203		size_t sigsize, const unsigned char *msg, size_t msg_len)
204	0	{
205	0	int ret = 0;
206	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
207	0	uint8_t add_rand[SLH_DSA_MAX_ADD_RANDOM_LEN], *opt_rand = NULL;
208	0	size_t n = 0;
209
210	0	if (!ossl_prov_is_running())
211	0	return 0;
212
213	0	if (sig != NULL) {
214	0	if (ctx->add_random_len != 0) {
215	0	opt_rand = ctx->add_random;
216	0	} else if (ctx->deterministic == 0) {
217	0	n = ossl_slh_dsa_key_get_n(ctx->key);
218	0	if (RAND_priv_bytes_ex(ctx->libctx, add_rand, n, 0) <= 0)
219	0	return 0;
220	0	opt_rand = add_rand;
221	0	}
222	0	}
223	0	ret = ossl_slh_dsa_sign(ctx->hash_ctx, msg, msg_len,
224	0	ctx->context_string, ctx->context_string_len,
225	0	opt_rand, ctx->msg_encode,
226	0	sig, siglen, sigsize);
227	0	if (opt_rand != add_rand)
228	0	OPENSSL_cleanse(opt_rand, n);
229	0	return ret;
230	0	}
231
232		static int slh_dsa_digest_sign(void vctx, uint8_t sig, size_t *siglen, size_t sigsize,
233		const uint8_t *tbs, size_t tbslen)
234	0	{
235	0	return slh_dsa_sign(vctx, sig, siglen, sigsize, tbs, tbslen);
236	0	}
237
238		static int slh_dsa_verify_msg_init(void vctx, void vkey, const OSSL_PARAM params[])
239	0	{
240	0	return slh_dsa_signverify_msg_init(vctx, vkey, params, EVP_PKEY_OP_VERIFY,
241	0	"SLH_DSA Verify Init");
242	0	}
243
244		static int slh_dsa_verify(void vctx, const uint8_t sig, size_t siglen,
245		const uint8_t *msg, size_t msg_len)
246	0	{
247	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
248
249	0	if (!ossl_prov_is_running())
250	0	return 0;
251	0	return ossl_slh_dsa_verify(ctx->hash_ctx, msg, msg_len,
252	0	ctx->context_string, ctx->context_string_len,
253	0	ctx->msg_encode, sig, siglen);
254	0	}
255		static int slh_dsa_digest_verify(void vctx, const uint8_t sig, size_t siglen,
256		const uint8_t *tbs, size_t tbslen)
257	0	{
258	0	return slh_dsa_verify(vctx, sig, siglen, tbs, tbslen);
259	0	}
260
261		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
262		#ifndef slh_dsa_set_ctx_params_list
263		static const OSSL_PARAM slh_dsa_set_ctx_params_list[] = {
264		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
265		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
266		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
267		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
268		OSSL_PARAM_END
269		};
270		#endif
271
272		#ifndef slh_dsa_set_ctx_params_st
273		struct slh_dsa_set_ctx_params_st {
274		OSSL_PARAM *context;
275		OSSL_PARAM *det;
276		OSSL_PARAM *entropy;
277		OSSL_PARAM *msgenc;
278		};
279		#endif
280
281		#ifndef slh_dsa_set_ctx_params_decoder
282		static int slh_dsa_set_ctx_params_decoder
283		(const OSSL_PARAM p, struct slh_dsa_set_ctx_params_st r)
284	0	{
285	0	const char *s;
286
287	0	memset(r, 0, sizeof(*r));
288	0	if (p != NULL)
289	0	for (; (s = p->key) != NULL; p++)
290	0	switch(s[0]) {
291	0	default:
292	0	break;
293	0	case 'c':
294	0	if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
295		/* SIGNATURE_PARAM_CONTEXT_STRING */
296	0	if (ossl_unlikely(r->context != NULL)) {
297	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
298	0	"param %s is repeated", s);
299	0	return 0;
300	0	}
301	0	r->context = (OSSL_PARAM *)p;
302	0	}
303	0	break;
304	0	case 'd':
305	0	if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
306		/* SIGNATURE_PARAM_DETERMINISTIC */
307	0	if (ossl_unlikely(r->det != NULL)) {
308	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
309	0	"param %s is repeated", s);
310	0	return 0;
311	0	}
312	0	r->det = (OSSL_PARAM *)p;
313	0	}
314	0	break;
315	0	case 'm':
316	0	if (ossl_likely(strcmp("essage-encoding", s + 1) == 0)) {
317		/* SIGNATURE_PARAM_MESSAGE_ENCODING */
318	0	if (ossl_unlikely(r->msgenc != NULL)) {
319	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
320	0	"param %s is repeated", s);
321	0	return 0;
322	0	}
323	0	r->msgenc = (OSSL_PARAM *)p;
324	0	}
325	0	break;
326	0	case 't':
327	0	if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
328		/* SIGNATURE_PARAM_TEST_ENTROPY */
329	0	if (ossl_unlikely(r->entropy != NULL)) {
330	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
331	0	"param %s is repeated", s);
332	0	return 0;
333	0	}
334	0	r->entropy = (OSSL_PARAM *)p;
335	0	}
336	0	}
337	0	return 1;
338	0	}
339		#endif
340		/* End of machine generated */
341
342		static int slh_dsa_set_ctx_params(void *vctx, const OSSL_PARAM params[])
343	0	{
344	0	PROV_SLH_DSA_CTX pctx = (PROV_SLH_DSA_CTX )vctx;
345	0	struct slh_dsa_set_ctx_params_st p;
346
347	0	if (pctx == NULL \|\| !slh_dsa_set_ctx_params_decoder(params, &p))
348	0	return 0;
349
350	0	if (p.context != NULL) {
351	0	void *vp = pctx->context_string;
352
353	0	if (!OSSL_PARAM_get_octet_string(p.context, &vp,
354	0	sizeof(pctx->context_string),
355	0	&(pctx->context_string_len))) {
356	0	pctx->context_string_len = 0;
357	0	return 0;
358	0	}
359	0	}
360
361	0	if (p.entropy != NULL) {
362	0	void *vp = pctx->add_random;
363	0	size_t n = ossl_slh_dsa_key_get_n(pctx->key);
364
365	0	if (!OSSL_PARAM_get_octet_string(p.entropy, &vp, n, &(pctx->add_random_len))
366	0	\|\| pctx->add_random_len != n) {
367	0	pctx->add_random_len = 0;
368	0	return 0;
369	0	}
370	0	}
371
372	0	if (p.det != NULL && !OSSL_PARAM_get_int(p.det, &pctx->deterministic))
373	0	return 0;
374
375	0	if (p.msgenc != NULL && !OSSL_PARAM_get_int(p.msgenc, &pctx->msg_encode))
376	0	return 0;
377	0	return 1;
378	0	}
379
380		static const OSSL_PARAM slh_dsa_settable_ctx_params(void vctx,
381		ossl_unused void *provctx)
382	0	{
383	0	return slh_dsa_set_ctx_params_list;
384	0	}
385
386		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
387		#ifndef slh_dsa_get_ctx_params_list
388		static const OSSL_PARAM slh_dsa_get_ctx_params_list[] = {
389		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
390		OSSL_PARAM_END
391		};
392		#endif
393
394		#ifndef slh_dsa_get_ctx_params_st
395		struct slh_dsa_get_ctx_params_st {
396		OSSL_PARAM *algid;
397		};
398		#endif
399
400		#ifndef slh_dsa_get_ctx_params_decoder
401		static int slh_dsa_get_ctx_params_decoder
402		(const OSSL_PARAM p, struct slh_dsa_get_ctx_params_st r)
403	0	{
404	0	const char *s;
405
406	0	memset(r, 0, sizeof(*r));
407	0	if (p != NULL)
408	0	for (; (s = p->key) != NULL; p++)
409	0	if (ossl_likely(strcmp("algorithm-id", s + 0) == 0)) {
410		/* SIGNATURE_PARAM_ALGORITHM_ID */
411	0	if (ossl_unlikely(r->algid != NULL)) {
412	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
413	0	"param %s is repeated", s);
414	0	return 0;
415	0	}
416	0	r->algid = (OSSL_PARAM *)p;
417	0	}
418	0	return 1;
419	0	}
420		#endif
421		/* End of machine generated */
422
423		static const OSSL_PARAM slh_dsa_gettable_ctx_params(ossl_unused void vctx,
424		ossl_unused void *provctx)
425	0	{
426	0	return slh_dsa_get_ctx_params_list;
427	0	}
428
429		static int slh_dsa_get_ctx_params(void vctx, OSSL_PARAM params)
430	0	{
431	0	PROV_SLH_DSA_CTX ctx = (PROV_SLH_DSA_CTX )vctx;
432	0	struct slh_dsa_get_ctx_params_st p;
433
434	0	if (ctx == NULL \|\| !slh_dsa_get_ctx_params_decoder(params, &p))
435	0	return 0;
436
437	0	if (p.algid != NULL
438	0	&& !OSSL_PARAM_set_octet_string(p.algid,
439	0	ctx->aid_len == 0 ? NULL : ctx->aid_buf,
440	0	ctx->aid_len))
441	0	return 0;
442
443	0	return 1;
444	0	}
445
446		#define MAKE_SIGNATURE_FUNCTIONS(alg, fn) \
447		static OSSL_FUNC_signature_newctx_fn slh_dsa_##fn##_newctx; \
448		static void slh_dsa_##fn##_newctx(void provctx, const char *propq) \
449	0	{ \
450	0	return slh_dsa_newctx(provctx, alg, propq); \
451	0	} \ Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_128s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_128f_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_192s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_192f_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_256s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_sha2_256f_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_128s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_128f_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_192s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_192f_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_256s_newctx Unexecuted instantiation: slh_dsa_sig.c:slh_dsa_shake_256f_newctx
452		const OSSL_DISPATCH ossl_slh_dsa_##fn##_signature_functions[] = { \
453		{ OSSL_FUNC_SIGNATURE_NEWCTX, (void (*)(void))slh_dsa_##fn##_newctx }, \
454		{ OSSL_FUNC_SIGNATURE_SIGN_MESSAGE_INIT, \
455		(void (*)(void))slh_dsa_sign_msg_init }, \
456		{ OSSL_FUNC_SIGNATURE_SIGN, (void (*)(void))slh_dsa_sign }, \
457		{ OSSL_FUNC_SIGNATURE_VERIFY_MESSAGE_INIT, \
458		(void (*)(void))slh_dsa_verify_msg_init }, \
459		{ OSSL_FUNC_SIGNATURE_VERIFY, (void (*)(void))slh_dsa_verify }, \
460		{ OSSL_FUNC_SIGNATURE_DIGEST_SIGN_INIT, \
461		(void (*)(void))slh_dsa_digest_signverify_init }, \
462		{ OSSL_FUNC_SIGNATURE_DIGEST_SIGN, \
463		(void (*)(void))slh_dsa_digest_sign }, \
464		{ OSSL_FUNC_SIGNATURE_DIGEST_VERIFY_INIT, \
465		(void (*)(void))slh_dsa_digest_signverify_init }, \
466		{ OSSL_FUNC_SIGNATURE_DIGEST_VERIFY, \
467		(void (*)(void))slh_dsa_digest_verify }, \
468		{ OSSL_FUNC_SIGNATURE_FREECTX, (void (*)(void))slh_dsa_freectx }, \
469		{ OSSL_FUNC_SIGNATURE_DUPCTX, (void (*)(void))slh_dsa_dupctx }, \
470		{ OSSL_FUNC_SIGNATURE_SET_CTX_PARAMS, (void (*)(void))slh_dsa_set_ctx_params },\
471		{ OSSL_FUNC_SIGNATURE_SETTABLE_CTX_PARAMS, \
472		(void (*)(void))slh_dsa_settable_ctx_params }, \
473		{ OSSL_FUNC_SIGNATURE_GET_CTX_PARAMS, \
474		(void (*)(void))slh_dsa_get_ctx_params }, \
475		{ OSSL_FUNC_SIGNATURE_GETTABLE_CTX_PARAMS, \
476		(void (*)(void))slh_dsa_gettable_ctx_params }, \
477		OSSL_DISPATCH_END \
478		}
479
480		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-128s", sha2_128s);
481		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-128f", sha2_128f);
482		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-192s", sha2_192s);
483		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-192f", sha2_192f);
484		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-256s", sha2_256s);
485		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHA2-256f", sha2_256f);
486		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-128s", shake_128s);
487		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-128f", shake_128f);
488		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-192s", shake_192s);
489		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-192f", shake_192f);
490		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-256s", shake_256s);
491		MAKE_SIGNATURE_FUNCTIONS("SLH-DSA-SHAKE-256f", shake_256f);