/src/openssl/providers/implementations/keymgmt/ecx_kmgmt.inc

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



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

#ifndef ecx_imexport_types_st
struct ecx_imexport_types_st {
    OSSL_PARAM *priv;
    OSSL_PARAM *pub;
};
#endif

#ifndef ecx_imexport_types_decoder
static int ecx_imexport_types_decoder
    (const OSSL_PARAM *p, struct ecx_imexport_types_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->priv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->priv = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_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 by util/perl/OpenSSL/paramnames.pm */
#ifndef ecx_get_params_list
static const OSSL_PARAM ecx_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_PUB_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef ecx_get_params_st
struct ecx_get_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *encpub;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *priv;
    OSSL_PARAM *pub;
    OSSL_PARAM *secbits;
    OSSL_PARAM *seccat;
    OSSL_PARAM *size;
};
#endif

#ifndef ecx_get_params_decoder
static int ecx_get_params_decoder
    (const OSSL_PARAM *p, struct ecx_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->encpub != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->encpub = (OSSL_PARAM *)p;
                }
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR */
                    if (ossl_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 'm':
                if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_MAX_SIZE */
                    if (ossl_unlikely(r->size != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->size = (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->priv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->priv = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_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;
                    }
                }
                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;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ed_get_params_list
static const OSSL_PARAM ed_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_PUB_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ed_get_params_st
struct ed_get_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *digest;
    OSSL_PARAM *priv;
    OSSL_PARAM *pub;
    OSSL_PARAM *secbits;
    OSSL_PARAM *seccat;
    OSSL_PARAM *size;
};
#endif

#ifndef ed_get_params_decoder
static int ed_get_params_decoder
    (const OSSL_PARAM *p, struct ed_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 'm':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    switch(s[2]) {
                    default:
                        break;
                    case 'n':
                        if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
                            if (ossl_unlikely(r->digest != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->digest = (OSSL_PARAM *)p;
                        }
                        break;
                    case 'x':
                        if (ossl_likely(strcmp("-size", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_MAX_SIZE */
                            if (ossl_unlikely(r->size != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->size = (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->priv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->priv = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_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;
                    }
                }
                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;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

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

#ifndef ecx_set_params_st
struct ecx_set_params_st {
    OSSL_PARAM *propq;
    OSSL_PARAM *pub;
};
#endif

#ifndef ecx_set_params_decoder
static int ecx_set_params_decoder
    (const OSSL_PARAM *p, struct ecx_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 'e':
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 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;
                }
                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;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

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

#ifndef ecx_gen_set_params_st
struct ecx_gen_set_params_st {
    OSSL_PARAM *group;
    OSSL_PARAM *ikm;
    OSSL_PARAM *kdfpropq;
};
#endif

#ifndef ecx_gen_set_params_decoder
static int ecx_gen_set_params_decoder
    (const OSSL_PARAM *p, struct ecx_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 'd':
                if (ossl_likely(strcmp("hkem-ikm", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_DHKEM_IKM */
                    if (ossl_unlikely(r->ikm != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ikm = (OSSL_PARAM *)p;
                }
                break;
            case 'g':
                if (ossl_likely(strcmp("roup", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_GROUP_NAME */
                    if (ossl_unlikely(r->group != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->group = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_PROPERTIES */
                    if (ossl_unlikely(r->kdfpropq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->kdfpropq = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2025-12-04 06:33

Line	Count	Source
1		/*
2		* Copyright 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
12		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
13		#ifndef ecx_imexport_types_list
14		static const OSSL_PARAM ecx_imexport_types_list[] = {
15		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
16		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
17		OSSL_PARAM_END
18		};
19		#endif
20
21		#ifndef ecx_imexport_types_st
22		struct ecx_imexport_types_st {
23		OSSL_PARAM *priv;
24		OSSL_PARAM *pub;
25		};
26		#endif
27
28		#ifndef ecx_imexport_types_decoder
29		static int ecx_imexport_types_decoder
30		(const OSSL_PARAM p, struct ecx_imexport_types_st r)
31	17	{
32	17	const char *s;
33
34	17	memset(r, 0, sizeof(*r));
35	17	if (p != NULL)
36	34	for (; (s = p->key) != NULL; p++)
37	17	switch(s[0]) {
38	0	default:
39	0	break;
40	17	case 'p':
41	17	switch(s[1]) {
42	0	default:
43	0	break;
44	0	case 'r':
45	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
46		/* OSSL_PKEY_PARAM_PRIV_KEY */
47	0	if (ossl_unlikely(r->priv != NULL)) {
48	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
49	0	"param %s is repeated", s);
50	0	return 0;
51	0	}
52	0	r->priv = (OSSL_PARAM *)p;
53	0	}
54	0	break;
55	17	case 'u':
56	17	if (ossl_likely(strcmp("b", s + 2) == 0)) {
57		/* OSSL_PKEY_PARAM_PUB_KEY */
58	17	if (ossl_unlikely(r->pub != NULL)) {
59	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
60	0	"param %s is repeated", s);
61	0	return 0;
62	0	}
63	17	r->pub = (OSSL_PARAM *)p;
64	17	}
65	17	}
66	17	}
67	17	return 1;
68	17	}
69		#endif
70		/* End of machine generated */
71
72		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
73		#ifndef ecx_get_params_list
74		static const OSSL_PARAM ecx_get_params_list[] = {
75		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
76		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
77		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
78		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
79		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
80		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
81		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
82		# if defined(FIPS_MODULE)
83		OSSL_PARAM_int(OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR, NULL),
84		# endif
85		OSSL_PARAM_END
86		};
87		#endif
88
89		#ifndef ecx_get_params_st
90		struct ecx_get_params_st {
91		OSSL_PARAM *bits;
92		OSSL_PARAM *encpub;
93		# if defined(FIPS_MODULE)
94		OSSL_PARAM *ind;
95		# endif
96		OSSL_PARAM *priv;
97		OSSL_PARAM *pub;
98		OSSL_PARAM *secbits;
99		OSSL_PARAM *seccat;
100		OSSL_PARAM *size;
101		};
102		#endif
103
104		#ifndef ecx_get_params_decoder
105		static int ecx_get_params_decoder
106		(const OSSL_PARAM p, struct ecx_get_params_st r)
107	126k	{
108	126k	const char *s;
109
110	126k	memset(r, 0, sizeof(*r));
111	126k	if (p != NULL)
112	454k	for (; (s = p->key) != NULL; p++)
113	328k	switch(s[0]) {
114	0	default:
115	0	break;
116	67.3k	case 'b':
117	67.3k	if (ossl_likely(strcmp("its", s + 1) == 0)) {
118		/* OSSL_PKEY_PARAM_BITS */
119	67.3k	if (ossl_unlikely(r->bits != NULL)) {
120	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
121	0	"param %s is repeated", s);
122	0	return 0;
123	0	}
124	67.3k	r->bits = (OSSL_PARAM *)p;
125	67.3k	}
126	67.3k	break;
127	67.3k	case 'e':
128	58.8k	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
129		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
130	58.8k	if (ossl_unlikely(r->encpub != NULL)) {
131	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
132	0	"param %s is repeated", s);
133	0	return 0;
134	0	}
135	58.8k	r->encpub = (OSSL_PARAM *)p;
136	58.8k	}
137	58.8k	break;
138	58.8k	case 'f':
139		# if defined(FIPS_MODULE)
140		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
141		/* OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR */
142		if (ossl_unlikely(r->ind != NULL)) {
143		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
144		"param %s is repeated", s);
145		return 0;
146		}
147		r->ind = (OSSL_PARAM *)p;
148		}
149		# endif
150	0	break;
151	67.3k	case 'm':
152	67.3k	if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
153		/* OSSL_PKEY_PARAM_MAX_SIZE */
154	67.3k	if (ossl_unlikely(r->size != NULL)) {
155	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
156	0	"param %s is repeated", s);
157	0	return 0;
158	0	}
159	67.3k	r->size = (OSSL_PARAM *)p;
160	67.3k	}
161	67.3k	break;
162	67.3k	case 'p':
163	0	switch(s[1]) {
164	0	default:
165	0	break;
166	0	case 'r':
167	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
168		/* OSSL_PKEY_PARAM_PRIV_KEY */
169	0	if (ossl_unlikely(r->priv != NULL)) {
170	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
171	0	"param %s is repeated", s);
172	0	return 0;
173	0	}
174	0	r->priv = (OSSL_PARAM *)p;
175	0	}
176	0	break;
177	0	case 'u':
178	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
179		/* OSSL_PKEY_PARAM_PUB_KEY */
180	0	if (ossl_unlikely(r->pub != NULL)) {
181	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
182	0	"param %s is repeated", s);
183	0	return 0;
184	0	}
185	0	r->pub = (OSSL_PARAM *)p;
186	0	}
187	0	}
188	0	break;
189	134k	case 's':
190	134k	switch(s[1]) {
191	0	default:
192	0	break;
193	134k	case 'e':
194	134k	switch(s[2]) {
195	0	default:
196	0	break;
197	134k	case 'c':
198	134k	switch(s[3]) {
199	0	default:
200	0	break;
201	134k	case 'u':
202	134k	switch(s[4]) {
203	0	default:
204	0	break;
205	134k	case 'r':
206	134k	switch(s[5]) {
207	0	default:
208	0	break;
209	134k	case 'i':
210	134k	switch(s[6]) {
211	0	default:
212	0	break;
213	134k	case 't':
214	134k	switch(s[7]) {
215	0	default:
216	0	break;
217	134k	case 'y':
218	134k	switch(s[8]) {
219	0	default:
220	0	break;
221	134k	case '-':
222	134k	switch(s[9]) {
223	0	default:
224	0	break;
225	67.3k	case 'b':
226	67.3k	if (ossl_likely(strcmp("its", s + 10) == 0)) {
227		/* OSSL_PKEY_PARAM_SECURITY_BITS */
228	67.3k	if (ossl_unlikely(r->secbits != NULL)) {
229	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
230	0	"param %s is repeated", s);
231	0	return 0;
232	0	}
233	67.3k	r->secbits = (OSSL_PARAM *)p;
234	67.3k	}
235	67.3k	break;
236	67.3k	case 'c':
237	67.3k	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
238		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
239	67.3k	if (ossl_unlikely(r->seccat != NULL)) {
240	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
241	0	"param %s is repeated", s);
242	0	return 0;
243	0	}
244	67.3k	r->seccat = (OSSL_PARAM *)p;
245	67.3k	}
246	134k	}
247	134k	}
248	134k	}
249	134k	}
250	134k	}
251	134k	}
252	134k	}
253	134k	}
254	134k	}
255	328k	}
256	126k	return 1;
257	126k	}
258		#endif
259		/* End of machine generated */
260
261		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
262		#ifndef ed_get_params_list
263		static const OSSL_PARAM ed_get_params_list[] = {
264		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
265		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
266		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
267		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
268		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
269		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
270		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
271		OSSL_PARAM_END
272		};
273		#endif
274
275		#ifndef ed_get_params_st
276		struct ed_get_params_st {
277		OSSL_PARAM *bits;
278		OSSL_PARAM *digest;
279		OSSL_PARAM *priv;
280		OSSL_PARAM *pub;
281		OSSL_PARAM *secbits;
282		OSSL_PARAM *seccat;
283		OSSL_PARAM *size;
284		};
285		#endif
286
287		#ifndef ed_get_params_decoder
288		static int ed_get_params_decoder
289		(const OSSL_PARAM p, struct ed_get_params_st r)
290	126	{
291	126	const char *s;
292
293	126	memset(r, 0, sizeof(*r));
294	126	if (p != NULL)
295	630	for (; (s = p->key) != NULL; p++)
296	504	switch(s[0]) {
297	0	default:
298	0	break;
299	126	case 'b':
300	126	if (ossl_likely(strcmp("its", s + 1) == 0)) {
301		/* OSSL_PKEY_PARAM_BITS */
302	126	if (ossl_unlikely(r->bits != NULL)) {
303	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
304	0	"param %s is repeated", s);
305	0	return 0;
306	0	}
307	126	r->bits = (OSSL_PARAM *)p;
308	126	}
309	126	break;
310	126	case 'm':
311	126	switch(s[1]) {
312	0	default:
313	0	break;
314	126	case 'a':
315	126	switch(s[2]) {
316	0	default:
317	0	break;
318	0	case 'n':
319	0	if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
320		/* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
321	0	if (ossl_unlikely(r->digest != NULL)) {
322	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
323	0	"param %s is repeated", s);
324	0	return 0;
325	0	}
326	0	r->digest = (OSSL_PARAM *)p;
327	0	}
328	0	break;
329	126	case 'x':
330	126	if (ossl_likely(strcmp("-size", s + 3) == 0)) {
331		/* OSSL_PKEY_PARAM_MAX_SIZE */
332	126	if (ossl_unlikely(r->size != NULL)) {
333	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
334	0	"param %s is repeated", s);
335	0	return 0;
336	0	}
337	126	r->size = (OSSL_PARAM *)p;
338	126	}
339	126	}
340	126	}
341	126	break;
342	126	case 'p':
343	0	switch(s[1]) {
344	0	default:
345	0	break;
346	0	case 'r':
347	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
348		/* OSSL_PKEY_PARAM_PRIV_KEY */
349	0	if (ossl_unlikely(r->priv != NULL)) {
350	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
351	0	"param %s is repeated", s);
352	0	return 0;
353	0	}
354	0	r->priv = (OSSL_PARAM *)p;
355	0	}
356	0	break;
357	0	case 'u':
358	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
359		/* OSSL_PKEY_PARAM_PUB_KEY */
360	0	if (ossl_unlikely(r->pub != NULL)) {
361	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
362	0	"param %s is repeated", s);
363	0	return 0;
364	0	}
365	0	r->pub = (OSSL_PARAM *)p;
366	0	}
367	0	}
368	0	break;
369	252	case 's':
370	252	switch(s[1]) {
371	0	default:
372	0	break;
373	252	case 'e':
374	252	switch(s[2]) {
375	0	default:
376	0	break;
377	252	case 'c':
378	252	switch(s[3]) {
379	0	default:
380	0	break;
381	252	case 'u':
382	252	switch(s[4]) {
383	0	default:
384	0	break;
385	252	case 'r':
386	252	switch(s[5]) {
387	0	default:
388	0	break;
389	252	case 'i':
390	252	switch(s[6]) {
391	0	default:
392	0	break;
393	252	case 't':
394	252	switch(s[7]) {
395	0	default:
396	0	break;
397	252	case 'y':
398	252	switch(s[8]) {
399	0	default:
400	0	break;
401	252	case '-':
402	252	switch(s[9]) {
403	0	default:
404	0	break;
405	126	case 'b':
406	126	if (ossl_likely(strcmp("its", s + 10) == 0)) {
407		/* OSSL_PKEY_PARAM_SECURITY_BITS */
408	126	if (ossl_unlikely(r->secbits != NULL)) {
409	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
410	0	"param %s is repeated", s);
411	0	return 0;
412	0	}
413	126	r->secbits = (OSSL_PARAM *)p;
414	126	}
415	126	break;
416	126	case 'c':
417	126	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
418		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
419	126	if (ossl_unlikely(r->seccat != NULL)) {
420	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
421	0	"param %s is repeated", s);
422	0	return 0;
423	0	}
424	126	r->seccat = (OSSL_PARAM *)p;
425	126	}
426	252	}
427	252	}
428	252	}
429	252	}
430	252	}
431	252	}
432	252	}
433	252	}
434	252	}
435	504	}
436	126	return 1;
437	126	}
438		#endif
439		/* End of machine generated */
440
441		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
442		#ifndef ecx_set_params_list
443		static const OSSL_PARAM ecx_set_params_list[] = {
444		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
445		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
446		OSSL_PARAM_END
447		};
448		#endif
449
450		#ifndef ecx_set_params_st
451		struct ecx_set_params_st {
452		OSSL_PARAM *propq;
453		OSSL_PARAM *pub;
454		};
455		#endif
456
457		#ifndef ecx_set_params_decoder
458		static int ecx_set_params_decoder
459		(const OSSL_PARAM p, struct ecx_set_params_st r)
460	10.4k	{
461	10.4k	const char *s;
462
463	10.4k	memset(r, 0, sizeof(*r));
464	10.4k	if (p != NULL)
465	20.8k	for (; (s = p->key) != NULL; p++)
466	10.4k	switch(s[0]) {
467	0	default:
468	0	break;
469	10.4k	case 'e':
470	10.4k	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
471		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
472	10.4k	if (ossl_unlikely(r->pub != NULL)) {
473	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
474	0	"param %s is repeated", s);
475	0	return 0;
476	0	}
477	10.4k	r->pub = (OSSL_PARAM *)p;
478	10.4k	}
479	10.4k	break;
480	10.4k	case 'p':
481	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
482		/* OSSL_PKEY_PARAM_PROPERTIES */
483	0	if (ossl_unlikely(r->propq != NULL)) {
484	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
485	0	"param %s is repeated", s);
486	0	return 0;
487	0	}
488	0	r->propq = (OSSL_PARAM *)p;
489	0	}
490	10.4k	}
491	10.4k	return 1;
492	10.4k	}
493		#endif
494		/* End of machine generated */
495
496		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
497		#ifndef ecx_gen_set_params_list
498		static const OSSL_PARAM ecx_gen_set_params_list[] = {
499		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
500		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
501		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DHKEM_IKM, NULL, 0),
502		OSSL_PARAM_END
503		};
504		#endif
505
506		#ifndef ecx_gen_set_params_st
507		struct ecx_gen_set_params_st {
508		OSSL_PARAM *group;
509		OSSL_PARAM *ikm;
510		OSSL_PARAM *kdfpropq;
511		};
512		#endif
513
514		#ifndef ecx_gen_set_params_decoder
515		static int ecx_gen_set_params_decoder
516		(const OSSL_PARAM p, struct ecx_gen_set_params_st r)
517	114k	{
518	114k	const char *s;
519
520	114k	memset(r, 0, sizeof(*r));
521	114k	if (p != NULL)
522	86.4k	for (; (s = p->key) != NULL; p++)
523	29.9k	switch(s[0]) {
524	0	default:
525	0	break;
526	0	case 'd':
527	0	if (ossl_likely(strcmp("hkem-ikm", s + 1) == 0)) {
528		/* OSSL_PKEY_PARAM_DHKEM_IKM */
529	0	if (ossl_unlikely(r->ikm != NULL)) {
530	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
531	0	"param %s is repeated", s);
532	0	return 0;
533	0	}
534	0	r->ikm = (OSSL_PARAM *)p;
535	0	}
536	0	break;
537	29.9k	case 'g':
538	29.9k	if (ossl_likely(strcmp("roup", s + 1) == 0)) {
539		/* OSSL_PKEY_PARAM_GROUP_NAME */
540	29.9k	if (ossl_unlikely(r->group != NULL)) {
541	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
542	0	"param %s is repeated", s);
543	0	return 0;
544	0	}
545	29.9k	r->group = (OSSL_PARAM *)p;
546	29.9k	}
547	29.9k	break;
548	29.9k	case 'p':
549	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
550		/* OSSL_KDF_PARAM_PROPERTIES */
551	0	if (ossl_unlikely(r->kdfpropq != NULL)) {
552	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
553	0	"param %s is repeated", s);
554	0	return 0;
555	0	}
556	0	r->kdfpropq = (OSSL_PARAM *)p;
557	0	}
558	29.9k	}
559	114k	return 1;
560	114k	}
561		#endif
562		/* End of machine generated */