[原创]易语言动态混淆加密纯源码(可解密)

dat恶人

只要调用精易模块就可以直接使用(使用了精易模块的几个DLL)
源码无调用模块以图片为准,之前那份解密没加密钥,所以解密失败,总体代码没问题

  

子程序名	返回值类型	公开	备 注
bat_自创数据加密	文本型
参数名	类 型	参考	可空	数组	备 注
加密文本	文本型
密钥	文本型

变量名	类 型	静态	数组	备 注
初始数据	字节集
加密密钥	字节集
随机前置	字节集
随机前置减数	整数型
i	整数型
临时文本	文本型
x	文本型		0

x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }
初始数据 ＝ 到字节集 (“bat” ＋ 加密文本 ＋ “bat”)
' 调试输出 (到字节集 (“bater”))
加密密钥 ＝ 到字节集 (“bat” ＋ 密钥 ＋ “bat”)
' 混淆数据 - 无实际用处——————
随机前置 ＝ { 0, 0, 0 }
置随机数种子 ()
随机前置 [1] ＝ 取随机数 (0, 9)
随机前置 [2] ＝ 取随机数 (0, 9)
随机前置 [3] ＝ 取随机数 (0, 9)
初始数据 ＝ 初始数据 ＋ 随机前置
如果真 (密钥 ＝ “”)
随机前置减数 ＝ 取随机数 (0, 随机前置 [2])
随机前置 [2] ＝ 随机前置 [2] － 随机前置减数
初始数据 ＝ 随机前置 ＋ 初始数据
' 混淆数据 - 无实际用处——————
计次循环首 (取字节集长度 (加密密钥), i)
加密密钥 [i] ＝ 加密密钥 [i] ＋ 1
计次循环尾 ()
加密密钥 ＝ 双位排列 (加密密钥, 真)
' 加密过程↓
' 调试输出 (初始数据)
初始数据 ＝ 双位排列 (初始数据, 真)
' 调试输出 (初始数据)
初始数据 ＝ 加密密钥 ＋ 初始数据 ＋ 加密密钥
' 调试输出 (初始数据, 加密密钥)
初始数据 ＝ 双位排列 (初始数据, 真)
置随机数种子 ()
随机前置减数 ＝ 取随机数 (1, 5)
计次循环首 (取字节集长度 (初始数据), i)
如果 (i ％ 2 ＝ 1)
初始数据 [i] ＝ 初始数据 [i] ＋ 随机前置减数
初始数据 [i] ＝ 初始数据 [i] ＋ 随机前置减数 － 1
' 初始数据 [i] ＝ 右移 (初始数据 [i], 8)
计次循环尾 ()
初始数据 ＝ 双位排列 (初始数据, 真) ＋ { 0 }
i ＝ 取字节集长度 (初始数据)
初始数据 [i] ＝ 随机前置减数
随机前置 ＝ { 0, 0 }
置随机数种子 ()
随机前置 [1] ＝ 取随机数 (0, 9)
随机前置 [2] ＝ 取随机数 (0, 9)
初始数据 ＝ 随机前置 ＋ 初始数据
随机前置 [1] ＝ 随机前置 [1] ％ 2
随机前置 [2] ＝ 随机前置 [2] ％ 3
初始数据 ＝ 初始数据 ＋ 随机前置
临时文本 ＝ 字节集转十六进制 (初始数据)
' 调试输出 (临时文本)
' 临时文本 ＝ 加密_数位缩减 (临时文本, 真)
' 调试输出 (临时文本)
临时文本 ＝ 到文本 (十六进制转数值 (生成加密校验码 (临时文本)) ％ 3) ＋ 临时文本 ＋ 生成加密校验码 (临时文本)
' 临时文本 ＝ 到文本 (双位排列 (双位排列 (到字节集 (临时文本), 真), 真))
i ＝ 取随机数 (5, 75)
临时文本 ＝ x [i] ＋ x [i － 1] ＋ 临时文本 ＋ x [i ＋ 2] ＋ x [i ＋ 3]
' 调试输出 (临时文本)
临时文本 ＝ 三位排列 (到文本 (双位排列 (到字节集 (临时文本), 真)), 真)
' 调试输出 (i)
' 调试输出 (临时文本)
返回 (临时文本)

子程序名	返回值类型	公开	备 注
bat_自创数据加密_反	文本型
参数名	类 型	参考	可空	数组	备 注
解密文本	文本型
密钥	文本型

变量名	类 型	静态	数组	备 注
初始数据	字节集
长度	整数型
随机前置减数	整数型
i	整数型
加密密钥	字节集
随机前置	字节集
临时文本	文本型
x	文本型		0

