汇编代码字节集翻转重写

jafyang

以下优秀汇编代码来源于易友zainex，此汇编翻转字节集速度很快，但会修改传参变量，求助论坛汇编大神帮忙修改为返回子程序结果为反转后的字节集而不直接替换传参变量。谢谢！

  

子程序名	返回值类型	公开	备 注
字节集翻转
参数名	类 型	参考	可空	数组	备 注
对象	字节集

置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })
' pop ebp
' mov eax, dword [esp+0x04]
' mov ecx, dword [eax]
' mov eax, dword [ecx+0x04]
' test eax, eax
' je Label1
' lea ecx, dword [ecx+0x08]
' lea edx, dword [ecx+eax]
' Label2:
' dec edx
' mov al, byte [ecx]
' mov ah, byte [edx]
' mov byte [ecx], ah
' mov byte [edx], al
' inc ecx
' cmp ecx, edx
' jc Label2
' Label1:
' retn 0x0004

.版本 2<br /> <br /> .子程序 字节集翻转<br /> .参数 对象, 字节集<br /> <br /> 置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })<br /> ' pop ebp<br /> ' mov eax, dword [esp+0x04]<br /> ' mov ecx, dword [eax]<br /> ' mov eax, dword [ecx+0x04]<br /> ' test eax, eax<br /> ' je Label1<br /> ' lea ecx, dword [ecx+0x08]<br /> ' lea edx, dword [ecx+eax]<br /> ' Label2:<br /> ' dec edx<br /> ' mov al, byte [ecx]<br /> ' mov ah, byte [edx]<br /> ' mov byte [ecx], ah<br /> ' mov byte [edx], al<br /> ' inc ecx<br /> ' cmp ecx, edx<br /> ' jc Label2<br /> ' Label1:<br /> ' retn 0x0004

jafyang

  

子程序名	返回值类型	公开	备 注
字节集翻转
参数名	类 型	参考	可空	数组	备 注
Bytes	字节集

置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })

.版本 2<br /> <br /> .子程序 字节集翻转<br /> .参数 Bytes, 字节集<br /> <br /> 置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })

zainex

涉及内存分配，都需要调用系统api，如果你想在汇编层面上实现这套流程，利用fs段寄存器中保存的信息就能做到。
下面是一个例子，调用的api是LocalAlloc：

  

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

子程序名	返回值类型	公开	备 注
倒序字节集	字节集
参数名	类 型	参考	可空	数组	备 注
对象	字节集

置入代码 ({ 93, 100, 139, 21, 48, 0, 0, 0, 139, 82, 12, 139, 82, 28, 139, 66, 8, 139, 74, 32, 139, 18, 128, 121, 12, 51, 117, 242, 137, 193, 3, 72, 60, 139, 81, 120, 1, 194, 139, 74, 32, 1, 193, 49, 219, 139, 60, 153, 1, 199, 67, 129, 127, 4, 108, 65, 108, 108, 117, 241, 139, 74, 36, 1, 193, 102, 139, 28, 89, 139, 74, 28, 1, 193, 139, 76, 153, 252, 1, 193, 139, 92, 36, 4, 139, 27, 139, 115, 4, 141, 86, 8, 82, 104, 0, 0, 0, 0, 255, 209, 198, 0, 1, 137, 112, 4, 131, 195, 8, 49, 255, 235, 10, 138, 84, 51, 255, 136, 84, 56, 8, 71, 78, 133, 246, 117, 242, 194, 4, 0 })
' pop ebp
' mov edx, dword [fs:0x00000030]
' mov edx, dword [edx+0x0C]
' mov edx, dword [edx+0x1C]
' Label1:
' mov eax, dword [edx+0x08]
' mov ecx, dword [edx+0x20]
' mov edx, dword [edx]
' cmp byte [ecx+0x0C], 0x33
' jne Label1
' mov ecx, eax
' add ecx, dword [eax+0x3C]
' mov edx, dword [ecx+0x78]
' add edx, eax
' mov ecx, dword [edx+0x20]
' add ecx, eax
' xor ebx, ebx
' Label2:
' mov edi, dword [ecx+ebx*4]
' add edi, eax
' inc ebx
' cmp dword [edi+0x04], 0x6C6C416C
' jne Label2
' mov ecx, dword [edx+0x24]
' add ecx, eax
' mov bx, word [ecx+ebx*2]
' mov ecx, dword [edx+0x1C]
' add ecx, eax
' mov ecx, dword [ecx+ebx*4-0x04]
' add ecx, eax
' mov ebx, dword [esp+0x04]
' mov ebx, dword [ebx]
' mov esi, dword [ebx+0x04]
' lea edx, dword [esi+0x08]
' push edx
' push 0x00000000
' call ecx
' mov byte [eax], 0x01
' mov dword [eax+0x04], esi
' add ebx, 0x08
' xor edi, edi
' jmp Label3
' Label4:
' mov dl, byte [ebx+esi-0x01]
' mov byte [eax+edi+0x08], dl
' inc edi
' dec esi
' Label3:
' test esi, esi
' jne Label4
' retn 0x0004
返回 ({  })

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

