To update vsperf/packet-forwarding configuration files
[kvmfornfv.git] / kernel / crypto / algif_aead.c
1 /*
2  * algif_aead: User-space interface for AEAD algorithms
3  *
4  * Copyright (C) 2014, Stephan Mueller <smueller@chronox.de>
5  *
6  * This file provides the user-space API for AEAD ciphers.
7  *
8  * This file is derived from algif_skcipher.c.
9  *
10  * This program is free software; you can redistribute it and/or modify it
11  * under the terms of the GNU General Public License as published by the Free
12  * Software Foundation; either version 2 of the License, or (at your option)
13  * any later version.
14  */
15
16 #include <crypto/aead.h>
17 #include <crypto/scatterwalk.h>
18 #include <crypto/if_alg.h>
19 #include <linux/init.h>
20 #include <linux/list.h>
21 #include <linux/kernel.h>
22 #include <linux/mm.h>
23 #include <linux/module.h>
24 #include <linux/net.h>
25 #include <net/sock.h>
26
27 struct aead_sg_list {
28         unsigned int cur;
29         struct scatterlist sg[ALG_MAX_PAGES];
30 };
31
32 struct aead_ctx {
33         struct aead_sg_list tsgl;
34         /*
35          * RSGL_MAX_ENTRIES is an artificial limit where user space at maximum
36          * can cause the kernel to allocate RSGL_MAX_ENTRIES * ALG_MAX_PAGES
37          * pages
38          */
39 #define RSGL_MAX_ENTRIES ALG_MAX_PAGES
40         struct af_alg_sgl rsgl[RSGL_MAX_ENTRIES];
41
42         void *iv;
43
44         struct af_alg_completion completion;
45
46         unsigned long used;
47
48         unsigned int len;
49         bool more;
50         bool merge;
51         bool enc;
52
53         size_t aead_assoclen;
54         struct aead_request aead_req;
55 };
56
57 static inline int aead_sndbuf(struct sock *sk)
58 {
59         struct alg_sock *ask = alg_sk(sk);
60         struct aead_ctx *ctx = ask->private;
61
62         return max_t(int, max_t(int, sk->sk_sndbuf & PAGE_MASK, PAGE_SIZE) -
63                           ctx->used, 0);
64 }
65
66 static inline bool aead_writable(struct sock *sk)
67 {
68         return PAGE_SIZE <= aead_sndbuf(sk);
69 }
70
71 static inline bool aead_sufficient_data(struct aead_ctx *ctx)
72 {
73         unsigned as = crypto_aead_authsize(crypto_aead_reqtfm(&ctx->aead_req));
74
75         return ctx->used >= ctx->aead_assoclen + as;
76 }
77
78 static void aead_put_sgl(struct sock *sk)
79 {
80         struct alg_sock *ask = alg_sk(sk);
81         struct aead_ctx *ctx = ask->private;
82         struct aead_sg_list *sgl = &ctx->tsgl;
83         struct scatterlist *sg = sgl->sg;
84         unsigned int i;
85
86         for (i = 0; i < sgl->cur; i++) {
87                 if (!sg_page(sg + i))
88                         continue;
89
90                 put_page(sg_page(sg + i));
91                 sg_assign_page(sg + i, NULL);
92         }
93         sg_init_table(sg, ALG_MAX_PAGES);
94         sgl->cur = 0;
95         ctx->used = 0;
96         ctx->more = 0;
97         ctx->merge = 0;
98 }
99
100 static void aead_wmem_wakeup(struct sock *sk)
101 {
102         struct socket_wq *wq;
103
104         if (!aead_writable(sk))
105                 return;
106
107         rcu_read_lock();
108         wq = rcu_dereference(sk->sk_wq);
109         if (wq_has_sleeper(wq))
110                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
111                                                            POLLRDNORM |
112                                                            POLLRDBAND);
113         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
114         rcu_read_unlock();
115 }
116
117 static int aead_wait_for_data(struct sock *sk, unsigned flags)
118 {
119         struct alg_sock *ask = alg_sk(sk);
120         struct aead_ctx *ctx = ask->private;
121         long timeout;
122         DEFINE_WAIT(wait);
123         int err = -ERESTARTSYS;
124
125         if (flags & MSG_DONTWAIT)
126                 return -EAGAIN;
127
128         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
129
130         for (;;) {
131                 if (signal_pending(current))
132                         break;
133                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
134                 timeout = MAX_SCHEDULE_TIMEOUT;
135                 if (sk_wait_event(sk, &timeout, !ctx->more)) {
136                         err = 0;
137                         break;
138                 }
139         }
140         finish_wait(sk_sleep(sk), &wait);
141
142         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
143
144         return err;
145 }
146
147 static void aead_data_wakeup(struct sock *sk)
148 {
149         struct alg_sock *ask = alg_sk(sk);
150         struct aead_ctx *ctx = ask->private;
151         struct socket_wq *wq;
152
153         if (ctx->more)
154                 return;
155         if (!ctx->used)
156                 return;
157
158         rcu_read_lock();
159         wq = rcu_dereference(sk->sk_wq);
160         if (wq_has_sleeper(wq))
161                 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
162                                                            POLLRDNORM |
163                                                            POLLRDBAND);
164         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
165         rcu_read_unlock();
166 }
167
168 static int aead_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
169 {
170         struct sock *sk = sock->sk;
171         struct alg_sock *ask = alg_sk(sk);
172         struct aead_ctx *ctx = ask->private;
173         unsigned ivsize =
174                 crypto_aead_ivsize(crypto_aead_reqtfm(&ctx->aead_req));
175         struct aead_sg_list *sgl = &ctx->tsgl;
176         struct af_alg_control con = {};
177         long copied = 0;
178         bool enc = 0;
179         bool init = 0;
180         int err = -EINVAL;
181
182         if (msg->msg_controllen) {
183                 err = af_alg_cmsg_send(msg, &con);
184                 if (err)
185                         return err;
186
187                 init = 1;
188                 switch (con.op) {
189                 case ALG_OP_ENCRYPT:
190                         enc = 1;
191                         break;
192                 case ALG_OP_DECRYPT:
193                         enc = 0;
194                         break;
195                 default:
196                         return -EINVAL;
197                 }
198
199                 if (con.iv && con.iv->ivlen != ivsize)
200                         return -EINVAL;
201         }
202
203         lock_sock(sk);
204         if (!ctx->more && ctx->used)
205                 goto unlock;
206
207         if (init) {
208                 ctx->enc = enc;
209                 if (con.iv)
210                         memcpy(ctx->iv, con.iv->iv, ivsize);
211
212                 ctx->aead_assoclen = con.aead_assoclen;
213         }
214
215         while (size) {
216                 unsigned long len = size;
217                 struct scatterlist *sg = NULL;
218
219                 /* use the existing memory in an allocated page */
220                 if (ctx->merge) {
221                         sg = sgl->sg + sgl->cur - 1;
222                         len = min_t(unsigned long, len,
223                                     PAGE_SIZE - sg->offset - sg->length);
224                         err = memcpy_from_msg(page_address(sg_page(sg)) +
225                                               sg->offset + sg->length,
226                                               msg, len);
227                         if (err)
228                                 goto unlock;
229
230                         sg->length += len;
231                         ctx->merge = (sg->offset + sg->length) &
232                                      (PAGE_SIZE - 1);
233
234                         ctx->used += len;
235                         copied += len;
236                         size -= len;
237                         continue;
238                 }
239
240                 if (!aead_writable(sk)) {
241                         /* user space sent too much data */
242                         aead_put_sgl(sk);
243                         err = -EMSGSIZE;
244                         goto unlock;
245                 }
246
247                 /* allocate a new page */
248                 len = min_t(unsigned long, size, aead_sndbuf(sk));
249                 while (len) {
250                         int plen = 0;
251
252                         if (sgl->cur >= ALG_MAX_PAGES) {
253                                 aead_put_sgl(sk);
254                                 err = -E2BIG;
255                                 goto unlock;
256                         }
257
258                         sg = sgl->sg + sgl->cur;
259                         plen = min_t(int, len, PAGE_SIZE);
260
261                         sg_assign_page(sg, alloc_page(GFP_KERNEL));
262                         err = -ENOMEM;
263                         if (!sg_page(sg))
264                                 goto unlock;
265
266                         err = memcpy_from_msg(page_address(sg_page(sg)),
267                                               msg, plen);
268                         if (err) {
269                                 __free_page(sg_page(sg));
270                                 sg_assign_page(sg, NULL);
271                                 goto unlock;
272                         }
273
274                         sg->offset = 0;
275                         sg->length = plen;
276                         len -= plen;
277                         ctx->used += plen;
278                         copied += plen;
279                         sgl->cur++;
280                         size -= plen;
281                         ctx->merge = plen & (PAGE_SIZE - 1);
282                 }
283         }
284
285         err = 0;
286
287         ctx->more = msg->msg_flags & MSG_MORE;
288         if (!ctx->more && !aead_sufficient_data(ctx)) {
289                 aead_put_sgl(sk);
290                 err = -EMSGSIZE;
291         }
292
293 unlock:
294         aead_data_wakeup(sk);
295         release_sock(sk);
296
297         return err ?: copied;
298 }
299
300 static ssize_t aead_sendpage(struct socket *sock, struct page *page,
301                              int offset, size_t size, int flags)
302 {
303         struct sock *sk = sock->sk;
304         struct alg_sock *ask = alg_sk(sk);
305         struct aead_ctx *ctx = ask->private;
306         struct aead_sg_list *sgl = &ctx->tsgl;
307         int err = -EINVAL;
308
309         if (flags & MSG_SENDPAGE_NOTLAST)
310                 flags |= MSG_MORE;
311
312         if (sgl->cur >= ALG_MAX_PAGES)
313                 return -E2BIG;
314
315         lock_sock(sk);
316         if (!ctx->more && ctx->used)
317                 goto unlock;
318
319         if (!size)
320                 goto done;
321
322         if (!aead_writable(sk)) {
323                 /* user space sent too much data */
324                 aead_put_sgl(sk);
325                 err = -EMSGSIZE;
326                 goto unlock;
327         }
328
329         ctx->merge = 0;
330
331         get_page(page);
332         sg_set_page(sgl->sg + sgl->cur, page, size, offset);
333         sgl->cur++;
334         ctx->used += size;
335
336         err = 0;
337
338 done:
339         ctx->more = flags & MSG_MORE;
340         if (!ctx->more && !aead_sufficient_data(ctx)) {
341                 aead_put_sgl(sk);
342                 err = -EMSGSIZE;
343         }
344
345 unlock:
346         aead_data_wakeup(sk);
347         release_sock(sk);
348
349         return err ?: size;
350 }
351
352 static int aead_recvmsg(struct socket *sock, struct msghdr *msg, size_t ignored, int flags)
353 {
354         struct sock *sk = sock->sk;
355         struct alg_sock *ask = alg_sk(sk);
356         struct aead_ctx *ctx = ask->private;
357         unsigned as = crypto_aead_authsize(crypto_aead_reqtfm(&ctx->aead_req));
358         struct aead_sg_list *sgl = &ctx->tsgl;
359         unsigned int i = 0;
360         int err = -EINVAL;
361         unsigned long used = 0;
362         size_t outlen = 0;
363         size_t usedpages = 0;
364         unsigned int cnt = 0;
365
366         /* Limit number of IOV blocks to be accessed below */
367         if (msg->msg_iter.nr_segs > RSGL_MAX_ENTRIES)
368                 return -ENOMSG;
369
370         lock_sock(sk);
371
372         /*
373          * AEAD memory structure: For encryption, the tag is appended to the
374          * ciphertext which implies that the memory allocated for the ciphertext
375          * must be increased by the tag length. For decryption, the tag
376          * is expected to be concatenated to the ciphertext. The plaintext
377          * therefore has a memory size of the ciphertext minus the tag length.
378          *
379          * The memory structure for cipher operation has the following
380          * structure:
381          *      AEAD encryption input:  assoc data || plaintext
382          *      AEAD encryption output: cipherntext || auth tag
383          *      AEAD decryption input:  assoc data || ciphertext || auth tag
384          *      AEAD decryption output: plaintext
385          */
386
387         if (ctx->more) {
388                 err = aead_wait_for_data(sk, flags);
389                 if (err)
390                         goto unlock;
391         }
392
393         used = ctx->used;
394
395         /*
396          * Make sure sufficient data is present -- note, the same check is
397          * is also present in sendmsg/sendpage. The checks in sendpage/sendmsg
398          * shall provide an information to the data sender that something is
399          * wrong, but they are irrelevant to maintain the kernel integrity.
400          * We need this check here too in case user space decides to not honor
401          * the error message in sendmsg/sendpage and still call recvmsg. This
402          * check here protects the kernel integrity.
403          */
404         if (!aead_sufficient_data(ctx))
405                 goto unlock;
406
407         outlen = used;
408
409         /*
410          * The cipher operation input data is reduced by the associated data
411          * length as this data is processed separately later on.
412          */
413         used -= ctx->aead_assoclen + (ctx->enc ? as : 0);
414
415         /* convert iovecs of output buffers into scatterlists */
416         while (iov_iter_count(&msg->msg_iter)) {
417                 size_t seglen = min_t(size_t, iov_iter_count(&msg->msg_iter),
418                                       (outlen - usedpages));
419
420                 /* make one iovec available as scatterlist */
421                 err = af_alg_make_sg(&ctx->rsgl[cnt], &msg->msg_iter,
422                                      seglen);
423                 if (err < 0)
424                         goto unlock;
425                 usedpages += err;
426                 /* chain the new scatterlist with previous one */
427                 if (cnt)
428                         af_alg_link_sg(&ctx->rsgl[cnt-1], &ctx->rsgl[cnt]);
429
430                 /* we do not need more iovecs as we have sufficient memory */
431                 if (outlen <= usedpages)
432                         break;
433                 iov_iter_advance(&msg->msg_iter, err);
434                 cnt++;
435         }
436
437         err = -EINVAL;
438         /* ensure output buffer is sufficiently large */
439         if (usedpages < outlen)
440                 goto unlock;
441
442         sg_mark_end(sgl->sg + sgl->cur - 1);
443
444         aead_request_set_crypt(&ctx->aead_req, sgl->sg, ctx->rsgl[0].sg,
445                                used, ctx->iv);
446         aead_request_set_ad(&ctx->aead_req, ctx->aead_assoclen);
447
448         err = af_alg_wait_for_completion(ctx->enc ?
449                                          crypto_aead_encrypt(&ctx->aead_req) :
450                                          crypto_aead_decrypt(&ctx->aead_req),
451                                          &ctx->completion);
452
453         if (err) {
454                 /* EBADMSG implies a valid cipher operation took place */
455                 if (err == -EBADMSG)
456                         aead_put_sgl(sk);
457                 goto unlock;
458         }
459
460         aead_put_sgl(sk);
461
462         err = 0;
463
464 unlock:
465         for (i = 0; i < cnt; i++)
466                 af_alg_free_sg(&ctx->rsgl[i]);
467
468         aead_wmem_wakeup(sk);
469         release_sock(sk);
470
471         return err ? err : outlen;
472 }
473
474 static unsigned int aead_poll(struct file *file, struct socket *sock,
475                               poll_table *wait)
476 {
477         struct sock *sk = sock->sk;
478         struct alg_sock *ask = alg_sk(sk);
479         struct aead_ctx *ctx = ask->private;
480         unsigned int mask;
481
482         sock_poll_wait(file, sk_sleep(sk), wait);
483         mask = 0;
484
485         if (!ctx->more)
486                 mask |= POLLIN | POLLRDNORM;
487
488         if (aead_writable(sk))
489                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
490
491         return mask;
492 }
493
494 static struct proto_ops algif_aead_ops = {
495         .family         =       PF_ALG,
496
497         .connect        =       sock_no_connect,
498         .socketpair     =       sock_no_socketpair,
499         .getname        =       sock_no_getname,
500         .ioctl          =       sock_no_ioctl,
501         .listen         =       sock_no_listen,
502         .shutdown       =       sock_no_shutdown,
503         .getsockopt     =       sock_no_getsockopt,
504         .mmap           =       sock_no_mmap,
505         .bind           =       sock_no_bind,
506         .accept         =       sock_no_accept,
507         .setsockopt     =       sock_no_setsockopt,
508
509         .release        =       af_alg_release,
510         .sendmsg        =       aead_sendmsg,
511         .sendpage       =       aead_sendpage,
512         .recvmsg        =       aead_recvmsg,
513         .poll           =       aead_poll,
514 };
515
516 static void *aead_bind(const char *name, u32 type, u32 mask)
517 {
518         return crypto_alloc_aead(name, type, mask);
519 }
520
521 static void aead_release(void *private)
522 {
523         crypto_free_aead(private);
524 }
525
526 static int aead_setauthsize(void *private, unsigned int authsize)
527 {
528         return crypto_aead_setauthsize(private, authsize);
529 }
530
531 static int aead_setkey(void *private, const u8 *key, unsigned int keylen)
532 {
533         return crypto_aead_setkey(private, key, keylen);
534 }
535
536 static void aead_sock_destruct(struct sock *sk)
537 {
538         struct alg_sock *ask = alg_sk(sk);
539         struct aead_ctx *ctx = ask->private;
540         unsigned int ivlen = crypto_aead_ivsize(
541                                 crypto_aead_reqtfm(&ctx->aead_req));
542
543         aead_put_sgl(sk);
544         sock_kzfree_s(sk, ctx->iv, ivlen);
545         sock_kfree_s(sk, ctx, ctx->len);
546         af_alg_release_parent(sk);
547 }
548
549 static int aead_accept_parent(void *private, struct sock *sk)
550 {
551         struct aead_ctx *ctx;
552         struct alg_sock *ask = alg_sk(sk);
553         unsigned int len = sizeof(*ctx) + crypto_aead_reqsize(private);
554         unsigned int ivlen = crypto_aead_ivsize(private);
555
556         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
557         if (!ctx)
558                 return -ENOMEM;
559         memset(ctx, 0, len);
560
561         ctx->iv = sock_kmalloc(sk, ivlen, GFP_KERNEL);
562         if (!ctx->iv) {
563                 sock_kfree_s(sk, ctx, len);
564                 return -ENOMEM;
565         }
566         memset(ctx->iv, 0, ivlen);
567
568         ctx->len = len;
569         ctx->used = 0;
570         ctx->more = 0;
571         ctx->merge = 0;
572         ctx->enc = 0;
573         ctx->tsgl.cur = 0;
574         ctx->aead_assoclen = 0;
575         af_alg_init_completion(&ctx->completion);
576         sg_init_table(ctx->tsgl.sg, ALG_MAX_PAGES);
577
578         ask->private = ctx;
579
580         aead_request_set_tfm(&ctx->aead_req, private);
581         aead_request_set_callback(&ctx->aead_req, CRYPTO_TFM_REQ_MAY_BACKLOG,
582                                   af_alg_complete, &ctx->completion);
583
584         sk->sk_destruct = aead_sock_destruct;
585
586         return 0;
587 }
588
589 static const struct af_alg_type algif_type_aead = {
590         .bind           =       aead_bind,
591         .release        =       aead_release,
592         .setkey         =       aead_setkey,
593         .setauthsize    =       aead_setauthsize,
594         .accept         =       aead_accept_parent,
595         .ops            =       &algif_aead_ops,
596         .name           =       "aead",
597         .owner          =       THIS_MODULE
598 };
599
600 static int __init algif_aead_init(void)
601 {
602         return af_alg_register_type(&algif_type_aead);
603 }
604
605 static void __exit algif_aead_exit(void)
606 {
607         int err = af_alg_unregister_type(&algif_type_aead);
608         BUG_ON(err);
609 }
610
611 module_init(algif_aead_init);
612 module_exit(algif_aead_exit);
613 MODULE_LICENSE("GPL");
614 MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
615 MODULE_DESCRIPTION("AEAD kernel crypto API user space interface");