1/*
2 * Copyright 2021-2022 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
19static 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
26static const OSSL_DISPATCH dummy_decoder_functions[] = {
27    { OSSL_FUNC_DECODER_DECODE, (void (*)(void))dummy_decoder_decode },
28    { 0, NULL }
29};
30
31static const OSSL_ALGORITHM dummy_decoders[] = {
32    { "DUMMY", "provider=dummy,input=pem", dummy_decoder_functions },
33    { NULL, NULL, NULL }
34};
35
36static 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
44static const OSSL_DISPATCH dummy_encoder_functions[] = {
45    { OSSL_FUNC_DECODER_DECODE, (void (*)(void))dummy_encoder_encode },
46    { 0, NULL }
47};
48
49static const OSSL_ALGORITHM dummy_encoders[] = {
50    { "DUMMY", "provider=dummy,output=pem", dummy_encoder_functions },
51    { NULL, NULL, NULL }
52};
53
54static void *dummy_store_open(void *provctx, const char *uri)
55{
56    return NULL;
57}
58
59static 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
66static int dumm_store_eof(void *loaderctx)
67{
68    return 0;
69}
70
71static int dummy_store_close(void *loaderctx)
72{
73    return 0;
74}
75
76static 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    { 0, NULL }
82};
83
84static const OSSL_ALGORITHM dummy_store[] = {
85    { "DUMMY", "provider=dummy", dummy_store_functions },
86    { NULL, NULL, NULL }
87};
88
89static void *dummy_rand_newctx(void *provctx, void *parent,
90                               const OSSL_DISPATCH *parent_calls)
91{
92    return provctx;
93}
94
95static void dummy_rand_freectx(void *vctx)
96{
97}
98
99static 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
107static int dummy_rand_uninstantiate(void *vdrbg)
108{
109    return 1;
110}
111
112static 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
124static 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
133static 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
144static int dummy_rand_enable_locking(void *vtest)
145{
146    return 1;
147}
148
149static int dummy_rand_lock(void *vtest)
150{
151    return 1;
152}
153
154static void dummy_rand_unlock(void *vtest)
155{
156}
157
158static 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    { 0, NULL }
171};
172
173static const OSSL_ALGORITHM dummy_rand[] = {
174    { "DUMMY", "provider=dummy", dummy_rand_functions },
175    { NULL, NULL, NULL }
176};
177
178static 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
195static 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    { 0, NULL }
199};
200
201static 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 */
230static 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
292int setup_tests(void)
293{
294    ADD_ALL_TESTS(fetch_test, 8);
295
296    return 1;
297}
298