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 25 static LIST_HEAD(crypto_template_list); 26 27 static 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 44 static 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 54 static 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 return crypto_set_driver_name(alg); 68 } 69 70 static void crypto_destroy_instance(struct crypto_alg *alg) 71 { 72 struct crypto_instance *inst = (void *)alg; 73 struct crypto_template *tmpl = inst->tmpl; 74 75 tmpl->free(inst); 76 crypto_tmpl_put(tmpl); 77 } 78 79 static struct list_head *crypto_more_spawns(struct crypto_alg *alg, 80 struct list_head *stack, 81 struct list_head *top, 82 struct list_head *secondary_spawns) 83 { 84 struct crypto_spawn *spawn, *n; 85 86 if (list_empty(stack)) 87 return NULL; 88 89 spawn = list_first_entry(stack, struct crypto_spawn, list); 90 n = list_entry(spawn->list.next, struct crypto_spawn, list); 91 92 if (spawn->alg && &n->list != stack && !n->alg) 93 n->alg = (n->list.next == stack) ? alg : 94 &list_entry(n->list.next, struct crypto_spawn, 95 list)->inst->alg; 96 97 list_move(&spawn->list, secondary_spawns); 98 99 return &n->list == stack ? top : &n->inst->alg.cra_users; 100 } 101 102 static void crypto_remove_spawn(struct crypto_spawn *spawn, 103 struct list_head *list) 104 { 105 struct crypto_instance *inst = spawn->inst; 106 struct crypto_template *tmpl = inst->tmpl; 107 108 if (crypto_is_dead(&inst->alg)) 109 return; 110 111 inst->alg.cra_flags |= CRYPTO_ALG_DEAD; 112 if (hlist_unhashed(&inst->list)) 113 return; 114 115 if (!tmpl || !crypto_tmpl_get(tmpl)) 116 return; 117 118 crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg); 119 list_move(&inst->alg.cra_list, list); 120 hlist_del(&inst->list); 121 inst->alg.cra_destroy = crypto_destroy_instance; 122 123 BUG_ON(!list_empty(&inst->alg.cra_users)); 124 } 125 126 void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list, 127 struct crypto_alg *nalg) 128 { 129 u32 new_type = (nalg ?: alg)->cra_flags; 130 struct crypto_spawn *spawn, *n; 131 LIST_HEAD(secondary_spawns); 132 struct list_head *spawns; 133 LIST_HEAD(stack); 134 LIST_HEAD(top); 135 136 spawns = &alg->cra_users; 137 list_for_each_entry_safe(spawn, n, spawns, list) { 138 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask) 139 continue; 140 141 list_move(&spawn->list, &top); 142 } 143 144 spawns = ⊤ 145 do { 146 while (!list_empty(spawns)) { 147 struct crypto_instance *inst; 148 149 spawn = list_first_entry(spawns, struct crypto_spawn, 150 list); 151 inst = spawn->inst; 152 153 BUG_ON(&inst->alg == alg); 154 155 list_move(&spawn->list, &stack); 156 157 if (&inst->alg == nalg) 158 break; 159 160 spawn->alg = NULL; 161 spawns = &inst->alg.cra_users; 162 } 163 } while ((spawns = crypto_more_spawns(alg, &stack, &top, 164 &secondary_spawns))); 165 166 list_for_each_entry_safe(spawn, n, &secondary_spawns, list) { 167 if (spawn->alg) 168 list_move(&spawn->list, &spawn->alg->cra_users); 169 else 170 crypto_remove_spawn(spawn, list); 171 } 172 } 173 EXPORT_SYMBOL_GPL(crypto_remove_spawns); 174 175 static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg) 176 { 177 struct crypto_alg *q; 178 struct crypto_larval *larval; 179 int ret = -EAGAIN; 180 181 if (crypto_is_dead(alg)) 182 goto err; 183 184 INIT_LIST_HEAD(&alg->cra_users); 185 186 /* No cheating! */ 187 alg->cra_flags &= ~CRYPTO_ALG_TESTED; 188 189 ret = -EEXIST; 190 191 atomic_set(&alg->cra_refcnt, 1); 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 228 out: 229 return larval; 230 231 free_larval: 232 kfree(larval); 233 err: 234 larval = ERR_PTR(ret); 235 goto out; 236 } 237 238 void 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 259 found: 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 307 complete: 308 complete_all(&test->completion); 309 310 unlock: 311 up_write(&crypto_alg_sem); 312 313 crypto_remove_final(&list); 314 } 315 EXPORT_SYMBOL_GPL(crypto_alg_tested); 316 317 void 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 } 327 EXPORT_SYMBOL_GPL(crypto_remove_final); 328 329 static 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_interruptible(&larval->completion); 341 WARN_ON(err); 342 343 out: 344 crypto_larval_kill(&larval->alg); 345 } 346 347 int 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 } 366 EXPORT_SYMBOL_GPL(crypto_register_alg); 367 368 static 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 382 int 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 } 401 EXPORT_SYMBOL_GPL(crypto_unregister_alg); 402 403 int 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 415 err: 416 for (--i; i >= 0; --i) 417 crypto_unregister_alg(&algs[i]); 418 419 return ret; 420 } 421 EXPORT_SYMBOL_GPL(crypto_register_algs); 422 423 int 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 } 436 EXPORT_SYMBOL_GPL(crypto_unregister_algs); 437 438 int 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; 455 out: 456 up_write(&crypto_alg_sem); 457 return err; 458 } 459 EXPORT_SYMBOL_GPL(crypto_register_template); 460 461 void 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 } 490 EXPORT_SYMBOL_GPL(crypto_unregister_template); 491 492 static 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 511 struct crypto_template *crypto_lookup_template(const char *name) 512 { 513 return try_then_request_module(__crypto_lookup_template(name), 514 "crypto-%s", name); 515 } 516 EXPORT_SYMBOL_GPL(crypto_lookup_template); 517 518 int 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 goto err; 527 528 inst->alg.cra_module = tmpl->module; 529 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE; 530 531 down_write(&crypto_alg_sem); 532 533 larval = __crypto_register_alg(&inst->alg); 534 if (IS_ERR(larval)) 535 goto unlock; 536 537 hlist_add_head(&inst->list, &tmpl->instances); 538 inst->tmpl = tmpl; 539 540 unlock: 541 up_write(&crypto_alg_sem); 542 543 err = PTR_ERR(larval); 544 if (IS_ERR(larval)) 545 goto err; 546 547 crypto_wait_for_test(larval); 548 err = 0; 549 550 err: 551 return err; 552 } 553 EXPORT_SYMBOL_GPL(crypto_register_instance); 554 555 int crypto_unregister_instance(struct crypto_alg *alg) 556 { 557 int err; 558 struct crypto_instance *inst = (void *)alg; 559 struct crypto_template *tmpl = inst->tmpl; 560 LIST_HEAD(users); 561 562 if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE)) 563 return -EINVAL; 564 565 BUG_ON(atomic_read(&alg->cra_refcnt) != 1); 566 567 down_write(&crypto_alg_sem); 568 569 hlist_del_init(&inst->list); 570 err = crypto_remove_alg(alg, &users); 571 572 up_write(&crypto_alg_sem); 573 574 if (err) 575 return err; 576 577 tmpl->free(inst); 578 crypto_remove_final(&users); 579 580 return 0; 581 } 582 EXPORT_SYMBOL_GPL(crypto_unregister_instance); 583 584 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, 585 struct crypto_instance *inst, u32 mask) 586 { 587 int err = -EAGAIN; 588 589 spawn->inst = inst; 590 spawn->mask = mask; 591 592 down_write(&crypto_alg_sem); 593 if (!crypto_is_moribund(alg)) { 594 list_add(&spawn->list, &alg->cra_users); 595 spawn->alg = alg; 596 err = 0; 597 } 598 up_write(&crypto_alg_sem); 599 600 return err; 601 } 602 EXPORT_SYMBOL_GPL(crypto_init_spawn); 603 604 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, 605 struct crypto_instance *inst, 606 const struct crypto_type *frontend) 607 { 608 int err = -EINVAL; 609 610 if ((alg->cra_flags ^ frontend->type) & frontend->maskset) 611 goto out; 612 613 spawn->frontend = frontend; 614 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); 615 616 out: 617 return err; 618 } 619 EXPORT_SYMBOL_GPL(crypto_init_spawn2); 620 621 void crypto_drop_spawn(struct crypto_spawn *spawn) 622 { 623 if (!spawn->alg) 624 return; 625 626 down_write(&crypto_alg_sem); 627 list_del(&spawn->list); 628 up_write(&crypto_alg_sem); 629 } 630 EXPORT_SYMBOL_GPL(crypto_drop_spawn); 631 632 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn) 633 { 634 struct crypto_alg *alg; 635 struct crypto_alg *alg2; 636 637 down_read(&crypto_alg_sem); 638 alg = spawn->alg; 639 alg2 = alg; 640 if (alg2) 641 alg2 = crypto_mod_get(alg2); 642 up_read(&crypto_alg_sem); 643 644 if (!alg2) { 645 if (alg) 646 crypto_shoot_alg(alg); 647 return ERR_PTR(-EAGAIN); 648 } 649 650 return alg; 651 } 652 653 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type, 654 u32 mask) 655 { 656 struct crypto_alg *alg; 657 struct crypto_tfm *tfm; 658 659 alg = crypto_spawn_alg(spawn); 660 if (IS_ERR(alg)) 661 return ERR_CAST(alg); 662 663 tfm = ERR_PTR(-EINVAL); 664 if (unlikely((alg->cra_flags ^ type) & mask)) 665 goto out_put_alg; 666 667 tfm = __crypto_alloc_tfm(alg, type, mask); 668 if (IS_ERR(tfm)) 669 goto out_put_alg; 670 671 return tfm; 672 673 out_put_alg: 674 crypto_mod_put(alg); 675 return tfm; 676 } 677 EXPORT_SYMBOL_GPL(crypto_spawn_tfm); 678 679 void *crypto_spawn_tfm2(struct crypto_spawn *spawn) 680 { 681 struct crypto_alg *alg; 682 struct crypto_tfm *tfm; 683 684 alg = crypto_spawn_alg(spawn); 685 if (IS_ERR(alg)) 686 return ERR_CAST(alg); 687 688 tfm = crypto_create_tfm(alg, spawn->frontend); 689 if (IS_ERR(tfm)) 690 goto out_put_alg; 691 692 return tfm; 693 694 out_put_alg: 695 crypto_mod_put(alg); 696 return tfm; 697 } 698 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2); 699 700 int crypto_register_notifier(struct notifier_block *nb) 701 { 702 return blocking_notifier_chain_register(&crypto_chain, nb); 703 } 704 EXPORT_SYMBOL_GPL(crypto_register_notifier); 705 706 int crypto_unregister_notifier(struct notifier_block *nb) 707 { 708 return blocking_notifier_chain_unregister(&crypto_chain, nb); 709 } 710 EXPORT_SYMBOL_GPL(crypto_unregister_notifier); 711 712 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb) 713 { 714 struct rtattr *rta = tb[0]; 715 struct crypto_attr_type *algt; 716 717 if (!rta) 718 return ERR_PTR(-ENOENT); 719 if (RTA_PAYLOAD(rta) < sizeof(*algt)) 720 return ERR_PTR(-EINVAL); 721 if (rta->rta_type != CRYPTOA_TYPE) 722 return ERR_PTR(-EINVAL); 723 724 algt = RTA_DATA(rta); 725 726 return algt; 727 } 728 EXPORT_SYMBOL_GPL(crypto_get_attr_type); 729 730 int crypto_check_attr_type(struct rtattr **tb, u32 type) 731 { 732 struct crypto_attr_type *algt; 733 734 algt = crypto_get_attr_type(tb); 735 if (IS_ERR(algt)) 736 return PTR_ERR(algt); 737 738 if ((algt->type ^ type) & algt->mask) 739 return -EINVAL; 740 741 return 0; 742 } 743 EXPORT_SYMBOL_GPL(crypto_check_attr_type); 744 745 const char *crypto_attr_alg_name(struct rtattr *rta) 746 { 747 struct crypto_attr_alg *alga; 748 749 if (!rta) 750 return ERR_PTR(-ENOENT); 751 if (RTA_PAYLOAD(rta) < sizeof(*alga)) 752 return ERR_PTR(-EINVAL); 753 if (rta->rta_type != CRYPTOA_ALG) 754 return ERR_PTR(-EINVAL); 755 756 alga = RTA_DATA(rta); 757 alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0; 758 759 return alga->name; 760 } 761 EXPORT_SYMBOL_GPL(crypto_attr_alg_name); 762 763 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta, 764 const struct crypto_type *frontend, 765 u32 type, u32 mask) 766 { 767 const char *name; 768 769 name = crypto_attr_alg_name(rta); 770 if (IS_ERR(name)) 771 return ERR_CAST(name); 772 773 return crypto_find_alg(name, frontend, type, mask); 774 } 775 EXPORT_SYMBOL_GPL(crypto_attr_alg2); 776 777 int crypto_attr_u32(struct rtattr *rta, u32 *num) 778 { 779 struct crypto_attr_u32 *nu32; 780 781 if (!rta) 782 return -ENOENT; 783 if (RTA_PAYLOAD(rta) < sizeof(*nu32)) 784 return -EINVAL; 785 if (rta->rta_type != CRYPTOA_U32) 786 return -EINVAL; 787 788 nu32 = RTA_DATA(rta); 789 *num = nu32->num; 790 791 return 0; 792 } 793 EXPORT_SYMBOL_GPL(crypto_attr_u32); 794 795 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, 796 unsigned int head) 797 { 798 struct crypto_instance *inst; 799 char *p; 800 int err; 801 802 p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn), 803 GFP_KERNEL); 804 if (!p) 805 return ERR_PTR(-ENOMEM); 806 807 inst = (void *)(p + head); 808 809 err = -ENAMETOOLONG; 810 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, 811 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) 812 goto err_free_inst; 813 814 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", 815 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) 816 goto err_free_inst; 817 818 return p; 819 820 err_free_inst: 821 kfree(p); 822 return ERR_PTR(err); 823 } 824 EXPORT_SYMBOL_GPL(crypto_alloc_instance2); 825 826 struct crypto_instance *crypto_alloc_instance(const char *name, 827 struct crypto_alg *alg) 828 { 829 struct crypto_instance *inst; 830 struct crypto_spawn *spawn; 831 int err; 832 833 inst = crypto_alloc_instance2(name, alg, 0); 834 if (IS_ERR(inst)) 835 goto out; 836 837 spawn = crypto_instance_ctx(inst); 838 err = crypto_init_spawn(spawn, alg, inst, 839 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC); 840 841 if (err) 842 goto err_free_inst; 843 844 return inst; 845 846 err_free_inst: 847 kfree(inst); 848 inst = ERR_PTR(err); 849 850 out: 851 return inst; 852 } 853 EXPORT_SYMBOL_GPL(crypto_alloc_instance); 854 855 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen) 856 { 857 INIT_LIST_HEAD(&queue->list); 858 queue->backlog = &queue->list; 859 queue->qlen = 0; 860 queue->max_qlen = max_qlen; 861 } 862 EXPORT_SYMBOL_GPL(crypto_init_queue); 863 864 int crypto_enqueue_request(struct crypto_queue *queue, 865 struct crypto_async_request *request) 866 { 867 int err = -EINPROGRESS; 868 869 if (unlikely(queue->qlen >= queue->max_qlen)) { 870 err = -EBUSY; 871 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) 872 goto out; 873 if (queue->backlog == &queue->list) 874 queue->backlog = &request->list; 875 } 876 877 queue->qlen++; 878 list_add_tail(&request->list, &queue->list); 879 880 out: 881 return err; 882 } 883 EXPORT_SYMBOL_GPL(crypto_enqueue_request); 884 885 void *__crypto_dequeue_request(struct crypto_queue *queue, unsigned int offset) 886 { 887 struct list_head *request; 888 889 if (unlikely(!queue->qlen)) 890 return NULL; 891 892 queue->qlen--; 893 894 if (queue->backlog != &queue->list) 895 queue->backlog = queue->backlog->next; 896 897 request = queue->list.next; 898 list_del(request); 899 900 return (char *)list_entry(request, struct crypto_async_request, list) - 901 offset; 902 } 903 EXPORT_SYMBOL_GPL(__crypto_dequeue_request); 904 905 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue) 906 { 907 return __crypto_dequeue_request(queue, 0); 908 } 909 EXPORT_SYMBOL_GPL(crypto_dequeue_request); 910 911 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm) 912 { 913 struct crypto_async_request *req; 914 915 list_for_each_entry(req, &queue->list, list) { 916 if (req->tfm == tfm) 917 return 1; 918 } 919 920 return 0; 921 } 922 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue); 923 924 static inline void crypto_inc_byte(u8 *a, unsigned int size) 925 { 926 u8 *b = (a + size); 927 u8 c; 928 929 for (; size; size--) { 930 c = *--b + 1; 931 *b = c; 932 if (c) 933 break; 934 } 935 } 936 937 void crypto_inc(u8 *a, unsigned int size) 938 { 939 __be32 *b = (__be32 *)(a + size); 940 u32 c; 941 942 for (; size >= 4; size -= 4) { 943 c = be32_to_cpu(*--b) + 1; 944 *b = cpu_to_be32(c); 945 if (c) 946 return; 947 } 948 949 crypto_inc_byte(a, size); 950 } 951 EXPORT_SYMBOL_GPL(crypto_inc); 952 953 static inline void crypto_xor_byte(u8 *a, const u8 *b, unsigned int size) 954 { 955 for (; size; size--) 956 *a++ ^= *b++; 957 } 958 959 void crypto_xor(u8 *dst, const u8 *src, unsigned int size) 960 { 961 u32 *a = (u32 *)dst; 962 u32 *b = (u32 *)src; 963 964 for (; size >= 4; size -= 4) 965 *a++ ^= *b++; 966 967 crypto_xor_byte((u8 *)a, (u8 *)b, size); 968 } 969 EXPORT_SYMBOL_GPL(crypto_xor); 970 971 static int __init crypto_algapi_init(void) 972 { 973 crypto_init_proc(); 974 return 0; 975 } 976 977 static void __exit crypto_algapi_exit(void) 978 { 979 crypto_exit_proc(); 980 } 981 982 module_init(crypto_algapi_init); 983 module_exit(crypto_algapi_exit); 984 985 MODULE_LICENSE("GPL"); 986 MODULE_DESCRIPTION("Cryptographic algorithms API"); 987