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