api.c 9.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438
  1. /*
  2. * Scatterlist Cryptographic API.
  3. *
  4. * Copyright (c) 2002 James Morris <jmorris@intercode.com.au>
  5. * Copyright (c) 2002 David S. Miller (davem@redhat.com)
  6. * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
  7. *
  8. * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
  9. * and Nettle, by Niels Möller.
  10. *
  11. * This program is free software; you can redistribute it and/or modify it
  12. * under the terms of the GNU General Public License as published by the Free
  13. * Software Foundation; either version 2 of the License, or (at your option)
  14. * any later version.
  15. *
  16. */
  17. #include <linux/err.h>
  18. #include <linux/errno.h>
  19. #include <linux/kernel.h>
  20. #include <linux/kmod.h>
  21. #include <linux/module.h>
  22. #include <linux/param.h>
  23. #include <linux/sched.h>
  24. #include <linux/slab.h>
  25. #include <linux/string.h>
  26. #include "internal.h"
  27. LIST_HEAD(crypto_alg_list);
  28. EXPORT_SYMBOL_GPL(crypto_alg_list);
  29. DECLARE_RWSEM(crypto_alg_sem);
  30. EXPORT_SYMBOL_GPL(crypto_alg_sem);
  31. BLOCKING_NOTIFIER_HEAD(crypto_chain);
  32. EXPORT_SYMBOL_GPL(crypto_chain);
  33. static inline struct crypto_alg *crypto_alg_get(struct crypto_alg *alg)
  34. {
  35. atomic_inc(&alg->cra_refcnt);
  36. return alg;
  37. }
  38. struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
  39. {
  40. return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
  41. }
  42. EXPORT_SYMBOL_GPL(crypto_mod_get);
  43. void crypto_mod_put(struct crypto_alg *alg)
  44. {
  45. struct module *module = alg->cra_module;
  46. crypto_alg_put(alg);
  47. module_put(module);
  48. }
  49. EXPORT_SYMBOL_GPL(crypto_mod_put);
  50. struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type, u32 mask)
  51. {
  52. struct crypto_alg *q, *alg = NULL;
  53. int best = -2;
  54. list_for_each_entry(q, &crypto_alg_list, cra_list) {
  55. int exact, fuzzy;
  56. if (crypto_is_moribund(q))
  57. continue;
  58. if ((q->cra_flags ^ type) & mask)
  59. continue;
  60. if (crypto_is_larval(q) &&
  61. ((struct crypto_larval *)q)->mask != mask)
  62. continue;
  63. exact = !strcmp(q->cra_driver_name, name);
  64. fuzzy = !strcmp(q->cra_name, name);
  65. if (!exact && !(fuzzy && q->cra_priority > best))
  66. continue;
  67. if (unlikely(!crypto_mod_get(q)))
  68. continue;
  69. best = q->cra_priority;
  70. if (alg)
  71. crypto_mod_put(alg);
  72. alg = q;
  73. if (exact)
  74. break;
  75. }
  76. return alg;
  77. }
  78. EXPORT_SYMBOL_GPL(__crypto_alg_lookup);
  79. static void crypto_larval_destroy(struct crypto_alg *alg)
  80. {
  81. struct crypto_larval *larval = (void *)alg;
  82. BUG_ON(!crypto_is_larval(alg));
  83. if (larval->adult)
  84. crypto_mod_put(larval->adult);
  85. kfree(larval);
  86. }
  87. static struct crypto_alg *crypto_larval_alloc(const char *name, u32 type,
  88. u32 mask)
  89. {
  90. struct crypto_alg *alg;
  91. struct crypto_larval *larval;
  92. larval = kzalloc(sizeof(*larval), GFP_KERNEL);
  93. if (!larval)
  94. return ERR_PTR(-ENOMEM);
  95. larval->mask = mask;
  96. larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
  97. larval->alg.cra_priority = -1;
  98. larval->alg.cra_destroy = crypto_larval_destroy;
  99. atomic_set(&larval->alg.cra_refcnt, 2);
  100. strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
  101. init_completion(&larval->completion);
  102. down_write(&crypto_alg_sem);
  103. alg = __crypto_alg_lookup(name, type, mask);
  104. if (!alg) {
  105. alg = &larval->alg;
  106. list_add(&alg->cra_list, &crypto_alg_list);
  107. }
  108. up_write(&crypto_alg_sem);
  109. if (alg != &larval->alg)
  110. kfree(larval);
  111. return alg;
  112. }
  113. static void crypto_larval_kill(struct crypto_alg *alg)
  114. {
  115. struct crypto_larval *larval = (void *)alg;
  116. down_write(&crypto_alg_sem);
  117. list_del(&alg->cra_list);
  118. up_write(&crypto_alg_sem);
  119. complete(&larval->completion);
  120. crypto_alg_put(alg);
  121. }
  122. static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
  123. {
  124. struct crypto_larval *larval = (void *)alg;
  125. wait_for_completion_interruptible_timeout(&larval->completion, 60 * HZ);
  126. alg = larval->adult;
  127. if (alg) {
  128. if (!crypto_mod_get(alg))
  129. alg = ERR_PTR(-EAGAIN);
  130. } else
  131. alg = ERR_PTR(-ENOENT);
  132. crypto_mod_put(&larval->alg);
  133. return alg;
  134. }
  135. static struct crypto_alg *crypto_alg_lookup(const char *name, u32 type,
  136. u32 mask)
  137. {
  138. struct crypto_alg *alg;
  139. down_read(&crypto_alg_sem);
  140. alg = __crypto_alg_lookup(name, type, mask);
  141. up_read(&crypto_alg_sem);
  142. return alg;
  143. }
  144. struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
  145. {
  146. struct crypto_alg *alg;
  147. struct crypto_alg *larval;
  148. int ok;
  149. if (!name)
  150. return ERR_PTR(-ENOENT);
  151. mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
  152. type &= mask;
  153. alg = try_then_request_module(crypto_alg_lookup(name, type, mask),
  154. name);
  155. if (alg)
  156. return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
  157. larval = crypto_larval_alloc(name, type, mask);
  158. if (IS_ERR(larval) || !crypto_is_larval(larval))
  159. return larval;
  160. ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
  161. if (ok == NOTIFY_DONE) {
  162. request_module("cryptomgr");
  163. ok = crypto_notify(CRYPTO_MSG_ALG_REQUEST, larval);
  164. }
  165. if (ok == NOTIFY_STOP)
  166. alg = crypto_larval_wait(larval);
  167. else {
  168. crypto_mod_put(larval);
  169. alg = ERR_PTR(-ENOENT);
  170. }
  171. crypto_larval_kill(larval);
  172. return alg;
  173. }
  174. EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
  175. static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
  176. {
  177. const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
  178. if (type_obj)
  179. return type_obj->init(tfm, type, mask);
  180. switch (crypto_tfm_alg_type(tfm)) {
  181. case CRYPTO_ALG_TYPE_CIPHER:
  182. return crypto_init_cipher_ops(tfm);
  183. case CRYPTO_ALG_TYPE_DIGEST:
  184. return crypto_init_digest_ops(tfm);
  185. case CRYPTO_ALG_TYPE_COMPRESS:
  186. return crypto_init_compress_ops(tfm);
  187. default:
  188. break;
  189. }
  190. BUG();
  191. return -EINVAL;
  192. }
  193. static void crypto_exit_ops(struct crypto_tfm *tfm)
  194. {
  195. const struct crypto_type *type = tfm->__crt_alg->cra_type;
  196. if (type) {
  197. if (type->exit)
  198. type->exit(tfm);
  199. return;
  200. }
  201. switch (crypto_tfm_alg_type(tfm)) {
  202. case CRYPTO_ALG_TYPE_CIPHER:
  203. crypto_exit_cipher_ops(tfm);
  204. break;
  205. case CRYPTO_ALG_TYPE_DIGEST:
  206. crypto_exit_digest_ops(tfm);
  207. break;
  208. case CRYPTO_ALG_TYPE_COMPRESS:
  209. crypto_exit_compress_ops(tfm);
  210. break;
  211. default:
  212. BUG();
  213. }
  214. }
  215. static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
  216. {
  217. const struct crypto_type *type_obj = alg->cra_type;
  218. unsigned int len;
  219. len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
  220. if (type_obj)
  221. return len + type_obj->ctxsize(alg, type, mask);
  222. switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
  223. default:
  224. BUG();
  225. case CRYPTO_ALG_TYPE_CIPHER:
  226. len += crypto_cipher_ctxsize(alg);
  227. break;
  228. case CRYPTO_ALG_TYPE_DIGEST:
  229. len += crypto_digest_ctxsize(alg);
  230. break;
  231. case CRYPTO_ALG_TYPE_COMPRESS:
  232. len += crypto_compress_ctxsize(alg);
  233. break;
  234. }
  235. return len;
  236. }
  237. void crypto_shoot_alg(struct crypto_alg *alg)
  238. {
  239. down_write(&crypto_alg_sem);
  240. alg->cra_flags |= CRYPTO_ALG_DYING;
  241. up_write(&crypto_alg_sem);
  242. }
  243. EXPORT_SYMBOL_GPL(crypto_shoot_alg);
  244. struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
  245. u32 mask)
  246. {
  247. struct crypto_tfm *tfm = NULL;
  248. unsigned int tfm_size;
  249. int err = -ENOMEM;
  250. tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
  251. tfm = kzalloc(tfm_size, GFP_KERNEL);
  252. if (tfm == NULL)
  253. goto out_err;
  254. tfm->__crt_alg = alg;
  255. err = crypto_init_ops(tfm, type, mask);
  256. if (err)
  257. goto out_free_tfm;
  258. if (alg->cra_init && (err = alg->cra_init(tfm))) {
  259. if (err == -EAGAIN)
  260. crypto_shoot_alg(alg);
  261. goto cra_init_failed;
  262. }
  263. goto out;
  264. cra_init_failed:
  265. crypto_exit_ops(tfm);
  266. out_free_tfm:
  267. kfree(tfm);
  268. out_err:
  269. tfm = ERR_PTR(err);
  270. out:
  271. return tfm;
  272. }
  273. EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
  274. /*
  275. * crypto_alloc_base - Locate algorithm and allocate transform
  276. * @alg_name: Name of algorithm
  277. * @type: Type of algorithm
  278. * @mask: Mask for type comparison
  279. *
  280. * crypto_alloc_base() will first attempt to locate an already loaded
  281. * algorithm. If that fails and the kernel supports dynamically loadable
  282. * modules, it will then attempt to load a module of the same name or
  283. * alias. If that fails it will send a query to any loaded crypto manager
  284. * to construct an algorithm on the fly. A refcount is grabbed on the
  285. * algorithm which is then associated with the new transform.
  286. *
  287. * The returned transform is of a non-determinate type. Most people
  288. * should use one of the more specific allocation functions such as
  289. * crypto_alloc_blkcipher.
  290. *
  291. * In case of error the return value is an error pointer.
  292. */
  293. struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
  294. {
  295. struct crypto_tfm *tfm;
  296. int err;
  297. for (;;) {
  298. struct crypto_alg *alg;
  299. alg = crypto_alg_mod_lookup(alg_name, type, mask);
  300. if (IS_ERR(alg)) {
  301. err = PTR_ERR(alg);
  302. goto err;
  303. }
  304. tfm = __crypto_alloc_tfm(alg, type, mask);
  305. if (!IS_ERR(tfm))
  306. return tfm;
  307. crypto_mod_put(alg);
  308. err = PTR_ERR(tfm);
  309. err:
  310. if (err != -EAGAIN)
  311. break;
  312. if (signal_pending(current)) {
  313. err = -EINTR;
  314. break;
  315. }
  316. }
  317. return ERR_PTR(err);
  318. }
  319. EXPORT_SYMBOL_GPL(crypto_alloc_base);
  320. /*
  321. * crypto_free_tfm - Free crypto transform
  322. * @tfm: Transform to free
  323. *
  324. * crypto_free_tfm() frees up the transform and any associated resources,
  325. * then drops the refcount on the associated algorithm.
  326. */
  327. void crypto_free_tfm(struct crypto_tfm *tfm)
  328. {
  329. struct crypto_alg *alg;
  330. int size;
  331. if (unlikely(!tfm))
  332. return;
  333. alg = tfm->__crt_alg;
  334. size = sizeof(*tfm) + alg->cra_ctxsize;
  335. if (alg->cra_exit)
  336. alg->cra_exit(tfm);
  337. crypto_exit_ops(tfm);
  338. crypto_mod_put(alg);
  339. memset(tfm, 0, size);
  340. kfree(tfm);
  341. }
  342. EXPORT_SYMBOL_GPL(crypto_free_tfm);
  343. int crypto_has_alg(const char *name, u32 type, u32 mask)
  344. {
  345. int ret = 0;
  346. struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
  347. if (!IS_ERR(alg)) {
  348. crypto_mod_put(alg);
  349. ret = 1;
  350. }
  351. return ret;
  352. }
  353. EXPORT_SYMBOL_GPL(crypto_has_alg);