[linux-block.git] / drivers / crypto / ccp / ccp-crypto-aes.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * AMD Cryptographic Coprocessor (CCP) AES crypto API support
 *
 * Copyright (C) 2013,2016 Advanced Micro Devices, Inc.
 *
 * Author: Tom Lendacky <thomas.lendacky@amd.com>
 */

#include <linux/module.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/scatterlist.h>
#include <linux/crypto.h>
#include <crypto/algapi.h>
#include <crypto/aes.h>
#include <crypto/ctr.h>
#include <crypto/scatterwalk.h>

#include "ccp-crypto.h"

static int ccp_aes_complete(struct crypto_async_request *async_req, int ret)
{
	struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);

	if (ret)
		return ret;

	if (ctx->u.aes.mode != CCP_AES_MODE_ECB)
		memcpy(req->info, rctx->iv, AES_BLOCK_SIZE);

	return 0;
}

static int ccp_aes_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
			  unsigned int key_len)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm));
	struct ccp_crypto_ablkcipher_alg *alg =
		ccp_crypto_ablkcipher_alg(crypto_ablkcipher_tfm(tfm));

	switch (key_len) {
	case AES_KEYSIZE_128:
		ctx->u.aes.type = CCP_AES_TYPE_128;
		break;
	case AES_KEYSIZE_192:
		ctx->u.aes.type = CCP_AES_TYPE_192;
		break;
	case AES_KEYSIZE_256:
		ctx->u.aes.type = CCP_AES_TYPE_256;
		break;
	default:
		crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
		return -EINVAL;
	}
	ctx->u.aes.mode = alg->mode;
	ctx->u.aes.key_len = key_len;

	memcpy(ctx->u.aes.key, key, key_len);
	sg_init_one(&ctx->u.aes.key_sg, ctx->u.aes.key, key_len);

	return 0;
}

static int ccp_aes_crypt(struct ablkcipher_request *req, bool encrypt)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
	struct scatterlist *iv_sg = NULL;
	unsigned int iv_len = 0;
	int ret;

	if (!ctx->u.aes.key_len)
		return -EINVAL;

	if (((ctx->u.aes.mode == CCP_AES_MODE_ECB) ||
	     (ctx->u.aes.mode == CCP_AES_MODE_CBC) ||
	     (ctx->u.aes.mode == CCP_AES_MODE_CFB)) &&
	    (req->nbytes & (AES_BLOCK_SIZE - 1)))
		return -EINVAL;

	if (ctx->u.aes.mode != CCP_AES_MODE_ECB) {
		if (!req->info)
			return -EINVAL;

		memcpy(rctx->iv, req->info, AES_BLOCK_SIZE);
		iv_sg = &rctx->iv_sg;
		iv_len = AES_BLOCK_SIZE;
		sg_init_one(iv_sg, rctx->iv, iv_len);
	}

	memset(&rctx->cmd, 0, sizeof(rctx->cmd));
	INIT_LIST_HEAD(&rctx->cmd.entry);
	rctx->cmd.engine = CCP_ENGINE_AES;
	rctx->cmd.u.aes.type = ctx->u.aes.type;
	rctx->cmd.u.aes.mode = ctx->u.aes.mode;
	rctx->cmd.u.aes.action =
		(encrypt) ? CCP_AES_ACTION_ENCRYPT : CCP_AES_ACTION_DECRYPT;
	rctx->cmd.u.aes.key = &ctx->u.aes.key_sg;
	rctx->cmd.u.aes.key_len = ctx->u.aes.key_len;
	rctx->cmd.u.aes.iv = iv_sg;
	rctx->cmd.u.aes.iv_len = iv_len;
	rctx->cmd.u.aes.src = req->src;
	rctx->cmd.u.aes.src_len = req->nbytes;
	rctx->cmd.u.aes.dst = req->dst;

	ret = ccp_crypto_enqueue_request(&req->base, &rctx->cmd);

	return ret;
}

static int ccp_aes_encrypt(struct ablkcipher_request *req)
{
	return ccp_aes_crypt(req, true);
}

static int ccp_aes_decrypt(struct ablkcipher_request *req)
{
	return ccp_aes_crypt(req, false);
}

