有哪位大佬可以帮忙把汇编代码转为逻辑代码

小彬QQ649871230

有哪位大佬可以帮忙把汇编代码转为逻辑代码。

  

子程序名	返回值类型	公开	备 注
密钥初始Ex	整数型
参数名	类 型	参考	可空	数组	备 注
a
b
c
d
e
f
g
h

变量名	类 型	静态	数组	备 注
密钥

密钥 ＝ 申请内存 (1052, 真)
如果真 (密钥 ≠ 0)
' ;置入代码 ({ 139, 69, 252, 201, 86, 139, 240, 138, 68, 36, 8, 138, 76, 36, 12, 141, 150, 8, 4, 0, 0, 136, 142, 10, 4, 0, 0, 138, 76, 36, 20, 83, 136, 2, 138, 68, 36, 20, 136, 134, 11, 4, 0, 0, 138, 68, 36, 28, 136, 142, 9, 4, 0, 0, 138, 76, 36, 32, 136, 134, 12, 4, 0, 0, 138, 68, 36, 36, 136, 142, 14, 4, 0, 0, 138, 76, 36, 40, 136, 134, 15, 4, 0, 0, 139, 2, 85, 141, 110, 4, 87, 136, 142, 13, 4, 0, 0, 137, 134, 16, 4, 0, 0, 137, 134, 20, 4, 0, 0, 185, 128, 0, 0, 0, 51, 192, 139, 253, 199, 134, 24, 4, 0, 0, 1, 0, 0, 0, 199, 6, 92, 114, 138, 0, 199, 68, 36, 24, 2, 0, 0, 0, 243, 171, 139, 202, 138, 65, 1, 51, 255, 136, 68, 36, 20, 136, 4, 47, 139, 68, 36, 20, 51, 210, 37, 255, 0, 0, 0, 138, 17, 51, 219, 15, 175, 208, 138, 89, 2, 3, 211, 15, 175, 208, 51, 192, 138, 65, 3, 3, 194, 37, 255, 0, 0, 128, 121, 7, 72, 13, 0, 255, 255, 255, 64, 71, 136, 68, 36, 20, 129, 255, 0, 1, 0, 0, 124, 193, 139, 68, 36, 24, 131, 193, 4, 129, 197, 0, 1, 0, 0, 72, 137, 68, 36, 24, 117, 164, 185, 128, 0, 0, 0, 51, 192, 141, 190, 4, 2, 0, 0, 243, 171, 185, 252, 254, 255, 255, 141, 134, 4, 1, 0, 0, 43, 206, 139, 144, 0, 255, 255, 255, 139, 56, 51, 215, 137, 144, 0, 1, 0, 0, 139, 144, 0, 255, 255, 255, 139, 40, 131, 192, 4, 35, 213, 137, 144, 252, 1, 0, 0, 141, 20, 1, 129, 250, 0, 1, 0, 0, 124, 210, 51, 192, 95, 102, 137, 134, 6, 4, 0, 0, 102, 137, 134, 4, 4, 0, 0, 93, 139, 198, 91, 94, 194, 32, 0 })
' __asm{
' mov eax, dword ptr ss:[ebp-0x04]
' leave
' push esi
' mov esi, eax
' mov al, byte ptr ss:[esp+0x08]
' mov cl, byte ptr ss:[esp+0x0C]
' lea edx, dword ptr ds:[esi+0x408]
' mov byte ptr ds:[esi+0x40A], cl
' mov cl, byte ptr ss:[esp+0x14]
' push ebx
' mov byte ptr ds:[edx], al
' mov al, byte ptr ss:[esp+0x14]
' mov byte ptr ds:[esi+0x40B], al
' mov al, byte ptr ss:[esp+0x1C]
' mov byte ptr ds:[esi+0x409], cl
' mov cl, byte ptr ss:[esp+0x20]
' mov byte ptr ds:[esi+0x40C], al
' mov al, byte ptr ss:[esp+0x24]
' mov byte ptr ds:[esi+0x40E], cl
' mov cl, byte ptr ss:[esp+0x28]
' mov byte ptr ds:[esi+0x40F], al
' mov eax, dword ptr ds:[edx]
' push ebp
' lea ebp, dword ptr ds:[esi+0x04]
' push edi
' mov byte ptr ds:[esi+0x40D], cl
' mov dword ptr ds:[esi+0x410], eax
' mov dword ptr ds:[esi+0x414], eax
' mov ecx, 0x80
' xor eax, eax
' mov edi, ebp
' mov dword ptr ds:[esi+0x418], 0x01
' mov dword ptr ds:[esi], 0x8A725C
' mov dword ptr ss:[esp+0x18], 0x02
' rep stosd
' mov ecx, edx
' label_0x92:
' mov al, byte ptr ds:[ecx+0x01]
' xor edi, edi
' mov byte ptr ss:[esp+0x14], al
' label_0x9B:
' mov byte ptr ds:[edi+ebp*1], al
' mov eax, dword ptr ss:[esp+0x14]
' xor edx, edx
' and eax, 0xFF
' mov dl, byte ptr ds:[ecx]
' xor ebx, ebx
' imul edx, eax
' mov bl, byte ptr ds:[ecx+0x02]
' add edx, ebx
' imul edx, eax
' xor eax, eax
' mov al, byte ptr ds:[ecx+0x03]
' add eax, edx
' and eax, 0x800000FF
' jns label_0xCD
' dec eax
' or eax, 0xFFFFFF00
' inc eax
' label_0xCD:
' inc edi
' mov byte ptr ss:[esp+0x14], al
' cmp edi, 0x100
' jl label_0x9B
' mov eax, dword ptr ss:[esp+0x18]
' add ecx, 0x04
' add ebp, 0x100
' dec eax
' mov dword ptr ss:[esp+0x18], eax
' jne label_0x92
' mov ecx, 0x80
' xor eax, eax
' lea edi, dword ptr ds:[esi+0x204]
' rep stosd
' mov ecx, 0xFFFFFEFC
' lea eax, dword ptr ds:[esi+0x104]
' sub ecx, esi
' label_0x10A:
' mov edx, dword ptr ds:[eax-0x100]
' mov edi, dword ptr ds:[eax]
' xor edx, edi
' mov dword ptr ds:[eax+0x100], edx
' mov edx, dword ptr ds:[eax-0x100]
' mov ebp, dword ptr ds:[eax]
' add eax, 0x04
' and edx, ebp
' mov dword ptr ds:[eax+0x1FC], edx
' lea edx, dword ptr ds:[ecx+eax*1]
' cmp edx, 0x100
' jl label_0x10A
' xor eax, eax
' pop edi
' mov word ptr ds:[esi+0x406], ax
' mov word ptr ds:[esi+0x404], ax
' pop ebp
' mov eax, esi
' pop ebx
' pop esi
' ret 0x20
' }
返回 (0)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 密钥初始Ex, 整数型<br /> .参数 a<br /> .参数 b<br /> .参数 c<br /> .参数 d<br /> .参数 e<br /> .参数 f<br /> .参数 g<br /> .参数 h<br /> .局部变量 密钥<br /> <br /> 密钥 ＝ 申请内存 (1052, 真)<br /> .如果真 (密钥 ≠ 0)<br />     ' ;置入代码 ({ 139, 69, 252, 201, 86, 139, 240, 138, 68, 36, 8, 138, 76, 36, 12, 141, 150, 8, 4, 0, 0, 136, 142, 10, 4, 0, 0, 138, 76, 36, 20, 83, 136, 2, 138, 68, 36, 20, 136, 134, 11, 4, 0, 0, 138, 68, 36, 28, 136, 142, 9, 4, 0, 0, 138, 76, 36, 32, 136, 134, 12, 4, 0, 0, 138, 68, 36, 36, 136, 142, 14, 4, 0, 0, 138, 76, 36, 40, 136, 134, 15, 4, 0, 0, 139, 2, 85, 141, 110, 4, 87, 136, 142, 13, 4, 0, 0, 137, 134, 16, 4, 0, 0, 137, 134, 20, 4, 0, 0, 185, 128, 0, 0, 0, 51, 192, 139, 253, 199, 134, 24, 4, 0, 0, 1, 0, 0, 0, 199, 6, 92, 114, 138, 0, 199, 68, 36, 24, 2, 0, 0, 0, 243, 171, 139, 202, 138, 65, 1, 51, 255, 136, 68, 36, 20, 136, 4, 47, 139, 68, 36, 20, 51, 210, 37, 255, 0, 0, 0, 138, 17, 51, 219, 15, 175, 208, 138, 89, 2, 3, 211, 15, 175, 208, 51, 192, 138, 65, 3, 3, 194, 37, 255, 0, 0, 128, 121, 7, 72, 13, 0, 255, 255, 255, 64, 71, 136, 68, 36, 20, 129, 255, 0, 1, 0, 0, 124, 193, 139, 68, 36, 24, 131, 193, 4, 129, 197, 0, 1, 0, 0, 72, 137, 68, 36, 24, 117, 164, 185, 128, 0, 0, 0, 51, 192, 141, 190, 4, 2, 0, 0, 243, 171, 185, 252, 254, 255, 255, 141, 134, 4, 1, 0, 0, 43, 206, 139, 144, 0, 255, 255, 255, 139, 56, 51, 215, 137, 144, 0, 1, 0, 0, 139, 144, 0, 255, 255, 255, 139, 40, 131, 192, 4, 35, 213, 137, 144, 252, 1, 0, 0, 141, 20, 1, 129, 250, 0, 1, 0, 0, 124, 210, 51, 192, 95, 102, 137, 134, 6, 4, 0, 0, 102, 137, 134, 4, 4, 0, 0, 93, 139, 198, 91, 94, 194, 32, 0 })<br />     ' __asm{<br />     ' mov eax, dword ptr ss:[ebp-0x04]<br />     ' leave<br />     ' push esi<br />     ' mov esi, eax<br />     ' mov al, byte ptr ss:[esp+0x08]<br />     ' mov cl, byte ptr ss:[esp+0x0C]<br />     ' lea edx, dword ptr ds:[esi+0x408]<br />     ' mov byte ptr ds:[esi+0x40A], cl<br />     ' mov cl, byte ptr ss:[esp+0x14]<br />     ' push ebx<br />     ' mov byte ptr ds:[edx], al<br />     ' mov al, byte ptr ss:[esp+0x14]<br />     ' mov byte ptr ds:[esi+0x40B], al<br />     ' mov al, byte ptr ss:[esp+0x1C]<br />     ' mov byte ptr ds:[esi+0x409], cl<br />     ' mov cl, byte ptr ss:[esp+0x20]<br />     ' mov byte ptr ds:[esi+0x40C], al<br />     ' mov al, byte ptr ss:[esp+0x24]<br />     ' mov byte ptr ds:[esi+0x40E], cl<br />     ' mov cl, byte ptr ss:[esp+0x28]<br />     ' mov byte ptr ds:[esi+0x40F], al<br />     ' mov eax, dword ptr ds:[edx]<br />     ' push ebp<br />     ' lea ebp, dword ptr ds:[esi+0x04]<br />     ' push edi<br />     ' mov byte ptr ds:[esi+0x40D], cl<br />     ' mov dword ptr ds:[esi+0x410], eax<br />     ' mov dword ptr ds:[esi+0x414], eax<br />     ' mov ecx, 0x80<br />     ' xor eax, eax<br />     ' mov edi, ebp<br />     ' mov dword ptr ds:[esi+0x418], 0x01<br />     ' mov dword ptr ds:[esi], 0x8A725C<br />     ' mov dword ptr ss:[esp+0x18], 0x02<br />     ' rep stosd<br />     ' mov ecx, edx<br />     ' label_0x92:<br />     ' mov al, byte ptr ds:[ecx+0x01]<br />     ' xor edi, edi<br />     ' mov byte ptr ss:[esp+0x14], al<br />     ' label_0x9B:<br />     ' mov byte ptr ds:[edi+ebp*1], al<br />     ' mov eax, dword ptr ss:[esp+0x14]<br />     ' xor edx, edx<br />     ' and eax, 0xFF<br />     ' mov dl, byte ptr ds:[ecx]<br />     ' xor ebx, ebx<br />     ' imul edx, eax<br />     ' mov bl, byte ptr ds:[ecx+0x02]<br />     ' add edx, ebx<br />     ' imul edx, eax<br />     ' xor eax, eax<br />     ' mov al, byte ptr ds:[ecx+0x03]<br />     ' add eax, edx<br />     ' and eax, 0x800000FF<br />     ' jns label_0xCD<br />     ' dec eax<br />     ' or eax, 0xFFFFFF00<br />     ' inc eax<br />     ' label_0xCD:<br />     ' inc edi<br />     ' mov byte ptr ss:[esp+0x14], al<br />     ' cmp edi, 0x100<br />     ' jl label_0x9B<br />     ' mov eax, dword ptr ss:[esp+0x18]<br />     ' add ecx, 0x04<br />     ' add ebp, 0x100<br />     ' dec eax<br />     ' mov dword ptr ss:[esp+0x18], eax<br />     ' jne label_0x92<br />     ' mov ecx, 0x80<br />     ' xor eax, eax<br />     ' lea edi, dword ptr ds:[esi+0x204]<br />     ' rep stosd<br />     ' mov ecx, 0xFFFFFEFC<br />     ' lea eax, dword ptr ds:[esi+0x104]<br />     ' sub ecx, esi<br />     ' label_0x10A:<br />     ' mov edx, dword ptr ds:[eax-0x100]<br />     ' mov edi, dword ptr ds:[eax]<br />     ' xor edx, edi<br />     ' mov dword ptr ds:[eax+0x100], edx<br />     ' mov edx, dword ptr ds:[eax-0x100]<br />     ' mov ebp, dword ptr ds:[eax]<br />     ' add eax, 0x04<br />     ' and edx, ebp<br />     ' mov dword ptr ds:[eax+0x1FC], edx<br />     ' lea edx, dword ptr ds:[ecx+eax*1]<br />     ' cmp edx, 0x100<br />     ' jl label_0x10A<br />     ' xor eax, eax<br />     ' pop edi<br />     ' mov word ptr ds:[esi+0x406], ax<br />     ' mov word ptr ds:[esi+0x404], ax<br />     ' pop ebp<br />     ' mov eax, esi<br />     ' pop ebx<br />     ' pop esi<br />     ' ret 0x20<br />     ' }<br /> <br /> .如果真结束<br /> 返回 (0)

