逆向分析中的密码学---MD5

最新推荐文章于 2024-10-11 22:42:53 发布

努力学习的大康

最新推荐文章于 2024-10-11 22:42:53 发布

阅读量1.9k

点赞数 5

分类专栏： CTF 逆向分析文章标签：安全密码学

本文链接：https://blog.youkuaiyun.com/abel_big_xu/article/details/115560865

版权

逆向分析同时被 2 个专栏收录

24 篇文章

订阅专栏

CTF

23 篇文章

订阅专栏

0x01 简介

MD5信息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值（hash value）。可以用于确保信息传输完整一致。数据库中密码的保存（md5(pass,salt)方式）。

0x02 算法流程

1.数据填充
对消息进行数据填充，使消息的长度对512取模得448，设消息长度为X，即满足X mod 512=448。根据此公式得出需要填充的数据长度。
填充方法：在消息后面进行填充，填充第一位为1，其余为0。
2、添加消息长度
在第一步结果之后再填充上原消息的长度，可用来进行的存储长度为64位。如果消息长度大于2^64，则只使用其低64位的值，即（消息长度对 264取模）。
在此步骤进行完毕后，最终消息长度就是512的整数倍。
3.初始化变量
用4个变量（A,B,C,D）来计算消息摘要。这里的A、B、C、D都是32位的寄存器。

A = 01234567h
B = 89abcdefh
C = fedcba98h
D = 76543210h

4.数据处理
以512位分组为单位处理消息。首先定义4个辅助函数，每个都是以3个32位双字为输入，输出一个32位双字。主要流程如下图，ABCD为4个32位值用于辅助计算MD5，X矩阵为512bite的一个chunk，T矩阵为加法常数。

F(X,Y,Z)=(X & Y) | ((~X) & Z); 
G(X,Y,Z)=(X & Z) | (Y & (~Z));  
H(X,Y,Z)=X ^ Y ^ Z; 
I(X,Y,Z)=Y ^ (X | (~Z));

在这里插入图片描述

5.输出
当512位分组运算完毕，A、B、C、D的级联输出为MD5散列的结果

0x03 源码实现1

网上找到的第一份源码是（https://github.com/pod32g/MD5/blob/master/md5.c），实现的流程是安装上面的算法实现来进行，比较容易理解。代码中存在两个常数的矩阵，加法常数矩阵和循环左移矩阵。其中初始化的ABCD也算是其中一个特征。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

//T[i]=4294967296*abs(sin(i))，加法常数矩阵
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))))

//unsigned int 转 byte[4]
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);
}
//byte[4] 转 unsigned int
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;

    // 初始化magic number A、B、C、D
    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; //0x80的二进制1000 0000 第一位添加1
    for (offset = initial_len + 1; offset < new_len; offset++)
        msg[offset] = 0;

    //添加长度
    to_bytes(initial_len * 8, msg + new_len);
    // initial_len>>29 == initial_len*8>>32,避免溢出
    to_bytes(initial_len >> 29, msg + new_len + 4);

    //对每一个512byte进行处理
    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);
}

int main(int argc, char** argv) {
    char* msg;
    size_t len;
    int i;
    uint8_t result[16];

    if (argc < 2) {
        printf("usage: %s 'string'\n", argv[0]);
        return 1;
    }
    msg = argv[1];

    len = strlen(msg);

    md5((uint8_t*)msg, len, result);

    // display result
    for (i = 0; i < 16; i++)
        printf("%2.2x", result[i]);
    puts("");

    return 0;
}

0x04 源码实现2

找到的第二份源码是基于算法的官方原文档及源码详细注释（https://blog.youkuaiyun.com/ZCShou优快云/article/details/83866095）。算法稍微难懂一点。

调用MD5Init初始化MD5_CTX，初始化ABCD常量
调用MD5Update，512byte的倍数部分先进行循环计算
调用MD5Final，对最后不是512byte部分先进行填01充和添加长度，再调用MD5Update进行循环计算，最后返回MD5值

