crypto/algif_kpp.c

   1 /*
   2  * algif_kpp: User-space interface for key protocol primitives algorithms
   3  *
   4  * Copyright (C) 2018 - 2020, Stephan Mueller <smueller@chronox.de>
   5  *
   6  * This file provides the user-space API for key protocol primitives.
   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  * The following concept of the memory management is used:
  14  *
  15  * The kernel maintains two SGLs, the TX SGL and the RX SGL. The TX SGL is
  16  * filled by user space with the data submitted via sendpage/sendmsg. Filling
  17  * up the TX SGL does not cause a crypto operation -- the data will only be
  18  * tracked by the kernel. Upon receipt of one recvmsg call, the caller must
  19  * provide a buffer which is tracked with the RX SGL.
  20  *
  21  * During the processing of the recvmsg operation, the cipher request is
  22  * allocated and prepared. As part of the recvmsg operation, the processed
  23  * TX buffers are extracted from the TX SGL into a separate SGL.
  24  *
  25  * After the completion of the crypto operation, the RX SGL and the cipher
  26  * request is released. The extracted TX SGL parts are released together with
  27  * the RX SGL release.
  28  */
  29
  30 #include <crypto/dh.h>
  31 #include <crypto/ecdh.h>
  32 #include <crypto/kpp.h>
  33 #include <crypto/rng.h>
  34 #include <crypto/if_alg.h>
  35 #include <crypto/scatterwalk.h>
  36 #include <linux/init.h>
  37 #include <linux/kernel.h>
  38 #include <linux/list.h>
  39 #include <linux/mm.h>
  40 #include <linux/module.h>
  41 #include <linux/net.h>
  42 #include <net/sock.h>
  43
  44 struct kpp_tfm {
  45         struct crypto_kpp *kpp;
  46         bool has_key;
  47
  48 #define KPP_NO_PARAMS   0
  49 #define KPP_DH_PARAMS   1
  50 #define KPP_ECDH_PARAMS 2
  51         int has_params;         /* Type of KPP mechanism */
  52 };
  53
  54 static int kpp_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
  55 {
  56         return af_alg_sendmsg(sock, msg, size, 0);
  57 }
  58
  59 static inline int kpp_cipher_op(struct af_alg_ctx *ctx,
  60                                 struct af_alg_async_req *areq)
  61 {
  62         switch (ctx->op) {
  63         case ALG_OP_KEYGEN:
  64                 return crypto_kpp_generate_public_key(&areq->cra_u.kpp_req);
  65         case ALG_OP_SSGEN:
  66                 return crypto_kpp_compute_shared_secret(&areq->cra_u.kpp_req);
  67         default:
  68                 return -EOPNOTSUPP;
  69         }
  70 }
  71
  72 static int _kpp_recvmsg(struct socket *sock, struct msghdr *msg,
  73                              size_t ignored, int flags)
  74 {
  75         struct sock *sk = sock->sk;
  76         struct alg_sock *ask = alg_sk(sk);
  77         struct sock *psk = ask->parent;
  78         struct alg_sock *pask = alg_sk(psk);
  79         struct af_alg_ctx *ctx = ask->private;
  80         struct kpp_tfm *kpp = pask->private;
  81         struct crypto_kpp *tfm = kpp->kpp;
  82         struct af_alg_async_req *areq;
  83         size_t len;
  84         size_t used = 0;
  85         int err;
  86         int maxsize;
  87
  88         if (!ctx->used) {
  89                 err = af_alg_wait_for_data(sk, flags, 0);
  90                 if (err)
  91                         return err;
  92         }
  93
  94         maxsize = crypto_kpp_maxsize(tfm);
  95         if (maxsize < 0)
  96                 return maxsize;
  97
  98         /* Allocate cipher request for current operation. */
  99         areq = af_alg_alloc_areq(sk, sizeof(struct af_alg_async_req) +
 100                                             crypto_kpp_reqsize(tfm));
 101         if (IS_ERR(areq))
 102                 return PTR_ERR(areq);
 103
 104         /* convert iovecs of output buffers into RX SGL */
 105         err = af_alg_get_rsgl(sk, msg, flags, areq, maxsize, &len);
 106         if (err)
 107                 goto free;
 108
 109         /* ensure output buffer is sufficiently large */
 110         if (len < maxsize) {
 111                 err = -EMSGSIZE;
 112                 goto free;
 113         }
 114
 115         /*
 116          * Create a per request TX SGL for this request which tracks the
 117          * SG entries from the global TX SGL.
 118          */
 119         if (ctx->op == ALG_OP_SSGEN) {
 120                 used = ctx->used;
 121
 122                 areq->tsgl_entries = af_alg_count_tsgl(sk, used, 0);
 123                 if (!areq->tsgl_entries)
 124                         areq->tsgl_entries = 1;
 125                 areq->tsgl = sock_kmalloc(
 126                                 sk, sizeof(*areq->tsgl) * areq->tsgl_entries,
 127                                 GFP_KERNEL);
 128                 if (!areq->tsgl) {
 129                         err = -ENOMEM;
 130                         goto free;
 131                 }
 132                 sg_init_table(areq->tsgl, areq->tsgl_entries);
 133                 af_alg_pull_tsgl(sk, used, areq->tsgl, 0);
 134         }
 135
 136         /* Initialize the crypto operation */
 137         kpp_request_set_input(&areq->cra_u.kpp_req, areq->tsgl, used);
 138         kpp_request_set_output(&areq->cra_u.kpp_req, areq->first_rsgl.sgl.sg,
 139                                len);
 140         kpp_request_set_tfm(&areq->cra_u.kpp_req, tfm);
 141
 142         if (msg->msg_iocb && !is_sync_kiocb(msg->msg_iocb)) {
 143                 /* AIO operation */
 144                 sock_hold(sk);
 145                 areq->iocb = msg->msg_iocb;
 146
 147                 /* Remember output size that will be generated. */
 148                 areq->outlen = len;
 149
 150                 kpp_request_set_callback(&areq->cra_u.kpp_req,
 151                                               CRYPTO_TFM_REQ_MAY_SLEEP,
 152                                               af_alg_async_cb, areq);
 153                 err = kpp_cipher_op(ctx, areq);
 154
 155                 /* AIO operation in progress */
 156                 if (err == -EINPROGRESS || err == -EBUSY)
 157                         return -EIOCBQUEUED;
 158
 159                 sock_put(sk);
 160         } else {
 161                 /* Synchronous operation */
 162                 kpp_request_set_callback(&areq->cra_u.kpp_req,
 163                                               CRYPTO_TFM_REQ_MAY_SLEEP |
 164                                               CRYPTO_TFM_REQ_MAY_BACKLOG,
 165                                               crypto_req_done,
 166                                               &ctx->wait);
 167                 err = crypto_wait_req(kpp_cipher_op(ctx, areq), &ctx->wait);
 168         }
 169
 170 free:
 171         af_alg_free_resources(areq);
 172
 173         return err ? err : len;
 174 }
 175
 176 static int kpp_recvmsg(struct socket *sock, struct msghdr *msg,
 177                             size_t ignored, int flags)
 178 {
 179         struct sock *sk = sock->sk;
 180         struct alg_sock *ask = alg_sk(sk);
 181         struct sock *psk = ask->parent;
 182         struct alg_sock *pask = alg_sk(psk);
 183         struct kpp_tfm *kpp = pask->private;
 184         struct crypto_kpp *tfm = kpp->kpp;
 185         int ret = 0;
 186         int err;
 187
 188         lock_sock(sk);
 189
 190         while (msg_data_left(msg)) {
 191                 err = _kpp_recvmsg(sock, msg, ignored, flags);
 192
 193                 /*
 194                  * This error covers -EIOCBQUEUED which implies that we can
 195                  * only handle one AIO request. If the caller wants to have
 196                  * multiple AIO requests in parallel, he must make multiple
 197                  * separate AIO calls.
 198                  */
 199                 if (err <= 0) {
 200                         if (err == -EIOCBQUEUED || err == -EBADMSG || !ret)
 201                                 ret = err;
 202                         goto out;
 203                 }
 204
 205                 ret += err;
 206
 207                 /*
 208                  * The caller must provide crypto_kpp_maxsize per request.
 209                  * If he provides more, we conclude that multiple kpp
 210                  * operations are requested.
 211                  */
 212                 iov_iter_advance(&msg->msg_iter,
 213                                  crypto_kpp_maxsize(tfm) - err);
 214         }
 215
 216 out:
 217
 218         af_alg_wmem_wakeup(sk);
 219         release_sock(sk);
 220         return ret;
 221 }
 222
 223 static struct proto_ops algif_kpp_ops = {
 224         .family         =       PF_ALG,
 225
 226         .connect        =       sock_no_connect,
 227         .socketpair     =       sock_no_socketpair,
 228         .getname        =       sock_no_getname,
 229         .ioctl          =       sock_no_ioctl,
 230         .listen         =       sock_no_listen,
 231         .shutdown       =       sock_no_shutdown,
 232         .mmap           =       sock_no_mmap,
 233         .bind           =       sock_no_bind,
 234         .accept         =       sock_no_accept,
 235
 236         .release        =       af_alg_release,
 237         .sendmsg        =       kpp_sendmsg,
 238         .sendpage       =       af_alg_sendpage,
 239         .recvmsg        =       kpp_recvmsg,
 240         .poll           =       af_alg_poll,
 241 };
 242
 243 static int kpp_check_key(struct socket *sock)
 244 {
 245         struct sock *psk;
 246         struct alg_sock *pask;
 247         struct kpp_tfm *tfm;
 248         struct sock *sk = sock->sk;
 249         struct alg_sock *ask = alg_sk(sk);
 250         int err = 0;
 251
 252         lock_sock(sk);
 253         if (!atomic_read(&ask->refcnt))
 254                 goto unlock_child;
 255
 256         psk = ask->parent;
 257         pask = alg_sk(ask->parent);
 258         tfm = pask->private;
 259
 260         lock_sock_nested(psk, SINGLE_DEPTH_NESTING);
 261         if (!tfm->has_key || (tfm->has_params == KPP_NO_PARAMS)) {
 262                 err = -ENOKEY;
 263                 goto unlock;
 264         }
 265
 266         atomic_dec(&pask->refcnt);
 267         atomic_set(&ask->refcnt, 0);
 268
 269         err = 0;
 270
 271 unlock:
 272         release_sock(psk);
 273 unlock_child:
 274         release_sock(sk);
 275
 276         return err;
 277 }
 278
 279 static int kpp_sendmsg_nokey(struct socket *sock, struct msghdr *msg,
 280                                   size_t size)
 281 {
 282         int err;
 283
 284         err = kpp_check_key(sock);
 285         if (err)
 286                 return err;
 287
 288         return kpp_sendmsg(sock, msg, size);
 289 }
 290
 291 static ssize_t kpp_sendpage_nokey(struct socket *sock, struct page *page,
 292                                        int offset, size_t size, int flags)
 293 {
 294         int err;
 295
 296         err = kpp_check_key(sock);
 297         if (err)
 298                 return err;
 299
 300         return af_alg_sendpage(sock, page, offset, size, flags);
 301 }
 302
 303 static int kpp_recvmsg_nokey(struct socket *sock, struct msghdr *msg,
 304                                   size_t ignored, int flags)
 305 {
 306         int err;
 307
 308         err = kpp_check_key(sock);
 309         if (err)
 310                 return err;
 311
 312         return kpp_recvmsg(sock, msg, ignored, flags);
 313 }
 314
 315 static struct proto_ops algif_kpp_ops_nokey = {
 316         .family         =       PF_ALG,
 317
 318         .connect        =       sock_no_connect,
 319         .socketpair     =       sock_no_socketpair,
 320         .getname        =       sock_no_getname,
 321         .ioctl          =       sock_no_ioctl,
 322         .listen         =       sock_no_listen,
 323         .shutdown       =       sock_no_shutdown,
 324         .mmap           =       sock_no_mmap,
 325         .bind           =       sock_no_bind,
 326         .accept         =       sock_no_accept,
 327
 328         .release        =       af_alg_release,
 329         .sendmsg        =       kpp_sendmsg_nokey,
 330         .sendpage       =       kpp_sendpage_nokey,
 331         .recvmsg        =       kpp_recvmsg_nokey,
 332         .poll           =       af_alg_poll,
 333 };
 334
 335 static void *kpp_bind(const char *name, u32 type, u32 mask)
 336 {
 337         struct kpp_tfm *tfm;
 338         struct crypto_kpp *kpp;
 339
 340         tfm = kmalloc(sizeof(*tfm), GFP_KERNEL);
 341         if (!tfm)
 342                 return ERR_PTR(-ENOMEM);
 343
 344         kpp = crypto_alloc_kpp(name, type, mask);
 345         if (IS_ERR(kpp)) {
 346                 kfree(tfm);
 347                 return ERR_CAST(kpp);
 348         }
 349
 350         tfm->kpp = kpp;
 351         tfm->has_key = false;
 352         tfm->has_params = KPP_NO_PARAMS;
 353
 354         return tfm;
 355 }
 356
 357 static void kpp_release(void *private)
 358 {
 359         struct kpp_tfm *tfm = private;
 360         struct crypto_kpp *kpp = tfm->kpp;
 361
 362         crypto_free_kpp(kpp);
 363         kfree(tfm);
 364 }
 365
 366 static int kpp_dh_set_secret(struct crypto_kpp *tfm, struct dh *params)
 367 {
 368         char *packed_key = NULL;
 369         unsigned int packed_key_len;
 370         int ret;
 371
 372         packed_key_len = crypto_dh_key_len(params);
 373         packed_key = kmalloc(packed_key_len, GFP_KERNEL);
 374         if (!packed_key)
 375                 return -ENOMEM;
 376
 377         ret = crypto_dh_encode_key(packed_key, packed_key_len, params);
 378         if (ret)
 379                 goto out;
 380
 381         ret = crypto_kpp_set_secret(tfm, packed_key, packed_key_len);
 382
 383 out:
 384         kfree(packed_key);
 385         return ret;
 386 }
 387
 388 static int kpp_dh_set_privkey(struct crypto_kpp *tfm, const u8 *key,
 389                               unsigned int keylen)
 390 {
 391         struct dh params = {
 392                 .key = key,
 393                 .key_size = keylen,
 394                 .p = NULL,
 395                 .p_size = 0,
 396                 .g = NULL,
 397                 .g_size = 0,
 398         };
 399
 400         return kpp_dh_set_secret(tfm, &params);
 401 }
 402
 403 static int kpp_ecdh_set_secret(struct crypto_kpp *tfm, struct ecdh *params)
 404 {
 405         char *packed_key = NULL;
 406         unsigned int packed_key_len;
 407         int ret;
 408
 409         packed_key_len = crypto_ecdh_key_len(params);
 410         packed_key = kmalloc(packed_key_len, GFP_KERNEL);
 411         if (!packed_key)
 412                 return -ENOMEM;
 413
 414         ret = crypto_ecdh_encode_key(packed_key, packed_key_len, params);
 415         if (ret)
 416                 goto out;
 417
 418         ret = crypto_kpp_set_secret(tfm, packed_key, packed_key_len);
 419
 420 out:
 421         kfree(packed_key);
 422         return ret;
 423 }
 424
 425 static int kpp_ecdh_set_privkey(struct crypto_kpp *tfm, const u8 *key,
 426                                 unsigned int keylen)
 427 {
 428         struct ecdh params = {
 429                 .curve_id = 0,
 430                 .key = key,
 431                 .key_size = keylen,
 432         };
 433
 434         return kpp_ecdh_set_secret(tfm, &params);
 435 }
 436
 437 static int kpp_setprivkey(void *private, const u8 *key, unsigned int keylen)
 438 {
 439         struct kpp_tfm *kpp = private;
 440         struct crypto_kpp *tfm = kpp->kpp;
 441         int err;
 442
 443         if (kpp->has_params == KPP_NO_PARAMS)
 444                 return -ENOKEY;
 445
 446         /* The DH code cannot generate private keys. ECDH can do that */
 447         if ((!key || !keylen) && (kpp->has_params == KPP_DH_PARAMS)) {
 448                 kpp->has_key = false;
 449                 return -EOPNOTSUPP;
 450         }
 451
 452         switch (kpp->has_params) {
 453         case KPP_DH_PARAMS:
 454                 err = kpp_dh_set_privkey(tfm, key, keylen);
 455                 break;
 456         case KPP_ECDH_PARAMS:
 457                 err = kpp_ecdh_set_privkey(tfm, key, keylen);
 458                 break;
 459         default:
 460                 err = -EFAULT;
 461         }
 462
 463         kpp->has_key = !err;
 464
 465         /* Return the maximum size of the kpp operation. */
 466         if (!err)
 467                 err = crypto_kpp_maxsize(tfm);
 468
 469         return err;
 470 }
 471
 472 static int kpp_dh_setparams_pkcs3(void *private, const u8 *params,
 473                                   unsigned int paramslen)
 474 {
 475         struct kpp_tfm *kpp = private;
 476         struct crypto_kpp *tfm = kpp->kpp;
 477         int err;
 478
 479         /* If parameters were already set, disallow setting them again. */
 480         if (kpp->has_params != KPP_NO_PARAMS)
 481                 return -EINVAL;
 482
 483         err = crypto_kpp_set_params(tfm, params, paramslen);
 484         if (!err) {
 485                 kpp->has_params = KPP_DH_PARAMS;
 486                 /* Return the maximum size of the kpp operation. */
 487                 err = crypto_kpp_maxsize(tfm);
 488         } else
 489                 kpp->has_params = KPP_NO_PARAMS;
 490
 491         return err;
 492 }
 493
 494 static int kpp_ecdh_setcurve(void *private, const u8 *curveid,
 495                              unsigned int curveidlen)
 496 {
 497         struct kpp_tfm *kpp = private;
 498         struct crypto_kpp *tfm = kpp->kpp;
 499         int err;
 500         struct ecdh params = {
 501                 .key = NULL,
 502                 .key_size = 0,
 503         };
 504
 505         /* If parameters were already set, disallow setting them again. */
 506         if (kpp->has_params != KPP_NO_PARAMS)
 507                 return -EINVAL;
 508
 509         if (curveidlen != sizeof(unsigned long))
 510                 return -EINVAL;
 511
 512         err = kstrtou16(curveid, 10, &params.curve_id);
 513         if (err)
 514                 return err;
 515
 516         err = kpp_ecdh_set_secret(tfm, &params);
 517         if (!err) {
 518                 kpp->has_params = KPP_ECDH_PARAMS;
 519                 /* Return the maximum size of the kpp operation. */
 520                 err = crypto_kpp_maxsize(tfm);
 521         } else
 522                 kpp->has_params = KPP_NO_PARAMS;
 523
 524         return err;
 525 }
 526
 527 static void kpp_sock_destruct(struct sock *sk)
 528 {
 529         struct alg_sock *ask = alg_sk(sk);
 530         struct af_alg_ctx *ctx = ask->private;
 531
 532         af_alg_pull_tsgl(sk, ctx->used, NULL, 0);
 533         sock_kfree_s(sk, ctx, ctx->len);
 534         af_alg_release_parent(sk);
 535 }
 536
 537 static int kpp_accept_parent_nokey(void *private, struct sock *sk)
 538 {
 539         struct af_alg_ctx *ctx;
 540         struct alg_sock *ask = alg_sk(sk);
 541         unsigned int len = sizeof(*ctx);
 542
 543         ctx = sock_kmalloc(sk, len, GFP_KERNEL);
 544         if (!ctx)
 545                 return -ENOMEM;
 546
 547         INIT_LIST_HEAD(&ctx->tsgl_list);
 548         ctx->len = len;
 549         ctx->used = 0;
 550         atomic_set(&ctx->rcvused, 0);
 551         ctx->more = 0;
 552         ctx->merge = 0;
 553         ctx->op = 0;
 554         crypto_init_wait(&ctx->wait);
 555
 556         ask->private = ctx;
 557
 558         sk->sk_destruct = kpp_sock_destruct;
 559
 560         return 0;
 561 }
 562
 563 static int kpp_accept_parent(void *private, struct sock *sk)
 564 {
 565         struct kpp_tfm *tfm = private;
 566
 567         if (!tfm->has_key || (tfm->has_params == KPP_NO_PARAMS))
 568                 return -ENOKEY;
 569
 570         return kpp_accept_parent_nokey(private, sk);
 571 }
 572
 573 static const struct af_alg_type algif_type_kpp = {
 574         .bind           =       kpp_bind,
 575         .release        =       kpp_release,
 576         .setkey         =       kpp_setprivkey,
 577         .setpubkey      =       NULL,
 578         .dhparams       =       kpp_dh_setparams_pkcs3,
 579         .ecdhcurve      =       kpp_ecdh_setcurve,
 580         .setauthsize    =       NULL,
 581         .accept         =       kpp_accept_parent,
 582         .accept_nokey   =       kpp_accept_parent_nokey,
 583         .ops            =       &algif_kpp_ops,
 584         .ops_nokey      =       &algif_kpp_ops_nokey,
 585         .name           =       "kpp",
 586         .owner          =       THIS_MODULE
 587 };
 588
 589 static int __init algif_kpp_init(void)
 590 {
 591         return af_alg_register_type(&algif_type_kpp);
 592 }
 593
 594 static void __exit algif_kpp_exit(void)
 595 {
 596         int err = af_alg_unregister_type(&algif_type_kpp);
 597
 598         BUG_ON(err);
 599 }
 600
 601 module_init(algif_kpp_init);
 602 module_exit(algif_kpp_exit);
 603 MODULE_LICENSE("GPL");
 604 MODULE_AUTHOR("Stephan Mueller <smueller@chronox.de>");
 605 MODULE_DESCRIPTION("Key protocol primitives kernel crypto API user space interface");
 606