1 /* 2 * Cryptographic API for algorithms (i.e., low-level API). 3 * 4 * Copyright (c) 2006 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/algapi.h> 14 #include <linux/err.h> 15 #include <linux/errno.h> 16 #include <linux/fips.h> 17 #include <linux/init.h> 18 #include <linux/kernel.h> 19 #include <linux/list.h> 20 #include <linux/module.h> 21 #include <linux/rtnetlink.h> 22 #include <linux/slab.h> 23 #include <linux/string.h> 24 25 #include "internal.h" 26 27 static LIST_HEAD(crypto_template_list); 28 29 static inline int crypto_set_driver_name(struct crypto_alg *alg) 30 { 31 static const char suffix[] = "-generic"; 32 char *driver_name = alg->cra_driver_name; 33 int len; 34 35 if (*driver_name) 36 return 0; 37 38 len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); 39 if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME) 40 return -ENAMETOOLONG; 41 42 memcpy(driver_name + len, suffix, sizeof(suffix)); 43 return 0; 44 } 45 46 static inline void crypto_check_module_sig(struct module *mod) 47 { 48 if (fips_enabled && mod && !module_sig_ok(mod)) 49 panic("Module %s signature verification failed in FIPS mode\n", 50 module_name(mod)); 51 } 52 53 static int crypto_check_alg(struct crypto_alg *alg) 54 { 55 crypto_check_module_sig(alg->cra_module); 56 57 if (alg->cra_alignmask & (alg->cra_alignmask + 1)) 58 return -EINVAL; 59 60 if (alg->cra_blocksize > PAGE_SIZE / 8) 61 return -EINVAL; 62 63 if (!alg->cra_type && (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == 64 CRYPTO_ALG_TYPE_CIPHER) { 65 if (alg->cra_alignmask > MAX_CIPHER_ALIGNMASK) 66 return -EINVAL; 67 68 if (alg->cra_blocksize > MAX_CIPHER_BLOCKSIZE) 69 return -EINVAL; 70 } 71 72 if (alg->cra_priority < 0) 73 return -EINVAL; 74 75 refcount_set(&alg->cra_refcnt, 1); 76 77 return crypto_set_driver_name(alg); 78 } 79 80 static void crypto_free_instance(struct crypto_instance *inst) 81 { 82 if (!inst->alg.cra_type->free) { 83 inst->tmpl->free(inst); 84 return; 85 } 86 87 inst->alg.cra_type->free(inst); 88 } 89 90 static void crypto_destroy_instance(struct crypto_alg *alg) 91 { 92 struct crypto_instance *inst = (void *)alg; 93 struct crypto_template *tmpl = inst->tmpl; 94 95 crypto_free_instance(inst); 96 crypto_tmpl_put(tmpl); 97 } 98 99 static struct list_head *crypto_more_spawns(struct crypto_alg *alg, 100 struct list_head *stack, 101 struct list_head *top, 102 struct list_head *secondary_spawns) 103 { 104 struct crypto_spawn *spawn, *n; 105 106 spawn = list_first_entry_or_null(stack, struct crypto_spawn, list); 107 if (!spawn) 108 return NULL; 109 110 n = list_next_entry(spawn, list); 111 112 if (spawn->alg && &n->list != stack && !n->alg) 113 n->alg = (n->list.next == stack) ? alg : 114 &list_next_entry(n, list)->inst->alg; 115 116 list_move(&spawn->list, secondary_spawns); 117 118 return &n->list == stack ? top : &n->inst->alg.cra_users; 119 } 120 121 static void crypto_remove_instance(struct crypto_instance *inst, 122 struct list_head *list) 123 { 124 struct crypto_template *tmpl = inst->tmpl; 125 126 if (crypto_is_dead(&inst->alg)) 127 return; 128 129 inst->alg.cra_flags |= CRYPTO_ALG_DEAD; 130 if (hlist_unhashed(&inst->list)) 131 return; 132 133 if (!tmpl || !crypto_tmpl_get(tmpl)) 134 return; 135 136 list_move(&inst->alg.cra_list, list); 137 hlist_del(&inst->list); 138 inst->alg.cra_destroy = crypto_destroy_instance; 139 140 BUG_ON(!list_empty(&inst->alg.cra_users)); 141 } 142 143 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list, 144 struct crypto_alg *nalg) 145 { 146 u32 new_type = (nalg ?: alg)->cra_flags; 147 struct crypto_spawn *spawn, *n; 148 LIST_HEAD(secondary_spawns); 149 struct list_head *spawns; 150 LIST_HEAD(stack); 151 LIST_HEAD(top); 152 153 spawns = &alg->cra_users; 154 list_for_each_entry_safe(spawn, n, spawns, list) { 155 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask) 156 continue; 157 158 list_move(&spawn->list, &top); 159 } 160 161 spawns = ⊤ 162 do { 163 while (!list_empty(spawns)) { 164 struct crypto_instance *inst; 165 166 spawn = list_first_entry(spawns, struct crypto_spawn, 167 list); 168 inst = spawn->inst; 169 170 BUG_ON(&inst->alg == alg); 171 172 list_move(&spawn->list, &stack); 173 174 if (&inst->alg == nalg) 175 break; 176 177 spawn->alg = NULL; 178 spawns = &inst->alg.cra_users; 179 180 /* 181 * We may encounter an unregistered instance here, since 182 * an instance's spawns are set up prior to the instance 183 * being registered. An unregistered instance will have 184 * NULL ->cra_users.next, since ->cra_users isn't 185 * properly initialized until registration. But an 186 * unregistered instance cannot have any users, so treat 187 * it the same as ->cra_users being empty. 188 */ 189 if (spawns->next == NULL) 190 break; 191 } 192 } while ((spawns = crypto_more_spawns(alg, &stack, &top, 193 &secondary_spawns))); 194 195 list_for_each_entry_safe(spawn, n, &secondary_spawns, list) { 196 if (spawn->alg) 197 list_move(&spawn->list, &spawn->alg->cra_users); 198 else 199 crypto_remove_instance(spawn->inst, list); 200 } 201 } 202 EXPORT_SYMBOL_GPL(crypto_remove_spawns); 203 204 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg) 205 { 206 struct crypto_alg *q; 207 struct crypto_larval *larval; 208 int ret = -EAGAIN; 209 210 if (crypto_is_dead(alg)) 211 goto err; 212 213 INIT_LIST_HEAD(&alg->cra_users); 214 215 /* No cheating! */ 216 alg->cra_flags &= ~CRYPTO_ALG_TESTED; 217 218 ret = -EEXIST; 219 220 list_for_each_entry(q, &crypto_alg_list, cra_list) { 221 if (q == alg) 222 goto err; 223 224 if (crypto_is_moribund(q)) 225 continue; 226 227 if (crypto_is_larval(q)) { 228 if (!strcmp(alg->cra_driver_name, q->cra_driver_name)) 229 goto err; 230 continue; 231 } 232 233 if (!strcmp(q->cra_driver_name, alg->cra_name) || 234 !strcmp(q->cra_name, alg->cra_driver_name)) 235 goto err; 236 } 237 238 larval = crypto_larval_alloc(alg->cra_name, 239 alg->cra_flags | CRYPTO_ALG_TESTED, 0); 240 if (IS_ERR(larval)) 241 goto out; 242 243 ret = -ENOENT; 244 larval->adult = crypto_mod_get(alg); 245 if (!larval->adult) 246 goto free_larval; 247 248 refcount_set(&larval->alg.cra_refcnt, 1); 249 memcpy(larval->alg.cra_driver_name, alg->cra_driver_name, 250 CRYPTO_MAX_ALG_NAME); 251 larval->alg.cra_priority = alg->cra_priority; 252 253 list_add(&alg->cra_list, &crypto_alg_list); 254 list_add(&larval->alg.cra_list, &crypto_alg_list); 255 256 out: 257 return larval; 258 259 free_larval: 260 kfree(larval); 261 err: 262 larval = ERR_PTR(ret); 263 goto out; 264 } 265 266 void crypto_alg_tested(const char *name, int err) 267 { 268 struct crypto_larval *test; 269 struct crypto_alg *alg; 270 struct crypto_alg *q; 271 LIST_HEAD(list); 272 273 down_write(&crypto_alg_sem); 274 list_for_each_entry(q, &crypto_alg_list, cra_list) { 275 if (crypto_is_moribund(q) || !crypto_is_larval(q)) 276 continue; 277 278 test = (struct crypto_larval *)q; 279 280 if (!strcmp(q->cra_driver_name, name)) 281 goto found; 282 } 283 284 pr_err("alg: Unexpected test result for %s: %d\n", name, err); 285 goto unlock; 286 287 found: 288 q->cra_flags |= CRYPTO_ALG_DEAD; 289 alg = test->adult; 290 if (err || list_empty(&alg->cra_list)) 291 goto complete; 292 293 alg->cra_flags |= CRYPTO_ALG_TESTED; 294 295 list_for_each_entry(q, &crypto_alg_list, cra_list) { 296 if (q == alg) 297 continue; 298 299 if (crypto_is_moribund(q)) 300 continue; 301 302 if (crypto_is_larval(q)) { 303 struct crypto_larval *larval = (void *)q; 304 305 /* 306 * Check to see if either our generic name or 307 * specific name can satisfy the name requested 308 * by the larval entry q. 309 */ 310 if (strcmp(alg->cra_name, q->cra_name) && 311 strcmp(alg->cra_driver_name, q->cra_name)) 312 continue; 313 314 if (larval->adult) 315 continue; 316 if ((q->cra_flags ^ alg->cra_flags) & larval->mask) 317 continue; 318 if (!crypto_mod_get(alg)) 319 continue; 320 321 larval->adult = alg; 322 continue; 323 } 324 325 if (strcmp(alg->cra_name, q->cra_name)) 326 continue; 327 328 if (strcmp(alg->cra_driver_name, q->cra_driver_name) && 329 q->cra_priority > alg->cra_priority) 330 continue; 331 332 crypto_remove_spawns(q, &list, alg); 333 } 334 335 complete: 336 complete_all(&test->completion); 337 338 unlock: 339 up_write(&crypto_alg_sem); 340 341 crypto_remove_final(&list); 342 } 343 EXPORT_SYMBOL_GPL(crypto_alg_tested); 344 345 void crypto_remove_final(struct list_head *list) 346 { 347 struct crypto_alg *alg; 348 struct crypto_alg *n; 349 350 list_for_each_entry_safe(alg, n, list, cra_list) { 351 list_del_init(&alg->cra_list); 352 crypto_alg_put(alg); 353 } 354 } 355 EXPORT_SYMBOL_GPL(crypto_remove_final); 356 357 static void crypto_wait_for_test(struct crypto_larval *larval) 358 { 359 int err; 360 361 err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult); 362 if (err != NOTIFY_STOP) { 363 if (WARN_ON(err != NOTIFY_DONE)) 364 goto out; 365 crypto_alg_tested(larval->alg.cra_driver_name, 0); 366 } 367 368 err = wait_for_completion_killable(&larval->completion); 369 WARN_ON(err); 370 371 out: 372 crypto_larval_kill(&larval->alg); 373 } 374 375 int crypto_register_alg(struct crypto_alg *alg) 376 { 377 struct crypto_larval *larval; 378 int err; 379 380 alg->cra_flags &= ~CRYPTO_ALG_DEAD; 381 err = crypto_check_alg(alg); 382 if (err) 383 return err; 384 385 down_write(&crypto_alg_sem); 386 larval = __crypto_register_alg(alg); 387 up_write(&crypto_alg_sem); 388 389 if (IS_ERR(larval)) 390 return PTR_ERR(larval); 391 392 crypto_wait_for_test(larval); 393 return 0; 394 } 395 EXPORT_SYMBOL_GPL(crypto_register_alg); 396 397 static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list) 398 { 399 if (unlikely(list_empty(&alg->cra_list))) 400 return -ENOENT; 401 402 alg->cra_flags |= CRYPTO_ALG_DEAD; 403 404 list_del_init(&alg->cra_list); 405 crypto_remove_spawns(alg, list, NULL); 406 407 return 0; 408 } 409 410 int crypto_unregister_alg(struct crypto_alg *alg) 411 { 412 int ret; 413 LIST_HEAD(list); 414 415 down_write(&crypto_alg_sem); 416 ret = crypto_remove_alg(alg, &list); 417 up_write(&crypto_alg_sem); 418 419 if (ret) 420 return ret; 421 422 BUG_ON(refcount_read(&alg->cra_refcnt) != 1); 423 if (alg->cra_destroy) 424 alg->cra_destroy(alg); 425 426 crypto_remove_final(&list); 427 return 0; 428 } 429 EXPORT_SYMBOL_GPL(crypto_unregister_alg); 430 431 int crypto_register_algs(struct crypto_alg *algs, int count) 432 { 433 int i, ret; 434 435 for (i = 0; i < count; i++) { 436 ret = crypto_register_alg(&algs[i]); 437 if (ret) 438 goto err; 439 } 440 441 return 0; 442 443 err: 444 for (--i; i >= 0; --i) 445 crypto_unregister_alg(&algs[i]); 446 447 return ret; 448 } 449 EXPORT_SYMBOL_GPL(crypto_register_algs); 450 451 int crypto_unregister_algs(struct crypto_alg *algs, int count) 452 { 453 int i, ret; 454 455 for (i = 0; i < count; i++) { 456 ret = crypto_unregister_alg(&algs[i]); 457 if (ret) 458 pr_err("Failed to unregister %s %s: %d\n", 459 algs[i].cra_driver_name, algs[i].cra_name, ret); 460 } 461 462 return 0; 463 } 464 EXPORT_SYMBOL_GPL(crypto_unregister_algs); 465 466 int crypto_register_template(struct crypto_template *tmpl) 467 { 468 struct crypto_template *q; 469 int err = -EEXIST; 470 471 down_write(&crypto_alg_sem); 472 473 crypto_check_module_sig(tmpl->module); 474 475 list_for_each_entry(q, &crypto_template_list, list) { 476 if (q == tmpl) 477 goto out; 478 } 479 480 list_add(&tmpl->list, &crypto_template_list); 481 err = 0; 482 out: 483 up_write(&crypto_alg_sem); 484 return err; 485 } 486 EXPORT_SYMBOL_GPL(crypto_register_template); 487 488 void crypto_unregister_template(struct crypto_template *tmpl) 489 { 490 struct crypto_instance *inst; 491 struct hlist_node *n; 492 struct hlist_head *list; 493 LIST_HEAD(users); 494 495 down_write(&crypto_alg_sem); 496 497 BUG_ON(list_empty(&tmpl->list)); 498 list_del_init(&tmpl->list); 499 500 list = &tmpl->instances; 501 hlist_for_each_entry(inst, list, list) { 502 int err = crypto_remove_alg(&inst->alg, &users); 503 504 BUG_ON(err); 505 } 506 507 up_write(&crypto_alg_sem); 508 509 hlist_for_each_entry_safe(inst, n, list, list) { 510 BUG_ON(refcount_read(&inst->alg.cra_refcnt) != 1); 511 crypto_free_instance(inst); 512 } 513 crypto_remove_final(&users); 514 } 515 EXPORT_SYMBOL_GPL(crypto_unregister_template); 516 517 static struct crypto_template *__crypto_lookup_template(const char *name) 518 { 519 struct crypto_template *q, *tmpl = NULL; 520 521 down_read(&crypto_alg_sem); 522 list_for_each_entry(q, &crypto_template_list, list) { 523 if (strcmp(q->name, name)) 524 continue; 525 if (unlikely(!crypto_tmpl_get(q))) 526 continue; 527 528 tmpl = q; 529 break; 530 } 531 up_read(&crypto_alg_sem); 532 533 return tmpl; 534 } 535 536 struct crypto_template *crypto_lookup_template(const char *name) 537 { 538 return try_then_request_module(__crypto_lookup_template(name), 539 "crypto-%s", name); 540 } 541 EXPORT_SYMBOL_GPL(crypto_lookup_template); 542 543 int crypto_register_instance(struct crypto_template *tmpl, 544 struct crypto_instance *inst) 545 { 546 struct crypto_larval *larval; 547 int err; 548 549 err = crypto_check_alg(&inst->alg); 550 if (err) 551 return err; 552 553 inst->alg.cra_module = tmpl->module; 554 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE; 555 556 down_write(&crypto_alg_sem); 557 558 larval = __crypto_register_alg(&inst->alg); 559 if (IS_ERR(larval)) 560 goto unlock; 561 562 hlist_add_head(&inst->list, &tmpl->instances); 563 inst->tmpl = tmpl; 564 565 unlock: 566 up_write(&crypto_alg_sem); 567 568 err = PTR_ERR(larval); 569 if (IS_ERR(larval)) 570 goto err; 571 572 crypto_wait_for_test(larval); 573 err = 0; 574 575 err: 576 return err; 577 } 578 EXPORT_SYMBOL_GPL(crypto_register_instance); 579 580 int crypto_unregister_instance(struct crypto_instance *inst) 581 { 582 LIST_HEAD(list); 583 584 down_write(&crypto_alg_sem); 585 586 crypto_remove_spawns(&inst->alg, &list, NULL); 587 crypto_remove_instance(inst, &list); 588 589 up_write(&crypto_alg_sem); 590 591 crypto_remove_final(&list); 592 593 return 0; 594 } 595 EXPORT_SYMBOL_GPL(crypto_unregister_instance); 596 597 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, 598 struct crypto_instance *inst, u32 mask) 599 { 600 int err = -EAGAIN; 601 602 spawn->inst = inst; 603 spawn->mask = mask; 604 605 down_write(&crypto_alg_sem); 606 if (!crypto_is_moribund(alg)) { 607 list_add(&spawn->list, &alg->cra_users); 608 spawn->alg = alg; 609 err = 0; 610 } 611 up_write(&crypto_alg_sem); 612 613 return err; 614 } 615 EXPORT_SYMBOL_GPL(crypto_init_spawn); 616 617 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, 618 struct crypto_instance *inst, 619 const struct crypto_type *frontend) 620 { 621 int err = -EINVAL; 622 623 if ((alg->cra_flags ^ frontend->type) & frontend->maskset) 624 goto out; 625 626 spawn->frontend = frontend; 627 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); 628 629 out: 630 return err; 631 } 632 EXPORT_SYMBOL_GPL(crypto_init_spawn2); 633 634 int crypto_grab_spawn(struct crypto_spawn *spawn, const char *name, 635 u32 type, u32 mask) 636 { 637 struct crypto_alg *alg; 638 int err; 639 640 alg = crypto_find_alg(name, spawn->frontend, type, mask); 641 if (IS_ERR(alg)) 642 return PTR_ERR(alg); 643 644 err = crypto_init_spawn(spawn, alg, spawn->inst, mask); 645 crypto_mod_put(alg); 646 return err; 647 } 648 EXPORT_SYMBOL_GPL(crypto_grab_spawn); 649 650 void crypto_drop_spawn(struct crypto_spawn *spawn) 651 { 652 if (!spawn->alg) 653 return; 654 655 down_write(&crypto_alg_sem); 656 list_del(&spawn->list); 657 up_write(&crypto_alg_sem); 658 } 659 EXPORT_SYMBOL_GPL(crypto_drop_spawn); 660 661 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn) 662 { 663 struct crypto_alg *alg; 664 struct crypto_alg *alg2; 665 666 down_read(&crypto_alg_sem); 667 alg = spawn->alg; 668 alg2 = alg; 669 if (alg2) 670 alg2 = crypto_mod_get(alg2); 671 up_read(&crypto_alg_sem); 672 673 if (!alg2) { 674 if (alg) 675 crypto_shoot_alg(alg); 676 return ERR_PTR(-EAGAIN); 677 } 678 679 return alg; 680 } 681 682 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type, 683 u32 mask) 684 { 685 struct crypto_alg *alg; 686 struct crypto_tfm *tfm; 687 688 alg = crypto_spawn_alg(spawn); 689 if (IS_ERR(alg)) 690 return ERR_CAST(alg); 691 692 tfm = ERR_PTR(-EINVAL); 693 if (unlikely((alg->cra_flags ^ type) & mask)) 694 goto out_put_alg; 695 696 tfm = __crypto_alloc_tfm(alg, type, mask); 697 if (IS_ERR(tfm)) 698 goto out_put_alg; 699 700 return tfm; 701 702 out_put_alg: 703 crypto_mod_put(alg); 704 return tfm; 705 } 706 EXPORT_SYMBOL_GPL(crypto_spawn_tfm); 707 708 void *crypto_spawn_tfm2(struct crypto_spawn *spawn) 709 { 710 struct crypto_alg *alg; 711 struct crypto_tfm *tfm; 712 713 alg = crypto_spawn_alg(spawn); 714 if (IS_ERR(alg)) 715 return ERR_CAST(alg); 716 717 tfm = crypto_create_tfm(alg, spawn->frontend); 718 if (IS_ERR(tfm)) 719 goto out_put_alg; 720 721 return tfm; 722 723 out_put_alg: 724 crypto_mod_put(alg); 725 return tfm; 726 } 727 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2); 728 729 int crypto_register_notifier(struct notifier_block *nb) 730 { 731 return blocking_notifier_chain_register(&crypto_chain, nb); 732 } 733 EXPORT_SYMBOL_GPL(crypto_register_notifier); 734 735 int crypto_unregister_notifier(struct notifier_block *nb) 736 { 737 return blocking_notifier_chain_unregister(&crypto_chain, nb); 738 } 739 EXPORT_SYMBOL_GPL(crypto_unregister_notifier); 740 741 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb) 742 { 743 struct rtattr *rta = tb[0]; 744 struct crypto_attr_type *algt; 745 746 if (!rta) 747 return ERR_PTR(-ENOENT); 748 if (RTA_PAYLOAD(rta) < sizeof(*algt)) 749 return ERR_PTR(-EINVAL); 750 if (rta->rta_type != CRYPTOA_TYPE) 751 return ERR_PTR(-EINVAL); 752 753 algt = RTA_DATA(rta); 754 755 return algt; 756 } 757 EXPORT_SYMBOL_GPL(crypto_get_attr_type); 758 759 int crypto_check_attr_type(struct rtattr **tb, u32 type) 760 { 761 struct crypto_attr_type *algt; 762 763 algt = crypto_get_attr_type(tb); 764 if (IS_ERR(algt)) 765 return PTR_ERR(algt); 766 767 if ((algt->type ^ type) & algt->mask) 768 return -EINVAL; 769 770 return 0; 771 } 772 EXPORT_SYMBOL_GPL(crypto_check_attr_type); 773 774 const char *crypto_attr_alg_name(struct rtattr *rta) 775 { 776 struct crypto_attr_alg *alga; 777 778 if (!rta) 779 return ERR_PTR(-ENOENT); 780 if (RTA_PAYLOAD(rta) < sizeof(*alga)) 781 return ERR_PTR(-EINVAL); 782 if (rta->rta_type != CRYPTOA_ALG) 783 return ERR_PTR(-EINVAL); 784 785 alga = RTA_DATA(rta); 786 alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0; 787 788 return alga->name; 789 } 790 EXPORT_SYMBOL_GPL(crypto_attr_alg_name); 791 792 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta, 793 const struct crypto_type *frontend, 794 u32 type, u32 mask) 795 { 796 const char *name; 797 798 name = crypto_attr_alg_name(rta); 799 if (IS_ERR(name)) 800 return ERR_CAST(name); 801 802 return crypto_find_alg(name, frontend, type, mask); 803 } 804 EXPORT_SYMBOL_GPL(crypto_attr_alg2); 805 806 int crypto_attr_u32(struct rtattr *rta, u32 *num) 807 { 808 struct crypto_attr_u32 *nu32; 809 810 if (!rta) 811 return -ENOENT; 812 if (RTA_PAYLOAD(rta) < sizeof(*nu32)) 813 return -EINVAL; 814 if (rta->rta_type != CRYPTOA_U32) 815 return -EINVAL; 816 817 nu32 = RTA_DATA(rta); 818 *num = nu32->num; 819 820 return 0; 821 } 822 EXPORT_SYMBOL_GPL(crypto_attr_u32); 823 824 int crypto_inst_setname(struct crypto_instance *inst, const char *name, 825 struct crypto_alg *alg) 826 { 827 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, 828 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) 829 return -ENAMETOOLONG; 830 831 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", 832 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) 833 return -ENAMETOOLONG; 834 835 return 0; 836 } 837 EXPORT_SYMBOL_GPL(crypto_inst_setname); 838 839 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, 840 unsigned int head) 841 { 842 struct crypto_instance *inst; 843 char *p; 844 int err; 845 846 p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn), 847 GFP_KERNEL); 848 if (!p) 849 return ERR_PTR(-ENOMEM); 850 851 inst = (void *)(p + head); 852 853 err = crypto_inst_setname(inst, name, alg); 854 if (err) 855 goto err_free_inst; 856 857 return p; 858 859 err_free_inst: 860 kfree(p); 861 return ERR_PTR(err); 862 } 863 EXPORT_SYMBOL_GPL(crypto_alloc_instance2); 864 865 struct crypto_instance *crypto_alloc_instance(const char *name, 866 struct crypto_alg *alg) 867 { 868 struct crypto_instance *inst; 869 struct crypto_spawn *spawn; 870 int err; 871 872 inst = crypto_alloc_instance2(name, alg, 0); 873 if (IS_ERR(inst)) 874 goto out; 875 876 spawn = crypto_instance_ctx(inst); 877 err = crypto_init_spawn(spawn, alg, inst, 878 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC); 879 880 if (err) 881 goto err_free_inst; 882 883 return inst; 884 885 err_free_inst: 886 kfree(inst); 887 inst = ERR_PTR(err); 888 889 out: 890 return inst; 891 } 892 EXPORT_SYMBOL_GPL(crypto_alloc_instance); 893 894 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen) 895 { 896 INIT_LIST_HEAD(&queue->list); 897 queue->backlog = &queue->list; 898 queue->qlen = 0; 899 queue->max_qlen = max_qlen; 900 } 901 EXPORT_SYMBOL_GPL(crypto_init_queue); 902 903 int crypto_enqueue_request(struct crypto_queue *queue, 904 struct crypto_async_request *request) 905 { 906 int err = -EINPROGRESS; 907 908 if (unlikely(queue->qlen >= queue->max_qlen)) { 909 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) { 910 err = -ENOSPC; 911 goto out; 912 } 913 err = -EBUSY; 914 if (queue->backlog == &queue->list) 915 queue->backlog = &request->list; 916 } 917 918 queue->qlen++; 919 list_add_tail(&request->list, &queue->list); 920 921 out: 922 return err; 923 } 924 EXPORT_SYMBOL_GPL(crypto_enqueue_request); 925 926 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue) 927 { 928 struct list_head *request; 929 930 if (unlikely(!queue->qlen)) 931 return NULL; 932 933 queue->qlen--; 934 935 if (queue->backlog != &queue->list) 936 queue->backlog = queue->backlog->next; 937 938 request = queue->list.next; 939 list_del(request); 940 941 return list_entry(request, struct crypto_async_request, list); 942 } 943 EXPORT_SYMBOL_GPL(crypto_dequeue_request); 944 945 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm) 946 { 947 struct crypto_async_request *req; 948 949 list_for_each_entry(req, &queue->list, list) { 950 if (req->tfm == tfm) 951 return 1; 952 } 953 954 return 0; 955 } 956 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue); 957 958 static inline void crypto_inc_byte(u8 *a, unsigned int size) 959 { 960 u8 *b = (a + size); 961 u8 c; 962 963 for (; size; size--) { 964 c = *--b + 1; 965 *b = c; 966 if (c) 967 break; 968 } 969 } 970 971 void crypto_inc(u8 *a, unsigned int size) 972 { 973 __be32 *b = (__be32 *)(a + size); 974 u32 c; 975 976 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) || 977 IS_ALIGNED((unsigned long)b, __alignof__(*b))) 978 for (; size >= 4; size -= 4) { 979 c = be32_to_cpu(*--b) + 1; 980 *b = cpu_to_be32(c); 981 if (likely(c)) 982 return; 983 } 984 985 crypto_inc_byte(a, size); 986 } 987 EXPORT_SYMBOL_GPL(crypto_inc); 988 989 void __crypto_xor(u8 *dst, const u8 *src1, const u8 *src2, unsigned int len) 990 { 991 int relalign = 0; 992 993 if (!IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)) { 994 int size = sizeof(unsigned long); 995 int d = (((unsigned long)dst ^ (unsigned long)src1) | 996 ((unsigned long)dst ^ (unsigned long)src2)) & 997 (size - 1); 998 999 relalign = d ? 1 << __ffs(d) : size; 1000 1001 /* 1002 * If we care about alignment, process as many bytes as 1003 * needed to advance dst and src to values whose alignments 1004 * equal their relative alignment. This will allow us to 1005 * process the remainder of the input using optimal strides. 1006 */ 1007 while (((unsigned long)dst & (relalign - 1)) && len > 0) { 1008 *dst++ = *src1++ ^ *src2++; 1009 len--; 1010 } 1011 } 1012 1013 while (IS_ENABLED(CONFIG_64BIT) && len >= 8 && !(relalign & 7)) { 1014 *(u64 *)dst = *(u64 *)src1 ^ *(u64 *)src2; 1015 dst += 8; 1016 src1 += 8; 1017 src2 += 8; 1018 len -= 8; 1019 } 1020 1021 while (len >= 4 && !(relalign & 3)) { 1022 *(u32 *)dst = *(u32 *)src1 ^ *(u32 *)src2; 1023 dst += 4; 1024 src1 += 4; 1025 src2 += 4; 1026 len -= 4; 1027 } 1028 1029 while (len >= 2 && !(relalign & 1)) { 1030 *(u16 *)dst = *(u16 *)src1 ^ *(u16 *)src2; 1031 dst += 2; 1032 src1 += 2; 1033 src2 += 2; 1034 len -= 2; 1035 } 1036 1037 while (len--) 1038 *dst++ = *src1++ ^ *src2++; 1039 } 1040 EXPORT_SYMBOL_GPL(__crypto_xor); 1041 1042 unsigned int crypto_alg_extsize(struct crypto_alg *alg) 1043 { 1044 return alg->cra_ctxsize + 1045 (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1)); 1046 } 1047 EXPORT_SYMBOL_GPL(crypto_alg_extsize); 1048 1049 int crypto_type_has_alg(const char *name, const struct crypto_type *frontend, 1050 u32 type, u32 mask) 1051 { 1052 int ret = 0; 1053 struct crypto_alg *alg = crypto_find_alg(name, frontend, type, mask); 1054 1055 if (!IS_ERR(alg)) { 1056 crypto_mod_put(alg); 1057 ret = 1; 1058 } 1059 1060 return ret; 1061 } 1062 EXPORT_SYMBOL_GPL(crypto_type_has_alg); 1063 1064 static int __init crypto_algapi_init(void) 1065 { 1066 crypto_init_proc(); 1067 return 0; 1068 } 1069 1070 static void __exit crypto_algapi_exit(void) 1071 { 1072 crypto_exit_proc(); 1073 } 1074 1075 module_init(crypto_algapi_init); 1076 module_exit(crypto_algapi_exit); 1077 1078 MODULE_LICENSE("GPL"); 1079 MODULE_DESCRIPTION("Cryptographic algorithms API"); 1080