Rename *_DATA_SIZE to *_BLOCK_SIZE.

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)