/src/openssl41/providers/implementations/ciphers/ciphercommon_ccm.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 ossl_cipher_ccm_set_ctx_params_list
static ossl_unused const OSSL_PARAM ossl_cipher_ccm_set_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ossl_cipher_ccm_set_ctx_params_st
struct ossl_cipher_ccm_set_ctx_params_st {
    OSSL_PARAM *aad;
    OSSL_PARAM *fixed;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *tag;
};
#endif

#ifndef ossl_cipher_ccm_set_ctx_params_decoder
static ossl_unused int ossl_cipher_ccm_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct ossl_cipher_ccm_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 'i':
                if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_AEAD_IVLEN */
                    if (ossl_unlikely(r->ivlen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ivlen = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("g", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_AEAD_TAG */
                        if (ossl_unlikely(r->tag != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->tag = (OSSL_PARAM *)p;
                    }
                    break;
                case 'l':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case 'a':
                            if (ossl_likely(strcmp("ad", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD */
                                if (ossl_unlikely(r->aad != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->aad = (OSSL_PARAM *)p;
                            }
                            break;
                        case 'i':
                            if (ossl_likely(strcmp("vfixed", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED */
                                if (ossl_unlikely(r->fixed != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->fixed = (OSSL_PARAM *)p;
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef ossl_cipher_ccm_get_ctx_params_list
static ossl_unused const OSSL_PARAM ossl_cipher_ccm_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef ossl_cipher_ccm_get_ctx_params_st
struct ossl_cipher_ccm_get_ctx_params_st {
    OSSL_PARAM *iv;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *keylen;
    OSSL_PARAM *pad;
    OSSL_PARAM *tag;
    OSSL_PARAM *taglen;
    OSSL_PARAM *updiv;
};
#endif

#ifndef ossl_cipher_ccm_get_ctx_params_decoder
static ossl_unused int ossl_cipher_ccm_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct ossl_cipher_ccm_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 'i':
                switch(s[1]) {
                default:
                    break;
                case 'v':
                    switch(s[2]) {
                    default:
                        break;
                    case 'l':
                        if (ossl_likely(strcmp("en", s + 3) == 0)) {
                            /* OSSL_CIPHER_PARAM_IVLEN */
                            if (ossl_unlikely(r->ivlen != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->ivlen = (OSSL_PARAM *)p;
                        }
                        break;
                    case '\0':
                        if (ossl_unlikely(r->iv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->iv = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->keylen = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    switch(s[2]) {
                    default:
                        break;
                    case 'g':
                        switch(s[3]) {
                        default:
                            break;
                        case 'l':
                            if (ossl_likely(strcmp("en", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_AEAD_TAGLEN */
                                if (ossl_unlikely(r->taglen != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->taglen = (OSSL_PARAM *)p;
                            }
                            break;
                        case '\0':
                            if (ossl_unlikely(r->tag != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->tag = (OSSL_PARAM *)p;
                        }
                    }
                    break;
                case 'l':
                    if (ossl_likely(strcmp("saadpad", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD */
                        if (ossl_unlikely(r->pad != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pad = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_UPDATED_IV */
                    if (ossl_unlikely(r->updiv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->updiv = (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 ossl_cipher_ccm_set_ctx_params_list
21		static ossl_unused const OSSL_PARAM ossl_cipher_ccm_set_ctx_params_list[] = {
22		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_IVLEN, NULL),
23		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
24		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD, NULL, 0),
25		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED, NULL, 0),
26		OSSL_PARAM_END
27		};
28		#endif
29
30		#ifndef ossl_cipher_ccm_set_ctx_params_st
31		struct ossl_cipher_ccm_set_ctx_params_st {
32		OSSL_PARAM *aad;
33		OSSL_PARAM *fixed;
34		OSSL_PARAM *ivlen;
35		OSSL_PARAM *tag;
36		};
37		#endif
38
39		#ifndef ossl_cipher_ccm_set_ctx_params_decoder
40		static ossl_unused int ossl_cipher_ccm_set_ctx_params_decoder
41		(const OSSL_PARAM p, struct ossl_cipher_ccm_set_ctx_params_st r)
42	44.6k	{
43	44.6k	const char *s;
44
45	44.6k	memset(r, 0, sizeof(*r));
46	44.6k	if (p != NULL)
47	86.9k	for (; (s = p->key) != NULL; p++)
48	43.8k	switch(s[0]) {
49	1	default:
50	1	break;
51	768	case 'i':
52	768	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
53		/* OSSL_CIPHER_PARAM_AEAD_IVLEN */
54	768	if (ossl_unlikely(r->ivlen != 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	768	r->ivlen = (OSSL_PARAM *)p;
60	768	}
61	768	break;
62	43.0k	case 't':
63	43.0k	switch(s[1]) {
64	0	default:
65	0	break;
66	768	case 'a':
67	768	if (ossl_likely(strcmp("g", s + 2) == 0)) {
68		/* OSSL_CIPHER_PARAM_AEAD_TAG */
69	768	if (ossl_unlikely(r->tag != NULL)) {
70	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
71	0	"param %s is repeated", s);
72	0	return 0;
73	0	}
74	768	r->tag = (OSSL_PARAM *)p;
75	768	}
76	768	break;
77	42.3k	case 'l':
78	42.3k	switch(s[2]) {
79	0	default:
80	0	break;
81	42.3k	case 's':
82	42.3k	switch(s[3]) {
83	1.50k	default:
84	1.50k	break;
85	40.0k	case 'a':
86	40.0k	if (ossl_likely(strcmp("ad", s + 4) == 0)) {
87		/* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD */
88	40.0k	if (ossl_unlikely(r->aad != NULL)) {
89	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
90	0	"param %s is repeated", s);
91	0	return 0;
92	0	}
93	40.0k	r->aad = (OSSL_PARAM *)p;
94	40.0k	}
95	40.0k	break;
96	40.0k	case 'i':
97	768	if (ossl_likely(strcmp("vfixed", s + 4) == 0)) {
98		/* OSSL_CIPHER_PARAM_AEAD_TLS1_IV_FIXED */
99	768	if (ossl_unlikely(r->fixed != NULL)) {
100	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
101	0	"param %s is repeated", s);
102	0	return 0;
103	0	}
104	768	r->fixed = (OSSL_PARAM *)p;
105	768	}
106	42.3k	}
107	42.3k	}
108	43.0k	}
109	43.8k	}
110	44.6k	return 1;
111	44.6k	}
112		#endif
113		/* End of machine generated */
114
115		/* Machine generated */
116		#ifndef ossl_cipher_ccm_get_ctx_params_list
117		static ossl_unused const OSSL_PARAM ossl_cipher_ccm_get_ctx_params_list[] = {
118		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
119		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
120		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TAGLEN, NULL),
121		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
122		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
123		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_AEAD_TAG, NULL, 0),
124		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD, NULL),
125		OSSL_PARAM_END
126		};
127		#endif
128
129		#ifndef ossl_cipher_ccm_get_ctx_params_st
130		struct ossl_cipher_ccm_get_ctx_params_st {
131		OSSL_PARAM *iv;
132		OSSL_PARAM *ivlen;
133		OSSL_PARAM *keylen;
134		OSSL_PARAM *pad;
135		OSSL_PARAM *tag;
136		OSSL_PARAM *taglen;
137		OSSL_PARAM *updiv;
138		};
139		#endif
140
141		#ifndef ossl_cipher_ccm_get_ctx_params_decoder
142		static ossl_unused int ossl_cipher_ccm_get_ctx_params_decoder
143		(const OSSL_PARAM p, struct ossl_cipher_ccm_get_ctx_params_st r)
144	40.7k	{
145	40.7k	const char *s;
146
147	40.7k	memset(r, 0, sizeof(*r));
148	40.7k	if (p != NULL)
149	81.5k	for (; (s = p->key) != NULL; p++)
150	40.7k	switch(s[0]) {
151	0	default:
152	0	break;
153	14	case 'i':
154	14	switch(s[1]) {
155	0	default:
156	0	break;
157	14	case 'v':
158	14	switch(s[2]) {
159	0	default:
160	0	break;
161	14	case 'l':
162	14	if (ossl_likely(strcmp("en", s + 3) == 0)) {
163		/* OSSL_CIPHER_PARAM_IVLEN */
164	14	if (ossl_unlikely(r->ivlen != NULL)) {
165	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
166	0	"param %s is repeated", s);
167	0	return 0;
168	0	}
169	14	r->ivlen = (OSSL_PARAM *)p;
170	14	}
171	14	break;
172	14	case '\0':
173	0	if (ossl_unlikely(r->iv != 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->iv = (OSSL_PARAM *)p;
179	14	}
180	14	}
181	14	break;
182	770	case 'k':
183	770	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
184		/* OSSL_CIPHER_PARAM_KEYLEN */
185	770	if (ossl_unlikely(r->keylen != NULL)) {
186	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
187	0	"param %s is repeated", s);
188	0	return 0;
189	0	}
190	770	r->keylen = (OSSL_PARAM *)p;
191	770	}
192	770	break;
193	39.9k	case 't':
194	39.9k	switch(s[1]) {
195	0	default:
196	0	break;
197	0	case 'a':
198	0	switch(s[2]) {
199	0	default:
200	0	break;
201	0	case 'g':
202	0	switch(s[3]) {
203	0	default:
204	0	break;
205	0	case 'l':
206	0	if (ossl_likely(strcmp("en", s + 4) == 0)) {
207		/* OSSL_CIPHER_PARAM_AEAD_TAGLEN */
208	0	if (ossl_unlikely(r->taglen != NULL)) {
209	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
210	0	"param %s is repeated", s);
211	0	return 0;
212	0	}
213	0	r->taglen = (OSSL_PARAM *)p;
214	0	}
215	0	break;
216	0	case '\0':
217	0	if (ossl_unlikely(r->tag != NULL)) {
218	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
219	0	"param %s is repeated", s);
220	0	return 0;
221	0	}
222	0	r->tag = (OSSL_PARAM *)p;
223	0	}
224	0	}
225	0	break;
226	39.9k	case 'l':
227	39.9k	if (ossl_likely(strcmp("saadpad", s + 2) == 0)) {
228		/* OSSL_CIPHER_PARAM_AEAD_TLS1_AAD_PAD */
229	39.9k	if (ossl_unlikely(r->pad != NULL)) {
230	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
231	0	"param %s is repeated", s);
232	0	return 0;
233	0	}
234	39.9k	r->pad = (OSSL_PARAM *)p;
235	39.9k	}
236	39.9k	}
237	39.9k	break;
238	39.9k	case 'u':
239	0	if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
240		/* OSSL_CIPHER_PARAM_UPDATED_IV */
241	0	if (ossl_unlikely(r->updiv != NULL)) {
242	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
243	0	"param %s is repeated", s);
244	0	return 0;
245	0	}
246	0	r->updiv = (OSSL_PARAM *)p;
247	0	}
248	40.7k	}
249	40.7k	return 1;
250	40.7k	}
251		#endif
252		/* End of machine generated */