api.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605
  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 struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg);
  34. struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
  35. {
  36. return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
  37. }
  38. EXPORT_SYMBOL_GPL(crypto_mod_get);
  39. void crypto_mod_put(struct crypto_alg *alg)
  40. {
  41. struct module *module = alg->cra_module;
  42. crypto_alg_put(alg);
  43. module_put(module);
  44. }
  45. EXPORT_SYMBOL_GPL(crypto_mod_put);
  46. static inline int crypto_is_test_larval(struct crypto_larval *larval)
  47. {
  48. return larval->alg.cra_driver_name[0];
  49. }
  50. static struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type,
  51. u32 mask)
  52. {
  53. struct crypto_alg *q, *alg = NULL;
  54. int best = -2;
  55. list_for_each_entry(q, &crypto_alg_list, cra_list) {
  56. int exact, fuzzy;
  57. if (crypto_is_moribund(q))
  58. continue;
  59. if ((q->cra_flags ^ type) & mask)
  60. continue;
  61. if (crypto_is_larval(q) &&
  62. !crypto_is_test_larval((struct crypto_larval *)q) &&
  63. ((struct crypto_larval *)q)->mask != mask)
  64. continue;
  65. exact = !strcmp(q->cra_driver_name, name);
  66. fuzzy = !strcmp(q->cra_name, name);
  67. if (!exact && !(fuzzy && q->cra_priority > best))
  68. continue;
  69. if (unlikely(!crypto_mod_get(q)))
  70. continue;
  71. best = q->cra_priority;
  72. if (alg)
  73. crypto_mod_put(alg);
  74. alg = q;
  75. if (exact)
  76. break;
  77. }
  78. return alg;
  79. }
  80. static void crypto_larval_destroy(struct crypto_alg *alg)
  81. {
  82. struct crypto_larval *larval = (void *)alg;
  83. BUG_ON(!crypto_is_larval(alg));
  84. if (larval->adult)
  85. crypto_mod_put(larval->adult);
  86. kfree(larval);
  87. }
  88. struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask)
  89. {
  90. struct crypto_larval *larval;
  91. larval = kzalloc(sizeof(*larval), GFP_KERNEL);
  92. if (!larval)
  93. return ERR_PTR(-ENOMEM);
  94. larval->mask = mask;
  95. larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
  96. larval->alg.cra_priority = -1;
  97. larval->alg.cra_destroy = crypto_larval_destroy;
  98. strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
  99. init_completion(&larval->completion);
  100. return larval;
  101. }
  102. EXPORT_SYMBOL_GPL(crypto_larval_alloc);
  103. static struct crypto_alg *crypto_larval_add(const char *name, u32 type,
  104. u32 mask)
  105. {
  106. struct crypto_alg *alg;
  107. struct crypto_larval *larval;
  108. larval = crypto_larval_alloc(name, type, mask);
  109. if (IS_ERR(larval))
  110. return ERR_CAST(larval);
  111. atomic_set(&larval->alg.cra_refcnt, 2);
  112. down_write(&crypto_alg_sem);
  113. alg = __crypto_alg_lookup(name, type, mask);
  114. if (!alg) {
  115. alg = &larval->alg;
  116. list_add(&alg->cra_list, &crypto_alg_list);
  117. }
  118. up_write(&crypto_alg_sem);
  119. if (alg != &larval->alg) {
  120. kfree(larval);
  121. if (crypto_is_larval(alg))
  122. alg = crypto_larval_wait(alg);
  123. }
  124. return alg;
  125. }
  126. void crypto_larval_kill(struct crypto_alg *alg)
  127. {
  128. struct crypto_larval *larval = (void *)alg;
  129. down_write(&crypto_alg_sem);
  130. list_del(&alg->cra_list);
  131. up_write(&crypto_alg_sem);
  132. complete_all(&larval->completion);
  133. crypto_alg_put(alg);
  134. }
  135. EXPORT_SYMBOL_GPL(crypto_larval_kill);
  136. static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
  137. {
  138. struct crypto_larval *larval = (void *)alg;
  139. long timeout;
  140. timeout = wait_for_completion_interruptible_timeout(
  141. &larval->completion, 60 * HZ);
  142. alg = larval->adult;
  143. if (timeout < 0)
  144. alg = ERR_PTR(-EINTR);
  145. else if (!timeout)
  146. alg = ERR_PTR(-ETIMEDOUT);
  147. else if (!alg)
  148. alg = ERR_PTR(-ENOENT);
  149. else if (crypto_is_test_larval(larval) &&
  150. !(alg->cra_flags & CRYPTO_ALG_TESTED))
  151. alg = ERR_PTR(-EAGAIN);
  152. else if (!crypto_mod_get(alg))
  153. alg = ERR_PTR(-EAGAIN);
  154. crypto_mod_put(&larval->alg);
  155. return alg;
  156. }
  157. struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, u32 mask)
  158. {
  159. struct crypto_alg *alg;
  160. down_read(&crypto_alg_sem);
  161. alg = __crypto_alg_lookup(name, type, mask);
  162. up_read(&crypto_alg_sem);
  163. return alg;
  164. }
  165. EXPORT_SYMBOL_GPL(crypto_alg_lookup);
  166. struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask)
  167. {
  168. struct crypto_alg *alg;
  169. if (!name)
  170. return ERR_PTR(-ENOENT);
  171. mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
  172. type &= mask;
  173. alg = crypto_alg_lookup(name, type, mask);
  174. if (!alg) {
  175. request_module("%s", name);
  176. if (!((type ^ CRYPTO_ALG_NEED_FALLBACK) & mask &
  177. CRYPTO_ALG_NEED_FALLBACK))
  178. request_module("%s-all", name);
  179. alg = crypto_alg_lookup(name, type, mask);
  180. }
  181. if (alg)
  182. return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
  183. return crypto_larval_add(name, type, mask);
  184. }
  185. EXPORT_SYMBOL_GPL(crypto_larval_lookup);
  186. int crypto_probing_notify(unsigned long val, void *v)
  187. {
  188. int ok;
  189. ok = blocking_notifier_call_chain(&crypto_chain, val, v);
  190. if (ok == NOTIFY_DONE) {
  191. request_module("cryptomgr");
  192. ok = blocking_notifier_call_chain(&crypto_chain, val, v);
  193. }
  194. return ok;
  195. }
  196. EXPORT_SYMBOL_GPL(crypto_probing_notify);
  197. struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
  198. {
  199. struct crypto_alg *alg;
  200. struct crypto_alg *larval;
  201. int ok;
  202. if (!((type | mask) & CRYPTO_ALG_TESTED)) {
  203. type |= CRYPTO_ALG_TESTED;
  204. mask |= CRYPTO_ALG_TESTED;
  205. }
  206. larval = crypto_larval_lookup(name, type, mask);
  207. if (IS_ERR(larval) || !crypto_is_larval(larval))
  208. return larval;
  209. ok = crypto_probing_notify(CRYPTO_MSG_ALG_REQUEST, larval);
  210. if (ok == NOTIFY_STOP)
  211. alg = crypto_larval_wait(larval);
  212. else {
  213. crypto_mod_put(larval);
  214. alg = ERR_PTR(-ENOENT);
  215. }
  216. crypto_larval_kill(larval);
  217. return alg;
  218. }
  219. EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
  220. static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
  221. {
  222. const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
  223. if (type_obj)
  224. return type_obj->init(tfm, type, mask);
  225. switch (crypto_tfm_alg_type(tfm)) {
  226. case CRYPTO_ALG_TYPE_CIPHER:
  227. return crypto_init_cipher_ops(tfm);
  228. case CRYPTO_ALG_TYPE_COMPRESS:
  229. return crypto_init_compress_ops(tfm);
  230. default:
  231. break;
  232. }
  233. BUG();
  234. return -EINVAL;
  235. }
  236. static void crypto_exit_ops(struct crypto_tfm *tfm)
  237. {
  238. const struct crypto_type *type = tfm->__crt_alg->cra_type;
  239. if (type) {
  240. if (tfm->exit)
  241. tfm->exit(tfm);
  242. return;
  243. }
  244. switch (crypto_tfm_alg_type(tfm)) {
  245. case CRYPTO_ALG_TYPE_CIPHER:
  246. crypto_exit_cipher_ops(tfm);
  247. break;
  248. case CRYPTO_ALG_TYPE_COMPRESS:
  249. crypto_exit_compress_ops(tfm);
  250. break;
  251. default:
  252. BUG();
  253. }
  254. }
  255. static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
  256. {
  257. const struct crypto_type *type_obj = alg->cra_type;
  258. unsigned int len;
  259. len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
  260. if (type_obj)
  261. return len + type_obj->ctxsize(alg, type, mask);
  262. switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
  263. default:
  264. BUG();
  265. case CRYPTO_ALG_TYPE_CIPHER:
  266. len += crypto_cipher_ctxsize(alg);
  267. break;
  268. case CRYPTO_ALG_TYPE_COMPRESS:
  269. len += crypto_compress_ctxsize(alg);
  270. break;
  271. }
  272. return len;
  273. }
  274. void crypto_shoot_alg(struct crypto_alg *alg)
  275. {
  276. down_write(&crypto_alg_sem);
  277. alg->cra_flags |= CRYPTO_ALG_DYING;
  278. up_write(&crypto_alg_sem);
  279. }
  280. EXPORT_SYMBOL_GPL(crypto_shoot_alg);
  281. struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
  282. u32 mask)
  283. {
  284. struct crypto_tfm *tfm = NULL;
  285. unsigned int tfm_size;
  286. int err = -ENOMEM;
  287. tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
  288. tfm = kzalloc(tfm_size, GFP_KERNEL);
  289. if (tfm == NULL)
  290. goto out_err;
  291. tfm->__crt_alg = alg;
  292. err = crypto_init_ops(tfm, type, mask);
  293. if (err)
  294. goto out_free_tfm;
  295. if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
  296. goto cra_init_failed;
  297. goto out;
  298. cra_init_failed:
  299. crypto_exit_ops(tfm);
  300. out_free_tfm:
  301. if (err == -EAGAIN)
  302. crypto_shoot_alg(alg);
  303. kfree(tfm);
  304. out_err:
  305. tfm = ERR_PTR(err);
  306. out:
  307. return tfm;
  308. }
  309. EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
  310. /*
  311. * crypto_alloc_base - Locate algorithm and allocate transform
  312. * @alg_name: Name of algorithm
  313. * @type: Type of algorithm
  314. * @mask: Mask for type comparison
  315. *
  316. * This function should not be used by new algorithm types.
  317. * Please use crypto_alloc_tfm instead.
  318. *
  319. * crypto_alloc_base() will first attempt to locate an already loaded
  320. * algorithm. If that fails and the kernel supports dynamically loadable
  321. * modules, it will then attempt to load a module of the same name or
  322. * alias. If that fails it will send a query to any loaded crypto manager
  323. * to construct an algorithm on the fly. A refcount is grabbed on the
  324. * algorithm which is then associated with the new transform.
  325. *
  326. * The returned transform is of a non-determinate type. Most people
  327. * should use one of the more specific allocation functions such as
  328. * crypto_alloc_blkcipher.
  329. *
  330. * In case of error the return value is an error pointer.
  331. */
  332. struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
  333. {
  334. struct crypto_tfm *tfm;
  335. int err;
  336. for (;;) {
  337. struct crypto_alg *alg;
  338. alg = crypto_alg_mod_lookup(alg_name, type, mask);
  339. if (IS_ERR(alg)) {
  340. err = PTR_ERR(alg);
  341. goto err;
  342. }
  343. tfm = __crypto_alloc_tfm(alg, type, mask);
  344. if (!IS_ERR(tfm))
  345. return tfm;
  346. crypto_mod_put(alg);
  347. err = PTR_ERR(tfm);
  348. err:
  349. if (err != -EAGAIN)
  350. break;
  351. if (signal_pending(current)) {
  352. err = -EINTR;
  353. break;
  354. }
  355. }
  356. return ERR_PTR(err);
  357. }
  358. EXPORT_SYMBOL_GPL(crypto_alloc_base);
  359. void *crypto_create_tfm(struct crypto_alg *alg,
  360. const struct crypto_type *frontend)
  361. {
  362. char *mem;
  363. struct crypto_tfm *tfm = NULL;
  364. unsigned int tfmsize;
  365. unsigned int total;
  366. int err = -ENOMEM;
  367. tfmsize = frontend->tfmsize;
  368. total = tfmsize + sizeof(*tfm) + frontend->extsize(alg);
  369. mem = kzalloc(total, GFP_KERNEL);
  370. if (mem == NULL)
  371. goto out_err;
  372. tfm = (struct crypto_tfm *)(mem + tfmsize);
  373. tfm->__crt_alg = alg;
  374. err = frontend->init_tfm(tfm);
  375. if (err)
  376. goto out_free_tfm;
  377. if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
  378. goto cra_init_failed;
  379. goto out;
  380. cra_init_failed:
  381. crypto_exit_ops(tfm);
  382. out_free_tfm:
  383. if (err == -EAGAIN)
  384. crypto_shoot_alg(alg);
  385. kfree(mem);
  386. out_err:
  387. mem = ERR_PTR(err);
  388. out:
  389. return mem;
  390. }
  391. EXPORT_SYMBOL_GPL(crypto_create_tfm);
  392. struct crypto_alg *crypto_find_alg(const char *alg_name,
  393. const struct crypto_type *frontend,
  394. u32 type, u32 mask)
  395. {
  396. struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask) =
  397. crypto_alg_mod_lookup;
  398. if (frontend) {
  399. type &= frontend->maskclear;
  400. mask &= frontend->maskclear;
  401. type |= frontend->type;
  402. mask |= frontend->maskset;
  403. if (frontend->lookup)
  404. lookup = frontend->lookup;
  405. }
  406. return lookup(alg_name, type, mask);
  407. }
  408. EXPORT_SYMBOL_GPL(crypto_find_alg);
  409. /*
  410. * crypto_alloc_tfm - Locate algorithm and allocate transform
  411. * @alg_name: Name of algorithm
  412. * @frontend: Frontend algorithm type
  413. * @type: Type of algorithm
  414. * @mask: Mask for type comparison
  415. *
  416. * crypto_alloc_tfm() will first attempt to locate an already loaded
  417. * algorithm. If that fails and the kernel supports dynamically loadable
  418. * modules, it will then attempt to load a module of the same name or
  419. * alias. If that fails it will send a query to any loaded crypto manager
  420. * to construct an algorithm on the fly. A refcount is grabbed on the
  421. * algorithm which is then associated with the new transform.
  422. *
  423. * The returned transform is of a non-determinate type. Most people
  424. * should use one of the more specific allocation functions such as
  425. * crypto_alloc_blkcipher.
  426. *
  427. * In case of error the return value is an error pointer.
  428. */
  429. void *crypto_alloc_tfm(const char *alg_name,
  430. const struct crypto_type *frontend, u32 type, u32 mask)
  431. {
  432. void *tfm;
  433. int err;
  434. for (;;) {
  435. struct crypto_alg *alg;
  436. alg = crypto_find_alg(alg_name, frontend, type, mask);
  437. if (IS_ERR(alg)) {
  438. err = PTR_ERR(alg);
  439. goto err;
  440. }
  441. tfm = crypto_create_tfm(alg, frontend);
  442. if (!IS_ERR(tfm))
  443. return tfm;
  444. crypto_mod_put(alg);
  445. err = PTR_ERR(tfm);
  446. err:
  447. if (err != -EAGAIN)
  448. break;
  449. if (signal_pending(current)) {
  450. err = -EINTR;
  451. break;
  452. }
  453. }
  454. return ERR_PTR(err);
  455. }
  456. EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
  457. /*
  458. * crypto_destroy_tfm - Free crypto transform
  459. * @mem: Start of tfm slab
  460. * @tfm: Transform to free
  461. *
  462. * This function frees up the transform and any associated resources,
  463. * then drops the refcount on the associated algorithm.
  464. */
  465. void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm)
  466. {
  467. struct crypto_alg *alg;
  468. if (unlikely(!mem))
  469. return;
  470. alg = tfm->__crt_alg;
  471. if (!tfm->exit && alg->cra_exit)
  472. alg->cra_exit(tfm);
  473. crypto_exit_ops(tfm);
  474. crypto_mod_put(alg);
  475. kzfree(mem);
  476. }
  477. EXPORT_SYMBOL_GPL(crypto_destroy_tfm);
  478. int crypto_has_alg(const char *name, u32 type, u32 mask)
  479. {
  480. int ret = 0;
  481. struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
  482. if (!IS_ERR(alg)) {
  483. crypto_mod_put(alg);
  484. ret = 1;
  485. }
  486. return ret;
  487. }
  488. EXPORT_SYMBOL_GPL(crypto_has_alg);
  489. MODULE_DESCRIPTION("Cryptographic core API");
  490. MODULE_LICENSE("GPL");