xref: /openbmc/linux/crypto/af_alg.c (revision 4bce6fce) 
1 /*
2  * af_alg: User-space algorithm interface
3  *
4  * This file provides the user-space API for algorithms.
5  *
6  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
7  *
8  * This program is free software; you can redistribute it and/or modify it
9  * under the terms of the GNU General Public License as published by the Free
10  * Software Foundation; either version 2 of the License, or (at your option)
11  * any later version.
12  *
13  */
14 
15 #include <linux/atomic.h>
16 #include <crypto/if_alg.h>
17 #include <linux/crypto.h>
18 #include <linux/init.h>
19 #include <linux/kernel.h>
20 #include <linux/list.h>
21 #include <linux/module.h>
22 #include <linux/net.h>
23 #include <linux/rwsem.h>
24 #include <linux/security.h>
25 
26 struct alg_type_list {
27 	const struct af_alg_type *type;
28 	struct list_head list;
29 };
30 
31 static atomic_long_t alg_memory_allocated;
32 
33 static struct proto alg_proto = {
34 	.name			= "ALG",
35 	.owner			= THIS_MODULE,
36 	.memory_allocated	= &alg_memory_allocated,
37 	.obj_size		= sizeof(struct alg_sock),
38 };
39 
40 static LIST_HEAD(alg_types);
41 static DECLARE_RWSEM(alg_types_sem);
42 
43 static const struct af_alg_type *alg_get_type(const char *name)
44 {
45 	const struct af_alg_type *type = ERR_PTR(-ENOENT);
46 	struct alg_type_list *node;
47 
48 	down_read(&alg_types_sem);
49 	list_for_each_entry(node, &alg_types, list) {
50 		if (strcmp(node->type->name, name))
51 			continue;
52 
53 		if (try_module_get(node->type->owner))
54 			type = node->type;
55 		break;
56 	}
57 	up_read(&alg_types_sem);
58 
59 	return type;
60 }
61 
62 int af_alg_register_type(const struct af_alg_type *type)
63 {
64 	struct alg_type_list *node;
65 	int err = -EEXIST;
66 
67 	down_write(&alg_types_sem);
68 	list_for_each_entry(node, &alg_types, list) {
69 		if (!strcmp(node->type->name, type->name))
70 			goto unlock;
71 	}
72 
73 	node = kmalloc(sizeof(*node), GFP_KERNEL);
74 	err = -ENOMEM;
75 	if (!node)
76 		goto unlock;
77 
78 	type->ops->owner = THIS_MODULE;
79 	node->type = type;
80 	list_add(&node->list, &alg_types);
81 	err = 0;
82 
83 unlock:
84 	up_write(&alg_types_sem);
85 
86 	return err;
87 }
88 EXPORT_SYMBOL_GPL(af_alg_register_type);
89 
90 int af_alg_unregister_type(const struct af_alg_type *type)
91 {
92 	struct alg_type_list *node;
93 	int err = -ENOENT;
94 
95 	down_write(&alg_types_sem);
96 	list_for_each_entry(node, &alg_types, list) {
97 		if (strcmp(node->type->name, type->name))
98 			continue;
99 
100 		list_del(&node->list);
101 		kfree(node);
102 		err = 0;
103 		break;
104 	}
105 	up_write(&alg_types_sem);
106 
107 	return err;
108 }
109 EXPORT_SYMBOL_GPL(af_alg_unregister_type);
110 
111 static void alg_do_release(const struct af_alg_type *type, void *private)
112 {
113 	if (!type)
114 		return;
115 
116 	type->release(private);
117 	module_put(type->owner);
118 }
119 
120 int af_alg_release(struct socket *sock)
121 {
122 	if (sock->sk)
123 		sock_put(sock->sk);
124 	return 0;
125 }
126 EXPORT_SYMBOL_GPL(af_alg_release);
127 
128 static int alg_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
129 {
130 	struct sock *sk = sock->sk;
131 	struct alg_sock *ask = alg_sk(sk);
132 	struct sockaddr_alg *sa = (void *)uaddr;
133 	const struct af_alg_type *type;
134 	void *private;
135 
136 	if (sock->state == SS_CONNECTED)
137 		return -EINVAL;
138 
139 	if (addr_len != sizeof(*sa))
140 		return -EINVAL;
141 
142 	sa->salg_type[sizeof(sa->salg_type) - 1] = 0;
143 	sa->salg_name[sizeof(sa->salg_name) - 1] = 0;
144 
145 	type = alg_get_type(sa->salg_type);
146 	if (IS_ERR(type) && PTR_ERR(type) == -ENOENT) {
147 		request_module("algif-%s", sa->salg_type);
148 		type = alg_get_type(sa->salg_type);
149 	}
150 
151 	if (IS_ERR(type))
152 		return PTR_ERR(type);
153 
154 	private = type->bind(sa->salg_name, sa->salg_feat, sa->salg_mask);
155 	if (IS_ERR(private)) {
156 		module_put(type->owner);
157 		return PTR_ERR(private);
158 	}
159 
160 	lock_sock(sk);
161 
162 	swap(ask->type, type);
163 	swap(ask->private, private);
164 
165 	release_sock(sk);
166 
167 	alg_do_release(type, private);
168 
169 	return 0;
170 }
171 
172 static int alg_setkey(struct sock *sk, char __user *ukey,
173 		      unsigned int keylen)
174 {
175 	struct alg_sock *ask = alg_sk(sk);
176 	const struct af_alg_type *type = ask->type;
177 	u8 *key;
178 	int err;
179 
180 	key = sock_kmalloc(sk, keylen, GFP_KERNEL);
181 	if (!key)
182 		return -ENOMEM;
183 
184 	err = -EFAULT;
185 	if (copy_from_user(key, ukey, keylen))
186 		goto out;
187 
188 	err = type->setkey(ask->private, key, keylen);
189 
190 out:
191 	sock_kzfree_s(sk, key, keylen);
192 
193 	return err;
194 }
195 
196 static int alg_setsockopt(struct socket *sock, int level, int optname,
197 			  char __user *optval, unsigned int optlen)
198 {
199 	struct sock *sk = sock->sk;
200 	struct alg_sock *ask = alg_sk(sk);
201 	const struct af_alg_type *type;
202 	int err = -ENOPROTOOPT;
203 
204 	lock_sock(sk);
205 	type = ask->type;
206 
207 	if (level != SOL_ALG || !type)
208 		goto unlock;
209 
210 	switch (optname) {
211 	case ALG_SET_KEY:
212 		if (sock->state == SS_CONNECTED)
213 			goto unlock;
214 		if (!type->setkey)
215 			goto unlock;
216 
217 		err = alg_setkey(sk, optval, optlen);
218 		break;
219 	case ALG_SET_AEAD_AUTHSIZE:
220 		if (sock->state == SS_CONNECTED)
221 			goto unlock;
222 		if (!type->setauthsize)
223 			goto unlock;
224 		err = type->setauthsize(ask->private, optlen);
225 	}
226 
227 unlock:
228 	release_sock(sk);
229 
230 	return err;
231 }
232 
233 int af_alg_accept(struct sock *sk, struct socket *newsock)
234 {
235 	struct alg_sock *ask = alg_sk(sk);
236 	const struct af_alg_type *type;
237 	struct sock *sk2;
238 	int err;
239 
240 	lock_sock(sk);
241 	type = ask->type;
242 
243 	err = -EINVAL;
244 	if (!type)
245 		goto unlock;
246 
247 	sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto);
248 	err = -ENOMEM;
249 	if (!sk2)
250 		goto unlock;
251 
252 	sock_init_data(newsock, sk2);
253 	sock_graft(sk2, newsock);
254 	security_sk_clone(sk, sk2);
255 
256 	err = type->accept(ask->private, sk2);
257 	if (err) {
258 		sk_free(sk2);
259 		goto unlock;
260 	}
261 
262 	sk2->sk_family = PF_ALG;
263 
264 	sock_hold(sk);
265 	alg_sk(sk2)->parent = sk;
266 	alg_sk(sk2)->type = type;
267 
268 	newsock->ops = type->ops;
269 	newsock->state = SS_CONNECTED;
270 
271 	err = 0;
272 
273 unlock:
274 	release_sock(sk);
275 
276 	return err;
277 }
278 EXPORT_SYMBOL_GPL(af_alg_accept);
279 
280 static int alg_accept(struct socket *sock, struct socket *newsock, int flags)
281 {
282 	return af_alg_accept(sock->sk, newsock);
283 }
284 
285 static const struct proto_ops alg_proto_ops = {
286 	.family		=	PF_ALG,
287 	.owner		=	THIS_MODULE,
288 
289 	.connect	=	sock_no_connect,
290 	.socketpair	=	sock_no_socketpair,
291 	.getname	=	sock_no_getname,
292 	.ioctl		=	sock_no_ioctl,
293 	.listen		=	sock_no_listen,
294 	.shutdown	=	sock_no_shutdown,
295 	.getsockopt	=	sock_no_getsockopt,
296 	.mmap		=	sock_no_mmap,
297 	.sendpage	=	sock_no_sendpage,
298 	.sendmsg	=	sock_no_sendmsg,
299 	.recvmsg	=	sock_no_recvmsg,
300 	.poll		=	sock_no_poll,
301 
302 	.bind		=	alg_bind,
303 	.release	=	af_alg_release,
304 	.setsockopt	=	alg_setsockopt,
305 	.accept		=	alg_accept,
306 };
307 
308 static void alg_sock_destruct(struct sock *sk)
309 {
310 	struct alg_sock *ask = alg_sk(sk);
311 
312 	alg_do_release(ask->type, ask->private);
313 }
314 
315 static int alg_create(struct net *net, struct socket *sock, int protocol,
316 		      int kern)
317 {
318 	struct sock *sk;
319 	int err;
320 
321 	if (sock->type != SOCK_SEQPACKET)
322 		return -ESOCKTNOSUPPORT;
323 	if (protocol != 0)
324 		return -EPROTONOSUPPORT;
325 
326 	err = -ENOMEM;
327 	sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto);
328 	if (!sk)
329 		goto out;
330 
331 	sock->ops = &alg_proto_ops;
332 	sock_init_data(sock, sk);
333 
334 	sk->sk_family = PF_ALG;
335 	sk->sk_destruct = alg_sock_destruct;
336 
337 	return 0;
338 out:
339 	return err;
340 }
341 
342 static const struct net_proto_family alg_family = {
343 	.family	=	PF_ALG,
344 	.create	=	alg_create,
345 	.owner	=	THIS_MODULE,
346 };
347 
348 int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len)
349 {
350 	size_t off;
351 	ssize_t n;
352 	int npages, i;
353 
354 	n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off);
355 	if (n < 0)
356 		return n;
357 
358 	npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT;
359 	if (WARN_ON(npages == 0))
360 		return -EINVAL;
361 	/* Add one extra for linking */
362 	sg_init_table(sgl->sg, npages + 1);
363 
364 	for (i = 0, len = n; i < npages; i++) {
365 		int plen = min_t(int, len, PAGE_SIZE - off);
366 
367 		sg_set_page(sgl->sg + i, sgl->pages[i], plen, off);
368 
369 		off = 0;
370 		len -= plen;
371 	}
372 	sg_mark_end(sgl->sg + npages - 1);
373 	sgl->npages = npages;
374 
375 	return n;
376 }
377 EXPORT_SYMBOL_GPL(af_alg_make_sg);
378 
379 void af_alg_link_sg(struct af_alg_sgl *sgl_prev, struct af_alg_sgl *sgl_new)
380 {
381 	sg_unmark_end(sgl_prev->sg + sgl_prev->npages - 1);
382 	sg_chain(sgl_prev->sg, sgl_prev->npages + 1, sgl_new->sg);
383 }
384 EXPORT_SYMBOL_GPL(af_alg_link_sg);
385 
386 void af_alg_free_sg(struct af_alg_sgl *sgl)
387 {
388 	int i;
389 
390 	for (i = 0; i < sgl->npages; i++)
391 		put_page(sgl->pages[i]);
392 }
393 EXPORT_SYMBOL_GPL(af_alg_free_sg);
394 
395 int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
396 {
397 	struct cmsghdr *cmsg;
398 
399 	for_each_cmsghdr(cmsg, msg) {
400 		if (!CMSG_OK(msg, cmsg))
401 			return -EINVAL;
402 		if (cmsg->cmsg_level != SOL_ALG)
403 			continue;
404 
405 		switch (cmsg->cmsg_type) {
406 		case ALG_SET_IV:
407 			if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
408 				return -EINVAL;
409 			con->iv = (void *)CMSG_DATA(cmsg);
410 			if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
411 						      sizeof(*con->iv)))
412 				return -EINVAL;
413 			break;
414 
415 		case ALG_SET_OP:
416 			if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
417 				return -EINVAL;
418 			con->op = *(u32 *)CMSG_DATA(cmsg);
419 			break;
420 
421 		case ALG_SET_AEAD_ASSOCLEN:
422 			if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
423 				return -EINVAL;
424 			con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
425 			break;
426 
427 		default:
428 			return -EINVAL;
429 		}
430 	}
431 
432 	return 0;
433 }
434 EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
435 
436 int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
437 {
438 	switch (err) {
439 	case -EINPROGRESS:
440 	case -EBUSY:
441 		wait_for_completion(&completion->completion);
442 		reinit_completion(&completion->completion);
443 		err = completion->err;
444 		break;
445 	};
446 
447 	return err;
448 }
449 EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
450 
451 void af_alg_complete(struct crypto_async_request *req, int err)
452 {
453 	struct af_alg_completion *completion = req->data;
454 
455 	if (err == -EINPROGRESS)
456 		return;
457 
458 	completion->err = err;
459 	complete(&completion->completion);
460 }
461 EXPORT_SYMBOL_GPL(af_alg_complete);
462 
463 static int __init af_alg_init(void)
464 {
465 	int err = proto_register(&alg_proto, 0);
466 
467 	if (err)
468 		goto out;
469 
470 	err = sock_register(&alg_family);
471 	if (err != 0)
472 		goto out_unregister_proto;
473 
474 out:
475 	return err;
476 
477 out_unregister_proto:
478 	proto_unregister(&alg_proto);
479 	goto out;
480 }
481 
482 static void __exit af_alg_exit(void)
483 {
484 	sock_unregister(PF_ALG);
485 	proto_unregister(&alg_proto);
486 }
487 
488 module_init(af_alg_init);
489 module_exit(af_alg_exit);
490 MODULE_LICENSE("GPL");
491 MODULE_ALIAS_NETPROTO(AF_ALG);
492