/src/openssl31/providers/common/bio_prov.c

Source (jump to first uncovered line)
/*
 * Copyright 2019-2021 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 <assert.h>
#include <openssl/core_dispatch.h>
#include "internal/cryptlib.h"
#include "prov/bio.h"

static OSSL_FUNC_BIO_new_file_fn *c_bio_new_file = NULL;
static OSSL_FUNC_BIO_new_membuf_fn *c_bio_new_membuf = NULL;
static OSSL_FUNC_BIO_read_ex_fn *c_bio_read_ex = NULL;
static OSSL_FUNC_BIO_write_ex_fn *c_bio_write_ex = NULL;
static OSSL_FUNC_BIO_gets_fn *c_bio_gets = NULL;
static OSSL_FUNC_BIO_puts_fn *c_bio_puts = NULL;
static OSSL_FUNC_BIO_ctrl_fn *c_bio_ctrl = NULL;
static OSSL_FUNC_BIO_up_ref_fn *c_bio_up_ref = NULL;
static OSSL_FUNC_BIO_free_fn *c_bio_free = NULL;
static OSSL_FUNC_BIO_vprintf_fn *c_bio_vprintf = NULL;

int ossl_prov_bio_from_dispatch(const OSSL_DISPATCH *fns)
{
    for (; fns->function_id != 0; fns++) {
        switch (fns->function_id) {
        case OSSL_FUNC_BIO_NEW_FILE:
            if (c_bio_new_file == NULL)
                c_bio_new_file = OSSL_FUNC_BIO_new_file(fns);
            break;
        case OSSL_FUNC_BIO_NEW_MEMBUF:
            if (c_bio_new_membuf == NULL)
                c_bio_new_membuf = OSSL_FUNC_BIO_new_membuf(fns);
            break;
        case OSSL_FUNC_BIO_READ_EX:
            if (c_bio_read_ex == NULL)
                c_bio_read_ex = OSSL_FUNC_BIO_read_ex(fns);
            break;
        case OSSL_FUNC_BIO_WRITE_EX:
            if (c_bio_write_ex == NULL)
                c_bio_write_ex = OSSL_FUNC_BIO_write_ex(fns);
            break;
        case OSSL_FUNC_BIO_GETS:
            if (c_bio_gets == NULL)
                c_bio_gets = OSSL_FUNC_BIO_gets(fns);
            break;
        case OSSL_FUNC_BIO_PUTS:
            if (c_bio_puts == NULL)
                c_bio_puts = OSSL_FUNC_BIO_puts(fns);
            break;
        case OSSL_FUNC_BIO_CTRL:
            if (c_bio_ctrl == NULL)
                c_bio_ctrl = OSSL_FUNC_BIO_ctrl(fns);
            break;
        case OSSL_FUNC_BIO_UP_REF:
            if (c_bio_up_ref == NULL)
                c_bio_up_ref = OSSL_FUNC_BIO_up_ref(fns);
            break;
        case OSSL_FUNC_BIO_FREE:
            if (c_bio_free == NULL)
                c_bio_free = OSSL_FUNC_BIO_free(fns);
            break;
        case OSSL_FUNC_BIO_VPRINTF:
            if (c_bio_vprintf == NULL)
                c_bio_vprintf = OSSL_FUNC_BIO_vprintf(fns);
            break;
        }
    }

    return 1;
}

OSSL_CORE_BIO *ossl_prov_bio_new_file(const char *filename, const char *mode)
{
    if (c_bio_new_file == NULL)
        return NULL;
    return c_bio_new_file(filename, mode);
}

OSSL_CORE_BIO *ossl_prov_bio_new_membuf(const char *filename, int len)
{
    if (c_bio_new_membuf == NULL)
        return NULL;
    return c_bio_new_membuf(filename, len);
}

int ossl_prov_bio_read_ex(OSSL_CORE_BIO *bio, void *data, size_t data_len,
                          size_t *bytes_read)
{
    if (c_bio_read_ex == NULL)
        return 0;
    return c_bio_read_ex(bio, data, data_len, bytes_read);
}

int ossl_prov_bio_write_ex(OSSL_CORE_BIO *bio, const void *data, size_t data_len,
                           size_t *written)
{
    if (c_bio_write_ex == NULL)
        return 0;
    return c_bio_write_ex(bio, data, data_len, written);
}

int ossl_prov_bio_gets(OSSL_CORE_BIO *bio, char *buf, int size)
{
    if (c_bio_gets == NULL)
        return -1;
    return c_bio_gets(bio, buf, size);
}

int ossl_prov_bio_puts(OSSL_CORE_BIO *bio, const char *str)
{
    if (c_bio_puts == NULL)
        return -1;
    return c_bio_puts(bio, str);
}

int ossl_prov_bio_ctrl(OSSL_CORE_BIO *bio, int cmd, long num, void *ptr)
{
    if (c_bio_ctrl == NULL)
        return -1;
    return c_bio_ctrl(bio, cmd, num, ptr);
}

int ossl_prov_bio_up_ref(OSSL_CORE_BIO *bio)
{
    if (c_bio_up_ref == NULL)
        return 0;
    return c_bio_up_ref(bio);
}

int ossl_prov_bio_free(OSSL_CORE_BIO *bio)
{
    if (c_bio_free == NULL)
        return 0;
    return c_bio_free(bio);
}

int ossl_prov_bio_vprintf(OSSL_CORE_BIO *bio, const char *format, va_list ap)
{
    if (c_bio_vprintf == NULL)
        return -1;
    return c_bio_vprintf(bio, format, ap);
}

int ossl_prov_bio_printf(OSSL_CORE_BIO *bio, const char *format, ...)
{
    va_list ap;
    int ret;

    va_start(ap, format);
    ret = ossl_prov_bio_vprintf(bio, format, ap);
    va_end(ap);

    return ret;
}

#ifndef FIPS_MODULE

/* No direct BIO support in the FIPS module */