变量名	类 型	静态	数组	备 注
对象	字节集
结果	字节集

对象 ＝ { 6, 2, 9, 5, 1, 4, 1, 0, 3 }
计次循环首 (100000, )
结果 ＝ 倒序字节集 (对象)
计次循环尾 ()
调试输出 (对象, 结果)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> <br /> .子程序 倒序字节集, 字节集<br /> .参数 对象, 字节集<br /> <br /> 置入代码 ({ 93, 100, 139, 21, 48, 0, 0, 0, 139, 82, 12, 139, 82, 28, 139, 66, 8, 139, 74, 32, 139, 18, 128, 121, 12, 51, 117, 242, 137, 193, 3, 72, 60, 139, 81, 120, 1, 194, 139, 74, 32, 1, 193, 49, 219, 139, 60, 153, 1, 199, 67, 129, 127, 4, 108, 65, 108, 108, 117, 241, 139, 74, 36, 1, 193, 102, 139, 28, 89, 139, 74, 28, 1, 193, 139, 76, 153, 252, 1, 193, 139, 92, 36, 4, 139, 27, 139, 115, 4, 141, 86, 8, 82, 104, 0, 0, 0, 0, 255, 209, 198, 0, 1, 137, 112, 4, 131, 195, 8, 49, 255, 235, 10, 138, 84, 51, 255, 136, 84, 56, 8, 71, 78, 133, 246, 117, 242, 194, 4, 0 })<br /> ' pop ebp<br /> ' mov edx, dword [fs:0x00000030]<br /> ' mov edx, dword [edx+0x0C]<br /> ' mov edx, dword [edx+0x1C]<br /> ' Label1:<br /> ' mov eax, dword [edx+0x08]<br /> ' mov ecx, dword [edx+0x20]<br /> ' mov edx, dword [edx]<br /> ' cmp byte [ecx+0x0C], 0x33<br /> ' jne Label1<br /> ' mov ecx, eax<br /> ' add ecx, dword [eax+0x3C]<br /> ' mov edx, dword [ecx+0x78]<br /> ' add edx, eax<br /> ' mov ecx, dword [edx+0x20]<br /> ' add ecx, eax<br /> ' xor ebx, ebx<br /> ' Label2:<br /> ' mov edi, dword [ecx+ebx*4]<br /> ' add edi, eax<br /> ' inc ebx<br /> ' cmp dword [edi+0x04], 0x6C6C416C<br /> ' jne Label2<br /> ' mov ecx, dword [edx+0x24]<br /> ' add ecx, eax<br /> ' mov bx, word [ecx+ebx*2]<br /> ' mov ecx, dword [edx+0x1C]<br /> ' add ecx, eax<br /> ' mov ecx, dword [ecx+ebx*4-0x04]<br /> ' add ecx, eax<br /> ' mov ebx, dword [esp+0x04]<br /> ' mov ebx, dword [ebx]<br /> ' mov esi, dword [ebx+0x04]<br /> ' lea edx, dword [esi+0x08]<br /> ' push edx<br /> ' push 0x00000000<br /> ' call ecx<br /> ' mov byte [eax], 0x01<br /> ' mov dword [eax+0x04], esi<br /> ' add ebx, 0x08<br /> ' xor edi, edi<br /> ' jmp Label3<br /> ' Label4:<br /> ' mov dl, byte [ebx+esi-0x01]<br /> ' mov byte [eax+edi+0x08], dl<br /> ' inc edi<br /> ' dec esi<br /> ' Label3:<br /> ' test esi, esi<br /> ' jne Label4<br /> ' retn 0x0004<br /> 返回 ({  })<br /> <br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 对象, 字节集<br /> .局部变量 结果, 字节集<br /> <br /> 对象 ＝ { 6, 2, 9, 5, 1, 4, 1, 0, 3 }<br /> .计次循环首 (100000, )<br />     结果 ＝ 倒序字节集 (对象)<br /> .计次循环尾 ()<br /> 调试输出 (对象, 结果)

