1 /*
2 * Copyright 2020-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 /*
11 * A filtering provider for test purposes. We pass all calls through to the
12 * default provider except where we want other behaviour for a test.
13 */
14
15 #include <string.h>
16 #include <openssl/core.h>
17 #include <openssl/provider.h>
18 #include <openssl/crypto.h>
19 #include "testutil.h"
20 #include "filterprov.h"
21
22 #define MAX_FILTERS 10
23 #define MAX_ALG_FILTERS 5
24
25 struct filter_prov_globals_st {
26 OSSL_LIB_CTX *libctx;
27 OSSL_PROVIDER *deflt;
28 struct {
29 int operation;
30 OSSL_ALGORITHM alg[MAX_ALG_FILTERS + 1];
31 } dispatch[MAX_FILTERS];
32 int num_dispatch;
33 int no_cache;
34 unsigned long int query_count;
35 int error;
36 };
37
38 static struct filter_prov_globals_st ourglobals;
39
get_globals(void)40 static struct filter_prov_globals_st *get_globals(void)
41 {
42 /*
43 * Ideally we'd like to store this in the OSSL_LIB_CTX so that we can have
44 * more than one instance of the filter provider at a time. But for now we
45 * just make it simple.
46 */
47 return &ourglobals;
48 }
49
50 static OSSL_FUNC_provider_gettable_params_fn filter_gettable_params;
51 static OSSL_FUNC_provider_get_params_fn filter_get_params;
52 static OSSL_FUNC_provider_query_operation_fn filter_query;
53 static OSSL_FUNC_provider_unquery_operation_fn filter_unquery;
54 static OSSL_FUNC_provider_teardown_fn filter_teardown;
55
filter_gettable_params(void * provctx)56 static const OSSL_PARAM *filter_gettable_params(void *provctx)
57 {
58 struct filter_prov_globals_st *globs = get_globals();
59
60 return OSSL_PROVIDER_gettable_params(globs->deflt);
61 }
62
filter_get_params(void * provctx,OSSL_PARAM params[])63 static int filter_get_params(void *provctx, OSSL_PARAM params[])
64 {
65 struct filter_prov_globals_st *globs = get_globals();
66
67 return OSSL_PROVIDER_get_params(globs->deflt, params);
68 }
69
filter_get_capabilities(void * provctx,const char * capability,OSSL_CALLBACK * cb,void * arg)70 static int filter_get_capabilities(void *provctx, const char *capability,
71 OSSL_CALLBACK *cb, void *arg)
72 {
73 struct filter_prov_globals_st *globs = get_globals();
74
75 return OSSL_PROVIDER_get_capabilities(globs->deflt, capability, cb, arg);
76 }
77
filter_query(void * provctx,int operation_id,int * no_cache)78 static const OSSL_ALGORITHM *filter_query(void *provctx,
79 int operation_id,
80 int *no_cache)
81 {
82 struct filter_prov_globals_st *globs = get_globals();
83 int i;
84
85 globs->query_count++;
86 for (i = 0; i < globs->num_dispatch; i++) {
87 if (globs->dispatch[i].operation == operation_id) {
88 *no_cache = globs->no_cache;
89 return globs->dispatch[i].alg;
90 }
91 }
92
93 /* No filter set, so pass it down to the chained provider */
94 return OSSL_PROVIDER_query_operation(globs->deflt, operation_id, no_cache);
95 }
96
filter_unquery(void * provctx,int operation_id,const OSSL_ALGORITHM * algs)97 static void filter_unquery(void *provctx, int operation_id,
98 const OSSL_ALGORITHM *algs)
99 {
100 struct filter_prov_globals_st *globs = get_globals();
101 int i;
102
103 if (!TEST_ulong_gt(globs->query_count, 0))
104 globs->error = 1;
105 else
106 globs->query_count--;
107
108 for (i = 0; i < globs->num_dispatch; i++)
109 if (globs->dispatch[i].alg == algs)
110 return;
111 OSSL_PROVIDER_unquery_operation(globs->deflt, operation_id, algs);
112 }
113
filter_teardown(void * provctx)114 static void filter_teardown(void *provctx)
115 {
116 struct filter_prov_globals_st *globs = get_globals();
117
118 OSSL_PROVIDER_unload(globs->deflt);
119 OSSL_LIB_CTX_free(globs->libctx);
120 memset(globs, 0, sizeof(*globs));
121 }
122
123 /* Functions we provide to the core */
124 static const OSSL_DISPATCH filter_dispatch_table[] = {
125 { OSSL_FUNC_PROVIDER_GETTABLE_PARAMS, (void (*)(void))filter_gettable_params },
126 { OSSL_FUNC_PROVIDER_GET_PARAMS, (void (*)(void))filter_get_params },
127 { OSSL_FUNC_PROVIDER_QUERY_OPERATION, (void (*)(void))filter_query },
128 { OSSL_FUNC_PROVIDER_UNQUERY_OPERATION, (void (*)(void))filter_unquery },
129 { OSSL_FUNC_PROVIDER_GET_CAPABILITIES, (void (*)(void))filter_get_capabilities },
130 { OSSL_FUNC_PROVIDER_TEARDOWN, (void (*)(void))filter_teardown },
131 OSSL_DISPATCH_END
132 };
133
filter_provider_init(const OSSL_CORE_HANDLE * handle,const OSSL_DISPATCH * in,const OSSL_DISPATCH ** out,void ** provctx)134 int filter_provider_init(const OSSL_CORE_HANDLE *handle,
135 const OSSL_DISPATCH *in,
136 const OSSL_DISPATCH **out,
137 void **provctx)
138 {
139 memset(&ourglobals, 0, sizeof(ourglobals));
140 ourglobals.libctx = OSSL_LIB_CTX_new();
141 if (ourglobals.libctx == NULL)
142 goto err;
143
144 ourglobals.deflt = OSSL_PROVIDER_load(ourglobals.libctx, "default");
145 if (ourglobals.deflt == NULL)
146 goto err;
147
148 *provctx = OSSL_PROVIDER_get0_provider_ctx(ourglobals.deflt);
149 *out = filter_dispatch_table;
150 return 1;
151
152 err:
153 OSSL_PROVIDER_unload(ourglobals.deflt);
154 OSSL_LIB_CTX_free(ourglobals.libctx);
155 return 0;
156 }
157
158 /*
159 * Set a filter for the given operation id. The filter string is a colon
160 * separated list of algorithms that will be made available by this provider.
161 * Anything not in the filter will be suppressed. If a filter is not set for
162 * a given operation id then all algorithms are made available.
163 */
filter_provider_set_filter(int operation,const char * filterstr)164 int filter_provider_set_filter(int operation, const char *filterstr)
165 {
166 int no_cache = 0;
167 int algnum = 0, last = 0, ret = 0;
168 struct filter_prov_globals_st *globs = get_globals();
169 size_t namelen;
170 char *filterstrtmp = OPENSSL_strdup(filterstr);
171 char *name, *sep;
172 const OSSL_ALGORITHM *provalgs = OSSL_PROVIDER_query_operation(globs->deflt,
173 operation,
174 &no_cache);
175 const OSSL_ALGORITHM *algs;
176
177 if (filterstrtmp == NULL)
178 goto err;
179
180 /* Nothing to filter */
181 if (provalgs == NULL)
182 goto err;
183
184 if (globs->num_dispatch >= MAX_FILTERS)
185 goto err;
186
187 for (name = filterstrtmp; !last; name = (sep == NULL ? NULL : sep + 1)) {
188 sep = strstr(name, ":");
189 if (sep != NULL)
190 *sep = '\0';
191 else
192 last = 1;
193 namelen = strlen(name);
194
195 for (algs = provalgs; algs->algorithm_names != NULL; algs++) {
196 const char *found = strstr(algs->algorithm_names, name);
197
198 if (found == NULL)
199 continue;
200 if (found[namelen] != '\0' && found[namelen] != ':')
201 continue;
202 if (found != algs->algorithm_names && found[-1] != ':')
203 continue;
204
205 /* We found a match */
206 if (algnum >= MAX_ALG_FILTERS)
207 goto err;
208
209 globs->dispatch[globs->num_dispatch].alg[algnum++] = *algs;
210 break;
211 }
212 if (algs->algorithm_names == NULL) {
213 /* No match found */
214 goto err;
215 }
216 }
217
218 globs->dispatch[globs->num_dispatch].operation = operation;
219 globs->no_cache = no_cache;
220 globs->num_dispatch++;
221
222 ret = 1;
223 err:
224 OSSL_PROVIDER_unquery_operation(globs->deflt, operation, provalgs);
225 OPENSSL_free(filterstrtmp);
226 return ret;
227 }
228
229 /*
230 * Test if a filter provider is in a clean finishing state.
231 * If it is return 1, otherwise return 0.
232 */
filter_provider_check_clean_finish(void)233 int filter_provider_check_clean_finish(void)
234 {
235 struct filter_prov_globals_st *globs = get_globals();
236
237 return TEST_ulong_eq(globs->query_count, 0) && !globs->error;
238 }
239
