/src/openssl/providers/implementations/macs/cmac_prov.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 cmac_get_ctx_params_list
static const OSSL_PARAM cmac_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef cmac_get_ctx_params_st
struct cmac_get_ctx_params_st {
    OSSL_PARAM *bsize;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *size;
};
#endif

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

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'b':
                if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_BLOCK_SIZE */
                    if (ossl_unlikely(r->bsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bsize = (OSSL_PARAM *)p;
                }
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_ALG_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 's':
                if (ossl_likely(strcmp("ize", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_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;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef cmac_set_ctx_params_list
static const OSSL_PARAM cmac_set_ctx_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef cmac_set_ctx_params_st
struct cmac_set_ctx_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *engine;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_ec;
# endif
    OSSL_PARAM *key;
    OSSL_PARAM *propq;
};
#endif

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

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'c':
                if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_CIPHER */
                    if (ossl_unlikely(r->cipher != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->cipher = (OSSL_PARAM *)p;
                }
                break;
            case 'e':
                switch(s[1]) {
                default:
                    break;
                case 'n':
                    switch(s[2]) {
                    default:
                        break;
                    case 'c':
# if defined(FIPS_MODULE)
                        if (ossl_likely(strcmp("rypt-check", s + 3) == 0)) {
                            /* OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK */
                            if (ossl_unlikely(r->ind_ec != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->ind_ec = (OSSL_PARAM *)p;
                        }
# endif
                        break;
                    case 'g':
                        if (ossl_likely(strcmp("ine", s + 3) == 0)) {
                            /* OSSL_ALG_PARAM_ENGINE */
                            if (ossl_unlikely(r->engine != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->engine = (OSSL_PARAM *)p;
                        }
                    }
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("ey", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_KEY */
                    if (ossl_unlikely(r->key != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->key = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_MAC_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 */

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 cmac_get_ctx_params_list
14		static const OSSL_PARAM cmac_get_ctx_params_list[] = {
15		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
16		OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
17		# if defined(FIPS_MODULE)
18		OSSL_PARAM_int(OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR, NULL),
19		# endif
20		OSSL_PARAM_END
21		};
22		#endif
23
24		#ifndef cmac_get_ctx_params_st
25		struct cmac_get_ctx_params_st {
26		OSSL_PARAM *bsize;
27		# if defined(FIPS_MODULE)
28		OSSL_PARAM *ind;
29		# endif
30		OSSL_PARAM *size;
31		};
32		#endif
33
34		#ifndef cmac_get_ctx_params_decoder
35		static int cmac_get_ctx_params_decoder
36		(const OSSL_PARAM p, struct cmac_get_ctx_params_st r)
37	0	{
38	0	const char *s;
39
40	0	memset(r, 0, sizeof(*r));
41	0	if (p != NULL)
42	0	for (; (s = p->key) != NULL; p++)
43	0	switch(s[0]) {
44	0	default:
45	0	break;
46	0	case 'b':
47	0	if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
48		/* OSSL_MAC_PARAM_BLOCK_SIZE */
49	0	if (ossl_unlikely(r->bsize != NULL)) {
50	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
51	0	"param %s is repeated", s);
52	0	return 0;
53	0	}
54	0	r->bsize = (OSSL_PARAM *)p;
55	0	}
56	0	break;
57	0	case 'f':
58		# if defined(FIPS_MODULE)
59		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
60		/* OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR */
61		if (ossl_unlikely(r->ind != NULL)) {
62		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
63		"param %s is repeated", s);
64		return 0;
65		}
66		r->ind = (OSSL_PARAM *)p;
67		}
68		# endif
69	0	break;
70	0	case 's':
71	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
72		/* OSSL_MAC_PARAM_SIZE */
73	0	if (ossl_unlikely(r->size != 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->size = (OSSL_PARAM *)p;
79	0	}
80	0	}
81	0	return 1;
82	0	}
83		#endif
84		/* End of machine generated */
85
86		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
87		#ifndef cmac_set_ctx_params_list
88		static const OSSL_PARAM cmac_set_ctx_params_list[] = {
89		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_CIPHER, NULL, 0),
90		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
91		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
92		# if defined(FIPS_MODULE)
93		OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK, NULL),
94		# endif
95		OSSL_PARAM_END
96		};
97		#endif
98
99		#ifndef cmac_set_ctx_params_st
100		struct cmac_set_ctx_params_st {
101		OSSL_PARAM *cipher;
102		OSSL_PARAM *engine;
103		# if defined(FIPS_MODULE)
104		OSSL_PARAM *ind_ec;
105		# endif
106		OSSL_PARAM *key;
107		OSSL_PARAM *propq;
108		};
109		#endif
110
111		#ifndef cmac_set_ctx_params_decoder
112		static int cmac_set_ctx_params_decoder
113		(const OSSL_PARAM p, struct cmac_set_ctx_params_st r)
114	0	{
115	0	const char *s;
116
117	0	memset(r, 0, sizeof(*r));
118	0	if (p != NULL)
119	0	for (; (s = p->key) != NULL; p++)
120	0	switch(s[0]) {
121	0	default:
122	0	break;
123	0	case 'c':
124	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
125		/* OSSL_MAC_PARAM_CIPHER */
126	0	if (ossl_unlikely(r->cipher != 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	0	r->cipher = (OSSL_PARAM *)p;
132	0	}
133	0	break;
134	0	case 'e':
135	0	switch(s[1]) {
136	0	default:
137	0	break;
138	0	case 'n':
139	0	switch(s[2]) {
140	0	default:
141	0	break;
142	0	case 'c':
143		# if defined(FIPS_MODULE)
144		if (ossl_likely(strcmp("rypt-check", s + 3) == 0)) {
145		/* OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK */
146		if (ossl_unlikely(r->ind_ec != NULL)) {
147		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
148		"param %s is repeated", s);
149		return 0;
150		}
151		r->ind_ec = (OSSL_PARAM *)p;
152		}
153		# endif
154	0	break;
155	0	case 'g':
156	0	if (ossl_likely(strcmp("ine", s + 3) == 0)) {
157		/* OSSL_ALG_PARAM_ENGINE */
158	0	if (ossl_unlikely(r->engine != NULL)) {
159	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
160	0	"param %s is repeated", s);
161	0	return 0;
162	0	}
163	0	r->engine = (OSSL_PARAM *)p;
164	0	}
165	0	}
166	0	}
167	0	break;
168	0	case 'k':
169	0	if (ossl_likely(strcmp("ey", s + 1) == 0)) {
170		/* OSSL_MAC_PARAM_KEY */
171	0	if (ossl_unlikely(r->key != NULL)) {
172	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
173	0	"param %s is repeated", s);
174	0	return 0;
175	0	}
176	0	r->key = (OSSL_PARAM *)p;
177	0	}
178	0	break;
179	0	case 'p':
180	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
181		/* OSSL_MAC_PARAM_PROPERTIES */
182	0	if (ossl_unlikely(r->propq != NULL)) {
183	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
184	0	"param %s is repeated", s);
185	0	return 0;
186	0	}
187	0	r->propq = (OSSL_PARAM *)p;
188	0	}
189	0	}
190	0	return 1;
191	0	}
192		#endif
193		/* End of machine generated */

Coverage Report

Created: 2025-11-07 06:36