zainex

大语言模型给出的答案有概率是错误的，如果你缺少相关的知识储备，很容易被误导。
比如上面那个GPT4.1给出的答案明显是错误的，最后需要的循环次数是64次，而不是256次：

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
参数	整数型		8
数	整数型
地址	整数型
结果1	字节集
结果2	字节集

置随机数种子 ()
计次循环首 (8, 数)
参数 [数] ＝ 取随机数 (0, 255)
计次循环尾 ()
地址 ＝ 密钥初始Ex (参数 [1], 参数 [2], 参数 [3], 参数 [4], 参数 [5], 参数 [6], 参数 [7], 参数 [8])
结果1 ＝ 指针到字节集 (地址, 1052)
结果2 ＝ 密钥初始化 (参数 [1], 参数 [2], 参数 [3], 参数 [4], 参数 [5], 参数 [6], 参数 [7], 参数 [8])
调试输出 (结果1)
调试输出 (结果1 ＝ 结果2)

子程序名	返回值类型	公开	备 注
密钥初始化	字节集
参数名	类 型	参考	可空	数组	备 注
参数1	字节型
参数2	字节型
参数3	字节型
参数4	字节型
参数5	字节型
参数6	字节型
参数7	字节型
参数8	字节型

变量名	类 型	静态	数组	备 注
密钥	字节集
地址	整数型
密钥字	整数型
密钥块指针	整数型
状态	字节型
指针到整数	整数型		0
临时状态	字节型
下标	整数型
S盒指针	整数型
混淆表指针	整数型
前值	整数型
当前值	整数型

