Merge master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6 (6adae5d9) · Commits · 戴 / test

crypto/Kconfig

+13 −0

Original line number	Diff line number	Diff line
		@@ -16,6 +16,10 @@ config CRYPTO_ALGAPI
		help
		This option provides the API for cryptographic algorithms.

		config CRYPTO_ABLKCIPHER
		tristate
		select CRYPTO_BLKCIPHER

		config CRYPTO_BLKCIPHER
		tristate
		select CRYPTO_ALGAPI
		@@ -171,6 +175,15 @@ config CRYPTO_LRW
		The first 128, 192 or 256 bits in the key are used for AES and the
		rest is used to tie each cipher block to its logical position.

		config CRYPTO_CRYPTD
		tristate "Software async crypto daemon"
		select CRYPTO_ABLKCIPHER
		select CRYPTO_MANAGER
		help
		This is a generic software asynchronous crypto daemon that
		converts an arbitrary synchronous software crypto algorithm
		into an asynchronous algorithm that executes in a kernel thread.

		config CRYPTO_DES
		tristate "DES and Triple DES EDE cipher algorithms"
		select CRYPTO_ALGAPI

crypto/Makefile

+2 −0

Original line number	Diff line number	Diff line
		@@ -8,6 +8,7 @@ crypto_algapi-$(CONFIG_PROC_FS) += proc.o
		crypto_algapi-objs := algapi.o $(crypto_algapi-y)
		obj-$(CONFIG_CRYPTO_ALGAPI) += crypto_algapi.o

		obj-$(CONFIG_CRYPTO_ABLKCIPHER) += ablkcipher.o
		obj-$(CONFIG_CRYPTO_BLKCIPHER) += blkcipher.o

		crypto_hash-objs := hash.o
		@@ -29,6 +30,7 @@ obj-$(CONFIG_CRYPTO_ECB) += ecb.o
		obj-$(CONFIG_CRYPTO_CBC) += cbc.o
		obj-$(CONFIG_CRYPTO_PCBC) += pcbc.o
		obj-$(CONFIG_CRYPTO_LRW) += lrw.o
		obj-$(CONFIG_CRYPTO_CRYPTD) += cryptd.o
		obj-$(CONFIG_CRYPTO_DES) += des.o
		obj-$(CONFIG_CRYPTO_FCRYPT) += fcrypt.o
		obj-$(CONFIG_CRYPTO_BLOWFISH) += blowfish.o

crypto/ablkcipher.c

0 → 100644

+83 −0

