* libcrypto to tell us about later thread stop events. c_thread_start
* is a callback to libcrypto defined in fipsprov.c
*/
- if (!c_thread_start(FIPS_get_provider(ctx), ossl_ctx_thread_stop))
+ if (!c_thread_start(FIPS_get_core_handle(ctx), ossl_ctx_thread_stop))
return 0;
}
#endif
/* Call the initialise function for the provider. */
if (prov->init_function == NULL
- || !prov->init_function(prov, core_dispatch, &provider_dispatch,
- &tmp_provctx)) {
+ || !prov->init_function((OSSL_CORE_HANDLE *)prov, core_dispatch,
+ &provider_dispatch, &tmp_provctx)) {
ERR_raise_data(ERR_LIB_CRYPTO, ERR_R_INIT_FAIL, NULL,
"name=%s", prov->name);
#ifndef FIPS_MODULE
static OSSL_core_pop_error_to_mark_fn core_pop_error_to_mark;
#endif
-static const OSSL_PARAM *core_gettable_params(const OSSL_PROVIDER *prov)
+static const OSSL_PARAM *core_gettable_params(const OSSL_CORE_HANDLE *handle)
{
return param_types;
}
-static int core_get_params(const OSSL_PROVIDER *prov, OSSL_PARAM params[])
+static int core_get_params(const OSSL_CORE_HANDLE *handle, OSSL_PARAM params[])
{
int i;
OSSL_PARAM *p;
+ /*
+ * We created this object originally and we know it is actually an
+ * OSSL_PROVIDER *, so the cast is safe
+ */
+ OSSL_PROVIDER *prov = (OSSL_PROVIDER *)handle;
if ((p = OSSL_PARAM_locate(params, "openssl-version")) != NULL)
OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR);
return 1;
}
-static OPENSSL_CTX *core_get_libctx(const OSSL_PROVIDER *prov)
+static OPENSSL_CORE_CTX *core_get_libctx(const OSSL_CORE_HANDLE *handle)
{
- return ossl_provider_library_context(prov);
+ /*
+ * We created this object originally and we know it is actually an
+ * OSSL_PROVIDER *, so the cast is safe
+ */
+ OSSL_PROVIDER *prov = (OSSL_PROVIDER *)handle;
+
+ return (OPENSSL_CORE_CTX *)ossl_provider_library_context(prov);
}
-static int core_thread_start(const OSSL_PROVIDER *prov,
+static int core_thread_start(const OSSL_CORE_HANDLE *handle,
OSSL_thread_stop_handler_fn handfn)
{
+ /*
+ * We created this object originally and we know it is actually an
+ * OSSL_PROVIDER *, so the cast is safe
+ */
+ OSSL_PROVIDER *prov = (OSSL_PROVIDER *)handle;
+
return ossl_init_thread_start(prov, prov->provctx, handfn);
}
*/
#ifndef FIPS_MODULE
/*
- * TODO(3.0) These error functions should use |prov| to select the proper
+ * TODO(3.0) These error functions should use |handle| to select the proper
* library context to report in the correct error stack, at least if error
* stacks become tied to the library context.
* We cannot currently do that since there's no support for it in the
* ERR subsystem.
*/
-static void core_new_error(const OSSL_PROVIDER *prov)
+static void core_new_error(const OSSL_CORE_HANDLE *handle)
{
ERR_new();
}
-static void core_set_error_debug(const OSSL_PROVIDER *prov,
+static void core_set_error_debug(const OSSL_CORE_HANDLE *handle,
const char *file, int line, const char *func)
{
ERR_set_debug(file, line, func);
}
-static void core_vset_error(const OSSL_PROVIDER *prov,
+static void core_vset_error(const OSSL_CORE_HANDLE *handle,
uint32_t reason, const char *fmt, va_list args)
{
+ /*
+ * We created this object originally and we know it is actually an
+ * OSSL_PROVIDER *, so the cast is safe
+ */
+ OSSL_PROVIDER *prov = (OSSL_PROVIDER *)handle;
+
/*
* If the uppermost 8 bits are non-zero, it's an OpenSSL library
* error and will be treated as such. Otherwise, it's a new style
}
}
-static int core_set_error_mark(const OSSL_PROVIDER *prov)
+static int core_set_error_mark(const OSSL_CORE_HANDLE *handle)
{
return ERR_set_mark();
}
-static int core_clear_last_error_mark(const OSSL_PROVIDER *prov)
+static int core_clear_last_error_mark(const OSSL_CORE_HANDLE *handle)
{
return ERR_clear_last_mark();
}
-static int core_pop_error_to_mark(const OSSL_PROVIDER *prov)
+static int core_pop_error_to_mark(const OSSL_CORE_HANDLE *handle)
{
return ERR_pop_to_mark();
}
{ OSSL_FUNC_BIO_NEW_FILE, (void (*)(void))BIO_new_file },
{ OSSL_FUNC_BIO_NEW_MEMBUF, (void (*)(void))BIO_new_mem_buf },
{ OSSL_FUNC_BIO_READ_EX, (void (*)(void))BIO_read_ex },
+ { OSSL_FUNC_BIO_WRITE_EX, (void (*)(void))BIO_write_ex },
{ OSSL_FUNC_BIO_FREE, (void (*)(void))BIO_free },
{ OSSL_FUNC_BIO_VPRINTF, (void (*)(void))BIO_vprintf },
{ OSSL_FUNC_BIO_VSNPRINTF, (void (*)(void))BIO_vsnprintf },
OSSL_SERIALIZER_CTX *ctx = write_data->ctx;
BIO *out = write_data->out;
- return ctx->ser->serialize_data(ctx->serctx, params, out,
+ return ctx->ser->serialize_data(ctx->serctx, params, (OSSL_CORE_BIO *)out,
serializer_passphrase_out_cb, ctx);
}
&serializer_write_cb, &write_data);
}
- return ctx->ser->serialize_object(ctx->serctx, keydata, out,
+ return ctx->ser->serialize_object(ctx->serctx, keydata,
+ (OSSL_CORE_BIO *)out,
serializer_passphrase_out_cb, ctx);
}
# define OPENSSL_CTX_FIPS_PROV_INDEX 9
# define OPENSSL_CTX_SERIALIZER_STORE_INDEX 10
# define OPENSSL_CTX_SELF_TEST_CB_INDEX 11
-# define OPENSSL_CTX_MAX_INDEXES 12
+# define OPENSSL_CTX_BIO_PROV_INDEX 12
+# define OPENSSL_CTX_MAX_INDEXES 13
typedef struct openssl_ctx_method {
void *(*new_func)(OPENSSL_CTX *ctx);
# 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_START 128
* to communicate data between them.
*/
+/* Opaque handles to be used with core upcall functions from providers */
+typedef struct ossl_core_handle_st OSSL_CORE_HANDLE;
+typedef struct openssl_core_ctx_st OPENSSL_CORE_CTX;
+typedef struct ossl_core_bio_st OSSL_CORE_BIO;
+
/*
* Dispatch table element. function_id numbers are defined further down,
* see macros with '_FUNC' in their names.
* module, that module is not an OpenSSL provider module.
*/
/*-
- * |provider| pointer to opaque type OSSL_PROVIDER. This can be used
+ * |handle| pointer to opaque type OSSL_CORE_HANDLE. This can be used
* together with some functions passed via |in| to query data.
* |in| is the array of functions that the Core passes to the provider.
* |out| will be the array of base functions that the provider passes
* provider needs it. This value is passed to other provider
* functions, notably other context constructors.
*/
-typedef int (OSSL_provider_init_fn)(const OSSL_PROVIDER *provider,
+typedef int (OSSL_provider_init_fn)(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx);
# include <stdarg.h>
# include <openssl/core.h>
-# include <openssl/self_test.h>
# ifdef __cplusplus
extern "C" {
/* Functions provided by the Core to the provider, reserved numbers 1-1023 */
# define OSSL_FUNC_CORE_GETTABLE_PARAMS 1
OSSL_CORE_MAKE_FUNC(const OSSL_PARAM *,
- core_gettable_params,(const OSSL_PROVIDER *prov))
+ core_gettable_params,(const OSSL_CORE_HANDLE *prov))
# define OSSL_FUNC_CORE_GET_PARAMS 2
-OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_PROVIDER *prov,
+OSSL_CORE_MAKE_FUNC(int,core_get_params,(const OSSL_CORE_HANDLE *prov,
OSSL_PARAM params[]))
# define OSSL_FUNC_CORE_THREAD_START 3
-OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_PROVIDER *prov,
+OSSL_CORE_MAKE_FUNC(int,core_thread_start,(const OSSL_CORE_HANDLE *prov,
OSSL_thread_stop_handler_fn handfn))
# define OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT 4
-OSSL_CORE_MAKE_FUNC(OPENSSL_CTX *,core_get_library_context,
- (const OSSL_PROVIDER *prov))
+OSSL_CORE_MAKE_FUNC(OPENSSL_CORE_CTX *,core_get_library_context,
+ (const OSSL_CORE_HANDLE *prov))
# define OSSL_FUNC_CORE_NEW_ERROR 5
-OSSL_CORE_MAKE_FUNC(void,core_new_error,(const OSSL_PROVIDER *prov))
+OSSL_CORE_MAKE_FUNC(void,core_new_error,(const OSSL_CORE_HANDLE *prov))
# define OSSL_FUNC_CORE_SET_ERROR_DEBUG 6
OSSL_CORE_MAKE_FUNC(void,core_set_error_debug,
- (const OSSL_PROVIDER *prov,
+ (const OSSL_CORE_HANDLE *prov,
const char *file, int line, const char *func))
# define OSSL_FUNC_CORE_VSET_ERROR 7
OSSL_CORE_MAKE_FUNC(void,core_vset_error,
- (const OSSL_PROVIDER *prov,
+ (const OSSL_CORE_HANDLE *prov,
uint32_t reason, const char *fmt, va_list args))
# define OSSL_FUNC_CORE_SET_ERROR_MARK 8
-OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_PROVIDER *prov))
+OSSL_CORE_MAKE_FUNC(int, core_set_error_mark, (const OSSL_CORE_HANDLE *prov))
# define OSSL_FUNC_CORE_CLEAR_LAST_ERROR_MARK 9
OSSL_CORE_MAKE_FUNC(int, core_clear_last_error_mark,
- (const OSSL_PROVIDER *prov))
+ (const OSSL_CORE_HANDLE *prov))
# define OSSL_FUNC_CORE_POP_ERROR_TO_MARK 10
-OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_PROVIDER *prov))
+OSSL_CORE_MAKE_FUNC(int, core_pop_error_to_mark, (const OSSL_CORE_HANDLE *prov))
/* Memory allocation, freeing, clearing. */
#define OSSL_FUNC_CRYPTO_MALLOC 20
#define OSSL_FUNC_BIO_NEW_FILE 40
#define OSSL_FUNC_BIO_NEW_MEMBUF 41
#define OSSL_FUNC_BIO_READ_EX 42
-#define OSSL_FUNC_BIO_FREE 43
-#define OSSL_FUNC_BIO_VPRINTF 44
-#define OSSL_FUNC_BIO_VSNPRINTF 45
-
-OSSL_CORE_MAKE_FUNC(BIO *, BIO_new_file, (const char *filename, const char *mode))
-OSSL_CORE_MAKE_FUNC(BIO *, BIO_new_membuf, (const void *buf, int len))
-OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (BIO *bio, void *data, size_t data_len,
- size_t *bytes_read))
-OSSL_CORE_MAKE_FUNC(int, BIO_free, (BIO *bio))
-OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (BIO *bio, const char *format,
+#define OSSL_FUNC_BIO_WRITE_EX 43
+#define OSSL_FUNC_BIO_FREE 44
+#define OSSL_FUNC_BIO_VPRINTF 45
+#define OSSL_FUNC_BIO_VSNPRINTF 46
+
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_file, (const char *filename,
+ const char *mode))
+OSSL_CORE_MAKE_FUNC(OSSL_CORE_BIO *, BIO_new_membuf, (const void *buf, int len))
+OSSL_CORE_MAKE_FUNC(int, BIO_read_ex, (OSSL_CORE_BIO *bio, void *data,
+ size_t data_len, size_t *bytes_read))
+OSSL_CORE_MAKE_FUNC(int, BIO_write_ex, (OSSL_CORE_BIO *bio, const void *data,
+ size_t data_len, size_t *written))
+OSSL_CORE_MAKE_FUNC(int, BIO_free, (OSSL_CORE_BIO *bio))
+OSSL_CORE_MAKE_FUNC(int, BIO_vprintf, (OSSL_CORE_BIO *bio, const char *format,
va_list args))
OSSL_CORE_MAKE_FUNC(int, BIO_vsnprintf,
(char *buf, size_t n, const char *fmt, va_list args))
#define OSSL_FUNC_SELF_TEST_CB 100
-OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CTX *ctx, OSSL_CALLBACK **cb,
+OSSL_CORE_MAKE_FUNC(void, self_test_cb, (OPENSSL_CORE_CTX *ctx, OSSL_CALLBACK **cb,
void **cbarg))
/* Functions provided by the provider to the Core, reserved numbers 1024-1535 */
(void))
OSSL_CORE_MAKE_FUNC(int, OP_serializer_serialize_data,
- (void *ctx, const OSSL_PARAM[], BIO *out,
+ (void *ctx, const OSSL_PARAM[], OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
OSSL_CORE_MAKE_FUNC(int, OP_serializer_serialize_object,
- (void *ctx, void *obj, BIO *out,
+ (void *ctx, void *obj, OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg))
# ifdef __cplusplus
* https://www.openssl.org/source/license.html
*/
+#include <assert.h>
#include <openssl/core_numbers.h>
+#include "internal/cryptlib.h"
#include "prov/bio.h"
static OSSL_BIO_new_file_fn *c_bio_new_file = NULL;
static OSSL_BIO_new_membuf_fn *c_bio_new_membuf = NULL;
static OSSL_BIO_read_ex_fn *c_bio_read_ex = NULL;
+static OSSL_BIO_write_ex_fn *c_bio_write_ex = NULL;
static OSSL_BIO_free_fn *c_bio_free = NULL;
static OSSL_BIO_vprintf_fn *c_bio_vprintf = NULL;
if (c_bio_read_ex == NULL)
c_bio_read_ex = OSSL_get_BIO_read_ex(fns);
break;
+ case OSSL_FUNC_BIO_WRITE_EX:
+ if (c_bio_write_ex == NULL)
+ c_bio_write_ex = OSSL_get_BIO_write_ex(fns);
+ break;
case OSSL_FUNC_BIO_FREE:
if (c_bio_free == NULL)
c_bio_free = OSSL_get_BIO_free(fns);
return 1;
}
-BIO *ossl_prov_bio_new_file(const char *filename, const char *mode)
+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);
}
-BIO *ossl_prov_bio_new_membuf(const char *filename, int len)
+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(BIO *bio, void *data, size_t data_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 c_bio_read_ex(bio, data, data_len, bytes_read);
}
-int ossl_prov_bio_free(BIO *bio)
+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_free(OSSL_CORE_BIO *bio)
{
if (c_bio_free == NULL)
return 0;
return c_bio_free(bio);
}
-int ossl_prov_bio_vprintf(BIO *bio, const char *format, va_list ap)
+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(BIO *bio, const char *format, ...)
+int ossl_prov_bio_printf(OSSL_CORE_BIO *bio, const char *format, ...)
{
va_list ap;
int ret;
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)
+{
+ /* We don't support this */
+ assert(0);
+ return 0;
+}
+
+static int bio_core_gets(BIO *bio, char *buf, int size)
+{
+ /* We don't support this */
+ assert(0);
+ return -1;
+}
+
+static int bio_core_puts(BIO *bio, const char *str)
+{
+ /* We don't support this */
+ assert(0);
+ return -1;
+}
+
+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;
+}
+
+BIO_METHOD *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 *bio_new_from_core_bio(PROV_CTX *provctx, OSSL_CORE_BIO *corebio)
+{
+ BIO *outbio;
+ BIO_METHOD *corebiometh = PROV_CTX_get0_core_bio_method(provctx);
+
+ if (corebiometh == NULL)
+ return NULL;
+
+ outbio = BIO_new(corebiometh);
+ if (outbio != NULL)
+ BIO_set_data(outbio, corebio);
+
+ return outbio;
+}
+
+#endif
#include <stdarg.h>
#include <openssl/bio.h>
#include <openssl/core.h>
+#include "prov/provider_ctx.h"
int ossl_prov_bio_from_dispatch(const OSSL_DISPATCH *fns);
-BIO *ossl_prov_bio_new_file(const char *filename, const char *mode);
-BIO *ossl_prov_bio_new_membuf(const char *filename, int len);
-int ossl_prov_bio_read_ex(BIO *bio, void *data, size_t data_len,
+OSSL_CORE_BIO *ossl_prov_bio_new_file(const char *filename, const char *mode);
+OSSL_CORE_BIO *ossl_prov_bio_new_membuf(const char *filename, int len);
+int ossl_prov_bio_read_ex(OSSL_CORE_BIO *bio, void *data, size_t data_len,
size_t *bytes_read);
-int ossl_prov_bio_free(BIO *bio);
-int ossl_prov_bio_vprintf(BIO *bio, const char *format, va_list ap);
-int ossl_prov_bio_printf(BIO *bio, const char *format, ...);
+int ossl_prov_bio_write_ex(OSSL_CORE_BIO *bio, const void *data, size_t data_len,
+ size_t *written);
+int ossl_prov_bio_free(OSSL_CORE_BIO *bio);
+int ossl_prov_bio_vprintf(OSSL_CORE_BIO *bio, const char *format, va_list ap);
+int ossl_prov_bio_printf(OSSL_CORE_BIO *bio, const char *format, ...);
+
+BIO_METHOD *bio_prov_init_bio_method(void);
+BIO *bio_new_from_core_bio(PROV_CTX *provctx, OSSL_CORE_BIO *corebio);
* https://www.openssl.org/source/license.html
*/
-#include <openssl/types.h>
-#include <openssl/crypto.h>
+#ifndef OSSL_PROV_PROVIDER_CTX_H
+# define OSSL_PROV_PROVIDER_CTX_H
+
+# include <openssl/types.h>
+# include <openssl/crypto.h>
+# include <openssl/bio.h>
+# include <openssl/core.h>
typedef struct prov_ctx_st {
- const OSSL_PROVIDER *provider;
+ const OSSL_CORE_HANDLE *handle;
OPENSSL_CTX *libctx; /* For all provider modules */
+ BIO_METHOD *corebiometh;
} PROV_CTX;
/*
* To be used anywhere the library context needs to be passed, such as to
* fetching functions.
*/
-#define PROV_LIBRARY_CONTEXT_OF(provctx) \
+# define PROV_LIBRARY_CONTEXT_OF(provctx) \
PROV_CTX_get0_library_context((provctx))
PROV_CTX *PROV_CTX_new(void);
void PROV_CTX_free(PROV_CTX *ctx);
void PROV_CTX_set0_library_context(PROV_CTX *ctx, OPENSSL_CTX *libctx);
-void PROV_CTX_set0_provider(PROV_CTX *ctx, const OSSL_PROVIDER *libctx);
+void PROV_CTX_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle);
+void PROV_CTX_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh);
OPENSSL_CTX *PROV_CTX_get0_library_context(PROV_CTX *ctx);
-const OSSL_PROVIDER *PROV_CTX_get0_provider(PROV_CTX *ctx);
+const OSSL_CORE_HANDLE *PROV_CTX_get0_handle(PROV_CTX *ctx);
+BIO_METHOD *PROV_CTX_get0_core_bio_method(PROV_CTX *ctx);
+
+#endif
#include <openssl/provider.h>
-const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *ctx);
+const OSSL_CORE_HANDLE *FIPS_get_core_handle(OPENSSL_CTX *ctx);
const char *ossl_prov_util_nid_to_name(int nid);
#include <stdlib.h>
#include "prov/provider_ctx.h"
+#include "prov/bio.h"
PROV_CTX *PROV_CTX_new(void)
{
ctx->libctx = libctx;
}
-void PROV_CTX_set0_provider(PROV_CTX *ctx, const OSSL_PROVIDER *provider)
+void PROV_CTX_set0_handle(PROV_CTX *ctx, const OSSL_CORE_HANDLE *handle)
{
if (ctx != NULL)
- ctx->provider = provider;
+ ctx->handle = handle;
}
+void PROV_CTX_set0_core_bio_method(PROV_CTX *ctx, BIO_METHOD *corebiometh)
+{
+ if (ctx != NULL)
+ ctx->corebiometh = corebiometh;
+}
OPENSSL_CTX *PROV_CTX_get0_library_context(PROV_CTX *ctx)
{
return ctx->libctx;
}
-const OSSL_PROVIDER *PROV_CTX_get0_provider(PROV_CTX *ctx)
+const OSSL_CORE_HANDLE *PROV_CTX_get0_handle(PROV_CTX *ctx)
+{
+ if (ctx == NULL)
+ return NULL;
+ return ctx->handle;
+}
+
+BIO_METHOD *PROV_CTX_get0_core_bio_method(PROV_CTX *ctx)
{
if (ctx == NULL)
return NULL;
- return ctx->provider;
+ return ctx->corebiometh;
}
static void deflt_teardown(void *provctx)
{
+ BIO_meth_free(PROV_CTX_get0_core_bio_method(provctx));
PROV_CTX_free(provctx);
}
OSSL_provider_init_fn ossl_default_provider_init;
-int ossl_default_provider_init(const OSSL_PROVIDER *provider,
+int ossl_default_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
{
OSSL_core_get_library_context_fn *c_get_libctx = NULL;
+ BIO_METHOD *corebiometh;
if (!ossl_prov_bio_from_dispatch(in))
return 0;
/*
* We want to make sure that all calls from this provider that requires
* a library context use the same context as the one used to call our
- * functions. We do that by passing it along as the provider context.
+ * functions. We do that by passing it along in the provider context.
*
- * This is special for built-in providers. External providers should
+ * This only works for built-in providers. Most providers should
* create their own library context.
*/
- if ((*provctx = PROV_CTX_new()) == NULL)
+ if ((*provctx = PROV_CTX_new()) == NULL
+ || (corebiometh = bio_prov_init_bio_method()) == NULL) {
+ PROV_CTX_free(*provctx);
+ *provctx = NULL;
return 0;
- PROV_CTX_set0_library_context(*provctx, c_get_libctx(provider));
- PROV_CTX_set0_provider(*provctx, provider);
+ }
+ PROV_CTX_set0_library_context(*provctx, (OPENSSL_CTX *)c_get_libctx(handle));
+ PROV_CTX_set0_handle(*provctx, handle);
+ PROV_CTX_set0_core_bio_method(*provctx, corebiometh);
*out = deflt_dispatch_table;
static OSSL_BIO_vsnprintf_fn *c_BIO_vsnprintf;
typedef struct fips_global_st {
- const OSSL_PROVIDER *prov;
+ const OSSL_CORE_HANDLE *handle;
} FIPS_GLOBAL;
static void *fips_prov_ossl_ctx_new(OPENSSL_CTX *libctx)
};
-int OSSL_provider_init(const OSSL_PROVIDER *provider,
+int OSSL_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
}
if (stcbfn != NULL && c_get_libctx != NULL) {
- stcbfn(c_get_libctx(provider), &selftest_params.cb,
+ stcbfn(c_get_libctx(handle), &selftest_params.cb,
&selftest_params.cb_arg);
}
else {
selftest_params.cb_arg = NULL;
}
- if (!c_get_params(provider, core_params))
+ if (!c_get_params(handle, core_params))
return 0;
/* Create a context. */
goto err;
}
PROV_CTX_set0_library_context(*provctx, libctx);
- PROV_CTX_set0_provider(*provctx, provider);
+ PROV_CTX_set0_handle(*provctx, handle);
if ((fgbl = openssl_ctx_get_data(libctx, OPENSSL_CTX_FIPS_PROV_INDEX,
&fips_prov_ossl_ctx_method)) == NULL)
goto err;
- fgbl->prov = provider;
+ fgbl->handle = handle;
selftest_params.libctx = libctx;
if (!SELF_TEST_post(&selftest_params, 0))
* that was used in the EVP call that initiated this recursive call.
*/
OSSL_provider_init_fn fips_intern_provider_init;
-int fips_intern_provider_init(const OSSL_PROVIDER *provider,
+int fips_intern_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
if ((*provctx = PROV_CTX_new()) == NULL)
return 0;
- PROV_CTX_set0_library_context(*provctx, c_get_libctx(provider));
- PROV_CTX_set0_provider(*provctx, provider);
+ /*
+ * Using the parent library context only works because we are a built-in
+ * internal provider. This is not something that most providers would be
+ * able to do.
+ */
+ PROV_CTX_set0_library_context(*provctx, (OPENSSL_CTX *)c_get_libctx(handle));
+ PROV_CTX_set0_handle(*provctx, handle);
*out = intern_dispatch_table;
return 1;
* is also called from other parts of libcrypto, which all pass around a
* OPENSSL_CTX pointer)
*/
-const OSSL_PROVIDER *FIPS_get_provider(OPENSSL_CTX *libctx)
+const OSSL_CORE_HANDLE *FIPS_get_core_handle(OPENSSL_CTX *libctx)
{
FIPS_GLOBAL *fgbl = openssl_ctx_get_data(libctx,
OPENSSL_CTX_FIPS_PROV_INDEX,
if (fgbl == NULL)
return NULL;
- return fgbl->prov;
+ return fgbl->handle;
}
void *CRYPTO_malloc(size_t num, const char *file, int line)
* the result matches the expected value.
* Return 1 if verified, or 0 if it fails.
*/
-static int verify_integrity(BIO *bio, OSSL_BIO_read_ex_fn read_ex_cb,
+static int verify_integrity(OSSL_CORE_BIO *bio, OSSL_BIO_read_ex_fn read_ex_cb,
unsigned char *expected, size_t expected_len,
OPENSSL_CTX *libctx, OSSL_SELF_TEST *ev,
const char *event_type)
int ok = 0;
int kats_already_passed = 0;
long checksum_len;
- BIO *bio_module = NULL, *bio_indicator = NULL;
+ OSSL_CORE_BIO *bio_module = NULL, *bio_indicator = NULL;
unsigned char *module_checksum = NULL;
unsigned char *indicator_checksum = NULL;
int loclstate;
}
if (BN_is_zero(bn))
- return ossl_prov_bio_printf(out, "%s%s0\n", label, post_label_spc);
+ return BIO_printf(out, "%s%s0\n", label, post_label_spc);
if (BN_num_bytes(bn) <= BN_BYTES) {
BN_ULONG *words = bn_get_words(bn);
if (BN_is_negative(bn))
neg = "-";
- return ossl_prov_bio_printf(out,
- "%s%s%s" BN_FMTu " (%s0x" BN_FMTx ")\n",
- label, post_label_spc, neg, words[0],
- neg, words[0]);
+ return BIO_printf(out, "%s%s%s" BN_FMTu " (%s0x" BN_FMTx ")\n",
+ label, post_label_spc, neg, words[0], neg, words[0]);
}
hex_str = BN_bn2hex(bn);
++p;
neg = " (Negative)";
}
- if (ossl_prov_bio_printf(out, "%s%s\n", label, neg) <= 0)
+ if (BIO_printf(out, "%s%s\n", label, neg) <= 0)
goto err;
/* Keep track of how many bytes we have printed out so far */
bytes = 0;
- if (ossl_prov_bio_printf(out, "%s", spaces) <= 0)
+ if (BIO_printf(out, "%s", spaces) <= 0)
goto err;
/* Add a leading 00 if the top bit is set */
if (*p >= '8') {
- if (ossl_prov_bio_printf(out, "%02x", 0) <= 0)
+ if (BIO_printf(out, "%02x", 0) <= 0)
goto err;
++bytes;
use_sep = 1;
while (*p != '\0') {
/* Do a newline after every 15 hex bytes + add the space indent */
if ((bytes % 15) == 0 && bytes > 0) {
- if (ossl_prov_bio_printf(out, ":\n%s", spaces) <= 0)
+ if (BIO_printf(out, ":\n%s", spaces) <= 0)
goto err;
use_sep = 0; /* The first byte on the next line doesnt have a : */
}
- if (ossl_prov_bio_printf(out, "%s%c%c", use_sep ? ":" : "",
- ossl_tolower(p[0]), ossl_tolower(p[1])) <= 0)
+ if (BIO_printf(out, "%s%c%c", use_sep ? ":" : "",
+ ossl_tolower(p[0]), ossl_tolower(p[1])) <= 0)
goto err;
++bytes;
p += 2;
use_sep = 1;
}
- if (ossl_prov_bio_printf(out, "\n") <= 0)
+ if (BIO_printf(out, "\n") <= 0)
goto err;
ret = 1;
err:
{
size_t i;
- if (ossl_prov_bio_printf(out, "%s\n", label) <= 0)
+ if (BIO_printf(out, "%s\n", label) <= 0)
return 0;
for (i = 0; i < buflen; i++) {
if ((i % LABELED_BUF_PRINT_WIDTH) == 0) {
- if (i > 0 && ossl_prov_bio_printf(out, "\n") <= 0)
+ if (i > 0 && BIO_printf(out, "\n") <= 0)
return 0;
- if (ossl_prov_bio_printf(out, " ") <= 0)
+ if (BIO_printf(out, " ") <= 0)
return 0;
}
- if (ossl_prov_bio_printf(out, "%02x%s", buf[i],
+ if (BIO_printf(out, "%02x%s", buf[i],
(i == buflen - 1) ? "" : ":") <= 0)
return 0;
}
- if (ossl_prov_bio_printf(out, "\n") <= 0)
+ if (BIO_printf(out, "\n") <= 0)
return 0;
return 1;
if (p == NULL)
goto null_err;
- if (ossl_prov_bio_printf(out, "%s: (%d bit)\n", type_label, BN_num_bits(p))
+ if (BIO_printf(out, "%s: (%d bit)\n", type_label, BN_num_bits(p))
<= 0)
goto err;
if (priv_key != NULL
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dh_param_newctx;
}
/* Public key : DER */
-static int dh_param_der_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dh_param_der_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
return ok;
}
-static int dh_param_der(void *ctx, void *dh, BIO *out,
+static int dh_param_der(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return i2d_DHparams_bio(out, dh);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+ ret = i2d_DHparams_bio(out, dh);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int dh_param_pem_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dh_param_pem_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
return ok;
}
-static int dh_param_pem(void *ctx, void *dh, BIO *out,
+static int dh_param_pem(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return PEM_write_bio_DHparams(out, dh);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = PEM_write_bio_DHparams(out, dh);
+ BIO_free(out);
+
+ return ret;
}
-static int dh_param_print_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dh_param_print_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
return ok;
}
-static int dh_param_print(void *ctx, void *dh, BIO *out,
+static int dh_param_print(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dh(out, dh, dh_print_params);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dh(out, dh, dh_print_params);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dh_param_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dh_priv_newctx;
}
/* Private key : DER */
-static int dh_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int dh_priv_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dh_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dh_priv_der(void *vctx, void *dh, BIO *out,
+static int dh_priv_der(void *vctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dh_priv_ctx_st *ctx = vctx;
int ret;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
ossl_prov_prepare_dh_params,
ossl_prov_dh_priv_to_der,
&ctx->sc);
+ BIO_free(out);
return ret;
}
/* Private key : PEM */
-static int dh_pem_priv_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int dh_pem_priv_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dh_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dh_pem_priv(void *vctx, void *dh, BIO *out,
+static int dh_pem_priv(void *vctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dh_priv_ctx_st *ctx = vctx;
int ret;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
ossl_prov_prepare_dh_params,
ossl_prov_dh_priv_to_der,
&ctx->sc);
+ BIO_free(out);
return ret;
}
{
}
-static int dh_priv_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int dh_priv_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dh_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dh_priv_print(void *ctx, void *dh, BIO *out,
+static int dh_priv_print(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dh(out, dh, dh_print_priv);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dh(out, dh, dh_print_priv);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dh_priv_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dh_pub_newctx;
}
/* Public key : DER */
-static int dh_pub_der_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dh_pub_der_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
return ok;
}
-static int dh_pub_der(void *ctx, void *dh, BIO *out,
+static int dh_pub_der(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_der_from_obj(out, dh, EVP_PKEY_DH,
- ossl_prov_prepare_dh_params,
- ossl_prov_dh_pub_to_der);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_der_from_obj(out, dh, EVP_PKEY_DH,
+ ossl_prov_prepare_dh_params,
+ ossl_prov_dh_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int dh_pub_pem_data(void *ctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int dh_pub_pem_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
OSSL_OP_keymgmt_free_fn *dh_free = ossl_prov_get_keymgmt_dh_free();
return ok;
}
-static int dh_pub_pem(void *ctx, void *dh, BIO *out,
+static int dh_pub_pem(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_pem_from_obj(out, dh, EVP_PKEY_DH,
- ossl_prov_prepare_dh_params,
- ossl_prov_dh_pub_to_der);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+ ret = ossl_prov_write_pub_pem_from_obj(out, dh, EVP_PKEY_DH,
+ ossl_prov_prepare_dh_params,
+ ossl_prov_dh_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
-static int dh_pub_print_data(void *ctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int dh_pub_print_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dh_new = ossl_prov_get_keymgmt_dh_new();
OSSL_OP_keymgmt_free_fn *dh_free = ossl_prov_get_keymgmt_dh_free();
return ok;
}
-static int dh_pub_print(void *ctx, void *dh, BIO *out,
+static int dh_pub_print(void *ctx, void *dh, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dh(out, dh, dh_print_pub);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dh(out, dh, dh_print_pub);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dh_pub_der_serializer_functions[] = {
if (p == NULL)
goto null_err;
- if (ossl_prov_bio_printf(out, "%s: (%d bit)\n", type_label,
- BN_num_bits(p)) <= 0)
+ if (BIO_printf(out, "%s: (%d bit)\n", type_label, BN_num_bits(p)) <= 0)
goto err;
if (priv_key != NULL
&& !ossl_prov_print_labeled_bignum(out, "priv:", priv_key))
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dsa_param_newctx;
}
/* Public key : DER */
-static int dsa_param_der_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_param_der_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_param_der(void *ctx, void *dsa, BIO *out,
+static int dsa_param_der(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return i2d_DSAparams_bio(out, dsa);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = i2d_DSAparams_bio(out, dsa);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int dsa_param_pem_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_param_pem_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_param_pem(void *ctx, void *dsa, BIO *out,
+static int dsa_param_pem(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return PEM_write_bio_DSAparams(out, dsa);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = PEM_write_bio_DSAparams(out, dsa);
+ BIO_free(out);
+
+ return ret;
}
-static int dsa_param_print_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_param_print_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_param_print(void *ctx, void *dsa, BIO *out,
+static int dsa_param_print(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dsa(out, dsa, dsa_print_params);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dsa(out, dsa, dsa_print_params);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dsa_param_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dsa_priv_newctx;
}
/* Private key : DER */
-static int dsa_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_priv_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dsa_priv_der(void *vctx, void *dsa, BIO *out,
+static int dsa_priv_der(void *vctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dsa_priv_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
- return ossl_prov_write_priv_der_from_obj(out, dsa, EVP_PKEY_DSA,
- ossl_prov_prepare_dsa_params,
- ossl_prov_dsa_priv_to_der,
- &ctx->sc);
+ ret = ossl_prov_write_priv_der_from_obj(out, dsa, EVP_PKEY_DSA,
+ ossl_prov_prepare_dsa_params,
+ ossl_prov_dsa_priv_to_der,
+ &ctx->sc);
+ BIO_free(out);
+
+ return ret;
}
/* Private key : PEM */
-static int dsa_pem_priv_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_pem_priv_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dsa_pem_priv(void *vctx, void *dsa, BIO *out,
+static int dsa_pem_priv(void *vctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dsa_priv_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
- return ossl_prov_write_priv_pem_from_obj(out, dsa, EVP_PKEY_DSA,
- ossl_prov_prepare_dsa_params,
- ossl_prov_dsa_priv_to_der,
- &ctx->sc);
+ ret = ossl_prov_write_priv_pem_from_obj(out, dsa, EVP_PKEY_DSA,
+ ossl_prov_prepare_dsa_params,
+ ossl_prov_dsa_priv_to_der,
+ &ctx->sc);
+ BIO_free(out);
+
+ return ret;
}
/*
}
static int dsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
- BIO *out,
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct dsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int dsa_priv_print(void *ctx, void *dsa, BIO *out,
+static int dsa_priv_print(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dsa(out, dsa, dsa_print_priv);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dsa(out, dsa, dsa_print_priv);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dsa_priv_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn dsa_pub_newctx;
}
/* Public key : DER */
-static int dsa_pub_der_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_pub_der_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_pub_der(void *ctx, void *dsa, BIO *out,
+static int dsa_pub_der(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
/*
* in crypto/dsa/dsa_ameth.c
*/
int save_parameters = 1;
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
- return
+ if (out == NULL)
+ return 0;
+
+ ret =
save_parameters
? ossl_prov_write_pub_der_from_obj(out, dsa, EVP_PKEY_DSA,
ossl_prov_prepare_all_dsa_params,
ossl_prov_prepare_dsa_params,
ossl_prov_dsa_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int dsa_pub_pem_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_pub_pem_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_pub_pem(void *ctx, void *dsa, BIO *out,
+static int dsa_pub_pem(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_pem_from_obj(out, dsa, EVP_PKEY_DSA,
- ossl_prov_prepare_dsa_params,
- ossl_prov_dsa_pub_to_der);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_pem_from_obj(out, dsa, EVP_PKEY_DSA,
+ ossl_prov_prepare_dsa_params,
+ ossl_prov_dsa_pub_to_der);
+
+ BIO_free(out);
+
+ return ret;
}
-static int dsa_pub_print_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int dsa_pub_print_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *dsa_new = ossl_prov_get_keymgmt_dsa_new();
return ok;
}
-static int dsa_pub_print(void *ctx, void *dsa, BIO *out,
+static int dsa_pub_print(void *ctx, void *dsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_dsa(out, dsa, 0);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_dsa(out, dsa, 0);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH dsa_pub_der_serializer_functions[] = {
if (curve_nid == NID_undef)
return 0;
- if (ossl_prov_bio_printf(out, "%s: %s\n", "ASN1 OID",
- OBJ_nid2sn(curve_nid)) <= 0)
+ if (BIO_printf(out, "%s: %s\n", "ASN1 OID", OBJ_nid2sn(curve_nid)) <= 0)
return 0;
/* TODO(3.0): Only named curves are currently supported */
curve_name = EC_curve_nid2nist(curve_nid);
return (curve_name == NULL
- || ossl_prov_bio_printf(out, "%s: %s\n", "NIST CURVE",
- curve_name) > 0);
+ || BIO_printf(out, "%s: %s\n", "NIST CURVE", curve_name) > 0);
}
int ossl_prov_print_eckey(BIO *out, EC_KEY *eckey, enum ec_print_type type)
goto err;
}
- if (ossl_prov_bio_printf(out, "%s: (%d bit)\n", type_label,
- EC_GROUP_order_bits(group)) <= 0)
+ if (BIO_printf(out, "%s: (%d bit)\n", type_label,
+ EC_GROUP_order_bits(group)) <= 0)
goto err;
if (priv != NULL
&& !ossl_prov_print_labeled_buf(out, "priv:", priv, priv_len))
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn ec_param_newctx;
}
/* Public key : DER */
-static int ec_param_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int ec_param_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
OSSL_OP_keymgmt_free_fn *ec_free;
return ok;
}
-static int ec_param_der(void *vctx, void *eckey, BIO *out,
+static int ec_param_der(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return i2d_ECPKParameters_bio(out, EC_KEY_get0_group(eckey));
+ BIO *out = bio_new_from_core_bio(vctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = i2d_ECPKParameters_bio(out, EC_KEY_get0_group(eckey));
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int ec_param_pem_data(void *vctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int ec_param_pem_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
OSSL_OP_keymgmt_free_fn *ec_free;
return ok;
}
-static int ec_param_pem(void *vctx, void *eckey, BIO *out,
+static int ec_param_pem(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return PEM_write_bio_ECPKParameters(out, EC_KEY_get0_group(eckey));
+ BIO *out = bio_new_from_core_bio(vctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = PEM_write_bio_ECPKParameters(out, EC_KEY_get0_group(eckey));
+ BIO_free(out);
+
+ return ret;
}
-static int ec_param_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int ec_param_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
OSSL_OP_keymgmt_free_fn *ec_free;
return ok;
}
-static int ec_param_print(void *vctx, void *eckey, BIO *out,
+static int ec_param_print(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_eckey(out, eckey, ec_print_params);
+ BIO *out = bio_new_from_core_bio(vctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_eckey(out, eckey, ec_print_params);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH ec_param_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn ec_priv_newctx;
}
/* Private key : DER */
-static int ec_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int ec_priv_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ec_priv_ctx_st *ctx = vctx;
OSSL_OP_keymgmt_new_fn *ec_new;
return ok;
}
-static int ec_priv_der(void *vctx, void *eckey, BIO *out,
+static int ec_priv_der(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ec_priv_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
- return ossl_prov_write_priv_der_from_obj(out, eckey, EVP_PKEY_EC,
- ossl_prov_prepare_ec_params,
- ossl_prov_ec_priv_to_der,
- &ctx->sc);
+ ret = ossl_prov_write_priv_der_from_obj(out, eckey, EVP_PKEY_EC,
+ ossl_prov_prepare_ec_params,
+ ossl_prov_ec_priv_to_der,
+ &ctx->sc);
+ BIO_free(out);
+
+ return ret;
}
/* Private key : PEM */
-static int ec_pem_priv_data(void *vctx, const OSSL_PARAM params[], BIO *out,
- OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
+static int ec_pem_priv_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
+ OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ec_priv_ctx_st *ctx = vctx;
OSSL_OP_keymgmt_new_fn *ec_new;
return ok;
}
-static int ec_pem_priv(void *vctx, void *eckey, BIO *out,
+static int ec_pem_priv(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ec_priv_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
- return ossl_prov_write_priv_pem_from_obj(out, eckey, EVP_PKEY_EC,
- ossl_prov_prepare_ec_params,
- ossl_prov_ec_priv_to_der,
- &ctx->sc);
+ ret = ossl_prov_write_priv_pem_from_obj(out, eckey, EVP_PKEY_EC,
+ ossl_prov_prepare_ec_params,
+ ossl_prov_ec_priv_to_der,
+ &ctx->sc);
+ BIO_free(out);
+
+ return ret;
}
/*
{
}
-static int ec_priv_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ec_priv_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ec_priv_ctx_st *ctx = vctx;
return ok;
}
-static int ec_priv_print(void *vctx, void *eckey, BIO *out,
+static int ec_priv_print(void *ctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_eckey(out, eckey, ec_print_priv);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_eckey(out, eckey, ec_print_priv);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH ec_priv_der_serializer_functions[] = {
#include <openssl/params.h>
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn ec_pub_newctx;
}
/* Public key : DER */
-static int ec_pub_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ec_pub_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
return ok;
}
-static int ec_pub_der(void *ctx, void *eckey, BIO *out,
+static int ec_pub_der(void *ctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_der_from_obj(out, eckey, EVP_PKEY_EC,
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_der_from_obj(out, eckey, EVP_PKEY_EC,
ossl_prov_prepare_ec_params,
ossl_prov_ec_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int ec_pub_pem_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ec_pub_pem_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
return ok;
}
-static int ec_pub_pem(void *vctx, void *eckey, BIO *out,
+static int ec_pub_pem(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_pem_from_obj(out, eckey, EVP_PKEY_EC,
- ossl_prov_prepare_ec_params,
- ossl_prov_ec_pub_to_der);
+ BIO *out = bio_new_from_core_bio(vctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_pem_from_obj(out, eckey, EVP_PKEY_EC,
+ ossl_prov_prepare_ec_params,
+ ossl_prov_ec_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
-static int ec_pub_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ec_pub_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *ec_new;
return ok;
}
-static int ec_pub_print(void *vctx, void *eckey, BIO *out,
+static int ec_pub_print(void *vctx, void *eckey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_eckey(out, eckey, ec_print_pub);
+ BIO *out = bio_new_from_core_bio(vctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_eckey(out, eckey, ec_print_pub);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH ec_pub_der_serializer_functions[] = {
return 0;
}
- if (ossl_prov_bio_printf(out, "%s:\n", type_label) <= 0)
+ if (BIO_printf(out, "%s:\n", type_label) <= 0)
return 0;
if (type == ecx_print_priv
&& !ossl_prov_print_labeled_buf(out, "priv:", ecxkey->privkey,
#include "crypto/ecx.h"
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn x25519_priv_newctx;
}
/* Private key : DER */
-static int ecx_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_priv_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_priv_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_priv_der(void *vctx, void *vecxkey, BIO *out,
+static int ecx_priv_der(void *vctx, void *vecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_priv_ctx_st *ctx = vctx;
ECX_KEY *ecxkey = vecxkey;
int ret;
int nid = KEYTYPE2NID(ctx->type);
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
NULL,
ossl_prov_ecx_priv_to_der,
&ctx->sc);
+ BIO_free(out);
return ret;
}
/* Private key : PEM */
-static int ecx_priv_pem_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_priv_pem_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_priv_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_priv_pem(void *vctx, void *ecxkey, BIO *out,
+static int ecx_priv_pem(void *vctx, void *ecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_priv_ctx_st *ctx = vctx;
int ret;
int nid = KEYTYPE2NID(ctx->type);
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
NULL,
ossl_prov_ecx_priv_to_der,
&ctx->sc);
+ BIO_free(out);
return ret;
}
-static int ecx_priv_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_priv_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_priv_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_priv_print(void *ctx, void *ecxkey, BIO *out,
+static int ecx_priv_print(void *vctx, void *ecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_ecx(out, ecxkey, ecx_print_priv);
+ struct ecx_priv_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_ecx(out, ecxkey, ecx_print_priv);
+ BIO_free(out);
+
+ return ret;
}
#define MAKE_SERIALIZER_FUNCTIONS(alg, type) \
#include "crypto/ecx.h"
#include "prov/bio.h"
#include "prov/implementations.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn x25519_pub_newctx;
}
/* Public key : DER */
-static int ecx_pub_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_pub_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_pub_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_pub_der(void *vctx, void *ecxkey, BIO *out,
+static int ecx_pub_der(void *vctx, void *ecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_pub_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
- return ossl_prov_write_pub_der_from_obj(out, ecxkey,
- KEYTYPE2NID(ctx->type),
- NULL,
- ossl_prov_ecx_pub_to_der);
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_der_from_obj(out, ecxkey,
+ KEYTYPE2NID(ctx->type),
+ NULL,
+ ossl_prov_ecx_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int ecx_pub_pem_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_pub_pem_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_pub_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_pub_pem(void *vctx, void *ecxkey, BIO *out,
+static int ecx_pub_pem(void *vctx, void *ecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_pub_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
- return ossl_prov_write_pub_pem_from_obj(out, ecxkey,
- KEYTYPE2NID(ctx->type),
- NULL,
- ossl_prov_ecx_pub_to_der);
+ if (out == NULL)
+ return 0;
+ ret = ossl_prov_write_pub_pem_from_obj(out, ecxkey,
+ KEYTYPE2NID(ctx->type),
+ NULL,
+ ossl_prov_ecx_pub_to_der);
+ BIO_free(out);
+
+ return ret;
}
-static int ecx_pub_print_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int ecx_pub_print_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct ecx_pub_ctx_st *ctx = vctx;
return ok;
}
-static int ecx_pub_print(void *ctx, void *ecxkey, BIO *out,
+static int ecx_pub_print(void *vctx, void *ecxkey, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_ecx(out, ecxkey, ecx_print_pub);
+ struct ecx_pub_ctx_st *ctx = vctx;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_ecx(out, ecxkey, ecx_print_pub);
+ BIO_free(out);
+
+ return ret;
}
#define MAKE_SERIALIZER_FUNCTIONS(alg, type) \
if (name == NULL)
goto err;
- if (ossl_prov_bio_printf(out, "GROUP: %s\n", name) <= 0)
+ if (BIO_printf(out, "GROUP: %s\n", name) <= 0)
goto err;
return 1;
#else
goto err;
}
if (ffc->gindex != -1) {
- if (ossl_prov_bio_printf(out, "gindex: %d\n", ffc->gindex) <= 0)
+ if (BIO_printf(out, "gindex: %d\n", ffc->gindex) <= 0)
goto err;
}
if (ffc->pcounter != -1) {
- if (ossl_prov_bio_printf(out, "pcounter: %d\n", ffc->pcounter) <= 0)
+ if (BIO_printf(out, "pcounter: %d\n", ffc->pcounter) <= 0)
goto err;
}
if (ffc->h != 0) {
- if (ossl_prov_bio_printf(out, "h: %d\n", ffc->h) <= 0)
+ if (BIO_printf(out, "h: %d\n", ffc->h) <= 0)
goto err;
}
return 1;
rsa_get0_all_params(rsa, factors, exps, coeffs);
if (priv && rsa_d != NULL) {
- if (ossl_prov_bio_printf(out, "Private-Key: (%d bit, %d primes)\n",
- BN_num_bits(rsa_n),
- sk_BIGNUM_const_num(factors)) <= 0)
+ if (BIO_printf(out, "Private-Key: (%d bit, %d primes)\n",
+ BN_num_bits(rsa_n),
+ sk_BIGNUM_const_num(factors)) <= 0)
goto err;
modulus_label = "modulus:";
exponent_label = "publicExponent:";
} else {
- if (ossl_prov_bio_printf(out, "Public-Key: (%d bit)\n",
- BN_num_bits(rsa_n)) <= 0)
+ if (BIO_printf(out, "Public-Key: (%d bit)\n", BN_num_bits(rsa_n)) <= 0)
goto err;
modulus_label = "Modulus:";
exponent_label = "Exponent:";
sk_BIGNUM_const_value(coeffs, 0)))
goto err;
for (i = 2; i < sk_BIGNUM_const_num(factors); i++) {
- if (ossl_prov_bio_printf(out, "prime%d:", i + 1) <= 0)
+ if (BIO_printf(out, "prime%d:", i + 1) <= 0)
goto err;
if (!ossl_prov_print_labeled_bignum(out, NULL,
sk_BIGNUM_const_value(factors,
i)))
goto err;
- if (ossl_prov_bio_printf(out, "exponent%d:", i + 1) <= 0)
+ if (BIO_printf(out, "exponent%d:", i + 1) <= 0)
goto err;
if (!ossl_prov_print_labeled_bignum(out, NULL,
sk_BIGNUM_const_value(exps, i)))
goto err;
- if (ossl_prov_bio_printf(out, "coefficient%d:", i + 1) <= 0)
+ if (BIO_printf(out, "coefficient%d:", i + 1) <= 0)
goto err;
if (!ossl_prov_print_labeled_bignum(out, NULL,
sk_BIGNUM_const_value(coeffs,
switch (RSA_test_flags(rsa, RSA_FLAG_TYPE_MASK)) {
case RSA_FLAG_TYPE_RSA:
if (!rsa_pss_params_30_is_unrestricted(pss_params)) {
- if (ossl_prov_bio_printf(out, "(INVALID PSS PARAMETERS)\n") <= 0)
+ if (BIO_printf(out, "(INVALID PSS PARAMETERS)\n") <= 0)
goto err;
}
break;
case RSA_FLAG_TYPE_RSASSAPSS:
if (rsa_pss_params_30_is_unrestricted(pss_params)) {
- if (ossl_prov_bio_printf(out,
- "No PSS parameter restrictions\n") <= 0)
+ if (BIO_printf(out, "No PSS parameter restrictions\n") <= 0)
goto err;
} else {
int hashalg_nid = rsa_pss_params_30_hashalg(pss_params);
int saltlen = rsa_pss_params_30_saltlen(pss_params);
int trailerfield = rsa_pss_params_30_trailerfield(pss_params);
- if (ossl_prov_bio_printf(out, "PSS parameter restrictions:\n") <= 0)
+ if (BIO_printf(out, "PSS parameter restrictions:\n") <= 0)
goto err;
- if (ossl_prov_bio_printf(out, " Hash Algorithm: %s%s\n",
- rsa_oaeppss_nid2name(hashalg_nid),
- (hashalg_nid == NID_sha1
- ? " (default)" : "")) <= 0)
+ if (BIO_printf(out, " Hash Algorithm: %s%s\n",
+ rsa_oaeppss_nid2name(hashalg_nid),
+ (hashalg_nid == NID_sha1
+ ? " (default)" : "")) <= 0)
goto err;
- if (ossl_prov_bio_printf(out, " Mask Algorithm: %s with %s%s\n",
- rsa_mgf_nid2name(maskgenalg_nid),
- rsa_oaeppss_nid2name(maskgenhashalg_nid),
- (maskgenalg_nid == NID_mgf1
- && maskgenhashalg_nid == NID_sha1
- ? " (default)" : "")) <= 0)
+ if (BIO_printf(out, " Mask Algorithm: %s with %s%s\n",
+ rsa_mgf_nid2name(maskgenalg_nid),
+ rsa_oaeppss_nid2name(maskgenhashalg_nid),
+ (maskgenalg_nid == NID_mgf1
+ && maskgenhashalg_nid == NID_sha1
+ ? " (default)" : "")) <= 0)
goto err;
- if (ossl_prov_bio_printf(out, " Minimum Salt Length: %d%s\n",
- saltlen,
- (saltlen == 20 ? " (default)" : "")) <= 0)
+ if (BIO_printf(out, " Minimum Salt Length: %d%s\n",
+ saltlen,
+ (saltlen == 20 ? " (default)" : "")) <= 0)
goto err;
/*
* TODO(3.0) Should we show the ASN.1 trailerField value, or
* does display 0xBC when the default applies, but the ASN.1
* trailerField value otherwise...
*/
- if (ossl_prov_bio_printf(out, " Trailer Field: 0x%x%s\n",
- trailerfield,
- (trailerfield == 1 ? " (default)" : ""))
+ if (BIO_printf(out, " Trailer Field: 0x%x%s\n",
+ trailerfield,
+ (trailerfield == 1 ? " (default)" : ""))
<= 0)
goto err;
}
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn rsa_priv_newctx;
}
/* Private key : DER */
-static int rsa_priv_der_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int rsa_priv_der_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct rsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int rsa_priv_der(void *vctx, void *rsa, BIO *out,
+static int rsa_priv_der(void *vctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct rsa_priv_ctx_st *ctx = vctx;
int ret;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
ossl_prov_prepare_rsa_params,
(i2d_of_void *)i2d_RSAPrivateKey,
&ctx->sc);
+ BIO_free(out);
return ret;
}
/* Private key : PEM */
-static int rsa_pem_priv_data(void *vctx, const OSSL_PARAM params[], BIO *out,
+static int rsa_pem_priv_data(void *vctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct rsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int rsa_pem_priv(void *vctx, void *rsa, BIO *out,
+static int rsa_pem_priv(void *vctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct rsa_priv_ctx_st *ctx = vctx;
int ret;
+ BIO *out = bio_new_from_core_bio(ctx->provctx, cout);
+
+ if (out == NULL)
+ return 0;
ctx->sc.cb = cb;
ctx->sc.cbarg = cbarg;
ossl_prov_prepare_rsa_params,
(i2d_of_void *)i2d_RSAPrivateKey,
&ctx->sc);
+ BIO_free(out);
return ret;
}
}
static int rsa_priv_print_data(void *vctx, const OSSL_PARAM params[],
- BIO *out,
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
struct rsa_priv_ctx_st *ctx = vctx;
return ok;
}
-static int rsa_priv_print(void *ctx, void *rsa, BIO *out,
+static int rsa_priv_print(void *ctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_rsa(out, rsa, 1);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_rsa(out, rsa, 1);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH rsa_priv_der_serializer_functions[] = {
#include "prov/bio.h"
#include "prov/implementations.h"
#include "prov/providercommonerr.h"
+#include "prov/provider_ctx.h"
#include "serializer_local.h"
static OSSL_OP_serializer_newctx_fn rsa_pub_newctx;
}
/* Public key : DER */
-static int rsa_pub_der_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int rsa_pub_der_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
return ok;
}
-static int rsa_pub_der(void *ctx, void *rsa, BIO *out,
+static int rsa_pub_der(void *ctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_der_from_obj(out, rsa,
- ossl_prov_rsa_type_to_evp(rsa),
- ossl_prov_prepare_rsa_params,
- (i2d_of_void *)i2d_RSAPublicKey);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_der_from_obj(out, rsa,
+ ossl_prov_rsa_type_to_evp(rsa),
+ ossl_prov_prepare_rsa_params,
+ (i2d_of_void *)i2d_RSAPublicKey);
+ BIO_free(out);
+
+ return ret;
}
/* Public key : PEM */
-static int rsa_pub_pem_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int rsa_pub_pem_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
return ok;
}
-static int rsa_pub_pem(void *ctx, void *rsa, BIO *out,
+static int rsa_pub_pem(void *ctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_write_pub_pem_from_obj(out, rsa,
- ossl_prov_rsa_type_to_evp(rsa),
- ossl_prov_prepare_rsa_params,
- (i2d_of_void *)i2d_RSAPublicKey);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_write_pub_pem_from_obj(out, rsa,
+ ossl_prov_rsa_type_to_evp(rsa),
+ ossl_prov_prepare_rsa_params,
+ (i2d_of_void *)i2d_RSAPublicKey);
+ BIO_free(out);
+
+ return ret;
}
-static int rsa_pub_print_data(void *ctx, const OSSL_PARAM params[], BIO *out,
+static int rsa_pub_print_data(void *ctx, const OSSL_PARAM params[],
+ OSSL_CORE_BIO *out,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
OSSL_OP_keymgmt_new_fn *rsa_new = ossl_prov_get_keymgmt_rsa_new();
return ok;
}
-static int rsa_pub_print(void *ctx, void *rsa, BIO *out,
+static int rsa_pub_print(void *ctx, void *rsa, OSSL_CORE_BIO *cout,
OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
{
- return ossl_prov_print_rsa(out, rsa, 0);
+ BIO *out = bio_new_from_core_bio(ctx, cout);
+ int ret;
+
+ if (out == NULL)
+ return 0;
+
+ ret = ossl_prov_print_rsa(out, rsa, 0);
+ BIO_free(out);
+
+ return ret;
}
const OSSL_DISPATCH rsa_pub_der_serializer_functions[] = {
{ 0, NULL }
};
-int OSSL_provider_init(const OSSL_PROVIDER *provider,
+int OSSL_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
return 0;
}
PROV_CTX_set0_library_context(*provctx, libctx);
- PROV_CTX_set0_provider(*provctx, provider);
+ PROV_CTX_set0_handle(*provctx, handle);
*out = legacy_dispatch_table;
OSSL_provider_init_fn ossl_null_provider_init;
-/* Functions provided by the core */
-static OSSL_core_gettable_params_fn *c_gettable_params = NULL;
-static OSSL_core_get_params_fn *c_get_params = NULL;
-
/* Parameters we provide to the core */
static const OSSL_ITEM null_param_types[] = {
{ OSSL_PARAM_UTF8_PTR, OSSL_PROV_PARAM_NAME },
{ 0, NULL }
};
-int ossl_null_provider_init(const OSSL_PROVIDER *provider,
+int ossl_null_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
{
- OSSL_core_get_library_context_fn *c_get_libctx = NULL;
-
- for (; in->function_id != 0; in++) {
- switch (in->function_id) {
- case OSSL_FUNC_CORE_GETTABLE_PARAMS:
- c_gettable_params = OSSL_get_core_gettable_params(in);
- break;
- case OSSL_FUNC_CORE_GET_PARAMS:
- c_get_params = OSSL_get_core_get_params(in);
- break;
- case OSSL_FUNC_CORE_GET_LIBRARY_CONTEXT:
- c_get_libctx = OSSL_get_core_get_library_context(in);
- break;
- /* Just ignore anything we don't understand */
- default:
- break;
- }
- }
-
- if (c_get_libctx == NULL)
- return 0;
-
*out = null_dispatch_table;
- /*
- * We want to make sure that all calls from this provider that requires
- * a library context use the same context as the one used to call our
- * functions. We do that by passing it along as the provider context.
- */
- *provctx = c_get_libctx(provider);
+ /* Could be anything - we don't use it */
+ *provctx = (void *)handle;
return 1;
}
return p_param_types;
}
-static int p_get_params(void *vprov, OSSL_PARAM params[])
+static int p_get_params(void *vhand, OSSL_PARAM params[])
{
- const OSSL_PROVIDER *prov = vprov;
+ const OSSL_CORE_HANDLE *hand = vhand;
OSSL_PARAM *p = params;
int ok = 1;
opensslv = provname = greeting = NULL;
- if (c_get_params(prov, counter_request)) {
+ if (c_get_params(hand, counter_request)) {
if (greeting) {
strcpy(buf, greeting);
} else {
{ 0, NULL }
};
-int OSSL_provider_init(const OSSL_PROVIDER *provider,
+int OSSL_provider_init(const OSSL_CORE_HANDLE *handle,
const OSSL_DISPATCH *in,
const OSSL_DISPATCH **out,
void **provctx)
}
/* Because we use this in get_params, we need to pass it back */
- *provctx = (void *)provider;
+ *provctx = (void *)handle;
*out = p_test_table;
return 1;
projects / thirdparty / openssl.git / commitdiff
