crypto/shash.c

   1 /*
   2  * Synchronous Cryptographic Hash operations.
   3  *
   4  * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  */
  12
  13 #include <crypto/scatterwalk.h>
  14 #include <crypto/internal/hash.h>
  15 #include <linux/err.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/slab.h>
  19 #include <linux/seq_file.h>
  20 #include <linux/cryptouser.h>
  21 #include <net/netlink.h>
  22 #include <linux/compiler.h>
  23
  24 #include "internal.h"
  25
  26 static const struct crypto_type crypto_shash_type;
  27
  28 int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
  29                     unsigned int keylen)
  30 {
  31         return -ENOSYS;
  32 }
  33 EXPORT_SYMBOL_GPL(shash_no_setkey);
  34
  35 static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
  36                                   unsigned int keylen)
  37 {
  38         struct shash_alg *shash = crypto_shash_alg(tfm);
  39         unsigned long alignmask = crypto_shash_alignmask(tfm);
  40         unsigned long absize;
  41         u8 *buffer, *alignbuffer;
  42         int err;
  43
  44         absize = keylen + (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
  45         buffer = kmalloc(absize, GFP_ATOMIC);
  46         if (!buffer)
  47                 return -ENOMEM;
  48
  49         alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
  50         memcpy(alignbuffer, key, keylen);
  51         err = shash->setkey(tfm, alignbuffer, keylen);
  52         kzfree(buffer);
  53         return err;
  54 }
  55
  56 static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
  57 {
  58         if (crypto_shash_alg_has_setkey(alg) &&
  59             !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
  60                 crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
  61 }
  62
  63 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
  64                         unsigned int keylen)
  65 {
  66         struct shash_alg *shash = crypto_shash_alg(tfm);
  67         unsigned long alignmask = crypto_shash_alignmask(tfm);
  68         int err;
  69
  70         if ((unsigned long)key & alignmask)
  71                 err = shash_setkey_unaligned(tfm, key, keylen);
  72         else
  73                 err = shash->setkey(tfm, key, keylen);
  74
  75         if (unlikely(err)) {
  76                 shash_set_needkey(tfm, shash);
  77                 return err;
  78         }
  79
  80         crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
  81         return 0;
  82 }
  83 EXPORT_SYMBOL_GPL(crypto_shash_setkey);
  84
  85 static inline unsigned int shash_align_buffer_size(unsigned len,
  86                                                    unsigned long mask)
  87 {
  88         typedef u8 __aligned_largest u8_aligned;
  89         return len + (mask & ~(__alignof__(u8_aligned) - 1));
  90 }
  91
  92 static int shash_update_unaligned(struct shash_desc *desc, const u8 *data,
  93                                   unsigned int len)
  94 {
  95         struct crypto_shash *tfm = desc->tfm;
  96         struct shash_alg *shash = crypto_shash_alg(tfm);
  97         unsigned long alignmask = crypto_shash_alignmask(tfm);
  98         unsigned int unaligned_len = alignmask + 1 -
  99                                      ((unsigned long)data & alignmask);
 100         u8 ubuf[shash_align_buffer_size(unaligned_len, alignmask)]
 101                 __aligned_largest;
 102         u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
 103         int err;
 104
 105         if (unaligned_len > len)
 106                 unaligned_len = len;
 107
 108         memcpy(buf, data, unaligned_len);
 109         err = shash->update(desc, buf, unaligned_len);
 110         memset(buf, 0, unaligned_len);
 111
 112         return err ?:
 113                shash->update(desc, data + unaligned_len, len - unaligned_len);
 114 }
 115
 116 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
 117                         unsigned int len)
 118 {
 119         struct crypto_shash *tfm = desc->tfm;
 120         struct shash_alg *shash = crypto_shash_alg(tfm);
 121         unsigned long alignmask = crypto_shash_alignmask(tfm);
 122
 123         if ((unsigned long)data & alignmask)
 124                 return shash_update_unaligned(desc, data, len);
 125
 126         return shash->update(desc, data, len);
 127 }
 128 EXPORT_SYMBOL_GPL(crypto_shash_update);
 129
 130 static int shash_final_unaligned(struct shash_desc *desc, u8 *out)
 131 {
 132         struct crypto_shash *tfm = desc->tfm;
 133         unsigned long alignmask = crypto_shash_alignmask(tfm);
 134         struct shash_alg *shash = crypto_shash_alg(tfm);
 135         unsigned int ds = crypto_shash_digestsize(tfm);
 136         u8 ubuf[shash_align_buffer_size(ds, alignmask)]
 137                 __aligned_largest;
 138         u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
 139         int err;
 140
 141         err = shash->final(desc, buf);
 142         if (err)
 143                 goto out;
 144
 145         memcpy(out, buf, ds);
 146
 147 out:
 148         memset(buf, 0, ds);
 149         return err;
 150 }
 151
 152 int crypto_shash_final(struct shash_desc *desc, u8 *out)
 153 {
 154         struct crypto_shash *tfm = desc->tfm;
 155         struct shash_alg *shash = crypto_shash_alg(tfm);
 156         unsigned long alignmask = crypto_shash_alignmask(tfm);
 157
 158         if ((unsigned long)out & alignmask)
 159                 return shash_final_unaligned(desc, out);
 160
 161         return shash->final(desc, out);
 162 }
 163 EXPORT_SYMBOL_GPL(crypto_shash_final);
 164
 165 static int shash_finup_unaligned(struct shash_desc *desc, const u8 *data,
 166                                  unsigned int len, u8 *out)
 167 {
 168         return crypto_shash_update(desc, data, len) ?:
 169                crypto_shash_final(desc, out);
 170 }
 171
 172 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
 173                        unsigned int len, u8 *out)
 174 {
 175         struct crypto_shash *tfm = desc->tfm;
 176         struct shash_alg *shash = crypto_shash_alg(tfm);
 177         unsigned long alignmask = crypto_shash_alignmask(tfm);
 178
 179         if (((unsigned long)data | (unsigned long)out) & alignmask)
 180                 return shash_finup_unaligned(desc, data, len, out);
 181
 182         return shash->finup(desc, data, len, out);
 183 }
 184 EXPORT_SYMBOL_GPL(crypto_shash_finup);
 185
 186 static int shash_digest_unaligned(struct shash_desc *desc, const u8 *data,
 187                                   unsigned int len, u8 *out)
 188 {
 189         return crypto_shash_init(desc) ?:
 190                crypto_shash_finup(desc, data, len, out);
 191 }
 192
 193 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
 194                         unsigned int len, u8 *out)
 195 {
 196         struct crypto_shash *tfm = desc->tfm;
 197         struct shash_alg *shash = crypto_shash_alg(tfm);
 198         unsigned long alignmask = crypto_shash_alignmask(tfm);
 199
 200         if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
 201                 return -ENOKEY;
 202
 203         if (((unsigned long)data | (unsigned long)out) & alignmask)
 204                 return shash_digest_unaligned(desc, data, len, out);
 205
 206         return shash->digest(desc, data, len, out);
 207 }
 208 EXPORT_SYMBOL_GPL(crypto_shash_digest);
 209
 210 static int shash_default_export(struct shash_desc *desc, void *out)
 211 {
 212         memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
 213         return 0;
 214 }
 215
 216 static int shash_default_import(struct shash_desc *desc, const void *in)
 217 {
 218         memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(desc->tfm));
 219         return 0;
 220 }
 221
 222 static int shash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
 223                               unsigned int keylen)
 224 {
 225         struct crypto_shash **ctx = crypto_ahash_ctx(tfm);
 226
 227         return crypto_shash_setkey(*ctx, key, keylen);
 228 }
 229
 230 static int shash_async_init(struct ahash_request *req)
 231 {
 232         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
 233         struct shash_desc *desc = ahash_request_ctx(req);
 234
 235         desc->tfm = *ctx;
 236         desc->flags = req->base.flags;
 237
 238         return crypto_shash_init(desc);
 239 }
 240
 241 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
 242 {
 243         struct crypto_hash_walk walk;
 244         int nbytes;
 245
 246         for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
 247              nbytes = crypto_hash_walk_done(&walk, nbytes))
 248                 nbytes = crypto_shash_update(desc, walk.data, nbytes);
 249
 250         return nbytes;
 251 }
 252 EXPORT_SYMBOL_GPL(shash_ahash_update);
 253
 254 static int shash_async_update(struct ahash_request *req)
 255 {
 256         return shash_ahash_update(req, ahash_request_ctx(req));
 257 }
 258
 259 static int shash_async_final(struct ahash_request *req)
 260 {
 261         return crypto_shash_final(ahash_request_ctx(req), req->result);
 262 }
 263
 264 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
 265 {
 266         struct crypto_hash_walk walk;
 267         int nbytes;
 268
 269         nbytes = crypto_hash_walk_first(req, &walk);
 270         if (!nbytes)
 271                 return crypto_shash_final(desc, req->result);
 272
 273         do {
 274                 nbytes = crypto_hash_walk_last(&walk) ?
 275                          crypto_shash_finup(desc, walk.data, nbytes,
 276                                             req->result) :
 277                          crypto_shash_update(desc, walk.data, nbytes);
 278                 nbytes = crypto_hash_walk_done(&walk, nbytes);
 279         } while (nbytes > 0);
 280
 281         return nbytes;
 282 }
 283 EXPORT_SYMBOL_GPL(shash_ahash_finup);
 284
 285 static int shash_async_finup(struct ahash_request *req)
 286 {
 287         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
 288         struct shash_desc *desc = ahash_request_ctx(req);
 289
 290         desc->tfm = *ctx;
 291         desc->flags = req->base.flags;
 292
 293         return shash_ahash_finup(req, desc);
 294 }
 295
 296 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
 297 {
 298         unsigned int nbytes = req->nbytes;
 299         struct scatterlist *sg;
 300         unsigned int offset;
 301         int err;
 302
 303         if (nbytes &&
 304             (sg = req->src, offset = sg->offset,
 305              nbytes < min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
 306                 void *data;
 307
 308                 data = kmap_atomic(sg_page(sg));
 309                 err = crypto_shash_digest(desc, data + offset, nbytes,
 310                                           req->result);
 311                 kunmap_atomic(data);
 312                 crypto_yield(desc->flags);
 313         } else
 314                 err = crypto_shash_init(desc) ?:
 315                       shash_ahash_finup(req, desc);
 316
 317         return err;
 318 }
 319 EXPORT_SYMBOL_GPL(shash_ahash_digest);
 320
 321 static int shash_async_digest(struct ahash_request *req)
 322 {
 323         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
 324         struct shash_desc *desc = ahash_request_ctx(req);
 325
 326         desc->tfm = *ctx;
 327         desc->flags = req->base.flags;
 328
 329         return shash_ahash_digest(req, desc);
 330 }
 331
 332 static int shash_async_export(struct ahash_request *req, void *out)
 333 {
 334         return crypto_shash_export(ahash_request_ctx(req), out);
 335 }
 336
 337 static int shash_async_import(struct ahash_request *req, const void *in)
 338 {
 339         struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
 340         struct shash_desc *desc = ahash_request_ctx(req);
 341
 342         desc->tfm = *ctx;
 343         desc->flags = req->base.flags;
 344
 345         return crypto_shash_import(desc, in);
 346 }
 347
 348 static void crypto_exit_shash_ops_async(struct crypto_tfm *tfm)
 349 {
 350         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
 351
 352         crypto_free_shash(*ctx);
 353 }
 354
 355 int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
 356 {
 357         struct crypto_alg *calg = tfm->__crt_alg;
 358         struct shash_alg *alg = __crypto_shash_alg(calg);
 359         struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
 360         struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
 361         struct crypto_shash *shash;
 362
 363         if (!crypto_mod_get(calg))
 364                 return -EAGAIN;
 365
 366         shash = crypto_create_tfm(calg, &crypto_shash_type);
 367         if (IS_ERR(shash)) {
 368                 crypto_mod_put(calg);
 369                 return PTR_ERR(shash);
 370         }
 371
 372         *ctx = shash;
 373         tfm->exit = crypto_exit_shash_ops_async;
 374
 375         crt->init = shash_async_init;
 376         crt->update = shash_async_update;
 377         crt->final = shash_async_final;
 378         crt->finup = shash_async_finup;
 379         crt->digest = shash_async_digest;
 380         if (crypto_shash_alg_has_setkey(alg))
 381                 crt->setkey = shash_async_setkey;
 382
 383         crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
 384                                     CRYPTO_TFM_NEED_KEY);
 385
 386         if (alg->export)
 387                 crt->export = shash_async_export;
 388         if (alg->import)
 389                 crt->import = shash_async_import;
 390
 391         crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
 392
 393         return 0;
 394 }
 395
 396 static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
 397 {
 398         struct crypto_shash *hash = __crypto_shash_cast(tfm);
 399         struct shash_alg *alg = crypto_shash_alg(hash);
 400
 401         hash->descsize = alg->descsize;
 402
 403         shash_set_needkey(hash, alg);
 404
 405         return 0;
 406 }
 407
 408 #ifdef CONFIG_NET
 409 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
 410 {
 411         struct crypto_report_hash rhash;
 412         struct shash_alg *salg = __crypto_shash_alg(alg);
 413
 414         strncpy(rhash.type, "shash", sizeof(rhash.type));
 415
 416         rhash.blocksize = alg->cra_blocksize;
 417         rhash.digestsize = salg->digestsize;
 418
 419         if (nla_put(skb, CRYPTOCFGA_REPORT_HASH,
 420                     sizeof(struct crypto_report_hash), &rhash))
 421                 goto nla_put_failure;
 422         return 0;
 423
 424 nla_put_failure:
 425         return -EMSGSIZE;
 426 }
 427 #else
 428 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
 429 {
 430         return -ENOSYS;
 431 }
 432 #endif
 433
 434 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
 435         __maybe_unused;
 436 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
 437 {
 438         struct shash_alg *salg = __crypto_shash_alg(alg);
 439
 440         seq_printf(m, "type         : shash\n");
 441         seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
 442         seq_printf(m, "digestsize   : %u\n", salg->digestsize);
 443 }
 444
 445 static const struct crypto_type crypto_shash_type = {
 446         .extsize = crypto_alg_extsize,
 447         .init_tfm = crypto_shash_init_tfm,
 448 #ifdef CONFIG_PROC_FS
 449         .show = crypto_shash_show,
 450 #endif
 451         .report = crypto_shash_report,
 452         .maskclear = ~CRYPTO_ALG_TYPE_MASK,
 453         .maskset = CRYPTO_ALG_TYPE_MASK,
 454         .type = CRYPTO_ALG_TYPE_SHASH,
 455         .tfmsize = offsetof(struct crypto_shash, base),
 456 };
 457
 458 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
 459                                         u32 mask)
 460 {
 461         return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
 462 }
 463 EXPORT_SYMBOL_GPL(crypto_alloc_shash);
 464
 465 static int shash_prepare_alg(struct shash_alg *alg)
 466 {
 467         struct crypto_alg *base = &alg->base;
 468
 469         if (alg->digestsize > PAGE_SIZE / 8 ||
 470             alg->descsize > PAGE_SIZE / 8 ||
 471             alg->statesize > PAGE_SIZE / 8)
 472                 return -EINVAL;
 473
 474         base->cra_type = &crypto_shash_type;
 475         base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
 476         base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
 477
 478         if (!alg->finup)
 479                 alg->finup = shash_finup_unaligned;
 480         if (!alg->digest)
 481                 alg->digest = shash_digest_unaligned;
 482         if (!alg->export) {
 483                 alg->export = shash_default_export;
 484                 alg->import = shash_default_import;
 485                 alg->statesize = alg->descsize;
 486         }
 487         if (!alg->setkey)
 488                 alg->setkey = shash_no_setkey;
 489
 490         return 0;
 491 }
 492
 493 int crypto_register_shash(struct shash_alg *alg)
 494 {
 495         struct crypto_alg *base = &alg->base;
 496         int err;
 497
 498         err = shash_prepare_alg(alg);
 499         if (err)
 500                 return err;
 501
 502         return crypto_register_alg(base);
 503 }
 504 EXPORT_SYMBOL_GPL(crypto_register_shash);
 505
 506 int crypto_unregister_shash(struct shash_alg *alg)
 507 {
 508         return crypto_unregister_alg(&alg->base);
 509 }
 510 EXPORT_SYMBOL_GPL(crypto_unregister_shash);
 511
 512 int crypto_register_shashes(struct shash_alg *algs, int count)
 513 {
 514         int i, ret;
 515
 516         for (i = 0; i < count; i++) {
 517                 ret = crypto_register_shash(&algs[i]);
 518                 if (ret)
 519                         goto err;
 520         }
 521
 522         return 0;
 523
 524 err:
 525         for (--i; i >= 0; --i)
 526                 crypto_unregister_shash(&algs[i]);
 527
 528         return ret;
 529 }
 530 EXPORT_SYMBOL_GPL(crypto_register_shashes);
 531
 532 int crypto_unregister_shashes(struct shash_alg *algs, int count)
 533 {
 534         int i, ret;
 535
 536         for (i = count - 1; i >= 0; --i) {
 537                 ret = crypto_unregister_shash(&algs[i]);
 538                 if (ret)
 539                         pr_err("Failed to unregister %s %s: %d\n",
 540                                algs[i].base.cra_driver_name,
 541                                algs[i].base.cra_name, ret);
 542         }
 543
 544         return 0;
 545 }
 546 EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
 547
 548 int shash_register_instance(struct crypto_template *tmpl,
 549                             struct shash_instance *inst)
 550 {
 551         int err;
 552
 553         err = shash_prepare_alg(&inst->alg);
 554         if (err)
 555                 return err;
 556
 557         return crypto_register_instance(tmpl, shash_crypto_instance(inst));
 558 }
 559 EXPORT_SYMBOL_GPL(shash_register_instance);
 560
 561 void shash_free_instance(struct crypto_instance *inst)
 562 {
 563         crypto_drop_spawn(crypto_instance_ctx(inst));
 564         kfree(shash_instance(inst));
 565 }
 566 EXPORT_SYMBOL_GPL(shash_free_instance);
 567
 568 int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
 569                             struct shash_alg *alg,
 570                             struct crypto_instance *inst)
 571 {
 572         return crypto_init_spawn2(&spawn->base, &alg->base, inst,
 573                                   &crypto_shash_type);
 574 }
 575 EXPORT_SYMBOL_GPL(crypto_init_shash_spawn);
 576
 577 struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask)
 578 {
 579         struct crypto_alg *alg;
 580
 581         alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask);
 582         return IS_ERR(alg) ? ERR_CAST(alg) :
 583                container_of(alg, struct shash_alg, base);
 584 }
 585 EXPORT_SYMBOL_GPL(shash_attr_alg);
 586
 587 MODULE_LICENSE("GPL");
 588 MODULE_DESCRIPTION("Synchronous cryptographic hash type");