MD5解密为什么不能成功（解密算法）
MD5解密为什么不能成功（解密算法）
首先MD5的密文数量36的32次方；
不加盐，不迭代，A-Z,a-z,0-9，8-16位密码，计算量：62的8次方至62的16次方
工具类
暴力算法
结合数据库实现
补充说明（原因）
生成密文的工具类
package com.decrypt;
import org.apache.shiro.crypto.hash.SimpleHash;
public class Decyrpt {
private static final String AGT = "md5";
//迭代，加盐
public static String encryption(String q1, Object q2,int COUNT) {
SimpleHash sp1 = new SimpleHash(AGT, q1, q2, COUNT);
return sp1.toString();
}
//不迭代，加盐
public static String encryption(String q1, Object q2) {
SimpleHash sp1 = new SimpleHash(AGT, q1, q2);
return sp1.toString();
}
//不加盐，不迭代
public static String encryption(String q1) {
SimpleHash sp1 = new SimpleHash(AGT, q1);
return sp1.toString();
}
}
暴力算法：逻辑大概就是如此
package com.decrypt.util;
import com.decrypt.Decyrpt;
public class ForUtils {
private static String[] chars = new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
"K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
public static String forUtil(String decyrpt) {
String password = "";
//8位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
//9位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
//10位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
//11位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
//12位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
for (int t = 0; t < chars.length; t++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s] + chars[t];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
//13位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
for (int t = 0; t < chars.length; t++) {
for (int u = 0; u < chars.length; u++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s] + chars[t] + chars[u];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
//14位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
for (int t = 0; t < chars.length; t++) {
for (int u = 0; u < chars.length; u++) {
for (int v = 0; v < chars.length; v++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s] + chars[t] + chars[u] + chars[v];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
//15位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
for (int t = 0; t < chars.length; t++) {
for (int u = 0; u < chars.length; u++) {
for (int v = 0; v < chars.length; v++) {
for (int w = 0; w < chars.length; w++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s] + chars[t] + chars[u] + chars[v] + chars[w];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
//16位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
for (int r = 0; r < chars.length; r++) {
for (int s = 0; s < chars.length; s++) {
for (int t = 0; t < chars.length; t++) {
for (int u = 0; u < chars.length; u++) {
for (int v = 0; v < chars.length; v++) {
for (int w = 0; w < chars.length; w++) {
for (int x = 0; x < chars.length; x++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p] + chars[r] + chars[s] + chars[t] + chars[u] + chars[v] + chars[w] + chars[x];
if (decyrpt.equals(Decyrpt.encryption(password))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
//加盐，普通盐,一颗
for (int i1 = 0; i1 < chars.length; i1++) {
//9位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p];
if (decyrpt.equals(Decyrpt.encryption(password, i1))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
int s1=0;
//加盐，迭代
while (true) {
s1+=1;
//加盐，普通盐,一颗
for (int i1 = 0; i1 < chars.length; i1++) {
//9位
for (int i = 0; i < chars.length; i++) {
for (int j = 0; j < chars.length; j++) {
for (int k = 0; k < chars.length; k++) {
for (int l = 0; l < chars.length; l++) {
for (int m = 0; m < chars.length; m++) {
for (int n = 0; n < chars.length; n++) {
for (int o = 0; o < chars.length; o++) {
for (int p = 0; p < chars.length; p++) {
for (int q = 0; q < chars.length; q++) {
password = chars[i] + chars[j] + chars[k] + chars[l] + chars[m] + chars[n] + chars[o] + chars[p] + chars[p];
if (decyrpt.equals(Decyrpt.encryption(password, i1,s1))) {
return password;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
结合数据库实现的算法
package com.decrypt.util;
import com.decrypt.Decyrpt;
import java.util.Random;
public class DatabaseUtil {
/*为减少重复的代码量我们可以使用数据库来做联查
* 需要四张表盐（id,数据），密码表（id, 随机生成的密码，密文），迭代次数表（id,随机数）,随机数表（id,生成的随机数）
* */
private static String[] chars = new String[]{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J",
"K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"};
//存储62的8次方至62的16次方的值
private static String[] number1 = new String[]{"111111111111111111100000000000"};
//位数
private static int iur = 8;
//不加盐，不迭代
public static String forUtil(String decyrpt) {
String s1 = "";
for (; ; ) {
for (int i = 0; i <= iur; i++) {
Random random = new Random();
int i1 = random.nextInt(61 - 0);
s1 += chars[i1];
}
/*这里把拿到的字符串拿到数据库对比如果是true(即该数据不存在)执行if
* boolean select(String s1)
*
* */
if (true) {
String encryption = Decyrpt.encryption(s1);
//这里可以将得到的密文和字符串存储起来，在未来可以做数据对比
if (encryption.equals(decyrpt)) {
return s1;
}
}
/* 这里要对数据库的数据量进行一个查询，如果数据量达到62的8次方，就执行if（）
* 当然如果表的无法储存这么大的数据量，我们可以让id来计数，使用包装类来对数据进行转换
*
* */
//记录数应从数据库中查询
int count = 100000000;
//number1字符数组计数器
int i = 0;
//8的62次方number1
String conut1 = Integer.toString(count);
if (conut1.equals(number1[i])) {
iur += 1;
i += 1;
}
}
}
//加盐后的数据将存进新的表
public static String forUtils(String decyrpt) {
String s1 = "";
int i2=1;
String s2= DatabaseUtil.salt(i2);
for (; ; ) {
for (int i = 0; i <= iur; i++) {
Random random = new Random();
int i1 = random.nextInt(61 - 0);
s1 += chars[i1];
}
/*这里把拿到的字符串拿到数据库对比如果是true执行if
* boolean select(String s1)
* */
if (true) {
String encryption = Decyrpt.encryption(s1,s2);
//这里可以将得到的密文和字符串存储起来，在未来可以做数据对比
if (encryption.equals(decyrpt)) {
return s1;
}
}
/* 这里要对数据库的数据量进行一个查询，如果数据量达到8的62次方，就执行if（）
* 当然如果表的无法储存这么大的数据量，我们可以让id来计数，使用包装类来对数据进行转换
*
* */
//记录数应从数据库中查询
int count = 100000000;
//number1字符数组计数器
int i = 0;
//8的62次方number1
String conut1 = Integer.toString(count);
if (conut1.equals(number1[i])) {
iur += 1;
i2+=1;
//当数据量到达一定级别时重新获取盐
s2 = DatabaseUtil.salt(i2);
i += 1;
}
}
}
//加盐，迭代
public static String forUtils1(String decyrpt) {
String s1 = "";
int i2=1;
String s2= DatabaseUtil.salt(i2);
int i3=0;
while (true){
i3+=1;
for (; ; ) {
for (int i = 0; i <= iur; i++) {
Random random = new Random();
int i1 = random.nextInt(61 - 0);
s1 += chars[i1];
}
/*这里把拿到的字符串拿到数据库对比如果是true执行if
* boolean select(String s1)
* */
if (true) {
String encryption = Decyrpt.encryption(s1,s2,i3);
//这里可以将得到的密文和字符串存储起来，在未来可以做数据对比
if (encryption.equals(decyrpt)) {
return s1;
}
}
/* 这里要对数据库的数据量进行一个查询，如果数据量达到8的62次方，就执行if（）
* 当然如果表的无法储存这么大的数据量，我们可以让id来计数，使用包装类来对数据进行转换
*
* */
//记录数应从数据库中查询
int count = 100000000;
//number1字符数组计数器
int i = 0;
//8的62次方number1
String conut1 = Integer.toString(count);
if (conut1.equals(number1[i])) {
iur += 1;
i2+=1;
//当数据量到达一定级别时重新获取盐
s2 = DatabaseUtil.salt(i2);
i += 1;
}
}
}
}
//生成盐的算法
public static String salt(int salt1) {
String s2 = "";
for (;;) {
//生成对应长度的盐
for (int i = 0; i <= salt1; i++) {
Random random = new Random();
int i1 = random.nextInt(61 - 0);
s2 += chars[i1];
}
//将s2填入selectSalt(String s2)方法，如果存在不进入if
//如过该盐存在在数据库重新生成
if (true) {
return s2;
}
}
}
}
补充说明：
解密的方式大概就是这么一个思路，单从数据量来说，这是一个成本极大的工程，如果在加密过程中把账号作为盐，之后对盐进行加密，通过绑定邮箱和电话号码的方式把账号存储在其他系统中，如果需要获取邮箱的验证码或者电话的验证码，成本就更加大了。md5不可解密主要原因是因为算力和时间成本，还有时效。