1 /* 2 * Copyright 2020-2025 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 "prov/names.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_rands[] = { 95 { PROV_NAMES_SEED_SRC, "provider=base", ossl_seed_src_functions }, 96 #ifndef OPENSSL_NO_JITTER 97 { PROV_NAMES_JITTER, "provider=base", ossl_jitter_functions }, 98 #endif 99 { NULL, NULL, NULL } 100 }; 101 102 static const OSSL_ALGORITHM *base_query(void *provctx, int operation_id, 103 int *no_cache) 104 { 105 *no_cache = 0; 106 switch (operation_id) { 107 case OSSL_OP_ENCODER: 108 return base_encoder; 109 case OSSL_OP_DECODER: 110 return base_decoder; 111 case OSSL_OP_STORE: 112 return base_store; 113 case OSSL_OP_RAND: 114 return base_rands; 115 } 116 return NULL; 117 } 118 119 static void base_teardown(void *provctx) 120 { 121 BIO_meth_free(ossl_prov_ctx_get0_core_bio_method(provctx)); 122 ossl_prov_ctx_free(provctx); 123 } 124 125 /* Functions we provide to the core */ 126 static const OSSL_DISPATCH base_dispatch_table[] = { 127 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))base_teardown }, 128 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, 129 (void (*)(void))base_gettable_params }, 130 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))base_get_params }, 131 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))base_query }, 132 OSSL_DISPATCH_END 133 }; 134 135 OSSL_provider_init_fn ossl_base_provider_init; 136 137 int ossl_base_provider_init(const OSSL_CORE_HANDLE *handle, 138 const OSSL_DISPATCH *in, const OSSL_DISPATCH **out, 139 void **provctx) 140 { 141 OSSL_FUNC_core_get_libctx_fn *c_get_libctx = NULL; 142 BIO_METHOD *corebiometh; 143 144 if (!ossl_prov_bio_from_dispatch(in)) 145 return 0; 146 for (; in->function_id != 0; in++) { 147 switch (in->function_id) { 148 case OSSL_FUNC_CORE_GETTABLE_PARAMS: 149 c_gettable_params = OSSL_FUNC_core_gettable_params(in); 150 break; 151 case OSSL_FUNC_CORE_GET_PARAMS: 152 c_get_params = OSSL_FUNC_core_get_params(in); 153 break; 154 case OSSL_FUNC_CORE_GET_LIBCTX: 155 c_get_libctx = OSSL_FUNC_core_get_libctx(in); 156 break; 157 default: 158 /* Just ignore anything we don't understand */ 159 break; 160 } 161 } 162 163 if (c_get_libctx == NULL) 164 return 0; 165 166 /* 167 * We want to make sure that all calls from this provider that requires 168 * a library context use the same context as the one used to call our 169 * functions. We do that by passing it along in the provider context. 170 * 171 * This only works for built-in providers. Most providers should 172 * create their own library context. 173 */ 174 if ((*provctx = ossl_prov_ctx_new()) == NULL 175 || (corebiometh = ossl_bio_prov_init_bio_method()) == NULL) { 176 ossl_prov_ctx_free(*provctx); 177 *provctx = NULL; 178 return 0; 179 } 180 ossl_prov_ctx_set0_libctx(*provctx, 181 (OSSL_LIB_CTX *)c_get_libctx(handle)); 182 ossl_prov_ctx_set0_handle(*provctx, handle); 183 ossl_prov_ctx_set0_core_bio_method(*provctx, corebiometh); 184 ossl_prov_ctx_set0_core_get_params(*provctx, c_get_params); 185 186 *out = base_dispatch_table; 187 188 return 1; 189 } 190
Indexes created Sat Feb 28 05:31:39 UTC 2026