2 * AMD Cryptographic Coprocessor (CCP) SHA 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/hash.h>
20 #include <crypto/internal/hash.h>
21 #include <crypto/sha.h>
22 #include <crypto/scatterwalk.h>
24 #include "ccp-crypto.h"
26 static int ccp_sha_complete(struct crypto_async_request
*async_req
, int ret
)
28 struct ahash_request
*req
= ahash_request_cast(async_req
);
29 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
30 struct ccp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
31 unsigned int digest_size
= crypto_ahash_digestsize(tfm
);
37 /* Save remaining data to buffer */
38 unsigned int offset
= rctx
->nbytes
- rctx
->hash_rem
;
40 scatterwalk_map_and_copy(rctx
->buf
, rctx
->src
,
41 offset
, rctx
->hash_rem
, 0);
42 rctx
->buf_count
= rctx
->hash_rem
;
47 /* Update result area if supplied */
49 memcpy(req
->result
, rctx
->ctx
, digest_size
);
52 sg_free_table(&rctx
->data_sg
);
57 static int ccp_do_sha_update(struct ahash_request
*req
, unsigned int nbytes
,
60 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
61 struct ccp_ctx
*ctx
= crypto_ahash_ctx(tfm
);
62 struct ccp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
63 struct scatterlist
*sg
;
64 unsigned int block_size
=
65 crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm
));
66 unsigned int sg_count
;
71 len
= (u64
)rctx
->buf_count
+ (u64
)nbytes
;
73 if (!final
&& (len
<= block_size
)) {
74 scatterwalk_map_and_copy(rctx
->buf
+ rctx
->buf_count
, req
->src
,
76 rctx
->buf_count
+= nbytes
;
82 rctx
->nbytes
= nbytes
;
85 rctx
->hash_rem
= final
? 0 : len
& (block_size
- 1);
86 rctx
->hash_cnt
= len
- rctx
->hash_rem
;
87 if (!final
&& !rctx
->hash_rem
) {
88 /* CCP can't do zero length final, so keep some data around */
89 rctx
->hash_cnt
-= block_size
;
90 rctx
->hash_rem
= block_size
;
93 /* Initialize the context scatterlist */
94 sg_init_one(&rctx
->ctx_sg
, rctx
->ctx
, sizeof(rctx
->ctx
));
97 if (rctx
->buf_count
&& nbytes
) {
98 /* Build the data scatterlist table - allocate enough entries
99 * for both data pieces (buffer and input data)
101 gfp
= req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
?
102 GFP_KERNEL
: GFP_ATOMIC
;
103 sg_count
= sg_nents(req
->src
) + 1;
104 ret
= sg_alloc_table(&rctx
->data_sg
, sg_count
, gfp
);
108 sg_init_one(&rctx
->buf_sg
, rctx
->buf
, rctx
->buf_count
);
109 sg
= ccp_crypto_sg_table_add(&rctx
->data_sg
, &rctx
->buf_sg
);
114 sg
= ccp_crypto_sg_table_add(&rctx
->data_sg
, req
->src
);
121 sg
= rctx
->data_sg
.sgl
;
122 } else if (rctx
->buf_count
) {
123 sg_init_one(&rctx
->buf_sg
, rctx
->buf
, rctx
->buf_count
);
130 rctx
->msg_bits
+= (rctx
->hash_cnt
<< 3); /* Total in bits */
132 memset(&rctx
->cmd
, 0, sizeof(rctx
->cmd
));
133 INIT_LIST_HEAD(&rctx
->cmd
.entry
);
134 rctx
->cmd
.engine
= CCP_ENGINE_SHA
;
135 rctx
->cmd
.u
.sha
.type
= rctx
->type
;
136 rctx
->cmd
.u
.sha
.ctx
= &rctx
->ctx_sg
;
137 rctx
->cmd
.u
.sha
.ctx_len
= sizeof(rctx
->ctx
);
138 rctx
->cmd
.u
.sha
.src
= sg
;
139 rctx
->cmd
.u
.sha
.src_len
= rctx
->hash_cnt
;
140 rctx
->cmd
.u
.sha
.opad
= ctx
->u
.sha
.key_len
?
141 &ctx
->u
.sha
.opad_sg
: NULL
;
142 rctx
->cmd
.u
.sha
.opad_len
= ctx
->u
.sha
.key_len
?
143 ctx
->u
.sha
.opad_count
: 0;
144 rctx
->cmd
.u
.sha
.first
= rctx
->first
;
145 rctx
->cmd
.u
.sha
.final
= rctx
->final
;
146 rctx
->cmd
.u
.sha
.msg_bits
= rctx
->msg_bits
;
150 ret
= ccp_crypto_enqueue_request(&req
->base
, &rctx
->cmd
);
155 sg_free_table(&rctx
->data_sg
);
160 static int ccp_sha_init(struct ahash_request
*req
)
162 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
163 struct ccp_ctx
*ctx
= crypto_ahash_ctx(tfm
);
164 struct ccp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
165 struct ccp_crypto_ahash_alg
*alg
=
166 ccp_crypto_ahash_alg(crypto_ahash_tfm(tfm
));
167 unsigned int block_size
=
168 crypto_tfm_alg_blocksize(crypto_ahash_tfm(tfm
));
170 memset(rctx
, 0, sizeof(*rctx
));
172 rctx
->type
= alg
->type
;
175 if (ctx
->u
.sha
.key_len
) {
176 /* Buffer the HMAC key for first update */
177 memcpy(rctx
->buf
, ctx
->u
.sha
.ipad
, block_size
);
178 rctx
->buf_count
= block_size
;
184 static int ccp_sha_update(struct ahash_request
*req
)
186 return ccp_do_sha_update(req
, req
->nbytes
, 0);
189 static int ccp_sha_final(struct ahash_request
*req
)
191 return ccp_do_sha_update(req
, 0, 1);
194 static int ccp_sha_finup(struct ahash_request
*req
)
196 return ccp_do_sha_update(req
, req
->nbytes
, 1);
199 static int ccp_sha_digest(struct ahash_request
*req
)
203 ret
= ccp_sha_init(req
);
207 return ccp_sha_finup(req
);
210 static int ccp_sha_export(struct ahash_request
*req
, void *out
)
212 struct ccp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
213 struct ccp_sha_exp_ctx
*state
= out
;
215 state
->type
= rctx
->type
;
216 state
->msg_bits
= rctx
->msg_bits
;
217 state
->first
= rctx
->first
;
218 memcpy(state
->ctx
, rctx
->ctx
, sizeof(state
->ctx
));
219 state
->buf_count
= rctx
->buf_count
;
220 memcpy(state
->buf
, rctx
->buf
, sizeof(state
->buf
));
225 static int ccp_sha_import(struct ahash_request
*req
, const void *in
)
227 struct ccp_sha_req_ctx
*rctx
= ahash_request_ctx(req
);
228 const struct ccp_sha_exp_ctx
*state
= in
;
230 rctx
->type
= state
->type
;
231 rctx
->msg_bits
= state
->msg_bits
;
232 rctx
->first
= state
->first
;
233 memcpy(rctx
->ctx
, state
->ctx
, sizeof(rctx
->ctx
));
234 rctx
->buf_count
= state
->buf_count
;
235 memcpy(rctx
->buf
, state
->buf
, sizeof(rctx
->buf
));
240 static int ccp_sha_setkey(struct crypto_ahash
*tfm
, const u8
*key
,
241 unsigned int key_len
)
243 struct ccp_ctx
*ctx
= crypto_tfm_ctx(crypto_ahash_tfm(tfm
));
244 struct crypto_shash
*shash
= ctx
->u
.sha
.hmac_tfm
;
246 SHASH_DESC_ON_STACK(sdesc
, shash
);
248 unsigned int block_size
= crypto_shash_blocksize(shash
);
249 unsigned int digest_size
= crypto_shash_digestsize(shash
);
252 /* Set to zero until complete */
253 ctx
->u
.sha
.key_len
= 0;
255 /* Clear key area to provide zero padding for keys smaller
256 * than the block size
258 memset(ctx
->u
.sha
.key
, 0, sizeof(ctx
->u
.sha
.key
));
260 if (key_len
> block_size
) {
261 /* Must hash the input key */
263 sdesc
->flags
= crypto_ahash_get_flags(tfm
) &
264 CRYPTO_TFM_REQ_MAY_SLEEP
;
266 ret
= crypto_shash_digest(sdesc
, key
, key_len
,
269 crypto_ahash_set_flags(tfm
, CRYPTO_TFM_RES_BAD_KEY_LEN
);
273 key_len
= digest_size
;
275 memcpy(ctx
->u
.sha
.key
, key
, key_len
);
278 for (i
= 0; i
< block_size
; i
++) {
279 ctx
->u
.sha
.ipad
[i
] = ctx
->u
.sha
.key
[i
] ^ 0x36;
280 ctx
->u
.sha
.opad
[i
] = ctx
->u
.sha
.key
[i
] ^ 0x5c;
283 sg_init_one(&ctx
->u
.sha
.opad_sg
, ctx
->u
.sha
.opad
, block_size
);
284 ctx
->u
.sha
.opad_count
= block_size
;
286 ctx
->u
.sha
.key_len
= key_len
;
291 static int ccp_sha_cra_init(struct crypto_tfm
*tfm
)
293 struct ccp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
294 struct crypto_ahash
*ahash
= __crypto_ahash_cast(tfm
);
296 ctx
->complete
= ccp_sha_complete
;
297 ctx
->u
.sha
.key_len
= 0;
299 crypto_ahash_set_reqsize(ahash
, sizeof(struct ccp_sha_req_ctx
));
304 static void ccp_sha_cra_exit(struct crypto_tfm
*tfm
)
308 static int ccp_hmac_sha_cra_init(struct crypto_tfm
*tfm
)
310 struct ccp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
311 struct ccp_crypto_ahash_alg
*alg
= ccp_crypto_ahash_alg(tfm
);
312 struct crypto_shash
*hmac_tfm
;
314 hmac_tfm
= crypto_alloc_shash(alg
->child_alg
, 0, 0);
315 if (IS_ERR(hmac_tfm
)) {
316 pr_warn("could not load driver %s need for HMAC support\n",
318 return PTR_ERR(hmac_tfm
);
321 ctx
->u
.sha
.hmac_tfm
= hmac_tfm
;
323 return ccp_sha_cra_init(tfm
);
326 static void ccp_hmac_sha_cra_exit(struct crypto_tfm
*tfm
)
328 struct ccp_ctx
*ctx
= crypto_tfm_ctx(tfm
);
330 if (ctx
->u
.sha
.hmac_tfm
)
331 crypto_free_shash(ctx
->u
.sha
.hmac_tfm
);
333 ccp_sha_cra_exit(tfm
);
338 const char *drv_name
;
339 enum ccp_sha_type type
;
344 static struct ccp_sha_def sha_algs
[] = {
347 .drv_name
= "sha1-ccp",
348 .type
= CCP_SHA_TYPE_1
,
349 .digest_size
= SHA1_DIGEST_SIZE
,
350 .block_size
= SHA1_BLOCK_SIZE
,
354 .drv_name
= "sha224-ccp",
355 .type
= CCP_SHA_TYPE_224
,
356 .digest_size
= SHA224_DIGEST_SIZE
,
357 .block_size
= SHA224_BLOCK_SIZE
,
361 .drv_name
= "sha256-ccp",
362 .type
= CCP_SHA_TYPE_256
,
363 .digest_size
= SHA256_DIGEST_SIZE
,
364 .block_size
= SHA256_BLOCK_SIZE
,
368 static int ccp_register_hmac_alg(struct list_head
*head
,
369 const struct ccp_sha_def
*def
,
370 const struct ccp_crypto_ahash_alg
*base_alg
)
372 struct ccp_crypto_ahash_alg
*ccp_alg
;
373 struct ahash_alg
*alg
;
374 struct hash_alg_common
*halg
;
375 struct crypto_alg
*base
;
378 ccp_alg
= kzalloc(sizeof(*ccp_alg
), GFP_KERNEL
);
382 /* Copy the base algorithm and only change what's necessary */
383 *ccp_alg
= *base_alg
;
384 INIT_LIST_HEAD(&ccp_alg
->entry
);
386 strncpy(ccp_alg
->child_alg
, def
->name
, CRYPTO_MAX_ALG_NAME
);
389 alg
->setkey
= ccp_sha_setkey
;
394 snprintf(base
->cra_name
, CRYPTO_MAX_ALG_NAME
, "hmac(%s)", def
->name
);
395 snprintf(base
->cra_driver_name
, CRYPTO_MAX_ALG_NAME
, "hmac-%s",
397 base
->cra_init
= ccp_hmac_sha_cra_init
;
398 base
->cra_exit
= ccp_hmac_sha_cra_exit
;
400 ret
= crypto_register_ahash(alg
);
402 pr_err("%s ahash algorithm registration error (%d)\n",
403 base
->cra_name
, ret
);
408 list_add(&ccp_alg
->entry
, head
);
413 static int ccp_register_sha_alg(struct list_head
*head
,
414 const struct ccp_sha_def
*def
)
416 struct ccp_crypto_ahash_alg
*ccp_alg
;
417 struct ahash_alg
*alg
;
418 struct hash_alg_common
*halg
;
419 struct crypto_alg
*base
;
422 ccp_alg
= kzalloc(sizeof(*ccp_alg
), GFP_KERNEL
);
426 INIT_LIST_HEAD(&ccp_alg
->entry
);
428 ccp_alg
->type
= def
->type
;
431 alg
->init
= ccp_sha_init
;
432 alg
->update
= ccp_sha_update
;
433 alg
->final
= ccp_sha_final
;
434 alg
->finup
= ccp_sha_finup
;
435 alg
->digest
= ccp_sha_digest
;
436 alg
->export
= ccp_sha_export
;
437 alg
->import
= ccp_sha_import
;
440 halg
->digestsize
= def
->digest_size
;
441 halg
->statesize
= sizeof(struct ccp_sha_exp_ctx
);
444 snprintf(base
->cra_name
, CRYPTO_MAX_ALG_NAME
, "%s", def
->name
);
445 snprintf(base
->cra_driver_name
, CRYPTO_MAX_ALG_NAME
, "%s",
447 base
->cra_flags
= CRYPTO_ALG_TYPE_AHASH
| CRYPTO_ALG_ASYNC
|
448 CRYPTO_ALG_KERN_DRIVER_ONLY
|
449 CRYPTO_ALG_NEED_FALLBACK
;
450 base
->cra_blocksize
= def
->block_size
;
451 base
->cra_ctxsize
= sizeof(struct ccp_ctx
);
452 base
->cra_priority
= CCP_CRA_PRIORITY
;
453 base
->cra_type
= &crypto_ahash_type
;
454 base
->cra_init
= ccp_sha_cra_init
;
455 base
->cra_exit
= ccp_sha_cra_exit
;
456 base
->cra_module
= THIS_MODULE
;
458 ret
= crypto_register_ahash(alg
);
460 pr_err("%s ahash algorithm registration error (%d)\n",
461 base
->cra_name
, ret
);
466 list_add(&ccp_alg
->entry
, head
);
468 ret
= ccp_register_hmac_alg(head
, def
, ccp_alg
);
473 int ccp_register_sha_algs(struct list_head
*head
)
477 for (i
= 0; i
< ARRAY_SIZE(sha_algs
); i
++) {
478 ret
= ccp_register_sha_alg(head
, &sha_algs
[i
]);