x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }
临时文本 ＝ 解密文本
临时文本 ＝ 到文本 (双位排列 (到字节集 (三位排列 (临时文本, 假)), 假))
i ＝ 十六进制转数值 (取文本左边 (临时文本, 1))
如果真 (取文本左边 (临时文本, 2) ≠ x [i] ＋ x [i － 1] 或 取文本右边 (临时文本, 2) ≠ x [i ＋ 2] ＋ x [i ＋ 3])
返回 (“”)

解密文本 ＝ 取文本中间 (临时文本, 3, 取文本长度 (临时文本) － 4)
' 调试输出 (到文本 (双位排列 (到字节集 (解密文本), 真)))
临时文本 ＝ 取文本中间 (解密文本, 2, 取文本长度 (解密文本) － 2)
如果真 (生成加密校验码 (临时文本) ≠ 取文本右边 (解密文本, 1) 或 十六进制转数值 (生成加密校验码 (临时文本)) ％ 3 ≠ 到整数 (取文本左边 (解密文本, 1)))
返回 (“”)
' 临时文本 ＝ 加密_数位缩减 (临时文本, 假)
' 调试输出 (临时文本)
初始数据 ＝ 十六进制转字节集 (临时文本)
长度 ＝ 取字节集长度 (初始数据) － 4
如果真 (初始数据 [1] ％ 2 ≠ 初始数据 [长度 ＋ 3] 或 初始数据 [2] ％ 3 ≠ 初始数据 [长度 ＋ 4])
返回 (“”)
初始数据 ＝ 取字节集左边 (初始数据, 长度 ＋ 2)
初始数据 ＝ 取字节集右边 (初始数据, 长度)
随机前置减数 ＝ 初始数据 [长度]
初始数据 ＝ 双位排列 (取字节集左边 (初始数据, 长度 － 1), 假)
计次循环首 (取字节集长度 (初始数据), i)
如果 (i ％ 2 ＝ 1)
初始数据 [i] ＝ 初始数据 [i] － 随机前置减数
初始数据 [i] ＝ 初始数据 [i] － 随机前置减数 ＋ 1

计次循环尾 ()
初始数据 ＝ 双位排列 (初始数据, 假)
加密密钥 ＝ 到字节集 (“bat” ＋ 密钥 ＋ “bat”)
计次循环首 (取字节集长度 (加密密钥), i)
加密密钥 [i] ＝ 加密密钥 [i] ＋ 1
计次循环尾 ()
加密密钥 ＝ 双位排列 (加密密钥, 真)
' 调试输出 (取字节集左边 (初始数据, 取字节集长度 (初始数据) － 取字节集长度 (加密密钥)))
如果真 (取字节集左边 (初始数据, 取字节集长度 (加密密钥)) ≠ 加密密钥 或 取字节集右边 (初始数据, 取字节集长度 (加密密钥)) ≠ 加密密钥)
返回 (“”)
初始数据 ＝ 取字节集右边 (取字节集左边 (初始数据, 取字节集长度 (初始数据) － 取字节集长度 (加密密钥)), 取字节集长度 (初始数据) － 取字节集长度 (加密密钥) × 2)
初始数据 ＝ 双位排列 (初始数据, 假)
随机前置 ＝ 取字节集左边 (初始数据, 3)
长度 ＝ 取字节集长度 (初始数据)
初始数据 ＝ 取字节集右边 (取字节集左边 (初始数据, 长度 － 3), 长度 － 6)
临时文本 ＝ 到文本 (初始数据)
如果真 (取文本左边 (临时文本, 3) ≠ “bat” 或 取文本右边 (临时文本, 3) ≠ “bat”)
返回 (“”)
返回 (取文本中间 (临时文本, 4, 取文本长度 (临时文本) － 6))

子程序名	返回值类型	公开	备 注
三位排列	文本型
参数名	类 型	参考	可空	数组	备 注
输入文本	文本型
是否为未排列	逻辑型

变量名	类 型	静态	数组	备 注
len	整数型
单元1	整数型
单元2	整数型
单元3	整数型
明文1	文本型
明文2	文本型
明文3	文本型
最终返回文本	文本型
i	整数型
N	整数型

len ＝ 取文本长度 (输入文本)
如果 (是否为未排列)
如果 (len ％ 3 ＝ 1)
单元1 ＝ (len － 1) ÷ 3 ＋ 1
单元2 ＝ (len － 单元1) ÷ 2
如果 (len ％ 3 ＝ 0)
单元1 ＝ len ÷ 3
单元1 ＝ (len － 1) ÷ 3 ＋ 1
单元2 ＝ 单元1
单元3 ＝ len － 单元1 － 单元2
明文1 ＝ 取文本左边 (输入文本, 单元1)
明文2 ＝ 取文本中间 (输入文本, 单元1 ＋ 1, 单元2)
明文3 ＝ 取文本右边 (输入文本, 单元3)
计次循环首 (取文本长度 (输入文本), i)
判断 (i ％ 3 ＝ 1)
N ＝ N ＋ 1
最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文1, N, 1)
判断 (i ％ 3 ＝ 2)
最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文2, N, 1)
最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文3, N, 1)

