1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Cryptographic API for algorithms (i.e., low-level API).
5 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
8 #include <crypto/algapi.h>
9 #include <crypto/internal/simd.h>
10 #include <linux/err.h>
11 #include <linux/errno.h>
12 #include <linux/fips.h>
13 #include <linux/init.h>
14 #include <linux/kernel.h>
15 #include <linux/list.h>
16 #include <linux/module.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/slab.h>
19 #include <linux/string.h>
20 #include <linux/workqueue.h>
24 static LIST_HEAD(crypto_template_list
);
26 #ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS
27 DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test
);
28 EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test
);
31 static inline void crypto_check_module_sig(struct module
*mod
)
33 if (fips_enabled
&& mod
&& !module_sig_ok(mod
))
34 panic("Module %s signature verification failed in FIPS mode\n",
38 static int crypto_check_alg(struct crypto_alg
*alg
)
40 crypto_check_module_sig(alg
->cra_module
);
42 if (!alg
->cra_name
[0] || !alg
->cra_driver_name
[0])
45 if (alg
->cra_alignmask
& (alg
->cra_alignmask
+ 1))
48 /* General maximums for all algs. */
49 if (alg
->cra_alignmask
> MAX_ALGAPI_ALIGNMASK
)
52 if (alg
->cra_blocksize
> MAX_ALGAPI_BLOCKSIZE
)
55 /* Lower maximums for specific alg types. */
56 if (!alg
->cra_type
&& (alg
->cra_flags
& CRYPTO_ALG_TYPE_MASK
) ==
57 CRYPTO_ALG_TYPE_CIPHER
) {
58 if (alg
->cra_alignmask
> MAX_CIPHER_ALIGNMASK
)
61 if (alg
->cra_blocksize
> MAX_CIPHER_BLOCKSIZE
)
65 if (alg
->cra_priority
< 0)
68 refcount_set(&alg
->cra_refcnt
, 1);
73 static void crypto_free_instance(struct crypto_instance
*inst
)
75 inst
->alg
.cra_type
->free(inst
);
78 static void crypto_destroy_instance_workfn(struct work_struct
*w
)
80 struct crypto_instance
*inst
= container_of(w
, struct crypto_instance
,
82 struct crypto_template
*tmpl
= inst
->tmpl
;
84 crypto_free_instance(inst
);
85 crypto_tmpl_put(tmpl
);
88 static void crypto_destroy_instance(struct crypto_alg
*alg
)
90 struct crypto_instance
*inst
= container_of(alg
,
91 struct crypto_instance
,
94 INIT_WORK(&inst
->free_work
, crypto_destroy_instance_workfn
);
95 schedule_work(&inst
->free_work
);
99 * This function adds a spawn to the list secondary_spawns which
100 * will be used at the end of crypto_remove_spawns to unregister
101 * instances, unless the spawn happens to be one that is depended
102 * on by the new algorithm (nalg in crypto_remove_spawns).
104 * This function is also responsible for resurrecting any algorithms
105 * in the dependency chain of nalg by unsetting n->dead.
107 static struct list_head
*crypto_more_spawns(struct crypto_alg
*alg
,
108 struct list_head
*stack
,
109 struct list_head
*top
,
110 struct list_head
*secondary_spawns
)
112 struct crypto_spawn
*spawn
, *n
;
114 spawn
= list_first_entry_or_null(stack
, struct crypto_spawn
, list
);
118 n
= list_prev_entry(spawn
, list
);
119 list_move(&spawn
->list
, secondary_spawns
);
121 if (list_is_last(&n
->list
, stack
))
124 n
= list_next_entry(n
, list
);
128 return &n
->inst
->alg
.cra_users
;
131 static void crypto_remove_instance(struct crypto_instance
*inst
,
132 struct list_head
*list
)
134 struct crypto_template
*tmpl
= inst
->tmpl
;
136 if (crypto_is_dead(&inst
->alg
))
139 inst
->alg
.cra_flags
|= CRYPTO_ALG_DEAD
;
141 if (!tmpl
|| !crypto_tmpl_get(tmpl
))
144 list_move(&inst
->alg
.cra_list
, list
);
145 hlist_del(&inst
->list
);
146 inst
->alg
.cra_destroy
= crypto_destroy_instance
;
148 BUG_ON(!list_empty(&inst
->alg
.cra_users
));
152 * Given an algorithm alg, remove all algorithms that depend on it
153 * through spawns. If nalg is not null, then exempt any algorithms
154 * that is depended on by nalg. This is useful when nalg itself
157 void crypto_remove_spawns(struct crypto_alg
*alg
, struct list_head
*list
,
158 struct crypto_alg
*nalg
)
160 u32 new_type
= (nalg
?: alg
)->cra_flags
;
161 struct crypto_spawn
*spawn
, *n
;
162 LIST_HEAD(secondary_spawns
);
163 struct list_head
*spawns
;
167 spawns
= &alg
->cra_users
;
168 list_for_each_entry_safe(spawn
, n
, spawns
, list
) {
169 if ((spawn
->alg
->cra_flags
^ new_type
) & spawn
->mask
)
172 list_move(&spawn
->list
, &top
);
176 * Perform a depth-first walk starting from alg through
177 * the cra_users tree. The list stack records the path
178 * from alg to the current spawn.
182 while (!list_empty(spawns
)) {
183 struct crypto_instance
*inst
;
185 spawn
= list_first_entry(spawns
, struct crypto_spawn
,
189 list_move(&spawn
->list
, &stack
);
190 spawn
->dead
= !spawn
->registered
|| &inst
->alg
!= nalg
;
192 if (!spawn
->registered
)
195 BUG_ON(&inst
->alg
== alg
);
197 if (&inst
->alg
== nalg
)
200 spawns
= &inst
->alg
.cra_users
;
203 * Even if spawn->registered is true, the
204 * instance itself may still be unregistered.
205 * This is because it may have failed during
206 * registration. Therefore we still need to
207 * make the following test.
209 * We may encounter an unregistered instance here, since
210 * an instance's spawns are set up prior to the instance
211 * being registered. An unregistered instance will have
212 * NULL ->cra_users.next, since ->cra_users isn't
213 * properly initialized until registration. But an
214 * unregistered instance cannot have any users, so treat
215 * it the same as ->cra_users being empty.
217 if (spawns
->next
== NULL
)
220 } while ((spawns
= crypto_more_spawns(alg
, &stack
, &top
,
221 &secondary_spawns
)));
224 * Remove all instances that are marked as dead. Also
225 * complete the resurrection of the others by moving them
226 * back to the cra_users list.
228 list_for_each_entry_safe(spawn
, n
, &secondary_spawns
, list
) {
230 list_move(&spawn
->list
, &spawn
->alg
->cra_users
);
231 else if (spawn
->registered
)
232 crypto_remove_instance(spawn
->inst
, list
);
235 EXPORT_SYMBOL_GPL(crypto_remove_spawns
);
237 static void crypto_alg_finish_registration(struct crypto_alg
*alg
,
238 bool fulfill_requests
,
239 struct list_head
*algs_to_put
)
241 struct crypto_alg
*q
;
243 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
247 if (crypto_is_moribund(q
))
250 if (crypto_is_larval(q
)) {
251 struct crypto_larval
*larval
= (void *)q
;
254 * Check to see if either our generic name or
255 * specific name can satisfy the name requested
256 * by the larval entry q.
258 if (strcmp(alg
->cra_name
, q
->cra_name
) &&
259 strcmp(alg
->cra_driver_name
, q
->cra_name
))
264 if ((q
->cra_flags
^ alg
->cra_flags
) & larval
->mask
)
267 if (fulfill_requests
&& crypto_mod_get(alg
))
270 larval
->adult
= ERR_PTR(-EAGAIN
);
275 if (strcmp(alg
->cra_name
, q
->cra_name
))
278 if (strcmp(alg
->cra_driver_name
, q
->cra_driver_name
) &&
279 q
->cra_priority
> alg
->cra_priority
)
282 crypto_remove_spawns(q
, algs_to_put
, alg
);
285 crypto_notify(CRYPTO_MSG_ALG_LOADED
, alg
);
288 static struct crypto_larval
*crypto_alloc_test_larval(struct crypto_alg
*alg
)
290 struct crypto_larval
*larval
;
292 if (!IS_ENABLED(CONFIG_CRYPTO_MANAGER
) ||
293 IS_ENABLED(CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
) ||
294 (alg
->cra_flags
& CRYPTO_ALG_INTERNAL
))
295 return NULL
; /* No self-test needed */
297 larval
= crypto_larval_alloc(alg
->cra_name
,
298 alg
->cra_flags
| CRYPTO_ALG_TESTED
, 0);
302 larval
->adult
= crypto_mod_get(alg
);
303 if (!larval
->adult
) {
305 return ERR_PTR(-ENOENT
);
308 refcount_set(&larval
->alg
.cra_refcnt
, 1);
309 memcpy(larval
->alg
.cra_driver_name
, alg
->cra_driver_name
,
310 CRYPTO_MAX_ALG_NAME
);
311 larval
->alg
.cra_priority
= alg
->cra_priority
;
316 static struct crypto_larval
*
317 __crypto_register_alg(struct crypto_alg
*alg
, struct list_head
*algs_to_put
)
319 struct crypto_alg
*q
;
320 struct crypto_larval
*larval
;
323 if (crypto_is_dead(alg
))
326 INIT_LIST_HEAD(&alg
->cra_users
);
330 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
334 if (crypto_is_moribund(q
))
337 if (crypto_is_larval(q
)) {
338 if (!strcmp(alg
->cra_driver_name
, q
->cra_driver_name
))
343 if (!strcmp(q
->cra_driver_name
, alg
->cra_name
) ||
344 !strcmp(q
->cra_name
, alg
->cra_driver_name
))
348 larval
= crypto_alloc_test_larval(alg
);
352 list_add(&alg
->cra_list
, &crypto_alg_list
);
356 alg
->cra_flags
&= ~CRYPTO_ALG_TESTED
;
358 list_add(&larval
->alg
.cra_list
, &crypto_alg_list
);
360 alg
->cra_flags
|= CRYPTO_ALG_TESTED
;
361 crypto_alg_finish_registration(alg
, true, algs_to_put
);
368 larval
= ERR_PTR(ret
);
372 void crypto_alg_tested(const char *name
, int err
)
374 struct crypto_larval
*test
;
375 struct crypto_alg
*alg
;
376 struct crypto_alg
*q
;
380 down_write(&crypto_alg_sem
);
381 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
382 if (crypto_is_moribund(q
) || !crypto_is_larval(q
))
385 test
= (struct crypto_larval
*)q
;
387 if (!strcmp(q
->cra_driver_name
, name
))
391 pr_err("alg: Unexpected test result for %s: %d\n", name
, err
);
395 q
->cra_flags
|= CRYPTO_ALG_DEAD
;
398 if (list_empty(&alg
->cra_list
))
401 if (err
== -ECANCELED
)
402 alg
->cra_flags
|= CRYPTO_ALG_FIPS_INTERNAL
;
406 alg
->cra_flags
&= ~CRYPTO_ALG_FIPS_INTERNAL
;
408 alg
->cra_flags
|= CRYPTO_ALG_TESTED
;
411 * If a higher-priority implementation of the same algorithm is
412 * currently being tested, then don't fulfill request larvals.
415 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
416 if (crypto_is_moribund(q
) || !crypto_is_larval(q
))
419 if (strcmp(alg
->cra_name
, q
->cra_name
))
422 if (q
->cra_priority
> alg
->cra_priority
) {
428 crypto_alg_finish_registration(alg
, best
, &list
);
431 complete_all(&test
->completion
);
434 up_write(&crypto_alg_sem
);
436 crypto_remove_final(&list
);
438 EXPORT_SYMBOL_GPL(crypto_alg_tested
);
440 void crypto_remove_final(struct list_head
*list
)
442 struct crypto_alg
*alg
;
443 struct crypto_alg
*n
;
445 list_for_each_entry_safe(alg
, n
, list
, cra_list
) {
446 list_del_init(&alg
->cra_list
);
450 EXPORT_SYMBOL_GPL(crypto_remove_final
);
452 int crypto_register_alg(struct crypto_alg
*alg
)
454 struct crypto_larval
*larval
;
455 LIST_HEAD(algs_to_put
);
456 bool test_started
= false;
459 alg
->cra_flags
&= ~CRYPTO_ALG_DEAD
;
460 err
= crypto_check_alg(alg
);
464 down_write(&crypto_alg_sem
);
465 larval
= __crypto_register_alg(alg
, &algs_to_put
);
466 if (!IS_ERR_OR_NULL(larval
)) {
467 test_started
= crypto_boot_test_finished();
468 larval
->test_started
= test_started
;
470 up_write(&crypto_alg_sem
);
473 return PTR_ERR(larval
);
475 crypto_wait_for_test(larval
);
476 crypto_remove_final(&algs_to_put
);
479 EXPORT_SYMBOL_GPL(crypto_register_alg
);
481 static int crypto_remove_alg(struct crypto_alg
*alg
, struct list_head
*list
)
483 if (unlikely(list_empty(&alg
->cra_list
)))
486 alg
->cra_flags
|= CRYPTO_ALG_DEAD
;
488 list_del_init(&alg
->cra_list
);
489 crypto_remove_spawns(alg
, list
, NULL
);
494 void crypto_unregister_alg(struct crypto_alg
*alg
)
499 down_write(&crypto_alg_sem
);
500 ret
= crypto_remove_alg(alg
, &list
);
501 up_write(&crypto_alg_sem
);
503 if (WARN(ret
, "Algorithm %s is not registered", alg
->cra_driver_name
))
506 if (WARN_ON(refcount_read(&alg
->cra_refcnt
) != 1))
509 if (alg
->cra_destroy
)
510 alg
->cra_destroy(alg
);
512 crypto_remove_final(&list
);
514 EXPORT_SYMBOL_GPL(crypto_unregister_alg
);
516 int crypto_register_algs(struct crypto_alg
*algs
, int count
)
520 for (i
= 0; i
< count
; i
++) {
521 ret
= crypto_register_alg(&algs
[i
]);
529 for (--i
; i
>= 0; --i
)
530 crypto_unregister_alg(&algs
[i
]);
534 EXPORT_SYMBOL_GPL(crypto_register_algs
);
536 void crypto_unregister_algs(struct crypto_alg
*algs
, int count
)
540 for (i
= 0; i
< count
; i
++)
541 crypto_unregister_alg(&algs
[i
]);
543 EXPORT_SYMBOL_GPL(crypto_unregister_algs
);
545 int crypto_register_template(struct crypto_template
*tmpl
)
547 struct crypto_template
*q
;
550 down_write(&crypto_alg_sem
);
552 crypto_check_module_sig(tmpl
->module
);
554 list_for_each_entry(q
, &crypto_template_list
, list
) {
559 list_add(&tmpl
->list
, &crypto_template_list
);
562 up_write(&crypto_alg_sem
);
565 EXPORT_SYMBOL_GPL(crypto_register_template
);
567 int crypto_register_templates(struct crypto_template
*tmpls
, int count
)
571 for (i
= 0; i
< count
; i
++) {
572 err
= crypto_register_template(&tmpls
[i
]);
579 for (--i
; i
>= 0; --i
)
580 crypto_unregister_template(&tmpls
[i
]);
583 EXPORT_SYMBOL_GPL(crypto_register_templates
);
585 void crypto_unregister_template(struct crypto_template
*tmpl
)
587 struct crypto_instance
*inst
;
588 struct hlist_node
*n
;
589 struct hlist_head
*list
;
592 down_write(&crypto_alg_sem
);
594 BUG_ON(list_empty(&tmpl
->list
));
595 list_del_init(&tmpl
->list
);
597 list
= &tmpl
->instances
;
598 hlist_for_each_entry(inst
, list
, list
) {
599 int err
= crypto_remove_alg(&inst
->alg
, &users
);
604 up_write(&crypto_alg_sem
);
606 hlist_for_each_entry_safe(inst
, n
, list
, list
) {
607 BUG_ON(refcount_read(&inst
->alg
.cra_refcnt
) != 1);
608 crypto_free_instance(inst
);
610 crypto_remove_final(&users
);
612 EXPORT_SYMBOL_GPL(crypto_unregister_template
);
614 void crypto_unregister_templates(struct crypto_template
*tmpls
, int count
)
618 for (i
= count
- 1; i
>= 0; --i
)
619 crypto_unregister_template(&tmpls
[i
]);
621 EXPORT_SYMBOL_GPL(crypto_unregister_templates
);
623 static struct crypto_template
*__crypto_lookup_template(const char *name
)
625 struct crypto_template
*q
, *tmpl
= NULL
;
627 down_read(&crypto_alg_sem
);
628 list_for_each_entry(q
, &crypto_template_list
, list
) {
629 if (strcmp(q
->name
, name
))
631 if (unlikely(!crypto_tmpl_get(q
)))
637 up_read(&crypto_alg_sem
);
642 struct crypto_template
*crypto_lookup_template(const char *name
)
644 return try_then_request_module(__crypto_lookup_template(name
),
647 EXPORT_SYMBOL_GPL(crypto_lookup_template
);
649 int crypto_register_instance(struct crypto_template
*tmpl
,
650 struct crypto_instance
*inst
)
652 struct crypto_larval
*larval
;
653 struct crypto_spawn
*spawn
;
654 u32 fips_internal
= 0;
655 LIST_HEAD(algs_to_put
);
658 err
= crypto_check_alg(&inst
->alg
);
662 inst
->alg
.cra_module
= tmpl
->module
;
663 inst
->alg
.cra_flags
|= CRYPTO_ALG_INSTANCE
;
665 down_write(&crypto_alg_sem
);
667 larval
= ERR_PTR(-EAGAIN
);
668 for (spawn
= inst
->spawns
; spawn
;) {
669 struct crypto_spawn
*next
;
676 spawn
->registered
= true;
678 fips_internal
|= spawn
->alg
->cra_flags
;
680 crypto_mod_put(spawn
->alg
);
685 inst
->alg
.cra_flags
|= (fips_internal
& CRYPTO_ALG_FIPS_INTERNAL
);
687 larval
= __crypto_register_alg(&inst
->alg
, &algs_to_put
);
691 larval
->test_started
= true;
693 hlist_add_head(&inst
->list
, &tmpl
->instances
);
697 up_write(&crypto_alg_sem
);
700 return PTR_ERR(larval
);
702 crypto_wait_for_test(larval
);
703 crypto_remove_final(&algs_to_put
);
706 EXPORT_SYMBOL_GPL(crypto_register_instance
);
708 void crypto_unregister_instance(struct crypto_instance
*inst
)
712 down_write(&crypto_alg_sem
);
714 crypto_remove_spawns(&inst
->alg
, &list
, NULL
);
715 crypto_remove_instance(inst
, &list
);
717 up_write(&crypto_alg_sem
);
719 crypto_remove_final(&list
);
721 EXPORT_SYMBOL_GPL(crypto_unregister_instance
);
723 int crypto_grab_spawn(struct crypto_spawn
*spawn
, struct crypto_instance
*inst
,
724 const char *name
, u32 type
, u32 mask
)
726 struct crypto_alg
*alg
;
729 if (WARN_ON_ONCE(inst
== NULL
))
732 /* Allow the result of crypto_attr_alg_name() to be passed directly */
734 return PTR_ERR(name
);
736 alg
= crypto_find_alg(name
, spawn
->frontend
,
737 type
| CRYPTO_ALG_FIPS_INTERNAL
, mask
);
741 down_write(&crypto_alg_sem
);
742 if (!crypto_is_moribund(alg
)) {
743 list_add(&spawn
->list
, &alg
->cra_users
);
746 spawn
->next
= inst
->spawns
;
747 inst
->spawns
= spawn
;
748 inst
->alg
.cra_flags
|=
749 (alg
->cra_flags
& CRYPTO_ALG_INHERITED_FLAGS
);
752 up_write(&crypto_alg_sem
);
757 EXPORT_SYMBOL_GPL(crypto_grab_spawn
);
759 void crypto_drop_spawn(struct crypto_spawn
*spawn
)
761 if (!spawn
->alg
) /* not yet initialized? */
764 down_write(&crypto_alg_sem
);
766 list_del(&spawn
->list
);
767 up_write(&crypto_alg_sem
);
769 if (!spawn
->registered
)
770 crypto_mod_put(spawn
->alg
);
772 EXPORT_SYMBOL_GPL(crypto_drop_spawn
);
774 static struct crypto_alg
*crypto_spawn_alg(struct crypto_spawn
*spawn
)
776 struct crypto_alg
*alg
= ERR_PTR(-EAGAIN
);
777 struct crypto_alg
*target
;
780 down_read(&crypto_alg_sem
);
783 if (!crypto_mod_get(alg
)) {
784 target
= crypto_alg_get(alg
);
786 alg
= ERR_PTR(-EAGAIN
);
789 up_read(&crypto_alg_sem
);
792 crypto_shoot_alg(target
);
793 crypto_alg_put(target
);
799 struct crypto_tfm
*crypto_spawn_tfm(struct crypto_spawn
*spawn
, u32 type
,
802 struct crypto_alg
*alg
;
803 struct crypto_tfm
*tfm
;
805 alg
= crypto_spawn_alg(spawn
);
807 return ERR_CAST(alg
);
809 tfm
= ERR_PTR(-EINVAL
);
810 if (unlikely((alg
->cra_flags
^ type
) & mask
))
813 tfm
= __crypto_alloc_tfm(alg
, type
, mask
);
823 EXPORT_SYMBOL_GPL(crypto_spawn_tfm
);
825 void *crypto_spawn_tfm2(struct crypto_spawn
*spawn
)
827 struct crypto_alg
*alg
;
828 struct crypto_tfm
*tfm
;
830 alg
= crypto_spawn_alg(spawn
);
832 return ERR_CAST(alg
);
834 tfm
= crypto_create_tfm(alg
, spawn
->frontend
);
844 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2
);
846 int crypto_register_notifier(struct notifier_block
*nb
)
848 return blocking_notifier_chain_register(&crypto_chain
, nb
);
850 EXPORT_SYMBOL_GPL(crypto_register_notifier
);
852 int crypto_unregister_notifier(struct notifier_block
*nb
)
854 return blocking_notifier_chain_unregister(&crypto_chain
, nb
);
856 EXPORT_SYMBOL_GPL(crypto_unregister_notifier
);
858 struct crypto_attr_type
*crypto_get_attr_type(struct rtattr
**tb
)
860 struct rtattr
*rta
= tb
[0];
861 struct crypto_attr_type
*algt
;
864 return ERR_PTR(-ENOENT
);
865 if (RTA_PAYLOAD(rta
) < sizeof(*algt
))
866 return ERR_PTR(-EINVAL
);
867 if (rta
->rta_type
!= CRYPTOA_TYPE
)
868 return ERR_PTR(-EINVAL
);
870 algt
= RTA_DATA(rta
);
874 EXPORT_SYMBOL_GPL(crypto_get_attr_type
);
877 * crypto_check_attr_type() - check algorithm type and compute inherited mask
878 * @tb: the template parameters
879 * @type: the algorithm type the template would be instantiated as
880 * @mask_ret: (output) the mask that should be passed to crypto_grab_*()
881 * to restrict the flags of any inner algorithms
883 * Validate that the algorithm type the user requested is compatible with the
884 * one the template would actually be instantiated as. E.g., if the user is
885 * doing crypto_alloc_shash("cbc(aes)", ...), this would return an error because
886 * the "cbc" template creates an "skcipher" algorithm, not an "shash" algorithm.
888 * Also compute the mask to use to restrict the flags of any inner algorithms.
890 * Return: 0 on success; -errno on failure
892 int crypto_check_attr_type(struct rtattr
**tb
, u32 type
, u32
*mask_ret
)
894 struct crypto_attr_type
*algt
;
896 algt
= crypto_get_attr_type(tb
);
898 return PTR_ERR(algt
);
900 if ((algt
->type
^ type
) & algt
->mask
)
903 *mask_ret
= crypto_algt_inherited_mask(algt
);
906 EXPORT_SYMBOL_GPL(crypto_check_attr_type
);
908 const char *crypto_attr_alg_name(struct rtattr
*rta
)
910 struct crypto_attr_alg
*alga
;
913 return ERR_PTR(-ENOENT
);
914 if (RTA_PAYLOAD(rta
) < sizeof(*alga
))
915 return ERR_PTR(-EINVAL
);
916 if (rta
->rta_type
!= CRYPTOA_ALG
)
917 return ERR_PTR(-EINVAL
);
919 alga
= RTA_DATA(rta
);
920 alga
->name
[CRYPTO_MAX_ALG_NAME
- 1] = 0;
924 EXPORT_SYMBOL_GPL(crypto_attr_alg_name
);
926 int crypto_inst_setname(struct crypto_instance
*inst
, const char *name
,
927 struct crypto_alg
*alg
)
929 if (snprintf(inst
->alg
.cra_name
, CRYPTO_MAX_ALG_NAME
, "%s(%s)", name
,
930 alg
->cra_name
) >= CRYPTO_MAX_ALG_NAME
)
931 return -ENAMETOOLONG
;
933 if (snprintf(inst
->alg
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
, "%s(%s)",
934 name
, alg
->cra_driver_name
) >= CRYPTO_MAX_ALG_NAME
)
935 return -ENAMETOOLONG
;
939 EXPORT_SYMBOL_GPL(crypto_inst_setname
);
941 void crypto_init_queue(struct crypto_queue
*queue
, unsigned int max_qlen
)
943 INIT_LIST_HEAD(&queue
->list
);
944 queue
->backlog
= &queue
->list
;
946 queue
->max_qlen
= max_qlen
;
948 EXPORT_SYMBOL_GPL(crypto_init_queue
);
950 int crypto_enqueue_request(struct crypto_queue
*queue
,
951 struct crypto_async_request
*request
)
953 int err
= -EINPROGRESS
;
955 if (unlikely(queue
->qlen
>= queue
->max_qlen
)) {
956 if (!(request
->flags
& CRYPTO_TFM_REQ_MAY_BACKLOG
)) {
961 if (queue
->backlog
== &queue
->list
)
962 queue
->backlog
= &request
->list
;
966 list_add_tail(&request
->list
, &queue
->list
);
971 EXPORT_SYMBOL_GPL(crypto_enqueue_request
);
973 void crypto_enqueue_request_head(struct crypto_queue
*queue
,
974 struct crypto_async_request
*request
)
976 if (unlikely(queue
->qlen
>= queue
->max_qlen
))
977 queue
->backlog
= queue
->backlog
->prev
;
980 list_add(&request
->list
, &queue
->list
);
982 EXPORT_SYMBOL_GPL(crypto_enqueue_request_head
);
984 struct crypto_async_request
*crypto_dequeue_request(struct crypto_queue
*queue
)
986 struct list_head
*request
;
988 if (unlikely(!queue
->qlen
))
993 if (queue
->backlog
!= &queue
->list
)
994 queue
->backlog
= queue
->backlog
->next
;
996 request
= queue
->list
.next
;
999 return list_entry(request
, struct crypto_async_request
, list
);
1001 EXPORT_SYMBOL_GPL(crypto_dequeue_request
);
1003 static inline void crypto_inc_byte(u8
*a
, unsigned int size
)
1008 for (; size
; size
--) {
1016 void crypto_inc(u8
*a
, unsigned int size
)
1018 __be32
*b
= (__be32
*)(a
+ size
);
1021 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
) ||
1022 IS_ALIGNED((unsigned long)b
, __alignof__(*b
)))
1023 for (; size
>= 4; size
-= 4) {
1024 c
= be32_to_cpu(*--b
) + 1;
1025 *b
= cpu_to_be32(c
);
1030 crypto_inc_byte(a
, size
);
1032 EXPORT_SYMBOL_GPL(crypto_inc
);
1034 unsigned int crypto_alg_extsize(struct crypto_alg
*alg
)
1036 return alg
->cra_ctxsize
+
1037 (alg
->cra_alignmask
& ~(crypto_tfm_ctx_alignment() - 1));
1039 EXPORT_SYMBOL_GPL(crypto_alg_extsize
);
1041 int crypto_type_has_alg(const char *name
, const struct crypto_type
*frontend
,
1045 struct crypto_alg
*alg
= crypto_find_alg(name
, frontend
, type
, mask
);
1048 crypto_mod_put(alg
);
1054 EXPORT_SYMBOL_GPL(crypto_type_has_alg
);
1056 static void __init
crypto_start_tests(void)
1058 if (IS_ENABLED(CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
))
1062 struct crypto_larval
*larval
= NULL
;
1063 struct crypto_alg
*q
;
1065 down_write(&crypto_alg_sem
);
1067 list_for_each_entry(q
, &crypto_alg_list
, cra_list
) {
1068 struct crypto_larval
*l
;
1070 if (!crypto_is_larval(q
))
1075 if (!crypto_is_test_larval(l
))
1078 if (l
->test_started
)
1081 l
->test_started
= true;
1086 up_write(&crypto_alg_sem
);
1091 crypto_wait_for_test(larval
);
1094 set_crypto_boot_test_finished();
1097 static int __init
crypto_algapi_init(void)
1100 crypto_start_tests();
1104 static void __exit
crypto_algapi_exit(void)
1110 * We run this at late_initcall so that all the built-in algorithms
1111 * have had a chance to register themselves first.
1113 late_initcall(crypto_algapi_init
);
1114 module_exit(crypto_algapi_exit
);
1116 MODULE_LICENSE("GPL");
1117 MODULE_DESCRIPTION("Cryptographic algorithms API");
1118 MODULE_SOFTDEP("pre: cryptomgr");