1 /*
2 * Copyright 1995-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 <stdlib.h>
11 #include "crypto/cryptlib.h"
12 #include "internal/thread_once.h"
13
ossl_do_ex_data_init(OSSL_LIB_CTX * ctx)14 int ossl_do_ex_data_init(OSSL_LIB_CTX *ctx)
15 {
16 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ctx);
17
18 if (global == NULL)
19 return 0;
20
21 global->ex_data_lock = CRYPTO_THREAD_lock_new();
22 return global->ex_data_lock != NULL;
23 }
24
25 /*
26 * Return the EX_CALLBACKS from the |ex_data| array that corresponds to
27 * a given class. On success, *holds the lock.*
28 * The |global| parameter is assumed to be non null (checked by the caller).
29 */
get_and_lock(OSSL_EX_DATA_GLOBAL * global,int class_index)30 static EX_CALLBACKS *get_and_lock(OSSL_EX_DATA_GLOBAL *global, int class_index)
31 {
32 EX_CALLBACKS *ip;
33
34 if (class_index < 0 || class_index >= CRYPTO_EX_INDEX__COUNT) {
35 ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT);
36 return NULL;
37 }
38
39 if (global->ex_data_lock == NULL) {
40 /*
41 * If we get here, someone (who?) cleaned up the lock, so just
42 * treat it as an error.
43 */
44 return NULL;
45 }
46
47 if (!CRYPTO_THREAD_write_lock(global->ex_data_lock))
48 return NULL;
49 ip = &global->ex_data[class_index];
50 return ip;
51 }
52
cleanup_cb(EX_CALLBACK * funcs)53 static void cleanup_cb(EX_CALLBACK *funcs)
54 {
55 OPENSSL_free(funcs);
56 }
57
58 /*
59 * Release all "ex_data" state to prevent memory leaks. This can't be made
60 * thread-safe without overhauling a lot of stuff, and shouldn't really be
61 * called under potential race-conditions anyway (it's for program shutdown
62 * after all).
63 */
ossl_crypto_cleanup_all_ex_data_int(OSSL_LIB_CTX * ctx)64 void ossl_crypto_cleanup_all_ex_data_int(OSSL_LIB_CTX *ctx)
65 {
66 int i;
67 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ctx);
68
69 if (global == NULL)
70 return;
71
72 for (i = 0; i < CRYPTO_EX_INDEX__COUNT; ++i) {
73 EX_CALLBACKS *ip = &global->ex_data[i];
74
75 sk_EX_CALLBACK_pop_free(ip->meth, cleanup_cb);
76 ip->meth = NULL;
77 }
78
79 CRYPTO_THREAD_lock_free(global->ex_data_lock);
80 global->ex_data_lock = NULL;
81 }
82
83
84 /*
85 * Unregister a new index by replacing the callbacks with no-ops.
86 * Any in-use instances are leaked.
87 */
dummy_new(void * parent,void * ptr,CRYPTO_EX_DATA * ad,int idx,long argl,void * argp)88 static void dummy_new(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx,
89 long argl, void *argp)
90 {
91 }
92
dummy_free(void * parent,void * ptr,CRYPTO_EX_DATA * ad,int idx,long argl,void * argp)93 static void dummy_free(void *parent, void *ptr, CRYPTO_EX_DATA *ad, int idx,
94 long argl, void *argp)
95 {
96 }
97
dummy_dup(CRYPTO_EX_DATA * to,const CRYPTO_EX_DATA * from,void ** from_d,int idx,long argl,void * argp)98 static int dummy_dup(CRYPTO_EX_DATA *to, const CRYPTO_EX_DATA *from,
99 void **from_d, int idx,
100 long argl, void *argp)
101 {
102 return 1;
103 }
104
ossl_crypto_free_ex_index_ex(OSSL_LIB_CTX * ctx,int class_index,int idx)105 int ossl_crypto_free_ex_index_ex(OSSL_LIB_CTX *ctx, int class_index, int idx)
106 {
107 EX_CALLBACKS *ip;
108 EX_CALLBACK *a;
109 int toret = 0;
110 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ctx);
111
112 if (global == NULL)
113 return 0;
114
115 ip = get_and_lock(global, class_index);
116 if (ip == NULL)
117 return 0;
118
119 if (idx < 0 || idx >= sk_EX_CALLBACK_num(ip->meth))
120 goto err;
121 a = sk_EX_CALLBACK_value(ip->meth, idx);
122 if (a == NULL)
123 goto err;
124 a->new_func = dummy_new;
125 a->dup_func = dummy_dup;
126 a->free_func = dummy_free;
127 toret = 1;
128 err:
129 CRYPTO_THREAD_unlock(global->ex_data_lock);
130 return toret;
131 }
132
CRYPTO_free_ex_index(int class_index,int idx)133 int CRYPTO_free_ex_index(int class_index, int idx)
134 {
135 return ossl_crypto_free_ex_index_ex(NULL, class_index, idx);
136 }
137
138 /*
139 * Register a new index.
140 */
ossl_crypto_get_ex_new_index_ex(OSSL_LIB_CTX * ctx,int class_index,long argl,void * argp,CRYPTO_EX_new * new_func,CRYPTO_EX_dup * dup_func,CRYPTO_EX_free * free_func,int priority)141 int ossl_crypto_get_ex_new_index_ex(OSSL_LIB_CTX *ctx, int class_index,
142 long argl, void *argp,
143 CRYPTO_EX_new *new_func,
144 CRYPTO_EX_dup *dup_func,
145 CRYPTO_EX_free *free_func,
146 int priority)
147 {
148 int toret = -1;
149 EX_CALLBACK *a;
150 EX_CALLBACKS *ip;
151 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ctx);
152
153 if (global == NULL)
154 return -1;
155
156 ip = get_and_lock(global, class_index);
157 if (ip == NULL)
158 return -1;
159
160 if (ip->meth == NULL) {
161 ip->meth = sk_EX_CALLBACK_new_null();
162 /* We push an initial value on the stack because the SSL
163 * "app_data" routines use ex_data index zero. See RT 3710. */
164 if (ip->meth == NULL
165 || !sk_EX_CALLBACK_push(ip->meth, NULL)) {
166 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
167 goto err;
168 }
169 }
170
171 a = (EX_CALLBACK *)OPENSSL_malloc(sizeof(*a));
172 if (a == NULL) {
173 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
174 goto err;
175 }
176 a->argl = argl;
177 a->argp = argp;
178 a->new_func = new_func;
179 a->dup_func = dup_func;
180 a->free_func = free_func;
181 a->priority = priority;
182
183 if (!sk_EX_CALLBACK_push(ip->meth, NULL)) {
184 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
185 OPENSSL_free(a);
186 goto err;
187 }
188 toret = sk_EX_CALLBACK_num(ip->meth) - 1;
189 (void)sk_EX_CALLBACK_set(ip->meth, toret, a);
190
191 err:
192 CRYPTO_THREAD_unlock(global->ex_data_lock);
193 return toret;
194 }
195
CRYPTO_get_ex_new_index(int class_index,long argl,void * argp,CRYPTO_EX_new * new_func,CRYPTO_EX_dup * dup_func,CRYPTO_EX_free * free_func)196 int CRYPTO_get_ex_new_index(int class_index, long argl, void *argp,
197 CRYPTO_EX_new *new_func, CRYPTO_EX_dup *dup_func,
198 CRYPTO_EX_free *free_func)
199 {
200 return ossl_crypto_get_ex_new_index_ex(NULL, class_index, argl, argp,
201 new_func, dup_func, free_func, 0);
202 }
203
204 /*
205 * Initialise a new CRYPTO_EX_DATA for use in a particular class - including
206 * calling new() callbacks for each index in the class used by this variable
207 * Thread-safe by copying a class's array of "EX_CALLBACK" entries
208 * in the lock, then using them outside the lock. Note this only applies
209 * to the global "ex_data" state (ie. class definitions), not 'ad' itself.
210 */
ossl_crypto_new_ex_data_ex(OSSL_LIB_CTX * ctx,int class_index,void * obj,CRYPTO_EX_DATA * ad)211 int ossl_crypto_new_ex_data_ex(OSSL_LIB_CTX *ctx, int class_index, void *obj,
212 CRYPTO_EX_DATA *ad)
213 {
214 int mx, i;
215 void *ptr;
216 EX_CALLBACK **storage = NULL;
217 EX_CALLBACK *stack[10];
218 EX_CALLBACKS *ip;
219 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ctx);
220
221 if (global == NULL)
222 return 0;
223
224 ip = get_and_lock(global, class_index);
225 if (ip == NULL)
226 return 0;
227
228 ad->ctx = ctx;
229 ad->sk = NULL;
230 mx = sk_EX_CALLBACK_num(ip->meth);
231 if (mx > 0) {
232 if (mx < (int)OSSL_NELEM(stack))
233 storage = stack;
234 else
235 storage = OPENSSL_malloc(sizeof(*storage) * mx);
236 if (storage != NULL)
237 for (i = 0; i < mx; i++)
238 storage[i] = sk_EX_CALLBACK_value(ip->meth, i);
239 }
240 CRYPTO_THREAD_unlock(global->ex_data_lock);
241
242 if (mx > 0 && storage == NULL) {
243 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
244 return 0;
245 }
246 for (i = 0; i < mx; i++) {
247 if (storage[i] != NULL && storage[i]->new_func != NULL) {
248 ptr = CRYPTO_get_ex_data(ad, i);
249 storage[i]->new_func(obj, ptr, ad, i,
250 storage[i]->argl, storage[i]->argp);
251 }
252 }
253 if (storage != stack)
254 OPENSSL_free(storage);
255 return 1;
256 }
257
CRYPTO_new_ex_data(int class_index,void * obj,CRYPTO_EX_DATA * ad)258 int CRYPTO_new_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
259 {
260 return ossl_crypto_new_ex_data_ex(NULL, class_index, obj, ad);
261 }
262
263 /*
264 * Duplicate a CRYPTO_EX_DATA variable - including calling dup() callbacks
265 * for each index in the class used by this variable
266 */
CRYPTO_dup_ex_data(int class_index,CRYPTO_EX_DATA * to,const CRYPTO_EX_DATA * from)267 int CRYPTO_dup_ex_data(int class_index, CRYPTO_EX_DATA *to,
268 const CRYPTO_EX_DATA *from)
269 {
270 int mx, j, i;
271 void *ptr;
272 EX_CALLBACK *stack[10];
273 EX_CALLBACK **storage = NULL;
274 EX_CALLBACKS *ip;
275 int toret = 0;
276 OSSL_EX_DATA_GLOBAL *global;
277
278 to->ctx = from->ctx;
279 if (from->sk == NULL)
280 /* Nothing to copy over */
281 return 1;
282
283 global = ossl_lib_ctx_get_ex_data_global(from->ctx);
284 if (global == NULL)
285 return 0;
286
287 ip = get_and_lock(global, class_index);
288 if (ip == NULL)
289 return 0;
290
291 mx = sk_EX_CALLBACK_num(ip->meth);
292 j = sk_void_num(from->sk);
293 if (j < mx)
294 mx = j;
295 if (mx > 0) {
296 if (mx < (int)OSSL_NELEM(stack))
297 storage = stack;
298 else
299 storage = OPENSSL_malloc(sizeof(*storage) * mx);
300 if (storage != NULL)
301 for (i = 0; i < mx; i++)
302 storage[i] = sk_EX_CALLBACK_value(ip->meth, i);
303 }
304 CRYPTO_THREAD_unlock(global->ex_data_lock);
305
306 if (mx == 0)
307 return 1;
308 if (storage == NULL) {
309 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
310 return 0;
311 }
312 /*
313 * Make sure the ex_data stack is at least |mx| elements long to avoid
314 * issues in the for loop that follows; so go get the |mx|'th element
315 * (if it does not exist CRYPTO_get_ex_data() returns NULL), and assign
316 * to itself. This is normally a no-op; but ensures the stack is the
317 * proper size
318 */
319 if (!CRYPTO_set_ex_data(to, mx - 1, CRYPTO_get_ex_data(to, mx - 1)))
320 goto err;
321
322 for (i = 0; i < mx; i++) {
323 ptr = CRYPTO_get_ex_data(from, i);
324 if (storage[i] != NULL && storage[i]->dup_func != NULL)
325 if (!storage[i]->dup_func(to, from, &ptr, i,
326 storage[i]->argl, storage[i]->argp))
327 goto err;
328 CRYPTO_set_ex_data(to, i, ptr);
329 }
330 toret = 1;
331 err:
332 if (storage != stack)
333 OPENSSL_free(storage);
334 return toret;
335 }
336
337 struct ex_callback_entry {
338 const EX_CALLBACK *excb;
339 int index;
340 };
341
ex_callback_compare(const void * a,const void * b)342 static int ex_callback_compare(const void *a, const void *b)
343 {
344 const struct ex_callback_entry *ap = (const struct ex_callback_entry *)a;
345 const struct ex_callback_entry *bp = (const struct ex_callback_entry *)b;
346
347 if (ap->excb == bp->excb)
348 return 0;
349
350 if (ap->excb == NULL)
351 return 1;
352 if (bp->excb == NULL)
353 return -1;
354 if (ap->excb->priority == bp->excb->priority)
355 return 0;
356 return ap->excb->priority > bp->excb->priority ? -1 : 1;
357 }
358
359 /*
360 * Cleanup a CRYPTO_EX_DATA variable - including calling free() callbacks for
361 * each index in the class used by this variable
362 */
CRYPTO_free_ex_data(int class_index,void * obj,CRYPTO_EX_DATA * ad)363 void CRYPTO_free_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad)
364 {
365 int mx, i;
366 EX_CALLBACKS *ip;
367 void *ptr;
368 const EX_CALLBACK *f;
369 struct ex_callback_entry stack[10];
370 struct ex_callback_entry *storage = NULL;
371 OSSL_EX_DATA_GLOBAL *global = ossl_lib_ctx_get_ex_data_global(ad->ctx);
372
373 if (global == NULL)
374 goto err;
375
376 ip = get_and_lock(global, class_index);
377 if (ip == NULL)
378 goto err;
379
380 mx = sk_EX_CALLBACK_num(ip->meth);
381 if (mx > 0) {
382 if (mx < (int)OSSL_NELEM(stack))
383 storage = stack;
384 else
385 storage = OPENSSL_malloc(sizeof(*storage) * mx);
386 if (storage != NULL)
387 for (i = 0; i < mx; i++) {
388 storage[i].excb = sk_EX_CALLBACK_value(ip->meth, i);
389 storage[i].index = i;
390 }
391 }
392 CRYPTO_THREAD_unlock(global->ex_data_lock);
393
394 if (storage != NULL) {
395 /* Sort according to priority. High priority first */
396 qsort(storage, mx, sizeof(*storage), ex_callback_compare);
397 for (i = 0; i < mx; i++) {
398 f = storage[i].excb;
399
400 if (f != NULL && f->free_func != NULL) {
401 ptr = CRYPTO_get_ex_data(ad, storage[i].index);
402 f->free_func(obj, ptr, ad, storage[i].index, f->argl, f->argp);
403 }
404 }
405 }
406
407 if (storage != stack)
408 OPENSSL_free(storage);
409 err:
410 sk_void_free(ad->sk);
411 ad->sk = NULL;
412 ad->ctx = NULL;
413 }
414
415 /*
416 * Allocate a given CRYPTO_EX_DATA item using the class specific allocation
417 * function
418 */
CRYPTO_alloc_ex_data(int class_index,void * obj,CRYPTO_EX_DATA * ad,int idx)419 int CRYPTO_alloc_ex_data(int class_index, void *obj, CRYPTO_EX_DATA *ad,
420 int idx)
421 {
422 void *curval;
423
424 curval = CRYPTO_get_ex_data(ad, idx);
425 /* Already there, no need to allocate */
426 if (curval != NULL)
427 return 1;
428
429 return ossl_crypto_alloc_ex_data_intern(class_index, obj, ad, idx);
430 }
431
ossl_crypto_alloc_ex_data_intern(int class_index,void * obj,CRYPTO_EX_DATA * ad,int idx)432 int ossl_crypto_alloc_ex_data_intern(int class_index, void *obj,
433 CRYPTO_EX_DATA *ad, int idx)
434 {
435 EX_CALLBACK *f;
436 EX_CALLBACKS *ip;
437 OSSL_EX_DATA_GLOBAL *global;
438
439 global = ossl_lib_ctx_get_ex_data_global(ad->ctx);
440 if (global == NULL)
441 return 0;
442
443 ip = get_and_lock(global, class_index);
444 if (ip == NULL)
445 return 0;
446 f = sk_EX_CALLBACK_value(ip->meth, idx);
447 CRYPTO_THREAD_unlock(global->ex_data_lock);
448
449 /*
450 * This should end up calling CRYPTO_set_ex_data(), which allocates
451 * everything necessary to support placing the new data in the right spot.
452 */
453 if (f->new_func == NULL)
454 return 0;
455
456 f->new_func(obj, NULL, ad, idx, f->argl, f->argp);
457
458 return 1;
459 }
460
461 /*
462 * For a given CRYPTO_EX_DATA variable, set the value corresponding to a
463 * particular index in the class used by this variable
464 */
CRYPTO_set_ex_data(CRYPTO_EX_DATA * ad,int idx,void * val)465 int CRYPTO_set_ex_data(CRYPTO_EX_DATA *ad, int idx, void *val)
466 {
467 int i;
468
469 if (ad->sk == NULL) {
470 if ((ad->sk = sk_void_new_null()) == NULL) {
471 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
472 return 0;
473 }
474 }
475
476 for (i = sk_void_num(ad->sk); i <= idx; ++i) {
477 if (!sk_void_push(ad->sk, NULL)) {
478 ERR_raise(ERR_LIB_CRYPTO, ERR_R_MALLOC_FAILURE);
479 return 0;
480 }
481 }
482 if (sk_void_set(ad->sk, idx, val) != val) {
483 /* Probably the index is out of bounds */
484 ERR_raise(ERR_LIB_CRYPTO, ERR_R_PASSED_INVALID_ARGUMENT);
485 return 0;
486 }
487 return 1;
488 }
489
490 /*
491 * For a given CRYPTO_EX_DATA_ variable, get the value corresponding to a
492 * particular index in the class used by this variable
493 */
CRYPTO_get_ex_data(const CRYPTO_EX_DATA * ad,int idx)494 void *CRYPTO_get_ex_data(const CRYPTO_EX_DATA *ad, int idx)
495 {
496 if (ad->sk == NULL || idx >= sk_void_num(ad->sk))
497 return NULL;
498 return sk_void_value(ad->sk, idx);
499 }
500
ossl_crypto_ex_data_get_ossl_lib_ctx(const CRYPTO_EX_DATA * ad)501 OSSL_LIB_CTX *ossl_crypto_ex_data_get_ossl_lib_ctx(const CRYPTO_EX_DATA *ad)
502 {
503 return ad->ctx;
504 }
505