blob: e5c1abfd451f4dc7668b87fe730ac14d2d8a2ea1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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)
Herbert Xu5cb14542005-11-05 16:58:14 +11006 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 *
8 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
John Anthony Kazos Jr991d1742007-10-19 23:06:17 +02009 * and Nettle, by Niels Möller.
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 *
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
Richard Hartmann3d01a332010-02-16 20:26:46 +080013 * Software Foundation; either version 2 of the License, or (at your option)
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * any later version.
15 *
16 */
Jesper Juhla61cc442005-07-06 13:54:31 -070017
Herbert Xu6bfd4802006-09-21 11:39:29 +100018#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <linux/errno.h>
Herbert Xu5cb14542005-11-05 16:58:14 +110020#include <linux/kernel.h>
Adrian Bunk176c3652005-07-06 13:53:09 -070021#include <linux/kmod.h>
Herbert Xu2b8c19d2006-09-21 11:31:44 +100022#include <linux/module.h>
Herbert Xu28259822006-08-06 21:23:26 +100023#include <linux/param.h>
Herbert Xu6bfd4802006-09-21 11:39:29 +100024#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/slab.h>
Herbert Xu5cb14542005-11-05 16:58:14 +110026#include <linux/string.h>
Jaegeuk Kim8dec0742017-06-22 12:14:40 -070027#include <linux/completion.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "internal.h"
29
30LIST_HEAD(crypto_alg_list);
Herbert Xucce9e062006-08-21 21:08:13 +100031EXPORT_SYMBOL_GPL(crypto_alg_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -070032DECLARE_RWSEM(crypto_alg_sem);
Herbert Xucce9e062006-08-21 21:08:13 +100033EXPORT_SYMBOL_GPL(crypto_alg_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Herbert Xu28259822006-08-06 21:23:26 +100035BLOCKING_NOTIFIER_HEAD(crypto_chain);
36EXPORT_SYMBOL_GPL(crypto_chain);
37
Herbert Xu77dbd7a2013-09-08 14:33:50 +100038static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg);
39
Herbert Xu28259822006-08-06 21:23:26 +100040struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
Herbert Xu6521f302006-08-06 20:28:44 +100041{
42 return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
43}
Herbert Xu28259822006-08-06 21:23:26 +100044EXPORT_SYMBOL_GPL(crypto_mod_get);
Herbert Xu6521f302006-08-06 20:28:44 +100045
Herbert Xu28259822006-08-06 21:23:26 +100046void crypto_mod_put(struct crypto_alg *alg)
Herbert Xu6521f302006-08-06 20:28:44 +100047{
Herbert Xuda7cd592007-05-19 14:51:00 +100048 struct module *module = alg->cra_module;
49
Herbert Xu6521f302006-08-06 20:28:44 +100050 crypto_alg_put(alg);
Herbert Xuda7cd592007-05-19 14:51:00 +100051 module_put(module);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052}
Herbert Xu28259822006-08-06 21:23:26 +100053EXPORT_SYMBOL_GPL(crypto_mod_put);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Herbert Xu73d38642008-08-03 21:15:23 +080055static inline int crypto_is_test_larval(struct crypto_larval *larval)
56{
57 return larval->alg.cra_driver_name[0];
58}
59
Herbert Xuc51b6c82008-08-04 11:44:59 +080060static struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type,
61 u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
63 struct crypto_alg *q, *alg = NULL;
Herbert Xu28259822006-08-06 21:23:26 +100064 int best = -2;
Linus Torvalds1da177e2005-04-16 15:20:36 -070065
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 list_for_each_entry(q, &crypto_alg_list, cra_list) {
Herbert Xu5cb14542005-11-05 16:58:14 +110067 int exact, fuzzy;
68
Herbert Xu6bfd4802006-09-21 11:39:29 +100069 if (crypto_is_moribund(q))
70 continue;
71
Herbert Xu492e2b62006-09-21 11:35:17 +100072 if ((q->cra_flags ^ type) & mask)
73 continue;
74
75 if (crypto_is_larval(q) &&
Herbert Xu73d38642008-08-03 21:15:23 +080076 !crypto_is_test_larval((struct crypto_larval *)q) &&
Herbert Xu492e2b62006-09-21 11:35:17 +100077 ((struct crypto_larval *)q)->mask != mask)
78 continue;
79
Herbert Xu5cb14542005-11-05 16:58:14 +110080 exact = !strcmp(q->cra_driver_name, name);
81 fuzzy = !strcmp(q->cra_name, name);
82 if (!exact && !(fuzzy && q->cra_priority > best))
83 continue;
84
Herbert Xu72fa4912006-05-28 09:05:24 +100085 if (unlikely(!crypto_mod_get(q)))
Herbert Xu5cb14542005-11-05 16:58:14 +110086 continue;
87
88 best = q->cra_priority;
89 if (alg)
Herbert Xu72fa4912006-05-28 09:05:24 +100090 crypto_mod_put(alg);
Herbert Xu5cb14542005-11-05 16:58:14 +110091 alg = q;
92
93 if (exact)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 }
Herbert Xu28259822006-08-06 21:23:26 +100096
97 return alg;
98}
Herbert Xu28259822006-08-06 21:23:26 +100099
100static void crypto_larval_destroy(struct crypto_alg *alg)
101{
102 struct crypto_larval *larval = (void *)alg;
103
104 BUG_ON(!crypto_is_larval(alg));
105 if (larval->adult)
106 crypto_mod_put(larval->adult);
107 kfree(larval);
108}
109
Herbert Xu73d38642008-08-03 21:15:23 +0800110struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask)
Herbert Xu28259822006-08-06 21:23:26 +1000111{
Herbert Xu28259822006-08-06 21:23:26 +1000112 struct crypto_larval *larval;
113
114 larval = kzalloc(sizeof(*larval), GFP_KERNEL);
115 if (!larval)
Herbert Xu6bfd4802006-09-21 11:39:29 +1000116 return ERR_PTR(-ENOMEM);
Herbert Xu28259822006-08-06 21:23:26 +1000117
Herbert Xu492e2b62006-09-21 11:35:17 +1000118 larval->mask = mask;
119 larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
Herbert Xu28259822006-08-06 21:23:26 +1000120 larval->alg.cra_priority = -1;
121 larval->alg.cra_destroy = crypto_larval_destroy;
122
Herbert Xu28259822006-08-06 21:23:26 +1000123 strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
124 init_completion(&larval->completion);
125
Herbert Xu73d38642008-08-03 21:15:23 +0800126 return larval;
127}
128EXPORT_SYMBOL_GPL(crypto_larval_alloc);
129
130static struct crypto_alg *crypto_larval_add(const char *name, u32 type,
131 u32 mask)
132{
133 struct crypto_alg *alg;
134 struct crypto_larval *larval;
135
136 larval = crypto_larval_alloc(name, type, mask);
137 if (IS_ERR(larval))
138 return ERR_CAST(larval);
139
140 atomic_set(&larval->alg.cra_refcnt, 2);
141
Herbert Xu28259822006-08-06 21:23:26 +1000142 down_write(&crypto_alg_sem);
Herbert Xu492e2b62006-09-21 11:35:17 +1000143 alg = __crypto_alg_lookup(name, type, mask);
Herbert Xu28259822006-08-06 21:23:26 +1000144 if (!alg) {
145 alg = &larval->alg;
146 list_add(&alg->cra_list, &crypto_alg_list);
147 }
148 up_write(&crypto_alg_sem);
149
Herbert Xu77dbd7a2013-09-08 14:33:50 +1000150 if (alg != &larval->alg) {
Herbert Xu28259822006-08-06 21:23:26 +1000151 kfree(larval);
Herbert Xu77dbd7a2013-09-08 14:33:50 +1000152 if (crypto_is_larval(alg))
153 alg = crypto_larval_wait(alg);
154 }
Herbert Xu28259822006-08-06 21:23:26 +1000155
156 return alg;
157}
158
Herbert Xub9c55aa2007-12-04 12:46:48 +1100159void crypto_larval_kill(struct crypto_alg *alg)
Herbert Xu28259822006-08-06 21:23:26 +1000160{
161 struct crypto_larval *larval = (void *)alg;
162
163 down_write(&crypto_alg_sem);
164 list_del(&alg->cra_list);
165 up_write(&crypto_alg_sem);
Herbert Xufe3c5202007-05-19 17:51:40 +1000166 complete_all(&larval->completion);
Herbert Xu28259822006-08-06 21:23:26 +1000167 crypto_alg_put(alg);
168}
Herbert Xub9c55aa2007-12-04 12:46:48 +1100169EXPORT_SYMBOL_GPL(crypto_larval_kill);
Herbert Xu28259822006-08-06 21:23:26 +1000170
171static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
172{
173 struct crypto_larval *larval = (void *)alg;
Herbert Xu73d38642008-08-03 21:15:23 +0800174 long timeout;
Herbert Xu28259822006-08-06 21:23:26 +1000175
Herbert Xu3fc89ad2015-10-19 18:23:57 +0800176 timeout = wait_for_completion_killable_timeout(
Herbert Xu73d38642008-08-03 21:15:23 +0800177 &larval->completion, 60 * HZ);
178
Herbert Xu28259822006-08-06 21:23:26 +1000179 alg = larval->adult;
Herbert Xu73d38642008-08-03 21:15:23 +0800180 if (timeout < 0)
181 alg = ERR_PTR(-EINTR);
182 else if (!timeout)
183 alg = ERR_PTR(-ETIMEDOUT);
184 else if (!alg)
Herbert Xu6bfd4802006-09-21 11:39:29 +1000185 alg = ERR_PTR(-ENOENT);
Herbert Xu73d38642008-08-03 21:15:23 +0800186 else if (crypto_is_test_larval(larval) &&
187 !(alg->cra_flags & CRYPTO_ALG_TESTED))
188 alg = ERR_PTR(-EAGAIN);
189 else if (!crypto_mod_get(alg))
190 alg = ERR_PTR(-EAGAIN);
Herbert Xu28259822006-08-06 21:23:26 +1000191 crypto_mod_put(&larval->alg);
192
193 return alg;
194}
195
Herbert Xuc51b6c82008-08-04 11:44:59 +0800196struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, u32 mask)
Herbert Xu28259822006-08-06 21:23:26 +1000197{
198 struct crypto_alg *alg;
199
Herbert Xu28259822006-08-06 21:23:26 +1000200 down_read(&crypto_alg_sem);
Herbert Xu492e2b62006-09-21 11:35:17 +1000201 alg = __crypto_alg_lookup(name, type, mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 up_read(&crypto_alg_sem);
Herbert Xu28259822006-08-06 21:23:26 +1000203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 return alg;
205}
Herbert Xuc51b6c82008-08-04 11:44:59 +0800206EXPORT_SYMBOL_GPL(crypto_alg_lookup);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Herbert Xub9c55aa2007-12-04 12:46:48 +1100208struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask)
Adrian Bunk176c3652005-07-06 13:53:09 -0700209{
Herbert Xu28259822006-08-06 21:23:26 +1000210 struct crypto_alg *alg;
Herbert Xu28259822006-08-06 21:23:26 +1000211
Herbert Xu6bfd4802006-09-21 11:39:29 +1000212 if (!name)
213 return ERR_PTR(-ENOENT);
214
215 mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
Herbert Xu492e2b62006-09-21 11:35:17 +1000216 type &= mask;
217
Herbert Xua760a662009-02-26 14:06:31 +0800218 alg = crypto_alg_lookup(name, type, mask);
219 if (!alg) {
Kees Cook5d26a102014-11-20 17:05:53 -0800220 request_module("crypto-%s", name);
Herbert Xua760a662009-02-26 14:06:31 +0800221
Herbert Xu37fc3342009-04-21 13:27:16 +0800222 if (!((type ^ CRYPTO_ALG_NEED_FALLBACK) & mask &
Alex Riesenaa07a692009-06-02 14:13:14 +1000223 CRYPTO_ALG_NEED_FALLBACK))
Kees Cook5d26a102014-11-20 17:05:53 -0800224 request_module("crypto-%s-all", name);
Herbert Xua760a662009-02-26 14:06:31 +0800225
226 alg = crypto_alg_lookup(name, type, mask);
227 }
228
Herbert Xu28259822006-08-06 21:23:26 +1000229 if (alg)
230 return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
231
Herbert Xu73d38642008-08-03 21:15:23 +0800232 return crypto_larval_add(name, type, mask);
Herbert Xub9c55aa2007-12-04 12:46:48 +1100233}
234EXPORT_SYMBOL_GPL(crypto_larval_lookup);
235
Herbert Xu73d38642008-08-03 21:15:23 +0800236int crypto_probing_notify(unsigned long val, void *v)
237{
238 int ok;
239
240 ok = blocking_notifier_call_chain(&crypto_chain, val, v);
241 if (ok == NOTIFY_DONE) {
242 request_module("cryptomgr");
243 ok = blocking_notifier_call_chain(&crypto_chain, val, v);
244 }
245
246 return ok;
247}
248EXPORT_SYMBOL_GPL(crypto_probing_notify);
249
Herbert Xub9c55aa2007-12-04 12:46:48 +1100250struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
251{
252 struct crypto_alg *alg;
253 struct crypto_alg *larval;
254 int ok;
255
Herbert Xuff753302009-02-17 20:18:34 +0800256 if (!((type | mask) & CRYPTO_ALG_TESTED)) {
Herbert Xu73d38642008-08-03 21:15:23 +0800257 type |= CRYPTO_ALG_TESTED;
258 mask |= CRYPTO_ALG_TESTED;
259 }
260
Stephan Mueller06ca7f62015-03-30 21:55:52 +0200261 /*
262 * If the internal flag is set for a cipher, require a caller to
263 * to invoke the cipher with the internal flag to use that cipher.
264 * Also, if a caller wants to allocate a cipher that may or may
265 * not be an internal cipher, use type | CRYPTO_ALG_INTERNAL and
266 * !(mask & CRYPTO_ALG_INTERNAL).
267 */
268 if (!((type | mask) & CRYPTO_ALG_INTERNAL))
269 mask |= CRYPTO_ALG_INTERNAL;
270
Herbert Xub9c55aa2007-12-04 12:46:48 +1100271 larval = crypto_larval_lookup(name, type, mask);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000272 if (IS_ERR(larval) || !crypto_is_larval(larval))
Herbert Xu28259822006-08-06 21:23:26 +1000273 return larval;
274
Herbert Xu73d38642008-08-03 21:15:23 +0800275 ok = crypto_probing_notify(CRYPTO_MSG_ALG_REQUEST, larval);
Herbert Xu2b8c19d2006-09-21 11:31:44 +1000276
277 if (ok == NOTIFY_STOP)
Herbert Xu28259822006-08-06 21:23:26 +1000278 alg = crypto_larval_wait(larval);
279 else {
280 crypto_mod_put(larval);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000281 alg = ERR_PTR(-ENOENT);
Herbert Xu28259822006-08-06 21:23:26 +1000282 }
283 crypto_larval_kill(larval);
284 return alg;
Adrian Bunk176c3652005-07-06 13:53:09 -0700285}
Herbert Xu492e2b62006-09-21 11:35:17 +1000286EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
Adrian Bunk176c3652005-07-06 13:53:09 -0700287
Herbert Xu27d2a332007-01-24 20:50:26 +1100288static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
Herbert Xu27d2a332007-01-24 20:50:26 +1100290 const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
Herbert Xue853c3c2006-08-22 00:06:54 +1000291
Herbert Xu27d2a332007-01-24 20:50:26 +1100292 if (type_obj)
293 return type_obj->init(tfm, type, mask);
Herbert Xue853c3c2006-08-22 00:06:54 +1000294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 switch (crypto_tfm_alg_type(tfm)) {
296 case CRYPTO_ALG_TYPE_CIPHER:
297 return crypto_init_cipher_ops(tfm);
Loc Ho004a4032008-05-14 20:41:47 +0800298
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 case CRYPTO_ALG_TYPE_COMPRESS:
300 return crypto_init_compress_ops(tfm);
Richard Hartmann3d01a332010-02-16 20:26:46 +0800301
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 default:
303 break;
304 }
Richard Hartmann3d01a332010-02-16 20:26:46 +0800305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 BUG();
307 return -EINVAL;
308}
309
310static void crypto_exit_ops(struct crypto_tfm *tfm)
311{
Herbert Xue853c3c2006-08-22 00:06:54 +1000312 const struct crypto_type *type = tfm->__crt_alg->cra_type;
313
314 if (type) {
Herbert Xu4a779482008-09-13 18:19:03 -0700315 if (tfm->exit)
316 tfm->exit(tfm);
Herbert Xue853c3c2006-08-22 00:06:54 +1000317 return;
318 }
319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 switch (crypto_tfm_alg_type(tfm)) {
321 case CRYPTO_ALG_TYPE_CIPHER:
322 crypto_exit_cipher_ops(tfm);
323 break;
Herbert Xu6941c3a2009-07-12 13:58:04 +0800324
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 case CRYPTO_ALG_TYPE_COMPRESS:
326 crypto_exit_compress_ops(tfm);
327 break;
Richard Hartmann3d01a332010-02-16 20:26:46 +0800328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 default:
330 BUG();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 }
332}
333
Herbert Xu27d2a332007-01-24 20:50:26 +1100334static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
Herbert Xufbdae9f2005-07-06 13:53:29 -0700335{
Herbert Xu27d2a332007-01-24 20:50:26 +1100336 const struct crypto_type *type_obj = alg->cra_type;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700337 unsigned int len;
338
Herbert Xue853c3c2006-08-22 00:06:54 +1000339 len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
Herbert Xu27d2a332007-01-24 20:50:26 +1100340 if (type_obj)
341 return len + type_obj->ctxsize(alg, type, mask);
Herbert Xue853c3c2006-08-22 00:06:54 +1000342
Herbert Xufbdae9f2005-07-06 13:53:29 -0700343 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
344 default:
345 BUG();
346
347 case CRYPTO_ALG_TYPE_CIPHER:
Herbert Xuf1ddcaf2007-01-27 10:05:15 +1100348 len += crypto_cipher_ctxsize(alg);
Herbert Xufbdae9f2005-07-06 13:53:29 -0700349 break;
Herbert Xu6941c3a2009-07-12 13:58:04 +0800350
Herbert Xufbdae9f2005-07-06 13:53:29 -0700351 case CRYPTO_ALG_TYPE_COMPRESS:
Herbert Xuf1ddcaf2007-01-27 10:05:15 +1100352 len += crypto_compress_ctxsize(alg);
Herbert Xufbdae9f2005-07-06 13:53:29 -0700353 break;
354 }
355
Herbert Xue853c3c2006-08-22 00:06:54 +1000356 return len;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700357}
358
Herbert Xu6bfd4802006-09-21 11:39:29 +1000359void crypto_shoot_alg(struct crypto_alg *alg)
360{
361 down_write(&crypto_alg_sem);
362 alg->cra_flags |= CRYPTO_ALG_DYING;
363 up_write(&crypto_alg_sem);
364}
365EXPORT_SYMBOL_GPL(crypto_shoot_alg);
366
Herbert Xu27d2a332007-01-24 20:50:26 +1100367struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
368 u32 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 struct crypto_tfm *tfm = NULL;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700371 unsigned int tfm_size;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000372 int err = -ENOMEM;
Herbert Xufbdae9f2005-07-06 13:53:29 -0700373
Herbert Xu27d2a332007-01-24 20:50:26 +1100374 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
Eric Sesterhennbbeb5632006-03-06 21:42:07 +1100375 tfm = kzalloc(tfm_size, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 if (tfm == NULL)
Akinobu Mita9765d262006-10-11 22:29:51 +1000377 goto out_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 tfm->__crt_alg = alg;
Herbert Xu6bfd4802006-09-21 11:39:29 +1000380
Herbert Xu27d2a332007-01-24 20:50:26 +1100381 err = crypto_init_ops(tfm, type, mask);
Herbert Xu6bfd4802006-09-21 11:39:29 +1000382 if (err)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 goto out_free_tfm;
Herbert Xuc7fc0592006-05-24 13:02:26 +1000384
Herbert Xu4a779482008-09-13 18:19:03 -0700385 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
Herbert Xuc7fc0592006-05-24 13:02:26 +1000386 goto cra_init_failed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
388 goto out;
389
Herbert Xuc7fc0592006-05-24 13:02:26 +1000390cra_init_failed:
391 crypto_exit_ops(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392out_free_tfm:
Herbert Xu4a779482008-09-13 18:19:03 -0700393 if (err == -EAGAIN)
394 crypto_shoot_alg(alg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 kfree(tfm);
Akinobu Mita9765d262006-10-11 22:29:51 +1000396out_err:
Herbert Xu6bfd4802006-09-21 11:39:29 +1000397 tfm = ERR_PTR(err);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398out:
399 return tfm;
400}
Herbert Xu6bfd4802006-09-21 11:39:29 +1000401EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
402
Herbert Xu6d7d6842006-07-30 11:53:01 +1000403/*
404 * crypto_alloc_base - Locate algorithm and allocate transform
405 * @alg_name: Name of algorithm
406 * @type: Type of algorithm
407 * @mask: Mask for type comparison
408 *
Herbert Xu7b0bac62008-09-21 06:52:53 +0900409 * This function should not be used by new algorithm types.
Cristian Stoicafd1a1902013-06-28 15:56:20 +0300410 * Please use crypto_alloc_tfm instead.
Herbert Xu7b0bac62008-09-21 06:52:53 +0900411 *
Herbert Xu6d7d6842006-07-30 11:53:01 +1000412 * crypto_alloc_base() will first attempt to locate an already loaded
413 * algorithm. If that fails and the kernel supports dynamically loadable
414 * modules, it will then attempt to load a module of the same name or
415 * alias. If that fails it will send a query to any loaded crypto manager
416 * to construct an algorithm on the fly. A refcount is grabbed on the
417 * algorithm which is then associated with the new transform.
418 *
419 * The returned transform is of a non-determinate type. Most people
420 * should use one of the more specific allocation functions such as
421 * crypto_alloc_blkcipher.
422 *
423 * In case of error the return value is an error pointer.
424 */
425struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
426{
427 struct crypto_tfm *tfm;
428 int err;
429
430 for (;;) {
431 struct crypto_alg *alg;
432
433 alg = crypto_alg_mod_lookup(alg_name, type, mask);
Akinobu Mita9765d262006-10-11 22:29:51 +1000434 if (IS_ERR(alg)) {
435 err = PTR_ERR(alg);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000436 goto err;
Akinobu Mita9765d262006-10-11 22:29:51 +1000437 }
Herbert Xu6d7d6842006-07-30 11:53:01 +1000438
Herbert Xu27d2a332007-01-24 20:50:26 +1100439 tfm = __crypto_alloc_tfm(alg, type, mask);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000440 if (!IS_ERR(tfm))
Akinobu Mita9765d262006-10-11 22:29:51 +1000441 return tfm;
Herbert Xu6d7d6842006-07-30 11:53:01 +1000442
443 crypto_mod_put(alg);
444 err = PTR_ERR(tfm);
445
446err:
447 if (err != -EAGAIN)
448 break;
Herbert Xu3fc89ad2015-10-19 18:23:57 +0800449 if (fatal_signal_pending(current)) {
Herbert Xu6d7d6842006-07-30 11:53:01 +1000450 err = -EINTR;
451 break;
452 }
Akinobu Mita9765d262006-10-11 22:29:51 +1000453 }
Herbert Xu6d7d6842006-07-30 11:53:01 +1000454
Akinobu Mita9765d262006-10-11 22:29:51 +1000455 return ERR_PTR(err);
Herbert Xu6d7d6842006-07-30 11:53:01 +1000456}
457EXPORT_SYMBOL_GPL(crypto_alloc_base);
Herbert Xu7b0bac62008-09-21 06:52:53 +0900458
Herbert Xu3f683d62009-02-18 16:56:59 +0800459void *crypto_create_tfm(struct crypto_alg *alg,
460 const struct crypto_type *frontend)
Herbert Xu7b0bac62008-09-21 06:52:53 +0900461{
462 char *mem;
463 struct crypto_tfm *tfm = NULL;
464 unsigned int tfmsize;
465 unsigned int total;
466 int err = -ENOMEM;
467
468 tfmsize = frontend->tfmsize;
Herbert Xu2ca33da2009-07-13 20:46:25 +0800469 total = tfmsize + sizeof(*tfm) + frontend->extsize(alg);
Herbert Xu7b0bac62008-09-21 06:52:53 +0900470
471 mem = kzalloc(total, GFP_KERNEL);
472 if (mem == NULL)
473 goto out_err;
474
475 tfm = (struct crypto_tfm *)(mem + tfmsize);
476 tfm->__crt_alg = alg;
477
Herbert Xu2ca33da2009-07-13 20:46:25 +0800478 err = frontend->init_tfm(tfm);
Herbert Xu7b0bac62008-09-21 06:52:53 +0900479 if (err)
480 goto out_free_tfm;
481
482 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
483 goto cra_init_failed;
484
485 goto out;
486
487cra_init_failed:
488 crypto_exit_ops(tfm);
489out_free_tfm:
490 if (err == -EAGAIN)
491 crypto_shoot_alg(alg);
492 kfree(mem);
493out_err:
Herbert Xu3f683d62009-02-18 16:56:59 +0800494 mem = ERR_PTR(err);
Herbert Xu7b0bac62008-09-21 06:52:53 +0900495out:
Herbert Xu3f683d62009-02-18 16:56:59 +0800496 return mem;
Herbert Xu7b0bac62008-09-21 06:52:53 +0900497}
498EXPORT_SYMBOL_GPL(crypto_create_tfm);
499
Herbert Xud06854f2009-07-08 17:53:16 +0800500struct crypto_alg *crypto_find_alg(const char *alg_name,
501 const struct crypto_type *frontend,
502 u32 type, u32 mask)
503{
504 struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask) =
505 crypto_alg_mod_lookup;
506
507 if (frontend) {
508 type &= frontend->maskclear;
509 mask &= frontend->maskclear;
510 type |= frontend->type;
511 mask |= frontend->maskset;
512
513 if (frontend->lookup)
514 lookup = frontend->lookup;
515 }
516
517 return lookup(alg_name, type, mask);
518}
519EXPORT_SYMBOL_GPL(crypto_find_alg);
520
Herbert Xu7b0bac62008-09-21 06:52:53 +0900521/*
522 * crypto_alloc_tfm - Locate algorithm and allocate transform
523 * @alg_name: Name of algorithm
524 * @frontend: Frontend algorithm type
525 * @type: Type of algorithm
526 * @mask: Mask for type comparison
527 *
528 * crypto_alloc_tfm() will first attempt to locate an already loaded
529 * algorithm. If that fails and the kernel supports dynamically loadable
530 * modules, it will then attempt to load a module of the same name or
531 * alias. If that fails it will send a query to any loaded crypto manager
532 * to construct an algorithm on the fly. A refcount is grabbed on the
533 * algorithm which is then associated with the new transform.
534 *
535 * The returned transform is of a non-determinate type. Most people
536 * should use one of the more specific allocation functions such as
537 * crypto_alloc_blkcipher.
538 *
539 * In case of error the return value is an error pointer.
540 */
Herbert Xu3f683d62009-02-18 16:56:59 +0800541void *crypto_alloc_tfm(const char *alg_name,
542 const struct crypto_type *frontend, u32 type, u32 mask)
Herbert Xu7b0bac62008-09-21 06:52:53 +0900543{
Herbert Xu3f683d62009-02-18 16:56:59 +0800544 void *tfm;
Herbert Xu7b0bac62008-09-21 06:52:53 +0900545 int err;
546
Herbert Xu7b0bac62008-09-21 06:52:53 +0900547 for (;;) {
548 struct crypto_alg *alg;
549
Herbert Xud06854f2009-07-08 17:53:16 +0800550 alg = crypto_find_alg(alg_name, frontend, type, mask);
Herbert Xu7b0bac62008-09-21 06:52:53 +0900551 if (IS_ERR(alg)) {
552 err = PTR_ERR(alg);
553 goto err;
554 }
555
556 tfm = crypto_create_tfm(alg, frontend);
557 if (!IS_ERR(tfm))
558 return tfm;
559
560 crypto_mod_put(alg);
561 err = PTR_ERR(tfm);
562
563err:
564 if (err != -EAGAIN)
565 break;
Herbert Xu3fc89ad2015-10-19 18:23:57 +0800566 if (fatal_signal_pending(current)) {
Herbert Xu7b0bac62008-09-21 06:52:53 +0900567 err = -EINTR;
568 break;
569 }
570 }
571
572 return ERR_PTR(err);
573}
574EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
Herbert Xu7b2cd922009-02-05 16:48:24 +1100575
Herbert Xu6d7d6842006-07-30 11:53:01 +1000576/*
Herbert Xu7b2cd922009-02-05 16:48:24 +1100577 * crypto_destroy_tfm - Free crypto transform
578 * @mem: Start of tfm slab
Herbert Xu6d7d6842006-07-30 11:53:01 +1000579 * @tfm: Transform to free
580 *
Herbert Xu7b2cd922009-02-05 16:48:24 +1100581 * This function frees up the transform and any associated resources,
Herbert Xu6d7d6842006-07-30 11:53:01 +1000582 * then drops the refcount on the associated algorithm.
583 */
Herbert Xu7b2cd922009-02-05 16:48:24 +1100584void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585{
Jesper Juhla61cc442005-07-06 13:54:31 -0700586 struct crypto_alg *alg;
Jesper Juhla61cc442005-07-06 13:54:31 -0700587
Herbert Xu7b2cd922009-02-05 16:48:24 +1100588 if (unlikely(!mem))
Jesper Juhla61cc442005-07-06 13:54:31 -0700589 return;
590
591 alg = tfm->__crt_alg;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592
Herbert Xu4a779482008-09-13 18:19:03 -0700593 if (!tfm->exit && alg->cra_exit)
Herbert Xuc7fc0592006-05-24 13:02:26 +1000594 alg->cra_exit(tfm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595 crypto_exit_ops(tfm);
Herbert Xu72fa4912006-05-28 09:05:24 +1000596 crypto_mod_put(alg);
Johannes Weiner811d8f02009-03-29 15:20:48 +0800597 kzfree(mem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598}
Herbert Xu7b2cd922009-02-05 16:48:24 +1100599EXPORT_SYMBOL_GPL(crypto_destroy_tfm);
Herbert Xufce32d72006-08-26 17:35:45 +1000600
601int crypto_has_alg(const char *name, u32 type, u32 mask)
602{
603 int ret = 0;
604 struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
Richard Hartmann3d01a332010-02-16 20:26:46 +0800605
Herbert Xufce32d72006-08-26 17:35:45 +1000606 if (!IS_ERR(alg)) {
607 crypto_mod_put(alg);
608 ret = 1;
609 }
Richard Hartmann3d01a332010-02-16 20:26:46 +0800610
Herbert Xufce32d72006-08-26 17:35:45 +1000611 return ret;
612}
613EXPORT_SYMBOL_GPL(crypto_has_alg);
Sebastian Siewiorc3715cb92008-03-30 16:36:09 +0800614
Jaegeuk Kim8dec0742017-06-22 12:14:40 -0700615void crypto_req_done(struct crypto_async_request *req, int err)
616{
617 struct crypto_wait *wait = req->data;
618
619 if (err == -EINPROGRESS)
620 return;
621
622 wait->err = err;
623 complete(&wait->completion);
624}
625EXPORT_SYMBOL_GPL(crypto_req_done);
626
Sebastian Siewiorc3715cb92008-03-30 16:36:09 +0800627MODULE_DESCRIPTION("Cryptographic core API");
628MODULE_LICENSE("GPL");