1 /*
2 * Cryptographic API for algorithms (i.e., low-level API).
3 *
4 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
5 *
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
9 * any later version.
10 *
11 */
12
13 #include <crypto/algapi.h>
14 #include <linux/err.h>
15 #include <linux/errno.h>
16 #include <linux/fips.h>
17 #include <linux/init.h>
18 #include <linux/kernel.h>
19 #include <linux/list.h>
20 #include <linux/module.h>
21 #include <linux/rtnetlink.h>
22 #include <linux/slab.h>
23 #include <linux/string.h>
24
25 #include "internal.h"
26
27 static LIST_HEAD(crypto_template_list);
28
crypto_set_driver_name(struct crypto_alg * alg)29 static inline int crypto_set_driver_name(struct crypto_alg *alg)
30 {
31 static const char suffix[] = "-generic";
32 char *driver_name = alg->cra_driver_name;
33 int len;
34
35 if (*driver_name)
36 return 0;
37
38 len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);
39 if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)
40 return -ENAMETOOLONG;
41
42 memcpy(driver_name + len, suffix, sizeof(suffix));
43 return 0;
44 }
45
crypto_check_module_sig(struct module * mod)46 static inline void crypto_check_module_sig(struct module *mod)
47 {
48 if (fips_enabled && mod && !module_sig_ok(mod))
49 panic("Module %s signature verification failed in FIPS mode\n",
50 module_name(mod));
51 }
52
crypto_check_alg(struct crypto_alg * alg)53 static int crypto_check_alg(struct crypto_alg *alg)
54 {
55 crypto_check_module_sig(alg->cra_module);
56
57 if (alg->cra_alignmask & (alg->cra_alignmask + 1))
58 return -EINVAL;
59
60 if (alg->cra_blocksize > PAGE_SIZE / 8)
61 return -EINVAL;
62
63 if (!alg->cra_type && (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==
64 CRYPTO_ALG_TYPE_CIPHER) {
65 if (alg->cra_alignmask > MAX_CIPHER_ALIGNMASK)
66 return -EINVAL;
67
68 if (alg->cra_blocksize > MAX_CIPHER_BLOCKSIZE)
69 return -EINVAL;
70 }
71
72 if (alg->cra_priority < 0)
73 return -EINVAL;
74
75 refcount_set(&alg->cra_refcnt, 1);
76
77 return crypto_set_driver_name(alg);
78 }
79
crypto_free_instance(struct crypto_instance * inst)80 static void crypto_free_instance(struct crypto_instance *inst)
81 {
82 if (!inst->alg.cra_type->free) {
83 inst->tmpl->free(inst);
84 return;
85 }
86
87 inst->alg.cra_type->free(inst);
88 }
89
crypto_destroy_instance(struct crypto_alg * alg)90 static void crypto_destroy_instance(struct crypto_alg *alg)
91 {
92 struct crypto_instance *inst = (void *)alg;
93 struct crypto_template *tmpl = inst->tmpl;
94
95 crypto_free_instance(inst);
96 crypto_tmpl_put(tmpl);
97 }
98
crypto_more_spawns(struct crypto_alg * alg,struct list_head * stack,struct list_head * top,struct list_head * secondary_spawns)99 static struct list_head *crypto_more_spawns(struct crypto_alg *alg,
100 struct list_head *stack,
101 struct list_head *top,
102 struct list_head *secondary_spawns)
103 {
104 struct crypto_spawn *spawn, *n;
105
106 spawn = list_first_entry_or_null(stack, struct crypto_spawn, list);
107 if (!spawn)
108 return NULL;
109
110 n = list_next_entry(spawn, list);
111
112 if (spawn->alg && &n->list != stack && !n->alg)
113 n->alg = (n->list.next == stack) ? alg :
114 &list_next_entry(n, list)->inst->alg;
115
116 list_move(&spawn->list, secondary_spawns);
117
118 return &n->list == stack ? top : &n->inst->alg.cra_users;
119 }
120
crypto_remove_instance(struct crypto_instance * inst,struct list_head * list)121 static void crypto_remove_instance(struct crypto_instance *inst,
122 struct list_head *list)
123 {
124 struct crypto_template *tmpl = inst->tmpl;
125
126 if (crypto_is_dead(&inst->alg))
127 return;
128
129 inst->alg.cra_flags |= CRYPTO_ALG_DEAD;
130 if (hlist_unhashed(&inst->list))
131 return;
132
133 if (!tmpl || !crypto_tmpl_get(tmpl))
134 return;
135
136 list_move(&inst->alg.cra_list, list);
137 hlist_del(&inst->list);
138 inst->alg.cra_destroy = crypto_destroy_instance;
139
140 BUG_ON(!list_empty(&inst->alg.cra_users));
141 }
142
crypto_remove_spawns(struct crypto_alg * alg,struct list_head * list,struct crypto_alg * nalg)143 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,
144 struct crypto_alg *nalg)
145 {
146 u32 new_type = (nalg ?: alg)->cra_flags;
147 struct crypto_spawn *spawn, *n;
148 LIST_HEAD(secondary_spawns);
149 struct list_head *spawns;
150 LIST_HEAD(stack);
151 LIST_HEAD(top);
152
153 spawns = &alg->cra_users;
154 list_for_each_entry_safe(spawn, n, spawns, list) {
155 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)
156 continue;
157
158 list_move(&spawn->list, &top);
159 }
160
161 spawns = ⊤
162 do {
163 while (!list_empty(spawns)) {
164 struct crypto_instance *inst;
165
166 spawn = list_first_entry(spawns, struct crypto_spawn,
167 list);
168 inst = spawn->inst;
169
170 BUG_ON(&inst->alg == alg);
171
172 list_move(&spawn->list, &stack);
173
174 if (&inst->alg == nalg)
175 break;
176
177 spawn->alg = NULL;
178 spawns = &inst->alg.cra_users;
179
180 /*
181 * We may encounter an unregistered instance here, since
182 * an instance's spawns are set up prior to the instance
183 * being registered. An unregistered instance will have
184 * NULL ->cra_users.next, since ->cra_users isn't
185 * properly initialized until registration. But an
186 * unregistered instance cannot have any users, so treat
187 * it the same as ->cra_users being empty.
188 */
189 if (spawns->next == NULL)
190 break;
191 }
192 } while ((spawns = crypto_more_spawns(alg, &stack, &top,
193 &secondary_spawns)));
194
195 list_for_each_entry_safe(spawn, n, &secondary_spawns, list) {
196 if (spawn->alg)
197 list_move(&spawn->list, &spawn->alg->cra_users);
198 else
199 crypto_remove_instance(spawn->inst, list);
200 }
201 }
202 EXPORT_SYMBOL_GPL(crypto_remove_spawns);
203
__crypto_register_alg(struct crypto_alg * alg)204 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg)
205 {
206 struct crypto_alg *q;
207 struct crypto_larval *larval;
208 int ret = -EAGAIN;
209
210 if (crypto_is_dead(alg))
211 goto err;
212
213 INIT_LIST_HEAD(&alg->cra_users);
214
215 /* No cheating! */
216 alg->cra_flags &= ~CRYPTO_ALG_TESTED;
217
218 ret = -EEXIST;
219
220 list_for_each_entry(q, &crypto_alg_list, cra_list) {
221 if (q == alg)
222 goto err;
223
224 if (crypto_is_moribund(q))
225 continue;
226
227 if (crypto_is_larval(q)) {
228 if (!strcmp(alg->cra_driver_name, q->cra_driver_name))
229 goto err;
230 continue;
231 }
232
233 if (!strcmp(q->cra_driver_name, alg->cra_name) ||
234 !strcmp(q->cra_name, alg->cra_driver_name))
235 goto err;
236 }
237
238 larval = crypto_larval_alloc(alg->cra_name,
239 alg->cra_flags | CRYPTO_ALG_TESTED, 0);
240 if (IS_ERR(larval))
241 goto out;
242
243 ret = -ENOENT;
244 larval->adult = crypto_mod_get(alg);
245 if (!larval->adult)
246 goto free_larval;
247
248 refcount_set(&larval->alg.cra_refcnt, 1);
249 memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,
250 CRYPTO_MAX_ALG_NAME);
251 larval->alg.cra_priority = alg->cra_priority;
252
253 list_add(&alg->cra_list, &crypto_alg_list);
254 list_add(&larval->alg.cra_list, &crypto_alg_list);
255
256 out:
257 return larval;
258
259 free_larval:
260 kfree(larval);
261 err:
262 larval = ERR_PTR(ret);
263 goto out;
264 }
265
crypto_alg_tested(const char * name,int err)266 void crypto_alg_tested(const char *name, int err)
267 {
268 struct crypto_larval *test;
269 struct crypto_alg *alg;
270 struct crypto_alg *q;
271 LIST_HEAD(list);
272
273 down_write(&crypto_alg_sem);
274 list_for_each_entry(q, &crypto_alg_list, cra_list) {
275 if (crypto_is_moribund(q) || !crypto_is_larval(q))
276 continue;
277
278 test = (struct crypto_larval *)q;
279
280 if (!strcmp(q->cra_driver_name, name))
281 goto found;
282 }
283
284 pr_err("alg: Unexpected test result for %s: %d\n", name, err);
285 goto unlock;
286
287 found:
288 q->cra_flags |= CRYPTO_ALG_DEAD;
289 alg = test->adult;
290 if (err || list_empty(&alg->cra_list))
291 goto complete;
292
293 alg->cra_flags |= CRYPTO_ALG_TESTED;
294
295 list_for_each_entry(q, &crypto_alg_list, cra_list) {
296 if (q == alg)
297 continue;
298
299 if (crypto_is_moribund(q))
300 continue;
301
302 if (crypto_is_larval(q)) {
303 struct crypto_larval *larval = (void *)q;
304
305 /*
306 * Check to see if either our generic name or
307 * specific name can satisfy the name requested
308 * by the larval entry q.
309 */
310 if (strcmp(alg->cra_name, q->cra_name) &&
311 strcmp(alg->cra_driver_name, q->cra_name))
312 continue;
313
314 if (larval->adult)
315 continue;
316 if ((q->cra_flags ^ alg->cra_flags) & larval->mask)
317 continue;
318 if (!crypto_mod_get(alg))
319 continue;
320
321 larval->adult = alg;
322 continue;
323 }
324
325 if (strcmp(alg->cra_name, q->cra_name))
326 continue;
327
328 if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&
329 q->cra_priority > alg->cra_priority)
330 continue;
331
332 crypto_remove_spawns(q, &list, alg);
333 }
334
335 complete:
336 complete_all(&test->completion);
337
338 unlock:
339 up_write(&crypto_alg_sem);
340
341 crypto_remove_final(&list);
342 }
343 EXPORT_SYMBOL_GPL(crypto_alg_tested);
344
crypto_remove_final(struct list_head * list)345 void crypto_remove_final(struct list_head *list)
346 {
347 struct crypto_alg *alg;
348 struct crypto_alg *n;
349
350 list_for_each_entry_safe(alg, n, list, cra_list) {
351 list_del_init(&alg->cra_list);
352 crypto_alg_put(alg);
353 }
354 }
355 EXPORT_SYMBOL_GPL(crypto_remove_final);
356
crypto_wait_for_test(struct crypto_larval * larval)357 static void crypto_wait_for_test(struct crypto_larval *larval)
358 {
359 int err;
360
361 err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);
362 if (err != NOTIFY_STOP) {
363 if (WARN_ON(err != NOTIFY_DONE))
364 goto out;
365 crypto_alg_tested(larval->alg.cra_driver_name, 0);
366 }
367
368 err = wait_for_completion_killable(&larval->completion);
369 WARN_ON(err);
370
371 out:
372 crypto_larval_kill(&larval->alg);
373 }
374
crypto_register_alg(struct crypto_alg * alg)375 int crypto_register_alg(struct crypto_alg *alg)
376 {
377 struct crypto_larval *larval;
378 int err;
379
380 alg->cra_flags &= ~CRYPTO_ALG_DEAD;
381 err = crypto_check_alg(alg);
382 if (err)
383 return err;
384
385 down_write(&crypto_alg_sem);
386 larval = __crypto_register_alg(alg);
387 up_write(&crypto_alg_sem);
388
389 if (IS_ERR(larval))
390 return PTR_ERR(larval);
391
392 crypto_wait_for_test(larval);
393 return 0;
394 }
395 EXPORT_SYMBOL_GPL(crypto_register_alg);
396
crypto_remove_alg(struct crypto_alg * alg,struct list_head * list)397 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)
398 {
399 if (unlikely(list_empty(&alg->cra_list)))
400 return -ENOENT;
401
402 alg->cra_flags |= CRYPTO_ALG_DEAD;
403
404 list_del_init(&alg->cra_list);
405 crypto_remove_spawns(alg, list, NULL);
406
407 return 0;
408 }
409
crypto_unregister_alg(struct crypto_alg * alg)410 int crypto_unregister_alg(struct crypto_alg *alg)
411 {
412 int ret;
413 LIST_HEAD(list);
414
415 down_write(&crypto_alg_sem);
416 ret = crypto_remove_alg(alg, &list);
417 up_write(&crypto_alg_sem);
418
419 if (ret)
420 return ret;
421
422 BUG_ON(refcount_read(&alg->cra_refcnt) != 1);
423 if (alg->cra_destroy)
424 alg->cra_destroy(alg);
425
426 crypto_remove_final(&list);
427 return 0;
428 }
429 EXPORT_SYMBOL_GPL(crypto_unregister_alg);
430
crypto_register_algs(struct crypto_alg * algs,int count)431 int crypto_register_algs(struct crypto_alg *algs, int count)
432 {
433 int i, ret;
434
435 for (i = 0; i < count; i++) {
436 ret = crypto_register_alg(&algs[i]);
437 if (ret)
438 goto err;
439 }
440
441 return 0;
442
443 err:
444 for (--i; i >= 0; --i)
445 crypto_unregister_alg(&algs[i]);
446
447 return ret;
448 }
449 EXPORT_SYMBOL_GPL(crypto_register_algs);
450
crypto_unregister_algs(struct crypto_alg * algs,int count)451 int crypto_unregister_algs(struct crypto_alg *algs, int count)
452 {
453 int i, ret;
454
455 for (i = 0; i < count; i++) {
456 ret = crypto_unregister_alg(&algs[i]);
457 if (ret)
458 pr_err("Failed to unregister %s %s: %d\n",
459 algs[i].cra_driver_name, algs[i].cra_name, ret);
460 }
461
462 return 0;
463 }
464 EXPORT_SYMBOL_GPL(crypto_unregister_algs);
465
crypto_register_template(struct crypto_template * tmpl)466 int crypto_register_template(struct crypto_template *tmpl)
467 {
468 struct crypto_template *q;
469 int err = -EEXIST;
470
471 down_write(&crypto_alg_sem);
472
473 crypto_check_module_sig(tmpl->module);
474
475 list_for_each_entry(q, &crypto_template_list, list) {
476 if (q == tmpl)
477 goto out;
478 }
479
480 list_add(&tmpl->list, &crypto_template_list);
481 err = 0;
482 out:
483 up_write(&crypto_alg_sem);
484 return err;
485 }
486 EXPORT_SYMBOL_GPL(crypto_register_template);
487
crypto_unregister_template(struct crypto_template * tmpl)488 void crypto_unregister_template(struct crypto_template *tmpl)
489 {
490 struct crypto_instance *inst;
491 struct hlist_node *n;
492 struct hlist_head *list;
493 LIST_HEAD(users);
494
495 down_write(&crypto_alg_sem);
496
497 BUG_ON(list_empty(&tmpl->list));
498 list_del_init(&tmpl->list);
499
500 list = &tmpl->instances;
501 hlist_for_each_entry(inst, list, list) {
502 int err = crypto_remove_alg(&inst->alg, &users);
503
504 BUG_ON(err);
505 }
506
507 up_write(&crypto_alg_sem);
508
509 hlist_for_each_entry_safe(inst, n, list, list) {
510 BUG_ON(refcount_read(&inst->alg.cra_refcnt) != 1);
511 crypto_free_instance(inst);
512 }
513 crypto_remove_final(&users);
514 }
515 EXPORT_SYMBOL_GPL(crypto_unregister_template);
516
__crypto_lookup_template(const char * name)517 static struct crypto_template *__crypto_lookup_template(const char *name)
518 {
519 struct crypto_template *q, *tmpl = NULL;
520
521 down_read(&crypto_alg_sem);
522 list_for_each_entry(q, &crypto_template_list, list) {
523 if (strcmp(q->name, name))
524 continue;
525 if (unlikely(!crypto_tmpl_get(q)))
526 continue;
527
528 tmpl = q;
529 break;
530 }
531 up_read(&crypto_alg_sem);
532
533 return tmpl;
534 }
535
crypto_lookup_template(const char * name)536 struct crypto_template *crypto_lookup_template(const char *name)
537 {
538 return try_then_request_module(__crypto_lookup_template(name),
539 "crypto-%s", name);
540 }
541 EXPORT_SYMBOL_GPL(crypto_lookup_template);
542
crypto_register_instance(struct crypto_template * tmpl,struct crypto_instance * inst)543 int crypto_register_instance(struct crypto_template *tmpl,
544 struct crypto_instance *inst)
545 {
546 struct crypto_larval *larval;
547 int err;
548
549 err = crypto_check_alg(&inst->alg);
550 if (err)
551 return err;
552
553 inst->alg.cra_module = tmpl->module;
554 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;
555
556 down_write(&crypto_alg_sem);
557
558 larval = __crypto_register_alg(&inst->alg);
559 if (IS_ERR(larval))
560 goto unlock;
561
562 hlist_add_head(&inst->list, &tmpl->instances);
563 inst->tmpl = tmpl;
564
565 unlock:
566 up_write(&crypto_alg_sem);
567
568 err = PTR_ERR(larval);
569 if (IS_ERR(larval))
570 goto err;
571
572 crypto_wait_for_test(larval);
573 err = 0;
574
575 err:
576 return err;
577 }
578 EXPORT_SYMBOL_GPL(crypto_register_instance);
579
crypto_unregister_instance(struct crypto_instance * inst)580 int crypto_unregister_instance(struct crypto_instance *inst)
581 {
582 LIST_HEAD(list);
583
584 down_write(&crypto_alg_sem);
585
586 crypto_remove_spawns(&inst->alg, &list, NULL);
587 crypto_remove_instance(inst, &list);
588
589 up_write(&crypto_alg_sem);
590
591 crypto_remove_final(&list);
592
593 return 0;
594 }
595 EXPORT_SYMBOL_GPL(crypto_unregister_instance);
596
crypto_init_spawn(struct crypto_spawn * spawn,struct crypto_alg * alg,struct crypto_instance * inst,u32 mask)597 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,
598 struct crypto_instance *inst, u32 mask)
599 {
600 int err = -EAGAIN;
601
602 spawn->inst = inst;
603 spawn->mask = mask;
604
605 down_write(&crypto_alg_sem);
606 if (!crypto_is_moribund(alg)) {
607 list_add(&spawn->list, &alg->cra_users);
608 spawn->alg = alg;
609 err = 0;
610 }
611 up_write(&crypto_alg_sem);
612
613 return err;
614 }
615 EXPORT_SYMBOL_GPL(crypto_init_spawn);
616
crypto_init_spawn2(struct crypto_spawn * spawn,struct crypto_alg * alg,struct crypto_instance * inst,const struct crypto_type * frontend)617 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg,
618 struct crypto_instance *inst,
619 const struct crypto_type *frontend)
620 {
621 int err = -EINVAL;
622
623 if ((alg->cra_flags ^ frontend->type) & frontend->maskset)
624 goto out;
625
626 spawn->frontend = frontend;
627 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset);
628
629 out:
630 return err;
631 }
632 EXPORT_SYMBOL_GPL(crypto_init_spawn2);
633
crypto_grab_spawn(struct crypto_spawn * spawn,const char * name,u32 type,u32 mask)634 int crypto_grab_spawn(struct crypto_spawn *spawn, const char *name,
635 u32 type, u32 mask)
636 {
637 struct crypto_alg *alg;
638 int err;
639
640 alg = crypto_find_alg(name, spawn->frontend, type, mask);
641 if (IS_ERR(alg))
642 return PTR_ERR(alg);
643
644 err = crypto_init_spawn(spawn, alg, spawn->inst, mask);
645 crypto_mod_put(alg);
646 return err;
647 }
648 EXPORT_SYMBOL_GPL(crypto_grab_spawn);
649
crypto_drop_spawn(struct crypto_spawn * spawn)650 void crypto_drop_spawn(struct crypto_spawn *spawn)
651 {
652 down_write(&crypto_alg_sem);
653 if (spawn->alg)
654 list_del(&spawn->list);
655 up_write(&crypto_alg_sem);
656 }
657 EXPORT_SYMBOL_GPL(crypto_drop_spawn);
658
crypto_spawn_alg(struct crypto_spawn * spawn)659 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn)
660 {
661 struct crypto_alg *alg;
662
663 down_read(&crypto_alg_sem);
664 alg = spawn->alg;
665 if (alg && !crypto_mod_get(alg)) {
666 alg->cra_flags |= CRYPTO_ALG_DYING;
667 alg = NULL;
668 }
669 up_read(&crypto_alg_sem);
670
671 return alg ?: ERR_PTR(-EAGAIN);
672 }
673
crypto_spawn_tfm(struct crypto_spawn * spawn,u32 type,u32 mask)674 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,
675 u32 mask)
676 {
677 struct crypto_alg *alg;
678 struct crypto_tfm *tfm;
679
680 alg = crypto_spawn_alg(spawn);
681 if (IS_ERR(alg))
682 return ERR_CAST(alg);
683
684 tfm = ERR_PTR(-EINVAL);
685 if (unlikely((alg->cra_flags ^ type) & mask))
686 goto out_put_alg;
687
688 tfm = __crypto_alloc_tfm(alg, type, mask);
689 if (IS_ERR(tfm))
690 goto out_put_alg;
691
692 return tfm;
693
694 out_put_alg:
695 crypto_mod_put(alg);
696 return tfm;
697 }
698 EXPORT_SYMBOL_GPL(crypto_spawn_tfm);
699
crypto_spawn_tfm2(struct crypto_spawn * spawn)700 void *crypto_spawn_tfm2(struct crypto_spawn *spawn)
701 {
702 struct crypto_alg *alg;
703 struct crypto_tfm *tfm;
704
705 alg = crypto_spawn_alg(spawn);
706 if (IS_ERR(alg))
707 return ERR_CAST(alg);
708
709 tfm = crypto_create_tfm(alg, spawn->frontend);
710 if (IS_ERR(tfm))
711 goto out_put_alg;
712
713 return tfm;
714
715 out_put_alg:
716 crypto_mod_put(alg);
717 return tfm;
718 }
719 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2);
720
crypto_register_notifier(struct notifier_block * nb)721 int crypto_register_notifier(struct notifier_block *nb)
722 {
723 return blocking_notifier_chain_register(&crypto_chain, nb);
724 }
725 EXPORT_SYMBOL_GPL(crypto_register_notifier);
726
crypto_unregister_notifier(struct notifier_block * nb)727 int crypto_unregister_notifier(struct notifier_block *nb)
728 {
729 return blocking_notifier_chain_unregister(&crypto_chain, nb);
730 }
731 EXPORT_SYMBOL_GPL(crypto_unregister_notifier);
732
crypto_get_attr_type(struct rtattr ** tb)733 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb)
734 {
735 struct rtattr *rta = tb[0];
736 struct crypto_attr_type *algt;
737
738 if (!rta)
739 return ERR_PTR(-ENOENT);
740 if (RTA_PAYLOAD(rta) < sizeof(*algt))
741 return ERR_PTR(-EINVAL);
742 if (rta->rta_type != CRYPTOA_TYPE)
743 return ERR_PTR(-EINVAL);
744
745 algt = RTA_DATA(rta);
746
747 return algt;
748 }
749 EXPORT_SYMBOL_GPL(crypto_get_attr_type);
750
crypto_check_attr_type(struct rtattr ** tb,u32 type)751 int crypto_check_attr_type(struct rtattr **tb, u32 type)
752 {
753 struct crypto_attr_type *algt;
754
755 algt = crypto_get_attr_type(tb);
756 if (IS_ERR(algt))
757 return PTR_ERR(algt);
758
759 if ((algt->type ^ type) & algt->mask)
760 return -EINVAL;
761
762 return 0;
763 }
764 EXPORT_SYMBOL_GPL(crypto_check_attr_type);
765
crypto_attr_alg_name(struct rtattr * rta)766 const char *crypto_attr_alg_name(struct rtattr *rta)
767 {
768 struct crypto_attr_alg *alga;
769
770 if (!rta)
771 return ERR_PTR(-ENOENT);
772 if (RTA_PAYLOAD(rta) < sizeof(*alga))
773 return ERR_PTR(-EINVAL);
774 if (rta->rta_type != CRYPTOA_ALG)
775 return ERR_PTR(-EINVAL);
776
777 alga = RTA_DATA(rta);
778 alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;
779
780 return alga->name;
781 }
782 EXPORT_SYMBOL_GPL(crypto_attr_alg_name);
783
crypto_attr_alg2(struct rtattr * rta,const struct crypto_type * frontend,u32 type,u32 mask)784 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta,
785 const struct crypto_type *frontend,
786 u32 type, u32 mask)
787 {
788 const char *name;
789
790 name = crypto_attr_alg_name(rta);
791 if (IS_ERR(name))
792 return ERR_CAST(name);
793
794 return crypto_find_alg(name, frontend, type, mask);
795 }
796 EXPORT_SYMBOL_GPL(crypto_attr_alg2);
797
crypto_attr_u32(struct rtattr * rta,u32 * num)798 int crypto_attr_u32(struct rtattr *rta, u32 *num)
799 {
800 struct crypto_attr_u32 *nu32;
801
802 if (!rta)
803 return -ENOENT;
804 if (RTA_PAYLOAD(rta) < sizeof(*nu32))
805 return -EINVAL;
806 if (rta->rta_type != CRYPTOA_U32)
807 return -EINVAL;
808
809 nu32 = RTA_DATA(rta);
810 *num = nu32->num;
811
812 return 0;
813 }
814 EXPORT_SYMBOL_GPL(crypto_attr_u32);
815
crypto_inst_setname(struct crypto_instance * inst,const char * name,struct crypto_alg * alg)816 int crypto_inst_setname(struct crypto_instance *inst, const char *name,
817 struct crypto_alg *alg)
818 {
819 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,
820 alg->cra_name) >= CRYPTO_MAX_ALG_NAME)
821 return -ENAMETOOLONG;
822
823 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",
824 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)
825 return -ENAMETOOLONG;
826
827 return 0;
828 }
829 EXPORT_SYMBOL_GPL(crypto_inst_setname);
830
crypto_alloc_instance2(const char * name,struct crypto_alg * alg,unsigned int head)831 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg,
832 unsigned int head)
833 {
834 struct crypto_instance *inst;
835 char *p;
836 int err;
837
838 p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn),
839 GFP_KERNEL);
840 if (!p)
841 return ERR_PTR(-ENOMEM);
842
843 inst = (void *)(p + head);
844
845 err = crypto_inst_setname(inst, name, alg);
846 if (err)
847 goto err_free_inst;
848
849 return p;
850
851 err_free_inst:
852 kfree(p);
853 return ERR_PTR(err);
854 }
855 EXPORT_SYMBOL_GPL(crypto_alloc_instance2);
856
crypto_alloc_instance(const char * name,struct crypto_alg * alg)857 struct crypto_instance *crypto_alloc_instance(const char *name,
858 struct crypto_alg *alg)
859 {
860 struct crypto_instance *inst;
861 struct crypto_spawn *spawn;
862 int err;
863
864 inst = crypto_alloc_instance2(name, alg, 0);
865 if (IS_ERR(inst))
866 goto out;
867
868 spawn = crypto_instance_ctx(inst);
869 err = crypto_init_spawn(spawn, alg, inst,
870 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC);
871
872 if (err)
873 goto err_free_inst;
874
875 return inst;
876
877 err_free_inst:
878 kfree(inst);
879 inst = ERR_PTR(err);
880
881 out:
882 return inst;
883 }
884 EXPORT_SYMBOL_GPL(crypto_alloc_instance);
885
crypto_init_queue(struct crypto_queue * queue,unsigned int max_qlen)886 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
887 {
888 INIT_LIST_HEAD(&queue->list);
889 queue->backlog = &queue->list;
890 queue->qlen = 0;
891 queue->max_qlen = max_qlen;
892 }
893 EXPORT_SYMBOL_GPL(crypto_init_queue);
894
crypto_enqueue_request(struct crypto_queue * queue,struct crypto_async_request * request)895 int crypto_enqueue_request(struct crypto_queue *queue,
896 struct crypto_async_request *request)
897 {
898 int err = -EINPROGRESS;
899
900 if (unlikely(queue->qlen >= queue->max_qlen)) {
901 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) {
902 err = -ENOSPC;
903 goto out;
904 }
905 err = -EBUSY;
906 if (queue->backlog == &queue->list)
907 queue->backlog = &request->list;
908 }
909
910 queue->qlen++;
911 list_add_tail(&request->list, &queue->list);
912
913 out:
914 return err;
915 }
916 EXPORT_SYMBOL_GPL(crypto_enqueue_request);
917
crypto_dequeue_request(struct crypto_queue * queue)918 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue)
919 {
920 struct list_head *request;
921
922 if (unlikely(!queue->qlen))
923 return NULL;
924
925 queue->qlen--;
926
927 if (queue->backlog != &queue->list)
928 queue->backlog = queue->backlog->next;
929
930 request = queue->list.next;
931 list_del(request);
932
933 return list_entry(request, struct crypto_async_request, list);
934 }
935 EXPORT_SYMBOL_GPL(crypto_dequeue_request);
936
crypto_tfm_in_queue(struct crypto_queue * queue,struct crypto_tfm * tfm)937 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm)
938 {
939 struct crypto_async_request *req;
940
941 list_for_each_entry(req, &queue->list, list) {
942 if (req->tfm == tfm)
943 return 1;
944 }
945
946 return 0;
947 }
948 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);
949
crypto_inc_byte(u8 * a,unsigned int size)950 static inline void crypto_inc_byte(u8 *a, unsigned int size)
951 {
952 u8 *b = (a + size);
953 u8 c;
954
955 for (; size; size--) {
956 c = *--b + 1;
957 *b = c;
958 if (c)
959 break;
960 }
961 }
962
crypto_inc(u8 * a,unsigned int size)963 void crypto_inc(u8 *a, unsigned int size)
964 {
965 __be32 *b = (__be32 *)(a + size);
966 u32 c;
967
968 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
969 IS_ALIGNED((unsigned long)b, __alignof__(*b)))
970 for (; size >= 4; size -= 4) {
971 c = be32_to_cpu(*--b) + 1;
972 *b = cpu_to_be32(c);
973 if (likely(c))
974 return;
975 }
976
977 crypto_inc_byte(a, size);
978 }
979 EXPORT_SYMBOL_GPL(crypto_inc);
980
__crypto_xor(u8 * dst,const u8 * src1,const u8 * src2,unsigned int len)981 void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int len)
982 {
983 int relalign = 0;
984
985 if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)) {
986 int size = sizeof(unsigned long);
987 int d = (((unsigned long)dst ^ (unsigned long)src1) |
988 ((unsigned long)dst ^ (unsigned long)src2)) &
989 (size - 1);
990
991 relalign = d ? 1 << __ffs(d) : size;
992
993 /*
994 * If we care about alignment, process as many bytes as
995 * needed to advance dst and src to values whose alignments
996 * equal their relative alignment. This will allow us to
997 * process the remainder of the input using optimal strides.
998 */
999 while (((unsigned long)dst & (relalign - 1)) && len > 0) {
1000 *dst++ = *src1++ ^ *src2++;
1001 len--;
1002 }
1003 }
1004
1005 while (IS_ENABLED(CONFIG_64BIT) && len >= 8 && !(relalign & 7)) {
1006 *(u64 *)dst = *(u64 *)src1 ^ *(u64 *)src2;
1007 dst += 8;
1008 src1 += 8;
1009 src2 += 8;
1010 len -= 8;
1011 }
1012
1013 while (len >= 4 && !(relalign & 3)) {
1014 *(u32 *)dst = *(u32 *)src1 ^ *(u32 *)src2;
1015 dst += 4;
1016 src1 += 4;
1017 src2 += 4;
1018 len -= 4;
1019 }
1020
1021 while (len >= 2 && !(relalign & 1)) {
1022 *(u16 *)dst = *(u16 *)src1 ^ *(u16 *)src2;
1023 dst += 2;
1024 src1 += 2;
1025 src2 += 2;
1026 len -= 2;
1027 }
1028
1029 while (len--)
1030 *dst++ = *src1++ ^ *src2++;
1031 }
1032 EXPORT_SYMBOL_GPL(__crypto_xor);
1033
crypto_alg_extsize(struct crypto_alg * alg)1034 unsigned int crypto_alg_extsize(struct crypto_alg *alg)
1035 {
1036 return alg->cra_ctxsize +
1037 (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));
1038 }
1039 EXPORT_SYMBOL_GPL(crypto_alg_extsize);
1040
crypto_type_has_alg(const char * name,const struct crypto_type * frontend,u32 type,u32 mask)1041 int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,
1042 u32 type, u32 mask)
1043 {
1044 int ret = 0;
1045 struct crypto_alg *alg = crypto_find_alg(name, frontend, type, mask);
1046
1047 if (!IS_ERR(alg)) {
1048 crypto_mod_put(alg);
1049 ret = 1;
1050 }
1051
1052 return ret;
1053 }
1054 EXPORT_SYMBOL_GPL(crypto_type_has_alg);
1055
crypto_algapi_init(void)1056 static int __init crypto_algapi_init(void)
1057 {
1058 crypto_init_proc();
1059 return 0;
1060 }
1061
crypto_algapi_exit(void)1062 static void __exit crypto_algapi_exit(void)
1063 {
1064 crypto_exit_proc();
1065 }
1066
1067 module_init(crypto_algapi_init);
1068 module_exit(crypto_algapi_exit);
1069
1070 MODULE_LICENSE("GPL");
1071 MODULE_DESCRIPTION("Cryptographic algorithms API");
1072