2019-05-27 02:55:01 -04:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-05-14 08:41:47 -04:00
|
|
|
/*
|
|
|
|
* Asynchronous Cryptographic Hash operations.
|
|
|
|
*
|
2023-10-22 04:10:55 -04:00
|
|
|
* This is the implementation of the ahash (asynchronous hash) API. It differs
|
|
|
|
* from shash (synchronous hash) in that ahash supports asynchronous operations,
|
|
|
|
* and it hashes data from scatterlists instead of virtually addressed buffers.
|
|
|
|
*
|
|
|
|
* The ahash API provides access to both ahash and shash algorithms. The shash
|
|
|
|
* API only provides access to shash algorithms.
|
2008-05-14 08:41:47 -04:00
|
|
|
*
|
|
|
|
* Copyright (c) 2008 Loc Ho <lho@amcc.com>
|
|
|
|
*/
|
|
|
|
|
2008-07-07 10:19:53 -04:00
|
|
|
#include <crypto/scatterwalk.h>
|
2023-02-16 05:35:15 -05:00
|
|
|
#include <linux/cryptouser.h>
|
2008-05-14 08:41:47 -04:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/seq_file.h>
|
2023-02-16 05:35:15 -05:00
|
|
|
#include <linux/string.h>
|
2011-09-27 01:41:07 -04:00
|
|
|
#include <net/netlink.h>
|
2008-05-14 08:41:47 -04:00
|
|
|
|
2023-02-16 05:35:15 -05:00
|
|
|
#include "hash.h"
|
2008-05-14 08:41:47 -04:00
|
|
|
|
2023-09-14 04:28:23 -04:00
|
|
|
#define CRYPTO_ALG_TYPE_AHASH_MASK 0x0000000e
|
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
static inline struct crypto_istat_hash *ahash_get_stat(struct ahash_alg *alg)
|
|
|
|
{
|
|
|
|
return hash_get_stat(&alg->halg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int crypto_ahash_errstat(struct ahash_alg *alg, int err)
|
|
|
|
{
|
|
|
|
if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (err && err != -EINPROGRESS && err != -EBUSY)
|
|
|
|
atomic64_inc(&ahash_get_stat(alg)->err_cnt);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
/*
|
|
|
|
* For an ahash tfm that is using an shash algorithm (instead of an ahash
|
|
|
|
* algorithm), this returns the underlying shash tfm.
|
|
|
|
*/
|
|
|
|
static inline struct crypto_shash *ahash_to_shash(struct crypto_ahash *tfm)
|
2023-10-22 04:10:58 -04:00
|
|
|
{
|
2023-10-22 04:11:00 -04:00
|
|
|
return *(struct crypto_shash **)crypto_ahash_ctx(tfm);
|
|
|
|
}
|
2023-10-22 04:10:58 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
static inline struct shash_desc *prepare_shash_desc(struct ahash_request *req,
|
|
|
|
struct crypto_ahash *tfm)
|
|
|
|
{
|
|
|
|
struct shash_desc *desc = ahash_request_ctx(req);
|
2023-10-22 04:10:58 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
desc->tfm = ahash_to_shash(tfm);
|
|
|
|
return desc;
|
2023-10-22 04:10:58 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
|
|
|
|
{
|
|
|
|
struct crypto_hash_walk walk;
|
|
|
|
int nbytes;
|
|
|
|
|
|
|
|
for (nbytes = crypto_hash_walk_first(req, &walk); nbytes > 0;
|
|
|
|
nbytes = crypto_hash_walk_done(&walk, nbytes))
|
|
|
|
nbytes = crypto_shash_update(desc, walk.data, nbytes);
|
|
|
|
|
|
|
|
return nbytes;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_update);
|
|
|
|
|
|
|
|
int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
|
|
|
|
{
|
|
|
|
struct crypto_hash_walk walk;
|
|
|
|
int nbytes;
|
|
|
|
|
|
|
|
nbytes = crypto_hash_walk_first(req, &walk);
|
|
|
|
if (!nbytes)
|
|
|
|
return crypto_shash_final(desc, req->result);
|
|
|
|
|
|
|
|
do {
|
|
|
|
nbytes = crypto_hash_walk_last(&walk) ?
|
|
|
|
crypto_shash_finup(desc, walk.data, nbytes,
|
|
|
|
req->result) :
|
|
|
|
crypto_shash_update(desc, walk.data, nbytes);
|
|
|
|
nbytes = crypto_hash_walk_done(&walk, nbytes);
|
|
|
|
} while (nbytes > 0);
|
|
|
|
|
|
|
|
return nbytes;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_finup);
|
|
|
|
|
|
|
|
int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
|
|
|
|
{
|
|
|
|
unsigned int nbytes = req->nbytes;
|
|
|
|
struct scatterlist *sg;
|
|
|
|
unsigned int offset;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (nbytes &&
|
|
|
|
(sg = req->src, offset = sg->offset,
|
|
|
|
nbytes <= min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
|
|
|
|
void *data;
|
|
|
|
|
|
|
|
data = kmap_local_page(sg_page(sg));
|
|
|
|
err = crypto_shash_digest(desc, data + offset, nbytes,
|
|
|
|
req->result);
|
|
|
|
kunmap_local(data);
|
|
|
|
} else
|
|
|
|
err = crypto_shash_init(desc) ?:
|
|
|
|
shash_ahash_finup(req, desc);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_digest);
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
static void crypto_exit_ahash_using_shash(struct crypto_tfm *tfm)
|
2023-10-22 04:10:58 -04:00
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
|
|
|
|
|
|
|
|
crypto_free_shash(*ctx);
|
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
static int crypto_init_ahash_using_shash(struct crypto_tfm *tfm)
|
2023-10-22 04:10:58 -04:00
|
|
|
{
|
|
|
|
struct crypto_alg *calg = tfm->__crt_alg;
|
|
|
|
struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
|
|
|
|
struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
|
|
|
|
struct crypto_shash *shash;
|
|
|
|
|
|
|
|
if (!crypto_mod_get(calg))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
|
|
|
shash = crypto_create_tfm(calg, &crypto_shash_type);
|
|
|
|
if (IS_ERR(shash)) {
|
|
|
|
crypto_mod_put(calg);
|
|
|
|
return PTR_ERR(shash);
|
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
crt->using_shash = true;
|
2023-10-22 04:10:58 -04:00
|
|
|
*ctx = shash;
|
2023-10-22 04:11:00 -04:00
|
|
|
tfm->exit = crypto_exit_ahash_using_shash;
|
2023-10-22 04:10:58 -04:00
|
|
|
|
|
|
|
crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
|
|
|
|
CRYPTO_TFM_NEED_KEY);
|
|
|
|
crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-07 10:19:53 -04:00
|
|
|
static int hash_walk_next(struct crypto_hash_walk *walk)
|
|
|
|
{
|
|
|
|
unsigned int offset = walk->offset;
|
|
|
|
unsigned int nbytes = min(walk->entrylen,
|
|
|
|
((unsigned int)(PAGE_SIZE)) - offset);
|
|
|
|
|
crypto: scatterwalk - use kmap_local() not kmap_atomic()
kmap_atomic() is used to create short-lived mappings of pages that may
not be accessible via the kernel direct map. This is only needed on
32-bit architectures that implement CONFIG_HIGHMEM, but it can be used
on 64-bit other architectures too, where the returned mapping is simply
the kernel direct address of the page.
However, kmap_atomic() does not support migration on CONFIG_HIGHMEM
configurations, due to the use of per-CPU kmap slots, and so it disables
preemption on all architectures, not just the 32-bit ones. This implies
that all scatterwalk based crypto routines essentially execute with
preemption disabled all the time, which is less than ideal.
So let's switch scatterwalk_map/_unmap and the shash/ahash routines to
kmap_local() instead, which serves a similar purpose, but without the
resulting impact on preemption on architectures that have no need for
CONFIG_HIGHMEM.
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "Elliott, Robert (Servers)" <elliott@hpe.com>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2022-12-13 11:13:10 -05:00
|
|
|
walk->data = kmap_local_page(walk->pg);
|
2008-07-07 10:19:53 -04:00
|
|
|
walk->data += offset;
|
|
|
|
walk->entrylen -= nbytes;
|
|
|
|
return nbytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int hash_walk_new_entry(struct crypto_hash_walk *walk)
|
|
|
|
{
|
|
|
|
struct scatterlist *sg;
|
|
|
|
|
|
|
|
sg = walk->sg;
|
|
|
|
walk->offset = sg->offset;
|
2016-05-04 05:52:56 -04:00
|
|
|
walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);
|
|
|
|
walk->offset = offset_in_page(walk->offset);
|
2008-07-07 10:19:53 -04:00
|
|
|
walk->entrylen = sg->length;
|
|
|
|
|
|
|
|
if (walk->entrylen > walk->total)
|
|
|
|
walk->entrylen = walk->total;
|
|
|
|
walk->total -= walk->entrylen;
|
|
|
|
|
|
|
|
return hash_walk_next(walk);
|
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_hash_walk_done(struct crypto_hash_walk *walk, int err)
|
|
|
|
{
|
|
|
|
walk->data -= walk->offset;
|
|
|
|
|
crypto: scatterwalk - use kmap_local() not kmap_atomic()
kmap_atomic() is used to create short-lived mappings of pages that may
not be accessible via the kernel direct map. This is only needed on
32-bit architectures that implement CONFIG_HIGHMEM, but it can be used
on 64-bit other architectures too, where the returned mapping is simply
the kernel direct address of the page.
However, kmap_atomic() does not support migration on CONFIG_HIGHMEM
configurations, due to the use of per-CPU kmap slots, and so it disables
preemption on all architectures, not just the 32-bit ones. This implies
that all scatterwalk based crypto routines essentially execute with
preemption disabled all the time, which is less than ideal.
So let's switch scatterwalk_map/_unmap and the shash/ahash routines to
kmap_local() instead, which serves a similar purpose, but without the
resulting impact on preemption on architectures that have no need for
CONFIG_HIGHMEM.
Cc: Eric Biggers <ebiggers@kernel.org>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: "Elliott, Robert (Servers)" <elliott@hpe.com>
Signed-off-by: Ard Biesheuvel <ardb@kernel.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2022-12-13 11:13:10 -05:00
|
|
|
kunmap_local(walk->data);
|
2020-08-10 20:40:15 -04:00
|
|
|
crypto_yield(walk->flags);
|
2008-07-07 10:19:53 -04:00
|
|
|
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2019-02-01 02:51:41 -05:00
|
|
|
if (walk->entrylen) {
|
2009-05-31 09:09:22 -04:00
|
|
|
walk->offset = 0;
|
|
|
|
walk->pg++;
|
2008-07-07 10:19:53 -04:00
|
|
|
return hash_walk_next(walk);
|
2009-05-31 09:09:22 -04:00
|
|
|
}
|
2008-07-07 10:19:53 -04:00
|
|
|
|
|
|
|
if (!walk->total)
|
|
|
|
return 0;
|
|
|
|
|
2015-01-20 03:06:16 -05:00
|
|
|
walk->sg = sg_next(walk->sg);
|
2008-07-07 10:19:53 -04:00
|
|
|
|
|
|
|
return hash_walk_new_entry(walk);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_hash_walk_done);
|
|
|
|
|
|
|
|
int crypto_hash_walk_first(struct ahash_request *req,
|
|
|
|
struct crypto_hash_walk *walk)
|
|
|
|
{
|
|
|
|
walk->total = req->nbytes;
|
|
|
|
|
2014-07-10 19:18:08 -04:00
|
|
|
if (!walk->total) {
|
|
|
|
walk->entrylen = 0;
|
2008-07-07 10:19:53 -04:00
|
|
|
return 0;
|
2014-07-10 19:18:08 -04:00
|
|
|
}
|
2008-07-07 10:19:53 -04:00
|
|
|
|
|
|
|
walk->sg = req->src;
|
2020-08-10 20:40:15 -04:00
|
|
|
walk->flags = req->base.flags;
|
2008-07-07 10:19:53 -04:00
|
|
|
|
|
|
|
return hash_walk_new_entry(walk);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_hash_walk_first);
|
|
|
|
|
2019-01-06 21:47:42 -05:00
|
|
|
static int ahash_nosetkey(struct crypto_ahash *tfm, const u8 *key,
|
|
|
|
unsigned int keylen)
|
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
static void ahash_set_needkey(struct crypto_ahash *tfm, struct ahash_alg *alg)
|
2019-01-06 21:47:42 -05:00
|
|
|
{
|
2023-10-22 04:11:00 -04:00
|
|
|
if (alg->setkey != ahash_nosetkey &&
|
|
|
|
!(alg->halg.base.cra_flags & CRYPTO_ALG_OPTIONAL_KEY))
|
2019-01-06 21:47:42 -05:00
|
|
|
crypto_ahash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
}
|
|
|
|
|
2009-07-15 00:40:40 -04:00
|
|
|
int crypto_ahash_setkey(struct crypto_ahash *tfm, const u8 *key,
|
2008-05-14 08:41:47 -04:00
|
|
|
unsigned int keylen)
|
|
|
|
{
|
2023-10-22 04:11:00 -04:00
|
|
|
if (likely(tfm->using_shash)) {
|
|
|
|
struct crypto_shash *shash = ahash_to_shash(tfm);
|
|
|
|
int err;
|
crypto: hash - prevent using keyed hashes without setting key
Currently, almost none of the keyed hash algorithms check whether a key
has been set before proceeding. Some algorithms are okay with this and
will effectively just use a key of all 0's or some other bogus default.
However, others will severely break, as demonstrated using
"hmac(sha3-512-generic)", the unkeyed use of which causes a kernel crash
via a (potentially exploitable) stack buffer overflow.
A while ago, this problem was solved for AF_ALG by pairing each hash
transform with a 'has_key' bool. However, there are still other places
in the kernel where userspace can specify an arbitrary hash algorithm by
name, and the kernel uses it as unkeyed hash without checking whether it
is really unkeyed. Examples of this include:
- KEYCTL_DH_COMPUTE, via the KDF extension
- dm-verity
- dm-crypt, via the ESSIV support
- dm-integrity, via the "internal hash" mode with no key given
- drbd (Distributed Replicated Block Device)
This bug is especially bad for KEYCTL_DH_COMPUTE as that requires no
privileges to call.
Fix the bug for all users by adding a flag CRYPTO_TFM_NEED_KEY to the
->crt_flags of each hash transform that indicates whether the transform
still needs to be keyed or not. Then, make the hash init, import, and
digest functions return -ENOKEY if the key is still needed.
The new flag also replaces the 'has_key' bool which algif_hash was
previously using, thereby simplifying the algif_hash implementation.
Reported-by: syzbot <syzkaller@googlegroups.com>
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-01-03 14:16:27 -05:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
err = crypto_shash_setkey(shash, key, keylen);
|
|
|
|
if (unlikely(err)) {
|
|
|
|
crypto_ahash_set_flags(tfm,
|
|
|
|
crypto_shash_get_flags(shash) &
|
|
|
|
CRYPTO_TFM_NEED_KEY);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct ahash_alg *alg = crypto_ahash_alg(tfm);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = alg->setkey(tfm, key, keylen);
|
|
|
|
if (unlikely(err)) {
|
|
|
|
ahash_set_needkey(tfm, alg);
|
|
|
|
return err;
|
|
|
|
}
|
2019-01-06 21:47:42 -05:00
|
|
|
}
|
crypto: hash - prevent using keyed hashes without setting key
Currently, almost none of the keyed hash algorithms check whether a key
has been set before proceeding. Some algorithms are okay with this and
will effectively just use a key of all 0's or some other bogus default.
However, others will severely break, as demonstrated using
"hmac(sha3-512-generic)", the unkeyed use of which causes a kernel crash
via a (potentially exploitable) stack buffer overflow.
A while ago, this problem was solved for AF_ALG by pairing each hash
transform with a 'has_key' bool. However, there are still other places
in the kernel where userspace can specify an arbitrary hash algorithm by
name, and the kernel uses it as unkeyed hash without checking whether it
is really unkeyed. Examples of this include:
- KEYCTL_DH_COMPUTE, via the KDF extension
- dm-verity
- dm-crypt, via the ESSIV support
- dm-integrity, via the "internal hash" mode with no key given
- drbd (Distributed Replicated Block Device)
This bug is especially bad for KEYCTL_DH_COMPUTE as that requires no
privileges to call.
Fix the bug for all users by adding a flag CRYPTO_TFM_NEED_KEY to the
->crt_flags of each hash transform that indicates whether the transform
still needs to be keyed or not. Then, make the hash init, import, and
digest functions return -ENOKEY if the key is still needed.
The new flag also replaces the 'has_key' bool which algif_hash was
previously using, thereby simplifying the algif_hash implementation.
Reported-by: syzbot <syzkaller@googlegroups.com>
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-01-03 14:16:27 -05:00
|
|
|
crypto_ahash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
return 0;
|
2008-05-14 08:41:47 -04:00
|
|
|
}
|
2009-07-15 00:40:40 -04:00
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_setkey);
|
2008-05-14 08:41:47 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
int crypto_ahash_init(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
|
|
|
|
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return crypto_shash_init(prepare_shash_desc(req, tfm));
|
|
|
|
if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
|
|
|
return -ENOKEY;
|
|
|
|
return crypto_ahash_alg(tfm)->init(req);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_init);
|
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
static int ahash_save_req(struct ahash_request *req, crypto_completion_t cplt,
|
|
|
|
bool has_state)
|
2009-07-15 00:40:40 -04:00
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
|
|
|
unsigned int ds = crypto_ahash_digestsize(tfm);
|
2023-02-10 07:20:20 -05:00
|
|
|
struct ahash_request *subreq;
|
|
|
|
unsigned int subreq_size;
|
|
|
|
unsigned int reqsize;
|
|
|
|
u8 *result;
|
|
|
|
gfp_t gfp;
|
|
|
|
u32 flags;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
subreq_size = sizeof(*subreq);
|
|
|
|
reqsize = crypto_ahash_reqsize(tfm);
|
|
|
|
reqsize = ALIGN(reqsize, crypto_tfm_ctx_alignment());
|
|
|
|
subreq_size += reqsize;
|
|
|
|
subreq_size += ds;
|
|
|
|
|
|
|
|
flags = ahash_request_flags(req);
|
|
|
|
gfp = (flags & CRYPTO_TFM_REQ_MAY_SLEEP) ? GFP_KERNEL : GFP_ATOMIC;
|
|
|
|
subreq = kmalloc(subreq_size, gfp);
|
|
|
|
if (!subreq)
|
2009-07-15 00:40:40 -04:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
ahash_request_set_tfm(subreq, tfm);
|
|
|
|
ahash_request_set_callback(subreq, flags, cplt, req);
|
|
|
|
|
|
|
|
result = (u8 *)(subreq + 1) + reqsize;
|
|
|
|
|
|
|
|
ahash_request_set_crypt(subreq, req->src, result, req->nbytes);
|
|
|
|
|
|
|
|
if (has_state) {
|
|
|
|
void *state;
|
|
|
|
|
|
|
|
state = kmalloc(crypto_ahash_statesize(tfm), gfp);
|
|
|
|
if (!state) {
|
|
|
|
kfree(subreq);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
crypto_ahash_export(req, state);
|
|
|
|
crypto_ahash_import(subreq, state);
|
|
|
|
kfree_sensitive(state);
|
|
|
|
}
|
|
|
|
|
|
|
|
req->priv = subreq;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2014-03-13 21:37:05 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-04-10 05:27:57 -04:00
|
|
|
static void ahash_restore_req(struct ahash_request *req, int err)
|
2014-03-13 21:37:05 -04:00
|
|
|
{
|
2023-02-10 07:20:20 -05:00
|
|
|
struct ahash_request *subreq = req->priv;
|
2014-03-13 21:37:05 -04:00
|
|
|
|
2017-04-10 05:27:57 -04:00
|
|
|
if (!err)
|
2023-02-10 07:20:20 -05:00
|
|
|
memcpy(req->result, subreq->result,
|
2017-04-10 05:27:57 -04:00
|
|
|
crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
|
|
|
|
|
2014-03-13 21:37:05 -04:00
|
|
|
req->priv = NULL;
|
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
kfree_sensitive(subreq);
|
2014-03-13 21:37:05 -04:00
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
int crypto_ahash_update(struct ahash_request *req)
|
2009-07-15 00:40:40 -04:00
|
|
|
{
|
2018-11-29 09:42:21 -05:00
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
2024-03-12 21:49:37 -04:00
|
|
|
struct ahash_alg *alg;
|
2018-09-19 06:10:54 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return shash_ahash_update(req, ahash_request_ctx(req));
|
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
alg = crypto_ahash_alg(tfm);
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
atomic64_add(req->nbytes, &ahash_get_stat(alg)->hash_tlen);
|
|
|
|
return crypto_ahash_errstat(alg, alg->update(req));
|
2023-10-22 04:11:00 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_update);
|
|
|
|
|
|
|
|
int crypto_ahash_final(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
2024-03-12 21:49:37 -04:00
|
|
|
struct ahash_alg *alg;
|
2023-10-22 04:11:00 -04:00
|
|
|
|
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return crypto_shash_final(ahash_request_ctx(req), req->result);
|
2023-02-16 05:35:15 -05:00
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
alg = crypto_ahash_alg(tfm);
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
atomic64_inc(&ahash_get_stat(alg)->hash_cnt);
|
|
|
|
return crypto_ahash_errstat(alg, alg->final(req));
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_final);
|
|
|
|
|
|
|
|
int crypto_ahash_finup(struct ahash_request *req)
|
|
|
|
{
|
2018-11-29 09:42:21 -05:00
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
2024-03-12 21:49:37 -04:00
|
|
|
struct ahash_alg *alg;
|
2023-10-22 04:11:00 -04:00
|
|
|
|
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return shash_ahash_finup(req, ahash_request_ctx(req));
|
2018-09-19 06:10:54 -04:00
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
alg = crypto_ahash_alg(tfm);
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
|
|
|
|
struct crypto_istat_hash *istat = ahash_get_stat(alg);
|
|
|
|
|
|
|
|
atomic64_inc(&istat->hash_cnt);
|
|
|
|
atomic64_add(req->nbytes, &istat->hash_tlen);
|
|
|
|
}
|
|
|
|
return crypto_ahash_errstat(alg, alg->finup(req));
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_finup);
|
|
|
|
|
|
|
|
int crypto_ahash_digest(struct ahash_request *req)
|
|
|
|
{
|
crypto: hash - prevent using keyed hashes without setting key
Currently, almost none of the keyed hash algorithms check whether a key
has been set before proceeding. Some algorithms are okay with this and
will effectively just use a key of all 0's or some other bogus default.
However, others will severely break, as demonstrated using
"hmac(sha3-512-generic)", the unkeyed use of which causes a kernel crash
via a (potentially exploitable) stack buffer overflow.
A while ago, this problem was solved for AF_ALG by pairing each hash
transform with a 'has_key' bool. However, there are still other places
in the kernel where userspace can specify an arbitrary hash algorithm by
name, and the kernel uses it as unkeyed hash without checking whether it
is really unkeyed. Examples of this include:
- KEYCTL_DH_COMPUTE, via the KDF extension
- dm-verity
- dm-crypt, via the ESSIV support
- dm-integrity, via the "internal hash" mode with no key given
- drbd (Distributed Replicated Block Device)
This bug is especially bad for KEYCTL_DH_COMPUTE as that requires no
privileges to call.
Fix the bug for all users by adding a flag CRYPTO_TFM_NEED_KEY to the
->crt_flags of each hash transform that indicates whether the transform
still needs to be keyed or not. Then, make the hash init, import, and
digest functions return -ENOKEY if the key is still needed.
The new flag also replaces the 'has_key' bool which algif_hash was
previously using, thereby simplifying the algif_hash implementation.
Reported-by: syzbot <syzkaller@googlegroups.com>
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-01-03 14:16:27 -05:00
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
2024-03-12 21:49:37 -04:00
|
|
|
struct ahash_alg *alg;
|
|
|
|
int err;
|
2023-02-16 05:35:15 -05:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return shash_ahash_digest(req, prepare_shash_desc(req, tfm));
|
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
alg = crypto_ahash_alg(tfm);
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
|
|
|
|
struct crypto_istat_hash *istat = ahash_get_stat(alg);
|
|
|
|
|
|
|
|
atomic64_inc(&istat->hash_cnt);
|
|
|
|
atomic64_add(req->nbytes, &istat->hash_tlen);
|
|
|
|
}
|
|
|
|
|
crypto: hash - prevent using keyed hashes without setting key
Currently, almost none of the keyed hash algorithms check whether a key
has been set before proceeding. Some algorithms are okay with this and
will effectively just use a key of all 0's or some other bogus default.
However, others will severely break, as demonstrated using
"hmac(sha3-512-generic)", the unkeyed use of which causes a kernel crash
via a (potentially exploitable) stack buffer overflow.
A while ago, this problem was solved for AF_ALG by pairing each hash
transform with a 'has_key' bool. However, there are still other places
in the kernel where userspace can specify an arbitrary hash algorithm by
name, and the kernel uses it as unkeyed hash without checking whether it
is really unkeyed. Examples of this include:
- KEYCTL_DH_COMPUTE, via the KDF extension
- dm-verity
- dm-crypt, via the ESSIV support
- dm-integrity, via the "internal hash" mode with no key given
- drbd (Distributed Replicated Block Device)
This bug is especially bad for KEYCTL_DH_COMPUTE as that requires no
privileges to call.
Fix the bug for all users by adding a flag CRYPTO_TFM_NEED_KEY to the
->crt_flags of each hash transform that indicates whether the transform
still needs to be keyed or not. Then, make the hash init, import, and
digest functions return -ENOKEY if the key is still needed.
The new flag also replaces the 'has_key' bool which algif_hash was
previously using, thereby simplifying the algif_hash implementation.
Reported-by: syzbot <syzkaller@googlegroups.com>
Cc: stable@vger.kernel.org
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2018-01-03 14:16:27 -05:00
|
|
|
if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
2024-03-12 21:49:37 -04:00
|
|
|
err = -ENOKEY;
|
|
|
|
else
|
|
|
|
err = alg->digest(req);
|
2023-02-16 05:35:15 -05:00
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
return crypto_ahash_errstat(alg, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_digest);
|
|
|
|
|
2023-02-08 00:58:44 -05:00
|
|
|
static void ahash_def_finup_done2(void *data, int err)
|
2009-07-15 00:40:40 -04:00
|
|
|
{
|
2023-02-08 00:58:44 -05:00
|
|
|
struct ahash_request *areq = data;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
|
|
|
if (err == -EINPROGRESS)
|
|
|
|
return;
|
|
|
|
|
2017-04-10 05:27:57 -04:00
|
|
|
ahash_restore_req(areq, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
ahash_request_complete(areq, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ahash_def_finup_finish1(struct ahash_request *req, int err)
|
|
|
|
{
|
2023-02-10 07:20:20 -05:00
|
|
|
struct ahash_request *subreq = req->priv;
|
|
|
|
|
2009-07-15 00:40:40 -04:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
subreq->base.complete = ahash_def_finup_done2;
|
2017-04-10 05:27:57 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
err = crypto_ahash_alg(crypto_ahash_reqtfm(req))->final(subreq);
|
2017-10-18 03:00:36 -04:00
|
|
|
if (err == -EINPROGRESS || err == -EBUSY)
|
2017-04-10 05:27:57 -04:00
|
|
|
return err;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
|
|
|
out:
|
2017-04-10 05:27:57 -04:00
|
|
|
ahash_restore_req(req, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2023-02-08 00:58:44 -05:00
|
|
|
static void ahash_def_finup_done1(void *data, int err)
|
2009-07-15 00:40:40 -04:00
|
|
|
{
|
2023-02-08 00:58:44 -05:00
|
|
|
struct ahash_request *areq = data;
|
2023-02-10 07:20:20 -05:00
|
|
|
struct ahash_request *subreq;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
if (err == -EINPROGRESS)
|
|
|
|
goto out;
|
2017-04-10 05:27:57 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
subreq = areq->priv;
|
|
|
|
subreq->base.flags &= CRYPTO_TFM_REQ_MAY_BACKLOG;
|
2017-04-10 05:27:57 -04:00
|
|
|
|
2009-07-15 00:40:40 -04:00
|
|
|
err = ahash_def_finup_finish1(areq, err);
|
2023-02-10 07:20:20 -05:00
|
|
|
if (err == -EINPROGRESS || err == -EBUSY)
|
2017-04-10 05:27:57 -04:00
|
|
|
return;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
out:
|
|
|
|
ahash_request_complete(areq, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ahash_def_finup(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
crypto: hash - Simplify the ahash_finup implementation
The ahash_def_finup() can make use of the request save/restore functions,
thus make it so. This simplifies the code a little and unifies the code
paths.
Note that the same remark about free()ing the req->priv applies here, the
req->priv can only be free()'d after the original request was restored.
Finally, squash a bug in the invocation of completion in the ASYNC path.
In both ahash_def_finup_done{1,2}, the function areq->base.complete(X, err);
was called with X=areq->base.data . This is incorrect , as X=&areq->base
is the correct value. By analysis of the data structures, we see the areq is
of type 'struct ahash_request' , areq->base is of type 'struct crypto_async_request'
and areq->base.completion is of type crypto_completion_t, which is defined in
include/linux/crypto.h as:
typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
This is one lead that the X should be &areq->base . Next up, we can inspect
other code which calls the completion callback to give us kind-of statistical
idea of how this callback is used. We can try:
$ git grep base\.complete\( drivers/crypto/
Finally, by inspecting ahash_request_set_callback() implementation defined
in include/crypto/hash.h , we observe that the .data entry of 'struct
crypto_async_request' is intended for arbitrary data, not for completion
argument.
Signed-off-by: Marek Vasut <marex@denx.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Fabio Estevam <fabio.estevam@freescale.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Shawn Guo <shawn.guo@linaro.org>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-03-13 21:37:06 -04:00
|
|
|
int err;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-02-10 07:20:20 -05:00
|
|
|
err = ahash_save_req(req, ahash_def_finup_done1, true);
|
crypto: hash - Simplify the ahash_finup implementation
The ahash_def_finup() can make use of the request save/restore functions,
thus make it so. This simplifies the code a little and unifies the code
paths.
Note that the same remark about free()ing the req->priv applies here, the
req->priv can only be free()'d after the original request was restored.
Finally, squash a bug in the invocation of completion in the ASYNC path.
In both ahash_def_finup_done{1,2}, the function areq->base.complete(X, err);
was called with X=areq->base.data . This is incorrect , as X=&areq->base
is the correct value. By analysis of the data structures, we see the areq is
of type 'struct ahash_request' , areq->base is of type 'struct crypto_async_request'
and areq->base.completion is of type crypto_completion_t, which is defined in
include/linux/crypto.h as:
typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
This is one lead that the X should be &areq->base . Next up, we can inspect
other code which calls the completion callback to give us kind-of statistical
idea of how this callback is used. We can try:
$ git grep base\.complete\( drivers/crypto/
Finally, by inspecting ahash_request_set_callback() implementation defined
in include/crypto/hash.h , we observe that the .data entry of 'struct
crypto_async_request' is intended for arbitrary data, not for completion
argument.
Signed-off-by: Marek Vasut <marex@denx.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Fabio Estevam <fabio.estevam@freescale.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Shawn Guo <shawn.guo@linaro.org>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-03-13 21:37:06 -04:00
|
|
|
if (err)
|
|
|
|
return err;
|
2009-07-15 00:40:40 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
err = crypto_ahash_alg(tfm)->update(req->priv);
|
2017-10-18 03:00:36 -04:00
|
|
|
if (err == -EINPROGRESS || err == -EBUSY)
|
2017-04-10 05:27:57 -04:00
|
|
|
return err;
|
|
|
|
|
crypto: hash - Simplify the ahash_finup implementation
The ahash_def_finup() can make use of the request save/restore functions,
thus make it so. This simplifies the code a little and unifies the code
paths.
Note that the same remark about free()ing the req->priv applies here, the
req->priv can only be free()'d after the original request was restored.
Finally, squash a bug in the invocation of completion in the ASYNC path.
In both ahash_def_finup_done{1,2}, the function areq->base.complete(X, err);
was called with X=areq->base.data . This is incorrect , as X=&areq->base
is the correct value. By analysis of the data structures, we see the areq is
of type 'struct ahash_request' , areq->base is of type 'struct crypto_async_request'
and areq->base.completion is of type crypto_completion_t, which is defined in
include/linux/crypto.h as:
typedef void (*crypto_completion_t)(struct crypto_async_request *req, int err);
This is one lead that the X should be &areq->base . Next up, we can inspect
other code which calls the completion callback to give us kind-of statistical
idea of how this callback is used. We can try:
$ git grep base\.complete\( drivers/crypto/
Finally, by inspecting ahash_request_set_callback() implementation defined
in include/crypto/hash.h , we observe that the .data entry of 'struct
crypto_async_request' is intended for arbitrary data, not for completion
argument.
Signed-off-by: Marek Vasut <marex@denx.de>
Cc: David S. Miller <davem@davemloft.net>
Cc: Fabio Estevam <fabio.estevam@freescale.com>
Cc: Herbert Xu <herbert@gondor.apana.org.au>
Cc: Shawn Guo <shawn.guo@linaro.org>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2014-03-13 21:37:06 -04:00
|
|
|
return ahash_def_finup_finish1(req, err);
|
2009-07-15 00:40:40 -04:00
|
|
|
}
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
int crypto_ahash_export(struct ahash_request *req, void *out)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
|
|
|
|
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return crypto_shash_export(ahash_request_ctx(req), out);
|
|
|
|
return crypto_ahash_alg(tfm)->export(req, out);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_export);
|
|
|
|
|
|
|
|
int crypto_ahash_import(struct ahash_request *req, const void *in)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *tfm = crypto_ahash_reqtfm(req);
|
|
|
|
|
|
|
|
if (likely(tfm->using_shash))
|
|
|
|
return crypto_shash_import(prepare_shash_desc(req, tfm), in);
|
|
|
|
if (crypto_ahash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
|
|
|
return -ENOKEY;
|
|
|
|
return crypto_ahash_alg(tfm)->import(req, in);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_ahash_import);
|
|
|
|
|
2020-08-18 04:25:34 -04:00
|
|
|
static void crypto_ahash_exit_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
|
|
|
|
struct ahash_alg *alg = crypto_ahash_alg(hash);
|
|
|
|
|
|
|
|
alg->exit_tfm(hash);
|
|
|
|
}
|
|
|
|
|
2009-07-14 00:28:26 -04:00
|
|
|
static int crypto_ahash_init_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_ahash *hash = __crypto_ahash_cast(tfm);
|
|
|
|
struct ahash_alg *alg = crypto_ahash_alg(hash);
|
|
|
|
|
2023-04-20 06:05:16 -04:00
|
|
|
crypto_ahash_set_statesize(hash, alg->halg.statesize);
|
|
|
|
|
2023-10-22 04:10:59 -04:00
|
|
|
if (tfm->__crt_alg->cra_type == &crypto_shash_type)
|
2023-10-22 04:11:00 -04:00
|
|
|
return crypto_init_ahash_using_shash(tfm);
|
|
|
|
|
|
|
|
ahash_set_needkey(hash, alg);
|
2009-07-14 00:28:26 -04:00
|
|
|
|
2020-08-18 04:25:34 -04:00
|
|
|
if (alg->exit_tfm)
|
|
|
|
tfm->exit = crypto_ahash_exit_tfm;
|
|
|
|
|
|
|
|
return alg->init_tfm ? alg->init_tfm(hash) : 0;
|
2009-07-14 00:28:26 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int crypto_ahash_extsize(struct crypto_alg *alg)
|
|
|
|
{
|
2023-10-22 04:10:59 -04:00
|
|
|
if (alg->cra_type == &crypto_shash_type)
|
2016-06-29 06:03:47 -04:00
|
|
|
return sizeof(struct crypto_shash *);
|
2009-07-14 00:28:26 -04:00
|
|
|
|
2016-06-29 06:03:47 -04:00
|
|
|
return crypto_alg_extsize(alg);
|
2009-07-14 00:28:26 -04:00
|
|
|
}
|
|
|
|
|
2020-01-02 23:04:35 -05:00
|
|
|
static void crypto_ahash_free_instance(struct crypto_instance *inst)
|
|
|
|
{
|
|
|
|
struct ahash_instance *ahash = ahash_instance(inst);
|
|
|
|
|
|
|
|
ahash->free(ahash);
|
|
|
|
}
|
|
|
|
|
2023-02-16 05:35:28 -05:00
|
|
|
static int __maybe_unused crypto_ahash_report(
|
|
|
|
struct sk_buff *skb, struct crypto_alg *alg)
|
2011-09-27 01:41:07 -04:00
|
|
|
{
|
|
|
|
struct crypto_report_hash rhash;
|
|
|
|
|
2018-11-03 17:56:03 -04:00
|
|
|
memset(&rhash, 0, sizeof(rhash));
|
|
|
|
|
|
|
|
strscpy(rhash.type, "ahash", sizeof(rhash.type));
|
2011-09-27 01:41:07 -04:00
|
|
|
|
|
|
|
rhash.blocksize = alg->cra_blocksize;
|
|
|
|
rhash.digestsize = __crypto_hash_alg_common(alg)->digestsize;
|
|
|
|
|
2018-11-03 17:56:03 -04:00
|
|
|
return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
|
2011-09-27 01:41:07 -04:00
|
|
|
}
|
|
|
|
|
2008-05-14 08:41:47 -04:00
|
|
|
static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
|
2016-12-31 10:56:23 -05:00
|
|
|
__maybe_unused;
|
2008-05-14 08:41:47 -04:00
|
|
|
static void crypto_ahash_show(struct seq_file *m, struct crypto_alg *alg)
|
|
|
|
{
|
|
|
|
seq_printf(m, "type : ahash\n");
|
|
|
|
seq_printf(m, "async : %s\n", alg->cra_flags & CRYPTO_ALG_ASYNC ?
|
|
|
|
"yes" : "no");
|
|
|
|
seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
|
2009-07-14 00:28:26 -04:00
|
|
|
seq_printf(m, "digestsize : %u\n",
|
|
|
|
__crypto_hash_alg_common(alg)->digestsize);
|
2008-05-14 08:41:47 -04:00
|
|
|
}
|
|
|
|
|
2024-03-12 21:49:37 -04:00
|
|
|
static int __maybe_unused crypto_ahash_report_stat(
|
|
|
|
struct sk_buff *skb, struct crypto_alg *alg)
|
|
|
|
{
|
|
|
|
return crypto_hash_report_stat(skb, alg, "ahash");
|
|
|
|
}
|
|
|
|
|
2020-01-02 22:59:07 -05:00
|
|
|
static const struct crypto_type crypto_ahash_type = {
|
2009-07-14 00:28:26 -04:00
|
|
|
.extsize = crypto_ahash_extsize,
|
|
|
|
.init_tfm = crypto_ahash_init_tfm,
|
2020-01-02 23:04:35 -05:00
|
|
|
.free = crypto_ahash_free_instance,
|
2008-05-14 08:41:47 -04:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
.show = crypto_ahash_show,
|
|
|
|
#endif
|
2023-05-02 04:02:33 -04:00
|
|
|
#if IS_ENABLED(CONFIG_CRYPTO_USER)
|
2011-09-27 01:41:07 -04:00
|
|
|
.report = crypto_ahash_report,
|
2024-03-12 21:49:37 -04:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
|
|
|
.report_stat = crypto_ahash_report_stat,
|
2023-02-16 05:35:15 -05:00
|
|
|
#endif
|
2009-07-14 00:28:26 -04:00
|
|
|
.maskclear = ~CRYPTO_ALG_TYPE_MASK,
|
|
|
|
.maskset = CRYPTO_ALG_TYPE_AHASH_MASK,
|
|
|
|
.type = CRYPTO_ALG_TYPE_AHASH,
|
|
|
|
.tfmsize = offsetof(struct crypto_ahash, base),
|
2008-05-14 08:41:47 -04:00
|
|
|
};
|
|
|
|
|
2020-01-02 22:58:50 -05:00
|
|
|
int crypto_grab_ahash(struct crypto_ahash_spawn *spawn,
|
|
|
|
struct crypto_instance *inst,
|
|
|
|
const char *name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
spawn->base.frontend = &crypto_ahash_type;
|
|
|
|
return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_grab_ahash);
|
|
|
|
|
2009-07-14 00:28:26 -04:00
|
|
|
struct crypto_ahash *crypto_alloc_ahash(const char *alg_name, u32 type,
|
|
|
|
u32 mask)
|
|
|
|
{
|
|
|
|
return crypto_alloc_tfm(alg_name, &crypto_ahash_type, type, mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_alloc_ahash);
|
|
|
|
|
2016-01-23 00:52:40 -05:00
|
|
|
int crypto_has_ahash(const char *alg_name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
return crypto_type_has_alg(alg_name, &crypto_ahash_type, type, mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_has_ahash);
|
|
|
|
|
2024-01-27 02:49:27 -05:00
|
|
|
static bool crypto_hash_alg_has_setkey(struct hash_alg_common *halg)
|
|
|
|
{
|
|
|
|
struct crypto_alg *alg = &halg->base;
|
|
|
|
|
|
|
|
if (alg->cra_type == &crypto_shash_type)
|
|
|
|
return crypto_shash_alg_has_setkey(__crypto_shash_alg(alg));
|
|
|
|
|
|
|
|
return __crypto_ahash_alg(alg)->setkey != ahash_nosetkey;
|
|
|
|
}
|
|
|
|
|
2023-04-13 02:24:19 -04:00
|
|
|
struct crypto_ahash *crypto_clone_ahash(struct crypto_ahash *hash)
|
|
|
|
{
|
|
|
|
struct hash_alg_common *halg = crypto_hash_alg_common(hash);
|
|
|
|
struct crypto_tfm *tfm = crypto_ahash_tfm(hash);
|
|
|
|
struct crypto_ahash *nhash;
|
|
|
|
struct ahash_alg *alg;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!crypto_hash_alg_has_setkey(halg)) {
|
|
|
|
tfm = crypto_tfm_get(tfm);
|
|
|
|
if (IS_ERR(tfm))
|
|
|
|
return ERR_CAST(tfm);
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
|
|
|
nhash = crypto_clone_tfm(&crypto_ahash_type, tfm);
|
|
|
|
|
|
|
|
if (IS_ERR(nhash))
|
|
|
|
return nhash;
|
|
|
|
|
|
|
|
nhash->reqsize = hash->reqsize;
|
2023-04-20 06:05:16 -04:00
|
|
|
nhash->statesize = hash->statesize;
|
2023-04-13 02:24:19 -04:00
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
if (likely(hash->using_shash)) {
|
|
|
|
struct crypto_shash **nctx = crypto_ahash_ctx(nhash);
|
|
|
|
struct crypto_shash *shash;
|
|
|
|
|
|
|
|
shash = crypto_clone_shash(ahash_to_shash(hash));
|
|
|
|
if (IS_ERR(shash)) {
|
|
|
|
err = PTR_ERR(shash);
|
|
|
|
goto out_free_nhash;
|
|
|
|
}
|
2023-11-06 21:37:17 -05:00
|
|
|
nhash->using_shash = true;
|
2023-10-22 04:11:00 -04:00
|
|
|
*nctx = shash;
|
|
|
|
return nhash;
|
|
|
|
}
|
2023-04-13 02:24:19 -04:00
|
|
|
|
|
|
|
err = -ENOSYS;
|
|
|
|
alg = crypto_ahash_alg(hash);
|
|
|
|
if (!alg->clone_tfm)
|
|
|
|
goto out_free_nhash;
|
|
|
|
|
|
|
|
err = alg->clone_tfm(nhash, hash);
|
|
|
|
if (err)
|
|
|
|
goto out_free_nhash;
|
|
|
|
|
|
|
|
return nhash;
|
|
|
|
|
|
|
|
out_free_nhash:
|
|
|
|
crypto_free_ahash(nhash);
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_clone_ahash);
|
|
|
|
|
2009-07-14 02:06:06 -04:00
|
|
|
static int ahash_prepare_alg(struct ahash_alg *alg)
|
|
|
|
{
|
|
|
|
struct crypto_alg *base = &alg->halg.base;
|
2023-02-16 05:35:15 -05:00
|
|
|
int err;
|
2009-07-14 02:06:06 -04:00
|
|
|
|
2023-02-16 05:35:15 -05:00
|
|
|
if (alg->halg.statesize == 0)
|
2009-07-14 02:06:06 -04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2023-02-16 05:35:15 -05:00
|
|
|
err = hash_prepare_alg(&alg->halg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2009-07-14 02:06:06 -04:00
|
|
|
base->cra_type = &crypto_ahash_type;
|
|
|
|
base->cra_flags |= CRYPTO_ALG_TYPE_AHASH;
|
|
|
|
|
2023-10-22 04:11:00 -04:00
|
|
|
if (!alg->finup)
|
|
|
|
alg->finup = ahash_def_finup;
|
|
|
|
if (!alg->setkey)
|
|
|
|
alg->setkey = ahash_nosetkey;
|
|
|
|
|
2009-07-14 02:06:06 -04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_register_ahash(struct ahash_alg *alg)
|
|
|
|
{
|
|
|
|
struct crypto_alg *base = &alg->halg.base;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = ahash_prepare_alg(alg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return crypto_register_alg(base);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_register_ahash);
|
|
|
|
|
2019-12-15 18:51:19 -05:00
|
|
|
void crypto_unregister_ahash(struct ahash_alg *alg)
|
2009-07-14 02:06:06 -04:00
|
|
|
{
|
2019-12-15 18:51:19 -05:00
|
|
|
crypto_unregister_alg(&alg->halg.base);
|
2009-07-14 02:06:06 -04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_ahash);
|
|
|
|
|
2017-08-10 08:53:52 -04:00
|
|
|
int crypto_register_ahashes(struct ahash_alg *algs, int count)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
ret = crypto_register_ahash(&algs[i]);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (--i; i >= 0; --i)
|
|
|
|
crypto_unregister_ahash(&algs[i]);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_register_ahashes);
|
|
|
|
|
|
|
|
void crypto_unregister_ahashes(struct ahash_alg *algs, int count)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = count - 1; i >= 0; --i)
|
|
|
|
crypto_unregister_ahash(&algs[i]);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_ahashes);
|
|
|
|
|
2009-07-14 02:06:06 -04:00
|
|
|
int ahash_register_instance(struct crypto_template *tmpl,
|
|
|
|
struct ahash_instance *inst)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2020-01-02 23:04:40 -05:00
|
|
|
if (WARN_ON(!inst->free))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-14 02:06:06 -04:00
|
|
|
err = ahash_prepare_alg(&inst->alg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return crypto_register_instance(tmpl, ahash_crypto_instance(inst));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(ahash_register_instance);
|
|
|
|
|
2008-05-14 08:41:47 -04:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("Asynchronous cryptographic hash type");
|