algif_skcipher.c

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