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 BUG_ON(err); 477 } 478 479 crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl); 480 481 up_write(&crypto_alg_sem); 482 483 hlist_for_each_entry_safe(inst, n, list, list) { 484 BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1); 485 tmpl->free(inst); 486 } 487 crypto_remove_final(&users); 488 } 489 EXPORT_SYMBOL_GPL(crypto_unregister_template); 490 491 static struct crypto_template *__crypto_lookup_template(const char *name) 492 { 493 struct crypto_template *q, *tmpl = NULL; 494 495 down_read(&crypto_alg_sem); 496 list_for_each_entry(q, &crypto_template_list, list) { 497 if (strcmp(q->name, name)) 498 continue; 499 if (unlikely(!crypto_tmpl_get(q))) 500 continue; 501 502 tmpl = q; 503 break; 504 } 505 up_read(&crypto_alg_sem); 506 507 return tmpl; 508 } 509 510 struct crypto_template *crypto_lookup_template(const char *name) 511 { 512 return try_then_request_module(__crypto_lookup_template(name), "%s", 513 name); 514 } 515 EXPORT_SYMBOL_GPL(crypto_lookup_template); 516 517 int crypto_register_instance(struct crypto_template *tmpl, 518 struct crypto_instance *inst) 519 { 520 struct crypto_larval *larval; 521 int err; 522 523 err = crypto_check_alg(&inst->alg); 524 if (err) 525 goto err; 526 527 inst->alg.cra_module = tmpl->module; 528 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE; 529 530 down_write(&crypto_alg_sem); 531 532 larval = __crypto_register_alg(&inst->alg); 533 if (IS_ERR(larval)) 534 goto unlock; 535 536 hlist_add_head(&inst->list, &tmpl->instances); 537 inst->tmpl = tmpl; 538 539 unlock: 540 up_write(&crypto_alg_sem); 541 542 err = PTR_ERR(larval); 543 if (IS_ERR(larval)) 544 goto err; 545 546 crypto_wait_for_test(larval); 547 err = 0; 548 549 err: 550 return err; 551 } 552 EXPORT_SYMBOL_GPL(crypto_register_instance); 553 554 int crypto_unregister_instance(struct crypto_alg *alg) 555 { 556 int err; 557 struct crypto_instance *inst = (void *)alg; 558 struct crypto_template *tmpl = inst->tmpl; 559 LIST_HEAD(users); 560 561 if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE)) 562 return -EINVAL; 563 564 BUG_ON(atomic_read(&alg->cra_refcnt) != 1); 565 566 down_write(&crypto_alg_sem); 567 568 hlist_del_init(&inst->list); 569 err = crypto_remove_alg(alg, &users); 570 571 up_write(&crypto_alg_sem); 572 573 if (err) 574 return err; 575 576 tmpl->free(inst); 577 crypto_remove_final(&users); 578 579 return 0; 580 } 581 EXPORT_SYMBOL_GPL(crypto_unregister_instance); 582 583 int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg, 584 struct crypto_instance *inst, u32 mask) 585 { 586 int err = -EAGAIN; 587 588 spawn->inst = inst; 589 spawn->mask = mask; 590 591 down_write(&crypto_alg_sem); 592 if (!crypto_is_moribund(alg)) { 593 list_add(&spawn->list, &alg->cra_users); 594 spawn->alg = alg; 595 err = 0; 596 } 597 up_write(&crypto_alg_sem); 598 599 return err; 600 } 601 EXPORT_SYMBOL_GPL(crypto_init_spawn); 602 603 int crypto_init_spawn2(struct crypto_spawn *spawn, struct crypto_alg *alg, 604 struct crypto_instance *inst, 605 const struct crypto_type *frontend) 606 { 607 int err = -EINVAL; 608 609 if ((alg->cra_flags ^ frontend->type) & frontend->maskset) 610 goto out; 611 612 spawn->frontend = frontend; 613 err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); 614 615 out: 616 return err; 617 } 618 EXPORT_SYMBOL_GPL(crypto_init_spawn2); 619 620 void crypto_drop_spawn(struct crypto_spawn *spawn) 621 { 622 if (!spawn->alg) 623 return; 624 625 down_write(&crypto_alg_sem); 626 list_del(&spawn->list); 627 up_write(&crypto_alg_sem); 628 } 629 EXPORT_SYMBOL_GPL(crypto_drop_spawn); 630 631 static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn) 632 { 633 struct crypto_alg *alg; 634 struct crypto_alg *alg2; 635 636 down_read(&crypto_alg_sem); 637 alg = spawn->alg; 638 alg2 = alg; 639 if (alg2) 640 alg2 = crypto_mod_get(alg2); 641 up_read(&crypto_alg_sem); 642 643 if (!alg2) { 644 if (alg) 645 crypto_shoot_alg(alg); 646 return ERR_PTR(-EAGAIN); 647 } 648 649 return alg; 650 } 651 652 struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type, 653 u32 mask) 654 { 655 struct crypto_alg *alg; 656 struct crypto_tfm *tfm; 657 658 alg = crypto_spawn_alg(spawn); 659 if (IS_ERR(alg)) 660 return ERR_CAST(alg); 661 662 tfm = ERR_PTR(-EINVAL); 663 if (unlikely((alg->cra_flags ^ type) & mask)) 664 goto out_put_alg; 665 666 tfm = __crypto_alloc_tfm(alg, type, mask); 667 if (IS_ERR(tfm)) 668 goto out_put_alg; 669 670 return tfm; 671 672 out_put_alg: 673 crypto_mod_put(alg); 674 return tfm; 675 } 676 EXPORT_SYMBOL_GPL(crypto_spawn_tfm); 677 678 void *crypto_spawn_tfm2(struct crypto_spawn *spawn) 679 { 680 struct crypto_alg *alg; 681 struct crypto_tfm *tfm; 682 683 alg = crypto_spawn_alg(spawn); 684 if (IS_ERR(alg)) 685 return ERR_CAST(alg); 686 687 tfm = crypto_create_tfm(alg, spawn->frontend); 688 if (IS_ERR(tfm)) 689 goto out_put_alg; 690 691 return tfm; 692 693 out_put_alg: 694 crypto_mod_put(alg); 695 return tfm; 696 } 697 EXPORT_SYMBOL_GPL(crypto_spawn_tfm2); 698 699 int crypto_register_notifier(struct notifier_block *nb) 700 { 701 return blocking_notifier_chain_register(&crypto_chain, nb); 702 } 703 EXPORT_SYMBOL_GPL(crypto_register_notifier); 704 705 int crypto_unregister_notifier(struct notifier_block *nb) 706 { 707 return blocking_notifier_chain_unregister(&crypto_chain, nb); 708 } 709 EXPORT_SYMBOL_GPL(crypto_unregister_notifier); 710 711 struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb) 712 { 713 struct rtattr *rta = tb[0]; 714 struct crypto_attr_type *algt; 715 716 if (!rta) 717 return ERR_PTR(-ENOENT); 718 if (RTA_PAYLOAD(rta) < sizeof(*algt)) 719 return ERR_PTR(-EINVAL); 720 if (rta->rta_type != CRYPTOA_TYPE) 721 return ERR_PTR(-EINVAL); 722 723 algt = RTA_DATA(rta); 724 725 return algt; 726 } 727 EXPORT_SYMBOL_GPL(crypto_get_attr_type); 728 729 int crypto_check_attr_type(struct rtattr **tb, u32 type) 730 { 731 struct crypto_attr_type *algt; 732 733 algt = crypto_get_attr_type(tb); 734 if (IS_ERR(algt)) 735 return PTR_ERR(algt); 736 737 if ((algt->type ^ type) & algt->mask) 738 return -EINVAL; 739 740 return 0; 741 } 742 EXPORT_SYMBOL_GPL(crypto_check_attr_type); 743 744 const char *crypto_attr_alg_name(struct rtattr *rta) 745 { 746 struct crypto_attr_alg *alga; 747 748 if (!rta) 749 return ERR_PTR(-ENOENT); 750 if (RTA_PAYLOAD(rta) < sizeof(*alga)) 751 return ERR_PTR(-EINVAL); 752 if (rta->rta_type != CRYPTOA_ALG) 753 return ERR_PTR(-EINVAL); 754 755 alga = RTA_DATA(rta); 756 alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0; 757 758 return alga->name; 759 } 760 EXPORT_SYMBOL_GPL(crypto_attr_alg_name); 761 762 struct crypto_alg *crypto_attr_alg2(struct rtattr *rta, 763 const struct crypto_type *frontend, 764 u32 type, u32 mask) 765 { 766 const char *name; 767 768 name = crypto_attr_alg_name(rta); 769 if (IS_ERR(name)) 770 return ERR_CAST(name); 771 772 return crypto_find_alg(name, frontend, type, mask); 773 } 774 EXPORT_SYMBOL_GPL(crypto_attr_alg2); 775 776 int crypto_attr_u32(struct rtattr *rta, u32 *num) 777 { 778 struct crypto_attr_u32 *nu32; 779 780 if (!rta) 781 return -ENOENT; 782 if (RTA_PAYLOAD(rta) < sizeof(*nu32)) 783 return -EINVAL; 784 if (rta->rta_type != CRYPTOA_U32) 785 return -EINVAL; 786 787 nu32 = RTA_DATA(rta); 788 *num = nu32->num; 789 790 return 0; 791 } 792 EXPORT_SYMBOL_GPL(crypto_attr_u32); 793 794 void *crypto_alloc_instance2(const char *name, struct crypto_alg *alg, 795 unsigned int head) 796 { 797 struct crypto_instance *inst; 798 char *p; 799 int err; 800 801 p = kzalloc(head + sizeof(*inst) + sizeof(struct crypto_spawn), 802 GFP_KERNEL); 803 if (!p) 804 return ERR_PTR(-ENOMEM); 805 806 inst = (void *)(p + head); 807 808 err = -ENAMETOOLONG; 809 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, 810 alg->cra_name) >= CRYPTO_MAX_ALG_NAME) 811 goto err_free_inst; 812 813 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", 814 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) 815 goto err_free_inst; 816 817 return p; 818 819 err_free_inst: 820 kfree(p); 821 return ERR_PTR(err); 822 } 823 EXPORT_SYMBOL_GPL(crypto_alloc_instance2); 824 825 struct crypto_instance *crypto_alloc_instance(const char *name, 826 struct crypto_alg *alg) 827 { 828 struct crypto_instance *inst; 829 struct crypto_spawn *spawn; 830 int err; 831 832 inst = crypto_alloc_instance2(name, alg, 0); 833 if (IS_ERR(inst)) 834 goto out; 835 836 spawn = crypto_instance_ctx(inst); 837 err = crypto_init_spawn(spawn, alg, inst, 838 CRYPTO_ALG_TYPE_MASK | CRYPTO_ALG_ASYNC); 839 840 if (err) 841 goto err_free_inst; 842 843 return inst; 844 845 err_free_inst: 846 kfree(inst); 847 inst = ERR_PTR(err); 848 849 out: 850 return inst; 851 } 852 EXPORT_SYMBOL_GPL(crypto_alloc_instance); 853 854 void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen) 855 { 856 INIT_LIST_HEAD(&queue->list); 857 queue->backlog = &queue->list; 858 queue->qlen = 0; 859 queue->max_qlen = max_qlen; 860 } 861 EXPORT_SYMBOL_GPL(crypto_init_queue); 862 863 int crypto_enqueue_request(struct crypto_queue *queue, 864 struct crypto_async_request *request) 865 { 866 int err = -EINPROGRESS; 867 868 if (unlikely(queue->qlen >= queue->max_qlen)) { 869 err = -EBUSY; 870 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) 871 goto out; 872 if (queue->backlog == &queue->list) 873 queue->backlog = &request->list; 874 } 875 876 queue->qlen++; 877 list_add_tail(&request->list, &queue->list); 878 879 out: 880 return err; 881 } 882 EXPORT_SYMBOL_GPL(crypto_enqueue_request); 883 884 void *__crypto_dequeue_request(struct crypto_queue *queue, unsigned int offset) 885 { 886 struct list_head *request; 887 888 if (unlikely(!queue->qlen)) 889 return NULL; 890 891 queue->qlen--; 892 893 if (queue->backlog != &queue->list) 894 queue->backlog = queue->backlog->next; 895 896 request = queue->list.next; 897 list_del(request); 898 899 return (char *)list_entry(request, struct crypto_async_request, list) - 900 offset; 901 } 902 EXPORT_SYMBOL_GPL(__crypto_dequeue_request); 903 904 struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue) 905 { 906 return __crypto_dequeue_request(queue, 0); 907 } 908 EXPORT_SYMBOL_GPL(crypto_dequeue_request); 909 910 int crypto_tfm_in_queue(struct crypto_queue *queue, struct crypto_tfm *tfm) 911 { 912 struct crypto_async_request *req; 913 914 list_for_each_entry(req, &queue->list, list) { 915 if (req->tfm == tfm) 916 return 1; 917 } 918 919 return 0; 920 } 921 EXPORT_SYMBOL_GPL(crypto_tfm_in_queue); 922 923 static inline void crypto_inc_byte(u8 *a, unsigned int size) 924 { 925 u8 *b = (a + size); 926 u8 c; 927 928 for (; size; size--) { 929 c = *--b + 1; 930 *b = c; 931 if (c) 932 break; 933 } 934 } 935 936 void crypto_inc(u8 *a, unsigned int size) 937 { 938 __be32 *b = (__be32 *)(a + size); 939 u32 c; 940 941 for (; size >= 4; size -= 4) { 942 c = be32_to_cpu(*--b) + 1; 943 *b = cpu_to_be32(c); 944 if (c) 945 return; 946 } 947 948 crypto_inc_byte(a, size); 949 } 950 EXPORT_SYMBOL_GPL(crypto_inc); 951 952 static inline void crypto_xor_byte(u8 *a, const u8 *b, unsigned int size) 953 { 954 for (; size; size--) 955 *a++ ^= *b++; 956 } 957 958 void crypto_xor(u8 *dst, const u8 *src, unsigned int size) 959 { 960 u32 *a = (u32 *)dst; 961 u32 *b = (u32 *)src; 962 963 for (; size >= 4; size -= 4) 964 *a++ ^= *b++; 965 966 crypto_xor_byte((u8 *)a, (u8 *)b, size); 967 } 968 EXPORT_SYMBOL_GPL(crypto_xor); 969 970 static int __init crypto_algapi_init(void) 971 { 972 crypto_init_proc(); 973 return 0; 974 } 975 976 static void __exit crypto_algapi_exit(void) 977 { 978 crypto_exit_proc(); 979 } 980 981 module_init(crypto_algapi_init); 982 module_exit(crypto_algapi_exit); 983 984 MODULE_LICENSE("GPL"); 985 MODULE_DESCRIPTION("Cryptographic algorithms API"); 986