crypto/algif_hash.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * algif_hash: User-space interface for hash algorithms
   4  *
   5  * This file provides the user-space API for hash algorithms.
   6  *
   7  * Copyright (c) 2010 Herbert Xu <herbert@gondor.apana.org.au>
   8  */
   9
  10 #include <crypto/hash.h>
  11 #include <crypto/if_alg.h>
  12 #include <linux/init.h>
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/module.h>
  16 #include <linux/net.h>
  17 #include <net/sock.h>
  18
  19 struct hash_ctx {
  20         struct af_alg_sgl sgl;
  21
  22         u8 *result;
  23
  24         struct crypto_wait wait;
  25
  26         unsigned int len;
  27         bool more;
  28
  29         struct ahash_request req;
  30 };
  31
  32 static int hash_alloc_result(struct sock *sk, struct hash_ctx *ctx)
  33 {
  34         unsigned ds;
  35
  36         if (ctx->result)
  37                 return 0;
  38
  39         ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
  40
  41         ctx->result = sock_kmalloc(sk, ds, GFP_KERNEL);
  42         if (!ctx->result)
  43                 return -ENOMEM;
  44
  45         memset(ctx->result, 0, ds);
  46
  47         return 0;
  48 }
  49
  50 static void hash_free_result(struct sock *sk, struct hash_ctx *ctx)
  51 {
  52         unsigned ds;
  53
  54         if (!ctx->result)
  55                 return;
  56
  57         ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
  58
  59         sock_kzfree_s(sk, ctx->result, ds);
  60         ctx->result = NULL;
  61 }
  62
  63 static int hash_sendmsg(struct socket *sock, struct msghdr *msg,
  64                         size_t ignored)
  65 {
  66         struct sock *sk = sock->sk;
  67         struct alg_sock *ask = alg_sk(sk);
  68         struct hash_ctx *ctx = ask->private;
  69         ssize_t copied = 0;
  70         size_t len, max_pages, npages;
  71         bool continuing, need_init = false;
  72         int err;
  73
  74         max_pages = min_t(size_t, ALG_MAX_PAGES,
  75                           DIV_ROUND_UP(sk->sk_sndbuf, PAGE_SIZE));
  76
  77         lock_sock(sk);
  78         continuing = ctx->more;
  79
  80         if (!continuing) {
  81                 /* Discard a previous request that wasn't marked MSG_MORE. */
  82                 hash_free_result(sk, ctx);
  83                 if (!msg_data_left(msg))
  84                         goto done; /* Zero-length; don't start new req */
  85                 need_init = true;
  86         } else if (!msg_data_left(msg)) {
  87                 /*
  88                  * No data - finalise the prev req if MSG_MORE so any error
  89                  * comes out here.
  90                  */
  91                 if (!(msg->msg_flags & MSG_MORE)) {
  92                         err = hash_alloc_result(sk, ctx);
  93                         if (err)
  94                                 goto unlock_free_result;
  95                         ahash_request_set_crypt(&ctx->req, NULL,
  96                                                 ctx->result, 0);
  97                         err = crypto_wait_req(crypto_ahash_final(&ctx->req),
  98                                               &ctx->wait);
  99                         if (err)
 100                                 goto unlock_free_result;
 101                 }
 102                 goto done_more;
 103         }
 104
 105         while (msg_data_left(msg)) {
 106                 ctx->sgl.sgt.sgl = ctx->sgl.sgl;
 107                 ctx->sgl.sgt.nents = 0;
 108                 ctx->sgl.sgt.orig_nents = 0;
 109
 110                 err = -EIO;
 111                 npages = iov_iter_npages(&msg->msg_iter, max_pages);
 112                 if (npages == 0)
 113                         goto unlock_free;
 114
 115                 sg_init_table(ctx->sgl.sgl, npages);
 116
 117                 ctx->sgl.need_unpin = iov_iter_extract_will_pin(&msg->msg_iter);
 118
 119                 err = extract_iter_to_sg(&msg->msg_iter, LONG_MAX,
 120                                          &ctx->sgl.sgt, npages, 0);
 121                 if (err < 0)
 122                         goto unlock_free;
 123                 len = err;
 124                 sg_mark_end(ctx->sgl.sgt.sgl + ctx->sgl.sgt.nents - 1);
 125
 126                 if (!msg_data_left(msg)) {
 127                         err = hash_alloc_result(sk, ctx);
 128                         if (err)
 129                                 goto unlock_free;
 130                 }
 131
 132                 ahash_request_set_crypt(&ctx->req, ctx->sgl.sgt.sgl,
 133                                         ctx->result, len);
 134
 135                 if (!msg_data_left(msg) && !continuing &&
 136                     !(msg->msg_flags & MSG_MORE)) {
 137                         err = crypto_ahash_digest(&ctx->req);
 138                 } else {
 139                         if (need_init) {
 140                                 err = crypto_wait_req(
 141                                         crypto_ahash_init(&ctx->req),
 142                                         &ctx->wait);
 143                                 if (err)
 144                                         goto unlock_free;
 145                                 need_init = false;
 146                         }
 147
 148                         if (msg_data_left(msg) || (msg->msg_flags & MSG_MORE))
 149                                 err = crypto_ahash_update(&ctx->req);
 150                         else
 151                                 err = crypto_ahash_finup(&ctx->req);
 152                         continuing = true;
 153                 }
 154
 155                 err = crypto_wait_req(err, &ctx->wait);
 156                 if (err)
 157                         goto unlock_free;
 158
 159                 copied += len;
 160                 af_alg_free_sg(&ctx->sgl);
 161         }
 162
 163 done_more:
 164         ctx->more = msg->msg_flags & MSG_MORE;
 165 done:
 166         err = 0;
 167 unlock:
 168         release_sock(sk);
 169         return copied ?: err;
 170
 171 unlock_free:
 172         af_alg_free_sg(&ctx->sgl);
 173 unlock_free_result:
 174         hash_free_result(sk, ctx);
 175         ctx->more = false;
 176         goto unlock;
 177 }
 178
 179 static int hash_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 180                         int flags)
 181 {
 182         struct sock *sk = sock->sk;
 183         struct alg_sock *ask = alg_sk(sk);
 184         struct hash_ctx *ctx = ask->private;
 185         unsigned ds = crypto_ahash_digestsize(crypto_ahash_reqtfm(&ctx->req));
 186         bool result;
 187         int err;
 188
 189         if (len > ds)
 190                 len = ds;
 191         else if (len < ds)
 192                 msg->msg_flags |= MSG_TRUNC;
 193
 194         lock_sock(sk);
 195         result = ctx->result;
 196         err = hash_alloc_result(sk, ctx);
 197         if (err)
 198                 goto unlock;
 199
 200         ahash_request_set_crypt(&ctx->req, NULL, ctx->result, 0);
 201
 202         if (!result && !ctx->more) {
 203                 err = crypto_wait_req(crypto_ahash_init(&ctx->req),
 204                                       &ctx->wait);
 205                 if (err)
 206                         goto unlock;
 207         }
 208
 209         if (!result || ctx->more) {
 210                 ctx->more = false;
 211                 err = crypto_wait_req(crypto_ahash_final(&ctx->req),
 212                                       &ctx->wait);
 213                 if (err)
 214                         goto unlock;
 215         }
 216
 217         err = memcpy_to_msg(msg, ctx->result, len);
 218
 219 unlock:
 220         hash_free_result(sk, ctx);
 221         release_sock(sk);
 222
 223         return err ?: len;
 224 }
 225
 226 static int hash_accept(struct socket *sock, struct socket *newsock,
 227                        struct proto_accept_arg *arg)
 228 {
 229         struct sock *sk = sock->sk;
 230         struct alg_sock *ask = alg_sk(sk);
 231         struct hash_ctx *ctx = ask->private;
 232         struct ahash_request *req = &ctx->req;
 233         struct crypto_ahash *tfm;
 234         struct sock *sk2;
 235         struct alg_sock *ask2;
 236         struct hash_ctx *ctx2;
 237         char *state;
 238         bool more;
 239         int err;
 240
 241         tfm = crypto_ahash_reqtfm(req);
 242         state = kmalloc(crypto_ahash_statesize(tfm), GFP_KERNEL);
 243         err = -ENOMEM;
 244         if (!state)
 245                 goto out;
 246
 247         lock_sock(sk);
 248         more = ctx->more;
 249         err = more ? crypto_ahash_export(req, state) : 0;
 250         release_sock(sk);
 251
 252         if (err)
 253                 goto out_free_state;
 254
 255         err = af_alg_accept(ask->parent, newsock, arg);
 256         if (err)
 257                 goto out_free_state;
 258
 259         sk2 = newsock->sk;
 260         ask2 = alg_sk(sk2);
 261         ctx2 = ask2->private;
 262         ctx2->more = more;
 263
 264         if (!more)
 265                 goto out_free_state;
 266
 267         err = crypto_ahash_import(&ctx2->req, state);
 268         if (err) {
 269                 sock_orphan(sk2);
 270                 sock_put(sk2);
 271         }
 272
 273 out_free_state:
 274         kfree_sensitive(state);
 275
 276 out:
 277         return err;
 278 }
 279
 280 static struct proto_ops algif_hash_ops = {
 281         .family         =       PF_ALG,
 282
 283         .connect        =       sock_no_connect,
 284         .socketpair     =       sock_no_socketpair,
 285         .getname        =       sock_no_getname,
 286         .ioctl          =       sock_no_ioctl,
 287         .listen         =       sock_no_listen,
 288         .shutdown       =       sock_no_shutdown,
 289         .mmap           =       sock_no_mmap,
 290         .bind           =       sock_no_bind,
 291
 292         .release        =       af_alg_release,
 293         .sendmsg        =       hash_sendmsg,
 294         .recvmsg        =       hash_recvmsg,
 295         .accept         =       hash_accept,
 296 };
 297
 298 static int hash_check_key(struct socket *sock)
 299 {
 300         int err = 0;
 301         struct sock *psk;
 302         struct alg_sock *pask;
 303         struct crypto_ahash *tfm;
 304         struct sock *sk = sock->sk;
 305         struct alg_sock *ask = alg_sk(sk);
 306
 307         lock_sock(sk);
 308         if (!atomic_read(&ask->nokey_refcnt))
 309                 goto unlock_child;
 310
 311         psk = ask->parent;
 312         pask = alg_sk(ask->parent);
 313         tfm = pask->private;
 314
 315         err = -ENOKEY;
 316         lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
 317         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 318                 goto unlock;
 319
 320         atomic_dec(&pask->nokey_refcnt);
 321         atomic_set(&ask->nokey_refcnt, 0);
 322
 323         err = 0;
 324
 325 unlock:
 326         release_sock(psk);
 327 unlock_child:
 328         release_sock(sk);
 329
 330         return err;
 331 }
 332
 333 static int hash_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
 334                               size_t size)
 335 {
 336         int err;
 337
 338         err = hash_check_key(sock);
 339         if (err)
 340                 return err;
 341
 342         return hash_sendmsg(sock, msg, size);
 343 }
 344
 345 static int hash_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
 346                               size_t ignored, int flags)
 347 {
 348         int err;
 349
 350         err = hash_check_key(sock);
 351         if (err)
 352                 return err;
 353
 354         return hash_recvmsg(sock, msg, ignored, flags);
 355 }
 356
 357 static int hash_accept_nokey(struct socket *sock, struct socket *newsock,
 358                              struct proto_accept_arg *arg)
 359 {
 360         int err;
 361
 362         err = hash_check_key(sock);
 363         if (err)
 364                 return err;
 365
 366         return hash_accept(sock, newsock, arg);
 367 }
 368
 369 static struct proto_ops algif_hash_ops_nokey = {
 370         .family         =       PF_ALG,
 371
 372         .connect        =       sock_no_connect,
 373         .socketpair     =       sock_no_socketpair,
 374         .getname        =       sock_no_getname,
 375         .ioctl          =       sock_no_ioctl,
 376         .listen         =       sock_no_listen,
 377         .shutdown       =       sock_no_shutdown,
 378         .mmap           =       sock_no_mmap,
 379         .bind           =       sock_no_bind,
 380
 381         .release        =       af_alg_release,
 382         .sendmsg        =       hash_sendmsg_nokey,
 383         .recvmsg        =       hash_recvmsg_nokey,
 384         .accept         =       hash_accept_nokey,
 385 };
 386
 387 static void *hash_bind(const char *name, u32 type, u32 mask)
 388 {
 389         return crypto_alloc_ahash(name, type, mask);
 390 }
 391
 392 static void hash_release(void *private)
 393 {
 394         crypto_free_ahash(private);
 395 }
 396
 397 static int hash_setkey(void *private, const u8 *key, unsigned int keylen)
 398 {
 399         return crypto_ahash_setkey(private, key, keylen);
 400 }
 401
 402 static void hash_sock_destruct(struct sock *sk)
 403 {
 404         struct alg_sock *ask = alg_sk(sk);
 405         struct hash_ctx *ctx = ask->private;
 406
 407         hash_free_result(sk, ctx);
 408         sock_kfree_s(sk, ctx, ctx->len);
 409         af_alg_release_parent(sk);
 410 }
 411
 412 static int hash_accept_parent_nokey(void *private, struct sock *sk)
 413 {
 414         struct crypto_ahash *tfm = private;
 415         struct alg_sock *ask = alg_sk(sk);
 416         struct hash_ctx *ctx;
 417         unsigned int len = sizeof(*ctx) + crypto_ahash_reqsize(tfm);
 418
 419         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
 420         if (!ctx)
 421                 return -ENOMEM;
 422
 423         ctx->result = NULL;
 424         ctx->len = len;
 425         ctx->more = false;
 426         crypto_init_wait(&ctx->wait);
 427
 428         ask->private = ctx;
 429
 430         ahash_request_set_tfm(&ctx->req, tfm);
 431         ahash_request_set_callback(&ctx->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
 432                                    crypto_req_done, &ctx->wait);
 433
 434         sk->sk_destruct = hash_sock_destruct;
 435
 436         return 0;
 437 }
 438
 439 static int hash_accept_parent(void *private, struct sock *sk)
 440 {
 441         struct crypto_ahash *tfm = private;
 442
 443         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 444                 return -ENOKEY;
 445
 446         return hash_accept_parent_nokey(private, sk);
 447 }
 448
 449 static const struct af_alg_type algif_type_hash = {
 450         .bind           =       hash_bind,
 451         .release        =       hash_release,
 452         .setkey         =       hash_setkey,
 453         .accept         =       hash_accept_parent,
 454         .accept_nokey   =       hash_accept_parent_nokey,
 455         .ops            =       &algif_hash_ops,
 456         .ops_nokey      =       &algif_hash_ops_nokey,
 457         .name           =       "hash",
 458         .owner          =       THIS_MODULE
 459 };
 460
 461 static int __init algif_hash_init(void)
 462 {
 463         return af_alg_register_type(&algif_type_hash);
 464 }
 465
 466 static void __exit algif_hash_exit(void)
 467 {
 468         int err = af_alg_unregister_type(&algif_type_hash);
 469         BUG_ON(err);
 470 }
 471
 472 module_init(algif_hash_init);
 473 module_exit(algif_hash_exit);
 474 MODULE_DESCRIPTION("Userspace interface for hash algorithms");
 475 MODULE_LICENSE("GPL");