[mirror_ubuntu-artful-kernel.git] / crypto / skcipher.c

/*
 * Symmetric key cipher operations.
 *
 * Generic encrypt/decrypt wrapper for ciphers, handles operations across
 * multiple page boundaries by using temporary blocks.  In user context,
 * the kernel is given a chance to schedule us once per page.
 *
 * Copyright (c) 2015 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/bug.h>
#include <linux/cryptouser.h>
#include <linux/module.h>
#include <linux/rtnetlink.h>
#include <linux/seq_file.h>
#include <net/netlink.h>

#include "internal.h"

static unsigned int crypto_skcipher_extsize(struct crypto_alg *alg)
{
	if (alg->cra_type == &crypto_blkcipher_type)
		return sizeof(struct crypto_blkcipher *);

	if (alg->cra_type == &crypto_ablkcipher_type ||
	    alg->cra_type == &crypto_givcipher_type)
		return sizeof(struct crypto_ablkcipher *);

	return crypto_alg_extsize(alg);
}

static int skcipher_setkey_blkcipher(struct crypto_skcipher *tfm,
				     const u8 *key, unsigned int keylen)
{
	struct crypto_blkcipher **ctx = crypto_skcipher_ctx(tfm);
	struct crypto_blkcipher *blkcipher = *ctx;
	int err;

	crypto_blkcipher_clear_flags(blkcipher, ~0);
	crypto_blkcipher_set_flags(blkcipher, crypto_skcipher_get_flags(tfm) &
					      CRYPTO_TFM_REQ_MASK);
	err = crypto_blkcipher_setkey(blkcipher, key, keylen);
	crypto_skcipher_set_flags(tfm, crypto_blkcipher_get_flags(blkcipher) &
				       CRYPTO_TFM_RES_MASK);

	return err;
}

static int skcipher_crypt_blkcipher(struct skcipher_request *req,
				    int (*crypt)(struct blkcipher_desc *,
						 struct scatterlist *,
						 struct scatterlist *,
						 unsigned int))
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct crypto_blkcipher **ctx = crypto_skcipher_ctx(tfm);
	struct blkcipher_desc desc = {
		.tfm = *ctx,
		.info = req->iv,
		.flags = req->base.flags,
	};


	return crypt(&desc, req->dst, req->src, req->cryptlen);
}

static int skcipher_encrypt_blkcipher(struct skcipher_request *req)
{
	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;

	return skcipher_crypt_blkcipher(req, alg->encrypt);
}

static int skcipher_decrypt_blkcipher(struct skcipher_request *req)
{
	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;

	return skcipher_crypt_blkcipher(req, alg->decrypt);
}

static void crypto_exit_skcipher_ops_blkcipher(struct crypto_tfm *tfm)
{
	struct crypto_blkcipher **ctx = crypto_tfm_ctx(tfm);

	crypto_free_blkcipher(*ctx);
}

static int crypto_init_skcipher_ops_blkcipher(struct crypto_tfm *tfm)
{
	struct crypto_alg *calg = tfm->__crt_alg;
	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	struct crypto_blkcipher **ctx = crypto_tfm_ctx(tfm);
	struct crypto_blkcipher *blkcipher;
	struct crypto_tfm *btfm;

	if (!crypto_mod_get(calg))
		return -EAGAIN;

	btfm = __crypto_alloc_tfm(calg, CRYPTO_ALG_TYPE_BLKCIPHER,
					CRYPTO_ALG_TYPE_MASK);
	if (IS_ERR(btfm)) {
		crypto_mod_put(calg);
		return PTR_ERR(btfm);
	}

	blkcipher = __crypto_blkcipher_cast(btfm);
	*ctx = blkcipher;
	tfm->exit = crypto_exit_skcipher_ops_blkcipher;

	skcipher->setkey = skcipher_setkey_blkcipher;
	skcipher->encrypt = skcipher_encrypt_blkcipher;
	skcipher->decrypt = skcipher_decrypt_blkcipher;

	skcipher->ivsize = crypto_blkcipher_ivsize(blkcipher);
	skcipher->keysize = calg->cra_blkcipher.max_keysize;

	return 0;
}

static int skcipher_setkey_ablkcipher(struct crypto_skcipher *tfm,
				      const u8 *key, unsigned int keylen)
{
	struct crypto_ablkcipher **ctx = crypto_skcipher_ctx(tfm);
	struct crypto_ablkcipher *ablkcipher = *ctx;
	int err;

	crypto_ablkcipher_clear_flags(ablkcipher, ~0);
	crypto_ablkcipher_set_flags(ablkcipher,
				    crypto_skcipher_get_flags(tfm) &
				    CRYPTO_TFM_REQ_MASK);
	err = crypto_ablkcipher_setkey(ablkcipher, key, keylen);
	crypto_skcipher_set_flags(tfm,
				  crypto_ablkcipher_get_flags(ablkcipher) &
				  CRYPTO_TFM_RES_MASK);

	return err;
}

static int skcipher_crypt_ablkcipher(struct skcipher_request *req,
				     int (*crypt)(struct ablkcipher_request *))
{
	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	struct crypto_ablkcipher **ctx = crypto_skcipher_ctx(tfm);
	struct ablkcipher_request *subreq = skcipher_request_ctx(req);

	ablkcipher_request_set_tfm(subreq, *ctx);
	ablkcipher_request_set_callback(subreq, skcipher_request_flags(req),
					req->base.complete, req->base.data);
	ablkcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
				     req->iv);

	return crypt(subreq);
}

static int skcipher_encrypt_ablkcipher(struct skcipher_request *req)
{
	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;

	return skcipher_crypt_ablkcipher(req, alg->encrypt);
}

static int skcipher_decrypt_ablkcipher(struct skcipher_request *req)
{
	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;

	return skcipher_crypt_ablkcipher(req, alg->decrypt);
}

static void crypto_exit_skcipher_ops_ablkcipher(struct crypto_tfm *tfm)
{
	struct crypto_ablkcipher **ctx = crypto_tfm_ctx(tfm);

	crypto_free_ablkcipher(*ctx);
}

static int crypto_init_skcipher_ops_ablkcipher(struct crypto_tfm *tfm)
{
	struct crypto_alg *calg = tfm->__crt_alg;
	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	struct crypto_ablkcipher **ctx = crypto_tfm_ctx(tfm);
	struct crypto_ablkcipher *ablkcipher;
	struct crypto_tfm *abtfm;

	if (!crypto_mod_get(calg))
		return -EAGAIN;

	abtfm = __crypto_alloc_tfm(calg, 0, 0);
	if (IS_ERR(abtfm)) {
		crypto_mod_put(calg);
		return PTR_ERR(abtfm);
	}

	ablkcipher = __crypto_ablkcipher_cast(abtfm);
	*ctx = ablkcipher;
	tfm->exit = crypto_exit_skcipher_ops_ablkcipher;

	skcipher->setkey = skcipher_setkey_ablkcipher;
	skcipher->encrypt = skcipher_encrypt_ablkcipher;
	skcipher->decrypt = skcipher_decrypt_ablkcipher;

	skcipher->ivsize = crypto_ablkcipher_ivsize(ablkcipher);
	skcipher->reqsize = crypto_ablkcipher_reqsize(ablkcipher) +
			    sizeof(struct ablkcipher_request);
	skcipher->keysize = calg->cra_ablkcipher.max_keysize;

	return 0;
}

static void crypto_skcipher_exit_tfm(struct crypto_tfm *tfm)
{
	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);

	alg->exit(skcipher);
}

static int crypto_skcipher_init_tfm(struct crypto_tfm *tfm)
{
	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);

	if (tfm->__crt_alg->cra_type == &crypto_blkcipher_type)
		return crypto_init_skcipher_ops_blkcipher(tfm);

	if (tfm->__crt_alg->cra_type == &crypto_ablkcipher_type ||
	    tfm->__crt_alg->cra_type == &crypto_givcipher_type)
		return crypto_init_skcipher_ops_ablkcipher(tfm);

	skcipher->setkey = alg->setkey;
	skcipher->encrypt = alg->encrypt;
	skcipher->decrypt = alg->decrypt;
	skcipher->ivsize = alg->ivsize;
	skcipher->keysize = alg->max_keysize;

	if (alg->exit)
		skcipher->base.exit = crypto_skcipher_exit_tfm;

	if (alg->init)
		return alg->init(skcipher);

	return 0;
}

static void crypto_skcipher_free_instance(struct crypto_instance *inst)
{
	struct skcipher_instance *skcipher =
		container_of(inst, struct skcipher_instance, s.base);

	skcipher->free(skcipher);
}

static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
	__attribute__ ((unused));
static void crypto_skcipher_show(struct seq_file *m, struct crypto_alg *alg)
{
	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
						     base);

	seq_printf(m, "type         : skcipher\n");
	seq_printf(m, "async        : %s\n",
		   alg->cra_flags & CRYPTO_ALG_ASYNC ?  "yes" : "no");
	seq_printf(m, "blocksize    : %u\n", alg->cra_blocksize);
	seq_printf(m, "min keysize  : %u\n", skcipher->min_keysize);
	seq_printf(m, "max keysize  : %u\n", skcipher->max_keysize);
	seq_printf(m, "ivsize       : %u\n", skcipher->ivsize);
	seq_printf(m, "chunksize    : %u\n", skcipher->chunksize);
}

#ifdef CONFIG_NET
static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
{
	struct crypto_report_blkcipher rblkcipher;
	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
						     base);

	strncpy(rblkcipher.type, "skcipher", sizeof(rblkcipher.type));
	strncpy(rblkcipher.geniv, "<none>", sizeof(rblkcipher.geniv));

	rblkcipher.blocksize = alg->cra_blocksize;
	rblkcipher.min_keysize = skcipher->min_keysize;
	rblkcipher.max_keysize = skcipher->max_keysize;
	rblkcipher.ivsize = skcipher->ivsize;

	if (nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
		    sizeof(struct crypto_report_blkcipher), &rblkcipher))
		goto nla_put_failure;
	return 0;

nla_put_failure:
	return -EMSGSIZE;
}
#else
static int crypto_skcipher_report(struct sk_buff *skb, struct crypto_alg *alg)
{
	return -ENOSYS;
}
#endif

static const struct crypto_type crypto_skcipher_type2 = {
	.extsize = crypto_skcipher_extsize,
	.init_tfm = crypto_skcipher_init_tfm,
	.free = crypto_skcipher_free_instance,
#ifdef CONFIG_PROC_FS
	.show = crypto_skcipher_show,
#endif
	.report = crypto_skcipher_report,
	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
	.maskset = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
	.type = CRYPTO_ALG_TYPE_SKCIPHER,
	.tfmsize = offsetof(struct crypto_skcipher, base),
};

int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
			  const char *name, u32 type, u32 mask)
{
	spawn->base.frontend = &crypto_skcipher_type2;
	return crypto_grab_spawn(&spawn->base, name, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_grab_skcipher);

struct crypto_skcipher *crypto_alloc_skcipher(const char *alg_name,
					      u32 type, u32 mask)
{
	return crypto_alloc_tfm(alg_name, &crypto_skcipher_type2, type, mask);
}
EXPORT_SYMBOL_GPL(crypto_alloc_skcipher);

int crypto_has_skcipher2(const char *alg_name, u32 type, u32 mask)
{
	return crypto_type_has_alg(alg_name, &crypto_skcipher_type2,
				   type, mask);
}
EXPORT_SYMBOL_GPL(crypto_has_skcipher2);

static int skcipher_prepare_alg(struct skcipher_alg *alg)
{
	struct crypto_alg *base = &alg->base;

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

	if (!alg->chunksize)
		alg->chunksize = base->cra_blocksize;

	base->cra_type = &crypto_skcipher_type2;
	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	base->cra_flags |= CRYPTO_ALG_TYPE_SKCIPHER;

	return 0;
}

int crypto_register_skcipher(struct skcipher_alg *alg)
{
	struct crypto_alg *base = &alg->base;
	int err;

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

	return crypto_register_alg(base);
}
EXPORT_SYMBOL_GPL(crypto_register_skcipher);

void crypto_unregister_skcipher(struct skcipher_alg *alg)
{
	crypto_unregister_alg(&alg->base);
}
EXPORT_SYMBOL_GPL(crypto_unregister_skcipher);

int crypto_register_skciphers(struct skcipher_alg *algs, int count)
{
	int i, ret;

	for (i = 0; i < count; i++) {
		ret = crypto_register_skcipher(&algs[i]);
		if (ret)
			goto err;
	}

	return 0;

err:
	for (--i; i >= 0; --i)
		crypto_unregister_skcipher(&algs[i]);

	return ret;
}
EXPORT_SYMBOL_GPL(crypto_register_skciphers);

void crypto_unregister_skciphers(struct skcipher_alg *algs, int count)
{
	int i;

	for (i = count - 1; i >= 0; --i)
		crypto_unregister_skcipher(&algs[i]);
}
EXPORT_SYMBOL_GPL(crypto_unregister_skciphers);

int skcipher_register_instance(struct crypto_template *tmpl,
			   struct skcipher_instance *inst)
{
	int err;

	err = skcipher_prepare_alg(&inst->alg);
	if (err)
		return err;

	return crypto_register_instance(tmpl, skcipher_crypto_instance(inst));
}
EXPORT_SYMBOL_GPL(skcipher_register_instance);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Symmetric key cipher type");
Commit	Line	Data
7a7ffe65 HX	1	/*
	2	* Symmetric key cipher operations.
	3	*
	4	* Generic encrypt/decrypt wrapper for ciphers, handles operations across
	5	* multiple page boundaries by using temporary blocks. In user context,
	6	* the kernel is given a chance to schedule us once per page.
	7	*
	8	* Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License as published by the Free
	12	* Software Foundation; either version 2 of the License, or (at your option)
	13	* any later version.
	14	*
	15	*/
	16
	17	#include <crypto/internal/skcipher.h>
	18	#include <linux/bug.h>
