Created
June 5, 2020 06:32
-
-
Save MrF-31337/6e17ea37f61bd98d3e250baffadb7b56 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include <arpa/inet.h> | |
const 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 }; | |
const 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}; | |
#define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c)))) | |
void to_bytes(uint32_t val, uint8_t *bytes) | |
{ | |
bytes[0] = (uint8_t) val; | |
bytes[1] = (uint8_t) (val >> 8); | |
bytes[2] = (uint8_t) (val >> 16); | |
bytes[3] = (uint8_t) (val >> 24); | |
} | |
uint32_t to_int32(const uint8_t *bytes) | |
{ | |
return (uint32_t) bytes[0] | |
| ((uint32_t) bytes[1] << 8) | |
| ((uint32_t) bytes[2] << 16) | |
| ((uint32_t) bytes[3] << 24); | |
} | |
void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) { | |
uint32_t h0, h1, h2, h3; | |
uint8_t *msg = NULL; | |
size_t new_len, offset; | |
uint32_t w[16]; | |
uint32_t a, b, c, d, i, f, g, temp; | |
h0 = 0x67452301; | |
h1 = 0xefcdab89; | |
h2 = 0x98badcfe; | |
h3 = 0x10325476; | |
for (new_len = initial_len + 1; new_len % (512/8) != 448/8; new_len++) | |
; | |
msg = (uint8_t*)malloc(new_len + 8); | |
memcpy(msg, initial_msg, initial_len); | |
msg[initial_len] = 0x80; | |
for (offset = initial_len + 1; offset < new_len; offset++) | |
msg[offset] = 0; | |
to_bytes(initial_len*8, msg + new_len); | |
to_bytes(initial_len>>29, msg + new_len + 4); | |
for(offset=0; offset<new_len; offset += (512/8)) { | |
for (i = 0; i < 16; i++) | |
w[i] = to_int32(msg + offset + i*4); | |
a = h0; | |
b = h1; | |
c = h2; | |
d = h3; | |
for(i = 0; i<64; i++) { | |
if (i < 16) { | |
f = (b & c) | ((~b) & d); | |
g = i; | |
} else if (i < 32) { | |
f = (d & b) | ((~d) & c); | |
g = (5*i + 1) % 16; | |
} else if (i < 48) { | |
f = b ^ c ^ d; | |
g = (3*i + 5) % 16; | |
} else { | |
f = c ^ (b | (~d)); | |
g = (7*i) % 16; | |
} | |
temp = d; | |
d = c; | |
c = b; | |
b = b + LEFTROTATE((a + f + k[i] + w[g]), r[i]); | |
a = temp; | |
} | |
h0 += a; | |
h1 += b; | |
h2 += c; | |
h3 += d; | |
} | |
free(msg); | |
to_bytes(h0, digest); | |
to_bytes(h1, digest + 4); | |
to_bytes(h2, digest + 8); | |
to_bytes(h3, digest + 12); | |
} | |
void wrong () | |
{ | |
puts("Wrong key!"); | |
exit(-1); | |
} | |
char* b64 (char *_data, unsigned int size) | |
{ | |
unsigned int orig_size = size; | |
//char *alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; | |
char *alphabet = "vzRHmp/DUiXh2ZkPGV9sWq6KoyfTb5BLCuMwegSxQrE07FNOjtcl8A3YI+nadJ14"; | |
if (size % 3) | |
size += 3 - (size%3); | |
char *r = malloc(size/3*4); | |
char *data = malloc(size); | |
memset(data, 0, size); | |
memcpy(data, _data, orig_size); | |
for (unsigned int i = 0; i < size/3; i++) | |
{ | |
int a = ((*(int *)(data + i*3)) & 0xffffff); | |
a = htonl(a) >> 8; | |
char n[5] = {a>>18,(a>>12)&0x3f,(a>>6)&0x3f, a&0x3f}; | |
for (int j = 0; j < 4; j++) | |
{ | |
int idx = (i*4)+j; | |
if (i*3+j > orig_size) | |
r[idx] = '='; | |
else | |
r[idx] = alphabet[n[j]]; | |
} | |
} | |
return r; | |
} | |
int main () | |
{ | |
unsigned char hashes[5][17] = { | |
"\x8d\x16\x9d\x9b\xe0\x74\xf2\xcc\xbd\xcd\x45\xc9\x2c\x4a\xd9\x1c", | |
"\xe8\xf1\x46\x03\x66\x5c\xcc\x06\x4d\xe7\x83\xb1\x59\xc1\xdb\x34", | |
"\xa7\x3c\x40\xd1\xd4\xec\x8b\x51\x41\x2f\xe1\xba\x4b\x96\xe7\x2a", | |
"\x41\x0d\xa1\x23\x6c\xcd\x9e\x5a\x64\x27\xbb\x25\xdf\x5a\x7f\x6a", | |
"\x5d\xfd\x89\x19\xa9\x72\x67\xec\x78\x0e\xd8\x98\xb9\x27\xbb\x39" | |
}; | |
//char *alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!\"#$%&{}_"; | |
char *alphabet = "0123456789abcdefghijklmnopqrstuvwxyz{}_"; | |
int x = 0x7b465443; | |
for (int j = 0; j < 5; j++) | |
{ | |
for (int a = 0; a < strlen(alphabet); a++) | |
{ | |
for (int b = 0; b < strlen(alphabet); b++) | |
{ | |
for (int c = 0; c < strlen(alphabet); c++) | |
{ | |
for (int d = 0; d < strlen(alphabet); d++) | |
{ | |
int r = alphabet[a] << 24 | alphabet[b] << 16 | alphabet[c] << 8 | alphabet[d]; | |
//printf("%x\n", r); | |
int tmp = x ^ r; | |
char *enc = b64((char *)&tmp, 4); | |
uint8_t hash[16]; | |
md5(enc, strlen(enc), hash); | |
if (memcmp(hash, hashes[j], 16) == 0) | |
{ | |
printf("%.4s", (char *)&r); | |
fflush(stdout); | |
x = tmp; | |
} | |
free(enc); | |
} | |
} | |
} | |
} | |
} | |
printf("\n"); | |
return 0; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment