[linux-block.git] / crypto / ablkcipher.c

/*
 * 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/internal/skcipher.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/seq_file.h>

#include "internal.h"

static int setkey_unaligned(struct crypto_ablkcipher *tfm, const u8 *key,
			    unsigned int keylen)
{
	struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
	unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);
	int ret;
	u8 *buffer, *alignbuffer;
	unsigned long absize;

	absize = keylen + alignmask;
	buffer = kmalloc(absize, GFP_ATOMIC);
	if (!buffer)
		return -ENOMEM;

	alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
	memcpy(alignbuffer, key, keylen);
	ret = cipher->setkey(tfm, alignbuffer, keylen);
	memset(alignbuffer, 0, keylen);
	kfree(buffer);
	return ret;
}

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

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

	if ((unsigned long)key & alignmask)
		return setkey_unaligned(tfm, key, keylen);

	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);
}

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);

static int no_givdecrypt(struct skcipher_givcrypt_request *req)
{
	return -ENOSYS;
}

static int crypto_init_givcipher_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->givencrypt = alg->givencrypt;
	crt->givdecrypt = alg->givdecrypt ?: no_givdecrypt;
	crt->ivsize = alg->ivsize;

	return 0;
}

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

	seq_printf(m, "type         : givcipher\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);
}

const struct crypto_type crypto_givcipher_type = {
	.ctxsize = crypto_ablkcipher_ctxsize,
	.init = crypto_init_givcipher_ops,
#ifdef CONFIG_PROC_FS
	.show = crypto_givcipher_show,
#endif
};
EXPORT_SYMBOL_GPL(crypto_givcipher_type);

int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn, const char *name,
			 u32 type, u32 mask)
{
	struct crypto_alg *alg;
	int err;

	type = crypto_skcipher_type(type);
	mask = crypto_skcipher_mask(mask);

	alg = crypto_alg_mod_lookup(name, type, mask);
	if (IS_ERR(alg))
		return PTR_ERR(alg);

	err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask);
	crypto_mod_put(alg);
	return err;
}
EXPORT_SYMBOL_GPL(crypto_grab_skcipher);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Asynchronous block chaining cipher type");
Commit	Line	Data
b5b7f088 HX	1	/*
	2	* Asynchronous block chaining cipher operations.
	3	*
	4	* This is the asynchronous version of blkcipher.c indicating completion
	5	* via a callback.
	6	*
	7	* Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au>
	8	*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the Free
	11	* Software Foundation; either version 2 of the License, or (at your option)
	12	* any later version.
	13	*
	14	*/
	15
378f4f51 HX	16	#include <crypto/internal/skcipher.h>
378f4f51 HX	17	#include <linux/err.h>
b5b7f088	18	#include <linux/init.h>
791b4d5f	19	#include <linux/kernel.h>
b5b7f088	20	#include <linux/module.h>
791b4d5f	21	#include <linux/slab.h>
b5b7f088 HX	22	#include <linux/seq_file.h>
b5b7f088 HX	23
378f4f51 HX	24	#include "internal.h"
378f4f51 HX	25
791b4d5f HX	26	static int setkey_unaligned(struct crypto_ablkcipher tfm, const u8 key,
791b4d5f HX	27	unsigned int keylen)
ca7c3938 SS	28	{
	29	struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
	30	unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);
	31	int ret;
	32	u8 buffer, alignbuffer;
	33	unsigned long absize;
	34
	35	absize = keylen + alignmask;
	36	buffer = kmalloc(absize, GFP_ATOMIC);
	37	if (!buffer)
	38	return -ENOMEM;
	39
	40	alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
	41	memcpy(alignbuffer, key, keylen);
	42	ret = cipher->setkey(tfm, alignbuffer, keylen);
06817176	43	memset(alignbuffer, 0, keylen);
ca7c3938 SS	44	kfree(buffer);
	45	return ret;
	46	}
	47
