如何在Java中手动实现MD5算法以获取文件哈希值

云上老周

2026-5-13

嘿，这个需求确实有点硬核，但手动实现MD5真的能做到——核心就是把MD5的算法规范一步步拆解成代码逻辑就行。我先给你理清楚MD5的核心流程，再附上完整的Java实现，你跟着看就能明白。

MD5算法的核心拆解

MD5本质是把任意长度的输入转换成128位（16字节）的哈希值，整个过程分4个关键阶段：

数据填充：不管输入多长，都要补位让总长度是512位的整数倍。规则是先补一个二进制的1（对应字节0x80），然后补0，直到长度模512剩448位，最后再加上原始长度的64位二进制表示（小端序）。
初始化哈希缓冲区：用四个32位整数作为初始哈希值，这是MD5的标准初始向量：
- A = 0x67452301
- B = 0xEFCDAB89
- C = 0x98BADCFE
- D = 0x10325476
分块处理：把填充后的数据分成每个512位（64字节）的块，对每个块做4轮（共64步）的变换，每一步都会更新A、B、C、D的值。每一轮会用到不同的逻辑函数（F、G、H、I）和预定义的常量数组。
结果拼接：所有块处理完后，把A、B、C、D四个32位整数按小端序转换成字节，再拼接成16进制字符串就是最终的MD5哈希值。

手动实现MD5的Java代码

public class ManualMD5 {
    // MD5的四个初始哈希值（小端序）
    private static final int A_INIT = 0x67452301;
    private static final int B_INIT = 0xEFCDAB89;
    private static final int C_INIT = 0x98BADCFE;
    private static final int D_INIT = 0x10325476;

    // MD5预定义常量：基于正弦函数平方根取整后乘以2^32得到
    private static final int[] CONSTANTS = {
        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
    };

    // 每轮操作的移位位数数组
    private static final int[] SHIFTS = {
        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
    };

    // MD5四轮变换对应的四个逻辑函数
    private static int F(int b, int c, int d) {
        return (b & c) | (~b & d);
    }

    private static int G(int b, int c, int d) {
        return (b & d) | (c & ~d);
    }

    private static int H(int b, int c, int d) {
        return b ^ c ^ d;
    }

    private static int I(int b, int c, int d) {
        return c ^ (b | ~d);
    }

    // 循环左移操作（MD5核心位运算）
    private static int rotateLeft(int x, int n) {
        return (x << n) | (x >>> (32 - n));
    }

    // 核心MD5计算方法
    public static String computeMD5(byte[] input) {
        // 步骤1：数据填充
        long originalBitLength = input.length * 8; // 原始输入的比特长度
        int paddingByteLength = (448 - (input.length * 8 + 1) % 512 + 512) % 512 / 8;

        byte[] paddedInput = new byte[input.length + 1 + paddingByteLength + 8];
        System.arraycopy(input, 0, paddedInput, 0, input.length);
        paddedInput[input.length] = (byte) 0x80; // 补第一个二进制1

        // 补原始长度的64位小端序表示
        for (int i = 0; i < 8; i++) {
            paddedInput[paddedInput.length - 8 + i] = (byte) (originalBitLength >>> (8 * i));
        }

        // 步骤2：初始化哈希值
        int A = A_INIT;
        int B = B_INIT;
        int C = C_INIT;
        int D = D_INIT;

        // 步骤3：分块处理每个512位（64字节）的块
        for (int blockIdx = 0; blockIdx < paddedInput.length / 64; blockIdx++) {
            int[] words = new int[16];
            // 将当前块拆分为16个32位小端序整数
            for (int i = 0; i < 16; i++) {
                int start = blockIdx * 64 + i * 4;
                words[i] = ((paddedInput[start] & 0xFF)) |
                           ((paddedInput[start + 1] & 0xFF) << 8) |
                           ((paddedInput[start + 2] & 0xFF) << 16) |
                           ((paddedInput[start + 3] & 0xFF) << 24);
            }

            int a = A;
            int b = B;
            int c = C;
            int d = D;

            // 四轮64步变换
            for (int i = 0; i < 64; i++) {
                int f;
                int wordIdx;
                if (i < 16) {
                    f = F(b, c, d);
                    wordIdx = i;
                } else if (i < 32) {
                    f = G(b, c, d);
                    wordIdx = (5 * i + 1) % 16;
                } else if (i < 48) {
                    f = H(b, c, d);
                    wordIdx = (3 * i + 5) % 16;
                } else {
                    f = I(b, c, d);
                    wordIdx = (7 * i) % 16;
                }

                int temp = d;
                d = c;
                c = b;
                b = b + rotateLeft(a + f + CONSTANTS[i] + words[wordIdx], SHIFTS[i]);
                a = temp;
            }

            // 更新全局哈希值
            A += a;
            B += b;
            C += c;
            D += d;
        }

        // 步骤4：将哈希值转换为16进制字符串（小端序）
        return bytesToHex(intToLittleEndianBytes(A)) +
               bytesToHex(intToLittleEndianBytes(B)) +
               bytesToHex(intToLittleEndianBytes(C)) +
               bytesToHex(intToLittleEndianBytes(D));
    }

    // 将32位整数转换为小端序字节数组
    private static byte[] intToLittleEndianBytes(int value) {
        byte[] bytes = new byte[4];
        for (int i = 0; i < 4; i++) {
            bytes[i] = (byte) (value >>> (8 * i));
        }
        return bytes;
    }

    // 字节数组转16进制字符串
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b & 0xFF));
        }
        return sb.toString();
    }

    // 测试用例
    public static void main(String[] args) {
        String testStr = "Hello, Manual MD5!";
        String md5Result = computeMD5(testStr.getBytes());
        System.out.println("字符串 \"" + testStr + "\" 的MD5值：" + md5Result);
        // 验证：正确值应为 0a0a9f2a6772942557ab5355d76af442
    }
}

代码关键点说明

数据填充：严格遵循MD5的补位规则，确保输入长度符合512位块的要求。
逻辑函数：F/G/H/I四个函数是MD5每轮用来混合哈希值的核心，不同轮次用不同函数增加混淆度。
循环左移：MD5要求的特定位运算，确保每一步的位变换符合算法规范。
分块处理：每个512位块都会经过64步变换，每一步对应预定义的常量和移位值，最终更新哈希缓冲区。

你可以直接运行这个代码测试，对比标准MD5工具的结果就能验证正确性——整个实现完全没有用到java.security.MessageDigest，所有逻辑都是手动按照MD5官方规范编写的。

内容的提问来源于stack exchange，提问作者Jame Moore