1 /* 2 * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved. 3 * 4 * Licensed under the Apache License 2.0 (the "License"). You may not use 5 * this file except in compliance with the License. You can obtain a copy 6 * in the file LICENSE in the source distribution or at 7 * https://www.openssl.org/source/license.html 8 */ 9 10 #include <string.h> 11 #include <stdio.h> 12 #include <openssl/opensslconf.h> 13 #include <openssl/core.h> 14 #include <openssl/core_dispatch.h> 15 #include <openssl/core_names.h> 16 #include <openssl/params.h> 17 #include "prov/bio.h" 18 #include "prov/provider_ctx.h" 19 #include "prov/providercommon.h" 20 #include "prov/implementations.h" 21 #include "prov/provider_util.h" 22 #include "internal/nelem.h" 23 24 /* 25 * Forward declarations to ensure that interface functions are correctly 26 * defined. 27 */ 28 static OSSL_FUNC_provider_gettable_params_fn base_gettable_params; 29 static OSSL_FUNC_provider_get_params_fn base_get_params; 30 static OSSL_FUNC_provider_query_operation_fn base_query; 31 32 /* Functions provided by the core */ 33 static OSSL_FUNC_core_gettable_params_fn *c_gettable_params = NULL; 34 static OSSL_FUNC_core_get_params_fn *c_get_params = NULL; 35 36 /* Parameters we provide to the core */ 37 static const OSSL_PARAM base_param_types[] = { 38 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_NAME, OSSL_PARAM_UTF8_PTR, NULL, 0), 39 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_VERSION, OSSL_PARAM_UTF8_PTR, NULL, 0), 40 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_BUILDINFO, OSSL_PARAM_UTF8_PTR, NULL, 0), 41 OSSL_PARAM_DEFN(OSSL_PROV_PARAM_STATUS, OSSL_PARAM_INTEGER, NULL, 0), 42 OSSL_PARAM_END 43 }; 44 45 static const OSSL_PARAM *base_gettable_params(void *provctx) 46 { 47 return base_param_types; 48 } 49 50 static int base_get_params(void *provctx, OSSL_PARAM params[]) 51 { 52 OSSL_PARAM *p; 53 54 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_NAME); 55 if (p != NULL 56 && !OSSL_PARAM_set_utf8_ptr(p, "OpenSSL Base Provider")) 57 return 0; 58 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_VERSION); 59 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_VERSION_STR)) 60 return 0; 61 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_BUILDINFO); 62 if (p != NULL && !OSSL_PARAM_set_utf8_ptr(p, OPENSSL_FULL_VERSION_STR)) 63 return 0; 64 p = OSSL_PARAM_locate(params, OSSL_PROV_PARAM_STATUS); 65 if (p != NULL && !OSSL_PARAM_set_int(p, ossl_prov_is_running())) 66 return 0; 67 68 return 1; 69 } 70 71 static const OSSL_ALGORITHM base_encoder[] = { 72 #define ENCODER_PROVIDER "base" 73 #include "encoders.inc" 74 { NULL, NULL, NULL } 75 #undef ENCODER_PROVIDER 76 }; 77 78 static const OSSL_ALGORITHM base_decoder[] = { 79 #define DECODER_PROVIDER "base" 80 #include "decoders.inc" 81 { NULL, NULL, NULL } 82 #undef DECODER_PROVIDER 83 }; 84 85 static const OSSL_ALGORITHM base_store[] = { 86 #define STORE(name, _fips, func_table) \ 87 { name, "provider=base,fips=" _fips, (func_table) }, 88 89 #include "stores.inc" 90 { NULL, NULL, NULL } 91 #undef STORE 92 }; 93 94 static const OSSL_ALGORITHM *base_query(void *provctx, int operation_id, 95 int *no_cache) 96 { 97 *no_cache = 0; 98 switch (operation_id) { 99 case OSSL_OP_ENCODER: 100 return base_encoder; 101 case OSSL_OP_DECODER: 102 return base_decoder; 103 case OSSL_OP_STORE: 104 return base_store; 105 } 106 return NULL; 107 } 108 109 static void base_teardown(void *provctx) 110 { 111 BIO_meth_free(ossl_prov_ctx_get0_core_bio_method(provctx)); 112 ossl_prov_ctx_free(provctx); 113 } 114 115 /* Functions we provide to the core */ 116 static const OSSL_DISPATCH base_dispatch_table[] = { 117 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))base_teardown }, 118 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, 119 (void (*)(void))base_gettable_params }, 120 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))base_get_params }, 121 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))base_query }, 122 { 0, NULL } 123 }; 124 125 OSSL_provider_init_fn ossl_base_provider_init; 126 127 int ossl_base_provider_init(const OSSL_CORE_HANDLE *handle, 128 const OSSL_DISPATCH *in, const OSSL_DISPATCH **out, 129 void **provctx) 130 { 131 OSSL_FUNC_core_get_libctx_fn *c_get_libctx = NULL; 132 BIO_METHOD *corebiometh; 133 134 if (!ossl_prov_bio_from_dispatch(in)) 135 return 0; 136 for (; in->function_id != 0; in++) { 137 switch (in->function_id) { 138 case OSSL_FUNC_CORE_GETTABLE_PARAMS: 139 c_gettable_params = OSSL_FUNC_core_gettable_params(in); 140 break; 141 case OSSL_FUNC_CORE_GET_PARAMS: 142 c_get_params = OSSL_FUNC_core_get_params(in); 143 break; 144 case OSSL_FUNC_CORE_GET_LIBCTX: 145 c_get_libctx = OSSL_FUNC_core_get_libctx(in); 146 break; 147 default: 148 /* Just ignore anything we don't understand */ 149 break; 150 } 151 } 152 153 if (c_get_libctx == NULL) 154 return 0; 155 156 /* 157 * We want to make sure that all calls from this provider that requires 158 * a library context use the same context as the one used to call our 159 * functions. We do that by passing it along in the provider context. 160 * 161 * This only works for built-in providers. Most providers should 162 * create their own library context. 163 */ 164 if ((*provctx = ossl_prov_ctx_new()) == NULL 165 || (corebiometh = ossl_bio_prov_init_bio_method()) == NULL) { 166 ossl_prov_ctx_free(*provctx); 167 *provctx = NULL; 168 return 0; 169 } 170 ossl_prov_ctx_set0_libctx(*provctx, 171 (OSSL_LIB_CTX *)c_get_libctx(handle)); 172 ossl_prov_ctx_set0_handle(*provctx, handle); 173 ossl_prov_ctx_set0_core_bio_method(*provctx, corebiometh); 174 175 *out = base_dispatch_table; 176 177 return 1; 178 } 179