计次循环尾 ()
计次循环首 (取文本长度 (输入文本), i)
判断 (i ％ 3 ＝ 1)
明文1 ＝ 明文1 ＋ 取文本中间 (输入文本, i, 1)
判断 (i ％ 3 ＝ 2)
明文2 ＝ 明文2 ＋ 取文本中间 (输入文本, i, 1)
明文3 ＝ 明文3 ＋ 取文本中间 (输入文本, i, 1)

计次循环尾 ()
最终返回文本 ＝ 明文1 ＋ 明文2 ＋ 明文3
' 调试输出 (最终返回文本)
返回 (最终返回文本)

子程序名	返回值类型	公开	备 注
双位排列	字节集
参数名	类 型	参考	可空	数组	备 注
输入字节集	字节集
是否为未排列	逻辑型

变量名	类 型	静态	数组	备 注
明文1	字节集
明文2	字节集
长度	整数型
前半长度	整数型
临时字节集	字节集
i	整数型
ii	整数型

长度 ＝ 取字节集长度 (输入字节集)
如果 (绝对取整 (长度 ÷ 2) ＝ 长度 ÷ 2)
前半长度 ＝ 长度 ÷ 2
前半长度 ＝ 长度 ÷ 2 ＋ 1

如果 (是否为未排列)
明文1 ＝ 取字节集左边 (输入字节集, 前半长度)
明文2 ＝ 取字节集右边 (输入字节集, 长度 － 前半长度)
临时字节集 ＝ 取空字节 (长度)
计次循环首 (长度, i)
如果 (i ％ 2 ＝ 1)
ii ＝ ii ＋ 1
临时字节集 [i] ＝ 明文1 [ii]
临时字节集 [i] ＝ 明文2 [ii]

计次循环尾 ()
明文1 ＝ 取空字节 (前半长度)
明文2 ＝ 取空字节 (长度 － 前半长度)
计次循环首 (长度, i)
如果 (i ％ 2 ＝ 1)
ii ＝ ii ＋ 1
明文1 [ii] ＝ 输入字节集 [i]
明文2 [ii] ＝ 输入字节集 [i]

计次循环尾 ()
临时字节集 ＝ 明文1 ＋ 明文2
返回 (临时字节集)

子程序名	返回值类型	公开	备 注
取空字节	字节集
参数名	类 型	参考	可空	数组	备 注
长度	整数型

变量名	类 型	静态	数组	备 注
字节集指针	整数型

如果真 (长度 ≤ 0)
置入代码 ({ 51, 192, 139, 229, 93, 194, 4, 0 })
字节集指针 ＝ HeapAlloc (GetProcessHeap (), 8, 长度 ＋ 8)
如果真 (字节集指针 ＝ 0)
置入代码 ({ 139, 229, 93, 194, 4, 0 })
置入代码 ({ 254, 0, 255, 117, 8, 143, 64, 4, 139, 229, 93, 194, 4, 0 })
返回 ({  })

子程序名	返回值类型	公开	备 注
字节集转十六进制	文本型
参数名	类 型	参考	可空	数组	备 注
原始字节集	字节集

变量名	类 型	静态	数组	备 注
len	整数型
byte	整数型
high	整数型
low	整数型
ret	字节集
len_ret	整数型
i	整数型
j	整数型

len ＝ 取字节集长度 (原始字节集)
len_ret ＝ len × 2
ret ＝ 取空字节 (len_ret ＋ 1)
变量循环首 (1, len_ret, 2, j)
i ＝ i ＋ 1
byte ＝ 原始字节集 [i]
如果 (byte ＞ 15)
high ＝ 位与 (右移 (byte, 4), 15)
如果 (high ＞ 9)
ret [j] ＝ high ＋ 55
ret [j] ＝ high ＋ 48

ret [j] ＝ 48
low ＝ 位与 (byte, 15)
如果 (low ＞ 9)
ret [j ＋ 1] ＝ low ＋ 55
ret [j ＋ 1] ＝ low ＋ 48

变量循环尾 ()
返回 (到文本 (ret))

子程序名	返回值类型	公开	备 注
十六进制转字节集	字节集
参数名	类 型	参考	可空	数组	备 注
原始16进制文本	文本型

