/src/openssl/providers/implementations/ciphers/cipher_null.c

Source
/*
 * Copyright 2020-2024 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 <openssl/crypto.h>
#include <openssl/core_dispatch.h>
#include <openssl/proverr.h>
#include "prov/implementations.h"
#include "prov/ciphercommon.h"
#include "prov/providercommon.h"

typedef struct prov_cipher_null_ctx_st {
    int enc;
    size_t tlsmacsize;
    const unsigned char *tlsmac;
} PROV_CIPHER_NULL_CTX;

static OSSL_FUNC_cipher_newctx_fn null_newctx;
static void *null_newctx(void *provctx)
{
    if (!ossl_prov_is_running())
        return NULL;

    return OPENSSL_zalloc(sizeof(PROV_CIPHER_NULL_CTX));
}

static OSSL_FUNC_cipher_freectx_fn null_freectx;
static void null_freectx(void *vctx)
{
    OPENSSL_free(vctx);
}

static OSSL_FUNC_cipher_encrypt_init_fn null_einit;
static int null_einit(void *vctx, const unsigned char *key, size_t keylen,
                      const unsigned char *iv, size_t ivlen,
                      const OSSL_PARAM params[])
{
    PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;

    ctx->enc = 1;
    return 1;
}

static OSSL_FUNC_cipher_decrypt_init_fn null_dinit;
static int null_dinit(void *vctx, const unsigned char *key, size_t keylen,
                      const unsigned char *iv, size_t ivlen,
                      const OSSL_PARAM params[])
{
    if (!ossl_prov_is_running())
        return 0;

    return 1;
}

static OSSL_FUNC_cipher_cipher_fn null_cipher;
static int null_cipher(void *vctx, unsigned char *out, size_t *outl,
                       size_t outsize, const unsigned char *in, size_t inl)
{
    PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;

    if (!ossl_prov_is_running())
        return 0;

    if (!ctx->enc && ctx->tlsmacsize > 0) {
        /*
         * TLS NULL cipher as per:
         * https://tools.ietf.org/html/rfc5246#section-6.2.3.1
         */
        if (inl < ctx->tlsmacsize)
            return 0;
        ctx->tlsmac = in + inl - ctx->tlsmacsize;
        inl -= ctx->tlsmacsize;
    }
    if (outsize < inl)
        return 0;
    if (out != NULL && in != out)
        memcpy(out, in, inl);
    *outl = inl;
    return 1;
}

static OSSL_FUNC_cipher_final_fn null_final;
static int null_final(void *vctx, unsigned char *out, size_t *outl,
                      size_t outsize)
{
    if (!ossl_prov_is_running())
        return 0;

    *outl = 0;
    return 1;
}

static OSSL_FUNC_cipher_get_params_fn null_get_params;
static int null_get_params(OSSL_PARAM params[])
{
    return ossl_cipher_generic_get_params(params, 0, 0, 0, 8, 0);
}

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef null_get_ctx_params_list
static const OSSL_PARAM null_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
    OSSL_PARAM_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef null_get_ctx_params_st
struct null_get_ctx_params_st {
    OSSL_PARAM *ivlen;
    OSSL_PARAM *keylen;
    OSSL_PARAM *mac;
};
#endif

