1 /*
2 * Copyright 2021-2023 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 <openssl/crypto.h>
11 #include <openssl/provider.h>
12 #include <openssl/decoder.h>
13 #include <openssl/encoder.h>
14 #include <openssl/store.h>
15 #include <openssl/rand.h>
16 #include <openssl/core_names.h>
17 #include "testutil.h"
18
dummy_decoder_decode(void * ctx,OSSL_CORE_BIO * cin,int selection,OSSL_CALLBACK * object_cb,void * object_cbarg,OSSL_PASSPHRASE_CALLBACK * pw_cb,void * pw_cbarg)19 static int dummy_decoder_decode(void *ctx, OSSL_CORE_BIO *cin, int selection,
20 OSSL_CALLBACK *object_cb, void *object_cbarg,
21 OSSL_PASSPHRASE_CALLBACK *pw_cb, void *pw_cbarg)
22 {
23 return 0;
24 }
25
26 static const OSSL_DISPATCH dummy_decoder_functions[] = {
27 { OSSL_FUNC_DECODER_DECODE, (void (*)(void))dummy_decoder_decode },
28 OSSL_DISPATCH_END
29 };
30
31 static const OSSL_ALGORITHM dummy_decoders[] = {
32 { "DUMMY", "provider=dummy,input=pem", dummy_decoder_functions },
33 { NULL, NULL, NULL }
34 };
35
dummy_encoder_encode(void * ctx,OSSL_CORE_BIO * out,const void * obj_raw,const OSSL_PARAM obj_abstract[],int selection,OSSL_PASSPHRASE_CALLBACK * cb,void * cbarg)36 static int dummy_encoder_encode(void *ctx, OSSL_CORE_BIO *out,
37 const void *obj_raw,
38 const OSSL_PARAM obj_abstract[], int selection,
39 OSSL_PASSPHRASE_CALLBACK *cb, void *cbarg)
40 {
41 return 0;
42 }
43
44 static const OSSL_DISPATCH dummy_encoder_functions[] = {
45 { OSSL_FUNC_DECODER_DECODE, (void (*)(void))dummy_encoder_encode },
46 OSSL_DISPATCH_END
47 };
48
49 static const OSSL_ALGORITHM dummy_encoders[] = {
50 { "DUMMY", "provider=dummy,output=pem", dummy_encoder_functions },
51 { NULL, NULL, NULL }
52 };
53
dummy_store_open(void * provctx,const char * uri)54 static void *dummy_store_open(void *provctx, const char *uri)
55 {
56 return NULL;
57 }
58
dummy_store_load(void * loaderctx,OSSL_CALLBACK * object_cb,void * object_cbarg,OSSL_PASSPHRASE_CALLBACK * pw_cb,void * pw_cbarg)59 static int dummy_store_load(void *loaderctx, OSSL_CALLBACK *object_cb,
60 void *object_cbarg, OSSL_PASSPHRASE_CALLBACK *pw_cb,
61 void *pw_cbarg)
62 {
63 return 0;
64 }
65
dumm_store_eof(void * loaderctx)66 static int dumm_store_eof(void *loaderctx)
67 {
68 return 0;
69 }
70
dummy_store_close(void * loaderctx)71 static int dummy_store_close(void *loaderctx)
72 {
73 return 0;
74 }
75
76 static const OSSL_DISPATCH dummy_store_functions[] = {
77 { OSSL_FUNC_STORE_OPEN, (void (*)(void))dummy_store_open },
78 { OSSL_FUNC_STORE_LOAD, (void (*)(void))dummy_store_load },
79 { OSSL_FUNC_STORE_EOF, (void (*)(void))dumm_store_eof },
80 { OSSL_FUNC_STORE_CLOSE, (void (*)(void))dummy_store_close },
81 OSSL_DISPATCH_END
82 };
83
84 static const OSSL_ALGORITHM dummy_store[] = {
85 { "DUMMY", "provider=dummy", dummy_store_functions },
86 { NULL, NULL, NULL }
87 };
88
dummy_rand_newctx(void * provctx,void * parent,const OSSL_DISPATCH * parent_calls)89 static void *dummy_rand_newctx(void *provctx, void *parent,
90 const OSSL_DISPATCH *parent_calls)
91 {
92 return provctx;
93 }
94
dummy_rand_freectx(void * vctx)95 static void dummy_rand_freectx(void *vctx)
96 {
97 }
98
dummy_rand_instantiate(void * vdrbg,unsigned int strength,int prediction_resistance,const unsigned char * pstr,size_t pstr_len,const OSSL_PARAM params[])99 static int dummy_rand_instantiate(void *vdrbg, unsigned int strength,
100 int prediction_resistance,
101 const unsigned char *pstr, size_t pstr_len,
102 const OSSL_PARAM params[])
103 {
104 return 1;
105 }
106
dummy_rand_uninstantiate(void * vdrbg)107 static int dummy_rand_uninstantiate(void *vdrbg)
108 {
109 return 1;
110 }
111
dummy_rand_generate(void * vctx,unsigned char * out,size_t outlen,unsigned int strength,int prediction_resistance,const unsigned char * addin,size_t addin_len)112 static int dummy_rand_generate(void *vctx, unsigned char *out, size_t outlen,
113 unsigned int strength, int prediction_resistance,
114 const unsigned char *addin, size_t addin_len)
115 {
116 size_t i;
117
118 for (i = 0; i <outlen; i++)
119 out[i] = (unsigned char)(i & 0xff);
120
121 return 1;
122 }
123
dummy_rand_gettable_ctx_params(void * vctx,void * provctx)124 static const OSSL_PARAM *dummy_rand_gettable_ctx_params(void *vctx, void *provctx)
125 {
126 static const OSSL_PARAM known_gettable_ctx_params[] = {
127 OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
128 OSSL_PARAM_END
129 };
130 return known_gettable_ctx_params;
131 }
132
dummy_rand_get_ctx_params(void * vctx,OSSL_PARAM params[])133 static int dummy_rand_get_ctx_params(void *vctx, OSSL_PARAM params[])
134 {
135 OSSL_PARAM *p;
136
137 p = OSSL_PARAM_locate(params, OSSL_RAND_PARAM_MAX_REQUEST);
138 if (p != NULL && !OSSL_PARAM_set_size_t(p, INT_MAX))
139 return 0;
140
141 return 1;
142 }
143
dummy_rand_enable_locking(void * vtest)144 static int dummy_rand_enable_locking(void *vtest)
145 {
146 return 1;
147 }
148
dummy_rand_lock(void * vtest)149 static int dummy_rand_lock(void *vtest)
150 {
151 return 1;
152 }
153
dummy_rand_unlock(void * vtest)154 static void dummy_rand_unlock(void *vtest)
155 {
156 }
157
158 static const OSSL_DISPATCH dummy_rand_functions[] = {
159 { OSSL_FUNC_RAND_NEWCTX, (void (*)(void))dummy_rand_newctx },
160 { OSSL_FUNC_RAND_FREECTX, (void (*)(void))dummy_rand_freectx },
161 { OSSL_FUNC_RAND_INSTANTIATE, (void (*)(void))dummy_rand_instantiate },
162 { OSSL_FUNC_RAND_UNINSTANTIATE, (void (*)(void))dummy_rand_uninstantiate },
163 { OSSL_FUNC_RAND_GENERATE, (void (*)(void))dummy_rand_generate },
164 { OSSL_FUNC_RAND_GETTABLE_CTX_PARAMS,
165 (void(*)(void))dummy_rand_gettable_ctx_params },
166 { OSSL_FUNC_RAND_GET_CTX_PARAMS, (void(*)(void))dummy_rand_get_ctx_params },
167 { OSSL_FUNC_RAND_ENABLE_LOCKING, (void(*)(void))dummy_rand_enable_locking },
168 { OSSL_FUNC_RAND_LOCK, (void(*)(void))dummy_rand_lock },
169 { OSSL_FUNC_RAND_UNLOCK, (void(*)(void))dummy_rand_unlock },
170 OSSL_DISPATCH_END
171 };
172
173 static const OSSL_ALGORITHM dummy_rand[] = {
174 { "DUMMY", "provider=dummy", dummy_rand_functions },
175 { NULL, NULL, NULL }
176 };
177
dummy_query(void * provctx,int operation_id,int * no_cache)178 static const OSSL_ALGORITHM *dummy_query(void *provctx, int operation_id,
179 int *no_cache)
180 {
181 *no_cache = 0;
182 switch (operation_id) {
183 case OSSL_OP_DECODER:
184 return dummy_decoders;
185 case OSSL_OP_ENCODER:
186 return dummy_encoders;
187 case OSSL_OP_STORE:
188 return dummy_store;
189 case OSSL_OP_RAND:
190 return dummy_rand;
191 }
192 return NULL;
193 }
194
195 static const OSSL_DISPATCH dummy_dispatch_table[] = {
196 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))dummy_query },
197 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))OSSL_LIB_CTX_free },
198 OSSL_DISPATCH_END
199 };
200
dummy_provider_init(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in,const OSSL_DISPATCH ** out,void ** provctx)201 static int dummy_provider_init(const OSSL_CORE_HANDLE *handle,
202 const OSSL_DISPATCH *in,
203 const OSSL_DISPATCH **out,
204 void **provctx)
205 {
206 OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new_child(handle, in);
207 unsigned char buf[32];
208
209 *provctx = (void *)libctx;
210 *out = dummy_dispatch_table;
211
212 /*
213 * Do some work using the child libctx, to make sure this is possible from
214 * inside the init function.
215 */
216 if (RAND_bytes_ex(libctx, buf, sizeof(buf), 0) <= 0)
217 return 0;
218
219 return 1;
220 }
221
222 /*
223 * Try fetching and freeing various things.
224 * Test 0: Decoder
225 * Test 1: Encoder
226 * Test 2: Store loader
227 * Test 3: EVP_RAND
228 * Test 4-7: As above, but additionally with a query string
229 */
fetch_test(int tst)230 static int fetch_test(int tst)
231 {
232 OSSL_LIB_CTX *libctx = OSSL_LIB_CTX_new();
233 OSSL_PROVIDER *dummyprov = NULL;
234 OSSL_PROVIDER *nullprov = NULL;
235 OSSL_DECODER *decoder = NULL;
236 OSSL_ENCODER *encoder = NULL;
237 OSSL_STORE_LOADER *loader = NULL;
238 int testresult = 0;
239 unsigned char buf[32];
240 int query = tst > 3;
241
242 if (!TEST_ptr(libctx))
243 goto err;
244
245 if (!TEST_true(OSSL_PROVIDER_add_builtin(libctx, "dummy-prov",
246 dummy_provider_init))
247 || !TEST_ptr(nullprov = OSSL_PROVIDER_load(libctx, "default"))
248 || !TEST_ptr(dummyprov = OSSL_PROVIDER_load(libctx, "dummy-prov")))
249 goto err;
250
251 switch (tst % 4) {
252 case 0:
253 decoder = OSSL_DECODER_fetch(libctx, "DUMMY",
254 query ? "provider=dummy" : NULL);
255 if (!TEST_ptr(decoder))
256 goto err;
257 break;
258 case 1:
259 encoder = OSSL_ENCODER_fetch(libctx, "DUMMY",
260 query ? "provider=dummy" : NULL);
261 if (!TEST_ptr(encoder))
262 goto err;
263 break;
264 case 2:
265 loader = OSSL_STORE_LOADER_fetch(libctx, "DUMMY",
266 query ? "provider=dummy" : NULL);
267 if (!TEST_ptr(loader))
268 goto err;
269 break;
270 case 3:
271 if (!TEST_true(RAND_set_DRBG_type(libctx, "DUMMY",
272 query ? "provider=dummy" : NULL,
273 NULL, NULL))
274 || !TEST_int_ge(RAND_bytes_ex(libctx, buf, sizeof(buf), 0), 1))
275 goto err;
276 break;
277 default:
278 goto err;
279 }
280
281 testresult = 1;
282 err:
283 OSSL_DECODER_free(decoder);
284 OSSL_ENCODER_free(encoder);
285 OSSL_STORE_LOADER_free(loader);
286 OSSL_PROVIDER_unload(dummyprov);
287 OSSL_PROVIDER_unload(nullprov);
288 OSSL_LIB_CTX_free(libctx);
289 return testresult;
290 }
291
setup_tests(void)292 int setup_tests(void)
293 {
294 ADD_ALL_TESTS(fetch_test, 8);
295
296 return 1;
297 }
298
