From b0ee1de9ab4fb8586934f3a8126432f06abf7115 Mon Sep 17 00:00:00 2001 From: Matt Caswell Date: Tue, 27 Apr 2021 19:56:39 +0100 Subject: Create libcrypto support for BIO_new_from_core_bio() Previously the concept of wrapping an OSSL_CORE_BIO in a real BIO was an internal only concept for our own providers. Since this is likely to be generally useful, we make it a part of the public API. Reviewed-by: Tomas Mraz (Merged from https://github.com/openssl/openssl/pull/15072) --- crypto/bio/bio_lib.c | 8 ++- crypto/bio/bio_local.h | 1 + crypto/bio/bss_core.c | 170 ++++++++++++++++++++++++++++++++++++++++++++ crypto/bio/build.info | 2 +- crypto/context.c | 16 +++++ include/internal/bio.h | 2 + include/internal/cryptlib.h | 7 +- include/openssl/bio.h.in | 6 +- include/openssl/crypto.h.in | 1 + util/libcrypto.num | 4 ++ 10 files changed, 211 insertions(+), 6 deletions(-) create mode 100644 crypto/bio/bss_core.c diff --git a/crypto/bio/bio_lib.c b/crypto/bio/bio_lib.c index 6d360b62ed..5cdd6d7cfd 100644 --- a/crypto/bio/bio_lib.c +++ b/crypto/bio/bio_lib.c @@ -68,7 +68,7 @@ static long bio_call_callback(BIO *b, int oper, const char *argp, size_t len, return ret; } -BIO *BIO_new(const BIO_METHOD *method) +BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method) { BIO *bio = OPENSSL_zalloc(sizeof(*bio)); @@ -77,6 +77,7 @@ BIO *BIO_new(const BIO_METHOD *method) return NULL; } + bio->libctx = libctx; bio->method = method; bio->shutdown = 1; bio->references = 1; @@ -107,6 +108,11 @@ err: return NULL; } +BIO *BIO_new(const BIO_METHOD *method) +{ + return BIO_new_ex(NULL, method); +} + int BIO_free(BIO *a) { int ret; diff --git a/crypto/bio/bio_local.h b/crypto/bio/bio_local.h index 30e56cba8d..3d9afe0760 100644 --- a/crypto/bio/bio_local.h +++ b/crypto/bio/bio_local.h @@ -113,6 +113,7 @@ typedef struct bio_f_buffer_ctx_struct { } BIO_F_BUFFER_CTX; struct bio_st { + OSSL_LIB_CTX *libctx; const BIO_METHOD *method; /* bio, mode, argp, argi, argl, ret */ BIO_callback_fn callback; diff --git a/crypto/bio/bss_core.c b/crypto/bio/bss_core.c new file mode 100644 index 0000000000..2baabe614e --- /dev/null +++ b/crypto/bio/bss_core.c @@ -0,0 +1,170 @@ +/* + * 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 +#include "bio_local.h" +#include "internal/cryptlib.h" + +typedef struct { + OSSL_FUNC_BIO_read_ex_fn *c_bio_read_ex; + OSSL_FUNC_BIO_write_ex_fn *c_bio_write_ex; + OSSL_FUNC_BIO_gets_fn *c_bio_gets; + OSSL_FUNC_BIO_puts_fn *c_bio_puts; + OSSL_FUNC_BIO_ctrl_fn *c_bio_ctrl; +} BIO_CORE_GLOBALS; + +static void bio_core_globals_free(void *vbcg) +{ + OPENSSL_free(vbcg); +} + +static void *bio_core_globals_new(OSSL_LIB_CTX *ctx) +{ + return OPENSSL_zalloc(sizeof(BIO_CORE_GLOBALS)); +} + +static const OSSL_LIB_CTX_METHOD bio_core_globals_method = { + bio_core_globals_new, + bio_core_globals_free, +}; + +static ossl_inline BIO_CORE_GLOBALS *get_globals(OSSL_LIB_CTX *libctx) +{ + return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_BIO_CORE_INDEX, + &bio_core_globals_method); +} + +static int bio_core_read_ex(BIO *bio, char *data, size_t data_len, + size_t *bytes_read) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(bio->libctx); + + if (bcgbl->c_bio_read_ex == NULL) + return 0; + return bcgbl->c_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) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(bio->libctx); + + if (bcgbl->c_bio_write_ex == NULL) + return 0; + return bcgbl->c_bio_write_ex(BIO_get_data(bio), data, data_len, written); +} + +static long bio_core_ctrl(BIO *bio, int cmd, long num, void *ptr) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(bio->libctx); + + if (bcgbl->c_bio_ctrl == NULL) + return -1; + return bcgbl->c_bio_ctrl(BIO_get_data(bio), cmd, num, ptr); +} + +static int bio_core_gets(BIO *bio, char *buf, int size) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(bio->libctx); + + if (bcgbl->c_bio_gets == NULL) + return -1; + return bcgbl->c_bio_gets(BIO_get_data(bio), buf, size); +} + +static int bio_core_puts(BIO *bio, const char *str) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(bio->libctx); + + if (bcgbl->c_bio_puts == NULL) + return -1; + return bcgbl->c_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); + + return 1; +} + +static const BIO_METHOD corebiometh = { + BIO_TYPE_CORE_TO_PROV, + "BIO to Core filter", + bio_core_write_ex, + NULL, + bio_core_read_ex, + NULL, + bio_core_puts, + bio_core_gets, + bio_core_ctrl, + bio_core_new, + bio_core_free, + NULL, +}; + +const BIO_METHOD *BIO_s_core(void) +{ + return &corebiometh; +} + +BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio) +{ + BIO *outbio; + BIO_CORE_GLOBALS *bcgbl = get_globals(libctx); + + /* Check the library context has been initialised with the callbacks */ + if (bcgbl->c_bio_write_ex == NULL && bcgbl->c_bio_read_ex == NULL) + return NULL; + + if ((outbio = BIO_new_ex(libctx, BIO_s_core())) == NULL) + return NULL; + + BIO_set_data(outbio, corebio); + return outbio; +} + +int ossl_bio_init_core(OSSL_LIB_CTX *libctx, const OSSL_DISPATCH *fns) +{ + BIO_CORE_GLOBALS *bcgbl = get_globals(libctx); + + for (; fns->function_id != 0; fns++) { + switch (fns->function_id) { + case OSSL_FUNC_BIO_READ_EX: + if (bcgbl->c_bio_read_ex == NULL) + bcgbl->c_bio_read_ex = OSSL_FUNC_BIO_read_ex(fns); + break; + case OSSL_FUNC_BIO_WRITE_EX: + if (bcgbl->c_bio_write_ex == NULL) + bcgbl->c_bio_write_ex = OSSL_FUNC_BIO_write_ex(fns); + break; + case OSSL_FUNC_BIO_GETS: + if (bcgbl->c_bio_gets == NULL) + bcgbl->c_bio_gets = OSSL_FUNC_BIO_gets(fns); + break; + case OSSL_FUNC_BIO_PUTS: + if (bcgbl->c_bio_puts == NULL) + bcgbl->c_bio_puts = OSSL_FUNC_BIO_puts(fns); + break; + case OSSL_FUNC_BIO_CTRL: + if (bcgbl->c_bio_ctrl == NULL) + bcgbl->c_bio_ctrl = OSSL_FUNC_BIO_ctrl(fns); + break; + } + } + + return 1; +} diff --git a/crypto/bio/build.info b/crypto/bio/build.info index 2bee64fc62..ba7e358c29 100644 --- a/crypto/bio/build.info +++ b/crypto/bio/build.info @@ -11,7 +11,7 @@ SOURCE[../../libcrypto]=\ SOURCE[../../libcrypto]=\ bss_null.c bss_mem.c bss_bio.c bss_fd.c bss_file.c \ bss_sock.c bss_conn.c bss_acpt.c bss_dgram.c \ - bss_log.c + bss_log.c bss_core.c # Filters SOURCE[../../libcrypto]=\ diff --git a/crypto/context.c b/crypto/context.c index 39f96366e2..4ea949970a 100644 --- a/crypto/context.c +++ b/crypto/context.c @@ -12,6 +12,7 @@ #include "internal/thread_once.h" #include "internal/property.h" #include "internal/core.h" +#include "internal/bio.h" struct ossl_lib_ctx_onfree_list_st { ossl_lib_ctx_onfree_fn *fn; @@ -184,6 +185,21 @@ OSSL_LIB_CTX *OSSL_LIB_CTX_new(void) } #ifndef FIPS_MODULE +OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_DISPATCH *in) +{ + OSSL_LIB_CTX *ctx = OSSL_LIB_CTX_new(); + + if (ctx == NULL) + return NULL; + + if (!ossl_bio_init_core(ctx, in)) { + OSSL_LIB_CTX_free(ctx); + return NULL; + } + + return ctx; +} + int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file) { return CONF_modules_load_file_ex(ctx, config_file, NULL, 0) > 0; diff --git a/include/internal/bio.h b/include/internal/bio.h index b905845a1a..2d36a7b980 100644 --- a/include/internal/bio.h +++ b/include/internal/bio.h @@ -86,4 +86,6 @@ int ossl_core_bio_up_ref(OSSL_CORE_BIO *cb); int ossl_core_bio_free(OSSL_CORE_BIO *cb); int ossl_core_bio_vprintf(OSSL_CORE_BIO *cb, const char *format, va_list args); +int ossl_bio_init_core(OSSL_LIB_CTX *libctx, const OSSL_DISPATCH *fns); + #endif diff --git a/include/internal/cryptlib.h b/include/internal/cryptlib.h index e7dd1f65b4..d583153b89 100644 --- a/include/internal/cryptlib.h +++ b/include/internal/cryptlib.h @@ -156,14 +156,15 @@ typedef struct ossl_ex_data_global_st { # define OSSL_LIB_CTX_RAND_CRNGT_INDEX 7 # define OSSL_LIB_CTX_THREAD_EVENT_HANDLER_INDEX 8 # define OSSL_LIB_CTX_FIPS_PROV_INDEX 9 -# define OSSL_LIB_CTX_ENCODER_STORE_INDEX 10 -# define OSSL_LIB_CTX_DECODER_STORE_INDEX 11 +# define OSSL_LIB_CTX_ENCODER_STORE_INDEX 10 +# define OSSL_LIB_CTX_DECODER_STORE_INDEX 11 # define OSSL_LIB_CTX_SELF_TEST_CB_INDEX 12 # define OSSL_LIB_CTX_BIO_PROV_INDEX 13 # define OSSL_LIB_CTX_GLOBAL_PROPERTIES 14 # define OSSL_LIB_CTX_STORE_LOADER_STORE_INDEX 15 # define OSSL_LIB_CTX_PROVIDER_CONF_INDEX 16 -# define OSSL_LIB_CTX_MAX_INDEXES 17 +# define OSSL_LIB_CTX_BIO_CORE_INDEX 17 +# define OSSL_LIB_CTX_MAX_INDEXES 18 typedef struct ossl_lib_ctx_method { void *(*new_func)(OSSL_LIB_CTX *ctx); diff --git a/include/openssl/bio.h.in b/include/openssl/bio.h.in index 336e386459..66ebfc5c7e 100644 --- a/include/openssl/bio.h.in +++ b/include/openssl/bio.h.in @@ -30,6 +30,7 @@ use OpenSSL::stackhash qw(generate_stack_macros); # include # include +# include #ifdef __cplusplus extern "C" { @@ -66,7 +67,7 @@ extern "C" { # ifndef OPENSSL_NO_SCTP # define BIO_TYPE_DGRAM_SCTP (24|BIO_TYPE_SOURCE_SINK|BIO_TYPE_DESCRIPTOR) # endif -# define BIO_TYPE_CORE_TO_PROV (25|BIO_TYPE_FILTER) +# define BIO_TYPE_CORE_TO_PROV (25|BIO_TYPE_SOURCE_SINK) #define BIO_TYPE_START 128 @@ -590,9 +591,11 @@ int BIO_asn1_get_suffix(BIO *b, asn1_ps_func **psuffix, const BIO_METHOD *BIO_s_file(void); BIO *BIO_new_file(const char *filename, const char *mode); +BIO *BIO_new_from_core_bio(OSSL_LIB_CTX *libctx, OSSL_CORE_BIO *corebio); # ifndef OPENSSL_NO_STDIO BIO *BIO_new_fp(FILE *stream, int close_flag); # endif +BIO *BIO_new_ex(OSSL_LIB_CTX *libctx, const BIO_METHOD *method); BIO *BIO_new(const BIO_METHOD *type); int BIO_free(BIO *a); void BIO_set_data(BIO *a, void *ptr); @@ -651,6 +654,7 @@ const BIO_METHOD *BIO_f_readbuffer(void); const BIO_METHOD *BIO_f_linebuffer(void); const BIO_METHOD *BIO_f_nbio_test(void); const BIO_METHOD *BIO_f_prefix(void); +const BIO_METHOD *BIO_s_core(void); # ifndef OPENSSL_NO_DGRAM const BIO_METHOD *BIO_s_datagram(void); int BIO_dgram_non_fatal_error(int error); diff --git a/include/openssl/crypto.h.in b/include/openssl/crypto.h.in index ec6f94d985..e868172acc 100644 --- a/include/openssl/crypto.h.in +++ b/include/openssl/crypto.h.in @@ -517,6 +517,7 @@ CRYPTO_THREAD_ID CRYPTO_THREAD_get_current_id(void); int CRYPTO_THREAD_compare_id(CRYPTO_THREAD_ID a, CRYPTO_THREAD_ID b); OSSL_LIB_CTX *OSSL_LIB_CTX_new(void); +OSSL_LIB_CTX *OSSL_LIB_CTX_new_from_dispatch(const OSSL_DISPATCH *in); int OSSL_LIB_CTX_load_config(OSSL_LIB_CTX *ctx, const char *config_file); void OSSL_LIB_CTX_free(OSSL_LIB_CTX *); OSSL_LIB_CTX *OSSL_LIB_CTX_get0_global_default(void); diff --git a/util/libcrypto.num b/util/libcrypto.num index d8a8eca05f..835b06b20b 100644 --- a/util/libcrypto.num +++ b/util/libcrypto.num @@ -5395,3 +5395,7 @@ PKCS5_pbe_set0_algor_ex ? 3_0_0 EXIST::FUNCTION: PKCS5_pbe_set_ex ? 3_0_0 EXIST::FUNCTION: PKCS5_pbe2_set_iv_ex ? 3_0_0 EXIST::FUNCTION: PKCS5_pbkdf2_set_ex ? 3_0_0 EXIST::FUNCTION: +BIO_new_from_core_bio ? 3_0_0 EXIST::FUNCTION: +BIO_new_ex ? 3_0_0 EXIST::FUNCTION: +BIO_s_core ? 3_0_0 EXIST::FUNCTION: +OSSL_LIB_CTX_new_from_dispatch ? 3_0_0 EXIST::FUNCTION: -- cgit v1.2.3