密钥 ＝ 取空白字节集 (1052)
密钥 [1033] ＝ 参数1
密钥 [1034] ＝ 参数4
密钥 [1035] ＝ 参数2
密钥 [1036] ＝ 参数3
密钥 [1037] ＝ 参数5
密钥 [1038] ＝ 参数8
密钥 [1039] ＝ 参数6
密钥 [1040] ＝ 参数7
地址 ＝ 取变量数据地址 (密钥)
密钥字 ＝ 指针到整数 (地址 ＋ 1032)
写到内存 (密钥字, 地址 ＋ 1040, )
写到内存 (密钥字, 地址 ＋ 1044, )
写到内存 (1, 地址 ＋ 1048, )
写到内存 (9073244, 地址, )
密钥块指针 ＝ 1033
S盒指针 ＝ 4
计次循环首 (2, )
状态 ＝ 密钥 [密钥块指针 ＋ 1]
临时状态 ＝ 状态
计次循环首 (256, 下标)
密钥 [S盒指针 ＋ 下标] ＝ 状态
状态 ＝ 临时状态 �� (密钥 [密钥块指针 ＋ 2] ＋ 临时状态 × 密钥 [密钥块指针]) ＋ 密钥 [密钥块指针 ＋ 3]
临时状态 ＝ 状态
计次循环尾 ()
密钥块指针 ＝ 密钥块指针 ＋ 4
S盒指针 ＝ S盒指针 ＋ 256
计次循环尾 ()
混淆表指针 ＝ 地址 ＋ 260
计次循环首 (64, )
前值 ＝ 指针到整数 (混淆表指针 － 64 × 4)
当前值 ＝ 指针到整数 (混淆表指针)
写到内存 (位异或 (当前值, 前值), 混淆表指针 ＋ 64 × 4, )
混淆表指针 ＝ 混淆表指针 ＋ 4
写到内存 (位与 (当前值, 前值), 混淆表指针 ＋ 127 × 4, )
计次循环尾 ()
写到内存 (0, 地址 ＋ 1028, )
返回 (密钥)

