Fix some warnings in MD5 code

[bertos.git] / bertos / sec / hash / md5.c

diff --git a/bertos/sec/hash/md5.c b/bertos/sec/hash/md5.c
index f139cd6ee7ded0c235640a0073f634276af1b432..7d6812d50cb0a133dfd8f959c13e3dea8737453f 100644 (file)
--- a/bertos/sec/hash/md5.c
+++ b/bertos/sec/hash/md5.c
@@ -37,7 +37,7 @@ static void byteReverse(uint32_t *buf, unsigned longs)
 static void MD5_begin(Hash *h)
 {
        MD5_Context *ctx = (MD5_Context *)h;
-       
+
     ctx->buf[0] = 0x67452301;
     ctx->buf[1] = 0xefcdab89;
     ctx->buf[2] = 0x98badcfe;
@@ -54,6 +54,11 @@ static void MD5_update(Hash *h, const void* vbuf, size_t len)
 {
        MD5_Context *ctx = (MD5_Context *)h;
        const char *buf = (const char *)vbuf;
+       uint32_t *aligned_ptr = NULL;
+       if (is_aligned(ctx->in, sizeof(uint32_t)))
+               aligned_ptr = (uint32_t *)((size_t)ctx->in);
+       else
+               ASSERT2(0, "Unaligned memory");
     uint32_t t;
 
     /* Update bitcount */
@@ -71,8 +76,8 @@ static void MD5_update(Hash *h, const void* vbuf, size_t len)
             return;
         }
         memcpy(p, buf, t);
-        byteReverse((uint32_t*)ctx->in, 16);
-        MD5Transform(ctx->buf, (uint32_t*)ctx->in);
+       byteReverse(aligned_ptr, 16);
+       MD5Transform(ctx->buf, aligned_ptr);
         buf += t;
         len -= t;
     }
@@ -80,8 +85,8 @@ static void MD5_update(Hash *h, const void* vbuf, size_t len)
 
     while (len >= 64) {
         memcpy(ctx->in, buf, 64);
-        byteReverse((uint32_t*)ctx->in, 16);
-        MD5Transform(ctx->buf, (uint32_t*)ctx->in);
+        byteReverse(aligned_ptr, 16);
+        MD5Transform(ctx->buf, aligned_ptr);
         buf += 64;
         len -= 64;
     }
@@ -94,11 +99,16 @@ static void MD5_update(Hash *h, const void* vbuf, size_t len)
  * Final wrapup - pad to 64-byte boundary with the bit pattern
  * 1 0* (64-bit count of bits processed, MSB-first)
  */
-uint8_t* MD5_final(struct Hash *h)
+static uint8_t* MD5_final(struct Hash *h)
 {
        MD5_Context *ctx = (MD5_Context *)h;
     unsigned count;
     unsigned char *p;
+       uint32_t *aligned_ptr = NULL;
+       if (is_aligned(ctx->in, sizeof(uint32_t)))
+               aligned_ptr = (uint32_t *)((size_t)ctx->in);
+       else
+               ASSERT2(0, "Unaligned memory");
 
     /* Compute number of bytes mod 64 */
     count = (ctx->bits >> 3) & 0x3F;
@@ -115,8 +125,8 @@ uint8_t* MD5_final(struct Hash *h)
     if (count < 8) {
         /* Two lots of padding:  Pad the first block to 64 bytes */
         memset(p, 0, count);
-        byteReverse((uint32_t*)ctx->in, 16);
-        MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+        byteReverse(aligned_ptr, 16);
+        MD5Transform(ctx->buf, aligned_ptr);
 
         /* Now fill the next block with 56 bytes */
         memset(ctx->in, 0, 56);
@@ -124,19 +134,19 @@ uint8_t* MD5_final(struct Hash *h)
         /* Pad block to 56 bytes */
         memset(p, 0, count - 8);
     }
-    byteReverse((uint32_t*)ctx->in, 14);
+    byteReverse(aligned_ptr, 14);
 
     /* Append length in bits and transform */
-    ((uint32_t*) ctx->in)[14] = (uint32_t)ctx->bits;
-    ((uint32_t*) ctx->in)[15] = (uint32_t)(ctx->bits >> 32);
+    aligned_ptr[14] = (uint32_t)ctx->bits;
+    aligned_ptr[15] = (uint32_t)(ctx->bits >> 32);
 
-    MD5Transform(ctx->buf, (uint32_t *) ctx->in);
+    MD5Transform(ctx->buf, aligned_ptr);
     byteReverse((uint32_t*)ctx->buf, 4);
 
        PURGE(ctx->in);
        PURGE(ctx->bits);
 
-       return ctx->buf;
+       return (uint8_t *)ctx->buf;
 }