4e6c3df4	19	#include <linux/cryptouser.h>
7a7ffe65	20	#include <linux/module.h>
4e6c3df4 HX	21	#include <linux/rtnetlink.h>
	22	#include <linux/seq_file.h>
	23	#include <net/netlink.h>
7a7ffe65 HX	24
	25	#include "internal.h"
	26
	27	static unsigned int crypto_skcipher_extsize(struct crypto_alg *alg)
	28	{
	29	if (alg->cra_type == &crypto_blkcipher_type)
	30	return sizeof(struct crypto_blkcipher *);
	31
4e6c3df4 HX	32	if (alg->cra_type == &crypto_ablkcipher_type \|\|
	33	alg->cra_type == &crypto_givcipher_type)
	34	return sizeof(struct crypto_ablkcipher *);
7a7ffe65	35
4e6c3df4	36	return crypto_alg_extsize(alg);
7a7ffe65 HX	37	}
	38
	39	static int skcipher_setkey_blkcipher(struct crypto_skcipher *tfm,
	40	const u8 *key, unsigned int keylen)
	41	{
	42	struct crypto_blkcipher **ctx = crypto_skcipher_ctx(tfm);
	43	struct crypto_blkcipher blkcipher = ctx;
	44	int err;
	45
	46	crypto_blkcipher_clear_flags(blkcipher, ~0);
	47	crypto_blkcipher_set_flags(blkcipher, crypto_skcipher_get_flags(tfm) &
	48	CRYPTO_TFM_REQ_MASK);
	49	err = crypto_blkcipher_setkey(blkcipher, key, keylen);
	50	crypto_skcipher_set_flags(tfm, crypto_blkcipher_get_flags(blkcipher) &
	51	CRYPTO_TFM_RES_MASK);
	52
	53	return err;
	54	}
	55
	56	static int skcipher_crypt_blkcipher(struct skcipher_request *req,
	57	int (crypt)(struct blkcipher_desc ,
	58	struct scatterlist *,
	59	struct scatterlist *,
	60	unsigned int))
	61	{
	62	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	63	struct crypto_blkcipher **ctx = crypto_skcipher_ctx(tfm);
	64	struct blkcipher_desc desc = {
	65	.tfm = *ctx,
	66	.info = req->iv,
	67	.flags = req->base.flags,
	68	};
	69
	70
	71	return crypt(&desc, req->dst, req->src, req->cryptlen);
	72	}
	73
	74	static int skcipher_encrypt_blkcipher(struct skcipher_request *req)
	75	{
	76	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	77	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	78	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
	79
	80	return skcipher_crypt_blkcipher(req, alg->encrypt);
	81	}
	82
	83	static int skcipher_decrypt_blkcipher(struct skcipher_request *req)
	84	{
	85	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	86	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	87	struct blkcipher_alg *alg = &tfm->__crt_alg->cra_blkcipher;
	88
	89	return skcipher_crypt_blkcipher(req, alg->decrypt);
	90	}
	91
	92	static void crypto_exit_skcipher_ops_blkcipher(struct crypto_tfm *tfm)
	93	{
	94	struct crypto_blkcipher **ctx = crypto_tfm_ctx(tfm);
	95
	96	crypto_free_blkcipher(*ctx);
	97	}
	98
