You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
256 lines
7.7 KiB
256 lines
7.7 KiB
/* |
|
* Derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm |
|
* and modified slightly to be functionally identical but condensed into control structures. |
|
*/ |
|
|
|
#include "md5.h" |
|
|
|
/* |
|
* Constants defined by the MD5 algorithm |
|
*/ |
|
#define A 0x67452301 |
|
#define B 0xefcdab89 |
|
#define C 0x98badcfe |
|
#define D 0x10325476 |
|
|
|
static uint32_t S[] = {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 uint32_t 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}; |
|
|
|
/* |
|
* Padding used to make the size (in bits) of the input congruent to 448 mod 512 |
|
*/ |
|
static uint8_t PADDING[] = {0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
|
|
|
/* |
|
* Initialize a context |
|
*/ |
|
void md5Init(MD5Context *ctx){ |
|
ctx->size = (uint64_t)0; |
|
|
|
ctx->buffer[0] = (uint32_t)A; |
|
ctx->buffer[1] = (uint32_t)B; |
|
ctx->buffer[2] = (uint32_t)C; |
|
ctx->buffer[3] = (uint32_t)D; |
|
} |
|
|
|
/* |
|
* Add some amount of input to the context |
|
* |
|
* If the input fills out a block of 512 bits, apply the algorithm (md5Step) |
|
* and save the result in the buffer. Also updates the overall size. |
|
*/ |
|
|
|
void md5Update(MD5Context *ctx, uint8_t *input_buffer, size_t input_len){ |
|
uint32_t input[16]; |
|
unsigned int offset = ctx->size % 64; |
|
ctx->size += (uint64_t)input_len; |
|
|
|
// Copy each byte in input_buffer into the next space in our context input |
|
for(unsigned int i = 0; i < input_len; ++i){ |
|
ctx->input[offset++] = (uint8_t)*(input_buffer + i); |
|
|
|
// If we've filled our context input, copy it into our local array input |
|
// then reset the offset to 0 and fill in a new buffer |
|
// The local array input is a list of 16 32-bit words for use in the algorithm |
|
if(offset % 64 == 0){ |
|
for(unsigned int j = 0; j < 16; ++j){ |
|
// Convert to little-endian |
|
input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 | |
|
(uint32_t)(ctx->input[(j * 4) + 2]) << 16 | |
|
(uint32_t)(ctx->input[(j * 4) + 1]) << 8 | |
|
(uint32_t)(ctx->input[(j * 4)]); |
|
} |
|
md5Step(ctx->buffer, input); |
|
offset = 0; |
|
} |
|
} |
|
} |
|
|
|
/* |
|
* Pad the current input to get to 448 bytes, append the size in bits to the very end, |
|
* and save the result of the final iteration into digest. |
|
*/ |
|
void md5Finalize(MD5Context *ctx){ |
|
uint32_t input[16]; |
|
unsigned int offset = ctx->size % 64; |
|
unsigned int padding_length = offset < 56 ? 56 - offset : (56 + 64) - offset; |
|
|
|
// Fill in the padding andndo the changes to size that resulted from the update |
|
md5Update(ctx, PADDING, padding_length); |
|
ctx->size -= (uint64_t)padding_length; |
|
|
|
// Do a final update (internal to this function) |
|
// Last two 32-bit words are the two halves of the size (converted from bytes to bits) |
|
for(unsigned int j = 0; j < 14; ++j){ |
|
input[j] = (uint32_t)(ctx->input[(j * 4) + 3]) << 24 | |
|
(uint32_t)(ctx->input[(j * 4) + 2]) << 16 | |
|
(uint32_t)(ctx->input[(j * 4) + 1]) << 8 | |
|
(uint32_t)(ctx->input[(j * 4)]); |
|
} |
|
input[14] = (uint32_t)(ctx->size * 8); |
|
input[15] = (uint32_t)((ctx->size * 8) >> 32); |
|
|
|
md5Step(ctx->buffer, input); |
|
|
|
// Move the result into digest |
|
// (Convert from little-endian) |
|
for(unsigned int i = 0; i < 4; ++i){ |
|
ctx->digest[(i * 4) + 0] = (uint8_t)((ctx->buffer[i] & 0x000000FF)); |
|
ctx->digest[(i * 4) + 1] = (uint8_t)((ctx->buffer[i] & 0x0000FF00) >> 8); |
|
ctx->digest[(i * 4) + 2] = (uint8_t)((ctx->buffer[i] & 0x00FF0000) >> 16); |
|
ctx->digest[(i * 4) + 3] = (uint8_t)((ctx->buffer[i] & 0xFF000000) >> 24); |
|
} |
|
} |
|
|
|
/* |
|
* Step on 512 bits of input with the main MD5 algorithm. |
|
*/ |
|
void md5Step(uint32_t *buffer, uint32_t *input){ |
|
uint32_t AA = buffer[0]; |
|
uint32_t BB = buffer[1]; |
|
uint32_t CC = buffer[2]; |
|
uint32_t DD = buffer[3]; |
|
|
|
uint32_t E; |
|
|
|
unsigned int j; |
|
|
|
for(unsigned int i = 0; i < 64; ++i){ |
|
switch(i / 16){ |
|
case 0: |
|
E = F(BB, CC, DD); |
|
j = i; |
|
break; |
|
case 1: |
|
E = G(BB, CC, DD); |
|
j = ((i * 5) + 1) % 16; |
|
break; |
|
case 2: |
|
E = H(BB, CC, DD); |
|
j = ((i * 3) + 5) % 16; |
|
break; |
|
default: |
|
E = I(BB, CC, DD); |
|
j = (i * 7) % 16; |
|
break; |
|
} |
|
|
|
uint32_t temp = DD; |
|
DD = CC; |
|
CC = BB; |
|
BB = BB + rotate_left(AA + E + K[i] + input[j], S[i]); |
|
AA = temp; |
|
} |
|
|
|
buffer[0] += AA; |
|
buffer[1] += BB; |
|
buffer[2] += CC; |
|
buffer[3] += DD; |
|
} |
|
|
|
/* |
|
* Functions that will return a pointer to the hash of the provided input |
|
*/ |
|
void md5String(char *input, uint8_t* output) { |
|
MD5Context ctx; |
|
md5Init(&ctx); |
|
md5Update(&ctx, (uint8_t *)input, strlen(input)); |
|
md5Finalize(&ctx); |
|
|
|
//uint8_t *result = malloc(16); |
|
memcpy(output, ctx.digest, 16); |
|
//return result; |
|
} |
|
|
|
uint8_t* md5File(FILE *file){ |
|
char *input_buffer = malloc(1024); |
|
size_t input_size = 0; |
|
|
|
MD5Context ctx; |
|
md5Init(&ctx); |
|
|
|
while((input_size = fread(input_buffer, 1, 1024, file)) > 0){ |
|
md5Update(&ctx, (uint8_t *)input_buffer, input_size); |
|
} |
|
|
|
md5Finalize(&ctx); |
|
|
|
free(input_buffer); |
|
|
|
uint8_t *result = malloc(16); |
|
memcpy(result, ctx.digest, 16); |
|
return result; |
|
} |
|
|
|
/* |
|
* Bit-manipulation functions defined by the MD5 algorithm |
|
*/ |
|
uint32_t F(uint32_t X, uint32_t Y, uint32_t Z){ |
|
return (X & Y) | (~X & Z); |
|
} |
|
|
|
uint32_t G(uint32_t X, uint32_t Y, uint32_t Z){ |
|
return (X & Z) | (Y & ~Z); |
|
} |
|
|
|
uint32_t H(uint32_t X, uint32_t Y, uint32_t Z){ |
|
return X ^ Y ^ Z; |
|
} |
|
|
|
uint32_t I(uint32_t X, uint32_t Y, uint32_t Z){ |
|
return Y ^ (X | ~Z); |
|
} |
|
|
|
/* |
|
* Rotates a 32-bit word left by n bits |
|
*/ |
|
uint32_t rotate_left(uint32_t x, uint32_t n){ |
|
return (x << n) | (x >> (32 - n)); |
|
} |
|
|
|
/* |
|
* Printing bytes from buffers or the hash |
|
*/ |
|
void print_bytes(void *p, size_t length){ |
|
uint8_t *pp = (uint8_t *)p; |
|
for(unsigned int i = 0; i < length; ++i){ |
|
if(i && !(i % 16)){ |
|
printf("\n"); |
|
} |
|
printf("%02X ", pp[i]); |
|
} |
|
printf("\n"); |
|
} |
|
|
|
void print_hash(uint8_t *p){ |
|
for(unsigned int i = 0; i < 16; ++i){ |
|
printf("%02x", p[i]); |
|
} |
|
printf("\n"); |
|
}
|
|
|