2 * Asynchronous Cryptographic Hash operations.
4 * This is the asynchronous version of hash.c with notification of
5 * completion via a callback.
7 * Copyright (c) 2008 Loc Ho <lho@amcc.com>
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the Free
11 * Software Foundation; either version 2 of the License, or (at your option)
16 #include <crypto/internal/hash.h>
17 #include <crypto/scatterwalk.h>
18 #include <linux/bug.h>
19 #include <linux/err.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/sched.h>
23 #include <linux/slab.h>
24 #include <linux/seq_file.h>
25 #include <linux/cryptouser.h>
26 #include <linux/compiler.h>
27 #include <net/netlink.h>
31 struct ahash_request_priv
{
32 crypto_completion_t complete
;
36 void *ubuf
[] CRYPTO_MINALIGN_ATTR
;
39 static inline struct ahash_alg
*crypto_ahash_alg(struct crypto_ahash
*hash
)
41 return container_of(crypto_hash_alg_common(hash
), struct ahash_alg
,
45 static int hash_walk_next(struct crypto_hash_walk
*walk
)
47 unsigned int alignmask
= walk
->alignmask
;
48 unsigned int offset
= walk
->offset
;
49 unsigned int nbytes
= min(walk
->entrylen
,
50 ((unsigned int)(PAGE_SIZE
)) - offset
);
52 if (walk
->flags
& CRYPTO_ALG_ASYNC
)
53 walk
->data
= kmap(walk
->pg
);
55 walk
->data
= kmap_atomic(walk
->pg
);
58 if (offset
& alignmask
) {
59 unsigned int unaligned
= alignmask
+ 1 - (offset
& alignmask
);
61 if (nbytes
> unaligned
)
65 walk
->entrylen
-= nbytes
;
69 static int hash_walk_new_entry(struct crypto_hash_walk
*walk
)
71 struct scatterlist
*sg
;
74 walk
->offset
= sg
->offset
;
75 walk
->pg
= sg_page(walk
->sg
) + (walk
->offset
>> PAGE_SHIFT
);
76 walk
->offset
= offset_in_page(walk
->offset
);
77 walk
->entrylen
= sg
->length
;
79 if (walk
->entrylen
> walk
->total
)
80 walk
->entrylen
= walk
->total
;
81 walk
->total
-= walk
->entrylen
;
83 return hash_walk_next(walk
);
86 int crypto_hash_walk_done(struct crypto_hash_walk
*walk
, int err
)
88 unsigned int alignmask
= walk
->alignmask
;
89 unsigned int nbytes
= walk
->entrylen
;
91 walk
->data
-= walk
->offset
;
93 if (nbytes
&& walk
->offset
& alignmask
&& !err
) {
94 walk
->offset
= ALIGN(walk
->offset
, alignmask
+ 1);
95 walk
->data
+= walk
->offset
;
98 ((unsigned int)(PAGE_SIZE
)) - walk
->offset
);
99 walk
->entrylen
-= nbytes
;
104 if (walk
->flags
& CRYPTO_ALG_ASYNC
)
107 kunmap_atomic(walk
->data
);
109 * The may sleep test only makes sense for sync users.
110 * Async users don't need to sleep here anyway.
112 crypto_yield(walk
->flags
);
121 return hash_walk_next(walk
);
127 walk
->sg
= sg_next(walk
->sg
);
129 return hash_walk_new_entry(walk
);
131 EXPORT_SYMBOL_GPL(crypto_hash_walk_done
);
133 int crypto_hash_walk_first(struct ahash_request
*req
,
134 struct crypto_hash_walk
*walk
)
136 walk
->total
= req
->nbytes
;
143 walk
->alignmask
= crypto_ahash_alignmask(crypto_ahash_reqtfm(req
));
145 walk
->flags
= req
->base
.flags
& CRYPTO_TFM_REQ_MASK
;
147 return hash_walk_new_entry(walk
);
149 EXPORT_SYMBOL_GPL(crypto_hash_walk_first
);
151 int crypto_ahash_walk_first(struct ahash_request
*req
,
152 struct crypto_hash_walk
*walk
)
154 walk
->total
= req
->nbytes
;
161 walk
->alignmask
= crypto_ahash_alignmask(crypto_ahash_reqtfm(req
));
163 walk
->flags
= req
->base
.flags
& CRYPTO_TFM_REQ_MASK
;
164 walk
->flags
|= CRYPTO_ALG_ASYNC
;
166 BUILD_BUG_ON(CRYPTO_TFM_REQ_MASK
& CRYPTO_ALG_ASYNC
);
168 return hash_walk_new_entry(walk
);
170 EXPORT_SYMBOL_GPL(crypto_ahash_walk_first
);
172 static int ahash_setkey_unaligned(struct crypto_ahash
*tfm
, const u8
*key
,
175 unsigned long alignmask
= crypto_ahash_alignmask(tfm
);
177 u8
*buffer
, *alignbuffer
;
178 unsigned long absize
;
180 absize
= keylen
+ alignmask
;
181 buffer
= kmalloc(absize
, GFP_KERNEL
);
185 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
186 memcpy(alignbuffer
, key
, keylen
);
187 ret
= tfm
->setkey(tfm
, alignbuffer
, keylen
);
192 int crypto_ahash_setkey(struct crypto_ahash
*tfm
, const u8
*key
,
195 unsigned long alignmask
= crypto_ahash_alignmask(tfm
);
197 if ((unsigned long)key
& alignmask
)
198 return ahash_setkey_unaligned(tfm
, key
, keylen
);
200 return tfm
->setkey(tfm
, key
, keylen
);
202 EXPORT_SYMBOL_GPL(crypto_ahash_setkey
);
204 static int ahash_nosetkey(struct crypto_ahash
*tfm
, const u8
*key
,
210 static inline unsigned int ahash_align_buffer_size(unsigned len
,
213 return len
+ (mask
& ~(crypto_tfm_ctx_alignment() - 1));
216 static int ahash_save_req(struct ahash_request
*req
, crypto_completion_t cplt
)
218 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
219 unsigned long alignmask
= crypto_ahash_alignmask(tfm
);
220 unsigned int ds
= crypto_ahash_digestsize(tfm
);
221 struct ahash_request_priv
*priv
;
223 priv
= kmalloc(sizeof(*priv
) + ahash_align_buffer_size(ds
, alignmask
),
224 (req
->base
.flags
& CRYPTO_TFM_REQ_MAY_SLEEP
) ?
225 GFP_KERNEL
: GFP_ATOMIC
);
230 * WARNING: Voodoo programming below!
232 * The code below is obscure and hard to understand, thus explanation
233 * is necessary. See include/crypto/hash.h and include/linux/crypto.h
234 * to understand the layout of structures used here!
236 * The code here will replace portions of the ORIGINAL request with
237 * pointers to new code and buffers so the hashing operation can store
238 * the result in aligned buffer. We will call the modified request
239 * an ADJUSTED request.
241 * The newly mangled request will look as such:
244 * .result = ADJUSTED[new aligned buffer]
245 * .base.complete = ADJUSTED[pointer to completion function]
246 * .base.data = ADJUSTED[*req (pointer to self)]
247 * .priv = ADJUSTED[new priv] {
248 * .result = ORIGINAL(result)
249 * .complete = ORIGINAL(base.complete)
250 * .data = ORIGINAL(base.data)
254 priv
->result
= req
->result
;
255 priv
->complete
= req
->base
.complete
;
256 priv
->data
= req
->base
.data
;
257 priv
->flags
= req
->base
.flags
;
260 * WARNING: We do not backup req->priv here! The req->priv
261 * is for internal use of the Crypto API and the
262 * user must _NOT_ _EVER_ depend on it's content!
265 req
->result
= PTR_ALIGN((u8
*)priv
->ubuf
, alignmask
+ 1);
266 req
->base
.complete
= cplt
;
267 req
->base
.data
= req
;
273 static void ahash_restore_req(struct ahash_request
*req
, int err
)
275 struct ahash_request_priv
*priv
= req
->priv
;
278 memcpy(priv
->result
, req
->result
,
279 crypto_ahash_digestsize(crypto_ahash_reqtfm(req
)));
281 /* Restore the original crypto request. */
282 req
->result
= priv
->result
;
284 ahash_request_set_callback(req
, priv
->flags
,
285 priv
->complete
, priv
->data
);
288 /* Free the req->priv.priv from the ADJUSTED request. */
292 static void ahash_notify_einprogress(struct ahash_request
*req
)
294 struct ahash_request_priv
*priv
= req
->priv
;
295 struct crypto_async_request oreq
;
297 oreq
.data
= priv
->data
;
299 priv
->complete(&oreq
, -EINPROGRESS
);
302 static void ahash_op_unaligned_done(struct crypto_async_request
*req
, int err
)
304 struct ahash_request
*areq
= req
->data
;
306 if (err
== -EINPROGRESS
) {
307 ahash_notify_einprogress(areq
);
312 * Restore the original request, see ahash_op_unaligned() for what
315 * The "struct ahash_request *req" here is in fact the "req.base"
316 * from the ADJUSTED request from ahash_op_unaligned(), thus as it
317 * is a pointer to self, it is also the ADJUSTED "req" .
320 /* First copy req->result into req->priv.result */
321 ahash_restore_req(areq
, err
);
323 /* Complete the ORIGINAL request. */
324 areq
->base
.complete(&areq
->base
, err
);
327 static int ahash_op_unaligned(struct ahash_request
*req
,
328 int (*op
)(struct ahash_request
*))
332 err
= ahash_save_req(req
, ahash_op_unaligned_done
);
337 if (err
== -EINPROGRESS
|| err
== -EBUSY
)
340 ahash_restore_req(req
, err
);
345 static int crypto_ahash_op(struct ahash_request
*req
,
346 int (*op
)(struct ahash_request
*))
348 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
349 unsigned long alignmask
= crypto_ahash_alignmask(tfm
);
351 if ((unsigned long)req
->result
& alignmask
)
352 return ahash_op_unaligned(req
, op
);
357 int crypto_ahash_final(struct ahash_request
*req
)
359 return crypto_ahash_op(req
, crypto_ahash_reqtfm(req
)->final
);
361 EXPORT_SYMBOL_GPL(crypto_ahash_final
);
363 int crypto_ahash_finup(struct ahash_request
*req
)
365 return crypto_ahash_op(req
, crypto_ahash_reqtfm(req
)->finup
);
367 EXPORT_SYMBOL_GPL(crypto_ahash_finup
);
369 int crypto_ahash_digest(struct ahash_request
*req
)
371 return crypto_ahash_op(req
, crypto_ahash_reqtfm(req
)->digest
);
373 EXPORT_SYMBOL_GPL(crypto_ahash_digest
);
375 static void ahash_def_finup_done2(struct crypto_async_request
*req
, int err
)
377 struct ahash_request
*areq
= req
->data
;
379 if (err
== -EINPROGRESS
)
382 ahash_restore_req(areq
, err
);
384 areq
->base
.complete(&areq
->base
, err
);
387 static int ahash_def_finup_finish1(struct ahash_request
*req
, int err
)
392 req
->base
.complete
= ahash_def_finup_done2
;
394 err
= crypto_ahash_reqtfm(req
)->final(req
);
395 if (err
== -EINPROGRESS
|| err
== -EBUSY
)
399 ahash_restore_req(req
, err
);
403 static void ahash_def_finup_done1(struct crypto_async_request
*req
, int err
)
405 struct ahash_request
*areq
= req
->data
;
407 if (err
== -EINPROGRESS
) {
408 ahash_notify_einprogress(areq
);
412 areq
->base
.flags
&= ~CRYPTO_TFM_REQ_MAY_SLEEP
;
414 err
= ahash_def_finup_finish1(areq
, err
);
418 areq
->base
.complete(&areq
->base
, err
);
421 static int ahash_def_finup(struct ahash_request
*req
)
423 struct crypto_ahash
*tfm
= crypto_ahash_reqtfm(req
);
426 err
= ahash_save_req(req
, ahash_def_finup_done1
);
430 err
= tfm
->update(req
);
431 if (err
== -EINPROGRESS
|| err
== -EBUSY
)
434 return ahash_def_finup_finish1(req
, err
);
437 static int ahash_no_export(struct ahash_request
*req
, void *out
)
442 static int ahash_no_import(struct ahash_request
*req
, const void *in
)
447 static int crypto_ahash_init_tfm(struct crypto_tfm
*tfm
)
449 struct crypto_ahash
*hash
= __crypto_ahash_cast(tfm
);
450 struct ahash_alg
*alg
= crypto_ahash_alg(hash
);
452 hash
->setkey
= ahash_nosetkey
;
453 hash
->has_setkey
= false;
454 hash
->export
= ahash_no_export
;
455 hash
->import
= ahash_no_import
;
457 if (tfm
->__crt_alg
->cra_type
!= &crypto_ahash_type
)
458 return crypto_init_shash_ops_async(tfm
);
460 hash
->init
= alg
->init
;
461 hash
->update
= alg
->update
;
462 hash
->final
= alg
->final
;
463 hash
->finup
= alg
->finup
?: ahash_def_finup
;
464 hash
->digest
= alg
->digest
;
467 hash
->setkey
= alg
->setkey
;
468 hash
->has_setkey
= true;
471 hash
->export
= alg
->export
;
473 hash
->import
= alg
->import
;
478 static unsigned int crypto_ahash_extsize(struct crypto_alg
*alg
)
480 if (alg
->cra_type
!= &crypto_ahash_type
)
481 return sizeof(struct crypto_shash
*);
483 return crypto_alg_extsize(alg
);
487 static int crypto_ahash_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
489 struct crypto_report_hash rhash
;
491 strncpy(rhash
.type
, "ahash", sizeof(rhash
.type
));
493 rhash
.blocksize
= alg
->cra_blocksize
;
494 rhash
.digestsize
= __crypto_hash_alg_common(alg
)->digestsize
;
496 if (nla_put(skb
, CRYPTOCFGA_REPORT_HASH
,
497 sizeof(struct crypto_report_hash
), &rhash
))
498 goto nla_put_failure
;
505 static int crypto_ahash_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
511 static void crypto_ahash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
513 static void crypto_ahash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
515 seq_printf(m
, "type : ahash\n");
516 seq_printf(m
, "async : %s\n", alg
->cra_flags
& CRYPTO_ALG_ASYNC
?
518 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
519 seq_printf(m
, "digestsize : %u\n",
520 __crypto_hash_alg_common(alg
)->digestsize
);
523 const struct crypto_type crypto_ahash_type
= {
524 .extsize
= crypto_ahash_extsize
,
525 .init_tfm
= crypto_ahash_init_tfm
,
526 #ifdef CONFIG_PROC_FS
527 .show
= crypto_ahash_show
,
529 .report
= crypto_ahash_report
,
530 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
531 .maskset
= CRYPTO_ALG_TYPE_AHASH_MASK
,
532 .type
= CRYPTO_ALG_TYPE_AHASH
,
533 .tfmsize
= offsetof(struct crypto_ahash
, base
),
535 EXPORT_SYMBOL_GPL(crypto_ahash_type
);
537 struct crypto_ahash
*crypto_alloc_ahash(const char *alg_name
, u32 type
,
540 return crypto_alloc_tfm(alg_name
, &crypto_ahash_type
, type
, mask
);
542 EXPORT_SYMBOL_GPL(crypto_alloc_ahash
);
544 int crypto_has_ahash(const char *alg_name
, u32 type
, u32 mask
)
546 return crypto_type_has_alg(alg_name
, &crypto_ahash_type
, type
, mask
);
548 EXPORT_SYMBOL_GPL(crypto_has_ahash
);
550 static int ahash_prepare_alg(struct ahash_alg
*alg
)
552 struct crypto_alg
*base
= &alg
->halg
.base
;
554 if (alg
->halg
.digestsize
> PAGE_SIZE
/ 8 ||
555 alg
->halg
.statesize
> PAGE_SIZE
/ 8 ||
556 alg
->halg
.statesize
== 0)
559 base
->cra_type
= &crypto_ahash_type
;
560 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
561 base
->cra_flags
|= CRYPTO_ALG_TYPE_AHASH
;
566 int crypto_register_ahash(struct ahash_alg
*alg
)
568 struct crypto_alg
*base
= &alg
->halg
.base
;
571 err
= ahash_prepare_alg(alg
);
575 return crypto_register_alg(base
);
577 EXPORT_SYMBOL_GPL(crypto_register_ahash
);
579 int crypto_unregister_ahash(struct ahash_alg
*alg
)
581 return crypto_unregister_alg(&alg
->halg
.base
);
583 EXPORT_SYMBOL_GPL(crypto_unregister_ahash
);
585 int crypto_register_ahashes(struct ahash_alg
*algs
, int count
)
589 for (i
= 0; i
< count
; i
++) {
590 ret
= crypto_register_ahash(&algs
[i
]);
598 for (--i
; i
>= 0; --i
)
599 crypto_unregister_ahash(&algs
[i
]);
603 EXPORT_SYMBOL_GPL(crypto_register_ahashes
);
605 void crypto_unregister_ahashes(struct ahash_alg
*algs
, int count
)
609 for (i
= count
- 1; i
>= 0; --i
)
610 crypto_unregister_ahash(&algs
[i
]);
612 EXPORT_SYMBOL_GPL(crypto_unregister_ahashes
);
614 int ahash_register_instance(struct crypto_template
*tmpl
,
615 struct ahash_instance
*inst
)
619 err
= ahash_prepare_alg(&inst
->alg
);
623 return crypto_register_instance(tmpl
, ahash_crypto_instance(inst
));
625 EXPORT_SYMBOL_GPL(ahash_register_instance
);
627 void ahash_free_instance(struct crypto_instance
*inst
)
629 crypto_drop_spawn(crypto_instance_ctx(inst
));
630 kfree(ahash_instance(inst
));
632 EXPORT_SYMBOL_GPL(ahash_free_instance
);
634 int crypto_init_ahash_spawn(struct crypto_ahash_spawn
*spawn
,
635 struct hash_alg_common
*alg
,
636 struct crypto_instance
*inst
)
638 return crypto_init_spawn2(&spawn
->base
, &alg
->base
, inst
,
641 EXPORT_SYMBOL_GPL(crypto_init_ahash_spawn
);
643 struct hash_alg_common
*ahash_attr_alg(struct rtattr
*rta
, u32 type
, u32 mask
)
645 struct crypto_alg
*alg
;
647 alg
= crypto_attr_alg2(rta
, &crypto_ahash_type
, type
, mask
);
648 return IS_ERR(alg
) ? ERR_CAST(alg
) : __crypto_hash_alg_common(alg
);
650 EXPORT_SYMBOL_GPL(ahash_attr_alg
);
652 MODULE_LICENSE("GPL");
653 MODULE_DESCRIPTION("Asynchronous cryptographic hash type");