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 static int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
35 * Check whether an shash algorithm has a setkey function.
37 * For CFI compatibility, this must not be an inline function. This is because
38 * when CFI is enabled, modules won't get the same address for shash_no_setkey
39 * (if it were exported, which inlining would require) as the core kernel will.
41 bool crypto_shash_alg_has_setkey(struct shash_alg *alg)
43 return alg->setkey != shash_no_setkey;
45 EXPORT_SYMBOL_GPL(crypto_shash_alg_has_setkey);
47 static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
50 struct shash_alg *shash = crypto_shash_alg(tfm);
51 unsigned long alignmask = crypto_shash_alignmask(tfm);
53 u8 *buffer, *alignbuffer;
56 absize = keylen + (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
57 buffer = kmalloc(absize, GFP_ATOMIC);
61 alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
62 memcpy(alignbuffer, key, keylen);
63 err = shash->setkey(tfm, alignbuffer, keylen);
68 static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
70 if (crypto_shash_alg_has_setkey(alg) &&
71 !(alg->base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
72 crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
75 int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
78 struct shash_alg *shash = crypto_shash_alg(tfm);
79 unsigned long alignmask = crypto_shash_alignmask(tfm);
82 if ((unsigned long)key & alignmask)
83 err = shash_setkey_unaligned(tfm, key, keylen);
85 err = shash->setkey(tfm, key, keylen);
88 shash_set_needkey(tfm, shash);
92 crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
95 EXPORT_SYMBOL_GPL(crypto_shash_setkey);
97 static inline unsigned int shash_align_buffer_size(unsigned len,
100 typedef u8 __aligned_largest u8_aligned;
101 return len + (mask & ~(__alignof__(u8_aligned) - 1));
104 static int shash_update_unaligned(struct shash_desc *desc, const u8 *data,
107 struct crypto_shash *tfm = desc->tfm;
108 struct shash_alg *shash = crypto_shash_alg(tfm);
109 unsigned long alignmask = crypto_shash_alignmask(tfm);
110 unsigned int unaligned_len = alignmask + 1 -
111 ((unsigned long)data & alignmask);
112 u8 ubuf[shash_align_buffer_size(unaligned_len, alignmask)]
114 u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
117 if (unaligned_len > len)
120 memcpy(buf, data, unaligned_len);
121 err = shash->update(desc, buf, unaligned_len);
122 memset(buf, 0, unaligned_len);
125 shash->update(desc, data + unaligned_len, len - unaligned_len);
128 int crypto_shash_update(struct shash_desc *desc, const u8 *data,
131 struct crypto_shash *tfm = desc->tfm;
132 struct shash_alg *shash = crypto_shash_alg(tfm);
133 unsigned long alignmask = crypto_shash_alignmask(tfm);
135 if ((unsigned long)data & alignmask)
136 return shash_update_unaligned(desc, data, len);
138 return shash->update(desc, data, len);
140 EXPORT_SYMBOL_GPL(crypto_shash_update);
142 static int shash_final_unaligned(struct shash_desc *desc, u8 *out)
144 struct crypto_shash *tfm = desc->tfm;
145 unsigned long alignmask = crypto_shash_alignmask(tfm);
146 struct shash_alg *shash = crypto_shash_alg(tfm);
147 unsigned int ds = crypto_shash_digestsize(tfm);
148 u8 ubuf[shash_align_buffer_size(ds, alignmask)]
150 u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
153 err = shash->final(desc, buf);
157 memcpy(out, buf, ds);
164 int crypto_shash_final(struct shash_desc *desc, u8 *out)
166 struct crypto_shash *tfm = desc->tfm;
167 struct shash_alg *shash = crypto_shash_alg(tfm);
168 unsigned long alignmask = crypto_shash_alignmask(tfm);
170 if ((unsigned long)out & alignmask)
171 return shash_final_unaligned(desc, out);
173 return shash->final(desc, out);
175 EXPORT_SYMBOL_GPL(crypto_shash_final);
177 static int shash_finup_unaligned(struct shash_desc *desc, const u8 *data,
178 unsigned int len, u8 *out)
180 return crypto_shash_update(desc, data, len) ?:
181 crypto_shash_final(desc, out);
184 int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
185 unsigned int len, u8 *out)
187 struct crypto_shash *tfm = desc->tfm;
188 struct shash_alg *shash = crypto_shash_alg(tfm);
189 unsigned long alignmask = crypto_shash_alignmask(tfm);
191 if (((unsigned long)data | (unsigned long)out) & alignmask)
192 return shash_finup_unaligned(desc, data, len, out);
194 return shash->finup(desc, data, len, out);
196 EXPORT_SYMBOL_GPL(crypto_shash_finup);
198 static int shash_digest_unaligned(struct shash_desc *desc, const u8 *data,
199 unsigned int len, u8 *out)
201 return crypto_shash_init(desc) ?:
202 crypto_shash_finup(desc, data, len, out);
205 int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
206 unsigned int len, u8 *out)
208 struct crypto_shash *tfm = desc->tfm;
209 struct shash_alg *shash = crypto_shash_alg(tfm);
210 unsigned long alignmask = crypto_shash_alignmask(tfm);
212 if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
215 if (((unsigned long)data | (unsigned long)out) & alignmask)
216 return shash_digest_unaligned(desc, data, len, out);
218 return shash->digest(desc, data, len, out);
220 EXPORT_SYMBOL_GPL(crypto_shash_digest);
222 static int shash_default_export(struct shash_desc *desc, void *out)
224 memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
228 static int shash_default_import(struct shash_desc *desc, const void *in)
230 memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(desc->tfm));
234 static int shash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
237 struct crypto_shash **ctx = crypto_ahash_ctx(tfm);
239 return crypto_shash_setkey(*ctx, key, keylen);
242 static int shash_async_init(struct ahash_request *req)
244 struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
245 struct shash_desc *desc = ahash_request_ctx(req);
248 desc->flags = req->base.flags;
250 return crypto_shash_init(desc);
253 int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
255 struct crypto_hash_walk walk;
258 for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
259 nbytes = crypto_hash_walk_done(&walk, nbytes))
260 nbytes = crypto_shash_update(desc, walk.data, nbytes);
264 EXPORT_SYMBOL_GPL(shash_ahash_update);
266 static int shash_async_update(struct ahash_request *req)
268 return shash_ahash_update(req, ahash_request_ctx(req));
271 static int shash_async_final(struct ahash_request *req)
273 return crypto_shash_final(ahash_request_ctx(req), req->result);
276 int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
278 struct crypto_hash_walk walk;
281 nbytes = crypto_hash_walk_first(req, &walk);
283 return crypto_shash_final(desc, req->result);
286 nbytes = crypto_hash_walk_last(&walk) ?
287 crypto_shash_finup(desc, walk.data, nbytes,
289 crypto_shash_update(desc, walk.data, nbytes);
290 nbytes = crypto_hash_walk_done(&walk, nbytes);
291 } while (nbytes > 0);
295 EXPORT_SYMBOL_GPL(shash_ahash_finup);
297 static int shash_async_finup(struct ahash_request *req)
299 struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
300 struct shash_desc *desc = ahash_request_ctx(req);
303 desc->flags = req->base.flags;
305 return shash_ahash_finup(req, desc);
308 int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
310 unsigned int nbytes = req->nbytes;
311 struct scatterlist *sg;
316 (sg = req->src, offset = sg->offset,
317 nbytes < min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
320 data = kmap_atomic(sg_page(sg));
321 err = crypto_shash_digest(desc, data + offset, nbytes,
324 crypto_yield(desc->flags);
326 err = crypto_shash_init(desc) ?:
327 shash_ahash_finup(req, desc);
331 EXPORT_SYMBOL_GPL(shash_ahash_digest);
333 static int shash_async_digest(struct ahash_request *req)
335 struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
336 struct shash_desc *desc = ahash_request_ctx(req);
339 desc->flags = req->base.flags;
341 return shash_ahash_digest(req, desc);
344 static int shash_async_export(struct ahash_request *req, void *out)
346 return crypto_shash_export(ahash_request_ctx(req), out);
349 static int shash_async_import(struct ahash_request *req, const void *in)
351 struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
352 struct shash_desc *desc = ahash_request_ctx(req);
355 desc->flags = req->base.flags;
357 return crypto_shash_import(desc, in);
360 static void crypto_exit_shash_ops_async(struct crypto_tfm *tfm)
362 struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
364 crypto_free_shash(*ctx);
367 int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
369 struct crypto_alg *calg = tfm->__crt_alg;
370 struct shash_alg *alg = __crypto_shash_alg(calg);
371 struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
372 struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
373 struct crypto_shash *shash;
375 if (!crypto_mod_get(calg))
378 shash = crypto_create_tfm(calg, &crypto_shash_type);
380 crypto_mod_put(calg);
381 return PTR_ERR(shash);
385 tfm->exit = crypto_exit_shash_ops_async;
387 crt->init = shash_async_init;
388 crt->update = shash_async_update;
389 crt->final = shash_async_final;
390 crt->finup = shash_async_finup;
391 crt->digest = shash_async_digest;
392 if (crypto_shash_alg_has_setkey(alg))
393 crt->setkey = shash_async_setkey;
395 crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
396 CRYPTO_TFM_NEED_KEY);
399 crt->export = shash_async_export;
401 crt->import = shash_async_import;
403 crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
408 static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
410 struct crypto_shash *hash = __crypto_shash_cast(tfm);
411 struct shash_alg *alg = crypto_shash_alg(hash);
413 hash->descsize = alg->descsize;
415 shash_set_needkey(hash, alg);
421 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
423 struct crypto_report_hash rhash;
424 struct shash_alg *salg = __crypto_shash_alg(alg);
426 strncpy(rhash.type, "shash", sizeof(rhash.type));
428 rhash.blocksize = alg->cra_blocksize;
429 rhash.digestsize = salg->digestsize;
431 if (nla_put(skb, CRYPTOCFGA_REPORT_HASH,
432 sizeof(struct crypto_report_hash), &rhash))
433 goto nla_put_failure;
440 static int crypto_shash_report(struct sk_buff *skb, struct crypto_alg *alg)
446 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
448 static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
450 struct shash_alg *salg = __crypto_shash_alg(alg);
452 seq_printf(m, "type : shash\n");
453 seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
454 seq_printf(m, "digestsize : %u\n", salg->digestsize);
457 static const struct crypto_type crypto_shash_type = {
458 .extsize = crypto_alg_extsize,
459 .init_tfm = crypto_shash_init_tfm,
460 #ifdef CONFIG_PROC_FS
461 .show = crypto_shash_show,
463 .report = crypto_shash_report,
464 .maskclear = ~CRYPTO_ALG_TYPE_MASK,
465 .maskset = CRYPTO_ALG_TYPE_MASK,
466 .type = CRYPTO_ALG_TYPE_SHASH,
467 .tfmsize = offsetof(struct crypto_shash, base),
470 struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
473 return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
475 EXPORT_SYMBOL_GPL(crypto_alloc_shash);
477 static int shash_prepare_alg(struct shash_alg *alg)
479 struct crypto_alg *base = &alg->base;
481 if (alg->digestsize > PAGE_SIZE / 8 ||
482 alg->descsize > PAGE_SIZE / 8 ||
483 alg->statesize > PAGE_SIZE / 8)
486 base->cra_type = &crypto_shash_type;
487 base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
488 base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
491 alg->finup = shash_finup_unaligned;
493 alg->digest = shash_digest_unaligned;
495 alg->export = shash_default_export;
496 alg->import = shash_default_import;
497 alg->statesize = alg->descsize;
500 alg->setkey = shash_no_setkey;
505 int crypto_register_shash(struct shash_alg *alg)
507 struct crypto_alg *base = &alg->base;
510 err = shash_prepare_alg(alg);
514 return crypto_register_alg(base);
516 EXPORT_SYMBOL_GPL(crypto_register_shash);
518 int crypto_unregister_shash(struct shash_alg *alg)
520 return crypto_unregister_alg(&alg->base);
522 EXPORT_SYMBOL_GPL(crypto_unregister_shash);
524 int crypto_register_shashes(struct shash_alg *algs, int count)
528 for (i = 0; i < count; i++) {
529 ret = crypto_register_shash(&algs[i]);
537 for (--i; i >= 0; --i)
538 crypto_unregister_shash(&algs[i]);
542 EXPORT_SYMBOL_GPL(crypto_register_shashes);
544 int crypto_unregister_shashes(struct shash_alg *algs, int count)
548 for (i = count - 1; i >= 0; --i) {
549 ret = crypto_unregister_shash(&algs[i]);
551 pr_err("Failed to unregister %s %s: %d\n",
552 algs[i].base.cra_driver_name,
553 algs[i].base.cra_name, ret);
558 EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
560 int shash_register_instance(struct crypto_template *tmpl,
561 struct shash_instance *inst)
565 err = shash_prepare_alg(&inst->alg);
569 return crypto_register_instance(tmpl, shash_crypto_instance(inst));
571 EXPORT_SYMBOL_GPL(shash_register_instance);
573 void shash_free_instance(struct crypto_instance *inst)
575 crypto_drop_spawn(crypto_instance_ctx(inst));
576 kfree(shash_instance(inst));
578 EXPORT_SYMBOL_GPL(shash_free_instance);
580 int crypto_init_shash_spawn(struct crypto_shash_spawn *spawn,
581 struct shash_alg *alg,
582 struct crypto_instance *inst)
584 return crypto_init_spawn2(&spawn->base, &alg->base, inst,
587 EXPORT_SYMBOL_GPL(crypto_init_shash_spawn);
589 struct shash_alg *shash_attr_alg(struct rtattr *rta, u32 type, u32 mask)
591 struct crypto_alg *alg;
593 alg = crypto_attr_alg2(rta, &crypto_shash_type, type, mask);
594 return IS_ERR(alg) ? ERR_CAST(alg) :
595 container_of(alg, struct shash_alg, base);
597 EXPORT_SYMBOL_GPL(shash_attr_alg);
599 MODULE_LICENSE("GPL");
600 MODULE_DESCRIPTION("Synchronous cryptographic hash type");