1082 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Cryptographic API for algorithms (i.e., low-level API).4 *5 * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>6 */7 8#include <crypto/algapi.h>9#include <crypto/internal/simd.h>10#include <linux/err.h>11#include <linux/errno.h>12#include <linux/fips.h>13#include <linux/init.h>14#include <linux/kernel.h>15#include <linux/list.h>16#include <linux/module.h>17#include <linux/rtnetlink.h>18#include <linux/slab.h>19#include <linux/string.h>20#include <linux/workqueue.h>21 22#include "internal.h"23 24static LIST_HEAD(crypto_template_list);25 26#ifdef CONFIG_CRYPTO_MANAGER_EXTRA_TESTS27DEFINE_PER_CPU(bool, crypto_simd_disabled_for_test);28EXPORT_PER_CPU_SYMBOL_GPL(crypto_simd_disabled_for_test);29#endif30 31static inline void crypto_check_module_sig(struct module *mod)32{33 if (fips_enabled && mod && !module_sig_ok(mod))34 panic("Module %s signature verification failed in FIPS mode\n",35 module_name(mod));36}37 38static int crypto_check_alg(struct crypto_alg *alg)39{40 crypto_check_module_sig(alg->cra_module);41 42 if (!alg->cra_name[0] || !alg->cra_driver_name[0])43 return -EINVAL;44 45 if (alg->cra_alignmask & (alg->cra_alignmask + 1))46 return -EINVAL;47 48 /* General maximums for all algs. */49 if (alg->cra_alignmask > MAX_ALGAPI_ALIGNMASK)50 return -EINVAL;51 52 if (alg->cra_blocksize > MAX_ALGAPI_BLOCKSIZE)53 return -EINVAL;54 55 /* Lower maximums for specific alg types. */56 if (!alg->cra_type && (alg->cra_flags & CRYPTO_ALG_TYPE_MASK) ==57 CRYPTO_ALG_TYPE_CIPHER) {58 if (alg->cra_alignmask > MAX_CIPHER_ALIGNMASK)59 return -EINVAL;60 61 if (alg->cra_blocksize > MAX_CIPHER_BLOCKSIZE)62 return -EINVAL;63 }64 65 if (alg->cra_priority < 0)66 return -EINVAL;67 68 refcount_set(&alg->cra_refcnt, 1);69 70 return 0;71}72 73static void crypto_free_instance(struct crypto_instance *inst)74{75 inst->alg.cra_type->free(inst);76}77 78static void crypto_destroy_instance_workfn(struct work_struct *w)79{80 struct crypto_instance *inst = container_of(w, struct crypto_instance,81 free_work);82 struct crypto_template *tmpl = inst->tmpl;83 84 crypto_free_instance(inst);85 crypto_tmpl_put(tmpl);86}87 88static void crypto_destroy_instance(struct crypto_alg *alg)89{90 struct crypto_instance *inst = container_of(alg,91 struct crypto_instance,92 alg);93 94 INIT_WORK(&inst->free_work, crypto_destroy_instance_workfn);95 schedule_work(&inst->free_work);96}97 98/*99 * This function adds a spawn to the list secondary_spawns which100 * will be used at the end of crypto_remove_spawns to unregister101 * instances, unless the spawn happens to be one that is depended102 * on by the new algorithm (nalg in crypto_remove_spawns).103 *104 * This function is also responsible for resurrecting any algorithms105 * in the dependency chain of nalg by unsetting n->dead.106 */107static struct list_head *crypto_more_spawns(struct crypto_alg *alg,108 struct list_head *stack,109 struct list_head *top,110 struct list_head *secondary_spawns)111{112 struct crypto_spawn *spawn, *n;113 114 spawn = list_first_entry_or_null(stack, struct crypto_spawn, list);115 if (!spawn)116 return NULL;117 118 n = list_prev_entry(spawn, list);119 list_move(&spawn->list, secondary_spawns);120 121 if (list_is_last(&n->list, stack))122 return top;123 124 n = list_next_entry(n, list);125 if (!spawn->dead)126 n->dead = false;127 128 return &n->inst->alg.cra_users;129}130 131static void crypto_remove_instance(struct crypto_instance *inst,132 struct list_head *list)133{134 struct crypto_template *tmpl = inst->tmpl;135 136 if (crypto_is_dead(&inst->alg))137 return;138 139 inst->alg.cra_flags |= CRYPTO_ALG_DEAD;140 141 if (!tmpl || !crypto_tmpl_get(tmpl))142 return;143 144 list_move(&inst->alg.cra_list, list);145 hlist_del(&inst->list);146 inst->alg.cra_destroy = crypto_destroy_instance;147 148 BUG_ON(!list_empty(&inst->alg.cra_users));149}150 151/*152 * Given an algorithm alg, remove all algorithms that depend on it153 * through spawns. If nalg is not null, then exempt any algorithms154 * that is depended on by nalg. This is useful when nalg itself155 * depends on alg.156 */157void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,158 struct crypto_alg *nalg)159{160 u32 new_type = (nalg ?: alg)->cra_flags;161 struct crypto_spawn *spawn, *n;162 LIST_HEAD(secondary_spawns);163 struct list_head *spawns;164 LIST_HEAD(stack);165 LIST_HEAD(top);166 167 spawns = &alg->cra_users;168 list_for_each_entry_safe(spawn, n, spawns, list) {169 if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)170 continue;171 172 list_move(&spawn->list, &top);173 }174 175 /*176 * Perform a depth-first walk starting from alg through177 * the cra_users tree. The list stack records the path178 * from alg to the current spawn.179 */180 spawns = ⊤181 do {182 while (!list_empty(spawns)) {183 struct crypto_instance *inst;184 185 spawn = list_first_entry(spawns, struct crypto_spawn,186 list);187 inst = spawn->inst;188 189 list_move(&spawn->list, &stack);190 spawn->dead = !spawn->registered || &inst->alg != nalg;191 192 if (!spawn->registered)193 break;194 195 BUG_ON(&inst->alg == alg);196 197 if (&inst->alg == nalg)198 break;199 200 spawns = &inst->alg.cra_users;201 202 /*203 * Even if spawn->registered is true, the204 * instance itself may still be unregistered.205 * This is because it may have failed during206 * registration. Therefore we still need to207 * make the following test.208 *209 * We may encounter an unregistered instance here, since210 * an instance's spawns are set up prior to the instance211 * being registered. An unregistered instance will have212 * NULL ->cra_users.next, since ->cra_users isn't213 * properly initialized until registration. But an214 * unregistered instance cannot have any users, so treat215 * it the same as ->cra_users being empty.216 */217 if (spawns->next == NULL)218 break;219 }220 } while ((spawns = crypto_more_spawns(alg, &stack, &top,221 &secondary_spawns)));222 223 /*224 * Remove all instances that are marked as dead. Also225 * complete the resurrection of the others by moving them226 * back to the cra_users list.227 */228 list_for_each_entry_safe(spawn, n, &secondary_spawns, list) {229 if (!spawn->dead)230 list_move(&spawn->list, &spawn->alg->cra_users);231 else if (spawn->registered)232 crypto_remove_instance(spawn->inst, list);233 }234}235EXPORT_SYMBOL_GPL(crypto_remove_spawns);236 237static void crypto_alg_finish_registration(struct crypto_alg *alg,238 struct list_head *algs_to_put)239{240 struct crypto_alg *q;241 242 list_for_each_entry(q, &crypto_alg_list, cra_list) {243 if (q == alg)244 continue;245 246 if (crypto_is_moribund(q))247 continue;248 249 if (crypto_is_larval(q))250 continue;251 252 if (strcmp(alg->cra_name, q->cra_name))253 continue;254 255 if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&256 q->cra_priority > alg->cra_priority)257 continue;258 259 crypto_remove_spawns(q, algs_to_put, alg);260 }261 262 crypto_notify(CRYPTO_MSG_ALG_LOADED, alg);263}264 265static struct crypto_larval *crypto_alloc_test_larval(struct crypto_alg *alg)266{267 struct crypto_larval *larval;268 269 if (!IS_ENABLED(CONFIG_CRYPTO_MANAGER) ||270 IS_ENABLED(CONFIG_CRYPTO_MANAGER_DISABLE_TESTS) ||271 (alg->cra_flags & CRYPTO_ALG_INTERNAL))272 return NULL; /* No self-test needed */273 274 larval = crypto_larval_alloc(alg->cra_name,275 alg->cra_flags | CRYPTO_ALG_TESTED, 0);276 if (IS_ERR(larval))277 return larval;278 279 larval->adult = crypto_mod_get(alg);280 if (!larval->adult) {281 kfree(larval);282 return ERR_PTR(-ENOENT);283 }284 285 refcount_set(&larval->alg.cra_refcnt, 1);286 memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,287 CRYPTO_MAX_ALG_NAME);288 larval->alg.cra_priority = alg->cra_priority;289 290 return larval;291}292 293static struct crypto_larval *294__crypto_register_alg(struct crypto_alg *alg, struct list_head *algs_to_put)295{296 struct crypto_alg *q;297 struct crypto_larval *larval;298 int ret = -EAGAIN;299 300 if (crypto_is_dead(alg))301 goto err;302 303 INIT_LIST_HEAD(&alg->cra_users);304 305 ret = -EEXIST;306 307 list_for_each_entry(q, &crypto_alg_list, cra_list) {308 if (q == alg)309 goto err;310 311 if (crypto_is_moribund(q))312 continue;313 314 if (crypto_is_larval(q)) {315 if (!strcmp(alg->cra_driver_name, q->cra_driver_name))316 goto err;317 continue;318 }319 320 if (!strcmp(q->cra_driver_name, alg->cra_name) ||321 !strcmp(q->cra_driver_name, alg->cra_driver_name) ||322 !strcmp(q->cra_name, alg->cra_driver_name))323 goto err;324 }325 326 larval = crypto_alloc_test_larval(alg);327 if (IS_ERR(larval))328 goto out;329 330 list_add(&alg->cra_list, &crypto_alg_list);331 332 if (larval) {333 /* No cheating! */334 alg->cra_flags &= ~CRYPTO_ALG_TESTED;335 336 list_add(&larval->alg.cra_list, &crypto_alg_list);337 } else {338 alg->cra_flags |= CRYPTO_ALG_TESTED;339 crypto_alg_finish_registration(alg, algs_to_put);340 }341 342out:343 return larval;344 345err:346 larval = ERR_PTR(ret);347 goto out;348}349 350void crypto_alg_tested(const char *name, int err)351{352 struct crypto_larval *test;353 struct crypto_alg *alg;354 struct crypto_alg *q;355 LIST_HEAD(list);356 357 down_write(&crypto_alg_sem);358 list_for_each_entry(q, &crypto_alg_list, cra_list) {359 if (crypto_is_moribund(q) || !crypto_is_larval(q))360 continue;361 362 test = (struct crypto_larval *)q;363 364 if (!strcmp(q->cra_driver_name, name))365 goto found;366 }367 368 pr_err("alg: Unexpected test result for %s: %d\n", name, err);369 up_write(&crypto_alg_sem);370 return;371 372found:373 q->cra_flags |= CRYPTO_ALG_DEAD;374 alg = test->adult;375 376 if (crypto_is_dead(alg))377 goto complete;378 379 if (err == -ECANCELED)380 alg->cra_flags |= CRYPTO_ALG_FIPS_INTERNAL;381 else if (err)382 goto complete;383 else384 alg->cra_flags &= ~CRYPTO_ALG_FIPS_INTERNAL;385 386 alg->cra_flags |= CRYPTO_ALG_TESTED;387 388 crypto_alg_finish_registration(alg, &list);389 390complete:391 list_del_init(&test->alg.cra_list);392 complete_all(&test->completion);393 394 up_write(&crypto_alg_sem);395 396 crypto_alg_put(&test->alg);397 crypto_remove_final(&list);398}399EXPORT_SYMBOL_GPL(crypto_alg_tested);400 401void crypto_remove_final(struct list_head *list)402{403 struct crypto_alg *alg;404 struct crypto_alg *n;405 406 list_for_each_entry_safe(alg, n, list, cra_list) {407 list_del_init(&alg->cra_list);408 crypto_alg_put(alg);409 }410}411EXPORT_SYMBOL_GPL(crypto_remove_final);412 413int crypto_register_alg(struct crypto_alg *alg)414{415 struct crypto_larval *larval;416 LIST_HEAD(algs_to_put);417 int err;418 419 alg->cra_flags &= ~CRYPTO_ALG_DEAD;420 err = crypto_check_alg(alg);421 if (err)422 return err;423 424 down_write(&crypto_alg_sem);425 larval = __crypto_register_alg(alg, &algs_to_put);426 if (!IS_ERR_OR_NULL(larval)) {427 bool test_started = crypto_boot_test_finished();428 429 larval->test_started = test_started;430 if (test_started)431 crypto_schedule_test(larval);432 }433 up_write(&crypto_alg_sem);434 435 if (IS_ERR(larval))436 return PTR_ERR(larval);437 crypto_remove_final(&algs_to_put);438 return 0;439}440EXPORT_SYMBOL_GPL(crypto_register_alg);441 442static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list)443{444 if (unlikely(list_empty(&alg->cra_list)))445 return -ENOENT;446 447 alg->cra_flags |= CRYPTO_ALG_DEAD;448 449 list_del_init(&alg->cra_list);450 crypto_remove_spawns(alg, list, NULL);451 452 return 0;453}454 455void crypto_unregister_alg(struct crypto_alg *alg)456{457 int ret;458 LIST_HEAD(list);459 460 down_write(&crypto_alg_sem);461 ret = crypto_remove_alg(alg, &list);462 up_write(&crypto_alg_sem);463 464 if (WARN(ret, "Algorithm %s is not registered", alg->cra_driver_name))465 return;466 467 if (WARN_ON(refcount_read(&alg->cra_refcnt) != 1))468 return;469 470 if (alg->cra_destroy)471 alg->cra_destroy(alg);472 473 crypto_remove_final(&list);474}475EXPORT_SYMBOL_GPL(crypto_unregister_alg);476 477int crypto_register_algs(struct crypto_alg *algs, int count)478{479 int i, ret;480 481 for (i = 0; i < count; i++) {482 ret = crypto_register_alg(&algs[i]);483 if (ret)484 goto err;485 }486 487 return 0;488 489err:490 for (--i; i >= 0; --i)491 crypto_unregister_alg(&algs[i]);492 493 return ret;494}495EXPORT_SYMBOL_GPL(crypto_register_algs);496 497void crypto_unregister_algs(struct crypto_alg *algs, int count)498{499 int i;500 501 for (i = 0; i < count; i++)502 crypto_unregister_alg(&algs[i]);503}504EXPORT_SYMBOL_GPL(crypto_unregister_algs);505 506int crypto_register_template(struct crypto_template *tmpl)507{508 struct crypto_template *q;509 int err = -EEXIST;510 511 down_write(&crypto_alg_sem);512 513 crypto_check_module_sig(tmpl->module);514 515 list_for_each_entry(q, &crypto_template_list, list) {516 if (q == tmpl)517 goto out;518 }519 520 list_add(&tmpl->list, &crypto_template_list);521 err = 0;522out:523 up_write(&crypto_alg_sem);524 return err;525}526EXPORT_SYMBOL_GPL(crypto_register_template);527 528int crypto_register_templates(struct crypto_template *tmpls, int count)529{530 int i, err;531 532 for (i = 0; i < count; i++) {533 err = crypto_register_template(&tmpls[i]);534 if (err)535 goto out;536 }537 return 0;538 539out:540 for (--i; i >= 0; --i)541 crypto_unregister_template(&tmpls[i]);542 return err;543}544EXPORT_SYMBOL_GPL(crypto_register_templates);545 546void crypto_unregister_template(struct crypto_template *tmpl)547{548 struct crypto_instance *inst;549 struct hlist_node *n;550 struct hlist_head *list;551 LIST_HEAD(users);552 553 down_write(&crypto_alg_sem);554 555 BUG_ON(list_empty(&tmpl->list));556 list_del_init(&tmpl->list);557 558 list = &tmpl->instances;559 hlist_for_each_entry(inst, list, list) {560 int err = crypto_remove_alg(&inst->alg, &users);561 562 BUG_ON(err);563 }564 565 up_write(&crypto_alg_sem);566 567 hlist_for_each_entry_safe(inst, n, list, list) {568 BUG_ON(refcount_read(&inst->alg.cra_refcnt) != 1);569 crypto_free_instance(inst);570 }571 crypto_remove_final(&users);572}573EXPORT_SYMBOL_GPL(crypto_unregister_template);574 575void crypto_unregister_templates(struct crypto_template *tmpls, int count)576{577 int i;578 579 for (i = count - 1; i >= 0; --i)580 crypto_unregister_template(&tmpls[i]);581}582EXPORT_SYMBOL_GPL(crypto_unregister_templates);583 584static struct crypto_template *__crypto_lookup_template(const char *name)585{586 struct crypto_template *q, *tmpl = NULL;587 588 down_read(&crypto_alg_sem);589 list_for_each_entry(q, &crypto_template_list, list) {590 if (strcmp(q->name, name))591 continue;592 if (unlikely(!crypto_tmpl_get(q)))593 continue;594 595 tmpl = q;596 break;597 }598 up_read(&crypto_alg_sem);599 600 return tmpl;601}602 603struct crypto_template *crypto_lookup_template(const char *name)604{605 return try_then_request_module(__crypto_lookup_template(name),606 "crypto-%s", name);607}608EXPORT_SYMBOL_GPL(crypto_lookup_template);609 610int crypto_register_instance(struct crypto_template *tmpl,611 struct crypto_instance *inst)612{613 struct crypto_larval *larval;614 struct crypto_spawn *spawn;615 u32 fips_internal = 0;616 LIST_HEAD(algs_to_put);617 int err;618 619 err = crypto_check_alg(&inst->alg);620 if (err)621 return err;622 623 inst->alg.cra_module = tmpl->module;624 inst->alg.cra_flags |= CRYPTO_ALG_INSTANCE;625 626 down_write(&crypto_alg_sem);627 628 larval = ERR_PTR(-EAGAIN);629 for (spawn = inst->spawns; spawn;) {630 struct crypto_spawn *next;631 632 if (spawn->dead)633 goto unlock;634 635 next = spawn->next;636 spawn->inst = inst;637 spawn->registered = true;638 639 fips_internal |= spawn->alg->cra_flags;640 641 crypto_mod_put(spawn->alg);642 643 spawn = next;644 }645 646 inst->alg.cra_flags |= (fips_internal & CRYPTO_ALG_FIPS_INTERNAL);647 648 larval = __crypto_register_alg(&inst->alg, &algs_to_put);649 if (IS_ERR(larval))650 goto unlock;651 else if (larval) {652 larval->test_started = true;653 crypto_schedule_test(larval);654 }655 656 hlist_add_head(&inst->list, &tmpl->instances);657 inst->tmpl = tmpl;658 659unlock:660 up_write(&crypto_alg_sem);661 662 if (IS_ERR(larval))663 return PTR_ERR(larval);664 crypto_remove_final(&algs_to_put);665 return 0;666}667EXPORT_SYMBOL_GPL(crypto_register_instance);668 669void crypto_unregister_instance(struct crypto_instance *inst)670{671 LIST_HEAD(list);672 673 down_write(&crypto_alg_sem);674 675 crypto_remove_spawns(&inst->alg, &list, NULL);676 crypto_remove_instance(inst, &list);677 678 up_write(&crypto_alg_sem);679 680 crypto_remove_final(&list);681}682EXPORT_SYMBOL_GPL(crypto_unregister_instance);683 684int crypto_grab_spawn(struct crypto_spawn *spawn, struct crypto_instance *inst,685 const char *name, u32 type, u32 mask)686{687 struct crypto_alg *alg;688 int err = -EAGAIN;689 690 if (WARN_ON_ONCE(inst == NULL))691 return -EINVAL;692 693 /* Allow the result of crypto_attr_alg_name() to be passed directly */694 if (IS_ERR(name))695 return PTR_ERR(name);696 697 alg = crypto_find_alg(name, spawn->frontend,698 type | CRYPTO_ALG_FIPS_INTERNAL, mask);699 if (IS_ERR(alg))700 return PTR_ERR(alg);701 702 down_write(&crypto_alg_sem);703 if (!crypto_is_moribund(alg)) {704 list_add(&spawn->list, &alg->cra_users);705 spawn->alg = alg;706 spawn->mask = mask;707 spawn->next = inst->spawns;708 inst->spawns = spawn;709 inst->alg.cra_flags |=710 (alg->cra_flags & CRYPTO_ALG_INHERITED_FLAGS);711 err = 0;712 }713 up_write(&crypto_alg_sem);714 if (err)715 crypto_mod_put(alg);716 return err;717}718EXPORT_SYMBOL_GPL(crypto_grab_spawn);719 720void crypto_drop_spawn(struct crypto_spawn *spawn)721{722 if (!spawn->alg) /* not yet initialized? */723 return;724 725 down_write(&crypto_alg_sem);726 if (!spawn->dead)727 list_del(&spawn->list);728 up_write(&crypto_alg_sem);729 730 if (!spawn->registered)731 crypto_mod_put(spawn->alg);732}733EXPORT_SYMBOL_GPL(crypto_drop_spawn);734 735static struct crypto_alg *crypto_spawn_alg(struct crypto_spawn *spawn)736{737 struct crypto_alg *alg = ERR_PTR(-EAGAIN);738 struct crypto_alg *target;739 bool shoot = false;740 741 down_read(&crypto_alg_sem);742 if (!spawn->dead) {743 alg = spawn->alg;744 if (!crypto_mod_get(alg)) {745 target = crypto_alg_get(alg);746 shoot = true;747 alg = ERR_PTR(-EAGAIN);748 }749 }750 up_read(&crypto_alg_sem);751 752 if (shoot) {753 crypto_shoot_alg(target);754 crypto_alg_put(target);755 }756 757 return alg;758}759 760struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,761 u32 mask)762{763 struct crypto_alg *alg;764 struct crypto_tfm *tfm;765 766 alg = crypto_spawn_alg(spawn);767 if (IS_ERR(alg))768 return ERR_CAST(alg);769 770 tfm = ERR_PTR(-EINVAL);771 if (unlikely((alg->cra_flags ^ type) & mask))772 goto out_put_alg;773 774 tfm = __crypto_alloc_tfm(alg, type, mask);775 if (IS_ERR(tfm))776 goto out_put_alg;777 778 return tfm;779 780out_put_alg:781 crypto_mod_put(alg);782 return tfm;783}784EXPORT_SYMBOL_GPL(crypto_spawn_tfm);785 786void *crypto_spawn_tfm2(struct crypto_spawn *spawn)787{788 struct crypto_alg *alg;789 struct crypto_tfm *tfm;790 791 alg = crypto_spawn_alg(spawn);792 if (IS_ERR(alg))793 return ERR_CAST(alg);794 795 tfm = crypto_create_tfm(alg, spawn->frontend);796 if (IS_ERR(tfm))797 goto out_put_alg;798 799 return tfm;800 801out_put_alg:802 crypto_mod_put(alg);803 return tfm;804}805EXPORT_SYMBOL_GPL(crypto_spawn_tfm2);806 807int crypto_register_notifier(struct notifier_block *nb)808{809 return blocking_notifier_chain_register(&crypto_chain, nb);810}811EXPORT_SYMBOL_GPL(crypto_register_notifier);812 813int crypto_unregister_notifier(struct notifier_block *nb)814{815 return blocking_notifier_chain_unregister(&crypto_chain, nb);816}817EXPORT_SYMBOL_GPL(crypto_unregister_notifier);818 819struct crypto_attr_type *crypto_get_attr_type(struct rtattr **tb)820{821 struct rtattr *rta = tb[0];822 struct crypto_attr_type *algt;823 824 if (!rta)825 return ERR_PTR(-ENOENT);826 if (RTA_PAYLOAD(rta) < sizeof(*algt))827 return ERR_PTR(-EINVAL);828 if (rta->rta_type != CRYPTOA_TYPE)829 return ERR_PTR(-EINVAL);830 831 algt = RTA_DATA(rta);832 833 return algt;834}835EXPORT_SYMBOL_GPL(crypto_get_attr_type);836 837/**838 * crypto_check_attr_type() - check algorithm type and compute inherited mask839 * @tb: the template parameters840 * @type: the algorithm type the template would be instantiated as841 * @mask_ret: (output) the mask that should be passed to crypto_grab_*()842 * to restrict the flags of any inner algorithms843 *844 * Validate that the algorithm type the user requested is compatible with the845 * one the template would actually be instantiated as. E.g., if the user is846 * doing crypto_alloc_shash("cbc(aes)", ...), this would return an error because847 * the "cbc" template creates an "skcipher" algorithm, not an "shash" algorithm.848 *849 * Also compute the mask to use to restrict the flags of any inner algorithms.850 *851 * Return: 0 on success; -errno on failure852 */853int crypto_check_attr_type(struct rtattr **tb, u32 type, u32 *mask_ret)854{855 struct crypto_attr_type *algt;856 857 algt = crypto_get_attr_type(tb);858 if (IS_ERR(algt))859 return PTR_ERR(algt);860 861 if ((algt->type ^ type) & algt->mask)862 return -EINVAL;863 864 *mask_ret = crypto_algt_inherited_mask(algt);865 return 0;866}867EXPORT_SYMBOL_GPL(crypto_check_attr_type);868 869const char *crypto_attr_alg_name(struct rtattr *rta)870{871 struct crypto_attr_alg *alga;872 873 if (!rta)874 return ERR_PTR(-ENOENT);875 if (RTA_PAYLOAD(rta) < sizeof(*alga))876 return ERR_PTR(-EINVAL);877 if (rta->rta_type != CRYPTOA_ALG)878 return ERR_PTR(-EINVAL);879 880 alga = RTA_DATA(rta);881 alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0;882 883 return alga->name;884}885EXPORT_SYMBOL_GPL(crypto_attr_alg_name);886 887int crypto_inst_setname(struct crypto_instance *inst, const char *name,888 struct crypto_alg *alg)889{890 if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name,891 alg->cra_name) >= CRYPTO_MAX_ALG_NAME)892 return -ENAMETOOLONG;893 894 if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)",895 name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME)896 return -ENAMETOOLONG;897 898 return 0;899}900EXPORT_SYMBOL_GPL(crypto_inst_setname);901 902void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)903{904 INIT_LIST_HEAD(&queue->list);905 queue->backlog = &queue->list;906 queue->qlen = 0;907 queue->max_qlen = max_qlen;908}909EXPORT_SYMBOL_GPL(crypto_init_queue);910 911int crypto_enqueue_request(struct crypto_queue *queue,912 struct crypto_async_request *request)913{914 int err = -EINPROGRESS;915 916 if (unlikely(queue->qlen >= queue->max_qlen)) {917 if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) {918 err = -ENOSPC;919 goto out;920 }921 err = -EBUSY;922 if (queue->backlog == &queue->list)923 queue->backlog = &request->list;924 }925 926 queue->qlen++;927 list_add_tail(&request->list, &queue->list);928 929out:930 return err;931}932EXPORT_SYMBOL_GPL(crypto_enqueue_request);933 934void crypto_enqueue_request_head(struct crypto_queue *queue,935 struct crypto_async_request *request)936{937 if (unlikely(queue->qlen >= queue->max_qlen))938 queue->backlog = queue->backlog->prev;939 940 queue->qlen++;941 list_add(&request->list, &queue->list);942}943EXPORT_SYMBOL_GPL(crypto_enqueue_request_head);944 945struct crypto_async_request *crypto_dequeue_request(struct crypto_queue *queue)946{947 struct list_head *request;948 949 if (unlikely(!queue->qlen))950 return NULL;951 952 queue->qlen--;953 954 if (queue->backlog != &queue->list)955 queue->backlog = queue->backlog->next;956 957 request = queue->list.next;958 list_del(request);959 960 return list_entry(request, struct crypto_async_request, list);961}962EXPORT_SYMBOL_GPL(crypto_dequeue_request);963 964static inline void crypto_inc_byte(u8 *a, unsigned int size)965{966 u8 *b = (a + size);967 u8 c;968 969 for (; size; size--) {970 c = *--b + 1;971 *b = c;972 if (c)973 break;974 }975}976 977void crypto_inc(u8 *a, unsigned int size)978{979 __be32 *b = (__be32 *)(a + size);980 u32 c;981 982 if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||983 IS_ALIGNED((unsigned long)b, __alignof__(*b)))984 for (; size >= 4; size -= 4) {985 c = be32_to_cpu(*--b) + 1;986 *b = cpu_to_be32(c);987 if (likely(c))988 return;989 }990 991 crypto_inc_byte(a, size);992}993EXPORT_SYMBOL_GPL(crypto_inc);994 995unsigned int crypto_alg_extsize(struct crypto_alg *alg)996{997 return alg->cra_ctxsize +998 (alg->cra_alignmask & ~(crypto_tfm_ctx_alignment() - 1));999}1000EXPORT_SYMBOL_GPL(crypto_alg_extsize);1001 1002int crypto_type_has_alg(const char *name, const struct crypto_type *frontend,1003 u32 type, u32 mask)1004{1005 int ret = 0;1006 struct crypto_alg *alg = crypto_find_alg(name, frontend, type, mask);1007 1008 if (!IS_ERR(alg)) {1009 crypto_mod_put(alg);1010 ret = 1;1011 }1012 1013 return ret;1014}1015EXPORT_SYMBOL_GPL(crypto_type_has_alg);1016 1017static void __init crypto_start_tests(void)1018{1019 if (!IS_BUILTIN(CONFIG_CRYPTO_ALGAPI))1020 return;1021 1022 if (IS_ENABLED(CONFIG_CRYPTO_MANAGER_DISABLE_TESTS))1023 return;1024 1025 for (;;) {1026 struct crypto_larval *larval = NULL;1027 struct crypto_alg *q;1028 1029 down_write(&crypto_alg_sem);1030 1031 list_for_each_entry(q, &crypto_alg_list, cra_list) {1032 struct crypto_larval *l;1033 1034 if (!crypto_is_larval(q))1035 continue;1036 1037 l = (void *)q;1038 1039 if (!crypto_is_test_larval(l))1040 continue;1041 1042 if (l->test_started)1043 continue;1044 1045 l->test_started = true;1046 larval = l;1047 crypto_schedule_test(larval);1048 break;1049 }1050 1051 up_write(&crypto_alg_sem);1052 1053 if (!larval)1054 break;1055 }1056 1057 set_crypto_boot_test_finished();1058}1059 1060static int __init crypto_algapi_init(void)1061{1062 crypto_init_proc();1063 crypto_start_tests();1064 return 0;1065}1066 1067static void __exit crypto_algapi_exit(void)1068{1069 crypto_exit_proc();1070}1071 1072/*1073 * We run this at late_initcall so that all the built-in algorithms1074 * have had a chance to register themselves first.1075 */1076late_initcall(crypto_algapi_init);1077module_exit(crypto_algapi_exit);1078 1079MODULE_LICENSE("GPL");1080MODULE_DESCRIPTION("Cryptographic algorithms API");1081MODULE_SOFTDEP("pre: cryptomgr");1082