Mostly aesthetic changes to CMAC.

diff --git a/ChangeLog b/ChangeLog
index b443e47cf7b1daec5de334e0f77ae7f5f2b6cb79..7700a14c82c90e016825da354be44109695a9cef 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,4 +1,16 @@
-2018-02-19    Nikos Mavrogiannopoulos  <nmav@redhat.com>
+2018-02-19  Niels Möller  <nisse@lysator.liu.se>
+
+       Mostly aesthetic changes. Besides indentation:
+       * cmac.h (struct cmac128): Rename, to cmac128_ctx.
+       (CMAC128_CTX): Rename first member from data to ctx.
+
+       * cmac.c: Use const void * as the type for cipher arguments.
+       (block_mulx): Un-inline.
+       (cmac128_set_key): Make a constant function local.
+
+       * testsuite/cmac-test.c: Delete local typedefs.
+
+2018-02-19  Nikos Mavrogiannopoulos  <nmav@redhat.com>
 
        Add support for CMAC.
        * cmac.h: New file.

diff --git a/cmac.c b/cmac.c
index eb7b2cf5f61d75bb6981037e022617bf24c847fd..d08bd8325b16ee3c2f24699855d0661150a63c5a 100644 (file)
--- a/cmac.c
+++ b/cmac.c
@@ -46,13 +46,8 @@
 #include "nettle-internal.h"
 #include "macros.h"
 
-static const uint8_t const_zero[] = {
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
-  0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00
-};
-
 /* shift one and XOR with 0x87. */
