1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Create default crypto algorithm instances.
5 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
8 #include <crypto/internal/aead.h>
9 #include <linux/completion.h>
10 #include <linux/ctype.h>
11 #include <linux/err.h>
12 #include <linux/init.h>
13 #include <linux/kthread.h>
14 #include <linux/module.h>
15 #include <linux/notifier.h>
16 #include <linux/rtnetlink.h>
17 #include <linux/sched/signal.h>
18 #include <linux/slab.h>
19 #include <linux/string.h>
23 struct cryptomgr_param
{
24 struct rtattr
*tb
[CRYPTO_MAX_ATTRS
+ 2];
28 struct crypto_attr_type data
;
33 struct crypto_attr_alg data
;
34 } attrs
[CRYPTO_MAX_ATTRS
];
36 char template[CRYPTO_MAX_ALG_NAME
];
38 struct crypto_larval
*larval
;
44 struct crypto_test_param
{
45 char driver
[CRYPTO_MAX_ALG_NAME
];
46 char alg
[CRYPTO_MAX_ALG_NAME
];
50 static int cryptomgr_probe(void *data
)
52 struct cryptomgr_param
*param
= data
;
53 struct crypto_template
*tmpl
;
56 tmpl
= crypto_lookup_template(param
->template);
61 err
= tmpl
->create(tmpl
, param
->tb
);
62 } while (err
== -EAGAIN
&& !signal_pending(current
));
64 crypto_tmpl_put(tmpl
);
67 complete_all(¶m
->larval
->completion
);
68 crypto_alg_put(¶m
->larval
->alg
);
70 module_put_and_exit(0);
73 static int cryptomgr_schedule_probe(struct crypto_larval
*larval
)
75 struct task_struct
*thread
;
76 struct cryptomgr_param
*param
;
77 const char *name
= larval
->alg
.cra_name
;
82 if (!try_module_get(THIS_MODULE
))
85 param
= kzalloc(sizeof(*param
), GFP_KERNEL
);
89 for (p
= name
; isalnum(*p
) || *p
== '-' || *p
== '_'; p
++)
93 if (!len
|| *p
!= '(')
96 memcpy(param
->template, name
, len
);
102 for (; isalnum(*p
) || *p
== '-' || *p
== '_'; p
++)
113 else if (*p
== ')' && !recursion
--)
124 param
->attrs
[i
].attr
.rta_len
= sizeof(param
->attrs
[i
]);
125 param
->attrs
[i
].attr
.rta_type
= CRYPTOA_ALG
;
126 memcpy(param
->attrs
[i
].data
.name
, name
, len
);
128 param
->tb
[i
+ 1] = ¶m
->attrs
[i
].attr
;
131 if (i
>= CRYPTO_MAX_ATTRS
)
144 param
->tb
[i
+ 1] = NULL
;
146 param
->type
.attr
.rta_len
= sizeof(param
->type
);
147 param
->type
.attr
.rta_type
= CRYPTOA_TYPE
;
148 param
->type
.data
.type
= larval
->alg
.cra_flags
& ~CRYPTO_ALG_TESTED
;
149 param
->type
.data
.mask
= larval
->mask
& ~CRYPTO_ALG_TESTED
;
150 param
->tb
[0] = ¶m
->type
.attr
;
152 param
->otype
= larval
->alg
.cra_flags
;
153 param
->omask
= larval
->mask
;
155 crypto_alg_get(&larval
->alg
);
156 param
->larval
= larval
;
158 thread
= kthread_run(cryptomgr_probe
, param
, "cryptomgr_probe");
165 crypto_alg_put(&larval
->alg
);
169 module_put(THIS_MODULE
);
174 static int cryptomgr_test(void *data
)
176 struct crypto_test_param
*param
= data
;
177 u32 type
= param
->type
;
180 #ifdef CONFIG_CRYPTO_MANAGER_DISABLE_TESTS
184 if (type
& CRYPTO_ALG_TESTED
)
187 err
= alg_test(param
->driver
, param
->alg
, type
, CRYPTO_ALG_TESTED
);
190 crypto_alg_tested(param
->driver
, err
);
193 module_put_and_exit(0);
196 static int cryptomgr_schedule_test(struct crypto_alg
*alg
)
198 struct task_struct
*thread
;
199 struct crypto_test_param
*param
;
202 if (!try_module_get(THIS_MODULE
))
205 param
= kzalloc(sizeof(*param
), GFP_KERNEL
);
209 memcpy(param
->driver
, alg
->cra_driver_name
, sizeof(param
->driver
));
210 memcpy(param
->alg
, alg
->cra_name
, sizeof(param
->alg
));
211 type
= alg
->cra_flags
;
213 /* Do not test internal algorithms. */
214 if (type
& CRYPTO_ALG_INTERNAL
)
215 type
|= CRYPTO_ALG_TESTED
;
219 thread
= kthread_run(cryptomgr_test
, param
, "cryptomgr_test");
228 module_put(THIS_MODULE
);
233 static int cryptomgr_notify(struct notifier_block
*this, unsigned long msg
,
237 case CRYPTO_MSG_ALG_REQUEST
:
238 return cryptomgr_schedule_probe(data
);
239 case CRYPTO_MSG_ALG_REGISTER
:
240 return cryptomgr_schedule_test(data
);
241 case CRYPTO_MSG_ALG_LOADED
:
248 static struct notifier_block cryptomgr_notifier
= {
249 .notifier_call
= cryptomgr_notify
,
252 static int __init
cryptomgr_init(void)
254 return crypto_register_notifier(&cryptomgr_notifier
);
257 static void __exit
cryptomgr_exit(void)
259 int err
= crypto_unregister_notifier(&cryptomgr_notifier
);
264 * This is arch_initcall() so that the crypto self-tests are run on algorithms
265 * registered early by subsys_initcall(). subsys_initcall() is needed for
266 * generic implementations so that they're available for comparison tests when
267 * other implementations are registered later by module_init().
269 arch_initcall(cryptomgr_init
);
270 module_exit(cryptomgr_exit
);
272 MODULE_LICENSE("GPL");
273 MODULE_DESCRIPTION("Crypto Algorithm Manager");