Latest update.
This commit is contained in:
@@ -0,0 +1,2 @@
|
||||
SOURCE[../../libcrypto]=serializer_meth.c serializer_lib.c serializer_pkey.c \
|
||||
serializer_err.c
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Generated by util/mkerr.pl DO NOT EDIT
|
||||
* Copyright 1995-2019 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 <openssl/err.h>
|
||||
#include <openssl/serializererr.h>
|
||||
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
|
||||
static const ERR_STRING_DATA OSSL_SERIALIZER_str_reasons[] = {
|
||||
{ERR_PACK(ERR_LIB_OSSL_SERIALIZER, 0, OSSL_SERIALIZER_R_INCORRECT_PROPERTY_QUERY),
|
||||
"incorrect property query"},
|
||||
{0, NULL}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
int ERR_load_OSSL_SERIALIZER_strings(void)
|
||||
{
|
||||
#ifndef OPENSSL_NO_ERR
|
||||
if (ERR_reason_error_string(OSSL_SERIALIZER_str_reasons[0].error) == NULL)
|
||||
ERR_load_strings_const(OSSL_SERIALIZER_str_reasons);
|
||||
#endif
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
/*
|
||||
* Copyright 2019 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 <openssl/bio.h>
|
||||
#include <openssl/serializer.h>
|
||||
#include "serializer_local.h"
|
||||
|
||||
int OSSL_SERIALIZER_to_bio(OSSL_SERIALIZER_CTX *ctx, BIO *out)
|
||||
{
|
||||
return ctx->do_output(ctx, out);
|
||||
}
|
||||
|
||||
#ifndef OPENSSL_NO_STDIO
|
||||
static BIO *bio_from_file(FILE *fp)
|
||||
{
|
||||
BIO *b;
|
||||
|
||||
if ((b = BIO_new(BIO_s_file())) == NULL) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_BUF_LIB);
|
||||
return NULL;
|
||||
}
|
||||
BIO_set_fp(b, fp, BIO_NOCLOSE);
|
||||
return b;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_to_fp(OSSL_SERIALIZER_CTX *ctx, FILE *fp)
|
||||
{
|
||||
BIO *b = bio_from_file(fp);
|
||||
int ret = 0;
|
||||
|
||||
if (b != NULL)
|
||||
ret = OSSL_SERIALIZER_to_bio(ctx, b);
|
||||
|
||||
BIO_free(b);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* Copyright 2019 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 <openssl/core_numbers.h>
|
||||
#include <openssl/types.h>
|
||||
#include "internal/cryptlib.h"
|
||||
#include "internal/refcount.h"
|
||||
|
||||
struct ossl_serializer_st {
|
||||
OSSL_PROVIDER *prov;
|
||||
int id;
|
||||
const char *propdef;
|
||||
|
||||
CRYPTO_REF_COUNT refcnt;
|
||||
CRYPTO_RWLOCK *lock;
|
||||
|
||||
OSSL_OP_serializer_newctx_fn *newctx;
|
||||
OSSL_OP_serializer_freectx_fn *freectx;
|
||||
OSSL_OP_serializer_set_ctx_params_fn *set_ctx_params;
|
||||
OSSL_OP_serializer_settable_ctx_params_fn *settable_ctx_params;
|
||||
OSSL_OP_serializer_serialize_data_fn *serialize_data;
|
||||
OSSL_OP_serializer_serialize_object_fn *serialize_object;
|
||||
};
|
||||
|
||||
struct ossl_serializer_ctx_st {
|
||||
OSSL_SERIALIZER *ser;
|
||||
void *serctx;
|
||||
|
||||
/*
|
||||
* |object| is the libcrypto object to handle.
|
||||
* |do_output| must have intimate knowledge of this object.
|
||||
*/
|
||||
const void *object;
|
||||
int (*do_output)(OSSL_SERIALIZER_CTX *ctx, BIO *out);
|
||||
|
||||
/* For any function that needs a passphrase reader */
|
||||
const UI_METHOD *ui_method;
|
||||
void *ui_data;
|
||||
/*
|
||||
* if caller used OSSL_SERIALIZER_CTX_set_passphrase_cb(), we need
|
||||
* intermediary storage.
|
||||
*/
|
||||
UI_METHOD *allocated_ui_method;
|
||||
};
|
||||
@@ -0,0 +1,516 @@
|
||||
/*
|
||||
* Copyright 2019 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 <openssl/core.h>
|
||||
#include <openssl/core_numbers.h>
|
||||
#include <openssl/serializer.h>
|
||||
#include <openssl/ui.h>
|
||||
#include "internal/core.h"
|
||||
#include "internal/namemap.h"
|
||||
#include "internal/property.h"
|
||||
#include "internal/provider.h"
|
||||
#include "crypto/serializer.h"
|
||||
#include "serializer_local.h"
|
||||
|
||||
/*
|
||||
* Serializer can have multiple names, separated with colons in a name string
|
||||
*/
|
||||
#define NAME_SEPARATOR ':'
|
||||
|
||||
/* Simple method structure constructor and destructor */
|
||||
static OSSL_SERIALIZER *ossl_serializer_new(void)
|
||||
{
|
||||
OSSL_SERIALIZER *ser = NULL;
|
||||
|
||||
if ((ser = OPENSSL_zalloc(sizeof(*ser))) == NULL
|
||||
|| (ser->lock = CRYPTO_THREAD_lock_new()) == NULL) {
|
||||
OSSL_SERIALIZER_free(ser);
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ser->refcnt = 1;
|
||||
|
||||
return ser;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_up_ref(OSSL_SERIALIZER *ser)
|
||||
{
|
||||
int ref = 0;
|
||||
|
||||
CRYPTO_UP_REF(&ser->refcnt, &ref, ser->lock);
|
||||
return 1;
|
||||
}
|
||||
|
||||
void OSSL_SERIALIZER_free(OSSL_SERIALIZER *ser)
|
||||
{
|
||||
int ref = 0;
|
||||
|
||||
if (ser == NULL)
|
||||
return;
|
||||
|
||||
CRYPTO_DOWN_REF(&ser->refcnt, &ref, ser->lock);
|
||||
if (ref > 0)
|
||||
return;
|
||||
ossl_provider_free(ser->prov);
|
||||
CRYPTO_THREAD_lock_free(ser->lock);
|
||||
OPENSSL_free(ser);
|
||||
}
|
||||
|
||||
/* Permanent serializer method store, constructor and destructor */
|
||||
static void serializer_store_free(void *vstore)
|
||||
{
|
||||
ossl_method_store_free(vstore);
|
||||
}
|
||||
|
||||
static void *serializer_store_new(OPENSSL_CTX *ctx)
|
||||
{
|
||||
return ossl_method_store_new(ctx);
|
||||
}
|
||||
|
||||
|
||||
static const OPENSSL_CTX_METHOD serializer_store_method = {
|
||||
serializer_store_new,
|
||||
serializer_store_free,
|
||||
};
|
||||
|
||||
/* Data to be passed through ossl_method_construct() */
|
||||
struct serializer_data_st {
|
||||
OPENSSL_CTX *libctx;
|
||||
OSSL_METHOD_CONSTRUCT_METHOD *mcm;
|
||||
int id; /* For get_serializer_from_store() */
|
||||
const char *names; /* For get_serializer_from_store() */
|
||||
const char *propquery; /* For get_serializer_from_store() */
|
||||
};
|
||||
|
||||
/*
|
||||
* Generic routines to fetch / create SERIALIZER methods with
|
||||
* ossl_method_construct()
|
||||
*/
|
||||
|
||||
/* Temporary serializer method store, constructor and destructor */
|
||||
static void *alloc_tmp_serializer_store(OPENSSL_CTX *ctx)
|
||||
{
|
||||
return ossl_method_store_new(ctx);
|
||||
}
|
||||
|
||||
static void dealloc_tmp_serializer_store(void *store)
|
||||
{
|
||||
if (store != NULL)
|
||||
ossl_method_store_free(store);
|
||||
}
|
||||
|
||||
/* Get the permanent serializer store */
|
||||
static OSSL_METHOD_STORE *get_serializer_store(OPENSSL_CTX *libctx)
|
||||
{
|
||||
return openssl_ctx_get_data(libctx, OPENSSL_CTX_SERIALIZER_STORE_INDEX,
|
||||
&serializer_store_method);
|
||||
}
|
||||
|
||||
/* Get serializer methods from a store, or put one in */
|
||||
static void *get_serializer_from_store(OPENSSL_CTX *libctx, void *store,
|
||||
void *data)
|
||||
{
|
||||
struct serializer_data_st *methdata = data;
|
||||
void *method = NULL;
|
||||
int id;
|
||||
|
||||
if ((id = methdata->id) == 0) {
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
|
||||
id = ossl_namemap_name2num(namemap, methdata->names);
|
||||
}
|
||||
|
||||
if (store == NULL
|
||||
&& (store = get_serializer_store(libctx)) == NULL)
|
||||
return NULL;
|
||||
|
||||
if (!ossl_method_store_fetch(store, id, methdata->propquery, &method))
|
||||
return NULL;
|
||||
return method;
|
||||
}
|
||||
|
||||
static int put_serializer_in_store(OPENSSL_CTX *libctx, void *store,
|
||||
void *method, const OSSL_PROVIDER *prov,
|
||||
int operation_id, const char *names,
|
||||
const char *propdef, void *unused)
|
||||
{
|
||||
OSSL_NAMEMAP *namemap;
|
||||
int id;
|
||||
|
||||
if ((namemap = ossl_namemap_stored(libctx)) == NULL
|
||||
|| (id = ossl_namemap_name2num(namemap, names)) == 0)
|
||||
return 0;
|
||||
|
||||
if (store == NULL && (store = get_serializer_store(libctx)) == NULL)
|
||||
return 0;
|
||||
|
||||
return ossl_method_store_add(store, prov, id, propdef, method,
|
||||
(int (*)(void *))OSSL_SERIALIZER_up_ref,
|
||||
(void (*)(void *))OSSL_SERIALIZER_free);
|
||||
}
|
||||
|
||||
/* Create and populate a serializer method */
|
||||
static void *serializer_from_dispatch(int id, const OSSL_ALGORITHM *algodef,
|
||||
OSSL_PROVIDER *prov)
|
||||
{
|
||||
OSSL_SERIALIZER *ser = NULL;
|
||||
const OSSL_DISPATCH *fns = algodef->implementation;
|
||||
|
||||
if ((ser = ossl_serializer_new()) == NULL)
|
||||
return NULL;
|
||||
ser->id = id;
|
||||
ser->propdef = algodef->property_definition;
|
||||
|
||||
for (; fns->function_id != 0; fns++) {
|
||||
switch (fns->function_id) {
|
||||
case OSSL_FUNC_SERIALIZER_NEWCTX:
|
||||
if (ser->newctx == NULL)
|
||||
ser->newctx =
|
||||
OSSL_get_OP_serializer_newctx(fns);
|
||||
break;
|
||||
case OSSL_FUNC_SERIALIZER_FREECTX:
|
||||
if (ser->freectx == NULL)
|
||||
ser->freectx =
|
||||
OSSL_get_OP_serializer_freectx(fns);
|
||||
break;
|
||||
case OSSL_FUNC_SERIALIZER_SET_CTX_PARAMS:
|
||||
if (ser->set_ctx_params == NULL)
|
||||
ser->set_ctx_params =
|
||||
OSSL_get_OP_serializer_set_ctx_params(fns);
|
||||
break;
|
||||
case OSSL_FUNC_SERIALIZER_SETTABLE_CTX_PARAMS:
|
||||
if (ser->settable_ctx_params == NULL)
|
||||
ser->settable_ctx_params =
|
||||
OSSL_get_OP_serializer_settable_ctx_params(fns);
|
||||
break;
|
||||
case OSSL_FUNC_SERIALIZER_SERIALIZE_DATA:
|
||||
if (ser->serialize_data == NULL)
|
||||
ser->serialize_data =
|
||||
OSSL_get_OP_serializer_serialize_data(fns);
|
||||
break;
|
||||
case OSSL_FUNC_SERIALIZER_SERIALIZE_OBJECT:
|
||||
if (ser->serialize_object == NULL)
|
||||
ser->serialize_object =
|
||||
OSSL_get_OP_serializer_serialize_object(fns);
|
||||
break;
|
||||
}
|
||||
}
|
||||
/*
|
||||
* Try to check that the method is sensible.
|
||||
* If you have a constructor, you must have a destructor and vice versa.
|
||||
* You must have at least one of the serializing driver functions.
|
||||
*/
|
||||
if (!((ser->newctx == NULL && ser->freectx == NULL)
|
||||
|| (ser->newctx != NULL && ser->freectx != NULL))
|
||||
|| (ser->serialize_data == NULL && ser->serialize_object == NULL)) {
|
||||
OSSL_SERIALIZER_free(ser);
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_INVALID_PROVIDER_FUNCTIONS);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (prov != NULL && !ossl_provider_up_ref(prov)) {
|
||||
OSSL_SERIALIZER_free(ser);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ser->prov = prov;
|
||||
return ser;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* The core fetching functionality passes the names of the implementation.
|
||||
* This function is responsible to getting an identity number for them,
|
||||
* then call serializer_from_dispatch() with that identity number.
|
||||
*/
|
||||
static void *construct_serializer(const OSSL_ALGORITHM *algodef,
|
||||
OSSL_PROVIDER *prov, void *unused)
|
||||
{
|
||||
/*
|
||||
* This function is only called if get_serializer_from_store() returned
|
||||
* NULL, so it's safe to say that of all the spots to create a new
|
||||
* namemap entry, this is it. Should the name already exist there, we
|
||||
* know that ossl_namemap_add() will return its corresponding number.
|
||||
*/
|
||||
OPENSSL_CTX *libctx = ossl_provider_library_context(prov);
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
const char *names = algodef->algorithm_names;
|
||||
int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
|
||||
void *method = NULL;
|
||||
|
||||
if (id != 0)
|
||||
method = serializer_from_dispatch(id, algodef, prov);
|
||||
|
||||
return method;
|
||||
}
|
||||
|
||||
/* Intermediary function to avoid ugly casts, used below */
|
||||
static void destruct_serializer(void *method, void *data)
|
||||
{
|
||||
OSSL_SERIALIZER_free(method);
|
||||
}
|
||||
|
||||
static int up_ref_serializer(void *method)
|
||||
{
|
||||
return OSSL_SERIALIZER_up_ref(method);
|
||||
}
|
||||
|
||||
static void free_serializer(void *method)
|
||||
{
|
||||
OSSL_SERIALIZER_free(method);
|
||||
}
|
||||
|
||||
/* Fetching support. Can fetch by numeric identity or by name */
|
||||
static OSSL_SERIALIZER *inner_ossl_serializer_fetch(OPENSSL_CTX *libctx,
|
||||
int id, const char *name,
|
||||
const char *properties)
|
||||
{
|
||||
OSSL_METHOD_STORE *store = get_serializer_store(libctx);
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
void *method = NULL;
|
||||
|
||||
if (store == NULL || namemap == NULL)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* If we have been passed neither a name_id or a name, we have an
|
||||
* internal programming error.
|
||||
*/
|
||||
if (!ossl_assert(id != 0 || name != NULL))
|
||||
return NULL;
|
||||
|
||||
if (id == 0)
|
||||
id = ossl_namemap_name2num(namemap, name);
|
||||
|
||||
if (id == 0
|
||||
|| !ossl_method_store_cache_get(store, id, properties, &method)) {
|
||||
OSSL_METHOD_CONSTRUCT_METHOD mcm = {
|
||||
alloc_tmp_serializer_store,
|
||||
dealloc_tmp_serializer_store,
|
||||
get_serializer_from_store,
|
||||
put_serializer_in_store,
|
||||
construct_serializer,
|
||||
destruct_serializer
|
||||
};
|
||||
struct serializer_data_st mcmdata;
|
||||
|
||||
mcmdata.libctx = libctx;
|
||||
mcmdata.mcm = &mcm;
|
||||
mcmdata.id = id;
|
||||
mcmdata.names = name;
|
||||
mcmdata.propquery = properties;
|
||||
if ((method = ossl_method_construct(libctx, OSSL_OP_SERIALIZER,
|
||||
0 /* !force_cache */,
|
||||
&mcm, &mcmdata)) != NULL) {
|
||||
/*
|
||||
* If construction did create a method for us, we know that
|
||||
* there is a correct name_id and meth_id, since those have
|
||||
* already been calculated in get_serializer_from_store() and
|
||||
* put_serializer_in_store() above.
|
||||
*/
|
||||
if (id == 0)
|
||||
id = ossl_namemap_name2num(namemap, name);
|
||||
ossl_method_store_cache_set(store, id, properties, method,
|
||||
up_ref_serializer, free_serializer);
|
||||
}
|
||||
}
|
||||
|
||||
return method;
|
||||
}
|
||||
|
||||
OSSL_SERIALIZER *OSSL_SERIALIZER_fetch(OPENSSL_CTX *libctx, const char *name,
|
||||
const char *properties)
|
||||
{
|
||||
return inner_ossl_serializer_fetch(libctx, 0, name, properties);
|
||||
}
|
||||
|
||||
OSSL_SERIALIZER *ossl_serializer_fetch_by_number(OPENSSL_CTX *libctx, int id,
|
||||
const char *properties)
|
||||
{
|
||||
return inner_ossl_serializer_fetch(libctx, id, NULL, properties);
|
||||
}
|
||||
|
||||
/*
|
||||
* Library of basic method functions
|
||||
*/
|
||||
|
||||
const OSSL_PROVIDER *OSSL_SERIALIZER_provider(const OSSL_SERIALIZER *ser)
|
||||
{
|
||||
if (!ossl_assert(ser != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ser->prov;
|
||||
}
|
||||
|
||||
const char *OSSL_SERIALIZER_properties(const OSSL_SERIALIZER *ser)
|
||||
{
|
||||
if (!ossl_assert(ser != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ser->propdef;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_number(const OSSL_SERIALIZER *ser)
|
||||
{
|
||||
if (!ossl_assert(ser != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ser->id;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_is_a(const OSSL_SERIALIZER *ser, const char *name)
|
||||
{
|
||||
if (ser->prov != NULL) {
|
||||
OPENSSL_CTX *libctx = ossl_provider_library_context(ser->prov);
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
|
||||
return ossl_namemap_name2num(namemap, name) == ser->id;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct serializer_do_all_data_st {
|
||||
void (*user_fn)(void *method, void *arg);
|
||||
void *user_arg;
|
||||
};
|
||||
|
||||
static void serializer_do_one(OSSL_PROVIDER *provider,
|
||||
const OSSL_ALGORITHM *algodef,
|
||||
int no_store, void *vdata)
|
||||
{
|
||||
struct serializer_do_all_data_st *data = vdata;
|
||||
OPENSSL_CTX *libctx = ossl_provider_library_context(provider);
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
const char *names = algodef->algorithm_names;
|
||||
int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
|
||||
void *method = NULL;
|
||||
|
||||
if (id != 0)
|
||||
method =
|
||||
serializer_from_dispatch(id, algodef, provider);
|
||||
|
||||
if (method != NULL) {
|
||||
data->user_fn(method, data->user_arg);
|
||||
OSSL_SERIALIZER_free(method);
|
||||
}
|
||||
}
|
||||
|
||||
void OSSL_SERIALIZER_do_all_provided(OPENSSL_CTX *libctx,
|
||||
void (*fn)(OSSL_SERIALIZER *ser,
|
||||
void *arg),
|
||||
void *arg)
|
||||
{
|
||||
struct serializer_do_all_data_st data;
|
||||
|
||||
data.user_fn = (void (*)(void *, void *))fn;
|
||||
data.user_arg = arg;
|
||||
ossl_algorithm_do_all(libctx, OSSL_OP_SERIALIZER, NULL,
|
||||
serializer_do_one, &data);
|
||||
}
|
||||
|
||||
void OSSL_SERIALIZER_names_do_all(const OSSL_SERIALIZER *ser,
|
||||
void (*fn)(const char *name, void *data),
|
||||
void *data)
|
||||
{
|
||||
if (ser == NULL)
|
||||
return;
|
||||
|
||||
if (ser->prov != NULL) {
|
||||
OPENSSL_CTX *libctx = ossl_provider_library_context(ser->prov);
|
||||
OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
|
||||
|
||||
ossl_namemap_doall_names(namemap, ser->id, fn, data);
|
||||
}
|
||||
}
|
||||
|
||||
const OSSL_PARAM *OSSL_SERIALIZER_settable_ctx_params(OSSL_SERIALIZER *ser)
|
||||
{
|
||||
if (ser != NULL && ser->settable_ctx_params != NULL)
|
||||
return ser->settable_ctx_params();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Serializer context support
|
||||
*/
|
||||
|
||||
/*
|
||||
* |ser| value NULL is valid, and signifies that there is no serializer.
|
||||
* This is useful to provide fallback mechanisms.
|
||||
* Functions that want to verify if there is a serializer can do so with
|
||||
* OSSL_SERIALIZER_CTX_get_serializer()
|
||||
*/
|
||||
OSSL_SERIALIZER_CTX *OSSL_SERIALIZER_CTX_new(OSSL_SERIALIZER *ser)
|
||||
{
|
||||
OSSL_SERIALIZER_CTX *ctx;
|
||||
|
||||
if ((ctx = OPENSSL_zalloc(sizeof(*ctx))) == NULL) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ctx->ser = ser;
|
||||
if (ser != NULL && ser->newctx != NULL) {
|
||||
const OSSL_PROVIDER *prov = OSSL_SERIALIZER_provider(ser);
|
||||
void *provctx = ossl_provider_ctx(prov);
|
||||
|
||||
if (OSSL_SERIALIZER_up_ref(ser)) {
|
||||
ctx->serctx = ser->newctx(provctx);
|
||||
} else {
|
||||
OSSL_SERIALIZER_free(ser);
|
||||
OPENSSL_free(ctx);
|
||||
ctx = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
return ctx;
|
||||
}
|
||||
|
||||
const OSSL_SERIALIZER *
|
||||
OSSL_SERIALIZER_CTX_get_serializer(OSSL_SERIALIZER_CTX *ctx)
|
||||
{
|
||||
if (!ossl_assert(ctx != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return ctx->ser;
|
||||
}
|
||||
|
||||
|
||||
int OSSL_SERIALIZER_CTX_set_params(OSSL_SERIALIZER_CTX *ctx,
|
||||
const OSSL_PARAM params[])
|
||||
{
|
||||
if (!ossl_assert(ctx != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ctx->ser != NULL && ctx->ser->set_ctx_params != NULL)
|
||||
return ctx->ser->set_ctx_params(ctx->serctx, params);
|
||||
return 0;
|
||||
}
|
||||
|
||||
void OSSL_SERIALIZER_CTX_free(OSSL_SERIALIZER_CTX *ctx)
|
||||
{
|
||||
if (ctx != NULL) {
|
||||
if (ctx->ser != NULL && ctx->ser->freectx != NULL)
|
||||
ctx->ser->freectx(ctx->serctx);
|
||||
OSSL_SERIALIZER_free(ctx->ser);
|
||||
UI_destroy_method(ctx->allocated_ui_method);
|
||||
OPENSSL_free(ctx);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,386 @@
|
||||
/*
|
||||
* Copyright 2019 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 <openssl/err.h>
|
||||
#include <openssl/ui.h>
|
||||
#include <openssl/params.h>
|
||||
#include <openssl/serializer.h>
|
||||
#include <openssl/core_names.h>
|
||||
#include "internal/provider.h"
|
||||
#include "internal/property.h"
|
||||
#include "crypto/evp.h"
|
||||
#include "serializer_local.h"
|
||||
|
||||
int OSSL_SERIALIZER_CTX_set_cipher(OSSL_SERIALIZER_CTX *ctx,
|
||||
const char *cipher_name,
|
||||
const char *propquery)
|
||||
{
|
||||
OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END, OSSL_PARAM_END };
|
||||
|
||||
params[0] =
|
||||
OSSL_PARAM_construct_utf8_string(OSSL_SERIALIZER_PARAM_CIPHER,
|
||||
(void *)cipher_name, 0);
|
||||
params[1] =
|
||||
OSSL_PARAM_construct_utf8_string(OSSL_SERIALIZER_PARAM_PROPERTIES,
|
||||
(void *)propquery, 0);
|
||||
|
||||
return OSSL_SERIALIZER_CTX_set_params(ctx, params);
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_CTX_set_passphrase(OSSL_SERIALIZER_CTX *ctx,
|
||||
const unsigned char *kstr,
|
||||
size_t klen)
|
||||
{
|
||||
OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
|
||||
|
||||
params[0] = OSSL_PARAM_construct_octet_string(OSSL_SERIALIZER_PARAM_PASS,
|
||||
(void *)kstr, klen);
|
||||
|
||||
return OSSL_SERIALIZER_CTX_set_params(ctx, params);
|
||||
}
|
||||
|
||||
static void serializer_ctx_reset_passphrase_ui(OSSL_SERIALIZER_CTX *ctx)
|
||||
{
|
||||
UI_destroy_method(ctx->allocated_ui_method);
|
||||
ctx->allocated_ui_method = NULL;
|
||||
ctx->ui_method = NULL;
|
||||
ctx->ui_data = NULL;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_CTX_set_passphrase_ui(OSSL_SERIALIZER_CTX *ctx,
|
||||
const UI_METHOD *ui_method,
|
||||
void *ui_data)
|
||||
{
|
||||
if (!ossl_assert(ctx != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
serializer_ctx_reset_passphrase_ui(ctx);
|
||||
ctx->ui_method = ui_method;
|
||||
ctx->ui_data = ui_data;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int OSSL_SERIALIZER_CTX_set_passphrase_cb(OSSL_SERIALIZER_CTX *ctx, int enc,
|
||||
pem_password_cb *cb, void *cbarg)
|
||||
{
|
||||
if (!ossl_assert(ctx != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
serializer_ctx_reset_passphrase_ui(ctx);
|
||||
if (cb == NULL)
|
||||
return 1;
|
||||
ctx->ui_method =
|
||||
ctx->allocated_ui_method = UI_UTIL_wrap_read_pem_callback(cb, enc);
|
||||
ctx->ui_data = cbarg;
|
||||
|
||||
return ctx->ui_method != NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Support for OSSL_SERIALIZER_CTX_new_by_TYPE:
|
||||
* finding a suitable serializer
|
||||
*/
|
||||
|
||||
struct selected_serializer_st {
|
||||
OPENSSL_CTX *libctx;
|
||||
const OSSL_PROVIDER *desired_provider;
|
||||
const char *propquery;
|
||||
|
||||
/*
|
||||
* When selecting serializers, we need to check the intended use.
|
||||
* This is governed by the |domainparams| flag in the EVP_PKEY,
|
||||
* we must just make sure to filter on 'type=domainparams' accordingly.
|
||||
*/
|
||||
int want_domainparams;
|
||||
|
||||
/*
|
||||
* Serializers offer two functions, one that handles object data in
|
||||
* the form of a OSSL_PARAM array, and one that directly handles a
|
||||
* provider side object. The latter requires that the serializer
|
||||
* is offered by the same provider that holds that object, but is
|
||||
* more desirable because it usually provides faster serialization.
|
||||
*
|
||||
* When looking up possible serializers, we save the first that can
|
||||
* handle an OSSL_PARAM array in |first|, and the first that can
|
||||
* handle a provider side object in |desired|.
|
||||
*/
|
||||
OSSL_SERIALIZER *first;
|
||||
OSSL_SERIALIZER *desired;
|
||||
};
|
||||
|
||||
static void select_serializer(const char *name, void *data)
|
||||
{
|
||||
struct selected_serializer_st *d = data;
|
||||
OSSL_SERIALIZER *s = NULL;
|
||||
OSSL_PROPERTY_LIST *check =
|
||||
d->want_domainparams
|
||||
? ossl_parse_query(d->libctx, "type=domainparams")
|
||||
: NULL;
|
||||
|
||||
/* No need to look further if we already have the more desirable option */
|
||||
if (d->desired != NULL)
|
||||
return;
|
||||
|
||||
if ((s = OSSL_SERIALIZER_fetch(d->libctx, name, d->propquery)) != NULL) {
|
||||
/*
|
||||
* Extra check if domain parameters are explicitly specified:
|
||||
* only accept serializers that have the "type=domainparams"
|
||||
* property.
|
||||
*
|
||||
* For data that isn't marked as domain parameters, a domain
|
||||
* parameters serializer is still acceptable, because a key
|
||||
* may hold domain parameters too.
|
||||
*/
|
||||
if (d->want_domainparams) {
|
||||
OSSL_PROPERTY_LIST *current_props =
|
||||
ossl_parse_property(d->libctx, OSSL_SERIALIZER_properties(s));
|
||||
int check_cnt = ossl_property_match_count(check, current_props);
|
||||
|
||||
if (check_cnt == 0) {
|
||||
OSSL_SERIALIZER_free(s);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
if (d->first == NULL && s->serialize_data != NULL) {
|
||||
d->first = s;
|
||||
} else if (OSSL_SERIALIZER_provider(s) == d->desired_provider
|
||||
&& s->serialize_object != NULL) {
|
||||
OSSL_SERIALIZER_free(d->first);
|
||||
d->first = NULL;
|
||||
d->desired = s;
|
||||
} else {
|
||||
OSSL_SERIALIZER_free(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Support for OSSL_SERIALIZER_CTX_new_by_TYPE and OSSL_SERIALIZER_to_bio:
|
||||
* Passphrase callbacks
|
||||
*/
|
||||
|
||||
/*
|
||||
* First, we define the generic passphrase function that supports both
|
||||
* outgoing (with passphrase verify) and incoming (without passphrase verify)
|
||||
* passphrase reading.
|
||||
*/
|
||||
static int serializer_passphrase(char *pass, size_t pass_size,
|
||||
size_t *pass_len, int verify,
|
||||
const OSSL_PARAM params[], void *arg)
|
||||
{
|
||||
OSSL_SERIALIZER_CTX *ctx = arg;
|
||||
const OSSL_PARAM *p;
|
||||
const char *prompt_info = NULL;
|
||||
char *prompt = NULL, *vpass = NULL;
|
||||
int prompt_idx = -1, verify_idx = -1;
|
||||
UI *ui = NULL;
|
||||
int ret = 0;
|
||||
|
||||
if (!ossl_assert(ctx != NULL && pass != NULL
|
||||
&& pass_size != 0 && pass_len != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if ((p = OSSL_PARAM_locate_const(params,
|
||||
OSSL_PASSPHRASE_PARAM_INFO)) != NULL) {
|
||||
if (p->data_type != OSSL_PARAM_UTF8_STRING)
|
||||
return 0;
|
||||
prompt_info = p->data;
|
||||
}
|
||||
|
||||
if ((ui = UI_new()) == NULL) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
UI_set_method(ui, ctx->ui_method);
|
||||
UI_add_user_data(ui, ctx->ui_data);
|
||||
|
||||
/* Get an application constructed prompt */
|
||||
prompt = UI_construct_prompt(ui, "pass phrase", prompt_info);
|
||||
if (prompt == NULL) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
|
||||
prompt_idx = UI_add_input_string(ui, prompt,
|
||||
UI_INPUT_FLAG_DEFAULT_PWD,
|
||||
pass, 0, pass_size - 1) - 1;
|
||||
if (prompt_idx < 0) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
|
||||
goto end;
|
||||
}
|
||||
|
||||
if (verify) {
|
||||
/* Get a buffer for verification prompt */
|
||||
vpass = OPENSSL_zalloc(pass_size);
|
||||
if (vpass == NULL) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_MALLOC_FAILURE);
|
||||
goto end;
|
||||
}
|
||||
verify_idx = UI_add_verify_string(ui, prompt,
|
||||
UI_INPUT_FLAG_DEFAULT_PWD,
|
||||
vpass, 0, pass_size - 1,
|
||||
pass) - 1;
|
||||
if (verify_idx < 0) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
|
||||
goto end;
|
||||
}
|
||||
}
|
||||
|
||||
switch (UI_process(ui)) {
|
||||
case -2:
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_INTERRUPTED_OR_CANCELLED);
|
||||
break;
|
||||
case -1:
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_UI_LIB);
|
||||
break;
|
||||
default:
|
||||
*pass_len = (size_t)UI_get_result_length(ui, prompt_idx);
|
||||
ret = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
end:
|
||||
OPENSSL_free(vpass);
|
||||
OPENSSL_free(prompt);
|
||||
UI_free(ui);
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* Ensure correct function definition for outgoing passphrase reader */
|
||||
static OSSL_PASSPHRASE_CALLBACK serializer_passphrase_out_cb;
|
||||
static int serializer_passphrase_out_cb(char *pass, size_t pass_size,
|
||||
size_t *pass_len,
|
||||
const OSSL_PARAM params[], void *arg)
|
||||
{
|
||||
return serializer_passphrase(pass, pass_size, pass_len, 1, params, arg);
|
||||
}
|
||||
|
||||
/*
|
||||
* Support for OSSL_SERIALIZER_to_bio:
|
||||
* writing callback for the OSSL_PARAM (the implementation doesn't have
|
||||
* intimate knowledge of the provider side object)
|
||||
*/
|
||||
|
||||
struct serializer_write_data_st {
|
||||
OSSL_SERIALIZER_CTX *ctx;
|
||||
BIO *out;
|
||||
};
|
||||
|
||||
static int serializer_write_cb(const OSSL_PARAM params[], void *arg)
|
||||
{
|
||||
struct serializer_write_data_st *write_data = arg;
|
||||
OSSL_SERIALIZER_CTX *ctx = write_data->ctx;
|
||||
BIO *out = write_data->out;
|
||||
|
||||
return ctx->ser->serialize_data(ctx->serctx, params, out,
|
||||
serializer_passphrase_out_cb, ctx);
|
||||
}
|
||||
|
||||
/*
|
||||
* Support for OSSL_SERIALIZER_to_bio:
|
||||
* Perform the actual output.
|
||||
*/
|
||||
|
||||
static int serializer_EVP_PKEY_to_bio(OSSL_SERIALIZER_CTX *ctx, BIO *out)
|
||||
{
|
||||
const EVP_PKEY *pkey = ctx->object;
|
||||
void *provdata = pkey->pkeys[0].provdata;
|
||||
int domainparams = pkey->pkeys[0].domainparams;
|
||||
EVP_KEYMGMT *keymgmt = pkey->pkeys[0].keymgmt;
|
||||
|
||||
/*
|
||||
* OSSL_SERIALIZER_CTX_new() creates a context, even when the
|
||||
* serializer it's given is NULL. Callers can detect the lack
|
||||
* of serializer with OSSL_SERIALIZER_CTX_get_serializer() and
|
||||
* should take precautions, possibly call a fallback instead of
|
||||
* OSSL_SERIALIZER_to_bio() / OSSL_SERIALIZER_to_fp(). If it's
|
||||
* come this far, we return an error.
|
||||
*/
|
||||
if (ctx->ser == NULL)
|
||||
return 0;
|
||||
|
||||
if (ctx->ser->serialize_object == NULL) {
|
||||
struct serializer_write_data_st write_data;
|
||||
|
||||
write_data.ctx = ctx;
|
||||
write_data.out = out;
|
||||
|
||||
if (domainparams)
|
||||
return evp_keymgmt_exportdomparams(keymgmt, provdata,
|
||||
serializer_write_cb,
|
||||
&write_data);
|
||||
return evp_keymgmt_exportkey(keymgmt, provdata,
|
||||
serializer_write_cb, &write_data);
|
||||
}
|
||||
|
||||
return ctx->ser->serialize_object(ctx->serctx, provdata, out,
|
||||
serializer_passphrase_out_cb, ctx);
|
||||
}
|
||||
|
||||
/*
|
||||
* OSSL_SERIALIZER_CTX_new_by_EVP_PKEY() returns a ctx with no serializer if
|
||||
* it couldn't find a suitable serializer. This allows a caller to detect if
|
||||
* a suitable serializer was found, with OSSL_SERIALIZER_CTX_get_serializer(),
|
||||
* and to use fallback methods if the result is NULL.
|
||||
*/
|
||||
OSSL_SERIALIZER_CTX *OSSL_SERIALIZER_CTX_new_by_EVP_PKEY(const EVP_PKEY *pkey,
|
||||
const char *propquery)
|
||||
{
|
||||
OSSL_SERIALIZER_CTX *ctx = NULL;
|
||||
OSSL_SERIALIZER *ser = NULL;
|
||||
EVP_KEYMGMT *keymgmt = pkey->pkeys[0].keymgmt;
|
||||
|
||||
if (!ossl_assert(pkey != NULL && propquery != NULL)) {
|
||||
ERR_raise(ERR_LIB_OSSL_SERIALIZER, ERR_R_PASSED_NULL_PARAMETER);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (keymgmt != NULL) {
|
||||
const OSSL_PROVIDER *desired_prov = EVP_KEYMGMT_provider(keymgmt);
|
||||
OPENSSL_CTX *libctx = ossl_provider_library_context(desired_prov);
|
||||
struct selected_serializer_st sel_data;
|
||||
|
||||
memset(&sel_data, 0, sizeof(sel_data));
|
||||
sel_data.libctx = libctx;
|
||||
sel_data.desired_provider = desired_prov;
|
||||
sel_data.propquery = propquery;
|
||||
sel_data.want_domainparams = pkey->pkeys[0].domainparams;
|
||||
EVP_KEYMGMT_names_do_all(keymgmt, select_serializer, &sel_data);
|
||||
|
||||
if (sel_data.desired != NULL) {
|
||||
ser = sel_data.desired;
|
||||
sel_data.desired = NULL;
|
||||
} else if (sel_data.first != NULL) {
|
||||
ser = sel_data.first;
|
||||
sel_data.first = NULL;
|
||||
}
|
||||
OSSL_SERIALIZER_free(sel_data.first);
|
||||
OSSL_SERIALIZER_free(sel_data.desired);
|
||||
}
|
||||
|
||||
ctx = OSSL_SERIALIZER_CTX_new(ser); /* refcnt(ser)++ */
|
||||
OSSL_SERIALIZER_free(ser); /* refcnt(ser)-- */
|
||||
|
||||
if (ctx != NULL) {
|
||||
/* Setup for OSSL_SERIALIZE_to_bio() */
|
||||
ctx->object = pkey;
|
||||
ctx->do_output = serializer_EVP_PKEY_to_bio;
|
||||
}
|
||||
|
||||
return ctx;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user