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