/src/openssl-3.5.4/providers/implementations/keymgmt/ml_dsa_kmgmt.c

Source
/*
 * 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_dispatch.h>
#include <openssl/core_names.h>
#include <openssl/evp.h>
#include <openssl/param_build.h>
#include <openssl/proverr.h>
#include <openssl/self_test.h>
#include "crypto/ml_dsa.h"
#include "internal/fips.h"
#include "internal/param_build_set.h"
#include "prov/implementations.h"
#include "prov/providercommon.h"
#include "prov/provider_ctx.h"
#include "prov/ml_dsa.h"

static OSSL_FUNC_keymgmt_free_fn ml_dsa_free_key;
static OSSL_FUNC_keymgmt_has_fn ml_dsa_has;
static OSSL_FUNC_keymgmt_match_fn ml_dsa_match;
static OSSL_FUNC_keymgmt_import_fn ml_dsa_import;
static OSSL_FUNC_keymgmt_export_fn ml_dsa_export;
static OSSL_FUNC_keymgmt_import_types_fn ml_dsa_imexport_types;
static OSSL_FUNC_keymgmt_export_types_fn ml_dsa_imexport_types;
static OSSL_FUNC_keymgmt_dup_fn ml_dsa_dup_key;
static OSSL_FUNC_keymgmt_get_params_fn ml_dsa_get_params;
static OSSL_FUNC_keymgmt_gettable_params_fn ml_dsa_gettable_params;
static OSSL_FUNC_keymgmt_validate_fn ml_dsa_validate;
static OSSL_FUNC_keymgmt_gen_init_fn ml_dsa_gen_init;
static OSSL_FUNC_keymgmt_gen_cleanup_fn ml_dsa_gen_cleanup;
static OSSL_FUNC_keymgmt_gen_set_params_fn ml_dsa_gen_set_params;
static OSSL_FUNC_keymgmt_gen_settable_params_fn ml_dsa_gen_settable_params;
#ifndef FIPS_MODULE
static OSSL_FUNC_keymgmt_load_fn ml_dsa_load;
#endif

struct ml_dsa_gen_ctx {
    PROV_CTX *provctx;
    char *propq;
    uint8_t entropy[32];
    size_t entropy_len;
};

#ifdef FIPS_MODULE
static int ml_dsa_pairwise_test(const ML_DSA_KEY *key)
{
    OSSL_SELF_TEST *st = NULL;
    OSSL_CALLBACK *cb = NULL;
    OSSL_LIB_CTX *ctx;
    void *cbarg = NULL;
    static const uint8_t msg[] = { 80, 108, 117, 103, 104 };
    uint8_t rnd[ML_DSA_ENTROPY_LEN];
    uint8_t sig[ML_DSA_87_SIG_LEN];
    size_t sig_len = 0;
    int ret = 0;

    if (!ml_dsa_has(key, OSSL_KEYMGMT_SELECT_KEYPAIR)
            || ossl_fips_self_testing())
        return 1;

    /*
     * The functions `OSSL_SELF_TEST_*` will return directly if parameter `st`
     * is NULL.
     */
    ctx = ossl_ml_dsa_key_get0_libctx(key);
    OSSL_SELF_TEST_get_callback(ctx, &cb, &cbarg);

    if ((st = OSSL_SELF_TEST_new(cb, cbarg)) == NULL)
        return 0;

    OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
                           OSSL_SELF_TEST_DESC_PCT_ML_DSA);

    memset(rnd, 0, sizeof(rnd));
    memset(sig, 0, sizeof(sig));

    if (ossl_ml_dsa_sign(key, 0, msg, sizeof(msg), NULL, 0, rnd, sizeof(rnd), 0,
                         sig, &sig_len, sizeof(sig)) <= 0)
        goto err;

    OSSL_SELF_TEST_oncorrupt_byte(st, sig);

    if (ossl_ml_dsa_verify(key, 0, msg, sizeof(msg), NULL, 0, 0,
                           sig, sig_len) <= 0)
        goto err;

    ret = 1;
 err:
    OSSL_SELF_TEST_onend(st, ret);
    OSSL_SELF_TEST_free(st);
    return ret;
}
#endif

ML_DSA_KEY *ossl_prov_ml_dsa_new(PROV_CTX *ctx, const char *propq, int evp_type)
{
    ML_DSA_KEY *key;

    if (!ossl_prov_is_running())
        return 0;

    key = ossl_ml_dsa_key_new(PROV_LIBCTX_OF(ctx), propq, evp_type);
    /*
     * When decoding, if the key ends up "loaded" into the same provider, these
     * are the correct config settings, otherwise, new values will be assigned
     * on import into a different provider.  The "load" API does not pass along
     * the provider context.
     */
    if (key != NULL) {
        int flags_set = 0, flags_clr = 0;

        if (ossl_prov_ctx_get_bool_param(
                ctx, OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED, 1))
            flags_set |= ML_DSA_KEY_RETAIN_SEED;
        else
            flags_clr = ML_DSA_KEY_RETAIN_SEED;

        if (ossl_prov_ctx_get_bool_param(
                ctx, OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED, 1))
            flags_set |= ML_DSA_KEY_PREFER_SEED;
        else
            flags_clr |= ML_DSA_KEY_PREFER_SEED;

        ossl_ml_dsa_set_prekey(key, flags_set, flags_clr, NULL, 0, NULL, 0);
    }
    return key;
}

static void ml_dsa_free_key(void *keydata)
{
    ossl_ml_dsa_key_free((ML_DSA_KEY *)keydata);
}