b5b7f088 HX	48	static int setkey(struct crypto_ablkcipher tfm, const u8 key,
	49	unsigned int keylen)
	50	{
	51	struct ablkcipher_alg *cipher = crypto_ablkcipher_alg(tfm);
ca7c3938	52	unsigned long alignmask = crypto_ablkcipher_alignmask(tfm);
b5b7f088 HX	53
	54	if (keylen < cipher->min_keysize \|\| keylen > cipher->max_keysize) {
	55	crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
	56	return -EINVAL;
	57	}
	58
ca7c3938 SS	59	if ((unsigned long)key & alignmask)
	60	return setkey_unaligned(tfm, key, keylen);
	61
b5b7f088 HX	62	return cipher->setkey(tfm, key, keylen);
	63	}
	64
	65	static unsigned int crypto_ablkcipher_ctxsize(struct crypto_alg *alg, u32 type,
	66	u32 mask)
	67	{
	68	return alg->cra_ctxsize;
	69	}
	70
	71	static int crypto_init_ablkcipher_ops(struct crypto_tfm *tfm, u32 type,
	72	u32 mask)
	73	{
	74	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
	75	struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
	76
	77	if (alg->ivsize > PAGE_SIZE / 8)
	78	return -EINVAL;
	79
	80	crt->setkey = setkey;
	81	crt->encrypt = alg->encrypt;
	82	crt->decrypt = alg->decrypt;
	83	crt->ivsize = alg->ivsize;
	84
	85	return 0;
	86	}
	87
	88	static void crypto_ablkcipher_show(struct seq_file m, struct crypto_alg alg)
	89	__attribute__ ((unused));
	90	static void crypto_ablkcipher_show(struct seq_file m, struct crypto_alg alg)
	91	{
	92	struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
	93
	94	seq_printf(m, "type : ablkcipher\n");
	95	seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
	96	seq_printf(m, "min keysize : %u\n", ablkcipher->min_keysize);
	97	seq_printf(m, "max keysize : %u\n", ablkcipher->max_keysize);
	98	seq_printf(m, "ivsize : %u\n", ablkcipher->ivsize);
b5b7f088 HX	99	}
	100
	101	const struct crypto_type crypto_ablkcipher_type = {
	102	.ctxsize = crypto_ablkcipher_ctxsize,
	103	.init = crypto_init_ablkcipher_ops,
	104	#ifdef CONFIG_PROC_FS
	105	.show = crypto_ablkcipher_show,
	106	#endif
	107	};
	108	EXPORT_SYMBOL_GPL(crypto_ablkcipher_type);
	109
61da88e2 HX	110	static int no_givdecrypt(struct skcipher_givcrypt_request *req)
	111	{
	112	return -ENOSYS;
	113	}
	114
	115	static int crypto_init_givcipher_ops(struct crypto_tfm *tfm, u32 type,
	116	u32 mask)
	117	{
	118	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
	119	struct ablkcipher_tfm *crt = &tfm->crt_ablkcipher;
	120
	121	if (alg->ivsize > PAGE_SIZE / 8)
	122	return -EINVAL;
	123
	124	crt->setkey = setkey;
	125	crt->encrypt = alg->encrypt;
	126	crt->decrypt = alg->decrypt;
	127	crt->givencrypt = alg->givencrypt;
	128	crt->givdecrypt = alg->givdecrypt ?: no_givdecrypt;
	129	crt->ivsize = alg->ivsize;
	130
	131	return 0;
	132	}
	133
	134	static void crypto_givcipher_show(struct seq_file m, struct crypto_alg alg)
	135	__attribute__ ((unused));
	136	static void crypto_givcipher_show(struct seq_file m, struct crypto_alg alg)
	137	{
	138	struct ablkcipher_alg *ablkcipher = &alg->cra_ablkcipher;
	139
	140	seq_printf(m, "type : givcipher\n");
	141	seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
	142	seq_printf(m, "min keysize : %u\n", ablkcipher->min_keysize);
	143	seq_printf(m, "max keysize : %u\n", ablkcipher->max_keysize);
	144	seq_printf(m, "ivsize : %u\n", ablkcipher->ivsize);
	145	}
	146
	147	const struct crypto_type crypto_givcipher_type = {
	148	.ctxsize = crypto_ablkcipher_ctxsize,
	149	.init = crypto_init_givcipher_ops,
	150	#ifdef CONFIG_PROC_FS
	151	.show = crypto_givcipher_show,
	152	#endif
	153	};
	154	EXPORT_SYMBOL_GPL(crypto_givcipher_type);
	155
378f4f51 HX	156	int crypto_grab_skcipher(struct crypto_skcipher_spawn spawn, const char name,
	157	u32 type, u32 mask)
	158	{
	159	struct crypto_alg *alg;
	160	int err;
	161
	162	type = crypto_skcipher_type(type);
	163	mask = crypto_skcipher_mask(mask);
	164
	165	alg = crypto_alg_mod_lookup(name, type, mask);
	166	if (IS_ERR(alg))
	167	return PTR_ERR(alg);
	168
	169	err = crypto_init_spawn(&spawn->base, alg, spawn->base.inst, mask);
	170	crypto_mod_put(alg);
	171	return err;
	172	}
	173	EXPORT_SYMBOL_GPL(crypto_grab_skcipher);
	174
b5b7f088 HX	175	MODULE_LICENSE("GPL");
b5b7f088 HX	176	MODULE_DESCRIPTION("Asynchronous block chaining cipher type");