子程序名	返回值类型	公开	备 注
密钥初始Ex	整数型
参数名	类 型	参考	可空	数组	备 注
a
b
c
d
e
f
g
h

变量名	类 型	静态	数组	备 注
密钥

密钥 ＝ 申请内存 (1052, 真)
如果真 (密钥 ≠ 0)
置入代码 ({ 139, 69, 252, 201, 86, 139, 240, 138, 68, 36, 8, 138, 76, 36, 12, 141, 150, 8, 4, 0, 0, 136, 142, 10, 4, 0, 0, 138, 76, 36, 20, 83, 136, 2, 138, 68, 36, 20, 136, 134, 11, 4, 0, 0, 138, 68, 36, 28, 136, 142, 9, 4, 0, 0, 138, 76, 36, 32, 136, 134, 12, 4, 0, 0, 138, 68, 36, 36, 136, 142, 14, 4, 0, 0, 138, 76, 36, 40, 136, 134, 15, 4, 0, 0, 139, 2, 85, 141, 110, 4, 87, 136, 142, 13, 4, 0, 0, 137, 134, 16, 4, 0, 0, 137, 134, 20, 4, 0, 0, 185, 128, 0, 0, 0, 51, 192, 139, 253, 199, 134, 24, 4, 0, 0, 1, 0, 0, 0, 199, 6, 92, 114, 138, 0, 199, 68, 36, 24, 2, 0, 0, 0, 243, 171, 139, 202, 138, 65, 1, 51, 255, 136, 68, 36, 20, 136, 4, 47, 139, 68, 36, 20, 51, 210, 37, 255, 0, 0, 0, 138, 17, 51, 219, 15, 175, 208, 138, 89, 2, 3, 211, 15, 175, 208, 51, 192, 138, 65, 3, 3, 194, 37, 255, 0, 0, 128, 121, 7, 72, 13, 0, 255, 255, 255, 64, 71, 136, 68, 36, 20, 129, 255, 0, 1, 0, 0, 124, 193, 139, 68, 36, 24, 131, 193, 4, 129, 197, 0, 1, 0, 0, 72, 137, 68, 36, 24, 117, 164, 185, 128, 0, 0, 0, 51, 192, 141, 190, 4, 2, 0, 0, 243, 171, 185, 252, 254, 255, 255, 141, 134, 4, 1, 0, 0, 43, 206, 139, 144, 0, 255, 255, 255, 139, 56, 51, 215, 137, 144, 0, 1, 0, 0, 139, 144, 0, 255, 255, 255, 139, 40, 131, 192, 4, 35, 213, 137, 144, 252, 1, 0, 0, 141, 20, 1, 129, 250, 0, 1, 0, 0, 124, 210, 51, 192, 95, 102, 137, 134, 6, 4, 0, 0, 102, 137, 134, 4, 4, 0, 0, 93, 139, 198, 91, 94, 194, 32, 0 })
返回 (0)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 参数, 整数型, , "8"<br /> .局部变量 数, 整数型<br /> .局部变量 地址, 整数型<br /> .局部变量 结果1, 字节集<br /> .局部变量 结果2, 字节集<br /> <br /> 置随机数种子 ()<br /> .计次循环首 (8, 数)<br />     参数 [数] ＝ 取随机数 (0, 255)<br /> .计次循环尾 ()<br /> 地址 ＝ 密钥初始Ex (参数 [1], 参数 [2], 参数 [3], 参数 [4], 参数 [5], 参数 [6], 参数 [7], 参数 [8])<br /> 结果1 ＝ 指针到字节集 (地址, 1052)<br /> 结果2 ＝ 密钥初始化 (参数 [1], 参数 [2], 参数 [3], 参数 [4], 参数 [5], 参数 [6], 参数 [7], 参数 [8])<br /> 调试输出 (结果1)<br /> 调试输出 (结果1 ＝ 结果2)<br /> <br /> <br /> .子程序 密钥初始化, 字节集<br /> .参数 参数1, 字节型<br /> .参数 参数2, 字节型<br /> .参数 参数3, 字节型<br /> .参数 参数4, 字节型<br /> .参数 参数5, 字节型<br /> .参数 参数6, 字节型<br /> .参数 参数7, 字节型<br /> .参数 参数8, 字节型<br /> .局部变量 密钥, 字节集<br /> .局部变量 地址, 整数型<br /> .局部变量 密钥字, 整数型<br /> .局部变量 密钥块指针, 整数型<br /> .局部变量 状态, 字节型<br /> .局部变量 指针到整数, 整数型, , "0"<br /> .局部变量 临时状态, 字节型<br /> .局部变量 下标, 整数型<br /> .局部变量 S盒指针, 整数型<br /> .局部变量 混淆表指针, 整数型<br /> .局部变量 前值, 整数型<br /> .局部变量 当前值, 整数型<br /> <br /> 密钥 ＝ 取空白字节集 (1052)<br /> 密钥 [1033] ＝ 参数1<br /> 密钥 [1034] ＝ 参数4<br /> 密钥 [1035] ＝ 参数2<br /> 密钥 [1036] ＝ 参数3<br /> 密钥 [1037] ＝ 参数5<br /> 密钥 [1038] ＝ 参数8<br /> 密钥 [1039] ＝ 参数6<br /> 密钥 [1040] ＝ 参数7<br /> 地址 ＝ 取变量数据地址 (密钥)<br /> 密钥字 ＝ 指针到整数 (地址 ＋ 1032)<br /> 写到内存 (密钥字, 地址 ＋ 1040, )<br /> 写到内存 (密钥字, 地址 ＋ 1044, )<br /> 写到内存 (1, 地址 ＋ 1048, )<br /> 写到内存 (9073244, 地址, )<br /> 密钥块指针 ＝ 1033<br /> S盒指针 ＝ 4<br /> .计次循环首 (2, )<br />     状态 ＝ 密钥 [密钥块指针 ＋ 1]<br />     临时状态 ＝ 状态<br />     .计次循环首 (256, 下标)<br />         密钥 [S盒指针 ＋ 下标] ＝ 状态<br />         状态 ＝ 临时状态 × (密钥 [密钥块指针 ＋ 2] ＋ 临时状态 × 密钥 [密钥块指针]) ＋ 密钥 [密钥块指针 ＋ 3]<br />         临时状态 ＝ 状态<br />     .计次循环尾 ()<br />     密钥块指针 ＝ 密钥块指针 ＋ 4<br />     S盒指针 ＝ S盒指针 ＋ 256<br /> .计次循环尾 ()<br /> 混淆表指针 ＝ 地址 ＋ 260<br /> .计次循环首 (64, )<br />     前值 ＝ 指针到整数 (混淆表指针 － 64 × 4)<br />     当前值 ＝ 指针到整数 (混淆表指针)<br />     写到内存 (位异或 (当前值, 前值), 混淆表指针 ＋ 64 × 4, )<br />     混淆表指针 ＝ 混淆表指针 ＋ 4<br />     写到内存 (位与 (当前值, 前值), 混淆表指针 ＋ 127 × 4, )<br /> .计次循环尾 ()<br /> 写到内存 (0, 地址 ＋ 1028, )<br /> 返回 (密钥)<br /> <br /> <br /> .子程序 密钥初始Ex, 整数型<br /> .参数 a<br /> .参数 b<br /> .参数 c<br /> .参数 d<br /> .参数 e<br /> .参数 f<br /> .参数 g<br /> .参数 h<br /> .局部变量 密钥<br /> <br /> 密钥 ＝ 申请内存 (1052, 真)<br /> .如果真 (密钥 ≠ 0)<br />     置入代码 ({ 139, 69, 252, 201, 86, 139, 240, 138, 68, 36, 8, 138, 76, 36, 12, 141, 150, 8, 4, 0, 0, 136, 142, 10, 4, 0, 0, 138, 76, 36, 20, 83, 136, 2, 138, 68, 36, 20, 136, 134, 11, 4, 0, 0, 138, 68, 36, 28, 136, 142, 9, 4, 0, 0, 138, 76, 36, 32, 136, 134, 12, 4, 0, 0, 138, 68, 36, 36, 136, 142, 14, 4, 0, 0, 138, 76, 36, 40, 136, 134, 15, 4, 0, 0, 139, 2, 85, 141, 110, 4, 87, 136, 142, 13, 4, 0, 0, 137, 134, 16, 4, 0, 0, 137, 134, 20, 4, 0, 0, 185, 128, 0, 0, 0, 51, 192, 139, 253, 199, 134, 24, 4, 0, 0, 1, 0, 0, 0, 199, 6, 92, 114, 138, 0, 199, 68, 36, 24, 2, 0, 0, 0, 243, 171, 139, 202, 138, 65, 1, 51, 255, 136, 68, 36, 20, 136, 4, 47, 139, 68, 36, 20, 51, 210, 37, 255, 0, 0, 0, 138, 17, 51, 219, 15, 175, 208, 138, 89, 2, 3, 211, 15, 175, 208, 51, 192, 138, 65, 3, 3, 194, 37, 255, 0, 0, 128, 121, 7, 72, 13, 0, 255, 255, 255, 64, 71, 136, 68, 36, 20, 129, 255, 0, 1, 0, 0, 124, 193, 139, 68, 36, 24, 131, 193, 4, 129, 197, 0, 1, 0, 0, 72, 137, 68, 36, 24, 117, 164, 185, 128, 0, 0, 0, 51, 192, 141, 190, 4, 2, 0, 0, 243, 171, 185, 252, 254, 255, 255, 141, 134, 4, 1, 0, 0, 43, 206, 139, 144, 0, 255, 255, 255, 139, 56, 51, 215, 137, 144, 0, 1, 0, 0, 139, 144, 0, 255, 255, 255, 139, 40, 131, 192, 4, 35, 213, 137, 144, 252, 1, 0, 0, 141, 20, 1, 129, 250, 0, 1, 0, 0, 124, 210, 51, 192, 95, 102, 137, 134, 6, 4, 0, 0, 102, 137, 134, 4, 4, 0, 0, 93, 139, 198, 91, 94, 194, 32, 0 })<br /> .如果真结束<br /> 返回 (0)

