root/crypto/simd.c

DEFINITIONS

1. simd_skcipher_setkey
2. simd_skcipher_encrypt
3. simd_skcipher_decrypt
4. simd_skcipher_exit
5. simd_skcipher_init
6. simd_skcipher_create_compat
7. simd_skcipher_create
8. simd_skcipher_free
9. simd_register_skciphers_compat
10. simd_unregister_skciphers
11. simd_aead_setkey
12. simd_aead_setauthsize
13. simd_aead_encrypt
14. simd_aead_decrypt
15. simd_aead_exit
16. simd_aead_init
17. simd_aead_create_compat
18. simd_aead_create
19. simd_aead_free
20. simd_register_aeads_compat
21. simd_unregister_aeads

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Shared crypto simd helpers
   4  *
   5  * Copyright (c) 2012 Jussi Kivilinna <jussi.kivilinna@mbnet.fi>
   6  * Copyright (c) 2016 Herbert Xu <herbert@gondor.apana.org.au>
   7  * Copyright (c) 2019 Google LLC
   8  *
   9  * Based on aesni-intel_glue.c by:
  10  *  Copyright (C) 2008, Intel Corp.
  11  *    Author: Huang Ying <ying.huang@intel.com>
  12  */
  13 
  14 /*
  15  * Shared crypto SIMD helpers.  These functions dynamically create and register
  16  * an skcipher or AEAD algorithm that wraps another, internal algorithm.  The
  17  * wrapper ensures that the internal algorithm is only executed in a context
  18  * where SIMD instructions are usable, i.e. where may_use_simd() returns true.
  19  * If SIMD is already usable, the wrapper directly calls the internal algorithm.
  20  * Otherwise it defers execution to a workqueue via cryptd.
  21  *
  22  * This is an alternative to the internal algorithm implementing a fallback for
  23  * the !may_use_simd() case itself.
  24  *
  25  * Note that the wrapper algorithm is asynchronous, i.e. it has the
  26  * CRYPTO_ALG_ASYNC flag set.  Therefore it won't be found by users who
  27  * explicitly allocate a synchronous algorithm.
  28  */
  29 
  30 #include <crypto/cryptd.h>
  31 #include <crypto/internal/aead.h>
  32 #include <crypto/internal/simd.h>
  33 #include <crypto/internal/skcipher.h>
  34 #include <linux/kernel.h>
  35 #include <linux/module.h>
  36 #include <linux/preempt.h>
  37 #include <asm/simd.h>
  38 
  39 /* skcipher support */
  40 
  41 struct simd_skcipher_alg {
  42         const char *ialg_name;
  43         struct skcipher_alg alg;
  44 };
  45 
  46 struct simd_skcipher_ctx {
  47         struct cryptd_skcipher *cryptd_tfm;
  48 };
  49 
  50 static int simd_skcipher_setkey(struct crypto_skcipher *tfm, const u8 *key,
  51                                 unsigned int key_len)
  52 {
  53         struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  54         struct crypto_skcipher *child = &ctx->cryptd_tfm->base;
  55         int err;
  56 
  57         crypto_skcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
  58         crypto_skcipher_set_flags(child, crypto_skcipher_get_flags(tfm) &
  59                                          CRYPTO_TFM_REQ_MASK);
  60         err = crypto_skcipher_setkey(child, key, key_len);
  61         crypto_skcipher_set_flags(tfm, crypto_skcipher_get_flags(child) &
  62                                        CRYPTO_TFM_RES_MASK);
  63         return err;
  64 }
  65 
  66 static int simd_skcipher_encrypt(struct skcipher_request *req)
  67 {
  68         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  69         struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  70         struct skcipher_request *subreq;
  71         struct crypto_skcipher *child;
  72 
  73         subreq = skcipher_request_ctx(req);
  74         *subreq = *req;
  75 
  76         if (!crypto_simd_usable() ||
  77             (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
  78                 child = &ctx->cryptd_tfm->base;
  79         else
  80                 child = cryptd_skcipher_child(ctx->cryptd_tfm);
  81 
  82         skcipher_request_set_tfm(subreq, child);
  83 
  84         return crypto_skcipher_encrypt(subreq);
  85 }
  86 
  87 static int simd_skcipher_decrypt(struct skcipher_request *req)
  88 {
  89         struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
  90         struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
  91         struct skcipher_request *subreq;
  92         struct crypto_skcipher *child;
  93 
  94         subreq = skcipher_request_ctx(req);
  95         *subreq = *req;
  96 
  97         if (!crypto_simd_usable() ||
  98             (in_atomic() && cryptd_skcipher_queued(ctx->cryptd_tfm)))
  99                 child = &ctx->cryptd_tfm->base;
 100         else
 101                 child = cryptd_skcipher_child(ctx->cryptd_tfm);
 102 
 103         skcipher_request_set_tfm(subreq, child);
 104 
 105         return crypto_skcipher_decrypt(subreq);
 106 }
 107 
 108 static void simd_skcipher_exit(struct crypto_skcipher *tfm)
 109 {
 110         struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
 111 
 112         cryptd_free_skcipher(ctx->cryptd_tfm);
 113 }
 114 
 115 static int simd_skcipher_init(struct crypto_skcipher *tfm)
 116 {
 117         struct simd_skcipher_ctx *ctx = crypto_skcipher_ctx(tfm);
 118         struct cryptd_skcipher *cryptd_tfm;
 119         struct simd_skcipher_alg *salg;
 120         struct skcipher_alg *alg;
 121         unsigned reqsize;
 122 
 123         alg = crypto_skcipher_alg(tfm);
 124         salg = container_of(alg, struct simd_skcipher_alg, alg);
 125 
 126         cryptd_tfm = cryptd_alloc_skcipher(salg->ialg_name,
 127                                            CRYPTO_ALG_INTERNAL,
 128                                            CRYPTO_ALG_INTERNAL);
 129         if (IS_ERR(cryptd_tfm))
 130                 return PTR_ERR(cryptd_tfm);
 131 
 132         ctx->cryptd_tfm = cryptd_tfm;
 133 
 134         reqsize = crypto_skcipher_reqsize(cryptd_skcipher_child(cryptd_tfm));
 135         reqsize = max(reqsize, crypto_skcipher_reqsize(&cryptd_tfm->base));
 136         reqsize += sizeof(struct skcipher_request);
 137 
 138         crypto_skcipher_set_reqsize(tfm, reqsize);
 139 
 140         return 0;
 141 }
 142 
 143 struct simd_skcipher_alg *simd_skcipher_create_compat(const char *algname,
 144                                                       const char *drvname,
 145                                                       const char *basename)
 146 {
 147         struct simd_skcipher_alg *salg;
 148         struct crypto_skcipher *tfm;
 149         struct skcipher_alg *ialg;
 150         struct skcipher_alg *alg;
 151         int err;
 152 
 153         tfm = crypto_alloc_skcipher(basename, CRYPTO_ALG_INTERNAL,
 154                                     CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
 155         if (IS_ERR(tfm))
 156                 return ERR_CAST(tfm);
 157 
 158         ialg = crypto_skcipher_alg(tfm);
 159 
 160         salg = kzalloc(sizeof(*salg), GFP_KERNEL);
 161         if (!salg) {
 162                 salg = ERR_PTR(-ENOMEM);
 163                 goto out_put_tfm;
 164         }
 165 
 166         salg->ialg_name = basename;
 167         alg = &salg->alg;
 168 
 169         err = -ENAMETOOLONG;
 170         if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
 171             CRYPTO_MAX_ALG_NAME)
 172                 goto out_free_salg;
 173 
 174         if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
 175                      drvname) >= CRYPTO_MAX_ALG_NAME)
 176                 goto out_free_salg;
 177 
 178         alg->base.cra_flags = CRYPTO_ALG_ASYNC;
 179         alg->base.cra_priority = ialg->base.cra_priority;
 180         alg->base.cra_blocksize = ialg->base.cra_blocksize;
 181         alg->base.cra_alignmask = ialg->base.cra_alignmask;
 182         alg->base.cra_module = ialg->base.cra_module;
 183         alg->base.cra_ctxsize = sizeof(struct simd_skcipher_ctx);
 184 
 185         alg->ivsize = ialg->ivsize;
 186         alg->chunksize = ialg->chunksize;
 187         alg->min_keysize = ialg->min_keysize;
 188         alg->max_keysize = ialg->max_keysize;
 189 
 190         alg->init = simd_skcipher_init;
 191         alg->exit = simd_skcipher_exit;
 192 
 193         alg->setkey = simd_skcipher_setkey;
 194         alg->encrypt = simd_skcipher_encrypt;
 195         alg->decrypt = simd_skcipher_decrypt;
 196 
 197         err = crypto_register_skcipher(alg);
 198         if (err)
 199                 goto out_free_salg;
 200 
 201 out_put_tfm:
 202         crypto_free_skcipher(tfm);
 203         return salg;
 204 
 205 out_free_salg:
 206         kfree(salg);
 207         salg = ERR_PTR(err);
 208         goto out_put_tfm;
 209 }
 210 EXPORT_SYMBOL_GPL(simd_skcipher_create_compat);
 211 
 212 struct simd_skcipher_alg *simd_skcipher_create(const char *algname,
 213                                                const char *basename)
 214 {
 215         char drvname[CRYPTO_MAX_ALG_NAME];
 216 
 217         if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
 218             CRYPTO_MAX_ALG_NAME)
 219                 return ERR_PTR(-ENAMETOOLONG);
 220 
 221         return simd_skcipher_create_compat(algname, drvname, basename);
 222 }
 223 EXPORT_SYMBOL_GPL(simd_skcipher_create);
 224 
 225 void simd_skcipher_free(struct simd_skcipher_alg *salg)
 226 {
 227         crypto_unregister_skcipher(&salg->alg);
 228         kfree(salg);
 229 }
 230 EXPORT_SYMBOL_GPL(simd_skcipher_free);
 231 
 232 int simd_register_skciphers_compat(struct skcipher_alg *algs, int count,
 233                                    struct simd_skcipher_alg **simd_algs)
 234 {
 235         int err;
 236         int i;
 237         const char *algname;
 238         const char *drvname;
 239         const char *basename;
 240         struct simd_skcipher_alg *simd;
 241 
 242         err = crypto_register_skciphers(algs, count);
 243         if (err)
 244                 return err;
 245 
 246         for (i = 0; i < count; i++) {
 247                 WARN_ON(strncmp(algs[i].base.cra_name, "__", 2));
 248                 WARN_ON(strncmp(algs[i].base.cra_driver_name, "__", 2));
 249                 algname = algs[i].base.cra_name + 2;
 250                 drvname = algs[i].base.cra_driver_name + 2;
 251                 basename = algs[i].base.cra_driver_name;
 252                 simd = simd_skcipher_create_compat(algname, drvname, basename);
 253                 err = PTR_ERR(simd);
 254                 if (IS_ERR(simd))
 255                         goto err_unregister;
 256                 simd_algs[i] = simd;
 257         }
 258         return 0;
 259 
 260 err_unregister:
 261         simd_unregister_skciphers(algs, count, simd_algs);
 262         return err;
 263 }
 264 EXPORT_SYMBOL_GPL(simd_register_skciphers_compat);
 265 
 266 void simd_unregister_skciphers(struct skcipher_alg *algs, int count,
 267                                struct simd_skcipher_alg **simd_algs)
 268 {
 269         int i;
 270 
 271         crypto_unregister_skciphers(algs, count);
 272 
 273         for (i = 0; i < count; i++) {
 274                 if (simd_algs[i]) {
 275                         simd_skcipher_free(simd_algs[i]);
 276                         simd_algs[i] = NULL;
 277                 }
 278         }
 279 }
 280 EXPORT_SYMBOL_GPL(simd_unregister_skciphers);
 281 
 282 /* AEAD support */
 283 
 284 struct simd_aead_alg {
 285         const char *ialg_name;
 286         struct aead_alg alg;
 287 };
 288 
 289 struct simd_aead_ctx {
 290         struct cryptd_aead *cryptd_tfm;
 291 };
 292 
 293 static int simd_aead_setkey(struct crypto_aead *tfm, const u8 *key,
 294                                 unsigned int key_len)
 295 {
 296         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 297         struct crypto_aead *child = &ctx->cryptd_tfm->base;
 298         int err;
 299 
 300         crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK);
 301         crypto_aead_set_flags(child, crypto_aead_get_flags(tfm) &
 302                                      CRYPTO_TFM_REQ_MASK);
 303         err = crypto_aead_setkey(child, key, key_len);
 304         crypto_aead_set_flags(tfm, crypto_aead_get_flags(child) &
 305                                    CRYPTO_TFM_RES_MASK);
 306         return err;
 307 }
 308 
 309 static int simd_aead_setauthsize(struct crypto_aead *tfm, unsigned int authsize)
 310 {
 311         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 312         struct crypto_aead *child = &ctx->cryptd_tfm->base;
 313 
 314         return crypto_aead_setauthsize(child, authsize);
 315 }
 316 
 317 static int simd_aead_encrypt(struct aead_request *req)
 318 {
 319         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
 320         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 321         struct aead_request *subreq;
 322         struct crypto_aead *child;
 323 
 324         subreq = aead_request_ctx(req);
 325         *subreq = *req;
 326 
 327         if (!crypto_simd_usable() ||
 328             (in_atomic() && cryptd_aead_queued(ctx->cryptd_tfm)))
 329                 child = &ctx->cryptd_tfm->base;
 330         else
 331                 child = cryptd_aead_child(ctx->cryptd_tfm);
 332 
 333         aead_request_set_tfm(subreq, child);
 334 
 335         return crypto_aead_encrypt(subreq);
 336 }
 337 
 338 static int simd_aead_decrypt(struct aead_request *req)
 339 {
 340         struct crypto_aead *tfm = crypto_aead_reqtfm(req);
 341         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 342         struct aead_request *subreq;
 343         struct crypto_aead *child;
 344 
 345         subreq = aead_request_ctx(req);
 346         *subreq = *req;
 347 
 348         if (!crypto_simd_usable() ||
 349             (in_atomic() && cryptd_aead_queued(ctx->cryptd_tfm)))
 350                 child = &ctx->cryptd_tfm->base;
 351         else
 352                 child = cryptd_aead_child(ctx->cryptd_tfm);
 353 
 354         aead_request_set_tfm(subreq, child);
 355 
 356         return crypto_aead_decrypt(subreq);
 357 }
 358 
 359 static void simd_aead_exit(struct crypto_aead *tfm)
 360 {
 361         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 362 
 363         cryptd_free_aead(ctx->cryptd_tfm);
 364 }
 365 
 366 static int simd_aead_init(struct crypto_aead *tfm)
 367 {
 368         struct simd_aead_ctx *ctx = crypto_aead_ctx(tfm);
 369         struct cryptd_aead *cryptd_tfm;
 370         struct simd_aead_alg *salg;
 371         struct aead_alg *alg;
 372         unsigned reqsize;
 373 
 374         alg = crypto_aead_alg(tfm);
 375         salg = container_of(alg, struct simd_aead_alg, alg);
 376 
 377         cryptd_tfm = cryptd_alloc_aead(salg->ialg_name, CRYPTO_ALG_INTERNAL,
 378                                        CRYPTO_ALG_INTERNAL);
 379         if (IS_ERR(cryptd_tfm))
 380                 return PTR_ERR(cryptd_tfm);
 381 
 382         ctx->cryptd_tfm = cryptd_tfm;
 383 
 384         reqsize = crypto_aead_reqsize(cryptd_aead_child(cryptd_tfm));
 385         reqsize = max(reqsize, crypto_aead_reqsize(&cryptd_tfm->base));
 386         reqsize += sizeof(struct aead_request);
 387 
 388         crypto_aead_set_reqsize(tfm, reqsize);
 389 
 390         return 0;
 391 }
 392 
 393 struct simd_aead_alg *simd_aead_create_compat(const char *algname,
 394                                               const char *drvname,
 395                                               const char *basename)
 396 {
 397         struct simd_aead_alg *salg;
 398         struct crypto_aead *tfm;
 399         struct aead_alg *ialg;
 400         struct aead_alg *alg;
 401         int err;
 402 
 403         tfm = crypto_alloc_aead(basename, CRYPTO_ALG_INTERNAL,
 404                                 CRYPTO_ALG_INTERNAL | CRYPTO_ALG_ASYNC);
 405         if (IS_ERR(tfm))
 406                 return ERR_CAST(tfm);
 407 
 408         ialg = crypto_aead_alg(tfm);
 409 
 410         salg = kzalloc(sizeof(*salg), GFP_KERNEL);
 411         if (!salg) {
 412                 salg = ERR_PTR(-ENOMEM);
 413                 goto out_put_tfm;
 414         }
 415 
 416         salg->ialg_name = basename;
 417         alg = &salg->alg;
 418 
 419         err = -ENAMETOOLONG;
 420         if (snprintf(alg->base.cra_name, CRYPTO_MAX_ALG_NAME, "%s", algname) >=
 421             CRYPTO_MAX_ALG_NAME)
 422                 goto out_free_salg;
 423 
 424         if (snprintf(alg->base.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
 425                      drvname) >= CRYPTO_MAX_ALG_NAME)
 426                 goto out_free_salg;
 427 
 428         alg->base.cra_flags = CRYPTO_ALG_ASYNC;
 429         alg->base.cra_priority = ialg->base.cra_priority;
 430         alg->base.cra_blocksize = ialg->base.cra_blocksize;
 431         alg->base.cra_alignmask = ialg->base.cra_alignmask;
 432         alg->base.cra_module = ialg->base.cra_module;
 433         alg->base.cra_ctxsize = sizeof(struct simd_aead_ctx);
 434 
 435         alg->ivsize = ialg->ivsize;
 436         alg->maxauthsize = ialg->maxauthsize;
 437         alg->chunksize = ialg->chunksize;
 438 
 439         alg->init = simd_aead_init;
 440         alg->exit = simd_aead_exit;
 441 
 442         alg->setkey = simd_aead_setkey;
 443         alg->setauthsize = simd_aead_setauthsize;
 444         alg->encrypt = simd_aead_encrypt;
 445         alg->decrypt = simd_aead_decrypt;
 446 
 447         err = crypto_register_aead(alg);
 448         if (err)
 449                 goto out_free_salg;
 450 
 451 out_put_tfm:
 452         crypto_free_aead(tfm);
 453         return salg;
 454 
 455 out_free_salg:
 456         kfree(salg);
 457         salg = ERR_PTR(err);
 458         goto out_put_tfm;
 459 }
 460 EXPORT_SYMBOL_GPL(simd_aead_create_compat);
 461 
 462 struct simd_aead_alg *simd_aead_create(const char *algname,
 463                                        const char *basename)
 464 {
 465         char drvname[CRYPTO_MAX_ALG_NAME];
 466 
 467         if (snprintf(drvname, CRYPTO_MAX_ALG_NAME, "simd-%s", basename) >=
 468             CRYPTO_MAX_ALG_NAME)
 469                 return ERR_PTR(-ENAMETOOLONG);
 470 
 471         return simd_aead_create_compat(algname, drvname, basename);
 472 }
 473 EXPORT_SYMBOL_GPL(simd_aead_create);
 474 
 475 void simd_aead_free(struct simd_aead_alg *salg)
 476 {
 477         crypto_unregister_aead(&salg->alg);
 478         kfree(salg);
 479 }
 480 EXPORT_SYMBOL_GPL(simd_aead_free);
 481 
 482 int simd_register_aeads_compat(struct aead_alg *algs, int count,
 483                                struct simd_aead_alg **simd_algs)
 484 {
 485         int err;
 486         int i;
 487         const char *algname;
 488         const char *drvname;
 489         const char *basename;
 490         struct simd_aead_alg *simd;
 491 
 492         err = crypto_register_aeads(algs, count);
 493         if (err)
 494                 return err;
 495 
 496         for (i = 0; i < count; i++) {
 497                 WARN_ON(strncmp(algs[i].base.cra_name, "__", 2));
 498                 WARN_ON(strncmp(algs[i].base.cra_driver_name, "__", 2));
 499                 algname = algs[i].base.cra_name + 2;
 500                 drvname = algs[i].base.cra_driver_name + 2;
 501                 basename = algs[i].base.cra_driver_name;
 502                 simd = simd_aead_create_compat(algname, drvname, basename);
 503                 err = PTR_ERR(simd);
 504                 if (IS_ERR(simd))
 505                         goto err_unregister;
 506                 simd_algs[i] = simd;
 507         }
 508         return 0;
 509 
 510 err_unregister:
 511         simd_unregister_aeads(algs, count, simd_algs);
 512         return err;
 513 }
 514 EXPORT_SYMBOL_GPL(simd_register_aeads_compat);
 515 
 516 void simd_unregister_aeads(struct aead_alg *algs, int count,
 517                            struct simd_aead_alg **simd_algs)
 518 {
 519         int i;
 520 
 521         crypto_unregister_aeads(algs, count);
 522 
 523         for (i = 0; i < count; i++) {
 524                 if (simd_algs[i]) {
 525                         simd_aead_free(simd_algs[i]);
 526                         simd_algs[i] = NULL;
 527                 }
 528         }
 529 }
 530 EXPORT_SYMBOL_GPL(simd_unregister_aeads);
 531 
 532 MODULE_LICENSE("GPL");