mirror of
https://github.com/fumiama/simple-crypto.git
synced 2026-06-05 18:10:23 +08:00
265 lines
6.4 KiB
C
265 lines
6.4 KiB
C
// https://github.com/pod32g/MD5
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
|
|
// 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 <stdio.h>
|
|
#include <sys/stat.h>
|
|
#include <time.h>
|
|
|
|
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 |