[thirdparty/kernel/stable.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);
		iv = dst;

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

	memcpy(walk->iv, iv, 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, src, 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 * const 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);

	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);
	if (err)
		goto err_put_alg;

	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;

	/*
	 * To simplify the implementation, configure the skcipher walk to only
	 * give a partial block at the very end, never earlier.
	 */
	inst->alg.chunksize = alg->cra_blocksize;

	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;
	crypto_mod_put(alg);

out:
	return err;

err_drop_spawn:
	crypto_drop_spawn(spawn);
err_put_alg:
	crypto_mod_put(alg);
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);
6c2e322b	80	iv = dst;
a7d85e06 JB	81
	82	src += bsize;
	83	dst += bsize;
	84	} while ((nbytes -= bsize) >= bsize);
	85
6c2e322b EB	86	memcpy(walk->iv, iv, bsize);
6c2e322b EB	87
a7d85e06 JB	88	return nbytes;
	89	}
	90
	91	static int crypto_cfb_encrypt_inplace(struct skcipher_walk *walk,
	92	struct crypto_skcipher *tfm)
	93	{
	94	const unsigned int bsize = crypto_cfb_bsize(tfm);
	95	unsigned int nbytes = walk->nbytes;
	96	u8 *src = walk->src.virt.addr;
	97	u8 *iv = walk->iv;
6650c4de	98	u8 tmp[MAX_CIPHER_BLOCKSIZE];
a7d85e06 JB	99
	100	do {
	101	crypto_cfb_encrypt_one(tfm, iv, tmp);
	102	crypto_xor(src, tmp, bsize);
	103	iv = src;
	104
	105	src += bsize;
	106	} while ((nbytes -= bsize) >= bsize);
	107
	108	memcpy(walk->iv, iv, bsize);
	109
	110	return nbytes;
	111	}
	112
	113	static int crypto_cfb_encrypt(struct skcipher_request *req)
	114	{
	115	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	116	struct skcipher_walk walk;
	117	unsigned int bsize = crypto_cfb_bsize(tfm);
	118	int err;
	119
	120	err = skcipher_walk_virt(&walk, req, false);
	121
	122	while (walk.nbytes >= bsize) {
	123	if (walk.src.virt.addr == walk.dst.virt.addr)
	124	err = crypto_cfb_encrypt_inplace(&walk, tfm);
	125	else
	126	err = crypto_cfb_encrypt_segment(&walk, tfm);
	127	err = skcipher_walk_done(&walk, err);
	128	}
	129
	130	if (walk.nbytes) {
	131	crypto_cfb_final(&walk, tfm);
	132	err = skcipher_walk_done(&walk, 0);
	133	}
	134
	135	return err;
	136	}
	137
	138	static int crypto_cfb_decrypt_segment(struct skcipher_walk *walk,
	139	struct crypto_skcipher *tfm)
	140	{
	141	const unsigned int bsize = crypto_cfb_bsize(tfm);
	142	unsigned int nbytes = walk->nbytes;
	143	u8 *src = walk->src.virt.addr;
	144	u8 *dst = walk->dst.virt.addr;
	145	u8 *iv = walk->iv;
	146
	147	do {
	148	crypto_cfb_encrypt_one(tfm, iv, dst);
fa460073	149	crypto_xor(dst, src, bsize);
a7d85e06 JB	150	iv = src;
	151
	152	src += bsize;
	153	dst += bsize;
	154	} while ((nbytes -= bsize) >= bsize);
	155
	156	memcpy(walk->iv, iv, bsize);
	157
	158	return nbytes;
	159	}
	160
	161	static int crypto_cfb_decrypt_inplace(struct skcipher_walk *walk,
	162	struct crypto_skcipher *tfm)
	163	{
	164	const unsigned int bsize = crypto_cfb_bsize(tfm);
	165	unsigned int nbytes = walk->nbytes;
	166	u8 *src = walk->src.virt.addr;
6c2e322b	167	u8 * const iv = walk->iv;
6650c4de	168	u8 tmp[MAX_CIPHER_BLOCKSIZE];
a7d85e06 JB	169
	170	do {
	171	crypto_cfb_encrypt_one(tfm, iv, tmp);
	172	memcpy(iv, src, bsize);
	173	crypto_xor(src, tmp, bsize);
	174	src += bsize;
	175	} while ((nbytes -= bsize) >= bsize);
	176
a7d85e06 JB	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);
a7d85e06	289	if (err)
e5bde04c	290	goto err_put_alg;
a7d85e06 JB	291
	292	err = crypto_inst_setname(skcipher_crypto_instance(inst), "cfb", alg);
	293	if (err)
	294	goto err_drop_spawn;
	295
	296	inst->alg.base.cra_priority = alg->cra_priority;
	297	/* we're a stream cipher independend of the crypto cra_blocksize */
	298	inst->alg.base.cra_blocksize = 1;
	299	inst->alg.base.cra_alignmask = alg->cra_alignmask;
	300
394a9e04 EB	301	/*
	302	* To simplify the implementation, configure the skcipher walk to only
	303	* give a partial block at the very end, never earlier.
	304	*/
	305	inst->alg.chunksize = alg->cra_blocksize;
	306
a7d85e06 JB	307	inst->alg.ivsize = alg->cra_blocksize;
	308	inst->alg.min_keysize = alg->cra_cipher.cia_min_keysize;
	309	inst->alg.max_keysize = alg->cra_cipher.cia_max_keysize;
	310
	311	inst->alg.base.cra_ctxsize = sizeof(struct crypto_cfb_ctx);
	312
	313	inst->alg.init = crypto_cfb_init_tfm;
	314	inst->alg.exit = crypto_cfb_exit_tfm;
	315
	316	inst->alg.setkey = crypto_cfb_setkey;
	317	inst->alg.encrypt = crypto_cfb_encrypt;
	318	inst->alg.decrypt = crypto_cfb_decrypt;
	319
	320	inst->free = crypto_cfb_free;
	321
	322	err = skcipher_register_instance(tmpl, inst);
	323	if (err)
	324	goto err_drop_spawn;
e5bde04c	325	crypto_mod_put(alg);
a7d85e06 JB	326
	327	out:
	328	return err;
	329
	330	err_drop_spawn:
	331	crypto_drop_spawn(spawn);
e5bde04c PB	332	err_put_alg:
e5bde04c PB	333	crypto_mod_put(alg);
a7d85e06 JB	334	err_free_inst:
	335	kfree(inst);
	336	goto out;
	337	}
	338
	339	static struct crypto_template crypto_cfb_tmpl = {
	340	.name = "cfb",
	341	.create = crypto_cfb_create,
	342	.module = THIS_MODULE,
	343	};
	344
	345	static int __init crypto_cfb_module_init(void)
	346	{
	347	return crypto_register_template(&crypto_cfb_tmpl);
	348	}
	349
	350	static void __exit crypto_cfb_module_exit(void)
	351	{
	352	crypto_unregister_template(&crypto_cfb_tmpl);
	353	}
	354
	355	module_init(crypto_cfb_module_init);
	356	module_exit(crypto_cfb_module_exit);
	357
	358	MODULE_LICENSE("GPL");
	359	MODULE_DESCRIPTION("CFB block cipher algorithm");
	360	MODULE_ALIAS_CRYPTO("cfb");