/src/openssl41/providers/implementations/keymgmt/ml_kem_kmgmt.inc

Source
/*
 * Copyright 2025-2026 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
 */



/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef ml_kem_import_params_list
static ossl_unused const OSSL_PARAM ml_kem_import_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_import_params_st
struct ml_kem_import_params_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *propq;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_kem_import_params_decoder
static ossl_unused int ml_kem_import_params_decoder
    (const OSSL_PARAM *p, struct ml_kem_import_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 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    switch(s[2]) {
                    default:
                        break;
                    case 'i':
                        if (ossl_likely(strcmp("v", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_PRIV_KEY */
                            if (ossl_unlikely(r->privkey != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->privkey = (OSSL_PARAM *)p;
                        }
                        break;
                    case 'o':
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_PROPERTIES */
                            if (ossl_unlikely(r->propq != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->propq = (OSSL_PARAM *)p;
                        }
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_KEY */
                        if (ossl_unlikely(r->pubkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pubkey = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 's':
                if (ossl_likely(strcmp("eed", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ML_KEM_SEED */
                    if (ossl_unlikely(r->seed != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->seed = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */
/* Machine generated */
#ifndef ml_kem_export_params_list
static ossl_unused const OSSL_PARAM ml_kem_export_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_export_params_st
struct ml_kem_export_params_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_kem_export_params_decoder
static ossl_unused int ml_kem_export_params_decoder
    (const OSSL_PARAM *p, struct ml_kem_export_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 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
                        if (ossl_unlikely(r->privkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->privkey = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_KEY */
                        if (ossl_unlikely(r->pubkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pubkey = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 's':
                if (ossl_likely(strcmp("eed", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ML_KEM_SEED */
                    if (ossl_unlikely(r->seed != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->seed = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef ml_kem_get_params_list
static ossl_unused const OSSL_PARAM ml_kem_get_params_list[] = {
    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_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_CMS_RI_TYPE, NULL),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_get_params_st
struct ml_kem_get_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *encpubkey;
    OSSL_PARAM *kemri_kdf_alg;
    OSSL_PARAM *maxsize;
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *ri_type;
    OSSL_PARAM *secbits;
    OSSL_PARAM *seccat;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_kem_get_params_decoder
static ossl_unused int ml_kem_get_params_decoder
    (const OSSL_PARAM *p, struct ml_kem_get_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 'b':
                if (ossl_likely(strcmp("its", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_BITS */
                    if (ossl_unlikely(r->bits != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bits = (OSSL_PARAM *)p;
                }
                break;
            case 'e':
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
                    if (ossl_unlikely(r->encpubkey != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->encpubkey = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("emri-kdf-alg", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM */
                    if (ossl_unlikely(r->kemri_kdf_alg != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->kemri_kdf_alg = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_MAX_SIZE */
                    if (ossl_unlikely(r->maxsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->maxsize = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
                        if (ossl_unlikely(r->privkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->privkey = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_KEY */
                        if (ossl_unlikely(r->pubkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pubkey = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'r':
                if (ossl_likely(strcmp("i-type", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_CMS_RI_TYPE */
                    if (ossl_unlikely(r->ri_type != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ri_type = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'c':
                        switch(s[3]) {
                        default:
                            break;
                        case 'u':
                            switch(s[4]) {
                            default:
                                break;
                            case 'r':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'i':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case 't':
                                        switch(s[7]) {
                                        default:
                                            break;
                                        case 'y':
                                            switch(s[8]) {
                                            default:
                                                break;
                                            case '-':
                                                switch(s[9]) {
                                                default:
                                                    break;
                                                case 'b':
                                                    if (ossl_likely(strcmp("its", s + 10) == 0)) {
                                                        /* OSSL_PKEY_PARAM_SECURITY_BITS */
                                                        if (ossl_unlikely(r->secbits != NULL)) {
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                           "param %s is repeated", s);
                                                            return 0;
                                                        }
                                                        r->secbits = (OSSL_PARAM *)p;
                                                    }
                                                    break;
                                                case 'c':
                                                    if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
                                                        /* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
                                                        if (ossl_unlikely(r->seccat != NULL)) {
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                           "param %s is repeated", s);
                                                            return 0;
                                                        }
                                                        r->seccat = (OSSL_PARAM *)p;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    case 'e':
                        if (ossl_likely(strcmp("d", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_ML_KEM_SEED */
                            if (ossl_unlikely(r->seed != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->seed = (OSSL_PARAM *)p;
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef ml_kem_set_params_list
static ossl_unused const OSSL_PARAM ml_kem_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_set_params_st
struct ml_kem_set_params_st {
    OSSL_PARAM *pub;
};
#endif

#ifndef ml_kem_set_params_decoder
static ossl_unused int ml_kem_set_params_decoder
    (const OSSL_PARAM *p, struct ml_kem_set_params_st *r)
{
    const char *s;

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

/* Machine generated */
#ifndef ml_kem_gen_set_params_list
static ossl_unused const OSSL_PARAM ml_kem_gen_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_gen_set_params_st
struct ml_kem_gen_set_params_st {
    OSSL_PARAM *propq;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_kem_gen_set_params_decoder
static ossl_unused int ml_kem_gen_set_params_decoder
    (const OSSL_PARAM *p, struct ml_kem_gen_set_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 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_PROPERTIES */
                    if (ossl_unlikely(r->propq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->propq = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                if (ossl_likely(strcmp("eed", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ML_KEM_SEED */
                    if (ossl_unlikely(r->seed != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->seed = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 2025-2026 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
12		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
13		#include <string.h>
14		#include <openssl/params.h>
15		#include <openssl/e_os2.h>
16		#include "internal/common.h"
17		#include "prov/proverr.h"
18
19		/* Machine generated */
20		#ifndef ml_kem_import_params_list
21		static ossl_unused const OSSL_PARAM ml_kem_import_params_list[] = {
22		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
23		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
24		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
25		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
26		OSSL_PARAM_END
27		};
28		#endif
29
30		#ifndef ml_kem_import_params_st
31		struct ml_kem_import_params_st {
32		OSSL_PARAM *privkey;
33		OSSL_PARAM *propq;
34		OSSL_PARAM *pubkey;
35		OSSL_PARAM *seed;
36		};
37		#endif
38
39		#ifndef ml_kem_import_params_decoder
40		static ossl_unused int ml_kem_import_params_decoder
41		(const OSSL_PARAM p, struct ml_kem_import_params_st r)
42	101	{
43	101	const char *s;
44
45	101	memset(r, 0, sizeof(*r));
46	101	if (p != NULL)
47	202	for (; (s = p->key) != NULL; p++)
48	101	switch(s[0]) {
49	0	default:
50	0	break;
51	101	case 'p':
52	101	switch(s[1]) {
53	0	default:
54	0	break;
55	36	case 'r':
56	36	switch(s[2]) {
57	0	default:
58	0	break;
59	36	case 'i':
60	36	if (ossl_likely(strcmp("v", s + 3) == 0)) {
61		/* OSSL_PKEY_PARAM_PRIV_KEY */
62	36	if (ossl_unlikely(r->privkey != NULL)) {
63	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
64	0	"param %s is repeated", s);
65	0	return 0;
66	0	}
67	36	r->privkey = (OSSL_PARAM *)p;
68	36	}
69	36	break;
70	36	case 'o':
71	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
72		/* OSSL_PKEY_PARAM_PROPERTIES */
73	0	if (ossl_unlikely(r->propq != NULL)) {
74	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
75	0	"param %s is repeated", s);
76	0	return 0;
77	0	}
78	0	r->propq = (OSSL_PARAM *)p;
79	0	}
80	36	}
81	36	break;
82	65	case 'u':
83	65	if (ossl_likely(strcmp("b", s + 2) == 0)) {
84		/* OSSL_PKEY_PARAM_PUB_KEY */
85	65	if (ossl_unlikely(r->pubkey != NULL)) {
86	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
87	0	"param %s is repeated", s);
88	0	return 0;
89	0	}
90	65	r->pubkey = (OSSL_PARAM *)p;
91	65	}
92	101	}
93	101	break;
94	101	case 's':
95	0	if (ossl_likely(strcmp("eed", s + 1) == 0)) {
96		/* OSSL_PKEY_PARAM_ML_KEM_SEED */
97	0	if (ossl_unlikely(r->seed != NULL)) {
98	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
99	0	"param %s is repeated", s);
100	0	return 0;
101	0	}
102	0	r->seed = (OSSL_PARAM *)p;
103	0	}
104	101	}
105	101	return 1;
106	101	}
107		#endif
108		/* End of machine generated */
109		/* Machine generated */
110		#ifndef ml_kem_export_params_list
111		static ossl_unused const OSSL_PARAM ml_kem_export_params_list[] = {
112		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
113		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
114		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
115		OSSL_PARAM_END
116		};
117		#endif
118
119		#ifndef ml_kem_export_params_st
120		struct ml_kem_export_params_st {
121		OSSL_PARAM *privkey;
122		OSSL_PARAM *pubkey;
123		OSSL_PARAM *seed;
124		};
125		#endif
126
127		#ifndef ml_kem_export_params_decoder
128		static ossl_unused int ml_kem_export_params_decoder
129		(const OSSL_PARAM p, struct ml_kem_export_params_st r)
130		{
131		const char *s;
132
133		memset(r, 0, sizeof(*r));
134		if (p != NULL)
135		for (; (s = p->key) != NULL; p++)
136		switch(s[0]) {
137		default:
138		break;
139		case 'p':
140		switch(s[1]) {
141		default:
142		break;
143		case 'r':
144		if (ossl_likely(strcmp("iv", s + 2) == 0)) {
145		/* OSSL_PKEY_PARAM_PRIV_KEY */
146		if (ossl_unlikely(r->privkey != NULL)) {
147		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
148		"param %s is repeated", s);
149		return 0;
150		}
151		r->privkey = (OSSL_PARAM *)p;
152		}
153		break;
154		case 'u':
155		if (ossl_likely(strcmp("b", s + 2) == 0)) {
156		/* OSSL_PKEY_PARAM_PUB_KEY */
157		if (ossl_unlikely(r->pubkey != NULL)) {
158		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
159		"param %s is repeated", s);
160		return 0;
161		}
162		r->pubkey = (OSSL_PARAM *)p;
163		}
164		}
165		break;
166		case 's':
167		if (ossl_likely(strcmp("eed", s + 1) == 0)) {
168		/* OSSL_PKEY_PARAM_ML_KEM_SEED */
169		if (ossl_unlikely(r->seed != NULL)) {
170		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
171		"param %s is repeated", s);
172		return 0;
173		}
174		r->seed = (OSSL_PARAM *)p;
175		}
176		}
177		return 1;
178		}
179		#endif
180		/* End of machine generated */
181
182		/* Machine generated */
183		#ifndef ml_kem_get_params_list
184		static ossl_unused const OSSL_PARAM ml_kem_get_params_list[] = {
185		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
186		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
187		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
188		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
189		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
190		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
191		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
192		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
193		OSSL_PARAM_int(OSSL_PKEY_PARAM_CMS_RI_TYPE, NULL),
194		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM, NULL, 0),
195		OSSL_PARAM_END
196		};
197		#endif
198
199		#ifndef ml_kem_get_params_st
200		struct ml_kem_get_params_st {
201		OSSL_PARAM *bits;
202		OSSL_PARAM *encpubkey;
203		OSSL_PARAM *kemri_kdf_alg;
204		OSSL_PARAM *maxsize;
205		OSSL_PARAM *privkey;
206		OSSL_PARAM *pubkey;
207		OSSL_PARAM *ri_type;
208		OSSL_PARAM *secbits;
209		OSSL_PARAM *seccat;
210		OSSL_PARAM *seed;
211		};
212		#endif
213
214		#ifndef ml_kem_get_params_decoder
215		static ossl_unused int ml_kem_get_params_decoder
216		(const OSSL_PARAM p, struct ml_kem_get_params_st r)
217	48.8k	{
218	48.8k	const char *s;
219
220	48.8k	memset(r, 0, sizeof(*r));
221	48.8k	if (p != NULL)
222	244k	for (; (s = p->key) != NULL; p++)
223	195k	switch(s[0]) {
224	0	default:
225	0	break;
226	48.8k	case 'b':
227	48.8k	if (ossl_likely(strcmp("its", s + 1) == 0)) {
228		/* OSSL_PKEY_PARAM_BITS */
229	48.8k	if (ossl_unlikely(r->bits != NULL)) {
230	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
231	0	"param %s is repeated", s);
232	0	return 0;
233	0	}
234	48.8k	r->bits = (OSSL_PARAM *)p;
235	48.8k	}
236	48.8k	break;
237	48.8k	case 'e':
238	0	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
239		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
240	0	if (ossl_unlikely(r->encpubkey != NULL)) {
241	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
242	0	"param %s is repeated", s);
243	0	return 0;
244	0	}
245	0	r->encpubkey = (OSSL_PARAM *)p;
246	0	}
247	0	break;
248	0	case 'k':
249	0	if (ossl_likely(strcmp("emri-kdf-alg", s + 1) == 0)) {
250		/* OSSL_PKEY_PARAM_CMS_KEMRI_KDF_ALGORITHM */
251	0	if (ossl_unlikely(r->kemri_kdf_alg != NULL)) {
252	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
253	0	"param %s is repeated", s);
254	0	return 0;
255	0	}
256	0	r->kemri_kdf_alg = (OSSL_PARAM *)p;
257	0	}
258	0	break;
259	48.8k	case 'm':
260	48.8k	if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
261		/* OSSL_PKEY_PARAM_MAX_SIZE */
262	48.8k	if (ossl_unlikely(r->maxsize != NULL)) {
263	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
264	0	"param %s is repeated", s);
265	0	return 0;
266	0	}
267	48.8k	r->maxsize = (OSSL_PARAM *)p;
268	48.8k	}
269	48.8k	break;
270	48.8k	case 'p':
271	0	switch(s[1]) {
272	0	default:
273	0	break;
274	0	case 'r':
275	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
276		/* OSSL_PKEY_PARAM_PRIV_KEY */
277	0	if (ossl_unlikely(r->privkey != NULL)) {
278	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
279	0	"param %s is repeated", s);
280	0	return 0;
281	0	}
282	0	r->privkey = (OSSL_PARAM *)p;
283	0	}
284	0	break;
285	0	case 'u':
286	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
287		/* OSSL_PKEY_PARAM_PUB_KEY */
288	0	if (ossl_unlikely(r->pubkey != NULL)) {
289	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
290	0	"param %s is repeated", s);
291	0	return 0;
292	0	}
293	0	r->pubkey = (OSSL_PARAM *)p;
294	0	}
295	0	}
296	0	break;
297	0	case 'r':
298	0	if (ossl_likely(strcmp("i-type", s + 1) == 0)) {
299		/* OSSL_PKEY_PARAM_CMS_RI_TYPE */
300	0	if (ossl_unlikely(r->ri_type != NULL)) {
301	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
302	0	"param %s is repeated", s);
303	0	return 0;
304	0	}
305	0	r->ri_type = (OSSL_PARAM *)p;
306	0	}
307	0	break;
308	97.7k	case 's':
309	97.7k	switch(s[1]) {
310	0	default:
311	0	break;
312	97.7k	case 'e':
313	97.7k	switch(s[2]) {
314	0	default:
315	0	break;
316	97.7k	case 'c':
317	97.7k	switch(s[3]) {
318	0	default:
319	0	break;
320	97.7k	case 'u':
321	97.7k	switch(s[4]) {
322	0	default:
323	0	break;
324	97.7k	case 'r':
325	97.7k	switch(s[5]) {
326	0	default:
327	0	break;
328	97.7k	case 'i':
329	97.7k	switch(s[6]) {
330	0	default:
331	0	break;
332	97.7k	case 't':
333	97.7k	switch(s[7]) {
334	0	default:
335	0	break;
336	97.7k	case 'y':
337	97.7k	switch(s[8]) {
338	0	default:
339	0	break;
340	97.7k	case '-':
341	97.7k	switch(s[9]) {
342	0	default:
343	0	break;
344	48.8k	case 'b':
345	48.8k	if (ossl_likely(strcmp("its", s + 10) == 0)) {
346		/* OSSL_PKEY_PARAM_SECURITY_BITS */
347	48.8k	if (ossl_unlikely(r->secbits != NULL)) {
348	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
349	0	"param %s is repeated", s);
350	0	return 0;
351	0	}
352	48.8k	r->secbits = (OSSL_PARAM *)p;
353	48.8k	}
354	48.8k	break;
355	48.8k	case 'c':
356	48.8k	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
357		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
358	48.8k	if (ossl_unlikely(r->seccat != NULL)) {
359	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
360	0	"param %s is repeated", s);
361	0	return 0;
362	0	}
363	48.8k	r->seccat = (OSSL_PARAM *)p;
364	48.8k	}
365	97.7k	}
366	97.7k	}
367	97.7k	}
368	97.7k	}
369	97.7k	}
370	97.7k	}
371	97.7k	}
372	97.7k	break;
373	97.7k	case 'e':
374	0	if (ossl_likely(strcmp("d", s + 3) == 0)) {
375		/* OSSL_PKEY_PARAM_ML_KEM_SEED */
376	0	if (ossl_unlikely(r->seed != NULL)) {
377	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
378	0	"param %s is repeated", s);
379	0	return 0;
380	0	}
381	0	r->seed = (OSSL_PARAM *)p;
382	0	}
383	97.7k	}
384	97.7k	}
385	195k	}
386	48.8k	return 1;
387	48.8k	}
388		#endif
389		/* End of machine generated */
390
391		/* Machine generated */
392		#ifndef ml_kem_set_params_list
393		static ossl_unused const OSSL_PARAM ml_kem_set_params_list[] = {
394		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
395		OSSL_PARAM_END
396		};
397		#endif
398
399		#ifndef ml_kem_set_params_st
400		struct ml_kem_set_params_st {
401		OSSL_PARAM *pub;
402		};
403		#endif
404
405		#ifndef ml_kem_set_params_decoder
406		static ossl_unused int ml_kem_set_params_decoder
407		(const OSSL_PARAM p, struct ml_kem_set_params_st r)
408	0	{
409	0	const char *s;
410
411	0	memset(r, 0, sizeof(*r));
412	0	if (p != NULL)
413	0	for (; (s = p->key) != NULL; p++)
414	0	if (ossl_likely(strcmp("encoded-pub-key", s + 0) == 0)) {
415		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
416	0	if (ossl_unlikely(r->pub != NULL)) {
417	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
418	0	"param %s is repeated", s);
419	0	return 0;
420	0	}
421	0	r->pub = (OSSL_PARAM *)p;
422	0	}
423	0	return 1;
424	0	}
425		#endif
426		/* End of machine generated */
427
428		/* Machine generated */
429		#ifndef ml_kem_gen_set_params_list
430		static ossl_unused const OSSL_PARAM ml_kem_gen_set_params_list[] = {
431		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_KEM_SEED, NULL, 0),
432		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
433		OSSL_PARAM_END
434		};
435		#endif
436
437		#ifndef ml_kem_gen_set_params_st
438		struct ml_kem_gen_set_params_st {
439		OSSL_PARAM *propq;
440		OSSL_PARAM *seed;
441		};
442		#endif
443
444		#ifndef ml_kem_gen_set_params_decoder
445		static ossl_unused int ml_kem_gen_set_params_decoder
446		(const OSSL_PARAM p, struct ml_kem_gen_set_params_st r)
447	96.4k	{
448	96.4k	const char *s;
449
450	96.4k	memset(r, 0, sizeof(*r));
451	96.4k	if (p != NULL)
452	47.9k	for (; (s = p->key) != NULL; p++)
453	0	switch(s[0]) {
454	0	default:
455	0	break;
456	0	case 'p':
457	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
458		/* OSSL_PKEY_PARAM_PROPERTIES */
459	0	if (ossl_unlikely(r->propq != NULL)) {
460	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
461	0	"param %s is repeated", s);
462	0	return 0;
463	0	}
464	0	r->propq = (OSSL_PARAM *)p;
465	0	}
466	0	break;
467	0	case 's':
468	0	if (ossl_likely(strcmp("eed", s + 1) == 0)) {
469		/* OSSL_PKEY_PARAM_ML_KEM_SEED */
470	0	if (ossl_unlikely(r->seed != NULL)) {
471	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
472	0	"param %s is repeated", s);
473	0	return 0;
474	0	}
475	0	r->seed = (OSSL_PARAM *)p;
476	0	}
477	0	}
478	96.4k	return 1;
479	96.4k	}
480		#endif
481		/* End of machine generated */