ecdd6bed	99	static int crypto_init_skcipher_ops_blkcipher(struct crypto_tfm *tfm)
7a7ffe65 HX	100	{
	101	struct crypto_alg *calg = tfm->__crt_alg;
	102	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	103	struct crypto_blkcipher **ctx = crypto_tfm_ctx(tfm);
	104	struct crypto_blkcipher *blkcipher;
	105	struct crypto_tfm *btfm;
	106
	107	if (!crypto_mod_get(calg))
	108	return -EAGAIN;
	109
	110	btfm = __crypto_alloc_tfm(calg, CRYPTO_ALG_TYPE_BLKCIPHER,
	111	CRYPTO_ALG_TYPE_MASK);
	112	if (IS_ERR(btfm)) {
	113	crypto_mod_put(calg);
	114	return PTR_ERR(btfm);
	115	}
	116
	117	blkcipher = __crypto_blkcipher_cast(btfm);
	118	*ctx = blkcipher;
	119	tfm->exit = crypto_exit_skcipher_ops_blkcipher;
	120
	121	skcipher->setkey = skcipher_setkey_blkcipher;
	122	skcipher->encrypt = skcipher_encrypt_blkcipher;
	123	skcipher->decrypt = skcipher_decrypt_blkcipher;
	124
	125	skcipher->ivsize = crypto_blkcipher_ivsize(blkcipher);
973fb3fb	126	skcipher->keysize = calg->cra_blkcipher.max_keysize;
7a7ffe65 HX	127
	128	return 0;
	129	}
	130
	131	static int skcipher_setkey_ablkcipher(struct crypto_skcipher *tfm,
	132	const u8 *key, unsigned int keylen)
	133	{
	134	struct crypto_ablkcipher **ctx = crypto_skcipher_ctx(tfm);
	135	struct crypto_ablkcipher ablkcipher = ctx;
	136	int err;
	137
	138	crypto_ablkcipher_clear_flags(ablkcipher, ~0);
	139	crypto_ablkcipher_set_flags(ablkcipher,
	140	crypto_skcipher_get_flags(tfm) &
	141	CRYPTO_TFM_REQ_MASK);
	142	err = crypto_ablkcipher_setkey(ablkcipher, key, keylen);
	143	crypto_skcipher_set_flags(tfm,
	144	crypto_ablkcipher_get_flags(ablkcipher) &
	145	CRYPTO_TFM_RES_MASK);
	146
	147	return err;
	148	}
	149
	150	static int skcipher_crypt_ablkcipher(struct skcipher_request *req,
	151	int (crypt)(struct ablkcipher_request ))
	152	{
	153	struct crypto_skcipher *tfm = crypto_skcipher_reqtfm(req);
	154	struct crypto_ablkcipher **ctx = crypto_skcipher_ctx(tfm);
	155	struct ablkcipher_request *subreq = skcipher_request_ctx(req);
	156
	157	ablkcipher_request_set_tfm(subreq, *ctx);
	158	ablkcipher_request_set_callback(subreq, skcipher_request_flags(req),
	159	req->base.complete, req->base.data);
	160	ablkcipher_request_set_crypt(subreq, req->src, req->dst, req->cryptlen,
	161	req->iv);
	162
	163	return crypt(subreq);
	164	}
	165
	166	static int skcipher_encrypt_ablkcipher(struct skcipher_request *req)
	167	{
	168	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	169	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	170	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
	171
	172	return skcipher_crypt_ablkcipher(req, alg->encrypt);
	173	}
	174
	175	static int skcipher_decrypt_ablkcipher(struct skcipher_request *req)
	176	{
	177	struct crypto_skcipher *skcipher = crypto_skcipher_reqtfm(req);
	178	struct crypto_tfm *tfm = crypto_skcipher_tfm(skcipher);
	179	struct ablkcipher_alg *alg = &tfm->__crt_alg->cra_ablkcipher;
	180
	181	return skcipher_crypt_ablkcipher(req, alg->decrypt);
	182	}
	183
	184	static void crypto_exit_skcipher_ops_ablkcipher(struct crypto_tfm *tfm)
	185	{
	186	struct crypto_ablkcipher **ctx = crypto_tfm_ctx(tfm);
	187
	188	crypto_free_ablkcipher(*ctx);
	189	}
	190
