MD5加密算法

前言

        最近因为yq，博主在家就又学习了下MD5的加密算法！说到MD5，相信很多人都听说和使用过，因为MD5实在是太常见，经常被用做登录密码加密、文件校验等等方面

Part 1——MD5介绍

什么是MD5？

        MD5 (Message-Digest Algorithm)：信息摘要算法。一种被广泛使用的密码散列函数，可以产生出一个128位（16字节）的散列值，用于确保信息传输完整一致。MD5由美国密码学家 罗纳德·李维斯特 设计，于1992年公开。 这套算法的程序在 RFC 1321 标准中被加以规范。

MD5性质

MD5的性质如下：
（1）压缩性：无论输入多少字节数据，输出都是长度为128位（16字节）
（2）容易计算性：从原数据计算出MD5值很容易
（3）抗修改性：对原数据进行任何改动，哪怕只修改1个字节，所得到的MD5值都有很大区别
（4）抗碰撞性：已知原数据和其MD5值，想找到一个具有相同MD5值的数据（即伪造数据）十分困难；（注意：这里的抗碰撞性并不是说散列算法无碰撞）
（5）不可逆特性：单向密码体制，从明文到密文的不可逆映射，只有加密过程没有解密过程

MD5为什么不可逆？

      我们知道MD5算法本质是一种散列函数，使用的是hash算法，在计算过程中原文的部分信息是丢失了的。至于在计算过程中原文部分信息是丢失，是因为MD5的压缩性所致，无论输入多少字节数据，输出都是长度为16字节 ，故而MD5的运算过程存在信息丢失。由于不知道运算过程中会有多少个进位在哪一步被丢弃，因而仅仅根据MD5的计算过程和得到的最终结果，是无法逆向计算出明文的。

这儿可能又有同学要问，即然不能解密，为什么网上有MD5的解密网站？

       针对这个问题，首先我们得知道这里所说的解密是不是真正的解密，答案很显然不是。网上的md5解密网站是成千上万的md5原文和md5密文，放到了数据里，所谓的解密就是从数据库里查询有没有原文。这种网站相当于md5的字典库，就是原文和密文的的对应表，数据量很庞大，上万亿级别，如果用户的密文正好在字典库里面，一查对应表就行。很多用户的密码都不够复杂，所以很容易被这种方式生成出来。一般网上这种md5解密网站能解密8位数左右的纯数字密码。密码太复杂的话，要根据这个网站的数据库和数据量而定。

MD5碰撞（Collision）

        2004年，我国中科院院士王小云证实md5算法无法防止碰撞（collision），因此不适用于安全性认证。实际上，王小云的研究成果如下：MD5( M1)=MD5( M2) 即给定消息M1，能够计算获取M2，使得M2产生的散列值与M1产生的散列值相同。如此，MD5的抗碰撞性就已经不满足了，使得MD5不再是安全的散列算法。但即便如此，直到今天，MD5算法依旧没有被彻底抛弃。

MD5碰撞概率

        简单来说，就是先得出一个字符串的MD5值，在根据这个值，逆算出另外一个不同的字符串，但是它们的MD5值是一致的。 这就是MD5碰撞。MD5碰撞概率为$1/2^{256}$,从这个概率可以看出MD5发生碰撞的概率还是极低的，几乎不可能。
        那我们有办法实现MD5碰撞的实现吗？答案是显然的，上面我们提到我国中科院院士王小云证实md5算法无法防止碰撞（collision），那我们当然可以通过一些技术手段得到MD5的碰撞。下面博主就演示下MD5的碰撞：

1、准备两个内容不同的文本
文本1：

文本2：

2、Java MD5加密代码：

import java.io.File;
import java.io.FileInputStream;
import java.security.MessageDigest;

public class md5ToFile {
	public static void main(String[] args) {
		System.out.println("=====MD5碰撞演示======");
		getFile("1_msg1.txt");
		getFile("1_msg2.txt");
	}

	// MD5加密文件
	private static void getFile(String path) {
		File file = new File(path);// 文件路径
		String md5 = getFileMD5(file);// 得到MD5码
		System.out.println(file.getName()+"加密文件的MD5为:\t" + md5);
	}

