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>
20 #include <linux/cryptouser.h>
21 #include <net/netlink.h>
22 #include <linux/compiler.h>
26 static const struct crypto_type crypto_shash_type
;
28 int shash_no_setkey(struct crypto_shash
*tfm
, const u8
*key
,
33 EXPORT_SYMBOL_GPL(shash_no_setkey
);
35 static int shash_setkey_unaligned(struct crypto_shash
*tfm
, const u8
*key
,
38 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
39 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
41 u8
*buffer
, *alignbuffer
;
44 absize
= keylen
+ (alignmask
& ~(crypto_tfm_ctx_alignment() - 1));
45 buffer
= kmalloc(absize
, GFP_ATOMIC
);
49 alignbuffer
= (u8
*)ALIGN((unsigned long)buffer
, alignmask
+ 1);
50 memcpy(alignbuffer
, key
, keylen
);
51 err
= shash
->setkey(tfm
, alignbuffer
, keylen
);
56 static void shash_set_needkey(struct crypto_shash
*tfm
, struct shash_alg
*alg
)
58 if (crypto_shash_alg_has_setkey(alg
) &&
59 !(alg
->base
.cra_flags
& CRYPTO_ALG_OPTIONAL_KEY
))
60 crypto_shash_set_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
63 int crypto_shash_setkey(struct crypto_shash
*tfm
, const u8
*key
,
66 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
67 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
70 if ((unsigned long)key
& alignmask
)
71 err
= shash_setkey_unaligned(tfm
, key
, keylen
);
73 err
= shash
->setkey(tfm
, key
, keylen
);
76 shash_set_needkey(tfm
, shash
);
80 crypto_shash_clear_flags(tfm
, CRYPTO_TFM_NEED_KEY
);
83 EXPORT_SYMBOL_GPL(crypto_shash_setkey
);
85 static int shash_update_unaligned(struct shash_desc
*desc
, const u8
*data
,
88 struct crypto_shash
*tfm
= desc
->tfm
;
89 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
90 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
91 unsigned int unaligned_len
= alignmask
+ 1 -
92 ((unsigned long)data
& alignmask
);
94 * We cannot count on __aligned() working for large values:
95 * https://patchwork.kernel.org/patch/9507697/
97 u8 ubuf
[MAX_ALGAPI_ALIGNMASK
* 2];
98 u8
*buf
= PTR_ALIGN(&ubuf
[0], alignmask
+ 1);
101 if (WARN_ON(buf
+ unaligned_len
> ubuf
+ sizeof(ubuf
)))
104 if (unaligned_len
> len
)
107 memcpy(buf
, data
, unaligned_len
);
108 err
= shash
->update(desc
, buf
, unaligned_len
);
109 memset(buf
, 0, unaligned_len
);
112 shash
->update(desc
, data
+ unaligned_len
, len
- unaligned_len
);
115 int crypto_shash_update(struct shash_desc
*desc
, const u8
*data
,
118 struct crypto_shash
*tfm
= desc
->tfm
;
119 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
120 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
122 if ((unsigned long)data
& alignmask
)
123 return shash_update_unaligned(desc
, data
, len
);
125 return shash
->update(desc
, data
, len
);
127 EXPORT_SYMBOL_GPL(crypto_shash_update
);
129 static int shash_final_unaligned(struct shash_desc
*desc
, u8
*out
)
131 struct crypto_shash
*tfm
= desc
->tfm
;
132 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
133 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
134 unsigned int ds
= crypto_shash_digestsize(tfm
);
136 * We cannot count on __aligned() working for large values:
137 * https://patchwork.kernel.org/patch/9507697/
139 u8 ubuf
[MAX_ALGAPI_ALIGNMASK
+ HASH_MAX_DIGESTSIZE
];
140 u8
*buf
= PTR_ALIGN(&ubuf
[0], alignmask
+ 1);
143 if (WARN_ON(buf
+ ds
> ubuf
+ sizeof(ubuf
)))
146 err
= shash
->final(desc
, buf
);
150 memcpy(out
, buf
, ds
);
157 int crypto_shash_final(struct shash_desc
*desc
, u8
*out
)
159 struct crypto_shash
*tfm
= desc
->tfm
;
160 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
161 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
163 if ((unsigned long)out
& alignmask
)
164 return shash_final_unaligned(desc
, out
);
166 return shash
->final(desc
, out
);
168 EXPORT_SYMBOL_GPL(crypto_shash_final
);
170 static int shash_finup_unaligned(struct shash_desc
*desc
, const u8
*data
,
171 unsigned int len
, u8
*out
)
173 return crypto_shash_update(desc
, data
, len
) ?:
174 crypto_shash_final(desc
, out
);
177 int crypto_shash_finup(struct shash_desc
*desc
, const u8
*data
,
178 unsigned int len
, u8
*out
)
180 struct crypto_shash
*tfm
= desc
->tfm
;
181 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
182 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
184 if (((unsigned long)data
| (unsigned long)out
) & alignmask
)
185 return shash_finup_unaligned(desc
, data
, len
, out
);
187 return shash
->finup(desc
, data
, len
, out
);
189 EXPORT_SYMBOL_GPL(crypto_shash_finup
);
191 static int shash_digest_unaligned(struct shash_desc
*desc
, const u8
*data
,
192 unsigned int len
, u8
*out
)
194 return crypto_shash_init(desc
) ?:
195 crypto_shash_finup(desc
, data
, len
, out
);
198 int crypto_shash_digest(struct shash_desc
*desc
, const u8
*data
,
199 unsigned int len
, u8
*out
)
201 struct crypto_shash
*tfm
= desc
->tfm
;
202 struct shash_alg
*shash
= crypto_shash_alg(tfm
);
203 unsigned long alignmask
= crypto_shash_alignmask(tfm
);
205 if (crypto_shash_get_flags(tfm
) & CRYPTO_TFM_NEED_KEY
)
208 if (((unsigned long)data
| (unsigned long)out
) & alignmask
)
209 return shash_digest_unaligned(desc
, data
, len
, out
);
211 return shash
->digest(desc
, data
, len
, out
);
213 EXPORT_SYMBOL_GPL(crypto_shash_digest
);
215 static int shash_default_export(struct shash_desc
*desc
, void *out
)
217 memcpy(out
, shash_desc_ctx(desc
), crypto_shash_descsize(desc
->tfm
));
221 static int shash_default_import(struct shash_desc
*desc
, const void *in
)
223 memcpy(shash_desc_ctx(desc
), in
, crypto_shash_descsize(desc
->tfm
));
227 static int shash_async_setkey(struct crypto_ahash
*tfm
, const u8
*key
,
230 struct crypto_shash
**ctx
= crypto_ahash_ctx(tfm
);
232 return crypto_shash_setkey(*ctx
, key
, keylen
);
235 static int shash_async_init(struct ahash_request
*req
)
237 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
238 struct shash_desc
*desc
= ahash_request_ctx(req
);
242 return crypto_shash_init(desc
);
245 int shash_ahash_update(struct ahash_request
*req
, struct shash_desc
*desc
)
247 struct crypto_hash_walk walk
;
250 for (nbytes
= crypto_hash_walk_first(req
, &walk
); nbytes
> 0;
251 nbytes
= crypto_hash_walk_done(&walk
, nbytes
))
252 nbytes
= crypto_shash_update(desc
, walk
.data
, nbytes
);
256 EXPORT_SYMBOL_GPL(shash_ahash_update
);
258 static int shash_async_update(struct ahash_request
*req
)
260 return shash_ahash_update(req
, ahash_request_ctx(req
));
263 static int shash_async_final(struct ahash_request
*req
)
265 return crypto_shash_final(ahash_request_ctx(req
), req
->result
);
268 int shash_ahash_finup(struct ahash_request
*req
, struct shash_desc
*desc
)
270 struct crypto_hash_walk walk
;
273 nbytes
= crypto_hash_walk_first(req
, &walk
);
275 return crypto_shash_final(desc
, req
->result
);
278 nbytes
= crypto_hash_walk_last(&walk
) ?
279 crypto_shash_finup(desc
, walk
.data
, nbytes
,
281 crypto_shash_update(desc
, walk
.data
, nbytes
);
282 nbytes
= crypto_hash_walk_done(&walk
, nbytes
);
283 } while (nbytes
> 0);
287 EXPORT_SYMBOL_GPL(shash_ahash_finup
);
289 static int shash_async_finup(struct ahash_request
*req
)
291 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
292 struct shash_desc
*desc
= ahash_request_ctx(req
);
296 return shash_ahash_finup(req
, desc
);
299 int shash_ahash_digest(struct ahash_request
*req
, struct shash_desc
*desc
)
301 unsigned int nbytes
= req
->nbytes
;
302 struct scatterlist
*sg
;
307 (sg
= req
->src
, offset
= sg
->offset
,
308 nbytes
<= min(sg
->length
, ((unsigned int)(PAGE_SIZE
)) - offset
))) {
311 data
= kmap_atomic(sg_page(sg
));
312 err
= crypto_shash_digest(desc
, data
+ offset
, nbytes
,
316 err
= crypto_shash_init(desc
) ?:
317 shash_ahash_finup(req
, desc
);
321 EXPORT_SYMBOL_GPL(shash_ahash_digest
);
323 static int shash_async_digest(struct ahash_request
*req
)
325 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
326 struct shash_desc
*desc
= ahash_request_ctx(req
);
330 return shash_ahash_digest(req
, desc
);
333 static int shash_async_export(struct ahash_request
*req
, void *out
)
335 return crypto_shash_export(ahash_request_ctx(req
), out
);
338 static int shash_async_import(struct ahash_request
*req
, const void *in
)
340 struct crypto_shash
**ctx
= crypto_ahash_ctx(crypto_ahash_reqtfm(req
));
341 struct shash_desc
*desc
= ahash_request_ctx(req
);
345 return crypto_shash_import(desc
, in
);
348 static void crypto_exit_shash_ops_async(struct crypto_tfm
*tfm
)
350 struct crypto_shash
**ctx
= crypto_tfm_ctx(tfm
);
352 crypto_free_shash(*ctx
);
355 int crypto_init_shash_ops_async(struct crypto_tfm
*tfm
)
357 struct crypto_alg
*calg
= tfm
->__crt_alg
;
358 struct shash_alg
*alg
= __crypto_shash_alg(calg
);
359 struct crypto_ahash
*crt
= __crypto_ahash_cast(tfm
);
360 struct crypto_shash
**ctx
= crypto_tfm_ctx(tfm
);
361 struct crypto_shash
*shash
;
363 if (!crypto_mod_get(calg
))
366 shash
= crypto_create_tfm(calg
, &crypto_shash_type
);
368 crypto_mod_put(calg
);
369 return PTR_ERR(shash
);
373 tfm
->exit
= crypto_exit_shash_ops_async
;
375 crt
->init
= shash_async_init
;
376 crt
->update
= shash_async_update
;
377 crt
->final
= shash_async_final
;
378 crt
->finup
= shash_async_finup
;
379 crt
->digest
= shash_async_digest
;
380 if (crypto_shash_alg_has_setkey(alg
))
381 crt
->setkey
= shash_async_setkey
;
383 crypto_ahash_set_flags(crt
, crypto_shash_get_flags(shash
) &
384 CRYPTO_TFM_NEED_KEY
);
386 crt
->export
= shash_async_export
;
387 crt
->import
= shash_async_import
;
389 crt
->reqsize
= sizeof(struct shash_desc
) + crypto_shash_descsize(shash
);
394 static int crypto_shash_init_tfm(struct crypto_tfm
*tfm
)
396 struct crypto_shash
*hash
= __crypto_shash_cast(tfm
);
397 struct shash_alg
*alg
= crypto_shash_alg(hash
);
399 hash
->descsize
= alg
->descsize
;
401 shash_set_needkey(hash
, alg
);
407 static int crypto_shash_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
409 struct crypto_report_hash rhash
;
410 struct shash_alg
*salg
= __crypto_shash_alg(alg
);
412 memset(&rhash
, 0, sizeof(rhash
));
414 strscpy(rhash
.type
, "shash", sizeof(rhash
.type
));
416 rhash
.blocksize
= alg
->cra_blocksize
;
417 rhash
.digestsize
= salg
->digestsize
;
419 return nla_put(skb
, CRYPTOCFGA_REPORT_HASH
, sizeof(rhash
), &rhash
);
422 static int crypto_shash_report(struct sk_buff
*skb
, struct crypto_alg
*alg
)
428 static void crypto_shash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
430 static void crypto_shash_show(struct seq_file
*m
, struct crypto_alg
*alg
)
432 struct shash_alg
*salg
= __crypto_shash_alg(alg
);
434 seq_printf(m
, "type : shash\n");
435 seq_printf(m
, "blocksize : %u\n", alg
->cra_blocksize
);
436 seq_printf(m
, "digestsize : %u\n", salg
->digestsize
);
439 static const struct crypto_type crypto_shash_type
= {
440 .extsize
= crypto_alg_extsize
,
441 .init_tfm
= crypto_shash_init_tfm
,
442 #ifdef CONFIG_PROC_FS
443 .show
= crypto_shash_show
,
445 .report
= crypto_shash_report
,
446 .maskclear
= ~CRYPTO_ALG_TYPE_MASK
,
447 .maskset
= CRYPTO_ALG_TYPE_MASK
,
448 .type
= CRYPTO_ALG_TYPE_SHASH
,
449 .tfmsize
= offsetof(struct crypto_shash
, base
),
452 struct crypto_shash
*crypto_alloc_shash(const char *alg_name
, u32 type
,
455 return crypto_alloc_tfm(alg_name
, &crypto_shash_type
, type
, mask
);
457 EXPORT_SYMBOL_GPL(crypto_alloc_shash
);
459 static int shash_prepare_alg(struct shash_alg
*alg
)
461 struct crypto_alg
*base
= &alg
->base
;
463 if (alg
->digestsize
> HASH_MAX_DIGESTSIZE
||
464 alg
->descsize
> HASH_MAX_DESCSIZE
||
465 alg
->statesize
> HASH_MAX_STATESIZE
)
468 if ((alg
->export
&& !alg
->import
) || (alg
->import
&& !alg
->export
))
471 base
->cra_type
= &crypto_shash_type
;
472 base
->cra_flags
&= ~CRYPTO_ALG_TYPE_MASK
;
473 base
->cra_flags
|= CRYPTO_ALG_TYPE_SHASH
;
476 alg
->finup
= shash_finup_unaligned
;
478 alg
->digest
= shash_digest_unaligned
;
480 alg
->export
= shash_default_export
;
481 alg
->import
= shash_default_import
;
482 alg
->statesize
= alg
->descsize
;
485 alg
->setkey
= shash_no_setkey
;
490 int crypto_register_shash(struct shash_alg
*alg
)
492 struct crypto_alg
*base
= &alg
->base
;
495 err
= shash_prepare_alg(alg
);
499 return crypto_register_alg(base
);
501 EXPORT_SYMBOL_GPL(crypto_register_shash
);
503 int crypto_unregister_shash(struct shash_alg
*alg
)
505 return crypto_unregister_alg(&alg
->base
);
507 EXPORT_SYMBOL_GPL(crypto_unregister_shash
);
509 int crypto_register_shashes(struct shash_alg
*algs
, int count
)
513 for (i
= 0; i
< count
; i
++) {
514 ret
= crypto_register_shash(&algs
[i
]);
522 for (--i
; i
>= 0; --i
)
523 crypto_unregister_shash(&algs
[i
]);
527 EXPORT_SYMBOL_GPL(crypto_register_shashes
);
529 int crypto_unregister_shashes(struct shash_alg
*algs
, int count
)
533 for (i
= count
- 1; i
>= 0; --i
) {
534 ret
= crypto_unregister_shash(&algs
[i
]);
536 pr_err("Failed to unregister %s %s: %d\n",
537 algs
[i
].base
.cra_driver_name
,
538 algs
[i
].base
.cra_name
, ret
);
543 EXPORT_SYMBOL_GPL(crypto_unregister_shashes
);
545 int shash_register_instance(struct crypto_template
*tmpl
,
546 struct shash_instance
*inst
)
550 err
= shash_prepare_alg(&inst
->alg
);
554 return crypto_register_instance(tmpl
, shash_crypto_instance(inst
));
556 EXPORT_SYMBOL_GPL(shash_register_instance
);
558 void shash_free_instance(struct crypto_instance
*inst
)
560 crypto_drop_spawn(crypto_instance_ctx(inst
));
561 kfree(shash_instance(inst
));
563 EXPORT_SYMBOL_GPL(shash_free_instance
);
565 int crypto_init_shash_spawn(struct crypto_shash_spawn
*spawn
,
566 struct shash_alg
*alg
,
567 struct crypto_instance
*inst
)
569 return crypto_init_spawn2(&spawn
->base
, &alg
->base
, inst
,
572 EXPORT_SYMBOL_GPL(crypto_init_shash_spawn
);
574 struct shash_alg
*shash_attr_alg(struct rtattr
*rta
, u32 type
, u32 mask
)
576 struct crypto_alg
*alg
;
578 alg
= crypto_attr_alg2(rta
, &crypto_shash_type
, type
, mask
);
579 return IS_ERR(alg
) ? ERR_CAST(alg
) :
580 container_of(alg
, struct shash_alg
, base
);
582 EXPORT_SYMBOL_GPL(shash_attr_alg
);
584 MODULE_LICENSE("GPL");
585 MODULE_DESCRIPTION("Synchronous cryptographic hash type");