static int ccp_aes_cra_init(struct crypto_tfm *tfm)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(tfm);

	ctx->complete = ccp_aes_complete;
	ctx->u.aes.key_len = 0;

	tfm->crt_ablkcipher.reqsize = sizeof(struct ccp_aes_req_ctx);

	return 0;
}

static void ccp_aes_cra_exit(struct crypto_tfm *tfm)
{
}

static int ccp_aes_rfc3686_complete(struct crypto_async_request *async_req,
				    int ret)
{
	struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);

	/* Restore the original pointer */
	req->info = rctx->rfc3686_info;

	return ccp_aes_complete(async_req, ret);
}

static int ccp_aes_rfc3686_setkey(struct crypto_ablkcipher *tfm, const u8 *key,
				  unsigned int key_len)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm));

	if (key_len < CTR_RFC3686_NONCE_SIZE)
		return -EINVAL;

	key_len -= CTR_RFC3686_NONCE_SIZE;
	memcpy(ctx->u.aes.nonce, key + key_len, CTR_RFC3686_NONCE_SIZE);

	return ccp_aes_setkey(tfm, key, key_len);
}

static int ccp_aes_rfc3686_crypt(struct ablkcipher_request *req, bool encrypt)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
	u8 *iv;

	/* Initialize the CTR block */
	iv = rctx->rfc3686_iv;
	memcpy(iv, ctx->u.aes.nonce, CTR_RFC3686_NONCE_SIZE);

	iv += CTR_RFC3686_NONCE_SIZE;
	memcpy(iv, req->info, CTR_RFC3686_IV_SIZE);

	iv += CTR_RFC3686_IV_SIZE;
	*(__be32 *)iv = cpu_to_be32(1);

	/* Point to the new IV */
	rctx->rfc3686_info = req->info;
	req->info = rctx->rfc3686_iv;

	return ccp_aes_crypt(req, encrypt);
}

static int ccp_aes_rfc3686_encrypt(struct ablkcipher_request *req)
{
	return ccp_aes_rfc3686_crypt(req, true);
}

static int ccp_aes_rfc3686_decrypt(struct ablkcipher_request *req)
{
	return ccp_aes_rfc3686_crypt(req, false);
}

static int ccp_aes_rfc3686_cra_init(struct crypto_tfm *tfm)
{
	struct ccp_ctx *ctx = crypto_tfm_ctx(tfm);

	ctx->complete = ccp_aes_rfc3686_complete;
	ctx->u.aes.key_len = 0;

	tfm->crt_ablkcipher.reqsize = sizeof(struct ccp_aes_req_ctx);

	return 0;
}

static void ccp_aes_rfc3686_cra_exit(struct crypto_tfm *tfm)
{
}

static struct crypto_alg ccp_aes_defaults = {
	.cra_flags	= CRYPTO_ALG_TYPE_ABLKCIPHER |
			  CRYPTO_ALG_ASYNC |
			  CRYPTO_ALG_KERN_DRIVER_ONLY |
			  CRYPTO_ALG_NEED_FALLBACK,
	.cra_blocksize	= AES_BLOCK_SIZE,
	.cra_ctxsize	= sizeof(struct ccp_ctx),
	.cra_priority	= CCP_CRA_PRIORITY,
	.cra_type	= &crypto_ablkcipher_type,
	.cra_init	= ccp_aes_cra_init,
	.cra_exit	= ccp_aes_cra_exit,
	.cra_module	= THIS_MODULE,
	.cra_ablkcipher	= {
		.setkey		= ccp_aes_setkey,
		.encrypt	= ccp_aes_encrypt,
		.decrypt	= ccp_aes_decrypt,
		.min_keysize	= AES_MIN_KEY_SIZE,
		.max_keysize	= AES_MAX_KEY_SIZE,
	},
};