	public static String getFileMD5(File file) {
		if (!file.isFile()) {
			return null;
		}
		MessageDigest md = null;
		FileInputStream in = null;
		byte buffer[] = new byte[1024];
		int len;
		try {
			md = MessageDigest.getInstance("MD5");
			in = new FileInputStream(file);
			while ((len = in.read(buffer, 0, 1024)) != -1) {
				md.update(buffer, 0, len);
			}
			in.close();
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
		return bytesToHexString(md.digest());
	}

	public static String bytesToHexString(byte[] md5Arr) {
		StringBuilder stringBuilder = new StringBuilder("");
		if (md5Arr == null || md5Arr.length <= 0) {
			return null;
		}
		//把byte[]数组转换成十六进制字符串表示形式
		for (int i = 0; i < md5Arr.length; i++) {
			//进行按位与操作,保证byte类型转int后其保持二进制补码的一致
			int v = md5Arr[i] & 0xFF;
			String md5Hex = Integer.toHexString(v);
			stringBuilder.append(md5Hex);
		}
		return stringBuilder.toString();
	}
}

加密结果：

我们可以看见，这两个文本的内容是不一样的，但经过MD5加密后，MD5确实一样的，说明MD5还是能产生碰撞，因此密码安全性要求很高的，不建议采用MD5加密。

Part 2——MD5加密原理

1、数据填充

2、添加消息长度

3、装入标准幻数

4、四轮循环运算

实现代码

public class MD5Source {
    //分块存储数组
    long[] groups = null;
    //MD5存储结果
    String resultMessage = "";

    //定义标准幻数,采用小端存储
    static final long A = 0x67452301L;
    static final long B = 0xefcdab89L;
    static final long C = 0x98badcfeL;
    static final long D = 0x10325476L;

