cmac+hash: change parameter types

For consistency and safety, change the CMC and HSH functions to accept
signed lengths and handle negative values as errors. Also, change the
input data type to void * to not require casting in the caller.

diff --git a/cmac.h b/cmac.h
index 206edc1fab53c673a757896e77e6637571a50e0b..935820d805f3acb069596c190827c25bf006814a 100644 (file)
--- a/cmac.h
+++ b/cmac.h
@@ -37,11 +37,11 @@ typedef enum {
 
 typedef struct CMC_Instance_Record *CMC_Instance;
 
-extern unsigned int CMC_GetKeyLength(CMC_Algorithm algorithm);
+extern int CMC_GetKeyLength(CMC_Algorithm algorithm);
 extern CMC_Instance CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key,
-                                       unsigned int length);
-extern unsigned int CMC_Hash(CMC_Instance inst, const unsigned char *in, unsigned int in_len,
-                             unsigned char *out, unsigned int out_len);
+                                       int length);
+extern int CMC_Hash(CMC_Instance inst, const void *in, int in_len,
+                    unsigned char *out, int out_len);
 extern void CMC_DestroyInstance(CMC_Instance inst);
 
 #endif

diff --git a/cmac_nettle.c b/cmac_nettle.c
index 239d006a466b5f783729f39eb105fd5a8e86b054..5b2c0d4cea9df8f37404899a93ca6824daee57d1 100644 (file)
--- a/cmac_nettle.c
+++ b/cmac_nettle.c
@@ -44,7 +44,7 @@ struct CMC_Instance_Record {
 
 /* ================================================== */
 
-unsigned int
+int
 CMC_GetKeyLength(CMC_Algorithm algorithm)
 {
   if (algorithm == CMC_AES128)
@@ -57,11 +57,11 @@ CMC_GetKeyLength(CMC_Algorithm algorithm)
 /* ================================================== */
 
 CMC_Instance
-CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key, unsigned int length)
+CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key, int length)
 {
   CMC_Instance inst;
 
-  if (length == 0 || length != CMC_GetKeyLength(algorithm))
+  if (length <= 0 || length != CMC_GetKeyLength(algorithm))
     return NULL;
 
   inst = MallocNew(struct CMC_Instance_Record);
@@ -83,10 +83,12 @@ CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key, unsigned i
 
 /* ================================================== */
 
-unsigned int
-CMC_Hash(CMC_Instance inst, const unsigned char *in, unsigned int in_len,
-         unsigned char *out, unsigned int out_len)
+int
+CMC_Hash(CMC_Instance inst, const void *in, int in_len, unsigned char *out, int out_len)
 {
+  if (in_len < 0 || out_len < 0)
+    return 0;
+
   if (out_len > CMAC128_DIGEST_SIZE)
     out_len = CMAC128_DIGEST_SIZE;
 

diff --git a/hash.h b/hash.h
index 12167bc002acaf0a2ffb732ea5eb84511c5c87eb..290710f4c500b50a5315e14b329d6aedc31a47f3 100644 (file)
--- a/hash.h
+++ b/hash.h
@@ -48,10 +48,8 @@ typedef enum {
 
 extern int HSH_GetHashId(HSH_Algorithm algorithm);
 
-extern unsigned int HSH_Hash(int id,
-    const unsigned char *in1, unsigned int in1_len,
-    const unsigned char *in2, unsigned int in2_len,
-    unsigned char *out, unsigned int out_len);
+extern int HSH_Hash(int id, const void *in1, int in1_len, const void *in2, int in2_len,
+                    unsigned char *out, int out_len);
 
 extern void HSH_Finalise(void);
 

diff --git a/hash_intmd5.c b/hash_intmd5.c
index 5a0debfe66feff1265c06a6772c0bfc8d0b700bf..4d101ea721c1887975799f6ed78ae0843029bb25 100644 (file)
--- a/hash_intmd5.c
+++ b/hash_intmd5.c
@@ -45,11 +45,13 @@ HSH_GetHashId(HSH_Algorithm algorithm)
   return 0;
 }
 
-unsigned int
-HSH_Hash(int id, const unsigned char *in1, unsigned int in1_len,
-    const unsigned char *in2, unsigned int in2_len,
-    unsigned char *out, unsigned int out_len)
+int
+HSH_Hash(int id, const void *in1, int in1_len, const void *in2, int in2_len,
+         unsigned char *out, int out_len)
 {
+  if (in1_len < 0 || in2_len < 0 || out_len < 0)
+    return 0;
+
   MD5Init(&ctx);
   MD5Update(&ctx, in1, in1_len);
   if (in2)

diff --git a/hash_nettle.c b/hash_nettle.c
index 66fbe755a4deeb38270eabdb9c24d6d401e460fc..dba17171f7134faf5526aa0ac98fee7a0300186b 100644 (file)
--- a/hash_nettle.c
+++ b/hash_nettle.c
@@ -84,14 +84,16 @@ HSH_GetHashId(HSH_Algorithm algorithm)
   return id;
 }
 
-unsigned int
-HSH_Hash(int id, const unsigned char *in1, unsigned int in1_len,
-         const unsigned char *in2, unsigned int in2_len,
-         unsigned char *out, unsigned int out_len)
+int
+HSH_Hash(int id, const void *in1, int in1_len, const void *in2, int in2_len,
+         unsigned char *out, int out_len)
 {
   const struct nettle_hash *hash;
   void *context;
 
+  if (in1_len < 0 || in2_len < 0 || out_len < 0)
+    return 0;
+
   hash = hashes[id].nettle_hash;
   context = hashes[id].context;
 

diff --git a/hash_nss.c b/hash_nss.c
index 81345c22d22e8218df201b4cf24dcb1890e61268..fe26627781663d0755ffcc697402566b6e70e960 100644 (file)
--- a/hash_nss.c
+++ b/hash_nss.c
@@ -74,14 +74,16 @@ HSH_GetHashId(HSH_Algorithm algorithm)
   return i;
 }
 
-unsigned int
-HSH_Hash(int id, const unsigned char *in1, unsigned int in1_len,
-    const unsigned char *in2, unsigned int in2_len,
-    unsigned char *out, unsigned int out_len)
+int
+HSH_Hash(int id, const void *in1, int in1_len, const void *in2, int in2_len,
+         unsigned char *out, int out_len)
 {
   unsigned char buf[MAX_HASH_LENGTH];
   unsigned int ret = 0;
 
+  if (in1_len < 0 || in2_len < 0 || out_len < 0)
+    return 0;
+
   NSSLOWHASH_Begin(hashes[id].context);
   NSSLOWHASH_Update(hashes[id].context, in1, in1_len);
   if (in2)

diff --git a/hash_tomcrypt.c b/hash_tomcrypt.c
index 5da09b27039c8e1632e2aba3991211fab1822c4f..5d126ca215565dc1836a4c37c9869c72860e1e31 100644 (file)
--- a/hash_tomcrypt.c
+++ b/hash_tomcrypt.c
@@ -89,15 +89,17 @@ HSH_GetHashId(HSH_Algorithm algorithm)
   return find_hash(hashes[i].int_name);
 }
 
-unsigned int
-HSH_Hash(int id, const unsigned char *in1, unsigned int in1_len,
-    const unsigned char *in2, unsigned int in2_len,
-    unsigned char *out, unsigned int out_len)
+int
+HSH_Hash(int id, const void *in1, int in1_len, const void *in2, int in2_len,
+         unsigned char *out, int out_len)
 {
   unsigned char buf[MAX_HASH_LENGTH];
   unsigned long len;
   int r;
 
+  if (in1_len < 0 || in2_len < 0 || out_len < 0)
+    return 0;
+
   len = sizeof (buf);
   if (in2)
     r = hash_memory_multi(id, buf, &len,

diff --git a/keys.c b/keys.c
index a08af973e716fd29229a6b8706dc69517d8dff42..69d7f89c15534643a3d70a37a89002ee65929ba9 100644 (file)
--- a/keys.c
+++ b/keys.c
@@ -376,8 +376,7 @@ KEY_GetKeyInfo(uint32_t key_id, int *type, int *bits)
 /* ================================================== */
 
 static int
-generate_auth(Key *key, const unsigned char *data, int data_len,
-              unsigned char *auth, int auth_len)
+generate_auth(Key *key, const void *data, int data_len, unsigned char *auth, int auth_len)
 {
   switch (key->class) {
     case NTP_MAC:
@@ -393,7 +392,7 @@ generate_auth(Key *key, const unsigned char *data, int data_len,
 /* ================================================== */
 
 static int
-check_auth(Key *key, const unsigned char *data, int data_len,
+check_auth(Key *key, const void *data, int data_len,
            const unsigned char *auth, int auth_len, int trunc_len)
 {
   unsigned char buf[MAX_HASH_LENGTH];
@@ -407,7 +406,7 @@ check_auth(Key *key, const unsigned char *data, int data_len,
 /* ================================================== */
 
 int
-KEY_GenerateAuth(uint32_t key_id, const unsigned char *data, int data_len,
+KEY_GenerateAuth(uint32_t key_id, const void *data, int data_len,
                  unsigned char *auth, int auth_len)
 {
   Key *key;
@@ -423,7 +422,7 @@ KEY_GenerateAuth(uint32_t key_id, const unsigned char *data, int data_len,
 /* ================================================== */
 
 int
-KEY_CheckAuth(uint32_t key_id, const unsigned char *data, int data_len,
+KEY_CheckAuth(uint32_t key_id, const void *data, int data_len,
               const unsigned char *auth, int auth_len, int trunc_len)
 {
   Key *key;

diff --git a/keys.h b/keys.h
index 706459071ee39cfce13d7e55fa05b6261c941f82..c89fea915043459cecd15bc46d8917bc8c0c2fe9 100644 (file)
--- a/keys.h
+++ b/keys.h
@@ -39,9 +39,9 @@ extern int KEY_GetAuthLength(uint32_t key_id);
 extern int KEY_CheckKeyLength(uint32_t key_id);
 extern int KEY_GetKeyInfo(uint32_t key_id, int *type, int *bits);
 
-extern int KEY_GenerateAuth(uint32_t key_id, const unsigned char *data,
-    int data_len, unsigned char *auth, int auth_len);
-extern int KEY_CheckAuth(uint32_t key_id, const unsigned char *data, int data_len,
+extern int KEY_GenerateAuth(uint32_t key_id, const void *data, int data_len,
+                            unsigned char *auth, int auth_len);
+extern int KEY_CheckAuth(uint32_t key_id, const void *data, int data_len,
                          const unsigned char *auth, int auth_len, int trunc_len);
 
 #endif /* GOT_KEYS_H */

diff --git a/ntp_auth.c b/ntp_auth.c
index f7c31c4f270fe2cd39b4e42fbff66aa1a0266eec..c7f61d1aba7ea8e115d4a7e6c353779acf8923b5 100644 (file)
--- a/ntp_auth.c
+++ b/ntp_auth.c
@@ -60,7 +60,7 @@ generate_symmetric_auth(uint32_t key_id, NTP_Packet *packet, NTP_PacketInfo *inf
   max_auth_len = (info->version == 4 ? NTP_MAX_V4_MAC_LENGTH : NTP_MAX_MAC_LENGTH) - 4;
   max_auth_len = MIN(max_auth_len, sizeof (NTP_Packet) - info->length - 4);
 
-  auth_len = KEY_GenerateAuth(key_id, (unsigned char *)packet, info->length,
+  auth_len = KEY_GenerateAuth(key_id, packet, info->length,
                               (unsigned char *)packet + info->length + 4, max_auth_len);
   if (!auth_len) {
     DEBUG_LOG("Could not generate auth data with key %"PRIu32, key_id);
@@ -86,7 +86,7 @@ check_symmetric_auth(NTP_Packet *packet, NTP_PacketInfo *info)
   trunc_len = info->version == 4 && info->auth.mac.length <= NTP_MAX_V4_MAC_LENGTH ?
               NTP_MAX_V4_MAC_LENGTH : NTP_MAX_MAC_LENGTH;
 
-  if (!KEY_CheckAuth(info->auth.mac.key_id, (void *)packet, info->auth.mac.start,
+  if (!KEY_CheckAuth(info->auth.mac.key_id, packet, info->auth.mac.start,
                      (unsigned char *)packet + info->auth.mac.start + 4,
                      info->auth.mac.length - 4, trunc_len - 4))
     return 0;

diff --git a/stubs.c b/stubs.c
index 73b9a95ea983a39b0383e7809293532cc4f797ef..43e6e3f200cbeb5d769883df5da0e5dfc77ed099 100644 (file)
--- a/stubs.c
+++ b/stubs.c
@@ -438,21 +438,20 @@ NSD_SignAndSendPacket(uint32_t key_id, NTP_Packet *packet, NTP_PacketInfo *info,
 
 #ifndef HAVE_CMAC
 
-unsigned int
+int
 CMC_GetKeyLength(CMC_Algorithm algorithm)
 {
   return 0;
 }
 
 CMC_Instance
-CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key, unsigned int length)
+CMC_CreateInstance(CMC_Algorithm algorithm, const unsigned char *key, int length)
 {
   return NULL;
 }
 
-unsigned int
-CMC_Hash(CMC_Instance inst, const unsigned char *in, unsigned int in_len,
-         unsigned char *out, unsigned int out_len)
+int
+CMC_Hash(CMC_Instance inst, const void *in, int in_len, unsigned char *out, int out_len)
 {
   return 0;
 }

diff --git a/test/unit/cmac.c b/test/unit/cmac.c
index 07fc3d565e4643606debcc14a303833e33570bc6..be4ffbbe41de7c0acde31a64c2d888cd29c8bb97 100644 (file)
--- a/test/unit/cmac.c
+++ b/test/unit/cmac.c
@@ -31,9 +31,9 @@
 struct cmac_test {
   const char *name;
   const unsigned char key[MAX_KEY_LENGTH];
-  unsigned int key_length;
+  int key_length;
   const unsigned char hash[MAX_HASH_LENGTH];
-  unsigned int hash_length;
+  int hash_length;
 };
 
 void
@@ -52,8 +52,7 @@ test_unit(void)
 
   CMC_Algorithm algorithm;
   CMC_Instance inst;
-  unsigned int length;
-  int i, j;
+  int i, j, length;
 
 #ifndef HAVE_CMAC
   TEST_REQUIRE(0);
@@ -68,7 +67,7 @@ test_unit(void)
 
     DEBUG_LOG("testing %s", tests[i].name);
 
-    for (j = 0; j <= 128; j++) {
+    for (j = -1; j <= 128; j++) {
       if (j == tests[i].key_length)
         continue;
       TEST_CHECK(!CMC_CreateInstance(algorithm, tests[i].key, j));
@@ -79,6 +78,9 @@ test_unit(void)
 
     TEST_CHECK(!CMC_CreateInstance(0, tests[i].key, tests[i].key_length));
 
+    TEST_CHECK(CMC_Hash(inst, data, -1, hash, sizeof (hash)) == 0);
+    TEST_CHECK(CMC_Hash(inst, data, sizeof (data) - 1, hash, -1) == 0);
+
     for (j = 0; j <= sizeof (hash); j++) {
       memset(hash, 0, sizeof (hash));
       length = CMC_Hash(inst, data, sizeof (data) - 1, hash, j);

diff --git a/test/unit/hash.c b/test/unit/hash.c
index 331dcac77c79007f0d9bab2189dc69f811285db0..d57c915ddf05494e8f7dfb2e9e78442b0c56dd7d 100644 (file)
--- a/test/unit/hash.c
+++ b/test/unit/hash.c
@@ -28,7 +28,7 @@
 struct hash_test {
   const char *name;
   const unsigned char out[MAX_HASH_LENGTH];
-  unsigned int length;
+  int length;
 };
 
 void
@@ -71,8 +71,7 @@ test_unit(void)
   };
 
   HSH_Algorithm algorithm;
-  unsigned int length;
-  int i, j, hash_id;
+  int i, j, hash_id, length;
 
   TEST_CHECK(HSH_INVALID == 0);
 
@@ -93,6 +92,10 @@ test_unit(void)
 
     DEBUG_LOG("testing %s", tests[i].name);
 
+    TEST_CHECK(HSH_Hash(hash_id, data1, -1, NULL, 0, out, sizeof (out)) == 0);
+    TEST_CHECK(HSH_Hash(hash_id, data1, sizeof (data1) - 1, data2, -1, out, sizeof (out)) == 0);
+    TEST_CHECK(HSH_Hash(hash_id, data1, sizeof (data1) - 1, NULL, 0, out, -1) == 0);
+
     for (j = 0; j <= sizeof (out); j++) {
       TEST_CHECK(HSH_GetHashId(algorithm) == hash_id);
       TEST_CHECK(HSH_GetHashId(0) < 0);