static struct crypto_alg ccp_aes_rfc3686_defaults = {
	.cra_flags	= CRYPTO_ALG_TYPE_ABLKCIPHER |
			   CRYPTO_ALG_ASYNC |
			   CRYPTO_ALG_KERN_DRIVER_ONLY |
			   CRYPTO_ALG_NEED_FALLBACK,
	.cra_blocksize	= CTR_RFC3686_BLOCK_SIZE,
	.cra_ctxsize	= sizeof(struct ccp_ctx),
	.cra_priority	= CCP_CRA_PRIORITY,
	.cra_type	= &crypto_ablkcipher_type,
	.cra_init	= ccp_aes_rfc3686_cra_init,
	.cra_exit	= ccp_aes_rfc3686_cra_exit,
	.cra_module	= THIS_MODULE,
	.cra_ablkcipher	= {
		.setkey		= ccp_aes_rfc3686_setkey,
		.encrypt	= ccp_aes_rfc3686_encrypt,
		.decrypt	= ccp_aes_rfc3686_decrypt,
		.min_keysize	= AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
		.max_keysize	= AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
	},
};

struct ccp_aes_def {
	enum ccp_aes_mode mode;
	unsigned int version;
	const char *name;
	const char *driver_name;
	unsigned int blocksize;
	unsigned int ivsize;
	struct crypto_alg *alg_defaults;
};

static struct ccp_aes_def aes_algs[] = {
	{
		.mode		= CCP_AES_MODE_ECB,
		.version	= CCP_VERSION(3, 0),
		.name		= "ecb(aes)",
		.driver_name	= "ecb-aes-ccp",
		.blocksize	= AES_BLOCK_SIZE,
		.ivsize		= 0,
		.alg_defaults	= &ccp_aes_defaults,
	},
	{
		.mode		= CCP_AES_MODE_CBC,
		.version	= CCP_VERSION(3, 0),
		.name		= "cbc(aes)",
		.driver_name	= "cbc-aes-ccp",
		.blocksize	= AES_BLOCK_SIZE,
		.ivsize		= AES_BLOCK_SIZE,
		.alg_defaults	= &ccp_aes_defaults,
	},
	{
		.mode		= CCP_AES_MODE_CFB,
		.version	= CCP_VERSION(3, 0),
		.name		= "cfb(aes)",
		.driver_name	= "cfb-aes-ccp",
		.blocksize	= AES_BLOCK_SIZE,
		.ivsize		= AES_BLOCK_SIZE,
		.alg_defaults	= &ccp_aes_defaults,
	},
	{
		.mode		= CCP_AES_MODE_OFB,
		.version	= CCP_VERSION(3, 0),
		.name		= "ofb(aes)",
		.driver_name	= "ofb-aes-ccp",
		.blocksize	= 1,
		.ivsize		= AES_BLOCK_SIZE,
		.alg_defaults	= &ccp_aes_defaults,
	},
	{
		.mode		= CCP_AES_MODE_CTR,
		.version	= CCP_VERSION(3, 0),
		.name		= "ctr(aes)",
		.driver_name	= "ctr-aes-ccp",
		.blocksize	= 1,
		.ivsize		= AES_BLOCK_SIZE,
		.alg_defaults	= &ccp_aes_defaults,
	},
	{
		.mode		= CCP_AES_MODE_CTR,
		.version	= CCP_VERSION(3, 0),
		.name		= "rfc3686(ctr(aes))",
		.driver_name	= "rfc3686-ctr-aes-ccp",
		.blocksize	= 1,
		.ivsize		= CTR_RFC3686_IV_SIZE,
		.alg_defaults	= &ccp_aes_rfc3686_defaults,
	},
};

static int ccp_register_aes_alg(struct list_head *head,
				const struct ccp_aes_def *def)
{
	struct ccp_crypto_ablkcipher_alg *ccp_alg;
	struct crypto_alg *alg;
	int ret;

	ccp_alg = kzalloc(sizeof(*ccp_alg), GFP_KERNEL);
	if (!ccp_alg)
		return -ENOMEM;

	INIT_LIST_HEAD(&ccp_alg->entry);

	ccp_alg->mode = def->mode;

	/* Copy the defaults and override as necessary */
	alg = &ccp_alg->alg;
	*alg = *def->alg_defaults;
	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
		 def->driver_name);
	alg->cra_blocksize = def->blocksize;
	alg->cra_ablkcipher.ivsize = def->ivsize;

	ret = crypto_register_alg(alg);
	if (ret) {
		pr_err("%s ablkcipher algorithm registration error (%d)\n",
		       alg->cra_name, ret);
		kfree(ccp_alg);
		return ret;
	}

	list_add(&ccp_alg->entry, head);

	return 0;
}