    //基本数据
    private long[] result = {A, B, C, D};
    //常量ti公式:floor(abs(sin(i+1))×(2pow32)
    static final long T[][] = {
            {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}};
    //向左位移数
    static final int k[][] = {
            {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
            {1, 6, 11, 0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12},
            {5, 8, 11, 14, 1, 4, 7, 10, 13, 0, 3, 6, 9, 12, 15, 2},
            {0, 7, 14, 5, 12, 3, 10, 1, 8, 15, 6, 13, 4, 11, 2, 9}};

    //各次迭代中采用的做循环移位的s值
    static final int S[][] = {
            {7, 12, 17, 22},
            {5, 9, 14, 20},
            {4, 11, 16, 23},
            {6, 10, 15, 21}};

    //4轮循环中使用的生成函数(轮函数)g
    private static long g(int i, long b, long c, long d) {
        switch (i) {
            case 0:
                return (b & c) | ((~b) & d);
            case 1:
                return (b & d) | (c & (~d));
            case 2:
                return b ^ c ^ d;
            case 3:
                return c ^ (b | (~d));
            default:
                return 0;
        }
    }
    //开始使用MD5加密
    private String start(String message) {
        //转化为字节数组
        byte[] inputBytes = message.getBytes();
        //获取字节数组的长度
        int byteLen = inputBytes.length;
        //得到K值（以bit作单位的message长度）
        long K = (long) (byteLen << 3);

        //完整小组(512bit)(64byte)的个数
        int groupCount = byteLen / 64;

        //分块
        for (int i = 0; i < groupCount; i++) {
            //每次取512bit
            //处理一个分组
            H(divide(inputBytes, i * 64));
        }

        //填充
        int rest = byteLen % 64;
        //即将填充的一个分组
        byte[] paddingBytes = new byte[64];
        //原来的尾部数据
        for (int i = 0; i < rest; i++)
            paddingBytes[i] = inputBytes[byteLen - rest + i];
        //即小于448bit的情况，先填充100...0再填充K值的低64位
        //此时只会新增一个分组
        if (rest <= 56) {
            //填充100...0
            if (rest < 56) {
                //填充10000000
                paddingBytes[rest] = (byte) (1 << 7);
                //填充00000000
                for (int i = 1; i < 56 - rest; i++)
                    paddingBytes[rest + i] = 0;
            }
            //填充K值低64位
            for (int i = 0; i < 8; i++) {
                paddingBytes[56 + i] = (byte) (K & 0xFFL);
                K = K >> 8;
            }
            //处理分组
            H(divide(paddingBytes, 0));
            //即大于448bit的情况，先填充100...0再填充K值的低64位
            //此时会新增两个分组
        } else {
            //填充10000000(左移)
            paddingBytes[rest] = (byte) (1 << 7);
            //填充00000000
            for (int i = rest + 1; i < 64; i++)
                paddingBytes[i] = 0;
            //处理第一个尾部分组
            H(divide(paddingBytes, 0));

            //填充00000000
            for (int i = 0; i < 56; i++)
                paddingBytes[i] = 0;

            //填充低64位
            for (int i = 0; i < 8; i++) {
                //使用小端方式，即Byte数组先存储len的低位数据，然后右移len
                paddingBytes[56 + i] = (byte) (K & 0xFFL);
                K = K >> 8;
            }
            //处理第二个尾部分组
            H(divide(paddingBytes, 0));
        }
        //将Hash值转换成十六进制的字符串
        //小端方式
        for (int i = 0; i < 4; i++) {
            //解决缺少前置0的问题
            resultMessage += String.format("%02x", result[i] & 0xFF) +
                    String.format("%02x", (result[i] & 0xFF00) >> 8) +
                    String.format("%02x", (result[i] & 0xFF0000) >> 16) +
                    String.format("%02x", (result[i] & 0xFF000000) >> 24);
        }
        return resultMessage;
    }

    //从inputBytes的index开始取512位，作为新的512bit的分组
    private static long[] divide(byte[] inputBytes, int start) {
        //存储一整个分组,就是512bit,数组里每个是32bit，就是4字节，为了消除符号位的影响，所以使用long
        long[] group = new long[16];
        for (int i = 0; i < 16; i++) {
            //每个32bit由4个字节拼接而来
            //小端的从byte数组到bit恢复方法
        	//“<<”表示循环左移位
            group[i] = byte2unsign(inputBytes[4 * i + start]) |
                    (byte2unsign(inputBytes[4 * i + 1 + start])) << 8 |
                    (byte2unsign(inputBytes[4 * i + 2 + start])) << 16 |
                    (byte2unsign(inputBytes[4 * i + 3 + start])) << 24;
        }
        return group;
    }

    //其实byte相当于一个字节的有符号整数，这里不需要符号位，所以把符号位去掉
    public static long byte2unsign(byte b) {
        return b < 0 ? b & 0x7F + 128 : b;//0x7F--0111 1111
    }

    // groups[] 中每一个分组512位（64字节）
    // MD5压缩函数
    private void H(long[] groups) {
        //缓冲区数组
        long a = result[0], b = result[1], c = result[2], d = result[3];
        //四轮循环
        for (int n = 0; n < 4; n++) {
            //16轮迭代
            for (int i = 0; i < 16; i++) {
                result[0] += (g(n, result[1], result[2], result[3]) & 0xFFFFFFFFL) + groups[k[n][i]] + T[n][i];
                result[0] = result[1] + ((result[0] & 0xFFFFFFFFL) << S[n][i % 4] | ((result[0] & 0xFFFFFFFFL) >>> (32 - S[n][i % 4])));
                //循环轮换
                long temp = result[3];
                result[3] = result[2];
                result[2] = result[1];
                result[1] = result[0];
                result[0] = temp;
            }
        }
        //加入之前计算的结果
        result[0] += a;
        result[1] += b;
        result[2] += c;
        result[3] += d;
        //防止溢出
        for (int n = 0; n < 4; n++) {
            result[n] &= 0xFFFFFFFFL;
        }
    }

    public static void main(String[] args) {
        MD5Source md = new MD5Source();
        //pwd的MD5：9003d1df22eb4d3820015070385194c8
        String message = "pwd";
        System.out.println("原始数据: " + message);
        System.out.println("加密结果: " + md.start(message));
        System.out.println("加密结果(Upper): " + md.resultMessage.toUpperCase());
    }
}

Part 3——MD5加盐

1、MD5+salt原理：
        MD5算法在保存用户密码信息的过程中，加入盐。盐可以是生成的随机数，也可以是自定义的数据。将密码结合MD5加盐，生成的数据摘要和盐保存起来 。以便于下次用户验证使用。就是在用户表里面，也保存salt。
2、为什么要MD5+盐：
        我们知道如果直接对密码进行散列，那么黑客可以对通过获得这个密码散列值，然后通过查散列值字典（如MD5密码破解网站），得到某用户的密码。
　　加Salt可以一定程度上解决这一问题。所谓加Salt方法，就是加点“佐料”。其基本想法是这样的：当用户首次提供密码时（通常是注册时），由系统自动往这个密码里撒一些“佐料”，然后再散列。而当用户登录时，系统为用户提供的代码撒上同样的“佐料”，然后散列，再比较散列值，已确定密码是否正确。
　　这里的“佐料”被称作“Salt值”，这个值是如果由系统随机生成的，并且只有系统知道。这样，即便两个用户使用了同一个密码，由于系统为它们生成的salt值不同，他们的散列值也是不同的。破解的几率大大减小。

实现代码

import java.util.Random;
import org.apache.commons.codec.binary.Hex;
import java.security.MessageDigest;

public class md5AddSalt {