static int bio_core_read_ex(BIO *bio, char *data, size_t data_len,
                            size_t *bytes_read)
{
    return ossl_prov_bio_read_ex(BIO_get_data(bio), data, data_len, bytes_read);
}

static int bio_core_write_ex(BIO *bio, const char *data, size_t data_len,
                             size_t *written)
{
    return ossl_prov_bio_write_ex(BIO_get_data(bio), data, data_len, written);
}

static long bio_core_ctrl(BIO *bio, int cmd, long num, void *ptr)
{
    return ossl_prov_bio_ctrl(BIO_get_data(bio), cmd, num, ptr);
}

static int bio_core_gets(BIO *bio, char *buf, int size)
{
    return ossl_prov_bio_gets(BIO_get_data(bio), buf, size);
}

static int bio_core_puts(BIO *bio, const char *str)
{
    return ossl_prov_bio_puts(BIO_get_data(bio), str);
}

static int bio_core_new(BIO *bio)
{
    BIO_set_init(bio, 1);

    return 1;
}

static int bio_core_free(BIO *bio)
{
    BIO_set_init(bio, 0);
    ossl_prov_bio_free(BIO_get_data(bio));

    return 1;
}

BIO_METHOD *ossl_bio_prov_init_bio_method(void)
{
    BIO_METHOD *corebiometh = NULL;

    corebiometh = BIO_meth_new(BIO_TYPE_CORE_TO_PROV, "BIO to Core filter");
    if (corebiometh == NULL
            || !BIO_meth_set_write_ex(corebiometh, bio_core_write_ex)
            || !BIO_meth_set_read_ex(corebiometh, bio_core_read_ex)
            || !BIO_meth_set_puts(corebiometh, bio_core_puts)
            || !BIO_meth_set_gets(corebiometh, bio_core_gets)
            || !BIO_meth_set_ctrl(corebiometh, bio_core_ctrl)
            || !BIO_meth_set_create(corebiometh, bio_core_new)
            || !BIO_meth_set_destroy(corebiometh, bio_core_free)) {
        BIO_meth_free(corebiometh);
        return NULL;
    }

    return corebiometh;
}

