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/internal/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_async_rsgl {
  33         struct af_alg_sgl sgl;
  34         struct list_head list;
  35 };
  36
  37 struct aead_async_req {
  38         struct scatterlist *tsgl;
  39         struct aead_async_rsgl first_rsgl;
  40         struct list_head list;
  41         struct kiocb *iocb;
  42         unsigned int tsgls;
  43         char iv[];
  44 };
  45
  46 struct aead_ctx {
  47         struct aead_sg_list tsgl;
  48         struct aead_async_rsgl first_rsgl;
  49         struct list_head list;
  50
  51         void *iv;
  52
  53         struct af_alg_completion completion;
  54
  55         unsigned long used;
  56
  57         unsigned int len;
  58         bool more;
  59         bool merge;
  60         bool enc;
  61
  62         size_t aead_assoclen;
  63         struct aead_request aead_req;
  64 };
  65
  66 static inline int aead_sndbuf(struct sock *sk)
  67 {
  68         struct alg_sock *ask = alg_sk(sk);
  69         struct aead_ctx *ctx = ask->private;
  70
  71         return max_t(int, max_t(int, sk->sk_sndbuf & PAGE_MASK, PAGE_SIZE) -
  72                           ctx->used, 0);
  73 }
  74
  75 static inline bool aead_writable(struct sock *sk)
  76 {
  77         return PAGE_SIZE <= aead_sndbuf(sk);
  78 }
  79
  80 static inline bool aead_sufficient_data(struct aead_ctx *ctx)
  81 {
  82         unsigned as = crypto_aead_authsize(crypto_aead_reqtfm(&ctx->aead_req));
  83
  84         return ctx->used >= ctx->aead_assoclen + as;
  85 }
  86
  87 static void aead_reset_ctx(struct aead_ctx *ctx)
  88 {
  89         struct aead_sg_list *sgl = &ctx->tsgl;
  90
  91         sg_init_table(sgl->sg, ALG_MAX_PAGES);
  92         sgl->cur = 0;
  93         ctx->used = 0;
  94         ctx->more = 0;
  95         ctx->merge = 0;
  96 }
  97
  98 static void aead_put_sgl(struct sock *sk)
  99 {
 100         struct alg_sock *ask = alg_sk(sk);
 101         struct aead_ctx *ctx = ask->private;
 102         struct aead_sg_list *sgl = &ctx->tsgl;
 103         struct scatterlist *sg = sgl->sg;
 104         unsigned int i;
 105
 106         for (i = 0; i < sgl->cur; i++) {
 107                 if (!sg_page(sg + i))
 108                         continue;
 109
 110                 put_page(sg_page(sg + i));
 111                 sg_assign_page(sg + i, NULL);
 112         }
 113         aead_reset_ctx(ctx);
 114 }
 115
 116 static void aead_wmem_wakeup(struct sock *sk)
 117 {
 118         struct socket_wq *wq;
 119
 120         if (!aead_writable(sk))
 121                 return;
 122
 123         rcu_read_lock();
 124         wq = rcu_dereference(sk->sk_wq);
 125         if (skwq_has_sleeper(wq))
 126                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN |
 127                                                            POLLRDNORM |
 128                                                            POLLRDBAND);
 129         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
 130         rcu_read_unlock();
 131 }
 132
 133 static int aead_wait_for_data(struct sock *sk, unsigned flags)
 134 {
 135         struct alg_sock *ask = alg_sk(sk);
 136         struct aead_ctx *ctx = ask->private;
 137         long timeout;
 138         DEFINE_WAIT(wait);
 139         int err = -ERESTARTSYS;
 140
 141         if (flags & MSG_DONTWAIT)
 142                 return -EAGAIN;
 143
 144         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
 145
 146         for (;;) {
 147                 if (signal_pending(current))
 148                         break;
 149                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 150                 timeout = MAX_SCHEDULE_TIMEOUT;
 151                 if (sk_wait_event(sk, &timeout, !ctx->more)) {
 152                         err = 0;
 153                         break;
 154                 }
 155         }
 156         finish_wait(sk_sleep(sk), &wait);
 157
 158         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
 159
 160         return err;
 161 }
 162
 163 static void aead_data_wakeup(struct sock *sk)
 164 {
 165         struct alg_sock *ask = alg_sk(sk);
 166         struct aead_ctx *ctx = ask->private;
 167         struct socket_wq *wq;
 168
 169         if (ctx->more)
 170                 return;
 171         if (!ctx->used)
 172                 return;
 173
 174         rcu_read_lock();
 175         wq = rcu_dereference(sk->sk_wq);
 176         if (skwq_has_sleeper(wq))
 177                 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
 178                                                            POLLRDNORM |
 179                                                            POLLRDBAND);
 180         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
 181         rcu_read_unlock();
 182 }
 183
 184 static int aead_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
 185 {
 186         struct sock *sk = sock->sk;
 187         struct alg_sock *ask = alg_sk(sk);
 188         struct aead_ctx *ctx = ask->private;
 189         unsigned ivsize =
 190                 crypto_aead_ivsize(crypto_aead_reqtfm(&ctx->aead_req));
 191         struct aead_sg_list *sgl = &ctx->tsgl;
 192         struct af_alg_control con = {};
 193         long copied = 0;
 194         bool enc = 0;
 195         bool init = 0;
 196         int err = -EINVAL;
 197
 198         if (msg->msg_controllen) {
 199                 err = af_alg_cmsg_send(msg, &con);
 200                 if (err)
 201                         return err;
 202
 203                 init = 1;
 204                 switch (con.op) {
 205                 case ALG_OP_ENCRYPT:
 206                         enc = 1;
 207                         break;
 208                 case ALG_OP_DECRYPT:
 209                         enc = 0;
 210                         break;
 211                 default:
 212                         return -EINVAL;
 213                 }
 214
 215                 if (con.iv && con.iv->ivlen != ivsize)
 216                         return -EINVAL;
 217         }
 218
 219         lock_sock(sk);
 220         if (!ctx->more && ctx->used)
 221                 goto unlock;
 222
 223         if (init) {
 224                 ctx->enc = enc;
 225                 if (con.iv)
 226                         memcpy(ctx->iv, con.iv->iv, ivsize);
 227
 228                 ctx->aead_assoclen = con.aead_assoclen;
 229         }
 230
 231         while (size) {
 232                 size_t len = size;
 233                 struct scatterlist *sg = NULL;
 234
 235                 /* use the existing memory in an allocated page */
 236                 if (ctx->merge) {
 237                         sg = sgl->sg + sgl->cur - 1;
 238                         len = min_t(unsigned long, len,
 239                                     PAGE_SIZE - sg->offset - sg->length);
 240                         err = memcpy_from_msg(page_address(sg_page(sg)) +
 241                                               sg->offset + sg->length,
 242                                               msg, len);
 243                         if (err)
 244                                 goto unlock;
 245
 246                         sg->length += len;
 247                         ctx->merge = (sg->offset + sg->length) &
 248                                      (PAGE_SIZE - 1);
 249
 250                         ctx->used += len;
 251                         copied += len;
 252                         size -= len;
 253                         continue;
 254                 }
 255
 256                 if (!aead_writable(sk)) {
 257                         /* user space sent too much data */
 258                         aead_put_sgl(sk);
 259                         err = -EMSGSIZE;
 260                         goto unlock;
 261                 }
 262
 263                 /* allocate a new page */
 264                 len = min_t(unsigned long, size, aead_sndbuf(sk));
 265                 while (len) {
 266                         size_t plen = 0;
 267
 268                         if (sgl->cur >= ALG_MAX_PAGES) {
 269                                 aead_put_sgl(sk);
 270                                 err = -E2BIG;
 271                                 goto unlock;
 272                         }
 273
 274                         sg = sgl->sg + sgl->cur;
 275                         plen = min_t(size_t, len, PAGE_SIZE);
 276
 277                         sg_assign_page(sg, alloc_page(GFP_KERNEL));
 278                         err = -ENOMEM;
 279                         if (!sg_page(sg))
 280                                 goto unlock;
 281
 282                         err = memcpy_from_msg(page_address(sg_page(sg)),
 283                                               msg, plen);
 284                         if (err) {
 285                                 __free_page(sg_page(sg));
 286                                 sg_assign_page(sg, NULL);
 287                                 goto unlock;
 288                         }
 289
 290                         sg->offset = 0;
 291                         sg->length = plen;
 292                         len -= plen;
 293                         ctx->used += plen;
 294                         copied += plen;
 295                         sgl->cur++;
 296                         size -= plen;
 297                         ctx->merge = plen & (PAGE_SIZE - 1);
 298                 }
 299         }
 300
 301         err = 0;
 302
 303         ctx->more = msg->msg_flags & MSG_MORE;
 304         if (!ctx->more && !aead_sufficient_data(ctx)) {
 305                 aead_put_sgl(sk);
 306                 err = -EMSGSIZE;
 307         }
 308
 309 unlock:
 310         aead_data_wakeup(sk);
 311         release_sock(sk);
 312
 313         return err ?: copied;
 314 }
 315
 316 static ssize_t aead_sendpage(struct socket *sock, struct page *page,
 317                              int offset, size_t size, int flags)
 318 {
 319         struct sock *sk = sock->sk;
 320         struct alg_sock *ask = alg_sk(sk);
 321         struct aead_ctx *ctx = ask->private;
 322         struct aead_sg_list *sgl = &ctx->tsgl;
 323         int err = -EINVAL;
 324
 325         if (flags & MSG_SENDPAGE_NOTLAST)
 326                 flags |= MSG_MORE;
 327
 328         if (sgl->cur >= ALG_MAX_PAGES)
 329                 return -E2BIG;
 330
 331         lock_sock(sk);
 332         if (!ctx->more && ctx->used)
 333                 goto unlock;
 334
 335         if (!size)
 336                 goto done;
 337
 338         if (!aead_writable(sk)) {
 339                 /* user space sent too much data */
 340                 aead_put_sgl(sk);
 341                 err = -EMSGSIZE;
 342                 goto unlock;
 343         }
 344
 345         ctx->merge = 0;
 346
 347         get_page(page);
 348         sg_set_page(sgl->sg + sgl->cur, page, size, offset);
 349         sgl->cur++;
 350         ctx->used += size;
 351
 352         err = 0;
 353
 354 done:
 355         ctx->more = flags & MSG_MORE;
 356         if (!ctx->more && !aead_sufficient_data(ctx)) {
 357                 aead_put_sgl(sk);
 358                 err = -EMSGSIZE;
 359         }
 360
 361 unlock:
 362         aead_data_wakeup(sk);
 363         release_sock(sk);
 364
 365         return err ?: size;
 366 }
 367
 368 #define GET_ASYM_REQ(req, tfm) (struct aead_async_req *) \
 369                 ((char *)req + sizeof(struct aead_request) + \
 370                  crypto_aead_reqsize(tfm))
 371
 372  #define GET_REQ_SIZE(tfm) sizeof(struct aead_async_req) + \
 373         crypto_aead_reqsize(tfm) + crypto_aead_ivsize(tfm) + \
 374         sizeof(struct aead_request)
 375
 376 static void aead_async_cb(struct crypto_async_request *_req, int err)
 377 {
 378         struct sock *sk = _req->data;
 379         struct alg_sock *ask = alg_sk(sk);
 380         struct aead_ctx *ctx = ask->private;
 381         struct crypto_aead *tfm = crypto_aead_reqtfm(&ctx->aead_req);
 382         struct aead_request *req = aead_request_cast(_req);
 383         struct aead_async_req *areq = GET_ASYM_REQ(req, tfm);
 384         struct scatterlist *sg = areq->tsgl;
 385         struct aead_async_rsgl *rsgl;
 386         struct kiocb *iocb = areq->iocb;
 387         unsigned int i, reqlen = GET_REQ_SIZE(tfm);
 388
 389         list_for_each_entry(rsgl, &areq->list, list) {
 390                 af_alg_free_sg(&rsgl->sgl);
 391                 if (rsgl != &areq->first_rsgl)
 392                         sock_kfree_s(sk, rsgl, sizeof(*rsgl));
 393         }
 394
 395         for (i = 0; i < areq->tsgls; i++)
 396                 put_page(sg_page(sg + i));
 397
 398         sock_kfree_s(sk, areq->tsgl, sizeof(*areq->tsgl) * areq->tsgls);
 399         sock_kfree_s(sk, req, reqlen);
 400         __sock_put(sk);
 401         iocb->ki_complete(iocb, err, err);
 402 }
 403
 404 static int aead_recvmsg_async(struct socket *sock, struct msghdr *msg,
 405                               int flags)
 406 {
 407         struct sock *sk = sock->sk;
 408         struct alg_sock *ask = alg_sk(sk);
 409         struct aead_ctx *ctx = ask->private;
 410         struct crypto_aead *tfm = crypto_aead_reqtfm(&ctx->aead_req);
 411         struct aead_async_req *areq;
 412         struct aead_request *req = NULL;
 413         struct aead_sg_list *sgl = &ctx->tsgl;
 414         struct aead_async_rsgl *last_rsgl = NULL, *rsgl;
 415         unsigned int as = crypto_aead_authsize(tfm);
 416         unsigned int i, reqlen = GET_REQ_SIZE(tfm);
 417         int err = -ENOMEM;
 418         unsigned long used;
 419         size_t outlen;
 420         size_t usedpages = 0;
 421
 422         lock_sock(sk);
 423         if (ctx->more) {
 424                 err = aead_wait_for_data(sk, flags);
 425                 if (err)
 426                         goto unlock;
 427         }
 428
 429         used = ctx->used;
 430         outlen = used;
 431
 432         if (!aead_sufficient_data(ctx))
 433                 goto unlock;
 434
 435         req = sock_kmalloc(sk, reqlen, GFP_KERNEL);
 436         if (unlikely(!req))
 437                 goto unlock;
 438
 439         areq = GET_ASYM_REQ(req, tfm);
 440         memset(&areq->first_rsgl, '\0', sizeof(areq->first_rsgl));
 441         INIT_LIST_HEAD(&areq->list);
 442         areq->iocb = msg->msg_iocb;
 443         memcpy(areq->iv, ctx->iv, crypto_aead_ivsize(tfm));
 444         aead_request_set_tfm(req, tfm);
 445         aead_request_set_ad(req, ctx->aead_assoclen);
 446         aead_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 447                                   aead_async_cb, sk);
 448         used -= ctx->aead_assoclen + (ctx->enc ? as : 0);
 449
 450         /* take over all tx sgls from ctx */
 451         areq->tsgl = sock_kmalloc(sk,
 452                                   sizeof(*areq->tsgl) * max_t(u32, sgl->cur, 1),
 453                                   GFP_KERNEL);
 454         if (unlikely(!areq->tsgl))
 455                 goto free;
 456
 457         sg_init_table(areq->tsgl, max_t(u32, sgl->cur, 1));
 458         for (i = 0; i < sgl->cur; i++)
 459                 sg_set_page(&areq->tsgl[i], sg_page(&sgl->sg[i]),
 460                             sgl->sg[i].length, sgl->sg[i].offset);
 461
 462         areq->tsgls = sgl->cur;
 463
 464         /* create rx sgls */
 465         while (iov_iter_count(&msg->msg_iter)) {
 466                 size_t seglen = min_t(size_t, iov_iter_count(&msg->msg_iter),
 467                                       (outlen - usedpages));
 468
 469                 if (list_empty(&areq->list)) {
 470                         rsgl = &areq->first_rsgl;
 471
 472                 } else {
 473                         rsgl = sock_kmalloc(sk, sizeof(*rsgl), GFP_KERNEL);
 474                         if (unlikely(!rsgl)) {
 475                                 err = -ENOMEM;
 476                                 goto free;
 477                         }
 478                 }
 479                 rsgl->sgl.npages = 0;
 480                 list_add_tail(&rsgl->list, &areq->list);
 481
 482                 /* make one iovec available as scatterlist */
 483                 err = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, seglen);
 484                 if (err < 0)
 485                         goto free;
 486
 487                 usedpages += err;
 488
 489                 /* chain the new scatterlist with previous one */
 490                 if (last_rsgl)
 491                         af_alg_link_sg(&last_rsgl->sgl, &rsgl->sgl);
 492
 493                 last_rsgl = rsgl;
 494
 495                 /* we do not need more iovecs as we have sufficient memory */
 496                 if (outlen <= usedpages)
 497                         break;
 498
 499                 iov_iter_advance(&msg->msg_iter, err);
 500         }
 501         err = -EINVAL;
 502         /* ensure output buffer is sufficiently large */
 503         if (usedpages < outlen)
 504                 goto free;
 505
 506         aead_request_set_crypt(req, areq->tsgl, areq->first_rsgl.sgl.sg, used,
 507                                areq->iv);
 508         err = ctx->enc ? crypto_aead_encrypt(req) : crypto_aead_decrypt(req);
 509         if (err) {
 510                 if (err == -EINPROGRESS) {
 511                         sock_hold(sk);
 512                         err = -EIOCBQUEUED;
 513                         aead_reset_ctx(ctx);
 514                         goto unlock;
 515                 } else if (err == -EBADMSG) {
 516                         aead_put_sgl(sk);
 517                 }
 518                 goto free;
 519         }
 520         aead_put_sgl(sk);
 521
 522 free:
 523         list_for_each_entry(rsgl, &areq->list, list) {
 524                 af_alg_free_sg(&rsgl->sgl);
 525                 if (rsgl != &areq->first_rsgl)
 526                         sock_kfree_s(sk, rsgl, sizeof(*rsgl));
 527         }
 528         if (areq->tsgl)
 529                 sock_kfree_s(sk, areq->tsgl, sizeof(*areq->tsgl) * areq->tsgls);
 530         if (req)
 531                 sock_kfree_s(sk, req, reqlen);
 532 unlock:
 533         aead_wmem_wakeup(sk);
 534         release_sock(sk);
 535         return err ? err : outlen;
 536 }
 537
 538 static int aead_recvmsg_sync(struct socket *sock, struct msghdr *msg, int flags)
 539 {
 540         struct sock *sk = sock->sk;
 541         struct alg_sock *ask = alg_sk(sk);
 542         struct aead_ctx *ctx = ask->private;
 543         unsigned as = crypto_aead_authsize(crypto_aead_reqtfm(&ctx->aead_req));
 544         struct aead_sg_list *sgl = &ctx->tsgl;
 545         struct aead_async_rsgl *last_rsgl = NULL;
 546         struct aead_async_rsgl *rsgl, *tmp;
 547         int err = -EINVAL;
 548         unsigned long used = 0;
 549         size_t outlen = 0;
 550         size_t usedpages = 0;
 551
 552         lock_sock(sk);
 553
 554         /*
 555          * AEAD memory structure: For encryption, the tag is appended to the
 556          * ciphertext which implies that the memory allocated for the ciphertext
 557          * must be increased by the tag length. For decryption, the tag
 558          * is expected to be concatenated to the ciphertext. The plaintext
 559          * therefore has a memory size of the ciphertext minus the tag length.
 560          *
 561          * The memory structure for cipher operation has the following
 562          * structure:
 563          *      AEAD encryption input:  assoc data || plaintext
 564          *      AEAD encryption output: cipherntext || auth tag
 565          *      AEAD decryption input:  assoc data || ciphertext || auth tag
 566          *      AEAD decryption output: plaintext
 567          */
 568
 569         if (ctx->more) {
 570                 err = aead_wait_for_data(sk, flags);
 571                 if (err)
 572                         goto unlock;
 573         }
 574
 575         used = ctx->used;
 576
 577         /*
 578          * Make sure sufficient data is present -- note, the same check is
 579          * is also present in sendmsg/sendpage. The checks in sendpage/sendmsg
 580          * shall provide an information to the data sender that something is
 581          * wrong, but they are irrelevant to maintain the kernel integrity.
 582          * We need this check here too in case user space decides to not honor
 583          * the error message in sendmsg/sendpage and still call recvmsg. This
 584          * check here protects the kernel integrity.
 585          */
 586         if (!aead_sufficient_data(ctx))
 587                 goto unlock;
 588
 589         outlen = used;
 590
 591         /*
 592          * The cipher operation input data is reduced by the associated data
 593          * length as this data is processed separately later on.
 594          */
 595         used -= ctx->aead_assoclen + (ctx->enc ? as : 0);
 596
 597         /* convert iovecs of output buffers into scatterlists */
 598         while (iov_iter_count(&msg->msg_iter)) {
 599                 size_t seglen = min_t(size_t, iov_iter_count(&msg->msg_iter),
 600                                       (outlen - usedpages));
 601
 602                 if (list_empty(&ctx->list)) {
 603                         rsgl = &ctx->first_rsgl;
 604                 } else {
 605                         rsgl = sock_kmalloc(sk, sizeof(*rsgl), GFP_KERNEL);
 606                         if (unlikely(!rsgl)) {
 607                                 err = -ENOMEM;
 608                                 goto unlock;
 609                         }
 610                 }
 611                 rsgl->sgl.npages = 0;
 612                 list_add_tail(&rsgl->list, &ctx->list);
 613
 614                 /* make one iovec available as scatterlist */
 615                 err = af_alg_make_sg(&rsgl->sgl, &msg->msg_iter, seglen);
 616                 if (err < 0)
 617                         goto unlock;
 618                 usedpages += err;
 619                 /* chain the new scatterlist with previous one */
 620                 if (last_rsgl)
 621                         af_alg_link_sg(&last_rsgl->sgl, &rsgl->sgl);
 622
 623                 last_rsgl = rsgl;
 624
 625                 /* we do not need more iovecs as we have sufficient memory */
 626                 if (outlen <= usedpages)
 627                         break;
 628                 iov_iter_advance(&msg->msg_iter, err);
 629         }
 630
 631         err = -EINVAL;
 632         /* ensure output buffer is sufficiently large */
 633         if (usedpages < outlen)
 634                 goto unlock;
 635
 636         sg_mark_end(sgl->sg + sgl->cur - 1);
 637         aead_request_set_crypt(&ctx->aead_req, sgl->sg, ctx->first_rsgl.sgl.sg,
 638                                used, ctx->iv);
 639         aead_request_set_ad(&ctx->aead_req, ctx->aead_assoclen);
 640
 641         err = af_alg_wait_for_completion(ctx->enc ?
 642                                          crypto_aead_encrypt(&ctx->aead_req) :
 643                                          crypto_aead_decrypt(&ctx->aead_req),
 644                                          &ctx->completion);
 645
 646         if (err) {
 647                 /* EBADMSG implies a valid cipher operation took place */
 648                 if (err == -EBADMSG)
 649                         aead_put_sgl(sk);
 650
 651                 goto unlock;
 652         }
 653
 654         aead_put_sgl(sk);
 655         err = 0;
 656
 657 unlock:
 658         list_for_each_entry_safe(rsgl, tmp, &ctx->list, list) {
 659                 af_alg_free_sg(&rsgl->sgl);
 660                 if (rsgl != &ctx->first_rsgl)
 661                         sock_kfree_s(sk, rsgl, sizeof(*rsgl));
 662                 list_del(&rsgl->list);
 663         }
 664         INIT_LIST_HEAD(&ctx->list);
 665         aead_wmem_wakeup(sk);
 666         release_sock(sk);
 667
 668         return err ? err : outlen;
 669 }
 670
 671 static int aead_recvmsg(struct socket *sock, struct msghdr *msg, size_t ignored,
 672                         int flags)
 673 {
 674         return (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) ?
 675                 aead_recvmsg_async(sock, msg, flags) :
 676                 aead_recvmsg_sync(sock, msg, flags);
 677 }
 678
 679 static unsigned int aead_poll(struct file *file, struct socket *sock,
 680                               poll_table *wait)
 681 {
 682         struct sock *sk = sock->sk;
 683         struct alg_sock *ask = alg_sk(sk);
 684         struct aead_ctx *ctx = ask->private;
 685         unsigned int mask;
 686
 687         sock_poll_wait(file, sk_sleep(sk), wait);
 688         mask = 0;
 689
 690         if (!ctx->more)
 691                 mask |= POLLIN | POLLRDNORM;
 692
 693         if (aead_writable(sk))
 694                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 695
 696         return mask;
 697 }
 698
 699 static struct proto_ops algif_aead_ops = {
 700         .family         =       PF_ALG,
 701
 702         .connect        =       sock_no_connect,
 703         .socketpair     =       sock_no_socketpair,
 704         .getname        =       sock_no_getname,
 705         .ioctl          =       sock_no_ioctl,
 706         .listen         =       sock_no_listen,
 707         .shutdown       =       sock_no_shutdown,
 708         .getsockopt     =       sock_no_getsockopt,
 709         .mmap           =       sock_no_mmap,
 710         .bind           =       sock_no_bind,
 711         .accept         =       sock_no_accept,
 712         .setsockopt     =       sock_no_setsockopt,
 713
 714         .release        =       af_alg_release,
 715         .sendmsg        =       aead_sendmsg,
 716         .sendpage       =       aead_sendpage,
 717         .recvmsg        =       aead_recvmsg,
 718         .poll           =       aead_poll,
 719 };
 720
 721 static void *aead_bind(const char *name, u32 type, u32 mask)
 722 {
 723         return crypto_alloc_aead(name, type, mask);
 724 }
 725
 726 static void aead_release(void *private)
 727 {
 728         crypto_free_aead(private);
 729 }
 730
 731 static int aead_setauthsize(void *private, unsigned int authsize)
 732 {
 733         return crypto_aead_setauthsize(private, authsize);
 734 }
 735
 736 static int aead_setkey(void *private, const u8 *key, unsigned int keylen)
 737 {
 738         return crypto_aead_setkey(private, key, keylen);
 739 }
 740
 741 static void aead_sock_destruct(struct sock *sk)
 742 {
 743         struct alg_sock *ask = alg_sk(sk);
 744         struct aead_ctx *ctx = ask->private;
 745         unsigned int ivlen = crypto_aead_ivsize(
 746                                 crypto_aead_reqtfm(&ctx->aead_req));
 747
 748         WARN_ON(atomic_read(&sk->sk_refcnt) != 0);
 749         aead_put_sgl(sk);
 750         sock_kzfree_s(sk, ctx->iv, ivlen);
 751         sock_kfree_s(sk, ctx, ctx->len);
 752         af_alg_release_parent(sk);
 753 }
 754
 755 static int aead_accept_parent(void *private, struct sock *sk)
 756 {
 757         struct aead_ctx *ctx;
 758         struct alg_sock *ask = alg_sk(sk);
 759         unsigned int len = sizeof(*ctx) + crypto_aead_reqsize(private);
 760         unsigned int ivlen = crypto_aead_ivsize(private);
 761
 762         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
 763         if (!ctx)
 764                 return -ENOMEM;
 765         memset(ctx, 0, len);
 766
 767         ctx->iv = sock_kmalloc(sk, ivlen, GFP_KERNEL);
 768         if (!ctx->iv) {
 769                 sock_kfree_s(sk, ctx, len);
 770                 return -ENOMEM;
 771         }
 772         memset(ctx->iv, 0, ivlen);
 773
 774         ctx->len = len;
 775         ctx->used = 0;
 776         ctx->more = 0;
 777         ctx->merge = 0;
 778         ctx->enc = 0;
 779         ctx->tsgl.cur = 0;
 780         ctx->aead_assoclen = 0;
 781         af_alg_init_completion(&ctx->completion);
 782         sg_init_table(ctx->tsgl.sg, ALG_MAX_PAGES);
 783         INIT_LIST_HEAD(&ctx->list);
 784
 785         ask->private = ctx;
 786
 787         aead_request_set_tfm(&ctx->aead_req, private);
 788         aead_request_set_callback(&ctx->aead_req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 789                                   af_alg_complete, &ctx->completion);
 790
 791         sk->sk_destruct = aead_sock_destruct;
 792
 793         return 0;
 794 }
 795
 796 static const struct af_alg_type algif_type_aead = {
 797         .bind           =       aead_bind,
 798         .release        =       aead_release,
 799         .setkey         =       aead_setkey,
 800         .setauthsize    =       aead_setauthsize,
 801         .accept         =       aead_accept_parent,
 802         .ops            =       &algif_aead_ops,
 803         .name           =       "aead",
 804         .owner          =       THIS_MODULE
 805 };
 806
 807 static int __init algif_aead_init(void)
 808 {
 809         return af_alg_register_type(&algif_type_aead);
 810 }
 811
 812 static void __exit algif_aead_exit(void)
 813 {
 814         int err = af_alg_unregister_type(&algif_type_aead);
 815         BUG_ON(err);
 816 }
 817
 818 module_init(algif_aead_init);
 819 module_exit(algif_aead_exit);
 820 MODULE_LICENSE("GPL");
 821 MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
 822 MODULE_DESCRIPTION("AEAD kernel crypto API user space interface");