2019-05-27 06:55:01 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2008-08-31 05:47:27 +00:00
|
|
|
/*
|
|
|
|
|
* Synchronous Cryptographic Hash operations.
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) 2008 Herbert Xu <herbert@gondor.apana.org.au>
|
|
|
|
|
*/
|
|
|
|
|
|
2008-08-31 08:52:18 +00:00
|
|
|
#include <crypto/scatterwalk.h>
|
2023-02-16 10:35:15 +00:00
|
|
|
#include <linux/cryptouser.h>
|
2008-08-31 05:47:27 +00:00
|
|
|
#include <linux/err.h>
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
|
#include <linux/seq_file.h>
|
2023-02-16 10:35:15 +00:00
|
|
|
#include <linux/string.h>
|
2011-09-27 05:26:10 +00:00
|
|
|
#include <net/netlink.h>
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
#include "hash.h"
|
2008-08-31 08:52:18 +00:00
|
|
|
|
2023-02-16 10:35:15 +00: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)
|
|
|
|
|
{
|
2023-10-22 08:11:00 +00:00
|
|
|
if (!IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
|
return err;
|
|
|
|
|
|
|
|
|
|
if (err && err != -EINPROGRESS && err != -EBUSY)
|
|
|
|
|
atomic64_inc(&shash_get_stat(alg)->err_cnt);
|
|
|
|
|
|
|
|
|
|
return err;
|
2023-02-16 10:35:15 +00:00
|
|
|
}
|
|
|
|
|
|
2022-11-18 19:44:21 +00:00
|
|
|
int shash_no_setkey(struct crypto_shash *tfm, const u8 *key,
|
|
|
|
|
unsigned int keylen)
|
2009-07-11 14:17:39 +00:00
|
|
|
{
|
|
|
|
|
return -ENOSYS;
|
|
|
|
|
}
|
2022-11-18 19:44:21 +00:00
|
|
|
EXPORT_SYMBOL_GPL(shash_no_setkey);
|
2009-07-11 14:17:39 +00:00
|
|
|
|
2019-01-07 02:47:42 +00:00
|
|
|
static void shash_set_needkey(struct crypto_shash *tfm, struct shash_alg *alg)
|
|
|
|
|
{
|
2019-11-29 19:35:22 +00:00
|
|
|
if (crypto_shash_alg_needs_key(alg))
|
2019-01-07 02:47:42 +00:00
|
|
|
crypto_shash_set_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-31 05:47:27 +00:00
|
|
|
int crypto_shash_setkey(struct crypto_shash *tfm, const u8 *key,
|
|
|
|
|
unsigned int keylen)
|
|
|
|
|
{
|
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(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 19:16:27 +00:00
|
|
|
int err;
|
2008-08-31 05:47:27 +00:00
|
|
|
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
err = shash->setkey(tfm, key, keylen);
|
2019-01-07 02:47:42 +00: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 19:16:27 +00:00
|
|
|
return err;
|
2019-01-07 02:47:42 +00:00
|
|
|
}
|
2008-08-31 05:47:27 +00: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 19:16:27 +00:00
|
|
|
crypto_shash_clear_flags(tfm, CRYPTO_TFM_NEED_KEY);
|
|
|
|
|
return 0;
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_setkey);
|
|
|
|
|
|
|
|
|
|
int crypto_shash_update(struct shash_desc *desc, const u8 *data,
|
|
|
|
|
unsigned int len)
|
|
|
|
|
{
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
struct shash_alg *shash = crypto_shash_alg(desc->tfm);
|
2023-02-16 10:35:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
|
atomic64_add(len, &shash_get_stat(shash)->hash_tlen);
|
2008-08-31 05:47:27 +00:00
|
|
|
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
err = shash->update(desc, data, len);
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_update);
|
|
|
|
|
|
|
|
|
|
int crypto_shash_final(struct shash_desc *desc, u8 *out)
|
|
|
|
|
{
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
struct shash_alg *shash = crypto_shash_alg(desc->tfm);
|
2023-02-16 10:35:15 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_CRYPTO_STATS))
|
|
|
|
|
atomic64_inc(&shash_get_stat(shash)->hash_cnt);
|
2008-08-31 05:47:27 +00:00
|
|
|
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
err = shash->final(desc, out);
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_final);
|
|
|
|
|
|
crypto: shash - optimize the default digest and finup
For an shash algorithm that doesn't implement ->digest, currently
crypto_shash_digest() with aligned input makes 5 indirect calls: 1 to
shash_digest_unaligned(), 1 to ->init, 2 to ->update ('alignmask + 1'
bytes, then the rest), then 1 to ->final. This is true even if the
algorithm implements ->finup. This is caused by an unnecessary fallback
to code meant to handle unaligned inputs. In fact,
crypto_shash_digest() already does the needed alignment check earlier.
Therefore, optimize the number of indirect calls for aligned inputs to 3
when the algorithm implements ->finup. It remains at 5 when the
algorithm implements neither ->finup nor ->digest.
Similarly, for an shash algorithm that doesn't implement ->finup,
currently crypto_shash_finup() with aligned input makes 4 indirect
calls: 1 to shash_finup_unaligned(), 2 to ->update, and
1 to ->final. Optimize this to 3 calls.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-09 07:32:13 +00:00
|
|
|
static int shash_default_finup(struct shash_desc *desc, const u8 *data,
|
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
|
{
|
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(desc->tfm);
|
|
|
|
|
|
|
|
|
|
return shash->update(desc, data, len) ?:
|
|
|
|
|
shash->final(desc, out);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-31 05:47:27 +00: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);
|
2023-02-16 10:35:15 +00: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 05:47:27 +00:00
|
|
|
|
crypto: shash - remove support for nonzero alignmask
Currently, the shash API checks the alignment of all message, key, and
digest buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. In the case of the message buffer,
cryptographic hash functions internally operate on fixed-size blocks, so
implementations end up needing to deal with byte-aligned data anyway
because the length(s) passed to ->update might not be divisible by the
block size. Word-alignment of the message can theoretically be helpful
for CRCs, like what was being done in crc32c-sparc64. But in practice
it's better for the algorithms to use unaligned accesses or align the
message themselves. A similar argument applies to the key and digest.
In any case, no shash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from shash. The benefit is
that all the code to handle "misaligned" buffers in the shash API goes
away, reducing the overhead of the shash API.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-19 05:53:37 +00:00
|
|
|
err = shash->finup(desc, data, len, out);
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_finup);
|
|
|
|
|
|
crypto: shash - optimize the default digest and finup
For an shash algorithm that doesn't implement ->digest, currently
crypto_shash_digest() with aligned input makes 5 indirect calls: 1 to
shash_digest_unaligned(), 1 to ->init, 2 to ->update ('alignmask + 1'
bytes, then the rest), then 1 to ->final. This is true even if the
algorithm implements ->finup. This is caused by an unnecessary fallback
to code meant to handle unaligned inputs. In fact,
crypto_shash_digest() already does the needed alignment check earlier.
Therefore, optimize the number of indirect calls for aligned inputs to 3
when the algorithm implements ->finup. It remains at 5 when the
algorithm implements neither ->finup nor ->digest.
Similarly, for an shash algorithm that doesn't implement ->finup,
currently crypto_shash_finup() with aligned input makes 4 indirect
calls: 1 to shash_finup_unaligned(), 2 to ->update, and
1 to ->final. Optimize this to 3 calls.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-09 07:32:13 +00:00
|
|
|
static int shash_default_digest(struct shash_desc *desc, const u8 *data,
|
|
|
|
|
unsigned int len, u8 *out)
|
|
|
|
|
{
|
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(desc->tfm);
|
|
|
|
|
|
|
|
|
|
return shash->init(desc) ?:
|
|
|
|
|
shash->finup(desc, data, len, out);
|
|
|
|
|
}
|
|
|
|
|
|
2008-08-31 05:47:27 +00: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);
|
2023-02-16 10:35:15 +00:00
|
|
|
int err;
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00: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 19:16:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
atomic64_inc(&istat->hash_cnt);
|
|
|
|
|
atomic64_add(len, &istat->hash_tlen);
|
|
|
|
|
}
|
2008-08-31 05:47:27 +00:00
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
|
|
|
|
err = -ENOKEY;
|
|
|
|
|
else
|
|
|
|
|
err = shash->digest(desc, data, len, out);
|
|
|
|
|
|
|
|
|
|
return crypto_shash_errstat(shash, err);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_digest);
|
|
|
|
|
|
2020-05-02 05:31:03 +00: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);
|
|
|
|
|
|
2023-10-18 22:34:55 +00:00
|
|
|
int crypto_shash_export(struct shash_desc *desc, void *out)
|
2008-11-02 13:38:11 +00:00
|
|
|
{
|
2023-10-18 22:34:55 +00:00
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
|
|
|
|
|
|
if (shash->export)
|
|
|
|
|
return shash->export(desc, out);
|
|
|
|
|
|
|
|
|
|
memcpy(out, shash_desc_ctx(desc), crypto_shash_descsize(tfm));
|
2009-07-22 04:37:06 +00:00
|
|
|
return 0;
|
2009-07-09 12:30:57 +00:00
|
|
|
}
|
2023-10-18 22:34:55 +00:00
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_export);
|
2008-11-02 13:38:11 +00:00
|
|
|
|
2023-10-18 22:34:55 +00:00
|
|
|
int crypto_shash_import(struct shash_desc *desc, const void *in)
|
2009-07-09 12:30:57 +00:00
|
|
|
{
|
2023-10-18 22:34:55 +00:00
|
|
|
struct crypto_shash *tfm = desc->tfm;
|
|
|
|
|
struct shash_alg *shash = crypto_shash_alg(tfm);
|
|
|
|
|
|
|
|
|
|
if (crypto_shash_get_flags(tfm) & CRYPTO_TFM_NEED_KEY)
|
|
|
|
|
return -ENOKEY;
|
|
|
|
|
|
|
|
|
|
if (shash->import)
|
|
|
|
|
return shash->import(desc, in);
|
|
|
|
|
|
|
|
|
|
memcpy(shash_desc_ctx(desc), in, crypto_shash_descsize(tfm));
|
2009-07-22 04:37:06 +00:00
|
|
|
return 0;
|
2008-11-02 13:38:11 +00:00
|
|
|
}
|
2023-10-18 22:34:55 +00:00
|
|
|
EXPORT_SYMBOL_GPL(crypto_shash_import);
|
2008-11-02 13:38:11 +00:00
|
|
|
|
2019-12-08 05:42:51 +00: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 12:46:25 +00:00
|
|
|
static int crypto_shash_init_tfm(struct crypto_tfm *tfm)
|
2008-08-31 05:47:27 +00:00
|
|
|
{
|
2009-07-14 04:50:12 +00: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 19:16:27 +00:00
|
|
|
struct shash_alg *alg = crypto_shash_alg(hash);
|
2019-12-08 05:42:51 +00: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 19:16:27 +00:00
|
|
|
|
|
|
|
|
hash->descsize = alg->descsize;
|
|
|
|
|
|
2019-01-07 02:47:42 +00:00
|
|
|
shash_set_needkey(hash, alg);
|
2009-07-14 04:50:12 +00:00
|
|
|
|
2019-12-08 05:42:51 +00: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 05:47:27 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2020-01-03 04:04:35 +00:00
|
|
|
static void crypto_shash_free_instance(struct crypto_instance *inst)
|
|
|
|
|
{
|
|
|
|
|
struct shash_instance *shash = shash_instance(inst);
|
|
|
|
|
|
|
|
|
|
shash->free(shash);
|
|
|
|
|
}
|
|
|
|
|
|
2023-02-16 10:35:28 +00:00
|
|
|
static int __maybe_unused crypto_shash_report(
|
|
|
|
|
struct sk_buff *skb, struct crypto_alg *alg)
|
2011-09-27 05:26:10 +00:00
|
|
|
{
|
|
|
|
|
struct crypto_report_hash rhash;
|
|
|
|
|
struct shash_alg *salg = __crypto_shash_alg(alg);
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
memset(&rhash, 0, sizeof(rhash));
|
|
|
|
|
|
|
|
|
|
strscpy(rhash.type, "shash", sizeof(rhash.type));
|
2013-02-05 17:19:13 +00:00
|
|
|
|
2011-09-27 05:26:10 +00:00
|
|
|
rhash.blocksize = alg->cra_blocksize;
|
|
|
|
|
rhash.digestsize = salg->digestsize;
|
|
|
|
|
|
2018-11-03 21:56:03 +00:00
|
|
|
return nla_put(skb, CRYPTOCFGA_REPORT_HASH, sizeof(rhash), &rhash);
|
2011-09-27 05:26:10 +00:00
|
|
|
}
|
|
|
|
|
|
2008-08-31 05:47:27 +00:00
|
|
|
static void crypto_shash_show(struct seq_file *m, struct crypto_alg *alg)
|
2016-12-31 15:56:23 +00:00
|
|
|
__maybe_unused;
|
2008-08-31 05:47:27 +00: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 10:35:15 +00: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");
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-22 08:10:58 +00:00
|
|
|
const struct crypto_type crypto_shash_type = {
|
2015-04-20 05:39:01 +00:00
|
|
|
.extsize = crypto_alg_extsize,
|
2008-08-31 05:47:27 +00:00
|
|
|
.init_tfm = crypto_shash_init_tfm,
|
2020-01-03 04:04:35 +00:00
|
|
|
.free = crypto_shash_free_instance,
|
2008-08-31 05:47:27 +00:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
.show = crypto_shash_show,
|
|
|
|
|
#endif
|
2023-05-02 08:02:33 +00:00
|
|
|
#if IS_ENABLED(CONFIG_CRYPTO_USER)
|
2011-09-27 05:26:10 +00:00
|
|
|
.report = crypto_shash_report,
|
2023-02-16 10:35:28 +00:00
|
|
|
#endif
|
2023-02-16 10:35:15 +00:00
|
|
|
#ifdef CONFIG_CRYPTO_STATS
|
|
|
|
|
.report_stat = crypto_shash_report_stat,
|
|
|
|
|
#endif
|
2008-08-31 05:47:27 +00: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 03:58:49 +00: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 05:47:27 +00:00
|
|
|
struct crypto_shash *crypto_alloc_shash(const char *alg_name, u32 type,
|
|
|
|
|
u32 mask)
|
|
|
|
|
{
|
2009-02-18 08:56:59 +00:00
|
|
|
return crypto_alloc_tfm(alg_name, &crypto_shash_type, type, mask);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_alloc_shash);
|
|
|
|
|
|
2022-06-27 09:51:57 +00: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-04-13 06:24:19 +00:00
|
|
|
struct crypto_shash *crypto_clone_shash(struct crypto_shash *hash)
|
|
|
|
|
{
|
|
|
|
|
struct crypto_tfm *tfm = crypto_shash_tfm(hash);
|
|
|
|
|
struct shash_alg *alg = crypto_shash_alg(hash);
|
|
|
|
|
struct crypto_shash *nhash;
|
|
|
|
|
int err;
|
|
|
|
|
|
|
|
|
|
if (!crypto_shash_alg_has_setkey(alg)) {
|
|
|
|
|
tfm = crypto_tfm_get(tfm);
|
|
|
|
|
if (IS_ERR(tfm))
|
|
|
|
|
return ERR_CAST(tfm);
|
|
|
|
|
|
|
|
|
|
return hash;
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-19 09:04:04 +00:00
|
|
|
if (!alg->clone_tfm && (alg->init_tfm || alg->base.cra_init))
|
2023-04-13 06:24:19 +00:00
|
|
|
return ERR_PTR(-ENOSYS);
|
|
|
|
|
|
|
|
|
|
nhash = crypto_clone_tfm(&crypto_shash_type, tfm);
|
|
|
|
|
if (IS_ERR(nhash))
|
|
|
|
|
return nhash;
|
|
|
|
|
|
|
|
|
|
nhash->descsize = hash->descsize;
|
|
|
|
|
|
2023-05-19 09:04:04 +00:00
|
|
|
if (alg->clone_tfm) {
|
|
|
|
|
err = alg->clone_tfm(nhash, hash);
|
|
|
|
|
if (err) {
|
|
|
|
|
crypto_free_shash(nhash);
|
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
}
|
2023-04-13 06:24:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nhash;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_clone_shash);
|
|
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
int hash_prepare_alg(struct hash_alg_common *alg)
|
2008-08-31 05:47:27 +00:00
|
|
|
{
|
2023-02-16 10:35:15 +00:00
|
|
|
struct crypto_istat_hash *istat = hash_get_stat(alg);
|
2008-08-31 05:47:27 +00:00
|
|
|
struct crypto_alg *base = &alg->base;
|
|
|
|
|
|
2023-03-28 03:57:09 +00:00
|
|
|
if (alg->digestsize > HASH_MAX_DIGESTSIZE)
|
2008-08-31 05:47:27 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
crypto: ahash - remove support for nonzero alignmask
Currently, the ahash API checks the alignment of all key and result
buffers against the algorithm's declared alignmask, and for any
unaligned buffers it falls back to manually aligned temporary buffers.
This is virtually useless, however. First, since it does not apply to
the message, its effect is much more limited than e.g. is the case for
the alignmask for "skcipher". Second, the key and result buffers are
given as virtual addresses and cannot (in general) be DMA'ed into, so
drivers end up having to copy to/from them in software anyway. As a
result it's easy to use memcpy() or the unaligned access helpers.
The crypto_hash_walk_*() helper functions do use the alignmask to align
the message. But with one exception those are only used for shash
algorithms being exposed via the ahash API, not for native ahashes, and
aligning the message is not required in this case, especially now that
alignmask support has been removed from shash. The exception is the
n2_core driver, which doesn't set an alignmask.
In any case, no ahash algorithms actually set a nonzero alignmask
anymore. Therefore, remove support for it from ahash. The benefit is
that all the code to handle "misaligned" buffers in the ahash API goes
away, reducing the overhead of the ahash API.
This follows the same change that was made to shash.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-22 08:10:44 +00:00
|
|
|
/* alignmask is not useful for hashes, so it is not supported. */
|
|
|
|
|
if (base->cra_alignmask)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2023-02-16 10:35:15 +00: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;
|
|
|
|
|
|
2019-01-07 03:07:20 +00:00
|
|
|
if ((alg->export && !alg->import) || (alg->import && !alg->export))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2023-02-16 10:35:15 +00:00
|
|
|
err = hash_prepare_alg(&alg->halg);
|
|
|
|
|
if (err)
|
|
|
|
|
return err;
|
|
|
|
|
|
2008-08-31 05:47:27 +00:00
|
|
|
base->cra_type = &crypto_shash_type;
|
|
|
|
|
base->cra_flags |= CRYPTO_ALG_TYPE_SHASH;
|
2009-07-09 12:30:57 +00:00
|
|
|
|
2023-10-18 22:34:55 +00:00
|
|
|
/*
|
|
|
|
|
* Handle missing optional functions. For each one we can either
|
|
|
|
|
* install a default here, or we can leave the pointer as NULL and check
|
|
|
|
|
* the pointer for NULL in crypto_shash_*(), avoiding an indirect call
|
|
|
|
|
* when the default behavior is desired. For ->finup and ->digest we
|
|
|
|
|
* install defaults, since for optimal performance algorithms should
|
|
|
|
|
* implement these anyway. On the other hand, for ->import and
|
|
|
|
|
* ->export the common case and best performance comes from the simple
|
|
|
|
|
* memcpy of the shash_desc_ctx, so when those pointers are NULL we
|
|
|
|
|
* leave them NULL and provide the memcpy with no indirect call.
|
|
|
|
|
*/
|
2009-07-09 12:36:44 +00:00
|
|
|
if (!alg->finup)
|
crypto: shash - optimize the default digest and finup
For an shash algorithm that doesn't implement ->digest, currently
crypto_shash_digest() with aligned input makes 5 indirect calls: 1 to
shash_digest_unaligned(), 1 to ->init, 2 to ->update ('alignmask + 1'
bytes, then the rest), then 1 to ->final. This is true even if the
algorithm implements ->finup. This is caused by an unnecessary fallback
to code meant to handle unaligned inputs. In fact,
crypto_shash_digest() already does the needed alignment check earlier.
Therefore, optimize the number of indirect calls for aligned inputs to 3
when the algorithm implements ->finup. It remains at 5 when the
algorithm implements neither ->finup nor ->digest.
Similarly, for an shash algorithm that doesn't implement ->finup,
currently crypto_shash_finup() with aligned input makes 4 indirect
calls: 1 to shash_finup_unaligned(), 2 to ->update, and
1 to ->final. Optimize this to 3 calls.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-09 07:32:13 +00:00
|
|
|
alg->finup = shash_default_finup;
|
2009-07-09 12:36:44 +00:00
|
|
|
if (!alg->digest)
|
crypto: shash - optimize the default digest and finup
For an shash algorithm that doesn't implement ->digest, currently
crypto_shash_digest() with aligned input makes 5 indirect calls: 1 to
shash_digest_unaligned(), 1 to ->init, 2 to ->update ('alignmask + 1'
bytes, then the rest), then 1 to ->final. This is true even if the
algorithm implements ->finup. This is caused by an unnecessary fallback
to code meant to handle unaligned inputs. In fact,
crypto_shash_digest() already does the needed alignment check earlier.
Therefore, optimize the number of indirect calls for aligned inputs to 3
when the algorithm implements ->finup. It remains at 5 when the
algorithm implements neither ->finup nor ->digest.
Similarly, for an shash algorithm that doesn't implement ->finup,
currently crypto_shash_finup() with aligned input makes 4 indirect
calls: 1 to shash_finup_unaligned(), 2 to ->update, and
1 to ->final. Optimize this to 3 calls.
Signed-off-by: Eric Biggers <ebiggers@google.com>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
2023-10-09 07:32:13 +00:00
|
|
|
alg->digest = shash_default_digest;
|
2023-10-18 22:34:55 +00:00
|
|
|
if (!alg->export)
|
2023-02-16 10:35:15 +00:00
|
|
|
alg->halg.statesize = alg->descsize;
|
2009-07-11 14:17:39 +00:00
|
|
|
if (!alg->setkey)
|
|
|
|
|
alg->setkey = shash_no_setkey;
|
2009-07-09 12:30:57 +00:00
|
|
|
|
2009-07-08 10:46:23 +00: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 05:47:27 +00:00
|
|
|
|
|
|
|
|
return crypto_register_alg(base);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_register_shash);
|
|
|
|
|
|
2019-12-15 23:51:19 +00:00
|
|
|
void crypto_unregister_shash(struct shash_alg *alg)
|
2008-08-31 05:47:27 +00:00
|
|
|
{
|
2019-12-15 23:51:19 +00:00
|
|
|
crypto_unregister_alg(&alg->base);
|
2008-08-31 05:47:27 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_shash);
|
|
|
|
|
|
2012-07-11 11:20:20 +00: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-15 23:51:19 +00:00
|
|
|
void crypto_unregister_shashes(struct shash_alg *algs, int count)
|
2012-07-11 11:20:20 +00:00
|
|
|
{
|
2019-12-15 23:51:19 +00:00
|
|
|
int i;
|
2012-07-11 11:20:20 +00:00
|
|
|
|
2019-12-15 23:51:19 +00:00
|
|
|
for (i = count - 1; i >= 0; --i)
|
|
|
|
|
crypto_unregister_shash(&algs[i]);
|
2012-07-11 11:20:20 +00:00
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(crypto_unregister_shashes);
|
|
|
|
|
|
2009-07-08 10:46:23 +00:00
|
|
|
int shash_register_instance(struct crypto_template *tmpl,
|
|
|
|
|
struct shash_instance *inst)
|
|
|
|
|
{
|
|
|
|
|
int err;
|
|
|
|
|
|
2020-01-03 04:04:40 +00:00
|
|
|
if (WARN_ON(!inst->free))
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2009-07-08 10:46:23 +00: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 04:04:38 +00:00
|
|
|
void shash_free_singlespawn_instance(struct shash_instance *inst)
|
2009-07-07 07:17:12 +00:00
|
|
|
{
|
2020-01-03 04:04:38 +00:00
|
|
|
crypto_drop_spawn(shash_instance_ctx(inst));
|
|
|
|
|
kfree(inst);
|
2009-07-07 07:17:12 +00:00
|
|
|
}
|
2020-01-03 04:04:38 +00:00
|
|
|
EXPORT_SYMBOL_GPL(shash_free_singlespawn_instance);
|
2009-07-07 07:17:12 +00:00
|
|
|
|
2008-08-31 05:47:27 +00:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
MODULE_DESCRIPTION("Synchronous cryptographic hash type");
|