ecdd6bed	191	static int crypto_init_skcipher_ops_ablkcipher(struct crypto_tfm *tfm)
7a7ffe65 HX	192	{
	193	struct crypto_alg *calg = tfm->__crt_alg;
	194	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	195	struct crypto_ablkcipher **ctx = crypto_tfm_ctx(tfm);
	196	struct crypto_ablkcipher *ablkcipher;
	197	struct crypto_tfm *abtfm;
	198
	199	if (!crypto_mod_get(calg))
	200	return -EAGAIN;
	201
	202	abtfm = __crypto_alloc_tfm(calg, 0, 0);
	203	if (IS_ERR(abtfm)) {
	204	crypto_mod_put(calg);
	205	return PTR_ERR(abtfm);
	206	}
	207
	208	ablkcipher = __crypto_ablkcipher_cast(abtfm);
	209	*ctx = ablkcipher;
	210	tfm->exit = crypto_exit_skcipher_ops_ablkcipher;
	211
	212	skcipher->setkey = skcipher_setkey_ablkcipher;
	213	skcipher->encrypt = skcipher_encrypt_ablkcipher;
	214	skcipher->decrypt = skcipher_decrypt_ablkcipher;
	215
	216	skcipher->ivsize = crypto_ablkcipher_ivsize(ablkcipher);
	217	skcipher->reqsize = crypto_ablkcipher_reqsize(ablkcipher) +
	218	sizeof(struct ablkcipher_request);
973fb3fb	219	skcipher->keysize = calg->cra_ablkcipher.max_keysize;
7a7ffe65 HX	220
	221	return 0;
	222	}
	223
