?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging:rtl8712 Aligned code with open parenthesis
[linux/fpc-iii.git] / crypto / algif_skcipher.c
bloba9e79d8eff87741690723fdb1be5b829d4263af2
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 */
14
15 #include <crypto/scatterwalk.h>
16 #include <crypto/skcipher.h>
17 #include <crypto/if_alg.h>
18 #include <linux/init.h>
19 #include <linux/list.h>
20 #include <linux/kernel.h>
21 #include <linux/mm.h>
22 #include <linux/module.h>
23 #include <linux/net.h>
24 #include <net/sock.h>
25
26 struct skcipher_sg_list {
27 struct list_head list;
28
29 int cur;
30
31 struct scatterlist sg[0];
32 };
33
34 struct skcipher_tfm {
35 struct crypto_skcipher *skcipher;
36 bool has_key;
37 };
38
39 struct skcipher_ctx {
40 struct list_head tsgl;
41 struct af_alg_sgl rsgl;
42
43 void *iv;
44
45 struct af_alg_completion completion;
46
47 atomic_t inflight;
48 size_t used;
49
50 unsigned int len;
51 bool more;
52 bool merge;
53 bool enc;
54
55 struct skcipher_request req;
56 };
57
58 struct skcipher_async_rsgl {
59 struct af_alg_sgl sgl;
60 struct list_head list;
61 };
62
63 struct skcipher_async_req {
64 struct kiocb *iocb;
65 struct skcipher_async_rsgl first_sgl;
66 struct list_head list;
67 struct scatterlist *tsg;
68 atomic_t *inflight;
69 struct skcipher_request req;
70 };
71
72 #define MAX_SGL_ENTS ((4096 - sizeof(struct skcipher_sg_list)) / \
73 sizeof(struct scatterlist) - 1)
74
75 static void skcipher_free_async_sgls(struct skcipher_async_req *sreq)
76 {
77 struct skcipher_async_rsgl *rsgl, *tmp;
78 struct scatterlist *sgl;
79 struct scatterlist *sg;
80 int i, n;
81
82 list_for_each_entry_safe(rsgl, tmp, &sreq->list, list) {
83 af_alg_free_sg(&rsgl->sgl);
84 if (rsgl != &sreq->first_sgl)
85 kfree(rsgl);
86 }
87 sgl = sreq->tsg;
88 n = sg_nents(sgl);
89 for_each_sg(sgl, sg, n, i)
90 put_page(sg_page(sg));
91
92 kfree(sreq->tsg);
93 }
94
95 static void skcipher_async_cb(struct crypto_async_request *req, int err)
96 {
97 struct skcipher_async_req *sreq = req->data;
98 struct kiocb *iocb = sreq->iocb;
99
100 atomic_dec(sreq->inflight);
101 skcipher_free_async_sgls(sreq);
102 kzfree(sreq);
103 iocb->ki_complete(iocb, err, err);
104 }
105
106 static inline int skcipher_sndbuf(struct sock *sk)
107 {
108 struct alg_sock *ask = alg_sk(sk);
109 struct skcipher_ctx *ctx = ask->private;
110
111 return max_t(int, max_t(int, sk->sk_sndbuf & PAGE_MASK, PAGE_SIZE) -
112 ctx->used, 0);
113 }
114
115 static inline bool skcipher_writable(struct sock *sk)
116 {
117 return PAGE_SIZE <= skcipher_sndbuf(sk);
118 }
119
120 static int skcipher_alloc_sgl(struct sock *sk)
121 {
122 struct alg_sock *ask = alg_sk(sk);
123 struct skcipher_ctx *ctx = ask->private;
124 struct skcipher_sg_list *sgl;
125 struct scatterlist *sg = NULL;
126
127 sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
128 if (!list_empty(&ctx->tsgl))
129 sg = sgl->sg;
130
131 if (!sg || sgl->cur >= MAX_SGL_ENTS) {
132 sgl = sock_kmalloc(sk, sizeof(*sgl) +
133 sizeof(sgl->sg[0]) * (MAX_SGL_ENTS + 1),
134 GFP_KERNEL);
135 if (!sgl)
136 return -ENOMEM;
137
138 sg_init_table(sgl->sg, MAX_SGL_ENTS + 1);
139 sgl->cur = 0;
140
141 if (sg)
142 sg_chain(sg, MAX_SGL_ENTS + 1, sgl->sg);
143
144 list_add_tail(&sgl->list, &ctx->tsgl);
145 }
146
147 return 0;
148 }
149
150 static void skcipher_pull_sgl(struct sock *sk, size_t used, int put)
151 {
152 struct alg_sock *ask = alg_sk(sk);
153 struct skcipher_ctx *ctx = ask->private;
154 struct skcipher_sg_list *sgl;
155 struct scatterlist *sg;
156 int i;
157
158 while (!list_empty(&ctx->tsgl)) {
159 sgl = list_first_entry(&ctx->tsgl, struct skcipher_sg_list,
160 list);
161 sg = sgl->sg;
162
163 for (i = 0; i < sgl->cur; i++) {
164 size_t plen = min_t(size_t, used, sg[i].length);
165
166 if (!sg_page(sg + i))
167 continue;
168
169 sg[i].length -= plen;
170 sg[i].offset += plen;
171
172 used -= plen;
173 ctx->used -= plen;
174
175 if (sg[i].length)
176 return;
177 if (put)
178 put_page(sg_page(sg + i));
179 sg_assign_page(sg + i, NULL);
180 }
181
182 list_del(&sgl->list);
183 sock_kfree_s(sk, sgl,
184 sizeof(*sgl) + sizeof(sgl->sg[0]) *
185 (MAX_SGL_ENTS + 1));
186 }
187
188 if (!ctx->used)
189 ctx->merge = 0;
190 }
191
192 static void skcipher_free_sgl(struct sock *sk)
193 {
194 struct alg_sock *ask = alg_sk(sk);
195 struct skcipher_ctx *ctx = ask->private;
196
197 skcipher_pull_sgl(sk, ctx->used, 1);
198 }
199
200 static int skcipher_wait_for_wmem(struct sock *sk, unsigned flags)
201 {
202 DEFINE_WAIT_FUNC(wait, woken_wake_function);
203 int err = -ERESTARTSYS;
204 long timeout;
205
206 if (flags & MSG_DONTWAIT)
207 return -EAGAIN;
208
209 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
210
211 add_wait_queue(sk_sleep(sk), &wait);
212 for (;;) {
213 if (signal_pending(current))
214 break;
215 timeout = MAX_SCHEDULE_TIMEOUT;
216 if (sk_wait_event(sk, &timeout, skcipher_writable(sk), &wait)) {
217 err = 0;
218 break;
219 }
220 }
221 remove_wait_queue(sk_sleep(sk), &wait);
222
223 return err;
224 }
225
226 static void skcipher_wmem_wakeup(struct sock *sk)
227 {
228 struct socket_wq *wq;
229
230 if (!skcipher_writable(sk))
231 return;
232
233 rcu_read_lock();
234 wq = rcu_dereference(sk->sk_wq);
235 if (skwq_has_sleeper(wq))
236 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
237 POLLRDNORM |
238 POLLRDBAND);
239 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
240 rcu_read_unlock();
241 }
242
243 static int skcipher_wait_for_data(struct sock *sk, unsigned flags)
244 {
245 DEFINE_WAIT_FUNC(wait, woken_wake_function);
246 struct alg_sock *ask = alg_sk(sk);
247 struct skcipher_ctx *ctx = ask->private;
248 long timeout;
249 int err = -ERESTARTSYS;
250
251 if (flags & MSG_DONTWAIT) {
252 return -EAGAIN;
253 }
254
255 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
256
257 add_wait_queue(sk_sleep(sk), &wait);
258 for (;;) {
259 if (signal_pending(current))
260 break;
261 timeout = MAX_SCHEDULE_TIMEOUT;
262 if (sk_wait_event(sk, &timeout, ctx->used, &wait)) {
263 err = 0;
264 break;
265 }
266 }
267 remove_wait_queue(sk_sleep(sk), &wait);
268
269 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
270
271 return err;
272 }
273
274 static void skcipher_data_wakeup(struct sock *sk)
275 {
276 struct alg_sock *ask = alg_sk(sk);
277 struct skcipher_ctx *ctx = ask->private;
278 struct socket_wq *wq;
279
280 if (!ctx->used)
281 return;
282
283 rcu_read_lock();
284 wq = rcu_dereference(sk->sk_wq);
285 if (skwq_has_sleeper(wq))
286 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
287 POLLRDNORM |
288 POLLRDBAND);
289 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
290 rcu_read_unlock();
291 }
292
293 static int skcipher_sendmsg(struct socket *sock, struct msghdr *msg,
294 size_t size)
295 {
296 struct sock *sk = sock->sk;
297 struct alg_sock *ask = alg_sk(sk);
298 struct sock *psk = ask->parent;
299 struct alg_sock *pask = alg_sk(psk);
300 struct skcipher_ctx *ctx = ask->private;
301 struct skcipher_tfm *skc = pask->private;
302 struct crypto_skcipher *tfm = skc->skcipher;
303 unsigned ivsize = crypto_skcipher_ivsize(tfm);
304 struct skcipher_sg_list *sgl;
305 struct af_alg_control con = {};
306 long copied = 0;
307 bool enc = 0;
308 bool init = 0;
309 int err;
310 int i;
311
312 if (msg->msg_controllen) {
313 err = af_alg_cmsg_send(msg, &con);
314 if (err)
315 return err;
316
317 init = 1;
318 switch (con.op) {
319 case ALG_OP_ENCRYPT:
320 enc = 1;
321 break;
322 case ALG_OP_DECRYPT:
323 enc = 0;
324 break;
325 default:
326 return -EINVAL;
327 }
328
329 if (con.iv && con.iv->ivlen != ivsize)
330 return -EINVAL;
331 }
332
333 err = -EINVAL;
334
335 lock_sock(sk);
336 if (!ctx->more && ctx->used)
337 goto unlock;
338
339 if (init) {
340 ctx->enc = enc;
341 if (con.iv)
342 memcpy(ctx->iv, con.iv->iv, ivsize);
343 }
344
345 while (size) {
346 struct scatterlist *sg;
347 unsigned long len = size;
348 size_t plen;
349
350 if (ctx->merge) {
351 sgl = list_entry(ctx->tsgl.prev,
352 struct skcipher_sg_list, list);
353 sg = sgl->sg + sgl->cur - 1;
354 len = min_t(unsigned long, len,
355 PAGE_SIZE - sg->offset - sg->length);
356
357 err = memcpy_from_msg(page_address(sg_page(sg)) +
358 sg->offset + sg->length,
359 msg, len);
360 if (err)
361 goto unlock;
362
363 sg->length += len;
364 ctx->merge = (sg->offset + sg->length) &
365 (PAGE_SIZE - 1);
366
367 ctx->used += len;
368 copied += len;
369 size -= len;
370 continue;
371 }
372
373 if (!skcipher_writable(sk)) {
374 err = skcipher_wait_for_wmem(sk, msg->msg_flags);
375 if (err)
376 goto unlock;
377 }
378
379 len = min_t(unsigned long, len, skcipher_sndbuf(sk));
380
381 err = skcipher_alloc_sgl(sk);
382 if (err)
383 goto unlock;
384
385 sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
386 sg = sgl->sg;
387 if (sgl->cur)
388 sg_unmark_end(sg + sgl->cur - 1);
389 do {
390 i = sgl->cur;
391 plen = min_t(size_t, len, PAGE_SIZE);
392
393 sg_assign_page(sg + i, alloc_page(GFP_KERNEL));
394 err = -ENOMEM;
395 if (!sg_page(sg + i))
396 goto unlock;
397
398 err = memcpy_from_msg(page_address(sg_page(sg + i)),
399 msg, plen);
400 if (err) {
401 __free_page(sg_page(sg + i));
402 sg_assign_page(sg + i, NULL);
403 goto unlock;
404 }
405
406 sg[i].length = plen;
407 len -= plen;
408 ctx->used += plen;
409 copied += plen;
410 size -= plen;
411 sgl->cur++;
412 } while (len && sgl->cur < MAX_SGL_ENTS);
413
414 if (!size)
415 sg_mark_end(sg + sgl->cur - 1);
416
417 ctx->merge = plen & (PAGE_SIZE - 1);
418 }
419
420 err = 0;
421
422 ctx->more = msg->msg_flags & MSG_MORE;
423
424 unlock:
425 skcipher_data_wakeup(sk);
426 release_sock(sk);
427
428 return copied ?: err;
429 }
430
431 static ssize_t skcipher_sendpage(struct socket *sock, struct page *page,
432 int offset, size_t size, int flags)
433 {
434 struct sock *sk = sock->sk;
435 struct alg_sock *ask = alg_sk(sk);
436 struct skcipher_ctx *ctx = ask->private;
437 struct skcipher_sg_list *sgl;
438 int err = -EINVAL;
439
440 if (flags & MSG_SENDPAGE_NOTLAST)
441 flags |= MSG_MORE;
442
443 lock_sock(sk);
444 if (!ctx->more && ctx->used)
445 goto unlock;
446
447 if (!size)
448 goto done;
449
450 if (!skcipher_writable(sk)) {
451 err = skcipher_wait_for_wmem(sk, flags);
452 if (err)
453 goto unlock;
454 }
455
456 err = skcipher_alloc_sgl(sk);
457 if (err)
458 goto unlock;
459
460 ctx->merge = 0;
461 sgl = list_entry(ctx->tsgl.prev, struct skcipher_sg_list, list);
462
463 if (sgl->cur)
464 sg_unmark_end(sgl->sg + sgl->cur - 1);
465
466 sg_mark_end(sgl->sg + sgl->cur);
467 get_page(page);
468 sg_set_page(sgl->sg + sgl->cur, page, size, offset);
469 sgl->cur++;
470 ctx->used += size;
471
472 done:
473 ctx->more = flags & MSG_MORE;
474
475 unlock:
476 skcipher_data_wakeup(sk);
477 release_sock(sk);
478
479 return err ?: size;
480 }
481
482 static int skcipher_all_sg_nents(struct skcipher_ctx *ctx)
483 {
484 struct skcipher_sg_list *sgl;
485 struct scatterlist *sg;
486 int nents = 0;
487
488 list_for_each_entry(sgl, &ctx->tsgl, list) {
489 sg = sgl->sg;
490
491 while (!sg->length)
492 sg++;
493
494 nents += sg_nents(sg);
495 }
496 return nents;
497 }
498
499 static int skcipher_recvmsg_async(struct socket *sock, struct msghdr *msg,
500 int flags)
501 {
502 struct sock *sk = sock->sk;
503 struct alg_sock *ask = alg_sk(sk);
504 struct sock *psk = ask->parent;
505 struct alg_sock *pask = alg_sk(psk);
506 struct skcipher_ctx *ctx = ask->private;
507 struct skcipher_tfm *skc = pask->private;
508 struct crypto_skcipher *tfm = skc->skcipher;
509 struct skcipher_sg_list *sgl;
510 struct scatterlist *sg;
511 struct skcipher_async_req *sreq;
512 struct skcipher_request *req;
513 struct skcipher_async_rsgl *last_rsgl = NULL;
514 unsigned int txbufs = 0, len = 0, tx_nents;
515 unsigned int reqsize = crypto_skcipher_reqsize(tfm);
516 unsigned int ivsize = crypto_skcipher_ivsize(tfm);
517 int err = -ENOMEM;
518 bool mark = false;
519 char *iv;
520
521 sreq = kzalloc(sizeof(*sreq) + reqsize + ivsize, GFP_KERNEL);
522 if (unlikely(!sreq))
523 goto out;
524
525 req = &sreq->req;
526 iv = (char *)(req + 1) + reqsize;
527 sreq->iocb = msg->msg_iocb;
528 INIT_LIST_HEAD(&sreq->list);
529 sreq->inflight = &ctx->inflight;
530
531 lock_sock(sk);
532 tx_nents = skcipher_all_sg_nents(ctx);
533 sreq->tsg = kcalloc(tx_nents, sizeof(*sg), GFP_KERNEL);
534 if (unlikely(!sreq->tsg))
535 goto unlock;
536 sg_init_table(sreq->tsg, tx_nents);
537 memcpy(iv, ctx->iv, ivsize);
538 skcipher_request_set_tfm(req, tfm);
539 skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_SLEEP,
540 skcipher_async_cb, sreq);
541
542 while (iov_iter_count(&msg->msg_iter)) {
543 struct skcipher_async_rsgl *rsgl;
544 int used;
545
546 if (!ctx->used) {
547 err = skcipher_wait_for_data(sk, flags);
548 if (err)
549 goto free;
550 }
551 sgl = list_first_entry(&ctx->tsgl,
552 struct skcipher_sg_list, list);
553 sg = sgl->sg;
554
555 while (!sg->length)
556 sg++;
557
558 used = min_t(unsigned long, ctx->used,
559 iov_iter_count(&msg->msg_iter));
560 used = min_t(unsigned long, used, sg->length);
561
562 if (txbufs == tx_nents) {
563 struct scatterlist *tmp;
564 int x;
565 /* Ran out of tx slots in async request
566 * need to expand */
567 tmp = kcalloc(tx_nents * 2, sizeof(*tmp),
568 GFP_KERNEL);
569 if (!tmp) {
570 err = -ENOMEM;
571 goto free;
572 }
573
574 sg_init_table(tmp, tx_nents * 2);
575 for (x = 0; x < tx_nents; x++)
576 sg_set_page(&tmp[x], sg_page(&sreq->tsg[x]),
577 sreq->tsg[x].length,
578 sreq->tsg[x].offset);
579 kfree(sreq->tsg);
580 sreq->tsg = tmp;
581 tx_nents *= 2;
582 mark = true;
583 }
584 /* Need to take over the tx sgl from ctx
585 * to the asynch req - these sgls will be freed later */
586 sg_set_page(sreq->tsg + txbufs++, sg_page(sg), sg->length,
587 sg->offset);
588
589 if (list_empty(&sreq->list)) {
590 rsgl = &sreq->first_sgl;
591 list_add_tail(&rsgl->list, &sreq->list);
592 } else {
593 rsgl = kmalloc(sizeof(*rsgl), GFP_KERNEL);
594 if (!rsgl) {
595 err = -ENOMEM;
596 goto free;
597 }
598 list_add_tail(&rsgl->list, &sreq->list);
599 }
600
601 used = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, used);
602 err = used;
603 if (used < 0)
604 goto free;
605 if (last_rsgl)
606 af_alg_link_sg(&last_rsgl->sgl, &rsgl->sgl);
607
608 last_rsgl = rsgl;
609 len += used;
610 skcipher_pull_sgl(sk, used, 0);
611 iov_iter_advance(&msg->msg_iter, used);
612 }
613
614 if (mark)
615 sg_mark_end(sreq->tsg + txbufs - 1);
616
617 skcipher_request_set_crypt(req, sreq->tsg, sreq->first_sgl.sgl.sg,
618 len, iv);
619 err = ctx->enc ? crypto_skcipher_encrypt(req) :
620 crypto_skcipher_decrypt(req);
621 if (err == -EINPROGRESS) {
622 atomic_inc(&ctx->inflight);
623 err = -EIOCBQUEUED;
624 sreq = NULL;
625 goto unlock;
626 }
627 free:
628 skcipher_free_async_sgls(sreq);
629 unlock:
630 skcipher_wmem_wakeup(sk);
631 release_sock(sk);
632 kzfree(sreq);
633 out:
634 return err;
635 }
636
637 static int skcipher_recvmsg_sync(struct socket *sock, struct msghdr *msg,
638 int flags)
639 {
640 struct sock *sk = sock->sk;
641 struct alg_sock *ask = alg_sk(sk);
642 struct sock *psk = ask->parent;
643 struct alg_sock *pask = alg_sk(psk);
644 struct skcipher_ctx *ctx = ask->private;
645 struct skcipher_tfm *skc = pask->private;
646 struct crypto_skcipher *tfm = skc->skcipher;
647 unsigned bs = crypto_skcipher_blocksize(tfm);
648 struct skcipher_sg_list *sgl;
649 struct scatterlist *sg;
650 int err = -EAGAIN;
651 int used;
652 long copied = 0;
653
654 lock_sock(sk);
655 while (msg_data_left(msg)) {
656 if (!ctx->used) {
657 err = skcipher_wait_for_data(sk, flags);
658 if (err)
659 goto unlock;
660 }
661
662 used = min_t(unsigned long, ctx->used, msg_data_left(msg));
663
664 used = af_alg_make_sg(&ctx->rsgl, &msg->msg_iter, used);
665 err = used;
666 if (err < 0)
667 goto unlock;
668
669 if (ctx->more || used < ctx->used)
670 used -= used % bs;
671
672 err = -EINVAL;
673 if (!used)
674 goto free;
675
676 sgl = list_first_entry(&ctx->tsgl,
677 struct skcipher_sg_list, list);
678 sg = sgl->sg;
679
680 while (!sg->length)
681 sg++;
682
683 skcipher_request_set_crypt(&ctx->req, sg, ctx->rsgl.sg, used,
684 ctx->iv);
685
686 err = af_alg_wait_for_completion(
687 ctx->enc ?
688 crypto_skcipher_encrypt(&ctx->req) :
689 crypto_skcipher_decrypt(&ctx->req),
690 &ctx->completion);
691
692 free:
693 af_alg_free_sg(&ctx->rsgl);
694
695 if (err)
696 goto unlock;
697
698 copied += used;
699 skcipher_pull_sgl(sk, used, 1);
700 iov_iter_advance(&msg->msg_iter, used);
701 }
702
703 err = 0;
704
705 unlock:
706 skcipher_wmem_wakeup(sk);
707 release_sock(sk);
708
709 return copied ?: err;
710 }
711
712 static int skcipher_recvmsg(struct socket *sock, struct msghdr *msg,
713 size_t ignored, int flags)
714 {
715 return (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) ?
716 skcipher_recvmsg_async(sock, msg, flags) :
717 skcipher_recvmsg_sync(sock, msg, flags);
718 }
719
720 static unsigned int skcipher_poll(struct file *file, struct socket *sock,
721 poll_table *wait)
722 {
723 struct sock *sk = sock->sk;
724 struct alg_sock *ask = alg_sk(sk);
725 struct skcipher_ctx *ctx = ask->private;
726 unsigned int mask;
727
728 sock_poll_wait(file, sk_sleep(sk), wait);
729 mask = 0;
730
731 if (ctx->used)
732 mask |= POLLIN | POLLRDNORM;
733
734 if (skcipher_writable(sk))
735 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
736
737 return mask;
738 }
739
740 static struct proto_ops algif_skcipher_ops = {
741 .family = PF_ALG,
742
743 .connect = sock_no_connect,
744 .socketpair = sock_no_socketpair,
745 .getname = sock_no_getname,
746 .ioctl = sock_no_ioctl,
747 .listen = sock_no_listen,
748 .shutdown = sock_no_shutdown,
749 .getsockopt = sock_no_getsockopt,
750 .mmap = sock_no_mmap,
751 .bind = sock_no_bind,
752 .accept = sock_no_accept,
753 .setsockopt = sock_no_setsockopt,
754
755 .release = af_alg_release,
756 .sendmsg = skcipher_sendmsg,
757 .sendpage = skcipher_sendpage,
758 .recvmsg = skcipher_recvmsg,
759 .poll = skcipher_poll,
760 };
761
762 static int skcipher_check_key(struct socket *sock)
763 {
764 int err = 0;
765 struct sock *psk;
766 struct alg_sock *pask;
767 struct skcipher_tfm *tfm;
768 struct sock *sk = sock->sk;
769 struct alg_sock *ask = alg_sk(sk);
770
771 lock_sock(sk);
772 if (ask->refcnt)
773 goto unlock_child;
774
775 psk = ask->parent;
776 pask = alg_sk(ask->parent);
777 tfm = pask->private;
778
779 err = -ENOKEY;
780 lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
781 if (!tfm->has_key)
782 goto unlock;
783
784 if (!pask->refcnt++)
785 sock_hold(psk);
786
787 ask->refcnt = 1;
788 sock_put(psk);
789
790 err = 0;
791
792 unlock:
793 release_sock(psk);
794 unlock_child:
795 release_sock(sk);
796
797 return err;
798 }
799
800 static int skcipher_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
801 size_t size)
802 {
803 int err;
804
805 err = skcipher_check_key(sock);
806 if (err)
807 return err;
808
809 return skcipher_sendmsg(sock, msg, size);
810 }
811
812 static ssize_t skcipher_sendpage_nokey(struct socket *sock, struct page *page,
813 int offset, size_t size, int flags)
814 {
815 int err;
816
817 err = skcipher_check_key(sock);
818 if (err)
819 return err;
820
821 return skcipher_sendpage(sock, page, offset, size, flags);
822 }
823
824 static int skcipher_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
825 size_t ignored, int flags)
826 {
827 int err;
828
829 err = skcipher_check_key(sock);
830 if (err)
831 return err;
832
833 return skcipher_recvmsg(sock, msg, ignored, flags);
834 }
835
836 static struct proto_ops algif_skcipher_ops_nokey = {
837 .family = PF_ALG,
838
839 .connect = sock_no_connect,
840 .socketpair = sock_no_socketpair,
841 .getname = sock_no_getname,
842 .ioctl = sock_no_ioctl,
843 .listen = sock_no_listen,
844 .shutdown = sock_no_shutdown,
845 .getsockopt = sock_no_getsockopt,
846 .mmap = sock_no_mmap,
847 .bind = sock_no_bind,
848 .accept = sock_no_accept,
849 .setsockopt = sock_no_setsockopt,
850
851 .release = af_alg_release,
852 .sendmsg = skcipher_sendmsg_nokey,
853 .sendpage = skcipher_sendpage_nokey,
854 .recvmsg = skcipher_recvmsg_nokey,
855 .poll = skcipher_poll,
856 };
857
858 static void *skcipher_bind(const char *name, u32 type, u32 mask)
859 {
860 struct skcipher_tfm *tfm;
861 struct crypto_skcipher *skcipher;
862
863 tfm = kzalloc(sizeof(*tfm), GFP_KERNEL);
864 if (!tfm)
865 return ERR_PTR(-ENOMEM);
866
867 skcipher = crypto_alloc_skcipher(name, type, mask);
868 if (IS_ERR(skcipher)) {
869 kfree(tfm);
870 return ERR_CAST(skcipher);
871 }
872
873 tfm->skcipher = skcipher;
874
875 return tfm;
876 }
877
878 static void skcipher_release(void *private)
879 {
880 struct skcipher_tfm *tfm = private;
881
882 crypto_free_skcipher(tfm->skcipher);
883 kfree(tfm);
884 }
885
886 static int skcipher_setkey(void *private, const u8 *key, unsigned int keylen)
887 {
888 struct skcipher_tfm *tfm = private;
889 int err;
890
891 err = crypto_skcipher_setkey(tfm->skcipher, key, keylen);
892 tfm->has_key = !err;
893
894 return err;
895 }
896
897 static void skcipher_wait(struct sock *sk)
898 {
899 struct alg_sock *ask = alg_sk(sk);
900 struct skcipher_ctx *ctx = ask->private;
901 int ctr = 0;
902
903 while (atomic_read(&ctx->inflight) && ctr++ < 100)
904 msleep(100);
905 }
906
907 static void skcipher_sock_destruct(struct sock *sk)
908 {
909 struct alg_sock *ask = alg_sk(sk);
910 struct skcipher_ctx *ctx = ask->private;
911 struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(&ctx->req);
912
913 if (atomic_read(&ctx->inflight))
914 skcipher_wait(sk);
915
916 skcipher_free_sgl(sk);
917 sock_kzfree_s(sk, ctx->iv, crypto_skcipher_ivsize(tfm));
918 sock_kfree_s(sk, ctx, ctx->len);
919 af_alg_release_parent(sk);
920 }
921
922 static int skcipher_accept_parent_nokey(void *private, struct sock *sk)
923 {
924 struct skcipher_ctx *ctx;
925 struct alg_sock *ask = alg_sk(sk);
926 struct skcipher_tfm *tfm = private;
927 struct crypto_skcipher *skcipher = tfm->skcipher;
928 unsigned int len = sizeof(*ctx) + crypto_skcipher_reqsize(skcipher);
929
930 ctx = sock_kmalloc(sk, len, GFP_KERNEL);
931 if (!ctx)
932 return -ENOMEM;
933
934 ctx->iv = sock_kmalloc(sk, crypto_skcipher_ivsize(skcipher),
935 GFP_KERNEL);
936 if (!ctx->iv) {
937 sock_kfree_s(sk, ctx, len);
938 return -ENOMEM;
939 }
940
941 memset(ctx->iv, 0, crypto_skcipher_ivsize(skcipher));
942
943 INIT_LIST_HEAD(&ctx->tsgl);
944 ctx->len = len;
945 ctx->used = 0;
946 ctx->more = 0;
947 ctx->merge = 0;
948 ctx->enc = 0;
949 atomic_set(&ctx->inflight, 0);
950 af_alg_init_completion(&ctx->completion);
951
952 ask->private = ctx;
953
954 skcipher_request_set_tfm(&ctx->req, skcipher);
955 skcipher_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_SLEEP |
956 CRYPTO_TFM_REQ_MAY_BACKLOG,
957 af_alg_complete, &ctx->completion);
958
959 sk->sk_destruct = skcipher_sock_destruct;
960
961 return 0;
962 }
963
964 static int skcipher_accept_parent(void *private, struct sock *sk)
965 {
966 struct skcipher_tfm *tfm = private;
967
968 if (!tfm->has_key && crypto_skcipher_has_setkey(tfm->skcipher))
969 return -ENOKEY;
970
971 return skcipher_accept_parent_nokey(private, sk);
972 }
973
974 static const struct af_alg_type algif_type_skcipher = {
975 .bind = skcipher_bind,
976 .release = skcipher_release,
977 .setkey = skcipher_setkey,
978 .accept = skcipher_accept_parent,
979 .accept_nokey = skcipher_accept_parent_nokey,
980 .ops = &algif_skcipher_ops,
981 .ops_nokey = &algif_skcipher_ops_nokey,
982 .name = "skcipher",
983 .owner = THIS_MODULE
984 };
985
986 static int __init algif_skcipher_init(void)
987 {
988 return af_alg_register_type(&algif_type_skcipher);
989 }
990
991 static void __exit algif_skcipher_exit(void)
992 {
993 int err = af_alg_unregister_type(&algif_type_skcipher);
994 BUG_ON(err);
995 }
996
997 module_init(algif_skcipher_init);
998 module_exit(algif_skcipher_exit);
999 MODULE_LICENSE("GPL");
Linux with added FPC-III support