Index: src/OFMD5Hash.h
==================================================================
--- src/OFMD5Hash.h
+++ src/OFMD5Hash.h
@@ -23,13 +23,16 @@
  */
 @interface OFMD5Hash: OFHash
 {
 	uint32_t buf[4];
 	uint32_t bits[2];
-	uint8_t	 in[64];
+	union {
+		uint8_t	u8[64];
+		uint32_t u32[16];
+	} in;
 }
 
 /**
  * \return A new autoreleased MD5 Hash
  */
 + MD5Hash;
 @end

Index: src/OFMD5Hash.m
==================================================================
--- src/OFMD5Hash.m
+++ src/OFMD5Hash.m
@@ -165,39 +165,39 @@
 	/* Bytes already in shsInfo->data */
 	t = (t >> 3) & 0x3F;
 
 	/* Handle any leading odd-sized chunks */
 	if (t) {
-		uint8_t *p = in + t;
+		uint8_t *p = in.u8 + t;
 
 		t = 64 - t;
 
 		if (size < t) {
 			memcpy(p, buffer, size);
 			return;
 		}
 
 		memcpy(p, buffer, t);
-		of_bswap32_vec_if_be((uint32_t*)in, 16);
-		md5_transform(buf, (uint32_t*)in);
+		of_bswap32_vec_if_be(in.u32, 16);
+		md5_transform(buf, in.u32);
 
 		buffer += t;
 		size -= t;
 	}
 
 	/* Process data in 64-byte chunks */
 	while (size >= 64) {
-		memcpy(in, buffer, 64);
-		of_bswap32_vec_if_be((uint32_t*)in, 16);
-		md5_transform(buf, (uint32_t*)in);
+		memcpy(in.u8, buffer, 64);
+		of_bswap32_vec_if_be(in.u32, 16);
+		md5_transform(buf, in.u32);
 
 		buffer += 64;
 		size -= 64;
 	}
 
 	/* Handle any remaining bytes of data. */
-	memcpy(in, buffer, size);
+	memcpy(in.u8, buffer, size);
 }
 
 - (uint8_t*)digest
 {
 	uint8_t	*p;
@@ -211,38 +211,38 @@
 
 	/*
 	 * Set the first char of padding to 0x80. This is safe since there is
 	 * always at least one byte free
 	 */
-	p = in + count;
+	p = in.u8 + count;
 	*p++ = 0x80;
 
 	/* Bytes of padding needed to make 64 bytes */
 	count = 64 - 1 - count;
 
 	/* Pad out to 56 mod 64 */
 	if (count < 8) {
 		/* Two lots of padding: Pad the first block to 64 bytes */
 		memset(p, 0, count);
-		of_bswap32_vec_if_be((uint32_t*)in, 16);
-		md5_transform(buf, (uint32_t*)in);
+		of_bswap32_vec_if_be(in.u32, 16);
+		md5_transform(buf, in.u32);
 
 		/* Now fill the next block with 56 bytes */
-		memset(in, 0, 56);
+		memset(in.u8, 0, 56);
 	} else {
 		/* Pad block to 56 bytes */
 		memset(p, 0, count - 8);
 	}
-	of_bswap32_vec_if_be((uint32_t*)in, 14);
+	of_bswap32_vec_if_be(in.u32, 14);
 
 	/* Append length in bits and transform */
-	((uint32_t*)in)[14] = bits[0];
-	((uint32_t*)in)[15] = bits[1];
+	in.u32[14] = bits[0];
+	in.u32[15] = bits[1];
 
-	md5_transform(buf, (uint32_t*)in);
+	md5_transform(buf, in.u32);
 	of_bswap32_vec_if_be(buf, 4);
 
 	isCalculated = YES;
 
 	return (uint8_t*)buf;
 }
 @end

Index: src/OFSHA1Hash.m
==================================================================
--- src/OFSHA1Hash.m
+++ src/OFSHA1Hash.m
@@ -23,19 +23,19 @@
 #import "macros.h"
 
 /* blk0() and blk() perform the initial expand. */
 #ifndef OF_BIG_ENDIAN
 #define blk0(i)							\
-	(block->l[i] = (OF_ROL(block->l[i], 24) & 0xFF00FF00) |	\
-	    (OF_ROL(block->l[i], 8) & 0x00FF00FF))
+	(block.l[i] = (OF_ROL(block.l[i], 24) & 0xFF00FF00) |	\
+	    (OF_ROL(block.l[i], 8) & 0x00FF00FF))
 #else
-#define blk0(i) block->l[i]
+#define blk0(i) block.l[i]
 #endif
 #define blk(i) \
-	(block->l[i & 15] = OF_ROL(block->l[(i + 13) & 15] ^	\
-	    block->l[(i + 8) & 15] ^ block->l[(i + 2) & 15] ^	\
-	    block->l[i & 15], 1))
+	(block.l[i & 15] = OF_ROL(block.l[(i + 13) & 15] ^	\
+	    block.l[(i + 8) & 15] ^ block.l[(i + 2) & 15] ^	\
+	    block.l[i & 15], 1))
 
 /* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
 #define R0(v, w, x, y, z, i)						\
 	z += ((w & (x ^ y)) ^ y) + blk0(i) + 0x5A827999 + OF_ROL(v, 5);	\
 	w = OF_ROL(w, 30);
@@ -59,15 +59,13 @@
 
 static inline void
 sha1_transform(uint32_t state[5], const char buffer[64])
 {
 	uint32_t      a, b, c, d, e;
-	char	      workspace[64];
-	sha1_c64l16_t *block;
+	sha1_c64l16_t block;
 
-	block = (sha1_c64l16_t*)workspace;
-	memcpy(block, buffer, 64);
+	memcpy(block.c, buffer, 64);
 
 	/* Copy state[] to working vars */
 	a = state[0];
 	b = state[1];
 	c = state[2];