crypto/ahash.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Asynchronous Cryptographic Hash operations.
   4  *
   5  * This is the implementation of the ahash (asynchronous hash) API.  It differs
   6  * from shash (synchronous hash) in that ahash supports asynchronous operations,
   7  * and it hashes data from scatterlists instead of virtually addressed buffers.
   8  *
   9  * The ahash API provides access to both ahash and shash algorithms.  The shash
  10  * API only provides access to shash algorithms.
  11  *
  12  * Copyright (c) 2008 Loc Ho <lho@amcc.com>
  13  */
  14
  15 #include <crypto/scatterwalk.h>
  16 #include <linux/cryptouser.h>
  17 #include <linux/err.h>
  18 #include <linux/kernel.h>
  19 #include <linux/module.h>
  20 #include <linux/sched.h>
  21 #include <linux/slab.h>
  22 #include <linux/seq_file.h>
  23 #include <linux/string.h>
  24 #include <net/netlink.h>
  25
  26 #include "hash.h"
  27
  28 #define CRYPTO_ALG_TYPE_AHASH_MASK      0x0000000e
  29
  30 /*
  31  * For an ahash tfm that is using an shash algorithm (instead of an ahash
  32  * algorithm), this returns the underlying shash tfm.
  33  */
  34 static inline struct crypto_shash *ahash_to_shash(struct crypto_ahash *tfm)
  35 {
  36         return *(struct crypto_shash **)crypto_ahash_ctx(tfm);
  37 }
  38
  39 static inline struct shash_desc *prepare_shash_desc(struct ahash_request *req,
  40                                                     struct crypto_ahash *tfm)
  41 {
  42         struct shash_desc *desc = ahash_request_ctx(req);
  43
  44         desc->tfm = ahash_to_shash(tfm);
  45         return desc;
  46 }
  47
  48 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
  49 {
  50         struct crypto_hash_walk walk;
  51         int nbytes;
  52
  53         for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
  54              nbytes = crypto_hash_walk_done(&walk, nbytes))
  55                 nbytes = crypto_shash_update(desc, walk.data, nbytes);
  56
  57         return nbytes;
  58 }
  59 EXPORT_SYMBOL_GPL(shash_ahash_update);
  60
  61 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
  62 {
  63         struct crypto_hash_walk walk;
  64         int nbytes;
  65
  66         nbytes = crypto_hash_walk_first(req, &walk);
  67         if (!nbytes)
  68                 return crypto_shash_final(desc, req->result);
  69
  70         do {
  71                 nbytes = crypto_hash_walk_last(&walk) ?
  72                          crypto_shash_finup(desc, walk.data, nbytes,
  73                                             req->result) :
  74                          crypto_shash_update(desc, walk.data, nbytes);
  75                 nbytes = crypto_hash_walk_done(&walk, nbytes);
  76         } while (nbytes > 0);
  77
  78         return nbytes;
  79 }
  80 EXPORT_SYMBOL_GPL(shash_ahash_finup);
  81
  82 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
  83 {
  84         unsigned int nbytes = req->nbytes;
  85         struct scatterlist *sg;
  86         unsigned int offset;
  87         int err;
  88
  89         if (nbytes &&
  90             (sg = req->src, offset = sg->offset,
  91              nbytes <= min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
  92                 void *data;
  93
  94                 data = kmap_local_page(sg_page(sg));
  95                 err = crypto_shash_digest(desc, data + offset, nbytes,
  96                                           req->result);
  97                 kunmap_local(data);
  98         } else
  99                 err = crypto_shash_init(desc) ?:
 100                       shash_ahash_finup(req, desc);
 101
 102         return err;
 103 }
 104 EXPORT_SYMBOL_GPL(shash_ahash_digest);
 105
 106 static void crypto_exit_ahash_using_shash(struct crypto_tfm *tfm)
 107 {
 108         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
 109
 110         crypto_free_shash(*ctx);
 111 }
 112
 113 static int crypto_init_ahash_using_shash(struct crypto_tfm *tfm)
 114 {
 115         struct crypto_alg *calg = tfm->__crt_alg;
 116         struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
 117         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
 118         struct crypto_shash *shash;
 119
 120         if (!crypto_mod_get(calg))
 121                 return -EAGAIN;
 122
 123         shash = crypto_create_tfm(calg, &crypto_shash_type);
 124         if (IS_ERR(shash)) {
 125                 crypto_mod_put(calg);
 126                 return PTR_ERR(shash);
 127         }
 128
 129         crt->using_shash = true;
 130         *ctx = shash;
 131         tfm->exit = crypto_exit_ahash_using_shash;
 132
 133         crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
 134                                     CRYPTO_TFM_NEED_KEY);
 135         crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
 136
 137         return 0;
 138 }
 139
 140 static int hash_walk_next(struct crypto_hash_walk *walk)
 141 {
 142         unsigned int offset = walk->offset;
 143         unsigned int nbytes = min(walk->entrylen,
 144                                   ((unsigned int)(PAGE_SIZE)) - offset);
 145
 146         walk->data = kmap_local_page(walk->pg);
 147         walk->data += offset;
 148         walk->entrylen -= nbytes;
 149         return nbytes;
 150 }
 151
 152 static int hash_walk_new_entry(struct crypto_hash_walk *walk)
 153 {
 154         struct scatterlist *sg;
 155
 156         sg = walk->sg;
 157         walk->offset = sg->offset;
 158         walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
 159         walk->offset = offset_in_page(walk->offset);
 160         walk->entrylen = sg->length;
 161
 162         if (walk->entrylen > walk->total)
 163                 walk->entrylen = walk->total;
 164         walk->total -= walk->entrylen;
 165
 166         return hash_walk_next(walk);
 167 }
 168
 169 int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
 170 {
 171         walk->data -= walk->offset;
 172
 173         kunmap_local(walk->data);
 174         crypto_yield(walk->flags);
 175
 176         if (err)
 177                 return err;
 178
 179         if (walk->entrylen) {
 180                 walk->offset = 0;
 181                 walk->pg++;
 182                 return hash_walk_next(walk);
 183         }
 184
 185         if (!walk->total)
 186                 return 0;
 187
 188         walk->sg = sg_next(walk->sg);
 189
 190         return hash_walk_new_entry(walk);
 191 }
 192 EXPORT_SYMBOL_GPL(crypto_hash_walk_done);
 193
 194 int crypto_hash_walk_first(struct ahash_request *req,
 195                            struct crypto_hash_walk *walk)
 196 {
 197         walk->total = req->nbytes;
 198
 199         if (!walk->total) {
 200                 walk->entrylen = 0;
 201                 return 0;
 202         }
 203
 204         walk->sg = req->src;
 205         walk->flags = req->base.flags;
 206
 207         return hash_walk_new_entry(walk);
 208 }
 209 EXPORT_SYMBOL_GPL(crypto_hash_walk_first);
 210
 211 static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
 212                           unsigned int keylen)
 213 {
 214         return -ENOSYS;
 215 }
 216
 217 static void ahash_set_needkey(struct crypto_ahash *tfm, struct ahash_alg *alg)
 218 {
 219         if (alg->setkey != ahash_nosetkey &&
 220             !(alg->halg.base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
 221                 crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
 222 }
 223
 224 int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
 225                         unsigned int keylen)
 226 {
 227         if (likely(tfm->using_shash)) {
 228                 struct crypto_shash *shash = ahash_to_shash(tfm);
 229                 int err;
 230
 231                 err = crypto_shash_setkey(shash, key, keylen);
 232                 if (unlikely(err)) {
 233                         crypto_ahash_set_flags(tfm,
 234                                                crypto_shash_get_flags(shash) &
 235                                                CRYPTO_TFM_NEED_KEY);
 236                         return err;
 237                 }
 238         } else {
 239                 struct ahash_alg *alg = crypto_ahash_alg(tfm);
 240                 int err;
 241
 242                 err = alg->setkey(tfm, key, keylen);
 243                 if (unlikely(err)) {
 244                         ahash_set_needkey(tfm, alg);
 245                         return err;
 246                 }
 247         }
 248         crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
 249         return 0;
 250 }
 251 EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
 252
 253 int crypto_ahash_init(struct ahash_request *req)
 254 {
 255         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 256
 257         if (likely(tfm->using_shash))
 258                 return crypto_shash_init(prepare_shash_desc(req, tfm));
 259         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 260                 return -ENOKEY;
 261         return crypto_ahash_alg(tfm)->init(req);
 262 }
 263 EXPORT_SYMBOL_GPL(crypto_ahash_init);
 264
 265 static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt,
 266                           bool has_state)
 267 {
 268         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 269         unsigned int ds = crypto_ahash_digestsize(tfm);
 270         struct ahash_request *subreq;
 271         unsigned int subreq_size;
 272         unsigned int reqsize;
 273         u8 *result;
 274         gfp_t gfp;
 275         u32 flags;
 276
 277         subreq_size = sizeof(*subreq);
 278         reqsize = crypto_ahash_reqsize(tfm);
 279         reqsize = ALIGN(reqsize, crypto_tfm_ctx_alignment());
 280         subreq_size += reqsize;
 281         subreq_size += ds;
 282
 283         flags = ahash_request_flags(req);
 284         gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ?  GFP_KERNEL : GFP_ATOMIC;
 285         subreq = kmalloc(subreq_size, gfp);
 286         if (!subreq)
 287                 return -ENOMEM;
 288
 289         ahash_request_set_tfm(subreq, tfm);
 290         ahash_request_set_callback(subreq, flags, cplt, req);
 291
 292         result = (u8 *)(subreq + 1) + reqsize;
 293
 294         ahash_request_set_crypt(subreq, req->src, result, req->nbytes);
 295
 296         if (has_state) {
 297                 void *state;
 298
 299                 state = kmalloc(crypto_ahash_statesize(tfm), gfp);
 300                 if (!state) {
 301                         kfree(subreq);
 302                         return -ENOMEM;
 303                 }
 304
 305                 crypto_ahash_export(req, state);
 306                 crypto_ahash_import(subreq, state);
 307                 kfree_sensitive(state);
 308         }
 309
 310         req->priv = subreq;
 311
 312         return 0;
 313 }
 314
 315 static void ahash_restore_req(struct ahash_request *req, int err)
 316 {
 317         struct ahash_request *subreq = req->priv;
 318
 319         if (!err)
 320                 memcpy(req->result, subreq->result,
 321                        crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
 322
 323         req->priv = NULL;
 324
 325         kfree_sensitive(subreq);
 326 }
 327
 328 int crypto_ahash_update(struct ahash_request *req)
 329 {
 330         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 331
 332         if (likely(tfm->using_shash))
 333                 return shash_ahash_update(req, ahash_request_ctx(req));
 334
 335         return crypto_ahash_alg(tfm)->update(req);
 336 }
 337 EXPORT_SYMBOL_GPL(crypto_ahash_update);
 338
 339 int crypto_ahash_final(struct ahash_request *req)
 340 {
 341         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 342
 343         if (likely(tfm->using_shash))
 344                 return crypto_shash_final(ahash_request_ctx(req), req->result);
 345
 346         return crypto_ahash_alg(tfm)->final(req);
 347 }
 348 EXPORT_SYMBOL_GPL(crypto_ahash_final);
 349
 350 int crypto_ahash_finup(struct ahash_request *req)
 351 {
 352         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 353
 354         if (likely(tfm->using_shash))
 355                 return shash_ahash_finup(req, ahash_request_ctx(req));
 356
 357         return crypto_ahash_alg(tfm)->finup(req);
 358 }
 359 EXPORT_SYMBOL_GPL(crypto_ahash_finup);
 360
 361 int crypto_ahash_digest(struct ahash_request *req)
 362 {
 363         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 364
 365         if (likely(tfm->using_shash))
 366                 return shash_ahash_digest(req, prepare_shash_desc(req, tfm));
 367
 368         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 369                 return -ENOKEY;
 370
 371         return crypto_ahash_alg(tfm)->digest(req);
 372 }
 373 EXPORT_SYMBOL_GPL(crypto_ahash_digest);
 374
 375 static void ahash_def_finup_done2(void *data, int err)
 376 {
 377         struct ahash_request *areq = data;
 378
 379         if (err == -EINPROGRESS)
 380                 return;
 381
 382         ahash_restore_req(areq, err);
 383
 384         ahash_request_complete(areq, err);
 385 }
 386
 387 static int ahash_def_finup_finish1(struct ahash_request *req, int err)
 388 {
 389         struct ahash_request *subreq = req->priv;
 390
 391         if (err)
 392                 goto out;
 393
 394         subreq->base.complete = ahash_def_finup_done2;
 395
 396         err = crypto_ahash_alg(crypto_ahash_reqtfm(req))->final(subreq);
 397         if (err == -EINPROGRESS || err == -EBUSY)
 398                 return err;
 399
 400 out:
 401         ahash_restore_req(req, err);
 402         return err;
 403 }
 404
 405 static void ahash_def_finup_done1(void *data, int err)
 406 {
 407         struct ahash_request *areq = data;
 408         struct ahash_request *subreq;
 409
 410         if (err == -EINPROGRESS)
 411                 goto out;
 412
 413         subreq = areq->priv;
 414         subreq->base.flags &= CRYPTO_TFM_REQ_MAY_BACKLOG;
 415
 416         err = ahash_def_finup_finish1(areq, err);
 417         if (err == -EINPROGRESS || err == -EBUSY)
 418                 return;
 419
 420 out:
 421         ahash_request_complete(areq, err);
 422 }
 423
 424 static int ahash_def_finup(struct ahash_request *req)
 425 {
 426         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 427         int err;
 428
 429         err = ahash_save_req(req, ahash_def_finup_done1, true);
 430         if (err)
 431                 return err;
 432
 433         err = crypto_ahash_alg(tfm)->update(req->priv);
 434         if (err == -EINPROGRESS || err == -EBUSY)
 435                 return err;
 436
 437         return ahash_def_finup_finish1(req, err);
 438 }
 439
 440 int crypto_ahash_export(struct ahash_request *req, void *out)
 441 {
 442         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 443
 444         if (likely(tfm->using_shash))
 445                 return crypto_shash_export(ahash_request_ctx(req), out);
 446         return crypto_ahash_alg(tfm)->export(req, out);
 447 }
 448 EXPORT_SYMBOL_GPL(crypto_ahash_export);
 449
 450 int crypto_ahash_import(struct ahash_request *req, const void *in)
 451 {
 452         struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
 453
 454         if (likely(tfm->using_shash))
 455                 return crypto_shash_import(prepare_shash_desc(req, tfm), in);
 456         if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 457                 return -ENOKEY;
 458         return crypto_ahash_alg(tfm)->import(req, in);
 459 }
 460 EXPORT_SYMBOL_GPL(crypto_ahash_import);
 461
 462 static void crypto_ahash_exit_tfm(struct crypto_tfm *tfm)
 463 {
 464         struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
 465         struct ahash_alg *alg = crypto_ahash_alg(hash);
 466
 467         alg->exit_tfm(hash);
 468 }
 469
 470 static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
 471 {
 472         struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
 473         struct ahash_alg *alg = crypto_ahash_alg(hash);
 474
 475         crypto_ahash_set_statesize(hash, alg->halg.statesize);
 476
 477         if (tfm->__crt_alg->cra_type == &crypto_shash_type)
 478                 return crypto_init_ahash_using_shash(tfm);
 479
 480         ahash_set_needkey(hash, alg);
 481
 482         if (alg->exit_tfm)
 483                 tfm->exit = crypto_ahash_exit_tfm;
 484
 485         return alg->init_tfm ? alg->init_tfm(hash) : 0;
 486 }
 487
 488 static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
 489 {
 490         if (alg->cra_type == &crypto_shash_type)
 491                 return sizeof(struct crypto_shash *);
 492
 493         return crypto_alg_extsize(alg);
 494 }
 495
 496 static void crypto_ahash_free_instance(struct crypto_instance *inst)
 497 {
 498         struct ahash_instance *ahash = ahash_instance(inst);
 499
 500         ahash->free(ahash);
 501 }
 502
 503 static int __maybe_unused crypto_ahash_report(
 504         struct sk_buff *skb, struct crypto_alg *alg)
 505 {
 506         struct crypto_report_hash rhash;
 507
 508         memset(&rhash, 0, sizeof(rhash));
 509
 510         strscpy(rhash.type, "ahash", sizeof(rhash.type));
 511
 512         rhash.blocksize = alg->cra_blocksize;
 513         rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
 514
 515         return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
 516 }
 517
 518 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
 519         __maybe_unused;
 520 static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
 521 {
 522         seq_printf(m, "type         : ahash\n");
 523         seq_printf(m, "async        : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
 524                                              "yes" : "no");
 525         seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
 526         seq_printf(m, "digestsize   : %u\n",
 527                    __crypto_hash_alg_common(alg)->digestsize);
 528 }
 529
 530 static const struct crypto_type crypto_ahash_type = {
 531         .extsize = crypto_ahash_extsize,
 532         .init_tfm = crypto_ahash_init_tfm,
 533         .free = crypto_ahash_free_instance,
 534 #ifdef CONFIG_PROC_FS
 535         .show = crypto_ahash_show,
 536 #endif
 537 #if IS_ENABLED(CONFIG_CRYPTO_USER)
 538         .report = crypto_ahash_report,
 539 #endif
 540         .maskclear = ~CRYPTO_ALG_TYPE_MASK,
 541         .maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
 542         .type = CRYPTO_ALG_TYPE_AHASH,
 543         .tfmsize = offsetof(struct crypto_ahash, base),
 544 };
 545
 546 int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
 547                       struct crypto_instance *inst,
 548                       const char *name, u32 type, u32 mask)
 549 {
 550         spawn->base.frontend = &crypto_ahash_type;
 551         return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
 552 }
 553 EXPORT_SYMBOL_GPL(crypto_grab_ahash);
 554
 555 struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
 556                                         u32 mask)
 557 {
 558         return crypto_alloc_tfm(alg_name, &crypto_ahash_type, type, mask);
 559 }
 560 EXPORT_SYMBOL_GPL(crypto_alloc_ahash);
 561
 562 int crypto_has_ahash(const char *alg_name, u32 type, u32 mask)
 563 {
 564         return crypto_type_has_alg(alg_name, &crypto_ahash_type, type, mask);
 565 }
 566 EXPORT_SYMBOL_GPL(crypto_has_ahash);
 567
 568 static bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
 569 {
 570         struct crypto_alg *alg = &halg->base;
 571
 572         if (alg->cra_type == &crypto_shash_type)
 573                 return crypto_shash_alg_has_setkey(__crypto_shash_alg(alg));
 574
 575         return __crypto_ahash_alg(alg)->setkey != ahash_nosetkey;
 576 }
 577
 578 struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
 579 {
 580         struct hash_alg_common *halg = crypto_hash_alg_common(hash);
 581         struct crypto_tfm *tfm = crypto_ahash_tfm(hash);
 582         struct crypto_ahash *nhash;
 583         struct ahash_alg *alg;
 584         int err;
 585
 586         if (!crypto_hash_alg_has_setkey(halg)) {
 587                 tfm = crypto_tfm_get(tfm);
 588                 if (IS_ERR(tfm))
 589                         return ERR_CAST(tfm);
 590
 591                 return hash;
 592         }
 593
 594         nhash = crypto_clone_tfm(&crypto_ahash_type, tfm);
 595
 596         if (IS_ERR(nhash))
 597                 return nhash;
 598
 599         nhash->reqsize = hash->reqsize;
 600         nhash->statesize = hash->statesize;
 601
 602         if (likely(hash->using_shash)) {
 603                 struct crypto_shash **nctx = crypto_ahash_ctx(nhash);
 604                 struct crypto_shash *shash;
 605
 606                 shash = crypto_clone_shash(ahash_to_shash(hash));
 607                 if (IS_ERR(shash)) {
 608                         err = PTR_ERR(shash);
 609                         goto out_free_nhash;
 610                 }
 611                 nhash->using_shash = true;
 612                 *nctx = shash;
 613                 return nhash;
 614         }
 615
 616         err = -ENOSYS;
 617         alg = crypto_ahash_alg(hash);
 618         if (!alg->clone_tfm)
 619                 goto out_free_nhash;
 620
 621         err = alg->clone_tfm(nhash, hash);
 622         if (err)
 623                 goto out_free_nhash;
 624
 625         return nhash;
 626
 627 out_free_nhash:
 628         crypto_free_ahash(nhash);
 629         return ERR_PTR(err);
 630 }
 631 EXPORT_SYMBOL_GPL(crypto_clone_ahash);
 632
 633 static int ahash_prepare_alg(struct ahash_alg *alg)
 634 {
 635         struct crypto_alg *base = &alg->halg.base;
 636         int err;
 637
 638         if (alg->halg.statesize == 0)
 639                 return -EINVAL;
 640
 641         err = hash_prepare_alg(&alg->halg);
 642         if (err)
 643                 return err;
 644
 645         base->cra_type = &crypto_ahash_type;
 646         base->cra_flags |= CRYPTO_ALG_TYPE_AHASH;
 647
 648         if (!alg->finup)
 649                 alg->finup = ahash_def_finup;
 650         if (!alg->setkey)
 651                 alg->setkey = ahash_nosetkey;
 652
 653         return 0;
 654 }
 655
 656 int crypto_register_ahash(struct ahash_alg *alg)
 657 {
 658         struct crypto_alg *base = &alg->halg.base;
 659         int err;
 660
 661         err = ahash_prepare_alg(alg);
 662         if (err)
 663                 return err;
 664
 665         return crypto_register_alg(base);
 666 }
 667 EXPORT_SYMBOL_GPL(crypto_register_ahash);
 668
 669 void crypto_unregister_ahash(struct ahash_alg *alg)
 670 {
 671         crypto_unregister_alg(&alg->halg.base);
 672 }
 673 EXPORT_SYMBOL_GPL(crypto_unregister_ahash);
 674
 675 int crypto_register_ahashes(struct ahash_alg *algs, int count)
 676 {
 677         int i, ret;
 678
 679         for (i = 0; i < count; i++) {
 680                 ret = crypto_register_ahash(&algs[i]);
 681                 if (ret)
 682                         goto err;
 683         }
 684
 685         return 0;
 686
 687 err:
 688         for (--i; i >= 0; --i)
 689                 crypto_unregister_ahash(&algs[i]);
 690
 691         return ret;
 692 }
 693 EXPORT_SYMBOL_GPL(crypto_register_ahashes);
 694
 695 void crypto_unregister_ahashes(struct ahash_alg *algs, int count)
 696 {
 697         int i;
 698
 699         for (i = count - 1; i >= 0; --i)
 700                 crypto_unregister_ahash(&algs[i]);
 701 }
 702 EXPORT_SYMBOL_GPL(crypto_unregister_ahashes);
 703
 704 int ahash_register_instance(struct crypto_template *tmpl,
 705                             struct ahash_instance *inst)
 706 {
 707         int err;
 708
 709         if (WARN_ON(!inst->free))
 710                 return -EINVAL;
 711
 712         err = ahash_prepare_alg(&inst->alg);
 713         if (err)
 714                 return err;
 715
 716         return crypto_register_instance(tmpl, ahash_crypto_instance(inst));
 717 }
 718 EXPORT_SYMBOL_GPL(ahash_register_instance);
 719
 720 MODULE_LICENSE("GPL");
 721 MODULE_DESCRIPTION("Asynchronous cryptographic hash type");