Original line number	Diff line number	Diff line
		/*
		* Asynchronous block chaining cipher operations.
		*
		* This is the asynchronous version of blkcipher.c indicating completion
		* via a callback.
		*
		* 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 <crypto/algapi.h>
		#include <linux/errno.h>
		#include <linux/init.h>
		#include <linux/module.h>
		#include <linux/seq_file.h>

		static int setkey(struct crypto_ablkcipher tfm, const u8 key,
		unsigned int keylen)
		{
		struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);

		if (keylen < cipher->min_keysize \|\| keylen > cipher->max_keysize) {
		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
		return -EINVAL;
		}

		return cipher->setkey(tfm, key, keylen);
		}

		static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,
		u32 mask)
		{
		return alg->cra_ctxsize;
		}

		static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,
		u32 mask)
		{
		struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
		struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;

		if (alg->ivsize > PAGE_SIZE / 8)
		return -EINVAL;

		crt->setkey = setkey;
		crt->encrypt = alg->encrypt;
		crt->decrypt = alg->decrypt;
		crt->ivsize = alg->ivsize;

		return 0;
		}

		static void crypto_ablkcipher_show(struct seq_file m, struct crypto_alg alg)
		__attribute__ ((unused));
		static void crypto_ablkcipher_show(struct seq_file m, struct crypto_alg alg)
		{
		struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;

		seq_printf(m, "type : ablkcipher\n");
		seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
		seq_printf(m, "min keysize : %u\n", ablkcipher->min_keysize);
		seq_printf(m, "max keysize : %u\n", ablkcipher->max_keysize);
		seq_printf(m, "ivsize : %u\n", ablkcipher->ivsize);
		seq_printf(m, "qlen : %u\n", ablkcipher->queue->qlen);
		seq_printf(m, "max qlen : %u\n", ablkcipher->queue->max_qlen);
		}

		const struct crypto_type crypto_ablkcipher_type = {
		.ctxsize = crypto_ablkcipher_ctxsize,
		.init = crypto_init_ablkcipher_ops,
		#ifdef CONFIG_PROC_FS
		.show = crypto_ablkcipher_show,
		#endif
		};
		EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);

		MODULE_LICENSE("GPL");
		MODULE_DESCRIPTION("Asynchronous block chaining cipher type");

crypto/algapi.c

+137 −32

Original line number	Diff line number	Diff line
		@@ -84,12 +84,10 @@ static void crypto_destroy_instance(struct crypto_alg *alg)
		crypto_tmpl_put(tmpl);
		}

		static void crypto_remove_spawns(struct list_head *spawns,
		struct list_head *list)
		static void crypto_remove_spawn(struct crypto_spawn *spawn,
		struct list_head *list,
		struct list_head *secondary_spawns)
		{
		struct crypto_spawn spawn, n;

		list_for_each_entry_safe(spawn, n, spawns, list) {
		struct crypto_instance *inst = spawn->inst;
		struct crypto_template *tmpl = inst->tmpl;

		@@ -97,23 +95,36 @@ static void crypto_remove_spawns(struct list_head *spawns,
		spawn->alg = NULL;

		if (crypto_is_dead(&inst->alg))
		continue;
		return;

		inst->alg.cra_flags \|= CRYPTO_ALG_DEAD;
		if (!tmpl \|\| !crypto_tmpl_get(tmpl))
		continue;
		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;

		if (!list_empty(&inst->alg.cra_users)) {
		if (&n->list == spawns)
		n = list_entry(inst->alg.cra_users.next,
		typeof(*n), list);
		__list_splice(&inst->alg.cra_users, spawns->prev);
		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);
		}
		}

		@@ -164,7 +175,7 @@ static int __crypto_register_alg(struct crypto_alg *alg,
		q->cra_priority > alg->cra_priority)
		continue;

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

		list_add(&alg->cra_list, &crypto_alg_list);
		@@ -214,7 +225,7 @@ static int crypto_remove_alg(struct crypto_alg alg, struct list_head list)

		crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg);
		list_del_init(&alg->cra_list);
		crypto_remove_spawns(&alg->cra_users, list);
		crypto_remove_spawns(&alg->cra_users, list, alg->cra_flags);

		return 0;
		}
		@@ -351,11 +362,12 @@ err:
		EXPORT_SYMBOL_GPL(crypto_register_instance);

		int crypto_init_spawn(struct crypto_spawn spawn, struct crypto_alg alg,
		struct crypto_instance *inst)
		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)) {
		@@ -425,15 +437,45 @@ int crypto_unregister_notifier(struct notifier_block *nb)
		}
		EXPORT_SYMBOL_GPL(crypto_unregister_notifier);

		struct crypto_alg crypto_get_attr_alg(void param, unsigned int len,
		u32 type, u32 mask)
		struct crypto_attr_type crypto_get_attr_type(struct rtattr *tb)
		{
		struct rtattr *rta = param;
		struct rtattr *rta = tb[CRYPTOA_TYPE - 1];
		struct crypto_attr_type *algt;

		if (!rta)
		return ERR_PTR(-ENOENT);
		if (RTA_PAYLOAD(rta) < sizeof(*algt))
		return ERR_PTR(-EINVAL);

		algt = RTA_DATA(rta);

		return algt;
		}
		EXPORT_SYMBOL_GPL(crypto_get_attr_type);

		int crypto_check_attr_type(struct rtattr **tb, u32 type)
		{
		struct crypto_attr_type *algt;

		algt = crypto_get_attr_type(tb);
		if (IS_ERR(algt))
		return PTR_ERR(algt);

		if ((algt->type ^ type) & algt->mask)
		return -EINVAL;

		return 0;
		}
		EXPORT_SYMBOL_GPL(crypto_check_attr_type);

		struct crypto_alg crypto_get_attr_alg(struct rtattr *tb, u32 type, u32 mask)
		{
		struct rtattr *rta = tb[CRYPTOA_ALG - 1];
		struct crypto_attr_alg *alga;

		if (!RTA_OK(rta, len))
		return ERR_PTR(-EBADR);
		if (rta->rta_type != CRYPTOA_ALG \|\| RTA_PAYLOAD(rta) < sizeof(*alga))
		if (!rta)
		return ERR_PTR(-ENOENT);
		if (RTA_PAYLOAD(rta) < sizeof(*alga))
		return ERR_PTR(-EINVAL);

		alga = RTA_DATA(rta);
		@@ -464,7 +506,8 @@ struct crypto_instance crypto_alloc_instance(const char name,
		goto err_free_inst;

		spawn = crypto_instance_ctx(inst);
		err = crypto_init_spawn(spawn, alg, inst);
		err = crypto_init_spawn(spawn, alg, inst,
		CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC);

		if (err)
		goto err_free_inst;
		@@ -477,6 +520,68 @@ err_free_inst:
		}
		EXPORT_SYMBOL_GPL(crypto_alloc_instance);

		void crypto_init_queue(struct crypto_queue *queue, unsigned int max_qlen)
		{
		INIT_LIST_HEAD(&queue->list);
		queue->backlog = &queue->list;
		queue->qlen = 0;
		queue->max_qlen = max_qlen;
		}
		EXPORT_SYMBOL_GPL(crypto_init_queue);

		int crypto_enqueue_request(struct crypto_queue *queue,
		struct crypto_async_request *request)
		{
		int err = -EINPROGRESS;

		if (unlikely(queue->qlen >= queue->max_qlen)) {
		err = -EBUSY;
		if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG))
		goto out;
		if (queue->backlog == &queue->list)
		queue->backlog = &request->list;
		}

		queue->qlen++;
		list_add_tail(&request->list, &queue->list);

		out:
		return err;
		}
		EXPORT_SYMBOL_GPL(crypto_enqueue_request);

		struct crypto_async_request crypto_dequeue_request(struct crypto_queue queue)
		{
		struct list_head *request;

		if (unlikely(!queue->qlen))
		return NULL;

		queue->qlen--;

		if (queue->backlog != &queue->list)
		queue->backlog = queue->backlog->next;

		request = queue->list.next;
		list_del(request);

		return list_entry(request, struct crypto_async_request, list);
		}
		EXPORT_SYMBOL_GPL(crypto_dequeue_request);

		int crypto_tfm_in_queue(struct crypto_queue queue, struct crypto_tfm tfm)
		{
		struct crypto_async_request *req;

		list_for_each_entry(req, &queue->list, list) {
		if (req->tfm == tfm)
		return 1;
		}

		return 0;
		}
		EXPORT_SYMBOL_GPL(crypto_tfm_in_queue);

		static int __init crypto_algapi_init(void)
		{
		crypto_init_proc();

crypto/blkcipher.c

+66 −6

Original line number	Diff line number	Diff line
		@@ -349,13 +349,48 @@ static int setkey(struct crypto_tfm tfm, const u8 key,
		return cipher->setkey(tfm, key, keylen);
		}

		static int async_setkey(struct crypto_ablkcipher tfm, const u8 key,
		unsigned int keylen)
		{
		return setkey(crypto_ablkcipher_tfm(tfm), key, keylen);
		}

		static int async_encrypt(struct ablkcipher_request *req)
		{
		struct crypto_tfm *tfm = req->base.tfm;
		struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
		struct blkcipher_desc desc = {
		.tfm = __crypto_blkcipher_cast(tfm),
		.info = req->info,
		.flags = req->base.flags,
		};


		return alg->encrypt(&desc, req->dst, req->src, req->nbytes);
		}

		static int async_decrypt(struct ablkcipher_request *req)
		{
		struct crypto_tfm *tfm = req->base.tfm;
		struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
		struct blkcipher_desc desc = {
		.tfm = __crypto_blkcipher_cast(tfm),
		.info = req->info,
		.flags = req->base.flags,
		};

		return alg->decrypt(&desc, req->dst, req->src, req->nbytes);
		}

		static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type,
		u32 mask)
		{
		struct blkcipher_alg *cipher = &alg->cra_blkcipher;
		unsigned int len = alg->cra_ctxsize;

		if (cipher->ivsize) {
		type ^= CRYPTO_ALG_ASYNC;
		mask &= CRYPTO_ALG_ASYNC;
		if ((type & mask) && cipher->ivsize) {
		len = ALIGN(len, (unsigned long)alg->cra_alignmask + 1);
		len += cipher->ivsize;
		}
		@@ -363,16 +398,26 @@ static unsigned int crypto_blkcipher_ctxsize(struct crypto_alg *alg, u32 type,
		return len;
		}

		static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
		static int crypto_init_blkcipher_ops_async(struct crypto_tfm *tfm)
		{
		struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
		struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;

		crt->setkey = async_setkey;
		crt->encrypt = async_encrypt;
		crt->decrypt = async_decrypt;
		crt->ivsize = alg->ivsize;

		return 0;
		}

		static int crypto_init_blkcipher_ops_sync(struct crypto_tfm *tfm)
		{
		struct blkcipher_tfm *crt = &tfm->crt_blkcipher;
		struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
		unsigned long align = crypto_tfm_alg_alignmask(tfm) + 1;
		unsigned long addr;

		if (alg->ivsize > PAGE_SIZE / 8)
		return -EINVAL;

		crt->setkey = setkey;
		crt->encrypt = alg->encrypt;
		crt->decrypt = alg->decrypt;
		@@ -385,8 +430,23 @@ static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
		return 0;
		}

		static int crypto_init_blkcipher_ops(struct crypto_tfm *tfm, u32 type, u32 mask)
		{
		struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;

		if (alg->ivsize > PAGE_SIZE / 8)
		return -EINVAL;

		type ^= CRYPTO_ALG_ASYNC;
		mask &= CRYPTO_ALG_ASYNC;
		if (type & mask)
		return crypto_init_blkcipher_ops_sync(tfm);
		else
		return crypto_init_blkcipher_ops_async(tfm);
		}

		static void crypto_blkcipher_show(struct seq_file m, struct crypto_alg alg)
		__attribute_used__;
		__attribute__ ((unused));
		static void crypto_blkcipher_show(struct seq_file m, struct crypto_alg alg)
		{
		seq_printf(m, "type : blkcipher\n");

Admin message