pcvx ccd 00000003算法

minivis

PC微信CCD 00000003加密算法过程中使用了一个固定的key
o1BI3{j_tayE5u+G

先填充对齐16字节大小

  

子程序名	返回值类型	公开	备 注
填充对齐	字节集
参数名	类 型	参考	可空	数组	备 注
in_data	字节集

变量名	类 型	静态	数组	备 注
len	整数型
补位	整数型
ret_data	字节集
i	整数型
补位字节集	字节集
补位字节	字节集

len ＝ 取字节集长度 (in_data)
补位 ＝ 16 － len ％ 16
判断 (补位 ≠ 16)
补位字节 ＝ 到字节集 (到字节 (补位))
计次循环首 (补位, i)
补位字节集 ＝ 补位字节集 ＋ 补位字节
计次循环尾 ()
ret_data ＝ in_data ＋ 补位字节集

ret_data ＝ in_data

.版本 2<br /> .子程序 填充对齐, 字节集<br /> .参数 in_data, 字节集<br /> .局部变量 len, 整数型<br /> .局部变量 补位, 整数型<br /> .局部变量 ret_data, 字节集<br /> .局部变量 i, 整数型<br /> .局部变量 补位字节集, 字节集<br /> .局部变量 补位字节, 字节集<br /> <br /> len ＝ 取字节集长度 (in_data)<br /> <br /> 补位 ＝ 16 － len ％ 16<br /> <br /> .判断开始 (补位 ≠ 16)<br />     补位字节 ＝ 到字节集 (到字节 (补位))<br /> <br />     .计次循环首 (补位, i)<br />         补位字节集 ＝ 补位字节集 ＋ 补位字节<br /> <br />     .计次循环尾 ()<br /> <br />     ret_data ＝ in_data ＋ 补位字节集<br /> <br /> <br /> <br /> .默认<br />     ret_data ＝ in_data<br /> .判断结束

获取需要加密的轮数

  

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

变量名	类 型	静态	数组	备 注
len	整数型
rounds	整数型

len ＝ 取字节集长度 (data)
rounds ＝ len ÷ 16
返回 (rounds)

.版本 2<br /> .子程序 get_rounds, 整数型<br /> .参数 data, 字节集<br /> .局部变量 len, 整数型<br /> .局部变量 rounds, 整数型<br /> <br /> len ＝ 取字节集长度 (data)<br /> rounds ＝ len ÷ 16<br /> 返回 (rounds)

然后每轮操作加密16字节大小数据
第一轮 将初始key 与 输入数据 xor， 后续每轮用 上一轮加密后的数据与 下一轮输入数据xor

  

子程序名	返回值类型	公开	备 注
异或一轮_128bit	字节集
参数名	类 型	参考	可空	数组	备 注
round_data	字节集
key_or_beforeround_data	字节集

变量名	类 型	静态	数组	备 注
i	整数型
tmp_byte	整数型
data_byte	字节集
key_byte	字节集
tmp_bytes	字节集
data_int	整数型
key_int	整数型

' 调试输出 (到十六_加空格 (round_data), 到十六_加空格 (key_or_beforeround_data))
计次循环首 (16, i)
data_byte ＝ 取字节集中间 (round_data, i, 1)
key_byte ＝ 取字节集中间 (key_or_beforeround_data, i, 1)
data_int ＝ 字节集_到整数 (data_byte)
key_int ＝ 字节集_到整数 (key_byte)
' 调试输出 (data_int, key_int)
tmp_byte ＝ 位异或 (data_int, key_int)
tmp_bytes ＝ tmp_bytes ＋ 到字节集 (到字节 (tmp_byte))
计次循环尾 ()
返回 (tmp_bytes)

.版本 2<br /> <br /> .子程序 异或一轮_128bit, 字节集<br /> .参数 round_data, 字节集<br /> .参数 key_or_beforeround_data, 字节集<br /> .局部变量 i, 整数型<br /> .局部变量 tmp_byte, 整数型<br /> .局部变量 data_byte, 字节集<br /> .局部变量 key_byte, 字节集<br /> .局部变量 tmp_bytes, 字节集<br /> .局部变量 data_int, 整数型<br /> .局部变量 key_int, 整数型<br /> <br /> ' 调试输出 (到十六_加空格 (round_data), 到十六_加空格 (key_or_beforeround_data))<br /> <br /> .计次循环首 (16, i)<br />     data_byte ＝ 取字节集中间 (round_data, i, 1)<br />     key_byte ＝ 取字节集中间 (key_or_beforeround_data, i, 1)<br /> <br />     data_int ＝ 字节集_到整数 (data_byte)<br />     key_int ＝ 字节集_到整数 (key_byte)<br /> <br />     ' 调试输出 (data_int, key_int)<br /> <br />     tmp_byte ＝ 位异或 (data_int, key_int)<br /> <br />     tmp_bytes ＝ tmp_bytes ＋ 到字节集 (到字节 (tmp_byte))<br /> <br /> .计次循环尾 ()<br /> <br /> <br /> 返回 (tmp_bytes)

然后矩阵重排列

  

子程序名	返回值类型	公开	备 注
矩阵排列	字节集
参数名	类 型	参考	可空	数组	备 注
data	字节集

变量名	类 型	静态	数组	备 注
ret_data	字节集
View	字节集		4,4
i	整数型
ii	整数型

计次循环首 (4, i)
计次循环首 (4, ii)
View [ii] [i] ＝ 取字节集中间 (data, ii ＋ 4 �� (i － 1), 1)
计次循环尾 ()
计次循环尾 ()
计次循环首 (4, i)
计次循环首 (4, ii)
ret_data ＝ ret_data ＋ View [i] [ii]
计次循环尾 ()
计次循环尾 ()
返回 (ret_data)

.版本 2<br /> <br /> .子程序 矩阵排列, 字节集<br /> .参数 data, 字节集<br /> .局部变量 ret_data, 字节集<br /> .局部变量 View, 字节集, , "4,4"<br /> .局部变量 i, 整数型<br /> .局部变量 ii, 整数型<br /> <br /> <br /> .计次循环首 (4, i)<br />     .计次循环首 (4, ii)<br />         View [ii] <i> ＝ 取字节集中间 (data, ii ＋ 4 × (i － 1), 1)<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> <br /> <br /> .计次循环首 (4, i)<br />     .计次循环首 (4, ii)<br />         ret_data ＝ ret_data ＋ View <i> [ii]<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> <br /> 返回 (ret_data)

再开始循环9次 加密处理本轮数据

先 行移位

  

[/i][/i]
[i][i].版本 2

子程序名	返回值类型	公开	备 注
行移位	字节集		ShiftRows
参数名	类 型	参考	可空	数组	备 注
data	字节集

变量名	类 型	静态	数组	备 注
row1	字节集
row2	字节集
row3	字节集
row4	字节集
new_row2	字节集
new_row3	字节集
new_row4	字节集

row1 ＝ 取字节集中间 (data, 1, 4)
row2 ＝ 取字节集中间 (data, 5, 4)
row3 ＝ 取字节集中间 (data, 9, 4)
row4 ＝ 取字节集中间 (data, 13, 4)
new_row2 ＝ 取字节集中间 (row2, 2, 3) ＋ 取字节集中间 (row2, 1, 1)
new_row3 ＝ 取字节集中间 (row3, 3, 2) ＋ 取字节集中间 (row3, 1, 2)
new_row4 ＝ 取字节集中间 (row4, 4, 1) ＋ 取字节集中间 (row4, 1, 3)
返回 (row1 ＋ new_row2 ＋ new_row3 ＋ new_row4)

</i></i><br /> <i><i>.版本 2<br /> <br /> .子程序 行移位, 字节集, , ShiftRows<br /> .参数 data, 字节集<br /> .局部变量 row1, 字节集<br /> .局部变量 row2, 字节集<br /> .局部变量 row3, 字节集<br /> .局部变量 row4, 字节集<br /> .局部变量 new_row2, 字节集<br /> .局部变量 new_row3, 字节集<br /> .局部变量 new_row4, 字节集<br /> <br /> row1 ＝ 取字节集中间 (data, 1, 4)<br /> row2 ＝ 取字节集中间 (data, 5, 4)<br /> row3 ＝ 取字节集中间 (data, 9, 4)<br /> row4 ＝ 取字节集中间 (data, 13, 4)<br /> <br /> new_row2 ＝ 取字节集中间 (row2, 2, 3) ＋ 取字节集中间 (row2, 1, 1)<br /> new_row3 ＝ 取字节集中间 (row3, 3, 2) ＋ 取字节集中间 (row3, 1, 2)<br /> new_row4 ＝ 取字节集中间 (row4, 4, 1) ＋ 取字节集中间 (row4, 1, 3)<br /> <br /> 返回 (row1 ＋ new_row2 ＋ new_row3 ＋ new_row4)

列混合 每次 T-table 偏移+0x4000 大小
返回0x40 大小数据

InvShiftRows_InvSubBytes


9次加密后 最后一轮的处理
行移位

查表替换

矩阵重排列

下一轮数据加密

如此便完成了对ccd zlib的加密（00000003算法）

核心代码

  

子程序名	返回值类型	公开	备 注
ccd_00000003_encrypt	文本型
参数名	类 型	参考	可空	数组	备 注
in_data	文本型
key	文本型

变量名	类 型	静态	数组	备 注
ori_data	字节集
ret_data	文本型
tmp_data	字节集
rounds	整数型
i	整数型
xor_data	字节集
key_or_beforedata	字节集
hex	文本型
bursts_arrgs	字节集
row_chgx	字节集
mix_col	字节集
out_addr	整数型
const_addr	整数型
out_bytes	字节集
const_bytes	字节集
len	整数型
n	整数型
const_addr_now	整数型
null	整数型
hex_all	文本型

ori_data ＝ 字节集_十六进制到字节集 (删全部空 (in_data))
ori_data ＝ 填充对齐 (ori_data)
rounds ＝ get_rounds (ori_data)
调试输出 (“[需要循环加密的轮数]”, rounds)
key_or_beforedata ＝ 到字节集 (key)
out_addr ＝ 申请内存 (4096, 真)
计次循环首 (rounds, i)
tmp_data ＝ 取字节集中间 (ori_data, (i － 1) × 16 ＋ 1, 16)
' 调试输出 (“[本次数据]”, 十六进制_添加空格 (字节集_字节集到十六进制 (tmp_data)))
' 调试输出 (“[本次密钥]”, 十六进制_添加空格 (字节集_字节集到十六进制 (key_or_beforedata)))
xor_data ＝ 异或一轮_128bit (tmp_data, key_or_beforedata)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (xor_data))
' 调试输出 (“[异或一轮]”, hex)
' 调试输出 (到文本 (i) ＋ “ 轮xor 完成 ----------------------------------------------------------”)
bursts_arrgs ＝ 矩阵排列 (xor_data)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (bursts_arrgs))
' 调试输出 (“[矩阵排列后]”, hex)
' 17 CA 4A 52 AD 05 E0 92 A1 91 BA 9B F1 0B C8 0E
计次循环首 (9, n)
' 调试输出 (到文本 (n) ＋ “ 轮开始 ----------------------------------------------------------”)
row_chgx ＝ 行移位 (bursts_arrgs)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (row_chgx))
' 调试输出 (到文本 (n) ＋ “ [行移位] 1”, hex)  ' 17 CA 4A 52 05 E0 92 AD BA 9B A1 91 0E F1 0B C8
const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 ( #t_table_txt )))
len ＝ 取字节集长度 (const_bytes)
const_addr ＝ 申请内存 (len, 真)
内存.写字节集 (-1, const_addr, const_bytes)
const_addr_now ＝ const_addr ＋ 进制_十六到十 (“4000”) �� (n － 1)
微信列混合算法 (out_addr, 取变量数据地址 (row_chgx), const_addr_now)
out_bytes ＝ 指针到字节集 (out_addr, 64)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (out_bytes))
调试输出 (到文本 (n) ＋ “ [列混合后] 2”, hex)
' 释放内存 (const_addr)
' InvShiftRows_InvSubBytes
const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 ( #s_box_txt )))
len ＝ 取字节集长度 (const_bytes)
const_addr ＝ 申请内存 (len, 真)
内存.写字节集 (-1, const_addr, const_bytes)
const_addr_now ＝ const_addr ＋ 进制_十六到十 (“3000”) �� (n － 1)
hex ＝ 微信_InvShiftRows_InvSubBytes算法 (取变量数据地址 (row_chgx), out_addr, const_addr_now)
' 调试输出 (“3 [轮密钥加后]”, hex)
bursts_arrgs ＝ 字节集_十六进制到字节集 (删全部空 (hex))
' 释放内存 (const_addr)
计次循环尾 ()
' 调试输出 (“[9轮组合算法后]”, hex)
row_chgx ＝ 行移位 (bursts_arrgs)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (row_chgx))
' 调试输出 (“[行移位]”, hex)
const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 ( #轮密钥常量 )))
const_addr ＝ 申请内存 (取字节集长度 (const_bytes), 真)
内存.写字节集 (-1, const_addr, const_bytes)
hex ＝ 微信_查表替换 (null, 取变量数据地址 (row_chgx), const_addr)
bursts_arrgs ＝ 字节集_十六进制到字节集 (删全部空 (hex))
' 调试输出 (“[查表替换]”, hex)
bursts_arrgs ＝ 矩阵排列 (bursts_arrgs)
hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (bursts_arrgs))
' 调试输出 (“[矩阵排列]”, hex)
key_or_beforedata ＝ bursts_arrgs
hex_all ＝ hex_all ＋ hex
调试输出 (到文本 (i) ＋ “/” ＋ 到文本 (rounds) ＋ “ ” ＋ hex)
' 跳出循环 ()
计次循环尾 ()
返回 (hex_all)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 ccd_00000003_encrypt, 文本型<br /> .参数 in_data, 文本型<br /> .参数 key, 文本型<br /> .局部变量 ori_data, 字节集<br /> .局部变量 ret_data, 文本型<br /> .局部变量 tmp_data, 字节集<br /> .局部变量 rounds, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 xor_data, 字节集<br /> .局部变量 key_or_beforedata, 字节集<br /> .局部变量 hex, 文本型<br /> .局部变量 bursts_arrgs, 字节集<br /> .局部变量 row_chgx, 字节集<br /> .局部变量 mix_col, 字节集<br /> .局部变量 out_addr, 整数型<br /> .局部变量 const_addr, 整数型<br /> .局部变量 out_bytes, 字节集<br /> .局部变量 const_bytes, 字节集<br /> .局部变量 len, 整数型<br /> .局部变量 n, 整数型<br /> .局部变量 const_addr_now, 整数型<br /> .局部变量 null, 整数型<br /> .局部变量 hex_all, 文本型<br /> <br /> ori_data ＝ 字节集_十六进制到字节集 (删全部空 (in_data))<br /> <br /> <br /> <br /> ori_data ＝ 填充对齐 (ori_data)<br /> <br /> rounds ＝ get_rounds (ori_data)<br /> 调试输出 (“[需要循环加密的轮数]”, rounds)<br /> <br /> <br /> key_or_beforedata ＝ 到字节集 (key)<br /> <br /> out_addr ＝ 申请内存 (4096, 真)<br /> <br /> .计次循环首 (rounds, i)<br />     tmp_data ＝ 取字节集中间 (ori_data, (i － 1) × 16 ＋ 1, 16)<br /> <br />     ' 调试输出 (“[本次数据]”, 十六进制_添加空格 (字节集_字节集到十六进制 (tmp_data)))<br />     ' 调试输出 (“[本次密钥]”, 十六进制_添加空格 (字节集_字节集到十六进制 (key_or_beforedata)))<br /> <br /> <br />     xor_data ＝ 异或一轮_128bit (tmp_data, key_or_beforedata)<br /> <br />     hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (xor_data))<br />     ' 调试输出 (“[异或一轮]”, hex)<br /> <br />     ' 调试输出 (到文本 (i) ＋ “ 轮xor 完成 ----------------------------------------------------------”)<br /> <br /> <br /> <br />     bursts_arrgs ＝ 矩阵排列 (xor_data)<br />     hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (bursts_arrgs))<br />     ' 调试输出 (“[矩阵排列后]”, hex)<br />     ' 17 CA 4A 52 AD 05 E0 92 A1 91 BA 9B F1 0B C8 0E<br /> <br />     .计次循环首 (9, n)<br />         ' 调试输出 (到文本 (n) ＋ “ 轮开始 ----------------------------------------------------------”)<br /> <br />         row_chgx ＝ 行移位 (bursts_arrgs)<br />         hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (row_chgx))<br />         ' 调试输出 (到文本 (n) ＋ “ [行移位] 1”, hex)  ' 17 CA 4A 52 05 E0 92 AD BA 9B A1 91 0E F1 0B C8<br /> <br />         const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 (#t_table_txt)))<br />         len ＝ 取字节集长度 (const_bytes)<br />         const_addr ＝ 申请内存 (len, 真)<br />         内存.写字节集 (-1, const_addr, const_bytes)<br />         const_addr_now ＝ const_addr ＋ 进制_十六到十 (“4000”) × (n － 1)<br /> <br /> <br />         微信列混合算法 (out_addr, 取变量数据地址 (row_chgx), const_addr_now)<br /> <br /> <br />         out_bytes ＝ 指针到字节集 (out_addr, 64)<br />         hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (out_bytes))<br />         调试输出 (到文本 (n) ＋ “ [列混合后] 2”, hex)<br /> <br />         ' 释放内存 (const_addr)<br /> <br />         ' InvShiftRows_InvSubBytes<br />         const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 (#s_box_txt)))<br />         len ＝ 取字节集长度 (const_bytes)<br />         const_addr ＝ 申请内存 (len, 真)<br />         内存.写字节集 (-1, const_addr, const_bytes)<br /> <br />         const_addr_now ＝ const_addr ＋ 进制_十六到十 (“3000”) × (n － 1)<br /> <br />         hex ＝ 微信_InvShiftRows_InvSubBytes算法 (取变量数据地址 (row_chgx), out_addr, const_addr_now)<br />         ' 调试输出 (“3 [轮密钥加后]”, hex)<br /> <br /> <br />         bursts_arrgs ＝ 字节集_十六进制到字节集 (删全部空 (hex))<br /> <br />         ' 释放内存 (const_addr)<br /> <br /> <br />     .计次循环尾 ()<br /> <br /> <br />     ' 调试输出 (“[9轮组合算法后]”, hex)<br /> <br />     row_chgx ＝ 行移位 (bursts_arrgs)<br />     hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (row_chgx))<br />     ' 调试输出 (“[行移位]”, hex)<br /> <br /> <br />     const_bytes ＝ 字节集_十六进制到字节集 (删全部空 (到文本 (#轮密钥常量)))<br />     const_addr ＝ 申请内存 (取字节集长度 (const_bytes), 真)<br />     内存.写字节集 (-1, const_addr, const_bytes)<br /> <br />     hex ＝ 微信_查表替换 (null, 取变量数据地址 (row_chgx), const_addr)<br /> <br />     bursts_arrgs ＝ 字节集_十六进制到字节集 (删全部空 (hex))<br /> <br />     ' 调试输出 (“[查表替换]”, hex)<br /> <br /> <br />     bursts_arrgs ＝ 矩阵排列 (bursts_arrgs)<br />     hex ＝ 十六进制_添加空格 (字节集_字节集到十六进制 (bursts_arrgs))<br />     ' 调试输出 (“[矩阵排列]”, hex)<br /> <br />     key_or_beforedata ＝ bursts_arrgs<br /> <br />     hex_all ＝ hex_all ＋ hex<br /> <br />     调试输出 (到文本 (i) ＋ “/” ＋ 到文本 (rounds) ＋ “ ” ＋ hex)<br /> <br />     ' 跳出循环 ()<br /> .计次循环尾 ()<br /> <br /> <br /> <br /> <br /> 返回 (hex_all)

测试数据：
输入zlib 数据
78 9C AD 58 7D 6C 13 E7 19 CF C5 D8 86 23 9B 0A

输出
77 36 C3 1C 38 A0 78 CB 82 F1 EA 87 46 C5 56 B3

验证一致

lijunfa12345

看看怎么样

hehz977

支持开源~！感谢分享

卡卡1111

支持开源~！感谢分享

何浩文

支持开源~！感谢分享

year1970

感谢分享

一尘不染

已经顶贴，感谢您对论坛的支持！

qqmqqg

6666666666666666666

bianyuan456

已经顶贴，感谢您对论坛的支持！

lassgo

固定key啊，那安全性有点悬呢，建议换动态的更安全点哈