/src/openssl/providers/implementations/include/prov/blake2_params.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
 */


#include <string.h>
#include "internal/common.h"

/* 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 blake2_get_ctx_list
static ossl_unused const OSSL_PARAM blake2_get_ctx_list[] = {
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef blake2_get_ctx_st
struct blake2_get_ctx_st {
    OSSL_PARAM *bsize;
    OSSL_PARAM *size;
};
#endif

#ifndef blake2_get_ctx_decoder
static ossl_unused int blake2_get_ctx_decoder
    (const OSSL_PARAM *p, struct blake2_get_ctx_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 '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 */
#ifndef blake2_mac_set_ctx_list
static ossl_unused const OSSL_PARAM blake2_mac_set_ctx_list[] = {
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_CUSTOM, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_SALT, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef blake2_mac_set_ctx_st
struct blake2_mac_set_ctx_st {
    OSSL_PARAM *cust;
    OSSL_PARAM *key;
    OSSL_PARAM *salt;
    OSSL_PARAM *size;
};
#endif

#ifndef blake2_mac_set_ctx_decoder
static ossl_unused int blake2_mac_set_ctx_decoder
    (const OSSL_PARAM *p, struct blake2_mac_set_ctx_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("ustom", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_CUSTOM */
                    if (ossl_unlikely(r->cust != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->cust = (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 's':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("lt", s + 2) == 0)) {
                        /* OSSL_MAC_PARAM_SALT */
                        if (ossl_unlikely(r->salt != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->salt = (OSSL_PARAM *)p;
                    }
                    break;
                case 'i':
                    if (ossl_likely(strcmp("ze", s + 2) == 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 */
    

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		#include <string.h>
12		#include "internal/common.h"
13
14		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
15		#include <string.h>
16		#include <openssl/params.h>
17		#include <openssl/e_os2.h>
18		#include "internal/common.h"
19		#include "prov/proverr.h"
20
21		/* Machine generated */
22		#ifndef blake2_get_ctx_list
23		static ossl_unused const OSSL_PARAM blake2_get_ctx_list[] = {
24		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
25		OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
26		OSSL_PARAM_END
27		};
28		#endif
29
30		#ifndef blake2_get_ctx_st
31		struct blake2_get_ctx_st {
32		OSSL_PARAM *bsize;
33		OSSL_PARAM *size;
34		};
35		#endif
36
37		#ifndef blake2_get_ctx_decoder
38		static ossl_unused int blake2_get_ctx_decoder
39		(const OSSL_PARAM p, struct blake2_get_ctx_st r)
40	0	{
41	0	const char *s;
42
43	0	memset(r, 0, sizeof(*r));
44	0	if (p != NULL)
45	0	for (; (s = p->key) != NULL; p++)
46	0	switch(s[0]) {
47	0	default:
48	0	break;
49	0	case 'b':
50	0	if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
51		/* OSSL_MAC_PARAM_BLOCK_SIZE */
52	0	if (ossl_unlikely(r->bsize != NULL)) {
53	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
54	0	"param %s is repeated", s);
55	0	return 0;
56	0	}
57	0	r->bsize = (OSSL_PARAM *)p;
58	0	}
59	0	break;
60	0	case 's':
61	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
62		/* OSSL_MAC_PARAM_SIZE */
63	0	if (ossl_unlikely(r->size != NULL)) {
64	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
65	0	"param %s is repeated", s);
66	0	return 0;
67	0	}
68	0	r->size = (OSSL_PARAM *)p;
69	0	}
70	0	}
71	0	return 1;
72	0	} Unexecuted instantiation: blake2b_mac.c:blake2_get_ctx_decoder Unexecuted instantiation: blake2s_mac.c:blake2_get_ctx_decoder
73		#endif
74		/* End of machine generated */
75
76		/* Machine generated */
77		#ifndef blake2_mac_set_ctx_list
78		static ossl_unused const OSSL_PARAM blake2_mac_set_ctx_list[] = {
79		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
80		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
81		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_CUSTOM, NULL, 0),
82		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_SALT, NULL, 0),
83		OSSL_PARAM_END
84		};
85		#endif
86
87		#ifndef blake2_mac_set_ctx_st
88		struct blake2_mac_set_ctx_st {
89		OSSL_PARAM *cust;
90		OSSL_PARAM *key;
91		OSSL_PARAM *salt;
92		OSSL_PARAM *size;
93		};
94		#endif
95
96		#ifndef blake2_mac_set_ctx_decoder
97		static ossl_unused int blake2_mac_set_ctx_decoder
98		(const OSSL_PARAM p, struct blake2_mac_set_ctx_st r)
99	0	{
100	0	const char *s;
101
102	0	memset(r, 0, sizeof(*r));
103	0	if (p != NULL)
104	0	for (; (s = p->key) != NULL; p++)
105	0	switch(s[0]) {
106	0	default:
107	0	break;
108	0	case 'c':
109	0	if (ossl_likely(strcmp("ustom", s + 1) == 0)) {
110		/* OSSL_MAC_PARAM_CUSTOM */
111	0	if (ossl_unlikely(r->cust != NULL)) {
112	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
113	0	"param %s is repeated", s);
114	0	return 0;
115	0	}
116	0	r->cust = (OSSL_PARAM *)p;
117	0	}
118	0	break;
119	0	case 'k':
120	0	if (ossl_likely(strcmp("ey", s + 1) == 0)) {
121		/* OSSL_MAC_PARAM_KEY */
122	0	if (ossl_unlikely(r->key != NULL)) {
123	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
124	0	"param %s is repeated", s);
125	0	return 0;
126	0	}
127	0	r->key = (OSSL_PARAM *)p;
128	0	}
129	0	break;
130	0	case 's':
131	0	switch(s[1]) {
132	0	default:
133	0	break;
134	0	case 'a':
135	0	if (ossl_likely(strcmp("lt", s + 2) == 0)) {
136		/* OSSL_MAC_PARAM_SALT */
137	0	if (ossl_unlikely(r->salt != 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->salt = (OSSL_PARAM *)p;
143	0	}
144	0	break;
145	0	case 'i':
146	0	if (ossl_likely(strcmp("ze", s + 2) == 0)) {
147		/* OSSL_MAC_PARAM_SIZE */
148	0	if (ossl_unlikely(r->size != NULL)) {
149	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
150	0	"param %s is repeated", s);
151	0	return 0;
152	0	}
153	0	r->size = (OSSL_PARAM *)p;
154	0	}
155	0	}
156	0	}
157	0	return 1;
158	0	} Unexecuted instantiation: blake2b_mac.c:blake2_mac_set_ctx_decoder Unexecuted instantiation: blake2s_mac.c:blake2_mac_set_ctx_decoder
159		#endif
160		/* End of machine generated */
161

Coverage Report

Created: 2026-09-13 06:13