这个版本实现中，没有了上面的两个常数的矩阵，但是还存在MD5_CTX初始化时的ABCD特征。4种基本的运算比如FF,GG,HH,II还是可以比较容易识别的

#include <string.h>
#include <stdio.h>
typedef struct
{
	/* 存储原始信息的bits数长度(不包括填充的bits)，最长为 2^64 bits。如果消息长度大于2^64，则只使用其低64位的值，即（消息长度 对 2^64取模） */
	unsigned int count[2];
	/* 四个32bits数，用于存放最终计算得到的消息摘要。当消息长度大于 512bits时，也用于存放每个512bits的中间结果 */
	unsigned int state[4];
	/*存放输入的信息的缓冲区，512bits */
	unsigned char buffer[64];
} MD5_CTX;

void MD5Init(MD5_CTX* context);
void MD5Update(MD5_CTX* context, unsigned char* input, unsigned int inputlen);
void MD5Final(MD5_CTX* context, unsigned char digest[16]);

/* MD5转换用到的常量，是算法本身规定的 */
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21

/* MD5算法本身规定的基本函数 */
#define F(x, y, z) ((x & y) | (~x & z))
#define G(x, y, z) ((x & z) | (y & ~z))
#define H(x, y, z) (x ^ y ^ z)
#define I(x, y, z) (y ^ (x | ~z))

/* 实现将x循环左移n位
 */
#define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))

 /** MD5算法本身规定的 4 轮变换
  * Rotation is separate from addition to prevent recomputation.
 **/
