From d22bac823e653bb6b04079e7ad1e8bc06a2342ca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Niels=20M=C3=B6ller?= <nisse@lysator.liu.se>
Date: Fri, 25 Apr 2014 22:12:36 +0200
Subject: [PATCH] Rename *_DATA_SIZE to *_BLOCK_SIZE.
---
ChangeLog | 4 ++++
examples/nettle-benchmark.c | 10 +++++-----
gosthash94.c | 8 ++++----
gosthash94.h | 6 ++++--
md2.c | 14 +++++++-------
md2.h | 10 ++++++----
md4.h | 6 ++++--
md5.c | 2 +-
md5.h | 6 ++++--
nettle-meta.h | 2 +-
nettle.texinfo | 36 ++++++++++++++++++------------------
ripemd160.h | 6 ++++--
sha1.c | 2 +-
sha1.h | 6 ++++--
sha2.h | 22 ++++++++++++++--------
sha256.c | 2 +-
sha3-224.c | 4 ++--
sha3-256.c | 4 ++--
sha3-384.c | 4 ++--
sha3-512.c | 4 ++--
sha3.h | 21 +++++++++++++--------
sha512-224-meta.c | 2 +-
sha512-256-meta.c | 2 +-
sha512.c | 4 ++--
umac-set-key.c | 2 +-
umac.h | 8 +++++---
umac128.c | 10 +++++-----
umac32.c | 4 ++--
umac64.c | 6 +++---
umac96.c | 8 ++++----
30 files changed, 127 insertions(+), 98 deletions(-)
diff --git a/ChangeLog b/ChangeLog
index 53cb48a7..a4e5633e 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,9 @@
2014-04-25 Niels Möller <nisse@lysator.liu.se>
+ * All hash-related files: Renamed all _DATA_SIZE constants to
+ _BLOCK_SIZE, for consistency. Old names kept for backwards
+ compatibility.
+
* nettle.texinfo (CCM): Documentation for CCM mode, contributed by
Owen Kirby.
diff --git a/examples/nettle-benchmark.c b/examples/nettle-benchmark.c
index f1f9f599..847b80c1 100644
--- a/examples/nettle-benchmark.c
+++ b/examples/nettle-benchmark.c
@@ -410,7 +410,7 @@ time_umac(void)
info.update = (nettle_hash_update_func *) umac32_update;
info.data = data;
- display("umac32", "update", UMAC_DATA_SIZE,
+ display("umac32", "update", UMAC_BLOCK_SIZE,
time_function(bench_hash, &info));
umac64_set_key (&ctx64, key);
@@ -418,7 +418,7 @@ time_umac(void)
info.update = (nettle_hash_update_func *) umac64_update;
info.data = data;
- display("umac64", "update", UMAC_DATA_SIZE,
+ display("umac64", "update", UMAC_BLOCK_SIZE,
time_function(bench_hash, &info));
umac96_set_key (&ctx96, key);
@@ -426,7 +426,7 @@ time_umac(void)
info.update = (nettle_hash_update_func *) umac96_update;
info.data = data;
- display("umac96", "update", UMAC_DATA_SIZE,
+ display("umac96", "update", UMAC_BLOCK_SIZE,
time_function(bench_hash, &info));
umac128_set_key (&ctx128, key);
@@ -434,7 +434,7 @@ time_umac(void)
info.update = (nettle_hash_update_func *) umac128_update;
info.data = data;
- display("umac128", "update", UMAC_DATA_SIZE,
+ display("umac128", "update", UMAC_BLOCK_SIZE,
time_function(bench_hash, &info));
}
@@ -677,7 +677,7 @@ static void
bench_sha1_compress(void)
{
uint32_t state[_SHA1_DIGEST_LENGTH];
- uint8_t data[SHA1_DATA_SIZE];
+ uint8_t data[SHA1_BLOCK_SIZE];
double t;
TIME_CYCLES (t, _nettle_sha1_compress(state, data));
diff --git a/gosthash94.c b/gosthash94.c
index a671b4fe..e60c9ae5 100644
--- a/gosthash94.c
+++ b/gosthash94.c
@@ -533,7 +533,7 @@ gosthash94_update (struct gosthash94_ctx *ctx,
/* fill partial block */
if (index)
{
- unsigned left = GOSTHASH94_DATA_SIZE - index;
+ unsigned left = GOSTHASH94_BLOCK_SIZE - index;
memcpy (ctx->message + index, msg, (length < left ? length : left));
if (length < left)
return;
@@ -543,11 +543,11 @@ gosthash94_update (struct gosthash94_ctx *ctx,
msg += left;
length -= left;
}
- while (length >= GOSTHASH94_DATA_SIZE)
+ while (length >= GOSTHASH94_BLOCK_SIZE)
{
gost_compute_sum_and_hash (ctx, msg);
- msg += GOSTHASH94_DATA_SIZE;
- length -= GOSTHASH94_DATA_SIZE;
+ msg += GOSTHASH94_BLOCK_SIZE;
+ length -= GOSTHASH94_BLOCK_SIZE;
}
if (length)
{
diff --git a/gosthash94.h b/gosthash94.h
index 5a1978e6..8e9d49fe 100644
--- a/gosthash94.h
+++ b/gosthash94.h
@@ -72,14 +72,16 @@ extern "C" {
#define gosthash94_update nettle_gosthash94_update
#define gosthash94_digest nettle_gosthash94_digest
-#define GOSTHASH94_DATA_SIZE 32
+#define GOSTHASH94_BLOCK_SIZE 32
#define GOSTHASH94_DIGEST_SIZE 32
+/* For backwards compatibility */
+#define GOSTHASH94_DATA_SIZE GOSTHASH94_BLOCK_SIZE
struct gosthash94_ctx
{
uint32_t hash[8]; /* algorithm 256-bit state */
uint32_t sum[8]; /* sum of processed message blocks */
- uint8_t message[GOSTHASH94_DATA_SIZE]; /* 256-bit buffer for leftovers */
+ uint8_t message[GOSTHASH94_BLOCK_SIZE]; /* 256-bit buffer for leftovers */
uint64_t length; /* number of processed bytes */
};
diff --git a/md2.c b/md2.c
index 19d870e1..a0cb1b64 100644
--- a/md2.c
+++ b/md2.c
@@ -87,21 +87,21 @@ md2_transform(struct md2_ctx *ctx, const uint8_t *data)
unsigned i;
uint8_t t;
- memcpy(ctx->X + 16, data, MD2_DATA_SIZE);
+ memcpy(ctx->X + 16, data, MD2_BLOCK_SIZE);
for (i = 0, t = ctx->C[15];
- i<MD2_DATA_SIZE; i++)
+ i<MD2_BLOCK_SIZE; i++)
{
- ctx->X[2 * MD2_DATA_SIZE + i]
- = ctx->X[i] ^ ctx->X[MD2_DATA_SIZE + i];
+ ctx->X[2 * MD2_BLOCK_SIZE + i]
+ = ctx->X[i] ^ ctx->X[MD2_BLOCK_SIZE + i];
t = (ctx->C[i] ^= S[data[i]^t]);
}
for (i = t = 0;
- i< MD2_DATA_SIZE + 2;
+ i< MD2_BLOCK_SIZE + 2;
t = (t + i) & 0xff, i++)
{
unsigned j;
- for (j = 0; j < 3 * MD2_DATA_SIZE; j++)
+ for (j = 0; j < 3 * MD2_BLOCK_SIZE; j++)
t = (ctx->X[j] ^= S[t]);
}
}
@@ -129,7 +129,7 @@ md2_digest(struct md2_ctx *ctx,
assert(length <= MD2_DIGEST_SIZE);
- left = MD2_DATA_SIZE - ctx->index;
+ left = MD2_BLOCK_SIZE - ctx->index;
memset(ctx->block + ctx->index, left, left);
md2_transform(ctx, ctx->block);
diff --git a/md2.h b/md2.h
index fe7013f6..560b2cbc 100644
--- a/md2.h
+++ b/md2.h
@@ -46,13 +46,15 @@ extern "C" {
#define md2_digest nettle_md2_digest
#define MD2_DIGEST_SIZE 16
-#define MD2_DATA_SIZE 16
+#define MD2_BLOCK_SIZE 16
+/* For backwards compatibility */
+#define MD2_DATA_SIZE MD2_BLOCK_SIZE
struct md2_ctx
{
- uint8_t C[MD2_DATA_SIZE];
- uint8_t X[3 * MD2_DATA_SIZE];
- uint8_t block[MD2_DATA_SIZE]; /* Block buffer */
+ uint8_t C[MD2_BLOCK_SIZE];
+ uint8_t X[3 * MD2_BLOCK_SIZE];
+ uint8_t block[MD2_BLOCK_SIZE]; /* Block buffer */
unsigned index; /* Into buffer */
};
diff --git a/md4.h b/md4.h
index d90ff2fa..f199a80e 100644
--- a/md4.h
+++ b/md4.h
@@ -46,7 +46,9 @@ extern "C" {
#define md4_digest nettle_md4_digest
#define MD4_DIGEST_SIZE 16
-#define MD4_DATA_SIZE 64
+#define MD4_BLOCK_SIZE 64
+/* For backwards compatibility */
+#define MD4_DATA_SIZE MD4_BLOCK_SIZE
/* Digest is kept internally as 4 32-bit words. */
#define _MD4_DIGEST_LENGTH 4
@@ -56,7 +58,7 @@ struct md4_ctx
{
uint32_t state[_MD4_DIGEST_LENGTH];
uint64_t count; /* Block count */
- uint8_t block[MD4_DATA_SIZE]; /* Block buffer */
+ uint8_t block[MD4_BLOCK_SIZE]; /* Block buffer */
unsigned index; /* Into buffer */
};
diff --git a/md5.c b/md5.c
index a518e65e..142b112e 100644
--- a/md5.c
+++ b/md5.c
@@ -85,7 +85,7 @@ md5_digest(struct md5_ctx *ctx,
/* There are 512 = 2^9 bits in one block */
bit_count = (ctx->count << 9) | (ctx->index << 3);
- LE_WRITE_UINT64(ctx->block + (MD5_DATA_SIZE - 8), bit_count);
+ LE_WRITE_UINT64(ctx->block + (MD5_BLOCK_SIZE - 8), bit_count);
_nettle_md5_compress(ctx->state, ctx->block);
_nettle_write_le32(length, digest, ctx->state);
diff --git a/md5.h b/md5.h
index 7a37872b..040cf9de 100644
--- a/md5.h
+++ b/md5.h
@@ -46,7 +46,9 @@ extern "C" {
#define md5_digest nettle_md5_digest
#define MD5_DIGEST_SIZE 16
-#define MD5_DATA_SIZE 64
+#define MD5_BLOCK_SIZE 64
+/* For backwards compatibility */
+#define MD5_DATA_SIZE MD5_BLOCK_SIZE
/* Digest is kept internally as 4 32-bit words. */
#define _MD5_DIGEST_LENGTH 4
@@ -55,7 +57,7 @@ struct md5_ctx
{
uint32_t state[_MD5_DIGEST_LENGTH];
uint64_t count; /* Block count */
- uint8_t block[MD5_DATA_SIZE]; /* Block buffer */
+ uint8_t block[MD5_BLOCK_SIZE]; /* Block buffer */
unsigned index; /* Into buffer */
};
diff --git a/nettle-meta.h b/nettle-meta.h
index c10dcbde..23a47ed9 100644
--- a/nettle-meta.h
+++ b/nettle-meta.h
@@ -108,7 +108,7 @@ struct nettle_hash
#name, \
sizeof(struct name##_ctx), \
NAME##_DIGEST_SIZE, \
- NAME##_DATA_SIZE, \
+ NAME##_BLOCK_SIZE, \
(nettle_hash_init_func *) name##_init, \
(nettle_hash_update_func *) name##_update, \
(nettle_hash_digest_func *) name##_digest \
diff --git a/nettle.texinfo b/nettle.texinfo
index 9bd08d51..f7d78e2a 100644
--- a/nettle.texinfo
+++ b/nettle.texinfo
@@ -428,7 +428,7 @@ bits, or 32 octets. Nettle defines SHA256 in @file{<nettle/sha2.h>}.
The size of a SHA256 digest, i.e. 32.
@end defvr
-@defvr Constant SHA256_DATA_SIZE
+@defvr Constant SHA256_BLOCK_SIZE
The internal block size of SHA256. Useful for some special constructions,
in particular HMAC-SHA256.
@end defvr
@@ -469,7 +469,7 @@ compatibility).
The size of a SHA224 digest, i.e. 28.
@end defvr
-@defvr Constant SHA224_DATA_SIZE
+@defvr Constant SHA224_BLOCK_SIZE
The internal block size of SHA224. Useful for some special constructions,
in particular HMAC-SHA224.
@end defvr
@@ -508,7 +508,7 @@ octets. Nettle defines SHA512 in @file{<nettle/sha2.h>} (and in
The size of a SHA512 digest, i.e. 64.
@end defvr
-@defvr Constant SHA512_DATA_SIZE
+@defvr Constant SHA512_BLOCK_SIZE
The internal block size of SHA512, 128. Useful for some special
constructions, in particular HMAC-SHA512.
@end defvr
@@ -554,10 +554,10 @@ identifiers for other purposes. So avoid doing that.
The digest size for each variant, i.e., 28, 32, and 48, respectively.
@end defvr
-@defvr Constant SHA512_224_DATA_SIZE
-@defvrx Constant SHA512_256_DATA_SIZE
-@defvrx Constant SHA384_DATA_SIZE
-The internal block size, same as SHA512_DATA_SIZE, i.e., 128. Useful for
+@defvr Constant SHA512_224_BLOCK_SIZE
+@defvrx Constant SHA512_256_BLOCK_SIZE
+@defvrx Constant SHA384_BLOCK_SIZE
+The internal block size, same as SHA512_BLOCK_SIZE, i.e., 128. Useful for
some special constructions, in particular HMAC-SHA384.
@end defvr
@@ -606,7 +606,7 @@ Nettle defines SHA3-224 in @file{<nettle/sha3.h>}.
The size of a SHA3_224 digest, i.e., 28.
@end defvr
-@defvr Constant SHA3_224_DATA_SIZE
+@defvr Constant SHA3_224_BLOCK_SIZE
The internal block size of SHA3_224.
@end defvr
@@ -641,7 +641,7 @@ Nettle defines SHA3-256 in @file{<nettle/sha3.h>}.
The size of a SHA3_256 digest, i.e., 32.
@end defvr
-@defvr Constant SHA3_256_DATA_SIZE
+@defvr Constant SHA3_256_BLOCK_SIZE
The internal block size of SHA3_256.
@end defvr
@@ -675,7 +675,7 @@ Nettle defines SHA3-384 in @file{<nettle/sha3.h>}.
The size of a SHA3_384 digest, i.e., 48.
@end defvr
-@defvr Constant SHA3_384_DATA_SIZE
+@defvr Constant SHA3_384_BLOCK_SIZE
The internal block size of SHA3_384.
@end defvr
@@ -709,7 +709,7 @@ Nettle defines SHA3-512 in @file{<nettle/sha3.h>}.
The size of a SHA3_512 digest, i.e. 64.
@end defvr
-@defvr Constant SHA3_512_DATA_SIZE
+@defvr Constant SHA3_512_BLOCK_SIZE
The internal block size of SHA3_512.
@end defvr
@@ -757,7 +757,7 @@ described in @cite{RFC 1321}. It outputs message digests of 128 bits, or
The size of an MD5 digest, i.e. 16.
@end defvr
-@defvr Constant MD5_DATA_SIZE
+@defvr Constant MD5_BLOCK_SIZE
The internal block size of MD5. Useful for some special constructions,
in particular HMAC-MD5.
@end defvr
@@ -801,7 +801,7 @@ Nettle defines MD2 in @file{<nettle/md2.h>}.
The size of an MD2 digest, i.e. 16.
@end defvr
-@defvr Constant MD2_DATA_SIZE
+@defvr Constant MD2_BLOCK_SIZE
The internal block size of MD2.
@end defvr
@@ -838,7 +838,7 @@ existing applications and protocols.
The size of an MD4 digest, i.e. 16.
@end defvr
-@defvr Constant MD4_DATA_SIZE
+@defvr Constant MD4_BLOCK_SIZE
The internal block size of MD4.
@end defvr
@@ -875,7 +875,7 @@ RIPEMD160 in @file{nettle/ripemd160.h}.
The size of a RIPEMD160 digest, i.e. 20.
@end defvr
-@defvr Constant RIPEMD160_DATA_SIZE
+@defvr Constant RIPEMD160_BLOCK_SIZE
The internal block size of RIPEMD160.
@end defvr
@@ -911,7 +911,7 @@ in @file{<nettle/sha.h>}, for backwards compatibility).
The size of a SHA1 digest, i.e. 20.
@end defvr
-@defvr Constant SHA1_DATA_SIZE
+@defvr Constant SHA1_BLOCK_SIZE
The internal block size of SHA1. Useful for some special constructions,
in particular HMAC-SHA1.
@end defvr
@@ -949,7 +949,7 @@ Nettle defines GOSTHASH94 in @file{<nettle/gosthash94.h>}.
The size of a GOSTHASH94 digest, i.e. 32.
@end defvr
-@defvr Constant GOSTHASH94_DATA_SIZE
+@defvr Constant GOSTHASH94_BLOCK_SIZE
The internal block size of GOSTHASH94, i.e., 32.
@end defvr
@@ -2743,7 +2743,7 @@ The size of an UMAC96 digest, 12.
@defvr Constant UMAC128_DIGEST_SIZE
The size of an UMAC128 digest, 16.
@end defvr
-@defvr Constant UMAC_DATA_SIZE
+@defvr Constant UMAC_BLOCK_SIZE
The internal block size of UMAC.
@end defvr
diff --git a/ripemd160.h b/ripemd160.h
index 86012d13..80d1d8a7 100644
--- a/ripemd160.h
+++ b/ripemd160.h
@@ -48,7 +48,9 @@ extern "C" {
/* RIPEMD160 */
#define RIPEMD160_DIGEST_SIZE 20
-#define RIPEMD160_DATA_SIZE 64
+#define RIPEMD160_BLOCK_SIZE 64
+/* For backwards compatibility */
+#define RIPEMD160_DATA_SIZE RIPEMD160_BLOCK_SIZE
/* Digest is kept internally as 5 32-bit words. */
#define _RIPEMD160_DIGEST_LENGTH 5
@@ -57,7 +59,7 @@ struct ripemd160_ctx
{
uint32_t state[_RIPEMD160_DIGEST_LENGTH];
uint64_t count; /* 64-bit block count */
- uint8_t block[RIPEMD160_DATA_SIZE];
+ uint8_t block[RIPEMD160_BLOCK_SIZE];
unsigned int index;
};
diff --git a/sha1.c b/sha1.c
index 615212a5..a585727e 100644
--- a/sha1.c
+++ b/sha1.c
@@ -92,7 +92,7 @@ sha1_digest(struct sha1_ctx *ctx,
bit_count = (ctx->count << 9) | (ctx->index << 3);
/* append the 64 bit count */
- WRITE_UINT64(ctx->block + (SHA1_DATA_SIZE - 8), bit_count);
+ WRITE_UINT64(ctx->block + (SHA1_BLOCK_SIZE - 8), bit_count);
_nettle_sha1_compress(ctx->state, ctx->block);
_nettle_write_be32(length, digest, ctx->state);
diff --git a/sha1.h b/sha1.h
index 94711bfa..7500d0c2 100644
--- a/sha1.h
+++ b/sha1.h
@@ -48,7 +48,9 @@ extern "C" {
/* SHA1 */
#define SHA1_DIGEST_SIZE 20
-#define SHA1_DATA_SIZE 64
+#define SHA1_BLOCK_SIZE 64
+/* For backwards compatibility */
+#define SHA1_DATA_SIZE SHA1_BLOCK_SIZE
/* Digest is kept internally as 5 32-bit words. */
#define _SHA1_DIGEST_LENGTH 5
@@ -57,7 +59,7 @@ struct sha1_ctx
{
uint32_t state[_SHA1_DIGEST_LENGTH]; /* State variables */
uint64_t count; /* 64-bit block count */
- uint8_t block[SHA1_DATA_SIZE]; /* SHA1 data buffer */
+ uint8_t block[SHA1_BLOCK_SIZE]; /* SHA1 data buffer */
unsigned int index; /* index into buffer */
};
diff --git a/sha2.h b/sha2.h
index acbcc16d..6537c0ec 100644
--- a/sha2.h
+++ b/sha2.h
@@ -56,10 +56,16 @@ extern "C" {
#define sha512_256_init nettle_sha512_256_init
#define sha512_256_digest nettle_sha512_256_digest
+/* For backwards compatibility */
+#define SHA224_DATA_SIZE SHA256_BLOCK_SIZE
+#define SHA256_DATA_SIZE SHA256_BLOCK_SIZE
+#define SHA512_DATA_SIZE SHA512_BLOCK_SIZE
+#define SHA384_DATA_SIZE SHA512_BLOCK_SIZE
+
/* SHA256 */
#define SHA256_DIGEST_SIZE 32
-#define SHA256_DATA_SIZE 64
+#define SHA256_BLOCK_SIZE 64
/* Digest is kept internally as 8 32-bit words. */
#define _SHA256_DIGEST_LENGTH 8
@@ -68,7 +74,7 @@ struct sha256_ctx
{
uint32_t state[_SHA256_DIGEST_LENGTH]; /* State variables */
uint64_t count; /* 64-bit block count */
- uint8_t block[SHA256_DATA_SIZE]; /* SHA256 data buffer */
+ uint8_t block[SHA256_BLOCK_SIZE]; /* SHA256 data buffer */
unsigned int index; /* index into buffer */
};
@@ -95,7 +101,7 @@ _nettle_sha256_compress(uint32_t *state, const uint8_t *data, const uint32_t *k)
/* SHA224, a truncated SHA256 with different initial state. */
#define SHA224_DIGEST_SIZE 28
-#define SHA224_DATA_SIZE SHA256_DATA_SIZE
+#define SHA224_BLOCK_SIZE SHA256_BLOCK_SIZE
#define sha224_ctx sha256_ctx
void
@@ -112,7 +118,7 @@ sha224_digest(struct sha256_ctx *ctx,
/* SHA512 */
#define SHA512_DIGEST_SIZE 64
-#define SHA512_DATA_SIZE 128
+#define SHA512_BLOCK_SIZE 128
/* Digest is kept internally as 8 64-bit words. */
#define _SHA512_DIGEST_LENGTH 8
@@ -121,7 +127,7 @@ struct sha512_ctx
{
uint64_t state[_SHA512_DIGEST_LENGTH]; /* State variables */
uint64_t count_low, count_high; /* 128-bit block count */
- uint8_t block[SHA512_DATA_SIZE]; /* SHA512 data buffer */
+ uint8_t block[SHA512_BLOCK_SIZE]; /* SHA512 data buffer */
unsigned int index; /* index into buffer */
};
@@ -148,7 +154,7 @@ _nettle_sha512_compress(uint64_t *state, const uint8_t *data, const uint64_t *k)
/* SHA384, a truncated SHA512 with different initial state. */
#define SHA384_DIGEST_SIZE 48
-#define SHA384_DATA_SIZE SHA512_DATA_SIZE
+#define SHA384_BLOCK_SIZE SHA512_BLOCK_SIZE
#define sha384_ctx sha512_ctx
void
@@ -166,7 +172,7 @@ sha384_digest(struct sha512_ctx *ctx,
with different initial states. */
#define SHA512_224_DIGEST_SIZE 28
-#define SHA512_224_DATA_SIZE SHA512_DATA_SIZE
+#define SHA512_224_BLOCK_SIZE SHA512_BLOCK_SIZE
#define sha512_224_ctx sha512_ctx
void
@@ -180,7 +186,7 @@ sha512_224_digest(struct sha512_224_ctx *ctx,
uint8_t *digest);
#define SHA512_256_DIGEST_SIZE 32
-#define SHA512_256_DATA_SIZE SHA512_DATA_SIZE
+#define SHA512_256_BLOCK_SIZE SHA512_BLOCK_SIZE
#define sha512_256_ctx sha512_ctx
void
diff --git a/sha256.c b/sha256.c
index 975d13aa..c632b7f4 100644
--- a/sha256.c
+++ b/sha256.c
@@ -116,7 +116,7 @@ sha256_write_digest(struct sha256_ctx *ctx,
/* This is slightly inefficient, as the numbers are converted to
big-endian format, and will be converted back by the compression
function. It's probably not worth the effort to fix this. */
- WRITE_UINT64(ctx->block + (SHA256_DATA_SIZE - 8), bit_count);
+ WRITE_UINT64(ctx->block + (SHA256_BLOCK_SIZE - 8), bit_count);
COMPRESS(ctx, ctx->block);
_nettle_write_be32(length, digest, ctx->state);
diff --git a/sha3-224.c b/sha3-224.c
index b4bb23b4..83fce158 100644
--- a/sha3-224.c
+++ b/sha3-224.c
@@ -53,7 +53,7 @@ sha3_224_update (struct sha3_224_ctx *ctx,
size_t length,
const uint8_t *data)
{
- ctx->index = _sha3_update (&ctx->state, SHA3_224_DATA_SIZE, ctx->block,
+ ctx->index = _sha3_update (&ctx->state, SHA3_224_BLOCK_SIZE, ctx->block,
ctx->index, length, data);
}
@@ -62,7 +62,7 @@ sha3_224_digest(struct sha3_224_ctx *ctx,
size_t length,
uint8_t *digest)
{
- _sha3_pad (&ctx->state, SHA3_224_DATA_SIZE, ctx->block, ctx->index);
+ _sha3_pad (&ctx->state, SHA3_224_BLOCK_SIZE, ctx->block, ctx->index);
_nettle_write_le64 (length, digest, ctx->state.a);
sha3_224_init (ctx);
}
diff --git a/sha3-256.c b/sha3-256.c
index d0a00e2b..ca9b0209 100644
--- a/sha3-256.c
+++ b/sha3-256.c
@@ -53,7 +53,7 @@ sha3_256_update (struct sha3_256_ctx *ctx,
size_t length,
const uint8_t *data)
{
- ctx->index = _sha3_update (&ctx->state, SHA3_256_DATA_SIZE, ctx->block,
+ ctx->index = _sha3_update (&ctx->state, SHA3_256_BLOCK_SIZE, ctx->block,
ctx->index, length, data);
}
@@ -62,7 +62,7 @@ sha3_256_digest(struct sha3_256_ctx *ctx,
size_t length,
uint8_t *digest)
{
- _sha3_pad (&ctx->state, SHA3_256_DATA_SIZE, ctx->block, ctx->index);
+ _sha3_pad (&ctx->state, SHA3_256_BLOCK_SIZE, ctx->block, ctx->index);
_nettle_write_le64 (length, digest, ctx->state.a);
sha3_256_init (ctx);
}
diff --git a/sha3-384.c b/sha3-384.c
index 245faaed..148ba1d3 100644
--- a/sha3-384.c
+++ b/sha3-384.c
@@ -53,7 +53,7 @@ sha3_384_update (struct sha3_384_ctx *ctx,
size_t length,
const uint8_t *data)
{
- ctx->index = _sha3_update (&ctx->state, SHA3_384_DATA_SIZE, ctx->block,
+ ctx->index = _sha3_update (&ctx->state, SHA3_384_BLOCK_SIZE, ctx->block,
ctx->index, length, data);
}
@@ -62,7 +62,7 @@ sha3_384_digest(struct sha3_384_ctx *ctx,
size_t length,
uint8_t *digest)
{
- _sha3_pad (&ctx->state, SHA3_384_DATA_SIZE, ctx->block, ctx->index);
+ _sha3_pad (&ctx->state, SHA3_384_BLOCK_SIZE, ctx->block, ctx->index);
_nettle_write_le64 (length, digest, ctx->state.a);
sha3_384_init (ctx);
}
diff --git a/sha3-512.c b/sha3-512.c
index 7a6de38b..145662b0 100644
--- a/sha3-512.c
+++ b/sha3-512.c
@@ -53,7 +53,7 @@ sha3_512_update (struct sha3_512_ctx *ctx,
size_t length,
const uint8_t *data)
{
- ctx->index = _sha3_update (&ctx->state, SHA3_512_DATA_SIZE, ctx->block,
+ ctx->index = _sha3_update (&ctx->state, SHA3_512_BLOCK_SIZE, ctx->block,
ctx->index, length, data);
}
@@ -62,7 +62,7 @@ sha3_512_digest(struct sha3_512_ctx *ctx,
size_t length,
uint8_t *digest)
{
- _sha3_pad (&ctx->state, SHA3_512_DATA_SIZE, ctx->block, ctx->index);
+ _sha3_pad (&ctx->state, SHA3_512_BLOCK_SIZE, ctx->block, ctx->index);
_nettle_write_le64 (length, digest, ctx->state.a);
sha3_512_init (ctx);
}
diff --git a/sha3.h b/sha3.h
index 897bbdd5..6435ad62 100644
--- a/sha3.h
+++ b/sha3.h
@@ -85,23 +85,28 @@ _sha3_pad (struct sha3_state *state,
size). */
#define SHA3_224_DIGEST_SIZE 28
-#define SHA3_224_DATA_SIZE 144
+#define SHA3_224_BLOCK_SIZE 144
#define SHA3_256_DIGEST_SIZE 32
-#define SHA3_256_DATA_SIZE 136
+#define SHA3_256_BLOCK_SIZE 136
#define SHA3_384_DIGEST_SIZE 48
-#define SHA3_384_DATA_SIZE 104
+#define SHA3_384_BLOCK_SIZE 104
#define SHA3_512_DIGEST_SIZE 64
-#define SHA3_512_DATA_SIZE 72
+#define SHA3_512_BLOCK_SIZE 72
+/* For backwards compatibility */
+#define SHA3_224_DATA_SIZE SHA3_224_BLOCK_SIZE
+#define SHA3_256_DATA_SIZE SHA3_256_BLOCK_SIZE
+#define SHA3_384_DATA_SIZE SHA3_384_BLOCK_SIZE
+#define SHA3_512_DATA_SIZE SHA3_512_BLOCK_SIZE
struct sha3_224_ctx
{
struct sha3_state state;
unsigned index;
- uint8_t block[SHA3_224_DATA_SIZE];
+ uint8_t block[SHA3_224_BLOCK_SIZE];
};
void
@@ -121,7 +126,7 @@ struct sha3_256_ctx
{
struct sha3_state state;
unsigned index;
- uint8_t block[SHA3_256_DATA_SIZE];
+ uint8_t block[SHA3_256_BLOCK_SIZE];
};
void
@@ -141,7 +146,7 @@ struct sha3_384_ctx
{
struct sha3_state state;
unsigned index;
- uint8_t block[SHA3_384_DATA_SIZE];
+ uint8_t block[SHA3_384_BLOCK_SIZE];
};
void
@@ -161,7 +166,7 @@ struct sha3_512_ctx
{
struct sha3_state state;
unsigned index;
- uint8_t block[SHA3_512_DATA_SIZE];
+ uint8_t block[SHA3_512_BLOCK_SIZE];
};
void
diff --git a/sha512-224-meta.c b/sha512-224-meta.c
index f86e5992..24c42bfc 100644
--- a/sha512-224-meta.c
+++ b/sha512-224-meta.c
@@ -41,7 +41,7 @@ const struct nettle_hash nettle_sha512_224 =
{
"sha512-224", sizeof(struct sha512_ctx),
SHA512_224_DIGEST_SIZE,
- SHA512_224_DATA_SIZE,
+ SHA512_224_BLOCK_SIZE,
(nettle_hash_init_func *) sha512_224_init,
(nettle_hash_update_func *) sha512_224_update,
(nettle_hash_digest_func *) sha512_224_digest
diff --git a/sha512-256-meta.c b/sha512-256-meta.c
index c1733a38..37d17c35 100644
--- a/sha512-256-meta.c
+++ b/sha512-256-meta.c
@@ -41,7 +41,7 @@ const struct nettle_hash nettle_sha512_256 =
{
"sha512-256", sizeof(struct sha512_ctx),
SHA512_256_DIGEST_SIZE,
- SHA512_256_DATA_SIZE,
+ SHA512_256_BLOCK_SIZE,
(nettle_hash_init_func *) sha512_256_init,
(nettle_hash_update_func *) sha512_256_update,
(nettle_hash_digest_func *) sha512_256_digest
diff --git a/sha512.c b/sha512.c
index e01658ce..249c4f05 100644
--- a/sha512.c
+++ b/sha512.c
@@ -172,8 +172,8 @@ sha512_write_digest(struct sha512_ctx *ctx,
/* This is slightly inefficient, as the numbers are converted to
big-endian format, and will be converted back by the compression
function. It's probably not worth the effort to fix this. */
- WRITE_UINT64(ctx->block + (SHA512_DATA_SIZE - 16), high);
- WRITE_UINT64(ctx->block + (SHA512_DATA_SIZE - 8), low);
+ WRITE_UINT64(ctx->block + (SHA512_BLOCK_SIZE - 16), high);
+ WRITE_UINT64(ctx->block + (SHA512_BLOCK_SIZE - 8), low);
COMPRESS(ctx, ctx->block);
words = length / 8;
diff --git a/umac-set-key.c b/umac-set-key.c
index fa4ca6b7..13a9589c 100644
--- a/umac-set-key.c
+++ b/umac-set-key.c
@@ -86,7 +86,7 @@ _umac_set_key (uint32_t *l1_key, uint32_t *l2_key,
aes128_set_encrypt_key (aes, key);
- size = UMAC_DATA_SIZE / 4 + 4*(n-1);
+ size = UMAC_BLOCK_SIZE / 4 + 4*(n-1);
umac_kdf (aes, 1, size * sizeof(uint32_t), (uint8_t *) l1_key);
BE_SWAP32_N (size, l1_key);
diff --git a/umac.h b/umac.h
index 7749353b..1136fcdc 100644
--- a/umac.h
+++ b/umac.h
@@ -74,11 +74,13 @@ extern "C" {
#define UMAC64_DIGEST_SIZE 8
#define UMAC96_DIGEST_SIZE 12
#define UMAC128_DIGEST_SIZE 16
-#define UMAC_DATA_SIZE 1024
+#define UMAC_BLOCK_SIZE 1024
+/* For backwards compatibility */
+#define UMAC_DATA_SIZE UMAC_BLOCK_SIZE
/* Subkeys and state for UMAC with tag size 32*n bits. */
#define _UMAC_STATE(n) \
- uint32_t l1_key[UMAC_DATA_SIZE/4 + 4*((n)-1)]; \
+ uint32_t l1_key[UMAC_BLOCK_SIZE/4 + 4*((n)-1)]; \
/* Keys in 32-bit pieces, high first */ \
uint32_t l2_key[6*(n)]; \
uint64_t l3_key1[8*(n)]; \
@@ -99,7 +101,7 @@ extern "C" {
unsigned index; \
/* Complete blocks processed */ \
uint64_t count; \
- uint8_t block[UMAC_DATA_SIZE]
+ uint8_t block[UMAC_BLOCK_SIZE]
#define _UMAC_NONCE_CACHED 0x80
diff --git a/umac128.c b/umac128.c
index 688f7519..d0c607e8 100644
--- a/umac128.c
+++ b/umac128.c
@@ -69,11 +69,11 @@ umac128_set_nonce (struct umac128_ctx *ctx,
#define UMAC128_BLOCK(ctx, block) do { \
uint64_t __umac128_y[4]; \
- _umac_nh_n (__umac128_y, 4, ctx->l1_key, UMAC_DATA_SIZE, block); \
- __umac128_y[0] += 8*UMAC_DATA_SIZE; \
- __umac128_y[1] += 8*UMAC_DATA_SIZE; \
- __umac128_y[2] += 8*UMAC_DATA_SIZE; \
- __umac128_y[3] += 8*UMAC_DATA_SIZE; \
+ _umac_nh_n (__umac128_y, 4, ctx->l1_key, UMAC_BLOCK_SIZE, block); \
+ __umac128_y[0] += 8*UMAC_BLOCK_SIZE; \
+ __umac128_y[1] += 8*UMAC_BLOCK_SIZE; \
+ __umac128_y[2] += 8*UMAC_BLOCK_SIZE; \
+ __umac128_y[3] += 8*UMAC_BLOCK_SIZE; \
_umac_l2 (ctx->l2_key, ctx->l2_state, 4, ctx->count++, __umac128_y); \
} while (0)
diff --git a/umac32.c b/umac32.c
index 427c500e..32f34c39 100644
--- a/umac32.c
+++ b/umac32.c
@@ -72,8 +72,8 @@ umac32_set_nonce (struct umac32_ctx *ctx,
#define UMAC32_BLOCK(ctx, block) do { \
uint64_t __umac32_y \
- = _umac_nh (ctx->l1_key, UMAC_DATA_SIZE, block) \
- + 8*UMAC_DATA_SIZE ; \
+ = _umac_nh (ctx->l1_key, UMAC_BLOCK_SIZE, block) \
+ + 8*UMAC_BLOCK_SIZE ; \
_umac_l2 (ctx->l2_key, ctx->l2_state, 1, ctx->count++, &__umac32_y); \
} while (0)
diff --git a/umac64.c b/umac64.c
index 179df9a0..a1122cb1 100644
--- a/umac64.c
+++ b/umac64.c
@@ -72,9 +72,9 @@ umac64_set_nonce (struct umac64_ctx *ctx,
#define UMAC64_BLOCK(ctx, block) do { \
uint64_t __umac64_y[2]; \
- _umac_nh_n (__umac64_y, 2, ctx->l1_key, UMAC_DATA_SIZE, block); \
- __umac64_y[0] += 8*UMAC_DATA_SIZE; \
- __umac64_y[1] += 8*UMAC_DATA_SIZE; \
+ _umac_nh_n (__umac64_y, 2, ctx->l1_key, UMAC_BLOCK_SIZE, block); \
+ __umac64_y[0] += 8*UMAC_BLOCK_SIZE; \
+ __umac64_y[1] += 8*UMAC_BLOCK_SIZE; \
_umac_l2 (ctx->l2_key, ctx->l2_state, 2, ctx->count++, __umac64_y); \
} while (0)
diff --git a/umac96.c b/umac96.c
index d4d9b88a..8d72f1bf 100644
--- a/umac96.c
+++ b/umac96.c
@@ -69,10 +69,10 @@ umac96_set_nonce (struct umac96_ctx *ctx,
#define UMAC96_BLOCK(ctx, block) do { \
uint64_t __umac96_y[3]; \
- _umac_nh_n (__umac96_y, 3, ctx->l1_key, UMAC_DATA_SIZE, block); \
- __umac96_y[0] += 8*UMAC_DATA_SIZE; \
- __umac96_y[1] += 8*UMAC_DATA_SIZE; \
- __umac96_y[2] += 8*UMAC_DATA_SIZE; \
+ _umac_nh_n (__umac96_y, 3, ctx->l1_key, UMAC_BLOCK_SIZE, block); \
+ __umac96_y[0] += 8*UMAC_BLOCK_SIZE; \
+ __umac96_y[1] += 8*UMAC_BLOCK_SIZE; \
+ __umac96_y[2] += 8*UMAC_BLOCK_SIZE; \
_umac_l2 (ctx->l2_key, ctx->l2_state, 3, ctx->count++, __umac96_y); \
} while (0)
--
GitLab