int ccp_register_aes_algs(struct list_head *head)
{
	int i, ret;
	unsigned int ccpversion = ccp_version();

	for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
		if (aes_algs[i].version > ccpversion)
			continue;
		ret = ccp_register_aes_alg(head, &aes_algs[i]);
		if (ret)
			return ret;
	}

	return 0;
}
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
2b789435 TL	2	/*
	3	* AMD Cryptographic Coprocessor (CCP) AES crypto API support
	4	*
c7019c4d	5	* Copyright (C) 2013,2016 Advanced Micro Devices, Inc.
2b789435 TL	6	*
2b789435 TL	7	* Author: Tom Lendacky <thomas.lendacky@amd.com>
2b789435 TL	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/sched.h>
	12	#include <linux/delay.h>
	13	#include <linux/scatterlist.h>
	14	#include <linux/crypto.h>
	15	#include <crypto/algapi.h>
	16	#include <crypto/aes.h>
	17	#include <crypto/ctr.h>
	18	#include <crypto/scatterwalk.h>
	19
	20	#include "ccp-crypto.h"
	21
2b789435 TL	22	static int ccp_aes_complete(struct crypto_async_request *async_req, int ret)
	23	{
	24	struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
	25	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
	26	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
	27
	28	if (ret)
	29	return ret;
	30
	31	if (ctx->u.aes.mode != CCP_AES_MODE_ECB)
	32	memcpy(req->info, rctx->iv, AES_BLOCK_SIZE);
	33
	34	return 0;
	35	}
	36
	37	static int ccp_aes_setkey(struct crypto_ablkcipher tfm, const u8 key,
	38	unsigned int key_len)
	39	{
	40	struct ccp_ctx *ctx = crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm));
	41	struct ccp_crypto_ablkcipher_alg *alg =
	42	ccp_crypto_ablkcipher_alg(crypto_ablkcipher_tfm(tfm));
	43
	44	switch (key_len) {
	45	case AES_KEYSIZE_128:
	46	ctx->u.aes.type = CCP_AES_TYPE_128;
	47	break;
	48	case AES_KEYSIZE_192:
	49	ctx->u.aes.type = CCP_AES_TYPE_192;
	50	break;
	51	case AES_KEYSIZE_256:
	52	ctx->u.aes.type = CCP_AES_TYPE_256;
	53	break;
	54	default:
	55	crypto_ablkcipher_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN);
	56	return -EINVAL;
	57	}
	58	ctx->u.aes.mode = alg->mode;
	59	ctx->u.aes.key_len = key_len;
	60
	61	memcpy(ctx->u.aes.key, key, key_len);
	62	sg_init_one(&ctx->u.aes.key_sg, ctx->u.aes.key, key_len);
	63
	64	return 0;
	65	}
	66
	67	static int ccp_aes_crypt(struct ablkcipher_request *req, bool encrypt)
	68	{
	69	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
	70	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
	71	struct scatterlist *iv_sg = NULL;
	72	unsigned int iv_len = 0;
	73	int ret;
	74
369f3dab	75	if (!ctx->u.aes.key_len)
2b789435	76	return -EINVAL;
2b789435 TL	77
	78	if (((ctx->u.aes.mode == CCP_AES_MODE_ECB) \|\|
	79	(ctx->u.aes.mode == CCP_AES_MODE_CBC) \|\|
	80	(ctx->u.aes.mode == CCP_AES_MODE_CFB)) &&
369f3dab	81	(req->nbytes & (AES_BLOCK_SIZE - 1)))
2b789435	82	return -EINVAL;
2b789435 TL	83
2b789435 TL	84	if (ctx->u.aes.mode != CCP_AES_MODE_ECB) {
369f3dab	85	if (!req->info)
2b789435	86	return -EINVAL;
2b789435 TL	87
	88	memcpy(rctx->iv, req->info, AES_BLOCK_SIZE);
	89	iv_sg = &rctx->iv_sg;
	90	iv_len = AES_BLOCK_SIZE;
	91	sg_init_one(iv_sg, rctx->iv, iv_len);
	92	}
	93
	94	memset(&rctx->cmd, 0, sizeof(rctx->cmd));
	95	INIT_LIST_HEAD(&rctx->cmd.entry);
	96	rctx->cmd.engine = CCP_ENGINE_AES;
	97	rctx->cmd.u.aes.type = ctx->u.aes.type;
	98	rctx->cmd.u.aes.mode = ctx->u.aes.mode;
	99	rctx->cmd.u.aes.action =
	100	(encrypt) ? CCP_AES_ACTION_ENCRYPT : CCP_AES_ACTION_DECRYPT;
	101	rctx->cmd.u.aes.key = &ctx->u.aes.key_sg;
	102	rctx->cmd.u.aes.key_len = ctx->u.aes.key_len;
	103	rctx->cmd.u.aes.iv = iv_sg;
	104	rctx->cmd.u.aes.iv_len = iv_len;
	105	rctx->cmd.u.aes.src = req->src;
	106	rctx->cmd.u.aes.src_len = req->nbytes;
	107	rctx->cmd.u.aes.dst = req->dst;
	108
	109	ret = ccp_crypto_enqueue_request(&req->base, &rctx->cmd);
	110
	111	return ret;
	112	}
	113
	114	static int ccp_aes_encrypt(struct ablkcipher_request *req)
	115	{
	116	return ccp_aes_crypt(req, true);
	117	}
	118
	119	static int ccp_aes_decrypt(struct ablkcipher_request *req)
	120	{
	121	return ccp_aes_crypt(req, false);
	122	}
	123
	124	static int ccp_aes_cra_init(struct crypto_tfm *tfm)
	125	{
	126	struct ccp_ctx *ctx = crypto_tfm_ctx(tfm);
	127
	128	ctx->complete = ccp_aes_complete;
	129	ctx->u.aes.key_len = 0;
	130
	131	tfm->crt_ablkcipher.reqsize = sizeof(struct ccp_aes_req_ctx);
	132
	133	return 0;
	134	}
	135
	136	static void ccp_aes_cra_exit(struct crypto_tfm *tfm)
	137	{
	138	}
	139
	140	static int ccp_aes_rfc3686_complete(struct crypto_async_request *async_req,
	141	int ret)
	142	{
	143	struct ablkcipher_request *req = ablkcipher_request_cast(async_req);
	144	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
	145
	146	/* Restore the original pointer */
	147	req->info = rctx->rfc3686_info;
	148
	149	return ccp_aes_complete(async_req, ret);
	150	}