BIO *ossl_bio_new_from_core_bio(PROV_CTX *provctx, OSSL_CORE_BIO *corebio)
{
    BIO *outbio;
    BIO_METHOD *corebiometh = ossl_prov_ctx_get0_core_bio_method(provctx);

    if (corebiometh == NULL)
        return NULL;

    if ((outbio = BIO_new(corebiometh)) == NULL)
        return NULL;
    if (!ossl_prov_bio_up_ref(corebio)) {
        BIO_free(outbio);
        return NULL;
    }
    BIO_set_data(outbio, corebio);
    return outbio;
}

#endif

Coverage Report

Created: 2025-06-13 06:58

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 2019-2021 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		#include <assert.h>
11		#include <openssl/core_dispatch.h>
12		#include "internal/cryptlib.h"
13		#include "prov/bio.h"
14
15		static OSSL_FUNC_BIO_new_file_fn *c_bio_new_file = NULL;
16		static OSSL_FUNC_BIO_new_membuf_fn *c_bio_new_membuf = NULL;
17		static OSSL_FUNC_BIO_read_ex_fn *c_bio_read_ex = NULL;
18		static OSSL_FUNC_BIO_write_ex_fn *c_bio_write_ex = NULL;
19		static OSSL_FUNC_BIO_gets_fn *c_bio_gets = NULL;
20		static OSSL_FUNC_BIO_puts_fn *c_bio_puts = NULL;
21		static OSSL_FUNC_BIO_ctrl_fn *c_bio_ctrl = NULL;
22		static OSSL_FUNC_BIO_up_ref_fn *c_bio_up_ref = NULL;
23		static OSSL_FUNC_BIO_free_fn *c_bio_free = NULL;
24		static OSSL_FUNC_BIO_vprintf_fn *c_bio_vprintf = NULL;
25
26		int ossl_prov_bio_from_dispatch(const OSSL_DISPATCH *fns)
27	45	{
28	2.33k	for (; fns->function_id != 0; fns++) {
29	2.28k	switch (fns->function_id) {
30	45	case OSSL_FUNC_BIO_NEW_FILE:
31	45	if (c_bio_new_file == NULL)
32	44	c_bio_new_file = OSSL_FUNC_BIO_new_file(fns);
33	45	break;
34	45	case OSSL_FUNC_BIO_NEW_MEMBUF:
35	45	if (c_bio_new_membuf == NULL)
36	44	c_bio_new_membuf = OSSL_FUNC_BIO_new_membuf(fns);
37	45	break;
38	45	case OSSL_FUNC_BIO_READ_EX:
39	45	if (c_bio_read_ex == NULL)
40	44	c_bio_read_ex = OSSL_FUNC_BIO_read_ex(fns);
41	45	break;
42	45	case OSSL_FUNC_BIO_WRITE_EX:
43	45	if (c_bio_write_ex == NULL)
44	44	c_bio_write_ex = OSSL_FUNC_BIO_write_ex(fns);
45	45	break;
46	45	case OSSL_FUNC_BIO_GETS:
47	45	if (c_bio_gets == NULL)
48	44	c_bio_gets = OSSL_FUNC_BIO_gets(fns);
49	45	break;
50	45	case OSSL_FUNC_BIO_PUTS:
51	45	if (c_bio_puts == NULL)
52	44	c_bio_puts = OSSL_FUNC_BIO_puts(fns);
53	45	break;
54	45	case OSSL_FUNC_BIO_CTRL:
55	45	if (c_bio_ctrl == NULL)
56	44	c_bio_ctrl = OSSL_FUNC_BIO_ctrl(fns);
57	45	break;
58	45	case OSSL_FUNC_BIO_UP_REF:
59	45	if (c_bio_up_ref == NULL)
60	44	c_bio_up_ref = OSSL_FUNC_BIO_up_ref(fns);
61	45	break;
62	45	case OSSL_FUNC_BIO_FREE:
63	45	if (c_bio_free == NULL)
64	44	c_bio_free = OSSL_FUNC_BIO_free(fns);
65	45	break;
66	45	case OSSL_FUNC_BIO_VPRINTF:
67	45	if (c_bio_vprintf == NULL)
68	44	c_bio_vprintf = OSSL_FUNC_BIO_vprintf(fns);
69	45	break;
70	2.28k	}
71	2.28k	}
72
73	45	return 1;
74	45	}
75
76		OSSL_CORE_BIO ossl_prov_bio_new_file(const char filename, const char *mode)
77	0	{
78	0	if (c_bio_new_file == NULL)
79	0	return NULL;
80	0	return c_bio_new_file(filename, mode);
81	0	}
82
83		OSSL_CORE_BIO ossl_prov_bio_new_membuf(const char filename, int len)
84	0	{
85	0	if (c_bio_new_membuf == NULL)
86	0	return NULL;
87	0	return c_bio_new_membuf(filename, len);
88	0	}
89
90		int ossl_prov_bio_read_ex(OSSL_CORE_BIO bio, void data, size_t data_len,
91		size_t *bytes_read)
92	1.29G	{
93	1.29G	if (c_bio_read_ex == NULL)
94	0	return 0;
95	1.29G	return c_bio_read_ex(bio, data, data_len, bytes_read);
96	1.29G	}
97
98		int ossl_prov_bio_write_ex(OSSL_CORE_BIO bio, const void data, size_t data_len,
99		size_t *written)
100	39.3M	{
101	39.3M	if (c_bio_write_ex == NULL)
102	0	return 0;
103	39.3M	return c_bio_write_ex(bio, data, data_len, written);
104	39.3M	}
105
106		int ossl_prov_bio_gets(OSSL_CORE_BIO bio, char buf, int size)
107	3.69M	{
108	3.69M	if (c_bio_gets == NULL)
109	0	return -1;
110	3.69M	return c_bio_gets(bio, buf, size);
111	3.69M	}
112
113		int ossl_prov_bio_puts(OSSL_CORE_BIO bio, const char str)
114	0	{
115	0	if (c_bio_puts == NULL)
116	0	return -1;
117	0	return c_bio_puts(bio, str);
118	0	}
119
120		int ossl_prov_bio_ctrl(OSSL_CORE_BIO bio, int cmd, long num, void ptr)
121	0	{
122	0	if (c_bio_ctrl == NULL)
123	0	return -1;
124	0	return c_bio_ctrl(bio, cmd, num, ptr);
125	0	}
126
127		int ossl_prov_bio_up_ref(OSSL_CORE_BIO *bio)
128	3.87M	{
129	3.87M	if (c_bio_up_ref == NULL)
130	0	return 0;
131	3.87M	return c_bio_up_ref(bio);
132	3.87M	}
133
134		int ossl_prov_bio_free(OSSL_CORE_BIO *bio)
135	3.87M	{
136	3.87M	if (c_bio_free == NULL)
137	0	return 0;
138	3.87M	return c_bio_free(bio);
139	3.87M	}
140
141		int ossl_prov_bio_vprintf(OSSL_CORE_BIO bio, const char format, va_list ap)
142	0	{
143	0	if (c_bio_vprintf == NULL)
144	0	return -1;
145	0	return c_bio_vprintf(bio, format, ap);
146	0	}
147
148		int ossl_prov_bio_printf(OSSL_CORE_BIO bio, const char format, ...)
149	0	{
150	0	va_list ap;
151	0	int ret;
152
153	0	va_start(ap, format);
154	0	ret = ossl_prov_bio_vprintf(bio, format, ap);
155	0	va_end(ap);
156
157	0	return ret;
158	0	}
159
160		#ifndef FIPS_MODULE
161
162		/* No direct BIO support in the FIPS module */
163
164		static int bio_core_read_ex(BIO bio, char data, size_t data_len,
165		size_t *bytes_read)
166	1.29G	{
167	1.29G	return ossl_prov_bio_read_ex(BIO_get_data(bio), data, data_len, bytes_read);
168	1.29G	}
169
170		static int bio_core_write_ex(BIO bio, const char data, size_t data_len,
171		size_t *written)
172	39.3M	{
173	39.3M	return ossl_prov_bio_write_ex(BIO_get_data(bio), data, data_len, written);
174	39.3M	}
175
176		static long bio_core_ctrl(BIO bio, int cmd, long num, void ptr)
177	0	{
178	0	return ossl_prov_bio_ctrl(BIO_get_data(bio), cmd, num, ptr);
179	0	}
180
181		static int bio_core_gets(BIO bio, char buf, int size)
182	3.69M	{
183	3.69M	return ossl_prov_bio_gets(BIO_get_data(bio), buf, size);
184	3.69M	}
185
186		static int bio_core_puts(BIO bio, const char str)
187	0	{
188	0	return ossl_prov_bio_puts(BIO_get_data(bio), str);
189	0	}
190
191		static int bio_core_new(BIO *bio)
192	3.87M	{
193	3.87M	BIO_set_init(bio, 1);
194
195	3.87M	return 1;
196	3.87M	}
197
198		static int bio_core_free(BIO *bio)
199	3.87M	{
200	3.87M	BIO_set_init(bio, 0);
201	3.87M	ossl_prov_bio_free(BIO_get_data(bio));
202
203	3.87M	return 1;
204	3.87M	}
205
206		BIO_METHOD *ossl_bio_prov_init_bio_method(void)
207	45	{
208	45	BIO_METHOD *corebiometh = NULL;
209
210	45	corebiometh = BIO_meth_new(BIO_TYPE_CORE_TO_PROV, "BIO to Core filter");
211	45	if (corebiometh == NULL
212	45	\|\| !BIO_meth_set_write_ex(corebiometh, bio_core_write_ex)
213	45	\|\| !BIO_meth_set_read_ex(corebiometh, bio_core_read_ex)
214	45	\|\| !BIO_meth_set_puts(corebiometh, bio_core_puts)
215	45	\|\| !BIO_meth_set_gets(corebiometh, bio_core_gets)
216	45	\|\| !BIO_meth_set_ctrl(corebiometh, bio_core_ctrl)
217	45	\|\| !BIO_meth_set_create(corebiometh, bio_core_new)
218	45	\|\| !BIO_meth_set_destroy(corebiometh, bio_core_free)) {
219	0	BIO_meth_free(corebiometh);
220	0	return NULL;
221	0	}
222
223	45	return corebiometh;
224	45	}
225
226		BIO ossl_bio_new_from_core_bio(PROV_CTX provctx, OSSL_CORE_BIO *corebio)
227	3.87M	{
228	3.87M	BIO *outbio;
229	3.87M	BIO_METHOD *corebiometh = ossl_prov_ctx_get0_core_bio_method(provctx);
230
231	3.87M	if (corebiometh == NULL)
232	0	return NULL;
233
234	3.87M	if ((outbio = BIO_new(corebiometh)) == NULL)
235	0	return NULL;
236	3.87M	if (!ossl_prov_bio_up_ref(corebio)) {
237	0	BIO_free(outbio);
238	0	return NULL;
239	0	}
240	3.87M	BIO_set_data(outbio, corebio);
241	3.87M	return outbio;
242	3.87M	}
243
244		#endif