/src/openssl/providers/implementations/include/prov/blake2_params.inc

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

Coverage Report

Created: 2025-08-28 06:41