2 * AMD Cryptographic Coprocessor (CCP) AES crypto API support
4 * Copyright (C) 2013 Advanced Micro Devices, Inc.
6 * Author: Tom Lendacky <thomas.lendacky@amd.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/module.h>
14 #include <linux/sched.h>
15 #include <linux/delay.h>
16 #include <linux/scatterlist.h>
17 #include <linux/crypto.h>
18 #include <crypto/algapi.h>
19 #include <crypto/aes.h>
20 #include <crypto/ctr.h>
21 #include <crypto/scatterwalk.h>
23 #include "ccp-crypto.h"
25 static int ccp_aes_complete(struct crypto_async_request
*async_req
, int ret
)
27 struct ablkcipher_request
*req
= ablkcipher_request_cast(async_req
);
28 struct ccp_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
29 struct ccp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
34 if (ctx
->u
.aes
.mode
!= CCP_AES_MODE_ECB
)
35 memcpy(req
->info
, rctx
->iv
, AES_BLOCK_SIZE
);
40 static int ccp_aes_setkey(struct crypto_ablkcipher
*tfm
, const u8
*key
,
43 struct ccp_ctx
*ctx
= crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm
));
44 struct ccp_crypto_ablkcipher_alg
*alg
=
45 ccp_crypto_ablkcipher_alg(crypto_ablkcipher_tfm(tfm
));
49 ctx
->u
.aes
.type
= CCP_AES_TYPE_128
;
52 ctx
->u
.aes
.type
= CCP_AES_TYPE_192
;
55 ctx
->u
.aes
.type
= CCP_AES_TYPE_256
;
58 crypto_ablkcipher_set_flags(tfm
, CRYPTO_TFM_RES_BAD_KEY_LEN
);
61 ctx
->u
.aes
.mode
= alg
->mode
;
62 ctx
->u
.aes
.key_len
= key_len
;
64 memcpy(ctx
->u
.aes
.key
, key
, key_len
);
65 sg_init_one(&ctx
->u
.aes
.key_sg
, ctx
->u
.aes
.key
, key_len
);
70 static int ccp_aes_crypt(struct ablkcipher_request
*req
, bool encrypt
)
72 struct ccp_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
73 struct ccp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
74 struct scatterlist
*iv_sg
= NULL
;
75 unsigned int iv_len
= 0;
78 if (!ctx
->u
.aes
.key_len
)
81 if (((ctx
->u
.aes
.mode
== CCP_AES_MODE_ECB
) ||
82 (ctx
->u
.aes
.mode
== CCP_AES_MODE_CBC
) ||
83 (ctx
->u
.aes
.mode
== CCP_AES_MODE_CFB
)) &&
84 (req
->nbytes
& (AES_BLOCK_SIZE
- 1)))
87 if (ctx
->u
.aes
.mode
!= CCP_AES_MODE_ECB
) {
91 memcpy(rctx
->iv
, req
->info
, AES_BLOCK_SIZE
);
93 iv_len
= AES_BLOCK_SIZE
;
94 sg_init_one(iv_sg
, rctx
->iv
, iv_len
);
97 memset(&rctx
->cmd
, 0, sizeof(rctx
->cmd
));
98 INIT_LIST_HEAD(&rctx
->cmd
.entry
);
99 rctx
->cmd
.engine
= CCP_ENGINE_AES
;
100 rctx
->cmd
.u
.aes
.type
= ctx
->u
.aes
.type
;
101 rctx
->cmd
.u
.aes
.mode
= ctx
->u
.aes
.mode
;
102 rctx
->cmd
.u
.aes
.action
=
103 (encrypt
) ? CCP_AES_ACTION_ENCRYPT
: CCP_AES_ACTION_DECRYPT
;
104 rctx
->cmd
.u
.aes
.key
= &ctx
->u
.aes
.key_sg
;
105 rctx
->cmd
.u
.aes
.key_len
= ctx
->u
.aes
.key_len
;
106 rctx
->cmd
.u
.aes
.iv
= iv_sg
;
107 rctx
->cmd
.u
.aes
.iv_len
= iv_len
;
108 rctx
->cmd
.u
.aes
.src
= req
->src
;
109 rctx
->cmd
.u
.aes
.src_len
= req
->nbytes
;
110 rctx
->cmd
.u
.aes
.dst
= req
->dst
;
112 ret
= ccp_crypto_enqueue_request(&req
->base
, &rctx
->cmd
);
117 static int ccp_aes_encrypt(struct ablkcipher_request
*req
)
119 return ccp_aes_crypt(req
, true);
122 static int ccp_aes_decrypt(struct ablkcipher_request
*req
)
124 return ccp_aes_crypt(req
, false);
127 static int ccp_aes_cra_init(struct crypto_tfm
*tfm
)
129 struct ccp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
131 ctx
->complete
= ccp_aes_complete
;
132 ctx
->u
.aes
.key_len
= 0;
134 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct ccp_aes_req_ctx
);
139 static void ccp_aes_cra_exit(struct crypto_tfm
*tfm
)
143 static int ccp_aes_rfc3686_complete(struct crypto_async_request
*async_req
,
146 struct ablkcipher_request
*req
= ablkcipher_request_cast(async_req
);
147 struct ccp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
149 /* Restore the original pointer */
150 req
->info
= rctx
->rfc3686_info
;
152 return ccp_aes_complete(async_req
, ret
);
155 static int ccp_aes_rfc3686_setkey(struct crypto_ablkcipher
*tfm
, const u8
*key
,
156 unsigned int key_len
)
158 struct ccp_ctx
*ctx
= crypto_tfm_ctx(crypto_ablkcipher_tfm(tfm
));
160 if (key_len
< CTR_RFC3686_NONCE_SIZE
)
163 key_len
-= CTR_RFC3686_NONCE_SIZE
;
164 memcpy(ctx
->u
.aes
.nonce
, key
+ key_len
, CTR_RFC3686_NONCE_SIZE
);
166 return ccp_aes_setkey(tfm
, key
, key_len
);
169 static int ccp_aes_rfc3686_crypt(struct ablkcipher_request
*req
, bool encrypt
)
171 struct ccp_ctx
*ctx
= crypto_tfm_ctx(req
->base
.tfm
);
172 struct ccp_aes_req_ctx
*rctx
= ablkcipher_request_ctx(req
);
175 /* Initialize the CTR block */
176 iv
= rctx
->rfc3686_iv
;
177 memcpy(iv
, ctx
->u
.aes
.nonce
, CTR_RFC3686_NONCE_SIZE
);
179 iv
+= CTR_RFC3686_NONCE_SIZE
;
180 memcpy(iv
, req
->info
, CTR_RFC3686_IV_SIZE
);
182 iv
+= CTR_RFC3686_IV_SIZE
;
183 *(__be32
*)iv
= cpu_to_be32(1);
185 /* Point to the new IV */
186 rctx
->rfc3686_info
= req
->info
;
187 req
->info
= rctx
->rfc3686_iv
;
189 return ccp_aes_crypt(req
, encrypt
);
192 static int ccp_aes_rfc3686_encrypt(struct ablkcipher_request
*req
)
194 return ccp_aes_rfc3686_crypt(req
, true);
197 static int ccp_aes_rfc3686_decrypt(struct ablkcipher_request
*req
)
199 return ccp_aes_rfc3686_crypt(req
, false);
202 static int ccp_aes_rfc3686_cra_init(struct crypto_tfm
*tfm
)
204 struct ccp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
206 ctx
->complete
= ccp_aes_rfc3686_complete
;
207 ctx
->u
.aes
.key_len
= 0;
209 tfm
->crt_ablkcipher
.reqsize
= sizeof(struct ccp_aes_req_ctx
);
214 static void ccp_aes_rfc3686_cra_exit(struct crypto_tfm
*tfm
)
218 static struct crypto_alg ccp_aes_defaults
= {
219 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
221 CRYPTO_ALG_KERN_DRIVER_ONLY
|
222 CRYPTO_ALG_NEED_FALLBACK
,
223 .cra_blocksize
= AES_BLOCK_SIZE
,
224 .cra_ctxsize
= sizeof(struct ccp_ctx
),
225 .cra_priority
= CCP_CRA_PRIORITY
,
226 .cra_type
= &crypto_ablkcipher_type
,
227 .cra_init
= ccp_aes_cra_init
,
228 .cra_exit
= ccp_aes_cra_exit
,
229 .cra_module
= THIS_MODULE
,
231 .setkey
= ccp_aes_setkey
,
232 .encrypt
= ccp_aes_encrypt
,
233 .decrypt
= ccp_aes_decrypt
,
234 .min_keysize
= AES_MIN_KEY_SIZE
,
235 .max_keysize
= AES_MAX_KEY_SIZE
,
239 static struct crypto_alg ccp_aes_rfc3686_defaults
= {
240 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
242 CRYPTO_ALG_KERN_DRIVER_ONLY
|
243 CRYPTO_ALG_NEED_FALLBACK
,
244 .cra_blocksize
= CTR_RFC3686_BLOCK_SIZE
,
245 .cra_ctxsize
= sizeof(struct ccp_ctx
),
246 .cra_priority
= CCP_CRA_PRIORITY
,
247 .cra_type
= &crypto_ablkcipher_type
,
248 .cra_init
= ccp_aes_rfc3686_cra_init
,
249 .cra_exit
= ccp_aes_rfc3686_cra_exit
,
250 .cra_module
= THIS_MODULE
,
252 .setkey
= ccp_aes_rfc3686_setkey
,
253 .encrypt
= ccp_aes_rfc3686_encrypt
,
254 .decrypt
= ccp_aes_rfc3686_decrypt
,
255 .min_keysize
= AES_MIN_KEY_SIZE
+ CTR_RFC3686_NONCE_SIZE
,
256 .max_keysize
= AES_MAX_KEY_SIZE
+ CTR_RFC3686_NONCE_SIZE
,
261 enum ccp_aes_mode mode
;
263 const char *driver_name
;
264 unsigned int blocksize
;
266 struct crypto_alg
*alg_defaults
;
269 static struct ccp_aes_def aes_algs
[] = {
271 .mode
= CCP_AES_MODE_ECB
,
273 .driver_name
= "ecb-aes-ccp",
274 .blocksize
= AES_BLOCK_SIZE
,
276 .alg_defaults
= &ccp_aes_defaults
,
279 .mode
= CCP_AES_MODE_CBC
,
281 .driver_name
= "cbc-aes-ccp",
282 .blocksize
= AES_BLOCK_SIZE
,
283 .ivsize
= AES_BLOCK_SIZE
,
284 .alg_defaults
= &ccp_aes_defaults
,
287 .mode
= CCP_AES_MODE_CFB
,
289 .driver_name
= "cfb-aes-ccp",
290 .blocksize
= AES_BLOCK_SIZE
,
291 .ivsize
= AES_BLOCK_SIZE
,
292 .alg_defaults
= &ccp_aes_defaults
,
295 .mode
= CCP_AES_MODE_OFB
,
297 .driver_name
= "ofb-aes-ccp",
299 .ivsize
= AES_BLOCK_SIZE
,
300 .alg_defaults
= &ccp_aes_defaults
,
303 .mode
= CCP_AES_MODE_CTR
,
305 .driver_name
= "ctr-aes-ccp",
307 .ivsize
= AES_BLOCK_SIZE
,
308 .alg_defaults
= &ccp_aes_defaults
,
311 .mode
= CCP_AES_MODE_CTR
,
312 .name
= "rfc3686(ctr(aes))",
313 .driver_name
= "rfc3686-ctr-aes-ccp",
315 .ivsize
= CTR_RFC3686_IV_SIZE
,
316 .alg_defaults
= &ccp_aes_rfc3686_defaults
,
320 static int ccp_register_aes_alg(struct list_head
*head
,
321 const struct ccp_aes_def
*def
)
323 struct ccp_crypto_ablkcipher_alg
*ccp_alg
;
324 struct crypto_alg
*alg
;
327 ccp_alg
= kzalloc(sizeof(*ccp_alg
), GFP_KERNEL
);
331 INIT_LIST_HEAD(&ccp_alg
->entry
);
333 ccp_alg
->mode
= def
->mode
;
335 /* Copy the defaults and override as necessary */
337 *alg
= *def
->alg_defaults
;
338 snprintf(alg
->cra_name
, CRYPTO_MAX_ALG_NAME
, "%s", def
->name
);
339 snprintf(alg
->cra_driver_name
, CRYPTO_MAX_ALG_NAME
, "%s",
341 alg
->cra_blocksize
= def
->blocksize
;
342 alg
->cra_ablkcipher
.ivsize
= def
->ivsize
;
344 ret
= crypto_register_alg(alg
);
346 pr_err("%s ablkcipher algorithm registration error (%d)\n",
352 list_add(&ccp_alg
->entry
, head
);
357 int ccp_register_aes_algs(struct list_head
*head
)
361 for (i
= 0; i
< ARRAY_SIZE(aes_algs
); i
++) {
362 ret
= ccp_register_aes_alg(head
, &aes_algs
[i
]);