同学麻烦让让

用IDA翻成伪代码

IIIllIIl

IDA反编译然后给AI处理的，逻辑应该没啥问题。更下面的是IDA反编译的原始代码

[C++] 纯文本查看 复制代码

int __stdcall InitializeEncryptionKey(char seed1, char seed2, char seed3, char seed4, 
                                      char seed5, char seed6, char seed7, char seed8)
{
  int seedDword; // eax
  int sBoxPtr; // ebp
  _BYTE *seedBytePtr; // ecx
  char currentByte; // al
  int byteIndex; // edi
  int *mixBoxPtr; // eax
  int tempValue1; // edx
  int tempValue2; // ebp
  int keyCtx; // [esp+4h] [ebp-4h] - 密钥上下文
  char nextByte; // [esp+10h] [ebp+8h]
  int boxCounter; // [esp+14h] [ebp+Ch]

  // 申请存储密钥状态的内存块 (1052字节)
  keyCtx = AllocMem(2, 1052, 0, 0x80000301, 1, 0, 0x80000002);
  if (!keyCtx)
    return 0;

  // 存储种子字节到密钥结构的特定位置
  *(_BYTE *)(keyCtx + 1034) = seed2;
  *(_BYTE *)(keyCtx + 1032) = seed1;
  *(_BYTE *)(keyCtx + 1035) = seed3;
  *(_BYTE *)(keyCtx + 1033) = seed4;
  *(_BYTE *)(keyCtx + 1036) = seed5;
  *(_BYTE *)(keyCtx + 1038) = seed6;
  *(_BYTE *)(keyCtx + 1039) = seed7;
  seedDword = *(_DWORD *)(keyCtx + 1032);
  sBoxPtr = keyCtx + 4;
  *(_BYTE *)(keyCtx + 1037) = seed8;
  *(_DWORD *)(keyCtx + 1040) = seedDword;
  *(_DWORD *)(keyCtx + 1044) = seedDword;
  *(_DWORD *)(keyCtx + 1048) = 1;
  *(_DWORD *)keyCtx = 9073244;  // 可能是算法标识符

  // 初始化两个S-box (置换盒)，每个256字节
  boxCounter = 2;
  memset((void *)(keyCtx + 4), 0, 0x200u);  // 512字节
  seedBytePtr = (_BYTE *)(keyCtx + 1032);
  do
  {
    currentByte = seedBytePtr[1];
    byteIndex = 0;
    nextByte = currentByte;
    do
    {
      // 填充S-box并通过多项式函数生成下一个字节
      *(_BYTE *)(byteIndex + sBoxPtr) = currentByte;
      currentByte = nextByte * (seedBytePtr[2] + nextByte * *seedBytePtr) + seedBytePtr[3];
      ++byteIndex;
      nextByte = currentByte;
    }
    while (byteIndex < 256);

    seedBytePtr += 4;
    sBoxPtr += 256;
    --boxCounter;
  }
  while (boxCounter);

  // 初始化混合盒，通过XOR和AND操作
  memset((void *)(keyCtx + 516), 0, 0x200u);
  mixBoxPtr = (int *)(keyCtx + 260);
  do
  {
    mixBoxPtr[64] = *mixBoxPtr ^ *(mixBoxPtr - 64);  // XOR操作
    tempValue1 = *(mixBoxPtr - 64);
    tempValue2 = *mixBoxPtr++;
    mixBoxPtr[127] = tempValue2 & tempValue1;  // AND操作
  }
  while ((int)mixBoxPtr - 260 - keyCtx < 256);

  // 初始化计数器
  *(_WORD *)(keyCtx + 1030) = 0;
  *(_WORD *)(keyCtx + 1028) = 0;
  
  return keyCtx;
}

