[linux-2.6-block.git] / crypto / cfb.c

//SPDX-License-Identifier: GPL-2.0
/*
 * CFB: Cipher FeedBack mode
 *
 * Copyright (c) 2018 James.Bottomley@HansenPartnership.com
 *
 * CFB is a stream cipher mode which is layered on to a block
 * encryption scheme.  It works very much like a one time pad where
 * the pad is generated initially from the encrypted IV and then
 * subsequently from the encrypted previous block of ciphertext.  The
 * pad is XOR'd into the plain text to get the final ciphertext.
 *
 * The scheme of CFB is best described by wikipedia:
 *
 * https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#CFB
 *
 * Note that since the pad for both encryption and decryption is
 * generated by an encryption operation, CFB never uses the block
 * decryption function.
 */

#include <crypto/algapi.h>
#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/string.h>
#include <linux/types.h>

struct crypto_cfb_ctx {
	struct crypto_cipher *child;
};

static unsigned int crypto_cfb_bsize(struct crypto_skcipher *tfm)
{
	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
	struct crypto_cipher *child = ctx->child;

	return crypto_cipher_blocksize(child);
}

static void crypto_cfb_encrypt_one(struct crypto_skcipher *tfm,
					  const u8 *src, u8 *dst)
{
	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);

	crypto_cipher_encrypt_one(ctx->child, dst, src);
}

/* final encrypt and decrypt is the same */
static void crypto_cfb_final(struct skcipher_walk *walk,
			     struct crypto_skcipher *tfm)
{
	const unsigned long alignmask = crypto_skcipher_alignmask(tfm);
	u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
	u8 *stream = PTR_ALIGN(tmp + 0, alignmask + 1);
	u8 *src = walk->src.virt.addr;
	u8 *dst = walk->dst.virt.addr;
	u8 *iv = walk->iv;
	unsigned int nbytes = walk->nbytes;

	crypto_cfb_encrypt_one(tfm, iv, stream);
	crypto_xor_cpy(dst, stream, src, nbytes);
}

static int crypto_cfb_encrypt_segment(struct skcipher_walk *walk,
				      struct crypto_skcipher *tfm)
{
	const unsigned int bsize = crypto_cfb_bsize(tfm);
	unsigned int nbytes = walk->nbytes;
	u8 *src = walk->src.virt.addr;
	u8 *dst = walk->dst.virt.addr;
	u8 *iv = walk->iv;

	do {
		crypto_cfb_encrypt_one(tfm, iv, dst);
		crypto_xor(dst, src, bsize);
		memcpy(iv, dst, bsize);

		src += bsize;
		dst += bsize;
	} while ((nbytes -= bsize) >= bsize);

	return nbytes;
}

static int crypto_cfb_encrypt_inplace(struct skcipher_walk *walk,
				      struct crypto_skcipher *tfm)
{
	const unsigned int bsize = crypto_cfb_bsize(tfm);
	unsigned int nbytes = walk->nbytes;
	u8 *src = walk->src.virt.addr;
	u8 *iv = walk->iv;
	u8 tmp[MAX_CIPHER_BLOCKSIZE];

	do {
		crypto_cfb_encrypt_one(tfm, iv, tmp);
		crypto_xor(src, tmp, bsize);
		iv = src;

		src += bsize;
	} while ((nbytes -= bsize) >= bsize);

	memcpy(walk->iv, iv, bsize);

	return nbytes;
}

static int crypto_cfb_encrypt(struct skcipher_request *req)
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct skcipher_walk walk;
	unsigned int bsize = crypto_cfb_bsize(tfm);
	int err;

	err = skcipher_walk_virt(&walk, req, false);

	while (walk.nbytes >= bsize) {
		if (walk.src.virt.addr == walk.dst.virt.addr)
			err = crypto_cfb_encrypt_inplace(&walk, tfm);
		else
			err = crypto_cfb_encrypt_segment(&walk, tfm);
		err = skcipher_walk_done(&walk, err);
	}

	if (walk.nbytes) {
		crypto_cfb_final(&walk, tfm);
		err = skcipher_walk_done(&walk, 0);
	}

	return err;
}

