看此函数完整代码

wormfox 内联汇编void fun(long arg) {   int 参数1;  __asm& ...

 他这个是64位的 ...
你写的是32位的    ,他的目的应该是在取 CALL的地址
{140,101,252,184,43,0,0,0,102,142,224,131,228,240}
{106,51,232,0,0,0,0,131,4,36,5,203}
{103, 139, 69, 8, 103, 139, 0, 103, 139, 72, 4, 133, 201, 116, 111, 72, 141, 64, 8, 72, 141
,20, 205, 8, 0, 0, 0, 72, 131, 250, 64, 115, 9, 72, 199, 194, 64, 0, 0, 0, 235, 8, 72, 141
,82, 15, 72, 131, 226, 240, 72, 43, 226, 103, 72, 137, 85, 244, 76, 141, 72, 8, 72, 139, 0
,72, 255, 201, 116, 43, 76, 139, 196, 73, 139, 17, 73, 137, 16, 72, 255, 201, 116, 10, 77
,141, 64, 8, 77, 141, 73, 8, 235, 235, 72, 139, 12, 36, 72, 139, 84, 36, 8, 76, 139, 68
,36, 16, 76, 139, 76, 36, 24, 255, 208, 103, 72, 139, 85, 244, 72, 141, 36, 20, 235
,3, 72, 51, 192, 72, 139, 208, 72, 193, 234, 32}
{232,0,0,0,0,199,68,36,4,35,0,0,0,131,4,36,13,203}
{102,140,217,102,142,209,139,77,252,102,142,225}
{139, 229, 93, 194, 4, 0}

Mxixihaha 看此函数完整代码

去掉头尾两个VM标识,取中间部分.

十六进制数据 

67 8B 45 08 67 8B 00 67 8B 48 04 85 C9 74 6F 48 8D 40 08 48 8D 14 CD 08 00 00 00 48 83 FA 40 73 09 48 C7 C2 40 00 00 00 EB 08 48 8D 52 0F 48 83 E2 F0 48 2B E2 67 48 89 55 F4 4C 8D 48 08 48 8B 00 48 FF C9 74 2B 4C 8B C4 49 8B 11 49 89 10 48 FF C9 74 0A 4D 8D 40 08 4D 8D 49 08 EB EB 48 8B 0C 24 48 8B 54 24 08 4C 8B 44 24 10 4C 8B 4C 24 18 FF D0 67 48 8B 55 F4 48 8D 24 14 EB 03 48 33 C0 48 8B D0 48 C1 EA 20 

CE随便打开个进程,查看内存->工具->申请内存->转到内存浏览->Ctrl+V

易语言的obj 文件吗

lononan 去掉头尾两个VM标识,取中间部分.十六进制数据 67 8B 45 08 67 8B 00 67 8B 48 04 85 C9 74 6F 48 8D 40 08 48 8D 14 C ...

谢谢大佬, 头尾两个是VM? 无用的代码吗?

小豆丁CE 谢谢大佬, 头尾两个是VM? 无用的代码吗?

00000000001AF61A 67 8B 45 08             mov         eax,dword ptr [ebp+8]  
00000000001AF61E 67 8B 00                mov         eax,dword ptr [eax]  
00000000001AF621 67 8B 48 04             mov         ecx,dword ptr [eax+4]  
00000000001AF625 85 C9                   test        ecx,ecx  
00000000001AF627 74 6F                   je          00000000001AF698  
00000000001AF629 48 8D 40 08             lea         rax,[rax+8]  
00000000001AF62D 48 8D 14 CD 08 00 00 00 lea         rdx,[rcx*8+00000008h]  
00000000001AF635 48 83 FA 40             cmp         rdx,40h  
00000000001AF639 73 09                   jae         00000000001AF644  
00000000001AF63B 48 C7 C2 40 00 00 00    mov         rdx,40h  
00000000001AF642 EB 08                   jmp         00000000001AF64C  
00000000001AF644 48 8D 52 0F             lea         rdx,[rdx+0Fh]  
00000000001AF648 48 83 E2 F0             and         rdx,0FFFFFFFFFFFFFFF0h  
00000000001AF64C 48 2B E2                sub         rsp,rdx  
00000000001AF64F 67 48 89 55 F4          mov         qword ptr [ebp-0Ch],rdx  
00000000001AF654 4C 8D 48 08             lea         r9,[rax+8]  
00000000001AF658 48 8B 00                mov         rax,qword ptr [rax]  
00000000001AF65B 48 FF C9                dec         rcx  
00000000001AF65E 74 2B                   je          00000000001AF68B  
00000000001AF660 4C 8B C4                mov         r8,rsp  
00000000001AF663 49 8B 11                mov         rdx,qword ptr [r9]  
00000000001AF666 49 89 10                mov         qword ptr [r8],rdx  
00000000001AF669 48 FF C9                dec         rcx  
00000000001AF66C 74 0A                   je          00000000001AF678  
00000000001AF66E 4D 8D 40 08             lea         r8,[r8+8]  
00000000001AF672 4D 8D 49 08             lea         r9,[r9+8]  
00000000001AF676 EB EB                   jmp         00000000001AF663  
00000000001AF678 48 8B 0C 24             mov         rcx,qword ptr [rsp]  
00000000001AF67C 48 8B 54 24 08          mov         rdx,qword ptr [rsp+8]  
00000000001AF681 4C 8B 44 24 10          mov         r8,qword ptr [rsp+10h]  
00000000001AF686 4C 8B 4C 24 18          mov         r9,qword ptr [rsp+18h]  
00000000001AF68B FF D0                   call        rax  
00000000001AF68D 67 48 8B 55 F4          mov         rdx,qword ptr [ebp-0Ch]  
00000000001AF692 48 8D 24 14             lea         rsp,[rsp+rdx]  
00000000001AF696 EB 03                   jmp         00000000001AF69B  
00000000001AF698 48 33 C0                xor         rax,rax  
00000000001AF69B 48 8B D0                mov         rdx,rax  
00000000001AF69E 48 C1 EA 20             shr         rdx,20h

只要支持 x64 编译的任何一版vs

打开vc 新建控制台应用程序

int _tmain(int argc, _TCHAR* argv[])
{
	unsigned char x64Bin[] = { 140, 101, 252, 184, 43, 0, 0, 0, 102, 142, 224, 131, 228, 240, 106, 51, 232, 0, 0, 0, 0, 131, 4, 36, 5, 203, 103, 139, 69, 8, 103, 139, 0, 103, 139, 72, 4, 133, 201, 116, 111, 72, 141, 64, 8, 72, 141, 20, 205, 8, 0, 0, 0, 72, 131, 250, 64, 115, 9, 72, 199, 194, 64, 0, 0, 0, 235, 8, 72, 141, 82, 15, 72, 131, 226, 240, 72, 43, 226, 103, 72, 137, 85, 244, 76, 141, 72, 8, 72, 139, 0, 72, 255, 201, 116, 43, 76, 139, 196, 73, 139, 17, 73, 137, 16, 72, 255, 201, 116, 10, 77, 141, 64, 8, 77, 141, 73, 8, 235, 235, 72, 139, 12, 36, 72, 139, 84, 36, 8, 76, 139, 68, 36, 16, 76, 139, 76, 36, 24, 255, 208, 103, 72, 139, 85, 244, 72, 141, 36, 20, 235, 3, 72, 51, 192, 72, 139, 208, 72, 193, 234, 32, 232, 0, 0, 0, 0, 199, 68, 36, 4, 35, 0, 0, 0, 131, 4, 36, 13, 203, 102, 140, 217, 102, 142, 209, 139, 77, 252, 102, 142, 225, 139, 229, 93, 194, 4, 0 };
	
	//在printf处下断点  
	printf("%s\n", (unsigned char *)x64Bin); 
	//断下来之后 在 调试-窗口-反汇编  在地址处输入 x64Bin   就可以看到对应的x64代码了   前几句是壳的标记,无视,只看正常代码的部分.
	return 0;
}

Mxixihaha 小豆丁CE 谢谢大佬, 头尾两个是VM? 无用的代码吗? 00000000001AF61A 67 8B 4 ...

谢谢 大佬, 他这个置入代码,
能用你写的这种数组,直接操作吗,,就是不用在转成汇编来执行

小豆丁CE 谢谢 大佬, 他这个置入代码, 能用你写的这种数组,直接操作吗,,就是不用在转成汇编来执行

可以的, 这个就是俗称的 shellcode     只保留代码部分就行了  那些其他壳的标记不要. 然后调用约定一样即可.

Mxixihaha 小豆丁CE 谢谢 大佬, 他这个置入代码, 能用你写的这种数组,直接操作吗,,就是不用在转成汇编来执行 可以的, 这个就是俗称的&n ...

谢谢

Mxixihaha 小豆丁CE 谢谢 大佬, 他这个置入代码, 能用你写的这种数组,直接操作吗,,就是不用在转成汇编来执行 可以的, 这个就是俗称的&n ...

上面是壳的话,从这一句开始用的话

进来就崩了,这是咋回事呀

小豆丁CE 上面是壳的话,从这一句开始用的话进来就崩了,这是咋回事呀

64位程序取[ebp]

地址截断了吧。。可不得出错么

小豆丁CE 上面是壳的话,从这一句开始用的话进来就崩了,这是咋回事呀

你这段代码是 32位程序构造64位程序代码在64位运行, 所以你得编译成 32位程序注入64位程序中使用. 

Mxixihaha 你这段代码是 32位程序构造64位程序代码在64位运行, 所以你得编译成 32位程序注入64位程序中使用.

好的,谢谢

mov [ebp-0x4],fs
mov eax,0x2b
mov fs,ax
and esp,byte -0x10
push byte +0x33
call 0x15
add dword [esp],byte +0x5
retf
mov eax,[di+0x8]
mov eax,[bx+si]
mov ecx,[bx+si+0x4]
test ecx,ecx
jz 0x98
dec eax
lea eax,[eax+0x8]
dec eax
lea edx,[ecx*8+0x8]
dec eax
cmp edx,byte +0x40
jnc 0x44
dec eax
mov edx,0x40
jmp short 0x4c
dec eax
lea edx,[edx+0xf]
dec eax
and edx,byte -0x10
dec eax
sub esp,edx
dec eax
mov [ebp-0xc],edx
dec esp
lea ecx,[eax+0x8]
dec eax
mov eax,[eax]
dec eax
dec ecx
jz 0x8b
dec esp
mov eax,esp
dec ecx
mov edx,[ecx]
dec ecx
mov [eax],edx
dec eax
dec ecx
jz 0x78
dec ebp
lea eax,[eax+0x8]
dec ebp
lea ecx,[ecx+0x8]
jmp short 0x63
dec eax
mov ecx,[esp]
dec eax
mov edx,[esp+0x8]
dec esp
mov eax,[esp+0x10]
dec esp
mov ecx,[esp+0x18]
call eax
dec eax
mov edx,[ebp-0xc]
dec eax
lea esp,[esp+edx]
jmp short 0x9b
dec eax
xor eax,eax
dec eax
mov edx,eax
dec eax
shr edx,byte 0x20
call 0xa7
mov dword [esp+0x4],0x23
add dword [esp],byte +0xd
retf
mov cx,ds
mov ss,cx
mov ecx,[ebp-0x4]
mov fs,cx
mov esp,ebp
pop ebp
ret 0x4

小豆丁CE

这不就是wow64ext吗这东西本来就是从c++翻译过来的啊。。。