/src/openssl/providers/implementations/macs/hmac_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 hmac_get_ctx_params_list
static const OSSL_PARAM hmac_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 hmac_get_ctx_params_st
struct hmac_get_ctx_params_st {
    OSSL_PARAM *bsize;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *size;
};
#endif

#ifndef hmac_get_ctx_params_decoder
static int hmac_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct hmac_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 hmac_set_ctx_params_list
static const OSSL_PARAM hmac_set_ctx_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_KEY_CHECK, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef hmac_set_ctx_params_st
struct hmac_set_ctx_params_st {
    OSSL_PARAM *digest;
    OSSL_PARAM *engine;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_k;
# endif
    OSSL_PARAM *key;
    OSSL_PARAM *propq;
    OSSL_PARAM *tlssize;
};
#endif

#ifndef hmac_set_ctx_params_decoder
static int hmac_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct hmac_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 'd':
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_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 'e':
                if (ossl_likely(strcmp("ngine", s + 1) == 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':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'y':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
# if defined(FIPS_MODULE)
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
                                /* OSSL_MAC_PARAM_FIPS_KEY_CHECK */
                                if (ossl_unlikely(r->ind_k != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->ind_k = (OSSL_PARAM *)p;
                            }
# endif
                            break;
                        case '\0':
                            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;
                }
                break;
            case 't':
                if (ossl_likely(strcmp("ls-data-size", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_TLS_DATA_SIZE */
                    if (ossl_unlikely(r->tlssize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->tlssize = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2025-11-07 06:36

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 hmac_get_ctx_params_list
14		static const OSSL_PARAM hmac_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 hmac_get_ctx_params_st
25		struct hmac_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 hmac_get_ctx_params_decoder
35		static int hmac_get_ctx_params_decoder
36		(const OSSL_PARAM p, struct hmac_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 hmac_set_ctx_params_list
88		static const OSSL_PARAM hmac_set_ctx_params_list[] = {
89		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_DIGEST, 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		OSSL_PARAM_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE, NULL),
93		# if defined(FIPS_MODULE)
94		OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_KEY_CHECK, NULL),
95		# endif
96		OSSL_PARAM_END
97		};
98		#endif
99
100		#ifndef hmac_set_ctx_params_st
101		struct hmac_set_ctx_params_st {
102		OSSL_PARAM *digest;
103		OSSL_PARAM *engine;
104		# if defined(FIPS_MODULE)
105		OSSL_PARAM *ind_k;
106		# endif
107		OSSL_PARAM *key;
108		OSSL_PARAM *propq;
109		OSSL_PARAM *tlssize;
110		};
111		#endif
112
113		#ifndef hmac_set_ctx_params_decoder
114		static int hmac_set_ctx_params_decoder
115		(const OSSL_PARAM p, struct hmac_set_ctx_params_st r)
116	0	{
117	0	const char *s;
118
119	0	memset(r, 0, sizeof(*r));
120	0	if (p != NULL)
121	0	for (; (s = p->key) != NULL; p++)
122	0	switch(s[0]) {
123	0	default:
124	0	break;
125	0	case 'd':
126	0	if (ossl_likely(strcmp("igest", s + 1) == 0)) {
127		/* OSSL_MAC_PARAM_DIGEST */
128	0	if (ossl_unlikely(r->digest != NULL)) {
129	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
130	0	"param %s is repeated", s);
131	0	return 0;
132	0	}
133	0	r->digest = (OSSL_PARAM *)p;
134	0	}
135	0	break;
136	0	case 'e':
137	0	if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
138		/* OSSL_ALG_PARAM_ENGINE */
139	0	if (ossl_unlikely(r->engine != NULL)) {
140	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
141	0	"param %s is repeated", s);
142	0	return 0;
143	0	}
144	0	r->engine = (OSSL_PARAM *)p;
145	0	}
146	0	break;
147	0	case 'k':
148	0	switch(s[1]) {
149	0	default:
150	0	break;
151	0	case 'e':
152	0	switch(s[2]) {
153	0	default:
154	0	break;
155	0	case 'y':
156	0	switch(s[3]) {
157	0	default:
158	0	break;
159	0	case '-':
160		# if defined(FIPS_MODULE)
161		if (ossl_likely(strcmp("check", s + 4) == 0)) {
162		/* OSSL_MAC_PARAM_FIPS_KEY_CHECK */
163		if (ossl_unlikely(r->ind_k != NULL)) {
164		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
165		"param %s is repeated", s);
166		return 0;
167		}
168		r->ind_k = (OSSL_PARAM *)p;
169		}
170		# endif
171	0	break;
172	0	case '\0':
173	0	if (ossl_unlikely(r->key != NULL)) {
174	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
175	0	"param %s is repeated", s);
176	0	return 0;
177	0	}
178	0	r->key = (OSSL_PARAM *)p;
179	0	}
180	0	}
181	0	}
182	0	break;
183	0	case 'p':
184	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
185		/* OSSL_MAC_PARAM_PROPERTIES */
186	0	if (ossl_unlikely(r->propq != NULL)) {
187	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
188	0	"param %s is repeated", s);
189	0	return 0;
190	0	}
191	0	r->propq = (OSSL_PARAM *)p;
192	0	}
193	0	break;
194	0	case 't':
195	0	if (ossl_likely(strcmp("ls-data-size", s + 1) == 0)) {
196		/* OSSL_MAC_PARAM_TLS_DATA_SIZE */
197	0	if (ossl_unlikely(r->tlssize != NULL)) {
198	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
199	0	"param %s is repeated", s);
200	0	return 0;
201	0	}
202	0	r->tlssize = (OSSL_PARAM *)p;
203	0	}
204	0	}
205	0	return 1;
206	0	}
207		#endif
208		/* End of machine generated */