mirrors/linux
2
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-07-16 15:39:42 -04:00
Code Issues Packages Projects Releases Wiki Activity

crypto: blake2b-generic - Use API partial block handling

Browse Source 
Use the Crypto API partial block handling.

Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
Herbert Xu
2025-04-18 10:58:43 +08:00
parent 7650f826f7
commit aa54e17020
3 changed files with 80 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
crypto/blake2b_generic.c
View File

@@ -15,12 +15,12 @@
* More information about BLAKE2 can be found at https://blake2.net.
*/
#include <linux/unaligned.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/bitops.h>
#include <crypto/internal/blake2b.h>
#include <crypto/internal/hash.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/string.h>
#include <linux/unaligned.h>
static const u8 blake2b_sigma[12][16] = {
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
@@ -111,8 +111,8 @@ static void blake2b_compress_one_generic(struct blake2b_state *S,
#undef G
#undef ROUND
void blake2b_compress_generic(struct blake2b_state *state,
const u8 *block, size_t nblocks, u32 inc)
static void blake2b_compress_generic(struct blake2b_state *state,
const u8 *block, size_t nblocks, u32 inc)
{
do {
blake2b_increment_counter(state, inc);
@@ -120,17 +120,19 @@ void blake2b_compress_generic(struct blake2b_state *state,
block += BLAKE2B_BLOCK_SIZE;
} while (--nblocks);
}
EXPORT_SYMBOL(blake2b_compress_generic);
static int crypto_blake2b_update_generic(struct shash_desc *desc,
const u8 *in, unsigned int inlen)
{
return crypto_blake2b_update(desc, in, inlen, blake2b_compress_generic);
return crypto_blake2b_update_bo(desc, in, inlen,
blake2b_compress_generic);
}
static int crypto_blake2b_final_generic(struct shash_desc *desc, u8 *out)
static int crypto_blake2b_finup_generic(struct shash_desc *desc, const u8 *in,
unsigned int inlen, u8 *out)
{
return crypto_blake2b_final(desc, out, blake2b_compress_generic);
return crypto_blake2b_finup(desc, in, inlen, out,
blake2b_compress_generic);
}
#define BLAKE2B_ALG(name, driver_name, digest_size) \
@@ -138,7 +140,9 @@ static int crypto_blake2b_final_generic(struct shash_desc *desc, u8 *out)
.base.cra_name = name, \
.base.cra_driver_name = driver_name, \
.base.cra_priority = 100, \
.base.cra_flags = CRYPTO_ALG_OPTIONAL_KEY, \
.base.cra_flags = CRYPTO_ALG_OPTIONAL_KEY | \
CRYPTO_AHASH_ALG_BLOCK_ONLY | \
CRYPTO_AHASH_ALG_FINAL_NONZERO, \
.base.cra_blocksize = BLAKE2B_BLOCK_SIZE, \
.base.cra_ctxsize = sizeof(struct blake2b_tfm_ctx), \
.base.cra_module = THIS_MODULE, \
@@ -146,8 +150,9 @@ static int crypto_blake2b_final_generic(struct shash_desc *desc, u8 *out)
.setkey = crypto_blake2b_setkey, \
.init = crypto_blake2b_init, \
.update = crypto_blake2b_update_generic, \
.final = crypto_blake2b_final_generic, \
.descsize = sizeof(struct blake2b_state), \
.finup = crypto_blake2b_finup_generic, \
.descsize = BLAKE2B_DESC_SIZE, \
.statesize = BLAKE2B_STATE_SIZE, \
}
static struct shash_alg blake2b_algs[] = {

14
include/crypto/blake2b.h
View File

@@ -11,6 +11,8 @@ enum blake2b_lengths {
BLAKE2B_BLOCK_SIZE = 128,
BLAKE2B_HASH_SIZE = 64,
BLAKE2B_KEY_SIZE = 64,
BLAKE2B_STATE_SIZE = 80,
BLAKE2B_DESC_SIZE = 96,
BLAKE2B_160_HASH_SIZE = 20,
BLAKE2B_256_HASH_SIZE = 32,
@@ -25,7 +27,6 @@ struct blake2b_state {
u64 f[2];
u8 buf[BLAKE2B_BLOCK_SIZE];
unsigned int buflen;
unsigned int outlen;
};
enum blake2b_iv {
@@ -40,7 +41,7 @@ enum blake2b_iv {
};
static inline void __blake2b_init(struct blake2b_state *state, size_t outlen,
const void *key, size_t keylen)
size_t keylen)
{
state->h[0] = BLAKE2B_IV0 ^ (0x01010000 | keylen << 8 | outlen);
state->h[1] = BLAKE2B_IV1;
@@ -52,15 +53,6 @@ static inline void __blake2b_init(struct blake2b_state *state, size_t outlen,
state->h[7] = BLAKE2B_IV7;
state->t[0] = 0;
state->t[1] = 0;
state->f[0] = 0;
state->f[1] = 0;
state->buflen = 0;
state->outlen = outlen;
if (keylen) {
memcpy(state->buf, key, keylen);
memset(&state->buf[keylen], 0, BLAKE2B_BLOCK_SIZE - keylen);
state->buflen = BLAKE2B_BLOCK_SIZE;
}
}
#endif /* _CRYPTO_BLAKE2B_H */

70
include/crypto/internal/blake2b.h
View File

@@ -7,16 +7,27 @@
#ifndef _CRYPTO_INTERNAL_BLAKE2B_H
#define _CRYPTO_INTERNAL_BLAKE2B_H
#include <asm/byteorder.h>
#include <crypto/blake2b.h>
#include <crypto/internal/hash.h>
#include <linux/array_size.h>
#include <linux/compiler.h>
#include <linux/build_bug.h>
#include <linux/errno.h>
#include <linux/math.h>
#include <linux/string.h>
void blake2b_compress_generic(struct blake2b_state *state,
const u8 *block, size_t nblocks, u32 inc);
#include <linux/types.h>
static inline void blake2b_set_lastblock(struct blake2b_state *state)
{
state->f[0] = -1;
state->f[1] = 0;
}
static inline void blake2b_set_nonlast(struct blake2b_state *state)
{
state->f[0] = 0;
state->f[1] = 0;
}
typedef void (*blake2b_compress_t)(struct blake2b_state *state,
@@ -30,6 +41,7 @@ static inline void __blake2b_update(struct blake2b_state *state,
if (unlikely(!inlen))
return;
blake2b_set_nonlast(state);
if (inlen > fill) {
memcpy(state->buf + state->buflen, in, fill);
(*compress)(state, state->buf, 1, BLAKE2B_BLOCK_SIZE);
@@ -49,6 +61,7 @@ static inline void __blake2b_update(struct blake2b_state *state,
}
static inline void __blake2b_final(struct blake2b_state *state, u8 *out,
unsigned int outlen,
blake2b_compress_t compress)
{
int i;
@@ -59,13 +72,13 @@ static inline void __blake2b_final(struct blake2b_state *state, u8 *out,
(*compress)(state, state->buf, 1, state->buflen);
for (i = 0; i < ARRAY_SIZE(state->h); i++)
__cpu_to_le64s(&state->h[i]);
memcpy(out, state->h, state->outlen);
memcpy(out, state->h, outlen);
}
/* Helper functions for shash implementations of BLAKE2b */
struct blake2b_tfm_ctx {
u8 key[BLAKE2B_KEY_SIZE];
u8 key[BLAKE2B_BLOCK_SIZE];
unsigned int keylen;
};
@@ -74,10 +87,13 @@ static inline int crypto_blake2b_setkey(struct crypto_shash *tfm,
{
struct blake2b_tfm_ctx *tctx = crypto_shash_ctx(tfm);
if (keylen == 0 || keylen > BLAKE2B_KEY_SIZE)
if (keylen > BLAKE2B_KEY_SIZE)
return -EINVAL;
BUILD_BUG_ON(BLAKE2B_KEY_SIZE > BLAKE2B_BLOCK_SIZE);
memcpy(tctx->key, key, keylen);
memset(tctx->key + keylen, 0, BLAKE2B_BLOCK_SIZE - keylen);
tctx->keylen = keylen;
return 0;
@@ -89,8 +105,9 @@ static inline int crypto_blake2b_init(struct shash_desc *desc)
struct blake2b_state *state = shash_desc_ctx(desc);
unsigned int outlen = crypto_shash_digestsize(desc->tfm);
__blake2b_init(state, outlen, tctx->key, tctx->keylen);
return 0;
__blake2b_init(state, outlen, tctx->keylen);
return tctx->keylen ?
crypto_shash_update(desc, tctx->key, BLAKE2B_BLOCK_SIZE) : 0;
}
static inline int crypto_blake2b_update(struct shash_desc *desc,
@@ -103,12 +120,43 @@ static inline int crypto_blake2b_update(struct shash_desc *desc,
return 0;
}
static inline int crypto_blake2b_final(struct shash_desc *desc, u8 *out,
blake2b_compress_t compress)
static inline int crypto_blake2b_update_bo(struct shash_desc *desc,
const u8 *in, unsigned int inlen,
blake2b_compress_t compress)
{
struct blake2b_state *state = shash_desc_ctx(desc);
__blake2b_final(state, out, compress);
blake2b_set_nonlast(state);
compress(state, in, inlen / BLAKE2B_BLOCK_SIZE, BLAKE2B_BLOCK_SIZE);
return inlen - round_down(inlen, BLAKE2B_BLOCK_SIZE);
}
static inline int crypto_blake2b_final(struct shash_desc *desc, u8 *out,
blake2b_compress_t compress)
{
unsigned int outlen = crypto_shash_digestsize(desc->tfm);
struct blake2b_state *state = shash_desc_ctx(desc);
__blake2b_final(state, out, outlen, compress);
return 0;
}
static inline int crypto_blake2b_finup(struct shash_desc *desc, const u8 *in,
unsigned int inlen, u8 *out,
blake2b_compress_t compress)
{
struct blake2b_state *state = shash_desc_ctx(desc);
u8 buf[BLAKE2B_BLOCK_SIZE];
int i;
memcpy(buf, in, inlen);
memset(buf + inlen, 0, BLAKE2B_BLOCK_SIZE - inlen);
blake2b_set_lastblock(state);
compress(state, buf, 1, inlen);
for (i = 0; i < ARRAY_SIZE(state->h); i++)
__cpu_to_le64s(&state->h[i]);
memcpy(out, state->h, crypto_shash_digestsize(desc->tfm));
memzero_explicit(buf, sizeof(buf));
return 0;
}