4e6c3df4 HX	224	static void crypto_skcipher_exit_tfm(struct crypto_tfm *tfm)
	225	{
	226	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	227	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
	228
	229	alg->exit(skcipher);
	230	}
	231
7a7ffe65 HX	232	static int crypto_skcipher_init_tfm(struct crypto_tfm *tfm)
7a7ffe65 HX	233	{
4e6c3df4 HX	234	struct crypto_skcipher *skcipher = __crypto_skcipher_cast(tfm);
	235	struct skcipher_alg *alg = crypto_skcipher_alg(skcipher);
	236
7a7ffe65 HX	237	if (tfm->__crt_alg->cra_type == &crypto_blkcipher_type)
	238	return crypto_init_skcipher_ops_blkcipher(tfm);
	239
4e6c3df4 HX	240	if (tfm->__crt_alg->cra_type == &crypto_ablkcipher_type \|\|
	241	tfm->__crt_alg->cra_type == &crypto_givcipher_type)
	242	return crypto_init_skcipher_ops_ablkcipher(tfm);
	243
	244	skcipher->setkey = alg->setkey;
	245	skcipher->encrypt = alg->encrypt;
	246	skcipher->decrypt = alg->decrypt;
	247	skcipher->ivsize = alg->ivsize;
	248	skcipher->keysize = alg->max_keysize;
	249
	250	if (alg->exit)
	251	skcipher->base.exit = crypto_skcipher_exit_tfm;
7a7ffe65	252
4e6c3df4 HX	253	if (alg->init)
	254	return alg->init(skcipher);
	255
	256	return 0;
	257	}
	258
	259	static void crypto_skcipher_free_instance(struct crypto_instance *inst)
	260	{
	261	struct skcipher_instance *skcipher =
	262	container_of(inst, struct skcipher_instance, s.base);
	263
	264	skcipher->free(skcipher);
	265	}
	266
	267	static void crypto_skcipher_show(struct seq_file m, struct crypto_alg alg)
	268	__attribute__ ((unused));
	269	static void crypto_skcipher_show(struct seq_file m, struct crypto_alg alg)
	270	{
	271	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
	272	base);
	273
	274	seq_printf(m, "type : skcipher\n");
	275	seq_printf(m, "async : %s\n",
	276	alg->cra_flags & CRYPTO_ALG_ASYNC ? "yes" : "no");
	277	seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
	278	seq_printf(m, "min keysize : %u\n", skcipher->min_keysize);
	279	seq_printf(m, "max keysize : %u\n", skcipher->max_keysize);
	280	seq_printf(m, "ivsize : %u\n", skcipher->ivsize);
	281	seq_printf(m, "chunksize : %u\n", skcipher->chunksize);
