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

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

#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;
# 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':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ncrypt-check", s + 1) == 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 '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		#include <string.h>
14		#include <openssl/params.h>
15		#include "internal/common.h"
16		#include "prov/proverr.h"
17
18		#ifndef cmac_get_ctx_params_list
19		static const OSSL_PARAM cmac_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 cmac_get_ctx_params_st
30		struct cmac_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 cmac_get_ctx_params_decoder
40		static int cmac_get_ctx_params_decoder
41		(const OSSL_PARAM p, struct cmac_get_ctx_params_st r)
42	596	{
43	596	const char *s;
44
45	596	memset(r, 0, sizeof(*r));
46	596	if (p != NULL)
47	1.19k	for (; (s = p->key) != NULL; p++)
48	596	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	596	case 's':
76	596	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
77		/* OSSL_MAC_PARAM_SIZE */
78	596	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	596	r->size = (OSSL_PARAM *)p;
84	596	}
85	596	}
86	596	return 1;
87	596	}
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 cmac_set_ctx_params_list
98		static const OSSL_PARAM cmac_set_ctx_params_list[] = {
99		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_CIPHER, 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		# if defined(FIPS_MODULE)
103		OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK, NULL),
104		# endif
105		OSSL_PARAM_END
106		};
107		#endif
108
109		#ifndef cmac_set_ctx_params_st
110		struct cmac_set_ctx_params_st {
111		OSSL_PARAM *cipher;
112		# if defined(FIPS_MODULE)
113		OSSL_PARAM *ind_ec;
114		# endif
115		OSSL_PARAM *key;
116		OSSL_PARAM *propq;
117		};
118		#endif
119
120		#ifndef cmac_set_ctx_params_decoder
121		static int cmac_set_ctx_params_decoder
122		(const OSSL_PARAM p, struct cmac_set_ctx_params_st r)
123	299	{
124	299	const char *s;
125
126	299	memset(r, 0, sizeof(*r));
127	299	if (p != NULL)
128	528	for (; (s = p->key) != NULL; p++)
129	347	switch(s[0]) {
130	72	default:
131	72	break;
132	118	case 'c':
133	118	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
134		/* OSSL_MAC_PARAM_CIPHER */
135	118	if (ossl_unlikely(r->cipher != NULL)) {
136	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
137	0	"param %s is repeated", s);
138	0	return 0;
139	0	}
140	118	r->cipher = (OSSL_PARAM *)p;
141	118	}
142	118	break;
143	118	case 'e':
144		# if defined(FIPS_MODULE)
145		if (ossl_likely(strcmp("ncrypt-check", s + 1) == 0)) {
146		/* OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK */
147		if (ossl_unlikely(r->ind_ec != NULL)) {
148		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
149		"param %s is repeated", s);
150		return 0;
151		}
152		r->ind_ec = (OSSL_PARAM *)p;
153		}
154		# endif
155	0	break;
156	46	case 'k':
157	46	if (ossl_likely(strcmp("ey", s + 1) == 0)) {
158		/* OSSL_MAC_PARAM_KEY */
159	46	if (ossl_unlikely(r->key != NULL)) {
160	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
161	0	"param %s is repeated", s);
162	0	return 0;
163	0	}
164	46	r->key = (OSSL_PARAM *)p;
165	46	}
166	46	break;
167	111	case 'p':
168	111	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
169		/* OSSL_MAC_PARAM_PROPERTIES */
170	111	if (ossl_unlikely(r->propq != NULL)) {
171	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
172	0	"param %s is repeated", s);
173	0	return 0;
174	0	}
175	111	r->propq = (OSSL_PARAM *)p;
176	111	}
177	347	}
178	299	return 1;
179	299	}
180		#endif
181		/* End of machine generated */

Coverage Report

Created: 2026-07-23 06:28