2 * Synchronous Cryptographic Hash operations.
4 * Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the Free
8 * Software Foundation; either version 2 of the License, or (at your option)
13 #include <crypto/scatterwalk.h>
14 #include <crypto/internal/hash.h>
15 #include <linux/err.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/slab.h>
19 #include <linux/seq_file.h>
23 static const struct crypto_type crypto_shash_type
;
25 static int shash_no_setkey(struct crypto_shash
*tfm
, const u8
*key
,
31 static int shash_setkey_unaligned(struct crypto_shash
*tfm
, const u8
*key
,
34 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
35 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
37 u8
*buffer
, *alignbuffer
;
40 absize
= keylen
+ (alignmask
& ~(CRYPTO_MINALIGN
- 1));
41 buffer
= kmalloc(absize
, GFP_KERNEL
);
45 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
46 memcpy(alignbuffer
, key
, keylen
);
47 err
= shash
->setkey(tfm
, alignbuffer
, keylen
);
52 int crypto_shash_setkey(struct crypto_shash
*tfm
, const u8
*key
,
55 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
56 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
58 if ((unsigned long)key
& alignmask
)
59 return shash_setkey_unaligned(tfm
, key
, keylen
);
61 return shash
->setkey(tfm
, key
, keylen
);
63 EXPORT_SYMBOL_GPL(crypto_shash_setkey
);
65 static inline unsigned int shash_align_buffer_size(unsigned len
,
68 return len
+ (mask
& ~(__alignof__(u8
__attribute__ ((aligned
))) - 1));
71 static int shash_update_unaligned(struct shash_desc
*desc
, const u8
*data
,
74 struct crypto_shash
*tfm
= desc
->tfm
;
75 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
76 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
77 unsigned int unaligned_len
= alignmask
+ 1 -
78 ((unsigned long)data
& alignmask
);
79 u8 ubuf
[shash_align_buffer_size(unaligned_len
, alignmask
)]
80 __attribute__ ((aligned
));
81 u8
*buf
= PTR_ALIGN(&ubuf
[0], alignmask
+ 1);
84 if (unaligned_len
> len
)
87 memcpy(buf
, data
, unaligned_len
);
88 err
= shash
->update(desc
, buf
, unaligned_len
);
89 memset(buf
, 0, unaligned_len
);
92 shash
->update(desc
, data
+ unaligned_len
, len
- unaligned_len
);
95 int crypto_shash_update(struct shash_desc
*desc
, const u8
*data
,
98 struct crypto_shash
*tfm
= desc
->tfm
;
99 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
100 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
102 if ((unsigned long)data
& alignmask
)
103 return shash_update_unaligned(desc
, data
, len
);
105 return shash
->update(desc
, data
, len
);
107 EXPORT_SYMBOL_GPL(crypto_shash_update
);
109 static int shash_final_unaligned(struct shash_desc
*desc
, u8
*out
)
111 struct crypto_shash
*tfm
= desc
->tfm
;
112 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
113 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
114 unsigned int ds
= crypto_shash_digestsize(tfm
);
115 u8 ubuf
[shash_align_buffer_size(ds
, alignmask
)]
116 __attribute__ ((aligned
));
117 u8
*buf
= PTR_ALIGN(&ubuf
[0], alignmask
+ 1);
120 err
= shash
->final(desc
, buf
);
124 memcpy(out
, buf
, ds
);
131 int crypto_shash_final(struct shash_desc
*desc
, u8
*out
)
133 struct crypto_shash
*tfm
= desc
->tfm
;
134 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
135 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
137 if ((unsigned long)out
& alignmask
)
138 return shash_final_unaligned(desc
, out
);
140 return shash
->final(desc
, out
);
142 EXPORT_SYMBOL_GPL(crypto_shash_final
);
144 static int shash_finup_unaligned(struct shash_desc
*desc
, const u8
*data
,
145 unsigned int len
, u8
*out
)
147 return crypto_shash_update(desc
, data
, len
) ?:
148 crypto_shash_final(desc
, out
);
151 int crypto_shash_finup(struct shash_desc
*desc
, const u8
*data
,
152 unsigned int len
, u8
*out
)
154 struct crypto_shash
*tfm
= desc
->tfm
;
155 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
156 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
158 if (((unsigned long)data
| (unsigned long)out
) & alignmask
)
159 return shash_finup_unaligned(desc
, data
, len
, out
);
161 return shash
->finup(desc
, data
, len
, out
);
163 EXPORT_SYMBOL_GPL(crypto_shash_finup
);
165 static int shash_digest_unaligned(struct shash_desc
*desc
, const u8
*data
,
166 unsigned int len
, u8
*out
)
168 return crypto_shash_init(desc
) ?:
169 crypto_shash_finup(desc
, data
, len
, out
);
172 int crypto_shash_digest(struct shash_desc
*desc
, const u8
*data
,
173 unsigned int len
, u8
*out
)
175 struct crypto_shash
*tfm
= desc
->tfm
;
176 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
177 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
179 if (((unsigned long)data
| (unsigned long)out
) & alignmask
)
180 return shash_digest_unaligned(desc
, data
, len
, out
);
182 return shash
->digest(desc
, data
, len
, out
);
184 EXPORT_SYMBOL_GPL(crypto_shash_digest
);
186 static int shash_no_export(struct shash_desc
*desc
, void *out
)
191 static int shash_no_import(struct shash_desc
*desc
, const void *in
)
196 static int shash_async_setkey(struct crypto_ahash
*tfm
, const u8
*key
,
199 struct crypto_shash
**ctx
= crypto_ahash_ctx(tfm
);
201 return crypto_shash_setkey(*ctx
, key
, keylen
);
204 static int shash_async_init(struct ahash_request
*req
)
206 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
207 struct shash_desc
*desc
= ahash_request_ctx(req
);
210 desc
->flags
= req
->base
.flags
;
212 return crypto_shash_init(desc
);
215 int shash_ahash_update(struct ahash_request
*req
, struct shash_desc
*desc
)
217 struct crypto_hash_walk walk
;
220 for (nbytes
= crypto_hash_walk_first(req
, &walk
); nbytes
> 0;
221 nbytes
= crypto_hash_walk_done(&walk
, nbytes
))
222 nbytes
= crypto_shash_update(desc
, walk
.data
, nbytes
);
226 EXPORT_SYMBOL_GPL(shash_ahash_update
);
228 static int shash_async_update(struct ahash_request
*req
)
230 return shash_ahash_update(req
, ahash_request_ctx(req
));
233 static int shash_async_final(struct ahash_request
*req
)
235 return crypto_shash_final(ahash_request_ctx(req
), req
->result
);
238 int shash_ahash_finup(struct ahash_request
*req
, struct shash_desc
*desc
)
240 struct crypto_hash_walk walk
;
243 nbytes
= crypto_hash_walk_first(req
, &walk
);
245 return crypto_shash_final(desc
, req
->result
);
248 nbytes
= crypto_hash_walk_last(&walk
) ?
249 crypto_shash_finup(desc
, walk
.data
, nbytes
,
251 crypto_shash_update(desc
, walk
.data
, nbytes
);
252 nbytes
= crypto_hash_walk_done(&walk
, nbytes
);
253 } while (nbytes
> 0);
257 EXPORT_SYMBOL_GPL(shash_ahash_finup
);
259 static int shash_async_finup(struct ahash_request
*req
)
261 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
262 struct shash_desc
*desc
= ahash_request_ctx(req
);
265 desc
->flags
= req
->base
.flags
;
267 return shash_ahash_finup(req
, desc
);
270 int shash_ahash_digest(struct ahash_request
*req
, struct shash_desc
*desc
)
272 struct scatterlist
*sg
= req
->src
;
273 unsigned int offset
= sg
->offset
;
274 unsigned int nbytes
= req
->nbytes
;
277 if (nbytes
< min(sg
->length
, ((unsigned int)(PAGE_SIZE
)) - offset
)) {
280 data
= crypto_kmap(sg_page(sg
), 0);
281 err
= crypto_shash_digest(desc
, data
+ offset
, nbytes
,
283 crypto_kunmap(data
, 0);
284 crypto_yield(desc
->flags
);
286 err
= crypto_shash_init(desc
) ?:
287 shash_ahash_finup(req
, desc
);
291 EXPORT_SYMBOL_GPL(shash_ahash_digest
);
293 static int shash_async_digest(struct ahash_request
*req
)
295 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
296 struct shash_desc
*desc
= ahash_request_ctx(req
);
299 desc
->flags
= req
->base
.flags
;
301 return shash_ahash_digest(req
, desc
);
304 static int shash_async_export(struct ahash_request
*req
, void *out
)
306 return crypto_shash_export(ahash_request_ctx(req
), out
);
309 static int shash_async_import(struct ahash_request
*req
, const void *in
)
311 return crypto_shash_import(ahash_request_ctx(req
), in
);
314 static void crypto_exit_shash_ops_async(struct crypto_tfm
*tfm
)
316 struct crypto_shash
**ctx
= crypto_tfm_ctx(tfm
);
318 crypto_free_shash(*ctx
);
321 int crypto_init_shash_ops_async(struct crypto_tfm
*tfm
)
323 struct crypto_alg
*calg
= tfm
->__crt_alg
;
324 struct shash_alg
*alg
= __crypto_shash_alg(calg
);
325 struct crypto_ahash
*crt
= __crypto_ahash_cast(tfm
);
326 struct crypto_shash
**ctx
= crypto_tfm_ctx(tfm
);
327 struct crypto_shash
*shash
;
329 if (!crypto_mod_get(calg
))
332 shash
= crypto_create_tfm(calg
, &crypto_shash_type
);
334 crypto_mod_put(calg
);
335 return PTR_ERR(shash
);
339 tfm
->exit
= crypto_exit_shash_ops_async
;
341 crt
->init
= shash_async_init
;
342 crt
->update
= shash_async_update
;
343 crt
->final
= shash_async_final
;
344 crt
->finup
= shash_async_finup
;
345 crt
->digest
= shash_async_digest
;
348 crt
->setkey
= shash_async_setkey
;
350 crt
->export
= shash_async_export
;
352 crt
->import
= shash_async_import
;
354 crt
->reqsize
= sizeof(struct shash_desc
) + crypto_shash_descsize(shash
);
359 static int shash_compat_setkey(struct crypto_hash
*tfm
, const u8
*key
,
362 struct shash_desc
**descp
= crypto_hash_ctx(tfm
);
363 struct shash_desc
*desc
= *descp
;
365 return crypto_shash_setkey(desc
->tfm
, key
, keylen
);
368 static int shash_compat_init(struct hash_desc
*hdesc
)
370 struct shash_desc
**descp
= crypto_hash_ctx(hdesc
->tfm
);
371 struct shash_desc
*desc
= *descp
;
373 desc
->flags
= hdesc
->flags
;
375 return crypto_shash_init(desc
);
378 static int shash_compat_update(struct hash_desc
*hdesc
, struct scatterlist
*sg
,
381 struct shash_desc
**descp
= crypto_hash_ctx(hdesc
->tfm
);
382 struct shash_desc
*desc
= *descp
;
383 struct crypto_hash_walk walk
;
386 for (nbytes
= crypto_hash_walk_first_compat(hdesc
, &walk
, sg
, len
);
387 nbytes
> 0; nbytes
= crypto_hash_walk_done(&walk
, nbytes
))
388 nbytes
= crypto_shash_update(desc
, walk
.data
, nbytes
);
393 static int shash_compat_final(struct hash_desc
*hdesc
, u8
*out
)
395 struct shash_desc
**descp
= crypto_hash_ctx(hdesc
->tfm
);
397 return crypto_shash_final(*descp
, out
);
400 static int shash_compat_digest(struct hash_desc
*hdesc
, struct scatterlist
*sg
,
401 unsigned int nbytes
, u8
*out
)
403 unsigned int offset
= sg
->offset
;
406 if (nbytes
< min(sg
->length
, ((unsigned int)(PAGE_SIZE
)) - offset
)) {
407 struct shash_desc
**descp
= crypto_hash_ctx(hdesc
->tfm
);
408 struct shash_desc
*desc
= *descp
;
411 desc
->flags
= hdesc
->flags
;
413 data
= crypto_kmap(sg_page(sg
), 0);
414 err
= crypto_shash_digest(desc
, data
+ offset
, nbytes
, out
);
415 crypto_kunmap(data
, 0);
416 crypto_yield(desc
->flags
);
420 err
= shash_compat_init(hdesc
);
424 err
= shash_compat_update(hdesc
, sg
, nbytes
);
428 err
= shash_compat_final(hdesc
, out
);
434 static void crypto_exit_shash_ops_compat(struct crypto_tfm
*tfm
)
436 struct shash_desc
**descp
= crypto_tfm_ctx(tfm
);
437 struct shash_desc
*desc
= *descp
;
439 crypto_free_shash(desc
->tfm
);
443 static int crypto_init_shash_ops_compat(struct crypto_tfm
*tfm
)
445 struct hash_tfm
*crt
= &tfm
->crt_hash
;
446 struct crypto_alg
*calg
= tfm
->__crt_alg
;
447 struct shash_alg
*alg
= __crypto_shash_alg(calg
);
448 struct shash_desc
**descp
= crypto_tfm_ctx(tfm
);
449 struct crypto_shash
*shash
;
450 struct shash_desc
*desc
;
452 if (!crypto_mod_get(calg
))
455 shash
= crypto_create_tfm(calg
, &crypto_shash_type
);
457 crypto_mod_put(calg
);
458 return PTR_ERR(shash
);
461 desc
= kmalloc(sizeof(*desc
) + crypto_shash_descsize(shash
),
464 crypto_free_shash(shash
);
470 tfm
->exit
= crypto_exit_shash_ops_compat
;
472 crt
->init
= shash_compat_init
;
473 crt
->update
= shash_compat_update
;
474 crt
->final
= shash_compat_final
;
475 crt
->digest
= shash_compat_digest
;
476 crt
->setkey
= shash_compat_setkey
;
478 crt
->digestsize
= alg
->digestsize
;
483 static int crypto_init_shash_ops(struct crypto_tfm
*tfm
, u32 type
, u32 mask
)
485 switch (mask
& CRYPTO_ALG_TYPE_MASK
) {
486 case CRYPTO_ALG_TYPE_HASH_MASK
:
487 return crypto_init_shash_ops_compat(tfm
);
493 static unsigned int crypto_shash_ctxsize(struct crypto_alg
*alg
, u32 type
,
496 switch (mask
& CRYPTO_ALG_TYPE_MASK
) {
497 case CRYPTO_ALG_TYPE_HASH_MASK
:
498 return sizeof(struct shash_desc
*);
504 static int crypto_shash_init_tfm(struct crypto_tfm
*tfm
)
506 struct crypto_shash
*hash
= __crypto_shash_cast(tfm
);
508 hash
->descsize
= crypto_shash_alg(hash
)->descsize
;
512 static unsigned int crypto_shash_extsize(struct crypto_alg
*alg
)
514 return alg
->cra_ctxsize
;
517 static void crypto_shash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
518 __attribute__ ((unused
));
519 static void crypto_shash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
521 struct shash_alg
*salg
= __crypto_shash_alg(alg
);
523 seq_printf(m
, "type : shash\n");
524 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
525 seq_printf(m
, "digestsize : %u\n", salg
->digestsize
);
528 static const struct crypto_type crypto_shash_type
= {
529 .ctxsize
= crypto_shash_ctxsize
,
530 .extsize
= crypto_shash_extsize
,
531 .init
= crypto_init_shash_ops
,
532 .init_tfm
= crypto_shash_init_tfm
,
533 #ifdef CONFIG_PROC_FS
534 .show
= crypto_shash_show
,
536 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
537 .maskset
= CRYPTO_ALG_TYPE_MASK
,
538 .type
= CRYPTO_ALG_TYPE_SHASH
,
539 .tfmsize
= offsetof(struct crypto_shash
, base
),
542 struct crypto_shash
*crypto_alloc_shash(const char *alg_name
, u32 type
,
545 return crypto_alloc_tfm(alg_name
, &crypto_shash_type
, type
, mask
);
547 EXPORT_SYMBOL_GPL(crypto_alloc_shash
);
549 static int shash_prepare_alg(struct shash_alg
*alg
)
551 struct crypto_alg
*base
= &alg
->base
;
553 if (alg
->digestsize
> PAGE_SIZE
/ 8 ||
554 alg
->descsize
> PAGE_SIZE
/ 8 ||
555 alg
->statesize
> PAGE_SIZE
/ 8)
558 base
->cra_type
= &crypto_shash_type
;
559 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
560 base
->cra_flags
|= CRYPTO_ALG_TYPE_SHASH
;
563 alg
->finup
= shash_finup_unaligned
;
565 alg
->digest
= shash_digest_unaligned
;
567 alg
->import
= shash_no_import
;
569 alg
->export
= shash_no_export
;
571 alg
->setkey
= shash_no_setkey
;
576 int crypto_register_shash(struct shash_alg
*alg
)
578 struct crypto_alg
*base
= &alg
->base
;
581 err
= shash_prepare_alg(alg
);
585 return crypto_register_alg(base
);
587 EXPORT_SYMBOL_GPL(crypto_register_shash
);
589 int crypto_unregister_shash(struct shash_alg
*alg
)
591 return crypto_unregister_alg(&alg
->base
);
593 EXPORT_SYMBOL_GPL(crypto_unregister_shash
);
595 int shash_register_instance(struct crypto_template
*tmpl
,
596 struct shash_instance
*inst
)
600 err
= shash_prepare_alg(&inst
->alg
);
604 return crypto_register_instance(tmpl
, shash_crypto_instance(inst
));
606 EXPORT_SYMBOL_GPL(shash_register_instance
);
608 void shash_free_instance(struct crypto_instance
*inst
)
610 crypto_drop_spawn(crypto_instance_ctx(inst
));
611 kfree(shash_instance(inst
));
613 EXPORT_SYMBOL_GPL(shash_free_instance
);
615 int crypto_init_shash_spawn(struct crypto_shash_spawn
*spawn
,
616 struct shash_alg
*alg
,
617 struct crypto_instance
*inst
)
619 return crypto_init_spawn2(&spawn
->base
, &alg
->base
, inst
,
622 EXPORT_SYMBOL_GPL(crypto_init_shash_spawn
);
624 struct shash_alg
*shash_attr_alg(struct rtattr
*rta
, u32 type
, u32 mask
)
626 struct crypto_alg
*alg
;
628 alg
= crypto_attr_alg2(rta
, &crypto_shash_type
, type
, mask
);
629 return IS_ERR(alg
) ? ERR_CAST(alg
) :
630 container_of(alg
, struct shash_alg
, base
);
632 EXPORT_SYMBOL_GPL(shash_attr_alg
);
634 MODULE_LICENSE("GPL");
635 MODULE_DESCRIPTION("Synchronous cryptographic hash type");