Skip to content

Commit

Permalink
crypto: api - Use test infrastructure
Browse files Browse the repository at this point in the history 
This patch makes use of the new testing infrastructure by requiring
algorithms to pass a run-time test before they're made available to
users.

Signed-off-by: Herbert Xu <[email protected]>
  • Loading branch information
@herbertx
herbertx committed Aug 29, 2008
1 parent da7f033 commit 73d3864
Show file tree
Hide file tree
Showing 6 changed files with 267 additions and 42 deletions.
143 changes: 123 additions & 20 deletions crypto/algapi.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,8 @@

#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)
Expand Down Expand Up @@ -126,23 +128,97 @@ static void crypto_remove_spawns(struct list_head *spawns,
}
}

static int __crypto_register_alg(struct crypto_alg *alg,
struct list_head *list)
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 out;
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 out;
goto err;

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_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:
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;
Expand Down Expand Up @@ -178,17 +254,18 @@ static int __crypto_register_alg(struct crypto_alg *alg,
q->cra_priority > alg->cra_priority)
continue;

crypto_remove_spawns(&q->cra_users, list, alg->cra_flags);
crypto_remove_spawns(&q->cra_users, &list, alg->cra_flags);
}

list_add(&alg->cra_list, &crypto_alg_list);

crypto_notify(CRYPTO_MSG_ALG_REGISTER, alg);
ret = 0;
complete:
complete_all(&test->completion);

out:
return ret;
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)
{
Expand All @@ -201,21 +278,42 @@ static void crypto_remove_final(struct list_head *list)
}
}

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)
{
LIST_HEAD(list);
struct crypto_larval *larval;
int err;

err = crypto_check_alg(alg);
if (err)
return err;

down_write(&crypto_alg_sem);
err = __crypto_register_alg(alg, &list);
larval = __crypto_register_alg(alg);
up_write(&crypto_alg_sem);

crypto_remove_final(&list);
return err;
if (IS_ERR(larval))
return PTR_ERR(larval);

crypto_wait_for_test(larval);
return 0;
}
EXPORT_SYMBOL_GPL(crypto_register_alg);

Expand Down Expand Up @@ -333,8 +431,8 @@ EXPORT_SYMBOL_GPL(crypto_lookup_template);
int crypto_register_instance(struct crypto_template *tmpl,
struct crypto_instance *inst)
{
LIST_HEAD(list);
int err = -EINVAL;
struct crypto_larval *larval;
int err;

err = crypto_check_alg(&inst->alg);
if (err)
Expand All @@ -344,8 +442,8 @@ int crypto_register_instance(struct crypto_template *tmpl,

down_write(&crypto_alg_sem);

err = __crypto_register_alg(&inst->alg, &list);
if (err)
larval = __crypto_register_alg(&inst->alg);
if (IS_ERR(larval))
goto unlock;

hlist_add_head(&inst->list, &tmpl->instances);
Expand All @@ -354,7 +452,12 @@ int crypto_register_instance(struct crypto_template *tmpl,
unlock:
up_write(&crypto_alg_sem);

crypto_remove_final(&list);
err = PTR_ERR(larval);
if (IS_ERR(larval))
goto err;

crypto_wait_for_test(larval);
err = 0;

err:
return err;
Expand Down
75 changes: 70 additions & 5 deletions crypto/algboss.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -45,6 +45,15 @@ struct cryptomgr_param {

char larval[CRYPTO_MAX_ALG_NAME];
char template[CRYPTO_MAX_ALG_NAME];

u32 otype;
u32 omask;
};

struct crypto_test_param {
char driver[CRYPTO_MAX_ALG_NAME];
char alg[CRYPTO_MAX_ALG_NAME];
u32 type;
};

static int cryptomgr_probe(void *data)
Expand Down Expand Up @@ -76,8 +85,7 @@ static int cryptomgr_probe(void *data)
module_put_and_exit(0);

err:
crypto_larval_error(param->larval, param->type.data.type,
param->type.data.mask);
crypto_larval_error(param->larval, param->otype, param->omask);
goto out;
}

Expand Down Expand Up @@ -169,13 +177,68 @@ static int cryptomgr_schedule_probe(struct crypto_larval *larval)

param->type.attr.rta_len = sizeof(param->type);
param->type.attr.rta_type = CRYPTOA_TYPE;
param->type.data.type = larval->alg.cra_flags;
param->type.data.mask = larval->mask;
param->type.data.type = larval->alg.cra_flags & ~CRYPTO_ALG_TESTED;
param->type.data.mask = larval->mask & ~CRYPTO_ALG_TESTED;
param->tb[0] = &param->type.attr;

param->otype = larval->alg.cra_flags;
param->omask = larval->mask;

memcpy(param->larval, larval->alg.cra_name, CRYPTO_MAX_ALG_NAME);

thread = kthread_run(cryptomgr_probe, param, "cryptomgr");
thread = kthread_run(cryptomgr_probe, param, "cryptomgr_probe");
if (IS_ERR(thread))
goto err_free_param;

return NOTIFY_STOP;

err_free_param:
kfree(param);
err_put_module:
module_put(THIS_MODULE);
err:
return NOTIFY_OK;
}

static int cryptomgr_test(void *data)
{
struct crypto_test_param *param = data;
u32 type = param->type;
int err = 0;

if (!((type ^ CRYPTO_ALG_TYPE_BLKCIPHER) &
CRYPTO_ALG_TYPE_BLKCIPHER_MASK) && !(type & CRYPTO_ALG_GENIV))
goto skiptest;

if ((type & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_CIPHER)
goto skiptest;

err = alg_test(param->driver, param->alg, 0, CRYPTO_ALG_TESTED);

skiptest:
crypto_alg_tested(param->driver, err);

kfree(param);
module_put_and_exit(0);
}

static int cryptomgr_schedule_test(struct crypto_alg *alg)
{
struct task_struct *thread;
struct crypto_test_param *param;

if (!try_module_get(THIS_MODULE))
goto err;

param = kzalloc(sizeof(*param), GFP_KERNEL);
if (!param)
goto err_put_module;

memcpy(param->driver, alg->cra_driver_name, sizeof(param->driver));
memcpy(param->alg, alg->cra_name, sizeof(param->alg));
param->type = alg->cra_flags;

thread = kthread_run(cryptomgr_test, param, "cryptomgr_test");
if (IS_ERR(thread))
goto err_free_param;

Expand All @@ -195,6 +258,8 @@ static int cryptomgr_notify(struct notifier_block *this, unsigned long msg,
switch (msg) {
case CRYPTO_MSG_ALG_REQUEST:
return cryptomgr_schedule_probe(data);
case CRYPTO_MSG_ALG_REGISTER:
return cryptomgr_schedule_test(data);
}

return NOTIFY_DONE;
Expand Down
Loading

0 comments on commit 73d3864

Please sign in to comment.