《Java知识应用》Java加密方式（MD5）详解

1. 应用

 使用MD5加密

因为：因为MD5的不可逆性，也可以保证你的key 是安全的，黑客无法通过原文和密文知晓你的key。

案例：

import java.math.BigInteger;
import java.security.MessageDigest;

public class MD5Util{

    /**
     * 使用MD5加密
     * @param plainText
     * @return
     */
    public static String encryptionByMD5(String plainText) {
        String md5code;
        try {
            byte[] secretBytes = MessageDigest.getInstance("md5").digest(plainText.getBytes());
            md5code = new BigInteger(1, secretBytes).toString(16);
            for (int i = 0; i < 32 - md5code.length(); i++) {
                md5code = "0" + md5code;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return md5code;
    }
}

import java.io.IOException;

public class Md5Test {

    public static void main(String[] args) throws IOException {
        //网络传输过程中被篡改很容易。
        //可逆加密也一样，只要让别人知道加密方式，就可以先还原再修改，再以同样的方式加密，一样篡改了传输信息。
        // 根据几种加密方式就可以推出你使用的加密方式。
        String str = "姓名=蕾蕾，支付=1000，账户：123";

        /**
         * 使用MD5是不可逆加密方式。
         * 就算黑客知道我是MD5加密的，他也不能通过密文反推我的原文是啥。
         */
        String result = MD5Util.encryptionByMD5(str);
        System.out.println(result);
        System.out.println("-----------实际使用场景------------");
        //先准备一个key 只有传输方和接收方知道。
        String key = "AHINTGJLL&&HH$%^";
        // 将原文和key拼接和一起使用MD5加密
        String resultMd5 = MD5Util.encryptionByMD5(str+key);
        //然后将原文和密文再拼接，然后传输。
        System.out.println(resultMd5);
        /**
         * 这样操作后，黑客拿到这个传输数据，改的了你的账户，金额，无法修改你的加密串，因为他无法知道你们约定的key:AHINTGJLL&&HH$%^.
         * 因为MD5的不可逆性，也可以保证你的key 是安全的，不能被黑客知晓。
         */
        System.out.println("传输：" +str+":"+resultMd5);
    }
}

运行结果：

2 MD5 加密原理（如何做到不可逆）

MD5算法特点：

1. 加密结果：固定长度。

2. 加密速度快。

3. 细微：原文改变一点，加密结果变化巨大。

4. 不可逆：

最简单的不可逆加密：比如 原文是“57” ，加密方式是相加得到“12”。 这个时候你发现你知道加密结果是12，但是你无法知道原文是什么，因为“57”，“66”，“48” 等都有可能。

当然按照上面的加密方法，虽然不知道原文，但是破解太简单了。

算法：

1、数据填充

对消息进行数据填充，使消息的长度对512取模得448，设消息长度为X，即满足X mod 512=448。根据此公式得出需要填充的数据长度。

填充方法：在消息后面进行填充，填充第一位为1，其余为0。

2、添加消息长度

在第一步结果之后再填充上原消息的长度，可用来进行的存储长度为64位。如果消息长度大于264，则只使用其低64位的值，即（消息长度 对 264取模）。

在此步骤进行完毕后，最终消息长度就是512的整数倍。

3、数据处理

准备需要用到的数据：

4个常数： A = 0x67452301, B = 0x0EFCDAB89, C = 0x98BADCFE, D = 0x10325476;
4个函数：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));
把消息分以512位为一分组进行处理，每一个分组进行4轮变换，以上面所说4个常数为起始变量进行计算，重新输出4个变量，以这4个变量再进行下一分组的运算，如果已经是最后一个分组，则这4个变量为最后的结果，即MD5值。

实现：

import java.math.BigInteger;
import java.util.Arrays;

public class MD5 {
    //标准的幻数
    private static final int A=0x67452301;
    private static final int B=0xefcdab89;
    private static final int C=0x98badcfe;
    private static final int D=0x10325476;
    
    //下面这些S11-S44实际上是一个4*4的矩阵，在四轮循环运算中用到
    static final int S11 = 7;
    static final int S12 = 12;
    static final int S13 = 17;
    static final int S14 = 22;

    static final int S21 = 5;
    static final int S22 = 9;
    static final int S23 = 14;
    static final int S24 = 20;

    static final int S31 = 4;
    static final int S32 = 11;
    static final int S33 = 16;
    static final int S34 = 23;

    static final int S41 = 6;
    static final int S42 = 10;
    static final int S43 = 15;
    static final int S44 = 21;