static void *ml_dsa_dup_key(const void *keydata_from, int selection)
{
    if (ossl_prov_is_running())
        return ossl_ml_dsa_key_dup(keydata_from, selection);
    return NULL;
}

static int ml_dsa_has(const void *keydata, int selection)
{
    const ML_DSA_KEY *key = keydata;

    if (!ossl_prov_is_running() || key == NULL)
        return 0;
    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
        return 1; /* the selection is not missing */

    return ossl_ml_dsa_key_has(key, selection);
}

static int ml_dsa_match(const void *keydata1, const void *keydata2, int selection)
{
    const ML_DSA_KEY *key1 = keydata1;
    const ML_DSA_KEY *key2 = keydata2;

    if (!ossl_prov_is_running())
        return 0;
    if (key1 == NULL || key2 == NULL)
        return 0;
    return ossl_ml_dsa_key_equal(key1, key2, selection);
}

static int ml_dsa_validate(const void *key_data, int selection, int check_type)
{
    const ML_DSA_KEY *key = key_data;

    if (!ml_dsa_has(key, selection))
        return 0;

    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR)
        return ossl_ml_dsa_key_pairwise_check(key);
    return 1;
}

/**
 * @brief Load a ML_DSA key from raw data.
 *
 * @param key An ML_DSA key to load into
 * @param params An array of parameters containing key data.
 * @param include_private Set to 1 to optionally include the private key data
 *                        if it exists.
 * @returns 1 on success, or 0 on failure.
 */
static int ml_dsa_key_fromdata(ML_DSA_KEY *key, const OSSL_PARAM params[],
                               int include_private)
{
    const OSSL_PARAM *p = NULL;
    const ML_DSA_PARAMS *key_params = ossl_ml_dsa_key_params(key);
    const uint8_t *pk = NULL, *sk = NULL, *seed = NULL;
    size_t pk_len = 0, sk_len = 0, seed_len = 0;

    p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
    if (p != NULL
        && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&pk, &pk_len))
        return 0;
    if (pk != NULL && pk_len != key_params->pk_len) {
        ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
                       "Invalid %s public key length", key_params->alg);
        return 0;
    }

    /* Private key is optional */
    if (include_private) {
        p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
        if (p != NULL
            && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&seed,
                                                &seed_len))
            return 0;
        if (seed != NULL && seed_len != ML_DSA_SEED_BYTES) {
            ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_SEED_LENGTH);
            return 0;
        }
        p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
        if (p != NULL
            && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&sk, &sk_len))
            return 0;
        if (sk != NULL && sk_len != key_params->sk_len) {
            ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
                           "Invalid %s private key length", key_params->alg);
            return 0;
        }
    }

    /* The caller MUST specify at least one of seed, private or public keys. */
    if (seed_len == 0 && pk_len == 0 && sk_len == 0) {
        ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_KEY);
        return 0;
    }

    if (seed_len != 0
        && (sk_len == 0
            || (ossl_ml_dsa_key_get_prov_flags(key) & ML_DSA_KEY_PREFER_SEED))) {
        if (!ossl_ml_dsa_set_prekey(key, 0, 0, seed, seed_len, sk, sk_len))
            return 0;
        if (!ossl_ml_dsa_generate_key(key)) {
            ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
            return 0;
        }
    } else if (sk_len > 0) {
        if (!ossl_ml_dsa_sk_decode(key, sk, sk_len))
            return 0;
    } else if (pk_len > 0) {
        if (!ossl_ml_dsa_pk_decode(key, pk, pk_len))
            return 0;
    }

    /* Error if the supplied public key does not match the generated key */
    if (pk_len == 0
        || seed_len + sk_len == 0
        || memcmp(ossl_ml_dsa_key_get_pub(key), pk, pk_len) == 0)
        return 1;
    ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
                   "explicit %s public key does not match private",
                   key_params->alg);
    ossl_ml_dsa_key_reset(key);
    return 0;
}

static int ml_dsa_import(void *keydata, int selection, const OSSL_PARAM params[])
{
    ML_DSA_KEY *key = keydata;
    int include_priv;
    int res;

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

    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
        return 0;

    include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
    res = ml_dsa_key_fromdata(key, params, include_priv);
#ifdef FIPS_MODULE
    if (res > 0) {
        res = ml_dsa_pairwise_test(key);
        if (!res) {
            ossl_ml_dsa_key_reset(key);
            ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT_IMPORT);
        }
    }
#endif  /* FIPS_MODULE */
    return res;
}

#define ML_DSA_IMEXPORTABLE_PARAMETERS \
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0), \
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)

static const OSSL_PARAM ml_dsa_key_types[] = {
    ML_DSA_IMEXPORTABLE_PARAMETERS,
    OSSL_PARAM_END
};
static const OSSL_PARAM *ml_dsa_imexport_types(int selection)
{
    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
        return NULL;
    return ml_dsa_key_types;
}

static const OSSL_PARAM ml_dsa_params[] = {
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
    ML_DSA_IMEXPORTABLE_PARAMETERS,
    OSSL_PARAM_END
};
static const OSSL_PARAM *ml_dsa_gettable_params(void *provctx)
{
    return ml_dsa_params;
}