7a7ffe65 HX	282	}
7a7ffe65 HX	283
4e6c3df4 HX	284	#ifdef CONFIG_NET
	285	static int crypto_skcipher_report(struct sk_buff skb, struct crypto_alg alg)
	286	{
	287	struct crypto_report_blkcipher rblkcipher;
	288	struct skcipher_alg *skcipher = container_of(alg, struct skcipher_alg,
	289	base);
	290
	291	strncpy(rblkcipher.type, "skcipher", sizeof(rblkcipher.type));
	292	strncpy(rblkcipher.geniv, "<none>", sizeof(rblkcipher.geniv));
	293
	294	rblkcipher.blocksize = alg->cra_blocksize;
	295	rblkcipher.min_keysize = skcipher->min_keysize;
	296	rblkcipher.max_keysize = skcipher->max_keysize;
	297	rblkcipher.ivsize = skcipher->ivsize;
	298
	299	if (nla_put(skb, CRYPTOCFGA_REPORT_BLKCIPHER,
	300	sizeof(struct crypto_report_blkcipher), &rblkcipher))
	301	goto nla_put_failure;
	302	return 0;
	303
	304	nla_put_failure:
	305	return -EMSGSIZE;
	306	}
	307	#else
	308	static int crypto_skcipher_report(struct sk_buff skb, struct crypto_alg alg)
	309	{
	310	return -ENOSYS;
	311	}
	312	#endif
	313
