// https://github.com/pod32g/MD5 #include #include #include // Constants are the integer part of the sines of integers (in radians) * 2^32. const static uint32_t k[64] = { 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 }; // r specifies the per-round shift amounts const static uint32_t 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}; // leftrotate function definition #define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c)))) static void to_bytes(uint32_t val, uint8_t *bytes) { #ifdef WORDS_BIGENDIAN *(uint32_t*)bytes = __builtin_bswap32(val); #else *(uint32_t*)bytes = val; #endif } static uint32_t to_uint32(const uint8_t *bytes) { #ifdef WORDS_BIGENDIAN return __builtin_bswap32(*(uint32_t*)bytes); #else return *(uint32_t*)bytes; #endif } #ifdef WORDS_BIGENDIAN /* break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15 */ #define break_chunk_into_w(trunk)\ (for(i = 0; i < 16; i++) w[i] = to_uint32((trunk) + i*4)) #else /* break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15 */ #define break_chunk_into_w(trunk) (w = (uint32_t*)(trunk)) #endif //for each 512-bit chunk of message: #define sum(trunk) {\ /* break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15 */\ break_chunk_into_w(trunk);\ \ /* Initialize hash value for this chunk: */\ a = h0;\ b = h1;\ c = h2;\ d = h3;\ \ /* Main loop: */\ for(i = 0; i < 16; i++) {\ f = (b & c) | ((~b) & d);\ g = i;\ temp = d;\ d = c;\ c = b;\ b += LEFTROTATE((a + f + k[i] + w[g]), r[i]);\ a = temp;\ }\ for(i = 16; i < 32; i++) {\ f = (d & b) | ((~d) & c);\ g = (5*i + 1) % 16;\ temp = d;\ d = c;\ c = b;\ b += LEFTROTATE((a + f + k[i] + w[g]), r[i]);\ a = temp;\ }\ for(i = 32; i < 48; i++) {\ f = b ^ c ^ d;\ g = (3*i + 5) % 16;\ temp = d;\ d = c;\ c = b;\ b += LEFTROTATE((a + f + k[i] + w[g]), r[i]);\ a = temp;\ }\ for(i = 48; i < 64; i++) {\ f = c ^ (b | (~d));\ g = (7*i) % 16;\ temp = d;\ d = c;\ c = b;\ b += LEFTROTATE((a + f + k[i] + w[g]), r[i]);\ a = temp;\ }\ \ /* Add this chunk's hash to result so far: */\ h0 += a;\ h1 += b;\ h2 += c;\ h3 += d;\ } uint8_t* md5(const uint8_t *data, size_t data_len, uint8_t digest[16]) { // buffer of last trunk uint8_t trunk[64]; #ifdef WORDS_BIGENDIAN uint32_t w[16]; #else uint32_t* w; #endif // These vars will contain the hash // Initialize variables - simple count in nibbles: uint32_t h0 = 0x67452301; uint32_t h1 = 0xefcdab89; uint32_t h2 = 0x98badcfe; uint32_t h3 = 0x10325476; size_t offset = 0; uint32_t a, b, c, d, i, f, g, temp; // Process the message in successive 512-bit chunks: if(data_len >= 64) for(offset=0; offset<(data_len&(~0x3f)); offset += 64) sum(data+offset); // Process the last trunk of message: //append "1" bit to message //append "0" bits until message length in bits ≡ 448 (mod 512) //append length mod (2^64) to message i = data_len-offset; if(i) memcpy(trunk, data+offset, i); trunk[i++] = 0x80; // append the "1" bit; most significant bit is "first" temp = 64-i; if(temp) memset(&trunk[i], 0, temp); // append "0" bits //no enough space to fill the len in bits //we need to process one more trunk if(i > 56) { sum(trunk); memset(trunk, 0, 64); } // append the len in bits at the end of the buffer. to_bytes(data_len * 8, &trunk[56]); // initial_len>>29 == initial_len*8>>32, but avoids overflow. to_bytes(data_len>>29, &trunk[60]); //sum the last trunk sum(trunk); //var char digest[16] := h0 append h1 append h2 append h3 //(Output is in little-endian) to_bytes(h0, &digest[0]); to_bytes(h1, &digest[4]); to_bytes(h2, &digest[8]); to_bytes(h3, &digest[12]); return (uint8_t*)digest; } #ifdef TEST_SIMPLE_CRYPTO #include #include #include unsigned long get_start_ms() { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000); } int main(int argc, char **argv) { char *msg; size_t len; int i; FILE* fp; uint8_t* buf; unsigned long t1, t2; uint8_t result[16]; struct stat statbuf; if (argc < 3) { printf("usage: %s [options]\n\toptions:\n\t-s string: encode a string\n\t-f file: encode a file\n\t-b file: benchmark using the file\n", argv[0]); return 1; } msg = argv[2]; switch(argv[1][1]) { case 's': len = strlen(msg); md5((uint8_t*)msg, len, result); // display result for (i = 0; i < 16; i++) printf("%2.2x", result[i]); putchar('\n'); break; case 'f': if(stat(msg, &statbuf)) { perror("stat: "); return 1; } fp = fopen(msg, "rb"); if(!fp) { perror("fopen: "); return 2; } buf = malloc(statbuf.st_size); if(!buf) { perror("malloc: "); return 3; } if(fread(buf, statbuf.st_size, 1, fp) != 1) { perror("fread: "); return 4; } md5(buf, statbuf.st_size, result); // display result for (i = 0; i < 16; i++) printf("%2.2x", result[i]); putchar('\n'); break; case 'b': if(stat(msg, &statbuf)) { perror("stat: "); return 1; } fp = fopen(msg, "rb"); if(!fp) { perror("fopen: "); return 2; } buf = malloc(statbuf.st_size); if(!buf) { perror("malloc: "); return 3; } if(fread(buf, statbuf.st_size, 1, fp) != 1) { perror("fread: "); return 4; } t1 = get_start_ms(); for(int i = 0; i < 4; i++) { md5(buf, statbuf.st_size, result); buf[0] = result[0]; } t2 = get_start_ms(); printf("benchmark: %lu ms.\n", t2-t1); break; } return 0; } #endif