变量名	类 型	静态	数组	备 注
bytes_ret	字节集
bytes	字节集
len	整数型
p1	整数型
byte1	整数型
byte2	整数型
i	整数型

bytes ＝ 到字节集 (原始16进制文本)
len ＝ 取字节集长度 (bytes)
如果真 (位与 (len, 1) ＝ 1)
bytes ＝ bytes ＋ { 0 }
len ＝ len ＋ 1
bytes [len] ＝ bytes [len － 1]
bytes [len － 1] ＝ 48
bytes_ret ＝ 取空字节 (右移 (len, 1))
变量循环首 (1, len, 2, p1)
i ＝ i ＋ 1
byte1 ＝ bytes [p1]
byte2 ＝ bytes [p1 ＋ 1]
判断 (byte1 ＞ 96)
byte1 ＝ byte1 － 87
判断 (byte1 ＞ 64)
byte1 ＝ byte1 － 55
byte1 ＝ byte1 － 48
判断 (byte2 ＞ 96)
byte2 ＝ byte2 － 87
判断 (byte2 ＞ 64)
byte2 ＝ byte2 － 55
byte2 ＝ byte2 － 48
bytes_ret [i] ＝ 左移 (byte1, 4) ＋ byte2
变量循环尾 ()
返回 (bytes_ret)

子程序名	返回值类型	公开	备 注
十六进制转数值	整数型
参数名	类 型	参考	可空	数组	备 注
十六进制文本	文本型

变量名	类 型	静态	数组	备 注
x	文本型
i	整数型

x ＝ “yPH!\m2ozx#@*sQFd3Z_t1LnI>Ac70E~u58rkGJX|4S'R[Owg9iBW6p{l.,%/hNqCUjVYDefKTb&?vaM;”
i ＝ 寻找文本 (x, 十六进制文本, , 假)
如果 (i ＝ -1)
返回 (81)
返回 (i)

子程序名	返回值类型	公开	备 注
生成加密校验码	文本型
参数名	类 型	参考	可空	数组	备 注
十六进制文本	文本型

变量名	类 型	静态	数组	备 注
x	文本型		0
i	整数型
n	整数型

x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }
计次循环首 (取文本长度 (十六进制文本), i)
n ＝ n ＋ 十六进制转数值 (取文本中间 (十六进制文本, i, 1)) ＋ 1
计次循环尾 ()
返回 (x [ (n － 1) ％ 79 ＋ 1])

