2
0

encoder_meth.c 20 KB

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