#define FF(a, b, c, d, x, s, ac) \
{                                \
    a += F(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define GG(a, b, c, d, x, s, ac) \
{                                \
    a += G(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define HH(a, b, c, d, x, s, ac) \
{                                \
    a += H(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}
#define II(a, b, c, d, x, s, ac) \
{                                \
    a += I(b, c, d) + x + ac;    \
    a = ROTATE_LEFT(a, s);       \
    a += b;                      \
}

 /**
  * 用于bits填充的缓冲区，为什么要64个字节呢？因为当欲加密的信息的bits数被512除其余数为448时，
  * 需要填充的bits的最大值为512=64*8 。
 **/
unsigned char PADDING[] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
			   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

static void MD5Transform(unsigned int state[4], unsigned char block[64]);
static void MD5Encode(unsigned char* output, unsigned int* input, unsigned int len);
static void MD5Decode(unsigned int* output, unsigned char* input, unsigned int len);

/* MD5 initialization. Begins an MD5 operation, writing a new context. */
/* 初始化md5的结构 */
void MD5Init(MD5_CTX* context)
{
	/* 将当前的有效信息的长度设成 0 */
	context->count[0] = 0;
	context->count[1] = 0;
	/* Load magic initialization constants.*/
	/* 初始化链接变量，算法要求这样 */
	context->state[0] = 0x67452301;
	context->state[1] = 0xEFCDAB89;
	context->state[2] = 0x98BADCFE;
	context->state[3] = 0x10325476;
}

/* MD5 block update operation. Continues an MD5 message-digest
  operation, processing another message block, and updating the
  context. */
  /* 将与加密的信息传递给md5结构，可以多次调用
  context：初始化过了的md5结构
  input：欲加密的信息，可以任意长
  inputLen：指定input的长度
  */
void MD5Update(MD5_CTX* context, unsigned char* input, unsigned int inputlen)
{
	unsigned int i = 0, index = 0, partlen = 0;

	/* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 用于判断已有信息加上当前传过来的信息的总长度能不能达到 512bits， 如果能够达到则对凑够的512bits进行一次处理 */
	index = (context->count[0] >> 3) & 0x3F;	/* (context->count[0] >> 3) = context->count[0]/8 ,即：算字节数； 后面的 & 3F 就是 Mod 64 */
	partlen = 64 - index;						/* 计算已有的字节数长度还差多少字节可以凑成 64Bytes（512bits） */
	/* 保存输入信息的比特位数 */
	context->count[0] += inputlen << 3;
	if (context->count[0] < (inputlen << 3))
	{
		context->count[1]++;
	}
	context->count[1] += inputlen >> 29;

	/* 如果当前输入的字节数 大于 已有字节数长度补足64字节整倍数所差的字节数 */
	if (inputlen >= partlen)
	{
		/* 用当前输入的内容把 context->buffer 的内容补足 512bits */
		memcpy(&context->buffer[index], input, partlen);
		/* 用基本函数对填充满的512bits（已经保存到context->buffer中） 做一次转换，转换结果保存到context->state中 */
		MD5Transform(context->state, context->buffer);
		/* 对当前输入的剩余字节做转换（如果剩余的字节大于512bits的话 ）， 转换结果保存到context->state中 */
		for (i = partlen; i + 64 <= inputlen; i += 64)
		{
			MD5Transform(context->state, &input[i]);
		}
		index = 0;
	}
	else
	{
		i = 0;
	}
	/*将输入缓冲区中的不足填充满512bits的剩余内容填充到context->buffer中，留待以后再作处理*/
	memcpy(&context->buffer[index], &input[i], inputlen - i);
}

/* MD5 finalization. Ends an MD5 message-digest operation, writing the
  the message digest and zeroizing the context. */
  /*获取加密 的最终结果
  digest：保存最终的加密串
  context：你前面初始化并填入了信息的md5结构
  */
void MD5Final(MD5_CTX* context, unsigned char digest[16])
{
	unsigned int index = 0, padlen = 0;
	unsigned char bits[8];

	/* 计算已有信息的bits长度的字节数的模64（64bytes = 512bits）。 */
	index = (context->count[0] >> 3) & 0x3F;
	/* 计算需要填充的字节数，padLen的取值范围在1-64之间 */
	padlen = (index < 56) ? (56 - index) : (120 - index);

	/* 将要被转换的信息(所有的)长度拷贝到bits中 */
	MD5Encode(bits, context->count, 8);
	/*  */
	MD5Update(context, PADDING, padlen);

	/* 补上原始信息的bits长度（bits长度固定的用64bits表示），这一次能够恰巧凑够512bits，不会多也不会少 */
	MD5Update(context, bits, 8);

	/* 将最终的结果保存到digest中。ok，终于大功告成了 */
	MD5Encode(digest, context->state, 16);
}

/* Encodes input (UINT4) into output (unsigned char). Assumes len is
  a multiple of 4. */
  /*将4字节的整数copy到字符形式的缓冲区中
  output：用于输出的字符缓冲区
  input：欲转换的四字节的整数形式的数组
  len：output缓冲区的长度，要求是4的整数倍
  */
static void MD5Encode(unsigned char* output, unsigned int* input, unsigned int len)
{
	unsigned int i = 0, j = 0;
	while (j < len)
	{
		output[j] = input[i] & 0xFF;
		output[j + 1] = (input[i] >> 8) & 0xFF;
		output[j + 2] = (input[i] >> 16) & 0xFF;
		output[j + 3] = (input[i] >> 24) & 0xFF;
		i++;
		j += 4;
	}
}

/* Decodes input (unsigned char) into output (UINT4). Assumes len is
  a multiple of 4. */
  /*与上面的函数正好相反，这一个把字符形式的缓冲区中的数据copy到4字节的整数中（即以整数形式保存）
  output：保存转换出的整数
  input：欲转换的字符缓冲区
  len：输入的字符缓冲区的长度，要求是4的整数倍
  */
static void MD5Decode(unsigned int* output, unsigned char* input, unsigned int len)
{
	unsigned int i = 0, j = 0;
	while (j < len)
	{
		output[i] = (input[j]) |
			(input[j + 1] << 8) |
			(input[j + 2] << 16) |
			(input[j + 3] << 24);
		i++;
		j += 4;
	}
}

/* MD5 basic transformation. Transforms state based on block. */
/*
对512bits信息(即block缓冲区)进行一次处理，每次处理包括四轮
state[4]：md5结构中的state[4]，用于保存对512bits信息加密的中间结果或者最终结果
block[64]：欲加密的512bits信息
*/
static void MD5Transform(unsigned int state[4], unsigned char block[64])
{
	unsigned int a = state[0];
	unsigned int b = state[1];
	unsigned int c = state[2];
	unsigned int d = state[3];
	unsigned int x[64];

	MD5Decode(x, block, 64);

	/* Round 1 */
	FF(a, b, c, d, x[0], S11, 0xd76aa478);  /* 1 */
	FF(d, a, b, c, x[1], S12, 0xe8c7b756);  /* 2 */
	FF(c, d, a, b, x[2], S13, 0x242070db);  /* 3 */
	FF(b, c, d, a, x[3], S14, 0xc1bdceee);  /* 4 */
	FF(a, b, c, d, x[4], S11, 0xf57c0faf);  /* 5 */
	FF(d, a, b, c, x[5], S12, 0x4787c62a);  /* 6 */
	FF(c, d, a, b, x[6], S13, 0xa8304613);  /* 7 */
	FF(b, c, d, a, x[7], S14, 0xfd469501);  /* 8 */
	FF(a, b, c, d, x[8], S11, 0x698098d8);  /* 9 */
	FF(d, a, b, c, x[9], S12, 0x8b44f7af);  /* 10 */
	FF(c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
	FF(b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
	FF(a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
	FF(d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
	FF(c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
	FF(b, c, d, a, x[15], S14, 0x49b40821); /* 16 */

	/* Round 2 */
	GG(a, b, c, d, x[1], S21, 0xf61e2562);  /* 17 */
	GG(d, a, b, c, x[6], S22, 0xc040b340);  /* 18 */
	GG(c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
	GG(b, c, d, a, x[0], S24, 0xe9b6c7aa);  /* 20 */
	GG(a, b, c, d, x[5], S21, 0xd62f105d);  /* 21 */
	GG(d, a, b, c, x[10], S22, 0x2441453);  /* 22 */
	GG(c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
	GG(b, c, d, a, x[4], S24, 0xe7d3fbc8);  /* 24 */
	GG(a, b, c, d, x[9], S21, 0x21e1cde6);  /* 25 */
	GG(d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
	GG(c, d, a, b, x[3], S23, 0xf4d50d87);  /* 27 */
	GG(b, c, d, a, x[8], S24, 0x455a14ed);  /* 28 */
	GG(a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
	GG(d, a, b, c, x[2], S22, 0xfcefa3f8);  /* 30 */
	GG(c, d, a, b, x[7], S23, 0x676f02d9);  /* 31 */
	GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

	/* Round 3 */
	HH(a, b, c, d, x[5], S31, 0xfffa3942);  /* 33 */
	HH(d, a, b, c, x[8], S32, 0x8771f681);  /* 34 */
	HH(c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
	HH(b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
	HH(a, b, c, d, x[1], S31, 0xa4beea44);  /* 37 */
	HH(d, a, b, c, x[4], S32, 0x4bdecfa9);  /* 38 */
	HH(c, d, a, b, x[7], S33, 0xf6bb4b60);  /* 39 */
	HH(b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
	HH(a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
	HH(d, a, b, c, x[0], S32, 0xeaa127fa);  /* 42 */
	HH(c, d, a, b, x[3], S33, 0xd4ef3085);  /* 43 */
	HH(b, c, d, a, x[6], S34, 0x4881d05);   /* 44 */
	HH(a, b, c, d, x[9], S31, 0xd9d4d039);  /* 45 */
	HH(d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
	HH(c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
	HH(b, c, d, a, x[2], S34, 0xc4ac5665);  /* 48 */

	/* Round 4 */
	II(a, b, c, d, x[0], S41, 0xf4292244);  /* 49 */
	II(d, a, b, c, x[7], S42, 0x432aff97);  /* 50 */
	II(c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
	II(b, c, d, a, x[5], S44, 0xfc93a039);  /* 52 */
	II(a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
	II(d, a, b, c, x[3], S42, 0x8f0ccc92);  /* 54 */
	II(c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
	II(b, c, d, a, x[1], S44, 0x85845dd1);  /* 56 */
	II(a, b, c, d, x[8], S41, 0x6fa87e4f);  /* 57 */
	II(d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
	II(c, d, a, b, x[6], S43, 0xa3014314);  /* 59 */
	II(b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
	II(a, b, c, d, x[4], S41, 0xf7537e82);  /* 61 */
	II(d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
	II(c, d, a, b, x[2], S43, 0x2ad7d2bb);  /* 63 */
	II(b, c, d, a, x[9], S44, 0xeb86d391);  /* 64 */

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

int main()
{
	MD5_CTX md5_ctx;
	unsigned char c[] = "123456"; //e10adc3949ba59abbe56e057f20f883e
	unsigned char md5[16];
	/* 计算前，先初始化 */
	MD5Init(&md5_ctx);
	/* 多次调用 MD5Update 循环计算多个包数据（如果有的话） */
	MD5Update(&md5_ctx, c, strlen((char*)c));
	/* 最后调用 MD5Final 获取最终结果 */
	MD5Final(&md5_ctx, md5);
	printf("字符串admin的MD5码为：");
	for (int i = 0; i < 16; i++) printf("%02x", md5[i]);
	printf("\n");
	return 0;
}

0x05 逆向分析识别MD5算法

将上面的实现都编译生成release X64版本的程序，下面对md5算法的关键结构进行识别

第一种MD5源码识别

使用PEid带的Krypto ANALyzer识别到MD5使用的加法常量矩阵
在这里插入图片描述
通过IDA 分析程序，先定位到Krypto ANALyzer识别到0x140003274，可以看到红色框0x140003270到0x140003370为加法常数矩阵，黄色框0x140003370到0x140003460为循环左移表。

通过使用ida的插件Findcrypt可以识别出MD5使用的常数ABCD和加法常量矩阵
在这里插入图片描述
算法识别
1.先初始化ABCD为0x67452301、0xefcdab89、0x98badcfe、0x10325476
2.进行数据填充1和0，直到mod 512 ===448
3.将文本长度填充到最后的8个字节中

4.因为ida识别的原因，将原本for循环的16次w数组赋值，变成了16条赋值语句
在这里插入图片描述
5.64次的主循环循环，可以较好的识别出4种基本运算。

第二种MD5源码识别

使用PEid带的Krypto ANALyzer无法识别
在这里插入图片描述
下面就是用ida pro7.5中使用Findcrypt来识别，可以识别到ABCD4个常数的赋值，而且还能识别到加法常数。

可能是因为vs优化的原因，MD5_init和MD5_update都被优化到了main函数里面。v7,v8,v9就是MD5_CTX结构体。

代码先对MD5_CTX进行初始化赋值0x67452301、0xEFCDAB89、0x98BADCFE、0x10325476
如何执行MD5_update代码，先记录length,再进入for循环调用MD5Transform

在这里插入图片描述
下面就是MD5Transform的代码，可以很明显的看到4种运算函数和加法常数。

0x06 总结

对于MD5的识别，可以通过常量ABCD、加法常数矩阵、循环左移表、4种基本函数FF、GG、HH、II结构的识别。
对于魔改的MD5也常会修改常量ABCD、加法常数矩阵。此时只能通过识别4种基本函数。
常见的MD5爆破可以通过在线网站查询。魔改的MD5如果每段加密字符不是很多的情况，可以通过先暴力计算所有字符的魔改md5再查表。

参考

《加密与解密第四版》
MD5 实现（基于算法的官方原文档）及源码详细注释https://blog.youkuaiyun.com/ZCShou优快云/article/details/83866095
MD5的实现
https://github.com/pod32g/MD5/blob/master/md5.c