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