Merge branch 'work.sock_recvmsg' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-2.6-block.git] / crypto / algif_skcipher.c
1 /*
2  * algif_skcipher: User-space interface for skcipher algorithms
3  *
4  * This file provides the user-space API for symmetric key ciphers.
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  * The following concept of the memory management is used:
14  *
15  * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
16  * filled by user space with the data submitted via sendpage/sendmsg. Filling
17  * up the TX SGL does not cause a crypto operation -- the data will only be
18  * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
19  * provide a buffer which is tracked with the RX SGL.
20  *
21  * During the processing of the recvmsg operation, the cipher request is
22  * allocated and prepared. As part of the recvmsg operation, the processed
23  * TX buffers are extracted from the TX SGL into a separate SGL.
24  *
25  * After the completion of the crypto operation, the RX SGL and the cipher
26  * request is released. The extracted TX SGL parts are released together with
27  * the RX SGL release.
28  */
29
30 #include <crypto/scatterwalk.h>
31 #include <crypto/skcipher.h>
32 #include <crypto/if_alg.h>
33 #include <linux/init.h>
34 #include <linux/list.h>
35 #include <linux/kernel.h>
36 #include <linux/mm.h>
37 #include <linux/module.h>
38 #include <linux/net.h>
39 #include <net/sock.h>
40
41 struct skcipher_tfm {
42         struct crypto_skcipher *skcipher;
43         bool has_key;
44 };
45
46 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
47                             size_t size)
48 {
49         struct sock *sk = sock->sk;
50         struct alg_sock *ask = alg_sk(sk);
51         struct sock *psk = ask->parent;
52         struct alg_sock *pask = alg_sk(psk);
53         struct skcipher_tfm *skc = pask->private;
54         struct crypto_skcipher *tfm = skc->skcipher;
55         unsigned ivsize = crypto_skcipher_ivsize(tfm);
56
57         return af_alg_sendmsg(sock, msg, size, ivsize);
58 }
59
60 static int _skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
61                              size_t ignored, int flags)
62 {
63         struct sock *sk = sock->sk;
64         struct alg_sock *ask = alg_sk(sk);
65         struct sock *psk = ask->parent;
66         struct alg_sock *pask = alg_sk(psk);
67         struct af_alg_ctx *ctx = ask->private;
68         struct skcipher_tfm *skc = pask->private;
69         struct crypto_skcipher *tfm = skc->skcipher;
70         unsigned int bs = crypto_skcipher_blocksize(tfm);
71         struct af_alg_async_req *areq;
72         int err = 0;
73         size_t len = 0;
74
75         if (!ctx->used) {
76                 err = af_alg_wait_for_data(sk, flags);
77                 if (err)
78                         return err;
79         }
80
81         /* Allocate cipher request for current operation. */
82         areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
83                                      crypto_skcipher_reqsize(tfm));
84         if (IS_ERR(areq))
85                 return PTR_ERR(areq);
86
87         /* convert iovecs of output buffers into RX SGL */
88         err = af_alg_get_rsgl(sk, msg, flags, areq, -1, &len);
89         if (err)
90                 goto free;
91
92         /* Process only as much RX buffers for which we have TX data */
93         if (len > ctx->used)
94                 len = ctx->used;
95
96         /*
97          * If more buffers are to be expected to be processed, process only
98          * full block size buffers.
99          */
100         if (ctx->more || len < ctx->used)
101                 len -= len % bs;
102
103         /*
104          * Create a per request TX SGL for this request which tracks the
105          * SG entries from the global TX SGL.
106          */
107         areq->tsgl_entries = af_alg_count_tsgl(sk, len, 0);
108         if (!areq->tsgl_entries)
109                 areq->tsgl_entries = 1;
110         areq->tsgl = sock_kmalloc(sk, sizeof(*areq->tsgl) * areq->tsgl_entries,
111                                   GFP_KERNEL);
112         if (!areq->tsgl) {
113                 err = -ENOMEM;
114                 goto free;
115         }
116         sg_init_table(areq->tsgl, areq->tsgl_entries);
117         af_alg_pull_tsgl(sk, len, areq->tsgl, 0);
118
119         /* Initialize the crypto operation */
120         skcipher_request_set_tfm(&areq->cra_u.skcipher_req, tfm);
121         skcipher_request_set_crypt(&areq->cra_u.skcipher_req, areq->tsgl,
122                                    areq->first_rsgl.sgl.sg, len, ctx->iv);
123
124         if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
125                 /* AIO operation */
126                 sock_hold(sk);
127                 areq->iocb = msg->msg_iocb;
128
129                 /* Remember output size that will be generated. */
130                 areq->outlen = len;
131
132                 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
133                                               CRYPTO_TFM_REQ_MAY_SLEEP,
134                                               af_alg_async_cb, areq);
135                 err = ctx->enc ?
136                         crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
137                         crypto_skcipher_decrypt(&areq->cra_u.skcipher_req);
138
139                 /* AIO operation in progress */
140                 if (err == -EINPROGRESS || err == -EBUSY)
141                         return -EIOCBQUEUED;
142
143                 sock_put(sk);
144         } else {
145                 /* Synchronous operation */
146                 skcipher_request_set_callback(&areq->cra_u.skcipher_req,
147                                               CRYPTO_TFM_REQ_MAY_SLEEP |
148                                               CRYPTO_TFM_REQ_MAY_BACKLOG,
149                                               crypto_req_done, &ctx->wait);
150                 err = crypto_wait_req(ctx->enc ?
151                         crypto_skcipher_encrypt(&areq->cra_u.skcipher_req) :
152                         crypto_skcipher_decrypt(&areq->cra_u.skcipher_req),
153                                                  &ctx->wait);
154         }
155
156
157 free:
158         af_alg_free_resources(areq);
159
160         return err ? err : len;
161 }
162
163 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
164                             size_t ignored, int flags)
165 {
166         struct sock *sk = sock->sk;
167         int ret = 0;
168
169         lock_sock(sk);
170         while (msg_data_left(msg)) {
171                 int err = _skcipher_recvmsg(sock, msg, ignored, flags);
172
173                 /*
174                  * This error covers -EIOCBQUEUED which implies that we can
175                  * only handle one AIO request. If the caller wants to have
176                  * multiple AIO requests in parallel, he must make multiple
177                  * separate AIO calls.
178                  *
179                  * Also return the error if no data has been processed so far.
180                  */
181                 if (err <= 0) {
182                         if (err == -EIOCBQUEUED || !ret)
183                                 ret = err;
184                         goto out;
185                 }
186
187                 ret += err;
188         }
189
190 out:
191         af_alg_wmem_wakeup(sk);
192         release_sock(sk);
193         return ret;
194 }
195
196 static struct proto_ops algif_skcipher_ops = {
197         .family         =       PF_ALG,
198
199         .connect        =       sock_no_connect,
200         .socketpair     =       sock_no_socketpair,
201         .getname        =       sock_no_getname,
202         .ioctl          =       sock_no_ioctl,
203         .listen         =       sock_no_listen,
204         .shutdown       =       sock_no_shutdown,
205         .getsockopt     =       sock_no_getsockopt,
206         .mmap           =       sock_no_mmap,
207         .bind           =       sock_no_bind,
208         .accept         =       sock_no_accept,
209         .setsockopt     =       sock_no_setsockopt,
210
211         .release        =       af_alg_release,
212         .sendmsg        =       skcipher_sendmsg,
213         .sendpage       =       af_alg_sendpage,
214         .recvmsg        =       skcipher_recvmsg,
215         .poll           =       af_alg_poll,
216 };
217
218 static int skcipher_check_key(struct socket *sock)
219 {
220         int err = 0;
221         struct sock *psk;
222         struct alg_sock *pask;
223         struct skcipher_tfm *tfm;
224         struct sock *sk = sock->sk;
225         struct alg_sock *ask = alg_sk(sk);
226
227         lock_sock(sk);
228         if (ask->refcnt)
229                 goto unlock_child;
230
231         psk = ask->parent;
232         pask = alg_sk(ask->parent);
233         tfm = pask->private;
234
235         err = -ENOKEY;
236         lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
237         if (!tfm->has_key)
238                 goto unlock;
239
240         if (!pask->refcnt++)
241                 sock_hold(psk);
242
243         ask->refcnt = 1;
244         sock_put(psk);
245
246         err = 0;
247
248 unlock:
249         release_sock(psk);
250 unlock_child:
251         release_sock(sk);
252
253         return err;
254 }
255
256 static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
257                                   size_t size)
258 {
259         int err;
260
261         err = skcipher_check_key(sock);
262         if (err)
263                 return err;
264
265         return skcipher_sendmsg(sock, msg, size);
266 }
267
268 static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
269                                        int offset, size_t size, int flags)
270 {
271         int err;
272
273         err = skcipher_check_key(sock);
274         if (err)
275                 return err;
276
277         return af_alg_sendpage(sock, page, offset, size, flags);
278 }
279
280 static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
281                                   size_t ignored, int flags)
282 {
283         int err;
284
285         err = skcipher_check_key(sock);
286         if (err)
287                 return err;
288
289         return skcipher_recvmsg(sock, msg, ignored, flags);
290 }
291
292 static struct proto_ops algif_skcipher_ops_nokey = {
293         .family         =       PF_ALG,
294
295         .connect        =       sock_no_connect,
296         .socketpair     =       sock_no_socketpair,
297         .getname        =       sock_no_getname,
298         .ioctl          =       sock_no_ioctl,
299         .listen         =       sock_no_listen,
300         .shutdown       =       sock_no_shutdown,
301         .getsockopt     =       sock_no_getsockopt,
302         .mmap           =       sock_no_mmap,
303         .bind           =       sock_no_bind,
304         .accept         =       sock_no_accept,
305         .setsockopt     =       sock_no_setsockopt,
306
307         .release        =       af_alg_release,
308         .sendmsg        =       skcipher_sendmsg_nokey,
309         .sendpage       =       skcipher_sendpage_nokey,
310         .recvmsg        =       skcipher_recvmsg_nokey,
311         .poll           =       af_alg_poll,
312 };
313
314 static void *skcipher_bind(const char *name, u32 type, u32 mask)
315 {
316         struct skcipher_tfm *tfm;
317         struct crypto_skcipher *skcipher;
318
319         tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
320         if (!tfm)
321                 return ERR_PTR(-ENOMEM);
322
323         skcipher = crypto_alloc_skcipher(name, type, mask);
324         if (IS_ERR(skcipher)) {
325                 kfree(tfm);
326                 return ERR_CAST(skcipher);
327         }
328
329         tfm->skcipher = skcipher;
330
331         return tfm;
332 }
333
334 static void skcipher_release(void *private)
335 {
336         struct skcipher_tfm *tfm = private;
337
338         crypto_free_skcipher(tfm->skcipher);
339         kfree(tfm);
340 }
341
342 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
343 {
344         struct skcipher_tfm *tfm = private;
345         int err;
346
347         err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
348         tfm->has_key = !err;
349
350         return err;
351 }
352
353 static void skcipher_sock_destruct(struct sock *sk)
354 {
355         struct alg_sock *ask = alg_sk(sk);
356         struct af_alg_ctx *ctx = ask->private;
357         struct sock *psk = ask->parent;
358         struct alg_sock *pask = alg_sk(psk);
359         struct skcipher_tfm *skc = pask->private;
360         struct crypto_skcipher *tfm = skc->skcipher;
361
362         af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
363         sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
364         sock_kfree_s(sk, ctx, ctx->len);
365         af_alg_release_parent(sk);
366 }
367
368 static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
369 {
370         struct af_alg_ctx *ctx;
371         struct alg_sock *ask = alg_sk(sk);
372         struct skcipher_tfm *tfm = private;
373         struct crypto_skcipher *skcipher = tfm->skcipher;
374         unsigned int len = sizeof(*ctx);
375
376         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
377         if (!ctx)
378                 return -ENOMEM;
379
380         ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
381                                GFP_KERNEL);
382         if (!ctx->iv) {
383                 sock_kfree_s(sk, ctx, len);
384                 return -ENOMEM;
385         }
386
387         memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));
388
389         INIT_LIST_HEAD(&ctx->tsgl_list);
390         ctx->len = len;
391         ctx->used = 0;
392         atomic_set(&ctx->rcvused, 0);
393         ctx->more = 0;
394         ctx->merge = 0;
395         ctx->enc = 0;
396         crypto_init_wait(&ctx->wait);
397
398         ask->private = ctx;
399
400         sk->sk_destruct = skcipher_sock_destruct;
401
402         return 0;
403 }
404
405 static int skcipher_accept_parent(void *private, struct sock *sk)
406 {
407         struct skcipher_tfm *tfm = private;
408
409         if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
410                 return -ENOKEY;
411
412         return skcipher_accept_parent_nokey(private, sk);
413 }
414
415 static const struct af_alg_type algif_type_skcipher = {
416         .bind           =       skcipher_bind,
417         .release        =       skcipher_release,
418         .setkey         =       skcipher_setkey,
419         .accept         =       skcipher_accept_parent,
420         .accept_nokey   =       skcipher_accept_parent_nokey,
421         .ops            =       &algif_skcipher_ops,
422         .ops_nokey      =       &algif_skcipher_ops_nokey,
423         .name           =       "skcipher",
424         .owner          =       THIS_MODULE
425 };
426
427 static int __init algif_skcipher_init(void)
428 {
429         return af_alg_register_type(&algif_type_skcipher);
430 }
431
432 static void __exit algif_skcipher_exit(void)
433 {
434         int err = af_alg_unregister_type(&algif_type_skcipher);
435         BUG_ON(err);
436 }
437
438 module_init(algif_skcipher_init);
439 module_exit(algif_skcipher_exit);
440 MODULE_LICENSE("GPL");