    //java不支持无符号的基本数据（unsigned）
    private int [] result={A,B,C,D};//存储hash结果，共4×32=128位，初始化值为（幻数的级联）
    //此重载方法是将传入的字符串加点特色(比如密码加密可以连同将用户名加入一起加密,这样就算密码和别人一样加密后的结果也不一样)
    private byte[] digest(String inputStr ,String salt) {
        return digest(salt+inputStr);
    }
    private byte[] digest(String inputStr){
        byte [] inputBytes=inputStr.getBytes();//将字符串转化成字节数组
        int byteLen=inputBytes.length;//长度（字节）
        int groupCount=0;//完整分组的个数
        groupCount=byteLen/64;//每组512位（64字节）
        int []groups=null;//每个小组(64字节)再细分后的16个小组(4字节)

        //处理每一个完整分组
        for(int step=0;step<groupCount;step++){
            groups=divGroup(inputBytes,step*64);//处理分组,将每一个完整分组16个小组(16×4)
            trans(groups);//处理分组，核心算法
        }

        //处理完整分组后的尾巴
        int rest=byteLen%64;//512位分组后的余数
        byte [] tempBytes=new byte[64];
        //余数小于<=56,先填充1,0数据,然后最后64位(8字节)储存长度
        if(rest<=56){
            //将尾巴先存储在临时数组中
            for(int i=0;i<rest;i++)
                tempBytes[i]=inputBytes[byteLen-rest+i];
            if(rest<56){
                //填充数据(448位之前第一个填充1,后面填充0)
                tempBytes[rest]=(byte)(1<<7);
                for(int i=1;i<56-rest;i++)
                    tempBytes[rest+i]=0;
            }
            //后64位储存原文实际长度(448-512),即8字节
            long len=byteLen<<3;//长度单位是bit 即原文字节数组长度×8
            for(int i=0;i<8;i++){
                tempBytes[56+i]=(byte)(len&0xFF);//每次取长度的低八位存入字节数组
                len=len>>8;//取完移除低八位
            }
            groups=divGroup(tempBytes,0);
            trans(groups);//处理分组
        }else{//余数大于56,需增加一组主循环,目的保证处理后的原文最后64位(8字节)储存长度
            for(int i=0;i<rest;i++)
                //将尾巴先存储在临时数组中
                tempBytes[i]=inputBytes[byteLen-rest+i];
            //填充数据(第一个填充1,后面填充0)
            tempBytes[rest]=(byte)(1<<7);
            for(int i=rest+1;i<64;i++)
                tempBytes[i]=0;
            groups=divGroup(tempBytes,0);
            trans(groups);//处理分组
            //前56元素填充0
            for(int i=0;i<56;i++)
                tempBytes[i]=0;
            //后64位储存原文实际长度(448-512),即8字节
            long len=(long)(byteLen<<3);
            for(int i=0;i<8;i++){
                tempBytes[56+i]=(byte)(len&0xFF);
                len=len>>8;
            }
            groups=divGroup(tempBytes,0);
            trans(groups);//处理分组
        }
        //将hash值转换成字节数组
        //int[] result={A,B,C,D};共4×32=128位,每八位转换一个byte类型,储存在一个结果集
        byte[] resultByte = new byte[16];
        for(int i = 0;i<4;i++) {
            for(int j = 0; j < 4; j++) {
                //每次取低八位
                resultByte[i*4+j] = (byte) (result[i] & 0xff);
                //取完移除
                result[i]=result[i]>>8;
            }
        }
        
        return resultByte;
    }

    /**
     * 从inputBytes的index开始取512位，作为新的分组
     * 将每一个512位的分组再细分成16个小组，每个小组64位（8个字节）
     * @param inputBytes
     * @param index
     * @return
     */
    private static int[] divGroup(byte[] inputBytes,int index){
        int [] temp=new int[16];
        for(int i=0;i<16;i++){
            //从byte数组中取四个元素组成一个int类型保存在数组中
            //b2iu方法是将byte的最高位符号位转化为代表数值位
            temp[i]=b2iu(inputBytes[4*i+index])|
                    (b2iu(inputBytes[4*i+1+index]))<<8|
                    (b2iu(inputBytes[4*i+2+index]))<<16|
                    (b2iu(inputBytes[4*i+3+index]))<<24;
        }
        //最后返回这分组
        return temp;
    }

    /**
     * 这时不存在符号位（符号位存储不再是代表正负），所以需要处理一下
     * @param b
     * @return
     */
    public static int b2iu(byte b){//0x7F + 128=0xff
        return b < 0 ? b & 0x7F + 128 : b;
    }

