/src/openssl41/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 */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef ecx_imexport_types_list
static ossl_unused 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 ossl_unused 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 */
#ifndef ecx_get_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef ed_get_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef ecx_set_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef ecx_gen_set_params_list
static ossl_unused 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 ossl_unused 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: 2026-09-12 06:55

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