static int ml_dsa_get_params(void *keydata, OSSL_PARAM params[])
{
    ML_DSA_KEY *key = keydata;
    OSSL_PARAM *p;
    const uint8_t *pub, *priv, *seed;

    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
            && !OSSL_PARAM_set_int(p, 8 * ossl_ml_dsa_key_get_pub_len(key)))
        return 0;
    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
            && !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_collision_strength_bits(key)))
        return 0;
    if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
            && !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_sig_len(key)))
        return 0;

    pub = ossl_ml_dsa_key_get_pub(key);
    priv = ossl_ml_dsa_key_get_priv(key);
    seed = ossl_ml_dsa_key_get_seed(key);

    if (seed != NULL
        && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_ML_DSA_SEED)) != NULL
        && !OSSL_PARAM_set_octet_string(p, seed, ML_DSA_SEED_BYTES))
        return 0;
    if (priv != NULL
        && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY)) != NULL
        && !OSSL_PARAM_set_octet_string(p, priv,
                                        ossl_ml_dsa_key_get_priv_len(key)))
        return 0;
    if (pub != NULL
        && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY)) != NULL
        && !OSSL_PARAM_set_octet_string(p, pub,
                                        ossl_ml_dsa_key_get_pub_len(key)))
        return 0;
    /*
     * This allows apps to use an empty digest, so that the old API
     * for digest signing can be used.
     */
    p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST);
    if (p != NULL && !OSSL_PARAM_set_utf8_string(p, ""))
        return 0;

    return 1;
}

static int ml_dsa_export(void *keydata, int selection,
                         OSSL_CALLBACK *param_cb, void *cbarg)
{
    ML_DSA_KEY *key = keydata;
    OSSL_PARAM params[4];
    const uint8_t *buf;
    int include_private, pnum = 0;

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

    if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
        return 0;

    include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);

    /*
     * Note that if the seed is present, both the seed and the private key are
     * exported.  The recipient will have a choice.
     */
    if (include_private) {
        if ((buf = ossl_ml_dsa_key_get_seed(key)) != NULL) {
            params[pnum++] = OSSL_PARAM_construct_octet_string
                (OSSL_PKEY_PARAM_ML_DSA_SEED, (void *)buf, ML_DSA_SEED_BYTES);
        }
        if ((buf = ossl_ml_dsa_key_get_priv(key)) != NULL) {
            params[pnum++] = OSSL_PARAM_construct_octet_string
                (OSSL_PKEY_PARAM_PRIV_KEY, (void *)buf,
                 ossl_ml_dsa_key_get_priv_len(key));
        }
    }
    if (((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
        && ((buf = ossl_ml_dsa_key_get_pub(key)) != NULL)) {
        params[pnum++] = OSSL_PARAM_construct_octet_string
            (OSSL_PKEY_PARAM_PUB_KEY, (void *)buf,
             ossl_ml_dsa_key_get_pub_len(key));
    }
    if (pnum == 0)
        return 0;
    params[pnum] = OSSL_PARAM_construct_end();
    return param_cb(params, cbarg);
}

#ifndef FIPS_MODULE
static void *ml_dsa_load(const void *reference, size_t reference_sz)
{
    ML_DSA_KEY *key = NULL;
    const ML_DSA_PARAMS *key_params;
    const uint8_t *sk, *seed;

    if (ossl_prov_is_running() && reference_sz == sizeof(key)) {
        /* The contents of the reference is the address to our object */
        key = *(ML_DSA_KEY **)reference;
        /* We grabbed, so we detach it */
        *(ML_DSA_KEY **)reference = NULL;
        /* All done, if the pubkey is present. */
        if (key == NULL || ossl_ml_dsa_key_get_pub(key) != NULL)
            return key;
        /* Handle private prekey inputs. */
        sk = ossl_ml_dsa_key_get_priv(key);
        seed = ossl_ml_dsa_key_get_seed(key);
        if (seed != NULL
            && (sk == NULL || (ossl_ml_dsa_key_get_prov_flags(key)
                               & ML_DSA_KEY_PREFER_SEED))) {
            if (ossl_ml_dsa_generate_key(key))
                return key;
        } else if (sk != NULL) {
            if (ossl_ml_dsa_sk_decode(key, sk,
                                      ossl_ml_dsa_key_get_priv_len(key)))
                return key;
            key_params = ossl_ml_dsa_key_params(key);
            ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
                           "error parsing %s private key",
                           key_params->alg);
        } else {
            return key;
        }
    }

    ossl_ml_dsa_key_free(key);
    return NULL;
}
#endif

static void *ml_dsa_gen_init(void *provctx, int selection,
                             const OSSL_PARAM params[])
{
    struct ml_dsa_gen_ctx *gctx = NULL;

    if (!ossl_prov_is_running())
        return NULL;

    if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
        gctx->provctx = provctx;
        if (!ml_dsa_gen_set_params(gctx, params)) {
            OPENSSL_free(gctx);
            gctx = NULL;
        }
    }
    return gctx;
}

static void *ml_dsa_gen(void *genctx, int evp_type)
{
    struct ml_dsa_gen_ctx *gctx = genctx;
    ML_DSA_KEY *key = NULL;

    if (!ossl_prov_is_running())
        return NULL;
    key = ossl_prov_ml_dsa_new(gctx->provctx, gctx->propq, evp_type);
    if (key == NULL)
        return NULL;
    if (gctx->entropy_len != 0
        && !ossl_ml_dsa_set_prekey(key, 0, 0,
                                   gctx->entropy, gctx->entropy_len, NULL, 0))
        goto err;
    if (!ossl_ml_dsa_generate_key(key)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
        goto err;
    }
#ifdef FIPS_MODULE
    if (!ml_dsa_pairwise_test(key)) {
        ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT);
        goto err;
    }