    /**
     * 主要的操作，四轮循环
     * @param groups--每一个分组512位（64字节）
     */
    private void trans(int[] groups) {
        int a = result[0], b = result[1], c = result[2], d = result[3];
        /*第一轮*/
        a = FF(a, b, c, d, groups[0], S11, 0xd76aa478); /* 1 */
        d = FF(d, a, b, c, groups[1], S12, 0xe8c7b756); /* 2 */
        c = FF(c, d, a, b, groups[2], S13, 0x242070db); /* 3 */
        b = FF(b, c, d, a, groups[3], S14, 0xc1bdceee); /* 4 */
        a = FF(a, b, c, d, groups[4], S11, 0xf57c0faf); /* 5 */
        d = FF(d, a, b, c, groups[5], S12, 0x4787c62a); /* 6 */
        c = FF(c, d, a, b, groups[6], S13, 0xa8304613); /* 7 */
        b = FF(b, c, d, a, groups[7], S14, 0xfd469501); /* 8 */
        a = FF(a, b, c, d, groups[8], S11, 0x698098d8); /* 9 */
        d = FF(d, a, b, c, groups[9], S12, 0x8b44f7af); /* 10 */
        c = FF(c, d, a, b, groups[10], S13, 0xffff5bb1); /* 11 */
        b = FF(b, c, d, a, groups[11], S14, 0x895cd7be); /* 12 */
        a = FF(a, b, c, d, groups[12], S11, 0x6b901122); /* 13 */
        d = FF(d, a, b, c, groups[13], S12, 0xfd987193); /* 14 */
        c = FF(c, d, a, b, groups[14], S13, 0xa679438e); /* 15 */
        b = FF(b, c, d, a, groups[15], S14, 0x49b40821); /* 16 */

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

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

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

        /*加入到之前计算的结果当中*/
        result[0] += a;
        result[1] += b;
        result[2] += c;
        result[3] += d;
        result[0]=result[0]&0xFFFFFFFF;
        result[1]=result[1]&0xFFFFFFFF;
        result[2]=result[2]&0xFFFFFFFF;
        result[3]=result[3]&0xFFFFFFFF;
    }

    /**
     * 下面是处理要用到的线性函数
     */
    private static int F(int x, int y, int z) {
        return (x & y) | ((~x) & z);
    }

    private static int G(int x, int y, int z) {
        return (x & z) | (y & (~z));
    }

    private static int H(int x, int y, int z) {
        return x ^ y ^ z;
    }

    private static int I(int x, int y, int z) {
        return y ^ (x | (~z));
    }

    private static int FF(int a, int b, int c, int d, int x, int s,
                          int ac) {
        a += (F(b, c, d)&0xFFFFFFFF) + x + ac;
        //<<<s表示循环左移s位,解决Java中无该运算符
        a = ((a&0xFFFFFFFF)<< s) | ((a&0xFFFFFFFF) >>> (32 - s));
        a += b;
        return (a&0xFFFFFFFF);
    }

    private static int GG(int a, int b, int c, int d, int x, int s,
                          int ac) {
        a += (G(b, c, d)&0xFFFFFFFF) + x + ac;
        a = ((a&0xFFFFFFFF) << s) | ((a&0xFFFFFFFF) >>> (32 - s));
        a += b;
        return (a&0xFFFFFFFF);
    }

    private static int HH(int a, int b, int c, int d, int x, int s,
                          long ac) {
        a += (H(b, c, d)&0xFFFFFFFF) + x + ac;
        a = ((a&0xFFFFFFFF) << s) | ((a&0xFFFFFFFF) >>> (32 - s));
        a += b;
        return (a&0xFFFFFFFF);
    }

    private static int II(int a, int b, int c, int d, int x, int s,
                          long ac) {
        a += (I(b, c, d)&0xFFFFFFFF) + x + ac;
        a = ((a&0xFFFFFFFF) << s) | ((a&0xFFFFFFFF) >>> (32 - s));
        a += b;
        return (a&0xFFFFFFFF);
    }
    //清除缓存,将int[] result={A,B,C,D},还原为初始状态
    public  void reset() {
        result[0] = A;
        result[1] = B;
        result[2] = C;
        result[3] = D;
    }
    
    public static void main(String []args){
        MD5 md=new MD5();
        byte[] digest = md.digest("姓名=蕾蕾，支付=1000，账户：123");
        String md5code = new BigInteger(1, digest).toString(16);
        for (int i = 0; i < 32 - md5code.length(); i++) {
            md5code = "0" + md5code;
        }
        System.out.println(md5code);
    }
}

运行结果：

对比Java 自带的MD5 加密结果一样。

破解MD5方法有：王小云破解。

参考：https://blog.csdn.net/JunhuiXie/article/details/100630841#%E7%AC%AC%E4%B8%80%E6%AD%A5%3A%E5%A4%84%E7%90%86%E5%8E%9F%E6%96%87%C2%A0