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