/* * 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/string.h> #include "internal.h" static void crypto_remove_final(struct list_head *list); static LIST_HEAD(crypto_template_list); void crypto_larval_error(const char *name, u32 type, u32 mask){	struct crypto_alg *alg; 	alg = crypto_alg_lookup(name, type, mask); 	if (alg) {		if (crypto_is_larval(alg)) {			struct crypto_larval *larval = (void *)alg;			complete_all(&larval->completion);		}		crypto_mod_put(alg);	}}EXPORT_SYMBOL_GPL(crypto_larval_error); 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 int crypto_check_alg(struct crypto_alg *alg){	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; 	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 void crypto_remove_spawn(struct crypto_spawn *spawn,				struct list_head *list,				struct list_head *secondary_spawns){	struct crypto_instance *inst = spawn->inst;	struct crypto_template *tmpl = inst->tmpl; 	list_del_init(&spawn->list);	spawn->alg = NULL; 	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; 	list_splice(&inst->alg.cra_users, secondary_spawns);} static void crypto_remove_spawns(struct list_head *spawns,				 struct list_head *list, u32 new_type){	struct crypto_spawn *spawn, *n;	LIST_HEAD(secondary_spawns); 	list_for_each_entry_safe(spawn, n, spawns, list) {		if ((spawn->alg->cra_flags ^ new_type) & spawn->mask)			continue; 		crypto_remove_spawn(spawn, list, &secondary_spawns);	} 	while (!list_empty(&secondary_spawns)) {		list_for_each_entry_safe(spawn, n, &secondary_spawns, list)			crypto_remove_spawn(spawn, list, &secondary_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; 	atomic_set(&alg->cra_refcnt, 1);	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;			complete_all(&larval->completion);			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->cra_users, &list, alg->cra_flags);	} complete:	complete_all(&test->completion); unlock:	up_write(&crypto_alg_sem); 	crypto_remove_final(&list);}EXPORT_SYMBOL_GPL(crypto_alg_tested); static 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);	}} 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->cra_users, list, alg->cra_flags); 	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_template(struct crypto_template *tmpl){	struct crypto_template *q;	int err = -EEXIST; 	down_write(&crypto_alg_sem); 	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 *p, *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, p, 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, p, 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)))			continue; 		tmpl = q;		break;	}	up_read(&crypto_alg_sem); 	return tmpl;} struct crypto_template *crypto_lookup_template(const char *name){	return try_then_request_module(__crypto_lookup_template(name), name);}EXPORT_SYMBOL_GPL(crypto_lookup_template); int crypto_register_instance(struct crypto_template *tmpl,			     struct crypto_instance *inst){	struct crypto_larval *larval;	int err; 	err = crypto_check_alg(&inst->alg);	if (err)		goto err; 	inst->alg.cra_module = tmpl->module; 	down_write(&crypto_alg_sem); 	larval = __crypto_register_alg(&inst->alg);	if (IS_ERR(larval))		goto unlock; 	hlist_add_head(&inst->list, &tmpl->instances);	inst->tmpl = tmpl; unlock:	up_write(&crypto_alg_sem); 	err = PTR_ERR(larval);	if (IS_ERR(larval))		goto err; 	crypto_wait_for_test(larval);	err = 0; err:	return err;}EXPORT_SYMBOL_GPL(crypto_register_instance); int crypto_init_spawn(struct crypto_spawn *spawn, struct crypto_alg *alg,		      struct crypto_instance *inst, u32 mask){	int err = -EAGAIN; 	spawn->inst = inst;	spawn->mask = mask; 	down_write(&crypto_alg_sem);	if (!crypto_is_moribund(alg)) {		list_add(&spawn->list, &alg->cra_users);		spawn->alg = alg;		err = 0;	}	up_write(&crypto_alg_sem); 	return err;}EXPORT_SYMBOL_GPL(crypto_init_spawn); void crypto_drop_spawn(struct crypto_spawn *spawn){	down_write(&crypto_alg_sem);	list_del(&spawn->list);	up_write(&crypto_alg_sem);}EXPORT_SYMBOL_GPL(crypto_drop_spawn); struct crypto_tfm *crypto_spawn_tfm(struct crypto_spawn *spawn, u32 type,				    u32 mask)

Lines 1–500 of 789. Load more