#endif
    return key;
 err:
    ossl_ml_dsa_key_free(key);
    return NULL;
}

static int ml_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
{
    struct ml_dsa_gen_ctx *gctx = genctx;
    const OSSL_PARAM *p;

    if (gctx == NULL)
        return 0;

    p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
    if (p != NULL) {
        void *vp = gctx->entropy;
        size_t len = sizeof(gctx->entropy);

        if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) {
            gctx->entropy_len = 0;
            return 0;
        }
    }

    p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES);
    if (p != NULL) {
        OPENSSL_free(gctx->propq);
        gctx->propq = NULL;
        if (!OSSL_PARAM_get_utf8_string(p, &gctx->propq, 0))
            return 0;
    }
    return 1;
}

static const OSSL_PARAM *ml_dsa_gen_settable_params(ossl_unused void *genctx,
                                                    ossl_unused void *provctx)
{
    static OSSL_PARAM settable[] = {
        OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
        OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
        OSSL_PARAM_END
    };
    return settable;
}

static void ml_dsa_gen_cleanup(void *genctx)
{
    struct ml_dsa_gen_ctx *gctx = genctx;

    if (gctx == NULL)
        return;

    OPENSSL_cleanse(gctx->entropy, gctx->entropy_len);
    OPENSSL_free(gctx->propq);
    OPENSSL_free(gctx);
}

#ifndef FIPS_MODULE
# define DISPATCH_LOAD_FN \
        { OSSL_FUNC_KEYMGMT_LOAD, (OSSL_FUNC) ml_dsa_load },
#else
# define DISPATCH_LOAD_FN   /* Non-FIPS only */
#endif

#define MAKE_KEYMGMT_FUNCTIONS(alg)                                            \
    static OSSL_FUNC_keymgmt_new_fn ml_dsa_##alg##_new_key;                    \
    static OSSL_FUNC_keymgmt_gen_fn ml_dsa_##alg##_gen;                        \
    static void *ml_dsa_##alg##_new_key(void *provctx)                         \
    {                                                                          \
        return ossl_prov_ml_dsa_new(provctx, NULL, EVP_PKEY_ML_DSA_##alg);     \
    }                                                                          \
    static void *ml_dsa_##alg##_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)\
    {                                                                          \
        return ml_dsa_gen(genctx, EVP_PKEY_ML_DSA_##alg);                      \
    }                                                                          \
    const OSSL_DISPATCH ossl_ml_dsa_##alg##_keymgmt_functions[] = {            \
        { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))ml_dsa_##alg##_new_key },     \
        { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ml_dsa_free_key },           \
        { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ml_dsa_has },                 \
        { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))ml_dsa_match },             \
        { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ml_dsa_import },           \
        { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
        { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ml_dsa_export },           \
        { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
        DISPATCH_LOAD_FN                                                       \
        { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))ml_dsa_get_params },  \
        { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ml_dsa_gettable_params },\
        { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))ml_dsa_validate },       \
        { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))ml_dsa_gen_init },       \
        { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))ml_dsa_##alg##_gen },         \
        { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))ml_dsa_gen_cleanup }, \
        { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS,                                    \
          (void (*)(void))ml_dsa_gen_set_params },                             \
        { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS,                               \
          (void (*)(void))ml_dsa_gen_settable_params },                        \
        { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))ml_dsa_dup_key },             \
        OSSL_DISPATCH_END                                                      \
    }

MAKE_KEYMGMT_FUNCTIONS(44);
MAKE_KEYMGMT_FUNCTIONS(65);
MAKE_KEYMGMT_FUNCTIONS(87);

Coverage Report

Created: 2025-12-31 07:12

