blob: 3e80d8b8be4571fa89185df5bb4883427c37764b [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:
191 sock_kfree_s(sk, key, keylen);
192
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);
218 }
219
220unlock:
221 release_sock(sk);
222
223 return err;
224}
225
226int af_alg_accept(struct sock *sk, struct socket *newsock)
227{
228 struct alg_sock *ask = alg_sk(sk);
229 const struct af_alg_type *type;
230 struct sock *sk2;
231 int err;
232
233 lock_sock(sk);
234 type = ask->type;
235
236 err = -EINVAL;
237 if (!type)
238 goto unlock;
239
240 sk2 = sk_alloc(sock_net(sk), PF_ALG, GFP_KERNEL, &alg_proto);
241 err = -ENOMEM;
242 if (!sk2)
243 goto unlock;
244
245 sock_init_data(newsock, sk2);
Miloslav Trmač507cad32010-12-08 14:36:19 +0800246 sock_graft(sk2, newsock);
Milan Broz4c63f832014-07-29 18:41:09 +0000247 security_sk_clone(sk, sk2);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800248
249 err = type->accept(ask->private, sk2);
250 if (err) {
251 sk_free(sk2);
252 goto unlock;
253 }
254
255 sk2->sk_family = PF_ALG;
256
257 sock_hold(sk);
258 alg_sk(sk2)->parent = sk;
259 alg_sk(sk2)->type = type;
260
261 newsock->ops = type->ops;
262 newsock->state = SS_CONNECTED;
263
264 err = 0;
265
266unlock:
267 release_sock(sk);
268
269 return err;
270}
271EXPORT_SYMBOL_GPL(af_alg_accept);
272
273static int alg_accept(struct socket *sock, struct socket *newsock, int flags)
274{
275 return af_alg_accept(sock->sk, newsock);
276}
277
278static const struct proto_ops alg_proto_ops = {
279 .family = PF_ALG,
280 .owner = THIS_MODULE,
281
282 .connect = sock_no_connect,
283 .socketpair = sock_no_socketpair,
284 .getname = sock_no_getname,
285 .ioctl = sock_no_ioctl,
286 .listen = sock_no_listen,
287 .shutdown = sock_no_shutdown,
288 .getsockopt = sock_no_getsockopt,
289 .mmap = sock_no_mmap,
290 .sendpage = sock_no_sendpage,
291 .sendmsg = sock_no_sendmsg,
292 .recvmsg = sock_no_recvmsg,
293 .poll = sock_no_poll,
294
295 .bind = alg_bind,
296 .release = af_alg_release,
297 .setsockopt = alg_setsockopt,
298 .accept = alg_accept,
299};
300
301static void alg_sock_destruct(struct sock *sk)
302{
303 struct alg_sock *ask = alg_sk(sk);
304
305 alg_do_release(ask->type, ask->private);
306}
307
308static int alg_create(struct net *net, struct socket *sock, int protocol,
309 int kern)
310{
311 struct sock *sk;
312 int err;
313
314 if (sock->type != SOCK_SEQPACKET)
315 return -ESOCKTNOSUPPORT;
316 if (protocol != 0)
317 return -EPROTONOSUPPORT;
318
319 err = -ENOMEM;
320 sk = sk_alloc(net, PF_ALG, GFP_KERNEL, &alg_proto);
321 if (!sk)
322 goto out;
323
324 sock->ops = &alg_proto_ops;
325 sock_init_data(sock, sk);
326
327 sk->sk_family = PF_ALG;
328 sk->sk_destruct = alg_sock_destruct;
329
330 return 0;
331out:
332 return err;
333}
334
335static const struct net_proto_family alg_family = {
336 .family = PF_ALG,
337 .create = alg_create,
338 .owner = THIS_MODULE,
339};
340
Al Viro1d10eb22014-11-28 16:39:25 -0500341int af_alg_make_sg(struct af_alg_sgl *sgl, struct iov_iter *iter, int len)
Herbert Xu03c8efc2010-10-19 21:12:39 +0800342{
Al Viro1d10eb22014-11-28 16:39:25 -0500343 size_t off;
344 ssize_t n;
345 int npages, i;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800346
Al Viro1d10eb22014-11-28 16:39:25 -0500347 n = iov_iter_get_pages(iter, sgl->pages, len, ALG_MAX_PAGES, &off);
348 if (n < 0)
349 return n;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800350
Linus Torvalds9399f0c2015-02-10 19:55:45 -0800351 npages = (off + n + PAGE_SIZE - 1) >> PAGE_SHIFT;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800352 if (WARN_ON(npages == 0))
Al Viro1d10eb22014-11-28 16:39:25 -0500353 return -EINVAL;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800354
355 sg_init_table(sgl->sg, npages);
356
Al Viro1d10eb22014-11-28 16:39:25 -0500357 for (i = 0, len = n; i < npages; i++) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800358 int plen = min_t(int, len, PAGE_SIZE - off);
359
360 sg_set_page(sgl->sg + i, sgl->pages[i], plen, off);
361
362 off = 0;
363 len -= plen;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800364 }
Al Viro1d10eb22014-11-28 16:39:25 -0500365 return n;
Herbert Xu03c8efc2010-10-19 21:12:39 +0800366}
367EXPORT_SYMBOL_GPL(af_alg_make_sg);
368
369void af_alg_free_sg(struct af_alg_sgl *sgl)
370{
371 int i;
372
373 i = 0;
374 do {
375 put_page(sgl->pages[i]);
376 } while (!sg_is_last(sgl->sg + (i++)));
377}
378EXPORT_SYMBOL_GPL(af_alg_free_sg);
379
380int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
381{
382 struct cmsghdr *cmsg;
383
Gu Zhengf95b4142014-12-11 11:22:04 +0800384 for_each_cmsghdr(cmsg, msg) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800385 if (!CMSG_OK(msg, cmsg))
386 return -EINVAL;
387 if (cmsg->cmsg_level != SOL_ALG)
388 continue;
389
390 switch(cmsg->cmsg_type) {
391 case ALG_SET_IV:
392 if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
393 return -EINVAL;
394 con->iv = (void *)CMSG_DATA(cmsg);
395 if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
396 sizeof(*con->iv)))
397 return -EINVAL;
398 break;
399
400 case ALG_SET_OP:
401 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
402 return -EINVAL;
403 con->op = *(u32 *)CMSG_DATA(cmsg);
404 break;
405
Stephan Muelleraf8e8072014-12-03 20:55:42 +0100406 case ALG_SET_AEAD_ASSOCLEN:
407 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
408 return -EINVAL;
409 con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
410 break;
411
Herbert Xu03c8efc2010-10-19 21:12:39 +0800412 default:
413 return -EINVAL;
414 }
415 }
416
417 return 0;
418}
419EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
420
421int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
422{
423 switch (err) {
424 case -EINPROGRESS:
425 case -EBUSY:
426 wait_for_completion(&completion->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800427 reinit_completion(&completion->completion);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800428 err = completion->err;
429 break;
430 };
431
432 return err;
433}
434EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
435
436void af_alg_complete(struct crypto_async_request *req, int err)
437{
438 struct af_alg_completion *completion = req->data;
439
Rabin Vincent7e77bde2014-12-19 13:36:08 +0100440 if (err == -EINPROGRESS)
441 return;
442
Herbert Xu03c8efc2010-10-19 21:12:39 +0800443 completion->err = err;
444 complete(&completion->completion);
445}
446EXPORT_SYMBOL_GPL(af_alg_complete);
447
448static int __init af_alg_init(void)
449{
450 int err = proto_register(&alg_proto, 0);
451
452 if (err)
453 goto out;
454
455 err = sock_register(&alg_family);
456 if (err != 0)
457 goto out_unregister_proto;
458
459out:
460 return err;
461
462out_unregister_proto:
463 proto_unregister(&alg_proto);
464 goto out;
465}
466
467static void __exit af_alg_exit(void)
468{
469 sock_unregister(PF_ALG);
470 proto_unregister(&alg_proto);
471}
472
473module_init(af_alg_init);
474module_exit(af_alg_exit);
475MODULE_LICENSE("GPL");
476MODULE_ALIAS_NETPROTO(AF_ALG);