blob: 76d739d08211892c37f2f1be5162fa6c58ad0187 [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
348int af_alg_make_sg(struct af_alg_sgl *sgl, void __user *addr, int len,
349 int write)
350{
351 unsigned long from = (unsigned long)addr;
352 unsigned long npages;
353 unsigned off;
354 int err;
355 int i;
356
357 err = -EFAULT;
358 if (!access_ok(write ? VERIFY_READ : VERIFY_WRITE, addr, len))
359 goto out;
360
361 off = from & ~PAGE_MASK;
362 npages = (off + len + PAGE_SIZE - 1) >> PAGE_SHIFT;
363 if (npages > ALG_MAX_PAGES)
364 npages = ALG_MAX_PAGES;
365
366 err = get_user_pages_fast(from, npages, write, sgl->pages);
367 if (err < 0)
368 goto out;
369
370 npages = err;
371 err = -EINVAL;
372 if (WARN_ON(npages == 0))
373 goto out;
374
375 err = 0;
376
377 sg_init_table(sgl->sg, npages);
378
379 for (i = 0; i < npages; i++) {
380 int plen = min_t(int, len, PAGE_SIZE - off);
381
382 sg_set_page(sgl->sg + i, sgl->pages[i], plen, off);
383
384 off = 0;
385 len -= plen;
386 err += plen;
387 }
388
389out:
390 return err;
391}
392EXPORT_SYMBOL_GPL(af_alg_make_sg);
393
394void af_alg_free_sg(struct af_alg_sgl *sgl)
395{
396 int i;
397
398 i = 0;
399 do {
400 put_page(sgl->pages[i]);
401 } while (!sg_is_last(sgl->sg + (i++)));
402}
403EXPORT_SYMBOL_GPL(af_alg_free_sg);
404
405int af_alg_cmsg_send(struct msghdr *msg, struct af_alg_control *con)
406{
407 struct cmsghdr *cmsg;
408
Gu Zhengf95b4142014-12-11 11:22:04 +0800409 for_each_cmsghdr(cmsg, msg) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800410 if (!CMSG_OK(msg, cmsg))
411 return -EINVAL;
412 if (cmsg->cmsg_level != SOL_ALG)
413 continue;
414
Joshua I. James267c4222014-12-05 14:38:40 +0900415 switch (cmsg->cmsg_type) {
Herbert Xu03c8efc2010-10-19 21:12:39 +0800416 case ALG_SET_IV:
417 if (cmsg->cmsg_len < CMSG_LEN(sizeof(*con->iv)))
418 return -EINVAL;
419 con->iv = (void *)CMSG_DATA(cmsg);
420 if (cmsg->cmsg_len < CMSG_LEN(con->iv->ivlen +
421 sizeof(*con->iv)))
422 return -EINVAL;
423 break;
424
425 case ALG_SET_OP:
426 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
427 return -EINVAL;
428 con->op = *(u32 *)CMSG_DATA(cmsg);
429 break;
430
Stephan Muelleraf8e8072014-12-03 20:55:42 +0100431 case ALG_SET_AEAD_ASSOCLEN:
432 if (cmsg->cmsg_len < CMSG_LEN(sizeof(u32)))
433 return -EINVAL;
434 con->aead_assoclen = *(u32 *)CMSG_DATA(cmsg);
435 break;
436
Herbert Xu03c8efc2010-10-19 21:12:39 +0800437 default:
438 return -EINVAL;
439 }
440 }
441
442 return 0;
443}
444EXPORT_SYMBOL_GPL(af_alg_cmsg_send);
445
446int af_alg_wait_for_completion(int err, struct af_alg_completion *completion)
447{
448 switch (err) {
449 case -EINPROGRESS:
450 case -EBUSY:
451 wait_for_completion(&completion->completion);
Wolfram Sang16735d02013-11-14 14:32:02 -0800452 reinit_completion(&completion->completion);
Herbert Xu03c8efc2010-10-19 21:12:39 +0800453 err = completion->err;
454 break;
455 };
456
457 return err;
458}
459EXPORT_SYMBOL_GPL(af_alg_wait_for_completion);
460
461void af_alg_complete(struct crypto_async_request *req, int err)
462{
463 struct af_alg_completion *completion = req->data;
464
Rabin Vincent7e77bde2014-12-19 13:36:08 +0100465 if (err == -EINPROGRESS)
466 return;
467
Herbert Xu03c8efc2010-10-19 21:12:39 +0800468 completion->err = err;
469 complete(&completion->completion);
470}
471EXPORT_SYMBOL_GPL(af_alg_complete);
472
473static int __init af_alg_init(void)
474{
475 int err = proto_register(&alg_proto, 0);
476
477 if (err)
478 goto out;
479
480 err = sock_register(&alg_family);
481 if (err != 0)
482 goto out_unregister_proto;
483
484out:
485 return err;
486
487out_unregister_proto:
488 proto_unregister(&alg_proto);
489 goto out;
490}
491
492static void __exit af_alg_exit(void)
493{
494 sock_unregister(PF_ALG);
495 proto_unregister(&alg_proto);
496}
497
498module_init(af_alg_init);
499module_exit(af_alg_exit);
500MODULE_LICENSE("GPL");
501MODULE_ALIAS_NETPROTO(AF_ALG);