Line	Count	Source
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		#include <openssl/core_dispatch.h>
11		#include <openssl/core_names.h>
12		#include <openssl/evp.h>
13		#include <openssl/param_build.h>
14		#include <openssl/proverr.h>
15		#include <openssl/self_test.h>
16		#include "crypto/ml_dsa.h"
17		#include "internal/fips.h"
18		#include "internal/param_build_set.h"
19		#include "prov/implementations.h"
20		#include "prov/providercommon.h"
21		#include "prov/provider_ctx.h"
22		#include "prov/ml_dsa.h"
23
24		static OSSL_FUNC_keymgmt_free_fn ml_dsa_free_key;
25		static OSSL_FUNC_keymgmt_has_fn ml_dsa_has;
26		static OSSL_FUNC_keymgmt_match_fn ml_dsa_match;
27		static OSSL_FUNC_keymgmt_import_fn ml_dsa_import;
28		static OSSL_FUNC_keymgmt_export_fn ml_dsa_export;
29		static OSSL_FUNC_keymgmt_import_types_fn ml_dsa_imexport_types;
30		static OSSL_FUNC_keymgmt_export_types_fn ml_dsa_imexport_types;
31		static OSSL_FUNC_keymgmt_dup_fn ml_dsa_dup_key;
32		static OSSL_FUNC_keymgmt_get_params_fn ml_dsa_get_params;
33		static OSSL_FUNC_keymgmt_gettable_params_fn ml_dsa_gettable_params;
34		static OSSL_FUNC_keymgmt_validate_fn ml_dsa_validate;
35		static OSSL_FUNC_keymgmt_gen_init_fn ml_dsa_gen_init;
36		static OSSL_FUNC_keymgmt_gen_cleanup_fn ml_dsa_gen_cleanup;
37		static OSSL_FUNC_keymgmt_gen_set_params_fn ml_dsa_gen_set_params;
38		static OSSL_FUNC_keymgmt_gen_settable_params_fn ml_dsa_gen_settable_params;
39		#ifndef FIPS_MODULE
40		static OSSL_FUNC_keymgmt_load_fn ml_dsa_load;
41		#endif
42
43		struct ml_dsa_gen_ctx {
44		PROV_CTX *provctx;
45		char *propq;
46		uint8_t entropy[32];
47		size_t entropy_len;
48		};
49
50		#ifdef FIPS_MODULE
51		static int ml_dsa_pairwise_test(const ML_DSA_KEY *key)
52		{
53		OSSL_SELF_TEST *st = NULL;
54		OSSL_CALLBACK *cb = NULL;
55		OSSL_LIB_CTX *ctx;
56		void *cbarg = NULL;
57		static const uint8_t msg[] = { 80, 108, 117, 103, 104 };
58		uint8_t rnd[ML_DSA_ENTROPY_LEN];
59		uint8_t sig[ML_DSA_87_SIG_LEN];
60		size_t sig_len = 0;
61		int ret = 0;
62
63		if (!ml_dsa_has(key, OSSL_KEYMGMT_SELECT_KEYPAIR)
64		\|\| ossl_fips_self_testing())
65		return 1;
66
67		/*
68		* The functions `OSSL_SELF_TEST_*` will return directly if parameter `st`
69		* is NULL.
70		*/
71		ctx = ossl_ml_dsa_key_get0_libctx(key);
72		OSSL_SELF_TEST_get_callback(ctx, &cb, &cbarg);
73
74		if ((st = OSSL_SELF_TEST_new(cb, cbarg)) == NULL)
75		return 0;
76
77		OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
78		OSSL_SELF_TEST_DESC_PCT_ML_DSA);
79
80		memset(rnd, 0, sizeof(rnd));
81		memset(sig, 0, sizeof(sig));
82
83		if (ossl_ml_dsa_sign(key, 0, msg, sizeof(msg), NULL, 0, rnd, sizeof(rnd), 0,
84		sig, &sig_len, sizeof(sig)) <= 0)
85		goto err;
86
87		OSSL_SELF_TEST_oncorrupt_byte(st, sig);
88
89		if (ossl_ml_dsa_verify(key, 0, msg, sizeof(msg), NULL, 0, 0,
90		sig, sig_len) <= 0)
91		goto err;
92
93		ret = 1;
94		err:
95		OSSL_SELF_TEST_onend(st, ret);
96		OSSL_SELF_TEST_free(st);
97		return ret;
98		}
99		#endif
100
101		ML_DSA_KEY ossl_prov_ml_dsa_new(PROV_CTX ctx, const char *propq, int evp_type)
102	0	{
103	0	ML_DSA_KEY *key;
104
105	0	if (!ossl_prov_is_running())
106	0	return 0;
107
108	0	key = ossl_ml_dsa_key_new(PROV_LIBCTX_OF(ctx), propq, evp_type);
109		/*
110		* When decoding, if the key ends up "loaded" into the same provider, these
111		* are the correct config settings, otherwise, new values will be assigned
112		* on import into a different provider. The "load" API does not pass along
113		* the provider context.
114		*/
115	0	if (key != NULL) {
116	0	int flags_set = 0, flags_clr = 0;
117
118	0	if (ossl_prov_ctx_get_bool_param(
119	0	ctx, OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED, 1))
120	0	flags_set \|= ML_DSA_KEY_RETAIN_SEED;
121	0	else
122	0	flags_clr = ML_DSA_KEY_RETAIN_SEED;
123
124	0	if (ossl_prov_ctx_get_bool_param(
125	0	ctx, OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED, 1))
126	0	flags_set \|= ML_DSA_KEY_PREFER_SEED;
127	0	else
128	0	flags_clr \|= ML_DSA_KEY_PREFER_SEED;
129
130	0	ossl_ml_dsa_set_prekey(key, flags_set, flags_clr, NULL, 0, NULL, 0);
131	0	}
132	0	return key;
133	0	}
134
135		static void ml_dsa_free_key(void *keydata)
136	0	{
137	0	ossl_ml_dsa_key_free((ML_DSA_KEY *)keydata);
138	0	}
139
140		static void ml_dsa_dup_key(const void keydata_from, int selection)
141	0	{
142	0	if (ossl_prov_is_running())
143	0	return ossl_ml_dsa_key_dup(keydata_from, selection);
144	0	return NULL;
145	0	}
146
147		static int ml_dsa_has(const void *keydata, int selection)
148	0	{
149	0	const ML_DSA_KEY *key = keydata;
150
151	0	if (!ossl_prov_is_running() \|\| key == NULL)
152	0	return 0;
153	0	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
154	0	return 1; /* the selection is not missing */
155
156	0	return ossl_ml_dsa_key_has(key, selection);
157	0	}
158
159		static int ml_dsa_match(const void keydata1, const void keydata2, int selection)
160	0	{
161	0	const ML_DSA_KEY *key1 = keydata1;
162	0	const ML_DSA_KEY *key2 = keydata2;
163
164	0	if (!ossl_prov_is_running())
165	0	return 0;
166	0	if (key1 == NULL \|\| key2 == NULL)
167	0	return 0;
168	0	return ossl_ml_dsa_key_equal(key1, key2, selection);
169	0	}
170
171		static int ml_dsa_validate(const void *key_data, int selection, int check_type)
172	0	{
173	0	const ML_DSA_KEY *key = key_data;
174
175	0	if (!ml_dsa_has(key, selection))
176	0	return 0;
177
178	0	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR)
179	0	return ossl_ml_dsa_key_pairwise_check(key);
180	0	return 1;
181	0	}
182
183		/**
184		* @brief Load a ML_DSA key from raw data.
185		*
186		* @param key An ML_DSA key to load into
187		* @param params An array of parameters containing key data.
188		* @param include_private Set to 1 to optionally include the private key data
189		* if it exists.
190		* @returns 1 on success, or 0 on failure.
191		*/
192		static int ml_dsa_key_fromdata(ML_DSA_KEY *key, const OSSL_PARAM params[],
193		int include_private)
194	0	{
195	0	const OSSL_PARAM *p = NULL;
196	0	const ML_DSA_PARAMS *key_params = ossl_ml_dsa_key_params(key);
197	0	const uint8_t pk = NULL, sk = NULL, *seed = NULL;
198	0	size_t pk_len = 0, sk_len = 0, seed_len = 0;
199
200	0	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
201	0	if (p != NULL
202	0	&& !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&pk, &pk_len))
203	0	return 0;
204	0	if (pk != NULL && pk_len != key_params->pk_len) {
205	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
206	0	"Invalid %s public key length", key_params->alg);
207	0	return 0;
208	0	}
209
210		/* Private key is optional */
211	0	if (include_private) {
212	0	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
213	0	if (p != NULL
214	0	&& !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&seed,
215	0	&seed_len))
216	0	return 0;
217	0	if (seed != NULL && seed_len != ML_DSA_SEED_BYTES) {
218	0	ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_SEED_LENGTH);
219	0	return 0;
220	0	}
221	0	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
222	0	if (p != NULL
223	0	&& !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&sk, &sk_len))
224	0	return 0;
225	0	if (sk != NULL && sk_len != key_params->sk_len) {
226	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
227	0	"Invalid %s private key length", key_params->alg);
228	0	return 0;
229	0	}
230	0	}
231
232		/* The caller MUST specify at least one of seed, private or public keys. */
233	0	if (seed_len == 0 && pk_len == 0 && sk_len == 0) {
234	0	ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_KEY);
235	0	return 0;
236	0	}
237
238	0	if (seed_len != 0
239	0	&& (sk_len == 0
240	0	\|\| (ossl_ml_dsa_key_get_prov_flags(key) & ML_DSA_KEY_PREFER_SEED))) {
241	0	if (!ossl_ml_dsa_set_prekey(key, 0, 0, seed, seed_len, sk, sk_len))
242	0	return 0;
243	0	if (!ossl_ml_dsa_generate_key(key)) {
244	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
245	0	return 0;
246	0	}
247	0	} else if (sk_len > 0) {
248	0	if (!ossl_ml_dsa_sk_decode(key, sk, sk_len))
249	0	return 0;
250	0	} else if (pk_len > 0) {
251	0	if (!ossl_ml_dsa_pk_decode(key, pk, pk_len))
252	0	return 0;
253	0	}
254
255		/* Error if the supplied public key does not match the generated key */
256	0	if (pk_len == 0
257	0	\|\| seed_len + sk_len == 0
258	0	\|\| memcmp(ossl_ml_dsa_key_get_pub(key), pk, pk_len) == 0)
259	0	return 1;
260	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
261	0	"explicit %s public key does not match private",
262	0	key_params->alg);
263	0	ossl_ml_dsa_key_reset(key);
264	0	return 0;
265	0	}
266
267		static int ml_dsa_import(void *keydata, int selection, const OSSL_PARAM params[])
268	0	{
269	0	ML_DSA_KEY *key = keydata;
270	0	int include_priv;
271	0	int res;
272
273	0	if (!ossl_prov_is_running() \|\| key == NULL)
274	0	return 0;
275
276	0	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
277	0	return 0;
278
279	0	include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
280	0	res = ml_dsa_key_fromdata(key, params, include_priv);
281		#ifdef FIPS_MODULE
282		if (res > 0) {
283		res = ml_dsa_pairwise_test(key);
284		if (!res) {
285		ossl_ml_dsa_key_reset(key);
286		ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT_IMPORT);
287		}
288		}
289		#endif /* FIPS_MODULE */
290	0	return res;
291	0	}
292
293		#define ML_DSA_IMEXPORTABLE_PARAMETERS \
294		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0), \
295		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \
296		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)
297
298		static const OSSL_PARAM ml_dsa_key_types[] = {
299		ML_DSA_IMEXPORTABLE_PARAMETERS,
300		OSSL_PARAM_END
301		};
302		static const OSSL_PARAM *ml_dsa_imexport_types(int selection)
303	0	{
304	0	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
305	0	return NULL;
306	0	return ml_dsa_key_types;
307	0	}
308
309		static const OSSL_PARAM ml_dsa_params[] = {
310		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
311		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
312		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
313		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
314		ML_DSA_IMEXPORTABLE_PARAMETERS,
315		OSSL_PARAM_END
316		};
317		static const OSSL_PARAM ml_dsa_gettable_params(void provctx)
318	0	{
319	0	return ml_dsa_params;
320	0	}
321
322		static int ml_dsa_get_params(void *keydata, OSSL_PARAM params[])
323	0	{
324	0	ML_DSA_KEY *key = keydata;
325	0	OSSL_PARAM *p;
326	0	const uint8_t pub, priv, *seed;
327
328	0	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
329	0	&& !OSSL_PARAM_set_int(p, 8 * ossl_ml_dsa_key_get_pub_len(key)))
330	0	return 0;
331	0	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
332	0	&& !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_collision_strength_bits(key)))
333	0	return 0;
334	0	if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
335	0	&& !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_sig_len(key)))
336	0	return 0;
337
338	0	pub = ossl_ml_dsa_key_get_pub(key);
339	0	priv = ossl_ml_dsa_key_get_priv(key);
340	0	seed = ossl_ml_dsa_key_get_seed(key);
341
342	0	if (seed != NULL
343	0	&& (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_ML_DSA_SEED)) != NULL
344	0	&& !OSSL_PARAM_set_octet_string(p, seed, ML_DSA_SEED_BYTES))
345	0	return 0;
346	0	if (priv != NULL
347	0	&& (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY)) != NULL
348	0	&& !OSSL_PARAM_set_octet_string(p, priv,
349	0	ossl_ml_dsa_key_get_priv_len(key)))
350	0	return 0;
351	0	if (pub != NULL
352	0	&& (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY)) != NULL
353	0	&& !OSSL_PARAM_set_octet_string(p, pub,
354	0	ossl_ml_dsa_key_get_pub_len(key)))
355	0	return 0;
356		/*
357		* This allows apps to use an empty digest, so that the old API
358		* for digest signing can be used.
359		*/
360	0	p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST);
361	0	if (p != NULL && !OSSL_PARAM_set_utf8_string(p, ""))
362	0	return 0;
363
364	0	return 1;
365	0	}
366
367		static int ml_dsa_export(void *keydata, int selection,
368		OSSL_CALLBACK param_cb, void cbarg)
369	0	{
370	0	ML_DSA_KEY *key = keydata;
371	0	OSSL_PARAM params[4];
372	0	const uint8_t *buf;
373	0	int include_private, pnum = 0;
374
375	0	if (!ossl_prov_is_running() \|\| key == NULL)
376	0	return 0;
377
378	0	if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
379	0	return 0;
380
381	0	include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
382
383		/*
384		* Note that if the seed is present, both the seed and the private key are
385		* exported. The recipient will have a choice.
386		*/
387	0	if (include_private) {
388	0	if ((buf = ossl_ml_dsa_key_get_seed(key)) != NULL) {
389	0	params[pnum++] = OSSL_PARAM_construct_octet_string
390	0	(OSSL_PKEY_PARAM_ML_DSA_SEED, (void *)buf, ML_DSA_SEED_BYTES);
391	0	}
392	0	if ((buf = ossl_ml_dsa_key_get_priv(key)) != NULL) {
393	0	params[pnum++] = OSSL_PARAM_construct_octet_string
394	0	(OSSL_PKEY_PARAM_PRIV_KEY, (void *)buf,
395	0	ossl_ml_dsa_key_get_priv_len(key));
396	0	}
397	0	}
398	0	if (((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
399	0	&& ((buf = ossl_ml_dsa_key_get_pub(key)) != NULL)) {
400	0	params[pnum++] = OSSL_PARAM_construct_octet_string
401	0	(OSSL_PKEY_PARAM_PUB_KEY, (void *)buf,
402	0	ossl_ml_dsa_key_get_pub_len(key));
403	0	}
404	0	if (pnum == 0)
405	0	return 0;
406	0	params[pnum] = OSSL_PARAM_construct_end();
407	0	return param_cb(params, cbarg);
408	0	}
409
410		#ifndef FIPS_MODULE
411		static void ml_dsa_load(const void reference, size_t reference_sz)
412	0	{
413	0	ML_DSA_KEY *key = NULL;
414	0	const ML_DSA_PARAMS *key_params;
415	0	const uint8_t sk, seed;
416
417	0	if (ossl_prov_is_running() && reference_sz == sizeof(key)) {
418		/* The contents of the reference is the address to our object */
419	0	key = (ML_DSA_KEY *)reference;
420		/* We grabbed, so we detach it */
421	0	(ML_DSA_KEY *)reference = NULL;
422		/* All done, if the pubkey is present. */
423	0	if (key == NULL \|\| ossl_ml_dsa_key_get_pub(key) != NULL)
424	0	return key;
425		/* Handle private prekey inputs. */
426	0	sk = ossl_ml_dsa_key_get_priv(key);
427	0	seed = ossl_ml_dsa_key_get_seed(key);
428	0	if (seed != NULL
429	0	&& (sk == NULL \|\| (ossl_ml_dsa_key_get_prov_flags(key)
430	0	& ML_DSA_KEY_PREFER_SEED))) {
431	0	if (ossl_ml_dsa_generate_key(key))
432	0	return key;
433	0	} else if (sk != NULL) {
434	0	if (ossl_ml_dsa_sk_decode(key, sk,
435	0	ossl_ml_dsa_key_get_priv_len(key)))
436	0	return key;
437	0	key_params = ossl_ml_dsa_key_params(key);
438	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
439	0	"error parsing %s private key",
440	0	key_params->alg);
441	0	} else {
442	0	return key;
443	0	}
444	0	}
445
446	0	ossl_ml_dsa_key_free(key);
447	0	return NULL;
448	0	}
449		#endif
450
451		static void ml_dsa_gen_init(void provctx, int selection,
452		const OSSL_PARAM params[])
453	0	{
454	0	struct ml_dsa_gen_ctx *gctx = NULL;
455
456	0	if (!ossl_prov_is_running())
457	0	return NULL;
458
459	0	if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
460	0	gctx->provctx = provctx;
461	0	if (!ml_dsa_gen_set_params(gctx, params)) {
462	0	OPENSSL_free(gctx);
463	0	gctx = NULL;
464	0	}
465	0	}
466	0	return gctx;
467	0	}
468
469		static void ml_dsa_gen(void genctx, int evp_type)
470	0	{
471	0	struct ml_dsa_gen_ctx *gctx = genctx;
472	0	ML_DSA_KEY *key = NULL;
473
474	0	if (!ossl_prov_is_running())
475	0	return NULL;
476	0	key = ossl_prov_ml_dsa_new(gctx->provctx, gctx->propq, evp_type);
477	0	if (key == NULL)
478	0	return NULL;
479	0	if (gctx->entropy_len != 0
480	0	&& !ossl_ml_dsa_set_prekey(key, 0, 0,
481	0	gctx->entropy, gctx->entropy_len, NULL, 0))
482	0	goto err;
483	0	if (!ossl_ml_dsa_generate_key(key)) {
484	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
485	0	goto err;
486	0	}
487		#ifdef FIPS_MODULE
488		if (!ml_dsa_pairwise_test(key)) {
489		ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT);
490		goto err;
491		}
492		#endif
493	0	return key;
494	0	err:
495	0	ossl_ml_dsa_key_free(key);
496	0	return NULL;
497	0	}
498
499		static int ml_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
500	0	{
501	0	struct ml_dsa_gen_ctx *gctx = genctx;
502	0	const OSSL_PARAM *p;
503
504	0	if (gctx == NULL)
505	0	return 0;
506
507	0	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
508	0	if (p != NULL) {
509	0	void *vp = gctx->entropy;
510	0	size_t len = sizeof(gctx->entropy);
511
512	0	if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) {
513	0	gctx->entropy_len = 0;
514	0	return 0;
515	0	}
516	0	}
517
518	0	p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES);
519	0	if (p != NULL) {
520	0	OPENSSL_free(gctx->propq);
521	0	gctx->propq = NULL;
522	0	if (!OSSL_PARAM_get_utf8_string(p, &gctx->propq, 0))
523	0	return 0;
524	0	}
525	0	return 1;
526	0	}
527
528		static const OSSL_PARAM ml_dsa_gen_settable_params(ossl_unused void genctx,
529		ossl_unused void *provctx)
530	0	{
531	0	static OSSL_PARAM settable[] = {
532	0	OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
533	0	OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
534	0	OSSL_PARAM_END
535	0	};
536	0	return settable;
537	0	}
538
539		static void ml_dsa_gen_cleanup(void *genctx)
540	0	{
541	0	struct ml_dsa_gen_ctx *gctx = genctx;
542
543	0	if (gctx == NULL)
544	0	return;
545
546	0	OPENSSL_cleanse(gctx->entropy, gctx->entropy_len);
547	0	OPENSSL_free(gctx->propq);
548	0	OPENSSL_free(gctx);
549	0	}
550
551		#ifndef FIPS_MODULE
552		# define DISPATCH_LOAD_FN \
553		{ OSSL_FUNC_KEYMGMT_LOAD, (OSSL_FUNC) ml_dsa_load },
554		#else
555		# define DISPATCH_LOAD_FN /* Non-FIPS only */
556		#endif
557
558		#define MAKE_KEYMGMT_FUNCTIONS(alg) \
559		static OSSL_FUNC_keymgmt_new_fn ml_dsa_##alg##_new_key; \
560		static OSSL_FUNC_keymgmt_gen_fn ml_dsa_##alg##_gen; \
561		static void ml_dsa_##alg##_new_key(void provctx) \
562	0	{ \
563	0	return ossl_prov_ml_dsa_new(provctx, NULL, EVP_PKEY_ML_DSA_##alg); \
564	0	} \
565		static void ml_dsa_##alg##_gen(void genctx, OSSL_CALLBACK osslcb, void cbarg)\
566	0	{ \
567	0	return ml_dsa_gen(genctx, EVP_PKEY_ML_DSA_##alg); \
568	0	} \ Unexecuted instantiation: ml_dsa_kmgmt.c:ml_dsa_44_gen Unexecuted instantiation: ml_dsa_kmgmt.c:ml_dsa_65_gen Unexecuted instantiation: ml_dsa_kmgmt.c:ml_dsa_87_gen
569		const OSSL_DISPATCH ossl_ml_dsa_##alg##_keymgmt_functions[] = { \
570		{ OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))ml_dsa_##alg##_new_key }, \
571		{ OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ml_dsa_free_key }, \
572		{ OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ml_dsa_has }, \
573		{ OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))ml_dsa_match }, \
574		{ OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ml_dsa_import }, \
575		{ OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
576		{ OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ml_dsa_export }, \
577		{ OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
578		DISPATCH_LOAD_FN \
579		{ OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))ml_dsa_get_params }, \
580		{ OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ml_dsa_gettable_params },\
581		{ OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))ml_dsa_validate }, \
582		{ OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))ml_dsa_gen_init }, \
583		{ OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))ml_dsa_##alg##_gen }, \
584		{ OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))ml_dsa_gen_cleanup }, \
585		{ OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, \
586		(void (*)(void))ml_dsa_gen_set_params }, \
587		{ OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS, \
588		(void (*)(void))ml_dsa_gen_settable_params }, \
589		{ OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))ml_dsa_dup_key }, \
590		OSSL_DISPATCH_END \
591		}
592
593	0	MAKE_KEYMGMT_FUNCTIONS(44);
594	0	MAKE_KEYMGMT_FUNCTIONS(65);
595		MAKE_KEYMGMT_FUNCTIONS(87);