#ifndef null_get_ctx_params_decoder
static int null_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct null_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':
                if (ossl_likely(strcmp("vlen", s + 1) == 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 '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':
                if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_TLS_MAC */
                    if (ossl_unlikely(r->mac != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->mac = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

static OSSL_FUNC_cipher_gettable_ctx_params_fn null_gettable_ctx_params;
static const OSSL_PARAM *null_gettable_ctx_params(ossl_unused void *cctx,
                                                  ossl_unused void *provctx)
{
    return null_get_ctx_params_list;
}

static OSSL_FUNC_cipher_get_ctx_params_fn null_get_ctx_params;
static int null_get_ctx_params(void *vctx, OSSL_PARAM params[])
{
    PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;
    struct null_get_ctx_params_st p;

    if (ctx == NULL || !null_get_ctx_params_decoder(params, &p))
        return 0;

    if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, 0)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }

    if (p.mac != NULL
        && !OSSL_PARAM_set_octet_ptr(p.mac, ctx->tlsmac, ctx->tlsmacsize)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
        return 0;
    }
    return 1;
}

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef null_set_ctx_params_list
static const OSSL_PARAM null_set_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef null_set_ctx_params_st
struct null_set_ctx_params_st {
    OSSL_PARAM *macsize;
};
#endif

#ifndef null_set_ctx_params_decoder
static int null_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct null_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("tls-mac-size", s + 0) == 0)) {
                /* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
                if (ossl_unlikely(r->macsize != NULL)) {
                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                   "param %s is repeated", s);
                    return 0;
                }
                r->macsize = (OSSL_PARAM *)p;
            }
    return 1;
}
#endif
/* End of machine generated */

static OSSL_FUNC_cipher_settable_ctx_params_fn null_settable_ctx_params;
static const OSSL_PARAM *null_settable_ctx_params(ossl_unused void *cctx,
                                                  ossl_unused void *provctx)
{
    return null_set_ctx_params_list;
}


static OSSL_FUNC_cipher_set_ctx_params_fn null_set_ctx_params;
static int null_set_ctx_params(void *vctx, const OSSL_PARAM params[])
{
    PROV_CIPHER_NULL_CTX *ctx = (PROV_CIPHER_NULL_CTX *)vctx;
    struct null_set_ctx_params_st p;

    if (ctx == NULL || !null_set_ctx_params_decoder(params, &p))
        return 0;

    if (p.macsize != NULL
            && !OSSL_PARAM_get_size_t(p.macsize, &ctx->tlsmacsize)) {
        ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
        return 0;
    }

    return 1;
}

const OSSL_DISPATCH ossl_null_functions[] = {
    { OSSL_FUNC_CIPHER_NEWCTX,
      (void (*)(void)) null_newctx },
    { OSSL_FUNC_CIPHER_FREECTX, (void (*)(void)) null_freectx },
    { OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void)) null_newctx },
    { OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))null_einit },
    { OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))null_dinit },
    { OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))null_cipher },
    { OSSL_FUNC_CIPHER_FINAL, (void (*)(void))null_final },
    { OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))null_cipher },
    { OSSL_FUNC_CIPHER_GET_PARAMS, (void (*)(void)) null_get_params },
    { OSSL_FUNC_CIPHER_GETTABLE_PARAMS,
        (void (*)(void))ossl_cipher_generic_gettable_params },
    { OSSL_FUNC_CIPHER_GET_CTX_PARAMS, (void (*)(void))null_get_ctx_params },
    { OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,
      (void (*)(void))null_gettable_ctx_params },
    { OSSL_FUNC_CIPHER_SET_CTX_PARAMS, (void (*)(void))null_set_ctx_params },
    { OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,
      (void (*)(void))null_settable_ctx_params },
    OSSL_DISPATCH_END
};

Coverage Report

Created: 2025-10-10 07:01