.版本 2<br /> <br /> .子程序 bat_自创数据加密, 文本型, 公开<br /> .参数 加密文本, 文本型<br /> .参数 密钥, 文本型, 可空<br /> .局部变量 初始数据, 字节集<br /> .局部变量 加密密钥, 字节集<br /> .局部变量 随机前置, 字节集<br /> .局部变量 随机前置减数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 临时文本, 文本型<br /> .局部变量 x, 文本型, , "0"<br /> <br /> x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }<br /> 初始数据 ＝ 到字节集 (“bat” ＋ 加密文本 ＋ “bat”)<br /> ' 调试输出 (到字节集 (“bater”))<br /> 加密密钥 ＝ 到字节集 (“bat” ＋ 密钥 ＋ “bat”)<br /> ' 混淆数据 - 无实际用处——————<br /> 随机前置 ＝ { 0, 0, 0 }<br /> 置随机数种子 ()<br /> 随机前置 [1] ＝ 取随机数 (0, 9)<br /> 随机前置 [2] ＝ 取随机数 (0, 9)<br /> 随机前置 [3] ＝ 取随机数 (0, 9)<br /> 初始数据 ＝ 初始数据 ＋ 随机前置<br /> .如果真 (密钥 ＝ “”)<br />     随机前置减数 ＝ 取随机数 (0, 随机前置 [2])<br />     随机前置 [2] ＝ 随机前置 [2] － 随机前置减数<br /> .如果真结束<br /> 初始数据 ＝ 随机前置 ＋ 初始数据<br /> ' 混淆数据 - 无实际用处——————<br /> <br /> .计次循环首 (取字节集长度 (加密密钥), i)<br />     加密密钥 <i> ＝ 加密密钥 <i> ＋ 1<br /> .计次循环尾 ()<br /> 加密密钥 ＝ 双位排列 (加密密钥, 真)<br /> ' 加密过程↓<br /> ' 调试输出 (初始数据)<br /> 初始数据 ＝ 双位排列 (初始数据, 真)<br /> ' 调试输出 (初始数据)<br /> 初始数据 ＝ 加密密钥 ＋ 初始数据 ＋ 加密密钥<br /> ' 调试输出 (初始数据, 加密密钥)<br /> 初始数据 ＝ 双位排列 (初始数据, 真)<br /> 置随机数种子 ()<br /> 随机前置减数 ＝ 取随机数 (1, 5)<br /> <br /> .计次循环首 (取字节集长度 (初始数据), i)<br />     .如果 (i ％ 2 ＝ 1)<br />         初始数据 <i> ＝ 初始数据 <i> ＋ 随机前置减数<br />     .否则<br />         初始数据 <i> ＝ 初始数据 <i> ＋ 随机前置减数 － 1<br />     .如果结束<br />     ' 初始数据 <i> ＝ 右移 (初始数据 <i>, 8)<br /> .计次循环尾 ()<br /> <br /> 初始数据 ＝ 双位排列 (初始数据, 真) ＋ { 0 }<br /> i ＝ 取字节集长度 (初始数据)<br /> 初始数据 <i> ＝ 随机前置减数<br /> 随机前置 ＝ { 0, 0 }<br /> 置随机数种子 ()<br /> 随机前置 [1] ＝ 取随机数 (0, 9)<br /> 随机前置 [2] ＝ 取随机数 (0, 9)<br /> 初始数据 ＝ 随机前置 ＋ 初始数据<br /> 随机前置 [1] ＝ 随机前置 [1] ％ 2<br /> 随机前置 [2] ＝ 随机前置 [2] ％ 3<br /> 初始数据 ＝ 初始数据 ＋ 随机前置<br /> 临时文本 ＝ 字节集转十六进制 (初始数据)<br /> ' 调试输出 (临时文本)<br /> ' 临时文本 ＝ 加密_数位缩减 (临时文本, 真)<br /> ' 调试输出 (临时文本)<br /> 临时文本 ＝ 到文本 (十六进制转数值 (生成加密校验码 (临时文本)) ％ 3) ＋ 临时文本 ＋ 生成加密校验码 (临时文本)<br /> ' 临时文本 ＝ 到文本 (双位排列 (双位排列 (到字节集 (临时文本), 真), 真))<br /> i ＝ 取随机数 (5, 75)<br /> 临时文本 ＝ x <i> ＋ x [i － 1] ＋ 临时文本 ＋ x [i ＋ 2] ＋ x [i ＋ 3]<br /> ' 调试输出 (临时文本)<br /> 临时文本 ＝ 三位排列 (到文本 (双位排列 (到字节集 (临时文本), 真)), 真)<br /> ' 调试输出 (i)<br /> ' 调试输出 (临时文本)<br /> <br /> 返回 (临时文本)<br /> <br /> .子程序 bat_自创数据加密_反, 文本型, 公开<br /> .参数 解密文本, 文本型<br /> .参数 密钥, 文本型, 可空<br /> .局部变量 初始数据, 字节集<br /> .局部变量 长度, 整数型<br /> .局部变量 随机前置减数, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 加密密钥, 字节集<br /> .局部变量 随机前置, 字节集<br /> .局部变量 临时文本, 文本型<br /> .局部变量 x, 文本型, , "0"<br /> <br /> x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }<br /> 临时文本 ＝ 解密文本<br /> 临时文本 ＝ 到文本 (双位排列 (到字节集 (三位排列 (临时文本, 假)), 假))<br /> i ＝ 十六进制转数值 (取文本左边 (临时文本, 1))<br /> .如果真 (取文本左边 (临时文本, 2) ≠ x <i> ＋ x [i － 1] 或 取文本右边 (临时文本, 2) ≠ x [i ＋ 2] ＋ x [i ＋ 3])<br />     返回 (“”)<br /> .如果真结束<br /> <br /> 解密文本 ＝ 取文本中间 (临时文本, 3, 取文本长度 (临时文本) － 4)<br /> ' 调试输出 (到文本 (双位排列 (到字节集 (解密文本), 真)))<br /> 临时文本 ＝ 取文本中间 (解密文本, 2, 取文本长度 (解密文本) － 2)<br /> .如果真 (生成加密校验码 (临时文本) ≠ 取文本右边 (解密文本, 1) 或 十六进制转数值 (生成加密校验码 (临时文本)) ％ 3 ≠ 到整数 (取文本左边 (解密文本, 1)))<br />     返回 (“”)<br /> .如果真结束<br /> ' 临时文本 ＝ 加密_数位缩减 (临时文本, 假)<br /> ' 调试输出 (临时文本)<br /> 初始数据 ＝ 十六进制转字节集 (临时文本)<br /> 长度 ＝ 取字节集长度 (初始数据) － 4<br /> .如果真 (初始数据 [1] ％ 2 ≠ 初始数据 [长度 ＋ 3] 或 初始数据 [2] ％ 3 ≠ 初始数据 [长度 ＋ 4])<br />     返回 (“”)<br /> .如果真结束<br /> 初始数据 ＝ 取字节集左边 (初始数据, 长度 ＋ 2)<br /> 初始数据 ＝ 取字节集右边 (初始数据, 长度)<br /> 随机前置减数 ＝ 初始数据 [长度]<br /> 初始数据 ＝ 双位排列 (取字节集左边 (初始数据, 长度 － 1), 假)<br /> .计次循环首 (取字节集长度 (初始数据), i)<br />     .如果 (i ％ 2 ＝ 1)<br />         初始数据 <i> ＝ 初始数据 <i> － 随机前置减数<br />     .否则<br />         初始数据 <i> ＝ 初始数据 <i> － 随机前置减数 ＋ 1<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 初始数据 ＝ 双位排列 (初始数据, 假)<br /> 加密密钥 ＝ 到字节集 (“bat” ＋ 密钥 ＋ “bat”)<br /> .计次循环首 (取字节集长度 (加密密钥), i)<br />     加密密钥 <i> ＝ 加密密钥 <i> ＋ 1<br /> .计次循环尾 ()<br /> 加密密钥 ＝ 双位排列 (加密密钥, 真)<br /> ' 调试输出 (取字节集左边 (初始数据, 取字节集长度 (初始数据) － 取字节集长度 (加密密钥)))<br /> .如果真 (取字节集左边 (初始数据, 取字节集长度 (加密密钥)) ≠ 加密密钥 或 取字节集右边 (初始数据, 取字节集长度 (加密密钥)) ≠ 加密密钥)<br />     返回 (“”)<br /> .如果真结束<br /> 初始数据 ＝ 取字节集右边 (取字节集左边 (初始数据, 取字节集长度 (初始数据) － 取字节集长度 (加密密钥)), 取字节集长度 (初始数据) － 取字节集长度 (加密密钥) × 2)<br /> 初始数据 ＝ 双位排列 (初始数据, 假)<br /> 随机前置 ＝ 取字节集左边 (初始数据, 3)<br /> 长度 ＝ 取字节集长度 (初始数据)<br /> 初始数据 ＝ 取字节集右边 (取字节集左边 (初始数据, 长度 － 3), 长度 － 6)<br /> 临时文本 ＝ 到文本 (初始数据)<br /> .如果真 (取文本左边 (临时文本, 3) ≠ “bat” 或 取文本右边 (临时文本, 3) ≠ “bat”)<br />     返回 (“”)<br /> .如果真结束<br /> 返回 (取文本中间 (临时文本, 4, 取文本长度 (临时文本) － 6))<br /> <br /> .子程序 三位排列, 文本型<br /> .参数 输入文本, 文本型<br /> .参数 是否为未排列, 逻辑型<br /> .局部变量 len, 整数型<br /> .局部变量 单元1, 整数型<br /> .局部变量 单元2, 整数型<br /> .局部变量 单元3, 整数型<br /> .局部变量 明文1, 文本型<br /> .局部变量 明文2, 文本型<br /> .局部变量 明文3, 文本型<br /> .局部变量 最终返回文本, 文本型<br /> .局部变量 i, 整数型<br /> .局部变量 N, 整数型<br /> <br /> len ＝ 取文本长度 (输入文本)<br /> .如果 (是否为未排列)<br />     .如果 (len ％ 3 ＝ 1)<br />         单元1 ＝ (len － 1) ÷ 3 ＋ 1<br />         单元2 ＝ (len － 单元1) ÷ 2<br />     .否则<br />         .如果 (len ％ 3 ＝ 0)<br />             单元1 ＝ len ÷ 3<br />         .否则<br />             单元1 ＝ (len － 1) ÷ 3 ＋ 1<br />         .如果结束<br />         单元2 ＝ 单元1<br />     .如果结束<br />     单元3 ＝ len － 单元1 － 单元2<br />     明文1 ＝ 取文本左边 (输入文本, 单元1)<br />     明文2 ＝ 取文本中间 (输入文本, 单元1 ＋ 1, 单元2)<br />     明文3 ＝ 取文本右边 (输入文本, 单元3)<br />     .计次循环首 (取文本长度 (输入文本), i)<br />         .判断开始 (i ％ 3 ＝ 1)<br />             N ＝ N ＋ 1<br />             最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文1, N, 1)<br />         .判断 (i ％ 3 ＝ 2)<br />             最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文2, N, 1)<br />         .默认<br />             最终返回文本 ＝ 最终返回文本 ＋ 取文本中间 (明文3, N, 1)<br />         .判断结束<br /> <br />     .计次循环尾 ()<br /> .否则<br />     .计次循环首 (取文本长度 (输入文本), i)<br />         .判断开始 (i ％ 3 ＝ 1)<br />             明文1 ＝ 明文1 ＋ 取文本中间 (输入文本, i, 1)<br />         .判断 (i ％ 3 ＝ 2)<br />             明文2 ＝ 明文2 ＋ 取文本中间 (输入文本, i, 1)<br />         .默认<br />             明文3 ＝ 明文3 ＋ 取文本中间 (输入文本, i, 1)<br />         .判断结束<br /> <br />     .计次循环尾 ()<br />     最终返回文本 ＝ 明文1 ＋ 明文2 ＋ 明文3<br /> .如果结束<br /> ' 调试输出 (最终返回文本)<br /> 返回 (最终返回文本)<br /> <br /> .子程序 双位排列, 字节集<br /> .参数 输入字节集, 字节集<br /> .参数 是否为未排列, 逻辑型<br /> .局部变量 明文1, 字节集<br /> .局部变量 明文2, 字节集<br /> .局部变量 长度, 整数型<br /> .局部变量 前半长度, 整数型<br /> .局部变量 临时字节集, 字节集<br /> .局部变量 i, 整数型<br /> .局部变量 ii, 整数型<br /> <br /> 长度 ＝ 取字节集长度 (输入字节集)<br /> .如果 (绝对取整 (长度 ÷ 2) ＝ 长度 ÷ 2)<br />     前半长度 ＝ 长度 ÷ 2<br /> .否则<br />     前半长度 ＝ 长度 ÷ 2 ＋ 1<br /> .如果结束<br /> <br /> .如果 (是否为未排列)<br />     明文1 ＝ 取字节集左边 (输入字节集, 前半长度)<br />     明文2 ＝ 取字节集右边 (输入字节集, 长度 － 前半长度)<br />     临时字节集 ＝ 取空字节 (长度)<br />     .计次循环首 (长度, i)<br />         .如果 (i ％ 2 ＝ 1)<br />             ii ＝ ii ＋ 1<br />             临时字节集 <i> ＝ 明文1 [ii]<br />         .否则<br />             临时字节集 <i> ＝ 明文2 [ii]<br />         .如果结束<br /> <br />     .计次循环尾 ()<br /> .否则<br />     明文1 ＝ 取空字节 (前半长度)<br />     明文2 ＝ 取空字节 (长度 － 前半长度)<br />     .计次循环首 (长度, i)<br />         .如果 (i ％ 2 ＝ 1)<br />             ii ＝ ii ＋ 1<br />             明文1 [ii] ＝ 输入字节集 <i><br />         .否则<br />             明文2 [ii] ＝ 输入字节集 <i><br />         .如果结束<br /> <br />     .计次循环尾 ()<br />     临时字节集 ＝ 明文1 ＋ 明文2<br /> .如果结束<br /> 返回 (临时字节集)<br /> <br /> .子程序 取空字节, 字节集<br /> .参数 长度, 整数型<br /> .局部变量 字节集指针, 整数型<br /> <br /> .如果真 (长度 ≤ 0)<br />     置入代码 ({ 51, 192, 139, 229, 93, 194, 4, 0 })<br /> .如果真结束<br /> 字节集指针 ＝ HeapAlloc (GetProcessHeap (), 8, 长度 ＋ 8)<br /> .如果真 (字节集指针 ＝ 0)<br />     置入代码 ({ 139, 229, 93, 194, 4, 0 })<br /> .如果真结束<br /> 置入代码 ({ 254, 0, 255, 117, 8, 143, 64, 4, 139, 229, 93, 194, 4, 0 })<br /> 返回 ({  })<br /> <br /> .子程序 字节集转十六进制, 文本型<br /> .参数 原始字节集, 字节集<br /> .局部变量 len, 整数型<br /> .局部变量 byte, 整数型<br /> .局部变量 high, 整数型<br /> .局部变量 low, 整数型<br /> .局部变量 ret, 字节集<br /> .局部变量 len_ret, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 j, 整数型<br /> <br /> len ＝ 取字节集长度 (原始字节集)<br /> len_ret ＝ len × 2<br /> ret ＝ 取空字节 (len_ret ＋ 1)<br /> .变量循环首 (1, len_ret, 2, j)<br />     i ＝ i ＋ 1<br />     byte ＝ 原始字节集 <i><br />     .如果 (byte ＞ 15)<br />         high ＝ 位与 (右移 (byte, 4), 15)<br />         .如果 (high ＞ 9)<br />             ret [j] ＝ high ＋ 55<br />         .否则<br />             ret [j] ＝ high ＋ 48<br />         .如果结束<br /> <br />     .否则<br />         ret [j] ＝ 48<br />     .如果结束<br />     low ＝ 位与 (byte, 15)<br />     .如果 (low ＞ 9)<br />         ret [j ＋ 1] ＝ low ＋ 55<br />     .否则<br />         ret [j ＋ 1] ＝ low ＋ 48<br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> 返回 (到文本 (ret))<br /> <br /> .子程序 十六进制转字节集, 字节集<br /> .参数 原始16进制文本, 文本型<br /> .局部变量 bytes_ret, 字节集<br /> .局部变量 bytes, 字节集<br /> .局部变量 len, 整数型<br /> .局部变量 p1, 整数型<br /> .局部变量 byte1, 整数型<br /> .局部变量 byte2, 整数型<br /> .局部变量 i, 整数型<br /> <br /> bytes ＝ 到字节集 (原始16进制文本)<br /> len ＝ 取字节集长度 (bytes)<br /> .如果真 (位与 (len, 1) ＝ 1)<br />     bytes ＝ bytes ＋ { 0 }<br />     len ＝ len ＋ 1<br />     bytes [len] ＝ bytes [len － 1]<br />     bytes [len － 1] ＝ 48<br /> .如果真结束<br /> bytes_ret ＝ 取空字节 (右移 (len, 1))<br /> .变量循环首 (1, len, 2, p1)<br />     i ＝ i ＋ 1<br />     byte1 ＝ bytes [p1]<br />     byte2 ＝ bytes [p1 ＋ 1]<br />     .判断开始 (byte1 ＞ 96)<br />         byte1 ＝ byte1 － 87<br />     .判断 (byte1 ＞ 64)<br />         byte1 ＝ byte1 － 55<br />     .默认<br />         byte1 ＝ byte1 － 48<br />     .判断结束<br />     .判断开始 (byte2 ＞ 96)<br />         byte2 ＝ byte2 － 87<br />     .判断 (byte2 ＞ 64)<br />         byte2 ＝ byte2 － 55<br />     .默认<br />         byte2 ＝ byte2 － 48<br />     .判断结束<br />     bytes_ret <i> ＝ 左移 (byte1, 4) ＋ byte2<br /> .变量循环尾 ()<br /> 返回 (bytes_ret)<br /> <br /> .子程序 十六进制转数值, 整数型<br /> .参数 十六进制文本, 文本型<br /> .局部变量 x, 文本型<br /> .局部变量 i, 整数型<br /> <br /> x ＝ “yPH!\m2ozx#@*sQFd3Z_t1LnI>Ac70E~u58rkGJX|4S'R[Owg9iBW6p{l.,%/hNqCUjVYDefKTb&?vaM;”<br /> i ＝ 寻找文本 (x, 十六进制文本, , 假)<br /> .如果 (i ＝ -1)<br />     返回 (81)<br /> .否则<br />     返回 (i)<br /> .如果结束<br /> <br /> <br /> <br /> .子程序 生成加密校验码, 文本型<br /> .参数 十六进制文本, 文本型<br /> .局部变量 x, 文本型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 n, 整数型<br /> <br /> x ＝ { “y”, “P”, “H”, “!”, “\”, “m”, “2”, “o”, “z”, “x”, “#”, “@”, “*”, “s”, “Q”, “F”, “d”, “3”, “Z”, “_”, “t”, “1”, “L”, “n”, “I”, “>”, “A”, “c”, “7”, “0”, “E”, “~”, “u”, “5”, “8”, “r”, “k”, “G”, “J”, “X”, “|”, “4”, “S”, “'”, “R”, “[”, “O”, “w”, “g”, “9”, “i”, “B”, “W”, “6”, “p”, “{”, “l”, “.”, “,”, “%”, “/”, “h”, “N”, “q”, “C”, “U”, “j”, “V”, “Y”, “D”, “e”, “f”, “K”, “T”, “b”, “&”, “?”, “v”, “a”, “M”, “;” }<br /> .计次循环首 (取文本长度 (十六进制文本), i)<br />     n ＝ n ＋ 十六进制转数值 (取文本中间 (十六进制文本, i, 1)) ＋ 1<br /> .计次循环尾 ()<br /> 返回 (x [(n － 1) ％ 79 ＋ 1])

dat恶人

784326742 发表于 2022-12-14 00:56
嗯果然很牛鼻

没保存成功,下面解密没加密钥,加上就可以了,总体代码没问题

yangjig

谢谢分享!

wpzyan123

支持开源~！感谢分享

宁静清澈

多谢分享，

缥缈星云

这个厉害了

天蓝LW

6666666666666666

Dreamskeer

嘿嘿 不错哟

boomsa

支持开源~！感谢分享

红色恋曲

66666666666666666666666666

999858

不知道怎么用。

kiss18151

4444444444444