Scribd
Upload
0 views3 pages

Lab Exercise Is

This document contains a C program that implements the MD5 hashing algorithm. It includes functions for MD5 transformation and digest generation, demonstrating how to compute the MD5 hash of a given input string. The program outputs the MD5 digest for the string 'The quick brown fox jumps over the lazy dog'.

Uploaded by

aviyanniraula01
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0 views3 pages

Lab Exercise Is

This document contains a C program that implements the MD5 hashing algorithm. It includes functions for MD5 transformation and digest generation, demonstrating how to compute the MD5 hash of a given input string. The program outputs the MD5 digest for the string 'The quick brown fox jumps over the lazy dog'.

Uploaded by

aviyanniraula01
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

LAB EXERCISE #8

Program: WAP to illustrate MD5 algorithm.


Code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>

typedef uint32_t uint32;


typedef uint8_t uint8;

typedef union {
uint32 w;
uint8 b[4];
} MD5union;

typedef uint32 DigestArray[4];

uint32 F(uint32 x, uint32 y, uint32 z) { return (x & y) | (~x & z); }


uint32 G(uint32 x, uint32 y, uint32 z) { return (x & z) | (y & ~z); }
uint32 H(uint32 x, uint32 y, uint32 z) { return x ^ y ^ z; }
uint32 I(uint32 x, uint32 y, uint32 z) { return y ^ (x | ~z); }

uint32 rotate_left(uint32 x, int n) {


return (x << n) | (x >> (32 - n));
}

void md5_transform(uint32 state[4], const uint8 block[64]) {


uint32 a = state[0], b = state[1], c = state[2], d = state[3], f, g;
uint32 m[16], i;

for (i = 0; i < 16; ++i)


m[i] = ((uint32)block[i*4]) | ((uint32)block[i*4+1] << 8) |
((uint32)block[i*4+2] << 16) | ((uint32)block[i*4+3] << 24);

static const uint32 r[] = {


7,12,17,22, 7,12,17,22, 7,12,17,22, 7,12,17,22,
5, 9,14,20, 5, 9,14,20, 5, 9,14,20, 5, 9,14,20,
4,11,16,23, 4,11,16,23, 4,11,16,23, 4,11,16,23,
6,10,15,21, 6,10,15,21, 6,10,15,21, 6,10,15,21
};

static const uint32 k[] = {


0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee,
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa,
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed,
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05,
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
};

for (i = 0; i < 64; ++i) {


if (i < 16) {
f = F(b, c, d);
g = i;
} else if (i < 32) {
f = G(b, c, d);
g = (5 * i + 1) % 16;
} else if (i < 48) {
f = H(b, c, d);
g = (3 * i + 5) % 16;
} else {
f = I(b, c, d);
g = (7 * i) % 16;
}

uint32 temp = d;
d = c;
c = b;
b = b + rotate_left(a + f + k[i] + m[g], r[i]);
a = temp;
}

state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
}

void md5(const uint8 *initial_msg, size_t initial_len, uint8 *digest) {


static uint32 state[4] = {
0x67452301, 0xefcdab89,
0x98badcfe, 0x10325476
};

size_t new_len = ((((initial_len + 8) / 64) + 1) * 64);


uint8 *msg = calloc(new_len, 1);
memcpy(msg, initial_msg, initial_len);
msg[initial_len] = 0x80;
uint64_t bits_len = initial_len * 8;
memcpy(msg + new_len - 8, &bits_len, 8);

for (size_t offset = 0; offset < new_len; offset += 64) {


md5_transform(state, msg + offset);
}

for (int i = 0; i < 4; ++i) {


digest[i*4+0] = (uint8)(state[i] & 0xff);
digest[i*4+1] = (uint8)((state[i] >> 8) & 0xff);
digest[i*4+2] = (uint8)((state[i] >> 16) & 0xff);
digest[i*4+3] = (uint8)((state[i] >> 24) & 0xff);
}

free(msg);
}

int main() {
const char *msg = "The quick brown fox jumps over the lazy dog";
uint8 result[16];

printf("\n\tMD5 ENCRYPTION ALGORITHM IN C\n\n");


printf("Input String:\n\t%s\n", msg);

md5((uint8 *)msg, strlen(msg), result);

printf("\nMD5 Digest:\n\t");
for (int i = 0; i < 16; i++) {
printf("%02x", result[i]);
}

printf("\n\n\tMD5 Encryption Completed Successfully!\n\n");


return 0;
}

OUTPUT:

You might also like