X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=bertos%2Fsec%2Fhash%2Fmd5.c;h=e4d2c135be86e48bb07fd97cb6d59cbfa712fe00;hb=0fea731d20c6106133186f4771efaaaf036c8321;hp=306bacc029da9aa2fd84b1dadb71bced17d0b263;hpb=5e615954460b48f828c99e03166687f0a91668dc;p=bertos.git

diff --git a/bertos/sec/hash/md5.c b/bertos/sec/hash/md5.c
index 306bacc0..e4d2c135 100644
--- a/bertos/sec/hash/md5.c
+++ b/bertos/sec/hash/md5.c
@@ -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 */
@@ -62,26 +67,29 @@ static void MD5_update(Hash *h, const void* vbuf, size_t len)
 
     /* Handle any leading odd-sized chunks */
 
-    if (t) {
+    if (t)
+	{
         uint8_t *p = (uint8_t*) ctx->in + t;
 
         t = 64 - t;
-        if (len < t) {
+        if (len < t)
+		{
             memcpy(p, buf, 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;
     }
     /* Process data in 64-byte chunks */
 
-    while (len >= 64) {
+    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;
     }
@@ -99,6 +107,11 @@ 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;
@@ -112,25 +125,29 @@ static uint8_t* MD5_final(struct Hash *h)
     count = 64 - 1 - count;
 
     /* Pad out to 56 mod 64 */
-    if (count < 8) {
+    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);
-    } else {
+    }
+	else
+	{
         /* 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);