static int crypto_cfb_decrypt_segment(struct skcipher_walk *walk,
				      struct crypto_skcipher *tfm)
{
	const unsigned int bsize = crypto_cfb_bsize(tfm);
	unsigned int nbytes = walk->nbytes;
	u8 *src = walk->src.virt.addr;
	u8 *dst = walk->dst.virt.addr;
	u8 *iv = walk->iv;

	do {
		crypto_cfb_encrypt_one(tfm, iv, dst);
		crypto_xor(dst, iv, bsize);
		iv = src;

		src += bsize;
		dst += bsize;
	} while ((nbytes -= bsize) >= bsize);

	memcpy(walk->iv, iv, bsize);

	return nbytes;
}

static int crypto_cfb_decrypt_inplace(struct skcipher_walk *walk,
				      struct crypto_skcipher *tfm)
{
	const unsigned int bsize = crypto_cfb_bsize(tfm);
	unsigned int nbytes = walk->nbytes;
	u8 *src = walk->src.virt.addr;
	u8 *iv = walk->iv;
	u8 tmp[MAX_CIPHER_BLOCKSIZE];

	do {
		crypto_cfb_encrypt_one(tfm, iv, tmp);
		memcpy(iv, src, bsize);
		crypto_xor(src, tmp, bsize);
		src += bsize;
	} while ((nbytes -= bsize) >= bsize);

	memcpy(walk->iv, iv, bsize);

	return nbytes;
}

static int crypto_cfb_decrypt_blocks(struct skcipher_walk *walk,
				     struct crypto_skcipher *tfm)
{
	if (walk->src.virt.addr == walk->dst.virt.addr)
		return crypto_cfb_decrypt_inplace(walk, tfm);
	else
		return crypto_cfb_decrypt_segment(walk, tfm);
}

static int crypto_cfb_setkey(struct crypto_skcipher *parent, const u8 *key,
			     unsigned int keylen)
{
	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(parent);
	struct crypto_cipher *child = ctx->child;
	int err;

	crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
	crypto_cipher_set_flags(child, crypto_skcipher_get_flags(parent) &
				       CRYPTO_TFM_REQ_MASK);
	err = crypto_cipher_setkey(child, key, keylen);
	crypto_skcipher_set_flags(parent, crypto_cipher_get_flags(child) &
					  CRYPTO_TFM_RES_MASK);
	return err;
}

static int crypto_cfb_decrypt(struct skcipher_request *req)
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct skcipher_walk walk;
	const unsigned int bsize = crypto_cfb_bsize(tfm);
	int err;

	err = skcipher_walk_virt(&walk, req, false);

	while (walk.nbytes >= bsize) {
		err = crypto_cfb_decrypt_blocks(&walk, tfm);
		err = skcipher_walk_done(&walk, err);
	}

	if (walk.nbytes) {
		crypto_cfb_final(&walk, tfm);
		err = skcipher_walk_done(&walk, 0);
	}

	return err;
}

static int crypto_cfb_init_tfm(struct crypto_skcipher *tfm)
{
	struct skcipher_instance *inst = skcipher_alg_instance(tfm);
	struct crypto_spawn *spawn = skcipher_instance_ctx(inst);
	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
	struct crypto_cipher *cipher;

	cipher = crypto_spawn_cipher(spawn);
	if (IS_ERR(cipher))
		return PTR_ERR(cipher);

	ctx->child = cipher;
	return 0;
}

static void crypto_cfb_exit_tfm(struct crypto_skcipher *tfm)
{
	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);

	crypto_free_cipher(ctx->child);
}

static void crypto_cfb_free(struct skcipher_instance *inst)
{
	crypto_drop_skcipher(skcipher_instance_ctx(inst));
	kfree(inst);
}

