md5 working

1 files changed, 82 insertions, 26 deletions

diff --git a/src/md5/main.c b/src/md5/main.c
index 81ca6ff..d389b60 100644
--- a/src/md5/main.c
+++ b/src/md5/main.c
@@ -6,7 +6,7 @@
 /*   By: cacharle <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2020/02/22 07:20:07 by cacharle          #+#    #+#             */
-/*   Updated: 2020/07/27 17:04:37 by charles          ###   ########.fr       */
+/*   Updated: 2020/08/01 13:50:41 by charles          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -48,7 +48,21 @@ uint32_t	leftrotate(uint32_t x, int s)
 	return (x << s) | (x >> (32 - s));
 }
 
-char	*message_digest_md5(uint8_t *msg, size_t size)
+/*
+** | bits | bytes |
+** |------|-------|
+** | 8    | 1     |
+** | 16   | 2     |
+** | 32   | 4     |
+** | 64   | 8     |
+** | 128  | 16    |
+** | 256  | 32    |
+** | 512  | 64    |
+**
+** | 448  | 56    |
+*/
+
+char	*message_digest_md5(uint8_t *msg, uint64_t size)
 {
 	// padding on 512 bit (64 bytes)
 	// format:
@@ -57,32 +71,34 @@ char	*message_digest_md5(uint8_t *msg, size_t size)
 	// 64 bit repr of the original len modulo 2^64 (ULONG_MAX)
 
 
-	uint8_t	*tmp;
-
-	tmp = msg;
+	// at least 1 byte for 1 bit + 8 bytes for 64bit size
+	uint64_t	pad_size = (64 - (size + 8) % 64) + 8;
 
+	/* printf("%lu\n", size % 64); */
+	/* printf("%lu\n", 64 - size % 64); */
+	printf("%lu + %lu = %lu byte\n", size, pad_size, size + pad_size);
 
-	size_t	pad_size = 32 - size % 32;
-
-	/* printf("%lu\n", size % 32); */
-	/* printf("%lu\n", 32 - size % 32); */
-	/* printf("%lu\n", pad_size); */
-
-	msg = malloc(size + pad_size);
+	uint8_t	*tmp;
+	tmp = msg;
+	msg = malloc(size + pad_size); // add ft_memdup
 
 	ft_memcpy(msg, tmp, size);
-	ft_memset(msg + size, 0x0, pad_size);
-
-	msg[size] |= 1 << 7;
+	ft_memset(msg + size, 0x0, pad_size);                           // fill end with 0
 
+	msg[size] |= 1 << 7;                                            // add 1 bit at padding start
 
-	/* printf("%lu\n", size + pad_size - sizeof(uint64_t)); */
-	*((uint64_t*)(msg + size + pad_size - sizeof(uint64_t))) = (uint64_t)size;
+	*((uint64_t*)(msg + size + pad_size - sizeof(uint64_t))) = (uint64_t)size * 8; // add
 	size += pad_size;
-	/* printf("%lu: %s\n", size, msg); */
-	/* printf("|%02x%02x%02x%02x|\n", msg[24], msg[25], msg[26], msg[27]); */
 
-	uint32_t	a, b, c, d;
+	for (uint64_t i = 0; i < size; i++)
+	{
+		if (i % 8 == 0)
+			printf("\n");
+		printf("%02x ", msg[i]);
+	}
+	printf("\n\n");
+	/* printf("\n%lu: %s\n", size, msg); */
+	/* printf("|%lu|\n", *((uint64_t*)(msg + size - 8))); */
 
 	// state initialized to predefined constants
 
@@ -90,6 +106,7 @@ char	*message_digest_md5(uint8_t *msg, size_t size)
 	// 128 bit state (a, b, c, d)
 	// 4 rounds on each block (128 * 4 = 512)
 
+
 	uint32_t	f;
 	int	g;
 	int	i;
@@ -97,32 +114,44 @@ char	*message_digest_md5(uint8_t *msg, size_t size)
 
 	size_t chunk_i;
 
+	uint32_t	a, b, c, d;
+
+	uint32_t a0 = A_INIT;
+	uint32_t b0 = B_INIT;
+	uint32_t c0 = C_INIT;
+	uint32_t d0 = D_INIT;
+
 	chunk_i = 0;
 	while (chunk_i < size)
 	{
+		a = a0;
+		b = b0;
+		c = c0;
+		d = d0;
 
 		i = -1;
 		while (++i < 64)
 		{
+
 			if (i < 16)
 			{
-				f = (b & c) | ~(b & d);
+				f = (b & c) | ((~b) & d);
 				g = i;
 			}
 			else if (i < 32)
 			{
-				f = (b & c) | (c & ~d);
+				f = (b & d) | (c & (~d));
 				g = (5 * i + 1) % 16;
 			}
 			else if (i < 48)
 			{
 				f = b ^ c ^ d;
-				g = (3 * i + 1) % 16;
+				g = (3 * i + 5) % 16;
 			}
 			else
 			{
 				f = c ^ (b | ~d);
-				g = (7 * i + 1) % 16;
+				g = (7 * i) % 16;
 			}
 
 			f += a + g_K[i] + ((uint32_t*)(msg + chunk_i))[g];
@@ -131,14 +160,41 @@ char	*message_digest_md5(uint8_t *msg, size_t size)
 			c = b;
 			b += leftrotate(f, g_shifts[i]);
 		}
+		a0 += a;
+		b0 += b;
+		c0 += c;
+		d0 += d;
 
-		chunk_i += 32;
+		chunk_i += 64;
 	}
 
+	uint8_t buf[16];
+	buf[0] = (a0 & 0xff000000) >> 24;
+	buf[1] = (a0 & 0x00ff0000) >> 16;
+	buf[2] = (a0 & 0x0000ff00) >> 8;
+	buf[3] = a0 & 0x000000ff;
+
+	buf[4] = (b0 & 0xff000000) >> 24;
+	buf[5] = (b0 & 0x00ff0000) >> 16;
+	buf[6] = (b0 & 0x0000ff00) >> 8;
+	buf[7] = b0 & 0x000000ff;
+
+	buf[8] = (c0 & 0xff000000) >> 24;
+	buf[9] = (c0 & 0x00ff0000) >> 16;
+	buf[10] = (c0 & 0x0000ff00) >> 8;
+	buf[11] = c0 & 0x000000ff;
+
+	buf[12] = (d0 & 0xff000000) >> 24;
+	buf[13] = (d0 & 0x00ff0000) >> 16;
+	buf[14] = (d0 & 0x0000ff00) >> 8;
+	buf[15] = d0 & 0x000000ff;
+
+
 	char *ret = malloc(33 * sizeof(char));
 	ret[32] = '\0';
 
-	sprintf(ret, "%08x%08x%08x%08x", a, b, c, d);
+	sprintf(ret, "%08x%08x%08x%08x", ((uint32_t*)buf)[0], ((uint32_t*)buf)[1],
+			((uint32_t*)buf)[2], ((uint32_t*)buf)[3]);
 
 	return (ret);
 }