]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - crypto/api.c
net: ena: update driver's rx drop statistics
[mirror_ubuntu-zesty-kernel.git] / crypto / api.c
CommitLineData
1da177e4
LT
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)
5cb1454b 6 * Copyright (c) 2005 Herbert Xu <herbert@gondor.apana.org.au>
1da177e4
LT
7 *
8 * Portions derived from Cryptoapi, by Alexander Kjeldaas <astor@fast.no>
991d1740 9 * and Nettle, by Niels Möller.
1da177e4
LT
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
3d01a33b 13 * Software Foundation; either version 2 of the License, or (at your option)
1da177e4
LT
14 * any later version.
15 *
16 */
a61cc448 17
6bfd4809 18#include <linux/err.h>
1da177e4 19#include <linux/errno.h>
5cb1454b 20#include <linux/kernel.h>
176c3652 21#include <linux/kmod.h>
2b8c19db 22#include <linux/module.h>
2825982d 23#include <linux/param.h>
6bfd4809 24#include <linux/sched.h>
1da177e4 25#include <linux/slab.h>
5cb1454b 26#include <linux/string.h>
1da177e4
LT
27#include "internal.h"
28
29LIST_HEAD(crypto_alg_list);
cce9e06d 30EXPORT_SYMBOL_GPL(crypto_alg_list);
1da177e4 31DECLARE_RWSEM(crypto_alg_sem);
cce9e06d 32EXPORT_SYMBOL_GPL(crypto_alg_sem);
1da177e4 33
2825982d
HX
34BLOCKING_NOTIFIER_HEAD(crypto_chain);
35EXPORT_SYMBOL_GPL(crypto_chain);
36
77dbd7a9
HX
37static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg);
38
2825982d 39struct crypto_alg *crypto_mod_get(struct crypto_alg *alg)
6521f302
HX
40{
41 return try_module_get(alg->cra_module) ? crypto_alg_get(alg) : NULL;
1da177e4 42}
2825982d 43EXPORT_SYMBOL_GPL(crypto_mod_get);
1da177e4 44
2825982d 45void crypto_mod_put(struct crypto_alg *alg)
1da177e4 46{
da7cd59a
HX
47 struct module *module = alg->cra_module;
48
6521f302 49 crypto_alg_put(alg);
da7cd59a 50 module_put(module);
1da177e4 51}
2825982d 52EXPORT_SYMBOL_GPL(crypto_mod_put);
1da177e4 53
73d3864a
HX
54static inline int crypto_is_test_larval(struct crypto_larval *larval)
55{
56 return larval->alg.cra_driver_name[0];
57}
58
c51b6c81
HX
59static struct crypto_alg *__crypto_alg_lookup(const char *name, u32 type,
60 u32 mask)
1da177e4
LT
61{
62 struct crypto_alg *q, *alg = NULL;
2825982d 63 int best = -2;
1da177e4 64
1da177e4 65 list_for_each_entry(q, &crypto_alg_list, cra_list) {
5cb1454b
HX
66 int exact, fuzzy;
67
6bfd4809
HX
68 if (crypto_is_moribund(q))
69 continue;
70
492e2b63
HX
71 if ((q->cra_flags ^ type) & mask)
72 continue;
73
74 if (crypto_is_larval(q) &&
73d3864a 75 !crypto_is_test_larval((struct crypto_larval *)q) &&
492e2b63
HX
76 ((struct crypto_larval *)q)->mask != mask)
77 continue;
78
5cb1454b
HX
79 exact = !strcmp(q->cra_driver_name, name);
80 fuzzy = !strcmp(q->cra_name, name);
81 if (!exact && !(fuzzy && q->cra_priority > best))
82 continue;
83
72fa4919 84 if (unlikely(!crypto_mod_get(q)))
5cb1454b
HX
85 continue;
86
87 best = q->cra_priority;
88 if (alg)
72fa4919 89 crypto_mod_put(alg);
5cb1454b
HX
90 alg = q;
91
92 if (exact)
1da177e4 93 break;
1da177e4 94 }
2825982d
HX
95
96 return alg;
97}
2825982d
HX
98
99static void crypto_larval_destroy(struct crypto_alg *alg)
100{
101 struct crypto_larval *larval = (void *)alg;
102
103 BUG_ON(!crypto_is_larval(alg));
104 if (larval->adult)
105 crypto_mod_put(larval->adult);
106 kfree(larval);
107}
108
73d3864a 109struct crypto_larval *crypto_larval_alloc(const char *name, u32 type, u32 mask)
2825982d 110{
2825982d
HX
111 struct crypto_larval *larval;
112
113 larval = kzalloc(sizeof(*larval), GFP_KERNEL);
114 if (!larval)
6bfd4809 115 return ERR_PTR(-ENOMEM);
2825982d 116
492e2b63
HX
117 larval->mask = mask;
118 larval->alg.cra_flags = CRYPTO_ALG_LARVAL | type;
2825982d
HX
119 larval->alg.cra_priority = -1;
120 larval->alg.cra_destroy = crypto_larval_destroy;
121
2825982d
HX
122 strlcpy(larval->alg.cra_name, name, CRYPTO_MAX_ALG_NAME);
123 init_completion(&larval->completion);
124
73d3864a
HX
125 return larval;
126}
127EXPORT_SYMBOL_GPL(crypto_larval_alloc);
128
129static struct crypto_alg *crypto_larval_add(const char *name, u32 type,
130 u32 mask)
131{
132 struct crypto_alg *alg;
133 struct crypto_larval *larval;
134
135 larval = crypto_larval_alloc(name, type, mask);
136 if (IS_ERR(larval))
137 return ERR_CAST(larval);
138
139 atomic_set(&larval->alg.cra_refcnt, 2);
140
2825982d 141 down_write(&crypto_alg_sem);
492e2b63 142 alg = __crypto_alg_lookup(name, type, mask);
2825982d
HX
143 if (!alg) {
144 alg = &larval->alg;
145 list_add(&alg->cra_list, &crypto_alg_list);
146 }
147 up_write(&crypto_alg_sem);
148
77dbd7a9 149 if (alg != &larval->alg) {
2825982d 150 kfree(larval);
77dbd7a9
HX
151 if (crypto_is_larval(alg))
152 alg = crypto_larval_wait(alg);
153 }
2825982d
HX
154
155 return alg;
156}
157
b9c55aa4 158void crypto_larval_kill(struct crypto_alg *alg)
2825982d
HX
159{
160 struct crypto_larval *larval = (void *)alg;
161
162 down_write(&crypto_alg_sem);
163 list_del(&alg->cra_list);
164 up_write(&crypto_alg_sem);
fe3c5206 165 complete_all(&larval->completion);
2825982d
HX
166 crypto_alg_put(alg);
167}
b9c55aa4 168EXPORT_SYMBOL_GPL(crypto_larval_kill);
2825982d
HX
169
170static struct crypto_alg *crypto_larval_wait(struct crypto_alg *alg)
171{
172 struct crypto_larval *larval = (void *)alg;
73d3864a
HX
173 long timeout;
174
3fc89adb 175 timeout = wait_for_completion_killable_timeout(
73d3864a 176 &larval->completion, 60 * HZ);
2825982d 177
2825982d 178 alg = larval->adult;
73d3864a
HX
179 if (timeout < 0)
180 alg = ERR_PTR(-EINTR);
181 else if (!timeout)
182 alg = ERR_PTR(-ETIMEDOUT);
183 else if (!alg)
6bfd4809 184 alg = ERR_PTR(-ENOENT);
73d3864a
HX
185 else if (crypto_is_test_larval(larval) &&
186 !(alg->cra_flags & CRYPTO_ALG_TESTED))
187 alg = ERR_PTR(-EAGAIN);
188 else if (!crypto_mod_get(alg))
189 alg = ERR_PTR(-EAGAIN);
2825982d
HX
190 crypto_mod_put(&larval->alg);
191
192 return alg;
193}
194
c51b6c81 195struct crypto_alg *crypto_alg_lookup(const char *name, u32 type, u32 mask)
2825982d
HX
196{
197 struct crypto_alg *alg;
198
2825982d 199 down_read(&crypto_alg_sem);
492e2b63 200 alg = __crypto_alg_lookup(name, type, mask);
1da177e4 201 up_read(&crypto_alg_sem);
2825982d 202
1da177e4
LT
203 return alg;
204}
c51b6c81 205EXPORT_SYMBOL_GPL(crypto_alg_lookup);
1da177e4 206
b9c55aa4 207struct crypto_alg *crypto_larval_lookup(const char *name, u32 type, u32 mask)
176c3652 208{
2825982d 209 struct crypto_alg *alg;
2825982d 210
6bfd4809
HX
211 if (!name)
212 return ERR_PTR(-ENOENT);
213
430b441c 214 type &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
6bfd4809 215 mask &= ~(CRYPTO_ALG_LARVAL | CRYPTO_ALG_DEAD);
492e2b63 216
a760a665
HX
217 alg = crypto_alg_lookup(name, type, mask);
218 if (!alg) {
5d26a105 219 request_module("crypto-%s", name);
a760a665 220
37fc334c 221 if (!((type ^ CRYPTO_ALG_NEED_FALLBACK) & mask &
aa07a699 222 CRYPTO_ALG_NEED_FALLBACK))
5d26a105 223 request_module("crypto-%s-all", name);
a760a665
HX
224
225 alg = crypto_alg_lookup(name, type, mask);
226 }
227
2825982d
HX
228 if (alg)
229 return crypto_is_larval(alg) ? crypto_larval_wait(alg) : alg;
230
73d3864a 231 return crypto_larval_add(name, type, mask);
b9c55aa4
HX
232}
233EXPORT_SYMBOL_GPL(crypto_larval_lookup);
234
73d3864a
HX
235int crypto_probing_notify(unsigned long val, void *v)
236{
237 int ok;
238
239 ok = blocking_notifier_call_chain(&crypto_chain, val, v);
240 if (ok == NOTIFY_DONE) {
241 request_module("cryptomgr");
242 ok = blocking_notifier_call_chain(&crypto_chain, val, v);
243 }
244
245 return ok;
246}
247EXPORT_SYMBOL_GPL(crypto_probing_notify);
248
b9c55aa4
HX
249struct crypto_alg *crypto_alg_mod_lookup(const char *name, u32 type, u32 mask)
250{
251 struct crypto_alg *alg;
252 struct crypto_alg *larval;
253 int ok;
254
ff753308 255 if (!((type | mask) & CRYPTO_ALG_TESTED)) {
73d3864a
HX
256 type |= CRYPTO_ALG_TESTED;
257 mask |= CRYPTO_ALG_TESTED;
258 }
259
06ca7f68
SM
260 /*
261 * If the internal flag is set for a cipher, require a caller to
262 * to invoke the cipher with the internal flag to use that cipher.
263 * Also, if a caller wants to allocate a cipher that may or may
264 * not be an internal cipher, use type | CRYPTO_ALG_INTERNAL and
265 * !(mask & CRYPTO_ALG_INTERNAL).
266 */
267 if (!((type | mask) & CRYPTO_ALG_INTERNAL))
268 mask |= CRYPTO_ALG_INTERNAL;
269
b9c55aa4 270 larval = crypto_larval_lookup(name, type, mask);
6bfd4809 271 if (IS_ERR(larval) || !crypto_is_larval(larval))
2825982d
HX
272 return larval;
273
73d3864a 274 ok = crypto_probing_notify(CRYPTO_MSG_ALG_REQUEST, larval);
2b8c19db
HX
275
276 if (ok == NOTIFY_STOP)
2825982d
HX
277 alg = crypto_larval_wait(larval);
278 else {
279 crypto_mod_put(larval);
6bfd4809 280 alg = ERR_PTR(-ENOENT);
2825982d
HX
281 }
282 crypto_larval_kill(larval);
283 return alg;
176c3652 284}
492e2b63 285EXPORT_SYMBOL_GPL(crypto_alg_mod_lookup);
176c3652 286
27d2a330 287static int crypto_init_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
1da177e4 288{
27d2a330 289 const struct crypto_type *type_obj = tfm->__crt_alg->cra_type;
e853c3cf 290
27d2a330
HX
291 if (type_obj)
292 return type_obj->init(tfm, type, mask);
e853c3cf 293
1da177e4
LT
294 switch (crypto_tfm_alg_type(tfm)) {
295 case CRYPTO_ALG_TYPE_CIPHER:
296 return crypto_init_cipher_ops(tfm);
004a403c 297
1da177e4
LT
298 case CRYPTO_ALG_TYPE_COMPRESS:
299 return crypto_init_compress_ops(tfm);
3d01a33b 300
1da177e4
LT
301 default:
302 break;
303 }
3d01a33b 304
1da177e4
LT
305 BUG();
306 return -EINVAL;
307}
308
309static void crypto_exit_ops(struct crypto_tfm *tfm)
310{
e853c3cf
HX
311 const struct crypto_type *type = tfm->__crt_alg->cra_type;
312
9c8ae17b
EB
313 if (type && tfm->exit)
314 tfm->exit(tfm);
1da177e4
LT
315}
316
27d2a330 317static unsigned int crypto_ctxsize(struct crypto_alg *alg, u32 type, u32 mask)
fbdae9f3 318{
27d2a330 319 const struct crypto_type *type_obj = alg->cra_type;
fbdae9f3
HX
320 unsigned int len;
321
e853c3cf 322 len = alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1);
27d2a330
HX
323 if (type_obj)
324 return len + type_obj->ctxsize(alg, type, mask);
e853c3cf 325
fbdae9f3
HX
326 switch (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) {
327 default:
328 BUG();
329
330 case CRYPTO_ALG_TYPE_CIPHER:
f1ddcaf3 331 len += crypto_cipher_ctxsize(alg);
fbdae9f3 332 break;
6941c3a0 333
fbdae9f3 334 case CRYPTO_ALG_TYPE_COMPRESS:
f1ddcaf3 335 len += crypto_compress_ctxsize(alg);
fbdae9f3
HX
336 break;
337 }
338
e853c3cf 339 return len;
fbdae9f3
HX
340}
341
6bfd4809
HX
342void crypto_shoot_alg(struct crypto_alg *alg)
343{
344 down_write(&crypto_alg_sem);
345 alg->cra_flags |= CRYPTO_ALG_DYING;
346 up_write(&crypto_alg_sem);
347}
348EXPORT_SYMBOL_GPL(crypto_shoot_alg);
349
27d2a330
HX
350struct crypto_tfm *__crypto_alloc_tfm(struct crypto_alg *alg, u32 type,
351 u32 mask)
1da177e4
LT
352{
353 struct crypto_tfm *tfm = NULL;
fbdae9f3 354 unsigned int tfm_size;
6bfd4809 355 int err = -ENOMEM;
fbdae9f3 356
27d2a330 357 tfm_size = sizeof(*tfm) + crypto_ctxsize(alg, type, mask);
bbeb563f 358 tfm = kzalloc(tfm_size, GFP_KERNEL);
1da177e4 359 if (tfm == NULL)
9765d262 360 goto out_err;
1da177e4 361
1da177e4 362 tfm->__crt_alg = alg;
6bfd4809 363
27d2a330 364 err = crypto_init_ops(tfm, type, mask);
6bfd4809 365 if (err)
1da177e4 366 goto out_free_tfm;
c7fc0599 367
4a779486 368 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
c7fc0599 369 goto cra_init_failed;
1da177e4
LT
370
371 goto out;
372
c7fc0599
HX
373cra_init_failed:
374 crypto_exit_ops(tfm);
1da177e4 375out_free_tfm:
4a779486
HX
376 if (err == -EAGAIN)
377 crypto_shoot_alg(alg);
1da177e4 378 kfree(tfm);
9765d262 379out_err:
6bfd4809 380 tfm = ERR_PTR(err);
1da177e4
LT
381out:
382 return tfm;
383}
6bfd4809
HX
384EXPORT_SYMBOL_GPL(__crypto_alloc_tfm);
385
6d7d684d
HX
386/*
387 * crypto_alloc_base - Locate algorithm and allocate transform
388 * @alg_name: Name of algorithm
389 * @type: Type of algorithm
390 * @mask: Mask for type comparison
391 *
7b0bac64 392 * This function should not be used by new algorithm types.
fd1a1900 393 * Please use crypto_alloc_tfm instead.
7b0bac64 394 *
6d7d684d
HX
395 * crypto_alloc_base() will first attempt to locate an already loaded
396 * algorithm. If that fails and the kernel supports dynamically loadable
397 * modules, it will then attempt to load a module of the same name or
398 * alias. If that fails it will send a query to any loaded crypto manager
399 * to construct an algorithm on the fly. A refcount is grabbed on the
400 * algorithm which is then associated with the new transform.
401 *
402 * The returned transform is of a non-determinate type. Most people
403 * should use one of the more specific allocation functions such as
404 * crypto_alloc_blkcipher.
405 *
406 * In case of error the return value is an error pointer.
407 */
408struct crypto_tfm *crypto_alloc_base(const char *alg_name, u32 type, u32 mask)
409{
410 struct crypto_tfm *tfm;
411 int err;
412
413 for (;;) {
414 struct crypto_alg *alg;
415
416 alg = crypto_alg_mod_lookup(alg_name, type, mask);
9765d262
AM
417 if (IS_ERR(alg)) {
418 err = PTR_ERR(alg);
6d7d684d 419 goto err;
9765d262 420 }
6d7d684d 421
27d2a330 422 tfm = __crypto_alloc_tfm(alg, type, mask);
6d7d684d 423 if (!IS_ERR(tfm))
9765d262 424 return tfm;
6d7d684d
HX
425
426 crypto_mod_put(alg);
427 err = PTR_ERR(tfm);
428
429err:
430 if (err != -EAGAIN)
431 break;
3fc89adb 432 if (fatal_signal_pending(current)) {
6d7d684d
HX
433 err = -EINTR;
434 break;
435 }
9765d262 436 }
6d7d684d 437
9765d262 438 return ERR_PTR(err);
6d7d684d
HX
439}
440EXPORT_SYMBOL_GPL(crypto_alloc_base);
7b0bac64 441
3f683d61
HX
442void *crypto_create_tfm(struct crypto_alg *alg,
443 const struct crypto_type *frontend)
7b0bac64
HX
444{
445 char *mem;
446 struct crypto_tfm *tfm = NULL;
447 unsigned int tfmsize;
448 unsigned int total;
449 int err = -ENOMEM;
450
451 tfmsize = frontend->tfmsize;
2ca33da1 452 total = tfmsize + sizeof(*tfm) + frontend->extsize(alg);
7b0bac64
HX
453
454 mem = kzalloc(total, GFP_KERNEL);
455 if (mem == NULL)
456 goto out_err;
457
458 tfm = (struct crypto_tfm *)(mem + tfmsize);
459 tfm->__crt_alg = alg;
460
2ca33da1 461 err = frontend->init_tfm(tfm);
7b0bac64
HX
462 if (err)
463 goto out_free_tfm;
464
465 if (!tfm->exit && alg->cra_init && (err = alg->cra_init(tfm)))
466 goto cra_init_failed;
467
468 goto out;
469
470cra_init_failed:
471 crypto_exit_ops(tfm);
472out_free_tfm:
473 if (err == -EAGAIN)
474 crypto_shoot_alg(alg);
475 kfree(mem);
476out_err:
3f683d61 477 mem = ERR_PTR(err);
7b0bac64 478out:
3f683d61 479 return mem;
7b0bac64
HX
480}
481EXPORT_SYMBOL_GPL(crypto_create_tfm);
482
d06854f0
HX
483struct crypto_alg *crypto_find_alg(const char *alg_name,
484 const struct crypto_type *frontend,
485 u32 type, u32 mask)
486{
487 struct crypto_alg *(*lookup)(const char *name, u32 type, u32 mask) =
488 crypto_alg_mod_lookup;
489
490 if (frontend) {
491 type &= frontend->maskclear;
492 mask &= frontend->maskclear;
493 type |= frontend->type;
494 mask |= frontend->maskset;
495
496 if (frontend->lookup)
497 lookup = frontend->lookup;
498 }
499
500 return lookup(alg_name, type, mask);
501}
502EXPORT_SYMBOL_GPL(crypto_find_alg);
503
7b0bac64
HX
504/*
505 * crypto_alloc_tfm - Locate algorithm and allocate transform
506 * @alg_name: Name of algorithm
507 * @frontend: Frontend algorithm type
508 * @type: Type of algorithm
509 * @mask: Mask for type comparison
510 *
511 * crypto_alloc_tfm() will first attempt to locate an already loaded
512 * algorithm. If that fails and the kernel supports dynamically loadable
513 * modules, it will then attempt to load a module of the same name or
514 * alias. If that fails it will send a query to any loaded crypto manager
515 * to construct an algorithm on the fly. A refcount is grabbed on the
516 * algorithm which is then associated with the new transform.
517 *
518 * The returned transform is of a non-determinate type. Most people
519 * should use one of the more specific allocation functions such as
520 * crypto_alloc_blkcipher.
521 *
522 * In case of error the return value is an error pointer.
523 */
3f683d61
HX
524void *crypto_alloc_tfm(const char *alg_name,
525 const struct crypto_type *frontend, u32 type, u32 mask)
7b0bac64 526{
3f683d61 527 void *tfm;
7b0bac64
HX
528 int err;
529
7b0bac64
HX
530 for (;;) {
531 struct crypto_alg *alg;
532
d06854f0 533 alg = crypto_find_alg(alg_name, frontend, type, mask);
7b0bac64
HX
534 if (IS_ERR(alg)) {
535 err = PTR_ERR(alg);
536 goto err;
537 }
538
539 tfm = crypto_create_tfm(alg, frontend);
540 if (!IS_ERR(tfm))
541 return tfm;
542
543 crypto_mod_put(alg);
544 err = PTR_ERR(tfm);
545
546err:
547 if (err != -EAGAIN)
548 break;
3fc89adb 549 if (fatal_signal_pending(current)) {
7b0bac64
HX
550 err = -EINTR;
551 break;
552 }
553 }
554
555 return ERR_PTR(err);
556}
557EXPORT_SYMBOL_GPL(crypto_alloc_tfm);
7b2cd92a 558
6d7d684d 559/*
7b2cd92a
HX
560 * crypto_destroy_tfm - Free crypto transform
561 * @mem: Start of tfm slab
6d7d684d
HX
562 * @tfm: Transform to free
563 *
7b2cd92a 564 * This function frees up the transform and any associated resources,
6d7d684d
HX
565 * then drops the refcount on the associated algorithm.
566 */
7b2cd92a 567void crypto_destroy_tfm(void *mem, struct crypto_tfm *tfm)
1da177e4 568{
a61cc448 569 struct crypto_alg *alg;
a61cc448 570
7b2cd92a 571 if (unlikely(!mem))
a61cc448
JJ
572 return;
573
574 alg = tfm->__crt_alg;
1da177e4 575
4a779486 576 if (!tfm->exit && alg->cra_exit)
c7fc0599 577 alg->cra_exit(tfm);
1da177e4 578 crypto_exit_ops(tfm);
72fa4919 579 crypto_mod_put(alg);
811d8f06 580 kzfree(mem);
1da177e4 581}
7b2cd92a 582EXPORT_SYMBOL_GPL(crypto_destroy_tfm);
fce32d70
HX
583
584int crypto_has_alg(const char *name, u32 type, u32 mask)
585{
586 int ret = 0;
587 struct crypto_alg *alg = crypto_alg_mod_lookup(name, type, mask);
3d01a33b 588
fce32d70
HX
589 if (!IS_ERR(alg)) {
590 crypto_mod_put(alg);
591 ret = 1;
592 }
3d01a33b 593
fce32d70
HX
594 return ret;
595}
596EXPORT_SYMBOL_GPL(crypto_has_alg);
c3715cb9
SS
597
598MODULE_DESCRIPTION("Cryptographic core API");
599MODULE_LICENSE("GPL");