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

《Java知识应用》Java加密方式(MD5)详解的更多相关文章

  1. 转 Java虚拟机5:Java垃圾回收(GC)机制详解

    转 Java虚拟机5:Java垃圾回收(GC)机制详解 Java虚拟机5:Java垃圾回收(GC)机制详解 哪些内存需要回收? 哪些内存需要回收是垃圾回收机制第一个要考虑的问题,所谓“要回收的垃圾”无 ...

  2. Java生鲜电商平台-Java后端生成Token架构与设计详解

    Java生鲜电商平台-Java后端生成Token架构与设计详解 目的:Java开源生鲜电商平台-Java后端生成Token目的是为了用于校验客户端,防止重复提交. 技术选型:用开源的JWT架构. 1. ...

  3. Java面试题(1):详解int与Integer

    Java面试题(1):详解int与Integer int与Integer的区别 int是Java的基本数据类型之一,Integer是int的包装类 int直接再内存中储存值,Integer进行new操 ...

  4. 把java文件打包成.jar (jar命令详解)

    把java文件打包成.jar (jar命令详解) 先打开命令提示符(win2000或在运行框里执行cmd命令,win98为DOS提示符),输入jar Chelp,然后回车(如果你盘上已经有了jdk1. ...

  5. Java进阶(三十二) HttpClient使用详解

    Java进阶(三十二) HttpClient使用详解 Http协议的重要性相信不用我多说了,HttpClient相比传统JDK自带的URLConnection,增加了易用性和灵活性(具体区别,日后我们 ...

  6. Java WebService接口生成和调用 图文详解>【转】【待调整】

    webservice简介: Web Service技术, 能使得运行在不同机器上的不同应用无须借助附加的.专门的第三方软件或硬件, 就可相互交换数据或集成.依据Web Service规范实施的应用之间 ...

  7. Java中的equals和hashCode方法详解

    Java中的equals和hashCode方法详解  转自 https://www.cnblogs.com/crazylqy/category/655181.html 参考:http://blog.c ...

  8. JAVA消息服务JMS规范及原理详解

    JAVA消息服务JMS规范及原理详解 一.简介 JMS即Java消息服务(Java Message Service)应用程序接口,是一个Java平台中关于面向消息中间件(MOM)的API,用于在两个应 ...

  9. Java基础-反射(reflect)技术详解

    Java基础-反射(reflect)技术详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.类加载器 1>.JVM 类加载机制  如下图所示,JVM类加载机制分为五个部分 ...

  10. Java基础-DBCP连接池(BasicDataSource类)详解

    Java基础-DBCP连接池(BasicDataSource类)详解 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任. 实际开发中“获得连接”或“释放资源”是非常消耗系统资源的两个过程 ...

随机推荐

  1. 无法优化的O(n!) 算法

    旅行商问题: 有一位旅行商,他需要前往5个城市. 要前往这5个城市,同时要确保旅程最短. 对于每种顺序,他都计算总旅程,再挑选出旅程最短的路线.5个城市有120种不同的排列方式.因此,在涉及5个城市时 ...

  2. ubuntu 16.04源码编译和配置caffe详细教程 | Install and Configure Caffe on ubuntu 16.04

    本文首发于个人博客https://kezunlin.me/post/b90033a9/,欢迎阅读! Install and Configure Caffe on ubuntu 16.04 Series ...

  3. windows下搭建dubbo 环境(dubbo-admin和服务提供者消费者)

    ---恢复内容开始--- 一.  dubbo-admin管理控制台 从 https://github.com/apache/dubbo-admin clone项目到本地. 修改dubbo-admin- ...

  4. Java从零到企业级电商项目实战(第1章 课程介绍)

  5. Dart Learn Notes 03

    操作符 dart 有一套自己定义的操作符: 这里我就不再写了,直接copy一份官网的. 如果有过编程基础,上边展示的操作符应该都不陌生. 算术运算符 加: + 减: - 乘: * 除: / 取余: % ...

  6. linux ftp配置及实操

    一.基础知识: 1.ftp:file transfer protocal 及文件传输协,工作与应用层. 2.ftp协议的实现: 服务器端实现软件:vsftpd,pureftpd,filezilla s ...

  7. C#异步案例一则

    场景 生产者和消费者队列, 生产者有多个, 消费者也有多个, 生产到消费需要异步. 下面用一个Asp.NetCore Web-API项目来模拟 创建两个API, 一个Get(), 一个Set(), G ...

  8. 科学使用Log4View2

    目录 目录 前言 科学使用 编辑和调试程序集 调试程序集 编辑程序集 结语 推荐文献 目录 NLog日志框架使用探究-1 NLog日志框架使用探究-2 科学使用Log4View2 前言 这个标题很低调 ...

  9. Win10 SQLServer 未在本地计算机上注册“Microsoft.ACE.OLEDB.12.0”提供程序

    环境:Win10+SQLServer2014 场景:在SQLServer导入Excel时,选择Excel2007格式,提示:未在本地计算机上注册“Microsoft.ACE.OLEDB.12.0”提供 ...

  10. Chapter 02—Creating a dataset(Part2)

    三. 导入数据 图02-03:Source of data that can be imported into a dataset 11. 从键盘导入数据 (1)可能是最简单的数据导入方式. (2)使 ...