7a7ffe65 HX	314	static const struct crypto_type crypto_skcipher_type2 = {
	315	.extsize = crypto_skcipher_extsize,
	316	.init_tfm = crypto_skcipher_init_tfm,
4e6c3df4 HX	317	.free = crypto_skcipher_free_instance,
	318	#ifdef CONFIG_PROC_FS
	319	.show = crypto_skcipher_show,
	320	#endif
	321	.report = crypto_skcipher_report,
7a7ffe65 HX	322	.maskclear = ~CRYPTO_ALG_TYPE_MASK,
7a7ffe65 HX	323	.maskset = CRYPTO_ALG_TYPE_BLKCIPHER_MASK,
4e6c3df4	324	.type = CRYPTO_ALG_TYPE_SKCIPHER,
7a7ffe65 HX	325	.tfmsize = offsetof(struct crypto_skcipher, base),
	326	};
	327
3a01d0ee	328	int crypto_grab_skcipher(struct crypto_skcipher_spawn *spawn,
4e6c3df4 HX	329	const char *name, u32 type, u32 mask)
	330	{
	331	spawn->base.frontend = &crypto_skcipher_type2;
	332	return crypto_grab_spawn(&spawn->base, name, type, mask);
	333	}
3a01d0ee	334	EXPORT_SYMBOL_GPL(crypto_grab_skcipher);
4e6c3df4	335
7a7ffe65 HX	336	struct crypto_skcipher crypto_alloc_skcipher(const char alg_name,
	337	u32 type, u32 mask)
	338	{
	339	return crypto_alloc_tfm(alg_name, &crypto_skcipher_type2, type, mask);
	340	}
	341	EXPORT_SYMBOL_GPL(crypto_alloc_skcipher);
	342