static int crypto_cfb_create(struct crypto_template *tmpl, struct rtattr **tb)
{
	struct skcipher_instance *inst;
	struct crypto_attr_type *algt;
	struct crypto_spawn *spawn;
	struct crypto_alg *alg;
	u32 mask;
	int err;

	err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER);
	if (err)
		return err;

	inst = kzalloc(sizeof(*inst) + sizeof(*spawn), GFP_KERNEL);
	if (!inst)
		return -ENOMEM;

	algt = crypto_get_attr_type(tb);
	err = PTR_ERR(algt);
	if (IS_ERR(algt))
		goto err_free_inst;

	mask = CRYPTO_ALG_TYPE_MASK |
		crypto_requires_off(algt->type, algt->mask,
				    CRYPTO_ALG_NEED_FALLBACK);

	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, mask);
	err = PTR_ERR(alg);
	if (IS_ERR(alg))
		goto err_free_inst;

	spawn = skcipher_instance_ctx(inst);
	err = crypto_init_spawn(spawn, alg, skcipher_crypto_instance(inst),
				CRYPTO_ALG_TYPE_MASK);
	crypto_mod_put(alg);
	if (err)
		goto err_free_inst;

	err = crypto_inst_setname(skcipher_crypto_instance(inst), "cfb", alg);
	if (err)
		goto err_drop_spawn;

	inst->alg.base.cra_priority = alg->cra_priority;
	/* we're a stream cipher independend of the crypto cra_blocksize */
	inst->alg.base.cra_blocksize = 1;
	inst->alg.base.cra_alignmask = alg->cra_alignmask;

	inst->alg.ivsize = alg->cra_blocksize;
	inst->alg.min_keysize = alg->cra_cipher.cia_min_keysize;
	inst->alg.max_keysize = alg->cra_cipher.cia_max_keysize;

	inst->alg.base.cra_ctxsize = sizeof(struct crypto_cfb_ctx);

	inst->alg.init = crypto_cfb_init_tfm;
	inst->alg.exit = crypto_cfb_exit_tfm;

	inst->alg.setkey = crypto_cfb_setkey;
	inst->alg.encrypt = crypto_cfb_encrypt;
	inst->alg.decrypt = crypto_cfb_decrypt;

	inst->free = crypto_cfb_free;

	err = skcipher_register_instance(tmpl, inst);
	if (err)
		goto err_drop_spawn;

out:
	return err;

err_drop_spawn:
	crypto_drop_spawn(spawn);
err_free_inst:
	kfree(inst);
	goto out;
}

static struct crypto_template crypto_cfb_tmpl = {
	.name = "cfb",
	.create = crypto_cfb_create,
	.module = THIS_MODULE,
};

static int __init crypto_cfb_module_init(void)
{
	return crypto_register_template(&crypto_cfb_tmpl);
}

static void __exit crypto_cfb_module_exit(void)
{
	crypto_unregister_template(&crypto_cfb_tmpl);
}

