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