4e6c3df4 HX	343	int crypto_has_skcipher2(const char *alg_name, u32 type, u32 mask)
	344	{
	345	return crypto_type_has_alg(alg_name, &crypto_skcipher_type2,
	346	type, mask);
	347	}
	348	EXPORT_SYMBOL_GPL(crypto_has_skcipher2);
	349
	350	static int skcipher_prepare_alg(struct skcipher_alg *alg)
	351	{
	352	struct crypto_alg *base = &alg->base;
	353
	354	if (alg->ivsize > PAGE_SIZE / 8 \|\| alg->chunksize > PAGE_SIZE / 8)
	355	return -EINVAL;
	356
	357	if (!alg->chunksize)
	358	alg->chunksize = base->cra_blocksize;
	359
	360	base->cra_type = &crypto_skcipher_type2;
	361	base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
	362	base->cra_flags \|= CRYPTO_ALG_TYPE_SKCIPHER;
	363
	364	return 0;
	365	}
	366
	367	int crypto_register_skcipher(struct skcipher_alg *alg)
	368	{
	369	struct crypto_alg *base = &alg->base;
	370	int err;
	371
	372	err = skcipher_prepare_alg(alg);
	373	if (err)
	374	return err;
	375
	376	return crypto_register_alg(base);
	377	}
	378	EXPORT_SYMBOL_GPL(crypto_register_skcipher);
	379
	380	void crypto_unregister_skcipher(struct skcipher_alg *alg)
	381	{
	382	crypto_unregister_alg(&alg->base);
	383	}
	384	EXPORT_SYMBOL_GPL(crypto_unregister_skcipher);
	385
	386	int crypto_register_skciphers(struct skcipher_alg *algs, int count)
	387	{
	388	int i, ret;
	389
	390	for (i = 0; i < count; i++) {
	391	ret = crypto_register_skcipher(&algs[i]);
	392	if (ret)
	393	goto err;
	394	}
	395
	396	return 0;
	397
	398	err:
	399	for (--i; i >= 0; --i)
	400	crypto_unregister_skcipher(&algs[i]);
	401
	402	return ret;
	403	}
	404	EXPORT_SYMBOL_GPL(crypto_register_skciphers);
	405
	406	void crypto_unregister_skciphers(struct skcipher_alg *algs, int count)
407	{
408	int i;
409
410	for (i = count - 1; i >= 0; --i)
411	crypto_unregister_skcipher(&algs[i]);
412	}
413	EXPORT_SYMBOL_GPL(crypto_unregister_skciphers);
414
415	int skcipher_register_instance(struct crypto_template *tmpl,
416	struct skcipher_instance *inst)
417	{
418	int err;
419
420	err = skcipher_prepare_alg(&inst->alg);
421	if (err)
422	return err;
423
424	return crypto_register_instance(tmpl, skcipher_crypto_instance(inst));
425	}
426	EXPORT_SYMBOL_GPL(skcipher_register_instance);
427
7a7ffe65 HX	428	MODULE_LICENSE("GPL");
7a7ffe65 HX	429	MODULE_DESCRIPTION("Symmetric key cipher type");