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

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

#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;
# 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 '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: 2026-05-20 07:05

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 "internal/common.h"
16		#include "prov/proverr.h"
17
18		#ifndef hmac_get_ctx_params_list
19		static const OSSL_PARAM hmac_get_ctx_params_list[] = {
20		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
21		OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
22		# if defined(FIPS_MODULE)
23		OSSL_PARAM_int(OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR, NULL),
24		# endif
25		OSSL_PARAM_END
26		};
27		#endif
28
29		#ifndef hmac_get_ctx_params_st
30		struct hmac_get_ctx_params_st {
31		OSSL_PARAM *bsize;
32		# if defined(FIPS_MODULE)
33		OSSL_PARAM *ind;
34		# endif
35		OSSL_PARAM *size;
36		};
37		#endif
38
39		#ifndef hmac_get_ctx_params_decoder
40		static int hmac_get_ctx_params_decoder
41		(const OSSL_PARAM p, struct hmac_get_ctx_params_st r)
42	0	{
43	0	const char *s;
44
45	0	memset(r, 0, sizeof(*r));
46	0	if (p != NULL)
47	0	for (; (s = p->key) != NULL; p++)
48	0	switch(s[0]) {
49	0	default:
50	0	break;
51	0	case 'b':
52	0	if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
53		/* OSSL_MAC_PARAM_BLOCK_SIZE */
54	0	if (ossl_unlikely(r->bsize != 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->bsize = (OSSL_PARAM *)p;
60	0	}
61	0	break;
62	0	case 'f':
63		# if defined(FIPS_MODULE)
64		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
65		/* OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR */
66		if (ossl_unlikely(r->ind != NULL)) {
67		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
68		"param %s is repeated", s);
69		return 0;
70		}
71		r->ind = (OSSL_PARAM *)p;
72		}
73		# endif
74	0	break;
75	0	case 's':
76	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
77		/* OSSL_MAC_PARAM_SIZE */
78	0	if (ossl_unlikely(r->size != NULL)) {
79	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
80	0	"param %s is repeated", s);
81	0	return 0;
82	0	}
83	0	r->size = (OSSL_PARAM *)p;
84	0	}
85	0	}
86	0	return 1;
87	0	}
88		#endif
89		/* End of machine generated */
90
91		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
92		#include <string.h>
93		#include <openssl/params.h>
94		#include "internal/common.h"
95		#include "prov/proverr.h"
96
97		#ifndef hmac_set_ctx_params_list
98		static const OSSL_PARAM hmac_set_ctx_params_list[] = {
99		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_DIGEST, NULL, 0),
100		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
101		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
102		OSSL_PARAM_size_t(OSSL_MAC_PARAM_TLS_DATA_SIZE, NULL),
103		# if defined(FIPS_MODULE)
104		OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_KEY_CHECK, NULL),
105		# endif
106		OSSL_PARAM_END
107		};
108		#endif
109
110		#ifndef hmac_set_ctx_params_st
111		struct hmac_set_ctx_params_st {
112		OSSL_PARAM *digest;
113		# if defined(FIPS_MODULE)
114		OSSL_PARAM *ind_k;
115		# endif
116		OSSL_PARAM *key;
117		OSSL_PARAM *propq;
118		OSSL_PARAM *tlssize;
119		};
120		#endif
121
122		#ifndef hmac_set_ctx_params_decoder
123		static int hmac_set_ctx_params_decoder
124		(const OSSL_PARAM p, struct hmac_set_ctx_params_st r)
125	0	{
126	0	const char *s;
127
128	0	memset(r, 0, sizeof(*r));
129	0	if (p != NULL)
130	0	for (; (s = p->key) != NULL; p++)
131	0	switch(s[0]) {
132	0	default:
133	0	break;
134	0	case 'd':
135	0	if (ossl_likely(strcmp("igest", s + 1) == 0)) {
136		/* OSSL_MAC_PARAM_DIGEST */
137	0	if (ossl_unlikely(r->digest != 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	0	r->digest = (OSSL_PARAM *)p;
143	0	}
144	0	break;
145	0	case 'k':
146	0	switch(s[1]) {
147	0	default:
148	0	break;
149	0	case 'e':
150	0	switch(s[2]) {
151	0	default:
152	0	break;
153	0	case 'y':
154	0	switch(s[3]) {
155	0	default:
156	0	break;
157	0	case '-':
158		# if defined(FIPS_MODULE)
159		if (ossl_likely(strcmp("check", s + 4) == 0)) {
160		/* OSSL_MAC_PARAM_FIPS_KEY_CHECK */
161		if (ossl_unlikely(r->ind_k != NULL)) {
162		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
163		"param %s is repeated", s);
164		return 0;
165		}
166		r->ind_k = (OSSL_PARAM *)p;
167		}
168		# endif
169	0	break;
170	0	case '\0':
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	}
179	0	}
180	0	break;
181	0	case 'p':
182	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
183		/* OSSL_MAC_PARAM_PROPERTIES */
184	0	if (ossl_unlikely(r->propq != NULL)) {
185	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
186	0	"param %s is repeated", s);
187	0	return 0;
188	0	}
189	0	r->propq = (OSSL_PARAM *)p;
190	0	}
191	0	break;
192	0	case 't':
193	0	if (ossl_likely(strcmp("ls-data-size", s + 1) == 0)) {
194		/* OSSL_MAC_PARAM_TLS_DATA_SIZE */
195	0	if (ossl_unlikely(r->tlssize != NULL)) {
196	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
197	0	"param %s is repeated", s);
198	0	return 0;
199	0	}
200	0	r->tlssize = (OSSL_PARAM *)p;
201	0	}
202	0	}
203	0	return 1;
204	0	}
205		#endif
206		/* End of machine generated */