标签：null 是你 加密方式 需要 初始 保存 数据处理 转换 alt
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方法有：王小云破解。
标签：null 是你 加密方式 需要 初始 保存 数据处理 转换 alt
原文地址：https://www.cnblogs.com/jssj/p/12001431.html