-static inline void
+static void
 block_mulx(union nettle_block16 *dst,
           const union nettle_block16 *src)
 {
@@ -70,9 +65,13 @@ block_mulx(union nettle_block16 *dst,
 }
 
 void
-cmac128_set_key(struct cmac128 *ctx, void *cipher,
+cmac128_set_key(struct cmac128_ctx *ctx, const void *cipher,
                nettle_cipher_func *encrypt)
 {
+  static const uint8_t const_zero[] = {
+    0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00,  0x00, 0x00, 0x00, 0x00
+  };
   union nettle_block16 *L = &ctx->block;
   memset(ctx, 0, sizeof(*ctx));
 
@@ -86,7 +85,7 @@ cmac128_set_key(struct cmac128 *ctx, void *cipher,
 #define MIN(x,y) ((x)<(y)?(x):(y))
 
 void
-cmac128_update(struct cmac128 *ctx, void *cipher,
+cmac128_update(struct cmac128_ctx *ctx, const void *cipher,
               nettle_cipher_func *encrypt,
               size_t msg_len, const uint8_t *msg)
 {
@@ -131,7 +130,7 @@ cmac128_update(struct cmac128 *ctx, void *cipher,
 }
 
 void
-cmac128_digest(struct cmac128 *ctx, void *cipher,
+cmac128_digest(struct cmac128_ctx *ctx, const void *cipher,
               nettle_cipher_func *encrypt,
               unsigned length,
               uint8_t *dst)

diff --git a/cmac.h b/cmac.h
index 30b8c002c3cb2aa771a1d9f8956fbd6ad0fc72a3..6d107982273e65cff175a4f578c37d9a5c0134e3 100644 (file)
--- a/cmac.h
+++ b/cmac.h
@@ -55,52 +55,55 @@ extern "C" {
 #define cmac_aes256_update nettle_cmac_aes256_update
 #define cmac_aes256_digest nettle_cmac_aes256_digest
 
-struct cmac128
+struct cmac128_ctx
 {
+  /* Key */
   union nettle_block16 K1;
   union nettle_block16 K2;
 
+  /* MAC state */
   union nettle_block16 X;
 
+  /* Block buffer */
   union nettle_block16 block;
   size_t index;
 };
 
 void
-cmac128_set_key(struct cmac128 *ctx, void *cipher,
+cmac128_set_key(struct cmac128_ctx *ctx, const void *cipher,
                nettle_cipher_func *encrypt);
 void
-cmac128_update(struct cmac128 *ctx, void *cipher,
+cmac128_update(struct cmac128_ctx *ctx, const void *cipher,
               nettle_cipher_func *encrypt,
               size_t msg_len, const uint8_t *msg);
 void
-cmac128_digest(struct cmac128 *ctx, void *cipher,
+cmac128_digest(struct cmac128_ctx *ctx, const void *cipher,
               nettle_cipher_func *encrypt,
               unsigned length,
-              uint8_t *out);
+              uint8_t *digest);
 
 
 #define CMAC128_CTX(type) \
-  { struct cmac128 data; type cipher; }
+  { struct cmac128_ctx ctx; type cipher; }
 
 /* NOTE: Avoid using NULL, as we don't include anything defining it. */
-#define CMAC128_SET_KEY(ctx, set_key, encrypt, cmac_key)       \
+#define CMAC128_SET_KEY(self, set_key, encrypt, cmac_key)      \
   do {                                                         \
-    (set_key)(&(ctx)->cipher, (cmac_key));                     \
-    if (0) (encrypt)(&(ctx)->cipher, ~(size_t) 0,              \
+    (set_key)(&(self)->cipher, (cmac_key));                    \
+    if (0) (encrypt)(&(self)->cipher, ~(size_t) 0,             \
                     (uint8_t *) 0, (const uint8_t *) 0);       \
-    cmac128_set_key(&(ctx)->data, &(ctx)->cipher,              \
+    cmac128_set_key(&(self)->ctx, &(self)->cipher,             \
                (nettle_cipher_func *) (encrypt));              \
   } while (0)
 
-#define CMAC128_UPDATE(ctx, encrypt, length, src)              \
-  cmac128_update(&(ctx)->data, &(ctx)->cipher,                 \
+#define CMAC128_UPDATE(self, encrypt, length, src)             \
+  cmac128_update(&(self)->ctx, &(self)->cipher,                        \
              (nettle_cipher_func *)encrypt, (length), (src))
 
-#define CMAC128_DIGEST(ctx, encrypt, length, digest)           \
-  (0 ? (encrypt)(&(ctx)->cipher, ~(size_t) 0,                  \
+#define CMAC128_DIGEST(self, encrypt, length, digest)          \
+  (0 ? (encrypt)(&(self)->cipher, ~(size_t) 0,                 \
                 (uint8_t *) 0, (const uint8_t *) 0)            \
-     : cmac128_digest(&(ctx)->data, &(ctx)->cipher,            \
+     : cmac128_digest(&(self)->ctx, &(self)->cipher,           \
                  (nettle_cipher_func *) (encrypt),             \
                  (length), (digest)))
 

diff --git a/testsuite/cmac-test.c b/testsuite/cmac-test.c
index 7208e8326f6b2fa8c600592a0c3285672af4eff2..1d351deb85c7fae57106d44e0d825a8a045b7459 100644 (file)
--- a/testsuite/cmac-test.c
+++ b/testsuite/cmac-test.c
@@ -2,23 +2,24 @@
 #include "nettle-internal.h"
 #include "cmac.h"
 
-typedef void set_key_func(void *ctx, const uint8_t *key);
-typedef void update_func(void *ctx, size_t length, const uint8_t *data);
-typedef void digest_func(void *ctx, size_t length, uint8_t *digest);
-
-#define test_cmac_aes128(key, msg, ref) \
-       test_cmac_hash ((set_key_func*)cmac_aes128_set_key, (update_func*)cmac_aes128_update, \
-                       (digest_func*)cmac_aes128_digest, sizeof(struct cmac_aes128_ctx), \
-                       key, msg, ref)
-
-#define test_cmac_aes256(key, msg, ref) \
-       test_cmac_hash ((set_key_func*)cmac_aes256_set_key, (update_func*)cmac_aes256_update, \
-                       (digest_func*)cmac_aes256_digest, sizeof(struct cmac_aes256_ctx), \
-                       key, msg, ref)
+#define test_cmac_aes128(key, msg, ref)                                        \
+  test_cmac_hash ((nettle_set_key_func*) cmac_aes128_set_key,          \
+                 (nettle_hash_update_func*) cmac_aes128_update,        \
+                 (nettle_hash_digest_func*) cmac_aes128_digest,        \
+                 sizeof(struct cmac_aes128_ctx),                       \
+                 key, msg, ref)
+
+#define test_cmac_aes256(key, msg, ref)                                        \
+  test_cmac_hash ((nettle_set_key_func*) cmac_aes256_set_key,          \
+                 (nettle_hash_update_func*) cmac_aes256_update,        \
+                 (nettle_hash_digest_func*) cmac_aes256_digest,        \
+                 sizeof(struct cmac_aes256_ctx),                       \
+                 key, msg, ref)
 
 static void
-test_cmac_hash (set_key_func *set_key, update_func *update,
-               digest_func *digest, size_t ctx_size,
+test_cmac_hash (nettle_set_key_func *set_key,
+               nettle_hash_update_func *update,
+               nettle_hash_digest_func *digest, size_t ctx_size,
                const struct tstring *key, const struct tstring *msg,
                const struct tstring *ref)
 {