遍歷所有MD5值解密算法：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SciTools
{
/// <summary>
/// 遍歷所有MD5值解密；
/// Test.Decrypt("adc31ceae10f3818ae2fc39d4b580bc9");
/// </summary>
public class Test
{
//public static void check2()
//{
// List<uint> a1 = new List<uint>();
// IntX int65536 = new IntX();
// while(int65536.haveNext())
// {
// uint result = MD5.md5_FF_Logic(int65536.Value());
// a1.Add(result);
// int65536.moveNext();
// }
// int x = a1.Count;
//}
//public static void test()
//{
// string s1 = "00000010000000000000000000000000";
// string s2 = "adc31ceae10f3818ae2fc39d4b580bc9";
// long startT = DateTime.Now.Ticks;
// string s3 = Test.Decrypt(s2);
// long startE = DateTime.Now.Ticks;
// long second = (startE - startT) / 10000 / 1000; // 85 s
//}
/// <summary>
/// MD5值總量 16^32 = 65536^8；
///
/// 普遍計算機遍歷預計耗時：85 * 16^26 / s;
///
/// </summary>
/// <param name="md5Str"></param>
/// <returns></returns>
public static string Decrypt(string md5Str)
{
BigIntX big = new BigIntX(8);
while(big.haveNext())
{
List<uint> value = big.Value();
big.moveNext();
uint[] X = new uint[16];
X[8] = 128;
X[14] = 256;
for (int i = 0; i < 8; i++) X[i] = value[i];
string str = MD5.calculate(X); // 計算對應md5值
if(str.Equals(md5Str))
{
string nativeStr = ToNativeStr(X);
return nativeStr;
}
}
return "";
}
/// <summary>
/// 將X數組還原爲原有字符串
/// </summary>
private static String ToNativeStr(uint[] X)
{
List<byte> list = new List<byte>();
for (int i = 0; i < 8; i++)
{
uint n = X[i];
for (int j = 0; j < 4; j++)
{
byte b = (byte)(n & 0xFF);
list.Add(b);
n = n >> 8;
}
}
byte[] Bytes = list.ToArray();
String Str = System.Text.Encoding.Default.GetString(Bytes);
return Str;
}
}
public class BigIntX
{
List<IntX> ValueList = new List<IntX>();
public BigIntX(int size)
{
for (int i = 0; i < size; i++)
{
ValueList.Add(new IntX());
}
}
private int index = 0;
/// <summary>
/// 是否存在下一個值
/// </summary>
public bool haveNext()
{
foreach (IntX x in ValueList)
{
if (x.haveNext()) return true;
}
return false;
}
/// <summary>
/// 獲取當前值
/// </summary>
public List<uint> Value()
{
List<uint> list = new List<uint>();
foreach (IntX x in ValueList)
{
list.Add(x.Value());
}
return list;
}
/// <summary>
/// 移動索引至下一個值
/// </summary>
public void moveNext()
{
IntX pre = null;
foreach (IntX x in ValueList)
{
if (pre != null)
{
pre.reset();
pre = null;
}
if (x.haveNext()) x.moveNext();
if (x.haveNext()) break;
else
{
pre = x;
}
}
}
public void reset()
{
foreach (IntX x in ValueList)
{
x.reset();
}
}
}
/// <summary>
/// 0000 -> ffff 有效取值範圍
/// </summary>
public class IntX
{
int index = 0;
public IntX()
{
Init();
}
/// <summary>
/// 是否存在下一個值
/// </summary>
public bool haveNext()
{
return index < R.Count;
}
/// <summary>
/// 獲取當前值
/// </summary>
public uint Value()
{
return R[index];
}
/// <summary>
/// 移動索引至下一個值
/// </summary>
public void moveNext()
{
index++;
}
/// <summary>
/// 重置
/// </summary>
public void reset()
{
index = 0;
}
#region 0000 -> ffff 有效取值範圍
/// <summary>
/// index = [0, 65535]
/// </summary>
public static uint Value(int index)
{
Init();
return R[index];
}
static byte[] Hex;
static List<uint> R = new List<uint>();
static void Init()
{
if (R.Count != 0) return;
// 字符取值範圍
Hex = new byte[16];
for (int i = 0; i < Hex.Length; i++)
{
if (0 <= i && i <= 9)
{
Hex[i] = (byte)((byte)'0' + i);
}
else
{
Hex[i] = (byte)((byte)'a' + (i - 10));
}
}
// uint取值範圍
//R = new uint[16 ^ 4];
for (int j1 = 0; j1 < 16; j1++)
{
uint n1 = Hex[j1];
for (int j2 = 0; j2 < 16; j2++)
{
uint n2 = (n1 << 8) + Hex[j2];
for (int j3 = 0; j3 < 16; j3++)
{
uint n3 = (n2 << 8) + Hex[j3];
for (int j4 = 0; j4 < 16; j4++)
{
uint n4 = (n3 << 8) + Hex[j4];
R.Add(n4);
}
}
}
}
}
#endregion
}
}
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace SciTools
{
//示例：
// MD5.Encrypt("a"); // 計算字符串MD5值
// MD5.Encrypt(new FileInfo("D:\\1.rar")); // 計算文件MD5值
// MD5.Encrypt(byte[] Bytes); // 計算Byte數組MD5值
//MD5 ("") = d41d8cd98f00b204e9800998ecf8427e
//MD5 ("a") = 0cc175b9c0f1b6a831c399e269772661
//MD5 ("abc") = 900150983cd24fb0d6963f7d28e17f72
//MD5 ("message digest") = f96b697d7cb7938d525a2f31aaf161d0
//MD5 ("abcdefghijklmnopqrstuvwxyz") = c3fcd3d76192e4007dfb496cca67e13b
class MD5
{
#region MD5調用接口
/// <summary>
/// 計算data的MD5值
/// </summary>
public static string Encrypt(string data)
{
uint[] X = To16Array(data);
string Str = ToNativeStr(X);
return calculate(X);
}
/// <summary>
/// 計算byte數組的MD5值
/// </summary>
public static string Encrypt(byte[] Bytes)
{
uint[] X = To16Array(Bytes);
return calculate(X);
}
/// <summary>
/// 計算文件的MD5值
/// </summary>
public static string Encrypt(FileInfo file)
{
uint[] X = To16Array(file);
return calculate(X);
}
#endregion
#region MD5計算邏輯
/// <summary>
/// 轉化byte數組爲uint數組，數組長度爲16的倍數
///
/// 1、字符串轉化爲字節數組，每4個字節轉化爲一個uint，依次存儲到uint數組
/// 2、附加0x80作爲最後一個字節
/// 3、在uint數組最後位置記錄文件字節長度信息
/// </summary>
public static uint[] To16Array(byte[] Bytes)
{
uint DataLen = (uint)Bytes.Length;
// 計算FileLen對應的uint長度（要求爲16的倍數、預留2個uint、最小爲16）
uint ArrayLen = (((DataLen + 8) / 64) + 1) * 16;
uint[] Array = new uint[ArrayLen];
uint ArrayPos = 0;
int pos = 0;
uint ByteCount = 0;
for (ByteCount = 0; ByteCount < DataLen; ByteCount++)
{
// 每4個Byte轉化爲1個uint
ArrayPos = ByteCount / 4;
pos = (int)(ByteCount % 4) * 8;
Array[ArrayPos] = Array[ArrayPos] | ((uint)Bytes[ByteCount] << pos);
}
// 附加0x80作爲最後一個字節，添加到uint數組對應位置
ArrayPos = ByteCount / 4;
pos = (int)(ByteCount % 4) * 8;
Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);
// 記錄總長度信息
Array[ArrayLen - 2] = (DataLen << 3);
Array[ArrayLen - 1] = (DataLen >> 29);
return Array;
}
/// <summary>
/// 轉化字符串爲uint數組，數組長度爲16的倍數
///
/// 1、字符串轉化爲字節數組，每4個字節轉化爲一個uint，依次存儲到uint數組
/// 2、附加0x80作爲最後一個字節
/// 3、在uint數組最後位置記錄文件字節長度信息
/// </summary>
public static uint[] To16Array(string data)
{
byte[] datas = System.Text.Encoding.Default.GetBytes(data);
return To16Array(datas);
}
/// <summary>
/// 轉化文件爲uint數組，數組長度爲16的倍數
///
/// 1、讀取文件字節信息，每4個字節轉化爲一個uint，依次存儲到uint數組
/// 2、附加0x80作爲最後一個字節
/// 3、在uint數組最後位置記錄文件字節長度信息
/// </summary>
public static uint[] To16Array(FileInfo info)
{
FileStream fs = new FileStream(info.FullName, FileMode.Open);// 讀取方式打開，得到流
int SIZE = 1024 * 1024 * 10; // 10M緩存
byte[] datas = new byte[SIZE]; // 要讀取的內容會放到這個數組裏
int countI = 0;
long offset = 0;
// 計算FileLen對應的uint長度（要求爲16的倍數、預留2個uint、最小爲16）
uint FileLen = (uint)info.Length;
uint ArrayLen = (((FileLen + 8) / 64) + 1) * 16;
uint[] Array = new uint[ArrayLen];
int pos = 0;
uint ByteCount = 0;
uint ArrayPos = 0;
while (ByteCount < FileLen)
{
if (countI == 0)
{
fs.Seek(offset, SeekOrigin.Begin);// 定位到指定字節
fs.Read(datas, 0, datas.Length);
offset += SIZE;
}
// 每4個Byte轉化爲1個uint
ArrayPos = ByteCount / 4;
pos = (int)(ByteCount % 4) * 8;
Array[ArrayPos] = Array[ArrayPos] | ((uint)datas[countI] << pos);
ByteCount = ByteCount + 1;
countI++;
if (countI == SIZE) countI = 0;
}
// 附加0x80作爲最後一個字節，添加到uint數組對應位置
ArrayPos = ByteCount / 4;
pos = (int)(ByteCount % 4) * 8;
Array[ArrayPos] = Array[ArrayPos] | ((uint)0x80 << pos);
// 記錄總長度信息
Array[ArrayLen - 2] = (FileLen<< 3);
Array[ArrayLen - 1] = (FileLen>>29);
fs.Close();
return Array;
}
/// <summary>
/// 將X數組還原爲原有字符串
/// </summary>
private static String ToNativeStr(uint[] X)
{
List<byte> list = new List<byte>();
for (int i = 0; i < 8; i++)
{
uint n = X[i];
for (int j = 0; j < 4; j++)
{
byte b = (byte)(n & 0xFF);
list.Add(b);
n = n >> 8;
}
}
byte[] Bytes = list.ToArray();
String Str = System.Text.Encoding.Default.GetString(Bytes);
return Str;
}
private static uint F(uint x, uint y, uint z)
{
return (x & y) | ((~x) & z);
}
private static uint G(uint x, uint y, uint z)
{
return (x & z) | (y & (~z));
}
// 0^0^0 = 0
// 0^0^1 = 1
// 0^1^0 = 1
// 0^1^1 = 0
// 1^0^0 = 1
// 1^0^1 = 0
// 1^1^0 = 0
// 1^1^1 = 1
private static uint H(uint x, uint y, uint z)
{
return (x ^ y ^ z);
}
private static uint I(uint x, uint y, uint z)
{
return (y ^ (x | (~z)));
}
// 循環左移
private static uint RL(uint x, int y)
{
y = y % 32;
return (x << y) | (x >> (32 - y));
}
private static void md5_FF(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
{
uint f = F(b, c, d);
a = x + ac + a + f;
a = RL(a, s);
a = a + b;
}
//public static uint md5_FF_Logic(uint x)
//{
// uint a = 0x67452301;
// uint b = 0xEFCDAB89;
// uint c = 0x98BADCFE;
// uint d = 0x10325476;
// int S11 = 7;
// uint a1 = a;
// md5_FF(ref a1, b, c, d, x, S11, 0xD76AA478); // 3604027302
// return a1;
//}
private static void md5_GG(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
{
uint g = G(b, c, d);
a = x + ac + a + g;
a = RL(a, s);
a = a + b;
}
private static void md5_HH(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
{
uint h = H(b, c, d);
a = x + ac + a + h;
a = RL(a, s);
a = a + b;
}
private static void md5_II(ref uint a, uint b, uint c, uint d, uint x, int s, uint ac)
{
uint i = I(b, c, d);
a = x + ac + a + i;
a = RL(a, s);
a = a + b;
}
private static string RHex(uint n)
{
string S = Convert.ToString(n, 16);
return ReOrder(S);
}
// 16進制串重排序 67452301 -> 01234567
private static string ReOrder(String S)
{
string T = "";
for (int i = S.Length - 2; i >= 0; i = i - 2)
{
if (i == -1) T = T + "0" + S[i + 1];
else T = T + "" + S[i] + S[i + 1];
}
return T;
}
/// <summary>
/// 對長度爲16倍數的uint數組，執行md5數據摘要，輸出md5信息
///
/// 根據a、b、c、d X[i] -> a的映射規則，構建逆向檢索表，有可能通過檢索獲取所有MD5原有串
/// </summary>
public static string calculate(uint[] x)
{
//uint time1 = DateTime.Now.Ticks;
// 7 12 17 22
// 5 9 14 20
// 4 11 16 23
// 6 10 15 21
const int S11 = 7;
const int S12 = 12;
const int S13 = 17;
const int S14 = 22;
const int S21 = 5;
const int S22 = 9;
const int S23 = 14;
const int S24 = 20;
const int S31 = 4;
const int S32 = 11;
const int S33 = 16;
const int S34 = 23;
const int S41 = 6;
const int S42 = 10;
const int S43 = 15;
const int S44 = 21;
uint a = 0x67452301;
uint b = 0xEFCDAB89;
uint c = 0x98BADCFE;
uint d = 0x10325476;
for (int k = 0; k < x.Length; k += 16)
{
uint AA = a;
uint BB = b;
uint CC = c;
uint DD = d;
md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478);
md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756);
md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB);
md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A);
md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613);
md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501);
md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8);
md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE);
md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122);
md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193);
md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E);
md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821);
md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562);
md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340);
md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51);
md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D);
md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453);
md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681);
md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6);
md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87);
md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED);
md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905);
md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9);
md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942);
md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681);
md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122);
md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C);
md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6);
md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA);
md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085);
md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05);
md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039);
md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665);
md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244);
md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97);
md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7);
md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039);
md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3);
md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1);
md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314);
md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1);
md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82);
md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235);
md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);
a = a + AA;
b = b + BB;
c = c + CC;
d = d + DD;
}
string MD5 = RHex(a) + RHex(b) + RHex(c) + RHex(d);
//uint time2 = DateTime.Now.Ticks;
//MessageBox.Show("MD5計算耗時：" + ((time2 - time1) / 10000000f) + "秒");
return MD5;
}
#endregion
}
}
遍歷，時間上不可行。