module_init(crypto_cfb_module_init);
module_exit(crypto_cfb_module_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("CFB block cipher algorithm");
MODULE_ALIAS_CRYPTO("cfb");
Commit	Line	Data
a7d85e06 JB	1	//SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* CFB: Cipher FeedBack mode
	4	*
	5	* Copyright (c) 2018 James.Bottomley@HansenPartnership.com
	6	*
	7	* CFB is a stream cipher mode which is layered on to a block
	8	* encryption scheme. It works very much like a one time pad where
	9	* the pad is generated initially from the encrypted IV and then
	10	* subsequently from the encrypted previous block of ciphertext. The
	11	* pad is XOR'd into the plain text to get the final ciphertext.
	12	*
	13	* The scheme of CFB is best described by wikipedia:
	14	*
	15	* https://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#CFB
	16	*
	17	* Note that since the pad for both encryption and decryption is
	18	* generated by an encryption operation, CFB never uses the block
	19	* decryption function.
	20	*/
	21
	22	#include <crypto/algapi.h>
	23	#include <crypto/internal/skcipher.h>
	24	#include <linux/err.h>
	25	#include <linux/init.h>
	26	#include <linux/kernel.h>
	27	#include <linux/module.h>
	28	#include <linux/slab.h>
	29	#include <linux/string.h>
	30	#include <linux/types.h>
	31
	32	struct crypto_cfb_ctx {
	33	struct crypto_cipher *child;
	34	};
	35
	36	static unsigned int crypto_cfb_bsize(struct crypto_skcipher *tfm)
	37	{
	38	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
	39	struct crypto_cipher *child = ctx->child;
	40
	41	return crypto_cipher_blocksize(child);
	42	}
	43
	44	static void crypto_cfb_encrypt_one(struct crypto_skcipher *tfm,
	45	const u8 src, u8 dst)
	46	{
	47	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
	48
	49	crypto_cipher_encrypt_one(ctx->child, dst, src);
	50	}
	51
	52	/* final encrypt and decrypt is the same */
	53	static void crypto_cfb_final(struct skcipher_walk *walk,
	54	struct crypto_skcipher *tfm)
	55	{
a7d85e06	56	const unsigned long alignmask = crypto_skcipher_alignmask(tfm);
6650c4de	57	u8 tmp[MAX_CIPHER_BLOCKSIZE + MAX_CIPHER_ALIGNMASK];
a7d85e06 JB	58	u8 *stream = PTR_ALIGN(tmp + 0, alignmask + 1);
	59	u8 *src = walk->src.virt.addr;
	60	u8 *dst = walk->dst.virt.addr;
	61	u8 *iv = walk->iv;
	62	unsigned int nbytes = walk->nbytes;
	63
	64	crypto_cfb_encrypt_one(tfm, iv, stream);
	65	crypto_xor_cpy(dst, stream, src, nbytes);
	66	}
	67
	68	static int crypto_cfb_encrypt_segment(struct skcipher_walk *walk,
	69	struct crypto_skcipher *tfm)
	70	{
	71	const unsigned int bsize = crypto_cfb_bsize(tfm);
	72	unsigned int nbytes = walk->nbytes;
	73	u8 *src = walk->src.virt.addr;
	74	u8 *dst = walk->dst.virt.addr;
	75	u8 *iv = walk->iv;
	76
	77	do {
	78	crypto_cfb_encrypt_one(tfm, iv, dst);
	79	crypto_xor(dst, src, bsize);
	80	memcpy(iv, dst, bsize);
	81
	82	src += bsize;
	83	dst += bsize;
	84	} while ((nbytes -= bsize) >= bsize);
	85
	86	return nbytes;
	87	}
	88
	89	static int crypto_cfb_encrypt_inplace(struct skcipher_walk *walk,
	90	struct crypto_skcipher *tfm)
	91	{
	92	const unsigned int bsize = crypto_cfb_bsize(tfm);
	93	unsigned int nbytes = walk->nbytes;
	94	u8 *src = walk->src.virt.addr;
	95	u8 *iv = walk->iv;
6650c4de	96	u8 tmp[MAX_CIPHER_BLOCKSIZE];
a7d85e06 JB	97
	98	do {
	99	crypto_cfb_encrypt_one(tfm, iv, tmp);
	100	crypto_xor(src, tmp, bsize);
	101	iv = src;
	102
	103	src += bsize;
	104	} while ((nbytes -= bsize) >= bsize);
	105
	106	memcpy(walk->iv, iv, bsize);
	107
	108	return nbytes;
	109	}
	110
	111	static int crypto_cfb_encrypt(struct skcipher_request *req)
	112	{
	113	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	114	struct skcipher_walk walk;
	115	unsigned int bsize = crypto_cfb_bsize(tfm);
	116	int err;
	117
	118	err = skcipher_walk_virt(&walk, req, false);
	119
	120	while (walk.nbytes >= bsize) {
	121	if (walk.src.virt.addr == walk.dst.virt.addr)
	122	err = crypto_cfb_encrypt_inplace(&walk, tfm);
	123	else
	124	err = crypto_cfb_encrypt_segment(&walk, tfm);
	125	err = skcipher_walk_done(&walk, err);
	126	}
	127
	128	if (walk.nbytes) {
	129	crypto_cfb_final(&walk, tfm);
	130	err = skcipher_walk_done(&walk, 0);
	131	}
	132
	133	return err;
	134	}
	135
	136	static int crypto_cfb_decrypt_segment(struct skcipher_walk *walk,
	137	struct crypto_skcipher *tfm)
	138	{
	139	const unsigned int bsize = crypto_cfb_bsize(tfm);
	140	unsigned int nbytes = walk->nbytes;
	141	u8 *src = walk->src.virt.addr;
	142	u8 *dst = walk->dst.virt.addr;
	143	u8 *iv = walk->iv;
	144
	145	do {
	146	crypto_cfb_encrypt_one(tfm, iv, dst);
	147	crypto_xor(dst, iv, bsize);
	148	iv = src;
	149
	150	src += bsize;
	151	dst += bsize;
	152	} while ((nbytes -= bsize) >= bsize);
	153
	154	memcpy(walk->iv, iv, bsize);
	155
	156	return nbytes;
	157	}
	158
	159	static int crypto_cfb_decrypt_inplace(struct skcipher_walk *walk,
	160	struct crypto_skcipher *tfm)
161	{
162	const unsigned int bsize = crypto_cfb_bsize(tfm);
163	unsigned int nbytes = walk->nbytes;
164	u8 *src = walk->src.virt.addr;
165	u8 *iv = walk->iv;
6650c4de	166	u8 tmp[MAX_CIPHER_BLOCKSIZE];
a7d85e06 JB	167
	168	do {
	169	crypto_cfb_encrypt_one(tfm, iv, tmp);
	170	memcpy(iv, src, bsize);
	171	crypto_xor(src, tmp, bsize);
	172	src += bsize;
	173	} while ((nbytes -= bsize) >= bsize);
	174
	175	memcpy(walk->iv, iv, bsize);
	176
	177	return nbytes;
	178	}
	179
	180	static int crypto_cfb_decrypt_blocks(struct skcipher_walk *walk,
	181	struct crypto_skcipher *tfm)
	182	{
	183	if (walk->src.virt.addr == walk->dst.virt.addr)
	184	return crypto_cfb_decrypt_inplace(walk, tfm);
	185	else
	186	return crypto_cfb_decrypt_segment(walk, tfm);
	187	}
	188
	189	static int crypto_cfb_setkey(struct crypto_skcipher parent, const u8 key,
	190	unsigned int keylen)
	191	{
	192	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(parent);
	193	struct crypto_cipher *child = ctx->child;
	194	int err;
	195
	196	crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK);
	197	crypto_cipher_set_flags(child, crypto_skcipher_get_flags(parent) &
	198	CRYPTO_TFM_REQ_MASK);
	199	err = crypto_cipher_setkey(child, key, keylen);
	200	crypto_skcipher_set_flags(parent, crypto_cipher_get_flags(child) &
	201	CRYPTO_TFM_RES_MASK);
	202	return err;
	203	}
	204
	205	static int crypto_cfb_decrypt(struct skcipher_request *req)
	206	{
	207	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	208	struct skcipher_walk walk;
	209	const unsigned int bsize = crypto_cfb_bsize(tfm);
	210	int err;
	211
	212	err = skcipher_walk_virt(&walk, req, false);
	213
	214	while (walk.nbytes >= bsize) {
	215	err = crypto_cfb_decrypt_blocks(&walk, tfm);
	216	err = skcipher_walk_done(&walk, err);
	217	}
	218
	219	if (walk.nbytes) {
	220	crypto_cfb_final(&walk, tfm);
	221	err = skcipher_walk_done(&walk, 0);
	222	}
	223
	224	return err;
	225	}
	226
	227	static int crypto_cfb_init_tfm(struct crypto_skcipher *tfm)
	228	{
	229	struct skcipher_instance *inst = skcipher_alg_instance(tfm);
	230	struct crypto_spawn *spawn = skcipher_instance_ctx(inst);
231	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
232	struct crypto_cipher *cipher;
233
234	cipher = crypto_spawn_cipher(spawn);
235	if (IS_ERR(cipher))
236	return PTR_ERR(cipher);
237
238	ctx->child = cipher;
239	return 0;
240	}
241
242	static void crypto_cfb_exit_tfm(struct crypto_skcipher *tfm)
243	{
244	struct crypto_cfb_ctx *ctx = crypto_skcipher_ctx(tfm);
245
246	crypto_free_cipher(ctx->child);
247	}
248
249	static void crypto_cfb_free(struct skcipher_instance *inst)
250	{
251	crypto_drop_skcipher(skcipher_instance_ctx(inst));
252	kfree(inst);
253	}
254
255	static int crypto_cfb_create(struct crypto_template tmpl, struct rtattr *tb)
256	{
257	struct skcipher_instance *inst;
258	struct crypto_attr_type *algt;
259	struct crypto_spawn *spawn;
260	struct crypto_alg *alg;
261	u32 mask;
262	int err;
263
264	err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SKCIPHER);
265	if (err)
266	return err;
267
268	inst = kzalloc(sizeof(inst) + sizeof(spawn), GFP_KERNEL);
269	if (!inst)
270	return -ENOMEM;
271
272	algt = crypto_get_attr_type(tb);
273	err = PTR_ERR(algt);
274	if (IS_ERR(algt))
275	goto err_free_inst;
276
277	mask = CRYPTO_ALG_TYPE_MASK \|
278	crypto_requires_off(algt->type, algt->mask,
279	CRYPTO_ALG_NEED_FALLBACK);
280
281	alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, mask);
282	err = PTR_ERR(alg);
283	if (IS_ERR(alg))
284	goto err_free_inst;
285
286	spawn = skcipher_instance_ctx(inst);
287	err = crypto_init_spawn(spawn, alg, skcipher_crypto_instance(inst),
288	CRYPTO_ALG_TYPE_MASK);
289	crypto_mod_put(alg);
290	if (err)
291	goto err_free_inst;
292
293	err = crypto_inst_setname(skcipher_crypto_instance(inst), "cfb", alg);
294	if (err)
295	goto err_drop_spawn;
296
297	inst->alg.base.cra_priority = alg->cra_priority;
298	/* we're a stream cipher independend of the crypto cra_blocksize */
299	inst->alg.base.cra_blocksize = 1;
300	inst->alg.base.cra_alignmask = alg->cra_alignmask;
301
302	inst->alg.ivsize = alg->cra_blocksize;
303	inst->alg.min_keysize = alg->cra_cipher.cia_min_keysize;
304	inst->alg.max_keysize = alg->cra_cipher.cia_max_keysize;
305
306	inst->alg.base.cra_ctxsize = sizeof(struct crypto_cfb_ctx);
307
308	inst->alg.init = crypto_cfb_init_tfm;
309	inst->alg.exit = crypto_cfb_exit_tfm;
310
311	inst->alg.setkey = crypto_cfb_setkey;
312	inst->alg.encrypt = crypto_cfb_encrypt;
313	inst->alg.decrypt = crypto_cfb_decrypt;
314
315	inst->free = crypto_cfb_free;
316
317	err = skcipher_register_instance(tmpl, inst);
318	if (err)
319	goto err_drop_spawn;
320
321	out:
322	return err;
323
324	err_drop_spawn:
325	crypto_drop_spawn(spawn);
326	err_free_inst:
327	kfree(inst);
328	goto out;
329	}
330
331	static struct crypto_template crypto_cfb_tmpl = {
332	.name = "cfb",
333	.create = crypto_cfb_create,
334	.module = THIS_MODULE,
335	};
336
337	static int __init crypto_cfb_module_init(void)
338	{
339	return crypto_register_template(&crypto_cfb_tmpl);
340	}
341
342	static void __exit crypto_cfb_module_exit(void)
343	{
344	crypto_unregister_template(&crypto_cfb_tmpl);
345	}
346
347	module_init(crypto_cfb_module_init);
348	module_exit(crypto_cfb_module_exit);
349
350	MODULE_LICENSE("GPL");
351	MODULE_DESCRIPTION("CFB block cipher algorithm");
352	MODULE_ALIAS_CRYPTO("cfb");