crypto: ahash - Handle partial blocks in API

+265 -288

2 changed files

expand all

crypto

ahash.c

include

crypto

hash.h

+255 -286

crypto/ahash.c

··· 12 12 * Copyright (c) 2008 Loc Ho <lho@amcc.com> 13 13 */ 14 14 15 + #include <crypto/scatterwalk.h> 15 16 #include <linux/cryptouser.h> 16 17 #include <linux/err.h> 17 18 #include <linux/kernel.h> 18 19 #include <linux/mm.h> 19 20 #include <linux/module.h> 21 + #include <linux/scatterlist.h> 20 22 #include <linux/slab.h> 21 23 #include <linux/seq_file.h> 22 24 #include <linux/string.h> ··· 42 40 struct scatterlist *sg; 43 41 }; 44 42 45 - struct ahash_save_req_state { 46 - struct ahash_request *req0; 47 - crypto_completion_t compl; 48 - void *data; 49 - struct scatterlist sg; 50 - const u8 *src; 51 - u8 *page; 52 - unsigned int offset; 53 - unsigned int nbytes; 54 - bool update; 55 - }; 56 - 57 - static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt); 58 - static void ahash_restore_req(struct ahash_request *req); 59 - static void ahash_def_finup_done1(void *data, int err); 60 - static int ahash_def_finup_finish1(struct ahash_request *req, int err); 61 43 static int ahash_def_finup(struct ahash_request *req); 44 + 45 + static inline bool crypto_ahash_block_only(struct crypto_ahash *tfm) 46 + { 47 + return crypto_ahash_alg(tfm)->halg.base.cra_flags & 48 + CRYPTO_AHASH_ALG_BLOCK_ONLY; 49 + } 50 + 51 + static inline bool crypto_ahash_final_nonzero(struct crypto_ahash *tfm) 52 + { 53 + return crypto_ahash_alg(tfm)->halg.base.cra_flags & 54 + CRYPTO_AHASH_ALG_FINAL_NONZERO; 55 + } 56 + 57 + static inline bool crypto_ahash_need_fallback(struct crypto_ahash *tfm) 58 + { 59 + return crypto_ahash_alg(tfm)->halg.base.cra_flags & 60 + CRYPTO_ALG_NEED_FALLBACK; 61 + } 62 + 63 + static inline void ahash_op_done(void *data, int err, 64 + int (*finish)(struct ahash_request *, int)) 65 + { 66 + struct ahash_request *areq = data; 67 + crypto_completion_t compl; 68 + 69 + compl = areq->saved_complete; 70 + data = areq->saved_data; 71 + if (err == -EINPROGRESS) 72 + goto out; 73 + 74 + areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 75 + 76 + err = finish(areq, err); 77 + if (err == -EINPROGRESS || err == -EBUSY) 78 + return; 79 + 80 + out: 81 + compl(data, err); 82 + } 62 83 63 84 static int hash_walk_next(struct crypto_hash_walk *walk) 64 85 { ··· 323 298 int err; 324 299 325 300 err = alg->setkey(tfm, key, keylen); 326 - if (!err && ahash_is_async(tfm)) 301 + if (!err && crypto_ahash_need_fallback(tfm)) 327 302 err = crypto_ahash_setkey(crypto_ahash_fb(tfm), 328 303 key, keylen); 329 304 if (unlikely(err)) { ··· 336 311 } 337 312 EXPORT_SYMBOL_GPL(crypto_ahash_setkey); 338 313 339 - static int ahash_reqchain_virt(struct ahash_save_req_state *state, 340 - int err, u32 mask) 341 - { 342 - struct ahash_request *req = state->req0; 343 - struct crypto_ahash *tfm; 344 - 345 - tfm = crypto_ahash_reqtfm(req); 346 - 347 - for (;;) { 348 - unsigned len = state->nbytes; 349 - 350 - if (!state->offset) 351 - break; 352 - 353 - if (state->offset == len || err) { 354 - u8 *result = req->result; 355 - 356 - ahash_request_set_virt(req, state->src, result, len); 357 - state->offset = 0; 358 - break; 359 - } 360 - 361 - len -= state->offset; 362 - 363 - len = min(PAGE_SIZE, len); 364 - memcpy(state->page, state->src + state->offset, len); 365 - state->offset += len; 366 - req->nbytes = len; 367 - 368 - err = crypto_ahash_alg(tfm)->update(req); 369 - if (err == -EINPROGRESS) { 370 - if (state->offset < state->nbytes) 371 - err = -EBUSY; 372 - break; 373 - } 374 - 375 - if (err == -EBUSY) 376 - break; 377 - } 378 - 379 - return err; 380 - } 381 - 382 - static int ahash_reqchain_finish(struct ahash_request *req0, 383 - struct ahash_save_req_state *state, 384 - int err, u32 mask) 385 - { 386 - u8 *page; 387 - 388 - err = ahash_reqchain_virt(state, err, mask); 389 - if (err == -EINPROGRESS || err == -EBUSY) 390 - goto out; 391 - 392 - page = state->page; 393 - if (page) { 394 - memset(page, 0, PAGE_SIZE); 395 - free_page((unsigned long)page); 396 - } 397 - ahash_restore_req(req0); 398 - 399 - out: 400 - return err; 401 - } 402 - 403 - static void ahash_reqchain_done(void *data, int err) 404 - { 405 - struct ahash_save_req_state *state = data; 406 - crypto_completion_t compl = state->compl; 407 - 408 - data = state->data; 409 - 410 - if (err == -EINPROGRESS) { 411 - if (state->offset < state->nbytes) 412 - return; 413 - goto notify; 414 - } 415 - 416 - err = ahash_reqchain_finish(state->req0, state, err, 417 - CRYPTO_TFM_REQ_MAY_BACKLOG); 418 - if (err == -EBUSY) 419 - return; 420 - 421 - notify: 422 - compl(data, err); 423 - } 424 - 425 314 static int ahash_do_req_chain(struct ahash_request *req, 426 - int (*op)(struct ahash_request *req)) 315 + int (*const *op)(struct ahash_request *req)) 427 316 { 428 317 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 429 - bool update = op == crypto_ahash_alg(tfm)->update; 430 - struct ahash_save_req_state *state; 431 - struct ahash_save_req_state state0; 432 - u8 *page = NULL; 433 318 int err; 434 319 435 - if (crypto_ahash_req_virt(tfm) || 436 - !update || !ahash_request_isvirt(req)) 437 - return op(req); 320 + if (crypto_ahash_req_virt(tfm) || !ahash_request_isvirt(req)) 321 + return (*op)(req); 438 322 439 - if (update && ahash_request_isvirt(req)) { 440 - page = (void *)__get_free_page(GFP_ATOMIC); 441 - err = -ENOMEM; 442 - if (!page) 443 - goto out; 444 - } 323 + if (crypto_ahash_statesize(tfm) > HASH_MAX_STATESIZE) 324 + return -ENOSYS; 445 325 446 - state = &state0; 447 - if (ahash_is_async(tfm)) { 448 - err = ahash_save_req(req, ahash_reqchain_done); 449 - if (err) 450 - goto out_free_page; 326 + { 327 + u8 state[HASH_MAX_STATESIZE]; 451 328 452 - state = req->base.data; 453 - } 329 + if (op == &crypto_ahash_alg(tfm)->digest) { 330 + ahash_request_set_tfm(req, crypto_ahash_fb(tfm)); 331 + err = crypto_ahash_digest(req); 332 + goto out_no_state; 333 + } 454 334 455 - state->update = update; 456 - state->page = page; 457 - state->offset = 0; 458 - state->nbytes = 0; 335 + err = crypto_ahash_export(req, state); 336 + ahash_request_set_tfm(req, crypto_ahash_fb(tfm)); 337 + err = err ?: crypto_ahash_import(req, state); 459 338 460 - if (page) 461 - sg_init_one(&state->sg, page, PAGE_SIZE); 339 + if (op == &crypto_ahash_alg(tfm)->finup) { 340 + err = err ?: crypto_ahash_finup(req); 341 + goto out_no_state; 342 + } 462 343 463 - if (update && ahash_request_isvirt(req) && req->nbytes) { 464 - unsigned len = req->nbytes; 465 - u8 *result = req->result; 344 + err = err ?: 345 + crypto_ahash_update(req) ?: 346 + crypto_ahash_export(req, state); 466 347 467 - state->src = req->svirt; 468 - state->nbytes = len; 348 + ahash_request_set_tfm(req, tfm); 349 + return err ?: crypto_ahash_import(req, state); 469 350 470 - len = min(PAGE_SIZE, len); 471 - 472 - memcpy(page, req->svirt, len); 473 - state->offset = len; 474 - 475 - ahash_request_set_crypt(req, &state->sg, result, len); 476 - } 477 - 478 - err = op(req); 479 - if (err == -EINPROGRESS || err == -EBUSY) { 480 - if (state->offset < state->nbytes) 481 - err = -EBUSY; 351 + out_no_state: 352 + ahash_request_set_tfm(req, tfm); 482 353 return err; 483 354 } 484 - 485 - return ahash_reqchain_finish(req, state, err, ~0); 486 - 487 - out_free_page: 488 - free_page((unsigned long)page); 489 - 490 - out: 491 - return err; 492 355 } 493 356 494 357 int crypto_ahash_init(struct ahash_request *req) ··· 389 476 return -ENOKEY; 390 477 if (ahash_req_on_stack(req) && ahash_is_async(tfm)) 391 478 return -EAGAIN; 392 - return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->init); 479 + if (crypto_ahash_block_only(tfm)) { 480 + u8 *buf = ahash_request_ctx(req); 481 + 482 + buf += crypto_ahash_reqsize(tfm) - 1; 483 + *buf = 0; 484 + } 485 + return crypto_ahash_alg(tfm)->init(req); 393 486 } 394 487 EXPORT_SYMBOL_GPL(crypto_ahash_init); 395 488 396 - static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt) 489 + static void ahash_save_req(struct ahash_request *req, crypto_completion_t cplt) 397 490 { 398 - struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 399 - struct ahash_save_req_state *state; 400 - 401 - if (!ahash_is_async(tfm)) 402 - return 0; 403 - 404 - state = kmalloc(sizeof(*state), GFP_ATOMIC); 405 - if (!state) 406 - return -ENOMEM; 407 - 408 - state->compl = req->base.complete; 409 - state->data = req->base.data; 491 + req->saved_complete = req->base.complete; 492 + req->saved_data = req->base.data; 410 493 req->base.complete = cplt; 411 - req->base.data = state; 412 - state->req0 = req; 413 - 414 - return 0; 494 + req->base.data = req; 415 495 } 416 496 417 497 static void ahash_restore_req(struct ahash_request *req) 418 498 { 419 - struct ahash_save_req_state *state; 420 - struct crypto_ahash *tfm; 499 + req->base.complete = req->saved_complete; 500 + req->base.data = req->saved_data; 501 + } 421 502 422 - tfm = crypto_ahash_reqtfm(req); 423 - if (!ahash_is_async(tfm)) 424 - return; 503 + static int ahash_update_finish(struct ahash_request *req, int err) 504 + { 505 + struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 506 + bool nonzero = crypto_ahash_final_nonzero(tfm); 507 + int bs = crypto_ahash_blocksize(tfm); 508 + u8 *blenp = ahash_request_ctx(req); 509 + int blen; 510 + u8 *buf; 425 511 426 - state = req->base.data; 512 + blenp += crypto_ahash_reqsize(tfm) - 1; 513 + blen = *blenp; 514 + buf = blenp - bs; 427 515 428 - req->base.complete = state->compl; 429 - req->base.data = state->data; 430 - kfree(state); 516 + if (blen) { 517 + req->src = req->sg_head + 1; 518 + if (sg_is_chain(req->src)) 519 + req->src = sg_chain_ptr(req->src); 520 + } 521 + 522 + req->nbytes += nonzero - blen; 523 + 524 + blen = err < 0 ? 0 : err + nonzero; 525 + if (ahash_request_isvirt(req)) 526 + memcpy(buf, req->svirt + req->nbytes - blen, blen); 527 + else 528 + memcpy_from_sglist(buf, req->src, req->nbytes - blen, blen); 529 + *blenp = blen; 530 + 531 + ahash_restore_req(req); 532 + 533 + return err; 534 + } 535 + 536 + static void ahash_update_done(void *data, int err) 537 + { 538 + ahash_op_done(data, err, ahash_update_finish); 431 539 } 432 540 433 541 int crypto_ahash_update(struct ahash_request *req) 434 542 { 435 543 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 544 + bool nonzero = crypto_ahash_final_nonzero(tfm); 545 + int bs = crypto_ahash_blocksize(tfm); 546 + u8 *blenp = ahash_request_ctx(req); 547 + int blen, err; 548 + u8 *buf; 436 549 437 550 if (likely(tfm->using_shash)) 438 551 return shash_ahash_update(req, ahash_request_ctx(req)); 439 552 if (ahash_req_on_stack(req) && ahash_is_async(tfm)) 440 553 return -EAGAIN; 441 - return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->update); 554 + if (!crypto_ahash_block_only(tfm)) 555 + return ahash_do_req_chain(req, &crypto_ahash_alg(tfm)->update); 556 + 557 + blenp += crypto_ahash_reqsize(tfm) - 1; 558 + blen = *blenp; 559 + buf = blenp - bs; 560 + 561 + if (blen + req->nbytes < bs + nonzero) { 562 + if (ahash_request_isvirt(req)) 563 + memcpy(buf + blen, req->svirt, req->nbytes); 564 + else 565 + memcpy_from_sglist(buf + blen, req->src, 0, 566 + req->nbytes); 567 + 568 + *blenp += req->nbytes; 569 + return 0; 570 + } 571 + 572 + if (blen) { 573 + memset(req->sg_head, 0, sizeof(req->sg_head[0])); 574 + sg_set_buf(req->sg_head, buf, blen); 575 + if (req->src != req->sg_head + 1) 576 + sg_chain(req->sg_head, 2, req->src); 577 + req->src = req->sg_head; 578 + req->nbytes += blen; 579 + } 580 + req->nbytes -= nonzero; 581 + 582 + ahash_save_req(req, ahash_update_done); 583 + 584 + err = ahash_do_req_chain(req, &crypto_ahash_alg(tfm)->update); 585 + if (err == -EINPROGRESS || err == -EBUSY) 586 + return err; 587 + 588 + return ahash_update_finish(req, err); 442 589 } 443 590 EXPORT_SYMBOL_GPL(crypto_ahash_update); 444 591 445 - int crypto_ahash_final(struct ahash_request *req) 592 + static int ahash_finup_finish(struct ahash_request *req, int err) 446 593 { 447 594 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 595 + u8 *blenp = ahash_request_ctx(req); 596 + int blen; 448 597 449 - if (likely(tfm->using_shash)) 450 - return crypto_shash_final(ahash_request_ctx(req), req->result); 451 - if (ahash_req_on_stack(req) && ahash_is_async(tfm)) 452 - return -EAGAIN; 453 - return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->final); 598 + blenp += crypto_ahash_reqsize(tfm) - 1; 599 + blen = *blenp; 600 + 601 + if (blen) { 602 + if (sg_is_last(req->src)) 603 + req->src = NULL; 604 + else { 605 + req->src = req->sg_head + 1; 606 + if (sg_is_chain(req->src)) 607 + req->src = sg_chain_ptr(req->src); 608 + } 609 + req->nbytes -= blen; 610 + } 611 + 612 + ahash_restore_req(req); 613 + 614 + return err; 454 615 } 455 - EXPORT_SYMBOL_GPL(crypto_ahash_final); 616 + 617 + static void ahash_finup_done(void *data, int err) 618 + { 619 + ahash_op_done(data, err, ahash_finup_finish); 620 + } 456 621 457 622 int crypto_ahash_finup(struct ahash_request *req) 458 623 { 459 624 struct crypto_ahash *tfm = crypto_ahash_reqtfm(req); 625 + int bs = crypto_ahash_blocksize(tfm); 626 + u8 *blenp = ahash_request_ctx(req); 627 + int blen, err; 628 + u8 *buf; 460 629 461 630 if (likely(tfm->using_shash)) 462 631 return shash_ahash_finup(req, ahash_request_ctx(req)); 463 632 if (ahash_req_on_stack(req) && ahash_is_async(tfm)) 464 633 return -EAGAIN; 465 - if (!crypto_ahash_alg(tfm)->finup || 466 - (!crypto_ahash_req_virt(tfm) && ahash_request_isvirt(req))) 634 + if (!crypto_ahash_alg(tfm)->finup) 467 635 return ahash_def_finup(req); 468 - return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->finup); 636 + if (!crypto_ahash_block_only(tfm)) 637 + return ahash_do_req_chain(req, &crypto_ahash_alg(tfm)->finup); 638 + 639 + blenp += crypto_ahash_reqsize(tfm) - 1; 640 + blen = *blenp; 641 + buf = blenp - bs; 642 + 643 + if (blen) { 644 + memset(req->sg_head, 0, sizeof(req->sg_head[0])); 645 + sg_set_buf(req->sg_head, buf, blen); 646 + if (!req->src) 647 + sg_mark_end(req->sg_head); 648 + else if (req->src != req->sg_head + 1) 649 + sg_chain(req->sg_head, 2, req->src); 650 + req->src = req->sg_head; 651 + req->nbytes += blen; 652 + } 653 + 654 + ahash_save_req(req, ahash_finup_done); 655 + 656 + err = ahash_do_req_chain(req, &crypto_ahash_alg(tfm)->finup); 657 + if (err == -EINPROGRESS || err == -EBUSY) 658 + return err; 659 + 660 + return ahash_finup_finish(req, err); 469 661 } 470 662 EXPORT_SYMBOL_GPL(crypto_ahash_finup); 471 - 472 - static int ahash_def_digest_finish(struct ahash_request *req, int err) 473 - { 474 - struct crypto_ahash *tfm; 475 - 476 - if (err) 477 - goto out; 478 - 479 - tfm = crypto_ahash_reqtfm(req); 480 - if (ahash_is_async(tfm)) 481 - req->base.complete = ahash_def_finup_done1; 482 - 483 - err = crypto_ahash_update(req); 484 - if (err == -EINPROGRESS || err == -EBUSY) 485 - return err; 486 - 487 - return ahash_def_finup_finish1(req, err); 488 - 489 - out: 490 - ahash_restore_req(req); 491 - return err; 492 - } 493 - 494 - static void ahash_def_digest_done(void *data, int err) 495 - { 496 - struct ahash_save_req_state *state0 = data; 497 - struct ahash_save_req_state state; 498 - struct ahash_request *areq; 499 - 500 - state = *state0; 501 - areq = state.req0; 502 - if (err == -EINPROGRESS) 503 - goto out; 504 - 505 - areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 506 - 507 - err = ahash_def_digest_finish(areq, err); 508 - if (err == -EINPROGRESS || err == -EBUSY) 509 - return; 510 - 511 - out: 512 - state.compl(state.data, err); 513 - } 514 - 515 - static int ahash_def_digest(struct ahash_request *req) 516 - { 517 - int err; 518 - 519 - err = ahash_save_req(req, ahash_def_digest_done); 520 - if (err) 521 - return err; 522 - 523 - err = crypto_ahash_init(req); 524 - if (err == -EINPROGRESS || err == -EBUSY) 525 - return err; 526 - 527 - return ahash_def_digest_finish(req, err); 528 - } 529 663 530 664 int crypto_ahash_digest(struct ahash_request *req) 531 665 { ··· 582 622 return shash_ahash_digest(req, prepare_shash_desc(req, tfm)); 583 623 if (ahash_req_on_stack(req) && ahash_is_async(tfm)) 584 624 return -EAGAIN; 585 - if (!crypto_ahash_req_virt(tfm) && ahash_request_isvirt(req)) 586 - return ahash_def_digest(req); 587 625 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 588 626 return -ENOKEY; 589 - return ahash_do_req_chain(req, crypto_ahash_alg(tfm)->digest); 627 + return ahash_do_req_chain(req, &crypto_ahash_alg(tfm)->digest); 590 628 } 591 629 EXPORT_SYMBOL_GPL(crypto_ahash_digest); 592 630 593 631 static void ahash_def_finup_done2(void *data, int err) 594 632 { 595 - struct ahash_save_req_state *state = data; 596 - struct ahash_request *areq = state->req0; 633 + struct ahash_request *areq = data; 597 634 598 635 if (err == -EINPROGRESS) 599 636 return; ··· 601 644 602 645 static int ahash_def_finup_finish1(struct ahash_request *req, int err) 603 646 { 604 - struct crypto_ahash *tfm; 605 - 606 647 if (err) 607 648 goto out; 608 649 609 - tfm = crypto_ahash_reqtfm(req); 610 - if (ahash_is_async(tfm)) 611 - req->base.complete = ahash_def_finup_done2; 650 + req->base.complete = ahash_def_finup_done2; 612 651 613 652 err = crypto_ahash_final(req); 614 653 if (err == -EINPROGRESS || err == -EBUSY) ··· 617 664 618 665 static void ahash_def_finup_done1(void *data, int err) 619 666 { 620 - struct ahash_save_req_state *state0 = data; 621 - struct ahash_save_req_state state; 622 - struct ahash_request *areq; 623 - 624 - state = *state0; 625 - areq = state.req0; 626 - if (err == -EINPROGRESS) 627 - goto out; 628 - 629 - areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; 630 - 631 - err = ahash_def_finup_finish1(areq, err); 632 - if (err == -EINPROGRESS || err == -EBUSY) 633 - return; 634 - 635 - out: 636 - state.compl(state.data, err); 667 + ahash_op_done(data, err, ahash_def_finup_finish1); 637 668 } 638 669 639 670 static int ahash_def_finup(struct ahash_request *req) 640 671 { 641 672 int err; 642 673 643 - err = ahash_save_req(req, ahash_def_finup_done1); 644 - if (err) 645 - return err; 674 + ahash_save_req(req, ahash_def_finup_done1); 646 675 647 676 err = crypto_ahash_update(req); 648 677 if (err == -EINPROGRESS || err == -EBUSY) ··· 649 714 650 715 if (likely(tfm->using_shash)) 651 716 return crypto_shash_export(ahash_request_ctx(req), out); 717 + if (crypto_ahash_block_only(tfm)) { 718 + unsigned int plen = crypto_ahash_blocksize(tfm) + 1; 719 + unsigned int reqsize = crypto_ahash_reqsize(tfm); 720 + unsigned int ss = crypto_ahash_statesize(tfm); 721 + u8 *buf = ahash_request_ctx(req); 722 + 723 + memcpy(out + ss - plen, buf + reqsize - plen, plen); 724 + } 652 725 return crypto_ahash_alg(tfm)->export(req, out); 653 726 } 654 727 EXPORT_SYMBOL_GPL(crypto_ahash_export); ··· 682 739 return crypto_shash_import(prepare_shash_desc(req, tfm), in); 683 740 if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY) 684 741 return -ENOKEY; 742 + if (crypto_ahash_block_only(tfm)) { 743 + unsigned int reqsize = crypto_ahash_reqsize(tfm); 744 + u8 *buf = ahash_request_ctx(req); 745 + 746 + buf[reqsize - 1] = 0; 747 + } 685 748 return crypto_ahash_alg(tfm)->import(req, in); 686 749 } 687 750 EXPORT_SYMBOL_GPL(crypto_ahash_import); ··· 702 753 else if (tfm->__crt_alg->cra_exit) 703 754 tfm->__crt_alg->cra_exit(tfm); 704 755 705 - if (ahash_is_async(hash)) 756 + if (crypto_ahash_need_fallback(hash)) 706 757 crypto_free_ahash(crypto_ahash_fb(hash)); 707 758 } 708 759 ··· 719 770 if (tfm->__crt_alg->cra_type == &crypto_shash_type) 720 771 return crypto_init_ahash_using_shash(tfm); 721 772 722 - if (ahash_is_async(hash)) { 773 + if (crypto_ahash_need_fallback(hash)) { 723 774 fb = crypto_alloc_ahash(crypto_ahash_alg_name(hash), 724 - 0, CRYPTO_ALG_ASYNC); 775 + CRYPTO_ALG_REQ_VIRT, 776 + CRYPTO_ALG_ASYNC | 777 + CRYPTO_ALG_REQ_VIRT | 778 + CRYPTO_AHASH_ALG_NO_EXPORT_CORE); 725 779 if (IS_ERR(fb)) 726 780 return PTR_ERR(fb); 727 781 ··· 748 796 if (!ahash_is_async(hash) && crypto_ahash_reqsize(hash) > 749 797 MAX_SYNC_HASH_REQSIZE) 750 798 goto out_exit_tfm; 799 + 800 + BUILD_BUG_ON(HASH_MAX_DESCSIZE > MAX_SYNC_HASH_REQSIZE); 801 + if (crypto_ahash_reqsize(hash) < HASH_MAX_DESCSIZE) 802 + crypto_ahash_set_reqsize(hash, HASH_MAX_DESCSIZE); 751 803 752 804 return 0; 753 805 ··· 897 941 return nhash; 898 942 } 899 943 900 - if (ahash_is_async(hash)) { 944 + if (crypto_ahash_need_fallback(hash)) { 901 945 fb = crypto_clone_ahash(crypto_ahash_fb(hash)); 902 946 err = PTR_ERR(fb); 903 947 if (IS_ERR(fb)) ··· 959 1003 base->cra_type = &crypto_ahash_type; 960 1004 base->cra_flags |= CRYPTO_ALG_TYPE_AHASH; 961 1005 1006 + if ((base->cra_flags ^ CRYPTO_ALG_REQ_VIRT) & 1007 + (CRYPTO_ALG_ASYNC | CRYPTO_ALG_REQ_VIRT)) 1008 + base->cra_flags |= CRYPTO_ALG_NEED_FALLBACK; 1009 + 962 1010 if (!alg->setkey) 963 1011 alg->setkey = ahash_nosetkey; 964 1012 965 - if (!alg->export_core || !alg->import_core) { 1013 + if (base->cra_flags & CRYPTO_AHASH_ALG_BLOCK_ONLY) { 1014 + BUILD_BUG_ON(MAX_ALGAPI_BLOCKSIZE >= 256); 1015 + if (!alg->finup) 1016 + return -EINVAL; 1017 + 1018 + base->cra_reqsize += base->cra_blocksize + 1; 1019 + alg->halg.statesize += base->cra_blocksize + 1; 1020 + alg->export_core = alg->export; 1021 + alg->import_core = alg->import; 1022 + } else if (!alg->export_core || !alg->import_core) { 966 1023 alg->export_core = ahash_default_export_core; 967 1024 alg->import_core = ahash_default_import_core; 968 1025 base->cra_flags |= CRYPTO_AHASH_ALG_NO_EXPORT_CORE;

+10 -2

include/crypto/hash.h

··· 8 8 #ifndef _CRYPTO_HASH_H 9 9 #define _CRYPTO_HASH_H 10 10 11 - #include <linux/atomic.h> 12 11 #include <linux/crypto.h> 12 + #include <linux/scatterlist.h> 13 13 #include <linux/slab.h> 14 14 #include <linux/string.h> 15 15 ··· 64 64 const u8 *svirt; 65 65 }; 66 66 u8 *result; 67 + 68 + struct scatterlist sg_head[2]; 69 + crypto_completion_t saved_complete; 70 + void *saved_data; 67 71 68 72 void *__ctx[] CRYPTO_MINALIGN_ATTR; 69 73 }; ··· 492 488 * -EBUSY if queue is full and request should be resubmitted later; 493 489 * other < 0 if an error occurred 494 490 */ 495 - int crypto_ahash_final(struct ahash_request *req); 491 + static inline int crypto_ahash_final(struct ahash_request *req) 492 + { 493 + req->nbytes = 0; 494 + return crypto_ahash_finup(req); 495 + } 496 496 497 497 /** 498 498 * crypto_ahash_digest() - calculate message digest for a buffer

Configure Feed

Configure Feed