注意，易语言规定，填写了返回值类型的子程序，必须要有返回语句，所以你期望的那种只有一行置入代码的“全汇编代码”在易语言中是做不到的，除非这个子程序没有返回值类型。

大司命

传递变量时复制一份就好了！原理是一样的~

  

aryBin ＝ { 1, 2, 3, 4, 5, 6 }
aryBin1 ＝ aryBin
字节集翻转 (aryBin1)
调试输出 (aryBin1)

.版本 2<br /> <br /> aryBin ＝ { 1, 2, 3, 4, 5, 6 }<br /> aryBin1 ＝ aryBin<br /> 字节集翻转 (aryBin1)<br /> 调试输出 (aryBin1)

7ian

再原数.据修改是最快的，不然你新申请个一样长度内存，再写进去会很慢；你还不如传进来前新建个变量，变的只是新变量数.据，旧数.据没变化

冬夏

  

子程序名	返回值类型	公开	备 注
字节集_翻转	字节集
参数名	类 型	参考	可空	数组	备 注
欲转换的字节集	字节集

变量名	类 型	静态	数组	备 注
局部字节集	字节集

如果真 (取字节集长度 (欲转换的字节集) ＞ 0)
局部字节集 ＝ 欲转换的字节集
字节集翻转 (局部字节集)
返回 (局部字节集)

子程序名	返回值类型	公开	备 注
字节集翻转
参数名	类 型	参考	可空	数组	备 注
Bytes	字节集

置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })

.版本 2<br /> <br /> .子程序 字节集_翻转, 字节集<br /> .参数 欲转换的字节集, 字节集<br /> .局部变量 局部字节集, 字节集<br /> <br /> .如果真 (取字节集长度 (欲转换的字节集) ＞ 0)<br />     局部字节集 ＝ 欲转换的字节集<br />     字节集翻转 (局部字节集)<br /> .如果真结束<br /> 返回 (局部字节集)<br /> <br /> .子程序 字节集翻转<br /> .参数 Bytes, 字节集<br /> <br /> 置入代码 ({ 93, 139, 68, 36, 4, 139, 8, 139, 65, 4, 133, 192, 116, 20, 141, 73, 8, 141, 20, 1, 74, 138, 1, 138, 34, 136, 33, 136, 2, 65, 57, 209, 114, 242, 194, 4, 0 })

jafyang

大司命 发表于 2023-8-14 17:25
传递变量时复制一份就好了！原理是一样的~

[e=5].版本 2

我目前的做法就是这样，想看看全汇编代码是怎么样的

jafyang

冬夏 发表于 2023-8-14 17:28
[e=1]
.版本 2

我目前的做法就是这样，想看看全汇编代码是怎么样的

jafyang

7ian 发表于 2023-8-14 17:26
再原数.据修改是最快的，不然你新申请个一样长度内存，再写进去会很慢；你还不如传进来前新建个变量，变的 ...

这样的全汇编代码怎么写呢？

大司命

jafyang 发表于 2023-8-15 10:47
这样的全汇编代码怎么写呢？

  

子程序名	返回值类型	公开	备 注
字节集翻转	字节集
参数名	类 型	参考	可空	数组	备 注
对象	字节集

变量名	类 型	静态	数组	备 注
aryBin	字节集

aryBin ＝ 取空白字节集 (取字节集长度 (对象))
置入代码 ({ 139, 69, 252, 139, 93, 8, 139, 27, 139, 75, 4, 133, 201, 116, 12, 141, 91, 8, 138, 19, 136, 84, 8, 7, 67, 226, 247, 201, 194, 4, 0 })
返回 (aryBin)

.版本 2<br /> .子程序 字节集翻转, 字节集<br /> .参数 对象, 字节集<br /> .局部变量 aryBin, 字节集<br /> aryBin ＝ 取空白字节集 (取字节集长度 (对象))<br /> 置入代码 ({ 139, 69, 252, 139, 93, 8, 139, 27, 139, 75, 4, 133, 201, 116, 12, 141, 91, 8, 138, 19, 136, 84, 8, 7, 67, 226, 247, 201, 194, 4, 0 })<br /> 返回 (aryBin)

随便写的！同样道理，无非就是换到子程序里申请而已~