eng_lib.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300
  1. /*
  2. * Copyright 2001-2020 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 "e_os.h"
  10. #include "eng_local.h"
  11. #include <openssl/rand.h>
  12. #include "internal/refcount.h"
  13. CRYPTO_RWLOCK *global_engine_lock;
  14. CRYPTO_ONCE engine_lock_init = CRYPTO_ONCE_STATIC_INIT;
  15. /* The "new"/"free" stuff first */
  16. DEFINE_RUN_ONCE(do_engine_lock_init)
  17. {
  18. if (!OPENSSL_init_crypto(0, NULL))
  19. return 0;
  20. global_engine_lock = CRYPTO_THREAD_lock_new();
  21. return global_engine_lock != NULL;
  22. }
  23. ENGINE *ENGINE_new(void)
  24. {
  25. ENGINE *ret;
  26. if (!RUN_ONCE(&engine_lock_init, do_engine_lock_init)
  27. || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL) {
  28. ENGINEerr(ENGINE_F_ENGINE_NEW, ERR_R_MALLOC_FAILURE);
  29. return NULL;
  30. }
  31. ret->struct_ref = 1;
  32. engine_ref_debug(ret, 0, 1);
  33. if (!CRYPTO_new_ex_data(CRYPTO_EX_INDEX_ENGINE, ret, &ret->ex_data)) {
  34. OPENSSL_free(ret);
  35. return NULL;
  36. }
  37. return ret;
  38. }
  39. /*
  40. * Placed here (close proximity to ENGINE_new) so that modifications to the
  41. * elements of the ENGINE structure are more likely to be caught and changed
  42. * here.
  43. */
  44. void engine_set_all_null(ENGINE *e)
  45. {
  46. e->id = NULL;
  47. e->name = NULL;
  48. e->rsa_meth = NULL;
  49. e->dsa_meth = NULL;
  50. e->dh_meth = NULL;
  51. e->rand_meth = NULL;
  52. e->ciphers = NULL;
  53. e->digests = NULL;
  54. e->destroy = NULL;
  55. e->init = NULL;
  56. e->finish = NULL;
  57. e->ctrl = NULL;
  58. e->load_privkey = NULL;
  59. e->load_pubkey = NULL;
  60. e->cmd_defns = NULL;
  61. e->flags = 0;
  62. }
  63. int engine_free_util(ENGINE *e, int not_locked)
  64. {
  65. int i;
  66. if (e == NULL)
  67. return 1;
  68. if (not_locked)
  69. CRYPTO_DOWN_REF(&e->struct_ref, &i, global_engine_lock);
  70. else
  71. i = --e->struct_ref;
  72. engine_ref_debug(e, 0, -1);
  73. if (i > 0)
  74. return 1;
  75. REF_ASSERT_ISNT(i < 0);
  76. /* Free up any dynamically allocated public key methods */
  77. engine_pkey_meths_free(e);
  78. engine_pkey_asn1_meths_free(e);
  79. /*
  80. * Give the ENGINE a chance to do any structural cleanup corresponding to
  81. * allocation it did in its constructor (eg. unload error strings)
  82. */
  83. if (e->destroy)
  84. e->destroy(e);
  85. CRYPTO_free_ex_data(CRYPTO_EX_INDEX_ENGINE, e, &e->ex_data);
  86. OPENSSL_free(e);
  87. return 1;
  88. }
  89. int ENGINE_free(ENGINE *e)
  90. {
  91. return engine_free_util(e, 1);
  92. }
  93. /* Cleanup stuff */
  94. /*
  95. * engine_cleanup_int() is coded such that anything that does work that will
  96. * need cleanup can register a "cleanup" callback here. That way we don't get
  97. * linker bloat by referring to all *possible* cleanups, but any linker bloat
  98. * into code "X" will cause X's cleanup function to end up here.
  99. */
  100. static STACK_OF(ENGINE_CLEANUP_ITEM) *cleanup_stack = NULL;
  101. static int int_cleanup_check(int create)
  102. {
  103. if (cleanup_stack)
  104. return 1;
  105. if (!create)
  106. return 0;
  107. cleanup_stack = sk_ENGINE_CLEANUP_ITEM_new_null();
  108. return (cleanup_stack ? 1 : 0);
  109. }
  110. static ENGINE_CLEANUP_ITEM *int_cleanup_item(ENGINE_CLEANUP_CB *cb)
  111. {
  112. ENGINE_CLEANUP_ITEM *item;
  113. if ((item = OPENSSL_malloc(sizeof(*item))) == NULL) {
  114. ENGINEerr(ENGINE_F_INT_CLEANUP_ITEM, ERR_R_MALLOC_FAILURE);
  115. return NULL;
  116. }
  117. item->cb = cb;
  118. return item;
  119. }
  120. void engine_cleanup_add_first(ENGINE_CLEANUP_CB *cb)
  121. {
  122. ENGINE_CLEANUP_ITEM *item;
  123. if (!int_cleanup_check(1))
  124. return;
  125. item = int_cleanup_item(cb);
  126. if (item)
  127. sk_ENGINE_CLEANUP_ITEM_insert(cleanup_stack, item, 0);
  128. }
  129. void engine_cleanup_add_last(ENGINE_CLEANUP_CB *cb)
  130. {
  131. ENGINE_CLEANUP_ITEM *item;
  132. if (!int_cleanup_check(1))
  133. return;
  134. item = int_cleanup_item(cb);
  135. if (item != NULL) {
  136. if (sk_ENGINE_CLEANUP_ITEM_push(cleanup_stack, item) <= 0)
  137. OPENSSL_free(item);
  138. }
  139. }
  140. /* The API function that performs all cleanup */
  141. static void engine_cleanup_cb_free(ENGINE_CLEANUP_ITEM *item)
  142. {
  143. (*(item->cb)) ();
  144. OPENSSL_free(item);
  145. }
  146. void engine_cleanup_int(void)
  147. {
  148. if (int_cleanup_check(0)) {
  149. sk_ENGINE_CLEANUP_ITEM_pop_free(cleanup_stack,
  150. engine_cleanup_cb_free);
  151. cleanup_stack = NULL;
  152. }
  153. CRYPTO_THREAD_lock_free(global_engine_lock);
  154. global_engine_lock = NULL;
  155. }
  156. /* Now the "ex_data" support */
  157. int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg)
  158. {
  159. return CRYPTO_set_ex_data(&e->ex_data, idx, arg);
  160. }
  161. void *ENGINE_get_ex_data(const ENGINE *e, int idx)
  162. {
  163. return CRYPTO_get_ex_data(&e->ex_data, idx);
  164. }
  165. /*
  166. * Functions to get/set an ENGINE's elements - mainly to avoid exposing the
  167. * ENGINE structure itself.
  168. */
  169. int ENGINE_set_id(ENGINE *e, const char *id)
  170. {
  171. if (id == NULL) {
  172. ENGINEerr(ENGINE_F_ENGINE_SET_ID, ERR_R_PASSED_NULL_PARAMETER);
  173. return 0;
  174. }
  175. e->id = id;
  176. return 1;
  177. }
  178. int ENGINE_set_name(ENGINE *e, const char *name)
  179. {
  180. if (name == NULL) {
  181. ENGINEerr(ENGINE_F_ENGINE_SET_NAME, ERR_R_PASSED_NULL_PARAMETER);
  182. return 0;
  183. }
  184. e->name = name;
  185. return 1;
  186. }
  187. int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f)
  188. {
  189. e->destroy = destroy_f;
  190. return 1;
  191. }
  192. int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f)
  193. {
  194. e->init = init_f;
  195. return 1;
  196. }
  197. int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f)
  198. {
  199. e->finish = finish_f;
  200. return 1;
  201. }
  202. int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f)
  203. {
  204. e->ctrl = ctrl_f;
  205. return 1;
  206. }
  207. int ENGINE_set_flags(ENGINE *e, int flags)
  208. {
  209. e->flags = flags;
  210. return 1;
  211. }
  212. int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns)
  213. {
  214. e->cmd_defns = defns;
  215. return 1;
  216. }
  217. const char *ENGINE_get_id(const ENGINE *e)
  218. {
  219. return e->id;
  220. }
  221. const char *ENGINE_get_name(const ENGINE *e)
  222. {
  223. return e->name;
  224. }
  225. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e)
  226. {
  227. return e->destroy;
  228. }
  229. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e)
  230. {
  231. return e->init;
  232. }
  233. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e)
  234. {
  235. return e->finish;
  236. }
  237. ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e)
  238. {
  239. return e->ctrl;
  240. }
  241. int ENGINE_get_flags(const ENGINE *e)
  242. {
  243. return e->flags;
  244. }
  245. const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e)
  246. {
  247. return e->cmd_defns;
  248. }
  249. /*
  250. * eng_lib.o is pretty much linked into anything that touches ENGINE already,
  251. * so put the "static_state" hack here.
  252. */
  253. static int internal_static_hack = 0;
  254. void *ENGINE_get_static_state(void)
  255. {
  256. return &internal_static_hack;
  257. }