2 * AMD Cryptographic Coprocessor (CCP) AES GCM crypto API support
4 * Copyright (C) 2016,2017 Advanced Micro Devices, Inc.
6 * Author: Gary R Hook <gary.hook@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/internal/aead.h>
19 #include <crypto/algapi.h>
20 #include <crypto/aes.h>
21 #include <crypto/ctr.h>
22 #include <crypto/gcm.h>
23 #include <crypto/scatterwalk.h>
24 #include <linux/delay.h>
26 #include "ccp-crypto.h"
28 static int ccp_aes_gcm_complete(struct crypto_async_request
*async_req
, int ret
)
33 static int ccp_aes_gcm_setkey(struct crypto_aead
*tfm
, const u8
*key
,
36 struct ccp_ctx
*ctx
= crypto_aead_ctx(tfm
);
40 ctx
->u
.aes
.type
= CCP_AES_TYPE_128
;
43 ctx
->u
.aes
.type
= CCP_AES_TYPE_192
;
46 ctx
->u
.aes
.type
= CCP_AES_TYPE_256
;
49 crypto_aead_set_flags(tfm
, CRYPTO_TFM_RES_BAD_KEY_LEN
);
53 ctx
->u
.aes
.mode
= CCP_AES_MODE_GCM
;
54 ctx
->u
.aes
.key_len
= key_len
;
56 memcpy(ctx
->u
.aes
.key
, key
, key_len
);
57 sg_init_one(&ctx
->u
.aes
.key_sg
, ctx
->u
.aes
.key
, key_len
);
62 static int ccp_aes_gcm_setauthsize(struct crypto_aead
*tfm
,
63 unsigned int authsize
)
68 static int ccp_aes_gcm_crypt(struct aead_request
*req
, bool encrypt
)
70 struct crypto_aead
*tfm
= crypto_aead_reqtfm(req
);
71 struct ccp_ctx
*ctx
= crypto_aead_ctx(tfm
);
72 struct ccp_aes_req_ctx
*rctx
= aead_request_ctx(req
);
73 struct scatterlist
*iv_sg
= NULL
;
74 unsigned int iv_len
= 0;
78 if (!ctx
->u
.aes
.key_len
)
81 if (ctx
->u
.aes
.mode
!= CCP_AES_MODE_GCM
)
89 * plaintext/ciphertext input
93 * Destination+tag buffer
96 /* Prepare the IV: 12 bytes + an integer (counter) */
97 memcpy(rctx
->iv
, req
->iv
, GCM_AES_IV_SIZE
);
98 for (i
= 0; i
< 3; i
++)
99 rctx
->iv
[i
+ GCM_AES_IV_SIZE
] = 0;
100 rctx
->iv
[AES_BLOCK_SIZE
- 1] = 1;
102 /* Set up a scatterlist for the IV */
103 iv_sg
= &rctx
->iv_sg
;
104 iv_len
= AES_BLOCK_SIZE
;
105 sg_init_one(iv_sg
, rctx
->iv
, iv_len
);
107 /* The AAD + plaintext are concatenated in the src buffer */
108 memset(&rctx
->cmd
, 0, sizeof(rctx
->cmd
));
109 INIT_LIST_HEAD(&rctx
->cmd
.entry
);
110 rctx
->cmd
.engine
= CCP_ENGINE_AES
;
111 rctx
->cmd
.u
.aes
.type
= ctx
->u
.aes
.type
;
112 rctx
->cmd
.u
.aes
.mode
= ctx
->u
.aes
.mode
;
113 rctx
->cmd
.u
.aes
.action
= encrypt
;
114 rctx
->cmd
.u
.aes
.key
= &ctx
->u
.aes
.key_sg
;
115 rctx
->cmd
.u
.aes
.key_len
= ctx
->u
.aes
.key_len
;
116 rctx
->cmd
.u
.aes
.iv
= iv_sg
;
117 rctx
->cmd
.u
.aes
.iv_len
= iv_len
;
118 rctx
->cmd
.u
.aes
.src
= req
->src
;
119 rctx
->cmd
.u
.aes
.src_len
= req
->cryptlen
;
120 rctx
->cmd
.u
.aes
.aad_len
= req
->assoclen
;
122 /* The cipher text + the tag are in the dst buffer */
123 rctx
->cmd
.u
.aes
.dst
= req
->dst
;
125 ret
= ccp_crypto_enqueue_request(&req
->base
, &rctx
->cmd
);
130 static int ccp_aes_gcm_encrypt(struct aead_request
*req
)
132 return ccp_aes_gcm_crypt(req
, CCP_AES_ACTION_ENCRYPT
);
135 static int ccp_aes_gcm_decrypt(struct aead_request
*req
)
137 return ccp_aes_gcm_crypt(req
, CCP_AES_ACTION_DECRYPT
);
140 static int ccp_aes_gcm_cra_init(struct crypto_aead
*tfm
)
142 struct ccp_ctx
*ctx
= crypto_aead_ctx(tfm
);
144 ctx
->complete
= ccp_aes_gcm_complete
;
145 ctx
->u
.aes
.key_len
= 0;
147 crypto_aead_set_reqsize(tfm
, sizeof(struct ccp_aes_req_ctx
));
152 static void ccp_aes_gcm_cra_exit(struct crypto_tfm
*tfm
)
156 static struct aead_alg ccp_aes_gcm_defaults
= {
157 .setkey
= ccp_aes_gcm_setkey
,
158 .setauthsize
= ccp_aes_gcm_setauthsize
,
159 .encrypt
= ccp_aes_gcm_encrypt
,
160 .decrypt
= ccp_aes_gcm_decrypt
,
161 .init
= ccp_aes_gcm_cra_init
,
162 .ivsize
= GCM_AES_IV_SIZE
,
163 .maxauthsize
= AES_BLOCK_SIZE
,
165 .cra_flags
= CRYPTO_ALG_TYPE_ABLKCIPHER
|
167 CRYPTO_ALG_KERN_DRIVER_ONLY
|
168 CRYPTO_ALG_NEED_FALLBACK
,
169 .cra_blocksize
= AES_BLOCK_SIZE
,
170 .cra_ctxsize
= sizeof(struct ccp_ctx
),
171 .cra_priority
= CCP_CRA_PRIORITY
,
172 .cra_type
= &crypto_ablkcipher_type
,
173 .cra_exit
= ccp_aes_gcm_cra_exit
,
174 .cra_module
= THIS_MODULE
,
178 struct ccp_aes_aead_def
{
179 enum ccp_aes_mode mode
;
180 unsigned int version
;
182 const char *driver_name
;
183 unsigned int blocksize
;
185 struct aead_alg
*alg_defaults
;
188 static struct ccp_aes_aead_def aes_aead_algs
[] = {
190 .mode
= CCP_AES_MODE_GHASH
,
191 .version
= CCP_VERSION(5, 0),
193 .driver_name
= "gcm-aes-ccp",
195 .ivsize
= AES_BLOCK_SIZE
,
196 .alg_defaults
= &ccp_aes_gcm_defaults
,
200 static int ccp_register_aes_aead(struct list_head
*head
,
201 const struct ccp_aes_aead_def
*def
)
203 struct ccp_crypto_aead
*ccp_aead
;
204 struct aead_alg
*alg
;
207 ccp_aead
= kzalloc(sizeof(*ccp_aead
), GFP_KERNEL
);
211 INIT_LIST_HEAD(&ccp_aead
->entry
);
213 ccp_aead
->mode
= def
->mode
;
215 /* Copy the defaults and override as necessary */
216 alg
= &ccp_aead
->alg
;
217 *alg
= *def
->alg_defaults
;
218 snprintf(alg
->base
.cra_name
, CRYPTO_MAX_ALG_NAME
, "%s", def
->name
);
219 snprintf(alg
->base
.cra_driver_name
, CRYPTO_MAX_ALG_NAME
, "%s",
221 alg
->base
.cra_blocksize
= def
->blocksize
;
222 alg
->base
.cra_ablkcipher
.ivsize
= def
->ivsize
;
224 ret
= crypto_register_aead(alg
);
226 pr_err("%s ablkcipher algorithm registration error (%d)\n",
227 alg
->base
.cra_name
, ret
);
232 list_add(&ccp_aead
->entry
, head
);
237 int ccp_register_aes_aeads(struct list_head
*head
)
240 unsigned int ccpversion
= ccp_version();
242 for (i
= 0; i
< ARRAY_SIZE(aes_aead_algs
); i
++) {
243 if (aes_aead_algs
[i
].version
> ccpversion
)
245 ret
= ccp_register_aes_aead(head
, &aes_aead_algs
[i
]);