projects/linux·blob v4.15 · refs

1082 lines · 22.6 KiB

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