2019-05-27 09:55:01 +03:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-08-31 09:47:27 +04:00
|
|
|
/*
|
|
|
|
* Synchronous Cryptographic Hash operations.
|
|
|
|
*
|
|
|
|
* Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
|
|
|
|
*/
|
|
|
|
|
2008-08-31 12:52:18 +04:00
|
|
|
#include <crypto/scatterwalk.h>
|
2023-02-16 13:35:15 +03:00
|
|
|
#include <linux/cryptouser.h>
|
2008-08-31 09:47:27 +04:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/seq_file.h>
|
2023-02-16 13:35:15 +03:00
|
|
|
#include <linux/string.h>
|
2011-09-27 09:26:10 +04:00
|
|
|
#include <net/netlink.h>
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
#include "hash.h"
|
2008-08-31 12:52:18 +04:00
|
|
|
|
2022-11-25 07:36:39 +03:00
|
|
|
#define MAX_SHASH_ALIGNMASK 63
|
|
|
|
|
2009-02-18 11:56:59 +03:00
|
|
|
static const struct crypto_type crypto_shash_type;
|
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
static inline struct crypto_istat_hash *shash_get_stat(struct shash_alg *alg)
|
|
|
|
{
|
|
|
|
return hash_get_stat(&alg->halg);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int crypto_shash_errstat(struct shash_alg *alg, int err)
|
|
|
|
{
|
|
|
|
return crypto_hash_errstat(&alg->halg, err);
|
|
|
|
}
|
|
|
|
|
2022-11-18 22:44:21 +03:00
|
|
|
int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
|
|
|
|
unsigned int keylen)
|
2009-07-11 18:17:39 +04:00
|
|
|
{
|
|
|
|
return -ENOSYS;
|
|
|
|
}
|
2022-11-18 22:44:21 +03:00
|
|
|
EXPORT_SYMBOL_GPL(shash_no_setkey);
|
2009-07-11 18:17:39 +04:00
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
static int shash_setkey_unaligned(struct crypto_shash *tfm, const u8 *key,
|
|
|
|
unsigned int keylen)
|
|
|
|
{
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
|
|
|
unsigned long absize;
|
|
|
|
u8 *buffer, *alignbuffer;
|
|
|
|
int err;
|
|
|
|
|
2010-05-19 05:50:58 +04:00
|
|
|
absize = keylen + (alignmask & ~(crypto_tfm_ctx_alignment() - 1));
|
2017-10-03 05:25:22 +03:00
|
|
|
buffer = kmalloc(absize, GFP_ATOMIC);
|
2008-08-31 09:47:27 +04:00
|
|
|
if (!buffer)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
alignbuffer = (u8 *)ALIGN((unsigned long)buffer, alignmask + 1);
|
|
|
|
memcpy(alignbuffer, key, keylen);
|
|
|
|
err = shash->setkey(tfm, alignbuffer, keylen);
|
2020-08-07 09:18:13 +03:00
|
|
|
kfree_sensitive(buffer);
|
2008-08-31 09:47:27 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2019-01-07 05:47:42 +03:00
|
|
|
static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
|
|
|
|
{
|
2019-11-29 22:35:22 +03:00
|
|
|
if (crypto_shash_alg_needs_key(alg))
|
2019-01-07 05:47:42 +03:00
|
|
|
crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
}
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
|
|
|
|
unsigned int keylen)
|
|
|
|
{
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
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 22:16:27 +03:00
|
|
|
int err;
|
2008-08-31 09:47:27 +04:00
|
|
|
|
|
|
|
if ((unsigned long)key & alignmask)
|
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 22:16:27 +03:00
|
|
|
err = shash_setkey_unaligned(tfm, key, keylen);
|
|
|
|
else
|
|
|
|
err = shash->setkey(tfm, key, keylen);
|
|
|
|
|
2019-01-07 05:47:42 +03:00
|
|
|
if (unlikely(err)) {
|
|
|
|
shash_set_needkey(tfm, shash);
|
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 22:16:27 +03:00
|
|
|
return err;
|
2019-01-07 05:47:42 +03:00
|
|
|
}
|
2008-08-31 09:47:27 +04: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 22:16:27 +03:00
|
|
|
crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
return 0;
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_setkey);
|
|
|
|
|
|
|
|
static int shash_update_unaligned(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
|
|
|
unsigned int unaligned_len = alignmask + 1 -
|
|
|
|
((unsigned long)data & alignmask);
|
2018-08-08 00:18:42 +03:00
|
|
|
/*
|
|
|
|
* We cannot count on __aligned() working for large values:
|
|
|
|
* https://patchwork.kernel.org/patch/9507697/
|
|
|
|
*/
|
2022-11-25 07:36:39 +03:00
|
|
|
u8 ubuf[MAX_SHASH_ALIGNMASK * 2];
|
2009-07-14 17:43:56 +04:00
|
|
|
u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
|
2009-07-14 17:35:36 +04:00
|
|
|
int err;
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2018-08-08 00:18:42 +03:00
|
|
|
if (WARN_ON(buf + unaligned_len > ubuf + sizeof(ubuf)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-03-27 08:03:51 +03:00
|
|
|
if (unaligned_len > len)
|
|
|
|
unaligned_len = len;
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
memcpy(buf, data, unaligned_len);
|
2009-07-14 17:35:36 +04:00
|
|
|
err = shash->update(desc, buf, unaligned_len);
|
|
|
|
memset(buf, 0, unaligned_len);
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2009-07-14 17:35:36 +04:00
|
|
|
return err ?:
|
2008-08-31 09:47:27 +04:00
|
|
|
shash->update(desc, data + unaligned_len, len - unaligned_len);
|
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_shash_update(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
2023-02-16 13:35:15 +03:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
atomic64_add(len, &shash_get_stat(shash)->hash_tlen);
|
2008-08-31 09:47:27 +04:00
|
|
|
|
|
|
|
if ((unsigned long)data & alignmask)
|
2023-02-16 13:35:15 +03:00
|
|
|
err = shash_update_unaligned(desc, data, len);
|
|
|
|
else
|
|
|
|
err = shash->update(desc, data, len);
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_update);
|
|
|
|
|
|
|
|
static int shash_final_unaligned(struct shash_desc *desc, u8 *out)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned int ds = crypto_shash_digestsize(tfm);
|
2018-08-08 00:18:42 +03:00
|
|
|
/*
|
|
|
|
* We cannot count on __aligned() working for large values:
|
|
|
|
* https://patchwork.kernel.org/patch/9507697/
|
|
|
|
*/
|
2022-11-25 07:36:39 +03:00
|
|
|
u8 ubuf[MAX_SHASH_ALIGNMASK + HASH_MAX_DIGESTSIZE];
|
2009-07-14 17:43:56 +04:00
|
|
|
u8 *buf = PTR_ALIGN(&ubuf[0], alignmask + 1);
|
2008-08-31 09:47:27 +04:00
|
|
|
int err;
|
|
|
|
|
2018-08-08 00:18:42 +03:00
|
|
|
if (WARN_ON(buf + ds > ubuf + sizeof(ubuf)))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
err = shash->final(desc, buf);
|
2009-07-14 17:35:36 +04:00
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
memcpy(out, buf, ds);
|
2009-07-14 17:35:36 +04:00
|
|
|
|
|
|
|
out:
|
|
|
|
memset(buf, 0, ds);
|
2008-08-31 09:47:27 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_shash_final(struct shash_desc *desc, u8 *out)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
2023-02-16 13:35:15 +03:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
atomic64_inc(&shash_get_stat(shash)->hash_cnt);
|
2008-08-31 09:47:27 +04:00
|
|
|
|
|
|
|
if ((unsigned long)out & alignmask)
|
2023-02-16 13:35:15 +03:00
|
|
|
err = shash_final_unaligned(desc, out);
|
|
|
|
else
|
|
|
|
err = shash->final(desc, out);
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_final);
|
|
|
|
|
|
|
|
static int shash_finup_unaligned(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
{
|
2023-02-16 13:35:15 +03:00
|
|
|
return shash_update_unaligned(desc, data, len) ?:
|
|
|
|
shash_final_unaligned(desc, out);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_shash_finup(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
2023-02-16 13:35:15 +03:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
|
|
|
|
struct crypto_istat_hash *istat = shash_get_stat(shash);
|
|
|
|
|
|
|
|
atomic64_inc(&istat->hash_cnt);
|
|
|
|
atomic64_add(len, &istat->hash_tlen);
|
|
|
|
}
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2009-07-09 16:36:44 +04:00
|
|
|
if (((unsigned long)data | (unsigned long)out) & alignmask)
|
2023-02-16 13:35:15 +03:00
|
|
|
err = shash_finup_unaligned(desc, data, len, out);
|
|
|
|
else
|
|
|
|
err = shash->finup(desc, data, len, out);
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_finup);
|
|
|
|
|
|
|
|
static int shash_digest_unaligned(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
{
|
|
|
|
return crypto_shash_init(desc) ?:
|
2023-02-16 13:35:15 +03:00
|
|
|
shash_update_unaligned(desc, data, len) ?:
|
|
|
|
shash_final_unaligned(desc, out);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_shash_digest(struct shash_desc *desc, const u8 *data,
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
{
|
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
unsigned long alignmask = crypto_shash_alignmask(tfm);
|
2023-02-16 13:35:15 +03:00
|
|
|
int err;
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS)) {
|
|
|
|
struct crypto_istat_hash *istat = shash_get_stat(shash);
|
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 22:16:27 +03:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
atomic64_inc(&istat->hash_cnt);
|
|
|
|
atomic64_add(len, &istat->hash_tlen);
|
|
|
|
}
|
2008-08-31 09:47:27 +04:00
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
|
|
|
err = -ENOKEY;
|
|
|
|
else if (((unsigned long)data | (unsigned long)out) & alignmask)
|
|
|
|
err = shash_digest_unaligned(desc, data, len, out);
|
|
|
|
else
|
|
|
|
err = shash->digest(desc, data, len, out);
|
|
|
|
|
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_digest);
|
|
|
|
|
2020-05-02 08:31:03 +03:00
|
|
|
int crypto_shash_tfm_digest(struct crypto_shash *tfm, const u8 *data,
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
{
|
|
|
|
SHASH_DESC_ON_STACK(desc, tfm);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
desc->tfm = tfm;
|
|
|
|
|
|
|
|
err = crypto_shash_digest(desc, data, len, out);
|
|
|
|
|
|
|
|
shash_desc_zero(desc);
|
|
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_tfm_digest);
|
|
|
|
|
2009-07-22 08:37:06 +04:00
|
|
|
static int shash_default_export(struct shash_desc *desc, void *out)
|
2008-11-02 16:38:11 +03:00
|
|
|
{
|
2009-07-22 08:37:06 +04:00
|
|
|
memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(desc->tfm));
|
|
|
|
return 0;
|
2009-07-09 16:30:57 +04:00
|
|
|
}
|
2008-11-02 16:38:11 +03:00
|
|
|
|
2009-07-22 08:37:06 +04:00
|
|
|
static int shash_default_import(struct shash_desc *desc, const void *in)
|
2009-07-09 16:30:57 +04:00
|
|
|
{
|
2009-07-22 08:37:06 +04:00
|
|
|
memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(desc->tfm));
|
|
|
|
return 0;
|
2008-11-02 16:38:11 +03:00
|
|
|
}
|
|
|
|
|
2008-08-31 12:52:18 +04:00
|
|
|
static int shash_async_setkey(struct crypto_ahash *tfm, const u8 *key,
|
|
|
|
unsigned int keylen)
|
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_ahash_ctx(tfm);
|
|
|
|
|
|
|
|
return crypto_shash_setkey(*ctx, key, keylen);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int shash_async_init(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
|
|
|
|
struct shash_desc *desc = ahash_request_ctx(req);
|
|
|
|
|
|
|
|
desc->tfm = *ctx;
|
|
|
|
|
|
|
|
return crypto_shash_init(desc);
|
|
|
|
}
|
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
int shash_ahash_update(struct ahash_request *req, struct shash_desc *desc)
|
2008-08-31 12:52:18 +04:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
2009-07-12 17:25:20 +04:00
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_update);
|
|
|
|
|
|
|
|
static int shash_async_update(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
return shash_ahash_update(req, ahash_request_ctx(req));
|
|
|
|
}
|
2008-08-31 12:52:18 +04:00
|
|
|
|
|
|
|
static int shash_async_final(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
return crypto_shash_final(ahash_request_ctx(req), req->result);
|
|
|
|
}
|
|
|
|
|
2009-07-15 08:40:40 +04:00
|
|
|
int shash_ahash_finup(struct ahash_request *req, struct shash_desc *desc)
|
|
|
|
{
|
|
|
|
struct crypto_hash_walk walk;
|
|
|
|
int nbytes;
|
|
|
|
|
2009-07-15 17:26:41 +04:00
|
|
|
nbytes = crypto_hash_walk_first(req, &walk);
|
|
|
|
if (!nbytes)
|
|
|
|
return crypto_shash_final(desc, req->result);
|
|
|
|
|
|
|
|
do {
|
2009-07-15 08:40:40 +04:00
|
|
|
nbytes = crypto_hash_walk_last(&walk) ?
|
|
|
|
crypto_shash_finup(desc, walk.data, nbytes,
|
|
|
|
req->result) :
|
|
|
|
crypto_shash_update(desc, walk.data, nbytes);
|
2009-07-15 17:26:41 +04:00
|
|
|
nbytes = crypto_hash_walk_done(&walk, nbytes);
|
|
|
|
} while (nbytes > 0);
|
2009-07-15 08:40:40 +04:00
|
|
|
|
|
|
|
return nbytes;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_finup);
|
|
|
|
|
|
|
|
static int shash_async_finup(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
|
|
|
|
struct shash_desc *desc = ahash_request_ctx(req);
|
|
|
|
|
|
|
|
desc->tfm = *ctx;
|
|
|
|
|
|
|
|
return shash_ahash_finup(req, desc);
|
|
|
|
}
|
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
int shash_ahash_digest(struct ahash_request *req, struct shash_desc *desc)
|
2008-08-31 12:52:18 +04:00
|
|
|
{
|
|
|
|
unsigned int nbytes = req->nbytes;
|
2017-10-09 18:30:02 +03:00
|
|
|
struct scatterlist *sg;
|
|
|
|
unsigned int offset;
|
2008-08-31 12:52:18 +04:00
|
|
|
int err;
|
|
|
|
|
2017-10-09 18:30:02 +03:00
|
|
|
if (nbytes &&
|
|
|
|
(sg = req->src, offset = sg->offset,
|
2019-04-15 02:23:33 +03:00
|
|
|
nbytes <= min(sg->length, ((unsigned int)(PAGE_SIZE)) - offset))) {
|
2008-08-31 12:52:18 +04:00
|
|
|
void *data;
|
|
|
|
|
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 19:13:10 +03:00
|
|
|
data = kmap_local_page(sg_page(sg));
|
2008-08-31 12:52:18 +04:00
|
|
|
err = crypto_shash_digest(desc, data + offset, nbytes,
|
|
|
|
req->result);
|
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 19:13:10 +03:00
|
|
|
kunmap_local(data);
|
2009-07-12 17:25:20 +04:00
|
|
|
} else
|
|
|
|
err = crypto_shash_init(desc) ?:
|
2009-07-15 08:40:40 +04:00
|
|
|
shash_ahash_finup(req, desc);
|
2008-08-31 12:52:18 +04:00
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_ahash_digest);
|
2008-08-31 12:52:18 +04:00
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
static int shash_async_digest(struct ahash_request *req)
|
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
|
|
|
|
struct shash_desc *desc = ahash_request_ctx(req);
|
2008-08-31 12:52:18 +04:00
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
desc->tfm = *ctx;
|
2008-08-31 12:52:18 +04:00
|
|
|
|
2009-07-12 17:25:20 +04:00
|
|
|
return shash_ahash_digest(req, desc);
|
2008-08-31 12:52:18 +04:00
|
|
|
}
|
|
|
|
|
2009-07-15 08:40:40 +04:00
|
|
|
static int shash_async_export(struct ahash_request *req, void *out)
|
|
|
|
{
|
|
|
|
return crypto_shash_export(ahash_request_ctx(req), out);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int shash_async_import(struct ahash_request *req, const void *in)
|
|
|
|
{
|
2010-11-04 21:00:22 +03:00
|
|
|
struct crypto_shash **ctx = crypto_ahash_ctx(crypto_ahash_reqtfm(req));
|
|
|
|
struct shash_desc *desc = ahash_request_ctx(req);
|
|
|
|
|
|
|
|
desc->tfm = *ctx;
|
|
|
|
|
|
|
|
return crypto_shash_import(desc, in);
|
2009-07-15 08:40:40 +04:00
|
|
|
}
|
|
|
|
|
2008-08-31 12:52:18 +04:00
|
|
|
static void crypto_exit_shash_ops_async(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
|
|
|
|
|
|
|
|
crypto_free_shash(*ctx);
|
|
|
|
}
|
|
|
|
|
2009-07-14 08:28:26 +04:00
|
|
|
int crypto_init_shash_ops_async(struct crypto_tfm *tfm)
|
2008-08-31 12:52:18 +04:00
|
|
|
{
|
|
|
|
struct crypto_alg *calg = tfm->__crt_alg;
|
2009-07-15 08:40:40 +04:00
|
|
|
struct shash_alg *alg = __crypto_shash_alg(calg);
|
2009-07-14 08:28:26 +04:00
|
|
|
struct crypto_ahash *crt = __crypto_ahash_cast(tfm);
|
2008-08-31 12:52:18 +04:00
|
|
|
struct crypto_shash **ctx = crypto_tfm_ctx(tfm);
|
|
|
|
struct crypto_shash *shash;
|
|
|
|
|
|
|
|
if (!crypto_mod_get(calg))
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2009-02-18 11:56:59 +03:00
|
|
|
shash = crypto_create_tfm(calg, &crypto_shash_type);
|
2008-08-31 12:52:18 +04:00
|
|
|
if (IS_ERR(shash)) {
|
|
|
|
crypto_mod_put(calg);
|
|
|
|
return PTR_ERR(shash);
|
|
|
|
}
|
|
|
|
|
|
|
|
*ctx = shash;
|
|
|
|
tfm->exit = crypto_exit_shash_ops_async;
|
|
|
|
|
|
|
|
crt->init = shash_async_init;
|
|
|
|
crt->update = shash_async_update;
|
2009-07-15 08:40:40 +04:00
|
|
|
crt->final = shash_async_final;
|
|
|
|
crt->finup = shash_async_finup;
|
2008-08-31 12:52:18 +04:00
|
|
|
crt->digest = shash_async_digest;
|
2019-01-07 05:47:42 +03:00
|
|
|
if (crypto_shash_alg_has_setkey(alg))
|
|
|
|
crt->setkey = shash_async_setkey;
|
2016-01-26 19:16:37 +03: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 22:16:27 +03:00
|
|
|
crypto_ahash_set_flags(crt, crypto_shash_get_flags(shash) &
|
|
|
|
CRYPTO_TFM_NEED_KEY);
|
2009-07-15 08:40:40 +04:00
|
|
|
|
2019-01-07 06:08:01 +03:00
|
|
|
crt->export = shash_async_export;
|
|
|
|
crt->import = shash_async_import;
|
2008-08-31 12:52:18 +04:00
|
|
|
|
|
|
|
crt->reqsize = sizeof(struct shash_desc) + crypto_shash_descsize(shash);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-12-08 08:42:51 +03:00
|
|
|
static void crypto_shash_exit_tfm(struct crypto_tfm *tfm)
|
|
|
|
{
|
|
|
|
struct crypto_shash *hash = __crypto_shash_cast(tfm);
|
|
|
|
struct shash_alg *alg = crypto_shash_alg(hash);
|
|
|
|
|
|
|
|
alg->exit_tfm(hash);
|
|
|
|
}
|
|
|
|
|
2009-07-13 16:46:25 +04:00
|
|
|
static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
|
2008-08-31 09:47:27 +04:00
|
|
|
{
|
2009-07-14 08:50:12 +04:00
|
|
|
struct crypto_shash *hash = __crypto_shash_cast(tfm);
|
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 22:16:27 +03:00
|
|
|
struct shash_alg *alg = crypto_shash_alg(hash);
|
2019-12-08 08:42:51 +03:00
|
|
|
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 22:16:27 +03:00
|
|
|
|
|
|
|
hash->descsize = alg->descsize;
|
|
|
|
|
2019-01-07 05:47:42 +03:00
|
|
|
shash_set_needkey(hash, alg);
|
2009-07-14 08:50:12 +04:00
|
|
|
|
2019-12-08 08:42:51 +03:00
|
|
|
if (alg->exit_tfm)
|
|
|
|
tfm->exit = crypto_shash_exit_tfm;
|
|
|
|
|
|
|
|
if (!alg->init_tfm)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err = alg->init_tfm(hash);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
/* ->init_tfm() may have increased the descsize. */
|
|
|
|
if (WARN_ON_ONCE(hash->descsize > HASH_MAX_DESCSIZE)) {
|
|
|
|
if (alg->exit_tfm)
|
|
|
|
alg->exit_tfm(hash);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2020-01-03 07:04:35 +03:00
|
|
|
static void crypto_shash_free_instance(struct crypto_instance *inst)
|
|
|
|
{
|
|
|
|
struct shash_instance *shash = shash_instance(inst);
|
|
|
|
|
|
|
|
shash->free(shash);
|
|
|
|
}
|
|
|
|
|
2023-02-16 13:35:28 +03:00
|
|
|
static int __maybe_unused crypto_shash_report(
|
|
|
|
struct sk_buff *skb, struct crypto_alg *alg)
|
2011-09-27 09:26:10 +04:00
|
|
|
{
|
|
|
|
struct crypto_report_hash rhash;
|
|
|
|
struct shash_alg *salg = __crypto_shash_alg(alg);
|
|
|
|
|
2018-11-04 00:56:03 +03:00
|
|
|
memset(&rhash, 0, sizeof(rhash));
|
|
|
|
|
|
|
|
strscpy(rhash.type, "shash", sizeof(rhash.type));
|
2013-02-05 21:19:13 +04:00
|
|
|
|
2011-09-27 09:26:10 +04:00
|
|
|
rhash.blocksize = alg->cra_blocksize;
|
|
|
|
rhash.digestsize = salg->digestsize;
|
|
|
|
|
2018-11-04 00:56:03 +03:00
|
|
|
return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
|
2011-09-27 09:26:10 +04:00
|
|
|
}
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
|
2016-12-31 18:56:23 +03:00
|
|
|
__maybe_unused;
|
2008-08-31 09:47:27 +04:00
|
|
|
static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
|
|
|
|
{
|
|
|
|
struct shash_alg *salg = __crypto_shash_alg(alg);
|
|
|
|
|
|
|
|
seq_printf(m, "type : shash\n");
|
|
|
|
seq_printf(m, "blocksize : %u\n", alg->cra_blocksize);
|
|
|
|
seq_printf(m, "digestsize : %u\n", salg->digestsize);
|
|
|
|
}
|
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
static int __maybe_unused crypto_shash_report_stat(
|
|
|
|
struct sk_buff *skb, struct crypto_alg *alg)
|
|
|
|
{
|
|
|
|
return crypto_hash_report_stat(skb, alg, "shash");
|
|
|
|
}
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
static const struct crypto_type crypto_shash_type = {
|
2015-04-20 08:39:01 +03:00
|
|
|
.extsize = crypto_alg_extsize,
|
2008-08-31 09:47:27 +04:00
|
|
|
.init_tfm = crypto_shash_init_tfm,
|
2020-01-03 07:04:35 +03:00
|
|
|
.free = crypto_shash_free_instance,
|
2008-08-31 09:47:27 +04:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
.show = crypto_shash_show,
|
|
|
|
#endif
|
2023-02-16 13:35:28 +03:00
|
|
|
#ifdef CONFIG_CRYPTO_USER
|
2011-09-27 09:26:10 +04:00
|
|
|
.report = crypto_shash_report,
|
2023-02-16 13:35:28 +03:00
|
|
|
#endif
|
2023-02-16 13:35:15 +03:00
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
|
|
|
.report_stat = crypto_shash_report_stat,
|
|
|
|
#endif
|
2008-08-31 09:47:27 +04:00
|
|
|
.maskclear = ~CRYPTO_ALG_TYPE_MASK,
|
|
|
|
.maskset = CRYPTO_ALG_TYPE_MASK,
|
|
|
|
.type = CRYPTO_ALG_TYPE_SHASH,
|
|
|
|
.tfmsize = offsetof(struct crypto_shash, base),
|
|
|
|
};
|
|
|
|
|
2020-01-03 06:58:49 +03:00
|
|
|
int crypto_grab_shash(struct crypto_shash_spawn *spawn,
|
|
|
|
struct crypto_instance *inst,
|
|
|
|
const char *name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
spawn->base.frontend = &crypto_shash_type;
|
|
|
|
return crypto_grab_spawn(&spawn->base, inst, name, type, mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_grab_shash);
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
|
|
|
|
u32 mask)
|
|
|
|
{
|
2009-02-18 11:56:59 +03:00
|
|
|
return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_alloc_shash);
|
|
|
|
|
2022-06-27 12:51:57 +03:00
|
|
|
int crypto_has_shash(const char *alg_name, u32 type, u32 mask)
|
|
|
|
{
|
|
|
|
return crypto_type_has_alg(alg_name, &crypto_shash_type, type, mask);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_has_shash);
|
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
int hash_prepare_alg(struct hash_alg_common *alg)
|
2008-08-31 09:47:27 +04:00
|
|
|
{
|
2023-02-16 13:35:15 +03:00
|
|
|
struct crypto_istat_hash *istat = hash_get_stat(alg);
|
2008-08-31 09:47:27 +04:00
|
|
|
struct crypto_alg *base = &alg->base;
|
|
|
|
|
2023-03-28 06:57:09 +03:00
|
|
|
if (alg->digestsize > HASH_MAX_DIGESTSIZE)
|
2008-08-31 09:47:27 +04:00
|
|
|
return -EINVAL;
|
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
base->cra_flags &= ~CRYPTO_ALG_TYPE_MASK;
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
memset(istat, 0, sizeof(*istat));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int shash_prepare_alg(struct shash_alg *alg)
|
|
|
|
{
|
|
|
|
struct crypto_alg *base = &alg->halg.base;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (alg->descsize > HASH_MAX_DESCSIZE)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2022-11-25 07:36:39 +03:00
|
|
|
if (base->cra_alignmask > MAX_SHASH_ALIGNMASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2019-01-07 06:07:20 +03:00
|
|
|
if ((alg->export && !alg->import) || (alg->import && !alg->export))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2023-02-16 13:35:15 +03:00
|
|
|
err = hash_prepare_alg(&alg->halg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
base->cra_type = &crypto_shash_type;
|
|
|
|
base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
|
2009-07-09 16:30:57 +04:00
|
|
|
|
2009-07-09 16:36:44 +04:00
|
|
|
if (!alg->finup)
|
|
|
|
alg->finup = shash_finup_unaligned;
|
|
|
|
if (!alg->digest)
|
|
|
|
alg->digest = shash_digest_unaligned;
|
2009-07-22 08:37:06 +04:00
|
|
|
if (!alg->export) {
|
|
|
|
alg->export = shash_default_export;
|
|
|
|
alg->import = shash_default_import;
|
2023-02-16 13:35:15 +03:00
|
|
|
alg->halg.statesize = alg->descsize;
|
2009-07-22 08:37:06 +04:00
|
|
|
}
|
2009-07-11 18:17:39 +04:00
|
|
|
if (!alg->setkey)
|
|
|
|
alg->setkey = shash_no_setkey;
|
2009-07-09 16:30:57 +04:00
|
|
|
|
2009-07-08 14:46:23 +04:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int crypto_register_shash(struct shash_alg *alg)
|
|
|
|
{
|
|
|
|
struct crypto_alg *base = &alg->base;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = shash_prepare_alg(alg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2008-08-31 09:47:27 +04:00
|
|
|
|
|
|
|
return crypto_register_alg(base);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_register_shash);
|
|
|
|
|
2019-12-16 02:51:19 +03:00
|
|
|
void crypto_unregister_shash(struct shash_alg *alg)
|
2008-08-31 09:47:27 +04:00
|
|
|
{
|
2019-12-16 02:51:19 +03:00
|
|
|
crypto_unregister_alg(&alg->base);
|
2008-08-31 09:47:27 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_shash);
|
|
|
|
|
2012-07-11 15:20:20 +04:00
|
|
|
int crypto_register_shashes(struct shash_alg *algs, int count)
|
|
|
|
{
|
|
|
|
int i, ret;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
ret = crypto_register_shash(&algs[i]);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
for (--i; i >= 0; --i)
|
|
|
|
crypto_unregister_shash(&algs[i]);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_register_shashes);
|
|
|
|
|
2019-12-16 02:51:19 +03:00
|
|
|
void crypto_unregister_shashes(struct shash_alg *algs, int count)
|
2012-07-11 15:20:20 +04:00
|
|
|
{
|
2019-12-16 02:51:19 +03:00
|
|
|
int i;
|
2012-07-11 15:20:20 +04:00
|
|
|
|
2019-12-16 02:51:19 +03:00
|
|
|
for (i = count - 1; i >= 0; --i)
|
|
|
|
crypto_unregister_shash(&algs[i]);
|
2012-07-11 15:20:20 +04:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
|
|
|
|
|
2009-07-08 14:46:23 +04:00
|
|
|
int shash_register_instance(struct crypto_template *tmpl,
|
|
|
|
struct shash_instance *inst)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2020-01-03 07:04:40 +03:00
|
|
|
if (WARN_ON(!inst->free))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-08 14:46:23 +04:00
|
|
|
err = shash_prepare_alg(&inst->alg);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return crypto_register_instance(tmpl, shash_crypto_instance(inst));
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(shash_register_instance);
|
|
|
|
|
2020-01-03 07:04:38 +03:00
|
|
|
void shash_free_singlespawn_instance(struct shash_instance *inst)
|
2009-07-07 11:17:12 +04:00
|
|
|
{
|
2020-01-03 07:04:38 +03:00
|
|
|
crypto_drop_spawn(shash_instance_ctx(inst));
|
|
|
|
kfree(inst);
|
2009-07-07 11:17:12 +04:00
|
|
|
}
|
2020-01-03 07:04:38 +03:00
|
|
|
EXPORT_SYMBOL_GPL(shash_free_singlespawn_instance);
|
2009-07-07 11:17:12 +04:00
|
|
|
|
2008-08-31 09:47:27 +04:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
MODULE_DESCRIPTION("Synchronous cryptographic hash type");
|