blob: 7f8b7edcadca3f64168e3451e52642a485a5d51f [file] [log] [blame]
Herbert Xu03c8efc2010-10-19 21:12:39 +08001/*
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
Arun Sharma600634972011-07-26 16:09:06 -070015#include <linux/atomic.h>
Herbert Xu03c8efc2010-10-19 21:12:39 +080016#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>
Milan Broz4c63f832014-07-29 18:41:09 +000024#include <linux/security.h>
Herbert Xu03c8efc2010-10-19 21:12:39 +080025
26struct alg_type_list {
27 const struct af_alg_type *type;
28 struct list_head list;
29};
30
Randy Dunlap06869522010-12-21 22:22:40 +110031static atomic_long_t alg_memory_allocated;
Herbert Xu03c8efc2010-10-19 21:12:39 +080032
33static 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
40static LIST_HEAD(alg_types);
41static DECLARE_RWSEM(alg_types_sem);
42
43static 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
62int 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
83unlock:
84 up_write(&alg_types_sem);
85
86 return err;
87}
88EXPORT_SYMBOL_GPL(af_alg_register_type);
89
90int 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}
109EXPORT_SYMBOL_GPL(af_alg_unregister_type);
110
111static 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
120int af_alg_release(struct socket *sock)
121{
122 if (sock->sk)
123 sock_put(sock->sk);
124 return 0;
125}
126EXPORT_SYMBOL_GPL(af_alg_release);
127
128static 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
172static 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
190out:
Stephan Muellerad202c82014-12-23 09:34:03 +0100191 sock_kzfree_s(sk, key, keylen);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800192
193 return err;
194}
195
196static 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);
Stephan Mueller25fb8632014-12-07 23:21:42 +0100218 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);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800225 }
226
227unlock:
228 release_sock(sk);
229
230 return err;
231}
232
233int 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);
Miloslav Trmač507cad32010-12-08 14:36:19 +0800253 sock_graft(sk2, newsock);
Milan Broz4c63f832014-07-29 18:41:09 +0000254 security_sk_clone(sk, sk2);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800255
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
273unlock:
274 release_sock(sk);
275
276 return err;
277}
278EXPORT_SYMBOL_GPL(af_alg_accept);
279
280static int alg_accept(struct socket *sock, struct socket *newsock, int flags)
281{
282 return af_alg_accept(sock->sk, newsock);
283}
284
285static 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
308static 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
315static 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;
338out:
339 return err;
340}
341
342static const struct net_proto_family alg_family = {
343 .family = PF_ALG,
344 .create = alg_create,
345 .owner = THIS_MODULE,
346};
347
Al Viro1d10eb22014-11-28 16:39:25 -0500348int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len)
Herbert Xu03c8efc2010-10-19 21:12:39 +0800349{
Al Viro1d10eb22014-11-28 16:39:25 -0500350 size_t off;
351 ssize_t n;
352 int npages, i;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800353
Al Viro1d10eb22014-11-28 16:39:25 -0500354 n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off);
355 if (n < 0)
356 return n;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800357
Linus Torvalds9399f0c2015-02-10 19:55:45 -0800358 npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800359 if (WARN_ON(npages == 0))
Al Viro1d10eb22014-11-28 16:39:25 -0500360 return -EINVAL;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800361
362 sg_init_table(sgl->sg, npages);
363
Al Viro1d10eb22014-11-28 16:39:25 -0500364 for (i = 0, len = n; i < npages; i++) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800365 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;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800371 }
Al Viro1d10eb22014-11-28 16:39:25 -0500372 return n;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800373}
374EXPORT_SYMBOL_GPL(af_alg_make_sg);
375
376void af_alg_free_sg(struct af_alg_sgl *sgl)
377{
378 int i;
379
380 i = 0;
381 do {
382 put_page(sgl->pages[i]);
383 } while (!sg_is_last(sgl->sg + (i++)));
384}
385EXPORT_SYMBOL_GPL(af_alg_free_sg);
386
387int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
388{
389 struct cmsghdr *cmsg;
390
Gu Zhengf95b4142014-12-11 11:22:04 +0800391 for_each_cmsghdr(cmsg, msg) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800392 if (!CMSG_OK(msg, cmsg))
393 return -EINVAL;
394 if (cmsg->cmsg_level != SOL_ALG)
395 continue;
396
Joshua I. James267c4222014-12-05 14:38:40 +0900397 switch (cmsg->cmsg_type) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800398 case ALG_SET_IV:
399 if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
400 return -EINVAL;
401 con->iv = (void *)CMSG_DATA(cmsg);
402 if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
403 sizeof(*con->iv)))
404 return -EINVAL;
405 break;
406
407 case ALG_SET_OP:
408 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
409 return -EINVAL;
410 con->op = *(u32 *)CMSG_DATA(cmsg);
411 break;
412
Stephan Muelleraf8e8072014-12-03 20:55:42 +0100413 case ALG_SET_AEAD_ASSOCLEN:
414 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
415 return -EINVAL;
416 con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
417 break;
418
Herbert Xu03c8efc2010-10-19 21:12:39 +0800419 default:
420 return -EINVAL;
421 }
422 }
423
424 return 0;
425}
426EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
427
428int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
429{
430 switch (err) {
431 case -EINPROGRESS:
432 case -EBUSY:
433 wait_for_completion(&completion->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800434 reinit_completion(&completion->completion);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800435 err = completion->err;
436 break;
437 };
438
439 return err;
440}
441EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
442
443void af_alg_complete(struct crypto_async_request *req, int err)
444{
445 struct af_alg_completion *completion = req->data;
446
Rabin Vincent7e77bde2014-12-19 13:36:08 +0100447 if (err == -EINPROGRESS)
448 return;
449
Herbert Xu03c8efc2010-10-19 21:12:39 +0800450 completion->err = err;
451 complete(&completion->completion);
452}
453EXPORT_SYMBOL_GPL(af_alg_complete);
454
455static int __init af_alg_init(void)
456{
457 int err = proto_register(&alg_proto, 0);
458
459 if (err)
460 goto out;
461
462 err = sock_register(&alg_family);
463 if (err != 0)
464 goto out_unregister_proto;
465
466out:
467 return err;
468
469out_unregister_proto:
470 proto_unregister(&alg_proto);
471 goto out;
472}
473
474static void __exit af_alg_exit(void)
475{
476 sock_unregister(PF_ALG);
477 proto_unregister(&alg_proto);
478}
479
480module_init(af_alg_init);
481module_exit(af_alg_exit);
482MODULE_LICENSE("GPL");
483MODULE_ALIAS_NETPROTO(AF_ALG);