/* * Cryptographic API for algorithms (i.e., low-level API). * * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * */ #include <linux/err.h>#include <linux/errno.h>#include <linux/init.h>#include <linux/kernel.h>#include <linux/list.h>#include <linux/module.h>#include <linux/rtnetlink.h>#include <linux/slab.h>#include <linux/string.h> #include "internal.h" static LIST_HEAD(crypto_template_list); static inline int crypto_set_driver_name(struct crypto_alg *alg){	static const char suffix[] = "-generic";	char *driver_name = alg->cra_driver_name;	int len; 	if (*driver_name)		return 0; 	len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME);	if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME)		return -ENAMETOOLONG; 	memcpy(driver_name + len, suffix, sizeof(suffix));	return 0;} static inline void crypto_check_module_sig(struct module *mod){#ifdef CONFIG_CRYPTO_FIPS	if (fips_enabled && mod && !mod->sig_ok)		panic("Module %s signature verification failed in FIPS mode\n",		      mod->name);#endif	return;} static int crypto_check_alg(struct crypto_alg *alg){	crypto_check_module_sig(alg->cra_module); 	if (alg->cra_alignmask & (alg->cra_alignmask + 1))		return -EINVAL; 	if (alg->cra_blocksize > PAGE_SIZE / 8)		return -EINVAL; 	if (alg->cra_priority < 0)		return -EINVAL; 	atomic_set(&alg->cra_refcnt, 1); 	return crypto_set_driver_name(alg);} static void crypto_destroy_instance(struct crypto_alg *alg){	struct crypto_instance *inst = (void *)alg;	struct crypto_template *tmpl = inst->tmpl; 	tmpl->free(inst);	crypto_tmpl_put(tmpl);} static struct list_head *crypto_more_spawns(struct crypto_alg *alg,					    struct list_head *stack,					    struct list_head *top,					    struct list_head *secondary_spawns){	struct crypto_spawn *spawn, *n; 	if (list_empty(stack))		return NULL; 	spawn = list_first_entry(stack, struct crypto_spawn, list);	n = list_entry(spawn->list.next, struct crypto_spawn, list); 	if (spawn->alg && &n->list != stack && !n->alg)		n->alg = (n->list.next == stack) ? alg :			 &list_entry(n->list.next, struct crypto_spawn,				     list)->inst->alg; 	list_move(&spawn->list, secondary_spawns); 	return &n->list == stack ? top : &n->inst->alg.cra_users;} static void crypto_remove_instance(struct crypto_instance *inst,				   struct list_head *list){	struct crypto_template *tmpl = inst->tmpl; 	if (crypto_is_dead(&inst->alg))		return; 	inst->alg.cra_flags |= CRYPTO_ALG_DEAD;	if (hlist_unhashed(&inst->list))		return; 	if (!tmpl || !crypto_tmpl_get(tmpl))		return; 	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg);	list_move(&inst->alg.cra_list, list);	hlist_del(&inst->list);	inst->alg.cra_destroy = crypto_destroy_instance; 	BUG_ON(!list_empty(&inst->alg.cra_users));} void crypto_remove_spawns(struct crypto_alg *alg, struct list_head *list,			  struct crypto_alg *nalg){	u32 new_type = (nalg ?: alg)->cra_flags;	struct crypto_spawn *spawn, *n;	LIST_HEAD(secondary_spawns);	struct list_head *spawns;	LIST_HEAD(stack);	LIST_HEAD(top); 	spawns = &alg->cra_users;	list_for_each_entry_safe(spawn, n, spawns, list) {		if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)			continue; 		list_move(&spawn->list, &top);	} 	spawns = &top;	do {		while (!list_empty(spawns)) {			struct crypto_instance *inst; 			spawn = list_first_entry(spawns, struct crypto_spawn,						 list);			inst = spawn->inst; 			BUG_ON(&inst->alg == alg); 			list_move(&spawn->list, &stack); 			if (&inst->alg == nalg)				break; 			spawn->alg = NULL;			spawns = &inst->alg.cra_users;		}	} while ((spawns = crypto_more_spawns(alg, &stack, &top,					      &secondary_spawns))); 	list_for_each_entry_safe(spawn, n, &secondary_spawns, list) {		if (spawn->alg)			list_move(&spawn->list, &spawn->alg->cra_users);		else			crypto_remove_instance(spawn->inst, list);	}}EXPORT_SYMBOL_GPL(crypto_remove_spawns); static struct crypto_larval *__crypto_register_alg(struct crypto_alg *alg){	struct crypto_alg *q;	struct crypto_larval *larval;	int ret = -EAGAIN; 	if (crypto_is_dead(alg))		goto err; 	INIT_LIST_HEAD(&alg->cra_users); 	/* No cheating! */	alg->cra_flags &= ~CRYPTO_ALG_TESTED; 	ret = -EEXIST; 	list_for_each_entry(q, &crypto_alg_list, cra_list) {		if (q == alg)			goto err; 		if (crypto_is_moribund(q))			continue; 		if (crypto_is_larval(q)) {			if (!strcmp(alg->cra_driver_name, q->cra_driver_name))				goto err;			continue;		} 		if (!strcmp(q->cra_driver_name, alg->cra_name) ||		    !strcmp(q->cra_name, alg->cra_driver_name))			goto err;	} 	larval = crypto_larval_alloc(alg->cra_name,				     alg->cra_flags | CRYPTO_ALG_TESTED, 0);	if (IS_ERR(larval))		goto out; 	ret = -ENOENT;	larval->adult = crypto_mod_get(alg);	if (!larval->adult)		goto free_larval; 	atomic_set(&larval->alg.cra_refcnt, 1);	memcpy(larval->alg.cra_driver_name, alg->cra_driver_name,	       CRYPTO_MAX_ALG_NAME);	larval->alg.cra_priority = alg->cra_priority; 	list_add(&alg->cra_list, &crypto_alg_list);	list_add(&larval->alg.cra_list, &crypto_alg_list); out:	return larval; free_larval:	kfree(larval);err:	larval = ERR_PTR(ret);	goto out;} void crypto_alg_tested(const char *name, int err){	struct crypto_larval *test;	struct crypto_alg *alg;	struct crypto_alg *q;	LIST_HEAD(list); 	down_write(&crypto_alg_sem);	list_for_each_entry(q, &crypto_alg_list, cra_list) {		if (crypto_is_moribund(q) || !crypto_is_larval(q))			continue; 		test = (struct crypto_larval *)q; 		if (!strcmp(q->cra_driver_name, name))			goto found;	} 	printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err);	goto unlock; found:	q->cra_flags |= CRYPTO_ALG_DEAD;	alg = test->adult;	if (err || list_empty(&alg->cra_list))		goto complete; 	alg->cra_flags |= CRYPTO_ALG_TESTED; 	list_for_each_entry(q, &crypto_alg_list, cra_list) {		if (q == alg)			continue; 		if (crypto_is_moribund(q))			continue; 		if (crypto_is_larval(q)) {			struct crypto_larval *larval = (void *)q; 			/*			 * Check to see if either our generic name or			 * specific name can satisfy the name requested			 * by the larval entry q.			 */			if (strcmp(alg->cra_name, q->cra_name) &&			    strcmp(alg->cra_driver_name, q->cra_name))				continue; 			if (larval->adult)				continue;			if ((q->cra_flags ^ alg->cra_flags) & larval->mask)				continue;			if (!crypto_mod_get(alg))				continue; 			larval->adult = alg;			continue;		} 		if (strcmp(alg->cra_name, q->cra_name))			continue; 		if (strcmp(alg->cra_driver_name, q->cra_driver_name) &&		    q->cra_priority > alg->cra_priority)			continue; 		crypto_remove_spawns(q, &list, alg);	} complete:	complete_all(&test->completion); unlock:	up_write(&crypto_alg_sem); 	crypto_remove_final(&list);}EXPORT_SYMBOL_GPL(crypto_alg_tested); void crypto_remove_final(struct list_head *list){	struct crypto_alg *alg;	struct crypto_alg *n; 	list_for_each_entry_safe(alg, n, list, cra_list) {		list_del_init(&alg->cra_list);		crypto_alg_put(alg);	}}EXPORT_SYMBOL_GPL(crypto_remove_final); static void crypto_wait_for_test(struct crypto_larval *larval){	int err; 	err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult);	if (err != NOTIFY_STOP) {		if (WARN_ON(err != NOTIFY_DONE))			goto out;		crypto_alg_tested(larval->alg.cra_driver_name, 0);	} 	err = wait_for_completion_interruptible(&larval->completion);	WARN_ON(err); out:	crypto_larval_kill(&larval->alg);} int crypto_register_alg(struct crypto_alg *alg){	struct crypto_larval *larval;	int err; 	err = crypto_check_alg(alg);	if (err)		return err; 	down_write(&crypto_alg_sem);	larval = __crypto_register_alg(alg);	up_write(&crypto_alg_sem); 	if (IS_ERR(larval))		return PTR_ERR(larval); 	crypto_wait_for_test(larval);	return 0;}EXPORT_SYMBOL_GPL(crypto_register_alg); static int crypto_remove_alg(struct crypto_alg *alg, struct list_head *list){	if (unlikely(list_empty(&alg->cra_list)))		return -ENOENT; 	alg->cra_flags |= CRYPTO_ALG_DEAD; 	crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);	list_del_init(&alg->cra_list);	crypto_remove_spawns(alg, list, NULL); 	return 0;} int crypto_unregister_alg(struct crypto_alg *alg){	int ret;	LIST_HEAD(list); 	down_write(&crypto_alg_sem);	ret = crypto_remove_alg(alg, &list);	up_write(&crypto_alg_sem); 	if (ret)		return ret; 	BUG_ON(atomic_read(&alg->cra_refcnt) != 1);	if (alg->cra_destroy)		alg->cra_destroy(alg); 	crypto_remove_final(&list);	return 0;}EXPORT_SYMBOL_GPL(crypto_unregister_alg); int crypto_register_algs(struct crypto_alg *algs, int count){	int i, ret; 	for (i = 0; i < count; i++) {		ret = crypto_register_alg(&algs[i]);		if (ret)			goto err;	} 	return 0; err:	for (--i; i >= 0; --i)		crypto_unregister_alg(&algs[i]); 	return ret;}EXPORT_SYMBOL_GPL(crypto_register_algs); int crypto_unregister_algs(struct crypto_alg *algs, int count){	int i, ret; 	for (i = 0; i < count; i++) {		ret = crypto_unregister_alg(&algs[i]);		if (ret)			pr_err("Failed to unregister %s %s: %d\n",			       algs[i].cra_driver_name, algs[i].cra_name, ret);	} 	return 0;}EXPORT_SYMBOL_GPL(crypto_unregister_algs); int crypto_register_template(struct crypto_template *tmpl){	struct crypto_template *q;	int err = -EEXIST; 	down_write(&crypto_alg_sem); 	crypto_check_module_sig(tmpl->module); 	list_for_each_entry(q, &crypto_template_list, list) {		if (q == tmpl)			goto out;	} 	list_add(&tmpl->list, &crypto_template_list);	crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl);	err = 0;out:	up_write(&crypto_alg_sem);	return err;}EXPORT_SYMBOL_GPL(crypto_register_template); void crypto_unregister_template(struct crypto_template *tmpl){	struct crypto_instance *inst;	struct hlist_node *n;	struct hlist_head *list;	LIST_HEAD(users); 	down_write(&crypto_alg_sem); 	BUG_ON(list_empty(&tmpl->list));	list_del_init(&tmpl->list); 	list = &tmpl->instances;	hlist_for_each_entry(inst, list, list) {		int err = crypto_remove_alg(&inst->alg, &users); 		BUG_ON(err);	} 	crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl); 	up_write(&crypto_alg_sem); 	hlist_for_each_entry_safe(inst, n, list, list) {		BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1);		tmpl->free(inst);	}	crypto_remove_final(&users);}EXPORT_SYMBOL_GPL(crypto_unregister_template); static struct crypto_template *__crypto_lookup_template(const char *name){	struct crypto_template *q, *tmpl = NULL; 	down_read(&crypto_alg_sem);	list_for_each_entry(q, &crypto_template_list, list) {		if (strcmp(q->name, name))			continue;		if (unlikely(!crypto_tmpl_get(q)))

Lines 1–500 of 982. Load more