151
152	static int ccp_aes_rfc3686_setkey(struct crypto_ablkcipher tfm, const u8 key,
153	unsigned int key_len)
154	{
155	struct ccp_ctx *ctx = crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm));
156
157	if (key_len < CTR_RFC3686_NONCE_SIZE)
158	return -EINVAL;
159
160	key_len -= CTR_RFC3686_NONCE_SIZE;
161	memcpy(ctx->u.aes.nonce, key + key_len, CTR_RFC3686_NONCE_SIZE);
162
163	return ccp_aes_setkey(tfm, key, key_len);
164	}
165
166	static int ccp_aes_rfc3686_crypt(struct ablkcipher_request *req, bool encrypt)
167	{
168	struct ccp_ctx *ctx = crypto_tfm_ctx(req->base.tfm);
169	struct ccp_aes_req_ctx *rctx = ablkcipher_request_ctx(req);
170	u8 *iv;
171
172	/* Initialize the CTR block */
173	iv = rctx->rfc3686_iv;
174	memcpy(iv, ctx->u.aes.nonce, CTR_RFC3686_NONCE_SIZE);
175
176	iv += CTR_RFC3686_NONCE_SIZE;
177	memcpy(iv, req->info, CTR_RFC3686_IV_SIZE);
178
179	iv += CTR_RFC3686_IV_SIZE;
180	(__be32 )iv = cpu_to_be32(1);
181
182	/* Point to the new IV */
183	rctx->rfc3686_info = req->info;
184	req->info = rctx->rfc3686_iv;
185
186	return ccp_aes_crypt(req, encrypt);
187	}
188
189	static int ccp_aes_rfc3686_encrypt(struct ablkcipher_request *req)
190	{
191	return ccp_aes_rfc3686_crypt(req, true);
192	}
193
194	static int ccp_aes_rfc3686_decrypt(struct ablkcipher_request *req)
195	{
196	return ccp_aes_rfc3686_crypt(req, false);
197	}
198
199	static int ccp_aes_rfc3686_cra_init(struct crypto_tfm *tfm)
200	{
201	struct ccp_ctx *ctx = crypto_tfm_ctx(tfm);
202
203	ctx->complete = ccp_aes_rfc3686_complete;
204	ctx->u.aes.key_len = 0;
205
206	tfm->crt_ablkcipher.reqsize = sizeof(struct ccp_aes_req_ctx);
207
208	return 0;
209	}
210
211	static void ccp_aes_rfc3686_cra_exit(struct crypto_tfm *tfm)
212	{
213	}
214
215	static struct crypto_alg ccp_aes_defaults = {
216	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
217	CRYPTO_ALG_ASYNC \|
218	CRYPTO_ALG_KERN_DRIVER_ONLY \|
219	CRYPTO_ALG_NEED_FALLBACK,
220	.cra_blocksize = AES_BLOCK_SIZE,
221	.cra_ctxsize = sizeof(struct ccp_ctx),
222	.cra_priority = CCP_CRA_PRIORITY,
223	.cra_type = &crypto_ablkcipher_type,
224	.cra_init = ccp_aes_cra_init,
225	.cra_exit = ccp_aes_cra_exit,
226	.cra_module = THIS_MODULE,
227	.cra_ablkcipher = {
228	.setkey = ccp_aes_setkey,
229	.encrypt = ccp_aes_encrypt,
230	.decrypt = ccp_aes_decrypt,
231	.min_keysize = AES_MIN_KEY_SIZE,
232	.max_keysize = AES_MAX_KEY_SIZE,
233	},
234	};
235
236	static struct crypto_alg ccp_aes_rfc3686_defaults = {
237	.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \|
238	CRYPTO_ALG_ASYNC \|
239	CRYPTO_ALG_KERN_DRIVER_ONLY \|
240	CRYPTO_ALG_NEED_FALLBACK,
241	.cra_blocksize = CTR_RFC3686_BLOCK_SIZE,
242	.cra_ctxsize = sizeof(struct ccp_ctx),
243	.cra_priority = CCP_CRA_PRIORITY,
244	.cra_type = &crypto_ablkcipher_type,
245	.cra_init = ccp_aes_rfc3686_cra_init,
246	.cra_exit = ccp_aes_rfc3686_cra_exit,
247	.cra_module = THIS_MODULE,
248	.cra_ablkcipher = {
249	.setkey = ccp_aes_rfc3686_setkey,
250	.encrypt = ccp_aes_rfc3686_encrypt,
251	.decrypt = ccp_aes_rfc3686_decrypt,
252	.min_keysize = AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
253	.max_keysize = AES_MAX_KEY_SIZE + CTR_RFC3686_NONCE_SIZE,
254	},
255	};
256
257	struct ccp_aes_def {
258	enum ccp_aes_mode mode;
c7019c4d	259	unsigned int version;
2b789435 TL	260	const char *name;
	261	const char *driver_name;
	262	unsigned int blocksize;
	263	unsigned int ivsize;
	264	struct crypto_alg *alg_defaults;
	265	};
	266
	267	static struct ccp_aes_def aes_algs[] = {
	268	{
	269	.mode = CCP_AES_MODE_ECB,
c7019c4d	270	.version = CCP_VERSION(3, 0),
2b789435 TL	271	.name = "ecb(aes)",
	272	.driver_name = "ecb-aes-ccp",
	273	.blocksize = AES_BLOCK_SIZE,
	274	.ivsize = 0,
	275	.alg_defaults = &ccp_aes_defaults,
	276	},
	277	{
	278	.mode = CCP_AES_MODE_CBC,
c7019c4d	279	.version = CCP_VERSION(3, 0),
2b789435 TL	280	.name = "cbc(aes)",
	281	.driver_name = "cbc-aes-ccp",
	282	.blocksize = AES_BLOCK_SIZE,
	283	.ivsize = AES_BLOCK_SIZE,
	284	.alg_defaults = &ccp_aes_defaults,
	285	},
	286	{
	287	.mode = CCP_AES_MODE_CFB,
c7019c4d	288	.version = CCP_VERSION(3, 0),
2b789435 TL	289	.name = "cfb(aes)",
	290	.driver_name = "cfb-aes-ccp",
	291	.blocksize = AES_BLOCK_SIZE,
	292	.ivsize = AES_BLOCK_SIZE,
	293	.alg_defaults = &ccp_aes_defaults,
	294	},
	295	{
	296	.mode = CCP_AES_MODE_OFB,
c7019c4d	297	.version = CCP_VERSION(3, 0),
2b789435 TL	298	.name = "ofb(aes)",
	299	.driver_name = "ofb-aes-ccp",
	300	.blocksize = 1,
	301	.ivsize = AES_BLOCK_SIZE,
	302	.alg_defaults = &ccp_aes_defaults,
	303	},
	304	{
	305	.mode = CCP_AES_MODE_CTR,
c7019c4d	306	.version = CCP_VERSION(3, 0),
2b789435 TL	307	.name = "ctr(aes)",
	308	.driver_name = "ctr-aes-ccp",
	309	.blocksize = 1,
	310	.ivsize = AES_BLOCK_SIZE,
	311	.alg_defaults = &ccp_aes_defaults,
	312	},
	313	{
	314	.mode = CCP_AES_MODE_CTR,
c7019c4d	315	.version = CCP_VERSION(3, 0),
2b789435 TL	316	.name = "rfc3686(ctr(aes))",
	317	.driver_name = "rfc3686-ctr-aes-ccp",
	318	.blocksize = 1,
	319	.ivsize = CTR_RFC3686_IV_SIZE,
	320	.alg_defaults = &ccp_aes_rfc3686_defaults,
	321	},
	322	};
	323
	324	static int ccp_register_aes_alg(struct list_head *head,
	325	const struct ccp_aes_def *def)
	326	{
	327	struct ccp_crypto_ablkcipher_alg *ccp_alg;
	328	struct crypto_alg *alg;
	329	int ret;
	330
	331	ccp_alg = kzalloc(sizeof(*ccp_alg), GFP_KERNEL);
	332	if (!ccp_alg)
	333	return -ENOMEM;
	334
	335	INIT_LIST_HEAD(&ccp_alg->entry);
	336
	337	ccp_alg->mode = def->mode;
	338
	339	/* Copy the defaults and override as necessary */
	340	alg = &ccp_alg->alg;
d1dd206c	341	alg = def->alg_defaults;
2b789435 TL	342	snprintf(alg->cra_name, CRYPTO_MAX_ALG_NAME, "%s", def->name);
	343	snprintf(alg->cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s",
	344	def->driver_name);
	345	alg->cra_blocksize = def->blocksize;
	346	alg->cra_ablkcipher.ivsize = def->ivsize;
	347
	348	ret = crypto_register_alg(alg);
	349	if (ret) {
	350	pr_err("%s ablkcipher algorithm registration error (%d)\n",
8db88467	351	alg->cra_name, ret);
2b789435 TL	352	kfree(ccp_alg);
	353	return ret;
	354	}
	355
	356	list_add(&ccp_alg->entry, head);
	357
	358	return 0;
	359	}
	360
	361	int ccp_register_aes_algs(struct list_head *head)
	362	{
	363	int i, ret;
c7019c4d	364	unsigned int ccpversion = ccp_version();
2b789435 TL	365
2b789435 TL	366	for (i = 0; i < ARRAY_SIZE(aes_algs); i++) {
c7019c4d GH	367	if (aes_algs[i].version > ccpversion)
c7019c4d GH	368	continue;
2b789435 TL	369	ret = ccp_register_aes_alg(head, &aes_algs[i]);
	370	if (ret)
	371	return ret;
	372	}
	373
	374	return 0;
	375	}