[C++] 纯文本查看 复制代码

int __stdcall sub_401076(char a1, char a2, char a3, char a4, char a5, char a6, char a7, char a8)
{
  int v8; // eax
  int v9; // ebp
  _BYTE *v10; // ecx
  char v11; // al
  int n256; // edi
  int *v13; // eax
  int v14; // edx
  int v15; // ebp
  int key; // [esp+4h] [ebp-4h] 密钥
  char v18; // [esp+10h] [ebp+8h]
  int n2; // [esp+14h] [ebp+Ch]

  key = AllocMem(2, 1052, 0, 0x80000301, 1, 0, 0x80000002);// 申请内存
  if ( !key )
    return 0;

  *(_BYTE *)(key + 1034) = a2;
  *(_BYTE *)(key + 1032) = a1;
  *(_BYTE *)(key + 1035) = a3;
  *(_BYTE *)(key + 1033) = a4;
  *(_BYTE *)(key + 1036) = a5;
  *(_BYTE *)(key + 1038) = a6;
  *(_BYTE *)(key + 1039) = a7;
  v8 = *(_DWORD *)(key + 1032);
  v9 = key + 4;
  *(_BYTE *)(key + 1037) = a8;
  *(_DWORD *)(key + 1040) = v8;
  *(_DWORD *)(key + 1044) = v8;
  *(_DWORD *)(key + 1048) = 1;
  *(_DWORD *)key = 9073244;
  n2 = 2;
  memset((void *)(key + 4), 0, 0x200u);
  v10 = (_BYTE *)(key + 1032);
  do
  {
    v11 = v10[1];
    n256 = 0;
    v18 = v11;
    do
    {
      *(_BYTE *)(n256 + v9) = v11;
      v11 = v18 * (v10[2] + v18 * *v10) + v10[3];
      ++n256;
      v18 = v11;
    }
    while ( n256 < 256 );

    v10 += 4;
    v9 += 256;
    --n2;
  }
  while ( n2 );

  memset((void *)(key + 516), 0, 0x200u);
  v13 = (int *)(key + 260);
  do
  {
    v13[64] = *v13 ^ *(v13 - 64);
    v14 = *(v13 - 64);
    v15 = *v13++;
    v13[127] = v15 & v14;
  }
  while ( (int)v13 - 260 - key < 256 );

  *(_WORD *)(key + 1030) = 0;
  *(_WORD *)(key + 1028) = 0;
  return key;
}

