eng_lib.c 6.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299
  1. /*
  2. * Copyright 2001-2018 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. }
  155. /* Now the "ex_data" support */
  156. int ENGINE_set_ex_data(ENGINE *e, int idx, void *arg)
  157. {
  158. return CRYPTO_set_ex_data(&e->ex_data, idx, arg);
  159. }
  160. void *ENGINE_get_ex_data(const ENGINE *e, int idx)
  161. {
  162. return CRYPTO_get_ex_data(&e->ex_data, idx);
  163. }
  164. /*
  165. * Functions to get/set an ENGINE's elements - mainly to avoid exposing the
  166. * ENGINE structure itself.
  167. */
  168. int ENGINE_set_id(ENGINE *e, const char *id)
  169. {
  170. if (id == NULL) {
  171. ENGINEerr(ENGINE_F_ENGINE_SET_ID, ERR_R_PASSED_NULL_PARAMETER);
  172. return 0;
  173. }
  174. e->id = id;
  175. return 1;
  176. }
  177. int ENGINE_set_name(ENGINE *e, const char *name)
  178. {
  179. if (name == NULL) {
  180. ENGINEerr(ENGINE_F_ENGINE_SET_NAME, ERR_R_PASSED_NULL_PARAMETER);
  181. return 0;
  182. }
  183. e->name = name;
  184. return 1;
  185. }
  186. int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f)
  187. {
  188. e->destroy = destroy_f;
  189. return 1;
  190. }
  191. int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f)
  192. {
  193. e->init = init_f;
  194. return 1;
  195. }
  196. int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f)
  197. {
  198. e->finish = finish_f;
  199. return 1;
  200. }
  201. int ENGINE_set_ctrl_function(ENGINE *e, ENGINE_CTRL_FUNC_PTR ctrl_f)
  202. {
  203. e->ctrl = ctrl_f;
  204. return 1;
  205. }
  206. int ENGINE_set_flags(ENGINE *e, int flags)
  207. {
  208. e->flags = flags;
  209. return 1;
  210. }
  211. int ENGINE_set_cmd_defns(ENGINE *e, const ENGINE_CMD_DEFN *defns)
  212. {
  213. e->cmd_defns = defns;
  214. return 1;
  215. }
  216. const char *ENGINE_get_id(const ENGINE *e)
  217. {
  218. return e->id;
  219. }
  220. const char *ENGINE_get_name(const ENGINE *e)
  221. {
  222. return e->name;
  223. }
  224. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e)
  225. {
  226. return e->destroy;
  227. }
  228. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e)
  229. {
  230. return e->init;
  231. }
  232. ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e)
  233. {
  234. return e->finish;
  235. }
  236. ENGINE_CTRL_FUNC_PTR ENGINE_get_ctrl_function(const ENGINE *e)
  237. {
  238. return e->ctrl;
  239. }
  240. int ENGINE_get_flags(const ENGINE *e)
  241. {
  242. return e->flags;
  243. }
  244. const ENGINE_CMD_DEFN *ENGINE_get_cmd_defns(const ENGINE *e)
  245. {
  246. return e->cmd_defns;
  247. }
  248. /*
  249. * eng_lib.o is pretty much linked into anything that touches ENGINE already,
  250. * so put the "static_state" hack here.
  251. */
  252. static int internal_static_hack = 0;
  253. void *ENGINE_get_static_state(void)
  254. {
  255. return &internal_static_hack;
  256. }