Line	Count	Source
1		/*
2		* Copyright 2020-2024 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 <openssl/crypto.h>
13		#include <openssl/core_dispatch.h>
14		#include <openssl/proverr.h>
15		#include "prov/implementations.h"
16		#include "prov/ciphercommon.h"
17		#include "prov/providercommon.h"
18
19		typedef struct prov_cipher_null_ctx_st {
20		int enc;
21		size_t tlsmacsize;
22		const unsigned char *tlsmac;
23		} PROV_CIPHER_NULL_CTX;
24
25		static OSSL_FUNC_cipher_newctx_fn null_newctx;
26		static void null_newctx(void provctx)
27	0	{
28	0	if (!ossl_prov_is_running())
29	0	return NULL;
30
31	0	return OPENSSL_zalloc(sizeof(PROV_CIPHER_NULL_CTX));
32	0	}
33
34		static OSSL_FUNC_cipher_freectx_fn null_freectx;
35		static void null_freectx(void *vctx)
36	0	{
37	0	OPENSSL_free(vctx);
38	0	}
39
40		static OSSL_FUNC_cipher_encrypt_init_fn null_einit;
41		static int null_einit(void vctx, const unsigned char key, size_t keylen,
42		const unsigned char *iv, size_t ivlen,
43		const OSSL_PARAM params[])
44	0	{
45	0	PROV_CIPHER_NULL_CTX ctx = (PROV_CIPHER_NULL_CTX )vctx;
46
47	0	if (!ossl_prov_is_running())
48	0	return 0;
49
50	0	ctx->enc = 1;
51	0	return 1;
52	0	}
53
54		static OSSL_FUNC_cipher_decrypt_init_fn null_dinit;
55		static int null_dinit(void vctx, const unsigned char key, size_t keylen,
56		const unsigned char *iv, size_t ivlen,
57		const OSSL_PARAM params[])
58	0	{
59	0	if (!ossl_prov_is_running())
60	0	return 0;
61
62	0	return 1;
63	0	}
64
65		static OSSL_FUNC_cipher_cipher_fn null_cipher;
66		static int null_cipher(void vctx, unsigned char out, size_t *outl,
67		size_t outsize, const unsigned char *in, size_t inl)
68	0	{
69	0	PROV_CIPHER_NULL_CTX ctx = (PROV_CIPHER_NULL_CTX )vctx;
70
71	0	if (!ossl_prov_is_running())
72	0	return 0;
73
74	0	if (!ctx->enc && ctx->tlsmacsize > 0) {
75		/*
76		* TLS NULL cipher as per:
77		* https://tools.ietf.org/html/rfc5246#section-6.2.3.1
78		*/
79	0	if (inl < ctx->tlsmacsize)
80	0	return 0;
81	0	ctx->tlsmac = in + inl - ctx->tlsmacsize;
82	0	inl -= ctx->tlsmacsize;
83	0	}
84	0	if (outsize < inl)
85	0	return 0;
86	0	if (out != NULL && in != out)
87	0	memcpy(out, in, inl);
88	0	*outl = inl;
89	0	return 1;
90	0	}
91
92		static OSSL_FUNC_cipher_final_fn null_final;
93		static int null_final(void vctx, unsigned char out, size_t *outl,
94		size_t outsize)
95	0	{
96	0	if (!ossl_prov_is_running())
97	0	return 0;
98
99	0	*outl = 0;
100	0	return 1;
101	0	}
102
103		static OSSL_FUNC_cipher_get_params_fn null_get_params;
104		static int null_get_params(OSSL_PARAM params[])
105	16	{
106	16	return ossl_cipher_generic_get_params(params, 0, 0, 0, 8, 0);
107	16	}
108
109		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
110		#ifndef null_get_ctx_params_list
111		static const OSSL_PARAM null_get_ctx_params_list[] = {
112		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
113		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
114		OSSL_PARAM_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
115		OSSL_PARAM_END
116		};
117		#endif
118
119		#ifndef null_get_ctx_params_st
120		struct null_get_ctx_params_st {
121		OSSL_PARAM *ivlen;
122		OSSL_PARAM *keylen;
123		OSSL_PARAM *mac;
124		};
125		#endif
126
127		#ifndef null_get_ctx_params_decoder
128		static int null_get_ctx_params_decoder
129		(const OSSL_PARAM p, struct null_get_ctx_params_st r)
130	0	{
131	0	const char *s;
132
133	0	memset(r, 0, sizeof(*r));
134	0	if (p != NULL)
135	0	for (; (s = p->key) != NULL; p++)
136	0	switch(s[0]) {
137	0	default:
138	0	break;
139	0	case 'i':
140	0	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
141		/* OSSL_CIPHER_PARAM_IVLEN */
142	0	if (ossl_unlikely(r->ivlen != NULL)) {
143	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
144	0	"param %s is repeated", s);
145	0	return 0;
146	0	}
147	0	r->ivlen = (OSSL_PARAM *)p;
148	0	}
149	0	break;
150	0	case 'k':
151	0	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
152		/* OSSL_CIPHER_PARAM_KEYLEN */
153	0	if (ossl_unlikely(r->keylen != NULL)) {
154	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
155	0	"param %s is repeated", s);
156	0	return 0;
157	0	}
158	0	r->keylen = (OSSL_PARAM *)p;
159	0	}
160	0	break;
161	0	case 't':
162	0	if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
163		/* OSSL_CIPHER_PARAM_TLS_MAC */
164	0	if (ossl_unlikely(r->mac != 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	0	r->mac = (OSSL_PARAM *)p;
170	0	}
171	0	}
172	0	return 1;
173	0	}
174		#endif
175		/* End of machine generated */
176
177		static OSSL_FUNC_cipher_gettable_ctx_params_fn null_gettable_ctx_params;
178		static const OSSL_PARAM null_gettable_ctx_params(ossl_unused void cctx,
179		ossl_unused void *provctx)
180	16	{
181	16	return null_get_ctx_params_list;
182	16	}
183
184		static OSSL_FUNC_cipher_get_ctx_params_fn null_get_ctx_params;
185		static int null_get_ctx_params(void *vctx, OSSL_PARAM params[])
186	0	{
187	0	PROV_CIPHER_NULL_CTX ctx = (PROV_CIPHER_NULL_CTX )vctx;
188	0	struct null_get_ctx_params_st p;
189
190	0	if (ctx == NULL \|\| !null_get_ctx_params_decoder(params, &p))
191	0	return 0;
192
193	0	if (p.ivlen != NULL && !OSSL_PARAM_set_size_t(p.ivlen, 0)) {
194	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
195	0	return 0;
196	0	}
197
198	0	if (p.keylen != NULL && !OSSL_PARAM_set_size_t(p.keylen, 0)) {
199	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
200	0	return 0;
201	0	}
202
203	0	if (p.mac != NULL
204	0	&& !OSSL_PARAM_set_octet_ptr(p.mac, ctx->tlsmac, ctx->tlsmacsize)) {
205	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_SET_PARAMETER);
206	0	return 0;
207	0	}
208	0	return 1;
209	0	}
210
211		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
212		#ifndef null_set_ctx_params_list
213		static const OSSL_PARAM null_set_ctx_params_list[] = {
214		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
215		OSSL_PARAM_END
216		};
217		#endif
218
219		#ifndef null_set_ctx_params_st
220		struct null_set_ctx_params_st {
221		OSSL_PARAM *macsize;
222		};
223		#endif
224
225		#ifndef null_set_ctx_params_decoder
226		static int null_set_ctx_params_decoder
227		(const OSSL_PARAM p, struct null_set_ctx_params_st r)
228	0	{
229	0	const char *s;
230
231	0	memset(r, 0, sizeof(*r));
232	0	if (p != NULL)
233	0	for (; (s = p->key) != NULL; p++)
234	0	if (ossl_likely(strcmp("tls-mac-size", s + 0) == 0)) {
235		/* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
236	0	if (ossl_unlikely(r->macsize != NULL)) {
237	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
238	0	"param %s is repeated", s);
239	0	return 0;
240	0	}
241	0	r->macsize = (OSSL_PARAM *)p;
242	0	}
243	0	return 1;
244	0	}
245		#endif
246		/* End of machine generated */
247
248		static OSSL_FUNC_cipher_settable_ctx_params_fn null_settable_ctx_params;
249		static const OSSL_PARAM null_settable_ctx_params(ossl_unused void cctx,
250		ossl_unused void *provctx)
251	0	{
252	0	return null_set_ctx_params_list;
253	0	}
254
255
256		static OSSL_FUNC_cipher_set_ctx_params_fn null_set_ctx_params;
257		static int null_set_ctx_params(void *vctx, const OSSL_PARAM params[])
258	0	{
259	0	PROV_CIPHER_NULL_CTX ctx = (PROV_CIPHER_NULL_CTX )vctx;
260	0	struct null_set_ctx_params_st p;
261
262	0	if (ctx == NULL \|\| !null_set_ctx_params_decoder(params, &p))
263	0	return 0;
264
265	0	if (p.macsize != NULL
266	0	&& !OSSL_PARAM_get_size_t(p.macsize, &ctx->tlsmacsize)) {
267	0	ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GET_PARAMETER);
268	0	return 0;
269	0	}
270
271	0	return 1;
272	0	}
273
274		const OSSL_DISPATCH ossl_null_functions[] = {
275		{ OSSL_FUNC_CIPHER_NEWCTX,
276		(void (*)(void)) null_newctx },
277		{ OSSL_FUNC_CIPHER_FREECTX, (void (*)(void)) null_freectx },
278		{ OSSL_FUNC_CIPHER_DUPCTX, (void (*)(void)) null_newctx },
279		{ OSSL_FUNC_CIPHER_ENCRYPT_INIT, (void (*)(void))null_einit },
280		{ OSSL_FUNC_CIPHER_DECRYPT_INIT, (void (*)(void))null_dinit },
281		{ OSSL_FUNC_CIPHER_UPDATE, (void (*)(void))null_cipher },
282		{ OSSL_FUNC_CIPHER_FINAL, (void (*)(void))null_final },
283		{ OSSL_FUNC_CIPHER_CIPHER, (void (*)(void))null_cipher },
284		{ OSSL_FUNC_CIPHER_GET_PARAMS, (void (*)(void)) null_get_params },
285		{ OSSL_FUNC_CIPHER_GETTABLE_PARAMS,
286		(void (*)(void))ossl_cipher_generic_gettable_params },
287		{ OSSL_FUNC_CIPHER_GET_CTX_PARAMS, (void (*)(void))null_get_ctx_params },
288		{ OSSL_FUNC_CIPHER_GETTABLE_CTX_PARAMS,
289		(void (*)(void))null_gettable_ctx_params },
290		{ OSSL_FUNC_CIPHER_SET_CTX_PARAMS, (void (*)(void))null_set_ctx_params },
291		{ OSSL_FUNC_CIPHER_SETTABLE_CTX_PARAMS,
292		(void (*)(void))null_settable_ctx_params },
293		OSSL_DISPATCH_END
294		};