IIIllIIl

再放个GPT4.1的，可读性好像好点

[C++] 纯文本查看 复制代码

int __stdcall StreamCipher_KeySetup(
    char k0, char k1, char k2, char k3, 
    char k4, char k5, char k6, char k7)
{
    int pKeyContext;   // 加密上下文结构体指针
    unsigned char *pKeyBlock;
    unsigned char state, stateTmp;
    int *pMixTable;
    int i, round, key_word, prevValue, value;

    pKeyContext = AllocMem(2, 1052, 0, 0x80000301, 1, 0, 0x80000002);
    if (!pKeyContext) return 0;
    
    // 组织密钥材料
    *(BYTE *)(pKeyContext + 1032) = k0;
    *(BYTE *)(pKeyContext + 1033) = k3;
    *(BYTE *)(pKeyContext + 1034) = k1;
    *(BYTE *)(pKeyContext + 1035) = k2;
    *(BYTE *)(pKeyContext + 1036) = k4;
    *(BYTE *)(pKeyContext + 1037) = k7;
    *(BYTE *)(pKeyContext + 1038) = k5;
    *(BYTE *)(pKeyContext + 1039) = k6;

    key_word = *(int *)(pKeyContext + 1032);
    *(int *)(pKeyContext + 1040) = key_word;
    *(int *)(pKeyContext + 1044) = key_word;
    *(int *)(pKeyContext + 1048) = 1;
    *(int *)pKeyContext = 9073244;

    // S盒初始化
    memset((void *)(pKeyContext + 4), 0, 0x200u);
    pKeyBlock = (unsigned char *)(pKeyContext + 1032);
    unsigned char *pSBox = (unsigned char *)(pKeyContext + 4);
    for (round = 0; round < 2; ++round) {
        state = pKeyBlock[1];
        stateTmp = state;
        for (i = 0; i < 256; ++i) {
            pSBox = state;
            state = stateTmp * (pKeyBlock[2] + stateTmp * pKeyBlock[0]) + pKeyBlock[3];
            stateTmp = state;
        }
        pKeyBlock += 4;
        pSBox += 256;
    }

    // 混淆表/混洗表生成
    memset((void *)(pKeyContext + 516), 0, 0x200u);
    pMixTable = (int *)(pKeyContext + 260);
    for (i = 0; i < 256; ++i) {
        pMixTable[64] = pMixTable[0] ^ pMixTable[-64];
        prevValue = pMixTable[-64];
        value = *pMixTable++;
        pMixTable[127] = value & prevValue;
    }

    // 状态指针归零
    *(unsigned short *)(pKeyContext + 1030) = 0;
    *(unsigned short *)(pKeyContext + 1028) = 0;

    return pKeyContext;
}