	/**
	 * 普通MD5
	 * @param x 原文
	 * @return result 密文
	 */
	public static String MD5(String x) {
		MessageDigest m;
		String result = "";
		try {
			m = MessageDigest.getInstance("MD5");
			m.update(x.getBytes("UTF8"));
			byte s[] = m.digest();
			for (int i = 0; i < s.length; i++) {
				result += Integer.toHexString((0x000000ff & s[i]) | 0xffffff00).substring(6);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return result;
	}

	/**
	 * 加盐MD5
	 * @param password 原文
	 * @return String(cArr) 加盐后的密文
	 */
	public static String generate(String password) {
		Random r = new Random();
		StringBuilder sb = new StringBuilder(16);
		sb.append(r.nextInt(99999999)).append(r.nextInt(99999999));
		int len = sb.length();
		if (len < 16) {
			for (int i = 0; i < 16 - len; i++) {
				sb.append("0");
			}
		}
		String salt = sb.toString();
		//将“盐”加到明文中，并生成新的MD5码
		password = md5Hex(password + salt);
		//将“盐”混到新生成的MD5码中，之所以这样做是为了后期更方便的校验明文和秘文
		char[] cArr = new char[48];//MD5(32位)+Slat(16位)
		for (int i = 0; i < 48; i += 3) {
			cArr[i] = password.charAt(i / 3 * 2);
			char c = salt.charAt(i / 3);
			cArr[i + 1] = c;
			cArr[i + 2] = password.charAt(i / 3 * 2 + 1);
		}
		return new String(cArr);
	}

	/**
	 * 校验加盐后是否和原文一致
	 * @param password
	 * @param md5
	 * @return
	 */
	public static boolean verify(String password, String md5) {
		//先从MD5码中取出之前加的“盐”和加“盐”后生成的MD5码
		char[] cArr1 = new char[32];//MD5
		char[] cArr2 = new char[16];//Salt
		for (int i = 0; i < 48; i += 3) {
			cArr1[i / 3 * 2] = md5.charAt(i);
			cArr1[i / 3 * 2 + 1] = md5.charAt(i + 2);
			cArr2[i / 3] = md5.charAt(i + 1);
		}
		String salt = new String(cArr2);
		return md5Hex(password + salt).equals(new String(cArr1));
	}

	/*
	 * 获取十六进制字符串形式的MD5摘要
	 */
	private static String md5Hex(String src) {
		try {
			MessageDigest md5 = MessageDigest.getInstance("MD5");
			byte[] bs = md5.digest(src.getBytes());
			return new String(new Hex().encode(bs));
		} catch (Exception e) {
			return null;
		}
	}
}