xref: /openbmc/linux/crypto/crypto_user_base.c (revision 2f0f2441b4a10948e2ec042b48fef13680387f7c) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Crypto user configuration API.
4  *
5  * Copyright (C) 2011 secunet Security Networks AG
6  * Copyright (C) 2011 Steffen Klassert <steffen.klassert@secunet.com>
7  */
8 
9 #include <linux/module.h>
10 #include <linux/crypto.h>
11 #include <linux/cryptouser.h>
12 #include <linux/sched.h>
13 #include <net/netlink.h>
14 #include <linux/security.h>
15 #include <net/net_namespace.h>
16 #include <crypto/internal/skcipher.h>
17 #include <crypto/internal/rng.h>
18 #include <crypto/akcipher.h>
19 #include <crypto/kpp.h>
20 #include <crypto/internal/cryptouser.h>
21 
22 #include "internal.h"
23 
24 #define null_terminated(x)	(strnlen(x, sizeof(x)) < sizeof(x))
25 
26 static DEFINE_MUTEX(crypto_cfg_mutex);
27 
28 /* The crypto netlink socket */
29 struct sock *crypto_nlsk;
30 
31 struct crypto_dump_info {
32 	struct sk_buff *in_skb;
33 	struct sk_buff *out_skb;
34 	u32 nlmsg_seq;
35 	u16 nlmsg_flags;
36 };
37 
38 struct crypto_alg *crypto_alg_match(struct crypto_user_alg *p, int exact)
39 {
40 	struct crypto_alg *q, *alg = NULL;
41 
42 	down_read(&crypto_alg_sem);
43 
44 	list_for_each_entry(q, &crypto_alg_list, cra_list) {
45 		int match = 0;
46 
47 		if ((q->cra_flags ^ p->cru_type) & p->cru_mask)
48 			continue;
49 
50 		if (strlen(p->cru_driver_name))
51 			match = !strcmp(q->cra_driver_name,
52 					p->cru_driver_name);
53 		else if (!exact)
54 			match = !strcmp(q->cra_name, p->cru_name);
55 
56 		if (!match)
57 			continue;
58 
59 		if (unlikely(!crypto_mod_get(q)))
60 			continue;
61 
62 		alg = q;
63 		break;
64 	}
65 
66 	up_read(&crypto_alg_sem);
67 
68 	return alg;
69 }
70 
71 static int crypto_report_cipher(struct sk_buff *skb, struct crypto_alg *alg)
72 {
73 	struct crypto_report_cipher rcipher;
74 
75 	memset(&rcipher, 0, sizeof(rcipher));
76 
77 	strscpy(rcipher.type, "cipher", sizeof(rcipher.type));
78 
79 	rcipher.blocksize = alg->cra_blocksize;
80 	rcipher.min_keysize = alg->cra_cipher.cia_min_keysize;
81 	rcipher.max_keysize = alg->cra_cipher.cia_max_keysize;
82 
83 	return nla_put(skb, CRYPTOCFGA_REPORT_CIPHER,
84 		       sizeof(rcipher), &rcipher);
85 }
86 
87 static int crypto_report_comp(struct sk_buff *skb, struct crypto_alg *alg)
88 {
89 	struct crypto_report_comp rcomp;
90 
91 	memset(&rcomp, 0, sizeof(rcomp));
92 
93 	strscpy(rcomp.type, "compression", sizeof(rcomp.type));
94 
95 	return nla_put(skb, CRYPTOCFGA_REPORT_COMPRESS, sizeof(rcomp), &rcomp);
96 }
97 
98 static int crypto_report_one(struct crypto_alg *alg,
99 			     struct crypto_user_alg *ualg, struct sk_buff *skb)
100 {
101 	memset(ualg, 0, sizeof(*ualg));
102 
103 	strscpy(ualg->cru_name, alg->cra_name, sizeof(ualg->cru_name));
104 	strscpy(ualg->cru_driver_name, alg->cra_driver_name,
105 		sizeof(ualg->cru_driver_name));
106 	strscpy(ualg->cru_module_name, module_name(alg->cra_module),
107 		sizeof(ualg->cru_module_name));
108 
109 	ualg->cru_type = 0;
110 	ualg->cru_mask = 0;
111 	ualg->cru_flags = alg->cra_flags;
112 	ualg->cru_refcnt = refcount_read(&alg->cra_refcnt);
113 
114 	if (nla_put_u32(skb, CRYPTOCFGA_PRIORITY_VAL, alg->cra_priority))
115 		goto nla_put_failure;
116 	if (alg->cra_flags & CRYPTO_ALG_LARVAL) {
117 		struct crypto_report_larval rl;
118 
119 		memset(&rl, 0, sizeof(rl));
120 		strscpy(rl.type, "larval", sizeof(rl.type));
121 		if (nla_put(skb, CRYPTOCFGA_REPORT_LARVAL, sizeof(rl), &rl))
122 			goto nla_put_failure;
123 		goto out;
124 	}
125 
126 	if (alg->cra_type && alg->cra_type->report) {
127 		if (alg->cra_type->report(skb, alg))
128 			goto nla_put_failure;
129 
130 		goto out;
131 	}
132 
133 	switch (alg->cra_flags & (CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_LARVAL)) {
134 	case CRYPTO_ALG_TYPE_CIPHER:
135 		if (crypto_report_cipher(skb, alg))
136 			goto nla_put_failure;
137 
138 		break;
139 	case CRYPTO_ALG_TYPE_COMPRESS:
140 		if (crypto_report_comp(skb, alg))
141 			goto nla_put_failure;
142 
143 		break;
144 	}
145 
146 out:
147 	return 0;
148 
149 nla_put_failure:
150 	return -EMSGSIZE;
151 }
152 
153 static int crypto_report_alg(struct crypto_alg *alg,
154 			     struct crypto_dump_info *info)
155 {
156 	struct sk_buff *in_skb = info->in_skb;
157 	struct sk_buff *skb = info->out_skb;
158 	struct nlmsghdr *nlh;
159 	struct crypto_user_alg *ualg;
160 	int err = 0;
161 
162 	nlh = nlmsg_put(skb, NETLINK_CB(in_skb).portid, info->nlmsg_seq,
163 			CRYPTO_MSG_GETALG, sizeof(*ualg), info->nlmsg_flags);
164 	if (!nlh) {
165 		err = -EMSGSIZE;
166 		goto out;
167 	}
168 
169 	ualg = nlmsg_data(nlh);
170 
171 	err = crypto_report_one(alg, ualg, skb);
172 	if (err) {
173 		nlmsg_cancel(skb, nlh);
174 		goto out;
175 	}
176 
177 	nlmsg_end(skb, nlh);
178 
179 out:
180 	return err;
181 }
182 
183 static int crypto_report(struct sk_buff *in_skb, struct nlmsghdr *in_nlh,
184 			 struct nlattr **attrs)
185 {
186 	struct crypto_user_alg *p = nlmsg_data(in_nlh);
187 	struct crypto_alg *alg;
188 	struct sk_buff *skb;
189 	struct crypto_dump_info info;
190 	int err;
191 
192 	if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
193 		return -EINVAL;
194 
195 	alg = crypto_alg_match(p, 0);
196 	if (!alg)
197 		return -ENOENT;
198 
199 	err = -ENOMEM;
200 	skb = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
201 	if (!skb)
202 		goto drop_alg;
203 
204 	info.in_skb = in_skb;
205 	info.out_skb = skb;
206 	info.nlmsg_seq = in_nlh->nlmsg_seq;
207 	info.nlmsg_flags = 0;
208 
209 	err = crypto_report_alg(alg, &info);
210 
211 drop_alg:
212 	crypto_mod_put(alg);
213 
214 	if (err)
215 		return err;
216 
217 	return nlmsg_unicast(crypto_nlsk, skb, NETLINK_CB(in_skb).portid);
218 }
219 
220 static int crypto_dump_report(struct sk_buff *skb, struct netlink_callback *cb)
221 {
222 	const size_t start_pos = cb->args[0];
223 	size_t pos = 0;
224 	struct crypto_dump_info info;
225 	struct crypto_alg *alg;
226 	int res;
227 
228 	info.in_skb = cb->skb;
229 	info.out_skb = skb;
230 	info.nlmsg_seq = cb->nlh->nlmsg_seq;
231 	info.nlmsg_flags = NLM_F_MULTI;
232 
233 	down_read(&crypto_alg_sem);
234 	list_for_each_entry(alg, &crypto_alg_list, cra_list) {
235 		if (pos >= start_pos) {
236 			res = crypto_report_alg(alg, &info);
237 			if (res == -EMSGSIZE)
238 				break;
239 			if (res)
240 				goto out;
241 		}
242 		pos++;
243 	}
244 	cb->args[0] = pos;
245 	res = skb->len;
246 out:
247 	up_read(&crypto_alg_sem);
248 	return res;
249 }
250 
251 static int crypto_dump_report_done(struct netlink_callback *cb)
252 {
253 	return 0;
254 }
255 
256 static int crypto_update_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
257 			     struct nlattr **attrs)
258 {
259 	struct crypto_alg *alg;
260 	struct crypto_user_alg *p = nlmsg_data(nlh);
261 	struct nlattr *priority = attrs[CRYPTOCFGA_PRIORITY_VAL];
262 	LIST_HEAD(list);
263 
264 	if (!netlink_capable(skb, CAP_NET_ADMIN))
265 		return -EPERM;
266 
267 	if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
268 		return -EINVAL;
269 
270 	if (priority && !strlen(p->cru_driver_name))
271 		return -EINVAL;
272 
273 	alg = crypto_alg_match(p, 1);
274 	if (!alg)
275 		return -ENOENT;
276 
277 	down_write(&crypto_alg_sem);
278 
279 	crypto_remove_spawns(alg, &list, NULL);
280 
281 	if (priority)
282 		alg->cra_priority = nla_get_u32(priority);
283 
284 	up_write(&crypto_alg_sem);
285 
286 	crypto_mod_put(alg);
287 	crypto_remove_final(&list);
288 
289 	return 0;
290 }
291 
292 static int crypto_del_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
293 			  struct nlattr **attrs)
294 {
295 	struct crypto_alg *alg;
296 	struct crypto_user_alg *p = nlmsg_data(nlh);
297 	int err;
298 
299 	if (!netlink_capable(skb, CAP_NET_ADMIN))
300 		return -EPERM;
301 
302 	if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
303 		return -EINVAL;
304 
305 	alg = crypto_alg_match(p, 1);
306 	if (!alg)
307 		return -ENOENT;
308 
309 	/* We can not unregister core algorithms such as aes-generic.
310 	 * We would loose the reference in the crypto_alg_list to this algorithm
311 	 * if we try to unregister. Unregistering such an algorithm without
312 	 * removing the module is not possible, so we restrict to crypto
313 	 * instances that are build from templates. */
314 	err = -EINVAL;
315 	if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE))
316 		goto drop_alg;
317 
318 	err = -EBUSY;
319 	if (refcount_read(&alg->cra_refcnt) > 2)
320 		goto drop_alg;
321 
322 	err = crypto_unregister_instance((struct crypto_instance *)alg);
323 
324 drop_alg:
325 	crypto_mod_put(alg);
326 	return err;
327 }
328 
329 static int crypto_add_alg(struct sk_buff *skb, struct nlmsghdr *nlh,
330 			  struct nlattr **attrs)
331 {
332 	int exact = 0;
333 	const char *name;
334 	struct crypto_alg *alg;
335 	struct crypto_user_alg *p = nlmsg_data(nlh);
336 	struct nlattr *priority = attrs[CRYPTOCFGA_PRIORITY_VAL];
337 
338 	if (!netlink_capable(skb, CAP_NET_ADMIN))
339 		return -EPERM;
340 
341 	if (!null_terminated(p->cru_name) || !null_terminated(p->cru_driver_name))
342 		return -EINVAL;
343 
344 	if (strlen(p->cru_driver_name))
345 		exact = 1;
346 
347 	if (priority && !exact)
348 		return -EINVAL;
349 
350 	alg = crypto_alg_match(p, exact);
351 	if (alg) {
352 		crypto_mod_put(alg);
353 		return -EEXIST;
354 	}
355 
356 	if (strlen(p->cru_driver_name))
357 		name = p->cru_driver_name;
358 	else
359 		name = p->cru_name;
360 
361 	alg = crypto_alg_mod_lookup(name, p->cru_type, p->cru_mask);
362 	if (IS_ERR(alg))
363 		return PTR_ERR(alg);
364 
365 	down_write(&crypto_alg_sem);
366 
367 	if (priority)
368 		alg->cra_priority = nla_get_u32(priority);
369 
370 	up_write(&crypto_alg_sem);
371 
372 	crypto_mod_put(alg);
373 
374 	return 0;
375 }
376 
377 static int crypto_del_rng(struct sk_buff *skb, struct nlmsghdr *nlh,
378 			  struct nlattr **attrs)
379 {
380 	if (!netlink_capable(skb, CAP_NET_ADMIN))
381 		return -EPERM;
382 	return crypto_del_default_rng();
383 }
384 
385 #define MSGSIZE(type) sizeof(struct type)
386 
387 static const int crypto_msg_min[CRYPTO_NR_MSGTYPES] = {
388 	[CRYPTO_MSG_NEWALG	- CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
389 	[CRYPTO_MSG_DELALG	- CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
390 	[CRYPTO_MSG_UPDATEALG	- CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
391 	[CRYPTO_MSG_GETALG	- CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
392 	[CRYPTO_MSG_DELRNG	- CRYPTO_MSG_BASE] = 0,
393 	[CRYPTO_MSG_GETSTAT	- CRYPTO_MSG_BASE] = MSGSIZE(crypto_user_alg),
394 };
395 
396 static const struct nla_policy crypto_policy[CRYPTOCFGA_MAX+1] = {
397 	[CRYPTOCFGA_PRIORITY_VAL]   = { .type = NLA_U32},
398 };
399 
400 #undef MSGSIZE
401 
402 static const struct crypto_link {
403 	int (*doit)(struct sk_buff *, struct nlmsghdr *, struct nlattr **);
404 	int (*dump)(struct sk_buff *, struct netlink_callback *);
405 	int (*done)(struct netlink_callback *);
406 } crypto_dispatch[CRYPTO_NR_MSGTYPES] = {
407 	[CRYPTO_MSG_NEWALG	- CRYPTO_MSG_BASE] = { .doit = crypto_add_alg},
408 	[CRYPTO_MSG_DELALG	- CRYPTO_MSG_BASE] = { .doit = crypto_del_alg},
409 	[CRYPTO_MSG_UPDATEALG	- CRYPTO_MSG_BASE] = { .doit = crypto_update_alg},
410 	[CRYPTO_MSG_GETALG	- CRYPTO_MSG_BASE] = { .doit = crypto_report,
411 						       .dump = crypto_dump_report,
412 						       .done = crypto_dump_report_done},
413 	[CRYPTO_MSG_DELRNG	- CRYPTO_MSG_BASE] = { .doit = crypto_del_rng },
414 	[CRYPTO_MSG_GETSTAT	- CRYPTO_MSG_BASE] = { .doit = crypto_reportstat},
415 };
416 
417 static int crypto_user_rcv_msg(struct sk_buff *skb, struct nlmsghdr *nlh,
418 			       struct netlink_ext_ack *extack)
419 {
420 	struct nlattr *attrs[CRYPTOCFGA_MAX+1];
421 	const struct crypto_link *link;
422 	int type, err;
423 
424 	type = nlh->nlmsg_type;
425 	if (type > CRYPTO_MSG_MAX)
426 		return -EINVAL;
427 
428 	type -= CRYPTO_MSG_BASE;
429 	link = &crypto_dispatch[type];
430 
431 	if ((type == (CRYPTO_MSG_GETALG - CRYPTO_MSG_BASE) &&
432 	    (nlh->nlmsg_flags & NLM_F_DUMP))) {
433 		struct crypto_alg *alg;
434 		unsigned long dump_alloc = 0;
435 
436 		if (link->dump == NULL)
437 			return -EINVAL;
438 
439 		down_read(&crypto_alg_sem);
440 		list_for_each_entry(alg, &crypto_alg_list, cra_list)
441 			dump_alloc += CRYPTO_REPORT_MAXSIZE;
442 		up_read(&crypto_alg_sem);
443 
444 		{
445 			struct netlink_dump_control c = {
446 				.dump = link->dump,
447 				.done = link->done,
448 				.min_dump_alloc = min(dump_alloc, 65535UL),
449 			};
450 			err = netlink_dump_start(crypto_nlsk, skb, nlh, &c);
451 		}
452 
453 		return err;
454 	}
455 
456 	err = nlmsg_parse_deprecated(nlh, crypto_msg_min[type], attrs,
457 				     CRYPTOCFGA_MAX, crypto_policy, extack);
458 	if (err < 0)
459 		return err;
460 
461 	if (link->doit == NULL)
462 		return -EINVAL;
463 
464 	return link->doit(skb, nlh, attrs);
465 }
466 
467 static void crypto_netlink_rcv(struct sk_buff *skb)
468 {
469 	mutex_lock(&crypto_cfg_mutex);
470 	netlink_rcv_skb(skb, &crypto_user_rcv_msg);
471 	mutex_unlock(&crypto_cfg_mutex);
472 }
473 
474 static int __init crypto_user_init(void)
475 {
476 	struct netlink_kernel_cfg cfg = {
477 		.input	= crypto_netlink_rcv,
478 	};
479 
480 	crypto_nlsk = netlink_kernel_create(&init_net, NETLINK_CRYPTO, &cfg);
481 	if (!crypto_nlsk)
482 		return -ENOMEM;
483 
484 	return 0;
485 }
486 
487 static void __exit crypto_user_exit(void)
488 {
489 	netlink_kernel_release(crypto_nlsk);
490 }
491 
492 module_init(crypto_user_init);
493 module_exit(crypto_user_exit);
494 MODULE_LICENSE("GPL");
495 MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");
496 MODULE_DESCRIPTION("Crypto userspace configuration API");
497 MODULE_ALIAS("net-pf-16-proto-21");
498