1 /*
2  * Copyright 2019-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/core.h>
11 #include <openssl/core_dispatch.h>
12 #include <openssl/encoder.h>
13 #include <openssl/ui.h>
14 #include "internal/core.h"
15 #include "internal/namemap.h"
16 #include "internal/property.h"
17 #include "internal/provider.h"
18 #include "crypto/encoder.h"
19 #include "encoder_local.h"
20 #include "crypto/context.h"
21 
22 /*
23  * Encoder can have multiple names, separated with colons in a name string
24  */
25 #define NAME_SEPARATOR ':'
26 
27 /* Simple method structure constructor and destructor */
ossl_encoder_new(void)28 static OSSL_ENCODER *ossl_encoder_new(void)
29 {
30     OSSL_ENCODER *encoder = NULL;
31 
32     if ((encoder = OPENSSL_zalloc(sizeof(*encoder))) == NULL)
33         return NULL;
34     if (!CRYPTO_NEW_REF(&encoder->base.refcnt, 1)) {
35         OSSL_ENCODER_free(encoder);
36         return NULL;
37     }
38 
39     return encoder;
40 }
41 
OSSL_ENCODER_up_ref(OSSL_ENCODER * encoder)42 int OSSL_ENCODER_up_ref(OSSL_ENCODER *encoder)
43 {
44     int ref = 0;
45 
46     CRYPTO_UP_REF(&encoder->base.refcnt, &ref);
47     return 1;
48 }
49 
OSSL_ENCODER_free(OSSL_ENCODER * encoder)50 void OSSL_ENCODER_free(OSSL_ENCODER *encoder)
51 {
52     int ref = 0;
53 
54     if (encoder == NULL)
55         return;
56 
57     CRYPTO_DOWN_REF(&encoder->base.refcnt, &ref);
58     if (ref > 0)
59         return;
60     OPENSSL_free(encoder->base.name);
61     ossl_property_free(encoder->base.parsed_propdef);
62     ossl_provider_free(encoder->base.prov);
63     CRYPTO_FREE_REF(&encoder->base.refcnt);
64     OPENSSL_free(encoder);
65 }
66 
67 /* Data to be passed through ossl_method_construct() */
68 struct encoder_data_st {
69     OSSL_LIB_CTX *libctx;
70     int id;                      /* For get_encoder_from_store() */
71     const char *names;           /* For get_encoder_from_store() */
72     const char *propquery;       /* For get_encoder_from_store() */
73 
74     OSSL_METHOD_STORE *tmp_store; /* For get_tmp_encoder_store() */
75 
76     unsigned int flag_construct_error_occurred : 1;
77 };
78 
79 /*
80  * Generic routines to fetch / create ENCODER methods with
81  * ossl_method_construct()
82  */
83 
84 /* Temporary encoder method store, constructor and destructor */
get_tmp_encoder_store(void * data)85 static void *get_tmp_encoder_store(void *data)
86 {
87     struct encoder_data_st *methdata = data;
88 
89     if (methdata->tmp_store == NULL)
90         methdata->tmp_store = ossl_method_store_new(methdata->libctx);
91     return methdata->tmp_store;
92 }
93 
dealloc_tmp_encoder_store(void * store)94 static void dealloc_tmp_encoder_store(void *store)
95 {
96     if (store != NULL)
97         ossl_method_store_free(store);
98 }
99 
100 /* Get the permanent encoder store */
get_encoder_store(OSSL_LIB_CTX * libctx)101 static OSSL_METHOD_STORE *get_encoder_store(OSSL_LIB_CTX *libctx)
102 {
103     return ossl_lib_ctx_get_data(libctx, OSSL_LIB_CTX_ENCODER_STORE_INDEX);
104 }
105 
reserve_encoder_store(void * store,void * data)106 static int reserve_encoder_store(void *store, void *data)
107 {
108     struct encoder_data_st *methdata = data;
109 
110     if (store == NULL
111         && (store = get_encoder_store(methdata->libctx)) == NULL)
112         return 0;
113 
114     return ossl_method_lock_store(store);
115 }
116 
unreserve_encoder_store(void * store,void * data)117 static int unreserve_encoder_store(void *store, void *data)
118 {
119     struct encoder_data_st *methdata = data;
120 
121     if (store == NULL
122         && (store = get_encoder_store(methdata->libctx)) == NULL)
123         return 0;
124 
125     return ossl_method_unlock_store(store);
126 }
127 
128 /* Get encoder methods from a store, or put one in */
get_encoder_from_store(void * store,const OSSL_PROVIDER ** prov,void * data)129 static void *get_encoder_from_store(void *store, const OSSL_PROVIDER **prov,
130                                     void *data)
131 {
132     struct encoder_data_st *methdata = data;
133     void *method = NULL;
134     int id;
135 
136     /*
137      * get_encoder_from_store() is only called to try and get the method
138      * that OSSL_ENCODER_fetch() is asking for, and the name or name id are
139      * passed via methdata.
140      */
141     if ((id = methdata->id) == 0 && methdata->names != NULL) {
142         OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
143         const char *names = methdata->names;
144         const char *q = strchr(names, NAME_SEPARATOR);
145         size_t l = (q == NULL ? strlen(names) : (size_t)(q - names));
146 
147         if (namemap == 0)
148             return NULL;
149         id = ossl_namemap_name2num_n(namemap, methdata->names, l);
150     }
151 
152     if (id == 0)
153         return NULL;
154 
155     if (store == NULL
156         && (store = get_encoder_store(methdata->libctx)) == NULL)
157         return NULL;
158 
159     if (!ossl_method_store_fetch(store, id, methdata->propquery, prov, &method))
160         return NULL;
161     return method;
162 }
163 
put_encoder_in_store(void * store,void * method,const OSSL_PROVIDER * prov,const char * names,const char * propdef,void * data)164 static int put_encoder_in_store(void *store, void *method,
165                                 const OSSL_PROVIDER *prov,
166                                 const char *names, const char *propdef,
167                                 void *data)
168 {
169     struct encoder_data_st *methdata = data;
170     OSSL_NAMEMAP *namemap;
171     int id;
172     size_t l = 0;
173 
174     /*
175      * put_encoder_in_store() is only called with an OSSL_ENCODER method that
176      * was successfully created by construct_encoder() below, which means that
177      * all the names should already be stored in the namemap with the same
178      * numeric identity, so just use the first to get that identity.
179      */
180     if (names != NULL) {
181         const char *q = strchr(names, NAME_SEPARATOR);
182 
183         l = (q == NULL ? strlen(names) : (size_t)(q - names));
184     }
185 
186     if ((namemap = ossl_namemap_stored(methdata->libctx)) == NULL
187         || (id = ossl_namemap_name2num_n(namemap, names, l)) == 0)
188         return 0;
189 
190     if (store == NULL && (store = get_encoder_store(methdata->libctx)) == NULL)
191         return 0;
192 
193     return ossl_method_store_add(store, prov, id, propdef, method,
194                                  (int (*)(void *))OSSL_ENCODER_up_ref,
195                                  (void (*)(void *))OSSL_ENCODER_free);
196 }
197 
198 /* Create and populate a encoder method */
encoder_from_algorithm(int id,const OSSL_ALGORITHM * algodef,OSSL_PROVIDER * prov)199 static void *encoder_from_algorithm(int id, const OSSL_ALGORITHM *algodef,
200                                     OSSL_PROVIDER *prov)
201 {
202     OSSL_ENCODER *encoder = NULL;
203     const OSSL_DISPATCH *fns = algodef->implementation;
204     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
205 
206     if ((encoder = ossl_encoder_new()) == NULL)
207         return NULL;
208     encoder->base.id = id;
209     if ((encoder->base.name = ossl_algorithm_get1_first_name(algodef)) == NULL) {
210         OSSL_ENCODER_free(encoder);
211         return NULL;
212     }
213     encoder->base.algodef = algodef;
214     if ((encoder->base.parsed_propdef
215          = ossl_parse_property(libctx, algodef->property_definition)) == NULL) {
216         OSSL_ENCODER_free(encoder);
217         return NULL;
218     }
219 
220     for (; fns->function_id != 0; fns++) {
221         switch (fns->function_id) {
222         case OSSL_FUNC_ENCODER_NEWCTX:
223             if (encoder->newctx == NULL)
224                 encoder->newctx =
225                     OSSL_FUNC_encoder_newctx(fns);
226             break;
227         case OSSL_FUNC_ENCODER_FREECTX:
228             if (encoder->freectx == NULL)
229                 encoder->freectx =
230                     OSSL_FUNC_encoder_freectx(fns);
231             break;
232         case OSSL_FUNC_ENCODER_GET_PARAMS:
233             if (encoder->get_params == NULL)
234                 encoder->get_params =
235                     OSSL_FUNC_encoder_get_params(fns);
236             break;
237         case OSSL_FUNC_ENCODER_GETTABLE_PARAMS:
238             if (encoder->gettable_params == NULL)
239                 encoder->gettable_params =
240                     OSSL_FUNC_encoder_gettable_params(fns);
241             break;
242         case OSSL_FUNC_ENCODER_SET_CTX_PARAMS:
243             if (encoder->set_ctx_params == NULL)
244                 encoder->set_ctx_params =
245                     OSSL_FUNC_encoder_set_ctx_params(fns);
246             break;
247         case OSSL_FUNC_ENCODER_SETTABLE_CTX_PARAMS:
248             if (encoder->settable_ctx_params == NULL)
249                 encoder->settable_ctx_params =
250                     OSSL_FUNC_encoder_settable_ctx_params(fns);
251             break;
252         case OSSL_FUNC_ENCODER_DOES_SELECTION:
253             if (encoder->does_selection == NULL)
254                 encoder->does_selection =
255                     OSSL_FUNC_encoder_does_selection(fns);
256             break;
257         case OSSL_FUNC_ENCODER_ENCODE:
258             if (encoder->encode == NULL)
259                 encoder->encode = OSSL_FUNC_encoder_encode(fns);
260             break;
261         case OSSL_FUNC_ENCODER_IMPORT_OBJECT:
262             if (encoder->import_object == NULL)
263                 encoder->import_object =
264                     OSSL_FUNC_encoder_import_object(fns);
265             break;
266         case OSSL_FUNC_ENCODER_FREE_OBJECT:
267             if (encoder->free_object == NULL)
268                 encoder->free_object =
269                     OSSL_FUNC_encoder_free_object(fns);
270             break;
271         }
272     }
273     /*
274      * Try to check that the method is sensible.
275      * If you have a constructor, you must have a destructor and vice versa.
276      * You must have the encoding driver functions.
277      */
278     if (!((encoder->newctx == NULL && encoder->freectx == NULL)
279           || (encoder->newctx != NULL && encoder->freectx != NULL)
280           || (encoder->import_object != NULL && encoder->free_object != NULL)
281           || (encoder->import_object == NULL && encoder->free_object == NULL))
282         || encoder->encode == NULL) {
283         OSSL_ENCODER_free(encoder);
284         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_INVALID_PROVIDER_FUNCTIONS);
285         return NULL;
286     }
287 
288     if (prov != NULL && !ossl_provider_up_ref(prov)) {
289         OSSL_ENCODER_free(encoder);
290         return NULL;
291     }
292 
293     encoder->base.prov = prov;
294     return encoder;
295 }
296 
297 
298 /*
299  * The core fetching functionality passes the names of the implementation.
300  * This function is responsible to getting an identity number for them,
301  * then call encoder_from_algorithm() with that identity number.
302  */
construct_encoder(const OSSL_ALGORITHM * algodef,OSSL_PROVIDER * prov,void * data)303 static void *construct_encoder(const OSSL_ALGORITHM *algodef,
304                                OSSL_PROVIDER *prov, void *data)
305 {
306     /*
307      * This function is only called if get_encoder_from_store() returned
308      * NULL, so it's safe to say that of all the spots to create a new
309      * namemap entry, this is it.  Should the name already exist there, we
310      * know that ossl_namemap_add() will return its corresponding number.
311      */
312     struct encoder_data_st *methdata = data;
313     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
314     OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
315     const char *names = algodef->algorithm_names;
316     int id = ossl_namemap_add_names(namemap, 0, names, NAME_SEPARATOR);
317     void *method = NULL;
318 
319     if (id != 0)
320         method = encoder_from_algorithm(id, algodef, prov);
321 
322     /*
323      * Flag to indicate that there was actual construction errors.  This
324      * helps inner_evp_generic_fetch() determine what error it should
325      * record on inaccessible algorithms.
326      */
327     if (method == NULL)
328         methdata->flag_construct_error_occurred = 1;
329 
330     return method;
331 }
332 
333 /* Intermediary function to avoid ugly casts, used below */
destruct_encoder(void * method,void * data)334 static void destruct_encoder(void *method, void *data)
335 {
336     OSSL_ENCODER_free(method);
337 }
338 
up_ref_encoder(void * method)339 static int up_ref_encoder(void *method)
340 {
341     return OSSL_ENCODER_up_ref(method);
342 }
343 
free_encoder(void * method)344 static void free_encoder(void *method)
345 {
346     OSSL_ENCODER_free(method);
347 }
348 
349 /* Fetching support.  Can fetch by numeric identity or by name */
350 static OSSL_ENCODER *
inner_ossl_encoder_fetch(struct encoder_data_st * methdata,const char * name,const char * properties)351 inner_ossl_encoder_fetch(struct encoder_data_st *methdata,
352                          const char *name, const char *properties)
353 {
354     OSSL_METHOD_STORE *store = get_encoder_store(methdata->libctx);
355     OSSL_NAMEMAP *namemap = ossl_namemap_stored(methdata->libctx);
356     const char *const propq = properties != NULL ? properties : "";
357     void *method = NULL;
358     int unsupported, id;
359 
360     if (store == NULL || namemap == NULL) {
361         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_INVALID_ARGUMENT);
362         return NULL;
363     }
364 
365     id = name != NULL ? ossl_namemap_name2num(namemap, name) : 0;
366 
367     /*
368      * If we haven't found the name yet, chances are that the algorithm to
369      * be fetched is unsupported.
370      */
371     unsupported = id == 0;
372 
373     if (id == 0
374         || !ossl_method_store_cache_get(store, NULL, id, propq, &method)) {
375         OSSL_METHOD_CONSTRUCT_METHOD mcm = {
376             get_tmp_encoder_store,
377             reserve_encoder_store,
378             unreserve_encoder_store,
379             get_encoder_from_store,
380             put_encoder_in_store,
381             construct_encoder,
382             destruct_encoder
383         };
384         OSSL_PROVIDER *prov = NULL;
385 
386         methdata->id = id;
387         methdata->names = name;
388         methdata->propquery = propq;
389         methdata->flag_construct_error_occurred = 0;
390         if ((method = ossl_method_construct(methdata->libctx, OSSL_OP_ENCODER,
391                                             &prov, 0 /* !force_cache */,
392                                             &mcm, methdata)) != NULL) {
393             /*
394              * If construction did create a method for us, we know that
395              * there is a correct name_id and meth_id, since those have
396              * already been calculated in get_encoder_from_store() and
397              * put_encoder_in_store() above.
398              */
399             if (id == 0)
400                 id = ossl_namemap_name2num(namemap, name);
401             ossl_method_store_cache_set(store, prov, id, propq, method,
402                                         up_ref_encoder, free_encoder);
403         }
404 
405         /*
406          * If we never were in the constructor, the algorithm to be fetched
407          * is unsupported.
408          */
409         unsupported = !methdata->flag_construct_error_occurred;
410     }
411 
412     if ((id != 0 || name != NULL) && method == NULL) {
413         int code = unsupported ? ERR_R_UNSUPPORTED : ERR_R_FETCH_FAILED;
414 
415         if (name == NULL)
416             name = ossl_namemap_num2name(namemap, id, 0);
417         ERR_raise_data(ERR_LIB_OSSL_ENCODER, code,
418                        "%s, Name (%s : %d), Properties (%s)",
419                        ossl_lib_ctx_get_descriptor(methdata->libctx),
420                        name == NULL ? "<null>" : name, id,
421                        properties == NULL ? "<null>" : properties);
422     }
423 
424     return method;
425 }
426 
OSSL_ENCODER_fetch(OSSL_LIB_CTX * libctx,const char * name,const char * properties)427 OSSL_ENCODER *OSSL_ENCODER_fetch(OSSL_LIB_CTX *libctx, const char *name,
428                                  const char *properties)
429 {
430     struct encoder_data_st methdata;
431     void *method;
432 
433     methdata.libctx = libctx;
434     methdata.tmp_store = NULL;
435     method = inner_ossl_encoder_fetch(&methdata, name, properties);
436     dealloc_tmp_encoder_store(methdata.tmp_store);
437     return method;
438 }
439 
ossl_encoder_store_cache_flush(OSSL_LIB_CTX * libctx)440 int ossl_encoder_store_cache_flush(OSSL_LIB_CTX *libctx)
441 {
442     OSSL_METHOD_STORE *store = get_encoder_store(libctx);
443 
444     if (store != NULL)
445         return ossl_method_store_cache_flush_all(store);
446     return 1;
447 }
448 
ossl_encoder_store_remove_all_provided(const OSSL_PROVIDER * prov)449 int ossl_encoder_store_remove_all_provided(const OSSL_PROVIDER *prov)
450 {
451     OSSL_LIB_CTX *libctx = ossl_provider_libctx(prov);
452     OSSL_METHOD_STORE *store = get_encoder_store(libctx);
453 
454     if (store != NULL)
455         return ossl_method_store_remove_all_provided(store, prov);
456     return 1;
457 }
458 
459 /*
460  * Library of basic method functions
461  */
462 
OSSL_ENCODER_get0_provider(const OSSL_ENCODER * encoder)463 const OSSL_PROVIDER *OSSL_ENCODER_get0_provider(const OSSL_ENCODER *encoder)
464 {
465     if (!ossl_assert(encoder != NULL)) {
466         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
467         return 0;
468     }
469 
470     return encoder->base.prov;
471 }
472 
OSSL_ENCODER_get0_properties(const OSSL_ENCODER * encoder)473 const char *OSSL_ENCODER_get0_properties(const OSSL_ENCODER *encoder)
474 {
475     if (!ossl_assert(encoder != NULL)) {
476         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
477         return 0;
478     }
479 
480     return encoder->base.algodef->property_definition;
481 }
482 
483 const OSSL_PROPERTY_LIST *
ossl_encoder_parsed_properties(const OSSL_ENCODER * encoder)484 ossl_encoder_parsed_properties(const OSSL_ENCODER *encoder)
485 {
486     if (!ossl_assert(encoder != NULL)) {
487         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
488         return 0;
489     }
490 
491     return encoder->base.parsed_propdef;
492 }
493 
ossl_encoder_get_number(const OSSL_ENCODER * encoder)494 int ossl_encoder_get_number(const OSSL_ENCODER *encoder)
495 {
496     if (!ossl_assert(encoder != NULL)) {
497         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
498         return 0;
499     }
500 
501     return encoder->base.id;
502 }
503 
OSSL_ENCODER_get0_name(const OSSL_ENCODER * encoder)504 const char *OSSL_ENCODER_get0_name(const OSSL_ENCODER *encoder)
505 {
506     return encoder->base.name;
507 }
508 
OSSL_ENCODER_get0_description(const OSSL_ENCODER * encoder)509 const char *OSSL_ENCODER_get0_description(const OSSL_ENCODER *encoder)
510 {
511     return encoder->base.algodef->algorithm_description;
512 }
513 
OSSL_ENCODER_is_a(const OSSL_ENCODER * encoder,const char * name)514 int OSSL_ENCODER_is_a(const OSSL_ENCODER *encoder, const char *name)
515 {
516     if (encoder->base.prov != NULL) {
517         OSSL_LIB_CTX *libctx = ossl_provider_libctx(encoder->base.prov);
518         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
519 
520         return ossl_namemap_name2num(namemap, name) == encoder->base.id;
521     }
522     return 0;
523 }
524 
525 struct do_one_data_st {
526     void (*user_fn)(OSSL_ENCODER *encoder, void *arg);
527     void *user_arg;
528 };
529 
do_one(ossl_unused int id,void * method,void * arg)530 static void do_one(ossl_unused int id, void *method, void *arg)
531 {
532     struct do_one_data_st *data = arg;
533 
534     data->user_fn(method, data->user_arg);
535 }
536 
OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX * libctx,void (* user_fn)(OSSL_ENCODER * encoder,void * arg),void * user_arg)537 void OSSL_ENCODER_do_all_provided(OSSL_LIB_CTX *libctx,
538                                   void (*user_fn)(OSSL_ENCODER *encoder,
539                                                   void *arg),
540                                   void *user_arg)
541 {
542     struct encoder_data_st methdata;
543     struct do_one_data_st data;
544 
545     methdata.libctx = libctx;
546     methdata.tmp_store = NULL;
547     (void)inner_ossl_encoder_fetch(&methdata, NULL, NULL /* properties */);
548 
549     data.user_fn = user_fn;
550     data.user_arg = user_arg;
551     if (methdata.tmp_store != NULL)
552         ossl_method_store_do_all(methdata.tmp_store, &do_one, &data);
553     ossl_method_store_do_all(get_encoder_store(libctx), &do_one, &data);
554     dealloc_tmp_encoder_store(methdata.tmp_store);
555 }
556 
OSSL_ENCODER_names_do_all(const OSSL_ENCODER * encoder,void (* fn)(const char * name,void * data),void * data)557 int OSSL_ENCODER_names_do_all(const OSSL_ENCODER *encoder,
558                               void (*fn)(const char *name, void *data),
559                               void *data)
560 {
561     if (encoder == NULL)
562         return 0;
563 
564     if (encoder->base.prov != NULL) {
565         OSSL_LIB_CTX *libctx = ossl_provider_libctx(encoder->base.prov);
566         OSSL_NAMEMAP *namemap = ossl_namemap_stored(libctx);
567 
568         return ossl_namemap_doall_names(namemap, encoder->base.id, fn, data);
569     }
570 
571     return 1;
572 }
573 
574 const OSSL_PARAM *
OSSL_ENCODER_gettable_params(OSSL_ENCODER * encoder)575 OSSL_ENCODER_gettable_params(OSSL_ENCODER *encoder)
576 {
577     if (encoder != NULL && encoder->gettable_params != NULL) {
578         void *provctx = ossl_provider_ctx(OSSL_ENCODER_get0_provider(encoder));
579 
580         return encoder->gettable_params(provctx);
581     }
582     return NULL;
583 }
584 
OSSL_ENCODER_get_params(OSSL_ENCODER * encoder,OSSL_PARAM params[])585 int OSSL_ENCODER_get_params(OSSL_ENCODER *encoder, OSSL_PARAM params[])
586 {
587     if (encoder != NULL && encoder->get_params != NULL)
588         return encoder->get_params(params);
589     return 0;
590 }
591 
OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER * encoder)592 const OSSL_PARAM *OSSL_ENCODER_settable_ctx_params(OSSL_ENCODER *encoder)
593 {
594     if (encoder != NULL && encoder->settable_ctx_params != NULL) {
595         void *provctx = ossl_provider_ctx(OSSL_ENCODER_get0_provider(encoder));
596 
597         return encoder->settable_ctx_params(provctx);
598     }
599     return NULL;
600 }
601 
602 /*
603  * Encoder context support
604  */
605 
OSSL_ENCODER_CTX_new(void)606 OSSL_ENCODER_CTX *OSSL_ENCODER_CTX_new(void)
607 {
608     OSSL_ENCODER_CTX *ctx;
609 
610     ctx = OPENSSL_zalloc(sizeof(*ctx));
611     return ctx;
612 }
613 
OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX * ctx,const OSSL_PARAM params[])614 int OSSL_ENCODER_CTX_set_params(OSSL_ENCODER_CTX *ctx,
615                                 const OSSL_PARAM params[])
616 {
617     int ok = 1;
618     size_t i;
619     size_t l;
620 
621     if (!ossl_assert(ctx != NULL)) {
622         ERR_raise(ERR_LIB_OSSL_ENCODER, ERR_R_PASSED_NULL_PARAMETER);
623         return 0;
624     }
625 
626     if (ctx->encoder_insts == NULL)
627         return 1;
628 
629     l = OSSL_ENCODER_CTX_get_num_encoders(ctx);
630     for (i = 0; i < l; i++) {
631         OSSL_ENCODER_INSTANCE *encoder_inst =
632             sk_OSSL_ENCODER_INSTANCE_value(ctx->encoder_insts, i);
633         OSSL_ENCODER *encoder = OSSL_ENCODER_INSTANCE_get_encoder(encoder_inst);
634         void *encoderctx = OSSL_ENCODER_INSTANCE_get_encoder_ctx(encoder_inst);
635 
636         if (encoderctx == NULL || encoder->set_ctx_params == NULL)
637             continue;
638         if (!encoder->set_ctx_params(encoderctx, params))
639             ok = 0;
640     }
641     return ok;
642 }
643 
OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX * ctx)644 void OSSL_ENCODER_CTX_free(OSSL_ENCODER_CTX *ctx)
645 {
646     if (ctx != NULL) {
647         sk_OSSL_ENCODER_INSTANCE_pop_free(ctx->encoder_insts,
648                                           ossl_encoder_instance_free);
649         OPENSSL_free(ctx->construct_data);
650         ossl_pw_clear_passphrase_data(&ctx->pwdata);
651         OPENSSL_free(ctx);
652     }
653 }
654