补充内容 (2025-4-28 17:55):
一回复就被转换成了 <i> 属实难顶

小彬QQ649871230

IIIllIIl 发表于 2025-4-28 17:50
再放个GPT4.1的，可读性好像好点

[mw_shl_code=cpp,true]int __stdcall StreamCipher_KeySetup(

我要的是翻译成易语言代码，问ai翻译出来的我试过了，计算结果出来跟汇编的结果不对。

xizhihan

[Python] 纯文本查看 复制代码

class KeyGenerator:
    def __init__(self):
        self.key_buffer = bytearray(1052)  # 申请1052字节内存
        self.struct_ptr = 0                # 模拟esi指针

    def 密钥初始Ex(self, a, b, c, d, e, f, g, h):
        # 结构体字段偏移映射
        FIELDS = {
            'field_40A': 0x40A,
            'field_40B': 0x40B,
            'field_409': 0x409,
            # ...其他字段偏移
        }

        # 参数赋值（对应汇编mov指令）
        self.key_buffer[FIELDS['field_40A']] = c & 0xFF
        self.key_buffer[FIELDS['field_40B']] = e & 0xFF
        self.key_buffer[FIELDS['field_409']] = d & 0xFF
        # ...其他参数赋值

        # 初始化内存块（rep stosd逻辑）
        self._memset(0x04, 0x00, 0x80*4)  # 初始化前128个DWORD
        self.key_buffer[0x00:0x04] = b'\x5C\x72\x8A\x00'  # 固定值

        # 核心处理循环（对应label_0x92）
        for _ in range(2):  # 外层循环计数
            ptr = 0x408     # 初始指针位置
            for i in range(0x100):  # 内层256次循环
                # 多项式计算逻辑
                a = self.key_buffer[ptr + 1]
                val = self.key_buffer[ptr]
                result = (a * val) % 256
                result += self.key_buffer[ptr + 2]
                result = (result * a) % 256
                result += self.key_buffer[ptr + 3]
                final = result & 0x800000FF
                # 回写计算结果
                self.key_buffer[ptr + 0x204 + i] = final & 0xFF
            ptr += 4

        # 后期处理（异或与位操作）
        for offset in range(0x104, 0x204, 4):
            prev = int.from_bytes(self.key_buffer[offset-0x100:offset-0x100+4], 'little')
            curr = int.from_bytes(self.key_buffer[offset:offset+4], 'little')
            mixed = prev ^ curr
            self.key_buffer[offset+0x100:offset+0x100+4] = mixed.to_bytes(4, 'little')

        return self.key_buffer

    def _memset(self, start, value, length):
        """模拟rep stosd指令"""
        self.key_buffer[start:start+length] = bytes([value]*length)

# 使用示例
key_gen = KeyGenerator()
result = key_gen.密钥初始Ex(0,0,0,0,0,0,0,0)
print(f"Generated Key: {result.hex()}")

小彬QQ649871230

xizhihan 发表于 2025-4-28 19:31
[mw_shl_code=python,true]class KeyGenerator:
    def __init__(self):
        self.key_buffer = bytea ...

能转为易语言代码吗

小彬QQ649871230

zainex 发表于 2025-4-30 00:29
大语言模型给出的答案有概率是错误的，如果你缺少相关的知识储备，很容易被误导。
比如上面那个GPT4.1给出 ...

厉害，大佬，准确